turbine-orm 0.81.0 → 0.90.0

package/dist/cjs/cli/index.js

@@ -60,6 +60,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATE_POOLER_EXPLANATION = exports.DEFAULT_LOCK_WAIT_SECONDS = void 0;
 exports.canonicalCommand = canonicalCommand;
 exports.knownCommands = knownCommands;
 exports.flagsForCommand = flagsForCommand;
@@ -81,6 +82,8 @@ exports.scaffoldEnvForUrl = scaffoldEnvForUrl;
 exports.generatedClientImport = generatedClientImport;
 exports.initEnvNotice = initEnvNotice;
 exports.refuseSchemaFilePath = refuseSchemaFilePath;
+exports.overlayCodeFirstTags = overlayCodeFirstTags;
+exports.generatorColumnTypes = generatorColumnTypes;
 exports.resolveMigrateFromPrismaUrl = resolveMigrateFromPrismaUrl;
 exports.readPrismaSchemaSource = readPrismaSchemaSource;
 exports.buildMigrateDeployOptions = buildMigrateDeployOptions;
@@ -105,8 +108,10 @@ const prisma_schema_fingerprint_js_1 = require("../prisma-schema-fingerprint.js"
 const utils_js_1 = require("../query/utils.js");
 const schema_js_1 = require("../schema.js");
 const schema_sql_js_1 = require("../schema-sql.js");
+const code_first_tags_js_1 = require("./code-first-tags.js");
 const config_js_1 = require("./config.js");
 const destructive_js_1 = require("./destructive.js");
+const error_text_js_1 = require("./error-text.js");
 const loader_js_1 = require("./loader.js");
 const mcp_js_1 = require("./mcp.js");
 const migrate_js_1 = require("./migrate.js");
@@ -116,6 +121,8 @@ const prisma_resolve_js_1 = require("./prisma-resolve.js");
 const prisma_schema_js_1 = require("./prisma-schema.js");
 const studio_js_1 = require("./studio.js");
 const ui_js_1 = require("./ui.js");
+/** How long a bare `migrate deploy --wait` waits for a concurrent deploy to finish. */
+exports.DEFAULT_LOCK_WAIT_SECONDS = 300;
 /**
  * Fail an argument-parse error the way every other CLI failure looks: banner,
  * red error line, then indented hint lines. The flag validators used to call
@@ -170,6 +177,7 @@ const GLOBAL_FLAGS = [
 const COMMAND_FLAGS = {
     init: ['--yes', '--schema-file', '--skip-schema', '--with-schema', '--skip-seed', '--skip-push', '--skip-generate'],
     generate: [
+        '--schema-file',
         '--zod',
         '--include-views',
         '--no-timestamp',
@@ -179,7 +187,7 @@ const COMMAND_FLAGS = {
         '--allow-empty',
     ],
     'migrate-from-prisma': ['--no-db', '--if-db', '--allow-partial', '--no-timestamp'],
-    push: ['--schema-file', '--dry-run', '--allow-destructive'],
+    push: ['--schema-file', '--dry-run', '--exit-code', '--allow-destructive'],
     migrate: [
         '--schema-file',
         '--auto',
@@ -187,8 +195,12 @@ const COMMAND_FLAGS = {
         '--recipe',
         '--step',
         '--dry-run',
+        '--exit-code',
+        '--wait',
         '--allow-drift',
         '--allow-destructive',
+        '--allow-pending',
+        '--allow-pooler',
     ],
     seed: [],
     status: [],
@@ -366,6 +378,8 @@ function parseArgs(argv = process.argv.slice(2)) {
     const unknownFlags = [];
     /** The raw `--step` operand, judged after the loop. Absent means unset. */
     let stepRaw;
+    /** The raw `--wait` operand, judged after the loop: undefined absent, null bare `--wait`. */
+    let waitRaw;
     for (; i < args.length; i++) {
         const arg = args[i];
         const next = args[i + 1];
@@ -373,8 +387,15 @@ function parseArgs(argv = process.argv.slice(2)) {
         // (`--step -1`, `--host -x`) is consumed by its own case and never reaches
         // this test. A bare `-`-prefixed token that is not a flag reaches it and is
         // rejected: no command takes a negative-number positional.
-        if (accepted && arg.startsWith('-') && !accepted.has(arg))
+        // `--wait=30` is the one flag whose value attaches with `=`, so it is
+        // matched by its name and handled here rather than by a `case` label.
+        const attachedWait = arg.startsWith('--wait=');
+        if (accepted && arg.startsWith('-') && !accepted.has(attachedWait ? '--wait' : arg))
             unknownFlags.push(arg);
+        if (attachedWait) {
+            waitRaw = arg.slice('--wait='.length);
+            continue;
+        }
         switch (arg) {
             case '--url':
             case '-u':
@@ -418,6 +439,23 @@ function parseArgs(argv = process.argv.slice(2)) {
             case '--dry-run':
                 result.dryRun = true;
                 break;
+            case '--exit-code':
+                result.exitCode = true;
+                break;
+            case '--allow-pending':
+                result.allowPending = true;
+                break;
+            case '--wait':
+                // `--wait 30` reads the next token only when it is all digits: `deploy`
+                // takes no positional, so a bare number after the flag is its value.
+                if (next !== undefined && /^\d+$/.test(next)) {
+                    waitRaw = next;
+                    i++;
+                }
+                else {
+                    waitRaw = null;
+                }
+                break;
             case '--auto':
                 result.auto = true;
                 break;
@@ -500,8 +538,8 @@ function parseArgs(argv = process.argv.slice(2)) {
                 break;
             case '--import-ext':
             case '--import-extension':
-                if (next !== 'js' && next !== 'none' && next !== 'auto') {
-                    failArg(`${(0, ui_js_1.cyan)('--import-ext')} requires one of: js, none, auto ${(0, ui_js_1.dim)(`(got ${next ?? 'nothing'})`)}`, 'Example: npx turbine generate --import-ext none');
+                if (next !== 'js' && next !== 'ts' && next !== 'none' && next !== 'auto') {
+                    failArg(`${(0, ui_js_1.cyan)('--import-ext')} requires one of: js, ts, none, auto ${(0, ui_js_1.dim)(`(got ${next ?? 'nothing'})`)}`, 'Example: npx turbine generate --import-ext ts');
                 }
                 result.importExtension = next;
                 i++;
@@ -592,6 +630,18 @@ function parseArgs(argv = process.argv.slice(2)) {
         }
         result.step = parsed;
     }
+    if (waitRaw !== undefined && accepted !== undefined) {
+        if (waitRaw === null) {
+            result.wait = exports.DEFAULT_LOCK_WAIT_SECONDS;
+        }
+        else {
+            const parsed = /^\d+$/.test(waitRaw.trim()) ? Number.parseInt(waitRaw, 10) : Number.NaN;
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                failArg(`${(0, ui_js_1.cyan)('--wait')} expects a positive whole number of seconds, got ${(0, ui_js_1.bold)(waitRaw === '' ? '(nothing)' : `"${waitRaw}"`)}.`, `Bare ${'--wait'} waits ${exports.DEFAULT_LOCK_WAIT_SECONDS} seconds. To not wait at all, leave the flag off.`, 'Example: npx turbine migrate deploy --wait=120');
+            }
+            result.wait = parsed;
+        }
+    }
     return result;
 }
 // ---------------------------------------------------------------------------
@@ -790,6 +840,11 @@ function loadDotEnvForCli(deps = {}) {
     if (!fileExists(envPath)) {
         return { fileExists: false, loaded: false, unsupported: false, databaseUrlProvenance: shellOrNone };
     }
+    // An exported-but-empty `DATABASE_URL=` means "not configured", and the loader
+    // never overrides a variable that is already set, so it would otherwise block
+    // the value in the `.env` for good.
+    if (env.DATABASE_URL === '')
+        delete env.DATABASE_URL;
     const loader = deps.loadEnvFile !== undefined
         ? deps.loadEnvFile
         : typeof process.loadEnvFile === 'function'
@@ -807,7 +862,7 @@ function loadDotEnvForCli(deps = {}) {
             loaded: false,
             unsupported: false,
             databaseUrlProvenance: shellOrNone,
-            loadError: err instanceof Error ? err.message : String(err),
+            loadError: (0, error_text_js_1.errorText)(err),
         };
     }
     // `.env`-sourced only if DATABASE_URL was absent before and present after.
@@ -1206,42 +1261,94 @@ DATABASE_URL=postgres://user:password@localhost:5432/database
  * @internal exported for tests.
  */
 function scaffoldEnvForUrl(url) {
+    // The plan is read from disk and the writes come after it, so a file can
+    // appear in between. Creation is exclusive (see createFileExclusive); when it
+    // loses, plan again from what is there now. The cap only ends the loop for a
+    // name that cannot be read but cannot be created either, a dangling symlink.
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const plan = applyEnvScaffold(url);
+        if (plan)
+            return plan;
+    }
+    throw new errors_js_1.ValidationError('Could not write .env, .env.example and .gitignore: one of those names is taken by something that cannot be read ' +
+        '(a dangling symlink?). Remove it and run the command again.');
+}
+/** One planning pass plus its writes; undefined when a create found its name already taken. */
+function applyEnvScaffold(url) {
     const envPath = '.env';
     const envExamplePath = '.env.example';
     const gitignorePath = '.gitignore';
-    const envExists = (0, node_fs_1.existsSync)(envPath);
+    const env = readIfPresent(envPath);
+    const gitignore = readIfPresent(gitignorePath);
     const plan = planEnvScaffold({
-        envExists,
-        envHasDatabaseUrl: envExists ? /^\s*(export\s+)?DATABASE_URL\s*=/m.test((0, node_fs_1.readFileSync)(envPath, 'utf-8')) : false,
-        envExampleExists: (0, node_fs_1.existsSync)(envExamplePath),
-        gitignoreExists: (0, node_fs_1.existsSync)(gitignorePath),
-        gitignoreIgnoresEnv: (0, node_fs_1.existsSync)(gitignorePath) ? gitignoreIgnoresEnv((0, node_fs_1.readFileSync)(gitignorePath, 'utf-8')) : false,
+        envExists: env !== undefined,
+        envHasDatabaseUrl: env !== undefined && /^\s*(export\s+)?DATABASE_URL\s*=/m.test(env),
+        envExampleExists: readIfPresent(envExamplePath) !== undefined,
+        gitignoreExists: gitignore !== undefined,
+        gitignoreIgnoresEnv: gitignore !== undefined && gitignoreIgnoresEnv(gitignore),
     });
     // .gitignore FIRST: the ignore rule has to exist before the file holding the
     // password does, or a `git add -A` in between commits it.
-    if (plan.gitignore === 'created')
-        (0, node_fs_1.writeFileSync)(gitignorePath, '# Local environment (secrets)\n.env\n', 'utf-8');
-    else if (plan.gitignore === 'appended')
+    if (plan.gitignore === 'created') {
+        if (!createFileExclusive(gitignorePath, '# Local environment (secrets)\n.env\n'))
+            return undefined;
+    }
+    else if (plan.gitignore === 'appended') {
         (0, node_fs_1.appendFileSync)(gitignorePath, '\n# Local environment (secrets)\n.env\n');
+    }
+    // 0600 on CREATION only. The whole point of this scaffold is moving a live
+    // password out of a committed file, and the default 0644 would leave it
+    // world-readable to every account on a shared box or CI runner. `mode` is
+    // applied by the OS only when the open() actually creates the file, so a
+    // `.env` that exists keeps whatever mode its owner chose.
     if (plan.env === 'created') {
-        // 0600 on CREATION only. The whole point of this scaffold is moving a live
-        // password out of a committed file, and the default 0644 would leave it
-        // world-readable to every account on a shared box or CI runner. `mode` is
-        // applied by the OS only when the open() actually creates the file, so if
-        // one appeared since the existsSync above we write into it without widening
-        // or narrowing whatever mode its owner chose.
-        (0, node_fs_1.writeFileSync)(envPath, `# Turbine database connection. Never commit this file.\nDATABASE_URL=${url}\n`, {
-            encoding: 'utf-8',
-            mode: 0o600,
-        });
+        const body = `# Turbine database connection. Never commit this file.\nDATABASE_URL=${url}\n`;
+        if (!createFileExclusive(envPath, body, 0o600))
+            return undefined;
     }
     else if (plan.env === 'appended') {
-        (0, node_fs_1.appendFileSync)(envPath, `\n# Added by turbine init\nDATABASE_URL=${url}\n`);
+        (0, node_fs_1.appendFileSync)(envPath, `\n# Added by turbine init\nDATABASE_URL=${url}\n`, { mode: 0o600 });
     }
-    if (plan.envExample === 'created')
-        (0, node_fs_1.writeFileSync)(envExamplePath, ENV_EXAMPLE_TEMPLATE, 'utf-8');
+    if (plan.envExample === 'created' && !createFileExclusive(envExamplePath, ENV_EXAMPLE_TEMPLATE))
+        return undefined;
     return plan;
 }
+/**
+ * A file's text, or undefined when there is no such file. One read in place of
+ * an existence check followed by a read, so there is no window between the two.
+ * A directory under that name counts as present: the write step then fails on
+ * it by name, which is the error that was always raised.
+ */
+function readIfPresent(path) {
+    try {
+        return (0, node_fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return undefined;
+        if (code === 'EISDIR')
+            return '';
+        throw err;
+    }
+}
+/**
+ * Create `path` only if nothing is there; false when the name is taken.
+ * `wx` is O_CREAT | O_EXCL: the kernel refuses (EEXIST) any existing name,
+ * a symlink included, so a file that appeared after the plan was made is never
+ * truncated and a link planted at the name is never written through.
+ */
+function createFileExclusive(path, body, mode) {
+    try {
+        (0, node_fs_1.writeFileSync)(path, body, { encoding: 'utf-8', flag: 'wx', ...(mode === undefined ? {} : { mode }) });
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'EEXIST')
+            return false;
+        throw err;
+    }
+}
 /** Say exactly what was written where, so nobody has to guess where the password went. */
 function reportEnvScaffold(plan, url) {
     (0, ui_js_1.warn)(`The connection string passed to ${(0, ui_js_1.cyan)('--url')} contains a password.`);
@@ -1277,8 +1384,8 @@ function ensureInitScaffoldDirs(config) {
         (0, ui_js_1.success)(`Created ${(0, ui_js_1.cyan)(`${config.out}/`)}`);
     }
     const gitignorePath = '.gitignore';
-    if ((0, node_fs_1.existsSync)(gitignorePath)) {
-        const gitignoreContent = (0, node_fs_1.readFileSync)(gitignorePath, 'utf-8');
+    const gitignoreContent = readIfPresent(gitignorePath);
+    if (gitignoreContent !== undefined) {
         const additions = [];
         if (!gitignoreContent.includes('generated/turbine'))
             additions.push('generated/turbine/');
@@ -1384,8 +1491,19 @@ async function runInitGenerate(config, url) {
         });
         const tableNames = Object.keys(schema.tables);
         spinner.succeed(`Found ${(0, ui_js_1.bold)(String(tableNames.length))} tables`);
+        // The schema file init just pushed is where `pii` / `updatedAt` live.
+        const appliedTags = await overlayCodeFirstTags(schema, config);
+        if (appliedTags && describeAppliedTags(appliedTags)) {
+            (0, ui_js_1.info)(`Applied column tags from ${(0, ui_js_1.cyan)(config.schemaFile)}: ${describeAppliedTags(appliedTags)}`);
+        }
         const genSpinner = new ui_js_1.Spinner('Generating TypeScript client').start();
-        const result = (0, generate_js_1.generate)({ schema, outDir: config.out, connectionString: url });
+        const result = (0, generate_js_1.generate)({
+            schema,
+            outDir: config.out,
+            connectionString: url,
+            importExtension: config.importExtension,
+            columnTypes: await generatorColumnTypesFor(appliedTags, config, schema, url),
+        });
         genSpinner.succeed(`Generated ${(0, ui_js_1.bold)(String(result.files.length))} files to ${(0, ui_js_1.cyan)(`${config.out}/`)}`);
         // The accessor name the generator emits is snakeToCamel of the table name
         // (generate.ts, generateIndex), so this is the spelling that autocompletes.
@@ -1394,8 +1512,7 @@ async function runInitGenerate(config, url) {
     }
     catch (err) {
         spinner.fail('Could not generate client');
-        if (err instanceof Error)
-            (0, ui_js_1.errorLine)((0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message)));
+        (0, ui_js_1.errorLine)((0, ui_js_1.dim)((0, ui_js_1.redactUrl)((0, error_text_js_1.errorText)(err))));
         (0, ui_js_1.info)(`Run generation later with: ${(0, ui_js_1.cyan)('npx turbine generate')}`);
         return { tableCount: null };
     }
@@ -1409,13 +1526,14 @@ async function runInitSeed(config) {
     }
     const spinner = new ui_js_1.Spinner('Running seed file').start();
     try {
-        await runSeedPlan(getSeedExecutionPlan(seedFile), config);
+        const outcome = await runSeedPlan(getSeedExecutionPlan(seedFile), config);
         spinner.succeed('Seed completed');
+        if (!outcome.confirmed)
+            (0, ui_js_1.warn)(UNCONFIRMED_SEED_NOTICE);
     }
     catch (err) {
         spinner.fail('Seed failed');
-        if (err instanceof Error)
-            console.log(`  ${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message))}`);
+        console.log(`  ${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)((0, error_text_js_1.errorText)(err)))}`);
     }
 }
 /** Human label for a step, used in prompts and skip messages. */
@@ -1726,7 +1844,7 @@ async function cmdInit(args, config) {
         console.log(`  ${(0, ui_js_1.dim)('Nothing to connect to yet?')} ${(0, ui_js_1.cyan)('npx turbine studio --demo')} ${(0, ui_js_1.dim)('needs no database.')}`);
     }
     else {
-        const accessor = generated.sampleAccessor ?? 'users';
+        const accessor = shown(generated.sampleAccessor ?? 'users');
         console.log(`  ${(0, ui_js_1.dim)('1.')} Import the generated client:`);
         console.log(`     ${(0, ui_js_1.cyan)(generatedClientImport(config))}`);
         (0, ui_js_1.newline)();
@@ -1775,7 +1893,7 @@ function refuseSchemaFilePath(config, options = {}) {
     (0, ui_js_1.errorLine)();
     (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)('Or set it once in')} ${(0, ui_js_1.cyan)('turbine.config.ts')}${(0, ui_js_1.dim)(':')}`);
     (0, ui_js_1.errorLine)(`  ${(0, ui_js_1.green)('schema:')} ${(0, ui_js_1.cyan)("'public'")}${(0, ui_js_1.dim)(",       // or omit, reads the 'public' schema")}`);
-    (0, ui_js_1.errorLine)(`  ${(0, ui_js_1.green)('schemaFile:')} ${(0, ui_js_1.cyan)(`'${config.schema}'`)}${(0, ui_js_1.dim)(', // your defineSchema() file (used by `turbine push`)')}`);
+    (0, ui_js_1.errorLine)(`  ${(0, ui_js_1.green)('schemaFile:')} ${(0, ui_js_1.cyan)(`'${config.schema}'`)}${(0, ui_js_1.dim)(', // your defineSchema() file (read by push and generate)')}`);
     if (options.escapeHatch) {
         (0, ui_js_1.errorLine)();
         (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)('Re-run with')} ${(0, ui_js_1.cyan)(options.escapeHatch)} ${(0, ui_js_1.dim)('to use this literal schema name anyway.')}`);
@@ -1784,6 +1902,113 @@ function refuseSchemaFilePath(config, options = {}) {
     process.exit(1);
 }
 // ---------------------------------------------------------------------------
+// Code-first column tags
+// ---------------------------------------------------------------------------
+/**
+ * Overlay the column tags the defineSchema() file declares (`pii`, `updatedAt`,
+ * `maxLength`) onto an introspected schema, before it is generated.
+ *
+ * Introspection reads the database, and the database has no column for these
+ * flags, so a client generated from introspection alone returns PII by default,
+ * never stamps `updatedAt`, and leaves Studio and the MCP server with nothing to
+ * redact. The schema file is the only place the tags exist.
+ *
+ * Loaded when the file was named (`--schema-file` / config `schemaFile`) or sits
+ * at the default path. A named file that is missing, or any file that cannot be
+ * loaded, fails the command: carrying on would generate the unredacted client
+ * this exists to prevent. Only a missing DEFAULT file is skipped, which is a
+ * database-first project with no schema file at all.
+ *
+ * Returns what was applied, or `null` when there was no schema file to read.
+ *
+ * @internal exported for tests.
+ */
+async function overlayCodeFirstTags(schema, config) {
+    if (config.schemaFileConfigured !== true && !(0, node_fs_1.existsSync)((0, node_path_1.resolve)(config.schemaFile)))
+        return null;
+    const def = await loadSchemaFile(config.schemaFile);
+    const filters = {
+        include: config.include.length ? config.include : undefined,
+        exclude: config.exclude.length ? config.exclude : undefined,
+    };
+    return (0, code_first_tags_js_1.applyCodeFirstColumnTags)(schema, (0, code_first_tags_js_1.extractCodeFirstColumnTags)(def), {
+        source: config.schemaFile,
+        // A table the caller filtered out of the client has no client to tag.
+        inScope: (table) => (0, introspect_js_1.applyTableFilters)([table], filters).length > 0,
+    });
+}
+/** "2 pii, 1 updatedAt" for the line that reports an {@link overlayCodeFirstTags} result. */
+function describeAppliedTags(applied) {
+    const parts = [];
+    if (applied.pii > 0)
+        parts.push(`${applied.pii} pii`);
+    if (applied.updatedAt > 0)
+        parts.push(`${applied.updatedAt} updatedAt`);
+    if (applied.maxLength > 0)
+        parts.push(`${applied.maxLength} maxLength`);
+    const tsTypes = Object.keys(applied.columnTypes).length;
+    if (tsTypes > 0)
+        parts.push(`${tsTypes} tsType`);
+    return parts.join(', ');
+}
+/**
+ * The generator's `columnTypes`: the schema file's `tsType` declarations, then
+ * the config file's `columnTypes`, which wins on the same key. A config key
+ * whose table the run's include / exclude filters leave out is dropped, since
+ * that table has no generated type to override; every other key goes to the
+ * generator, which rejects one naming no table or column.
+ *
+ * An `include` list leaves out every table it does not name, so a misspelt
+ * table looks exactly like a real table that was left out. `databaseTables`
+ * (every table the schema holds, before filtering) tells them apart: only a
+ * table the database has is dropped, and a name it does not have goes on to the
+ * generator, which names the closest match. Without it every key outside the
+ * filters is dropped.
+ *
+ * @internal exported for tests.
+ */
+function generatorColumnTypes(applied, config, schema, databaseTables) {
+    const filters = {
+        include: config.include.length ? config.include : undefined,
+        exclude: config.exclude.length ? config.exclude : undefined,
+    };
+    const merged = { ...applied?.columnTypes };
+    for (const [key, type] of Object.entries(config.columnTypes ?? {})) {
+        const table = key.slice(0, key.lastIndexOf('.'));
+        const leftOut = !Object.hasOwn(schema.tables, table) && (0, introspect_js_1.applyTableFilters)([table], filters).length === 0;
+        if (leftOut && (databaseTables === undefined || databaseTables.has(table)))
+            continue;
+        merged[key] = type;
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+/** The names of every table and view in `schema`, before any include / exclude filter. */
+async function listDatabaseTables(url, schema) {
+    const { default: pg } = await Promise.resolve().then(() => __importStar(require('pg')));
+    const client = new pg.Client({ connectionString: url });
+    (0, connection_guard_js_1.guardConnection)(client);
+    await client.connect();
+    try {
+        const res = await client.query('SELECT table_name FROM information_schema.tables WHERE table_schema = $1', [schema]);
+        return new Set(res.rows.map((r) => r.table_name));
+    }
+    finally {
+        await client.end();
+    }
+}
+/**
+ * {@link generatorColumnTypes} for a run against a database. The catalog is read
+ * only when an `include` list is set and a config key names a table outside the
+ * generated set, which is the one case where a typo and a table left out look
+ * alike.
+ */
+async function generatorColumnTypesFor(applied, config, schema, url, namespace = config.schema) {
+    const keys = Object.keys(config.columnTypes ?? {});
+    const outsideInclude = config.include.length > 0 && keys.some((key) => !Object.hasOwn(schema.tables, key.slice(0, key.lastIndexOf('.'))));
+    const databaseTables = outsideInclude && url ? await listDatabaseTables(url, namespace) : undefined;
+    return generatorColumnTypes(applied, config, schema, databaseTables);
+}
+// ---------------------------------------------------------------------------
 // Command: generate (pull)
 // ---------------------------------------------------------------------------
 async function cmdGenerate(args, config) {
@@ -1822,6 +2047,10 @@ async function cmdGenerate(args, config) {
     for (const t of skippedInternalTables) {
         console.log(`    ${(0, ui_js_1.dim)(`${ui_js_1.symbols.teeEnd} skipped internal table ${t} (add it to include to keep it)`)}`);
     }
+    const appliedTags = await overlayCodeFirstTags(schema, config);
+    if (appliedTags && describeAppliedTags(appliedTags)) {
+        console.log(`    ${(0, ui_js_1.dim)(`${ui_js_1.symbols.teeEnd} applied column tags from ${config.schemaFile}: ${describeAppliedTags(appliedTags)}`)}`);
+    }
     // Guard: zero tables means the generated client would be empty. That is almost
     // always a misconfiguration (wrong `schema`, an include/exclude that filtered
     // everything, or a database with no tables yet) rather than intent. Fail loudly
@@ -1846,12 +2075,12 @@ async function cmdGenerate(args, config) {
         for (const tbl of Object.values(schema.tables)) {
             const relCount = Object.keys(tbl.relations).length;
             const pk = tbl.primaryKey.join(', ') || '(none)';
-            console.log(`  ${ui_js_1.symbols.tee} ${(0, ui_js_1.bold)(tbl.name)} ${(0, ui_js_1.dim)(`${tbl.columns.length} cols, PK: ${pk}`)}${relCount > 0 ? (0, ui_js_1.dim)(`, ${relCount} rels`) : ''}`);
+            console.log(`  ${ui_js_1.symbols.tee} ${(0, ui_js_1.bold)(shown(tbl.name))} ${(0, ui_js_1.dim)(`${tbl.columns.length} cols, PK: ${shown(pk)}`)}${relCount > 0 ? (0, ui_js_1.dim)(`, ${relCount} rels`) : ''}`);
         }
         (0, ui_js_1.newline)();
     }
     if (Object.keys(schema.enums).length > 0) {
-        (0, ui_js_1.info)(`Enums: ${Object.keys(schema.enums).join(', ')}`);
+        (0, ui_js_1.info)(`Enums: ${Object.keys(schema.enums).map(shown).join(', ')}`);
     }
     // Generate
     const genSpinner = new ui_js_1.Spinner('Generating TypeScript client').start();
@@ -1863,6 +2092,7 @@ async function cmdGenerate(args, config) {
         noTimestamp: args.noTimestamp,
         importExtension: config.importExtension,
         keepColumnNames: config.keepColumnNames,
+        columnTypes: await generatorColumnTypesFor(appliedTags, config, schema, url),
     });
     genSpinner.succeed(`Generated ${(0, ui_js_1.bold)(String(result.files.length))} files in ${(0, ui_js_1.elapsed)(startTime)}`);
     // List files
@@ -1879,7 +2109,12 @@ async function cmdGenerate(args, config) {
     console.log(`  ${(0, ui_js_1.dim)('const db = turbine({ connectionString: process.env.DATABASE_URL });')}`);
     // Name a table the client just emitted rather than a hardcoded `users`.
     const sampleAccessor = (0, schema_js_1.snakeToCamel)(tableNames[0] ?? 'users');
-    console.log(`  ${(0, ui_js_1.dim)(`const row = await db.${sampleAccessor}.findFirst();`)}`);
+    console.log(`  ${(0, ui_js_1.dim)(`const row = await db.${shown(sampleAccessor)}.findFirst();`)}`);
+    if (config.importExtension === 'ts') {
+        (0, ui_js_1.newline)();
+        console.log(`  ${(0, ui_js_1.dim)('Run it with Node type stripping:')} ${(0, ui_js_1.cyan)('node --env-file=.env app.ts')} ${(0, ui_js_1.dim)('(Node 22.18+ or 23.6+; earlier 22.x needs --experimental-strip-types)')}`);
+        console.log(`  ${(0, ui_js_1.dim)('A type checker needs')} ${(0, ui_js_1.cyan)('allowImportingTsExtensions')} ${(0, ui_js_1.dim)('(or')} ${(0, ui_js_1.cyan)('rewriteRelativeImportExtensions')}${(0, ui_js_1.dim)(') in tsconfig.json.')}`);
+    }
     (0, ui_js_1.newline)();
 }
 /**
@@ -1917,8 +2152,15 @@ function resolveMigrateFromPrismaUrl(configUrl, ast, env) {
  * concatenation, so each file is introduced by a comment naming it.
  */
 function readPrismaSchemaSource(path) {
-    if (!(0, node_fs_1.statSync)(path).isDirectory())
+    // Read first, ask what it is only if that fails: a stat followed by a read
+    // can disagree with itself when the path is replaced in between.
+    try {
         return (0, node_fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (err) {
+        if (err.code !== 'EISDIR')
+            throw err;
+    }
     const files = (0, node_fs_1.readdirSync)(path)
         .filter((f) => f.endsWith('.prisma'))
         .sort();
@@ -1953,7 +2195,7 @@ async function cmdMigrateFromPrisma(args, config) {
     catch (err) {
         (0, ui_js_1.newline)();
         (0, ui_js_1.error)(`Could not read ${(0, ui_js_1.cyan)(prismaPath)}`);
-        (0, ui_js_1.errorLine)(`${(0, ui_js_1.red)(err instanceof Error ? err.message : String(err))}`);
+        (0, ui_js_1.errorLine)(`${(0, ui_js_1.red)((0, error_text_js_1.errorText)(err))}`);
         (0, ui_js_1.errorLine)();
         process.exit(1);
     }
@@ -2076,6 +2318,8 @@ async function cmdMigrateFromPrisma(args, config) {
             noTimestamp: args.noTimestamp,
             importExtension: config.importExtension,
             keepColumnNames: config.keepColumnNames,
+            // No schema file is read here, so only the config file's overrides apply.
+            columnTypes: await generatorColumnTypesFor(null, config, schemaMeta, url, 'public'),
         });
         for (const file of gen.files) {
             console.log(`  ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.cyan)((0, node_path_1.join)(outDir, file))} ${(0, ui_js_1.dim)('(client)')}`);
@@ -2108,9 +2352,26 @@ async function cmdMigrateFromPrisma(args, config) {
 // ---------------------------------------------------------------------------
 // Command: push
 // ---------------------------------------------------------------------------
+/**
+ * Print what a diff did NOT compare, under an "in sync" style message.
+ *
+ * "Already in sync" only means the compared surface matches. The rest is listed
+ * so the sentence is not read as a guarantee about the whole database.
+ */
+function printNotCompared(items) {
+    if (!items || items.length === 0)
+        return;
+    console.log(`  ${(0, ui_js_1.dim)('Not compared, so this says nothing about:')}`);
+    for (const item of items)
+        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.dot)} ${(0, ui_js_1.dim)(item)}`);
+    (0, ui_js_1.newline)();
+}
 async function cmdPush(args, config) {
     (0, ui_js_1.banner)();
     refuseSchemaFilePath(config);
+    if (args.exitCode && !args.dryRun) {
+        failArg(`${(0, ui_js_1.cyan)('--exit-code')} needs ${(0, ui_js_1.cyan)('--dry-run')} on push.`, 'It reports whether the database differs from the schema file (exit 2) without changing it.', 'Example: npx turbine push --dry-run --exit-code');
+    }
     const url = requireUrl(config);
     (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
     (0, ui_js_1.label)('Schema file', config.schemaFile);
@@ -2122,8 +2383,32 @@ async function cmdPush(args, config) {
     const diffSpinner = new ui_js_1.Spinner('Computing schema diff').start();
     const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
     if (diff.statements.length === 0 && diff.drop.length === 0) {
-        diffSpinner.succeed('Database is already in sync');
+        // "In sync" is a claim about everything the diff looked at, so it is made
+        // only when the diff also has nothing to say. A difference it cannot apply
+        // (an undeclared index, a reordered enum) is reported as exactly that.
+        const advisories = diff.warnings ?? [];
+        if (advisories.length === 0) {
+            diffSpinner.succeed('Database is already in sync');
+        }
+        else {
+            diffSpinner.succeed('Nothing to apply, but the database is not fully in sync');
+        }
         (0, ui_js_1.newline)();
+        for (const w of advisories)
+            (0, ui_js_1.warn)(w);
+        if (advisories.length > 0)
+            (0, ui_js_1.newline)();
+        printNotCompared(diff.notCompared);
+        // A warning is a difference the diff found and cannot apply (a unique index
+        // that is not unique, a removed enum label), so a gate fails on it. What the
+        // diff only discloses as "not compared" is not a difference it found, and a
+        // CHECK expression that merely reads differently is a warning it cannot
+        // confirm (driftWarnings leaves it out).
+        if (args.exitCode && (0, schema_sql_js_1.driftWarnings)(diff).length > 0) {
+            (0, ui_js_1.warn)(`The database differs from the schema file ${(0, ui_js_1.dim)('(--exit-code: exiting 2)')}.`);
+            (0, ui_js_1.newline)();
+            process.exit(2);
+        }
         return;
     }
     diffSpinner.succeed('Found changes');
@@ -2180,6 +2465,11 @@ async function cmdPush(args, config) {
     if (args.dryRun) {
         (0, ui_js_1.info)('Dry run, no changes applied.');
         (0, ui_js_1.newline)();
+        if (args.exitCode) {
+            (0, ui_js_1.warn)(`The database differs from the schema file ${(0, ui_js_1.dim)('(--exit-code: exiting 2)')}.`);
+            (0, ui_js_1.newline)();
+            process.exit(2);
+        }
         return;
     }
     if (args.allowDestructive) {
@@ -2253,8 +2543,12 @@ async function cmdMigrate(args, config) {
         console.log(`    ${(0, ui_js_1.cyan)('--recipe <name>')}    Scaffold a sanctioned migration pattern`);
         console.log(`    ${(0, ui_js_1.cyan)('--step, -n')}         Number of migrations to apply/rollback`);
         console.log(`    ${(0, ui_js_1.cyan)('--dry-run')}          Show SQL without executing`);
+        console.log(`    ${(0, ui_js_1.cyan)('--exit-code')}        Exit 2 when ${(0, ui_js_1.cyan)('status')} finds pending, modified, missing or misnamed migrations`);
+        console.log(`    ${(0, ui_js_1.cyan)('--wait')}${(0, ui_js_1.dim)('[=<seconds>]')}   Make ${(0, ui_js_1.cyan)('deploy')} wait for a concurrent deploy's lock`);
+        console.log(`    ${(0, ui_js_1.cyan)('--allow-pending')}    Let ${(0, ui_js_1.cyan)('--auto')} / ${(0, ui_js_1.cyan)('--from-diff')} run with migrations pending`);
         console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')} Run data-destroying statements without prompting`);
         console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}      Re-baseline drifted checksums on ${(0, ui_js_1.cyan)('up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} ${(0, ui_js_1.dim)('(advanced)')}`);
+        console.log(`    ${(0, ui_js_1.cyan)('--allow-pooler')}     Run ${(0, ui_js_1.cyan)('up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} against a transaction pooler anyway ${(0, ui_js_1.dim)('(refused by default: the migration lock is session-level and a pooler can release it on another backend)')}`);
         (0, ui_js_1.newline)();
         console.log(`  ${(0, ui_js_1.bold)('Recipes')} ${(0, ui_js_1.dim)('(--recipe):')}`);
         for (const [key, recipe] of Object.entries(migrate_js_1.MIGRATION_RECIPES)) {
@@ -2272,6 +2566,23 @@ async function cmdMigrate(args, config) {
         (0, ui_js_1.newline)();
         return;
     }
+    // Flags that change what a subcommand does are refused where they do nothing,
+    // rather than accepted and ignored: a CI gate that silently never gates is
+    // worse than one that will not start.
+    if (args.exitCode && sub !== 'status' && sub !== 'list') {
+        failArg(`${(0, ui_js_1.cyan)('--exit-code')} only applies to ${(0, ui_js_1.cyan)('migrate status')} (and ${(0, ui_js_1.cyan)('push --dry-run')}).`, 'Example: npx turbine migrate status --exit-code');
+    }
+    if (args.wait !== undefined && sub !== 'deploy') {
+        failArg(`${(0, ui_js_1.cyan)('--wait')} only applies to ${(0, ui_js_1.cyan)('migrate deploy')}.`, 'Example: npx turbine migrate deploy --wait=120');
+    }
+    // The commands that take the migration lock, before the banner and before any
+    // connection. A dry run takes no lock, so it may use any endpoint.
+    if ((sub === 'up' || sub === 'deploy' || sub === 'down') && args.dryRun !== true && config.url) {
+        refusePoolerConnection(config.url, args, {
+            command: `turbine migrate ${sub}`,
+            explanation: exports.MIGRATE_POOLER_EXPLANATION,
+        });
+    }
     switch (sub) {
         case 'create':
             await cmdMigrateCreate(args, config);
@@ -2295,6 +2606,58 @@ async function cmdMigrate(args, config) {
             process.exit(1);
     }
 }
+/**
+ * Stop `migrate create --auto` / `--from-diff` while migrations are pending.
+ *
+ * Both diff the schema file against the live database, and a pending migration
+ * is a change the file already describes and the database does not have yet. The
+ * new migration would repeat it and fail on the first database that runs the
+ * pending one first. See {@link formatPendingAutoRefusal}.
+ */
+async function refuseWhenMigrationsPending(args, config, url, flag) {
+    if ((0, migrate_js_1.listMigrationFiles)(config.migrationsDir).length === 0)
+        return;
+    const pending = (0, migrate_js_1.pendingMigrationFiles)(await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir, { schema: config.schema }));
+    if (pending.length === 0)
+        return;
+    if (args.allowPending) {
+        (0, ui_js_1.warn)(`--allow-pending is set: ${(0, ui_js_1.bold)(String(pending.length))} pending migration(s) are NOT reflected in the diff.`);
+        (0, ui_js_1.newline)();
+        return;
+    }
+    const [first, ...rest] = (0, migrate_js_1.formatPendingAutoRefusal)(pending, flag).split('\n');
+    (0, ui_js_1.error)(first);
+    for (const line of rest)
+        (0, ui_js_1.errorLine)(line);
+    (0, ui_js_1.errorLine)();
+    process.exit(1);
+}
+/**
+ * Explain an empty `--auto` / `--from-diff` diff without claiming more than it
+ * knows: "in sync" only when nothing, extra tables and advisories included, was
+ * left over.
+ */
+function reportNothingToMigrate(diff, spinner) {
+    const advisories = diff.warnings ?? [];
+    if (diff.drop.length === 0 && advisories.length === 0) {
+        spinner.succeed('Database is already in sync: nothing to migrate');
+        (0, ui_js_1.newline)();
+        printNotCompared(diff.notCompared);
+        return;
+    }
+    spinner.succeed('Nothing to migrate: no statement to write, but the database is not fully in sync');
+    (0, ui_js_1.newline)();
+    if (diff.drop.length > 0) {
+        (0, ui_js_1.warn)(`${(0, ui_js_1.bold)(String(diff.drop.length))} table(s) exist in the database but not in the schema file ` +
+            `(${diff.drop.join(', ')}). A migration never drops a table on its own: write that one by hand.`);
+        (0, ui_js_1.newline)();
+    }
+    for (const w of advisories)
+        (0, ui_js_1.warn)(w);
+    if (advisories.length > 0)
+        (0, ui_js_1.newline)();
+    printNotCompared(diff.notCompared);
+}
 async function cmdMigrateCreate(args, config) {
     (0, ui_js_1.banner)();
     // `--auto` / `--from-diff` diff the schema FILE against the namespace, so both
@@ -2324,18 +2687,21 @@ async function cmdMigrateCreate(args, config) {
         (0, ui_js_1.errorLine)();
         process.exit(1);
     }
+    if (args.allowPending && !args.auto && !args.fromDiff) {
+        failArg(`${(0, ui_js_1.cyan)('--allow-pending')} only applies to ${(0, ui_js_1.cyan)('--auto')} and ${(0, ui_js_1.cyan)('--from-diff')}.`, 'It lets a diff-generated migration proceed while earlier migrations are still pending.');
+    }
     if (args.auto) {
         // Auto-generate migration from schema diff
         const url = requireUrl(config);
         (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
         (0, ui_js_1.label)('Schema file', config.schemaFile);
         (0, ui_js_1.newline)();
+        await refuseWhenMigrationsPending(args, config, url, '--auto');
         const schemaDef = await loadSchemaFile(config.schemaFile);
         const diffSpinner = new ui_js_1.Spinner('Computing schema diff').start();
         const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
         if (diff.statements.length === 0) {
-            diffSpinner.succeed('Database is already in sync: nothing to migrate');
-            (0, ui_js_1.newline)();
+            reportNothingToMigrate(diff, diffSpinner);
             return;
         }
         diffSpinner.succeed(`Found ${(0, ui_js_1.bold)(String(diff.statements.length))} change(s)`);
@@ -2387,7 +2753,9 @@ async function cmdMigrateCreate(args, config) {
                 console.log(`    ${(0, ui_js_1.red)(ui_js_1.symbols.warning)} ${(0, ui_js_1.dim)('DOWN')} [${h.kind}] ${h.target}`);
             }
             (0, ui_js_1.newline)();
-            console.log(`  ${(0, ui_js_1.dim)('`migrate up` refuses destructive statements by default: confirm interactively or pass')} ${(0, ui_js_1.cyan)('--allow-destructive')}${(0, ui_js_1.dim)('.')}`);
+            console.log(body.destructiveUp.length > 0
+                ? `  ${(0, ui_js_1.dim)('`migrate up` refuses destructive statements by default: confirm interactively or pass')} ${(0, ui_js_1.cyan)('--allow-destructive')}${(0, ui_js_1.dim)('.')}`
+                : `  ${(0, ui_js_1.dim)('Only the DOWN section is destructive: `migrate up` runs this file without a prompt, `migrate down` asks first.')}`);
             (0, ui_js_1.newline)();
         }
         if (diff.warnings && diff.warnings.length > 0) {
@@ -2407,12 +2775,12 @@ async function cmdMigrateCreate(args, config) {
         (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
         (0, ui_js_1.label)('Schema file', config.schemaFile);
         (0, ui_js_1.newline)();
+        await refuseWhenMigrationsPending(args, config, url, '--from-diff');
         const schemaDef = await loadSchemaFile(config.schemaFile);
         const diffSpinner = new ui_js_1.Spinner('Computing schema diff').start();
         const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
         if (diff.statements.length === 0) {
-            diffSpinner.succeed('Database is already in sync: nothing to migrate');
-            (0, ui_js_1.newline)();
+            reportNothingToMigrate(diff, diffSpinner);
             return;
         }
         diffSpinner.succeed(`Found ${(0, ui_js_1.bold)(String(diff.statements.length))} change(s)`);
@@ -2459,7 +2827,9 @@ async function cmdMigrateCreate(args, config) {
                 console.log(`    ${(0, ui_js_1.red)(ui_js_1.symbols.warning)} ${(0, ui_js_1.dim)('DOWN')} [${h.kind}] ${h.target}`);
             }
             (0, ui_js_1.newline)();
-            console.log(`  ${(0, ui_js_1.dim)('`migrate up` refuses destructive statements by default: confirm interactively or pass')} ${(0, ui_js_1.cyan)('--allow-destructive')}${(0, ui_js_1.dim)('.')}`);
+            console.log(body.destructiveUp.length > 0
+                ? `  ${(0, ui_js_1.dim)('`migrate up` refuses destructive statements by default: confirm interactively or pass')} ${(0, ui_js_1.cyan)('--allow-destructive')}${(0, ui_js_1.dim)('.')}`
+                : `  ${(0, ui_js_1.dim)('Only the DOWN section is destructive: `migrate up` runs this file without a prompt, `migrate down` asks first.')}`);
             (0, ui_js_1.newline)();
         }
         if (diff.warnings && diff.warnings.length > 0) {
@@ -2780,7 +3150,18 @@ async function cmdMigrateDeploy(args, config) {
     if (destructive.length > 0)
         printDestructiveNotice(destructive);
     const runSpinner = new ui_js_1.Spinner('Deploying migrations').start();
-    const result = await (0, migrate_js_1.migrateDeploy)(url, config.migrationsDir, { allowDrift: args.allowDrift, schema: config.schema });
+    const result = await (0, migrate_js_1.migrateDeploy)(url, config.migrationsDir, {
+        allowDrift: args.allowDrift,
+        schema: config.schema,
+        lockWaitMs: args.wait !== undefined ? args.wait * 1000 : undefined,
+        onLockWait: () => {
+            runSpinner.stop();
+            (0, ui_js_1.warn)(`Another migration holds the lock: waiting up to ${(0, ui_js_1.bold)(String(args.wait))}s for it to finish.`);
+            console.log(`  ${(0, ui_js_1.dim)('Whatever it applies is then no longer pending, so this run will skip it.')}`);
+            (0, ui_js_1.newline)();
+            runSpinner.start();
+        },
+    });
     if (result.applied.length > 0) {
         runSpinner.succeed(`${(0, ui_js_1.bold)(String(result.applied.length))} applied`);
         for (const file of result.applied) {
@@ -2907,6 +3288,15 @@ async function cmdMigrateDown(args, config) {
         for (const file of result.rolledBack) {
             console.log(`    ${(0, ui_js_1.yellow)(ui_js_1.symbols.arrowRight)} ${file.filename}`);
         }
+        const noSql = (0, migrate_js_1.rollbacksWithoutSql)(result.rolledBack);
+        if (noSql.length > 0) {
+            (0, ui_js_1.newline)();
+            (0, ui_js_1.warn)(`${(0, ui_js_1.bold)(String(noSql.length))} rolled-back migration(s) have a DOWN section that runs no SQL:`);
+            for (const file of noSql)
+                console.log(`    ${(0, ui_js_1.yellow)(ui_js_1.symbols.dot)} ${file.filename}`);
+            console.log(`  ${(0, ui_js_1.dim)('Their tracking rows are removed, but nothing they changed was undone (a dropped column')}`);
+            console.log(`  ${(0, ui_js_1.dim)('cannot be restored automatically). Restore that data from a backup.')}`);
+        }
     }
     else if (result.errors.length === 0) {
         spinner.succeed('No migrations to roll back');
@@ -2930,20 +3320,24 @@ async function cmdMigrateDown(args, config) {
     }
     (0, ui_js_1.newline)();
 }
-async function cmdMigrateStatus(_args, config) {
+async function cmdMigrateStatus(args, config) {
     (0, ui_js_1.banner)();
     const url = requireUrl(config);
     (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
     (0, ui_js_1.label)('Migrations', config.migrationsDir);
     (0, ui_js_1.newline)();
     const allFiles = (0, migrate_js_1.listMigrationFiles)(config.migrationsDir);
-    if (allFiles.length === 0) {
+    // A gate still has to ask the database when there are no files: applied
+    // migrations whose files are gone are exactly the drift it exists to catch.
+    if (allFiles.length === 0 && !args.exitCode) {
         (0, ui_js_1.warn)('No migration files found.');
         console.log(`  ${(0, ui_js_1.dim)('Create one with:')} ${(0, ui_js_1.cyan)('npx turbine migrate create <name>')}`);
         (0, ui_js_1.newline)();
         return;
     }
     warnIgnoredMigrationFiles(config.migrationsDir);
+    if (allFiles.length === 0)
+        (0, ui_js_1.warn)('No migration files found.');
     const statuses = await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir, { schema: config.schema });
     const appliedCount = statuses.filter((s) => s.applied).length;
     const pendingCount = statuses.filter((s) => !s.applied).length;
@@ -2998,6 +3392,14 @@ async function cmdMigrateStatus(_args, config) {
         console.log(`  ${(0, ui_js_1.dim)('Run')} ${(0, ui_js_1.cyan)('npx turbine migrate up')} ${(0, ui_js_1.dim)('to apply pending migrations.')}`);
         (0, ui_js_1.newline)();
     }
+    if (args.exitCode) {
+        const problems = (0, migrate_js_1.statusGateProblems)((0, migrate_js_1.summarizeMigrationStatus)(statuses), (0, migrate_js_1.listIgnoredSqlFiles)(config.migrationsDir).map(introspect_js_1.printableCatalogName));
+        if (problems.length > 0) {
+            (0, ui_js_1.warn)(`Migration history is not clean: ${problems.join(', ')} ${(0, ui_js_1.dim)('(--exit-code: exiting 2)')}.`);
+            (0, ui_js_1.newline)();
+            process.exit(2);
+        }
+    }
 }
 function getSeedExecutionPlan(seedFile) {
     const ext = (0, node_path_1.extname)(seedFile).toLowerCase();
@@ -3056,6 +3458,9 @@ async function seedConnectionString(config) {
     }
     return (0, migrate_js_1.connectionStringForSchema)(config.url, schema, inherited);
 }
+/** The notice for a {@link SeedRunOutcome} that could not be confirmed. */
+const UNCONFIRMED_SEED_NOTICE = 'The seed file ran to completion, but it does not call defineSeed(), so Turbine cannot tell whether it wrote anything. ' +
+    'Wrap the work in defineSeed(async (db) => { ... }) to have it confirmed.';
 async function runSeedPlan(plan, config) {
     const oldDatabaseUrl = process.env.DATABASE_URL;
     // The seed connects through DATABASE_URL, whichever way it runs: `defineSeed`
@@ -3075,9 +3480,11 @@ async function runSeedPlan(plan, config) {
             }
             // The seed runs in a child process, so we cannot observe its callback
             // directly. Hand it a sentinel path: `defineSeed`'s runner writes the file
-            // only after a callback executes to completion. If the child exits cleanly
-            // but the sentinel never appears, the seed module loaded without running
-            // anything: a silent no-op we must report as a failure, not success.
+            // only after a callback executes to completion. A non-zero exit is a
+            // failure. A clean exit with no sentinel is a script that did its work at
+            // the top level (a typed-client seed), which succeeds and says so, unless
+            // the file names `defineSeed`: then its callback was expected to run and
+            // did not, which is a no-op to report as a failure.
             const sentinelDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'turbine-seed-'));
             const sentinel = (0, node_path_1.join)(sentinelDir, 'ran');
             const { execFileSync } = await Promise.resolve().then(() => __importStar(require('node:child_process')));
@@ -3090,15 +3497,18 @@ async function runSeedPlan(plan, config) {
                         TURBINE_SEED_SENTINEL: sentinel,
                     },
                 });
-                if (!(0, node_fs_1.existsSync)(sentinel)) {
+                if ((0, node_fs_1.existsSync)(sentinel))
+                    return { confirmed: true };
+                const seedFile = plan.args[plan.args.length - 1] ?? '';
+                if (/\bdefineSeed\b/.test((0, node_fs_1.readFileSync)(seedFile, 'utf-8'))) {
                     throw new Error('The seed file completed without running a seed callback. ' +
                         'Make sure it calls defineSeed(async (db) => { ... }) at the top level.');
                 }
+                return { confirmed: false };
             }
             finally {
                 (0, node_fs_1.rmSync)(sentinelDir, { recursive: true, force: true });
             }
-            return;
         }
         if (plan.kind === 'js') {
             const mod = await Promise.resolve(`${(0, node_url_1.pathToFileURL)(plan.file).href}`).then(s => __importStar(require(s)));
@@ -3107,7 +3517,7 @@ async function runSeedPlan(plan, config) {
                     'Export your seed with `export default defineSeed(async (db) => { ... })`.');
             }
             await mod.default();
-            return;
+            return { confirmed: true };
         }
         // `seedUrl` is already pinned and already schema-checked; `requireUrl` is
         // only reached when no url was configured at all, in which case there is no
@@ -3123,6 +3533,7 @@ async function runSeedPlan(plan, config) {
         finally {
             await client.end();
         }
+        return { confirmed: true };
     }
     finally {
         if (oldDatabaseUrl === undefined) {
@@ -3148,14 +3559,14 @@ async function cmdSeed(_args, config) {
     }
     const spinner = new ui_js_1.Spinner('Running seed file').start();
     try {
-        await runSeedPlan(getSeedExecutionPlan(seedFile), config);
+        const outcome = await runSeedPlan(getSeedExecutionPlan(seedFile), config);
         spinner.succeed('Seed completed');
+        if (!outcome.confirmed)
+            (0, ui_js_1.warn)(UNCONFIRMED_SEED_NOTICE);
     }
     catch (err) {
         spinner.fail('Seed failed');
-        if (err instanceof Error) {
-            console.log(`  ${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message))}`);
-        }
+        console.log(`  ${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)((0, error_text_js_1.errorText)(err)))}`);
         (0, ui_js_1.newline)();
         process.exit(1);
     }
@@ -3186,7 +3597,7 @@ async function cmdStatus(_args, config) {
     for (const tbl of Object.values(schema.tables)) {
         const relCount = Object.keys(tbl.relations).length;
         const _pk = tbl.primaryKey.join(', ') || (0, ui_js_1.dim)('(none)');
-        console.log(`  ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(tbl.name))}`);
+        console.log(`  ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(shown(tbl.name)))}`);
         for (let i = 0; i < tbl.columns.length; i++) {
             const col = tbl.columns[i];
             const isLast = i === tbl.columns.length - 1 && relCount === 0;
@@ -3194,7 +3605,7 @@ async function cmdStatus(_args, config) {
             const nullable = col.nullable ? (0, ui_js_1.dim)('?') : '';
             const def = col.hasDefault ? (0, ui_js_1.dim)(' (default)') : '';
             const pkLabel = tbl.primaryKey.includes(col.name) ? ` ${(0, ui_js_1.magenta)('PK')}` : '';
-            console.log(`    ${(0, ui_js_1.dim)(prefix)} ${col.field}${nullable}: ${(0, ui_js_1.green)(col.tsType)}${pkLabel}${def}  ${(0, ui_js_1.gray)(`${ui_js_1.symbols.arrow} ${col.pgType}`)}`);
+            console.log(`    ${(0, ui_js_1.dim)(prefix)} ${shown(col.field)}${nullable}: ${(0, ui_js_1.green)(shown(col.tsType))}${pkLabel}${def}  ${(0, ui_js_1.gray)(`${ui_js_1.symbols.arrow} ${shown(col.pgType)}`)}`);
         }
         const rels = Object.entries(tbl.relations);
         if (rels.length > 0) {
@@ -3204,7 +3615,7 @@ async function cmdStatus(_args, config) {
                 const prefix = isLast ? ui_js_1.symbols.teeEnd : ui_js_1.symbols.tee;
                 const relColor = rel.type === 'hasMany' ? ui_js_1.blue : ui_js_1.yellow;
                 const fkDisplay = Array.isArray(rel.foreignKey) ? rel.foreignKey.join(', ') : rel.foreignKey;
-                console.log(`    ${(0, ui_js_1.dim)(prefix)} ${relColor(relName)} ${(0, ui_js_1.dim)(ui_js_1.symbols.arrow)} ${rel.to} ${(0, ui_js_1.dim)(`(${rel.type}, FK: ${fkDisplay})`)}`);
+                console.log(`    ${(0, ui_js_1.dim)(prefix)} ${relColor(shown(relName))} ${(0, ui_js_1.dim)(ui_js_1.symbols.arrow)} ${shown(rel.to)} ${(0, ui_js_1.dim)(`(${rel.type}, FK: ${shown(fkDisplay)})`)}`);
             }
         }
         (0, ui_js_1.newline)();
@@ -3212,7 +3623,7 @@ async function cmdStatus(_args, config) {
     if (Object.keys(schema.enums).length > 0) {
         console.log(`  ${(0, ui_js_1.bold)('Enums:')}`);
         for (const [enumName, labels] of Object.entries(schema.enums)) {
-            console.log(`    ${(0, ui_js_1.cyan)(enumName)}: ${labels.map((l) => (0, ui_js_1.green)(`'${l}'`)).join((0, ui_js_1.dim)(' | '))}`);
+            console.log(`    ${(0, ui_js_1.cyan)(shown(enumName))}: ${labels.map((l) => (0, ui_js_1.green)(`'${shown(l)}'`)).join((0, ui_js_1.dim)(' | '))}`);
         }
         (0, ui_js_1.newline)();
     }
@@ -3270,6 +3681,23 @@ const CONCURRENTLY_RECIPE_COMMENT = [
     '--      makes "migrate up" look hung. For bounded waits, SET lock_timeout /',
     '--      statement_timeout in a psql session.',
 ].join('\n');
+/**
+ * Why `migrate up`, `deploy` and `down` refuse a pooled endpoint. The reason is
+ * the migration lock, not the doctor's session-state argument.
+ */
+exports.MIGRATE_POOLER_EXPLANATION = [
+    'turbine migrate serializes runs with a session-level advisory lock (pg_try_advisory_lock).',
+    'That lock belongs to one server backend and only means something while the same backend',
+    'serves every statement of the run. A transaction pooler (PgBouncer, a Neon "-pooler"',
+    "endpoint, Supabase's pooler) hands each transaction to whichever backend is free, so:",
+    '',
+    '  1. The lock is not tied to this run. It can be taken on one backend and released on',
+    '     another, which leaves it held on a shared backend (later runs are told another',
+    '     migration is in progress) and lets two runs apply the same file.',
+    '  2. Session state a migration file sets (SET lock_timeout, SET search_path) is left on',
+    '     a shared backend for other clients, and state an earlier client left there applies',
+    '     to this run.',
+];
 /**
  * Refuse a `doctor` run whose connection string points at a transaction pooler.
  *
@@ -3291,13 +3719,13 @@ const CONCURRENTLY_RECIPE_COMMENT = [
  * Exported for the unit test only (like {@link isLoopbackHost}): a gate whose
  * failure path is `process.exit` is untestable through the command itself.
  */
-function refusePoolerConnection(url, args) {
+function refusePoolerConnection(url, args, refusal = { command: 'turbine doctor' }) {
     if (args.allowPooler === true)
         return;
     const detection = (0, connection_url_js_1.detectPooler)(url);
     if (!detection.pooled)
         return;
-    const lines = (0, connection_url_js_1.poolerRefusalMessage)(detection, { command: 'turbine doctor', allowFlag: '--allow-pooler' });
+    const lines = (0, connection_url_js_1.poolerRefusalMessage)(detection, { ...refusal, allowFlag: '--allow-pooler' });
     console.error('');
     console.error(`  ${(0, ui_js_1.red)(ui_js_1.symbols.cross)} ${lines[0]}`);
     for (const line of lines.slice(1))
@@ -3365,7 +3793,7 @@ async function cmdDoctor(args, config) {
             tables: {},
             indexes: [],
             nullFrac: {},
-            notices: [`statistics collection failed: ${err instanceof Error ? err.message : String(err)}`],
+            notices: [`statistics collection failed: ${(0, error_text_js_1.errorText)(err)}`],
         };
     }
     // Table-heat boost: read _turbine_metrics (app DB or --metrics-url) and use
@@ -3590,6 +4018,12 @@ function renderUnusedCaveats(minScans, snapshot) {
     }
     (0, ui_js_1.newline)();
 }
+/**
+ * Catalog names go to the terminal through this. A database lets its creator
+ * pick any characters for a table or index name, and a raw ESC or bidi control
+ * in one rewrites the line it is printed on.
+ */
+const shown = introspect_js_1.printableCatalogName;
 /** doctor --unused: never-scanned indexes with DROP suggestions (report-only). */
 function renderUnusedIndexes(unused, minScans, snapshot) {
     if (unused.length === 0)
@@ -3598,12 +4032,12 @@ function renderUnusedIndexes(unused, minScans, snapshot) {
     (0, ui_js_1.warn)(`Found ${(0, ui_js_1.bold)(String(unused.length))} never-scanned index(es) (${(0, index_stats_js_1.formatBytes)(total)} reclaimable).`);
     renderUnusedCaveats(minScans, snapshot);
     for (const u of unused) {
-        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(u.table))} ${(0, ui_js_1.dim)(`(${u.columns.join(', ') || '?'})`)}  ${(0, ui_js_1.gray)(`${u.indexName} · ${u.idxScan} scans · ${(0, index_stats_js_1.formatBytes)(u.sizeBytes)}`)}`);
+        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(shown(u.table)))} ${(0, ui_js_1.dim)(`(${shown(u.columns.join(', ') || '?')})`)}  ${(0, ui_js_1.gray)(`${shown(u.indexName)} · ${u.idxScan} scans · ${(0, index_stats_js_1.formatBytes)(u.sizeBytes)}`)}`);
         // A functional / partial / non-btree index is not a plain `(col)` rebuild:
         // say what it actually is before anyone runs the DROP.
         if (u.caveat)
             console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} ${(0, ui_js_1.yellow)(u.caveat)}`);
-        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(u.dropSql)}`);
+        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(shown(u.dropSql))}`);
         (0, ui_js_1.newline)();
     }
 }
@@ -3616,9 +4050,9 @@ function renderRedundantIndexes(redundant) {
     console.log(`  ${(0, ui_js_1.dim)('Each is a leading prefix of a wider index that already serves the same lookups. Report-only, never auto-dropped.')}`);
     (0, ui_js_1.newline)();
     for (const r of redundant) {
-        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(r.table))} ${(0, ui_js_1.dim)(`(${r.columns.join(', ')})`)}  ${(0, ui_js_1.gray)(`${r.indexName} · ${(0, index_stats_js_1.formatBytes)(r.sizeBytes)}`)}`);
-        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} covered by ${(0, ui_js_1.blue)(r.coveredBy)} ${(0, ui_js_1.dim)(`(${r.coveredByColumns.join(', ')})`)}`);
-        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(r.dropSql)}`);
+        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(shown(r.table)))} ${(0, ui_js_1.dim)(`(${shown(r.columns.join(', '))})`)}  ${(0, ui_js_1.gray)(`${shown(r.indexName)} · ${(0, index_stats_js_1.formatBytes)(r.sizeBytes)}`)}`);
+        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} covered by ${(0, ui_js_1.blue)(shown(r.coveredBy))} ${(0, ui_js_1.dim)(`(${shown(r.coveredByColumns.join(', '))})`)}`);
+        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(shown(r.dropSql))}`);
         (0, ui_js_1.newline)();
     }
 }
@@ -3633,7 +4067,7 @@ function renderDoctorAudit(audit, minScans, snapshot) {
     renderUnusedCaveats(minScans, snapshot);
     for (const a of audit) {
         const tag = a.ambiguous ? (0, ui_js_1.red)(' [ambiguous: truncated name collides with another column set]') : '';
-        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(a.table))} ${(0, ui_js_1.dim)(`(${a.columns.join(', ') || '?'})`)}  ${(0, ui_js_1.gray)(`${a.indexName} · ${a.idxScan} scans · ${(0, index_stats_js_1.formatBytes)(a.sizeBytes)}`)}${tag}`);
+        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(shown(a.table)))} ${(0, ui_js_1.dim)(`(${shown(a.columns.join(', ') || '?')})`)}  ${(0, ui_js_1.gray)(`${shown(a.indexName)} · ${a.idxScan} scans · ${(0, index_stats_js_1.formatBytes)(a.sizeBytes)}`)}${tag}`);
         if (a.ambiguous) {
             console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} ${(0, ui_js_1.dim)('the 63-byte name maps to more than one probe column set; confirm before dropping')}`);
         }
@@ -3642,7 +4076,7 @@ function renderDoctorAudit(audit, minScans, snapshot) {
             console.log(`      ${(0, ui_js_1.dim)('reappear as a missing-index finding in this same report.')}`);
         }
         else if (a.dropSql) {
-            console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(a.dropSql)}`);
+            console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(shown(a.dropSql))}`);
         }
         (0, ui_js_1.newline)();
     }
@@ -3696,12 +4130,12 @@ function divergenceAmplificationLines(d) {
     const amp = divInt(d.worstCaseAmplification ?? 0);
     const corr = d.orderColumnCorrelation;
     const corrLabel = corr === null || corr === undefined
-        ? `no pg_stats correlation available for "${d.orderColumn}"`
-        : `correlation ${corr.toFixed(5)} on "${d.orderColumn}"`;
+        ? `no pg_stats correlation available for "${shown(d.orderColumn)}"`
+        : `correlation ${corr.toFixed(5)} on "${shown(d.orderColumn)}"`;
     if (d.heapNearlyOrdered === true) {
         return [
             `The size of that flip turns on the heap's physical order, and THIS heap is in near-exact`,
-            `"${d.orderColumn}" order (${corrLabel}), so consecutive index entries hit the`,
+            `"${shown(d.orderColumn)}" order (${corrLabel}), so consecutive index entries hit the`,
             `same pinned page: measured ~1x, not the ~${amp}x an unordered heap reads. Most likely this`,
             `one is not costing you anything today. It is also one sampled statistic away from the`,
             `much worse reading, so measure rather than assume in either direction.`,
@@ -3710,7 +4144,7 @@ function divergenceAmplificationLines(d) {
     return [
         `That costs ~${amp}x the buffers of the seq scan, because each index entry is its own heap`,
         `fetch (${corrLabel}). The one shape that reads ~1x instead is a heap`,
-        `in near-exact "${d.orderColumn}" order; two pages of local disorder already reads ~41x.`,
+        `in near-exact "${shown(d.orderColumn)}" order; two pages of local disorder already reads ~41x.`,
     ];
 }
 function renderDivergenceEvidence(d) {
@@ -3718,7 +4152,7 @@ function renderDivergenceEvidence(d) {
     console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} ${(0, ui_js_1.yellow)('cached-plan risk:')} this unindexed filter column can also flip a cached plan.`);
     console.log(`      ${(0, ui_js_1.dim)(`${divInt(d.rows)} rows in ${divInt(d.pages)} pages, rarest value ~${divInt(d.rarestBucket)} rows, below the assumed LIMIT ${d.assumedLimit}.`)}`);
     console.log(`      ${(0, ui_js_1.dim)(`Without the index the good plan is a seq scan (${divInt(d.pages)} pages); a promoted generic`)}`);
-    console.log(`      ${(0, ui_js_1.dim)(`plan cannot see the value is rare, keeps the ordered "${d.orderColumn}" walk, and reads`)}`);
+    console.log(`      ${(0, ui_js_1.dim)(`plan cannot see the value is rare, keeps the ordered "${shown(d.orderColumn)}" walk, and reads`)}`);
     console.log(`      ${(0, ui_js_1.dim)(`up to ~${tuples} tuples before it fills the LIMIT.`)}`);
     console.log(`      ${(0, ui_js_1.dim)('Postgres promotes this shape exactly when the workload keeps asking for the rare')}`);
     console.log(`      ${(0, ui_js_1.dim)('value: that is the case where the custom plan is expensive enough for the generic')}`);
@@ -3727,7 +4161,7 @@ function renderDivergenceEvidence(d) {
         console.log(`      ${(0, ui_js_1.dim)(line)}`);
     console.log(`      ${(0, ui_js_1.dim)('Adding the index above is the fix. Confirm first if you want to:')}`);
     for (const line of d.diagnosticSql.split('\n')) {
-        console.log(`        ${(0, ui_js_1.green)(line)}`);
+        console.log(`        ${(0, ui_js_1.green)(shown(line))}`);
     }
     console.log(`      ${(0, ui_js_1.dim)('After adding this index, re-run doctor. This column is expected to reappear as a')}`);
     console.log(`      ${(0, ui_js_1.dim)('sparse-value finding in the cached-plan section. That later finding is exposure, not')}`);
@@ -3781,9 +4215,9 @@ function renderFinding(f, opts) {
     const rows = f.score.metrics.rows;
     const rowsLabel = rows !== null ? `~${rows.toLocaleString()} rows` : 'row count unknown';
     const sizeLabel = f.score.metrics.sizeBytes !== null ? `, ${(0, index_stats_js_1.formatBytes)(f.score.metrics.sizeBytes)}` : '';
-    console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(m.table))} ${(0, ui_js_1.dim)(`(${m.columns.join(', ')})`)}  ${(0, ui_js_1.gray)(`${rowsLabel}${sizeLabel}`)}`);
+    console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(shown(m.table)))} ${(0, ui_js_1.dim)(`(${shown(m.columns.join(', '))})`)}  ${(0, ui_js_1.gray)(`${rowsLabel}${sizeLabel}`)}`);
     for (const p of m.probes) {
-        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} probed by ${p.from}.${(0, ui_js_1.blue)(p.relation)} ${(0, ui_js_1.dim)(`(${p.type})`)}`);
+        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} probed by ${shown(p.from)}.${(0, ui_js_1.blue)(shown(p.relation))} ${(0, ui_js_1.dim)(`(${p.type})`)}`);
     }
     if (opts.withReasons) {
         for (const reason of f.score.reasons) {
@@ -3791,7 +4225,7 @@ function renderFinding(f, opts) {
         }
     }
     const last = opts.divergence ? ui_js_1.symbols.tee : ui_js_1.symbols.teeEnd;
-    console.log(`    ${(0, ui_js_1.dim)(last)} ${(0, ui_js_1.green)(doctorCreateSql(f, { concurrently: opts.concurrently }))}`);
+    console.log(`    ${(0, ui_js_1.dim)(last)} ${(0, ui_js_1.green)(shown(doctorCreateSql(f, { concurrently: opts.concurrently })))}`);
     if (opts.divergence)
         renderDivergenceEvidence(opts.divergence);
     (0, ui_js_1.newline)();
@@ -3804,8 +4238,8 @@ function renderInvalidIndexes(invalid) {
     console.log(`  ${(0, ui_js_1.dim)('IF NOT EXISTS skips an invalid index on rerun, so it never rebuilds. Drop it, then rerun:')}`);
     (0, ui_js_1.newline)();
     for (const idx of invalid) {
-        console.log(`  ${(0, ui_js_1.red)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(idx.table))} ${(0, ui_js_1.dim)(`(${idx.columns.join(', ') || '?'})`)}  ${(0, ui_js_1.gray)(idx.indexName)}`);
-        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(idx.dropSql)}`);
+        console.log(`  ${(0, ui_js_1.red)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(shown(idx.table)))} ${(0, ui_js_1.dim)(`(${shown(idx.columns.join(', ') || '?')})`)}  ${(0, ui_js_1.gray)(shown(idx.indexName))}`);
+        console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.green)(shown(idx.dropSql))}`);
         (0, ui_js_1.newline)();
     }
 }
@@ -3898,10 +4332,10 @@ function renderPlanDivergence(divergence, attached) {
             // on (an index that exists but cannot serve the equality: partial,
             // expression, or non-btree). The remedy is still an index, not a
             // plan-cache setting, so this entry never suggests forceCustomPlan.
-            console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(`${f.table}.${f.column}`))}  ${(0, ui_js_1.gray)('UNINDEXED-FILTER FLIP')}`);
+            console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(`${shown(f.table)}.${shown(f.column)}`))}  ${(0, ui_js_1.gray)('UNINDEXED-FILTER FLIP')}`);
             console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} ${divInt(f.rows)} rows in ${divInt(f.pages)} pages, rarest value ~${(0, ui_js_1.bold)(divInt(f.rarestBucket))} rows, below the assumed LIMIT ${f.assumedLimit}`);
