@quereus/store 4.5.0 → 4.7.0

package/dist/src/common/store-module-schema-sync.js

@@ -0,0 +1,529 @@
+/**
+ * Keeping the engine's live schema and the persisted catalog in agreement, in both
+ * directions: reading the catalog back at open (rehydration), lazily reconnecting a
+ * table the engine already knows about, and reacting to the engine's schema-change
+ * notifications (catalog-only tag swaps, view/materialized-view DDL upkeep, and the
+ * stale-materialized-view set that survives a restart).
+ *
+ * Third layer of the store-module chain:
+ *   StoreModuleBase -> StoreModuleCatalog -> StoreModuleSchemaSync -> StoreModuleIndex
+ *   -> StoreModuleAlterColumn -> StoreModuleAlter -> StoreModuleRename -> StoreModule
+ */
+import { isMaintainedTable } from '@quereus/quereus';
+import { StoreTable } from './store-table.js';
+import { buildCatalogKey, classifyCatalogKey, parseMaterializedViewCatalogKey } from './key-builder.js';
+import { StoreModuleCatalog } from './store-module-catalog.js';
+export class StoreModuleSchemaSync extends StoreModuleCatalog {
+    /**
+     * Returns the connected StoreTable for `schemaName.tableName`, lazily
+     * reconnecting from the engine's schema registry when absent.
+     *
+     * `renameTable` evicts the old key from `this.tables` and expects the next
+     * `connect()` to repopulate under the new name, but `apply schema` can run
+     * follow-up DDL (ALTER TABLE, CREATE/DROP INDEX) against the new name
+     * without an intervening connect. Mirror connect()'s schemaManager lookup
+     * so that DDL finds the moved table. Safe for the index paths because
+     * SchemaManager calls the module BEFORE mutating the registered table
+     * schema, so the reconnected cache matches what a connected instance holds.
+     */
+    getOrReconnectTable(db, schemaName, tableName) {
+        const tableKey = `${schemaName}.${tableName}`.toLowerCase();
+        let table = this.tables.get(tableKey);
+        if (!table) {
+            const registeredSchema = db.schemaManager.getTable(schemaName, tableName);
+            if (registeredSchema) {
+                table = new StoreTable(db, this, registeredSchema, this.parseConfig(registeredSchema.vtabArgs ?? {}), this.eventEmitter, true);
+                this.tables.set(tableKey, table);
+            }
+        }
+        return table;
+    }
+    /**
+     * Rehydrate the persisted catalog into the in-memory schema manager, in
+     * dependency order.
+     *
+     * Re-asserts the engine schema-change subscription up front — normally already
+     * established by `StoreModule.onRegister` at `Database.registerModule`, but this
+     * entry point is also reachable with a `db` this module was never registered on, and
+     * phase 3 cannot observe MV staleness without it. Then loads every catalog entry
+     * once, classifies each by its key prefix into {tables, views, materialized views},
+     * and imports in three phases:
+     *
+     *   1. **Tables** — `importCatalog` (connect to existing storage; refresh connected
+     *      `StoreTable` schemas).
+     *   2. **Views** — `importCatalog` (engine silent-register; body validation deferred
+     *      to query time, so order among views — and view-over-MV / view-over-view —
+     *      does not matter, and no schema-change event fires → phase 2 writes nothing).
+     *   3. **Materialized views** — `importCatalog` per entry (engine re-materialize:
+     *      rebuilds the memory backing from current source data, re-registers row-time
+     *      maintenance, re-runs the eligibility gate — the same core the create emitter
+     *      uses, but silent: no `materialized_view_added` fires, so phase 3 writes
+     *      nothing back to the catalog). A store-hosted backing that phase 1 already
+     *      rehydrated is **adopted without the refill** when the engine's adopt gates
+     *      pass — see the clean-shutdown marker below.
+     *
+     * **Clean-shutdown marker.** Before anything loads, the reserved
+     * `\x00meta\x00clean_shutdown` catalog entry (written by `StoreModule.closeAll` after
+     * every batch flushed) is consumed: parsed into `{ trusted, staleAtClose }`, then
+     * **deleted immediately** — single-use, so a crash later in this session (or a
+     * second rehydrate without an intervening clean close) is detected at the next open
+     * and every adopt falls back to the always-correct drop+refill, self-healing any
+     * crash-window divergence (coordinated commit is not 2PC across stores). The marker
+     * payload is the JSON set of MVs that were **stale-at-close** (row-time maintenance
+     * detached, so the durable backing may be behind); phase 3 withholds trust per-entry
+     * for those — `trustBackings: trusted && !staleAtClose.has(name)` — so a
+     * stale-at-close MV refills (recomputing content and re-arming maintenance) while
+     * every live-at-close MV keeps the fast path. The one shared `adoptedBackings` set
+     * composes across fixpoint rounds (an upstream MV adopted in round 1 enables its
+     * dependent in round 2, while a refilled — or stale-at-close — upstream is never
+     * added to it, forcing dependents to refill).
+     *
+     * **MV-over-MV ordering** is handled by a fixpoint retry rather than a static topo
+     * sort: an MV's resolved `sourceTables` are computed at import time, not serialized
+     * in the DDL, so they are unavailable before import. Each round passes the names of
+     * every OTHER still-pending MV entry as `pendingDerivations`; the engine defers any
+     * entry whose body reads one (its source already pre-exists as a phase-1 plain
+     * table, so the body would otherwise plan against content the upstream's own import
+     * may be about to replace). The loop repeats while any MV makes progress — robust to
+     * arbitrary nesting depth. A genuinely unbuildable MV — a missing (e.g. memory)
+     * source, or an unresolvable cycle — makes no progress in a round and is recorded in
+     * `errors`.
+     *
+     * Per-entry errors in any phase are collected (not fatal) so one bad object does not
+     * abort the rest.
+     *
+     * Call after `db.registerModule()` (and `db.setDefaultVtabName()` if DDL may lack a
+     * USING clause).
+     */
+    async rehydrateCatalog(db) {
+        // Idempotent: `StoreModule.onRegister` already subscribed at `db.registerModule`.
+        // Kept because `rehydrateCatalog` is also reachable with a `db` this module was
+        // never registered on (tests, embedders driving rehydration directly), and because
+        // the subscription must exist before phase 3 can observe MV staleness.
+        this.ensureSchemaSubscription(db);
+        // Capability gate (method presence — matching the coordinator's own gate): an
+        // atomic-commit provider commits a source write and its same-module backing in
+        // one all-or-nothing batch, so a crash can no longer tear them apart (the
+        // crash-divergence window gate 5 historically guarded). In that domain, gate 4
+        // alone governs same-module backings and a non-stale backing adopts after a crash
+        // too — the LOGICAL-staleness window is closed instead by the durable stale-MV
+        // set, which (unlike the clean-shutdown marker) survives a crash. A non-atomic
+        // provider never writes the set (see `StoreModuleBase.atomicProvider`), so skip the read.
+        const atomic = this.atomicProvider;
+        const durableStale = atomic ? await this.readDurableStaleMvSet() : { present: false };
+        // Consume the clean-shutdown marker FIRST (before the catalog scan): in the
+        // non-atomic domain its presence is the adopt trust basis for this rehydration
+        // only, and deleting it immediately makes it single-use. Its payload names the MVs
+        // that were stale-at-close. Always consumed for single-use hygiene even in the
+        // atomic branch (where its trust bit is ignored in favor of the durable set).
+        const { trusted, staleAtClose } = await this.consumeCleanShutdownMarker();
+        // Per-entry adopt trust basis, capability-aware:
+        // - Atomic domain WITH a durable stale-set on disk → gate 4 alone governs; the
+        //   marker is NOT required, so a non-stale backing adopts even after a crash. A
+        //   present-but-unparseable stale-set (`stale === null`) refills everything.
+        // - Otherwise (non-atomic provider, OR atomic but no stale-set yet — the upgrade
+        //   path) → today's marker path, byte-for-byte.
+        const trustBacking = (name) => atomic && durableStale.present
+            ? durableStale.stale !== null && !durableStale.stale.has(name)
+            : trusted && !staleAtClose.has(name);
+        const entries = await this.loadCatalogEntries();
+        const result = { tables: [], indexes: [], views: [], materializedViews: [], errors: [] };
+        if (entries.length === 0)
+            return result;
+        const recordError = (ddl, e) => {
+            const error = e instanceof Error ? e : new Error(String(e));
+            console.warn(`[StoreModule] Failed to rehydrate DDL entry, skipping: ${error.message}\n  DDL: ${ddl.substring(0, 120)}`);
+            result.errors.push({ ddl, error });
+        };
+        // Classify every loaded entry by key prefix. The full-range catalog scan returns
+        // table, view, and MV entries intermixed; each must reach the correct phase — a
+        // view/MV entry fed to the table-phase importCatalog would fail-loud or mis-handle.
+        const tableDDLs = [];
+        const viewDDLs = [];
+        // MV entries retain their qualified `schema.mv` name (derived from the catalog
+        // key) so phase 3 can withhold the adopt fast path per-entry for any MV that
+        // was stale-at-close.
+        const mvEntries = [];
+        for (const { key, ddl } of entries) {
+            switch (classifyCatalogKey(key)) {
+                case 'view': {
+                    viewDDLs.push(ddl);
+                    break;
+                }
+                case 'materializedView': {
+                    mvEntries.push({ name: parseMaterializedViewCatalogKey(key), ddl });
+                    break;
+                }
+                // Meta entries are store-internal, never DDL. (The marker itself was
+                // already consumed above; this guards any future meta key.)
+                case 'meta': {
+                    break;
+                }
+                default: {
+                    tableDDLs.push(ddl);
+                    break;
+                }
+            }
+        }
+        // Phase 1 — tables. Per-entry import isolates a corrupt entry so the rest load.
+        for (const ddl of tableDDLs) {
+            try {
+                const imported = await db.schemaManager.importCatalog([ddl]);
+                result.tables.push(...imported.tables);
+                result.indexes.push(...imported.indexes);
+            }
+            catch (e) {
+                recordError(ddl, e);
+            }
+        }
+        // Phase 2 — views (silent register; deferred body validation → order-independent).
+        for (const ddl of viewDDLs) {
+            try {
+                const imported = await db.schemaManager.importCatalog([ddl]);
+                result.views.push(...imported.views);
+            }
+            catch (e) {
+                recordError(ddl, e);
+            }
+        }
+        // Phase 3 — materialized views, dependency-ordered via fixpoint retry (see
+        // docstring). One shared adopt ledger across all rounds: adopted upstream
+        // backings unlock their dependents' adoption in later rounds.
+        const adoptedBackings = new Set();
+        let pending = mvEntries;
+        while (pending.length > 0) {
+            const failed = [];
+            let progressed = false;
+            for (const entry of pending) {
+                try {
+                    // Ordering gate (unified model): a dependent's source may already
+                    // pre-exist as the upstream's phase-1 *plain* table, so its body
+                    // PLANS before the upstream's own MV entry has imported. Pass the
+                    // names of every OTHER still-pending MV entry; the engine defers
+                    // (throws → retried next round) any entry whose body reads one.
+                    const pendingDerivations = new Set(pending.filter(p => p !== entry).map(p => p.name));
+                    // Trust this backing only when the per-entry capability-aware basis
+                    // (`trustBacking`) holds: in the atomic domain a non-stale backing is
+                    // trusted (even after a crash); otherwise a clean shutdown AND not
+                    // stale-at-close. A withheld MV refills — recomputing content and
+                    // re-arming maintenance (clearing `stale`) — and is never added to
+                    // `adoptedBackings`, so the ledger gate forces its MV-over-MV dependents
+                    // to refill too.
+                    const imported = await db.schemaManager.importCatalog([entry.ddl], {
+                        trustBackings: trustBacking(entry.name),
+                        adoptedBackings,
+                        pendingDerivations,
+                    });
+                    result.materializedViews.push(...imported.materializedViews);
+                    progressed = true;
+                }
+                catch (e) {
+                    failed.push({ entry, error: e });
+                }
+            }
+            if (!progressed) {
+                // No MV built this round → the remaining failures are genuine (missing
+                // source, ineligible body, unresolvable cycle). Record them and stop.
+                for (const f of failed)
+                    recordError(f.entry.ddl, f.error);
+                break;
+            }
+            pending = failed.map(f => f.entry);
+        }
+        // Refresh each connected StoreTable from the now-current registry. During
+        // import, `importTable` connects a StoreTable holding the table-only schema,
+        // then `importIndex` appends the index (and its derived UNIQUE constraint) to
+        // the SchemaManager's registered schema but NOT to that live StoreTable
+        // instance — `importCatalog` deliberately skips module hooks to stay generic,
+        // so the store module reconciles here. Without this, DML on a rehydrated table
+        // would not maintain its indexes and the derived UNIQUE would not enforce.
+        //
+        // Per-table isolation, matching the per-entry posture above: `updateSchema`
+        // validates the incoming schema's key collations, and an INDEX-appended schema
+        // can fail where the phase-1 table-only import passed (an index column naming a
+        // collation this connection never registered, or a comparator-only one). On a
+        // refusal, record the error and EVICT the instance rather than leaving it live
+        // on the import-time index-less schema — a half-schema'd table would accept DML
+        // without maintaining its indexes. The registered schema stays; the next
+        // statement to touch the table reconnects, and the StoreTable constructor
+        // re-raises the same error at the point of use.
+        for (const [tableKey, table] of [...this.tables.entries()]) {
+            const current = table.getSchema();
+            const fresh = db.schemaManager.getTable(current.schemaName, current.name);
+            if (!fresh)
+                continue;
+            try {
+                table.updateSchema(fresh);
+            }
+            catch (e) {
+                recordError(`<index reconcile for ${current.schemaName}.${current.name}>`, e);
+                this.tables.delete(tableKey);
+                // Fire-and-forget: the eviction is complete without it (nothing reads the
+                // instance again), so a failing stats flush must not reject the rehydrate —
+                // but it must not become an unhandled rejection either.
+                void table.dispose().catch(disposeError => console.warn(`[StoreModule] dispose of evicted ${current.schemaName}.${current.name} failed: ${String(disposeError)}`));
+            }
+        }
+        // Recompute the durable stale-MV set from the now-current flags and compare-write
+        // it: refilled MVs cleared `stale`, adopted MVs were never stale, so the on-disk
+        // entry (which a crash may have left naming an MV this rehydrate just refilled)
+        // now reflects post-rehydrate truth — preventing a wasteful re-refill at the next
+        // open. Phase 3's `importCatalog` is silent (no schema-change events fire), so the
+        // listener never ran this rehydration; this explicit tail write establishes the
+        // session baseline (`lastPersistedStaleMvs`). It rides `persistQueue`, drained by
+        // the next `closeAll`/`whenCatalogPersisted`. (An optimization, not soundness: a
+        // crash before it lands leaves a stale-set that only over-names → a sound refill.)
+        this.persistStaleMvSetIfChanged();
+        return result;
+    }
+    /**
+     * Subscribe (once) to the engine's `SchemaChangeNotifier`, the channel every
+     * event-driven catalog write rides: `table_added` (a new store table's entry),
+     * catalog-only mutations that bypass `module.alterTable` — notably `ALTER … SET TAGS`
+     * and the programmatic `setTableTags`/`setColumnTags`/`setConstraintTags` — and the
+     * whole view / materialized-view lifecycle.
+     *
+     * Normally called from `StoreModule.onRegister` at `Database.registerModule`, before
+     * any statement runs; also called from `rehydrateCatalog` and the `create`/`connect`/
+     * `alterTable` hooks, which are reachable with a `db` this module was not registered
+     * on. Idempotent.
+     *
+     * One `StoreModule` instance is assumed to serve one `Database`. A later hook
+     * carrying a *different* `db` keeps the existing subscription (multi-database
+     * sharing of a single module instance is out of scope) and logs.
+     */
+    ensureSchemaSubscription(db) {
+        if (this.schemaListenerUnsub) {
+            if (this.subscribedDb && this.subscribedDb !== db) {
+                console.warn('[StoreModule] ensureSchemaSubscription called with a different Database; '
+                    + 'keeping the existing subscription (one module instance is assumed to serve one Database).');
+            }
+            return;
+        }
+        this.subscribedDb = db;
+        // A fresh subscription has no on-disk stale-set baseline yet (this module never
+        // wrote one this session); reset so the first relevant event — or the rehydrate
+        // tail — re-establishes it rather than comparing against a prior subscription's.
+        this.lastPersistedStaleMvs = undefined;
+        this.schemaListenerUnsub = db.schemaManager.getChangeNotifier().addListener(this.onEngineSchemaChange);
+    }
+    /**
+     * Engine schema-change listener. Persists the catalog incrementally for the events
+     * that bypass `module.alterTable` / `module.destroy`:
+     *
+     * - `table_added` — a table the engine has just fully validated and registered. This is
+     *   what persists a store table nobody ever reads or writes (the lazy
+     *   first-storage-access save never runs for one).
+     * - `table_modified` — every catalog-only tag swap (and the redundant follow-up a
+     *   structural ALTER fires). Keeps a connected `StoreTable`'s cached schema consistent
+     *   (SET TAGS does not call `updateSchema`) then read-compare-writes the table bundle.
+     * - `view_added` / `view_modified` / `view_removed` — plain `CREATE`/`ALTER … SET TAGS`/
+     *   `DROP VIEW` (the engine fires these from the runtime emitters).
+     * - `materialized_view_added` / `_modified` / `_refreshed` / `_removed` — MV lifecycle.
+     *   Like `table_modified`, the `_added`/`_modified`/`_refreshed` arms also synchronously
+     *   refresh the connected `StoreTable`'s cached schema so a tag change (e.g.
+     *   `quereus.sync.replicate`) takes effect immediately without reopen.
+     *
+     * Unlike the table path there is **no** catalog-absent self-filter for view/MV
+     * add/remove: one `StoreModule` instance serves one `Database`, so that database's
+     * views/MVs belong in its catalog unconditionally. A MEMORY-hosted maintained table
+     * fires `table_added`/`table_removed`/`table_modified` like any table; those stay
+     * ignored (`table_added` fails the ownership filter, `table_removed` falls through,
+     * its `table_modified` is catalog-absent → skipped), so only the MV entry persists for
+     * it. A STORE-hosted maintained table additionally persists its own table bundle
+     * through the ordinary store-table machinery (which phase-1 rehydrate connects for the
+     * adopt fast path).
+     *
+     * Synchronous by contract (`notifyChange` does not await listeners); every async write
+     * rides `persistQueue`, drained by `closeAll`/`whenCatalogPersisted`.
+     *
+     * After dispatching the event's own catalog persistence, the listener recomputes the
+     * durable stale-MV set and compare-writes it (see {@link persistStaleMvSetIfChanged}).
+     * Because the engine's MV manager subscribes to the same notifier in the `Database`
+     * constructor — before this lazy subscription — its listener runs first, so the
+     * `derivation.stale` flags are already current when this recompute reads them.
+     */
+    onEngineSchemaChange = (event) => {
+        this.dispatchSchemaChange(event);
+        // Every staleness SET transition is bracketed by an event observed here (a source
+        // `table_modified`/`table_removed`, or the synthetic backing-invalidation
+        // `table_modified` for an MV-over-MV cascade), and every CLEAR but the no-event
+        // rename-restore fires one too — so recompute on each event keeps the durable set
+        // current. Enqueued on `persistQueue` AFTER the dispatch above, so the `sync` lands
+        // after the event's own source-DDL write is queued (the durability ordering the
+        // adopt soundness argument relies on — see `docs/mv-backing-host.md` § Cross-module atomicity).
+        this.persistStaleMvSetIfChanged();
+    };
+    /**
+     * Dispatch a single engine schema-change event to its catalog-persistence arm.
+     *
+     * The `table_added` arm is where a store table's catalog entry is written. It fires
+     * from `SchemaManager.createTable` only AFTER the engine has fully validated the table
+     * (notably `validateForeignKeyCollations`, which runs after `module.create` returns and
+     * throws WITHOUT calling `destroy`) and registered it — so, unlike an eager write
+     * inside `StoreModule.create`, it can never leave an entry behind for a table the user
+     * never got, which would reopen as a phantom table.
+     *
+     * Two things distinguish this arm from the view/MV arms above it:
+     *
+     * - **It self-filters on ownership.** Every table the engine registers is announced,
+     *   including memory tables and other modules'. `ownsTableCatalogEntry` is the test for
+     *   "would this module write that table's entry" (and already handles the isolation
+     *   wrapper, whose `vtabModule` is the wrapper exposing us as `underlying`). The
+     *   view/MV arms need no such filter — views and MVs are not owned by a module.
+     * - **It compare-writes rather than blind-puts.** `table_added` is re-delivered during
+     *   rehydration for a store-hosted materialized-view backing
+     *   (`SchemaManager.createBackingTable`), where the entry phase 1 already wrote is
+     *   current; comparing keeps that a no-op so a second consecutive reopen still yields
+     *   identical catalog bytes. (Plain table import during rehydration is silent — no
+     *   `table_added` fires at all.)
+     *
+     * A failure on this path is logged and swallowed by `enqueuePersist`, not raised on the
+     * statement — identical to how `create view` / `create materialized view` already
+     * persist. That is why `StoreTableBase.initializeStore` keeps its first-storage-access
+     * catalog write as a compare-write BACKSTOP: it is the only site where a table whose
+     * DDL text cannot be encoded at all (a lone surrogate in a quoted column name, a
+     * DEFAULT string literal, a CHECK constant) still raises on a statement.
+     */
+    dispatchSchemaChange(event) {
+        switch (event.type) {
+            // NOTE: the compare-write costs one catalog READ per CREATE TABLE, and the
+            // first-storage-access backstop costs a second one. DDL is rare, so neither is
+            // worth avoiding today; if a schema-heavy `apply schema` creating many tables at
+            // once ever shows up hot here, have the arm hand the freshly written bundle to
+            // the StoreTable (as `createIndex` does with `markDdlSaved`) so the backstop can
+            // be skipped outright.
+            case 'table_added': {
+                const table = event.newObject;
+                if (!this.ownsTableCatalogEntry(table))
+                    return;
+                // `newObject` is the post-`finalizeCreatedTableSchema` schema, so it already
+                // carries the store's reconciled PK collations — byte-identical to what the
+                // first-storage-access backstop in `StoreTableBase.initializeStore` writes,
+                // which is what makes that backstop a compare-skip rather than a second put.
+                this.enqueuePersist(() => this.persistTableCatalogEntryIfChanged(table));
+                return;
+            }
+            case 'table_modified': {
+                // SET TAGS does not call `table.updateSchema`, so a connected instance's cached
+                // schema would otherwise go stale (and a later lazy `saveTableDDL` could re-write
+                // tag-less DDL). Persistence below always reads `newObject`, never this cache.
+                const tableKey = `${event.schemaName}.${event.objectName}`.toLowerCase();
+                const connected = this.tables.get(tableKey);
+                if (connected)
+                    connected.updateSchema(event.newObject);
+                const key = buildCatalogKey(event.schemaName, event.objectName);
+                const newObject = event.newObject;
+                this.enqueuePersist(() => this.persistCatalogIfChanged(key, newObject));
+                return;
+            }
+            case 'view_added':
+            case 'view_modified': {
+                const view = event.newObject;
+                this.enqueuePersist(() => this.saveViewDDL(view));
+                return;
+            }
+            case 'view_removed': {
+                const { schemaName, objectName } = event;
+                this.enqueuePersist(() => this.removeViewDDL(schemaName, objectName));
+                return;
+            }
+            case 'materialized_view_added':
+            case 'materialized_view_modified':
+                // Unified model: the payload is the maintained table itself.
+                this.refreshConnectedMaterializedView(event.schemaName, event.objectName, event.newObject);
+                return;
+            case 'materialized_view_refreshed':
+                // DDL is usually unchanged by a REFRESH (body/tags identical) → compare-skip,
+                // but re-read tags in case they were updated alongside the refresh.
+                this.refreshConnectedMaterializedView(event.schemaName, event.objectName, event.object);
+                return;
+            case 'materialized_view_removed': {
+                const { schemaName, objectName } = event;
+                // DROP MAINTAINED detaches catalog-only: the engine has already swapped the
+                // catalog entry to a plain (derivation-less) schema before firing this event,
+                // but a connected `StoreTable` still caches the maintained schema. The store's
+                // `alterTable` reads that cache (`getSchema`), so a following structural ALTER
+                // would spread the stale `derivation` onto the rebuilt schema and re-register
+                // the table as a materialized view (rejecting the next ALTER). Refresh the cache
+                // to the now-plain catalog entry. When the entry is gone entirely (DROP TABLE /
+                // DROP MATERIALIZED VIEW), there is nothing to refresh — `destroy` retires it.
+                const plain = this.subscribedDb?.schemaManager.getTable(schemaName, objectName);
+                if (plain && !isMaintainedTable(plain)) {
+                    const connected = this.tables.get(`${schemaName}.${objectName}`.toLowerCase());
+                    if (connected)
+                        connected.updateSchema(plain);
+                }
+                this.enqueuePersist(() => this.removeMaterializedViewDDL(schemaName, objectName));
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /**
+     * Shared MV add/modify/refresh handling. Narrow defensively — a derivation-less
+     * payload would be an engine bug, so skip. Otherwise, mirror `table_modified`:
+     * synchronously refresh a connected `StoreTable`'s cached schema (so a tag change
+     * such as `quereus.sync.replicate` takes effect immediately without reopen) before
+     * enqueuing the catalog DDL persist.
+     */
+    refreshConnectedMaterializedView(schemaName, objectName, payload) {
+        if (!isMaintainedTable(payload))
+            return;
+        const key = `${schemaName}.${objectName}`.toLowerCase();
+        const connected = this.tables.get(key);
+        if (connected)
+            connected.updateSchema(payload);
+        this.enqueuePersist(() => this.saveMaterializedViewDDL(payload));
+    }
+    /**
+     * The qualified lowercased `schema.mv` names of every maintained table currently
+     * marked `derivation.stale` — an MV whose row-time maintenance detached mid-session
+     * (a body-relevant `table_modified`/`table_removed` on a source, or a cascade
+     * backing-invalidation), so its durable backing may be behind. The single source of
+     * truth for both the clean-shutdown marker payload and the durable stale-MV set.
+     *
+     * No subscribed db ⇒ the empty set. Since `StoreModule.onRegister` subscribes at
+     * `Database.registerModule`, that now means a module never registered on any
+     * `Database` (constructed and closed directly) — which by construction observed no
+     * schema at all, so it detached no persisted MV's maintenance. Memory-backed MVs that appear here
+     * are harmless — their catalog entries always refill (no phase-1 pre-existing
+     * backing), so withholding trust from them is a no-op.
+     */
+    computeStaleMvSet() {
+        return this.subscribedDb
+            ? this.subscribedDb.schemaManager.getAllMaintainedTables()
+                .filter(mv => mv.derivation.stale)
+                .map(mv => `${mv.schemaName}.${mv.name}`.toLowerCase())
+            : [];
+    }
+    /**
+     * Recompute the durable stale-MV set and, only when it differs from the last value
+     * enqueued this subscription (`StoreModuleBase.lastPersistedStaleMvs`), enqueue a `sync: true`
+     * point-write of it onto `StoreModuleBase.persistQueue`. The compare-skip keeps an unrelated
+     * `table_modified` (a tag swap that changes no MV's staleness) from costing an fsync.
+     *
+     * The recompute reads `derivation.stale` synchronously (the flags are current at
+     * listener-dispatch time); the field is updated synchronously at enqueue time, and
+     * `persistQueue` serializes the writes in order, so the field always names the last
+     * enqueued value. Riding `persistQueue` (rather than a bare `put`) also serializes
+     * this `sync` behind the triggering event's own source-DDL compare-write, so the
+     * stale-set becomes durable no-later-than the source DDL that caused the staleness —
+     * the ordering the adopt soundness argument depends on.
+     */
+    persistStaleMvSetIfChanged() {
+        // Only an atomic-capable session writes the durable set — it is the sole reader and
+        // trust basis (see `StoreModuleBase.atomicProvider`); a non-atomic session's trust basis is the
+        // clean-shutdown marker, so writing the set there is both useless and a soundness
+        // hazard (it could be trusted by a later atomic reopen). Skip before recomputing.
+        if (!this.atomicProvider)
+            return;
+        const json = JSON.stringify(this.computeStaleMvSet());
+        if (json === this.lastPersistedStaleMvs)
+            return;
+        this.lastPersistedStaleMvs = json;
+        this.enqueuePersist(() => this.writeDurableStaleMvSet(json));
+    }
+}
+//# sourceMappingURL=store-module-schema-sync.js.map

package/dist/src/common/store-module-schema-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-module-schema-sync.js","sourceRoot":"","sources":["../../../src/common/store-module-schema-sync.ts"],"names":[],"mappings":"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"}