@quereus/isolation 4.3.1 → 4.3.2

package/dist/src/isolated-table.d.ts

@@ -1,5 +1,6 @@
 import type { Database, MaybePromise, Row, TableIndexSchema as IndexSchema, FilterInfo, SchemaChangeInfo, UpdateArgs, VirtualTableConnection, UpdateResult } from '@quereus/quereus';
 import { VirtualTable } from '@quereus/quereus';
+import type { EffectiveRowSource } from '@quereus/quereus';
 import type { IsolationModule } from './isolation-module.js';
 import { type IsolatedTableCallback } from './isolated-connection.js';
 /**
@@ -29,15 +30,59 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
      * lets the GC reclaim entries for retired constraints.
      */
     private readonly predicateCache;
+    /**
+     * `db.getCollationResolver()`, bound once at connect. Both the overlay/underlying
+     * merge comparators and the UNIQUE conflict checks resolve collation names through
+     * it, so a collation registered with `db.registerCollation` participates instead of
+     * silently degrading to BINARY.
+     *
+     * The overlay's key comparator and the underlying table's must agree, or a staged
+     * row fails to shadow the base row it replaces; both now derive from this one
+     * database registry.
+     */
+    private readonly collationResolver;
+    /**
+     * `db.getKeyNormalizerResolver()`, bound once at connect beside {@link collationResolver}
+     * for the same reason: the modified-PK set's key encoding and the comparators above must
+     * agree on which rows are equal, or a staged row fails to shadow the base row it replaces.
+     */
+    private readonly keyNormalizerResolver;
+    /**
+     * Per-PK-column comparison functions and sort directions, resolved from the PK
+     * columns' declared collations and memoized against the `TableSchema` object
+     * identity — an `alter table` hands this instance a fresh (frozen) schema object,
+     * which invalidates the entry.
+     */
+    private pkCollationCache?;
     /**
      * Returns the connection-scoped set of savepoint depths that pre-date the overlay.
      * Stored in IsolationModule (keyed by db+schema+table) so all IsolatedTable instances
      * for the same connection see the same set — important because each statement creates
      * a fresh IsolatedTable instance via module.connect(), so instance-local state would
      * be lost between the createSavepoint callback and the ensureOverlay() call.
+     *
+     * NOTE: keyed by the name this IsolatedTable was *constructed* with, which after a
+     * mid-transaction `alter table … rename to …` is the pre-rename name. Deliberate:
+     * this same instance stays the registered connection's callback object for the rest
+     * of the transaction and clears the set at commit/rollback, so the key must not move
+     * out from under it. A statement after the rename connects a fresh IsolatedTable under
+     * the new name, which builds its own set from `Database.registerConnection`'s savepoint
+     * replay. See `IsolationModule.renameTable`.
      */
     private get savepointsBeforeOverlay();
-    constructor(db: Database, module: IsolationModule, underlyingTable: VirtualTable, readCommitted?: boolean);
+    /**
+     * @param schemaName Schema name as supplied to `IsolationModule.create()`/`.connect()` — the
+     *   same identity `IsolationModule.underlyingTables` is keyed by.
+     * @param tableName Bare table name from the same source. These MUST NOT be read off
+     *   `underlyingTable.schemaName` / `.tableName`: `VirtualTable.tableName` is contracted bare,
+     *   but an underlying module that reports a schema-qualified name there (lamina-quereus does,
+     *   using the field as a catalogue key) would key this table's overlay as
+     *   `<dbId>:store.store.widget` while `underlyingTables` holds `store.widget`. The commit
+     *   flush looks the overlay's key up in `underlyingTables`, misses, and silently discards
+     *   every staged row. Keying off the connect-time pair keeps both maps on one identity by
+     *   construction, whatever the underlying self-reports.
+     */
+    constructor(db: Database, module: IsolationModule, schemaName: string, tableName: string, underlyingTable: VirtualTable, readCommitted?: boolean);
     /**
      * Gets the tombstone column name from the module.
      */