-            console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} no index serves ${f.column} = $1, so the good plan is a seq scan (${divInt(f.pages)} pages);`);
-            console.log(`      ${(0, ui_js_1.dim)(`a promoted generic plan keeps the ordered "${f.orderColumn}" walk and reads up to ~${divInt(f.tuplesWalked ?? f.rows)} tuples`)}`);
+            console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} no index serves ${shown(f.column)} = $1, so the good plan is a seq scan (${divInt(f.pages)} pages);`);
+            console.log(`      ${(0, ui_js_1.dim)(`a promoted generic plan keeps the ordered "${shown(f.orderColumn)}" walk and reads up to ~${divInt(f.tuplesWalked ?? f.rows)} tuples`)}`);
             console.log(`      ${(0, ui_js_1.dim)('before it fills the LIMIT.')}`);
             for (const line of divergenceAmplificationLines(f))
                 console.log(`      ${(0, ui_js_1.dim)(line)}`);
@@ -3916,13 +4350,13 @@ function renderPlanDivergence(divergence, attached) {
             (0, ui_js_1.newline)();
             continue;
         }
-        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(`${f.table}.${f.column}`))}  ${(0, ui_js_1.gray)('SPARSE-VALUE FLIP')}`);
+        console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${(0, ui_js_1.bold)((0, ui_js_1.cyan)(`${shown(f.table)}.${shown(f.column)}`))}  ${(0, ui_js_1.gray)('SPARSE-VALUE FLIP')}`);
         console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} generic estimate ${(0, ui_js_1.bold)(divInt(f.genericEstimate))} rows ${(0, ui_js_1.dim)(`(${divInt(f.rows)} rows / ${divInt(f.distinctValues)} distinct values)`)}`);
         console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} rarest value bucket ${(0, ui_js_1.bold)(divInt(f.rarestBucket))} rows ${(0, ui_js_1.dim)('(pg_stats most_common_freqs / residual bucket)')}`);
         console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} crossover ${(0, ui_js_1.bold)(divInt(f.crossoverRows ?? 0))} rows ${(0, ui_js_1.dim)(`(sqrt(limit ${f.assumedLimit} x ${divInt(f.pages)} pages); ${divInt(f.crossoverRowsWide ?? 0)} at limit ${f.thresholds.wideLimit})`)}`);
         console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} ${(0, ui_js_1.dim)(`values below the crossover: ${divInt(f.valuesBelowCrossover ?? 0)} of ${divInt(f.distinctValues)}, filter-column correlation ${f.correlation.toFixed(2)}, ${analyzedLabel(f)}`)}`);
         console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} for such a value the generic plan walks ~${(0, ui_js_1.bold)(divInt(f.walkPages ?? 0))} of ${divInt(f.pages)} pages ${(0, ui_js_1.dim)(`(${Math.round((f.walkFraction ?? 0) * 100)}% of the table)`)}`);
-        console.log(`      ${(0, ui_js_1.dim)(`for reads shaped WHERE ${f.column} = $1 ORDER BY ${f.orderColumn} LIMIT $n,`)}`);
+        console.log(`      ${(0, ui_js_1.dim)(`for reads shaped WHERE ${shown(f.column)} = $1 ORDER BY ${shown(f.orderColumn)} LIMIT $n,`)}`);
         console.log(`      ${(0, ui_js_1.dim)("where the custom plan reads only that value's own rows.")}`);
         console.log(`    ${(0, ui_js_1.dim)(ui_js_1.symbols.tee)} ${(0, ui_js_1.dim)('No amplification figure is printed, deliberately. This models how many rows a')}`);
         console.log(`      ${(0, ui_js_1.dim)('value has, not WHERE they sit in the heap, and the second half can move the')}`);
@@ -3984,7 +4418,7 @@ function renderPlanDivergence(divergence, attached) {
             console.log(`       ${(0, ui_js_1.dim)('in one direction trades this finding for its mirror image. That applies equally to')}`);
             console.log(`       ${(0, ui_js_1.dim)("Turbine's client-level `planCacheMode` and to a SET or ALTER ROLE applied outside")}`);
             console.log(`       ${(0, ui_js_1.dim)('Turbine.')}`);
-            console.log(`    5. A composite index on (${first.column}, ${first.orderColumn}) makes the GOOD plan better. It`);
+            console.log(`    5. A composite index on (${shown(first.column)}, ${shown(first.orderColumn)}) makes the GOOD plan better. It`);
             console.log(`       ${(0, ui_js_1.dim)('does NOT stop the generic plan from choosing the other one, and it can widen the gap.')}`);
             console.log(`       ${(0, ui_js_1.dim)('Add it for the custom-plan win, not as a fix for this finding.')}`);
         }
@@ -4009,7 +4443,7 @@ function renderPlanDivergence(divergence, attached) {
     if (notices.length > 0) {
         console.log(`  ${(0, ui_js_1.dim)('Not scored for cached-plan divergence (statistics missing):')}`);
         for (const n of notices) {
-            console.log(`    ${(0, ui_js_1.dim)(`- ${n.table}.${n.column}: ${n.reason}`)}`);
+            console.log(`    ${(0, ui_js_1.dim)(`- ${shown(n.table)}.${shown(n.column)}: ${n.reason}`)}`);
         }
         (0, ui_js_1.newline)();
     }
@@ -4107,7 +4541,7 @@ async function cmdStudio(args, config) {
         spinner.succeed(demo ? 'Demo Studio is running' : 'Studio is running');
     }
     catch (err) {
-        spinner.fail(`Failed to start Studio: ${err instanceof Error ? err.message : String(err)}`);
+        spinner.fail(`Failed to start Studio: ${(0, error_text_js_1.errorText)(err)}`);
         process.exit(1);
     }
     if (demo) {
@@ -4240,7 +4674,7 @@ async function cmdObserve(args) {
         spinner.succeed('Observe dashboard is running');
     }
     catch (err) {
-        spinner.fail(`Failed to start Observe: ${err instanceof Error ? err.message : String(err)}`);
+        spinner.fail(`Failed to start Observe: ${(0, error_text_js_1.errorText)(err)}`);
         process.exit(1);
     }
     (0, ui_js_1.newline)();
@@ -4348,10 +4782,12 @@ function showGenerateHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--schema, -s')} ${(0, ui_js_1.dim)('<name>')}   Postgres schema ${(0, ui_js_1.dim)('(default: public)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--include')} ${(0, ui_js_1.dim)('<tables>')}    Comma-separated tables to include`);
     console.log(`    ${(0, ui_js_1.cyan)('--exclude')} ${(0, ui_js_1.dim)('<tables>')}    Comma-separated tables to exclude`);
