@quereus/store 4.5.0 → 4.7.0

package/dist/src/common/store-module-base.d.ts

@@ -0,0 +1,268 @@
+/**
+ * Module-wide state and storage plumbing shared by every layer of the generic
+ * KVStore-backed virtual-table module: the provider handle, the cached store and
+ * {@link StoreTable} maps, the single shared transaction coordinator, the
+ * serialized catalog-write queue, and the physical-store-name collision guard.
+ *
+ * Base of the store-module layer chain:
+ *   StoreModuleBase -> StoreModuleCatalog -> StoreModuleSchemaSync -> StoreModuleIndex
+ *   -> StoreModuleAlterColumn -> StoreModuleAlter -> StoreModuleRename -> StoreModule
+ */
+import type { BaseModuleConfig, Database, LensDeploymentSnapshot, SqlValue, TableSchema } from '@quereus/quereus';
+import type { KVStore, KVStoreProvider } from './kv-store.js';
+import type { StoreEventEmitter } from './events.js';
+import { TransactionCoordinator } from './transaction.js';
+import { StoreTable } from './store-table.js';
+import type { StoreTableConfig } from './store-table-base.js';
+/**
+ * Listener the host binds via `StoreModule.setLensDeploymentListener` to
+ * forward a logical `apply schema` lens deployment onward (typically to the sync
+ * layer's basis-table lifecycle bookkeeping). Kept as a plain callback so
+ * `@quereus/store` stays free of a `@quereus/sync` dependency; the worker — which
+ * depends on both — wires the two together.
+ */
+export type LensDeploymentListener = (db: Database, logicalSchemaName: string, snapshot: LensDeploymentSnapshot) => void | Promise<void>;
+/**
+ * Configuration options for StoreModule tables.
+ */
+export interface StoreModuleConfig extends BaseModuleConfig {
+    /** Collation for text keys. Default: 'NOCASE'. */
+    collation?: 'BINARY' | 'NOCASE';
+    /**
+     * Serialized-byte budget for a single index-build write batch (see
+     * `buildIndexEntries` (store-module-index-build.ts)). Set from the `max_batch_bytes`
+     * module arg; a missing / non-positive value falls back to
+     * {@link DEFAULT_MAX_BATCH_BYTES}. Module-wide, not per-index.
+     */
+    maxBatchBytes?: number;
+    /** Additional platform-specific options. */
+    [key: string]: unknown;
+}
+/**
+ * Default serialized-byte budget for a single index-build write batch. Bounds
+ * heap directly: `buildIndexEntries` (store-module-index-build.ts) flushes and starts a fresh
+ * batch whenever the accumulated key bytes cross this, so a table larger than
+ * memory never buffers its whole index in one batch. A byte budget (rather than a
+ * fixed entry count) is used because index entries vary in size, so bytes bound
+ * memory more tightly. 8 MiB trades a modest number of extra flushes against peak
+ * memory; override per store with `using store (max_batch_bytes = …)`.
+ */
+export declare const DEFAULT_MAX_BATCH_BYTES: number;
+/**
+ * Build the set of physical store names this module's data/index stores
+ * currently occupy in `schemaName`, mapping each name to a human description
+ * of the logical object that owns it (for sited collision messages).
+ *
+ * Physical store names are built by string concatenation (`{schema}.{table}` /
+ * `{schema}.{table}_idx_{index}`) and the `_idx_` delimiter is itself a legal
+ * substring of any identifier, so two distinct logical objects (e.g. index
+ * `archive` on `t` and a sibling table `t_idx_archive`) can collapse to the
+ * same physical name. This set is the authoritative occupancy used by
+ * {@link StoreModuleBase.assertStoreNameFree} to reject such a collision at CREATE time.
+ *
+ * The occupancy is the union of two sources, robust to lazy connection and the
+ * isolation wrapper (see the ticket's "Enumeration source" section):
+ *   1. `tables` — every store table the owning module touched this session.
+ *   2. the target schema's catalog tables whose `vtabModule === owner` and which
+ *      are not views — store-backed tables not yet lazily connected.
+ * Names embed the schema prefix, so cross-schema entries never collide and no
+ * per-schema filter on `tables` is needed. Memory-backed siblings and
+ * views own no store in this provider and are excluded (the `=== owner` /
+ * `!isView` filter) to avoid false-positive rejects.
+ *
+ * No self-exclusion: at each guarded call the candidate object is not yet
+ * registered (create/createIndex run before the engine adds it) so it cannot
+ * self-collide; and for renameTable the renamed table's OWN stores stay in the
+ * set deliberately. Any overlap between a name the rename introduces and an
+ * own current store is a footprint-swap rename (`t` with index `x` → `t_idx_x`,
+ * or table `u_idx_x` with index `x` → `u`) that providers cannot relocate
+ * safely — relocation order determines whether a source is clobbered before it
+ * is moved — while no benign rename produces such an overlap. Keeping own
+ * stores in the set therefore causes no false rejects and keeps the
+ * reject-before-any-side-effect guarantee uniform.
+ *
+ * `owner` is the module instance whose stores these are — the concrete `StoreModule` at
+ * the top of the layer chain, which this base layer cannot name without an import cycle.
+ * It is a parameter (rather than `this`) purely so the identity check keeps a real type
+ * instead of needing a cast; the enumeration itself reads no other module state.
+ */
+export declare function collectOccupiedStoreNames(tables: Iterable<StoreTable>, db: Database, schemaName: string, owner: object): Map<string, string>;
+export declare abstract class StoreModuleBase {
+    protected provider: KVStoreProvider;
+    protected stores: Map<string, KVStore>;
+    /**
+     * The single transaction coordinator shared by every {@link StoreTable} this
+     * module owns — the unit of cross-table atomicity (see {@link getCoordinator}).
+     * Lives for the module's lifetime: a single table's drop must NOT evict it
+     * (sibling tables still use it); only `StoreModule.closeAll` clears it.
+     */
+    protected moduleCoordinator?: TransactionCoordinator;
+    protected tables: Map<string, StoreTable>;
+    protected eventEmitter?: StoreEventEmitter;
+    /**
+     * Optional listener wired by the host (the worker) to forward a logical
+     * `apply schema` lens deployment to the sync layer's lifecycle bookkeeping.
+     * The store module is the only basis-backing host with both persistence and a
+     * `db` handle, so it is the forwarder; `@quereus/store` must not depend on
+     * `@quereus/sync`, so the listener is a plain callback the worker binds.
+     */
+    protected lensDeploymentListener?: LensDeploymentListener;
+    /** Unsubscribe thunk for the engine `SchemaChangeNotifier` listener, set on first hook with a `db`. */
+    protected schemaListenerUnsub?: () => void;
+    /** The `Database` whose notifier we subscribed to. One module instance serves one `Database`. */
+    protected subscribedDb?: Database;
+    /**
+     * Serialized chain of pending catalog writes triggered by engine schema-change
+     * events (catalog-only tag swaps). `notifyChange` invokes listeners synchronously
+     * and does not await them, so the actual read-compare-write runs here, in order,
+     * and is drained by `closeAll` (and `whenCatalogPersisted`) before the provider closes.
+     */
+    protected persistQueue: Promise<unknown>;
+    /**
+     * The JSON-serialized stale-MV set last enqueued onto {@link persistQueue} (the
+     * `\x00meta\x00stale_mvs` value), or `undefined` when no baseline is established
+     * for the current subscription. The schema-change listener compares each
+     * recomputed set against this so an unrelated `table_modified` (e.g. a tag swap
+     * that changes no MV's staleness) costs no extra fsync. Reset to `undefined`
+     * whenever a fresh `Database` is subscribed (`StoreModuleSchemaSync.ensureSchemaSubscription`) so
+     * a reopened module re-establishes the baseline from the first relevant event (or
+     * the rehydrate tail).
+     */
+    protected lastPersistedStaleMvs: string | undefined;
+    /**
+     * Whether the provider exposes an atomic cross-store commit domain
+     * ({@link KVStoreProvider.beginAtomicBatch}) — the capability the MV adopt fast
+     * path's gate-5 drop hinges on. Fixed for the provider's lifetime, so cached at
+     * construction (and used as the single gate for both writing AND reading the durable
+     * stale-MV set). Gating the **write** on it is load-bearing for soundness, not just an
+     * fsync saving: only an atomic-capable session — whose commits can never tear a source
+     * from its same-module backing — ever writes the durable set, so the set a later atomic
+     * session reads was necessarily written under that same no-tear guarantee. A persistent
+     * non-atomic provider therefore can never leave a torn-but-"not-stale" set for an atomic
+     * reopen to trust (it writes none); such a store falls back to the clean-shutdown marker.
+     */
+    protected readonly atomicProvider: boolean;
+    constructor(provider: KVStoreProvider, eventEmitter?: StoreEventEmitter);
+    /**
+     * Get the KVStoreProvider used by this module.
+     */
+    getProvider(): KVStoreProvider;
+    /**
+     * Get the event emitter for this module.
+     */
+    getEventEmitter(): StoreEventEmitter | undefined;
+    /**
+     * Get a table by schema and name.
+     */
+    getTable(schemaName: string, tableName: string): StoreTable | undefined;
+    /**
+     * Parse module configuration from vtab args.
+     */
+    protected parseConfig(args: Record<string, SqlValue> | undefined): StoreModuleConfig;
+    /**
+     * Get or create a data store for a table.
+     */
+    getStore(schemaName: string, tableName: string, _config: StoreTableConfig): Promise<KVStore>;
+    /**
+     * Get or create an index store for a table.
+     */
+    getIndexStore(schemaName: string, tableName: string, indexName: string): Promise<KVStore>;
+    /**
+     * Get or create a stats store for a table.
+     */
+    getStatsStore(schemaName: string, tableName: string): Promise<KVStore>;
+    /**
+     * Get (lazily constructing) the SINGLE transaction coordinator shared by every
+     * table this module owns — the unit of cross-table atomicity. Every
+     * {@link StoreTable} attaches to the same instance, so a transaction touching
+     * several of the module's tables commits/rolls back as one all-or-nothing
+     * batch.
+     *
+     * Synchronously constructible: ops are addressed by explicit store handle, so
+     * the coordinator never needs to open a store to be created. This lets callers
+     * that must stay synchronous (e.g. a `BackingHost.connect()`) obtain a working
+     * coordinator before any table's store has been opened.
+     */
+    getCoordinator(): TransactionCoordinator;
+    /**
+     * Flush the module's buffered writes before a DDL operation that physically
+     * rewrites or relocates storage.
+     *
+     * Such a DDL cannot honor the coordinator's buffer: pending ops are
+     * `(keyBytes, valueBytes, store)` triples computed at DML time under the
+     * PRE-DDL schema, and every physical rewrite (`StoreTable.rekeyRows` /
+     * `migrateRows`, the provider's directory move) reads and writes the COMMITTED
+     * store directly. Replaying stale-schema ops over the rewritten store on the
+     * eventual commit corrupts, loses, or misfiles those rows. So an `ALTER TABLE`
+     * that touches storage is effectively DDL-committing on a store-backed table:
+     * flush NOW, before the first physical read, so the rewrite sees every live row
+     * and there is nothing left to replay afterwards.
+     *
+     * Consequences, both deliberate:
+     * - The coordinator is module-wide, so this commits the WHOLE module
+     *   transaction — every table's pending ops, not just the altered/renamed
+     *   table's — in one all-or-nothing batch. An ALTER cannot half-commit some
+     *   sibling tables.
+     * - Validation running AFTER this point (e.g. `ALTER PRIMARY KEY`'s duplicate-key
+     *   pass — `rekeyRows` pass 1, which must see the flushed rows because a pending
+     *   insert can itself be the duplicate) throws with the enclosing transaction
+     *   already flushed. The store stays unmutated — only the transaction is gone.
+     *   Validation that can read effectively belongs before the call, so the
+     *   transaction survives it — the SET COLLATE PK re-key does exactly that
+     *   (`StoreTable.validateRekeyedPrimaryKey` reads the effective rows, pending
+     *   ops included, before this flush; `rekeyRows` pass 1 is only its backstop).
+     *
+     * Subsequent `commit()` calls on the same coordinator are no-ops
+     * (`inTransaction` is cleared), which keeps the enclosing transaction safe.
+     * The savepoint stack is cleared too, so a later `ROLLBACK TO` / `RELEASE` that
+     * the engine still broadcasts warns and degrades rather than throwing — see
+     * `TransactionCoordinator.rollbackToSavepoint`, which mirrors the memory
+     * module's identical posture.
+     */
+    protected ddlCommitPendingOps(): Promise<void>;
+    /**
+     * Append a catalog-persistence task to the serialized `persistQueue`, so successive
+     * mutations (e.g. SET TAGS (a=1) then SET TAGS ()) apply in order and are drained by
+     * `closeAll`/`whenCatalogPersisted` before the provider closes. Errors are
+     * swallowed+logged to mirror `notifyChange`'s own try/catch contract — a listener
+     * rejection must never escape.
+     */
+    protected enqueuePersist(work: () => Promise<void>): void;
+    /**
+     * Resolve once all catalog writes queued by async schema-change listeners
+     * (catalog-only tag swaps) have settled. A durability barrier: `closeAll` awaits
+     * it internally; callers/tests that need the persisted catalog current without a
+     * full close can await it directly. Never rejects — queued errors are logged in
+     * the chain.
+     */
+    whenCatalogPersisted(): Promise<void>;
+    /**
+     * The physical index-store names a table owns for DROP / RENAME TABLE to relocate
+     * or reclaim: the MATERIALIZED index set — every explicit `CREATE INDEX` PLUS the
+     * hidden `_uc_*` realizing each plain UNIQUE. Reading only `getSchema().indexes`
+     * (the engine-facing schema, which carries no `_uc_*`) would strand a `_uc_*` store
+     * on disk after DROP TABLE, and — worse — after RENAME TABLE leave the renamed
+     * table seeking a freshly-created EMPTY `_uc_*` store, silently accepting a
+     * duplicate of a pre-rename row. Prefers the cached StoreTable's own materialized
+     * schema; falls back to materializing the schema-manager copy when the instance is
+     * already gone.
+     */
+    protected materializedIndexNames(table: StoreTable | undefined, fallback: TableSchema | undefined): string[];
+    /**
+     * Throws `StatusCode.ERROR` when `candidate` (a physical store name produced by
+     * the key-builder for an object about to be created/renamed) already names an
+     * existing data or index store in `schemaName`. `candidateDesc` describes the
+     * incoming logical object; the message names the candidate physical store and
+     * both conflicting logical objects and is actionable (rename one of them).
+     *
+     * Must run BEFORE any storage side-effect (`getStore` / `getIndexStore` / the
+     * physical relocation): the provider opens/creates the store eagerly, so a
+     * guard that ran after would already have aliased the colliding object's store.
+     *
+     * Callers checking several candidates against the same occupancy (renameTable
+     * checks the new data store plus every relocated index store) pass a
+     * precomputed `occupied` map so the occupancy is collected once, not per call.
+     */
+    protected assertStoreNameFree(db: Database, schemaName: string, candidate: string, candidateDesc: string, occupied?: Map<string, string>): void;
+}
+//# sourceMappingURL=store-module-base.d.ts.map

