@quereus/store 4.3.1 → 4.4.0

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

@@ -13,6 +13,7 @@
  *   - Catalog store: __catalog__ - DDL metadata keyed by {schema}.{table}
  */
 import type { Database, TableSchema, TableIndexSchema, VirtualTableModule, BaseModuleConfig, BestAccessPlanRequest, BestAccessPlanResult, ModuleCapabilities, SchemaChangeInfo, Schema, MappingAdvertisement, ViewSchema, MaintainedTableSchema, BackingHost, LensDeploymentSnapshot } from '@quereus/quereus';
+import type { EffectiveRowSource } from '@quereus/quereus';
 import type { KVStore, KVStoreProvider } from './kv-store.js';
 import type { StoreEventEmitter } from './events.js';
 import { TransactionCoordinator } from './transaction.js';
@@ -51,6 +52,13 @@ export type LensDeploymentListener = (db: Database, logicalSchemaName: string, s
 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
+     * {@link StoreModule.buildIndexEntries}). 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;
 }
@@ -341,8 +349,17 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
     private getOrReconnectTable;
     /**
      * Creates an index on a store-backed table.
+     *
+     * `rows` — an {@link EffectiveRowSource} supplied by a wrapper module (the isolation
+     * layer) — replaces this module's own rows as the set the UNIQUE duplicate check judges.
+     * When present the check runs UP FRONT, before `getIndexStore` opens the index-store
+     * directory, so a rejection leaves no directory behind; and `buildIndexEntries` then
+     * populates the physical index from this module's own (committed) rows with its in-pass
+     * dup check disabled. Those two row sets legitimately differ — the wrapper's transaction
+     * may have deleted a committed duplicate — and an index entry with no live row behind it
+     * is harmless (see the entry-resolution note in `buildIndexEntries`).
      */