+    console.log(`    ${(0, ui_js_1.cyan)('--schema-file')} ${(0, ui_js_1.dim)('<path>')}  Your ${(0, ui_js_1.cyan)('defineSchema()')} file, whose ${(0, ui_js_1.cyan)('pii')} / ${(0, ui_js_1.cyan)('updatedAt')} tags are applied ${(0, ui_js_1.dim)('(default: ./turbine/schema.ts)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--zod')}                 Also emit ${(0, ui_js_1.cyan)('zod.ts')} validation schemas ${(0, ui_js_1.dim)('(needs the zod dep)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--include-views')}       Include views + materialized views as read-only entities`);
     console.log(`    ${(0, ui_js_1.cyan)('--no-timestamp')}        Omit the ${(0, ui_js_1.dim)('Generated at:')} header line ${(0, ui_js_1.dim)('(reproducible, diff-stable output)')}`);
-    console.log(`    ${(0, ui_js_1.cyan)('--import-ext')} ${(0, ui_js_1.dim)('<mode>')}    Sibling-import extension: ${(0, ui_js_1.cyan)('js')} / ${(0, ui_js_1.cyan)('none')} / ${(0, ui_js_1.cyan)('auto')} ${(0, ui_js_1.dim)('(default: auto)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--import-ext')} ${(0, ui_js_1.dim)('<mode>')}    Sibling-import extension: ${(0, ui_js_1.cyan)('js')} / ${(0, ui_js_1.cyan)('ts')} / ${(0, ui_js_1.cyan)('none')} / ${(0, ui_js_1.cyan)('auto')} ${(0, ui_js_1.dim)('(default: auto)')}`);
+    console.log(`                           ${(0, ui_js_1.dim)('ts emits ./types.ts so')} ${(0, ui_js_1.cyan)('node app.ts')} ${(0, ui_js_1.dim)('can run the client with native type stripping')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--keep-column-names')}   Keep raw DB column names as field names ${(0, ui_js_1.dim)('(snake_case, not camelCase)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--legacy-to-many-uniques')} Emit ${(0, ui_js_1.cyan)('hasMany')} for unique-FK children ${(0, ui_js_1.dim)('(pre-0.41 shape; default flips to hasOne)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-empty')}         Generate even when introspection matches 0 tables`);
@@ -4408,6 +4844,7 @@ function showPushHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--url, -u')} ${(0, ui_js_1.dim)('<url>')}   Postgres connection string`);
     console.log(`    ${(0, ui_js_1.cyan)('--schema-file')} ${(0, ui_js_1.dim)('<path>')} Your ${(0, ui_js_1.cyan)('defineSchema()')} file ${(0, ui_js_1.dim)('(default: ./turbine/schema.ts)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--dry-run')}          Show SQL without executing`);
