@quereus/store 3.3.0 → 4.0.0

package/dist/src/common/store-table.d.ts

@@ -9,13 +9,36 @@
  *   - Index stores: {schema}.{table}_idx_{name} - one per secondary index
  *   - Stats store: __stats__ - unified store for all table statistics, keyed by {schema}.{table}
  */
-import { VirtualTable, IndexConstraintOp, ConflictResolution, type Database, type TableSchema, type Row, type FilterInfo, type SqlValue, type VirtualTableConnection, type UpdateArgs, type UpdateResult } from '@quereus/quereus';
-import type { KVStore } from './kv-store.js';
+import { VirtualTable, IndexConstraintOp, ConflictResolution, type Database, type ColumnSchema, type TableSchema, type Row, type FilterInfo, type SqlValue, type VirtualTableConnection, type UpdateArgs, type UpdateResult, type BackingRowChange } from '@quereus/quereus';
+import type { IterateOptions, KVEntry, KVStore } from './kv-store.js';
 import type { StoreEventEmitter } from './events.js';
 import type { TransactionCoordinator } from './transaction.js';
 import { StoreConnection } from './store-connection.js';
 import { type TableStats } from './serialization.js';
-import type { EncodeOptions } from './encoding.js';
+import { type EncodeOptions } from './encoding.js';
+/**
+ * Resolve the per-column KEY collation for each primary-key column.
+ *
+ * The store encodes PRIMARY KEY uniqueness/ordering PHYSICALLY in the key bytes,
+ * so each text PK column's key must be encoded under that column's declared
+ * collation (BINARY / NOCASE / RTRIM — the registered encoders). Returns one
+ * entry per PK member, in `pkDef` order:
+ *   - text member → its declared `collation` (normalized upper-case), or
+ *     `fallback` (the table key collation K) when the column carries none.
+ *   - non-text member → `undefined`: collation is meaningless for
+ *     integer/real/blob keys (they encode type-natively), so the encoder ignores
+ *     it and the data/index key bytes are identical regardless.
+ *
+ * A custom comparator-only collation with no registered byte encoder still maps
+ * to NOCASE bytes inside `encodeText` (its `?? NOCASE_ENCODER` fallback); that
+ * residual is the same one documented for store UNIQUE enforcement and is out of
+ * scope here. Shared by {@link StoreTable} (data-key + index-maintenance) and
+ * `StoreModule.buildIndexEntries` (index rebuild) so the PK suffix encoding can
+ * never drift between the two.
+ */
+export declare function resolvePkKeyCollations(pkDef: ReadonlyArray<{
+    index: number;
+}>, columns: ReadonlyArray<ColumnSchema>, fallback: string): (string | undefined)[];
 /**
  * Configuration for a store table.
  */
@@ -36,11 +59,30 @@ export interface StoreTableModule {
     getIndexStore(schemaName: string, tableName: string, indexName: string): Promise<KVStore>;
     /** Get the stats store for a table. */
     getStatsStore(schemaName: string, tableName: string): Promise<KVStore>;
-    /** Get a coordinator for a table. */
-    getCoordinator(tableKey: string, config: StoreTableConfig): Promise<TransactionCoordinator>;
+    /**
+     * Get the module's single shared transaction coordinator (one per storage
+     * module, shared by every table — the unit of cross-table atomicity).
+     * Synchronous: ops are addressed by explicit store handle, so obtaining a
+     * coordinator never requires opening storage.
+     */
+    getCoordinator(): TransactionCoordinator;
     /** Save table DDL to persistent storage. */
     saveTableDDL(tableSchema: TableSchema): Promise<void>;
 }
+/**
+ * One externally-applied row op against a SOURCE table's committed storage,
+ * the input vocabulary of {@link StoreTable.applyExternalRowChanges}. An
+ * `upsert` carries the full table row in schema column order (its PK — and thus
+ * its data key — is derived from the row, so an upsert can never relocate a
+ * row); a `delete` carries the PK values in PK-definition order.
+ */
+export type ExternalRowOp = {
+    op: 'upsert';
+    row: Row;
+} | {
+    op: 'delete';
+    pk: SqlValue[];
+};
 /**
  * Generic KVStore-backed virtual table.
  *
@@ -56,16 +98,32 @@ export declare class StoreTable extends VirtualTable {
     protected indexStores: Map<string, KVStore>;
     protected statsStore: KVStore | null;
     protected coordinator: TransactionCoordinator | null;
+    /**
+     * Disposer returned by the coordinator's `registerCallbacks`, captured on the
+     * first {@link attachCoordinator}. Run by {@link dispose} at hard eviction to
+     * deregister this instance's {stats apply/discard} pair from the module-wide
+     * coordinator; null until attached, and nulled again after dispose.
+     */
+    private coordinatorDisposer;
     protected connection: StoreConnection | null;
     protected eventEmitter?: StoreEventEmitter;
     protected encodeOptions: EncodeOptions;
     protected pkDirections: boolean[];