@@ -47,13 +92,14 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
      */
     private getOverlayState;
     /**
-     * Throws if this connection's overlay was poisoned by a cross-connection ALTER
-     * (see `IsolationModule.alterTable`). A poisoned overlay still holds rows in the
-     * PRE-alter column layout, so it can neither be merged into a read nor flushed to
-     * the now-altered underlying. Called at the data-op chokepoints (write, the merged
-     * read branch, and the commit flush) — never on the committed-snapshot read path,
-     * which bypasses the overlay entirely and stays safe. The connection recovers by
-     * rolling back, which discards the overlay (and its poison).
+     * Throws if this connection's overlay was poisoned by a cross-connection DDL: an ALTER
+     * that could not migrate it (see `IsolationModule.alterTable`), leaving its rows in the
+     * PRE-alter column layout, or a DROP TABLE that removed the table underneath it (see
+     * `IsolationModule.destroy`). Either way it can neither be merged into a read nor
+     * flushed. Called at the data-op chokepoints (write, the merged read branch, and the
+     * commit flush) — never on the committed-snapshot read path, which bypasses the overlay
+     * entirely and stays safe. The connection recovers by rolling back, which discards the
+     * overlay (and its poison).
      */
     private assertOverlayUsable;
     /**
@@ -151,26 +197,89 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
      *
      * Instead of position-based merging (which fails when overlay entries have
      * different index key values than the underlying rows they shadow), this:
-     * 1. Collects all PKs modified in the overlay (full scan)
-     * 2. Queries underlying via secondary index, excluding modified PKs
-     * 3. Queries overlay via secondary index for non-tombstone data rows
-     * 4. Merges the two disjoint, sorted streams by sort key
+     * 1. Full-scans the overlay ONCE, collecting all modified PKs and the non-tombstone
+     *    data rows that fall inside the query's constraint window
+     * 2. Sorts the collected overlay rows by the scan's (indexKey, PK) sort key
+     * 3. Queries underlying via secondary index, excluding modified PKs, and merges the
+     *    sorted overlay rows in by sort key
+     *
+     * The overlay is deliberately never asked to resolve the query's index name. The
+     * underlying module may drive this scan under an index it minted itself (lamina
+     * mints `_column_<id>_`, `_compound_<name>_`, `_nd_<name>_`, `_intersect_<ids>_`
+     * per plan) — a name no table schema, and therefore no overlay, declares — so
+     * re-issuing the index-named FilterInfo against the overlay would throw
+     * "Secondary index not found". The isolation layer filters and sorts the overlay
+     * delta itself instead.
      */
     private mergedSecondaryIndexQuery;
     /**
-     * Parses FilterInfo to determine which index is being used.
-     * Returns null for full table scan or primary key scan, index name for secondary indexes.
-     */
-    private parseIndexFromFilterInfo;
-    /**
-     * Gets the column indices for a secondary index.
+     * Determine the order the underlying scan emits, from the planner's typed access path.
+     *
+     * A `fullScan` (or a provably-empty plan) merges by primary key: every underlying module
+     * the isolation layer wraps emits an unbounded scan in primary-key order. That is a
+     * contract on the underlying, not an inference from any string — see
+     * docs/design-isolation-layer.md.
+     *
+     * `role` is authoritative over `name`: a descriptor with `role: 'primary'` IS the table's
+     * primary key however the module named it (an alias like `_primary_1`), so it merges by PK.
+     * An `unresolvedIndex` — a name the engine could not resolve to any index, with no
+     * module-supplied descriptor — cannot yield a comparator, so we fail loudly rather than
+     * silently merge by the wrong sort key.
      */
-    private getIndexColumnIndices;
+    private resolveScanIndex;
     /**
      * Adapts FilterInfo for the overlay table schema (which has an extra tombstone column).
      * The constraints and index references remain the same since the overlay has matching indexes.
+     *
+     * The one mismatch is the index NAME. The underlying may drive its PK plan under a per-plan
+     * alias (e.g. `_primary_1`) that the overlay MemoryTable does not know — the overlay always
+     * names its PK index `_primary_`. When the access path is the primary key under such an
+     * alias, retarget the FilterInfo's index name to `_primary_` so the overlay re-plans it as a
+     * primary-key scan instead of failing to resolve a non-existent secondary index of that name.
+     * A genuine secondary scan (or the bare `_primary_`) is returned unchanged.
      */
     private adaptFilterInfoForOverlay;
