@quereus/isolation 4.3.2 → 4.4.1

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, EffectiveRowSource } from '@quereus/quereus';
+import type { Database, VirtualTableModule, BaseModuleConfig, TableSchema, TableIndexSchema as IndexSchema, ModuleCapabilities, VirtualTable, BestAccessPlanRequest, BestAccessPlanResult, SchemaChangeInfo, Schema, MappingAdvertisement, LensDeploymentSnapshot, VtabConcurrencyMode, VirtualTableConnection, BackingHost, EffectiveRowSource, CatalogObjectKind, ViewSchema } from '@quereus/quereus';
 import type { IsolationModuleConfig } from './isolation-types.js';
 import { IsolatedTable } from './isolated-table.js';
 /**
@@ -40,9 +40,10 @@ export interface ConnectionOverlayState {
      * 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.
+     * Set at every real creation site (`ensureOverlay`, and the ALTER PRIMARY KEY
+     * clean-overlay swap in `replaceOverlayForPrimaryKeyChange`); 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;
     /**
@@ -408,6 +409,18 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * basis module would silently never hear the deployment.
      */
     notifyLensDeployment(db: Database, logicalSchemaName: string, snapshot: LensDeploymentSnapshot): Promise<void>;
+    /**
+     * Forwards the view / materialized-view catalog-persistability veto to the underlying
+     * module.
+     *
+     * `allModules()` yields the REGISTERED module, which is this wrapper when a store is
+     * isolated — so without this forward an isolation-wrapped store would never be
+     * consulted and would keep the silent-drop bug (a view it cannot persist creates
+     * "successfully" and vanishes on reopen). Whether a catalog entry is encodable is a
+     * property of the definition text, not of the overlay, so a straight delegate is
+     * correct; the throw must propagate (that is the entire point of the hook).
+     */
+    assertCatalogObjectPersistable(db: Database, kind: CatalogObjectKind, object: ViewSchema | TableSchema): void;
     /**
      * Delegates access plan selection to the underlying module.
      * This ensures the query planner knows about indexes and can generate
@@ -484,40 +497,22 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     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).
+     * The INTERNAL raised when the DDL-ISSUING connection's own overlay rejects the change the
+     * DDL just made (routed through {@link applyInPlaceOverlayChange} by the index paths and
+     * every ALTER TABLE forward).
+     *
+     * Unreachable by construction: 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 loudly — the
+     * alternative is the silent row loss these guards exist to end.
      */
-    private insertIntoRebuiltOverlay;
+    private issuerOverlayDriftError;
     /**
-     * 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.
+     * Builds the poison message stamped onto a foreign overlay whose staged rows cannot adopt
+     * a constraint another connection's DDL just declared (see
+     * {@link applyInPlaceOverlayChange}). Companion to {@link buildAlterPoisonMessage}, which
+     * covers the data conditions the pre-validation pass rejects before any overlay is touched;
+     * this one covers a UNIQUE (or any other) violation raised by the in-place adoption itself.
      */
     private buildRebuildPoisonMessage;
     /**
@@ -561,9 +556,9 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     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.
+     * Creates an index on the underlying table, then hands the same index to every
+     * per-connection overlay so it (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:
      *
@@ -575,14 +570,29 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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.
+     *    the index. Forwarding 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>;
+    /**
+     * Adds one index to an already-open overlay, in the overlay's own flavor (predicate
+     * narrowed to live rows and rescoped onto the overlay's table name — see
+     * {@link createOverlayIndexSchema}).
+     *
+     * A UNIQUE index the overlay's staged rows violate raises `CONSTRAINT` out of
+     * `MemoryTableManager.createIndex`'s pre-validation pass, which
+     * {@link applyIndexChangeToOverlays} routes to INTERNAL (issuer) or poison (foreign).
+     * The pass runs before any mutation, so a rejected overlay is left exactly as it was.
+     *
+     * No-ops when the overlay module has no index support, or when the overlay already
+     * carries an index of that name (an overlay built after the underlying's create already
+     * copied it in through {@link createOverlaySchema}).
+     */
+    private createOverlayIndex;
     /**
      * Reads back the underlying table instance's post-`createIndex` schema, asserting it now
      * carries the new index.
@@ -594,64 +604,97 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * schema, re-opening the very hole this method exists to close — so assert rather than assume.
      */
     private assertIndexPresent;