+    /**
+     * Per-PK-column KEY collation (see {@link resolvePkKeyCollations}). Drives the
+     * physical encoding of every data key and the PK suffix of every secondary-index
+     * key, so a text PK column declared BINARY/NOCASE/RTRIM is keyed under its own
+     * collation rather than one fixed table-level collation. Recomputed on every
+     * {@link updateSchema} (an ALTER COLUMN SET COLLATE on a PK member changes it).
+     */
+    protected pkKeyCollations: (string | undefined)[];
     protected ddlSaved: boolean;
     protected cachedStats: TableStats | null;
     protected pendingStatsDelta: number;
     protected mutationCount: number;
     protected statsFlushPending: boolean;
     private readonly predicateCache;
+    private readonly indexPredicateCache;
     constructor(db: Database, storeModule: StoreTableModule, tableSchema: TableSchema, config: StoreTableConfig, eventEmitter?: StoreEventEmitter, isConnected?: boolean);
     /** Get the table configuration. */
     getConfig(): StoreTableConfig;
@@ -73,6 +131,13 @@ export declare class StoreTable extends VirtualTable {
     getSchema(): TableSchema;
     /** Update the table schema after an ALTER TABLE operation. */
     updateSchema(newSchema: TableSchema): void;
+    /**
+     * Mark the table's DDL as already persisted to the catalog, so the lazy
+     * first-store-access save in {@link initializeStore} is skipped. Called by
+     * `StoreModule.createIndex` / `dropIndex` after they eagerly write the catalog
+     * bundle, so a subsequent INSERT does not redundantly re-persist identical DDL.
+     */
+    markDdlSaved(): void;
     /** Close and forget a cached index-store handle, if any. */
     releaseIndexStore(indexName: string): Promise<void>;
     /**
@@ -100,17 +165,37 @@ export declare class StoreTable extends VirtualTable {
      * Only the data store is rewritten — secondary indexes are rebuilt by the
      * caller (the keys embed the PK suffix, so they must be rebuilt whenever
      * the PK changes).
+     *
+     * The new key for each row is encoded under `newColumns`'s per-column PK
+     * collations, so this drives BOTH:
+     *   - `ALTER PRIMARY KEY` — the PK *columns* change; `newColumns` defaults to the
+     *     current column set (their collations are unchanged), and
+     *   - `ALTER COLUMN … SET COLLATE` on a PK member — the PK columns stay the same
+     *     but one column's collation changes; the caller passes the post-ALTER
+     *     `updatedSchema.columns` so the new key bytes follow the new collation.
+     * The OLD key is taken verbatim from the stored entry (never re-encoded), so the
+     * old collation is implicit in the existing bytes and need not be supplied.
      */
     rekeyRows(newPkDef: ReadonlyArray<{
         index: number;
-        desc: boolean;
-    }>): Promise<void>;
+        desc?: boolean;
+    }>, newColumns?: ReadonlyArray<ColumnSchema>): Promise<void>;
     /**
      * Migrate all stored rows from the old column layout to a new one.
      * The remap array maps newColumnIndex -> oldColumnIndex | -1.
      * -1 means the column is new (fill with defaultValue).
+     *
+     * `backfill`, when supplied (ADD COLUMN with a non-foldable DEFAULT such as
+     * `new.<col>`), derives the new column's value from each existing row instead of the
+     * single `defaultValue`, and rejects a NULL it produces for a NOT NULL column. The
+     * batch is only written once every row migrates, so a throwing evaluator / NOT NULL
+     * violation leaves the store untouched for the caller's rollback.
      */
-    migrateRows(remap: number[], defaultValue: SqlValue): Promise<void>;
+    migrateRows(remap: number[], defaultValue: SqlValue, backfill?: {
+        evaluator: (row: Row) => SqlValue | Promise<SqlValue>;
+        notNull: boolean;
+        columnName: string;
+    }): Promise<void>;
     /**
      * Ensure the data store is open and DDL is persisted.
      * Uses a promise-based singleton pattern to prevent race conditions
@@ -130,6 +215,29 @@ export declare class StoreTable extends VirtualTable {
      * Get or create the stats store.
      */
     protected ensureStatsStore(): Promise<KVStore>;