+    console.log(`    ${(0, ui_js_1.cyan)('--exit-code')}        With ${(0, ui_js_1.cyan)('--dry-run')}: exit 2 when the database differs from the schema file, 0 when in sync ${(0, ui_js_1.dim)('(CI)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')} Skip the interactive confirmation for data-destroying statements ${(0, ui_js_1.dim)('(CI)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--verbose, -v')}      Show detailed output`);
     (0, ui_js_1.newline)();
@@ -4434,7 +4871,11 @@ function showMigrateHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--recipe')} ${(0, ui_js_1.dim)('<name>')}   Scaffold a sanctioned migration pattern ${(0, ui_js_1.dim)('(create only, e.g. backfill)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--step, -n')} ${(0, ui_js_1.dim)('<N>')}    Number of migrations to apply/rollback`);
     console.log(`    ${(0, ui_js_1.cyan)('--dry-run')}         Show SQL without executing`);
+    console.log(`    ${(0, ui_js_1.cyan)('--exit-code')}       Exit 2 when migrations are pending, modified, missing or misnamed ${(0, ui_js_1.dim)('(status only, CI)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--wait')}${(0, ui_js_1.dim)('[=<seconds>]')}  Wait for a concurrent deploy to release the lock, default ${exports.DEFAULT_LOCK_WAIT_SECONDS}s ${(0, ui_js_1.dim)('(deploy only)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--allow-pending')}   Let ${(0, ui_js_1.cyan)('--auto')} / ${(0, ui_js_1.cyan)('--from-diff')} run while earlier migrations are still pending ${(0, ui_js_1.dim)('(create only)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}     Re-baseline drifted checksums, REWRITING history ${(0, ui_js_1.dim)('(up / deploy / down)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--allow-pooler')}    Run ${(0, ui_js_1.cyan)('up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} through a transaction pooler ${(0, ui_js_1.dim)('(refused: the migration lock is session-level)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')} Run data-destroying migration statements without the interactive confirm`);
     console.log(`    ${(0, ui_js_1.cyan)('--schema, -s')} ${(0, ui_js_1.dim)('<name>')}  Postgres schema the migrations run in ${(0, ui_js_1.dim)('(default: public)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--verbose, -v')}     Show detailed output`);