+    /** Case-insensitive "does `schema` declare an index named `indexName`". */
+    private schemaHasIndex;
     /**
-     * Drops an index on the underlying table.
+     * Drops an index on the underlying table, then drops it from every per-connection overlay.
      *
      * Mirrors createIndex: when the underlying VirtualTable exposes an
      * instance-level dropIndex (e.g. MemoryTable, which forwards to its manager
      * so MemoryTable.tableSchema stays fresh), prefer that. Otherwise fall back
      * to the module-level dropIndex (e.g. StoreModule, which refreshes the
      * StoreTable's cached tableSchema and tears down the index store).
-     *
-     * Any per-connection overlay that already exists for this table is
-     * rebuilt under the post-drop schema, preserving staged rows. A bare
-     * forward to `overlay.dropIndex` is insufficient: when the overlay's
-     * MemoryTable has an active write `TransactionLayer`, its
-     * `tableSchemaAtCreation` is frozen at layer-creation time, so the
-     * synthesized UNIQUE constraint keeps firing inside the overlay's
-     * own UC check on the next write even after the manager's schema is
-     * refreshed. Rebuilding gives the new MemoryTable a fresh
-     * transaction layer that captures the post-drop schema. Overlays
-     * created AFTER this point inherit the post-drop schema from the
-     * underlying at ensureOverlay time.
      */
     dropIndex(db: Database, schemaName: string, tableName: string, indexName: string): Promise<void>;
     /**
-     * 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.
+     * Drops one index (and the UNIQUE constraint derived from it) from an already-open
+     * overlay. No-ops when the overlay module has no index support, or when the overlay never
+     * carried the index.
      */
-    private rebuildOverlaysForIndexChange;
+    private dropOverlayIndex;
     /**
-     * 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).
+     * Applies an index change (CREATE INDEX or DROP INDEX) IN PLACE to every non-poisoned
+     * per-connection overlay of one table.
+     *
+     * In place, not by rebuild. Both paths used to discard the overlay and copy its staged
+     * rows into a fresh `MemoryTable`, which silently destroyed the overlay's savepoint chain:
+     * the copy's first write lazily registers the new overlay's connection, and
+     * `Database.registerConnection` replays `begin()` plus the whole active savepoint stack
+     * BEFORE the copy runs — so every copied row landed ABOVE the replayed savepoint and the
+     * next `rollback to savepoint` discarded rows staged long before that savepoint was taken
+     * (`bug-isolation-index-ddl-rebuild-drops-savepoint-writes`).
+     *
+     * The rebuild was originally forced by a memory-module limitation — an open write
+     * `TransactionLayer` froze its schema at creation, so a bare `overlay.dropIndex` left the
+     * synthesized UNIQUE constraint firing inside the layer. `TransactionLayer.adoptSchema`
+     * now has both an additive and a removal branch, and `MemoryTableManager` calls it for
+     * both index directions, so an open layer adopts the change with its savepoint snapshots
+     * intact.
+     *
+     * CONSTRAINT is routed by who owns the overlay via {@link applyInPlaceOverlayChange},
+     * shared with every ALTER TABLE forward.
+     *
+     * A poisoned overlay is skipped: it holds rows in a pre-ALTER column layout and its owner
+     * must roll back regardless, so there is nothing to keep enforcing for it.
      */
