@happyvertical/smrt-core 0.50.0 → 0.51.1

package/dist/migrations/differ.js

@@ -1,8 +1,9 @@
 import { normalizeForeignKeyAction, requireForeignKeyAction } from "../schema/foreign-key-policy.js";
 import { isJsonPathIndex, isStiSubtypeUniqueIndex, renderIndexTarget } from "../schema/index-utils.js";
-import { CANONICAL_UUID_PATTERN, CANONICAL_UUID_SQLITE_GLOB_PATTERN, foreignKeyConstraintName, foreignKeyRelationshipKey, renderForeignKeyAddStatements, renderForeignKeyOrphanDetector, renderForeignKeyOrphanRepair, schemaForeignKeys, schemaForeignKeysForEngine } from "../schema/foreign-key-ddl.js";
+import { foreignKeyConstraintName, foreignKeyRelationshipKey, renderForeignKeyAddStatements, renderForeignKeyOrphanDetector, renderForeignKeyOrphanRepair, schemaForeignKeys, schemaForeignKeysForEngine } from "../schema/foreign-key-ddl.js";
 import { renderNullEqualConflictIndex } from "../schema/ddl/null-equal-index.js";
 import { detectEngine, getDDLStrategy } from "../schema/ddl/index.js";
+import { columnsAllValuesUuidShapedBatch, columnsHaveNonEmptyValueBatch, nonEmptyValuePredicate, uuidInvalidShapePredicate } from "../schema/column-data-probes.js";
 import { maskSampleValue, probeCastSafety, renderJsonbColumnConversion, renderTimestamptzColumnConversion } from "../schema/text-cast-probe.js";
 import { describeForeignKeyTypeConflict, planUuidConvergence, renderUuidConvergenceRepairHint, renderUuidShapeProbe } from "../schema/uuid-convergence.js";
 import "../schema/utils.js";