+    /**
+     * Builds the window predicate for the overlay side of a merged secondary-index read.
+     *
+     * The overlay is full-scanned there (it cannot resolve an underlying-minted index
+     * name), so every staged row surfaces — including rows outside the query's window.
+     * This predicate re-applies the pushed constraints that the underlying's index seek
+     * enforces on its own stream.
+     *
+     * Interpretation follows the plan kind:
+     * - `scan` pushes no window — everything matches.
+     * - `eqSeek` / `rangeSeek` / `prefixRangeSeek` / `multiSeek` carry one genuine
+     *   (column, op, value) triple per constraint entry. Per-column EQ values form an
+     *   IN set — the planner encodes an IN multi-seek as one EQ constraint per seek
+     *   value on the same column, and a composite IN as its full per-column
+     *   cross-product — so EQ matches when the row equals ANY of the column's values,
+     *   while range bounds all AND together.
+     * - `multiRangeSeek` constraint entries are positional placeholders (every arg is
+     *   stamped GE); the real OR-of-ranges lives in the idxStr `rangeOps` parameters,
+     *   decoded by {@link buildMultiRangeWindowMatcher}.
+     *
+     * Comparisons run under the index key column's collation (falling back to the table
+     * column's, then BINARY) with seek semantics for NULL: a NULL operand or a NULL row
+     * value never matches, mirroring what an index seek returns. Operators the matcher
+     * does not interpret (LIKE, MATCH, ...) are ignored — that can only let through
+     * rows a residual Filter above still removes, never drop rows.
+     */
+    private buildConstraintMatcher;
+    /**
+     * Window matcher for a `multiRangeSeek` — an OR of ranges over the index's leading
+     * key column. The FilterInfo's constraint entries are positional placeholders for
+     * this plan kind, so the ranges are decoded from the idxStr `rangeCount`/`rangeOps`
+     * parameters exactly as the memory module's scan-plan builder does.
+     */
+    private buildMultiRangeWindowMatcher;
+    /**
+     * Comparison collation for a window-matcher column: the index key column's declared
+     * collation when the column is part of the scanned index (the seek's own window
+     * follows the index collation), else the table column's declared collation, else
+     * BINARY.
+     */
+    private constraintCollation;
     /**
      * Queries the overlay table and converts rows to MergeEntry format.
      *
@@ -194,10 +303,44 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
      * @param indexInfo Which index is being scanned. Defaults to primary key scan.
      */
     private buildMergeConfig;
+    /**
+     * Per-PK-column comparison functions for this table's current schema, resolved
+     * against THIS database's collation registry (so `db.registerCollation` names
+     * participate) rather than the process-global built-in trio.
+     *
+     * A PK column with no declared `COLLATE` resolves to BINARY; a PK definition
+     * shorter than the key being compared (or absent entirely) yields BINARY for the
+     * trailing positions, matching the prior `collation === undefined` behaviour.
+     *
+     * Memoized on the schema object so comparator construction — and the per-call
+     * {@link keysEqual} — never re-resolves per row. Resolution is not retroactive: a
+     * collation registered *after* a comparator was built is not picked up, the same
+     * contract `Database.registerCollation` documents engine-wide.
+     *
+     * NOTE: this is the *comparison* collation only. The store's physical key bytes come
+     * from a separate encoder registry that does not consult the database — see
+     * `fix/bug-store-key-encoder-ignores-database-collations`.
+     */
+    private getPkCollations;
+    /**
+     * Per-PK-column sort directions (`true` ⇒ DESC), positionally aligned with
+     * {@link getPkCollations}. Only the ordering comparator needs them; `keysEqual`
+     * asks about equality, which direction cannot change.
+     */
+    private getPkDirections;
+    private getPkKeyShape;
     /**
      * Gets the primary key comparator, preferring the underlying table's comparator.
      */
     private getComparePK;