-    private rebuildOverlayForIndexChange;
+    private applyIndexChangeToOverlays;
     /**
-     * Delegates ALTER TABLE to the underlying module and migrates any per-connection
+     * Applies one in-place DDL mutation to a single overlay, routing a CONSTRAINT failure
+     * by who owns the overlay: the issuer's own overlay → INTERNAL (its rows were already
+     * judged by the DDL's own validation pass, so a rejection here means validation and
+     * migration have drifted — {@link issuerOverlayDriftError}); a foreign overlay →
+     * poison and leave it untouched so its owner errors and rolls back
+     * ({@link buildRebuildPoisonMessage}). Any non-CONSTRAINT failure is a layer-invariant
+     * violation, not a data condition, and rethrows for everyone.
+     *
+     * Shared by the index paths ({@link applyIndexChangeToOverlays}) and the ALTER TABLE
+     * column-shape forwards ({@link alterTable}), so the two cannot drift on error routing.
+     */
+    private applyInPlaceOverlayChange;
+    /**
+     * Delegates ALTER TABLE to the underlying module and carries any per-connection
      * overlays to the post-alter schema without discarding staged rows.
      *
-     * ADD COLUMN  — appends the new column's value to each overlay row's data columns,
-     *               backfilled per row exactly as the committed path does (literal default,
-     *               per-row `new.<col>` evaluator, or NULL); tombstone rows get NULL.
-     * DROP COLUMN — removes the dropped column from each overlay row.
-     * RENAME / ALTER COLUMN — data column indices are unchanged; only schema metadata rotates.
+     * Every change type forwards to each overlay IN PLACE — through the overlay's own
+     * `alterSchema` / `createIndex` / ordinary writes — so the overlay's layer chain and
+     * savepoint snapshots survive the ALTER and `rollback to savepoint` keeps
+     * distinguishing rows staged before the savepoint from rows staged after it (see
+     * {@link applyIndexChangeToOverlays} for why the old rebuild — copying staged rows
+     * into a fresh staging table — destroyed that distinction). Per change type:
+     *
+     * - ADD / DROP / RENAME COLUMN: {@link forwardColumnShapeToOverlay}. ADD COLUMN
+     *   backfills each staged row exactly as the committed path does (literal default,
+     *   per-row `new.<col>` evaluator, or NULL); tombstone rows get NULL.
+     * - ALTER COLUMN: {@link forwardAlterColumnToOverlay}. `set data type` / `set collate`
+     *   / `set default` forward straight through (the overlay module converts / re-keys its
+     *   open layers itself); `set not null` is withheld from the overlay and the staged
+     *   live rows' NULLs are backfilled via ordinary overlay writes instead.
+     * - ADD / DROP / RENAME CONSTRAINT: {@link forwardAddConstraintToOverlay} /
+     *   {@link forwardConstraintNameChangeToOverlay}. A UNIQUE lands as a
+     *   tombstone-narrowed unique index; CHECK forwards verbatim; FOREIGN KEY does not
+     *   forward at all.
+     * - ALTER PRIMARY KEY: no overlay can follow (its layer trees are keyed by the old
+     *   primary key) — the issuer with staged rows is rejected before the underlying
+     *   mutates, a foreign overlay with staged rows is poisoned, and a clean overlay is
+     *   swapped for a fresh staging table ({@link replaceOverlayForPrimaryKeyChange}).
      *
      * **Atomicity guarantee.** DDL through Quereus is not transaction-scoped and the
      * underlying (shared, committed) base auto-commits its mutation immediately —
      * there is no frame to unwind, and `dropColumn` / type-converting `alterColumn`
      * are lossy and not invertible, so "revert the underlying on overlay-migration
      * failure" is not viable. Instead this method **pre-validates** every affected
-     * overlay's backfill (the per-row NOT NULL check and the tombstone-present guard)
-     * BEFORE calling `underlying.alterTable`. A rejection therefore fires while the
+     * overlay's migration (the per-row NOT NULL check, the per-value retype conversion, and
+     * the tombstone-present guard) BEFORE calling `underlying.alterTable`. A rejection therefore fires while the
      * underlying, the schema catalog, and every overlay are still untouched, so the
      * ALTER either fails clean or fully applies — base/catalog can no longer diverge.
      * This mirrors the engine's pre-mutation `validateNotNullBackfill` in
@@ -668,8 +711,9 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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 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
+     * path (a new NOT-NULL column with no usable default), the `set not null` tightening
+     * path (a staged NULL with no usable default), and the `set data type` path (a staged value
+     * that cannot be converted to the new type); other change types never reach here but
      * are handled defensively.
      */
     private buildAlterPoisonMessage;