@@ -301,7 +302,7 @@ function canonicalizeDefault(fragment, columnType) {
 /**
 * SchemaComparer class for comparing manifest schemas to database
 */
-var SchemaComparer = class {
+var SchemaComparer = class SchemaComparer {
 	db;
 	options;
 	engine;
@@ -315,6 +316,40 @@ var SchemaComparer = class {
 	liveSchemas = /* @__PURE__ */ new Map();
 	/** Convergence plan for this run; `null` on non-PostgreSQL engines. */
 	uuidConvergence = null;
+	/**
+	* Rename-pending advisory findings for this `compare()` run, keyed by
+	* table name (#2878). `compareTable()` reads from here when it is being
+	* driven by `compare()` over the full manifest, which lets the probe be
+	* batched *across every table in one round trip* instead of paying at
+	* least one round trip per table (#2876 batched a table's own columns
+	* into one round trip but never batched across tables — with a
+	* realistic 71-table schema that per-table floor was itself the entire
+	* residual). `null` means "not precomputed for this run" (a standalone
+	* `compareTable()` call outside `compare()`, or a non-PostgreSQL/SQLite
+	* engine), in which case `detectRenameDataPending()` falls back to the
+	* original single-table probe so standalone callers keep working
+	* unchanged. Cleared every `compare()` call, same as `liveSchemas` —
+	* this is a per-run cache, never reused across runs, so a live schema
+	* change is always seen on the next comparison (no invalidation story
+	* needed because nothing survives past one `compare()` call).
+	*/
+	renameDataPendingCache = null;
+	/**
+	* Cross-table batch queries stay bounded regardless of schema shape: this
+	* caps how many scalar-subquery columns one probe statement packs into a
+	* single row. Conservative relative to PostgreSQL's ~1600 column limit
+	* per result row, and SQLite has no such ceiling but benefits from the
+	* same bound for query-text size. Applied twice (PR #2888 review): once
+	* per table, so a single pathologically wide table (more probed columns
+	* than this cap) is itself sliced across more than one statement rather
+	* than landing in one oversized chunk; and again across tables, packing
+	* every (possibly sliced) entry into as few chunks as this cap allows.
+	* A schema with no single table wider than this cap needs more than
+	* `MAX_CROSS_TABLE_PROBE_COLUMNS` probed columns *in total* before a
+	* second statement is needed at all — still O(1)-ish round trips for a
+	* realistic schema.
+	*/
+	static MAX_CROSS_TABLE_PROBE_COLUMNS = 400;
 	constructor(db, options = {}) {
 		this.db = db;
 		this.options = {
@@ -338,34 +373,40 @@ var SchemaComparer = class {
 			has_changes: false
 		};
 		this.liveSchemas.clear();
-		const existingTables = await this.getExistingTables();
-		this.uuidConvergence = await this.buildUuidConvergencePlan(manifestSchemas, existingTables);
-		for (const change of this.uuidConvergenceChanges(manifestSchemas)) {
-			diff.changes.push(change);
-			if (!isInfoOnlyChange(change)) diff.has_changes = true;
-		}
-		for (const [tableName, schema] of Object.entries(manifestSchemas)) if (!existingTables.has(tableName)) {
-			diff.added_tables.push(schema);
-			diff.has_changes = true;
-		} else {
-			const tableChanges = await this.compareTable(tableName, schema, manifestSchemas);
-			if (tableChanges.length > 0) {
-				diff.changes.push(...tableChanges);
-				if (tableChanges.some((change) => !isInfoOnlyChange(change))) diff.has_changes = true;
+		this.renameDataPendingCache = null;
+		try {
+			const existingTables = await this.getExistingTables();
+			await this.precomputeRenameDataPending(manifestSchemas, existingTables);
+			this.uuidConvergence = await this.buildUuidConvergencePlan(manifestSchemas, existingTables);
+			for (const change of this.uuidConvergenceChanges(manifestSchemas)) {
+				diff.changes.push(change);
+				if (!isInfoOnlyChange(change)) diff.has_changes = true;
 			}
+			for (const [tableName, schema] of Object.entries(manifestSchemas)) if (!existingTables.has(tableName)) {
+				diff.added_tables.push(schema);
+				diff.has_changes = true;
+			} else {
+				const tableChanges = await this.compareTable(tableName, schema, manifestSchemas);
+				if (tableChanges.length > 0) {
+					diff.changes.push(...tableChanges);
+					if (tableChanges.some((change) => !isInfoOnlyChange(change))) diff.has_changes = true;
+				}
+			}
+			const orphanTables = [];
+			for (const tableName of existingTables) {
+				if (tableName.startsWith("_smrt_") || tableName.startsWith("sqlite_")) continue;
+				if (!manifestSchemas[tableName]) orphanTables.push(tableName);
+			}
+			orphanTables.sort();
+			diff.orphan_tables = orphanTables;
+			if (this.options.includeDroppedTables && orphanTables.length > 0) {
+				diff.dropped_tables.push(...orphanTables);
+				diff.has_changes = true;
+			}
+			return diff;
+		} finally {
+			this.renameDataPendingCache = null;
 		}
-		const orphanTables = [];
-		for (const tableName of existingTables) {
-			if (tableName.startsWith("_smrt_") || tableName.startsWith("sqlite_")) continue;
-			if (!manifestSchemas[tableName]) orphanTables.push(tableName);
-		}
-		orphanTables.sort();
-		diff.orphan_tables = orphanTables;
-		if (this.options.includeDroppedTables && orphanTables.length > 0) {
-			diff.dropped_tables.push(...orphanTables);
-			diff.has_changes = true;
-		}
-		return diff;
 	}
 	/**
 	* Compare a single table's schema to manifest
@@ -964,6 +1005,19 @@ var SchemaComparer = class {
 		return changes;
 	}
 	/**
+	* Detect a pending rename backfill (#2752) for one table. Reads
+	* `renameDataPendingCache` when `compare()` has already batched this
+	* table's probe across the whole manifest (#2878); otherwise falls back
+	* to {@link detectRenameDataPendingSingleTable}, so a standalone
+	* `compareTable()` call (outside `compare()`) still gets a correct
+	* answer, just without the cross-table batching.
+	*/
+	async detectRenameDataPending(tableName, manifest, dbSchema) {
+		const cached = this.renameDataPendingCache?.get(tableName);
+		if (cached !== void 0) return cached;
+		return this.detectRenameDataPendingSingleTable(tableName, manifest, dbSchema);
+	}
+	/**
 	* Detect a pending rename backfill (#2752): a manifest-declared column
 	* that exists live but holds no data, paired with an orphan (undeclared)
 	* live column of a compatible type that does hold data — the shape a
@@ -975,89 +1029,330 @@ var SchemaComparer = class {
 	* `DO $$ ... $$` block); SQLite has no conditional-DDL construct, so its
 	* repair is operator-mediated instead — a guard query plus instructions,
 	* not a blind-rerun-safe statement. See {@link describeRenameDataPending}.
+	*
+	* Single-table probe: at least one round trip for this table alone.
+	* `compare()` does not call this directly — see
+	* {@link precomputeRenameDataPending} for the cross-table batched path
+	* that every ordinary `compare()` run takes instead (#2878). This stays
+	* as the fallback for a standalone `compareTable()` call.
 	*/
-	async detectRenameDataPending(tableName, manifest, dbSchema) {
+	async detectRenameDataPendingSingleTable(tableName, manifest, dbSchema) {
 		if (this.engine !== "postgres" && this.engine !== "sqlite") return [];
 		const dbColumnNames = new Set(Object.keys(dbSchema.columns));
 		const manifestColumnNames = new Set(Object.keys(manifest.columns));
 		const orphanColumnNames = [...dbColumnNames].filter((name) => !manifestColumnNames.has(name));
 		if (orphanColumnNames.length === 0) return [];
+		const declaredCandidateNames = Object.keys(manifest.columns).filter((colName) => dbSchema.columns[colName]);
+		if (declaredCandidateNames.length === 0) return [];
+		const declaredHasData = await columnsHaveNonEmptyValueBatch(this.db, tableName, declaredCandidateNames);
+		const emptyDeclaredNames = declaredCandidateNames.filter((colName) => !(declaredHasData.get(colName) ?? true));
+		if (emptyDeclaredNames.length === 0) return [];
+		const compatibleOrphanNames = orphanColumnNames.filter((orphanName) => {
+			const orphanNormalized = this.normalizeType(dbSchema.columns[orphanName].type);
+			return emptyDeclaredNames.some((colName) => {
+				const validatedType = isValidSQLDataType(manifest.columns[colName].type) ? manifest.columns[colName].type : "TEXT";
+				const declaredNormalized = this.normalizeType(this.ddlStrategy.mapType(validatedType));
+				return validatedType === "UUID" && orphanNormalized === "TEXT" || orphanNormalized === declaredNormalized;
+			});
+		});
+		if (compatibleOrphanNames.length === 0) return [];
+		const orphanHasData = await columnsHaveNonEmptyValueBatch(this.db, tableName, compatibleOrphanNames);
+		const hasData = new Map([...declaredHasData, ...orphanHasData]);
 		const changes = [];
+		const pending = [];
+		const shapeCheckOrphans = /* @__PURE__ */ new Set();
 		for (const [colName, colDef] of Object.entries(manifest.columns)) {
 			if (!dbSchema.columns[colName]) continue;
-			let declaredHasData;
-			try {
-				declaredHasData = await this.columnHasNonEmptyValue(tableName, colName);
-			} catch {
-				continue;
-			}
-			if (declaredHasData) continue;
+			if (hasData.get(colName) ?? true) continue;
 			const validatedType = isValidSQLDataType(colDef.type) ? colDef.type : "TEXT";
 			const isLogicalUuid = validatedType === "UUID";
 			const declaredNormalized = this.normalizeType(this.ddlStrategy.mapType(validatedType));
-			const candidates = [];
-			for (const orphanName of orphanColumnNames) {
+			for (const orphanName of compatibleOrphanNames) {
 				const orphanCol = dbSchema.columns[orphanName];
 				const orphanNormalized = this.normalizeType(orphanCol.type);
 				const requiresShapeCheck = isLogicalUuid && orphanNormalized === "TEXT";
 				if (!requiresShapeCheck && !(orphanNormalized === declaredNormalized)) continue;
-				let orphanHasData;
-				try {
-					orphanHasData = await this.columnHasNonEmptyValue(tableName, orphanName);
-				} catch {
-					continue;
-				}
-				if (!orphanHasData) continue;
-				if (requiresShapeCheck) {
-					let shaped;
-					try {
-						shaped = await this.allNonEmptyValuesUuidShaped(tableName, orphanName);
-					} catch {
-						continue;
-					}
-					if (!shaped) continue;
-				}
-				candidates.push({
+				if (!(hasData.get(orphanName) ?? false)) continue;
+				if (requiresShapeCheck) shapeCheckOrphans.add(orphanName);
+				pending.push({
+					colName,
 					orphanName,
-					isUuidCast: declaredNormalized === "UUID"
+					isUuidCast: declaredNormalized === "UUID",
+					requiresShapeCheck
 				});
 			}
-			if (candidates.length === 1) changes.push(this.describeRenameDataPending(tableName, colName, candidates[0].orphanName, candidates[0].isUuidCast));
-			else if (candidates.length > 1) changes.push(this.describeRenameDataPendingAmbiguous(tableName, colName, candidates.map((c) => c.orphanName)));
 		}
+		const shaped = shapeCheckOrphans.size > 0 ? await columnsAllValuesUuidShapedBatch(this.db, this.engine, tableName, [...shapeCheckOrphans]) : /* @__PURE__ */ new Map();
+		const candidatesByColumn = /* @__PURE__ */ new Map();
+		for (const candidate of pending) {
+			if (candidate.requiresShapeCheck && !(shaped.get(candidate.orphanName) ?? false)) continue;
+			const list = candidatesByColumn.get(candidate.colName) ?? [];
+			list.push({
+				orphanName: candidate.orphanName,
+				isUuidCast: candidate.isUuidCast
+			});
+			candidatesByColumn.set(candidate.colName, list);
+		}
+		for (const [colName, candidates] of candidatesByColumn) if (candidates.length === 1) changes.push(this.describeRenameDataPending(tableName, colName, candidates[0].orphanName, candidates[0].isUuidCast));
+		else if (candidates.length > 1) changes.push(this.describeRenameDataPendingAmbiguous(tableName, colName, candidates.map((c) => c.orphanName)));
 		return changes;
 	}
 	/**
-	* Live-data probe: does the column hold any non-null, non-empty value?
-	* Used by {@link detectRenameDataPending}. Errors propagate to the
-	* caller, which skips the pair rather than guessing (#2752).
+	* Batch every table's rename-pending advisory probe (#2752/#2878) into a
+	* small, table-count-independent number of round trips, and populate
+	* {@link renameDataPendingCache} so `compareTable()`'s per-table
+	* `detectRenameDataPending()` call becomes a cache read for the rest of
+	* this `compare()` run.
+	*
+	* Mirrors {@link detectRenameDataPendingSingleTable}'s phases exactly —
+	* same gates, same type-compatibility rules, same per-column `LIMIT 1`
+	* early exit — just resequenced so each phase's *query* covers every
+	* table that needs it in one statement, instead of one statement per
+	* table. With a 71-table schema this is the difference between a
+	* 71-statement floor (#2878) and a handful of statements for the whole
+	* schema, independent of table count.
+	*
+	* No caching beyond this: the cache this populates is cleared at the top
+	* of every `compare()` call, so a live schema change is always visible
+	* on the next comparison.
 	*/
-	async columnHasNonEmptyValue(tableName, colName) {
-		const quotedTable = this.quoteIdentifier(tableName);
-		const quotedCol = this.quoteIdentifier(colName);
-		return ((await this.db.query(`SELECT 1 AS present FROM ${quotedTable} WHERE ${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> '' LIMIT 1`)).rows?.length ?? 0) > 0;
+	async precomputeRenameDataPending(manifestSchemas, existingTables) {
+		this.renameDataPendingCache = /* @__PURE__ */ new Map();
+		if (this.engine !== "postgres" && this.engine !== "sqlite") return;
+		const tables = [];
+		for (const [tableName, manifest] of Object.entries(manifestSchemas)) {
+			if (!existingTables.has(tableName)) continue;
+			const dbSchema = await this.getLiveSchema(tableName);
+			if (!dbSchema) {
+				this.renameDataPendingCache.set(tableName, []);
+				continue;
+			}
+			const dbColumnNames = new Set(Object.keys(dbSchema.columns));
+			const manifestColumnNames = new Set(Object.keys(manifest.columns));
+			const orphanColumnNames = [...dbColumnNames].filter((name) => !manifestColumnNames.has(name));
+			if (orphanColumnNames.length === 0) {
+				this.renameDataPendingCache.set(tableName, []);
+				continue;
+			}
+			const declaredCandidateNames = Object.keys(manifest.columns).filter((colName) => dbSchema.columns[colName]);
+			if (declaredCandidateNames.length === 0) {
+				this.renameDataPendingCache.set(tableName, []);
+				continue;
+			}
+			tables.push({
+				tableName,
+				manifest,
+				dbSchema,
+				declaredCandidateNames,
+				orphanColumnNames
+			});
+		}
+		if (tables.length === 0) return;
+		const declaredHasDataByTable = await this.crossTableColumnsHaveNonEmptyValueBatch(tables.map((t) => ({
+			tableName: t.tableName,
+			colNames: t.declaredCandidateNames
+		})));
+		const phase2Tables = [];
+		for (const t of tables) {
+			const declaredHasData = declaredHasDataByTable.get(t.tableName) ?? /* @__PURE__ */ new Map();
+			const emptyDeclaredNames = t.declaredCandidateNames.filter((colName) => !(declaredHasData.get(colName) ?? true));
+			if (emptyDeclaredNames.length === 0) {
+				this.renameDataPendingCache.set(t.tableName, []);
+				continue;
+			}
+			const compatibleOrphanNames = t.orphanColumnNames.filter((orphanName) => {
+				const orphanNormalized = this.normalizeType(t.dbSchema.columns[orphanName].type);
+				return emptyDeclaredNames.some((colName) => {
+					const validatedType = isValidSQLDataType(t.manifest.columns[colName].type) ? t.manifest.columns[colName].type : "TEXT";
+					const declaredNormalized = this.normalizeType(this.ddlStrategy.mapType(validatedType));
+					return validatedType === "UUID" && orphanNormalized === "TEXT" || orphanNormalized === declaredNormalized;
+				});
+			});
+			if (compatibleOrphanNames.length === 0) {
+				this.renameDataPendingCache.set(t.tableName, []);
+				continue;
+			}
+			phase2Tables.push({
+				tableName: t.tableName,
+				compatibleOrphanNames
+			});
+		}
+		if (phase2Tables.length === 0) return;
+		const orphanHasDataByTable = await this.crossTableColumnsHaveNonEmptyValueBatch(phase2Tables.map((t) => ({
+			tableName: t.tableName,
+			colNames: t.compatibleOrphanNames
+		})));
+		const byName = new Map(tables.map((t) => [t.tableName, t]));
+		const pendingByTable = /* @__PURE__ */ new Map();
+		const shapeCheckByTable = /* @__PURE__ */ new Map();
+		for (const { tableName, compatibleOrphanNames } of phase2Tables) {
+			const t = byName.get(tableName);
+			if (!t) continue;
+			const declaredHasData = declaredHasDataByTable.get(tableName) ?? /* @__PURE__ */ new Map();
+			const orphanHasData = orphanHasDataByTable.get(tableName) ?? /* @__PURE__ */ new Map();
+			const hasData = new Map([...declaredHasData, ...orphanHasData]);
+			const pending = [];
+			const shapeCheckOrphans = /* @__PURE__ */ new Set();
+			for (const [colName, colDef] of Object.entries(t.manifest.columns)) {
+				if (!t.dbSchema.columns[colName]) continue;
+				if (hasData.get(colName) ?? true) continue;
+				const validatedType = isValidSQLDataType(colDef.type) ? colDef.type : "TEXT";
+				const isLogicalUuid = validatedType === "UUID";
+				const declaredNormalized = this.normalizeType(this.ddlStrategy.mapType(validatedType));
+				for (const orphanName of compatibleOrphanNames) {
+					const orphanCol = t.dbSchema.columns[orphanName];
+					const orphanNormalized = this.normalizeType(orphanCol.type);
+					const requiresShapeCheck = isLogicalUuid && orphanNormalized === "TEXT";
+					if (!requiresShapeCheck && !(orphanNormalized === declaredNormalized)) continue;
+					if (!(hasData.get(orphanName) ?? false)) continue;
+					if (requiresShapeCheck) shapeCheckOrphans.add(orphanName);
+					pending.push({
+						colName,
+						orphanName,
+						isUuidCast: declaredNormalized === "UUID",
+						requiresShapeCheck
+					});
+				}
+			}
+			pendingByTable.set(tableName, pending);
+			if (shapeCheckOrphans.size > 0) shapeCheckByTable.set(tableName, shapeCheckOrphans);
+		}
+		let shapedByTable = /* @__PURE__ */ new Map();
+		if (shapeCheckByTable.size > 0) shapedByTable = await this.crossTableColumnsAllValuesUuidShapedBatch([...shapeCheckByTable.entries()].map(([tableName, cols]) => ({
+			tableName,
+			colNames: [...cols]
+		})));
+		for (const [tableName, pending] of pendingByTable) {
+			const shaped = shapedByTable.get(tableName) ?? /* @__PURE__ */ new Map();
+			const changes = [];
+			const candidatesByColumn = /* @__PURE__ */ new Map();
+			for (const candidate of pending) {
+				if (candidate.requiresShapeCheck && !(shaped.get(candidate.orphanName) ?? false)) continue;
+				const list = candidatesByColumn.get(candidate.colName) ?? [];
+				list.push({
+					orphanName: candidate.orphanName,
+					isUuidCast: candidate.isUuidCast
+				});
+				candidatesByColumn.set(candidate.colName, list);
+			}
+			for (const [colName, candidates] of candidatesByColumn) if (candidates.length === 1) changes.push(this.describeRenameDataPending(tableName, colName, candidates[0].orphanName, candidates[0].isUuidCast));
+			else if (candidates.length > 1) changes.push(this.describeRenameDataPendingAmbiguous(tableName, colName, candidates.map((c) => c.orphanName)));
+			this.renameDataPendingCache.set(tableName, changes);
+		}
 	}
 	/**
-	* Live-data probe: are every one of a column's non-empty values
-	* UUID-shaped ({@link CANONICAL_UUID_PATTERN})? PostgreSQL pushes the
-	* check into the query with its regex operator; SQLite has no regex
-	* operator, but its case-sensitive `GLOB` can still express the fixed
-	* 36-character canonical shape ({@link CANONICAL_UUID_SQLITE_GLOB_PATTERN}
-	* against `LOWER(...)`, guarded by an exact `LENGTH(...) = 36` check), so
-	* both engines run one server-side aggregate `count(*)` rather than
-	* fetching every non-empty value into JS to test in a loop — important on
-	* a production table with many rows (#2767 review).
+	* Cross-table variant of {@link columnsHaveNonEmptyValueBatch}: the same
+	* uncorrelated-scalar-subquery, per-column `LIMIT 1` shape, but packed
+	* into one row *per query* across every named table's columns instead of
+	* one row per table — the #2878 lever. Chunks at
+	* {@link MAX_CROSS_TABLE_PROBE_COLUMNS} columns per statement so a very
+	* large schema still issues a small, bounded number of round trips
+	* rather than one arbitrarily wide row.
+	*
+	* Falls back to the existing per-table batch (itself falling back
+	* further to per-column) for any chunk whose combined statement fails,
+	* so one bad table never discards another table's detection — the same
+	* failure-isolation guarantee {@link columnsHaveNonEmptyValueBatch}
+	* already gives per-column, extended one level up.
 	*/
-	async allNonEmptyValuesUuidShaped(tableName, colName) {
-		const quotedTable = this.quoteIdentifier(tableName);
-		const quotedCol = this.quoteIdentifier(colName);
-		const nonEmptyPredicate = `${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> ''`;
-		if (this.engine === "postgres") {
-			const row = (await this.db.query(`SELECT count(*) AS invalid_count FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND CAST(${quotedCol} AS TEXT) !~* '${CANONICAL_UUID_PATTERN}'`)).rows?.[0];
-			return Number(row?.invalid_count ?? 0) === 0;
+	async crossTableColumnsHaveNonEmptyValueBatch(tables) {
+		return this.crossTableProbeBatch(tables, (t) => columnsHaveNonEmptyValueBatch(this.db, t.tableName, t.colNames), (quotedTable, quotedCol, alias) => `(SELECT 1 FROM ${quotedTable} WHERE ${nonEmptyValuePredicate(quotedCol)} LIMIT 1) AS ${alias}`, (value) => value != null);
+	}
+	/**
+	* Cross-table variant of {@link columnsAllValuesUuidShapedBatch} — same
+	* shape as {@link crossTableColumnsHaveNonEmptyValueBatch}, engine-aware
+	* invalid-shape predicate included.
+	*/
+	async crossTableColumnsAllValuesUuidShapedBatch(tables) {
+		return this.crossTableProbeBatch(tables, (t) => columnsAllValuesUuidShapedBatch(this.db, this.engine, t.tableName, t.colNames), (quotedTable, quotedCol, alias) => `(SELECT 1 FROM ${quotedTable} WHERE ${nonEmptyValuePredicate(quotedCol)} AND ${uuidInvalidShapePredicate(this.engine, quotedCol)} LIMIT 1) AS ${alias}`, (value) => value == null);
+	}
+	/**
+	* Shared cross-table batching engine for the two probes above. Builds one
+	* `SELECT` per chunk with a scalar subquery per (table, column) pair,
+	* globally aliased `t{tableIndex}_c{colIndex}` — PostgreSQL truncates a
+	* `name` identifier to 63 bytes, so a positional alias is used instead of
+	* the real column name for the same reason the single-table batch does
+	* (#2874 review finding F2'). On a chunk's query failure, that chunk's
+	* tables fall back to the single-table batch path individually (each of
+	* which falls back further to per-column) rather than discarding every
+	* table's result.
+	*
+	* Known lock-footprint change (#2878 final review F2, deferred to
+	* #2887): one chunked statement takes `ACCESS SHARE` on every
+	* table in that chunk *simultaneously*, where the pre-#2878 per-table
+	* probe held at most one table's `ACCESS SHARE` at a time (each
+	* autocommitted statement releases its lock before the next one runs).
+	* That is a materially different PostgreSQL locking pattern: it is now
+	* possible, in principle, for this session to be one side of a deadlock
+	* with a concurrent multi-table DDL transaction (e.g. a `db:migrate` in
+	* flight) in a way the old per-table probe structurally could not be.
+	* PostgreSQL's deadlock detector resolves any such cycle by aborting one
+	* side with a loud `deadlock detected` error — never silently, and never
+	* with partial/corrupt state — so if this session is the victim, the
+	* `catch` above already degrades it to the safe per-table fallback; if
+	* the *other* side (the migration) is the victim, that transaction rolls
+	* back cleanly and is safe to re-run. No test in this repository exercises
+	* concurrent DDL against the probed tables, so this risk is unverified by
+	* suite rather than disproven. Bounding it further — chunking by table
+	* count as well as column count, and/or a short `lock_timeout` on these
+	* statements so this session always yields first — is deferred to #2887
+	* rather than fixed here.
+	*/
+	async crossTableProbeBatch(tables, singleTableFallback, renderSelect, isTrue) {
+		const nonEmpty = tables.filter((t) => t.colNames.length > 0);
+		if (nonEmpty.length === 0) return /* @__PURE__ */ new Map();
+		const slices = [];
+		for (const t of nonEmpty) for (let i = 0; i < t.colNames.length; i += SchemaComparer.MAX_CROSS_TABLE_PROBE_COLUMNS) slices.push({
+			tableName: t.tableName,
+			colNames: t.colNames.slice(i, i + SchemaComparer.MAX_CROSS_TABLE_PROBE_COLUMNS)
+		});
+		const chunks = [];
+		let current = [];
+		let currentWidth = 0;
+		for (const slice of slices) {
+			if (currentWidth + slice.colNames.length > SchemaComparer.MAX_CROSS_TABLE_PROBE_COLUMNS && current.length > 0) {
+				chunks.push(current);
+				current = [];
+				currentWidth = 0;
+			}
+			current.push(slice);
+			currentWidth += slice.colNames.length;
+		}
+		if (current.length > 0) chunks.push(current);
+		const result = /* @__PURE__ */ new Map();
+		for (const chunk of chunks) {
+			const selects = [];
+			const index = [];
+			chunk.forEach((t, ti) => {
+				const quotedTable = this.quoteIdentifier(t.tableName);
+				t.colNames.forEach((colName, ci) => {
+					const quotedCol = this.quoteIdentifier(colName);
+					const alias = `t${ti}_c${ci}`;
+					selects.push(renderSelect(quotedTable, quotedCol, alias));
+					index.push({
+						tableName: t.tableName,
+						colName,
+						alias
+					});
+				});
+			});
+			try {
+				const row = (await this.db.query(`SELECT ${selects.join(", ")}`)).rows?.[0] ?? {};
+				for (const { tableName, colName, alias } of index) {
+					const m = result.get(tableName) ?? /* @__PURE__ */ new Map();
+					m.set(colName, isTrue(row[alias]));
+					result.set(tableName, m);
+				}
+			} catch {
+				for (const t of chunk) {
+					const m = result.get(t.tableName) ?? /* @__PURE__ */ new Map();
+					const fallback = await singleTableFallback(t);
+					for (const [colName, value] of fallback) m.set(colName, value);
+					result.set(t.tableName, m);
+				}
+			}
 		}
-		const row = (await this.db.query(`SELECT count(*) AS invalid_count FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND NOT (LENGTH(CAST(${quotedCol} AS TEXT)) = 36 AND LOWER(CAST(${quotedCol} AS TEXT)) GLOB '${CANONICAL_UUID_SQLITE_GLOB_PATTERN}')`)).rows?.[0];
-		return Number(row?.invalid_count ?? 0) === 0;
+		return result;
 	}
 	/**
 	* Render the repair for one rename-data-pending pair (#2752): copy
@@ -1073,7 +1368,7 @@ var SchemaComparer = class {
 	*   for `integer`/`boolean`/`timestamp`/etc. before a same-type rename
 	*   pair of one of those types ever copies anything. Fixed by comparing
 	*   `CAST(col AS TEXT) = ''` instead, mirroring the same portable
-	*   emptiness check {@link columnHasNonEmptyValue} already uses for
+	*   emptiness check {@link columnsHaveNonEmptyValueBatch} already uses for
 	*   detection, so the predicate is valid for every column type.
 	* - (P2) An `UPDATE` unconditionally naming `oldColumn` fails once that
 	*   column is gone, on either engine, regardless of the DROP's own