+    /**
+     * Per-column comparators derived from an index descriptor's key columns — the
+     * fallback when the underlying exposes no `getIndexComparator` for the index
+     * (always the case for a module-minted synthetic name). Honors each key column's
+     * declared direction and collation so the merge walks the underlying's emission
+     * order.
+     */
+    private buildDescriptorComparators;
     /**
      * Builds a sort key comparator for secondary index scans.
      *
@@ -213,6 +356,15 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
      * Gets the primary key column indices from the underlying table schema.
      */
     getPrimaryKeyIndices(): number[];
+    /**
+     * Coerce each cell to its declared column logical type before PK extraction and
+     * conflict detection — the same step StoreTable.coerceRow / MemoryTableManager.performInsert
+     * run. Without it, an ON CONFLICT insert whose proposed key is a different storage class than
+     * the stored key (TEXT '1' into an INTEGER key holding 1) probes the underlying with the
+     * un-coerced key, misses the committed row, and stages the proposed row instead of updating
+     * the existing one (bug-store-isolation-upsert-affinity-coerced-pk).
+     */
+    private coerceRow;
     /**
      * Performs INSERT, UPDATE, or DELETE on the overlay.
      * Changes are not visible to underlying until commit.
@@ -298,11 +450,74 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
      */
     private checkMergedPKConflict;
     /**
-     * Scans the underlying table for a row conflicting with newRow on `uc.columns`,
-     * excluding selfPks and rows tombstoned in the overlay. For partial UNIQUE,
-     * candidates whose row does not satisfy the predicate are skipped.
+     * Finds a row conflicting with `newRow` on `uc.columns` across the MERGED view —
+     * this connection's overlay superimposed on the underlying committed rows —
+     * excluding `selfPks`. For partial UNIQUE, candidates outside the predicate's scope
+     * are skipped.
+     *
+     * The merged view splits cleanly into two disjoint halves, each searched the way it
+     * is cheap to search:
+     *
+     *     merged view  =  (overlay rows)  ∪  (underlying rows with no overlay entry)
+     *
+     * Phase 1 scans the small in-memory overlay; Phase 2 seeks/scans the large
+     * underlying, skipping any candidate whose PK the overlay already owns (Phase 1's
+     * territory, whatever the underlying still says). Together they cover the merged
+     * view exactly once with no row visited twice.
+     *
+     * Phase 1 runs first, so when the constraint was ALREADY violated an overlay-side
+     * conflict is reported in preference to an underlying one. Under a satisfied
+     * constraint at most one conflicting row can exist, so this tie-break only changes
+     * WHICH row is named in that pre-violated case.
      */
     private findMergedUniqueConflict;