@@ -731,15 +775,6 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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;
     /**
      * Precomputes the per-ALTER constants an `addColumn` overlay backfill needs:
      * the folded literal DEFAULT (the `tryFoldLiteral` of the DEFAULT expr, or `null`
@@ -764,12 +799,29 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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
+     * column's PRE-alter schema (via a to-be-migrated overlay — 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;
+    /**
+     * Precomputes the per-ALTER constants an `alter column … set data type` overlay conversion
+     * needs: the retyped column's index and a per-value `convert`. Returns undefined unless this
+     * is a retype with at least one overlay to convert, and undefined for an ALIAS retype (the
+     * new logical type IS the old type object — `inferType` flattens `varchar(50)` to
+     * `TEXT_TYPE`) — both underlyings gate their value rewrite on that exact identity
+     * comparison, so mirroring it here keeps overlay and committed rows moving together should
+     * "what counts as a value-rewriting retype" ever change. A same-storage-class retype between
+     * different types (text → date) DOES convert: staged values are validated and normalized to
+     * the new type's canonical spelling, exactly as the underlyings treat their committed rows.
+     *
+     * `inferType` never throws (an unknown type name falls through SQLite-style affinity rules),
+     * so deriving this BEFORE the underlying mutation is safe. `convert` is the literal mirror of
+     * `MemoryTableManager.alterColumn` / `StoreModule.alterColumnSetDataType`: `validateAndParse`,
+     * rethrowing failure as the same MISMATCH message, so the two legs cannot drift.
+     */
+    private deriveSetDataTypeConvert;
     /**
      * 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
@@ -787,14 +839,28 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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.
+     * poison. With a usable DEFAULT the staged NULLs are backfilled by
+     * {@link backfillStagedNotNull}, so nothing is rejected here.
+     *
+     * For `set data type` (`setDataTypeCtx`), every staged non-NULL value is run through the
+     * conversion and the result discarded, so an unconvertible one throws MISMATCH here. For the
+     * ISSUER this is belt-and-braces — the underlying's own pre-mutation pass walks the same rows
+     * via {@link issuerEffectiveRows} — EXCEPT when an outer wrapper supplied `rows`, in which case
+     * this is the only check. For a FOREIGN overlay it is the only pass that ever sees those rows,
+     * and it must run before the migration so a failure becomes poison rather than a half-migrated
+     * overlay.
+     *
+     * Non-addColumn / non-tightening / non-retype changes (`addColumnCtx === undefined`, no
+     * reject-mode `setNotNullCtx`, no `setDataTypeCtx`) only run the tombstone guard; their row
+     * translation appends/removes nothing fallible on data grounds.
      */
     private validateOverlayMigration;
