@happyvertical/smrt-core 0.51.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,8 +1029,14 @@ 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));
@@ -984,7 +1044,7 @@ var SchemaComparer = class {
 		if (orphanColumnNames.length === 0) return [];
 		const declaredCandidateNames = Object.keys(manifest.columns).filter((colName) => dbSchema.columns[colName]);
 		if (declaredCandidateNames.length === 0) return [];
-		const declaredHasData = await this.columnsHaveNonEmptyValueBatch(tableName, declaredCandidateNames);
+		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) => {
@@ -996,7 +1056,7 @@ var SchemaComparer = class {
 			});
 		});
 		if (compatibleOrphanNames.length === 0) return [];
-		const orphanHasData = await this.columnsHaveNonEmptyValueBatch(tableName, compatibleOrphanNames);
+		const orphanHasData = await columnsHaveNonEmptyValueBatch(this.db, tableName, compatibleOrphanNames);
 		const hasData = new Map([...declaredHasData, ...orphanHasData]);
 		const changes = [];
 		const pending = [];
@@ -1022,7 +1082,7 @@ var SchemaComparer = class {
 				});
 			}
 		}
-		const shaped = shapeCheckOrphans.size > 0 ? await this.columnsAllValuesUuidShapedBatch(tableName, [...shapeCheckOrphans]) : /* @__PURE__ */ new Map();
+		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;
@@ -1038,112 +1098,261 @@ var SchemaComparer = class {
 		return changes;
 	}
 	/**
-	* Live-data probe, batched across every column named: does each hold any
-	* non-null, non-empty value? One round trip regardless of column count
-	* (#2874) — one row of uncorrelated scalar subqueries,
-	* `(SELECT 1 FROM t WHERE ... LIMIT 1) AS "col"`, portable across
-	* PostgreSQL and SQLite. Deliberately *not* an aggregate
-	* (`MAX(CASE WHEN ...)`) over the whole table: an aggregate forces a full
-	* scan for every probed column even when the very first row already
-	* answers it, which would turn a healthy, mostly-populated large table
-	* into a guaranteed full scan on every comparison — worse than the
-	* original per-column probe for exactly the schemas #2874 cares about
-	* (#2874 review finding F1). Each subquery keeps the original
-	* `LIMIT 1` early exit; only the round trip is batched, not the
-	* per-column scan cost.
+	* 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.
 	*
-	* Falls back to {@link columnHasNonEmptyValueSingle} per column when the
-	* batched statement itself fails (a column dropped concurrently, or a
-	* `CAST` the engine rejects) — #2874 review finding F2: a single bad
-	* column must withhold only that column's result, not the whole table's
-	* detection. A column absent from the returned map means "could not be
-	* probed"; callers apply their own fail-closed default.
+	* 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 columnsHaveNonEmptyValueBatch(tableName, colNames) {
-		if (colNames.length === 0) return /* @__PURE__ */ new Map();
-		try {
-			return await this.columnsHaveNonEmptyValueBatchQuery(tableName, colNames);
-		} catch {
-			const hasData = /* @__PURE__ */ new Map();
-			for (const colName of colNames) try {
-				hasData.set(colName, await this.columnHasNonEmptyValueSingle(tableName, colName));
-			} catch {}
-			return hasData;
+	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);
 		}
 	}
