@quereus/quereus 4.3.1 → 4.4.0

package/dist/src/vtab/memory/layer/manager.js

@@ -1,16 +1,15 @@
 import { buildColumnIndexMap, columnDefToSchema, resolvePkDefaultConflict, resolveNamedConstraintClass, validateCollationForType } from '../../../schema/table.js';
 import { BTree } from 'inheritree';
 import { StatusCode } from '../../../common/types.js';
-import { BaseLayer } from './base.js';
+import { BaseLayer, iteratePrimaryRows, populateIndexFromRows, populateIndexFromRowsAsync } from './base.js';
 import { TransactionLayer } from './transaction.js';
 import { MemoryTableConnection } from './connection.js';
 import { MemoryVirtualTableConnection } from '../connection.js';
-import { Latches } from '../../../util/latches.js';
 import { QuereusError } from '../../../common/errors.js';
 import { ConflictResolution } from '../../../common/constants.js';
 import { buildUniqueConstraintSchema, buildForeignKeyConstraintSchema, buildCheckConstraintSchema, validateForeignKeyOverExistingRows, maintainedTableUniqueViolationError } from '../../../schema/constraint-builder.js';
-import { uniqueEnforcementCollations } from '../../../schema/unique-enforcement.js';
-import { compareSqlValues, rowsValueIdentical, normalizeCollationName } from '../../../util/comparison.js';
+import { indexEnforcesUnique, uniqueEnforcementCollations } from '../../../schema/unique-enforcement.js';
+import { compareSqlValues, compareSqlValuesFast, rowsValueIdentical, normalizeCollationName } from '../../../util/comparison.js';
 import { scanLayer as scanLayerImpl } from './scan-layer.js';
 import { createPrimaryKeyFunctions, buildPrimaryKeyFromValues } from '../utils/primary-key.js';
 import { createMemoryTableLoggers } from '../utils/logging.js';
@@ -18,6 +17,8 @@ import { tryFoldLiteral } from '../../../parser/utils.js';
 import { validateAndParse } from '../../../types/validation.js';
 import { inferType } from '../../../types/registry.js';
 import { compilePredicate } from '../utils/predicate.js';