+    /**
+     * The staged rows an overlay holds that represent LIVE data, i.e. every row except the
+     * tombstones — those carry placeholder NULLs at every data column and must never be fed to a
+     * per-value check, which would read a NULL that is not the row's real value.
+     */
+    private stagedLiveRows;
     /**
      * Computes one staged row's value for a freshly added column, mirroring the
      * committed-row backfill (see `base.ts` `recreatePrimaryTreeWithNewColumn` and
@@ -810,25 +876,165 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     private computeAddColumnValue;
     /**
-     * Translates a single overlay row from the pre-alter to the post-alter column layout.
-     * The tombstone value is preserved in the last position.
-     *
-     * `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.
+     * Forwards one column-shape change (ADD / DROP / RENAME COLUMN) to an already-open
+     * overlay IN PLACE via the overlay's optional `alterSchema`. The overlay module (the
+     * memory module by default) reshapes its open transaction layers with their savepoint
+     * snapshots intact, so `rollback to savepoint` keeps distinguishing rows staged before
+     * the savepoint from rows staged after it — the rebuild path destroyed that
+     * distinction in both directions (see {@link applyIndexChangeToOverlays}).
+     *
+     * A missing `alterSchema` is treated as a no-op, the way the index paths treat a
+     * missing `createIndex` / `dropIndex`.
+     *
+     * `dropColumn` / `renameColumn` forward the caller's change unchanged. `addColumn`
+     * forwards an overlay-flavoured copy — see {@link buildOverlayAddColumnChange}.
+     */
+    private forwardColumnShapeToOverlay;
+    /**
+     * The overlay-flavoured form of one `addColumn` change:
+     *
+     * - `insertAtIndex` = the overlay's current tombstone column index, so the new data
+     *   column lands ahead of the tombstone flag and the flag stays LAST — the layout
+     *   every read/write path of this package assumes. A bare forward would append after
+     *   the flag and every value written to the new column would be dropped on read.
+     * - The column definition is made NULLABLE. The overlay's ADD re-runs the overlay
+     *   module's own NOT NULL validation against a different row population than the
+     *   base's: tombstone rows carry placeholder NULL in every non-PK column, so a
+     *   NOT NULL column the base already accepted would be rejected here. The base's
+     *   NOT NULL is still enforced where it belongs — by the engine's pre-mutation
+     *   `validateNotNullBackfill` and the underlying's own ADD (both judged the issuer's
+     *   effective rows), and per staged row by {@link computeAddColumnValue}'s
+     *   evaluator-path check.
+     * - `backfillEvaluator` receives an OVERLAY row (data columns plus the flag) and
+     *   routes through {@link computeAddColumnValue} — the same helper
+     *   {@link validateOverlayMigration} dry-runs, so validation and forward cannot
+     *   drift: NULL for a tombstone row, else the engine's per-row `new.<col>` evaluator
+     *   over the flag-stripped row, or the folded literal default.
+     */
+    private buildOverlayAddColumnChange;
+    /**
+     * Forwards one ALTER COLUMN attribute change to an already-open overlay IN PLACE, with the
+     * NOT NULL attribute deliberately withheld.
+     *
+     * `set data type` / `set collate` / `set default` forward through the overlay's own
+     * `alterSchema`: the overlay module converts / re-keys its open transaction layers with
+     * their savepoint snapshots intact, and NULLs pass a retype untouched, so tombstone rows —
+     * placeholder NULLs at every non-key data column — ride through unharmed.
+     *
+     * `set not null` must NOT forward: the overlay's copy of the column stays nullable.
+     * Tombstone rows carry NULL at every non-PK data column, so the overlay module's own
+     * tightening would backfill a deletion marker's placeholder NULL from the DEFAULT
+     * (corrupting a row that is not a row) or reject it outright when no usable DEFAULT
+     * exists. The base's NOT NULL is enforced where it belongs — by the underlying over the
+     * issuer's effective rows, and per overlay by {@link validateOverlayMigration} — and the
+     * staged LIVE rows' NULLs are filled here via {@link backfillStagedNotNull}. The runtime
+     * admits exactly one attribute per ALTER COLUMN, so a `setNotNull` change carries nothing
+     * else to forward. A missing overlay `alterSchema` is a no-op, as in
+     * {@link forwardColumnShapeToOverlay}.
+     */
+    private forwardAlterColumnToOverlay;
+    /**
+     * Backfills a `set not null` tightening into an overlay's staged LIVE rows: every
+     * non-tombstone row holding NULL at the tightened column is rewritten with the column's
+     * folded literal DEFAULT through the overlay's ordinary write path, so the overlay's layer
+     * chain and savepoint snapshots stay intact — the overlay-side mirror of the value rewrite
+     * the underlying applies to its committed rows. Tombstone rows are never touched
+     * ({@link stagedLiveRows}).
+     *
+     * Only called with a usable DEFAULT ({@link SetNotNullBackfillContext.hasDefault}); the
+     * no-DEFAULT case rejects (issuer) or poisons (foreign) in {@link validateOverlayMigration}
+     * before any overlay is touched.
+     *
+     * NOTE: these rewrites land in the overlay's CURRENT savepoint frame — each is a normal
+     * staged write. A later `rollback to savepoint` taken BEFORE this ALTER therefore restores
+     * the pre-backfill NULL while the column stays NOT NULL (DDL is not transactional here).
+     * That is the same class of divergence as any rolled-back row violating surviving DDL — a
+     * row un-inserted past an ADD CONSTRAINT, say — tracked by the backlog ticket
+     * `bug-rolled-back-rows-violate-surviving-ddl`, not a new hole opened by this forward.
+     */
+    private backfillStagedNotNull;
+    /**
+     * Forwards one ADD CONSTRAINT to an already-open overlay, per constraint class:
+     *
+     * - **UNIQUE** is NOT forwarded as a constraint. The AST `TableConstraint` carries no
+     *   partial-predicate field, so a bare forward would enforce uniqueness over tombstone rows
+     *   too — a UNIQUE whose columns sit inside the primary key would see two deleted rows
+     *   (each carrying its PK and placeholder NULLs elsewhere) as duplicates of each other.
+     *   Instead it lands as a tombstone-narrowed **unique index** through the same route CREATE
+     *   INDEX takes ({@link installOverlayUniqueConstraint}).
+     * - **CHECK** forwards verbatim: the overlay module appends it schema-only (no row scan, no
+     *   physical structure). Enforcement is engine-side at DML plan time against the user
+     *   table; the overlay's copy exists so a later DROP / RENAME CONSTRAINT resolves it.
+     * - **FOREIGN KEY** is deliberately NOT forwarded. FK enforcement is engine-side
+     *   (planner-synthesized EXISTS checks) — the overlay never enforces it — and the overlay
+     *   module's ADD arm validates existing child rows through a catalog query by table name,
+     *   which the unregistered `_overlay_*` staging table cannot serve. The presence guard in
+     *   {@link forwardConstraintNameChangeToOverlay} keeps a later DROP / RENAME of the
+     *   unforwarded FK a clean no-op on the overlay.
+     * - **PRIMARY KEY** cannot reach here — both bundled underlyings reject
+     *   `add constraint … primary key` with UNSUPPORTED before any overlay work — so it asserts
+     *   INTERNAL rather than leaving a silent gap for a third-party underlying that accepts it
+     *   (the overlay could not follow; see the alterPrimaryKey handling in {@link alterTable}).
      */