@@ -4446,8 +4887,10 @@ function showMigrateHelp() {
     console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate create backfill_full_name --recipe backfill`);
     console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate up`);
     console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate deploy --dry-run`);
+    console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate deploy --wait=120`);
     console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate down --step 2`);
     console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate status`);
+    console.log(`    ${(0, ui_js_1.dim)('$')} npx turbine migrate status --exit-code`);
     (0, ui_js_1.newline)();
 }
 function showSeedHelp() {
@@ -4671,8 +5114,12 @@ function showHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--from-diff')}          Generate from schema diff, destructive statements flagged ${(0, ui_js_1.dim)('(create)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--recipe')} ${(0, ui_js_1.dim)('<name>')}       Scaffold a named migration recipe, e.g. backfill ${(0, ui_js_1.dim)('(create)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--step, -n')} ${(0, ui_js_1.dim)('<N>')}       Number of migrations to apply/rollback`);
+    console.log(`    ${(0, ui_js_1.cyan)('--exit-code')}          Exit 2 on drift ${(0, ui_js_1.dim)('(push --dry-run, migrate status)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--wait')}${(0, ui_js_1.dim)('[=<seconds>]')}     Wait for a concurrent deploy's lock instead of failing ${(0, ui_js_1.dim)('(deploy)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--allow-pending')}      Diff even while migrations are pending ${(0, ui_js_1.dim)('(create --auto / --from-diff)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')}  Run data-destroying statements without prompting ${(0, ui_js_1.dim)('(up/down/push)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}        Re-baseline drifted checksums on ${(0, ui_js_1.cyan)('migrate up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} ${(0, ui_js_1.dim)('(advanced)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--allow-pooler')}       Let ${(0, ui_js_1.cyan)('migrate up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} and ${(0, ui_js_1.cyan)('doctor')} use a transaction pooler ${(0, ui_js_1.dim)('(refused by default)')}`);
     (0, ui_js_1.newline)();
     console.log(`  ${(0, ui_js_1.bold)('Init options:')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--yes, -y')}            Accept every step's default (non-interactive)`);
@@ -4789,9 +5236,19 @@ function cmdSkill(args) {
     }
     const skillsDir = args.dir ?? (0, node_path_1.join)('.claude', 'skills');
     const target = (0, node_path_1.resolve)(process.cwd(), skillsDir, 'turbine-orm', 'SKILL.md');
-    const existed = (0, node_fs_1.existsSync)(target);
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(target), { recursive: true });
-    (0, node_fs_1.writeFileSync)(target, body);
+    // Exclusive create first: only the wording depends on whether the file was
+    // there, and asking separately would let the answer go stale before the write.
+    let existed = false;
+    try {
+        (0, node_fs_1.writeFileSync)(target, body, { flag: 'wx' });
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST')
+            throw err;
+        existed = true;
+        (0, node_fs_1.writeFileSync)(target, body);
+    }
     (0, ui_js_1.newline)();
     (0, ui_js_1.success)(`${existed ? 'Updated' : 'Installed'} the Turbine query skill`);
     console.log(`  ${(0, ui_js_1.dim)((0, node_path_1.relative)(process.cwd(), target))}`);