+    /**
+     * Phase 1 — scan the overlay (this connection's uncommitted write set, small and
+     * in-memory) for a live row conflicting with `newRow`. Tombstones and `selfPks` are
+     * skipped; a matching live overlay row IS the merged row (stripped of the trailing
+     * tombstone column), and its overlay value — not any stale underlying value — is
+     * what the merged view holds for that PK
+     * (isolation-merged-unique-stale-underlying-false-positive).
+     */
+    private findOverlayUniqueConflict;
+    /**
+     * Phase 2 — find an underlying committed row conflicting with `newRow`, skipping
+     * `selfPks` and any PK the overlay already owns (Phase 1's territory). The lookup is
+     * an index seek when {@link canSeekForConstraint} allows it, else the full scan —
+     * either way the per-column match runs, so a module that ignores the index hint and
+     * returns extra rows stays correct. `getOverlayRow` fires only for the candidates the
+     * seek actually returned, so it no longer costs one lookup per underlying row.
+     */
+    private findUnderlyingUniqueConflict;
+    /**
+     * True-match test shared by both merged-check phases so they compare identically:
+     * `candidate` matches `newRow` on every constrained column under that column's
+     * enforcement collation (NULLs never match), and — for a partial UNIQUE — the
+     * predicate holds for `candidate`.
+     *
+     * The per-column collation (the index's per-column COLLATE for an index-derived
+     * UNIQUE, else the declared column collation) enforces a UNIQUE over a collated
+     * column against merged rows through the isolation path
+     * (unique-constraint-honors-column-collation / store-index-derived-unique).
+     */
+    private rowMatchesUniqueConstraint;
+    /**
+     * The secondary index Phase 2 may seek for `uc`, or null to fall back to a full scan.
+     *
+     * Seek only when the constraint was synthesized from a `CREATE UNIQUE INDEX`
+     * (`derivedFromIndex` names a live entry in `tableSchema.indexes`) AND every key
+     * column's effective enforcement collation is BINARY.
+     *
+     * NOTE: the BINARY gate is load-bearing, not an optimisation choice. The store's
+     * physical index key bytes come from a separate encoder registry that does NOT
+     * consult the database's collation registry
+     * (backlog/debt-store-index-keys-use-column-collation, see the comment at
+     * getPkKeyShape above). Seeking a NOCASE index for 'B@X' would miss the committed
+     * 'b@x' that the full scan catches, turning this perf fix into a LOST UNIQUE
+     * violation. Widen this gate (to per-column enforcement collations generally) only
+     * once that encoder defect is fixed.
+     */
+    private canSeekForConstraint;
     /**
      * Checks all non-PK UNIQUE constraints against the merged view.
      * Returns null when all pass or REPLACE evictions succeed.
@@ -317,41 +532,12 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
     begin(): Promise<void>;
     sync(): Promise<void>;
     commit(): Promise<void>;
-    /**
-     * Flushes overlay changes to underlying (if any) and discards the overlay.
-     * Shared by commit() and onConnectionCommit().
-     */
-    private flushAndClearOverlay;
-    /**
-     * Flushes all overlay changes to the underlying table.
-     * Called during commit to persist changes.
-     *
-     * This method manages the underlying table's transaction lifecycle independently
-     * to ensure that flushed data is committed and won't be rolled back by subsequent
-     * transaction rollbacks.
-     */
-    private flushOverlayToUnderlying;
-    /**
-     * Asserts that an underlying write performed during the commit flush succeeded.
-     *
-     * The overlay's merged-view pre-checks ({@link checkMergedPKConflict} /
-     * {@link checkMergedUniqueConstraints}) resolve every constraint before commit, so a
-     * `constraint` result returned here means a real invariant was violated *after* those
-     * checks. Historically this result was discarded, silently dropping the colliding
-     * write and surfacing as data corruption. Convert it into a loud INTERNAL error; the
-     * caller's try/catch rolls back the underlying flush transaction and rethrows.
-     */
-    private assertFlushWriteOk;
-    /**
-     * Checks if a row with the given primary key exists in the underlying table.
-     * Uses O(log n) point lookup via the PK index.
-     */
-    private rowExistsInUnderlying;
     rollback(): Promise<void>;
     /**
-     * Discards the connection-scoped overlay entirely.
-     * The overlay table is per-connection and ephemeral, so simply removing
-     * the reference allows GC to reclaim it. A fresh overlay will be created
+     * Discards the connection-scoped overlay entirely. The module frees the overlay's
+     * staging table (see IsolationModule.clearConnectionOverlay → releaseOverlayTable) rather
+     * than merely dropping the reference — the overlay module's registry pins the manager, so
+     * a bare reference-drop leaked it for the life of the Database. A fresh overlay is created
      * lazily via ensureOverlay() on the next write.
      */
     private clearOverlay;
@@ -361,7 +547,16 @@ export declare class IsolatedTable extends VirtualTable implements IsolatedTable
     disconnect(): Promise<void>;
     rename(newName: string): Promise<void>;
     alterSchema(changeInfo: SchemaChangeInfo): Promise<void>;