-    private translateOverlayRow;
+    private forwardAddConstraintToOverlay;
+    /**
+     * Installs one runtime-added UNIQUE constraint on an overlay as a tombstone-narrowed unique
+     * index (see {@link forwardAddConstraintToOverlay} for why a bare constraint forward is
+     * wrong). Column indices and per-column collations are read from the post-alter underlying
+     * schema — the canonical form, positionally identical to the overlay's data columns (the
+     * tombstone flag is appended last). The index is named `constraint name ?? '_uc_<cols>'`,
+     * the memory module's own covering-index naming rule (`implicitIndexNameFor`), so the
+     * derived UNIQUE the overlay module synthesizes from it resolves under the SAME name a
+     * later DROP / RENAME CONSTRAINT forward carries.
+     *
+     * `MemoryTableManager.createIndex` pre-validates the overlay's effective rows against the
+     * narrowed predicate before any mutation, so a staged duplicate raises CONSTRAINT with the
+     * overlay untouched — routed by the caller to INTERNAL (the issuer, whose merged rows the
+     * underlying already judged via {@link issuerEffectiveRows}) or poison (a foreign overlay).
+     * A missing overlay `createIndex` is a no-op, as in the index paths.
+     */
+    private installOverlayUniqueConstraint;
+    /**
+     * Forwards DROP / RENAME CONSTRAINT to an already-open overlay, presence-guarded: a
+     * constraint the overlay never carried is skipped silently rather than letting the overlay
+     * module's NOTFOUND abort the issuer's already-applied ALTER. The guard is what makes the
+     * unforwarded classes safe ({@link forwardAddConstraintToOverlay}: FOREIGN KEY always, and
+     * UNIQUE under an overlay module without `createIndex`) — their DROP / RENAME is simply a
+     * no-op on the overlay.
+     *
+     * For a UNIQUE the overlay module drops/renames the constraint AND its covering index in
+     * lock-step — both live under the constraint's name (or the `_uc_<cols>` implicit-name
+     * rule), whether copied at overlay creation ({@link createOverlaySchema}) or installed by
+     * {@link installOverlayUniqueConstraint} — so the base and overlay representations stay
+     * resolvable by one name across the whole constraint lifecycle.
+     */
+    private forwardConstraintNameChangeToOverlay;
+    /** Case-insensitive "does `schema` declare a named constraint of ANY class (CHECK / UNIQUE / FOREIGN KEY)". */
+    private schemaHasNamedConstraint;
+    /**
+     * Carries one overlay across an ALTER PRIMARY KEY, which no overlay can follow in place:
+     * its layer BTrees are keyed by the OLD primary key, and a staged tombstone identifies the
+     * row it deletes BY that key — under a new key a tombstone's identity columns may be
+     * placeholder NULLs, i.e. garbage. So:
+     *
+     * - An overlay WITH staged rows is either the ISSUER's — unreachable, {@link alterTable}
+     *   rejected it before the underlying mutated, so assert INTERNAL — or FOREIGN, which is
+     *   poisoned exactly like a foreign overlay whose staged values a retype cannot convert.
+     * - A CLEAN overlay stages nothing; it is swapped for a fresh empty staging table built
+     *   from the post-alter schema, so later writes in this transaction key by the new primary
+     *   key. The fresh table's connection registers lazily at its first write, replaying the
+     *   active savepoint stack — correct for a table with no pre-existing staged rows (the
+     *   replay hazard is only ever about rows copied beneath it, and there are none).
+     */
+    private replaceOverlayForPrimaryKeyChange;
     /**
      * Creates overlay schema from underlying schema.
      * Adds tombstone column and uses unique name to avoid conflicts.
      *
-     * Called by IsolatedTable when lazily creating its overlay, and by the two overlay-rebuild
-     * paths (`rebuildOverlayForIndexChange`, `migrateOverlayForAlter`).
+     * Called by IsolatedTable when lazily creating its overlay, and by the ALTER PRIMARY KEY
+     * clean-overlay swap (`replaceOverlayForPrimaryKeyChange`). Index DDL and every other ALTER
+     * adopt in place — a new UNIQUE arrives through {@link createOverlayIndexSchema} /
+     * {@link overlayPredicate}, which this method shares.
      *
      * 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
@@ -844,6 +1050,31 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * these indexes, so narrowing them is what it already expects.
      */
     createOverlaySchema(baseSchema: TableSchema): TableSchema;