-    createIndex(db: Database, schemaName: string, tableName: string, indexSchema: TableIndexSchema): Promise<void>;
+    createIndex(db: Database, schemaName: string, tableName: string, indexSchema: TableIndexSchema, rows?: EffectiveRowSource): Promise<void>;
     /**
      * Drops an index on a store-backed table.
      *
@@ -355,11 +372,26 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
     /**
      * Build index entries for all existing rows in a table.
      *
+     * `dataEntries` is the row stream to index. Callers choose its visibility:
+     * `createIndex` passes the table's EFFECTIVE stream (committed + pending, so
+     * an open transaction's rows are indexed too), while `rebuildSecondaryIndexes`
+     * passes the raw committed stream — it runs immediately after an ALTER has
+     * re-encoded the data store in place, and any pending ops still address the
+     * pre-ALTER key bytes.
+     *
      * For UNIQUE indexes, performs an in-pass duplicate check (honoring partial
      * predicates and SQL NULL semantics: multiple NULLs are allowed) and throws
      * CONSTRAINT before any entries are written. Mirrors the memory module's
      * populateNewIndex so `CREATE UNIQUE INDEX` over duplicated data fails
-     * atomically.
+     * atomically. `skipDuplicateCheck` suppresses it: `createIndex` sets it when a
+     * wrapper module supplied the rows to judge, having already validated them (see
+     * {@link validateUniqueIndexOverRows}). Judging `dataEntries` too would reject a
+     * committed duplicate the wrapper's transaction has already deleted.
+     *
+     * `normalizers` MUST be the owning connection's `db.getKeyNormalizerResolver()` —
+     * the same resolver `StoreTable.encodeOptions` carries. A rebuild that resolved
+     * collations any other way would re-encode the PK suffix under different bytes than
+     * the table writes at maintenance time, silently corrupting the index.
      */
     private buildIndexEntries;
     /**
@@ -370,35 +402,194 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
      * COLLATE` on a PK member (a PK column's key collation changes). Shared by both
      * arms so the clear-then-rebuild stays identical. `schema` must already be the
      * post-ALTER schema (its `primaryKeyDefinition` + column collations drive the new
-     * PK-suffix encoding via {@link buildIndexEntries}).
+     * PK-suffix encoding via {@link buildIndexEntries}). `normalizers` is the owning
+     * connection's `db.getKeyNormalizerResolver()` — see {@link buildIndexEntries}.
+     *
+     * NOTE: reads the data store committed-only and writes the index stores outside the
+     * coordinator. Sound only because both callers (the two re-key arms) call
+     * {@link ddlCommitPendingOps} first, so "committed" is "everything live". A caller
+     * that skips that flush would rebuild an index missing its transaction's pending rows.
      */
     private rebuildSecondaryIndexes;
     /**
-     * Validates the existing rows in `dataStore` against a UNIQUE constraint,
-     * throwing `CONSTRAINT` on the first duplicate before any schema mutation.
-     * Used by `ADD CONSTRAINT UNIQUE` (validate against the current collation) and
-     * by `SET COLLATE` (pass an `updatedSchema` whose altered column carries the
-     * NEW collation, so the dedup is performed under it). Mirrors the duplicate
-     * detection in {@link buildIndexEntries}: a `seen` Set keyed on a per-column
-     * collation-aware signature of the constrained values, with SQL NULL semantics
-     * (a row with any NULL constrained value never counts as a duplicate) and the
-     * partial `predicate` honored.
+     * Validates `rows` against a UNIQUE constraint, throwing `CONSTRAINT` on the first
+     * duplicate before any schema mutation. Used by `ADD CONSTRAINT UNIQUE` (validate
+     * against the current collation) and by `SET COLLATE` (pass an `updatedSchema` whose
+     * altered column carries the NEW collation, so the dedup is performed under it).
+     * Mirrors the duplicate detection in {@link buildIndexEntries}: a `seen` Set keyed on
+     * a per-column collation-aware signature of the constrained values, with SQL NULL
+     * semantics (a row with any NULL constrained value never counts as a duplicate) and
+     * the partial `predicate` honored.
+     *
+     * `rows` MUST be the rows the DDL-issuing connection can SEE. Ordinarily that is this
+     * table's EFFECTIVE stream (committed rows merged with the open transaction's own
+     * pending puts/deletes — `StoreTable.iterateEffectiveEntries`, adapted by
+     * {@link rowsFromEntries}); when a wrapper module holds the pending rows outside this
+     * module it hands them down as an `EffectiveRowSource` instead. Either way, a
+     * committed-only stream would let a duplicate inserted earlier in the same transaction
+     * slip past validation and land in the table once the transaction commits.
      *
      * No index store is written — store UNIQUE enforcement is a full-scan over
      * `uniqueConstraints` at write time. The signature is built by
-     * {@link serializeRowKey} with one normalizer per constrained column drawn from
-     * `tableSchema.columns[idx].collation`, so a per-column NOCASE/RTRIM collation
-     * is honored (matching write-time `compareSqlValues` enforcement). Residual: a
-     * custom comparator-only collation has no string normalizer and falls back to
-     * BINARY for the dedup (see docs/schema.md store-collation note).
+     * {@link serializeRowKey} with one normalizer per constrained column, resolved from
+     * `tableSchema.columns[idx].collation` through the connection's
+     * `db.getKeyNormalizerResolver()`, so a per-column collation registered with
+     * `db.registerCollation` is honored (matching write-time `compareSqlValues`
+     * enforcement). A comparator-only collation raises: rows that cannot be bucketed
+     * cannot be deduped. Columns whose declared type can never hold text take the
+     * identity normalizer and so never raise.
      */
     private validateUniqueOverExistingRows;
     /**
-     * Alters an existing store table's structure (ADD/DROP/RENAME COLUMN).
-     * Performs eager row migration for ADD and DROP, schema-only update for RENAME.
-     * Returns the updated TableSchema for the engine to register.
+     * Index-shaped twin of {@link validateUniqueOverExistingRows}, used by
+     * {@link createIndex} when a wrapper module supplies the rows to judge. Dedupes on the
+     * index's own columns under the index column's COLLATE (falling back to the table
+     * column's), so it enforces exactly what `buildIndexEntries`' suppressed in-pass check
+     * would have — over the wrapper's rows instead of this module's committed ones.
+     */
+    private validateUniqueIndexOverRows;
+    /**
+     * 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. `rekeyRows`' duplicate-key pass,
+     *   which must see pending 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 does NOT
+     *   need pending rows belongs before the call, so the transaction survives it.
+     *
+     * 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.
+     */
+    private ddlCommitPendingOps;
+    /**
+     * Alters an existing store table's structure. Resolves the table, captures the
+     * pre-alter schema, and dispatches to the per-change-type `alter*` helper below;
+     * the helper does the arm's work (row migration, physical re-key, constraint
+     * validation, DDL persist) and returns the updated TableSchema for the engine to
+     * register. The shared preamble (schema subscription, reconnect, not-found throw,
+     * `defaultNotNull`) lives here so every arm sees the same resolved state.
+     */
+    alterTable(db: Database, schemaName: string, tableName: string, change: SchemaChangeInfo, rows?: EffectiveRowSource): Promise<TableSchema>;
+    /**
+     * Build / tear down the physical index stores backing implicit UNIQUE indexes
+     * (`_uc_*`) after an ALTER, by diffing the implicit-index NAMES of the old vs new
+     * constraint sets:
+     *   - a name newly PRESENT (ADD CONSTRAINT UNIQUE, or the target half of a
+     *     RENAME CONSTRAINT / rename of an unnamed UC's column) has its physical store
+     *     populated from this module's effective rows;
+     *   - a name newly ABSENT (DROP CONSTRAINT UNIQUE, or the source half of a rename)
+     *     has its store torn down, so a later re-ADD does not reopen stale entries.
+     *
+     * The SCHEMA entry itself is materialized/removed by `withImplicitUniqueIndexes`
+     * on the arm's `table.updateSchema`; only the physical store needs this. Runs after
+     * every ALTER but is a no-op whenever the implicit-index name set is unchanged
+     * (incl. PK / collation / data-type ALTERs, whose same-name physical re-encode is
+     * already done by {@link rebuildSecondaryIndexes}).
+     *
+     * `oldSchema` carries the pre-ALTER `uniqueConstraints` (its `.indexes` may be
+     * de-materialized — the diff reads `uniqueConstraints`, not `.indexes`).
+     *
+     * NOTE: the build populates from THIS module's own effective rows (committed + this
+     * transaction's pending), never a wrapper's — mirroring `createIndex`. Under the
+     * isolation layer the wrapper's rows are what ADD CONSTRAINT's validation judged;
+     * the physical index legitimately fills from this module's committed rows and an
+     * entry with no live row behind it is harmless (both readers resolve to the live
+     * row). Duplicates were already rejected by `validateUniqueOverExistingRows` (ADD)
+     * or cannot exist (RENAME leaves data unchanged), so the in-pass check is skipped.
+     */
+    private reconcileImplicitUniqueIndexStores;
+    /**
+     * 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.
+     */
+    private materializedIndexNames;
+    /** Close + delete the physical store of an implicit UNIQUE index. Mirrors `dropIndex`. */
+    private tearDownImplicitUniqueIndexStore;
+    /**
+     * ADD COLUMN arm of {@link alterTable}: append the new column, eagerly migrate
+     * each row (literal or per-row backfill), and persist. Behavior-preserving
+     * extraction of the former `switch` arm.
+     */
+    private alterAddColumn;
+    /** DROP COLUMN arm of {@link alterTable}: drop the column slot, reindex PK / indexes /
+     *  UNIQUE, migrate rows, and persist. Behavior-preserving extraction. */
+    private alterDropColumn;
+    /** RENAME COLUMN arm of {@link alterTable}: schema-only rewrite (columns, indexes, self-FK,
+     *  in-place predicate / CHECK AST rewrite) and persist. Behavior-preserving extraction. */
+    private alterRenameColumn;
+    /** ALTER PRIMARY KEY arm of {@link alterTable}: physically re-key the data store, rebuild
+     *  secondary indexes, and persist. Behavior-preserving extraction. */
+    private alterPrimaryKeyChange;
+    /** ADD CONSTRAINT arm of {@link alterTable}: validate existing rows as the constraint kind
+     *  (UNIQUE / FOREIGN KEY / CHECK) requires, then persist. Behavior-preserving extraction. */
+    private alterAddConstraint;
+    /** DROP CONSTRAINT arm of {@link alterTable}: schema-only catalog rewrite dropping a named
+     *  constraint, then persist. Behavior-preserving extraction. */
+    private alterDropConstraint;
+    /** RENAME CONSTRAINT arm of {@link alterTable}: schema-only rename of a named constraint,
+     *  then persist. A renamed named-UNIQUE changes its implicit `_uc_*` index name, so
+     *  `reconcileImplicitUniqueIndexStores` (run after this arm) MOVES the physical store —
+     *  tears down the old-named store and rebuilds the new-named one from effective rows. */
+    private alterRenameConstraint;
+    /** ALTER COLUMN arm of {@link alterTable}: change one attribute (NOT NULL / data type /
+     *  default / collation), running the physical re-key + existing-row re-validation the
+     *  collation / PK paths require, then persist. Behavior-preserving extraction. */
+    private alterColumnChange;
+    /**
+     * SET NOT NULL / DROP NOT NULL sub-branch of {@link alterColumnChange}. Returns the
+     * new column schema, or null when the column is already in the desired nullability
+     * (the pre-refactor `return oldSchema` no-op). The NULL-backfill probe and rewrite
+     * order (throw-only probe before {@link ddlCommitPendingOps}) is unchanged.
+     *
+     * `rows` is the wrapper-supplied effective row source (the isolation overlay). When present,
+     * the reject-vs-backfill decision scans it instead of `table.rowsWithNullAtIndex`: behind the
+     * isolation layer the issuer's pending inserts live in the wrapper's overlay, not this store,
+     * so the store's own count would miss them and wrongly accept the ALTER. The committed-store
+     * `mapRowsAtIndex` backfill is unchanged — the overlay-resident pending rows are the isolation
+     * layer's job (its overlay migration), this store only owns its committed rows.
+     */
+    private alterColumnSetNotNull;
+    /**
+     * SET DATA TYPE sub-branch of {@link alterColumnChange}. Returns the retyped column
+     * schema. When the physical type changes, a throw-only convert pass over the live
+     * rows precedes {@link ddlCommitPendingOps} and the rewrite — order unchanged.
      */