-    createIndex(indexInfo: IndexSchema): Promise<void>;
+    /**
+     * Index DDL delegates to the module rather than driving the underlying and the overlay
+     * directly. The module owns the full protocol — validating against the issuing
+     * connection's effective rows, then REBUILDING every affected overlay under the new
+     * schema — and a bare `underlying.createIndex()` + `overlay.createIndex()` pair silently
+     * skips both halves. The engine only ever reaches the module-level hook, so these
+     * instance methods exist for a module that wraps `IsolationModule` in turn; routing them
+     * through the module keeps that path on the same protocol.
+     */
+    createIndex(indexInfo: IndexSchema, rows?: EffectiveRowSource): Promise<void>;
     dropIndex(indexName: string): Promise<void>;
     /**
      * Returns whether there are pending uncommitted changes.

package/dist/src/isolated-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isolated-table.d.ts","sourceRoot":"","sources":["../../src/isolated-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAoB,YAAY,EAAE,GAAG,EAAY,gBAAgB,IAAI,WAAW,EAAE,UAAU,EAAE,gBAAgB,EAA0D,UAAU,EAAE,sBAAsB,EAAE,YAAY,EAAS,MAAM,kBAAkB,CAAC;AAChR,OAAO,EAAE,YAAY,EAAuK,MAAM,kBAAkB,CAAC;AACrN,OAAO,KAAK,EAAE,eAAe,EAA0B,MAAM,uBAAuB,CAAC;AACrF,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAW1F;;;;;;;;;;;;;;GAcG;AACH,qBAAa,aAAc,SAAQ,YAAa,YAAW,qBAAqB;IAC/E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAe;IAC/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IAExC,OAAO,CAAC,oBAAoB,CAAmC;IAE/D;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqE;IAEpG;;;;;;OAMG;IACH,OAAO,KAAK,uBAAuB,GAElC;gBAGA,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,eAAe,EACvB,eAAe,EAAE,YAAY,EAC7B,aAAa,GAAE,OAAe;IAW/B;;OAEG;IACH,OAAO,KAAK,eAAe,GAE1B;IAED;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACH,OAAO,KAAK,YAAY,GAEvB;IAED;;OAEG;IACH,OAAO,KAAK,UAAU,GAErB;IAED;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;;;;;OAQG;YACW,aAAa;IAkD3B;;;;;;;;;;;;;;;;;;;;OAoBG;YACW,gBAAgB;IAY9B;;;;;;;;;;;;OAYG;YACW,eAAe;IA+B7B;;;;OAIG;IACH,gBAAgB,IAAI,YAAY,CAAC,sBAAsB,CAAC;YAkB1C,qBAAqB;IAanC;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC;IAqBjD;;OAEG;YACY,yBAAyB;IAKxC;;;;;;;;;OASG;YACY,WAAW;IAsB1B;;;;;;;;;OASG;YACY,yBAAyB;IA8DxC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA+BhC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAU7B;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAOjC;;;;;OAKG;YACY,0BAA0B;IA8BzC;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAWpB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAmCxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAqB3B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAY/B;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAQhC;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IA2OrD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAMhC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAQrB;;OAEG;YACW,aAAa;IAS3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA+BhC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,SAAS;YAeH,gBAAgB;IAQ9B;;;;;;;;;;;;;;;;OAgBG;YACW,iBAAiB;YAuBjB,oBAAoB;IAelC;;;;;;;;;;;OAWG;YACW,qBAAqB;IA0BnC;;;;OAIG;YACW,wBAAwB;IAgDtC;;;;;;;;;OASG;YACW,4BAA4B;IA8CpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAK7B;;;OAGG;YACW,oBAAoB;IAclC;;;;;;;OAOG;YACW,wBAAwB;IA2EtC;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;OAGG;YACW,qBAAqB;IAS7B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IASd,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,WAAW,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IASxD,WAAW,CAAC,SAAS,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlD,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BjD;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAc5B;;;OAGG;IACG,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAKzC;;;OAGG;IACG,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3C;;;;;;;;;;;OAWG;IACG,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOzD;;OAEG;IACG,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhE;;;;;;OAMG;IACG,+BAA+B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAanE"}
+{"version":3,"file":"isolated-table.d.ts","sourceRoot":"","sources":["../../src/isolated-table.ts"],"names":[],"mappings":"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"}