gencow 0.1.257 → 0.1.259

package/lib/app-command.mjs

@@ -488,6 +488,8 @@ ${dashboardLine}
       if (delData.stopErrorCode) {
         warnImpl(`App stop needs administrator review. Code: ${delData.stopErrorCode}. Handoff ID: ${delData.handoffId}`);
       }
+      // The handoff changes ownership only; the app keeps serving until an administrator processes it.
+      warnImpl(`Until an administrator processes the deletion, the app's public URL can keep responding. Request ID: ${requestId}. This request is already recorded; do not repeat the delete.`);
       return 0;
     }
 

package/lib/cli-command-runner.mjs

@@ -83,10 +83,16 @@ const SAFE_LOCAL_ERROR_CODES = new Map([
   [
     "CODEGEN_SOURCE_LOAD_FAILED",
     {
-      message: "Deploy stopped before upload: a backend source file throws while it is loaded.",
+      message: "Deploy stopped before upload: a backend source file could not be loaded.",
       stage: "codegen",
-      action:
-        "Retryable: yes, after the top-level code that throws during module load is fixed — run `npx gencow@latest codegen` to confirm it passes, then rerun your deploy command. The throw location is not available; check the backend files that run code at import time.",
+      action: (caught) => {
+        const cause =
+          "the top-level code that throws during module load, or an import path that does not resolve (check the path and that the imported package is installed)";
+        if (safeSourceLocation(caught)) {
+          return `Retryable: yes, after the source at the location above is fixed (${cause}) — run \`npx gencow@latest codegen\` to confirm it passes, then rerun your deploy command.`;
+        }
+        return `Retryable: yes, after ${cause} is fixed — run \`npx gencow@latest codegen\` to confirm it passes, then rerun your deploy command. The failing location is not available; check the backend files that run code at import time and the paths they import.`;
+      },
     },
   ],
   [
@@ -111,16 +117,35 @@ const SAFE_LOCAL_ERROR_CODES = new Map([
         "Retryable: no, until `npx gencow@latest codegen` passes locally — run it, fix what it reports, then rerun your deploy command.",
     },
   ],
+  [
+    "STATIC_DIR_NOT_FOUND",
+    {
+      message: (caught) => {
+        const dir = safeDisplayDir(caught);
+        return dir
+          ? `Static deploy stopped before upload: the static directory "${dir}" does not exist or is not a directory.`
+          : "Static deploy stopped before upload: the static directory does not exist or is not a directory.";
+      },
+      stage: "preflight",
+      action: (caught) => {
+        const dir = safeDisplayDir(caught) ?? "<static-dir>";
+        if (caught.staticDirSource === "config") {
+          return `Retryable: yes, after ${dir} exists as a directory — run \`ls -ld ${dir}\` to confirm, or correct the client static.dir setting in your Gencow config, then rerun the same command.`;
+        }
+        return `Retryable: yes, after ${dir} exists as a directory — run \`ls -ld ${dir}\` to confirm, then rerun the same command with a correct path, or omit the directory argument to auto-detect (dist, out, build, .next/out).`;
+      },
+    },
+  ],
   [
     "STATIC_ARTIFACT_INDEX_EMPTY",
     {
       message:
-        "Static deploy stopped before upload: the build output's index.html is empty or contains only whitespace.",
+        "Static deploy stopped before upload: the build output's index.html is empty or contains only whitespace, a BOM, or HTML comments.",
       stage: "artifact",
       action: (caught) => {
         const dir = safeDisplayDir(caught);
         const target = dir ?? "<build-output-dir>";
-        return `Retryable: yes, after the build writes an index.html with real content into ${target} — run \`ls -l ${target}/index.html\` to confirm its size is above 0 bytes and that it is not only whitespace, then rerun \`gencow static ${target}\`.`;
+        return `Retryable: yes, after the build writes an index.html with real content into ${target} — run \`ls -l ${target}/index.html\` to confirm its size is above 0 bytes and that it holds more than whitespace or HTML comments, then rerun \`gencow static ${target}\`.`;
       },
     },
   ],

package/lib/cloud-targets.mjs

@@ -33,6 +33,28 @@ export function readProjectAppTargets(cwd = process.cwd()) {
   }
 }
 
+// Single decision for "which prod app does --prod (+ optional --app) target".
+// acceptExplicitWithoutProdApp preserves call sites that trust an explicit app
+// when the project has no prodApp binding (legacy metadata); others fail closed.
+export function resolveProdAppTarget({ explicitAppId = null, prodApp = null, acceptExplicitWithoutProdApp = false }) {
+  if (!prodApp) {
+    if (explicitAppId && acceptExplicitWithoutProdApp) return { appId: explicitAppId };
+    return { appId: null, reason: "no_prod_app" };
+  }
+  if (explicitAppId && explicitAppId !== prodApp) {
+    return { appId: null, reason: "explicit_app_not_prod_app", prodApp };
+  }
+  return { appId: prodApp };
+}
+
+// Shared human message for a failed prod target; falls back to the call site's own text.
+export function describeProdTargetFailure(result, fallbackMessage) {
+  if (result?.reason === "explicit_app_not_prod_app") {
+    return `\`--app\` with \`--prod\` must name this project's prod app: ${result.prodApp}. Run again with --app ${result.prodApp} or without --app.`;
+  }
+  return fallbackMessage;
+}
+
 export function resolveCloudAppTarget(restArgs, options = {}) {
   const {
     cwd = process.cwd(),
@@ -59,17 +81,24 @@ export function resolveCloudAppTarget(restArgs, options = {}) {
   if (projectTargets.invalid) {
     return { error: "MIGRATION_PROJECT_CONFIG_INVALID" };
   }
+  // The project's own prod app id names the prod environment even without --prod.
+  if (explicitApp && envTarget === "dev" && projectTargets.prodApp && appId === projectTargets.prodApp) {
+    envTarget = "prod";
+  }
   if (!appId) {
     appId = envTarget === "prod" ? projectTargets.prodApp : projectTargets.appId;
   }
 
   if (envTarget === "prod") {
-    if (!projectTargets.prodApp && !explicitApp) {
-      return { error: missingProdMessage };
-    }
-    if (explicitApp && projectTargets.prodApp && appId !== projectTargets.prodApp) {
-      return { error: missingProdMessage };
+    const prodTarget = resolveProdAppTarget({
+      explicitAppId: explicitApp ? appId : null,
+      prodApp: projectTargets.prodApp,
+      acceptExplicitWithoutProdApp: true,
+    });
+    if (!prodTarget.appId) {
+      return { error: describeProdTargetFailure(prodTarget, missingProdMessage) };
     }
+    appId = prodTarget.appId;
   }
 
   if (!appId) {

package/lib/db-command.mjs

@@ -17,6 +17,7 @@ import { createDbCheckCommand, createDbPushCommand } from "./db-push-command.mjs
 import { logEnvFileOperationWithType } from "./backend-env-resolver.mjs";
 import { runDrizzleGenerateWithFallback } from "./drizzle-generate.mjs";
 import { BOLD, CYAN, DIM, GREEN, RED, RESET, error, info, log, success, warn } from "./output.mjs";
+import { describeProdTargetFailure, resolveProdAppTarget } from "./cloud-targets.mjs";
 import { platformFetch, requireCreds } from "./platform-client.mjs";
 import { readProjectMetadata } from "./project-context.mjs";
 
@@ -35,9 +36,17 @@ export function resolveDbCloudTarget(args, gencowJson = null) {
   if (gencowJson) {
     platformUrl = gencowJson.platformUrl || null;
     if (isProd) {
-      const prodApp = gencowJson.prodApp || null;
-      const appId = prodApp ? (!explicitAppId || explicitAppId === prodApp ? prodApp : null) : explicitAppId;
-      return { appId, isProd, platformUrl };
+      const prodTarget = resolveProdAppTarget({
+        explicitAppId,
+        prodApp: gencowJson.prodApp || null,
+        acceptExplicitWithoutProdApp: true,
+      });
+      return {
+        appId: prodTarget.appId,
+        isProd,
+        platformUrl,
+        prodTargetFailure: prodTarget.appId ? undefined : prodTarget,
+      };
     }
     return { appId: explicitAppId || gencowJson.appId || gencowJson.appName || null, isProd, platformUrl };
   }
@@ -369,10 +378,16 @@ export function createDbCommands({
         readFileSyncImpl,
         resolvePathImpl,
       });
-      const { appId, isProd, platformUrl } = resolveDbCloudTarget(args, gencowJson);
+      const target = resolveDbCloudTarget(args, gencowJson);
+      const { appId, isProd, platformUrl } = target;
 
       if (isProd && !appId) {
-        errorImpl("Prod app not found. Run 'gencow deploy' first to create a prod app.");
+        errorImpl(
+          describeProdTargetFailure(
+            target.prodTargetFailure,
+            "Prod app not found. Run 'gencow deploy' first to create a prod app.",
+          ),
+        );
         return 1;
       }
 

package/lib/db-push-command.mjs

@@ -53,6 +53,7 @@ import {
   resolveConfirmationMode,
 } from "./confirm-gate.mjs";
 import { emitMigrationResponsibilityNotice } from "./migration-advisory.mjs";
+import { describeProdTargetFailure } from "./cloud-targets.mjs";
 import { readProjectMetadata } from "./project-context.mjs";
 
 function clientCorrelationId() {
@@ -246,7 +247,12 @@ function createDbMigrationCommand(deps, command) {
             buildClientUserFixableDiagnostic("MIGRATION_APP_TARGET_MISSING", clientCorrelationId()),
           );
         } else if (isProd) {
-          deps.errorImpl("Prod app not found. Run 'gencow deploy' first to create a prod app.");
+          deps.errorImpl(
+            describeProdTargetFailure(
+              target.prodTargetFailure,
+              "Prod app not found. Run 'gencow deploy' first to create a prod app.",
+            ),
+          );
         } else {
           deps.errorImpl("Cloud app not found. Make sure gencow.json exists with an appId.");
           deps.infoImpl(`${DIM}Run 'gencow dev' first to create your app.${RESET}`);

package/lib/deploy-codegen-failure.mjs

@@ -33,6 +33,18 @@ function toProjectRelativePath(rawPath, cwd, processCwd) {
   return normalized;
 }
 
+// esbuild prints one diagnostic per line (`<file>:<line>:<col>: ERROR: <text>`) and the
+// Bun loader prints `Could not resolve`/`Cannot find module` for an import path that does
+// not exist. Those are load failures: the source is well-formed, its import is not.
+const DIAGNOSTIC_LINE_PATTERN = /ERROR: |Could not resolve "|Cannot find (?:module|package)\b/u;
+const UNRESOLVED_MODULE_PATTERN = /Could not resolve "|Cannot find (?:module|package)\b/u;
+
+// The first diagnostic decides the class, matching how the first location is reported.
+function isUnresolvedModuleFailure(message) {
+  const firstDiagnostic = message.split("\n").find((line) => DIAGNOSTIC_LINE_PATTERN.test(line)) ?? message;
+  return UNRESOLVED_MODULE_PATTERN.test(firstDiagnostic);
+}
+
 // Returns the first project-relative source location found in a raw message, or null.
 // Absolute paths, stacks and the raw text are never returned.
 function findProjectSourceLocation(message, { cwd, processCwd }) {
@@ -53,11 +65,14 @@ export function classifyDeployCodegenFailure(error, { cwd, backendRoot = "gencow
   const message = (error instanceof Error ? error.message : String(error ?? "")).slice(0, MAX_CLASSIFIED_MESSAGE_LENGTH);
   if (message.includes("Transpile error:")) {
     const location = findProjectSourceLocation(message, { cwd, processCwd });
+    const backendLocation = location && location.sourceFile.startsWith(`${backendRoot}/`) ? location : null;
+    if (isUnresolvedModuleFailure(message)) {
+      return { code: CODEGEN_FAILURE_CODES.SOURCE_LOAD_FAILED, ...(backendLocation ?? {}) };
+    }
     if (location) {
-      const inBackend = location.sourceFile.startsWith(`${backendRoot}/`);
       return {
         code: CODEGEN_FAILURE_CODES.SOURCE_SYNTAX_ERROR,
-        ...(inBackend ? location : {}),
+        ...(backendLocation ?? {}),
       };
     }
   }

package/lib/deploy-prod-target.mjs

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+import { CONFIRMATION_MODE, resolveConfirmationMode } from "./confirm-gate.mjs";
+import { confirmFirstProductionDeploy } from "./deploy-first-prod-confirm.mjs";
+import { reconcileProductionAppTarget } from "./deploy-app-target.mjs";
+import { readJsonObjectResponse } from "./http-response-json.mjs";
+import { BOLD, DIM, GREEN, RED, RESET, error, info, log, success } from "./output.mjs";
+import { prodCreateFailureMessage } from "./prod-create-failure.mjs";
+
+export async function ensureProductionDeployTarget({
+  appId,
+  displayName,
+  createCloudAppIfNeeded,
+  createInterfaceImpl,
+  creds,
+  deployArgs,
+  gencowJsonPath,
+  platformFetchImpl,
+  processEnv = process.env,
+  readFileSyncImpl = readFileSync,
+  setTimeoutImpl = setTimeout,
+  successImpl = success,
+  errorImpl = error,
+  infoImpl = info,
+  logImpl = log,
+  writeFileSyncImpl = writeFileSync,
+  exitImpl = (code) => process.exit(code),
+  prodAppId = null,
+  region = null,
+  prepareLocalSource = null,
+}) {
+  const confirmMode = resolveConfirmationMode({
+    allowCiBypass: true,
+    args: deployArgs,
+    createInterfaceImpl,
+    processEnv,
+  });
+  // Without a recorded prod app, the first create always needs confirmation, so a
+  // non-interactive run fails before any platform lookup or create request.
+  if (!prodAppId && confirmMode === CONFIRMATION_MODE.NON_INTERACTIVE) {
+    await confirmFirstProductionDeploy({ appId, errorImpl, infoImpl, logImpl, mode: confirmMode, region });
+    exitImpl(1);
+    return null;
+  }
+  const reconciledTarget = await reconcileProductionAppTarget({
+    appId,
+    prodAppId,
+    creds,
+    displayName,
+    gencowJsonPath,
+    platformFetchImpl,
+    createCloudAppIfNeeded,
+    infoImpl,
+    errorImpl,
+    exitImpl,
+  });
+  if (!reconciledTarget) return null;
+  const productionParentAppId = reconciledTarget.appId;
+  const existingProdAppId = reconciledTarget.prodAppId;
+  if (existingProdAppId) return existingProdAppId;
+  if (!productionParentAppId) return null;
+
+  const proceed = await confirmFirstProductionDeploy({
+    appId: productionParentAppId,
+    createInterfaceImpl,
+    errorImpl,
+    infoImpl,
+    logImpl,
+    mode: confirmMode,
+    region,
+  });
+  if (!proceed) {
+    exitImpl(1);
+    return null;
+  }
+
+  // Local source validation must pass before any remote create: a rejected source
+  // (for example a codegen failure) must not leave an empty production app behind.
+  // The callback renders its own diagnosis and returns false when it aborts.
+  if (prepareLocalSource && !(await prepareLocalSource())) return null;
+
+  infoImpl("Creating prod app...");
+  const createProdRes = await platformFetchImpl(
+    creds,
+    `/platform/apps/${productionParentAppId}/create-prod`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(region ? { region } : {}),
+    },
+  );
+
+  if (!createProdRes.ok) {
+    const errData = await readJsonObjectResponse(createProdRes);
+    if (createProdRes.status === 403) {
+      logImpl("");
+      logImpl(`  ${RED}⛔ Production Deploy — Startup or Enterprise required${RESET}`);
+      logImpl("");
+      logImpl(`  ${DIM}gencow deploy --prod is for production deployment.${RESET}`);
+      logImpl("");
+      logImpl(`  ${BOLD}💡 Dev environment deploy:${RESET}`);
+      logImpl(`     ${GREEN}gencow deploy${RESET}          ${DIM}← Deploy backend to dev${RESET}`);
+      logImpl(`     ${GREEN}gencow dev${RESET}             ${DIM}← Real-time backend + live logs${RESET}`);
+      logImpl(`     ${GREEN}gencow static dist/${RESET}    ${DIM}← Static file (dist/) deploy${RESET}`);
+      logImpl("");
+      logImpl(`  ${BOLD}🚀 Unlock production deploy:${RESET}`);
+      logImpl(`     ${GREEN}gencow upgrade${RESET}       ${DIM}← Upgrade to Startup${RESET}`);
+      logImpl("");
+    } else {
+      errorImpl(prodCreateFailureMessage(errData, createProdRes));
+    }
+    exitImpl(1);
+    return null;
+  }
+
+  const createProdData = await readJsonObjectResponse(createProdRes);
+  if (!createProdData) {
+    errorImpl("Prod app creation failed: server returned an invalid JSON response");
+    exitImpl(1);
+    return null;
+  }
+  const nextProdAppId = createProdData.prodApp;
+  const gencowJson = existsSync(gencowJsonPath) ? JSON.parse(readFileSyncImpl(gencowJsonPath, "utf8")) : {};
+  gencowJson.prodApp = nextProdAppId;
+  writeFileSyncImpl(gencowJsonPath, JSON.stringify(gencowJson, null, 2));
+
+  if (createProdData.alreadyExists) {
+    infoImpl(`Prod app verified: ${nextProdAppId}`);
+    if (region && createProdData.region && createProdData.region !== region) {
+      infoImpl(
+        `Region unchanged: existing prod app is in ${createProdData.region}; --region only applies to first prod creation.`,
+      );
+    }
+  } else {
+    successImpl(`Prod app created: ${nextProdAppId}`);
+    infoImpl(`URL: ${createProdData.url}`);
+    if (createProdData.region) {
+      infoImpl(`Region: ${createProdData.region} (${createProdData.regionSource || "selected"})`);
+    }
+    await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, 3000));
+  }
+
+  return nextProdAppId;
+}

package/lib/deploy-runtime.mjs

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { basename, resolve } from "path";
 import { readProjectDisplayName } from "./cli-project-runtime.mjs";
-import { BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
+import { BOLD, CYAN, DIM, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
 import { createDeployPackageRuntime } from "./deploy-package-runtime.mjs";
 import {
   getCliInvocationSelection,
@@ -16,11 +16,9 @@ import {
   runStaticDeployFlow,
 } from "./deploy-static-fullstack-runtime.mjs";
 import { detectStaticDeployBackend, preflightStaticDeployArtifact } from "./static-deploy-command.mjs";
-import { prodCreateFailureMessage } from "./prod-create-failure.mjs";
+import { formatCommandError } from "./cli-command-runner.mjs";
 import { readJsonObjectResponse } from "./http-response-json.mjs";
-import { reconcileProductionAppTarget } from "./deploy-app-target.mjs";
-import { CONFIRMATION_MODE, resolveConfirmationMode } from "./confirm-gate.mjs";
-import { confirmFirstProductionDeploy } from "./deploy-first-prod-confirm.mjs";
+import { ensureProductionDeployTarget } from "./deploy-prod-target.mjs";
 
 export function parseDeployArgs(deployArgs) {
   const parsed = {
@@ -185,134 +183,12 @@ function showUnknownDeployArgument(arg, { errorImpl = error, infoImpl = info, lo
   infoImpl("  gencow static [dir]           Deploy static files only");
 }
 
-async function ensureProductionDeployTarget({
-  appId,
-  displayName,
-  createCloudAppIfNeeded,
-  createInterfaceImpl,
-  creds,
-  deployArgs,
-  gencowJsonPath,
-  platformFetchImpl,
-  processEnv = process.env,
-  readFileSyncImpl = readFileSync,
-  setTimeoutImpl = setTimeout,
-  successImpl = success,
-  errorImpl = error,
-  infoImpl = info,
-  logImpl = log,
-  writeFileSyncImpl = writeFileSync,
-  exitImpl = (code) => process.exit(code),
-  prodAppId = null,
-  region = null,
-}) {
-  const confirmMode = resolveConfirmationMode({
-    allowCiBypass: true,
-    args: deployArgs,
-    createInterfaceImpl,
-    processEnv,
-  });
-  // Without a recorded prod app, the first create always needs confirmation, so a
-  // non-interactive run fails before any platform lookup or create request.
-  if (!prodAppId && confirmMode === CONFIRMATION_MODE.NON_INTERACTIVE) {
-    await confirmFirstProductionDeploy({ appId, errorImpl, infoImpl, logImpl, mode: confirmMode, region });
-    exitImpl(1);
-    return null;
-  }
-  const reconciledTarget = await reconcileProductionAppTarget({
-    appId,
-    prodAppId,
-    creds,
-    displayName,
-    gencowJsonPath,
-    platformFetchImpl,
-    createCloudAppIfNeeded,
-    infoImpl,
-    errorImpl,
-    exitImpl,
-  });
-  if (!reconciledTarget) return null;
-  const productionParentAppId = reconciledTarget.appId;
-  const existingProdAppId = reconciledTarget.prodAppId;
-  if (existingProdAppId) return existingProdAppId;
-  if (!productionParentAppId) return null;
-
-  const proceed = await confirmFirstProductionDeploy({
-    appId: productionParentAppId,
-    createInterfaceImpl,
-    errorImpl,
-    infoImpl,
-    logImpl,
-    mode: confirmMode,
-    region,
-  });
-  if (!proceed) {
-    exitImpl(1);
-    return null;
-  }
-
-  infoImpl("Creating prod app...");
-  const createProdRes = await platformFetchImpl(
-    creds,
-    `/platform/apps/${productionParentAppId}/create-prod`,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(region ? { region } : {}),
-    },
-  );
-
-  if (!createProdRes.ok) {
-    const errData = await readJsonObjectResponse(createProdRes);
-    if (createProdRes.status === 403) {
-      logImpl("");
-      logImpl(`  ${RED}⛔ Production Deploy — Startup or Enterprise required${RESET}`);
-      logImpl("");
-      logImpl(`  ${DIM}gencow deploy --prod is for production deployment.${RESET}`);
-      logImpl("");
-      logImpl(`  ${BOLD}💡 Dev environment deploy:${RESET}`);
-      logImpl(`     ${GREEN}gencow deploy${RESET}          ${DIM}← Deploy backend to dev${RESET}`);
-      logImpl(`     ${GREEN}gencow dev${RESET}             ${DIM}← Real-time backend + live logs${RESET}`);
-      logImpl(`     ${GREEN}gencow static dist/${RESET}    ${DIM}← Static file (dist/) deploy${RESET}`);
-      logImpl("");
-      logImpl(`  ${BOLD}🚀 Unlock production deploy:${RESET}`);
-      logImpl(`     ${GREEN}gencow upgrade${RESET}       ${DIM}← Upgrade to Startup${RESET}`);
-      logImpl("");
-    } else {
-      errorImpl(prodCreateFailureMessage(errData, createProdRes));
-    }
-    exitImpl(1);
-    return null;
-  }
-
-  const createProdData = await readJsonObjectResponse(createProdRes);
-  if (!createProdData) {
-    errorImpl("Prod app creation failed: server returned an invalid JSON response");
-    exitImpl(1);
-    return null;
-  }
-  const nextProdAppId = createProdData.prodApp;
-  const gencowJson = existsSync(gencowJsonPath) ? JSON.parse(readFileSyncImpl(gencowJsonPath, "utf8")) : {};
-  gencowJson.prodApp = nextProdAppId;
-  writeFileSyncImpl(gencowJsonPath, JSON.stringify(gencowJson, null, 2));
-
-  if (createProdData.alreadyExists) {
-    infoImpl(`Prod app verified: ${nextProdAppId}`);
-    if (region && createProdData.region && createProdData.region !== region) {
-      infoImpl(
-        `Region unchanged: existing prod app is in ${createProdData.region}; --region only applies to first prod creation.`,
-      );
-    }
-  } else {
-    successImpl(`Prod app created: ${nextProdAppId}`);
-    infoImpl(`URL: ${createProdData.url}`);
-    if (createProdData.region) {
-      infoImpl(`Region: ${createProdData.region} (${createProdData.regionSource || "selected"})`);
-    }
-    await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, 3000));
-  }
-
-  return nextProdAppId;
+// Returns the prepared backend source, or null when the capability check rejected it
+// (the rejection is already rendered and exit is already requested).
+async function prepareBackendSourceForProdCreate(runtime) {
+  if ((await runtime.preflightBackendCapability?.()) === false) return null;
+  const generatorVersion = await runtime.prepareDeployProjectSource?.({ existingBundleMode: false });
+  return { runtime, generatorVersion };
 }
 
 async function runRollbackDeploy({
@@ -528,12 +404,15 @@ export function createDeployCommand({
       try {
         staticArtifactPreflight = preflightStaticDeployArtifactImpl({
           staticDirArg: resolvedStaticDirArg,
+          // Display text is what the user typed or the client config says, never the resolved path.
+          staticDirDisplay: parsed.staticDirArg ?? selectedClient?.static?.dir ?? null,
+          staticDirSource: parsed.staticDirArg ? "argument" : "config",
           cwd: staticArtifactCwd,
           existsSyncImpl,
           resolvePathImpl,
         });
       } catch (manifestError) {
-        errorImpl(manifestError instanceof Error ? manifestError.message : String(manifestError));
+        errorImpl(formatCommandError(manifestError));
         exitImpl(1);
         return;
       }
@@ -614,28 +493,46 @@ export function createDeployCommand({
       return;
     }
 
+    // Backend source preparation (capability check, migration generation, codegen) runs
+    // before the production app is created, so a rejected source creates no remote app.
+    // It is prepared once here and handed to deployBackendPackage/runStaticDeployFlow.
+    let preparedSource = null;
     if (parsed.envTarget === "prod" && appId && !parsed.existingBundleMode && !parsed.resumeRequested) {
-      const prodTarget = await ensureProductionDeployTarget({
-        appId: rootAppId,
-        displayName,
-        createCloudAppIfNeeded: backendDeployRuntime.createCloudAppIfNeeded,
-        createInterfaceImpl,
-        creds,
-        deployArgs,
-        gencowJsonPath,
-        platformFetchImpl,
-        processEnv,
-        readFileSyncImpl,
-        setTimeoutImpl,
-        successImpl,
-        errorImpl,
-        infoImpl,
-        logImpl,
-        writeFileSyncImpl,
-        exitImpl,
-        prodAppId,
-        region: parsed.region,
-      });
+      // A static-only deploy has no backend source to prepare.
+      const preparesBackendSource = !parsed.staticDeploy || hasDetectedBackend;
+      let prodTarget = null;
+      try {
+        prodTarget = await ensureProductionDeployTarget({
+          appId: rootAppId,
+          displayName,
+          createCloudAppIfNeeded: backendDeployRuntime.createCloudAppIfNeeded,
+          createInterfaceImpl,
+          creds,
+          deployArgs,
+          gencowJsonPath,
+          platformFetchImpl,
+          processEnv,
+          readFileSyncImpl,
+          setTimeoutImpl,
+          successImpl,
+          errorImpl,
+          infoImpl,
+          logImpl,
+          writeFileSyncImpl,
+          exitImpl,
+          prodAppId,
+          region: parsed.region,
+          prepareLocalSource: preparesBackendSource
+            ? async () => {
+                preparedSource = await prepareBackendSourceForProdCreate(backendDeployRuntime);
+                return preparedSource !== null;
+              }
+            : null,
+        });
+      } finally {
+        // Prepared codegen output is temporary; drop it when no production app was created.
+        if (!prodTarget) backendDeployRuntime.cleanupPreparedDeploySource?.();
+      }
       if (!prodTarget) return;
       appId = prodTarget;
       infoImpl(`Deploy target: ${CYAN}${appId}${RESET} (production)`);
@@ -649,6 +546,7 @@ export function createDeployCommand({
     if (parsed.staticDeploy) {
       await runStaticDeployFlow({
         appId,
+        preparedSource,
         backendRoot: backendProjectRoot,
         creds,
         displayName,
@@ -736,6 +634,7 @@ export function createDeployCommand({
 
       await deployBackendPackage({
         activePackageRuntime,
+        preparedSource,
         appId,
         creds,
         displayName,