turbine-orm 0.49.0 → 0.50.0

package/dist/cli/index.js

@@ -33,7 +33,7 @@ import { buildCreateIndexSql, buildDropIndexSql, collectDoctorProbeIndexNames, c
 import { auditDoctorIndexes, collectStatsSnapshot, collectTableHeat, findInvalidIndexes, findRedundantIndexes, findUnusedIndexes, formatBytes, isSnapshotUsable, STATS_THRESHOLDS, scoreMissingIndex, } from '../index-stats.js';
 import { introspect } from '../introspect.js';
 import { DestructivePushRefusal, schemaDiff, schemaPush } from '../schema-sql.js';
-import { configTemplate, findConfigFile, loadConfigResult, looksLikeSchemaFilePath, resolveConfig, resolveSeedFile, unwrapModuleDefault, } from './config.js';
+import { configTemplate, DEFAULT_INIT_SEED_FILE, findConfigFile, loadConfigResult, looksLikeSchemaFilePath, resolveConfig, resolveSeedFile, unwrapModuleDefault, } from './config.js';
 import { DESTRUCTIVE_KIND_LABEL } from './destructive.js';
 import { canResolveTsx, getTsLoaderError, needsTsLoader, registerTsLoader } from './loader.js';
 import { runMcpServer } from './mcp.js';
@@ -41,7 +41,7 @@ import { buildDiffMigrationBody, collectUpDestructive, createMigration, formatCh
 import { startObserve } from './observe.js';
 import { formatPrismaReport, summaryLines } from './prisma-report.js';
 import { DEFAULT_EXCLUDED_TABLES, resolvePrismaSchema } from './prisma-resolve.js';
-import { PrismaParseError, parsePrismaSchema } from './prisma-schema.js';
+import { PrismaParseError, parsePrismaSchema, resolvePrismaDatasourceUrl, } from './prisma-schema.js';
 import { startStudio } from './studio.js';
 import { banner, blue, bold, box, cyan, dim, divider, elapsed, error, table as formatTable, gray, green, header, info, label, magenta, newline, red, redactUrl, Spinner, success, symbols, warn, yellow, } from './ui.js';
 export function parseArgs(argv = process.argv.slice(2)) {
@@ -267,9 +267,49 @@ function failMissingTsLoader(filePath, reason) {
     process.exit(1);
 }
 // ---------------------------------------------------------------------------
-// Helpers
+// Config bootstrap
 // ---------------------------------------------------------------------------
-function requireUrl(config) {
+/**
+ * Does this invocation need a `turbine.config.*` file?
+ *
+ * Everything does, with one deliberate exception: `turbine studio --demo` boots
+ * a seeded in-memory database, needs no `DATABASE_URL` and no config file, and
+ * is the very next command the quickstart suggests after `turbine init`.
+ * Resolving the config anyway means a freshly scaffolded directory (a
+ * `turbine.config.ts` with `tsx` not installed yet) dies with "Cannot load
+ * TypeScript file" before demo mode ever starts.
+ *
+ * @internal exported for tests.
+ */
+export function usesProjectConfig(args) {
+    return !(args.command === 'studio' && args.demo === true);
+}
+/**
+ * Resolve the effective CLI config: register the tsx loader when the config file
+ * is TypeScript, import it, then merge it with env vars and CLI flags. Exits with
+ * the actionable "Cannot load TypeScript file" error when a `.ts` config cannot
+ * be loaded. Config-free invocations short-circuit without touching the disk.
+ *
+ * @internal exported for tests.
+ */
+export async function bootstrapCliConfig(args, overrides) {
+    if (!usesProjectConfig(args)) {
+        return { config: resolveConfig({}, overrides), fileConfig: {}, skipped: true };
+    }
+    // If the user has a TypeScript config file, register the tsx ESM loader
+    // before we attempt to import it. Otherwise Node throws
+    // ERR_UNKNOWN_FILE_EXTENSION for `.ts`.
+    const configPath = findConfigFile();
+    if (needsTsLoader(configPath)) {
+        const status = await registerTsLoader();
+        if (status === 'missing' || status === 'unsupported' || status === 'failed') {
+            failMissingTsLoader(configPath ?? 'turbine.config.ts', status);
+        }
+    }
+    const { config: fileConfig, loadError } = await loadConfigResult();
+    return { config: resolveConfig(fileConfig, overrides), fileConfig, loadError, skipped: false };
+}
+function requireUrl(config, options = {}) {
     if (!config.url) {
         error('No database URL provided.');
         newline();
@@ -279,6 +319,12 @@ function requireUrl(config) {
         const envFileNote = typeof process.loadEnvFile === 'function' ? '(auto-loaded)' : '(needs Node 20.12+ to auto-load)';
         console.log(`    ${dim('2.')} Set ${cyan('DATABASE_URL')} in your environment or a ${cyan('.env')} file ${dim(envFileNote)}`);
         console.log(`    ${dim('3.')} Pass ${cyan('--url')} flag`);
+        const vars = options.datasourceVars ?? [];
+        if (vars.length > 0) {
+            const list = vars.map((v) => cyan(v)).join(', ');
+            const plural = vars.length > 1 ? 'these variables' : 'this variable';
+            console.log(`    ${dim('4.')} Set ${list} ${dim(`(${plural}, declared by your schema.prisma datasource, ${vars.length > 1 ? 'are' : 'is'} unset)`)}`);
+        }
         newline();
         process.exit(1);
     }
@@ -430,6 +476,57 @@ export function dotEnvUrlConflictWarning(input) {
         `(${redactUrl(fileUrl)}). Using the .env value. Remove DATABASE_URL from .env, or unset the config url, ` +
         `to silence this.`);
 }
+/**
+ * Detect the consumer's package manager from its lockfile, defaulting to npm.
+ * Used only to print an exact, copy-pasteable install command.
+ *
+ * @internal exported for tests.
+ */
+export function detectPackageManager(cwd = process.cwd()) {
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock')))
+        return 'bun';
+    return 'npm';
+}
+/**
+ * The exact "add tsx as a dev dependency" command for a package manager.
+ *
+ * @internal exported for tests.
+ */
+export function tsxInstallCommand(pm) {
+    switch (pm) {
+        case 'pnpm':
+            return 'pnpm add -D tsx';
+        case 'yarn':
+            return 'yarn add -D tsx';
+        case 'bun':
+            return 'bun add -d tsx';
+        default:
+            return 'npm install --save-dev tsx';
+    }
+}
+/**
+ * The heads-up `turbine init` prints when it has just scaffolded TypeScript
+ * files and `tsx` is not resolvable: without it the CLI cannot load them, and
+ * the very next command the user runs dies on "Cannot load TypeScript file".
+ * Pure (returns the lines, prints nothing) so it can be asserted in tests.
+ *
+ * @internal exported for tests.
+ */
+export function tsxRequiredNotice(tsFiles, installCommand) {
+    return [
+        `Turbine needs ${cyan('tsx')} to load the TypeScript files just created:`,
+        ...tsFiles.map((f) => `    ${dim(symbols.dot)} ${cyan(f)}`),
+        '',
+        `  ${dim('Install it as a dev dependency:')}`,
+        `    ${cyan(installCommand)}`,
+        '',
+        `  ${dim('Without it, the next Turbine command fails with')} ${dim('"Cannot load TypeScript file".')}`,
+    ];
+}
 /**
  * Read the consumer's `package.json` `"type"` field. Returns `'module'` for an
  * ESM project, `'commonjs'` for an explicit or absent (defaulted) CommonJS
@@ -755,6 +852,48 @@ function initPromptQuestion(step, config, seedFilePath) {
             return `Run ${initStepLabel(step.id)}?`;
     }
 }
+/**
+ * Decide which connection notice `turbine init` prints. Pure so the whole
+ * decision matrix is testable.
+ *
+ * "No DATABASE_URL found in environment" is reserved for the case where NO
+ * source supplied one: printing it while happily using `--url` (or a config
+ * `url`) reads like a failure the user then goes looking for.
+ *
+ * @internal exported for tests.
+ */
+export function initEnvNotice(input) {
+    if (input.envUrl) {
+        return { kind: 'success', message: `Detected ${cyan('DATABASE_URL')} in the environment` };
+    }
+    if (input.hasEnvFile && !input.canAutoLoadEnv) {
+        return {
+            kind: 'info',
+            message: `Found ${cyan('.env')} ${dim('(this Node version cannot auto-load it. Upgrade to Node 20.12+ or export')} ${cyan('DATABASE_URL')}${dim(')')}`,
+        };
+    }
+    if (input.hasEnvFile) {
+        // .env exists but did not provide DATABASE_URL; if it had, the auto-load
+        // in main() would have populated envUrl above.
+        return {
+            kind: 'info',
+            message: `Found ${cyan('.env')} ${dim('(no')} ${cyan('DATABASE_URL')} ${dim('set in it yet)')}`,
+        };
+    }
+    if (input.hasEnvLocal) {
+        return {
+            kind: 'info',
+            message: `Found ${cyan('.env.local')} ${dim('(note: Turbine only auto-loads')} ${cyan('.env')}${dim(')')}`,
+        };
+    }
+    if (input.flagUrl) {
+        return { kind: 'success', message: `Using the connection string passed with ${cyan('--url')}` };
+    }
+    if (input.configUrl) {
+        return { kind: 'success', message: `Using the ${cyan('url')} from your config file` };
+    }
+    return { kind: 'info', message: `No ${cyan('DATABASE_URL')} found in environment` };
+}
 async function cmdInit(args, config) {
     banner();
     header('Initializing Turbine project');
@@ -767,23 +906,18 @@ async function cmdInit(args, config) {
     // On Node < 20.12 (no process.loadEnvFile) main() could not auto-load .env, so
     // we cannot claim it "has no DATABASE_URL"; we simply could not read it.
     const canAutoLoadEnv = typeof process.loadEnvFile === 'function';
-    if (envUrl) {
-        success(`Detected ${cyan('DATABASE_URL')} in the environment`);
-    }
-    else if (hasEnvFile && !canAutoLoadEnv) {
-        info(`Found ${cyan('.env')} ${dim('(this Node version cannot auto-load it. Upgrade to Node 20.12+ or export')} ${cyan('DATABASE_URL')}${dim(')')}`);
-    }
-    else if (hasEnvFile) {
-        // .env exists but did not provide DATABASE_URL; if it had, the auto-load
-        // in main() would have populated envUrl above.
-        info(`Found ${cyan('.env')} ${dim('(no')} ${cyan('DATABASE_URL')} ${dim('set in it yet)')}`);
-    }
-    else if (hasEnvLocal) {
-        info(`Found ${cyan('.env.local')} ${dim('(note: Turbine only auto-loads')} ${cyan('.env')}${dim(')')}`);
-    }
-    else {
-        info(`No ${cyan('DATABASE_URL')} found in environment`);
-    }
+    const envNotice = initEnvNotice({
+        envUrl,
+        hasEnvFile,
+        hasEnvLocal,
+        canAutoLoadEnv,
+        flagUrl: args.url,
+        configUrl: config.url,
+    });
+    if (envNotice.kind === 'success')
+        success(envNotice.message);
+    else
+        info(envNotice.message);
     newline();
     // Heads-up (not an edit) about the consumer's module system. A CommonJS
     // project (`npm init -y` default, or no "type" field) works fine now that the
@@ -800,7 +934,9 @@ async function cmdInit(args, config) {
     const hasUrl = Boolean(url);
     const interactive = Boolean(process.stdin.isTTY);
     const yes = args.yes === true;
-    const seedFilePath = config.seedFile ?? './seed.ts';
+    // Where init scaffolds the seed file. A root-level ./seed.ts from an older
+    // init still counts, so a re-run never scaffolds a second seed file.
+    const seedFilePath = config.seedFile ?? (existsSync('./seed.ts') ? './seed.ts' : DEFAULT_INIT_SEED_FILE);
     const configPath = findConfigFile();
     const state = {
         configExists: Boolean(configPath),
@@ -834,6 +970,8 @@ async function cmdInit(args, config) {
     // Supporting dirs + .gitignore, regardless of prompts (unchanged behavior).
     ensureInitScaffoldDirs(config);
     newline();
+    // TypeScript files this run actually created: they drive the tsx heads-up below.
+    const tsFilesWritten = [];
     // Execute the plan in order. `run` proceeds; `prompt` asks; `skip` reports.
     for (const step of plan) {
         if (step.action === 'skip') {
@@ -849,12 +987,17 @@ async function cmdInit(args, config) {
             case 'config':
                 writeFileSync('turbine.config.ts', configTemplate(args.url ?? undefined), 'utf-8');
                 success(state.configExists ? `Overwrote ${cyan('turbine.config.ts')}` : `Created ${cyan('turbine.config.ts')}`);
+                tsFilesWritten.push('turbine.config.ts');
                 break;
             case 'schema':
                 writeInitSchemaTemplate(config);
+                if (needsTsLoader(config.schemaFile))
+                    tsFilesWritten.push(config.schemaFile);
                 break;
             case 'seed-file':
                 writeInitSeedTemplate(seedFilePath);
+                if (needsTsLoader(seedFilePath))
+                    tsFilesWritten.push(seedFilePath);
                 break;
             case 'push':
                 await runInitPush(config, url);
@@ -867,6 +1010,17 @@ async function cmdInit(args, config) {
                 break;
         }
     }
+    // Scaffolding .ts files and staying silent about tsx is how a fresh project
+    // hits "Cannot load TypeScript file" on its very next command. Warn now, name
+    // the exact install command, and never install anything ourselves.
+    const tsxMissing = tsFilesWritten.length > 0 && !canResolveTsx();
+    if (tsxMissing) {
+        newline();
+        const [headline, ...rest] = tsxRequiredNotice(tsFilesWritten, tsxInstallCommand(detectPackageManager()));
+        warn(headline ?? '');
+        for (const line of rest)
+            console.log(line);
+    }
     if (degraded) {
         newline();
         info('Non-interactive shell: interactive prompts were skipped.');
@@ -884,8 +1038,9 @@ async function cmdInit(args, config) {
             console.log(`     ${dim('or create a')} ${cyan('.env')} ${dim('file with')} ${cyan('DATABASE_URL=postgres://...')}`);
         }
         console.log(`  ${dim('2.')} Run ${cyan('npx turbine generate')} to introspect your DB`);
-        if (!canResolveTsx()) {
-            console.log(`     ${dim('Note: the TypeScript config requires')} ${cyan('tsx')} ${dim('—')} ${cyan('npm install --save-dev tsx')}`);
+        // Only when the fuller heads-up above did not already run (nothing scaffolded).
+        if (!tsxMissing && !canResolveTsx()) {
+            console.log(`     ${dim('Note: the TypeScript config requires')} ${cyan('tsx')}: ${cyan(tsxInstallCommand(detectPackageManager()))}`);
         }
     }
     else {
@@ -1010,20 +1165,30 @@ async function cmdGenerate(args, config) {
     console.log(`  ${dim('const user = await db.users.findUnique({ where: { id: 1 } });')}`);
     newline();
 }
-// ---------------------------------------------------------------------------
-// migrate-from-prisma
-// ---------------------------------------------------------------------------
 /**
- * `turbine migrate-from-prisma --schema prisma/schema.prisma` parses a Prisma
- * schema, resolve its models/fields/relations/compound-uniques against the live
- * database (unless `--no-db`), and emit (a) a Markdown resolution report and
- * (b) a typed `prisma-map.ts` name map next to the generated client.
+ * Pick the connection string for `migrate-from-prisma`.
  *
- * NOTE: within THIS command `--schema` names the Prisma schema FILE (not the
- * Postgres namespace, which the rest of the CLI's `--schema` means). The
- * Postgres namespace is `public` here; multi-schema (`@@schema`) is unsupported
- * in v1 and listed as a parser note in the report.
+ * `configUrl` is what {@link resolveConfig} already produced (`--url`, then
+ * `DATABASE_URL`, then `turbine.config.ts`) and always wins: an explicit flag
+ * must never be overridden by a value declared in someone else's schema file.
+ * Only when that is empty do we fall back to the `datasource` block, which
+ * removes the flag a project with a non-standard variable name would otherwise
+ * pass on every run.
  */
+export function resolveMigrateFromPrismaUrl(configUrl, ast, env) {
+    const lookup = resolvePrismaDatasourceUrl(ast, env);
+    if (configUrl)
+        return { url: configUrl, source: 'config', missingVariables: lookup.missingVariables };
+    if (lookup.resolved) {
+        return {
+            url: lookup.resolved.url,
+            source: 'datasource',
+            datasource: lookup.resolved,
+            missingVariables: lookup.missingVariables,
+        };
+    }
+    return { source: 'none', missingVariables: lookup.missingVariables };
+}
 async function cmdMigrateFromPrisma(args, config) {
     banner();
     // `--schema` is the Prisma schema file path in this command.
@@ -1061,7 +1226,15 @@ async function cmdMigrateFromPrisma(args, config) {
         info('Parse-only mode (--no-db): names will not be resolved.');
     }
     else {
-        url = requireUrl(config);
+        // The schema.prisma datasource is the LAST resort for the connection string,
+        // below `--url`, `DATABASE_URL`, and `turbine.config.ts`.
+        const resolvedUrl = resolveMigrateFromPrismaUrl(config.url, ast, process.env);
+        if (resolvedUrl.source === 'datasource' && resolvedUrl.datasource) {
+            const { variable, datasource: dsName, key } = resolvedUrl.datasource;
+            const origin = variable ? `${cyan(variable)} via datasource "${dsName}"` : `datasource "${dsName}" ${key}`;
+            info(`Using the connection string declared by your Prisma schema (${origin}).`);
+        }
+        url = resolvedUrl.url ?? requireUrl(config, { datasourceVars: resolvedUrl.missingVariables });
         label('Database', redactUrl(url));
         const spinner = new Spinner('Introspecting database schema').start();
         schemaMeta = await introspect({
@@ -2752,6 +2925,8 @@ function showMigrateFromPrismaHelp() {
     console.log(`    ${dim('•')} ${cyan('prisma-map.ts')}              - typed PRISMA_MAP name map`);
     newline();
     console.log(`  ${dim('Note:')} here ${cyan('--schema')} names the Prisma FILE (not the Postgres namespace).`);
+    console.log(`  ${dim('Note:')} with no ${cyan('--url')} / ${cyan('DATABASE_URL')} / config ${cyan('url')}, the connection string`);
+    console.log(`        declared by your ${cyan('datasource')} block is used (including its ${cyan('env("...")')}).`);
     newline();
     console.log(`  ${bold('Options:')}`);
     console.log(`    ${cyan('--schema')} ${dim('<file>')}     Path to schema.prisma ${dim('(default: prisma/schema.prisma)')}`);
@@ -3012,27 +3187,6 @@ async function main() {
         warn(`Found ${cyan('.env')} but this Node version cannot auto-load it. ` +
             `Upgrade to Node 20.12+ or export ${cyan('DATABASE_URL')} yourself.`);
     }
-    // If the user has a TypeScript config file, register the tsx ESM loader
-    // before we attempt to import it. Otherwise Node throws
-    // ERR_UNKNOWN_FILE_EXTENSION for `.ts`.
-    const configPath = findConfigFile();
-    if (needsTsLoader(configPath)) {
-        const status = await registerTsLoader();
-        if (status === 'missing' || status === 'unsupported' || status === 'failed') {
-            failMissingTsLoader(configPath ?? 'turbine.config.ts', status);
-        }
-    }
-    // Load config file. A config that exists but fails to import is surfaced
-    // loudly (with a name + the underlying error) instead of being swallowed and
-    // later misreported as a missing database URL.
-    const { config: fileConfig, loadError } = await loadConfigResult();
-    if (loadError && args.command !== 'init') {
-        const underlying = loadError.error instanceof Error ? loadError.error.message : String(loadError.error);
-        warn(`Could not load ${cyan(loadError.filename)}: ${underlying}`);
-        if (loadError.error instanceof Error)
-            printCjsHintIfApplicable(loadError.error);
-        newline();
-    }
     const overrides = {
         url: args.url,
         out: args.out,
@@ -3043,7 +3197,18 @@ async function main() {
         keepColumnNames: args.keepColumnNames,
         legacyToManyUniques: args.legacyToManyUniques,
     };
-    const config = resolveConfig(fileConfig, overrides);
+    // Resolve the config file (skipped entirely for config-free invocations such
+    // as `studio --demo`). A config that exists but fails to import is surfaced
+    // loudly (with a name + the underlying error) instead of being swallowed and
+    // later misreported as a missing database URL.
+    const { config, fileConfig, loadError } = await bootstrapCliConfig(args, overrides);
+    if (loadError && args.command !== 'init') {
+        const underlying = loadError.error instanceof Error ? loadError.error.message : String(loadError.error);
+        warn(`Could not load ${cyan(loadError.filename)}: ${underlying}`);
+        if (loadError.error instanceof Error)
+            printCjsHintIfApplicable(loadError.error);
+        newline();
+    }
     // Warn (don't change precedence) when an .env-sourced DATABASE_URL is silently
     // overriding a differing, non-empty url in the config file (a wrong-database
     // hazard for push/migrate/seed). Shell-exported DATABASE_URL stays silent.

package/dist/cli/migrate.d.ts

@@ -11,6 +11,7 @@
  *   -- DOWN
  *   DROP TABLE users;
  */
+import pg from 'pg';
 import type { DatabaseAdapter } from '../adapters/index.js';
 import { type Dialect } from '../dialect.js';
 import { type DestructiveStatement } from './destructive.js';
@@ -133,6 +134,29 @@ export declare function splitSqlStatements(sql: string): string[];
  * Parse a migration file into UP and DOWN sections.
  */
 export declare function parseMigrationSQL(filePath: string): ParsedMigration;
+/**
+ * Can a stored pre-v0.6 checksum be safely upgraded to SHA-256?
+ *
+ * Only when the LEGACY algorithm, run over the file's CURRENT content,
+ * reproduces the stored value: that is what proves the file has not changed
+ * since it was applied. Upgrading without this proof blesses whatever the file
+ * says today and permanently disables drift detection for that migration.
+ *
+ * @internal exported for tests.
+ */
+export declare function canUpgradeLegacyChecksum(stored: string, content: string): boolean;
+/**
+ * Is an applied migration's stored checksum still valid for the file on disk?
+ *
+ * A SHA-256 match is the normal case. A pre-v0.6 row that {@link
+ * canUpgradeLegacyChecksum} would upgrade counts as valid too: `migrate up`
+ * accepts and upgrades it, so reporting it as invalid in `migrate status` would
+ * have the two commands disagree about the same unchanged file. Genuine drift
+ * (a legacy hash the current content no longer reproduces) still reports false.
+ *
+ * @internal exported for tests.
+ */
+export declare function isChecksumValid(stored: string, content: string): boolean;
 /**
  * A named migration scaffold. `build()` returns the commented-SQL UP/DOWN body
  * for the recipe; `createMigration({ recipe })` wraps it in the file header.
@@ -216,6 +240,28 @@ export declare function createMigration(migrationsDir: string, name: string, aut
  * without contending on a single hardcoded lock ID.
  */
 export declare function deriveLockId(databaseName: string): number;
+/**
+ * The minimal query surface a transactional migration body needs.
+ * `pg.Client` satisfies it; tests supply a fake.
+ */
+export interface MigrationTxClient {
+    query(sql: string, params?: unknown[]): Promise<unknown>;
+}
+/**
+ * Run one migration body (UP or DOWN) plus its tracking-table write inside a
+ * single transaction. Returns `null` on success, or the error message on
+ * failure, leaving the caller to record it and stop.
+ *
+ * The ROLLBACK is best-effort: if the connection died, ROLLBACK throws too, and
+ * letting that escape would replace the real migration failure with a
+ * connection error. Same guard as `client.ts`, `query/builder.ts`, `dialect.ts`.
+ *
+ * @internal exported for tests; not part of the CLI's public surface.
+ */
+export declare function runMigrationInTransaction(client: MigrationTxClient, body: string, tracking: {
+    sql: string;
+    params: unknown[];
+}): Promise<string | null>;
 export interface ChecksumMismatch {
     name: string;
     expected: string;
@@ -227,6 +273,13 @@ export interface MigrationDeployPlan {
     pending: MigrationFile[];
     mismatches: ChecksumMismatch[];
 }
+/**
+ * Validate that applied migration files have not been modified or deleted since they were run.
+ * Returns an array of mismatched migrations (empty if all are clean).
+ *
+ * @internal exported for tests; not part of the CLI's public surface.
+ */
+export declare function validateChecksums(client: pg.Client, migrationsDir: string, dialect?: Dialect): Promise<ChecksumMismatch[]>;
 export declare function formatChecksumMismatchError(mismatches: ChecksumMismatch[]): string;
 /**
  * Build a deploy plan from local migration files and applied migration rows.
@@ -237,9 +290,7 @@ export declare function planMigrationDeploy(migrationsDir: string, applied: Appl
 /**
  * Inspect deploy status without applying migrations.
  */
-export declare function inspectMigrationDeploy(connectionString: string, migrationsDir: string, options?: {
-    dialect?: Dialect;
-}): Promise<MigrationDeployPlan>;
+export declare function inspectMigrationDeploy(connectionString: string, migrationsDir: string): Promise<MigrationDeployPlan>;
 /**
  * Apply all pending migrations (UP).
  *
@@ -261,7 +312,6 @@ export declare function migrateUp(connectionString: string, migrationsDir: strin
     /** Run migrations even when they contain data-destroying statements. Default false. */
     allowDestructive?: boolean;
     adapter?: DatabaseAdapter;
-    dialect?: Dialect;
     /**
      * Called right before a `-- turbine:no-transaction` migration runs, so the
      * CLI can print its loud pre-run notice (a concurrent index build can wait a
@@ -275,7 +325,6 @@ export declare function migrateUp(connectionString: string, migrationsDir: strin
  */
 export declare function migrateDeploy(connectionString: string, migrationsDir: string, options?: {
     adapter?: DatabaseAdapter;
-    dialect?: Dialect;
     allowDrift?: boolean;
 }): Promise<MigrationRunResult>;
 /**
@@ -290,7 +339,6 @@ export declare function migrateDown(connectionString: string, migrationsDir: str
     step?: number;
     allowDestructive?: boolean;
     adapter?: DatabaseAdapter;
-    dialect?: Dialect;
 }): Promise<{
     rolledBack: MigrationFile[];
     errors: Array<{
@@ -300,8 +348,9 @@ export declare function migrateDown(connectionString: string, migrationsDir: str
 }>;
 /**
  * Get the status of all migrations (applied vs pending).
- * Includes checksum validation for applied migrations.
+ *
+ * Applied rows carry `checksumValid`, decided by {@link isChecksumValid} so an
+ * unchanged pre-v0.6 row reports the same way `migrate up` treats it (valid,
+ * pending an in-place hash upgrade) rather than looking like drift.
  */
-export declare function migrateStatus(connectionString: string, migrationsDir: string, options?: {
-    dialect?: Dialect;
-}): Promise<MigrationStatus[]>;
+export declare function migrateStatus(connectionString: string, migrationsDir: string): Promise<MigrationStatus[]>;