+import { renameColumnInIndexPredicates } from '../../../schema/rename-rewriter.js';
+import { MemoryIndex } from '../index.js';
 let tableManagerCounter = 0;
 const logger = createMemoryTableLoggers('layer:manager');
 export class MemoryTableManager {
@@ -31,6 +32,13 @@ export class MemoryTableManager {
     connections = new Map();
     isReadOnly;
     tableSchema;
+    /**
+     * `db.getCollationResolver()`, bound once. Every comparator this manager or its
+     * layers build — primary key, secondary index, UNIQUE enforcement, scan bounds —
+     * resolves names through it, so a collation registered on *this* database is
+     * honored and one registered on no database raises instead of byte-ordering.
+     */
+    collationResolver;
     primaryKeyFunctions;
     /**
      * Implicit covering structures: constraint identity → the auto-index that
@@ -46,6 +54,7 @@ export class MemoryTableManager {
     constructor(db, _moduleName, schemaName, tableName, initialSchema, readOnly = false, eventEmitter) {
         this.managerId = tableManagerCounter++;
         this.db = db;
+        this.collationResolver = db.getCollationResolver();
         this.schemaName = schemaName;
         this._tableName = tableName;
         this.tableSchema = initialSchema;
@@ -63,11 +72,11 @@ export class MemoryTableManager {
             this.ensureUniqueConstraintIndexes();
         }
         this.initializePrimaryKeyFunctions();
-        this.baseLayer = new BaseLayer(this.tableSchema);
+        this.baseLayer = new BaseLayer(this.tableSchema, this.collationResolver);
         this._currentCommittedLayer = this.baseLayer;
     }
     initializePrimaryKeyFunctions() {
-        this.primaryKeyFunctions = createPrimaryKeyFunctions(this.tableSchema);
+        this.primaryKeyFunctions = createPrimaryKeyFunctions(this.tableSchema, this.collationResolver);
     }
     /**
      * One-bit guard on `Schema.kind` (docs/lens.md § Departures): true when this
@@ -324,70 +333,84 @@ export class MemoryTableManager {
             connection.readLayer = this._currentCommittedLayer;
             return;
         }
-        // Capture changes from pendingLayer and any ancestor TransactionLayers
-        // up to (but not including) the currentCommittedLayer. Ancestor layers
-        // in the chain are typically savepoint-promoted in-transaction layers
-        // whose pendingChanges were never emitted (they were never directly
-        // committed). Walking the chain ensures events from earlier writes
-        // in the same transaction aren't dropped just because a SAVEPOINT
-        // promotion swapped the pending layer mid-transaction.
-        const eventChunks = [];
-        {
-            let layer = pendingLayer;
-            while (layer && layer !== this._currentCommittedLayer) {
-                if (layer instanceof TransactionLayer) {
-                    const events = layer.getPendingChanges();
-                    if (events.length > 0)
-                        eventChunks.push(events);
-                }
-                layer = layer.getParent();
-            }
-        }
-        // Chunks are newest-layer-first; reverse to chronological order while
-        // preserving intra-layer event order.
-        const changes = eventChunks.reverse().flat();
         const lockKey = `MemoryTable.Commit:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         logger.debugLog(`[Commit ${connection.connectionId}] Acquired lock for ${this._tableName}`);
         try {
-            // Walk up the parent chain to find if the current committed layer is an ancestor
-            // This handles savepoint chains properly
-            let currentParent = pendingLayer.getParent();
-            let foundCommittedLayer = false;
-            while (currentParent) {
-                if (currentParent === this._currentCommittedLayer) {
-                    foundCommittedLayer = true;
-                    break;
-                }
-                currentParent = currentParent.getParent();
-            }
-            // Also check if the current committed layer and pending layer are siblings
-            // (both children of the same parent) - this handles coordinated multi-connection commits
-            if (!foundCommittedLayer) {
-                const pendingParent = pendingLayer.getParent();
-                let committedAncestor = this._currentCommittedLayer;
-                while (committedAncestor) {
-                    if (committedAncestor === pendingParent) {
-                        foundCommittedLayer = true;
+            // Relate the pending layer's chain to the current committed head.
+            //
+            // Case A — the head is an ancestor of the pending layer: pending forked
+            //   off (a descendant of) the current head, so its chain already
+            //   contains everything committed so far. Publish it wholesale.
+            // Case B — the head advanced past the pending layer's fork point
+            //   (a sibling connection committed a disjoint change to the same table
+            //   in a coordinated multi-connection commit): pending and head share a
+            //   common ancestor — the fork point — that is a *proper* ancestor of
+            //   the head. Rebase pending's own writes onto the head so the sibling's
+            //   already-committed rows are not discarded (the bug this guards).
+            // Case C — no common ancestor reachable: a genuinely stale commit. Roll
+            //   back with BUSY outside a coordinated commit (the caller can retry);
+            //   inside one, preserve the prior wholesale fallback.
+            let headIsAncestorOfPending = false;
+            {
+                let cur = pendingLayer;
+                while (cur) {
+                    if (cur === this._currentCommittedLayer) {
+                        headIsAncestorOfPending = true;
                         break;
                     }
-                    committedAncestor = committedAncestor.getParent();
+                    cur = cur.getParent();
                 }
             }
-            if (!foundCommittedLayer) {
-                // During coordinated multi-connection commits (explicit COMMIT or implicit transaction commit),
-                // sibling layers are allowed. Only enforce strict validation outside coordinated commits.
-                if (!this.db._inCoordinatedCommit()) {
+            let committedLayer;
+            let changes;
+            if (headIsAncestorOfPending) {
+                // Case A: the un-emitted in-transaction event span ends at the head.
+                changes = this.collectPendingChanges(pendingLayer, this._currentCommittedLayer);
+                pendingLayer.markCommitted();
+                committedLayer = pendingLayer;
+            }
+            else {
+                // Find the fork point: the deepest layer present in BOTH chains.
+                const headChain = this.layerChainSet(this._currentCommittedLayer);
+                let forkPoint = pendingLayer.getParent();
+                while (forkPoint && !headChain.has(forkPoint)) {
+                    forkPoint = forkPoint.getParent();
+                }
+                if (forkPoint) {
+                    // Schema drift: an ALTER consolidated the head to a different schema
+                    // since the pending layer forked. Replaying stale-schema rows onto
+                    // the new-schema head is unsafe — abort with BUSY rather than corrupt
+                    // the committed head (mirrors the stale-ancestor caution above).
+                    if (pendingLayer.getSchema() !== this.tableSchema) {
+                        connection.pendingTransactionLayer = null;
+                        connection.clearSavepoints();
+                        logger.warn('Commit Transaction', this._tableName, 'Schema drift under sibling commit, rolling back', { connectionId: connection.connectionId });
+                        throw new QuereusError(`Commit failed: schema changed under transaction on table ${this._tableName}. Retry.`, StatusCode.BUSY);
+                    }
+                    // Case B: rebase. Events come from the same fork-bounded pending-chain
+                    // span; structural writes are replayed onto the advanced head.
+                    changes = this.collectPendingChanges(pendingLayer, forkPoint);
+                    committedLayer = this.rebaseLayerOntoHead(pendingLayer, forkPoint);
+                }
+                else if (!this.db._inCoordinatedCommit()) {
                     connection.pendingTransactionLayer = null;
                     connection.clearSavepoints();
                     logger.warn('Commit Transaction', this._tableName, 'Stale commit detected, rolling back', { connectionId: connection.connectionId });
                     throw new QuereusError(`Commit failed: concurrent update on table ${this._tableName}. Retry.`, StatusCode.BUSY);
                 }
+                else {
+                    // Case C fallback inside a coordinated commit: no safe rebase target,
+                    // but aborting would roll back every connection. Preserve the prior
+                    // wholesale publish.
+                    changes = this.collectPendingChanges(pendingLayer, this._currentCommittedLayer);
+                    pendingLayer.markCommitted();
+                    committedLayer = pendingLayer;
+                }
             }
-            pendingLayer.markCommitted();
-            this._currentCommittedLayer = pendingLayer;
-            logger.debugLog(`[Commit ${connection.connectionId}] CurrentCommittedLayer set to ${pendingLayer.getLayerId()} for ${this._tableName}`);
-            connection.readLayer = pendingLayer;
+            this._currentCommittedLayer = committedLayer;
+            logger.debugLog(`[Commit ${connection.connectionId}] CurrentCommittedLayer set to ${committedLayer.getLayerId()} for ${this._tableName}`);
+            connection.readLayer = committedLayer;
             connection.pendingTransactionLayer = null;
             connection.clearSavepoints();
             // Emit data change events after successful commit
@@ -414,11 +437,92 @@ export class MemoryTableManager {
             logger.debugLog(`[Commit ${connection.connectionId}] Released lock for ${this._tableName}`);
         }
     }
+    /** All layers in `layer`'s parent chain, including `layer` itself. */
+    layerChainSet(layer) {
+        const chain = new Set();
+        let cur = layer;
+        while (cur) {
+            chain.add(cur);
+            cur = cur.getParent();
+        }
+        return chain;
+    }
+    /**
+     * Collect pending change events from `fromLayer` up to (but not including)
+     * `boundary`, in chronological order (oldest layer first, intra-layer order
+     * preserved). Mirrors the in-transaction event span whose writes are being
+     * committed: savepoint-promoted ancestor layers whose events were never
+     * directly emitted are included; already-committed layers at/below the
+     * boundary are not (their events were emitted when they committed).
+     */
+    collectPendingChanges(fromLayer, boundary) {
+        const eventChunks = [];
+        let layer = fromLayer;
+        while (layer && layer !== boundary) {
+            if (layer instanceof TransactionLayer) {
+                const events = layer.getPendingChanges();
+                if (events.length > 0)
+                    eventChunks.push(events);
+            }
+            layer = layer.getParent();
+        }
+        // Chunks are newest-layer-first; reverse to chronological order while
+        // preserving intra-layer event order.
+        return eventChunks.reverse().flat();
+    }
+    /**
+     * Rebase a pending layer onto the current committed head after a sibling
+     * connection advanced the head past this layer's fork point. Replays the
+     * pending chain's own structural writes (pending + in-transaction ancestors
+     * down to, but not including, `forkPoint`) onto a fresh {@link TransactionLayer}
+     * parented on the head, so the sibling's already-committed rows survive.
+     *
+     * The head becomes the new layer's base, so every row the sibling committed is
+     * inherited automatically; only this branch's own writes are replayed on top.
+     */
+    rebaseLayerOntoHead(pendingLayer, forkPoint) {
+        // Gather own-writes from pendingLayer up to (excluding) the fork point.
+        // Chunks are newest-layer-first; reverse so the oldest layer replays first.
+        const writeChunks = [];
+        let layer = pendingLayer;
+        while (layer && layer !== forkPoint) {
+            if (layer instanceof TransactionLayer) {
+                writeChunks.push(layer.getOwnWrites());
+            }
+            layer = layer.getParent();
+        }
+        const ownWrites = writeChunks.reverse().flat();
+        const rebased = new TransactionLayer(this._currentCommittedLayer);
+        if (this.eventEmitter?.hasDataListeners?.()) {
+            rebased.enableChangeTracking();
+        }
+        for (const write of ownWrites) {
+            // Re-derive the effective row at this PK on the NEW head (including
+            // earlier replays in this loop) and pass it as the old row, so
+            // secondary-index maintenance removes the correct pre-existing entry.
+            // NOTE: a primary key OR a secondary-UNIQUE value written by BOTH
+            // siblings resolves last-writer-wins to the rebasing writer's row —
+            // every non-contended key from both siblings survives. recordUpsert is
+            // the raw structural write and does not re-run checkUniqueConstraints, so
+            // a UNIQUE collision existing only BETWEEN the two siblings' rows is not
+            // detected here. This matches the memory manager's read-your-own-writes
+            // model (snapshot-isolation conflict detection lives in quereus-isolation).
+            const effective = this.lookupEffectiveRow(write.primaryKey, rebased);
+            if (write.type === 'upsert') {
+                rebased.recordUpsert(write.primaryKey, write.newRow, effective);
+            }
+            else if (effective) {
+                rebased.recordDelete(write.primaryKey, effective);
+            }
+        }
+        rebased.markCommitted();
+        return rebased;
+    }
     async tryCollapseLayers() {
         const lockKey = `MemoryTable.Collapse:${this.schemaName}.${this._tableName}`;
         let release = null;
         try {
-            const acquirePromise = Latches.acquire(lockKey);
+            const acquirePromise = this.db.latches.acquire(lockKey);
             const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), 10)); // Short timeout
             const result = await Promise.race([
                 acquirePromise.then(releaseFn => ({ release: releaseFn })),
@@ -466,9 +570,7 @@ export class MemoryTableManager {
                 // by examining if this layer can be promoted above its (now detached) parent
                 logger.debugLog(`[Collapse] Layer ${layerToPromote.getLayerId()} is now independent for ${this._tableName}`);
             }
-            // Trigger garbage collection of unreferenced layers
             if (collapsedCount > 0) {
-                void this.cleanupUnreferencedLayers();
                 logger.operation('Collapse Layers', this._tableName, { collapsedCount, iterations });
             }
             else {
@@ -517,26 +619,6 @@ export class MemoryTableManager {
         }
         return false;
     }
-    /**
-     * Performs garbage collection of layers that are no longer referenced
-     * by any connections or the current committed layer chain.
-     */
-    cleanupUnreferencedLayers() {
-        // For now, this is a no-op since JavaScript's garbage collector
-        // will handle cleanup of unreferenced objects automatically.
-        // In the future, we could implement more aggressive cleanup
-        // or tracking of layer references for memory monitoring.
-        logger.debugLog(`[Cleanup] Triggering garbage collection hint for ${this._tableName}`);
-        // Optional: Force garbage collection if available (Node.js with --expose-gc)
-        if (typeof global !== 'undefined' && global.gc) {
-            try {
-                global.gc();
-            }
-            catch {
-                // Ignore errors - gc() might not be available
-            }
-        }
-    }
     // With inherited BTrees, lookupEffectiveRow is much simpler
     lookupEffectiveRow(primaryKey, startLayer) {
         // With inherited BTrees, a simple get() will traverse the inheritance chain automatically
@@ -767,7 +849,7 @@ export class MemoryTableManager {
                 // which columns can transition the row across the predicate's scope.
                 const referenced = covering?.kind === 'memory-index'
                     ? covering.index.predicate?.referencedColumns
-                    : compilePredicate(uc.predicate, schema.columns).referencedColumns;
+                    : compilePredicate(uc.predicate, schema.columns, schema.name).referencedColumns;
                 if (referenced) {
                     for (const colIdx of referenced) {
                         if (compareSqlValues(oldRow[colIdx], newRow[colIdx]) !== 0)
@@ -813,7 +895,7 @@ export class MemoryTableManager {
         }
         if (covering?.kind === 'materialized-view'
             && uc.predicate
-            && compilePredicate(uc.predicate, schema.columns).evaluate(newRowData) !== true) {
+            && compilePredicate(uc.predicate, schema.columns, schema.name).evaluate(newRowData) !== true) {
             return null;
         }
         // Resolve effective action: statement OR > constraint default > ABORT.
@@ -901,6 +983,13 @@ export class MemoryTableManager {
     checkUniqueViaIndex(targetLayer, schema, uc, index, newRowData, newPrimaryKey, onConflict, evicted) {
         const indexKey = index.keyFromRow(newRowData);
         const existingPKs = index.getPrimaryKeys(indexKey);
+        // The overwhelmingly common insert has no candidate at all; bail before paying
+        // for the collation resolves below.
+        if (existingPKs.length === 0)
+            return null;
+        // Resolve the per-column enforcement collations once, ahead of the candidate loop
+        // (which collation governs, and why, is spelled out at the compare below).
+        const enforcementCollations = uc.columns.map((col, i) => this.collationResolver(index.specColumns[i]?.collation ?? schema.columns[col].collation ?? 'BINARY'));
         for (const existingPK of existingPKs) {
             if (this.comparePrimaryKeys(newPrimaryKey, existingPK) === 0)
                 continue;
@@ -939,7 +1028,7 @@ export class MemoryTableManager {
             const conflictingRow = this.lookupEffectiveRow(existingPK, targetLayer);
             if (!conflictingRow)
                 continue;
-            if (!uc.columns.every((col, i) => compareSqlValues(newRowData[col], conflictingRow[col], index.specColumns[i]?.collation ?? schema.columns[col].collation) === 0))
+            if (!uc.columns.every((col, i) => compareSqlValuesFast(newRowData[col], conflictingRow[col], enforcementCollations[i]) === 0))
                 continue;
             if (index.predicate && !index.rowMatchesPredicate(conflictingRow))
                 continue;
@@ -995,7 +1084,7 @@ export class MemoryTableManager {
         // index-derived UNIQUE whose declared candidate set could be a subset is declined
         // upstream by findRowTimeCoveringStructure's collation gate, so only BINARY-floor
         // or equal-collation MVs ever reach here.
-        const collations = uniqueEnforcementCollations(schema, uc);
+        const collations = uniqueEnforcementCollations(schema, uc).map(name => this.collationResolver(name ?? 'BINARY'));
         for (const conflict of conflicts) {
             const existingPK = buildPrimaryKeyFromValues(conflict.pk, schema.primaryKeyDefinition);
             if (this.comparePrimaryKeys(newPrimaryKey, existingPK) === 0)
@@ -1004,7 +1093,7 @@ export class MemoryTableManager {
             const conflictingRow = this.lookupEffectiveRow(existingPK, targetLayer);
             if (!conflictingRow)
                 continue;
-            if (!uc.columns.every((col, i) => compareSqlValues(newRowData[col], conflictingRow[col], collations[i]) === 0))
+            if (!uc.columns.every((col, i) => compareSqlValuesFast(newRowData[col], conflictingRow[col], collations[i]) === 0))
                 continue;
             if (onConflict === ConflictResolution.IGNORE) {
                 return { status: 'ok', row: undefined };
@@ -1032,8 +1121,10 @@ export class MemoryTableManager {
         // Compile partial-UNIQUE predicate ad-hoc (cold path: an auto-index normally
         // services this check, so this branch fires only for pathological schemas).
         const predicate = uc.predicate
-            ? compilePredicate(uc.predicate, schema.columns)
+            ? compilePredicate(uc.predicate, schema.columns, schema.name)
             : undefined;
+        // One resolve per column, not per scanned row.
+        const collations = uc.columns.map(colIdx => this.collationResolver(schema.columns[colIdx].collation ?? 'BINARY'));
         for (const path of primaryTree.ascending(primaryTree.first())) {
             const existingRow = primaryTree.at(path);
             const existingPK = this.primaryKeyFromRow(existingRow);
@@ -1041,7 +1132,7 @@ export class MemoryTableManager {
                 continue;
             if (predicate && predicate.evaluate(existingRow) !== true)
                 continue;
-            const allMatch = uc.columns.every(colIdx => compareSqlValues(newRowData[colIdx], existingRow[colIdx], schema.columns[colIdx].collation) === 0);
+            const allMatch = uc.columns.every((colIdx, i) => compareSqlValuesFast(newRowData[colIdx], existingRow[colIdx], collations[i]) === 0);
             if (!allMatch)
                 continue;
             if (onConflict === ConflictResolution.IGNORE) {
@@ -1121,13 +1212,13 @@ export class MemoryTableManager {
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         }
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         try {
             // Drain any in-flight transaction layers down to the base so the swap
             // below isn't shadowed by a committed transaction layer ahead of base.
             await this.ensureSchemaChangeSafety();
             const oldBase = this.baseLayer;
-            const newBase = new BaseLayer(this.tableSchema);
+            const newBase = new BaseLayer(this.tableSchema, this.collationResolver);
             for (const row of rows) {
                 const key = this.primaryKeyFunctions.extractFromRow(row);
                 const path = newBase.primaryTree.find(key);
@@ -1240,7 +1331,7 @@ export class MemoryTableManager {
                     // Collect-then-delete avoids mutating the tree mid-iteration.
                     const scanPlan = { indexName: 'primary', descending: false, equalityPrefix: op.keyPrefix };
                     const matched = [];
-                    for await (const row of scanLayerImpl(layer, scanPlan)) {
+                    for (const row of scanLayerImpl(layer, scanPlan)) {
                         matched.push({ key: this.primaryKeyFunctions.extractFromRow(row), row });
                     }
                     for (const { key, row } of matched) {
@@ -1262,7 +1353,7 @@ export class MemoryTableManager {
                     // delete that would leak secondary-index bookkeeping. VALUE fidelity of a paired
                     // row is byte-faithful (`rowsValueIdentical`, below) — one discipline, not two.
                     const oldByKey = new BTree(e => e.key, this.comparePrimaryKeys);
-                    for await (const row of scanLayerImpl(layer, { indexName: 'primary', descending: false })) {
+                    for (const row of scanLayerImpl(layer, { indexName: 'primary', descending: false })) {
                         oldByKey.insert({ key: this.primaryKeyFunctions.extractFromRow(row), row });
                     }
                     // New-row keys (same PK comparator) for the delete pass's membership test.
@@ -1313,7 +1404,7 @@ export class MemoryTableManager {
      * Declared secondary-UNIQUE enforcement for maintenance writes — the
      * collision-shaped half of the derived-row constraint contract (CHECK / FK
      * are per-row properties and validate engine-side; see
-     * docs/materialized-views.md § Derived-row constraint validation). The
+     * docs/mv-constraints.md § Derived-row constraint validation). The
      * privileged surface bypasses the DML constraint pipeline, so without this
      * the batch above would store two derived rows colliding on a declared
      * UNIQUE silently.
@@ -1366,7 +1457,7 @@ export class MemoryTableManager {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
@@ -1377,7 +1468,7 @@ export class MemoryTableManager {
             // COLLATE, matching the CREATE path (and the differ's resolved-COLLATE emission) so
             // an ADD-COLUMN-ed text column gets the same collation a CREATE-d one would.
             // resolveDefaultCollation falls non-text types back to BINARY automatically.
-            const newColumnSchema = columnDefToSchema(columnDefAst, defaultNotNull, this.db.options.getStringOption('default_collation'));
+            const newColumnSchema = columnDefToSchema(columnDefAst, defaultNotNull, this.db.options.getStringOption('default_collation'), (n) => this.db.isCollationRegistered(n));
             if (this.tableSchema.columns.some(c => c.name.toLowerCase() === newColumnSchema.name.toLowerCase())) {
                 throw new QuereusError(`Duplicate column name: ${newColumnSchema.name}`, StatusCode.ERROR);
             }
@@ -1445,7 +1536,7 @@ export class MemoryTableManager {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
@@ -1536,8 +1627,11 @@ export class MemoryTableManager {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
+        const schemaManager = this.db.schemaManager;
+        const resolveColumnInSource = (s, t, col) => schemaManager.getSchema(s)?.getTable(t)?.columnIndexMap.has(col.toLowerCase()) ?? false;
+        let predicatesRewritten = false;
         try {
             await this.ensureSchemaChangeSafety();
             const oldNameLower = oldName.toLowerCase();
@@ -1552,7 +1646,7 @@ export class MemoryTableManager {
             // Get default nullability setting from database options
             const defaultNullability = this.db.options.getStringOption('default_column_nullability');
             const defaultNotNull = defaultNullability === 'not_null';
-            const newColumnSchemaAtIndex = columnDefToSchema(newColumnDefAst, defaultNotNull);
+            const newColumnSchemaAtIndex = columnDefToSchema(newColumnDefAst, defaultNotNull, 'BINARY', (n) => this.db.isCollationRegistered(n));
             const updatedCols = this.tableSchema.columns.map((c, i) => i === colIndex ? newColumnSchemaAtIndex : c);
             const updatedIndexes = (this.tableSchema.indexes || []).map(idx => ({
                 ...idx,
@@ -1565,6 +1659,28 @@ export class MemoryTableManager {
                 primaryKeyDefinition: Object.freeze(this.tableSchema.primaryKeyDefinition),
                 indexes: Object.freeze(updatedIndexes),
             });
+            // Rewrite partial-index predicates into the new column name BEFORE the
+            // rebuild that `handleColumnRename()` triggers: `createSecondaryIndexes`
+            // compiles each predicate against the new column list, so a `WHERE` still
+            // naming the old column cannot build.
+            //
+            // The window is narrow. `ensureSchemaChangeSafety()` above consolidates the
+            // transaction layers into the base and rebuilds every secondary index against
+            // the OLD column list — an already-rewritten predicate would break that. So
+            // the rewrite belongs here and nowhere earlier (in particular, not before the
+            // engine calls `module.alterTable`).
+            //
+            // In place, so the catalog's `TableSchema` and a unique partial index's derived
+            // UNIQUE constraint — which share the `Expression` by reference — follow along.
+            // `propagateColumnRename` re-runs the same rewrite once the engine regains
+            // control and finds nothing left to do.
+            // Armed BEFORE the call, not from its return value: the rewrite walks the
+            // indexes one at a time, so a throw partway through would otherwise leave the
+            // already-rewritten predicates renamed with the flag still false. The reverse
+            // pass is a no-op when nothing names `newColumnName`, so arming it eagerly
+            // costs nothing when the rewrite finds no predicate to touch.
+            predicatesRewritten = true;
+            renameColumnInIndexPredicates(finalNewTableSchema.indexes, this._tableName, oldName, newColumnName, this.schemaName, resolveColumnInSource);
             this.baseLayer.updateSchema(finalNewTableSchema);
             await this.baseLayer.handleColumnRename();
             this.tableSchema = finalNewTableSchema;
@@ -1581,6 +1697,12 @@ export class MemoryTableManager {
             logger.operation('Rename Column', this._tableName, { oldName, newName: newColumnName });
         }
         catch (e) {
+            // The predicate ASTs are shared with the catalog's TableSchema, so restoring
+            // `originalManagerSchema` does not undo the rewrite — run it in reverse. The
+            // flag keeps a failure raised *before* the rewrite from un-renaming anything.
+            if (predicatesRewritten) {
+                renameColumnInIndexPredicates(originalManagerSchema.indexes, this._tableName, newColumnDefAst.name, oldName, this.schemaName, resolveColumnInSource);
+            }
             this.baseLayer.updateSchema(originalManagerSchema);
             this.tableSchema = originalManagerSchema;
             this.initializePrimaryKeyFunctions();
@@ -1596,12 +1718,14 @@ export class MemoryTableManager {
      * The caller supplies exactly one populated change; multi-attribute combinations
      * are rejected by the runtime before reaching this method.
      */
-    async alterColumn(change) {
+    async alterColumn(change, rows) {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
+        /** The base primary tree `rebuildPrimaryTreeStrict` replaced, for the catch's rollback. */
+        let basePrimaryTreeBeforeRekey = null;
         try {
             await this.ensureSchemaChangeSafety();
             const colNameLower = change.columnName.toLowerCase();
@@ -1614,8 +1738,18 @@ export class MemoryTableManager {
             // A collation change re-keys any PK / UNIQUE / index that orders by this
             // column, so it needs the structure re-sort + uniqueness re-validation below.
             let collationChanged = false;
+            // Set to the per-value conversion function when a physical value rewrite is needed:
+            // SET DATA TYPE (retype every value) or SET NOT NULL backfill (map null → DEFAULT).
+            // Both REPLACE the base primary tree with a freshly-built one (never an in-place
+            // mutation, which inheritree forbids while the open transaction's layers derive from
+            // it) and convert the transaction's own-written rows in every open layer, after
+            // `updateSchema` (see the rebuild section and convertColumnOnOpenLayers).
+            let valueConvert = null;
+            // SET NOT NULL backfill also routes NULL values through `valueConvert`; SET DATA TYPE
+            // leaves nulls untouched. Selects the null-including path in convertBaseRows/convertColumn.
+            let convertNulls = false;
             if (change.setCollation !== undefined) {
-                const normalized = validateCollationForType(change.setCollation, oldCol.logicalType, change.columnName);
+                const normalized = validateCollationForType(change.setCollation, oldCol.logicalType, change.columnName, (n) => this.db.isCollationRegistered(n));
                 const nameMatches = normalized === (oldCol.collation || 'BINARY');
                 if (nameMatches && oldCol.collationExplicit) {
                     return; // already explicit in the desired collation — nothing to do
@@ -1634,30 +1768,43 @@ export class MemoryTableManager {
             }
             else if (change.setNotNull !== undefined) {
                 if (change.setNotNull === true && !oldCol.notNull) {
-                    // Tightening: scan for NULLs. If DEFAULT present, backfill first.
+                    // Tightening: scan the DDL transaction's EFFECTIVE rows for NULLs — committed rows
+                    // overlaid with this transaction's own pending writes — exactly as the setDataType
+                    // arm does. A pending NULL the transaction can SEE rejects the ALTER; one only in a
+                    // row it has DELETED does not block it. `rows` is the wrapper-supplied effective set
+                    // (the isolation overlay); when absent, effectiveDdlRows() is the layered view.
                     const defaultExpr = oldCol.defaultValue;
-                    let defaultLiteral;
-                    if (defaultExpr) {
-                        defaultLiteral = tryFoldLiteral(defaultExpr);
+                    const defaultLiteral = defaultExpr ? tryFoldLiteral(defaultExpr) : undefined;
+                    let anyNull = false;
+                    if (rows) {
+                        for await (const row of rows()) {
+                            if (row[colIndex] === null) {
+                                anyNull = true;
+                                break;
+                            }
+                        }
                     }
-                    const tree = this.baseLayer.primaryTree;
-                    const nullRows = [];
-                    for (const path of tree.ascending(tree.first())) {
-                        const row = tree.at(path);
-                        if (row[colIndex] === null)
-                            nullRows.push(row);
+                    else {
+                        for (const row of this.effectiveDdlRows()) {
+                            if (row[colIndex] === null) {
+                                anyNull = true;
+                                break;
+                            }
+                        }
                     }
-                    if (nullRows.length > 0) {
+                    if (anyNull) {
                         if (defaultLiteral === undefined || defaultLiteral === null) {
                             throw new QuereusError(`column ${change.columnName} contains NULL values`, StatusCode.CONSTRAINT);
                         }
-                        // Backfill NULLs with the default literal.
-                        for (const row of nullRows) {
-                            const newRow = row.map((v, i) => i === colIndex ? defaultLiteral : v);
-                            // replace in-place: same PK, mutate row array. BTree keys by PK extraction,
-                            // so overwriting the value at the same key is sufficient.
-                            tree.insert(newRow);
-                        }
+                        // Backfill: map null → the folded DEFAULT literal, routed through the SAME
+                        // base-replacement + open-layer conversion machinery setDataType uses — no
+                        // logical-type change, no PK re-key, no in-place base mutation. The old in-place
+                        // `tree.upsert` backfill could not fill the transaction's pending rows (they live
+                        // in the pending layer, not the base) and mutated a base the open layers derive
+                        // from — both fixed by the unified path.
+                        const literal = defaultLiteral;
+                        valueConvert = (v) => (v === null ? literal : v);
+                        convertNulls = true;
                     }
                     newCol = { ...oldCol, notNull: true };
                 }
@@ -1678,27 +1825,49 @@ export class MemoryTableManager {
                     newCol = { ...oldCol, logicalType: newLogicalType };
                 }
                 else {
-                    // Physical conversion required. Iterate rows and convert.
-                    const tree = this.baseLayer.primaryTree;
-                    const toConvert = [];
-                    for (const path of tree.ascending(tree.first())) {
-                        const row = tree.at(path);
-                        toConvert.push({ path, row });
+                    // Retyping a PRIMARY KEY column changes the physical key bytes. The in-place
+                    // base rewrite below cannot re-key the primary tree (an upsert of a row whose
+                    // PK value changed physical type lands at a NEW key, orphaning the old entry),
+                    // and the transaction-layer conversion deliberately leaves every layer's primary
+                    // tree keyed as-is. Reject rather than corrupt it — the type-change analogue of
+                    // the SET COLLATE primary-key carve-out (`alter-collate-pk-in-transaction`).
+                    if (this.tableSchema.primaryKeyDefinition.some(def => def.index === colIndex)) {
+                        throw new QuereusError(`Cannot change the data type of primary key column '${change.columnName}' of table '${this._tableName}'.`, StatusCode.CONSTRAINT);
                     }
-                    for (const { row } of toConvert) {
-                        const oldVal = row[colIndex];
-                        if (oldVal === null)
-                            continue;
-                        let newVal;
+                    const convert = (v) => {
                         try {
-                            newVal = validateAndParse(oldVal, newLogicalType, change.columnName);
+                            return validateAndParse(v, newLogicalType, change.columnName);
                         }
                         catch {
                             throw new QuereusError(`Cannot convert value in '${change.columnName}' to ${change.setDataType}`, StatusCode.MISMATCH);
                         }
-                        const newRow = row.map((v, i) => i === colIndex ? newVal : v);
-                        tree.insert(newRow);
+                    };
+                    // Validate BEFORE any mutation, over the DDL transaction's EFFECTIVE rows
+                    // (committed rows overlaid with this transaction's own pending writes): an
+                    // unconvertible value the transaction can SEE rejects the ALTER, and one only in
+                    // a row it has DELETED does not block it. A throw here leaves the schema, the base
+                    // and the transaction untouched. `rows` is the wrapper-supplied effective set (the
+                    // isolation overlay); when absent, `effectiveDdlRows()` is the layered view.
+                    if (rows) {
+                        for await (const row of rows()) {
+                            const val = row[colIndex];
+                            if (val !== null)
+                                convert(val);
+                        }
                     }
+                    else {
+                        for (const row of this.effectiveDdlRows()) {
+                            const val = row[colIndex];
+                            if (val !== null)
+                                convert(val);
+                        }
+                    }
+                    // The base rows are converted below, AFTER `updateSchema`, by REPLACING the base
+                    // primary tree with a fresh one (see the `valueConvert` branch) — never by an
+                    // in-place mutation, which inheritree forbids while the open transaction's layers
+                    // derive from that tree (`MutatedBaseError`). `valueConvert` drives both the base
+                    // replacement and the transaction-layer conversion.
+                    valueConvert = convert;
                     newCol = { ...oldCol, logicalType: newLogicalType };
                 }
             }
@@ -1727,20 +1896,89 @@ export class MemoryTableManager {
                 primaryKeyDefinition: Object.freeze(updatedPkDef),
                 indexes: updatedIndexes ? Object.freeze(updatedIndexes) : updatedIndexes,
             });
+            const pkColumnRekeyed = collationChanged && updatedPkDef.some(def => def.index === colIndex);
+            // Validate BEFORE any mutation, over the DDL transaction's EFFECTIVE rows: a pair
+            // the transaction inserted that collides under the NEW collation must reject the
+            // change, and one it has deleted must not block it. A throw here leaves the schema,
+            // the base layer and the index map exactly as they were.
+            //
+            // The primary key gets a stricter pre-pass (`validateRekeyedPrimaryKey`): no layer in
+            // the chain, base included, may hold a collision. That is what lets every step below
+            // succeed unconditionally, and what `TransactionLayer.rekeyPrimaryKey` relies on.
+            if (collationChanged) {
+                await this.validateRekeyedUniqueStructures(finalNewTableSchema, colIndex, rows);
+                // NOTE: `validateRekeyedPrimaryKey` deliberately ignores `rows`. It asserts that no
+                // LAYER of this manager's own chain holds a PK collision under the new comparator —
+                // a physical property of the structures it is about to re-key, which a wrapper's
+                // merged row stream cannot speak to. A wrapper's staged rows live in the wrapper's
+                // own overlay, which enforces the PK itself, so the pair "one staged row + one
+                // committed row that collide only under the new collation" is checked by neither
+                // side. Rejecting it here would need the wrapper to expose its overlay's PK set, not
+                // just its merged rows.
+                if (pkColumnRekeyed)
+                    this.validateRekeyedPrimaryKey(finalNewTableSchema);
+            }
             this.baseLayer.updateSchema(finalNewTableSchema);
-            // A collation change re-sorts structures that order by the column and
-            // re-validates uniqueness under the new collation. Rebuild the secondary
-            // indexes FIRST (strict — a UNIQUE collision throws CONSTRAINT) and the
-            // primary tree LAST (also strict — a PK collision throws), so a throw at
-            // either step leaves the live primary tree intact for the catch's rollback.
+            // A collation change re-sorts the structures that order by the column. The
+            // secondary rebuild is NON-enforcing (the pre-pass above owns uniqueness, and the
+            // base's rows are not a subset of the effective rows); the primary tree rebuild is
+            // strict, since a PK collision cannot be represented at all — the pre-pass has
+            // already proved the base collision-free, so the strict rebuild is a live invariant
+            // check, not the enforcement path. It runs LAST so its throw leaves the live tree
+            // intact for the catch's rollback.
             if (collationChanged) {
-                this.baseLayer.rebuildAllSecondaryIndexesStrict();
-                if (updatedPkDef.some(def => def.index === colIndex)) {
+                this.baseLayer.rebuildAllSecondaryIndexes();
+                if (pkColumnRekeyed) {
+                    basePrimaryTreeBeforeRekey = this.baseLayer.primaryTree;
                     this.baseLayer.rebuildPrimaryTreeStrict();
                 }
             }
+            else if (valueConvert) {
+                // SET DATA TYPE / SET NOT NULL backfill: convert the committed base rows and REPLACE
+                // the primary tree with a fresh one holding them (not an in-place upsert — inheritree
+                // forbids mutating a base while the open transaction's layers derive from it).
+                // `rebuildPrimaryTreeFromRows` also rebuilds every secondary index from the converted
+                // rows, so index-backed lookups see the new values. The old tree is saved for the
+                // catch's rollback, exactly as the PK-rekey path does.
+                // NOTE: rebuilds EVERY secondary index, not only those covering the altered column;
+                // if a wide-index table ever shows this as slow, filter to indexes whose columns
+                // include colIndex. Mirrors the collationChanged path's unconditional rebuild.
+                //
+                // SET DATA TYPE: a base value that fails to convert is kept as-is — validation over
+                // the effective view already rejected any unconvertible value the transaction can SEE,
+                // so a surviving one is shadowed by a pending delete/overwrite and is never read back
+                // (a ROLLBACK re-exposes it under the new type — DDL is not undone by rollback, the
+                // known behavior of `feat-ddl-transaction-capability`).
+                // SET NOT NULL (`convertNulls`): null base values are mapped to the DEFAULT literal.
+                const convertedBaseRows = this.convertBaseRows(colIndex, valueConvert, convertNulls);
+                basePrimaryTreeBeforeRekey = this.baseLayer.primaryTree;
+                this.baseLayer.rebuildPrimaryTreeFromRows(convertedBaseRows);
+            }
             this.tableSchema = finalNewTableSchema;
             this.initializePrimaryKeyFunctions();
+            // The base rebuild handed every secondary index a fresh tree under the new
+            // collation; the DDL transaction's own layers still inherit the old ones and froze
+            // the old schema at construction. Re-key them, or the rest of the transaction — and
+            // everything after the pending layer becomes the committed head at commit — keeps
+            // comparing under the old collation.
+            //
+            // When the altered column is part of the primary key, `rebuildPrimaryTreeStrict` also
+            // swapped the base primary tree object out from under those layers' copy-on-write
+            // bases and invalidated their `pkFunctions`; `rekeyPrimaryKey` rebuilds both, plus
+            // every secondary index (each derives its PK comparator/encoder from the PK
+            // definition). Outside a transaction there are no open layers and both are no-ops.
+            if (collationChanged) {
+                this.adoptSchemaOnOpenLayers(finalNewTableSchema, pkColumnRekeyed);
+            }
+            else if (valueConvert) {
+                // SET DATA TYPE / SET NOT NULL backfill converted the base above; the DDL
+                // transaction's own open layers still froze the old schema and hold their own-written
+                // rows unconverted. Swap the schema and convert those values so the rest of the
+                // transaction — and the committed head at commit — read the new value. For SET NOT
+                // NULL this fills the transaction's OWN pending NULL rows (which live in the pending
+                // layer, never reached by the old in-place base upsert). No-op in autocommit.
+                this.convertColumnOnOpenLayers(finalNewTableSchema, colIndex, valueConvert, convertNulls);
+            }
             this.eventEmitter?.emitSchemaChange?.({
                 type: 'alter',
                 objectType: 'column',
@@ -1751,11 +1989,21 @@ export class MemoryTableManager {
             logger.operation('Alter Column', this._tableName, { columnName: change.columnName });
         }
         catch (e) {
-            // Restore the prior schema, then rebuild secondary indexes (non-strict) so
-            // a partially-cleared strict rebuild can't strand the index map in an
-            // inconsistent state. The primary tree is only swapped on full success, so
-            // it is already the original here.
+            // Restore the prior schema and primary tree, then re-key the secondary indexes back
+            // to it. Both pre-passes now run before any mutation, so nothing below `updateSchema`
+            // is expected to throw; the restores are the safety net for an unexpected one (and
+            // for `rebuildPrimaryTreeStrict`'s invariant check, whose precondition
+            // `validateRekeyedPrimaryKey` has already established).
+            //
+            // NOTE: a throw from a pre-pass (or from `setNotNull`'s NULL scan) mutated nothing,
+            // so this rebuild only swaps the base's index trees for fresh, content-identical
+            // ones — an O(rows) cost on a pure rejection. Harmless (a pending layer keeps
+            // reading its orphaned but content-correct copy-on-write base), but if a rejected
+            // ALTER on a large table ever shows up as slow, gate the rebuild on a "mutation
+            // started" flag set just before `updateSchema`.
             this.baseLayer.updateSchema(originalManagerSchema);
+            if (basePrimaryTreeBeforeRekey)
+                this.baseLayer.primaryTree = basePrimaryTreeBeforeRekey;
             this.baseLayer.rebuildAllSecondaryIndexes();
             this.tableSchema = originalManagerSchema;
             this.initializePrimaryKeyFunctions();
@@ -1766,11 +2014,11 @@ export class MemoryTableManager {
             release();
         }
     }
-    async createIndex(newIndexSchemaEntry, ifNotExistsFromAst) {
+    async createIndex(newIndexSchemaEntry, ifNotExistsFromAst, rows) {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
@@ -1787,6 +2035,13 @@ export class MemoryTableManager {
                     throw new QuereusError(`Column index ${iCol.index} for index '${indexName}' is out of bounds for table '${this._tableName}'.`, StatusCode.ERROR);
                 }
             }
+            // Validate BEFORE any mutation, over the DDL transaction's EFFECTIVE rows — a
+            // duplicate the transaction inserted but has not committed must reject the build,
+            // and one it has deleted must not. A throw here leaves schema, base layer and
+            // index map exactly as they were.
+            if (newIndexSchemaEntry.unique) {
+                await this.validateUniqueOverEffectiveRows(newIndexSchemaEntry, this.tableSchema, rows);
+            }
             const updatedIndexes = Object.freeze([...(this.tableSchema.indexes || []), newIndexSchemaEntry]);
             let updatedUniqueConstraints = this.tableSchema.uniqueConstraints;
             if (newIndexSchemaEntry.unique) {
@@ -1809,6 +2064,9 @@ export class MemoryTableManager {
             this.baseLayer.updateSchema(finalNewTableSchema);
             await this.baseLayer.addIndexToBase(newIndexSchemaEntry);
             this.tableSchema = finalNewTableSchema;
+            // The DDL transaction's own layers froze their schema at creation; hand them the
+            // new one so the rest of the transaction scans and enforces the new index.
+            this.adoptSchemaOnOpenLayers(finalNewTableSchema);
             // Emit schema change event
             this.eventEmitter?.emitSchemaChange?.({
                 type: 'create',
@@ -1819,7 +2077,16 @@ export class MemoryTableManager {
             logger.operation('Create Index', this._tableName, { indexName });
         }
         catch (e) {
+            // Restore the prior schema, and drop the index if `addIndexToBase` already landed
+            // it — otherwise the base layer's index map would advertise a structure the schema
+            // no longer declares. Guarded on the ORIGINAL schema so the "index already exists"
+            // arm never tears down the pre-existing index of the same name.
             this.baseLayer.updateSchema(originalManagerSchema);
+            const name = newIndexSchemaEntry.name;
+            const preexisting = originalManagerSchema.indexes?.some(i => i.name.toLowerCase() === name.toLowerCase()) ?? false;
+            if (!preexisting && this.baseLayer.getSecondaryIndex(name)) {
+                await this.baseLayer.dropIndexFromBase(name);
+            }
             this.tableSchema = originalManagerSchema;
             logger.error('Create Index', this._tableName, e);
             throw e;
@@ -1832,7 +2099,7 @@ export class MemoryTableManager {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
@@ -1859,6 +2126,9 @@ export class MemoryTableManager {
             this.baseLayer.updateSchema(finalNewTableSchema);
             await this.baseLayer.dropIndexFromBase(indexName);
             this.tableSchema = finalNewTableSchema;
+            // The DDL transaction's own layers froze their schema at creation; hand them the new
+            // one so the rest of the transaction stops enforcing (and scanning) the dropped index.
+            this.adoptSchemaOnOpenLayers(finalNewTableSchema);
             // Emit schema change event
             this.eventEmitter?.emitSchemaChange?.({
                 type: 'drop',
@@ -1890,7 +2160,7 @@ export class MemoryTableManager {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
@@ -1933,6 +2203,10 @@ export class MemoryTableManager {
                 await this.baseLayer.dropIndexFromBase(droppedIndexName);
             this.tableSchema = newSchema;
             this.initializePrimaryKeyFunctions();
+            // Hand the new schema to the DDL transaction's own frozen layers so a dropped UNIQUE
+            // stops enforcing for the rest of it; harmless for CHECK/FK (they re-freeze an
+            // equivalent schema, holding no per-layer structure).
+            this.adoptSchemaOnOpenLayers(newSchema);
             this.eventEmitter?.emitSchemaChange?.({
                 type: 'alter',
                 objectType: 'table',
@@ -1962,7 +2236,7 @@ export class MemoryTableManager {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
@@ -2049,16 +2323,16 @@ export class MemoryTableManager {
      *   keeps an engine-side fallback in `runtime/emit/add-constraint.ts` only for
      *   modules that omit `alterTable` — which cannot DROP/RENAME a constraint anyway.)
      */
-    async addConstraint(constraint) {
+    async addConstraint(constraint, rows) {
         if (this.isReadOnly)
             throw new QuereusError(`Table '${this._tableName}' is read-only`, StatusCode.READONLY);
         const lockKey = `MemoryTable.SchemaChange:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         const originalManagerSchema = this.tableSchema;
         try {
             await this.ensureSchemaChangeSafety();
             if (constraint.type === 'unique') {
-                await this.addUniqueConstraint(constraint);
+                await this.addUniqueConstraint(constraint, rows);
             }
             else if (constraint.type === 'foreignKey') {
                 await this.addForeignKeyConstraint(constraint);
@@ -2109,12 +2383,12 @@ export class MemoryTableManager {
     }
     /**
      * UNIQUE arm of {@link addConstraint}. Builds the covering secondary index the
-     * same way {@link ensureUniqueConstraintIndexes} does (validating existing rows
-     * via `addIndexToBase` → `populateNewIndex`), unless an existing *unique* index
-     * already covers the exact columns — in which case the data is already
-     * validated and we only register the covering structure.
+     * same way {@link ensureUniqueConstraintIndexes} does (validating the DDL
+     * transaction's effective rows via {@link validateUniqueOverEffectiveRows} first),
+     * unless an existing *unique* index already covers the exact columns — in which
+     * case the data is already validated and we only register the covering structure.
      */
-    async addUniqueConstraint(constraint) {
+    async addUniqueConstraint(constraint, rows) {
         const uc = buildUniqueConstraintSchema(constraint, this.tableSchema.columnIndexMap);
         const columns = this.tableSchema.columns;
         const existingIndexes = this.tableSchema.indexes ?? [];
@@ -2133,6 +2407,8 @@ export class MemoryTableManager {
             idx.columns.every((col, i) => col.index === uc.columns[i]) &&
             this.indexCollationsMatchDeclared(idx, uc));
         if (matchingUniqueIndex) {
+            // No validation pass: the reused index is UNIQUE, so its own derived constraint
+            // has already rejected every colliding row — committed and pending alike.
             const newSchema = Object.freeze({
                 ...this.tableSchema,
                 uniqueConstraints: appendedUcs,
@@ -2141,6 +2417,9 @@ export class MemoryTableManager {
             this.tableSchema = newSchema;
             this.initializePrimaryKeyFunctions();
             this.implicitCoveringStructures.set(uc.name ?? matchingUniqueIndex.name, { indexName: matchingUniqueIndex.name, origin: 'implicit-from-unique-constraint' });
+            // This arm skips addIndexToBase, but the open transaction's layers still need the
+            // new `uniqueConstraints` entry or they will not enforce it.
+            this.adoptSchemaOnOpenLayers(newSchema);
             return;
         }
         const colNames = uc.columns.map(i => columns[i]?.name ?? String(i));
@@ -2153,19 +2432,23 @@ export class MemoryTableManager {
             columns: uc.columns.map(colIdx => ({ index: colIdx, collation: columns[colIdx]?.collation })),
             predicate: uc.predicate,
         };
+        // Validate BEFORE any mutation, over the DDL transaction's EFFECTIVE rows (throws
+        // CONSTRAINT on the first in-scope duplicate). The covering index carries no
+        // `unique: true` flag, so `addIndexToBase` would not check it anyway — and must
+        // not: it populates from committed rows, which may still hold a duplicate this
+        // transaction has deleted.
+        await this.validateUniqueOverEffectiveRows(indexSchema, this.tableSchema, rows);
         const newSchema = Object.freeze({
             ...this.tableSchema,
             uniqueConstraints: appendedUcs,
             indexes: Object.freeze([...existingIndexes, indexSchema]),
         });
-        // Swap the schema FIRST so `addIndexToBase` → `indexEnforcesUnique` sees the
-        // new constraint and rejects duplicates, then populate (throws CONSTRAINT on
-        // the first in-scope duplicate). A throw rolls back via the catch in addConstraint.
         this.baseLayer.updateSchema(newSchema);
         await this.baseLayer.addIndexToBase(indexSchema);
         this.tableSchema = newSchema;
         this.initializePrimaryKeyFunctions();
         this.implicitCoveringStructures.set(uc.name ?? indexName, { indexName, origin: 'implicit-from-unique-constraint' });
+        this.adoptSchemaOnOpenLayers(newSchema);
     }
     /**
      * FOREIGN KEY arm of {@link addConstraint}. Validates existing child rows
@@ -2189,14 +2472,14 @@ export class MemoryTableManager {
     }
     async destroy() {
         const lockKey = `MemoryTable.Destroy:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         try {
             for (const connection of this.connections.values()) {
                 if (connection.pendingTransactionLayer)
                     connection.rollback();
             }
             this.connections.clear();
-            this.baseLayer = new BaseLayer(this.tableSchema);
+            this.baseLayer = new BaseLayer(this.tableSchema, this.collationResolver);
             this._currentCommittedLayer = this.baseLayer;
             logger.operation('Destroy', this._tableName, 'Manager destroyed and data cleared');
         }
@@ -2214,10 +2497,24 @@ export class MemoryTableManager {
                 throw new QuereusError(`Cannot perform schema change on table ${this._tableName} while older transaction versions are in use by active connections. Commit/rollback active transactions and retry.`, StatusCode.BUSY);
             }
         }
+        // Consolidation drains COMMITTED layers into the base; a connection's own
+        // UNCOMMITTED writes are untouched by it. Those rows are invisible to the DDL's
+        // transaction, so a row-validating schema change cannot be checked against them,
+        // and the sibling's layers cannot be re-pointed at the new schema. Only the
+        // DDL-issuing connection may hold open work — everyone else must land first.
+        const ddlConnection = this.ddlConnection();
+        for (const connection of this.knownConnections()) {
+            if (connection === ddlConnection || !connection.hasOpenWork())
+                continue;
+            throw new QuereusError(`Cannot perform schema change on table ${this._tableName} while another connection has uncommitted changes. Commit/rollback active transactions and retry.`, StatusCode.BUSY);
+        }
         // After ensuring we're at the base layer, update all connections to read from the base layer
-        // This is necessary because connections might still be reading from promoted/collapsed layers
+        // This is necessary because connections might still be reading from promoted/collapsed layers.
+        // The DDL issuer's own open transaction is exempt: its read view is a pending layer or an
+        // eager savepoint snapshot holding its uncommitted rows, and re-pointing it at the base
+        // would silently drop them from every later read in that transaction.
         for (const connection of this.connections.values()) {
-            if (connection.readLayer !== this.baseLayer) {
+            if (connection.readLayer !== this.baseLayer && !connection.hasOpenWork()) {
                 logger.debugLog(`[Schema Safety] Updating connection ${connection.connectionId} to read from base layer`);
                 connection.readLayer = this.baseLayer;
             }
@@ -2242,6 +2539,17 @@ export class MemoryTableManager {
      * the Database registry but not in the manager's map.
      */
     repointRegisteredConnections() {
+        for (const mc of this.registeredConnections()) {
+            if (mc.hasOpenWork())
+                continue;
+            if (mc.readLayer === this.baseLayer)
+                continue;
+            logger.debugLog(`[Schema Safety] Re-pointing registered connection ${mc.connectionId} to base layer`);
+            mc.readLayer = this.baseLayer;
+        }
+    }
+    /** Every Database-registered {@link MemoryTableConnection} backed by this manager. */
+    *registeredConnections() {
         const qualifiedName = `${this.schemaName}.${this._tableName}`;
         for (const c of this.db.getConnectionsForTable(qualifiedName)) {
             if (!(c instanceof MemoryVirtualTableConnection))
@@ -2249,18 +2557,282 @@ export class MemoryTableManager {
             const mc = c.getMemoryConnection();
             if (mc.tableManager !== this)
                 continue;
-            if (mc.pendingTransactionLayer !== null)
+            yield mc;
+        }
+    }
+    /**
+     * Every connection this manager can see: the ones still attached to {@link connections}
+     * (including unregistered committed-snapshot readers) plus the Database-registered ones,
+     * which may have been detached from the map by a post-autocommit disconnect.
+     */
+    *knownConnections() {
+        const seen = new Set();
+        for (const mc of this.connections.values()) {
+            seen.add(mc);
+            yield mc;
+        }
+        for (const mc of this.registeredConnections()) {
+            if (seen.has(mc))
                 continue;
-            if (mc.readLayer === this.baseLayer)
+            seen.add(mc);
+            yield mc;
+        }
+    }
+    /**
+     * The connection through which the current DDL statement's transaction runs, if any.
+     *
+     * A statement reaches a memory table through the single Database-registered connection
+     * for it (`MemoryTable.ensureConnection` and `getVTableConnection` both reuse the first
+     * one), so that connection's view IS this statement's transaction. In autocommit with
+     * no prior scan there is no connection at all, and the committed base is the whole story.
+     *
+     * NOTE: takes the FIRST registered connection, matching how both reuse sites pick one.
+     * If the registry ever holds more than one connection per (table, transaction), this
+     * picks arbitrarily — validate against the writer instead, and treat the rest as
+     * siblings.
+     */
+    ddlConnection() {
+        for (const mc of this.registeredConnections())
+            return mc;
+        return undefined;
+    }
+    /**
+     * The rows a `select` issued by the DDL statement's own transaction would see: the
+     * committed base overlaid with that connection's uncommitted writes. Degenerates to the
+     * base primary tree when no connection holds open work.
+     *
+     * `pendingTransactionLayer ?? readLayer` is exactly the layer `MemoryTable.query` scans,
+     * and each layer's primary BTree is copy-on-write over its parent's, so one ascending
+     * walk yields the merged view (pending inserts/updates present, pending deletes absent).
+     */
+    effectiveDdlRows() {
+        const connection = this.ddlConnection();
+        const layer = connection
+            ? (connection.pendingTransactionLayer ?? connection.readLayer)
+            : this.baseLayer;
+        return iteratePrimaryRows(layer.getModificationTree('primary') ?? this.baseLayer.primaryTree);
+    }
+    /**
+     * The committed base rows for `alter column … set data type` / `set not null` backfill, with the
+     * value at `colIndex` run through `convert`. NULLs pass through untouched UNLESS `convertNulls` is
+     * set (the SET NOT NULL backfill maps null → DEFAULT). A value that fails to convert is kept as-is:
+     * the manager validated every value in the effective VIEW before calling, so a base value that
+     * fails here is one a pending delete/overwrite shadows and no reader can see. The result is a fresh
+     * full row list for {@link BaseLayer.rebuildPrimaryTreeFromRows} — the base primary tree is
+     * REPLACED, never mutated in place (inheritree forbids mutating a tree the open transaction's
+     * layers derive from).
+     */
+    convertBaseRows(colIndex, convert, convertNulls = false) {
+        const out = [];
+        for (const row of iteratePrimaryRows(this.baseLayer.primaryTree)) {
+            const oldVal = row[colIndex];
+            if (oldVal === null && !convertNulls) {
+                out.push(row);
                 continue;
-            logger.debugLog(`[Schema Safety] Re-pointing registered connection ${mc.connectionId} to base layer`);
-            mc.readLayer = this.baseLayer;
+            }
+            let newVal;
+            try {
+                newVal = convert(oldVal);
+            }
+            catch {
+                out.push(row); // shadowed unconvertible value — keep as-is
+                continue;
+            }
+            out.push(row.map((v, i) => i === colIndex ? newVal : v));
+        }
+        return out;
+    }
+    /**
+     * Rejects an index/constraint whose uniqueness the DDL transaction's own effective rows
+     * already violate, BEFORE anything is mutated. Builds a throwaway {@link MemoryIndex} —
+     * the collation-aware, partial-predicate-aware key comparator — over those rows and lets
+     * {@link populateIndexFromRows} raise CONSTRAINT on the first duplicate.
+     *
+     * `rows` overrides {@link effectiveDdlRows}. A wrapper module (the isolation layer) holds
+     * the transaction's pending rows outside this manager, so only it can name the rows the
+     * issuing connection actually sees; when it supplies them, they are the judged set and this
+     * manager's own committed rows are ignored. See `vtab/module.ts` {@link EffectiveRowSource}.
+     */
+    async validateUniqueOverEffectiveRows(indexSchema, schema, rows) {
+        const probe = new MemoryIndex(indexSchema, schema.columns, this.collationResolver, this.primaryKeyFunctions.compare, this.primaryKeyFunctions.encode, schema.name);
+        if (rows) {
+            await populateIndexFromRowsAsync(rows(), probe, this.primaryKeyFunctions.extractFromRow, true, this._tableName, schema.columns);
+            return;
+        }
+        populateIndexFromRows(this.effectiveDdlRows(), probe, this.primaryKeyFunctions.extractFromRow, true, this._tableName, schema.columns);
+    }
+    /**
+     * `ALTER COLUMN … SET COLLATE` arm of {@link validateUniqueOverEffectiveRows}: rejects the
+     * change when it makes two of the DDL transaction's effective rows collide under any
+     * uniqueness-enforcing structure that orders by the altered column. Runs before anything is
+     * mutated, so a rejection leaves the table and schema untouched and the transaction usable.
+     *
+     * `newSchema` carries the post-change per-column collations, so each probe index compares
+     * exactly as the rebuilt structure will. Indexes that do not mention the column keep their
+     * keys and need no re-check.
+     *
+     * NOTE: walks `schema.indexes`, so a UNIQUE constraint covered by a row-time materialized
+     * view rather than its auto-index (`findIndexForConstraint` prefers the MV) is not re-checked
+     * here. The auto-index always exists alongside, so the structure is still validated — but if
+     * an MV-only covering shape ever becomes reachable, this walk must follow it.
+     */
+    async validateRekeyedUniqueStructures(newSchema, alteredColumnIndex, rows) {
+        // NOTE: the probe index carries the manager's PRE-change `primaryKeyFunctions` (the new
+        // ones cannot exist before the schema swaps). Only the probe's per-entry PK bookkeeping
+        // uses them, and every effective row already has a distinct PK under the old encoder, so
+        // duplicate detection — which fires on the index key, before any PK is stored — is
+        // unaffected. If a probe ever needs to compare PKs semantically, pass the new functions in.
+        for (const indexSchema of newSchema.indexes ?? []) {
+            if (!indexSchema.columns.some(c => c.index === alteredColumnIndex))
+                continue;
+            if (!indexEnforcesUnique(newSchema, indexSchema))
+                continue;
+            // `rows` is re-callable, so each structure gets a fresh stream.
+            await this.validateUniqueOverEffectiveRows(indexSchema, newSchema, rows);
+        }
+    }
+    /**
+     * PRIMARY KEY arm of the `alter column … set collate` pre-pass. Runs before anything is
+     * mutated, so a rejection leaves the table, the schema and the transaction untouched.
+     *
+     * The primary tree is a map, not a multi-map, so — unlike a secondary index — it cannot
+     * physically hold two rows whose keys collapse under the new comparator. Every layer the
+     * DDL connection still reads through therefore has to be collision-free, not just the
+     * transaction's effective view:
+     *
+     *  1. **The effective view collides** → `CONSTRAINT`. The duplicate is visible to a `select`
+     *     in this transaction; the change is simply illegal.
+     *  2. **A layer beneath it collides** → `BUSY`. Those rows are not visible now, but every
+     *     such layer is the copy-on-write base the view reads through, and one of them may be a
+     *     savepoint snapshot a `rollback to savepoint` must restore. A re-keyed tree could not
+     *     represent the pair at all. Committing (or rolling back) settles the transaction and
+     *     the ALTER can be retried — the same "commit/rollback and retry" posture as
+     *     {@link ensureSchemaChangeSafety}.
+     *
+     * Case 2 is deliberately conservative. The chain holds one immutable layer per statement
+     * boundary (see `MemoryTableConnection.createSavepoint`'s eager path), so it rejects any
+     * transaction that has held a colliding pair at ANY statement boundary — even one whose
+     * final view is clean and whose intermediate layer no savepoint can reach. Narrowing that
+     * would mean re-parenting the view's tree past the unreachable layers, which is exactly the
+     * rebase that savepoint snapshots exist to avoid. The tradeoff is a rare false BUSY on a
+     * statement sequence the user can retry after committing, versus losing a row on rollback.
+     *
+     * This precondition is also what makes `TransactionLayer.rekeyPrimaryKey`'s replay sound:
+     * with no collisions anywhere in the chain, every primary key resolves to at most one row
+     * in each layer under the new comparator.
+     */
+    validateRekeyedPrimaryKey(newSchema) {
+        const newPkFunctions = createPrimaryKeyFunctions(newSchema, this.collationResolver);
+        const connection = this.ddlConnection();
+        const view = connection
+            ? (connection.pendingTransactionLayer ?? connection.readLayer)
+            : this.baseLayer;
+        this.assertNoPrimaryKeyCollision(view, newPkFunctions, StatusCode.CONSTRAINT, `UNIQUE constraint failed: ${this._tableName} primary key collides under new collation`);
+        // `ensureSchemaChangeSafety` has already drained every committed layer into the base and
+        // rejected sibling connections with open work, so the chain below the view holds only
+        // this transaction's own layers.
+        for (let layer = view.getParent(); layer; layer = layer.getParent()) {
+            this.assertNoPrimaryKeyCollision(layer, newPkFunctions, StatusCode.BUSY, `Cannot change the collation of a primary key column of table ${this._tableName}: `
+                + `rows this transaction has removed still collide under the new collation and must survive a rollback. `
+                + `Commit/rollback and retry.`);
+        }
+    }
+    /**
+     * Raises `code` when two of `layer`'s rows share a primary key under `pkFunctions`.
+     *
+     * NOTE: O(rows) per layer, so O(layers × rows) for a whole chain — one more full pass than
+     * the base rebuild the caller is about to do anyway. Fine for a statement this rare; if a
+     * deep savepoint stack over a large table ever makes an ALTER slow, note that a layer's rows
+     * differ from its parent's only at the keys it wrote, so the walk can be narrowed to those.
+     */
+    assertNoPrimaryKeyCollision(layer, pkFunctions, code, message) {
+        const tree = layer.getModificationTree('primary');
+        if (!tree)
+            return;
+        const probe = new BTree((row) => pkFunctions.extractFromRow(row), pkFunctions.compare);
+        for (const row of iteratePrimaryRows(tree)) {
+            const key = pkFunctions.extractFromRow(row);
+            if (probe.get(key) !== undefined)
+                throw new QuereusError(message, code);
+            probe.insert(row);
+        }
+    }
+    /**
+     * Propagates a schema change — a new index and/or UNIQUE constraint, or a set of structures
+     * re-keyed by `alter column … set collate` — into every {@link TransactionLayer} the DDL
+     * connection's open transaction still reads through: its pending layer and every savepoint
+     * snapshot below it, which are exactly the transaction layers on the view layer's parent
+     * chain above the base.
+     *
+     * Without this the transaction would keep enforcing (and scanning) its creation-time schema
+     * for the rest of its life, a `rollback to savepoint` would restore a stale-schema layer,
+     * and at commit the pending layer would become the committed head carrying its stale schema
+     * and structures — shadowing the base's rebuilt ones. Rebasing would achieve the same but
+     * invalidate those snapshots. Applied oldest-first: both
+     * {@link TransactionLayer.adoptSchema} and {@link TransactionLayer.rekeyPrimaryKey} inherit
+     * their parent's already-rebuilt trees.
+     *
+     * `rekeyPrimary` selects the heavier path, for the one change that invalidates a layer's
+     * primary key functions and every structure derived from them: a collation change on a
+     * primary key column.
+     */
+    adoptSchemaOnOpenLayers(newSchema, rekeyPrimary = false) {
+        for (const layer of this.openTransactionLayersOldestFirst()) {
+            if (rekeyPrimary)
+                layer.rekeyPrimaryKey(newSchema);
+            else
+                layer.adoptSchema(newSchema);
         }
     }
+    /**
+     * Converts the altered column's own-written values in every open transaction layer, after
+     * `alter column … set data type` / `set not null` backfill has converted the base. Runs
+     * oldest-first so each layer's copy-on-write base inherits its parent's already-converted rows
+     * and only the layer's OWN writes are rewritten (see {@link TransactionLayer.convertColumn}).
+     * `convertNulls` routes null own-values through `convert` (the SET NOT NULL null → DEFAULT map);
+     * SET DATA TYPE leaves them untouched. No-op in autocommit.
+     *
+     * PRIMARY-KEY columns never reach here — a physical retype of a key column is rejected before
+     * any mutation, and SET NOT NULL leaves the key bytes unchanged — so the primary tree's keys are
+     * stable and no re-key is needed.
+     */
+    convertColumnOnOpenLayers(newSchema, colIndex, convert, convertNulls = false) {
+        for (const layer of this.openTransactionLayersOldestFirst()) {
+            layer.convertColumn(colIndex, convert, newSchema, convertNulls);
+        }
+    }
+    /**
+     * The DDL connection's open {@link TransactionLayer}s, oldest-first, base excluded — its
+     * pending layer and every savepoint snapshot below it, the layers on the view's parent chain
+     * above the base. Empty in autocommit (no connection, or the view IS the base).
+     *
+     * Both schema adoption ({@link adoptSchemaOnOpenLayers}) and value conversion
+     * ({@link convertColumnOnOpenLayers}) MUST apply oldest-first: each layer rebuilds its
+     * structures over its parent's, so the parent's must already be the new/converted ones.
+     *
+     * NOTE: the walk takes every TransactionLayer below the view, which normally means the pending
+     * layer and its savepoint snapshots. A committed layer already drained into the base by
+     * `ensureSchemaChangeSafety` can also sit in the chain (the pending layer forked from it before
+     * consolidation); it still shadows the base with its OWN unadapted rows while it remains the
+     * view's copy-on-write base, so it must be adapted too — it cannot be skipped, since a savepoint
+     * snapshot is `markCommitted()` as well. Both callers' per-layer work is idempotent and additive.
+     */
+    openTransactionLayersOldestFirst() {
+        const connection = this.ddlConnection();
+        if (!connection)
+            return [];
+        const view = connection.pendingTransactionLayer ?? connection.readLayer;
+        const chain = [];
+        for (let cur = view; cur && cur !== this.baseLayer; cur = cur.getParent()) {
+            if (cur instanceof TransactionLayer)
+                chain.push(cur);
+        }
+        return chain.reverse();
+    }
     /** Consolidates all transaction data into the base layer for schema changes */
     async consolidateToBaseLayer() {
         const lockKey = `MemoryTable.Consolidate:${this.schemaName}.${this._tableName}`;
-        const release = await Latches.acquire(lockKey);
+        const release = await this.db.latches.acquire(lockKey);
         try {
             logger.debugLog(`[Consolidate] Acquired lock for ${this._tableName}`);
             // If current committed layer is a transaction layer, we need to merge its data into the base
@@ -2305,9 +2877,21 @@ export class MemoryTableManager {
         // rebuilds the base secondary indexes from the new tree.
         this.baseLayer.rebuildPrimaryTreeFromRows(allRows);
     }
-    /** Scans a layer according to the given plan, yielding matching rows. */
+    /**
+     * Sync scan — the hot path (query()/internal maintenance) avoids the async hop.
+     * The backing BTree (inheritree) and all per-row filter/early-term logic are
+     * fully synchronous, so no async boundary belongs here.
+     */
+    scanLayerSync(layer, plan) {
+        return scanLayerImpl(layer, plan);
+    }
+    /**
+     * Async adapter for external `AsyncIterable<Row>` callers (tests,
+     * `module.scanEffective`, the backing-host). Retained deliberately — do not
+     * delete thinking it is dead; delegates to {@link scanLayerSync}.
+     */
     async *scanLayer(layer, plan) {
-        yield* scanLayerImpl(layer, plan);
+        yield* this.scanLayerSync(layer, plan);
     }
 }
 //# sourceMappingURL=manager.js.map