@quereus/isolation 4.3.1 → 4.3.2

package/dist/src/isolation-module.d.ts

@@ -1,4 +1,4 @@
-import type { Database, VirtualTableModule, BaseModuleConfig, TableSchema, TableIndexSchema as IndexSchema, ModuleCapabilities, VirtualTable, BestAccessPlanRequest, BestAccessPlanResult, SchemaChangeInfo, Schema, MappingAdvertisement, LensDeploymentSnapshot, VtabConcurrencyMode, VirtualTableConnection, BackingHost } from '@quereus/quereus';
+import type { Database, VirtualTableModule, BaseModuleConfig, TableSchema, TableIndexSchema as IndexSchema, ModuleCapabilities, VirtualTable, BestAccessPlanRequest, BestAccessPlanResult, SchemaChangeInfo, Schema, MappingAdvertisement, LensDeploymentSnapshot, VtabConcurrencyMode, VirtualTableConnection, BackingHost, EffectiveRowSource } from '@quereus/quereus';
 import type { IsolationModuleConfig } from './isolation-types.js';
 import { IsolatedTable } from './isolated-table.js';
 /**
@@ -35,12 +35,24 @@ export interface ConnectionOverlayState {
     overlayTable: VirtualTable;
     hasChanges: boolean;
     /**
-     * Set by a cross-connection ALTER that could not migrate this (foreign)
-     * overlay to the post-alter column layout. The overlay still holds
-     * PRE-alter rows, so it is structurally inconsistent with the now-committed
-     * schema; any data op that would merge or flush it must throw this message.
-     * Undefined = healthy. Cleared only by discarding the overlay (rollback /
-     * commit-failure → rollback).
+     * The `Database` this overlay was created against — carried so
+     * {@link IsolationModule.releaseOverlayTable} can free the overlay's staging
+     * table on ANY discard path, including {@link IsolationModule.destroy} and
+     * {@link IsolationModule.closeAll}, which sweep overlays across multiple db ids
+     * and so have no single ambient `db` to hand the overlay module's `destroy`.
+     * Set at every real creation site (`ensureOverlay`, the two rebuild builders);
+     * the default `MemoryTableModule` overlay ignores it, but a host-injected
+     * `config.overlay` keyed per-db needs the overlay's OWN db, not the sweeper's.
+     */
+    db: Database;
+    /**
+     * Set by a cross-connection DDL that left this (foreign) overlay unflushable:
+     * an ALTER that could not migrate it to the post-alter column layout (the overlay
+     * still holds PRE-alter rows, structurally inconsistent with the now-committed
+     * schema), or a DROP TABLE that removed the table it stages rows for. Either way
+     * any data op that would merge or flush it must throw this message. Undefined =
+     * healthy. Cleared only by discarding the overlay (rollback / commit-failure →
+     * rollback).
      */
     poison?: {
         message: string;
@@ -62,7 +74,10 @@ export interface ConnectionOverlayState {
  *
  * This provides ACID semantics including:
  * - Read-your-own-writes within a transaction
- * - Snapshot isolation (reads see consistent state)
+ * - Read-committed reads of shared state (the underlying table is live and shared
+ *   across connections — this is NOT snapshot isolation; another connection's commit
+ *   can become visible mid-transaction, and there is no write-write conflict
+ *   detection). A stable snapshot, if needed, is the underlying module's job.
  * - Savepoint support via overlay module's transaction support
  */
 export declare class IsolationModule implements VirtualTableModule<IsolatedTable, BaseModuleConfig> {
@@ -206,10 +221,30 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     setConnectionOverlay(db: Database, schemaName: string, tableName: string, state: ConnectionOverlayState): void;
     /**
-     * Removes the overlay state for a specific connection and table.
-     * Called after commit/rollback to clean up.
+     * Frees the in-memory staging (overlay) table backing `state` by calling the overlay
+     * module's `destroy`, so its manager entry (and the rows it holds) is removed from the
+     * overlay module's table registry rather than leaking there for the life of the
+     * `Database`. This is the single sink every overlay-discard path funnels through —
+     * without it, `MemoryTableModule.tables` accumulates one dead `_overlay_<table>_<id>`
+     * entry per writing transaction (and one more per rebuild), unbounded.
+     *
+     * `MemoryTableManager.destroy` rolls back the overlay's own pending layer and clears its
+     * connections; a later db-side teardown of the (now-detached) `MemoryVirtualTableConnection`
+     * is tolerated by `MemoryTableManager.disconnect` (`!connection` → no-op), so destroying
+     * here mid-commit/rollback does not throw when the connection is torn down afterwards.
+     *
+     * Defensive on a missing schema: real overlays always carry one (`createOverlaySchema`),
+     * so a schemaless state can only be a malformed/test-fabricated one — skip rather than throw.
+     */
+    private releaseOverlayTable;
+    /**
+     * Removes the overlay state for a specific connection and table, first releasing its
+     * staging table so it does not leak (see {@link releaseOverlayTable}). Async because the
+     * release drives the overlay module's `destroy`; all callers (`clearOverlay`, `alterSchema`)
+     * are already async and `await` it. Called on the rollback / alter-schema / rollback-to-
+     * pre-overlay-savepoint discard paths.
      */
-    clearConnectionOverlay(db: Database, schemaName: string, tableName: string): void;
+    clearConnectionOverlay(db: Database, schemaName: string, tableName: string): Promise<void>;
     /**
      * Returns (creating if absent) the set of savepoint depths that pre-date the overlay
      * for this connection+table.  Shared across all IsolatedTable instances in the
@@ -218,6 +253,72 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
     getPreOverlaySavepoints(db: Database, schemaName: string, tableName: string): Set<number>;
     /** Removes the pre-overlay savepoint set for a connection+table. */
     clearPreOverlaySavepoints(db: Database, schemaName: string, tableName: string): void;
+    /**
+     * Returns every key of a connection-scoped map (`<dbId>:<schema>.<table>`, the
+     * shape of {@link connectionOverlays} / {@link preOverlaySavepoints} /
+     * {@link connectionInFlight}) that belongs to `schemaName.tableName`, across ALL
+     * db ids. Those maps embed the db id as a prefix, so a per-table sweep is a suffix
+     * match on `:<schema>.<table>`. Keys are stored lowercased, so the suffix is too.
+     *
+     * The keys are materialized into an array rather than yielded, so callers may
+     * delete or re-key entries while walking the result.
+     */
+    private connectionScopedKeys;
+    /**
+     * Commits every overlay this db-transaction staged as ONE coordinated two-phase
+     * flush, instead of each table flushing+committing its own underlying
+     * independently. The per-table approach tears a multi-table commit: table A's
+     * underlying `commit()` durably lands (and, for a shared-coordinator
+     * `quereus-store`, flushes *every* pending table) before table B has even
+     * applied, so a failure in B leaves A committed. See the fix ticket and
+     * `quereus-store/README` § "Atomic multi-store commit".
+     *
+     * Phase 1 (apply): for every staged overlay, begin its underlying table and
+     * apply the overlay's rows WITHOUT committing (see {@link applyOverlayToUnderlying}).
+     * For a `quereus-store` underlying, every table's writes accumulate in the
+     * module's single shared coordinator (the first `begin()` opens it; the rest are
+     * idempotent no-ops).
+     *
+     * Phase 2 (commit): once ALL overlays have applied, commit the affected
+     * underlying tables. For `quereus-store` the first `commit()` flushes every
+     * table's ops in one atomic coordinator commit — a single `AtomicBatch.write()`
+     * on a provider that exposes `beginAtomicBatch` — and the rest no-op. For an
+     * underlying with per-table transaction domains (the memory vtab), each table
+     * commits independently.
+     *
+     * On any Phase-1 error, roll back every underlying begun so far and rethrow;
+     * nothing was committed, so the transaction aborts atomically. Because all the
+     * fallible data work (constraint re-checks, injected/IO write errors) happens in
+     * Phase 1 before any commit, a data-driven abort is always clean. Full
+     * crash-atomicity across the commit phase itself is contingent on the underlying
+     * exposing a shared atomic commit domain (see docs/design-isolation-layer.md
+     * § "Commit Failure Recovery").
+     *
+     * A poisoned overlay aborts the whole commit before any apply — mirroring the
+     * per-connection `assertOverlayUsable` check, now with the added benefit that no earlier
+     * table is left committed. The overlay is left intact so the ensuing rollback discards
+     * it. Two DDLs poison: a cross-connection ALTER (rows left in the pre-alter layout) and
+     * a cross-connection DROP TABLE (the table is gone; see {@link destroy}).
+     *
+     * Driven once per db-transaction: the first `IsolatedConnection.commit()` in the
+     * database's commit loop runs this whole flush and clears every overlay, so the
+     * remaining connections find no overlay for their table and this is a no-op — no
+     * explicit "already flushed" latch is needed, the cleared-overlay state guards
+     * itself.
+     *
+     * **Invariant: every staged overlay resolves to an underlying table here, or is
+     * poisoned.** The table-lifecycle hooks are what keep that true — {@link destroy}
+     * discards or poisons the overlays of a dropped table across every connection, and
+     * {@link renameTable} re-connects the underlying under the new name whenever it re-keys
+     * an overlay onto it. The poison check above is the enforcement point: it runs BEFORE
+     * the `underlyingTables` lookup, so a dropped table's surviving foreign overlay raises
+     * its poison message rather than the orphan error below. A miss that is neither resolved
+     * nor poisoned is therefore a layer-invariant violation, not a routine condition, and is
+     * raised as `StatusCode.INTERNAL`: the alternative — dropping the staged rows and letting
+     * the commit report success — is silent data loss. Only a CLEAN overlay
+     * (`hasChanges === false`) may miss harmlessly; it staged nothing, so it is discarded.
+     */
+    commitConnectionOverlays(db: Database): Promise<void>;
     /**
      * Coalesces concurrent covering-connection builds for one (db, table) onto a
      * single in-flight promise, keyed identically to {@link connectionOverlays}
@@ -248,6 +349,13 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
     private getDbId;
     /**
      * Returns capabilities combining underlying module with isolation guarantees.
+     *
+     * `ddlTransactionality` is forwarded verbatim through the spread — the wrapper
+     * NEVER upgrades it. The overlay stages DML outside the underlying module, so an
+     * underlying DDL-commit flushes only module-side ops, leaving overlay writes
+     * behind (the `bug-store-savepoint-ddl-drop-lost-insert` asymmetry). Forwarding
+     * the underlying's (pessimistic) value is the honest choice; only `isolation` /
+     * `savepoints` are augmented, since the wrapper genuinely adds those.
      */
     getCapabilities(): ModuleCapabilities;
     /**
@@ -324,25 +432,168 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     connect(db: Database, pAux: unknown, moduleName: string, schemaName: string, tableName: string, options: BaseModuleConfig, tableSchema?: TableSchema): Promise<IsolatedTable>;
     /**
-     * Destroys the underlying table.
+     * Destroys the underlying table, then resolves every connection's staged state for it.
+     *
+     * DROP TABLE is not transaction-scoped: the table is gone for *every* connection the
+     * moment this returns, so no overlay staging writes against it can ever be flushed.
+     * What differs is who gets told. Per overlay key matching the dropped table (both maps
+     * are keyed `<dbId>:<schema>.<table>`, so the sweep spans all db ids):
+     *
+     * - **The dropping connection's own overlay** is discarded silently. It issued the DROP;
+     *   there is nobody to notify.
+     * - **A foreign overlay with staged rows** (`hasChanges`) is **poisoned**, not swept.
+     *   Sweeping it let that connection commit against an empty overlay set and report
+     *   success after its rows were thrown away — silent cross-connection data loss. Poison
+     *   makes its next read/write/commit throw `CONSTRAINT` (see
+     *   {@link IsolatedTable.assertOverlayUsable} and the poison check at the head of
+     *   {@link commitConnectionOverlays}, which precedes the `underlyingTables` lookup and so
+     *   raises the poison message rather than the orphan INTERNAL error). An already-poisoned
+     *   overlay keeps its original message — the first cause is the one worth reporting.
+     * - **A foreign overlay with no staged rows** is discarded: it staged nothing, so nothing
+     *   is lost.
+     *
+     * `preOverlaySavepoints` is swept for every matching key whose overlay did NOT survive.
+     * A surviving poisoned overlay keeps its set: `ensureOverlay` padding still consults it,
+     * and the owning connection's `onConnectionRollback` reaps it when its failed commit
+     * rolls back. Without the sweep, an abandoned set outlived the table for the lifetime of
+     * the `Database` (nothing else is keyed to reap it once the table is gone).
+     *
+     * Nothing is discarded or poisoned until the underlying destroy SUCCEEDS. A throwing
+     * `underlying.destroy` means the table still exists, so every connection's staged
+     * writes are still flushable and every map entry must survive untouched — the same
+     * reason {@link renameTable} delegates before mutating its maps.
+     *
+     * NOTE: poison rides on the `ConnectionOverlayState`, not on its rows, so a foreign
+     * connection that later unwinds every staged row past the drop (rollback to a savepoint
+     * taken after the overlay existed) still fails its commit. Deliberately over-strict —
+     * the table is gone either way. If a caller ever needs the clean-unwind case to commit,
+     * re-evaluate the poison on `onConnectionRollbackToSavepoint` rather than special-casing
+     * here.
+     *
+     * NOTE: a connection whose own overlay was already poisoned (by another connection's
+     * ALTER) escapes that poison for this table by dropping it — the own-overlay branch
+     * deletes the state, poison and all. Correct as written: the rows it discards belong to
+     * a table this connection just asked to remove. If poison ever carries a cause that
+     * outlives the table, gate the own-overlay delete on it.
+     *
+     * NOTE: this mutates `connectionOverlays` while a foreign connection may be mid-scan in
+     * `IsolatedTable.query`'s merged branch — that scan will keep merging against an overlay
+     * whose underlying is now destroyed. The module clamps to `'reentrant-reads'`, so no
+     * in-tree host reaches it. If a host ever runs a DROP concurrently with a foreign scan,
+     * the merged iterator needs a per-scan snapshot of the overlay + underlying pair.
      */
     destroy(db: Database, pAux: unknown, moduleName: string, schemaName: string, tableName: string): Promise<void>;
+    /**
+     * Inserts one staged row into a freshly built overlay, raising on anything but success.
+     *
+     * `MemoryTable.update` RETURNS a `constraint` status rather than throwing it. Every overlay
+     * rebuild loop ignored that return, so a row the new schema forbids was dropped on the floor
+     * and the transaction committed without it — silent data loss, reachable today by
+     * `alter table … add constraint … unique` over pending duplicate rows. Convert it into a
+     * throw; {@link adoptRebuiltOverlay} decides whether that means INTERNAL (the issuer, whose
+     * rows the DDL's own validation pass already accepted) or poison (a foreign connection,
+     * which must roll back).
+     */
+    private insertIntoRebuiltOverlay;
+    /**
+     * Runs one overlay's rebuild and installs the result, routing a CONSTRAINT failure by who
+     * owns the overlay:
+     *
+     * - **The DDL-issuing connection.** Unreachable: the row source handed to the underlying
+     *   (see {@link issuerEffectiveRows}) judged a superset of exactly these rows and accepted
+     *   them, so a rejection here means validation and migration have drifted. Raise INTERNAL —
+     *   loudly, because the alternative is the silent row loss this guard exists to end.
+     * - **A foreign connection.** Reachable and legitimate: its staged rows may violate a
+     *   constraint another connection just declared. Poison that overlay and leave it
+     *   unmigrated, so its owner errors on its next read/write/commit and rolls back. The
+     *   issuer's DDL proceeds. Mirrors the tier-3 NOT NULL handling in {@link alterTable}.
+     *
+     * A rebuild that throws leaves the OLD overlay installed either way — the new table is
+     * simply discarded.
+     */
+    private adoptRebuiltOverlay;
+    /**
+     * Builds the poison message stamped onto a foreign overlay whose staged rows cannot be
+     * migrated under a constraint another connection's DDL just declared (see
+     * {@link adoptRebuiltOverlay}). Companion to {@link buildAlterPoisonMessage}, which covers
+     * the `addColumn` NOT NULL backfill rejected before the underlying is touched; this one
+     * covers a UNIQUE (or any other) violation raised by the rebuild itself.
+     */
+    private buildRebuildPoisonMessage;
+    /**
+     * Builds the poison message stamped onto a foreign overlay whose table was dropped out
+     * from under it (see {@link destroy}). Names the schema.table so the owning connection's
+     * eventual read/write/commit error is self-explanatory. Companion to
+     * {@link buildAlterPoisonMessage}: both poison sources raise the same
+     * `StatusCode.CONSTRAINT` and are told apart by their message, not their code.
+     */
+    private buildDropPoisonMessage;
     /**
      * Closes all resources held by the underlying module (if it supports closeAll).
      * Also clears connection overlay state.
      */
     closeAll(): Promise<void>;
     /**
-     * Creates an index on the underlying table.
+     * The rows the connection owning `overlayState` can SEE — the underlying's committed rows
+     * merged with that overlay's staged writes. Re-callable, as `EffectiveRowSource` requires.
+     *
+     * This is the seam the whole fix turns on: the underlying module validates row-content DDL
+     * (UNIQUE duplicate detection, collation-rekey collisions) against its OWN rows, which under
+     * isolation are the committed rows only. The transaction's pending rows live here, in the
+     * overlay, where the underlying cannot reach them — so we hand them down.
+     *
+     * NOTE: each call re-materializes the overlay and re-scans the underlying. `alter column …
+     * set collate` calls once per UNIQUE constraint covering the altered column, so a table with
+     * many such constraints pays that many scans. If it ever shows up as slow, materialize the
+     * overlay's PK map once per DDL and share it across the calls.
+     */
+    private effectiveRowsFor;
+    /**
+     * The row source to hand a row-validating DDL on behalf of the connection issuing it, or
+     * undefined when that connection has nothing staged and the underlying's own rows already
+     * ARE its effective rows.
+     *
+     * **Only the issuing connection's overlay feeds validation.** A foreign connection's
+     * overlay may hold rows that collide with the new constraint; that is its problem when it
+     * commits, exactly as an ordinary concurrent duplicate insert would be. A poisoned issuer
+     * overlay is likewise skipped — its rows are structurally stale, and the connection can
+     * only recover by rolling back.
+     */
+    private issuerEffectiveRows;
+    /**
+     * Creates an index on the underlying table, then rebuilds every per-connection overlay so
+     * the new index (and, for a UNIQUE index, the constraint derived from it) is enforced for
+     * the rest of each open transaction.
+     *
+     * Two things the underlying cannot do for itself:
      *
-     * Note: Indexes on per-connection overlays are created lazily when the
-     * overlay is created, by copying from the underlying table's schema.
+     * 1. **Judge the right rows.** The issuing connection's pending rows are in its overlay,
+     *    invisible to the underlying, so a duplicate it staged would slip past the build and a
+     *    duplicate it deleted would spuriously reject it. {@link issuerEffectiveRows} supplies
+     *    the merged view; the underlying builds its physical structure from its own committed
+     *    rows, which is sound because every reader resolves an index entry back to its live row.
+     * 2. **Enforce the new constraint.** An overlay built before the index knows nothing of it,
+     *    and `IsolatedTable.findMergedUniqueConflict` only scans the underlying — so a pending
+     *    row colliding with another pending row is nobody's job until the overlay itself carries
+     *    the index. Hence the rebuild, which is also what gives a merged secondary-index scan
+     *    later in the transaction an overlay that can serve it.
+     *
+     * We use the stored table instance's createIndex() rather than the module-level method so
+     * that the MemoryTable's local tableSchema property stays in sync. That property is what
+     * ensureOverlay() reads when building the overlay schema.
+     */
+    createIndex(db: Database, schemaName: string, tableName: string, indexSchema: IndexSchema, rows?: EffectiveRowSource): Promise<void>;
+    /**
+     * Reads back the underlying table instance's post-`createIndex` schema, asserting it now
+     * carries the new index.
      *
-     * We use the stored table instance's createIndex() rather than the module-level
-     * method so that the MemoryTable's local tableSchema property stays in sync.
-     * That property is what ensureOverlay() reads when building the overlay schema.
+     * Both bundled underlyings refresh the instance's cached `tableSchema` (memory through
+     * `MemoryTable.createIndex`, the store through `StoreTable.updateSchema`), and the overlay
+     * rebuild below copies its index/constraint set from it. A third-party underlying that
+     * refreshed only its module-level schema would silently rebuild overlays under the PRE-index
+     * schema, re-opening the very hole this method exists to close — so assert rather than assume.
      */
-    createIndex(db: Database, schemaName: string, tableName: string, indexSchema: IndexSchema): Promise<void>;
+    private assertIndexPresent;
     /**
      * Drops an index on the underlying table.
      *
@@ -366,11 +617,24 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     dropIndex(db: Database, schemaName: string, tableName: string, indexName: string): Promise<void>;
     /**
-     * Rebuilds an overlay table under the post-drop-index schema, preserving
-     * staged rows (including tombstones). Column layout is unchanged by
-     * DROP INDEX, so rows can be copied verbatim.
+     * Rebuilds every non-poisoned per-connection overlay of one table under a schema whose
+     * index / constraint set just changed (CREATE INDEX or DROP INDEX). Shared because the two
+     * directions differ only in which structures the new schema carries — the column layout is
+     * identical either way, so staged rows copy verbatim.
+     *
+     * A poisoned overlay (from a cross-connection ALTER, or a DROP TABLE) holds rows in the
+     * pre-alter column layout, narrower/wider than `updatedSchema`. Rebuilding it would copy
+     * layout-mismatched rows AND drop the poison flag (the new state carries none), silently
+     * un-poisoning a connection that must still roll back. Leave it as-is.
+     */
+    private rebuildOverlaysForIndexChange;
+    /**
+     * Rebuilds an overlay table under a post-CREATE/DROP-INDEX schema, preserving staged rows
+     * (including tombstones). Column layout is unchanged by either, so rows copy verbatim — but
+     * the new overlay's index/constraint set is not, so an insert here can legitimately raise
+     * UNIQUE (a foreign connection staged two rows the new index forbids).
      */
-    private migrateOverlayForDropIndex;
+    private rebuildOverlayForIndexChange;
     /**
      * Delegates ALTER TABLE to the underlying module and migrates any per-connection
      * overlays to the post-alter schema without discarding staged rows.
@@ -392,15 +656,21 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * ALTER either fails clean or fully applies — base/catalog can no longer diverge.
      * This mirrors the engine's pre-mutation `validateNotNullBackfill` in
      * `runtime/emit/alter-table.ts`.
+     *
+     * **Row-content validation.** The row-validating arms (`add constraint … unique`,
+     * `alter column … set collate`) judge the ISSUING connection's effective rows, not the
+     * underlying's committed ones — see {@link issuerEffectiveRows}. The underlying runs that
+     * check before it mutates anything, so the atomic-abort guarantee above still holds.
      */
-    alterTable(db: Database, schemaName: string, tableName: string, change: SchemaChangeInfo): Promise<TableSchema>;
+    alterTable(db: Database, schemaName: string, tableName: string, change: SchemaChangeInfo, rows?: EffectiveRowSource): Promise<TableSchema>;
     /**
      * Builds the poison message stamped onto a foreign overlay whose backfill could not
      * satisfy a cross-connection ALTER (see {@link alterTable} tier 3). Names the
      * schema.table and the offending column so the owning connection's eventual
-     * read/write/commit error is self-explanatory. Poison only arises on the addColumn
-     * NOT NULL path, so the column name is taken from the addColumn change; other change
-     * types never reach here but are handled defensively.
+     * read/write/commit error is self-explanatory. Poison arises on the addColumn NOT NULL
+     * path (a new NOT-NULL column with no usable default) and the `set not null` tightening
+     * path (a staged NULL with no usable default); other change types never reach here but
+     * are handled defensively.
      */
     private buildAlterPoisonMessage;
     /**
@@ -414,16 +684,60 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * Done in this order so a failure in the underlying rename leaves our
      * internal maps untouched (the engine will not update the schema catalog
      * if this method throws).
+     *
+     * **Why the underlying is re-connected, not re-keyed.** A rename mid-transaction
+     * moves any staged overlay onto the new name, and `commitConnectionOverlays`
+     * resolves an overlay's underlying by that name. Simply re-keying
+     * `underlyingTables` old→new would be cheaper, but the cached `VirtualTable` may
+     * be dead: `StoreModule.renameTable` closes and re-opens the store, so the stale
+     * handle yields "store is closed". So we evict it and, when an overlay was
+     * carried onto the new name, immediately connect a fresh underlying under that
+     * name — otherwise the transaction commits against a table that is in neither
+     * map, and the overlay's rows vanish (see {@link commitConnectionOverlays}'s
+     * invariant). With no overlay carried over there is nothing to flush, so the
+     * eviction alone is enough and the next `connect()` re-resolves lazily.
      */
     renameTable(db: Database, schemaName: string, oldName: string, newName: string): Promise<void>;
+    /**
+     * Forward the engine's post-propagation rename finalize to the underlying (see
+     * {@link renameTable} for the two-phase split). The underlying (e.g. `StoreModule`)
+     * uses it to drop the old name's catalog entry only after the cross-table rewrites
+     * `propagateTableRename` enqueued are durable. `IsolationModule` owns no persistent
+     * catalog of its own and already evicted every old-name state in `renameTable`, so
+     * it simply delegates.
+     */
+    finalizeRename(db: Database, schemaName: string, oldName: string, newName: string): Promise<void>;
+    /**
+     * Connects a fresh underlying table under the post-rename name and records it in
+     * `underlyingTables`, restoring the "every staged overlay resolves to an underlying"
+     * invariant that {@link renameTable}'s eviction would otherwise break.
+     *
+     * `preRenameSchema` is the catalog's pre-rename `TableSchema`; it is cloned under the
+     * new name so the underlying module sees the same column layout, PK, and vtab args it
+     * was created with.
+     *
+     * NOTE: `pAux` is passed as `undefined`: the aux data the engine hands
+     * `IsolationModule.connect()` belongs to *this* wrapper's registration, not the
+     * underlying's, and both bundled underlyings (`MemoryTableModule`, `StoreModule`)
+     * ignore the parameter — the same assumption `connect()` already relies on when it
+     * forwards its own caller's `pAux` straight through. If a third-party underlying ever
+     * reads `pAux` in `connect()`, `IsolationModule` must capture the underlying's own aux
+     * data at registration and hand it back here.
+     */
+    private reconnectUnderlyingAfterRename;
     /**
      * Re-keys all entries of a connection-scoped map (`<dbId>:<schema>.<table>`)
      * from oldName to newName, leaving entries for other tables untouched.
+     * Returns how many entries moved.
      */
     private rekeyConnectionScopedMap;
     /**
      * Rebuilds an overlay table under the post-alter schema, translating each
      * staged row to the new column layout.
+     *
+     * A row the post-alter schema's constraints reject throws CONSTRAINT out of
+     * {@link insertIntoRebuiltOverlay} rather than being silently discarded; the caller
+     * ({@link adoptRebuiltOverlay}) maps that to INTERNAL or poison.
      */
     private migrateOverlayForAlter;
     /**
@@ -442,6 +756,20 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * BEFORE the irreversible underlying mutation and reused by the migration after.
      */
     private deriveAddColumnBackfill;
+    /**
+     * Precomputes the per-ALTER constants an `alter column … set not null` overlay migration needs:
+     * the now-NOT-NULL column's index and the folded literal DEFAULT (with `hasDefault` gating
+     * backfill vs reject). Returns undefined unless this is a NOT NULL *tightening*
+     * (`setNotNull: true`) with at least one overlay to migrate — a DROP NOT NULL loosens and
+     * needs no staged-row work, and with no overlays there is nothing to backfill or reject.
+     *
+     * `change` for `set not null` carries no default expression, so the DEFAULT is read from the
+     * column's PRE-alter schema (via a to-be-migrated overlay — the same source `dropColumnIdx`
+     * uses, and the same layout every migrated overlay shares). Folded exactly as
+     * {@link deriveAddColumnBackfill} folds its DEFAULT, so backfill and reject decisions here
+     * cannot drift from what the underlying enforces over its committed rows.
+     */
+    private deriveSetNotNullBackfill;
     /**
      * Dry-runs an overlay's ALTER migration-fallible work without mutating anything,
      * so the caller can run it for every affected overlay BEFORE the irreversible
@@ -456,8 +784,15 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      *   rows short-circuit to `null` (the evaluator never runs), and a NOT-NULL-violating
      *   evaluated row throws CONSTRAINT here, atomically. Computed values are discarded.
      *
-     * Non-addColumn changes (`addColumnCtx === undefined`) only run the tombstone guard;
-     * their row translation appends/removes nothing fallible on data grounds.
+     * For `set not null` with NO usable DEFAULT (`setNotNullCtx.hasDefault === false`), a staged
+     * non-tombstone NULL at the now-NOT-NULL column throws CONSTRAINT here — for the issuer this
+     * aborts atomically before the underlying mutates; for a foreign overlay the caller maps it to
+     * poison. With a usable DEFAULT the staged NULLs are backfilled by {@link translateOverlayRow},
+     * so nothing is rejected here.
+     *
+     * Non-addColumn / non-tightening changes (`addColumnCtx === undefined` and no reject-mode
+     * `setNotNullCtx`) only run the tombstone guard; their row translation appends/removes nothing
+     * fallible on data grounds.
      */
     private validateOverlayMigration;
     /**
@@ -481,16 +816,43 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * `addColumnValue` is the per-row value the caller computed for an `addColumn`
      * (via {@link computeAddColumnValue}); it is `undefined` for every other change
      * type. Keeping the (async) backfill in the caller's loop lets this stay synchronous.
+     *
+     * `setNotNullCtx` (present only for a `set not null` tightening WITH a usable DEFAULT) maps a
+     * staged NULL at the now-NOT-NULL column to that DEFAULT — filling the issuer's own pending
+     * rows, which the underlying's committed-row backfill never touches. Reject-mode contexts (no
+     * DEFAULT) never reach here: {@link validateOverlayMigration} aborts/poisons first.
      */
     private translateOverlayRow;
-    /** Creates a FilterInfo for a full table scan (no constraints). */
-    private makeFullScanFilterInfo;
     /**
      * Creates overlay schema from underlying schema.
      * Adds tombstone column and uses unique name to avoid conflicts.
      *
-     * Called by IsolatedTable when lazily creating its overlay.
+     * Called by IsolatedTable when lazily creating its overlay, and by the two overlay-rebuild
+     * paths (`rebuildOverlayForIndexChange`, `migrateOverlayForAlter`).
+     *
+     * Every copied secondary index — and every copied UNIQUE constraint, including the ones
+     * a UNIQUE index derives — is narrowed to a PARTIAL structure over live rows only
+     * (`<tombstone> = 0`), AND-ed onto whatever partial predicate it already carried. A
+     * tombstone is a deletion marker, not a row, so no uniqueness rule may be evaluated over
+     * it: it carries its row's PK and NULL everywhere else, so a UNIQUE structure whose
+     * columns all sit inside the PK would otherwise see two deleted rows as duplicates.
+     * (Non-PK unique columns escaped only because their tombstone key is NULL and SQL treats
+     * NULLs as distinct.) The overlay's PRIMARY KEY uniqueness is NOT narrowed — it must keep
+     * covering tombstones so a re-insert at a tombstoned PK is detected and converted.
+     *
+     * `IsolatedTable.mergedSecondaryIndexQuery` wants exactly the live overlay rows out of
+     * these indexes, so narrowing them is what it already expects.
      */
     createOverlaySchema(baseSchema: TableSchema): TableSchema;
+    /**
+     * `<tombstoneColumn> = 0` — the partial-structure predicate that scopes an overlay index
+     * or UNIQUE constraint to live rows. Built as an AST rather than parsed from text because
+     * the tombstone column name is host-configurable.
+     *
+     * NOTE: the default overlay is a `MemoryTableModule`, which honors `IndexSchema.predicate`
+     * and `UniqueConstraintSchema.predicate`. A host that injects its own `config.overlay`
+     * module must honor them too, or its overlay will re-enforce uniqueness over tombstones.
+     */
+    private liveRowPredicate;
 }
 //# sourceMappingURL=isolation-module.d.ts.map

package/dist/src/isolation-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isolation-module.d.ts","sourceRoot":"","sources":["../../src/isolation-module.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"isolation-module.d.ts","sourceRoot":"","sources":["../../src/isolation-module.ts"],"names":[],"mappings":"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"}