-	async columnsHaveNonEmptyValueBatchQuery(tableName, colNames) {
-		const quotedTable = this.quoteIdentifier(tableName);
-		const selects = colNames.map((colName, index) => {
-			const quotedCol = this.quoteIdentifier(colName);
-			return `(SELECT 1 FROM ${quotedTable} WHERE ${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> '' LIMIT 1) AS c${index}`;
-		});
-		const row = (await this.db.query(`SELECT ${selects.join(", ")}`)).rows?.[0] ?? {};
-		const hasData = /* @__PURE__ */ new Map();
-		colNames.forEach((colName, index) => {
-			hasData.set(colName, row[`c${index}`] != null);
-		});
-		return hasData;
+	/**
+	* 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 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);
 	}
-	/** Single-column fallback for {@link columnsHaveNonEmptyValueBatch}. */
-	async columnHasNonEmptyValueSingle(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;
+	/**
+	* 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);
 	}
 	/**
-	* Live-data probe, batched across every orphan column named: are every
-	* one of each column's non-empty values UUID-shaped
-	* ({@link CANONICAL_UUID_PATTERN})? One round trip regardless of column
-	* count (#2874), mirroring {@link columnsHaveNonEmptyValueBatch}: one row
-	* of uncorrelated scalar subqueries, each
-	* `(SELECT 1 FROM t WHERE <non-empty> AND <invalid> LIMIT 1)` — a live
-	* value is absent from the result exactly when no invalid row exists, so
-	* this also short-circuits on the first invalid row rather than counting
-	* every one (an early-exit improvement over the pre-#2874 per-column
-	* `count(*)` probe, not just a batching change). PostgreSQL pushes the
-	* shape check into 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).
+	* 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.
 	*
-	* Falls back to {@link allNonEmptyValuesUuidShapedSingle} per column on a
-	* batch failure, same posture as {@link columnsHaveNonEmptyValueBatch}
-	* (#2874 review finding F2).
+	* 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 columnsAllValuesUuidShapedBatch(tableName, colNames) {
-		if (colNames.length === 0) return /* @__PURE__ */ new Map();
-		try {
-			return await this.columnsAllValuesUuidShapedBatchQuery(tableName, colNames);
-		} catch {
-			const shaped = /* @__PURE__ */ new Map();
-			for (const colName of colNames) try {
-				shaped.set(colName, await this.allNonEmptyValuesUuidShapedSingle(tableName, colName));
-			} catch {}
-			return shaped;
-		}
-	}
-	async columnsAllValuesUuidShapedBatchQuery(tableName, colNames) {
-		const quotedTable = this.quoteIdentifier(tableName);
-		const selects = colNames.map((colName, index) => {
-			const quotedCol = this.quoteIdentifier(colName);
-			const nonEmptyPredicate = `${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> ''`;
-			const invalidPredicate = this.engine === "postgres" ? `CAST(${quotedCol} AS TEXT) !~* '${CANONICAL_UUID_PATTERN}'` : `NOT (LENGTH(CAST(${quotedCol} AS TEXT)) = 36 AND LOWER(CAST(${quotedCol} AS TEXT)) GLOB '${CANONICAL_UUID_SQLITE_GLOB_PATTERN}')`;
-			return `(SELECT 1 FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND ${invalidPredicate} LIMIT 1) AS c${index}`;
-		});
-		const row = (await this.db.query(`SELECT ${selects.join(", ")}`)).rows?.[0] ?? {};
-		const shaped = /* @__PURE__ */ new Map();
-		colNames.forEach((colName, index) => {
-			shaped.set(colName, row[`c${index}`] == null);
+	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)
 		});
-		return shaped;
-	}
-	/** Single-column fallback for {@link columnsAllValuesUuidShapedBatch}. */
-	async allNonEmptyValuesUuidShapedSingle(tableName, colName) {
-		const quotedTable = this.quoteIdentifier(tableName);
-		const quotedCol = this.quoteIdentifier(colName);
-		const nonEmptyPredicate = `${quotedCol} IS NOT NULL AND CAST(${quotedCol} AS TEXT) <> ''`;
-		const invalidPredicate = this.engine === "postgres" ? `CAST(${quotedCol} AS TEXT) !~* '${CANONICAL_UUID_PATTERN}'` : `NOT (LENGTH(CAST(${quotedCol} AS TEXT)) = 36 AND LOWER(CAST(${quotedCol} AS TEXT)) GLOB '${CANONICAL_UUID_SQLITE_GLOB_PATTERN}')`;
-		return ((await this.db.query(`SELECT 1 AS invalid FROM ${quotedTable} WHERE ${nonEmptyPredicate} AND ${invalidPredicate} LIMIT 1`)).rows?.length ?? 0) === 0;
+		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);
+				}
+			}
+		}
+		return result;
 	}
 	/**
 	* Render the repair for one rename-data-pending pair (#2752): copy