-    alterTable(db: Database, schemaName: string, tableName: string, change: SchemaChangeInfo): Promise<TableSchema>;
+    private alterColumnSetDataType;
+    /**
+     * SET COLLATE sub-branch of {@link alterColumnChange}. Returns the recollated column
+     * schema with `collationChanged` set when the collation bytes actually change (a bare
+     * metadata flip keeps it false), or null when the column is already explicit in the
+     * desired collation (the pre-refactor `return oldSchema` no-op). Synchronous — no
+     * row scan happens here; the caller runs the re-validation / re-key the flag gates.
+     */
+    private alterColumnSetCollation;
     /**
      * Rename a store-backed table.
      *
@@ -410,6 +601,29 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
      * against the moved directories.
      */
     renameTable(db: Database, schemaName: string, oldName: string, newName: string): Promise<void>;
+    /**
+     * Second phase of a two-phase RENAME TABLE (see {@link renameTable}). The engine calls
+     * this at the END of ALTER TABLE ... RENAME TO — AFTER its `propagateTableRename` has
+     * rewritten every dependent object that named `oldName` and enqueued their corrective
+     * catalog writes onto {@link persistQueue}. `renameTable` deliberately left `oldName`'s
+     * catalog entry in place; here we drain those dependent writes to durability and only
+     * THEN drop the old entry. During the window both entries coexist on disk, so every
+     * dependent resolves against one of them and every intermediate catalog set rehydrates
+     * into a working database.
+     *
+     * The old-entry delete rides `persistQueue` behind the dependents' already-enqueued
+     * writes (FIFO), so it can only run after them, and the drain below awaits the whole
+     * chain. Errors are swallowed+logged (the {@link enqueuePersist} contract): a failed
+     * delete leaves the old entry present — a visible, droppable orphan, strictly safer
+     * than a dependent stranded against a vanished table.
+     *
+     * NOTE: full cross-table atomicity — bundling this old-entry delete together with every
+     * dependent rewrite into one `provider.beginAtomicBatch` commit — would eliminate even
+     * the transient two-entry window (and the physical-move orphan `renameTableStores`
+     * leaves), but only on atomic providers, and the dependent set is known only to the
+     * engine post-propagate. That is the atomic-provider hardening path; out of scope here.
+     */
+    finalizeRename(_db: Database, schemaName: string, oldName: string, _newName: string): Promise<void>;
     /**
      * Modern access planning interface.
      *
@@ -423,12 +637,48 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
      * (via `StoreTable.buildPKRangeBounds`) encodes the LT/LE/GT/GE bounds under the
      * same per-column key collations the data keys use and iterates that
      * seek-start/early-termination window. The window is a SUPERSET, so the post-fetch
-     * row filter still reproduces the exact collation semantics — and a comparator-only
-     * collation with no byte encoder safely falls back to a full scan. Mirrors the
-     * memory module's advertisement.
+     * row filter still reproduces the exact collation semantics. (A collation that cannot
+     * key at all never reaches a PK column: `StoreTable`'s constructor rejects it at DDL
+     * time.) Mirrors the memory module's advertisement.
+     *
+     * The seek/ordering claims are additionally gated on the key collation being
+     * ORDER-PRESERVING — byte order and comparator order must coincide, or the seek would
+     * under-fetch and the ordering advertisement would elide a Sort it must not. That gate
+     * needs the connection's collation registry, hence `db` is threaded down.
      */