+    /**
+     * The overlay-flavored form of one base `IndexSchema`: same name and columns, predicate
+     * narrowed to live rows and rescoped onto the overlay's table name (see
+     * {@link overlayPredicate}).
+     *
+     * Shared by {@link createOverlaySchema}, which maps the whole index set when an overlay is
+     * first created, and {@link createIndex}, which hands a single index to an overlay that is
+     * already open — so both produce structurally identical entries, and the UNIQUE constraint
+     * `MemoryTableManager.createIndex` synthesizes from a unique index inherits the same
+     * predicate either way.
+     */
+    private createOverlayIndexSchema;
+    /**
+     * `<base predicate, rescoped to the overlay> AND <tombstone> = 0`.
+     *
+     * A partial-index / UNIQUE predicate copied from the base carries a self-qualifier bound to
+     * the base table's name (e.g. `where t.v > 0`). The overlay renames the table to
+     * `overlayName`, so that qualifier now names a DIFFERENT table than the overlay's
+     * MemoryIndex is scoped to — and `compilePredicate` rejects a foreign qualifier at
+     * index-build time (see partial-index-predicate table-qualifier rejection). Rescope the
+     * self-qualifier to the overlay name so it stays a self-reference. A foreign qualifier
+     * cannot occur here: `compilePredicate` already rejected one when the base index/UNIQUE
+     * was created, so every qualifier present is the base name.
+     */
+    private overlayPredicate;
     /**
      * `<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

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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"}