@@ -4854,7 +5311,7 @@ async function main() {
         // expected here; anything that does arrive is a bug in the parser rather
         // than in the caller's command line, and printing it beats swallowing it.
         (0, ui_js_1.errorLine)();
-        (0, ui_js_1.error)(err instanceof Error ? err.message : String(err));
+        (0, ui_js_1.error)((0, error_text_js_1.errorText)(err));
         (0, ui_js_1.errorLine)();
         process.exit(1);
     }
@@ -4987,6 +5444,9 @@ async function main() {
     }
     catch (err) {
         if (err instanceof Error) {
+            // `errorText`, not `message`: a refused `localhost` is an
+            // AggregateError with an empty message (see cli/error-text.ts).
+            const message = (0, error_text_js_1.errorText)(err);
             // TYPE first, message second. These branches sniff for substrings, and
             // `ValidationError` beat them by accident: a refused `--schema` value says
             // "used as a connection parameter", which contains "connection", so a bad
@@ -4994,35 +5454,35 @@ async function main() {
             // firewall hints. A typed error already knows what it is.
             if (err instanceof errors_js_1.ValidationError) {
                 (0, ui_js_1.errorLine)();
-                (0, ui_js_1.error)((0, ui_js_1.redactUrl)(err.message));
+                (0, ui_js_1.error)((0, ui_js_1.redactUrl)(message));
                 if (args.verbose && err.stack) {
                     (0, ui_js_1.errorLine)();
                     console.error((0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.stack)));
                 }
             }
-            else if (err.message.includes('ECONNREFUSED') || err.message.includes('connection')) {
+            else if (message.includes('ECONNREFUSED') || message.includes('connection')) {
                 (0, ui_js_1.errorLine)();
                 (0, ui_js_1.error)(`Could not connect to database`);
-                (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message))}`);
+                (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(message))}`);
                 (0, ui_js_1.errorLine)();
                 (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)('Check that:')}`);
                 (0, ui_js_1.errorLine)(`  ${(0, ui_js_1.dim)('1.')} Your database is running`);
                 (0, ui_js_1.errorLine)(`  ${(0, ui_js_1.dim)('2.')} The connection string is correct`);
                 (0, ui_js_1.errorLine)(`  ${(0, ui_js_1.dim)('3.')} Network/firewall allows the connection`);
             }
-            else if (err.message.includes('authentication')) {
+            else if (message.includes('authentication')) {
                 (0, ui_js_1.errorLine)();
                 (0, ui_js_1.error)(`Authentication failed`);
-                (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message))}`);
+                (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(message))}`);
             }
-            else if (err.message.includes('does not exist')) {
+            else if (message.includes('does not exist')) {
                 (0, ui_js_1.errorLine)();
                 (0, ui_js_1.error)(`Database or schema not found`);
-                (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message))}`);
+                (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(message))}`);
             }
             else {
                 (0, ui_js_1.errorLine)();
-                (0, ui_js_1.error)((0, ui_js_1.redactUrl)(err.message));
+                (0, ui_js_1.error)((0, ui_js_1.redactUrl)(message));
                 if (args.verbose && err.stack) {
                     (0, ui_js_1.errorLine)();
                     console.error((0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.stack)));