-    getBestAccessPlan(_db: Database, tableInfo: TableSchema, request: BestAccessPlanRequest): BestAccessPlanResult;
+    getBestAccessPlan(db: Database, tableInfo: TableSchema, request: BestAccessPlanRequest): BestAccessPlanResult;
     private computeBestAccessPlan;
+    /**
+     * Build the access plan for one secondary index against `request`, or null when
+     * the index is not usable for this predicate.
+     *
+     * Usable = a contiguous leading-prefix EQ on the index columns (an index seek /
+     * point), or a LT/LE/GT/GE range on the LEADING index column. These mirror the
+     * two windows {@link StoreTable.analyzeIndexAccess} can build.
+     *
+     * **Collation-safety guard against under-fetch.** The store's index-column
+     * window is encoded under the table key collation K, but `matchesFilters`
+     * compares under the COLUMN's declared collation. Marking a filter handled drops
+     * the residual Filter, so the K-window must be a guaranteed SUPERSET of the
+     * qualifying rows. That holds only when K is coarser-or-equal to the column's
+     * declared collation. To stay provably safe with minimal logic we mark the
+     * covered filters handled — setting `indexName` + `seekColumns` — only when every
+     * seek column is non-text, OR its declared collation equals K, OR (K = NOCASE
+     * while the column is BINARY, i.e. K strictly coarser). Otherwise we return a
+     * cost-only plan (cheaper cost, filters unhandled, residual retained — correct,
+     * just not sped up). K itself always keys: `StoreTable`'s constructor rejects a
+     * table whose key encoding would need a collation it cannot resolve to a normalizer.
+     *
+     * NOTE: the coarser-K relaxation is sound for EQUALITY only. A RANGE window equates
+     * memcmp of K-normalized bytes with C's comparator order, which a merely coarser K does
+     * not give — under K = NOCASE and C = BINARY, 'K' (U+212A) is `> 'z'` yet keys as 'k',
+     * before 'z'. So the range arm demands `C === K` *and* K's `orderPreserving` assertion,
+     * via the shared {@link keyOrderMatchesCollation}; `StoreTable.analyzeIndexAccess`
+     * declines the same windows, so the two decisions cannot disagree. The cost is that a
+     * default-K (NOCASE) table with an index on a plain BINARY text column loses its index
+     * RANGE seek and falls back to the cost-only plan; EQ seeks are unchanged.
+     */
+    private tryIndexAccessPlan;
     /**
      * Compute the PK-ordering advertisement for a scan-style plan. Returns the
      * `providesOrdering` / `monotonicOn` / `supportsAsofRight` fields for a plan
@@ -452,12 +702,19 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
      *
      * Returns an empty object when there is no PK (heap-only table) — without a
      * leading key column there is no natural emit order.
+     *
+     * Every claim here is about the PHYSICAL key-byte order the store iterates in, but the
+     * consumers of `providesOrdering` / `monotonicOn` reason in the columns' COLLATION order.
+     * `orderPreservingPrefix` (from {@link pkOrderPreservingPrefixLength}) is how many leading
+     * PK members those two orders provably agree on: the advertisement is truncated to that
+     * prefix, and voided entirely when even the leading member disagrees — otherwise the
+     * absorb-Sort rule would elide a Sort and hand the caller byte-ordered rows.
      */
     private buildPkOrderingAdvertisement;
     /**
      * Get or create a data store for a table.
      */
-    getStore(tableKey: string, _config: StoreTableConfig): Promise<KVStore>;
+    getStore(schemaName: string, tableName: string, _config: StoreTableConfig): Promise<KVStore>;
     /**
      * Get or create an index store for a table.
      */
@@ -517,6 +774,16 @@ export declare class StoreModule implements VirtualTableModule<StoreTable, Store
      * the compare-write in `persistCatalogIfChanged` relies on.
      */
     private buildCatalogEntry;
+    /**
+     * Encode a bundle of persisted schema text (DDL) for the catalog store.
+     *
+     * Guards the FULL text, not just the object's name: a lone surrogate anywhere in it — a
+     * quoted column name, a `default '…'` string literal, a `check` constraint's string
+     * constant — would otherwise fold to U+FFFD under `TextEncoder` and read back as
+     * different schema text than what was created. This does not rely on the catalog-key
+     * builders' identifier guard having already caught it; it catches it independently.
+     */
+    private encodeCatalogDDL;
     /**
      * Save table DDL (bundled with its secondary index DDL) to the catalog store.
      */

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

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