@quereus/isolation 4.5.0 → 4.6.0

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

@@ -1,6 +1,7 @@
-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 type { Database, VirtualTableModule, BaseModuleConfig, TableSchema, TableIndexSchema as IndexSchema, ModuleCapabilities, BestAccessPlanRequest, BestAccessPlanResult, SchemaChangeInfo, Schema, MappingAdvertisement, LensDeploymentSnapshot, VtabConcurrencyMode, VirtualTableConnection, BackingHost, EffectiveRowSource, CatalogObjectKind, ViewSchema } from '@quereus/quereus';
+import type { ConnectionOverlayState, IsolationModuleConfig, Predicate, UnderlyingTableState } from './isolation-types.js';
 import { IsolatedTable } from './isolated-table.js';
+import type { AlterMigrationHost } from './alter-migration.js';
 /**
  * Generates a unique overlay ID for each overlay table instance.
  * Used to avoid name conflicts when multiple overlays exist.
@@ -21,44 +22,6 @@ export declare function weakerMode(a: VtabConcurrencyMode, b: VtabConcurrencyMod
  * invariant is enforced.
  */
 export declare function clampToReentrantReads(mode: VtabConcurrencyMode): VtabConcurrencyMode;
-/**
- * Per-table state tracking the underlying table (shared across all connections).
- */
-export interface UnderlyingTableState {
-    underlyingTable: VirtualTable;
-}
-/**
- * Per-connection overlay state for a specific table.
- * Each connection gets its own overlay that persists across IsolatedTable instances.
- */
-export interface ConnectionOverlayState {
-    overlayTable: VirtualTable;
-    hasChanges: boolean;
-    /**
-     * 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`, 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;
-    /**
-     * 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;
-    };
-}
 /**
  * A module wrapper that adds transaction isolation to any underlying module.
  *
@@ -81,7 +44,7 @@ export interface ConnectionOverlayState {
  *   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> {
+export declare class IsolationModule implements VirtualTableModule<IsolatedTable, BaseModuleConfig>, AlterMigrationHost {
     readonly underlying: VirtualTableModule<any, any>;
     readonly overlayModule: VirtualTableModule<any, any>;
     readonly tombstoneColumn: string;
@@ -410,6 +373,19 @@ 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 module registration to the underlying module.
+     *
+     * `Database.registerModule` calls `onRegister` on the REGISTERED module, which is this
+     * wrapper when a store is isolated. The underlying module uses it to subscribe to the
+     * database's schema-change notifier before any statement runs; without this forward an
+     * isolation-wrapped store would fall back to subscribing lazily at its first table
+     * hook and would silently drop a view created ahead of that.
+     *
+     * Which `Database` the module serves is isolation-transparent, so a straight delegate
+     * is correct; a throw must propagate (it fails the registration by contract).
+     */
+    onRegister(db: Database, moduleName: string): void;
     /**
      * Forwards the view / materialized-view catalog-persistability veto to the underlying
      * module.
@@ -608,8 +584,8 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
     private assertIndexPresent;
     /** `schema`'s index named `indexName` (case-insensitively), if it declares one. */
     private findSchemaIndex;
-    /** Case-insensitive "does `schema` declare an index named `indexName`". */
-    private schemaHasIndex;
+    /** Case-insensitive "does `schema` declare an index named `indexName`". Part of {@link AlterMigrationHost}. */
+    schemaHasIndex(schema: TableSchema, indexName: string): boolean;
     /**
      * Drops an index on the underlying table, then drops it from every per-connection overlay.
      *
@@ -674,31 +650,20 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * Delegates ALTER TABLE to the underlying module and carries any per-connection
      * overlays to the post-alter schema without discarding staged rows.
      *
-     * Every change type forwards to each overlay IN PLACE — through the overlay's own
+     * The migration machinery itself — deriving the per-change-type constants, dry-running
+     * one overlay against them, and reshaping it forward — lives in `alter-migration.ts`;
+     * this method owns the surrounding lifecycle. Every change type but one forwards to each
+     * overlay IN PLACE via {@link migrateOverlayForward} — 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 through the overlay's `alterSchema` (the overlay module
-     *   converts / re-keys its open layers itself), with one preparation step: a `set collate`
-     *   that re-keys the PRIMARY KEY first discards any deletion markers the new key collapses
-     *   onto another staged row ({@link dropCollapsedPkRekeyMarkers}). `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}).
+     * into a fresh staging table — destroyed that distinction).
+     *
+     * ALTER PRIMARY KEY is the exception: no overlay can follow it (its layer trees are keyed
+     * by the old primary key), so 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 —
@@ -718,37 +683,6 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * check before it mutates anything, so the atomic-abort guarantee above still holds.
      */
     alterTable(db: Database, schemaName: string, tableName: string, change: SchemaChangeInfo, rows?: EffectiveRowSource): Promise<TableSchema>;
-    /**
-     * Rejects an ADD / RENAME COLUMN that would give a base column the same name as the
-     * overlay's private tombstone flag, BEFORE `underlying.alterTable` runs.
-     *
-     * Every overlay carries one extra column named {@link tombstoneColumn}, so a base column
-     * of that name collides with it. Forwarding the change to an open overlay makes the
-     * overlay module raise a duplicate-name `ERROR`, which is not a data condition and so
-     * rethrows out of {@link applyInPlaceOverlayChange} — after the underlying has already
-     * (irreversibly) applied. The catalog then keeps the pre-alter column set while the base
-     * holds the new one, and the next write to the table lands values against the wrong
-     * columns. Rejecting up front keeps the atomic-abort guarantee this method documents.
-     *
-     * NOTE: the check is unconditional — not gated on an overlay existing — so the answer
-     * does not depend on whether some connection happens to have a transaction open. That
-     * also stops a table from acquiring the colliding name while idle and hitting
-     * {@link createOverlaySchema}'s (silent) duplicate at the next BEGIN. A CREATE TABLE
-     * declaring the name still gets that duplicate — tracked separately.
-     */
-    private assertColumnNameNotTombstone;
-    /**
-     * 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 arises on the addColumn NOT NULL
-     * path (a new NOT-NULL column with no usable default), the `set not null` tightening
-     * path (a staged NULL with no usable default), the `set data type` path (a staged value
-     * that cannot be converted to the new type), and the primary-key `set collate` path (two
-     * staged live rows colliding under the new collation); other change types never reach
-     * here but are handled defensively.
-     */
-    private buildAlterPoisonMessage;
     /**
      * Renames a table through the isolation layer.
      *
@@ -807,342 +741,6 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * Returns how many entries moved.
      */
     private rekeyConnectionScopedMap;
-    /**
-     * Precomputes the per-ALTER constants an `addColumn` overlay backfill needs:
-     * the folded literal DEFAULT (the `tryFoldLiteral` of the DEFAULT expr, or `null`
-     * when there is no DEFAULT or it folds to NULL), the engine-supplied per-row
-     * evaluator (present only for a non-foldable `new.<col>` default), and whether
-     * the new column is NOT NULL. Returns undefined for every non-`addColumn` change
-     * so the row loop appends nothing.
-     *
-     * The new column's nullability is resolved exactly as both underlyings resolve it
-     * (`columnDefToSchema(columnDef, default_column_nullability === 'not_null')`) so the
-     * pre-validation cannot drift from what the underlying will enforce. Because it is
-     * derived purely from `change` + the session option — not the post-alter schema,
-     * which does not exist until `underlying.alterTable` runs — this can be built
-     * 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 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;
-    /**
-     * Precomputes the per-ALTER constants a primary-key re-keying `alter column … set collate`
-     * overlay migration needs: the PK column positions and a key serializer built over the
-     * POST-change collation — the PRE-alter overlay schema with the named column's collation
-     * replaced. The overlay's PK definition mirrors the base's (the tombstone flag is appended
-     * after the data columns), so the synthesized schema keys exactly as the re-keyed base will.
-     *
-     * Returns undefined unless the named column is a PRIMARY KEY member and the normalized
-     * collation actually differs from the column's current one — mirroring the underlying's
-     * metadata-only gate (`MemoryTableManager.alterColumn`'s `nameMatches`), so overlay and
-     * committed rows re-key together or not at all. `validateCollationForType` can throw for an
-     * unknown collation, but the engine already validated the name before dispatching the ALTER,
-     * and a direct module caller gets the same pre-mutation rejection the underlying would give.
-     */
-    private derivePkRekey;
-    /**
-     * Buckets an overlay's staged rows by their PRIMARY KEY as the pending `set collate` will
-     * re-key it: one {@link PkRekeyGroup} per post-change key. Shared by the validation dry run
-     * (which refuses a group holding two live rows) and the migrate-step marker drop (which
-     * discards collapsed markers), so the two passes cannot disagree about what collapses.
-     *
-     * NOTE: materializes one serialized key + one PK tuple per staged row (plus the marker rows
-     * themselves), once per pass of one ALTER. If an overlay with very many staged rows ever
-     * makes this ALTER slow, group lazily or reuse the merge `effectiveRowsFor` already builds.
-     */
-    private collectPkRekeyGroups;
-    /**
-     * 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
-     * `underlying.alterTable` (see {@link alterTable}). It exercises the EXACT code
-     * paths the real migration uses — the tombstone-present guard and, for addColumn,
-     * `computeAddColumnValue` per staged row — so a dry-run pass and the subsequent
-     * migrate pass cannot diverge:
-     *
-     * - A clean overlay (`!hasChanges`) stages no rows, so there is nothing to validate.
-     * - A missing tombstone column throws INTERNAL here, before the underlying is touched.
-     * - For addColumn, each staged row runs through `computeAddColumnValue`: tombstone
-     *   rows short-circuit to `null` (the evaluator never runs), and a NOT-NULL-violating
-     *   evaluated row throws CONSTRAINT here, atomically. Computed values are discarded.
-     *
-     * 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 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.
-     *
-     * For a primary-key re-keying `set collate` (`pkRekeyCtx`), the staged rows are grouped by
-     * their POST-change key: a deletion marker sharing a key with one live row is that row's
-     * before-image (the migrate step discards it — {@link dropCollapsedPkRekeyMarkers}), and
-     * markers alone on one key are one deletion — neither is a duplicate. Two LIVE rows on one
-     * key ARE, so that throws CONSTRAINT here, mirroring the underlying's own collision message.
-     * For the ISSUER this is belt-and-braces (the underlying's pre-mutation pass judges the same
-     * staged rows via {@link issuerEffectiveRows}, though this check fires first); for a FOREIGN
-     * overlay it is the only pass that sees those rows, and its throw becomes poison.
-     *
-     * Non-addColumn / non-tightening / non-retype / non-re-key changes (`addColumnCtx ===
-     * undefined`, no reject-mode `setNotNullCtx`, no `setDataTypeCtx`, no `pkRekeyCtx`) 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
-     * `store-module.ts` `migrateRows`):
-     *
-     * - Tombstone rows carry NULL placeholders and their appended value is never read,
-     *   so append `null` and never run the evaluator against them (it could reference
-     *   NULL siblings or spuriously trip the NOT NULL check).
-     * - With a per-row evaluator, derive the value from the existing-columns slice and
-     *   enforce NOT NULL on that path only (a literal/NULL default's nullability is gated
-     *   up-front by the engine, exactly as `base.ts` does).
-     * - Otherwise use the folded literal default.
-     */
-    private computeAddColumnValue;
-    /**
-     * 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.
-     *   A caller that named its own position keeps it: the overlay's data columns mirror
-     *   the base's one-for-one below the flag, so the base's index is the overlay's too.
-     *   (SQL always appends, so today the caller never names one — but silently ignoring
-     *   it would diverge the two layouts.)
-     * - 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. One preparation
-     * step precedes a PRIMARY-KEY re-keying `set collate` (`pkRekeyCtx`): deletion markers the
-     * re-key collapses onto another staged row are discarded first
-     * ({@link dropCollapsedPkRekeyMarkers}) — the overlay's PK deliberately covers markers, so
-     * without the drop its own `alterSchema` would reject the collapsed pair as a PK collision.
-     *
-     * Neither NOT NULL direction forwards, and the overlay's `notNull` flag is left where it
-     * stood when the overlay was created:
-     *
-     * - **Tightening (`set not null`).** Forwarding would have the overlay module tighten a
-     *   column whose tombstone rows carry NULL at every non-PK data column, so it would either
-     *   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}.
-     * - **Relaxing (`drop not null`).** Nothing to do: the overlay never enforced the flag, and
-     *   the rows it stages are written with `preCoerced: true` through the overlay module's own
-     *   write path, which does not consult column nullability at all.
-     *
-     * NOTE: both directions therefore leave the overlay's `notNull` flag drifted from the base
-     * for the rest of the transaction. Inert today — nothing on the overlay path reads it. The
-     * one consumer that would, `MemoryTableModule.getBestAccessPlan` (which prunes `IS NULL` on
-     * a NOT NULL column to an empty result), is unreachable because the isolation layer builds
-     * the overlay's `FilterInfo` itself (see `filter-info.ts`) instead of planning against the
-     * overlay module. If overlay scans ever route through the overlay module's planner hook, or
-     * its write path starts enforcing nullability, this has to become a real forward that
-     * excludes tombstones.
-     *
-     * 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;
-    /**
-     * Discards the deletion markers a pending PRIMARY-KEY re-key collapses onto another staged
-     * row, through the overlay's ordinary write path so its layer chain and savepoint snapshots
-     * stay intact. Two shapes collapse (see {@link PkRekeyContext}): a marker sharing its
-     * post-change key with a live row is that row's before-image — the live row's flush upsert
-     * is the complete net effect, so the marker is dropped; markers alone together on one key
-     * are one deletion, so all but the first are dropped. A group holding two live rows was
-     * already refused by {@link validateOverlayMigration} before the underlying mutated.
-     *
-     * Runs BEFORE the re-key is forwarded to the overlay, and deletes by each marker's OLD
-     * primary key — the overlay is still keyed under the old collation at that moment.
-     *
-     * NOTE: like {@link backfillStagedNotNull}'s rewrites, the drops land in the overlay's
-     * CURRENT savepoint frame. A later `rollback to savepoint` taken BEFORE this ALTER restores
-     * the marker while the table stays re-keyed — the same divergence class that method's NOTE
-     * documents (`bug-rolled-back-rows-violate-surviving-ddl`), not a new hole opened here.
-     */
-    private dropCollapsedPkRekeyMarkers;
-    /**
-     * The whole overlay rows of every deletion marker {@link dropCollapsedPkRekeyMarkers} will
-     * discard, computed without mutating anything. Re-planning after the drops finds nothing
-     * (each group then holds at most one marker and no marker beside a live row), so the
-     * issuer path — which drops in tier 2 for the pre-flight — can safely run the shared
-     * migrate-step drop again as a no-op.
-     */
-    private planPkRekeyMarkerDrops;
-    /** Deletes each planned marker by its OLD primary key through the overlay's ordinary write path. */
-    private applyPkRekeyMarkerDrops;
-    /**
-     * Undoes {@link applyPkRekeyMarkerDrops} after a refusal that aborts the whole ALTER —
-     * the overlay pre-flight's or the underlying's (see the tier-2 re-key block in
-     * {@link alterTable}). Reinserts each marker row verbatim: a marker minted for a committed
-     * row carries NULL at every non-key data column, but one made by deleting a row this
-     * transaction had already staged keeps that row's values (the convert-to-tombstone branch
-     * of `IsolatedTable.update`), so a reconstructed-from-PK row would not restore what was
-     * dropped. The reinserts land in the same savepoint frame the drops did, so the pair nets
-     * to nothing.
-     */
-    private reinsertPkRekeyMarkers;
-    /** The overlay's tombstone-flag column index, or INTERNAL if the schema lost it. */
-    private requireTombstoneIndex;
-    /**
-     * 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 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
@@ -1215,8 +813,11 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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.
+     *
+     * Part of {@link AlterMigrationHost} — `alter-migration.ts` builds an overlay UNIQUE index
+     * through this same seam.
      */
-    private overlayPredicate;
+    overlayPredicate(base: Predicate | undefined, baseName: string, overlayName: string): Predicate;
     /**
      * `<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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"}