@quereus/isolation 4.4.1 → 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;
@@ -227,7 +190,8 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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.
+     * entry per writing transaction (and one more per `alterPrimaryKey` overlay swap — the
+     * only DDL path left that replaces an overlay rather than adopting in place), 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`
@@ -409,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.
@@ -514,7 +491,7 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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;
+    private buildInPlaceAdoptPoisonMessage;
     /**
      * 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
@@ -594,18 +571,21 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      */
     private createOverlayIndex;
     /**
-     * Reads back the underlying table instance's post-`createIndex` schema, asserting it now
-     * carries the new index.
+     * Reads back the underlying table instance's post-`createIndex` schema plus the entry it now
+     * carries for the new index — the canonical post-create form each overlay's copy is derived
+     * from ({@link createOverlayIndex}).
      *
      * 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.
+     * `MemoryTable.createIndex`, the store through `StoreTable.updateSchema`). A third-party
+     * underlying that refreshed only its module-level schema would leave every overlay without
+     * the index — silently re-opening the very hole `createIndex`'s forward exists to close — so
+     * assert rather than assume.
      */
     private assertIndexPresent;
-    /** Case-insensitive "does `schema` declare an index named `indexName`". */
-    private schemaHasIndex;
+    /** `schema`'s index named `indexName` (case-insensitively), if it declares one. */
+    private findSchemaIndex;
+    /** 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.
      *
@@ -614,6 +594,11 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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).
+     *
+     * Mirrors createIndex's early return when neither hook exists too: an underlying that
+     * declares indexes at CREATE TABLE time but cannot drop one still has them, and dropping
+     * from the overlays alone would leave each overlay enforcing LESS than the base it flushes
+     * into — a silent divergence surfacing only as a commit-time rejection.
      */
     dropIndex(db: Database, schemaName: string, tableName: string, indexName: string): Promise<void>;
     /**
@@ -654,7 +639,7 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      * 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
+     * ({@link buildInPlaceAdoptPoisonMessage}). 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
@@ -665,28 +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 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}).
+     * 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 —
@@ -706,17 +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>;
-    /**
-     * 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), 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;
     /**
      * Renames a table through the isolation layer.
      *
@@ -775,242 +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;
-    /**
-     * 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.
-     *
-     * 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
-     * `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.
-     * - 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 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
@@ -1048,6 +778,16 @@ export declare class IsolationModule implements VirtualTableModule<IsolatedTable
      *
      * `IsolatedTable.mergedSecondaryIndexQuery` wants exactly the live overlay rows out of
      * these indexes, so narrowing them is what it already expects.
+     *
+     * NOTE: a base column already named {@link tombstoneColumn} lands here as a SECOND column
+     * of that name, and `columnIndexMap` resolves the name to the appended flag. Harmless
+     * today — every consumer reaches the flag by index, and reads, merged scans, a unique
+     * secondary index over that column and a staged deletion all behave exactly as they do
+     * for a non-colliding name. If anything ever resolves the overlay's columns BY NAME (a
+     * hand-built overlay predicate, a module that re-derives its own index map from the
+     * column list), give the overlay a collision-free flag name here instead. ALTER into the
+     * name is rejected outright — see {@link assertColumnNameNotTombstone} for why that one
+     * cannot be tolerated.
      */
     createOverlaySchema(baseSchema: TableSchema): TableSchema;
     /**
@@ -1073,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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"}