+    /**
+     * Resolve + cache the module's shared TransactionCoordinator and hook the
+     * stats lifecycle callbacks, WITHOUT creating or registering a connection.
+     * Synchronous (the coordinator is handle-addressed, never store-opening — see
+     * `StoreTableModule.getCoordinator`), so the backing host's resolution path can
+     * call it eagerly. Attaching matters for reads: `iterateEffective` /
+     * `readEffectiveRowByKey` consult `this.coordinator` for the pending merge, so a
+     * table whose only writer is the privileged backing host (which queues ops on the
+     * module coordinator, never through `update()`) must still hold the
+     * reference for its read paths to be reads-own-writes.
+     *
+     * The coordinator is module-wide, so its commit/rollback callback array holds
+     * one {stats apply/discard} pair per PARTICIPATING table; each table's
+     * `applyPendingStats` early-returns when its own `pendingStatsDelta` is 0, so a
+     * table that did no work contributes nothing. Registers only on first call per
+     * StoreTable instance (the `if (!this.coordinator)` guard); a fresh instance
+     * after drop+recreate re-registers against the shared coordinator. The OLD
+     * instance is not GC'd on its own — its callback closures capture `this` and
+     * stay pinned on the module-wide coordinator until {@link dispose} runs the
+     * captured disposer (called at the genuine eviction sites, see
+     * `StoreModule.tearDownTableStorage` / `renameTable`).
+     */
+    attachCoordinator(): TransactionCoordinator;
     /**
      * Ensure the coordinator is available and connection is registered.
      */