package/dist/src/common/store-module-base.d.ts.map

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

package/dist/src/common/store-module-base.js

@@ -0,0 +1,362 @@
+/**
+ * Module-wide state and storage plumbing shared by every layer of the generic
+ * KVStore-backed virtual-table module: the provider handle, the cached store and
+ * {@link StoreTable} maps, the single shared transaction coordinator, the
+ * serialized catalog-write queue, and the physical-store-name collision guard.
+ *
+ * Base of the store-module layer chain:
+ *   StoreModuleBase -> StoreModuleCatalog -> StoreModuleSchemaSync -> StoreModuleIndex
+ *   -> StoreModuleAlterColumn -> StoreModuleAlter -> StoreModuleRename -> StoreModule
+ */
+import { QuereusError, StatusCode } from '@quereus/quereus';
+import { TransactionCoordinator } from './transaction.js';
+import { withImplicitUniqueIndexes } from './implicit-unique-index.js';
+import { buildDataStoreName, buildIndexStoreName } from './key-builder.js';
+/**
+ * Default serialized-byte budget for a single index-build write batch. Bounds
+ * heap directly: `buildIndexEntries` (store-module-index-build.ts) flushes and starts a fresh
+ * batch whenever the accumulated key bytes cross this, so a table larger than
+ * memory never buffers its whole index in one batch. A byte budget (rather than a
+ * fixed entry count) is used because index entries vary in size, so bytes bound
+ * memory more tightly. 8 MiB trades a modest number of extra flushes against peak
+ * memory; override per store with `using store (max_batch_bytes = …)`.
+ */
+export const DEFAULT_MAX_BATCH_BYTES = 8 * 1024 * 1024; // 8 MiB
+/**
+ * Resolve the index-build batch byte budget from a `max_batch_bytes` module arg.
+ * A missing, non-numeric, or non-positive value falls back to
+ * {@link DEFAULT_MAX_BATCH_BYTES} — a zero or negative budget must NEVER disable
+ * flushing, which would restore the unbounded single-batch behavior this guards
+ * against.
+ */
+function resolveMaxBatchBytes(raw) {
+    let n;
+    if (typeof raw === 'number')
+        n = raw;
+    else if (typeof raw === 'bigint')
+        n = Number(raw);
+    else if (typeof raw === 'string' && raw.trim() !== '')
+        n = Number(raw);
+    else
+        return DEFAULT_MAX_BATCH_BYTES;
+    if (!Number.isFinite(n) || n <= 0)
+        return DEFAULT_MAX_BATCH_BYTES;
+    return Math.floor(n);
+}
+/**
+ * Build the set of physical store names this module's data/index stores
+ * currently occupy in `schemaName`, mapping each name to a human description
+ * of the logical object that owns it (for sited collision messages).
+ *
+ * Physical store names are built by string concatenation (`{schema}.{table}` /
+ * `{schema}.{table}_idx_{index}`) and the `_idx_` delimiter is itself a legal
+ * substring of any identifier, so two distinct logical objects (e.g. index
+ * `archive` on `t` and a sibling table `t_idx_archive`) can collapse to the
+ * same physical name. This set is the authoritative occupancy used by
+ * {@link StoreModuleBase.assertStoreNameFree} to reject such a collision at CREATE time.
+ *
+ * The occupancy is the union of two sources, robust to lazy connection and the
+ * isolation wrapper (see the ticket's "Enumeration source" section):
+ *   1. `tables` — every store table the owning module touched this session.
+ *   2. the target schema's catalog tables whose `vtabModule === owner` and which
+ *      are not views — store-backed tables not yet lazily connected.
+ * Names embed the schema prefix, so cross-schema entries never collide and no
+ * per-schema filter on `tables` is needed. Memory-backed siblings and
+ * views own no store in this provider and are excluded (the `=== owner` /
+ * `!isView` filter) to avoid false-positive rejects.
+ *
+ * No self-exclusion: at each guarded call the candidate object is not yet
+ * registered (create/createIndex run before the engine adds it) so it cannot
+ * self-collide; and for renameTable the renamed table's OWN stores stay in the
+ * set deliberately. Any overlap between a name the rename introduces and an
+ * own current store is a footprint-swap rename (`t` with index `x` → `t_idx_x`,
+ * or table `u_idx_x` with index `x` → `u`) that providers cannot relocate
+ * safely — relocation order determines whether a source is clobbered before it
+ * is moved — while no benign rename produces such an overlap. Keeping own
+ * stores in the set therefore causes no false rejects and keeps the
+ * reject-before-any-side-effect guarantee uniform.
+ *
+ * `owner` is the module instance whose stores these are — the concrete `StoreModule` at
+ * the top of the layer chain, which this base layer cannot name without an import cycle.
+ * It is a parameter (rather than `this`) purely so the identity check keeps a real type
+ * instead of needing a cast; the enumeration itself reads no other module state.
+ */
+// NOTE: the builders below carry the unpaired-surrogate identifier guard, so this
+// enumeration can THROW on an EXISTING schema object, not just on the incoming one —
+// an unrelated CREATE/RENAME in the same schema would then fail with a confusing
+// "cannot store the identifier ..." error. Unreachable today: `create` throws before
+// the table is registered, and a catalog entry written before the guard existed was
+// folded to a real U+FFFD character, which passes. If a lone-surrogate-named table ever
+// does reach the schema manager by another route, skip such an object here (it occupies
+// no store) rather than letting the enumeration throw.
+export function collectOccupiedStoreNames(tables, db, schemaName, owner) {
+    const names = new Map();
+    const add = (s) => {
+        const dataName = buildDataStoreName(s.schemaName, s.name);
+        if (!names.has(dataName)) {
+            names.set(dataName, `data store of table '${s.schemaName}.${s.name}'`);
+        }
+        for (const idx of s.indexes ?? []) {
+            const idxName = buildIndexStoreName(s.schemaName, s.name, idx.name);
+            if (!names.has(idxName)) {
+                names.set(idxName, `index store of index '${idx.name}' on table '${s.schemaName}.${s.name}'`);
+            }
+        }
+    };
+    for (const t of tables) {
+        add(t.getSchema());
+    }
+    for (const t of db.schemaManager.getSchemaOrFail(schemaName).getAllTables()) {
+        if (t.vtabModule !== owner || t.isView)
+            continue;
+        add(t);
+    }
+    return names;
+}
+export class StoreModuleBase {
+    provider;
+    stores = new Map();
+    /**
+     * The single transaction coordinator shared by every {@link StoreTable} this
+     * module owns — the unit of cross-table atomicity (see {@link getCoordinator}).
+     * Lives for the module's lifetime: a single table's drop must NOT evict it
+     * (sibling tables still use it); only `StoreModule.closeAll` clears it.
+     */
+    moduleCoordinator;
+    tables = new Map();
+    eventEmitter;
+    /**
+     * Optional listener wired by the host (the worker) to forward a logical
+     * `apply schema` lens deployment to the sync layer's lifecycle bookkeeping.
+     * The store module is the only basis-backing host with both persistence and a
+     * `db` handle, so it is the forwarder; `@quereus/store` must not depend on
+     * `@quereus/sync`, so the listener is a plain callback the worker binds.
+     */
+    lensDeploymentListener;
+    /** Unsubscribe thunk for the engine `SchemaChangeNotifier` listener, set on first hook with a `db`. */
+    schemaListenerUnsub;
+    /** The `Database` whose notifier we subscribed to. One module instance serves one `Database`. */
+    subscribedDb;
+    /**
+     * Serialized chain of pending catalog writes triggered by engine schema-change
+     * events (catalog-only tag swaps). `notifyChange` invokes listeners synchronously
+     * and does not await them, so the actual read-compare-write runs here, in order,
+     * and is drained by `closeAll` (and `whenCatalogPersisted`) before the provider closes.
+     */
+    persistQueue = Promise.resolve();
+    /**
+     * The JSON-serialized stale-MV set last enqueued onto {@link persistQueue} (the
+     * `\x00meta\x00stale_mvs` value), or `undefined` when no baseline is established
+     * for the current subscription. The schema-change listener compares each
+     * recomputed set against this so an unrelated `table_modified` (e.g. a tag swap
+     * that changes no MV's staleness) costs no extra fsync. Reset to `undefined`
+     * whenever a fresh `Database` is subscribed (`StoreModuleSchemaSync.ensureSchemaSubscription`) so
+     * a reopened module re-establishes the baseline from the first relevant event (or
+     * the rehydrate tail).
+     */
+    lastPersistedStaleMvs;
+    /**
+     * Whether the provider exposes an atomic cross-store commit domain
+     * ({@link KVStoreProvider.beginAtomicBatch}) — the capability the MV adopt fast
+     * path's gate-5 drop hinges on. Fixed for the provider's lifetime, so cached at
+     * construction (and used as the single gate for both writing AND reading the durable
+     * stale-MV set). Gating the **write** on it is load-bearing for soundness, not just an
+     * fsync saving: only an atomic-capable session — whose commits can never tear a source
+     * from its same-module backing — ever writes the durable set, so the set a later atomic
+     * session reads was necessarily written under that same no-tear guarantee. A persistent
+     * non-atomic provider therefore can never leave a torn-but-"not-stale" set for an atomic
+     * reopen to trust (it writes none); such a store falls back to the clean-shutdown marker.
+     */
+    atomicProvider;
+    constructor(provider, eventEmitter) {
+        this.provider = provider;
+        this.eventEmitter = eventEmitter;
+        this.atomicProvider = typeof provider.beginAtomicBatch === 'function';
+    }
+    /**
+     * Get the KVStoreProvider used by this module.
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Get the event emitter for this module.
+     */
+    getEventEmitter() {
+        return this.eventEmitter;
+    }
+    /**
+     * Get a table by schema and name.
+     */
+    getTable(schemaName, tableName) {
+        const tableKey = `${schemaName}.${tableName}`.toLowerCase();
+        return this.tables.get(tableKey);
+    }
+    /**
+     * Parse module configuration from vtab args.
+     */
+    parseConfig(args) {
+        return {
+            collation: args?.collation || 'NOCASE',
+            // Index-build batch budget; malformed / non-positive clamps to the default
+            // so a bad arg can never disable the bounded-memory flush (see resolveMaxBatchBytes).
+            maxBatchBytes: resolveMaxBatchBytes(args?.max_batch_bytes),
+        };
+    }
+    // --- Engine schema-change subscription (catalog-only tag persistence) ---
+    /**
+     * Get or create a data store for a table.
+     */
+    async getStore(schemaName, tableName, _config) {
+        const tableKey = `${schemaName}.${tableName}`.toLowerCase();
+        let store = this.stores.get(tableKey);
+        if (!store) {
+            store = await this.provider.getStore(schemaName, tableName);
+            if (!store) {
+                throw new Error(`Provider.getStore returned null/undefined for ${tableKey}`);
+            }
+            this.stores.set(tableKey, store);
+        }
+        return store;
+    }
+    /**
+     * Get or create an index store for a table.
+     */
+    async getIndexStore(schemaName, tableName, indexName) {
+        return this.provider.getIndexStore(schemaName, tableName, indexName);
+    }
+    /**
+     * Get or create a stats store for a table.
+     */
+    async getStatsStore(schemaName, tableName) {
+        return this.provider.getStatsStore(schemaName, tableName);
+    }
+    /**
+     * Get (lazily constructing) the SINGLE transaction coordinator shared by every
+     * table this module owns — the unit of cross-table atomicity. Every
+     * {@link StoreTable} attaches to the same instance, so a transaction touching
+     * several of the module's tables commits/rolls back as one all-or-nothing
+     * batch.
+     *
+     * Synchronously constructible: ops are addressed by explicit store handle, so
+     * the coordinator never needs to open a store to be created. This lets callers
+     * that must stay synchronous (e.g. a `BackingHost.connect()`) obtain a working
+     * coordinator before any table's store has been opened.
+     */
+    getCoordinator() {
+        if (!this.moduleCoordinator) {
+            this.moduleCoordinator = new TransactionCoordinator(this.eventEmitter, 
+            // Re-evaluated per commit (see TransactionCoordinator.atomicBatchFactory)
+            // so a provider that gains/loses the capability is always honored.
+            () => this.provider.beginAtomicBatch?.());
+        }
+        return this.moduleCoordinator;
+    }
+    /**
+     * Flush the module's buffered writes before a DDL operation that physically
+     * rewrites or relocates storage.
+     *
+     * Such a DDL cannot honor the coordinator's buffer: pending ops are
+     * `(keyBytes, valueBytes, store)` triples computed at DML time under the
+     * PRE-DDL schema, and every physical rewrite (`StoreTable.rekeyRows` /
+     * `migrateRows`, the provider's directory move) reads and writes the COMMITTED
+     * store directly. Replaying stale-schema ops over the rewritten store on the
+     * eventual commit corrupts, loses, or misfiles those rows. So an `ALTER TABLE`
+     * that touches storage is effectively DDL-committing on a store-backed table:
+     * flush NOW, before the first physical read, so the rewrite sees every live row
+     * and there is nothing left to replay afterwards.
+     *
+     * Consequences, both deliberate:
+     * - The coordinator is module-wide, so this commits the WHOLE module
+     *   transaction — every table's pending ops, not just the altered/renamed
+     *   table's — in one all-or-nothing batch. An ALTER cannot half-commit some
+     *   sibling tables.
+     * - Validation running AFTER this point (e.g. `ALTER PRIMARY KEY`'s duplicate-key
+     *   pass — `rekeyRows` pass 1, which must see the flushed rows because a pending
+     *   insert can itself be the duplicate) throws with the enclosing transaction
+     *   already flushed. The store stays unmutated — only the transaction is gone.
+     *   Validation that can read effectively belongs before the call, so the
+     *   transaction survives it — the SET COLLATE PK re-key does exactly that
+     *   (`StoreTable.validateRekeyedPrimaryKey` reads the effective rows, pending
+     *   ops included, before this flush; `rekeyRows` pass 1 is only its backstop).
+     *
+     * Subsequent `commit()` calls on the same coordinator are no-ops
+     * (`inTransaction` is cleared), which keeps the enclosing transaction safe.
+     * The savepoint stack is cleared too, so a later `ROLLBACK TO` / `RELEASE` that
+     * the engine still broadcasts warns and degrades rather than throwing — see
+     * `TransactionCoordinator.rollbackToSavepoint`, which mirrors the memory
+     * module's identical posture.
+     */
+    async ddlCommitPendingOps() {
+        if (this.moduleCoordinator?.isInTransaction()) {
+            await this.moduleCoordinator.commit();
+        }
+    }
+    /**
+     * Append a catalog-persistence task to the serialized `persistQueue`, so successive
+     * mutations (e.g. SET TAGS (a=1) then SET TAGS ()) apply in order and are drained by
+     * `closeAll`/`whenCatalogPersisted` before the provider closes. Errors are
+     * swallowed+logged to mirror `notifyChange`'s own try/catch contract — a listener
+     * rejection must never escape.
+     */
+    enqueuePersist(work) {
+        this.persistQueue = this.persistQueue
+            .then(work)
+            .catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn(`[StoreModule] Failed to persist catalog DDL after schema change: ${message}`);
+        });
+    }
+    /**
+     * Resolve once all catalog writes queued by async schema-change listeners
+     * (catalog-only tag swaps) have settled. A durability barrier: `closeAll` awaits
+     * it internally; callers/tests that need the persisted catalog current without a
+     * full close can await it directly. Never rejects — queued errors are logged in
+     * the chain.
+     */
+    async whenCatalogPersisted() {
+        await this.persistQueue;
+    }
+    /**
+     * The physical index-store names a table owns for DROP / RENAME TABLE to relocate
+     * or reclaim: the MATERIALIZED index set — every explicit `CREATE INDEX` PLUS the
+     * hidden `_uc_*` realizing each plain UNIQUE. Reading only `getSchema().indexes`
+     * (the engine-facing schema, which carries no `_uc_*`) would strand a `_uc_*` store
+     * on disk after DROP TABLE, and — worse — after RENAME TABLE leave the renamed
+     * table seeking a freshly-created EMPTY `_uc_*` store, silently accepting a
+     * duplicate of a pre-rename row. Prefers the cached StoreTable's own materialized
+     * schema; falls back to materializing the schema-manager copy when the instance is
+     * already gone.
+     */
+    materializedIndexNames(table, fallback) {
+        const schema = table
+            ? table.getMaterializedSchema()
+            : (fallback ? withImplicitUniqueIndexes(fallback) : undefined);
+        return (schema?.indexes ?? []).map(i => i.name);
+    }
+    /**
+     * Throws `StatusCode.ERROR` when `candidate` (a physical store name produced by
+     * the key-builder for an object about to be created/renamed) already names an
+     * existing data or index store in `schemaName`. `candidateDesc` describes the
+     * incoming logical object; the message names the candidate physical store and
+     * both conflicting logical objects and is actionable (rename one of them).
+     *
+     * Must run BEFORE any storage side-effect (`getStore` / `getIndexStore` / the
+     * physical relocation): the provider opens/creates the store eagerly, so a
+     * guard that ran after would already have aliased the colliding object's store.
+     *
+     * Callers checking several candidates against the same occupancy (renameTable
+     * checks the new data store plus every relocated index store) pass a
+     * precomputed `occupied` map so the occupancy is collected once, not per call.
+     */
+    assertStoreNameFree(db, schemaName, candidate, candidateDesc, occupied) {
+        const occupiedBy = (occupied ?? collectOccupiedStoreNames(this.tables.values(), db, schemaName, this)).get(candidate);
+        if (occupiedBy !== undefined) {
+            throw new QuereusError(`Physical store-name collision: the ${candidateDesc} would map to physical store `
+                + `'${candidate}', which already backs the ${occupiedBy}. These two objects would `
+                + `share one physical store and silently corrupt each other. Rename the table or the `
+                + `colliding index.`, StatusCode.ERROR);
+        }
+    }
+}
+//# sourceMappingURL=store-module-base.js.map

package/dist/src/common/store-module-base.js.map

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