@@ -153,16 +261,93 @@ export declare class StoreTable extends VirtualTable {
      * objects before PK extraction, serialization, and index-key construction.
      */
     protected coerceRow(row: Row): Row;
-    /** Query the table with optional filters. */
+    /**
+     * Query the table with optional filters.
+     *
+     * All three access arms read the EFFECTIVE row state: the committed store
+     * merged with this table's coordinator's pending ops when a transaction is
+     * active (read-your-own-writes — see {@link iterateEffective} /
+     * {@link readLiveRowByPk}). Merged emission stays in encoded-PK-key order,
+     * preserving the module's `providesOrdering` / `monotonicOn` advertisements.
+     */
     query(filterInfo: FilterInfo): AsyncIterable<Row>;
+    /**
+     * Iterate the effective entry state of this table's data store within
+     * `bounds`: the committed `store.iterate` stream merged with the
+     * coordinator's pending ops for the data store (read-your-own-writes).
+     *
+     * Both inputs are sorted by encoded key bytes, so this is an
+     * order-preserving two-way merge: a pending put wins over a committed entry
+     * at the same key, a pending delete suppresses its committed entry, and
+     * pending puts outside `bounds` are excluded. With no active transaction
+     * (or an empty pending bucket) it degrades to the bare committed iterate.
+     *
+     * The pending side is the module coordinator's bucket for THIS table's data
+     * store handle (`store`) — every data op is queued under that exact handle, so
+     * a sibling table's pending ops (a different data-store handle) never bleed in.
+     */
+    protected iterateEffective(store: KVStore, bounds: IterateOptions, reverse?: boolean): AsyncIterable<KVEntry>;
     /** Analyze filter info to determine PK access pattern. */
     protected analyzePKAccess(filterInfo: FilterInfo): PKAccessPattern;
-    /** Scan a range of PK values. */
-    protected scanPKRange(store: KVStore, _access: PKAccessPattern, filterInfo: FilterInfo): AsyncIterable<Row>;
+    /**
+     * Convert a leading-PK-column range access into one seek + early-terminate
+     * iterate window.
+     *
+     * Each LT/LE/GT/GE constraint's bound value is encoded under the SAME
+     * per-column DESC direction and key collation as the data keys (via
+     * {@link encodePkPrefixBounds}), giving the byte region `[lo, hi)` whose
+     * leading column equals that value (`lo = encode([x])`,
+     * `hi = incrementLastByte(lo)`). The op maps that region's endpoints onto a
+     * `gte`/`lt` window; because a DESC column bit-inverts its bytes (larger value
+     * ⇒ smaller bytes), the lower/upper assignment swaps with direction:
+     *
+     *   | op | ASC      | DESC     |
+     *   |----|----------|----------|
+     *   | GE | gte = lo | lt  = hi |
+     *   | GT | gte = hi | lt  = lo |
+     *   | LE | lt  = hi | gte = lo |
+     *   | LT | lt  = lo | gte = hi |
+     *
+     * Across constraints (BETWEEN ⇒ one lower + one upper; a redundant same-side
+     * pair ⇒ the tighter wins) we keep the MAX lower candidate for `gte` and the
+     * MIN upper candidate for `lt`. A candidate that resolves to `undefined` (an
+     * `hi` whose increment overflowed all-0xff) leaves that side unbounded — a safe
+     * SUPERSET, since {@link matchesFilters} stays the authoritative collation-aware
+     * row filter. A NULL/missing bound value is likewise skipped (the planner never
+     * pushes `= NULL`, and a range op against NULL rejects every row in matchesFilters).
+     *
+     * Falls back to a full scan when the leading text PK column declares a
+     * comparator-only collation with no registered byte encoder: `encodeText` would
+     * silently key it under NOCASE bytes that do not track the column's logical
+     * order, so a derived window could UNDER-fetch. A non-text leading column has
+     * `pkKeyCollations[0] === undefined` and encodes type-natively — always safe.
+     */
+    protected buildPKRangeBounds(access: PKAccessPattern): IterateOptions;
+    /**
+     * Scan a leading-PK-column range, seeking to the window start and
+     * early-terminating at its end.
+     *
+     * {@link buildPKRangeBounds} converts the LT/LE/GT/GE constraints into one
+     * encoded-byte `gte`/`lt` window under the same per-column DESC directions and
+     * key collations the data keys use, so the iterate visits a SUPERSET of the
+     * qualifying rows (a collation widening or the bound-byte increment can
+     * over-fetch, never under-fetch). {@link matchesFilters} stays the authoritative
+     * collation-aware row filter. {@link iterateEffective} restricts the pending
+     * merge to the same `bounds`, so read-your-own-writes holds on the narrowed window.
+     */
+    protected scanPKRange(store: KVStore, access: PKAccessPattern, filterInfo: FilterInfo): AsyncIterable<Row>;
     /** Check if a row matches the filter constraints. */
     protected matchesFilters(row: Row, filterInfo: FilterInfo): boolean;
-    /** Compare two values according to an operator. */
-    protected compareValues(a: SqlValue, op: IndexConstraintOp, b: SqlValue): boolean;
+    /**
+     * Compare two values according to an operator, under `collation` (the column's
+     * declared collation; undefined ⇒ BINARY). Delegates to the engine's
+     * `compareSqlValues`, so the LT/LE/GT/GE range bounds honour a NOCASE/RTRIM
+     * column collation rather than a raw BINARY JS comparison — the capability
+     * `StoreModule.getBestAccessPlan` advertises via `honorsCollatedRangeBounds`.
+     * NULL on either side fails every operator except EQ-with-both-NULL (the
+     * internal point-lookup convention; the planner never pushes `= NULL`).
+     */
+    protected compareValues(a: SqlValue, op: IndexConstraintOp, b: SqlValue, collation?: string): boolean;
     /** Perform an update operation (INSERT, UPDATE, DELETE). */
     update(args: UpdateArgs): Promise<UpdateResult>;
     /**
@@ -179,6 +364,12 @@ export declare class StoreTable extends VirtualTable {
      * UniqueConstraintSchema instance so the hot UNIQUE-check path doesn't recompile.
      */
     private compileFor;
+    /**
+     * Returns the compiled predicate for a partial secondary index, or undefined
+     * for a full index. Compilation is memoized per IndexSchema instance so the hot
+     * DML index-maintenance path doesn't recompile.
+     */
+    private compileIndexFor;
     /** Check if two PK arrays are equal. */
     protected keysEqual(a: SqlValue[], b: SqlValue[]): boolean;
     /**
@@ -200,8 +391,12 @@ export declare class StoreTable extends VirtualTable {
      *
      * Reads through the transaction coordinator's pending writes when active so
      * intra-transaction duplicates are detected.
+     *
+     * REPLACE evictions (rows at OTHER PKs) are deleted from storage and pushed onto
+     * `evicted` so the DML executor runs the full delete pipeline for each
+     * (change-tracking, row-time MV maintenance, FK cascade, auto-events).
      */
-    protected checkUniqueConstraints(inTransaction: boolean, newRow: Row, selfPks: SqlValue[][], onConflict?: ConflictResolution): Promise<UpdateResult | null>;
+    protected checkUniqueConstraints(inTransaction: boolean, newRow: Row, selfPks: SqlValue[][], onConflict: ConflictResolution | undefined, evicted: Row[]): Promise<UpdateResult | null>;
     /**
      * Scan committed + pending data rows for a row matching `newRow` on
      * `uc.columns` whose PK is not in `selfPks`. For partial UNIQUE, candidates
@@ -209,6 +404,125 @@ export declare class StoreTable extends VirtualTable {
      * match or null.
      */
     private findUniqueConflict;
+    /**
+     * Find a UNIQUE conflict through a linked row-time covering MV's backing table
+     * (the store analogue of the memory `checkUniqueViaMaterializedView`). The
+     * backing scan yields candidate conflicting **source** PKs (reads-own-writes via
+     * the backing's coordinated connection); each is validated against the *live*
+     * store row (committed + this transaction's pending overlay) so a backing entry
+     * that lags a row deleted/updated internally this statement is skipped rather
+     * than raised as a false conflict. Returns the first real conflict or null.
+     */
+    private findUniqueConflictViaCoveringMv;
+    /**
+     * Read the live row at `pk` — this transaction's pending overlay (a pending
+     * delete ⇒ gone; a pending put ⇒ its value) shadowing the committed store.
+     * Backs `query()`'s point-lookup arm and validates covering-MV conflict
+     * candidates against the source of truth.
+     */
+    private readLiveRowByPk;
+    /** Encode `pkValues` (in PK-definition order) exactly as the data store keys rows. */
+    encodeDataKey(pkValues: SqlValue[]): Uint8Array;
+    /**
+     * Byte bounds covering every data key whose leading PK columns equal
+     * `prefixValues` — encoded under the same per-column DESC directions and key
+     * collations as {@link encodeDataKey}, so seek + early-terminate addresses the
+     * exact slice. An empty prefix yields full-scan bounds.
+     */
+    encodePkPrefixBounds(prefixValues: SqlValue[]): {
+        gte: Uint8Array;
+        lt?: Uint8Array;
+    };
+    /**
+     * Effective (pending-over-committed) point read by encoded data key: a pending
+     * delete ⇒ null, a pending put ⇒ its value, else the committed store entry.
+     */
+    readEffectiveRowByKey(key: Uint8Array): Promise<Row | null>;
+    /**
+     * Effective ordered entry scan within `bounds` (see {@link iterateEffective}).
+     * Opens the data store first — which fires the lazy first-access `saveTableDDL`
+     * for a freshly created table, the catalog write a store-backed MV backing
+     * relies on to survive reopen.
+     */
+    iterateEffectiveEntries(bounds: IterateOptions, reverse?: boolean): AsyncIterable<KVEntry>;
+    /** Buffer a privileged row-count delta, applied at coordinator commit (host writes). */
+    trackPrivilegedMutation(delta: number): void;
+    /**
+     * Declared secondary-UNIQUE enforcement for maintenance writes — the store
+     * mirror of the memory manager's `enforceSecondaryUniqueOnMaintenance` (see
+     * `vtab/backing-host.ts` § Constraint validation for the contract and
+     * docs/materialized-views.md § Derived-row constraint validation for the
+     * semantics). Called by `StoreBackingHost.applyMaintenance` AFTER the op
+     * batch lands in the coordinator's pending state: post-batch is load-bearing
+     * (a `replace-all` diff applies puts before deletes, so a per-op check would
+     * false-positive when the derived set moves a unique value between primary
+     * keys), and checking only the WRITTEN images is complete (pre-existing
+     * contents already satisfied the constraint).
+     *
+     * Reuses {@link findUniqueConflict} — pending-overlay reads, per-column
+     * collations, NULL-pass, partial-predicate scope, self-PK exclusion — with
+     * the covering-MV route deliberately bypassed: a covering MV over THIS table
+     * is cascade-maintained only after the batch returns, so it lags the batch
+     * and would miss a same-batch colliding pair. The conflict action is a hard
+     * abort (a derivation write carries no user OR clause, and a declared
+     * `on conflict replace`/`ignore` default must not evict or drop derived
+     * rows). Per-image cost is one effective scan — the same full-scan posture
+     * the store's DML UNIQUE enforcement already takes.
+     *
+     * Zero overhead when the table declares no secondary UNIQUE (every MV-sugar
+     * backing, and most maintained tables): one empty-array check.
+     */
+    enforceSecondaryUniqueForMaintenance(changes: readonly BackingRowChange[]): Promise<void>;
+    /**
+     * Reset statistics to an absolute committed row count and flush immediately.
+     * Used by the host's `replaceContents` (create-fill / refresh), where the new
+     * count is exact, replacing any drifted delta-tracked estimate.
+     */
+    resetStats(rowCount: number): Promise<void>;
+    /**
+     * Open (and cache) the data store, firing the lazy first-access `saveTableDDL`.
+     * Public for the host's `replaceContents`, which writes the store directly.
+     */
+    openDataStore(): Promise<KVStore>;
+    /**
+     * Effective (pending-over-committed) point read by PK values — the public
+     * read an external writer issues before an upsert to learn the row's current
+     * image. Thin wrapper over the same private point-lookup that backs
+     * {@link query}'s point arm, so an external read merges pending-over-committed
+     * exactly like an engine read does.
+     */
+    readRowByPk(pk: SqlValue[]): Promise<Row | null>;
+    /**
+     * Apply externally-originated row ops directly to this source table's
+     * COMMITTED storage: table-owned data-key put/delete, secondary-index
+     * maintenance, and stats tracking. The index-maintaining counterpart of
+     * `StoreBackingHost.applyMaintenance` (which targets index-less MV backings),
+     * built for trusted replication-style writes.
+     *
+     * Deliberately:
+     *   - emits NO module {@link DataChangeEvent}s — the external writer owns
+     *     emission and the `remote` flag;
+     *   - opens NO coordinator transaction — writes land in committed state
+     *     immediately (`store.put`/`store.delete`, never the coordinator);
+     *   - runs NO constraint validation (PK/UNIQUE/CHECK/FK) — the origin is
+     *     trusted, mirroring the backing-host posture.
+     *
+     * Returns the EFFECTIVE per-op {@link BackingRowChange}s with accurate
+     * before-images (the shape `Database.ingestExternalRowChanges` consumes),
+     * suppressing no-ops to match the normative upsert-suppression contract in
+     * `vtab/backing-host.ts`: a delete of an absent key, and a value-identical
+     * upsert (`rowsValueIdentical` — byte-faithful, collation-UNAWARE, against the
+     * effective existing row) write nothing and report nothing. A collation-equal /
+     * byte-different upsert (e.g. a case-only rewrite under a NOCASE PK) keeps the
+     * SAME data key (key identity is collation-aware) but IS a real update that
+     * replaces the stored bytes and reports `update`.
+     *
+     * Last-writer-wins against any concurrently pending local transaction on this
+     * table: the external write commits to storage at once, and that transaction's
+     * pending batch may overwrite these keys when it commits. This is the same
+     * posture the prior raw-KV sync adapter took — not a regression, now stated.
+     */
+    applyExternalRowChanges(ops: readonly ExternalRowOp[]): Promise<BackingRowChange[]>;
     /**
      * Fully delete the row at `pk` (data + secondary indexes + stats + delete event).
      * Used by REPLACE conflict resolution to evict a conflicting unique row before
@@ -236,6 +550,25 @@ export declare class StoreTable extends VirtualTable {
     rollback(): Promise<void>;
     /** Disconnect from the store. */
     disconnect(): Promise<void>;
+    /**
+     * Hard teardown: fully detach this instance from the module-wide coordinator.
+     *
+     * Distinct from the per-scan {@link disconnect} (which only flushes stats and
+     * deliberately keeps the table hooked mid-life). Called ONLY at the genuine
+     * eviction sites — `StoreModule.tearDownTableStorage` (drop / reclaim) and
+     * `renameTable` — where this instance is removed from the module's `tables` map
+     * and will never be used again. It best-effort flushes any buffered stats (the
+     * backing store is about to be deleted / relocated, so this is the last chance,
+     * same posture as the teardown-time `disconnect` it replaces), then runs the
+     * coordinator disposer so this instance's {stats apply/discard} callback pair —
+     * and the `this` its closures capture — is spliced off the shared coordinator's
+     * array rather than pinned for the module's lifetime.
+     *
+     * Idempotent: the disposer is run at most once and both it and the coordinator
+     * reference are nulled, so a double-dispose is a no-op and a re-`attachCoordinator`
+     * after dispose registers a fresh pair instead of double-registering.
+     */
+    dispose(): Promise<void>;
     /** Get the current estimated row count. */
     getEstimatedRowCount(): Promise<number>;
     /** Track a mutation and schedule lazy stats persistence. */

package/dist/src/common/store-table.d.ts.map

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