persian-data-grid 0.5.0 → 0.7.0

package/dist/chunk-J4XJ4UBC.js

@@ -0,0 +1,1404 @@
+import { Cell, Row, Collection, Table } from './chunk-5HKVMPBD.js';
+import { RowId, ColumnId, CellValue, RowState, Pagination } from './chunk-XLRE2J25.js';
+
+// infrastructure/Repositories/paged/PagedIndexedDbTableRepository.ts
+var DB_NAME = "ERP_TABLE_DB";
+function rowRecordId(tableId, collection, rowId) {
+  return `${tableId}::${collection}::${rowId}`;
+}
+function sortIndexOf(row) {
+  const raw = row.getCell("index")?.getValue();
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : 0;
+}
+function isValidIdbKey(value) {
+  if (typeof value === "string") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (value instanceof Date) return !Number.isNaN(value.getTime());
+  if (Array.isArray(value)) return value.length > 0 && value.every(isValidIdbKey);
+  if (value instanceof ArrayBuffer) return true;
+  if (ArrayBuffer.isView(value)) return true;
+  return false;
+}
+function asTableIdKey(tableId) {
+  if (typeof tableId === "string" && tableId.length > 0) return tableId;
+  if (typeof tableId === "number" && Number.isFinite(tableId)) return String(tableId);
+  return null;
+}
+var PagedIndexedDbTableRepository = class {
+  constructor() {
+    this.dbPromise = this.initDb();
+  }
+  bindDb(db) {
+    db.onversionchange = () => {
+      db.close();
+      console.warn("DB version changed, connection closed");
+      this.dbPromise = this.initDb();
+    };
+    return db;
+  }
+  /**
+   * Open at the *existing* DB version (no fixed version number).
+   * ensureStores() bumps version only when new object stores are needed.
+   * A fixed open(version) would throw VersionError after lazy upgrades.
+   */
+  initDb() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME);
+      request.onsuccess = () => resolve(this.bindDb(request.result));
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getDb() {
+    return this.dbPromise;
+  }
+  metaStore(storeName) {
+    return storeName;
+  }
+  rowsStore(storeName) {
+    return `${storeName}__rows`;
+  }
+  async ensureStores(db, storeName) {
+    const meta = this.metaStore(storeName);
+    const rows = this.rowsStore(storeName);
+    if (db.objectStoreNames.contains(meta) && db.objectStoreNames.contains(rows)) {
+      return db;
+    }
+    const nextVersion = db.version + 1;
+    db.close();
+    const newDb = await new Promise((resolve, reject) => {
+      const req = indexedDB.open(DB_NAME, nextVersion);
+      req.onupgradeneeded = (event) => {
+        const upgraded = event.target.result;
+        if (!upgraded.objectStoreNames.contains(meta)) {
+          upgraded.createObjectStore(meta, { keyPath: "id" });
+        }
+        if (!upgraded.objectStoreNames.contains(rows)) {
+          const rowStore = upgraded.createObjectStore(rows, { keyPath: "id" });
+          rowStore.createIndex("byTableCollectionSort", ["tableId", "collection", "sortIndex"], {
+            unique: false
+          });
+          rowStore.createIndex("byTable", "tableId", { unique: false });
+        }
+      };
+      req.onsuccess = () => resolve(this.bindDb(req.result));
+      req.onerror = () => reject(req.error);
+    });
+    this.dbPromise = Promise.resolve(newDb);
+    return newDb;
+  }
+  // ─── Row (de)serialization ──────────────────────────────────────────────────
+  serializeRow(tableId, row) {
+    return {
+      id: rowRecordId(tableId, row.collection, row.id.value),
+      tableId,
+      rowId: row.id.value,
+      collection: row.collection,
+      sortIndex: sortIndexOf(row),
+      rowState: row.rowState.value,
+      visibilityCondition: row.visibilityCondition,
+      isSaveDescription: row.isSaveDescription,
+      cells: Array.from(row.getCells().entries()).map(([colId, cell]) => ({
+        colId,
+        value: cell.getValue(),
+        originalValue: cell.getOriginalValue().value,
+        display: cell.getDisplay()
+      }))
+    };
+  }
+  deserializeRow(r) {
+    const cells = /* @__PURE__ */ new Map();
+    r.cells.forEach((c) => {
+      cells.set(
+        c.colId,
+        new Cell(
+          new RowId(r.rowId),
+          new ColumnId(c.colId),
+          new CellValue(c.value),
+          new CellValue(c.originalValue),
+          new CellValue(c.display)
+        )
+      );
+    });
+    const changeFields = /* @__PURE__ */ new Set();
+    if (r.rowState === "Update" /* Modified */) {
+      r.cells.forEach((c) => {
+        if (c.value !== c.originalValue) changeFields.add(c.colId);
+      });
+    }
+    return new Row(
+      new RowId(r.rowId),
+      cells,
+      new RowState(r.rowState),
+      changeFields,
+      r.visibilityCondition,
+      r.collection,
+      r.isSaveDescription
+    );
+  }
+  serializeColumn(col) {
+    return {
+      fieldName: col.fieldName,
+      fieldCaption: col.fieldCaption,
+      fieldType: col.fieldType,
+      fieldCollection: col.fieldCollection,
+      order: col.order,
+      editable: col.editable,
+      isUnique: col.isUnique,
+      noCache: col.noCache,
+      expandable: col.expandable,
+      enableDeleteButton: col.enableDeleteButton,
+      enableExpandButton: col.enableExpandButton,
+      enableMoveButton: col.enableMoveButton,
+      enableOptionsButton: col.enableOptionsButton,
+      disable: col.disable,
+      hidden: col.hidden,
+      className: col.className,
+      visibility: col.visibility,
+      selectOptions: col.selectOptions,
+      minWidth: col.minWidth,
+      style: col.style,
+      popUpWidth: col.popUpWidth,
+      labelValue: col.labelValue
+    };
+  }
+  buildMetaFromTable(table, totalRowsOverride, existing) {
+    const id = asTableIdKey(table.id);
+    if (!id) {
+      throw new Error(`[PagedIndexedDbTableRepository] Cannot persist meta: invalid table.id (${String(table.id)})`);
+    }
+    const pagination = table.getPagination();
+    const active = table.getActiveCollectionName() || "default";
+    const collections = [];
+    for (const [name, col] of table.getCollections()) {
+      collections.push({
+        name,
+        columns: Array.from(col.getColumns().values()).map((c) => this.serializeColumn(c))
+      });
+    }
+    const windowCounts = {};
+    let counted = 0;
+    let otherCollectionsHaveRows = false;
+    for (const [name, col] of table.getCollections()) {
+      const size = col.getRows().size;
+      if (name === active) windowCounts[name] = size;
+      else if (size > 0) otherCollectionsHaveRows = true;
+      counted += size;
+    }
+    const isFullMultiCollectionSeed = otherCollectionsHaveRows;
+    const totalRows = isFullMultiCollectionSeed ? windowCounts[active] ?? 0 : totalRowsOverride ?? Math.max(pagination.totalRows, counted);
+    const totalRowsByCollection = {
+      ...existing?.totalRowsByCollection ?? {},
+      ...windowCounts,
+      [active]: totalRows
+    };
+    if (isFullMultiCollectionSeed) {
+      for (const [name, col] of table.getCollections()) {
+        totalRowsByCollection[name] = col.getRows().size;
+      }
+    }
+    return {
+      id,
+      kind: "meta",
+      activeCollection: active,
+      page: pagination.page || 1,
+      pageSize: pagination.pageSize || 10,
+      totalRows,
+      totalRowsByCollection,
+      collections
+    };
+  }
+  buildTableFromPage(meta, pageRows, page, pageSize) {
+    const collectionMap = /* @__PURE__ */ new Map();
+    const active = meta.activeCollection || "default";
+    for (const colMeta of meta.collections ?? []) {
+      const colMap = /* @__PURE__ */ new Map();
+      for (const c of colMeta.columns ?? []) {
+        colMap.set(c.fieldName, c);
+      }
+      collectionMap.set(colMeta.name, new Collection(colMeta.name, /* @__PURE__ */ new Map(), colMap));
+    }
+    if (!collectionMap.has(active)) {
+      collectionMap.set(active, new Collection(active, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()));
+    }
+    for (const row of pageRows) {
+      const name = row.collection || active;
+      let collection = collectionMap.get(name);
+      if (!collection) {
+        collection = new Collection(name, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+        collectionMap.set(name, collection);
+      }
+      collection.getRows().set(row.id.value, row);
+    }
+    const total = meta.totalRowsByCollection?.[active] ?? meta.totalRows;
+    return new Table(
+      meta.id,
+      collectionMap,
+      new Pagination(page, pageSize, total),
+      null,
+      active
+    ).setPageWindow(true);
+  }
+  async readMeta(db, storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) return null;
+    const metaName = this.metaStore(storeName);
+    if (!db.objectStoreNames.contains(metaName)) return null;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(metaName, "readonly");
+      const req = tx.objectStore(metaName).get(key);
+      req.onsuccess = () => resolve(req.result ?? null);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  isLegacy(data) {
+    return !("kind" in data) || data.kind !== "meta";
+  }
+  async migrateLegacy(db, storeName, legacy) {
+    const active = legacy.activeCollection ?? legacy.activeDetailType ?? "default";
+    const allRows = [];
+    const collections = [];
+    for (const c of legacy.collections ?? []) {
+      const name = c.name ?? c.type ?? active;
+      collections.push({ name, columns: [] });
+      for (const r of c.rows ?? []) {
+        allRows.push(
+          this.deserializeRow({
+            id: rowRecordId(legacy.id, r.collection ?? r.rowType ?? name, r.rowId),
+            tableId: legacy.id,
+            rowId: r.rowId,
+            collection: r.collection ?? r.rowType ?? name,
+            sortIndex: 0,
+            rowState: r.rowState,
+            visibilityCondition: r.visibilityCondition,
+            isSaveDescription: r.isSaveDescription,
+            cells: r.cells
+          })
+        );
+      }
+    }
+    for (const row of allRows) {
+    }
+    const meta = {
+      id: legacy.id,
+      kind: "meta",
+      activeCollection: active,
+      page: 1,
+      pageSize: 10,
+      totalRows: allRows.length,
+      collections
+    };
+    db = await this.ensureStores(db, storeName);
+    await this.putMeta(db, storeName, meta);
+    await this.putRows(db, storeName, legacy.id, allRows);
+    return meta;
+  }
+  putMeta(db, storeName, meta) {
+    const id = asTableIdKey(meta.id);
+    if (!id) {
+      console.warn("[PagedIndexedDbTableRepository] putMeta skipped: invalid id", meta?.id);
+      return Promise.resolve();
+    }
+    let cloneable;
+    try {
+      cloneable = JSON.parse(JSON.stringify({ ...meta, id }));
+    } catch (e) {
+      console.warn("[PagedIndexedDbTableRepository] putMeta skipped: not serializable", e);
+      return Promise.resolve();
+    }
+    cloneable.id = id;
+    if (!isValidIdbKey(cloneable.id)) {
+      console.warn("[PagedIndexedDbTableRepository] putMeta skipped: id not a valid IDB key", cloneable.id);
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.metaStore(storeName), "readwrite");
+      tx.objectStore(this.metaStore(storeName)).put(cloneable);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  putRows(db, storeName, tableId, rows) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] putRows skipped: invalid tableId", tableId);
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.rowsStore(storeName), "readwrite");
+      const os = tx.objectStore(this.rowsStore(storeName));
+      for (const row of rows) {
+        const record = this.serializeRow(key, row);
+        if (!isValidIdbKey(record.id)) continue;
+        const cloneable = JSON.parse(JSON.stringify(record));
+        cloneable.id = record.id;
+        cloneable.tableId = key;
+        os.put(cloneable);
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  /** Put already-serialized row records directly (no domain Row round-trip). */
+  putRowRecords(db, storeName, records) {
+    if (records.length === 0) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.rowsStore(storeName), "readwrite");
+      const os = tx.objectStore(this.rowsStore(storeName));
+      for (const record of records) {
+        if (!isValidIdbKey(record.id)) continue;
+        os.put(JSON.parse(JSON.stringify(record)));
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async deleteAllRowsForTable(db, storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] deleteAllRows skipped: invalid tableId", tableId);
+      return;
+    }
+    const rowsName = this.rowsStore(storeName);
+    if (!db.objectStoreNames.contains(rowsName)) return;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(rowsName, "readwrite");
+      const store = tx.objectStore(rowsName);
+      const runFullScan = () => {
+        const req = store.openCursor();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) return;
+          const row = cursor.value;
+          if (String(row.tableId) === key) cursor.delete();
+          cursor.continue();
+        };
+      };
+      try {
+        if (store.indexNames.contains("byTable") && isValidIdbKey(key)) {
+          const index = store.index("byTable");
+          const req = index.openCursor(IDBKeyRange.only(key));
+          req.onsuccess = () => {
+            const cursor = req.result;
+            if (!cursor) return;
+            cursor.delete();
+            cursor.continue();
+          };
+          req.onerror = () => {
+            runFullScan();
+          };
+        } else {
+          runFullScan();
+        }
+      } catch {
+        runFullScan();
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  /**
+   * Single cursor pass over the byTableCollectionSort index, yielding batches.
+   * The index gives collection-sorted order — no in-memory sort needed.
+   * Falls back to a full scan when the index is missing (legacy stores).
+   * onBatch may return false to stop early.
+   */
+  async iterateRows(db, storeName, tableId, collection, onBatch, batchSize = 500) {
+    const key = asTableIdKey(tableId);
+    if (!key) return;
+    const rowsName = this.rowsStore(storeName);
+    if (!db.objectStoreNames.contains(rowsName)) return;
+    const useIndex = collection !== null;
+    let pending = [];
+    let ordinal = 0;
+    let stopped = false;
+    const flush = async () => {
+      if (pending.length === 0 || stopped) return;
+      const batch = pending;
+      pending = [];
+      const base = ordinal;
+      ordinal += batch.length;
+      if (await onBatch(batch, base) === false) stopped = true;
+    };
+    const batchOrDefer = async (record) => {
+      if (record) pending.push(record);
+      if (pending.length >= batchSize) await flush();
+    };
+    if (useIndex && collection) {
+      const runIndexed = () => new Promise((resolve, reject) => {
+        const tx = db.transaction(rowsName, "readonly");
+        const index = tx.objectStore(rowsName).index("byTableCollectionSort");
+        const range = IDBKeyRange.bound(
+          [key, collection, Number.MIN_SAFE_INTEGER],
+          [key, collection, Number.MAX_SAFE_INTEGER]
+        );
+        const req = index.openCursor(range);
+        req.onsuccess = async () => {
+          const cursor = req.result;
+          if (!cursor || stopped) {
+            await flush();
+            resolve();
+            return;
+          }
+          await batchOrDefer(cursor.value);
+          if (stopped) {
+            await flush();
+            resolve();
+            return;
+          }
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      });
+      try {
+        await runIndexed();
+        return;
+      } catch {
+        pending = [];
+        ordinal = 0;
+        stopped = false;
+      }
+    }
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(rowsName, "readonly");
+      const store = tx.objectStore(rowsName);
+      const req = store.openCursor();
+      req.onsuccess = async () => {
+        const cursor = req.result;
+        if (!cursor || stopped) {
+          await flush();
+          resolve();
+          return;
+        }
+        const record = cursor.value;
+        if (String(record.tableId) === key && (!collection || record.collection === collection)) {
+          await batchOrDefer(record);
+          if (stopped) {
+            await flush();
+            resolve();
+            return;
+          }
+        }
+        cursor.continue();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  /**
+   * Page-window read via cursor + offset on the sorted index.
+   * Only `pageSize` records cross the heap — not the whole collection.
+   */
+  async queryPageRows(db, storeName, tableId, collection, page, pageSize) {
+    const start = Math.max(0, (page - 1) * pageSize);
+    const picked = [];
+    await this.iterateRows(
+      db,
+      storeName,
+      tableId,
+      collection,
+      async (records, ordinalBase) => {
+        if (ordinalBase + records.length > start && picked.length < pageSize) {
+          for (let i = 0; i < records.length; i++) {
+            const pos = ordinalBase + i;
+            if (pos >= start && pos < start + pageSize) {
+              picked.push(records[i]);
+              if (picked.length === pageSize) return false;
+            }
+          }
+        }
+        if (ordinalBase > start + pageSize) return false;
+      },
+      Math.max(pageSize, 500)
+    );
+    return picked.map((r) => this.deserializeRow(r));
+  }
+  async queryAllRowRecords(db, storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) return [];
+    const rowsName = this.rowsStore(storeName);
+    if (!db.objectStoreNames.contains(rowsName)) return [];
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(rowsName, "readonly");
+      const store = tx.objectStore(rowsName);
+      if (store.indexNames.contains("byTable") && isValidIdbKey(key)) {
+        try {
+          const index = store.index("byTable");
+          const req2 = index.getAll(IDBKeyRange.only(key));
+          req2.onsuccess = () => resolve(req2.result ?? []);
+          req2.onerror = () => reject(req2.error);
+          return;
+        } catch {
+        }
+      }
+      const req = store.getAll();
+      req.onsuccess = () => {
+        const all = req.result ?? [];
+        resolve(all.filter((r) => String(r.tableId) === key));
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async ensureMeta(db, storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      throw new Error(`[PagedIndexedDbTableRepository] ensureMeta: invalid tableId (${String(tableId)})`);
+    }
+    let current = await this.getDb().then((d) => this.ensureStores(d, storeName));
+    let raw = await this.readMeta(current, storeName, key);
+    if (!raw) {
+      throw new Error(`Table ${key} not found`);
+    }
+    if (this.isLegacy(raw)) {
+      const migrated = await this.migrateLegacy(current, storeName, raw);
+      current = await this.getDb();
+      return { db: current, meta: migrated };
+    }
+    if (raw.recordKeyVersion !== 2) {
+      const migrated = await this.migrateToCollectionScopedKeys(current, storeName, raw);
+      current = await this.getDb();
+      return { db: current, meta: migrated };
+    }
+    return { db: current, meta: raw };
+  }
+  /**
+   * One-time re-key: `table::rowId` → `table::collection::rowId`.
+   * Old-format records may collide (same PK in different collections overwrote
+   * each other); after re-keying, per-collection counts in meta are re-derived
+   * from the actual records so pagination stops being scrambled.
+   */
+  async migrateToCollectionScopedKeys(db, storeName, meta) {
+    db = await this.ensureStores(db, storeName);
+    const rowsName = this.rowsStore(storeName);
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(rowsName, "readwrite");
+      const store = tx.objectStore(rowsName);
+      const rekey = (src) => {
+        const req = src.openCursor();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) return;
+          const rec = cursor.value;
+          const segments = typeof rec.id === "string" ? rec.id.split("::").length : 0;
+          if (String(rec.tableId) === (meta.id ?? "") && segments === 2) {
+            const rec2 = { ...rec, id: rowRecordId(rec.tableId, rec.collection, rec.rowId) };
+            cursor.delete();
+            store.put(JSON.parse(JSON.stringify(rec2)));
+          }
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      };
+      rekey(store);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+    const counts = {};
+    await this.iterateRows(
+      db,
+      storeName,
+      meta.id ?? "",
+      null,
+      async (records) => {
+        for (const rec of records) {
+          counts[rec.collection] = (counts[rec.collection] ?? 0) + 1;
+        }
+      }
+    );
+    const next = {
+      ...meta,
+      recordKeyVersion: 2,
+      totalRowsByCollection: counts,
+      totalRows: counts[meta.activeCollection || "default"] ?? meta.totalRows ?? 0
+    };
+    await this.putMeta(db, storeName, next);
+    return next;
+  }
+  // ─── TableRepository ────────────────────────────────────────────────────────
+  async getById(storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      throw new Error(`[PagedIndexedDbTableRepository] getById: invalid tableId (${String(tableId)})`);
+    }
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const { db: d2, meta } = await this.ensureMeta(db, storeName, key);
+    const page = meta.page || 1;
+    const pageSize = meta.pageSize || 10;
+    const rows = await this.queryPageRows(
+      d2,
+      storeName,
+      key,
+      meta.activeCollection || "default",
+      page,
+      pageSize
+    );
+    return this.buildTableFromPage(meta, rows, page, pageSize);
+  }
+  async save(storeName, table) {
+    const key = asTableIdKey(table?.id);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] save skipped: invalid table.id", table?.id);
+      return;
+    }
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    let existingTotal = table.getPagination().totalRows;
+    let existingMeta = null;
+    try {
+      const raw = await this.readMeta(db, storeName, key);
+      if (raw && !this.isLegacy(raw)) {
+        existingMeta = raw;
+        existingTotal = Math.max(existingTotal, raw.totalRows);
+      }
+    } catch {
+    }
+    const totalRows = Math.max(existingTotal, table.getPagination().totalRows);
+    const meta = this.buildMetaFromTable(table, totalRows, existingMeta);
+    await this.putMeta(db, storeName, meta);
+    const rows = [];
+    for (const col of table.getCollections().values()) {
+      rows.push(...col.getRows().values());
+    }
+    await this.putRows(db, storeName, key, rows);
+  }
+  async replaceAll(storeName, table) {
+    const key = asTableIdKey(table?.id);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] replaceAll skipped: invalid table.id", table?.id);
+      return;
+    }
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    let survivorRecords = [];
+    try {
+      const raw = await this.readMeta(db, storeName, key);
+      if (raw && !this.isLegacy(raw)) {
+        const active = raw.activeCollection || "default";
+        const incoming = /* @__PURE__ */ new Set();
+        for (const col of table.getCollections().values()) {
+          if (col.getRows().size > 0) incoming.add(col.getCollectionName());
+        }
+        const allRecords = await this.queryAllRowRecords(db, storeName, key);
+        survivorRecords = allRecords.filter(
+          (r) => r.collection !== active && !incoming.has(r.collection)
+        );
+      }
+    } catch {
+    }
+    const rows = [];
+    for (const col of table.getCollections().values()) {
+      rows.push(...col.getRows().values());
+    }
+    await this.deleteAllRowsForTable(db, storeName, key);
+    const meta = this.buildMetaFromTable(table, rows.length);
+    meta.page = 1;
+    meta.recordKeyVersion = 2;
+    const survivorCounts = {};
+    for (const rec of survivorRecords) {
+      survivorCounts[rec.collection] = (survivorCounts[rec.collection] ?? 0) + 1;
+    }
+    for (const [name, count] of Object.entries(survivorCounts)) {
+      meta.totalRowsByCollection = meta.totalRowsByCollection ?? {};
+      meta.totalRowsByCollection[name] = count;
+    }
+    await this.putMeta(db, storeName, meta);
+    await this.putRows(db, storeName, key, rows);
+    if (survivorRecords.length > 0) {
+      await this.putRowRecords(db, storeName, survivorRecords);
+    }
+  }
+  async loadPage(storeName, tableId, page, pageSize) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] loadPage skipped: invalid tableId", tableId);
+      return null;
+    }
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const { db: d2, meta } = await this.ensureMeta(db, storeName, key);
+    const size = pageSize ?? meta.pageSize ?? 10;
+    const totalPages = Math.max(1, Math.ceil(Math.max(0, meta.totalRows) / Math.max(1, size)));
+    const safePage = Math.max(1, Math.min(page, totalPages));
+    const active = meta.activeCollection || "default";
+    const rows = await this.queryPageRows(
+      d2,
+      storeName,
+      key,
+      active,
+      safePage,
+      size
+    );
+    const activeTotal = meta.totalRowsByCollection?.[active] ?? meta.totalRows ?? 0;
+    const activeTotalPages = Math.max(1, Math.ceil(Math.max(0, activeTotal) / Math.max(1, size)));
+    const collectionSafePage = Math.max(1, Math.min(safePage, activeTotalPages));
+    let pageRows = rows;
+    if (collectionSafePage !== safePage) {
+      pageRows = await this.queryPageRows(d2, storeName, key, active, collectionSafePage, size);
+    }
+    meta.page = collectionSafePage;
+    meta.pageSize = size;
+    await this.putMeta(d2, storeName, meta);
+    return this.buildTableFromPage(meta, pageRows, collectionSafePage, size);
+  }
+  /**
+   * Persist the new active collection (page back to 1) and return a RAM window
+   * holding page 1 of that collection only. Rows of other collections stay
+   * untouched in IndexedDB — the returned Table contains no other-collection rows.
+   */
+  async setActiveCollection(storeName, tableId, collection) {
+    const key = asTableIdKey(tableId);
+    if (!key) return null;
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const { db: d2, meta } = await this.ensureMeta(db, storeName, key);
+    if (!meta.collections?.some((c) => c.name === collection)) {
+      console.warn(`[PagedIndexedDbTableRepository] setActiveCollection: unknown collection "${collection}"`);
+      return null;
+    }
+    const pageSize = meta.pageSize || 10;
+    const total = meta.totalRowsByCollection?.[collection] ?? 0;
+    const rows = await this.queryPageRows(d2, storeName, key, collection, 1, pageSize);
+    meta.activeCollection = collection;
+    meta.page = 1;
+    meta.totalRows = total;
+    await this.putMeta(d2, storeName, meta);
+    return this.buildTableFromPage(meta, rows, 1, pageSize);
+  }
+  async getAllRows(storeName, tableId, collectionScope = "active") {
+    const key = asTableIdKey(tableId);
+    if (!key) return [];
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const { db: d2, meta } = await this.ensureMeta(db, storeName, key);
+    const records = await this.queryAllRowRecords(d2, storeName, key);
+    let rows = records.map((r) => this.deserializeRow(r));
+    if (collectionScope === "all") {
+      return rows.sort((a, b) => sortIndexOf(a) - sortIndexOf(b));
+    }
+    if (Array.isArray(collectionScope)) {
+      const set = new Set(collectionScope);
+      rows = rows.filter((r) => set.has(r.collection));
+    } else {
+      const active = meta.activeCollection || "default";
+      rows = rows.filter((r) => r.collection === active);
+    }
+    return rows.sort((a, b) => sortIndexOf(a) - sortIndexOf(b));
+  }
+  async getAllRowIds(storeName, tableId, collectionScope = "active") {
+    const key = asTableIdKey(tableId);
+    if (!key) return [];
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const { db: d2, meta } = await this.ensureMeta(db, storeName, key);
+    let records = await this.queryAllRowRecords(d2, storeName, key);
+    if (collectionScope === "all") ; else if (Array.isArray(collectionScope)) {
+      const set = new Set(collectionScope);
+      records = records.filter((r) => set.has(r.collection));
+    } else {
+      const active = meta.activeCollection || "default";
+      records = records.filter((r) => r.collection === active);
+    }
+    records.sort((a, b) => a.sortIndex - b.sortIndex);
+    return records.map((r) => r.rowId);
+  }
+  clearLocal(_store, _tableKey) {
+  }
+  async flush(_store, _tableKey) {
+  }
+  async exists(storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) return false;
+    const db = await this.getDb();
+    const metaName = this.metaStore(storeName);
+    if (!db.objectStoreNames.contains(metaName)) return false;
+    return new Promise((resolve) => {
+      const tx = db.transaction(metaName, "readonly");
+      const req = tx.objectStore(metaName).get(key);
+      req.onsuccess = () => resolve(Boolean(req.result));
+      req.onerror = () => resolve(false);
+    });
+  }
+  async delete(storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] delete skipped: invalid tableId", tableId);
+      return;
+    }
+    let db = await this.getDb();
+    if (!db.objectStoreNames.contains(this.metaStore(storeName))) return;
+    db = await this.ensureStores(db, storeName);
+    await this.deleteAllRowsForTable(db, storeName, key);
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(this.metaStore(storeName), "readwrite");
+      tx.objectStore(this.metaStore(storeName)).delete(key);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async resetTable(storeName, tableId) {
+    const key = asTableIdKey(tableId);
+    if (!key) {
+      console.warn("[PagedIndexedDbTableRepository] resetTable skipped: invalid tableId", tableId);
+      return;
+    }
+    let db = await this.getDb();
+    if (!db.objectStoreNames.contains(this.metaStore(storeName))) return;
+    db = await this.ensureStores(db, storeName);
+    const raw = await this.readMeta(db, storeName, key);
+    if (!raw) throw new Error(`Table ${key} not found`);
+    await this.deleteAllRowsForTable(db, storeName, key);
+    const active = this.isLegacy(raw) ? raw.activeCollection ?? raw.activeDetailType ?? "default" : raw.activeCollection;
+    const meta = {
+      id: key,
+      kind: "meta",
+      activeCollection: active,
+      page: 1,
+      pageSize: this.isLegacy(raw) ? 10 : raw.pageSize || 10,
+      totalRows: 0,
+      collections: this.isLegacy(raw) ? [] : (raw.collections ?? []).map((c) => ({ name: c.name, columns: c.columns ?? [] }))
+    };
+    await this.putMeta(db, storeName, meta);
+  }
+  /**
+   * Port: stream serialized row records in bounded batches (cursor over the
+   * sorted index). 'active' → index cursor on the active collection;
+   * 'all'/array → full scan filtered in-memory per batch. Heap = one batch.
+   */
+  async iterateRowRecords(storeName, tableId, collectionScope = "active", onBatch, batchSize = 500) {
+    const key = asTableIdKey(tableId);
+    if (!key) return;
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const { db: d2, meta } = await this.ensureMeta(db, storeName, key);
+    const active = meta.activeCollection || "default";
+    const collection = collectionScope === "active" ? active : null;
+    if (collection !== null) {
+      const normalized = async (records, ordinalBase) => onBatch(
+        records.map((r) => ({
+          rowId: r.rowId,
+          collection: r.collection,
+          sortIndex: r.sortIndex,
+          rowState: r.rowState,
+          cells: Object.fromEntries(
+            r.cells.map((c) => [c.colId, { value: c.value, originalValue: c.originalValue, display: c.display }])
+          )
+        })),
+        ordinalBase
+      );
+      await this.iterateRows(d2, storeName, key, collection, normalized, batchSize);
+      return;
+    }
+    const allowed = collectionScope === "all" ? null : new Set(collectionScope);
+    await this.iterateRows(
+      d2,
+      storeName,
+      key,
+      null,
+      async (records, ordinalBase) => {
+        const filtered = allowed ? records.filter((r) => allowed.has(r.collection)) : records;
+        if (filtered.length === 0) return;
+        return onBatch(
+          filtered.map((r) => ({
+            rowId: r.rowId,
+            collection: r.collection,
+            sortIndex: r.sortIndex,
+            rowState: r.rowState,
+            cells: Object.fromEntries(
+              r.cells.map((c) => [c.colId, { value: c.value, originalValue: c.originalValue, display: c.display }])
+            )
+          })),
+          ordinalBase
+        );
+      },
+      batchSize
+    );
+  }
+  /**
+   * Bulk soft/hard delete directly on persisted records in ONE readwrite
+   * transaction — cursor over the `byTable` index (no full hydration, heap
+   * stays O(1)). `Added` → hard delete; others → cursor.update to Deleted;
+   * already-Deleted → untouched. Never goes through replaceAll.
+   */
+  async softDeleteRows(storeName, tableId, rowIds) {
+    const key = asTableIdKey(tableId);
+    if (!key || rowIds.length === 0) {
+      return { softDeleted: 0, hardRemoved: 0, remaining: 0 };
+    }
+    const wanted = new Set(rowIds);
+    let softDeleted = 0;
+    let hardRemoved = 0;
+    let remaining = 0;
+    const deleteOne = (record, recordStore) => {
+      if (record.rowState === "Add" /* Added */) {
+        recordStore.delete(rowRecordId(key, record.collection, record.rowId));
+        hardRemoved += 1;
+        return;
+      }
+      if (record.rowState === "Delete" /* Deleted */) {
+        return;
+      }
+      record.rowState = "Delete" /* Deleted */;
+      record.cells = record.cells.map((c) => ({ ...c, originalValue: c.value }));
+      recordStore.put(JSON.parse(JSON.stringify(record)));
+      softDeleted += 1;
+    };
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const rowsName = this.rowsStore(storeName);
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction([rowsName, this.metaStore(storeName)], "readwrite");
+      const recordStore = tx.objectStore(rowsName);
+      const finishMeta = () => {
+        const metaReq = tx.objectStore(this.metaStore(storeName)).get(key);
+        metaReq.onsuccess = () => {
+          const meta = metaReq.result;
+          if (meta && meta.kind === "meta") {
+            const active = meta.activeCollection || "default";
+            const activeTotal = meta.totalRowsByCollection?.[active] ?? meta.totalRows ?? 0;
+            remaining = Math.max(0, activeTotal - softDeleted - hardRemoved);
+            meta.totalRows = remaining;
+            if (meta.totalRowsByCollection) {
+              meta.totalRowsByCollection[active] = remaining;
+            }
+            tx.objectStore(this.metaStore(storeName)).put(
+              JSON.parse(JSON.stringify(meta))
+            );
+          }
+        };
+        metaReq.onerror = () => reject(metaReq.error);
+      };
+      const runFullScan = () => {
+        const req = recordStore.openCursor();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) {
+            finishMeta();
+            return;
+          }
+          const record = cursor.value;
+          if (String(record.tableId) === key && wanted.has(record.rowId)) {
+            deleteOne(record, recordStore);
+          }
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      };
+      const runIndexed = () => {
+        const index = recordStore.index("byTable");
+        const req = index.openCursor(IDBKeyRange.only(key));
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) {
+            finishMeta();
+            return;
+          }
+          const record = cursor.value;
+          if (wanted.has(record.rowId)) deleteOne(record, recordStore);
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      };
+      try {
+        if (recordStore.indexNames.contains("byTable")) {
+          runIndexed();
+        } else {
+          runFullScan();
+        }
+      } catch {
+        runFullScan();
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error ?? new Error("softDeleteRows aborted"));
+    });
+    return { softDeleted, hardRemoved, remaining };
+  }
+  async removeRows(storeName, tableId, rowIds) {
+    const key = asTableIdKey(tableId);
+    if (!key || rowIds.length === 0) return;
+    let db = await this.getDb();
+    db = await this.ensureStores(db, storeName);
+    const rowsName = this.rowsStore(storeName);
+    const wanted = new Set(rowIds);
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction([rowsName, this.metaStore(storeName)], "readwrite");
+      const rowStore = tx.objectStore(rowsName);
+      const sweep = (store) => {
+        const runIndexed = () => {
+          const req = store.index("byTable").openCursor(IDBKeyRange.only(key));
+          req.onsuccess = () => {
+            const cursor = req.result;
+            if (!cursor) return;
+            const rec = cursor.value;
+            if (wanted.has(rec.rowId)) cursor.delete();
+            cursor.continue();
+          };
+        };
+        try {
+          if (store.indexNames.contains("byTable")) runIndexed();
+          else runFullScan(store);
+        } catch {
+          runFullScan(store);
+        }
+      };
+      const runFullScan = (store) => {
+        const req = store.openCursor();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) return;
+          const rec = cursor.value;
+          if (String(rec.tableId) === key && wanted.has(rec.rowId)) cursor.delete();
+          cursor.continue();
+        };
+      };
+      sweep(rowStore);
+      const metaReq = tx.objectStore(this.metaStore(storeName)).get(key);
+      metaReq.onsuccess = () => {
+        const meta = metaReq.result;
+        if (meta && meta.kind === "meta") {
+          meta.totalRows = Math.max(0, (meta.totalRows ?? 0) - rowIds.length);
+          tx.objectStore(this.metaStore(storeName)).put(
+            JSON.parse(JSON.stringify(meta))
+          );
+        }
+      };
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+};
+
+// infrastructure/Repositories/paged/PagedLocalTableRepository.ts
+var PagedLocalTableRepository = class {
+  constructor() {
+    this.tables = /* @__PURE__ */ new Map();
+  }
+  async exists(_store, tableKey) {
+    return this.tables.has(tableKey);
+  }
+  async getById(_store, tableKey) {
+    const table = this.tables.get(tableKey);
+    if (!table) throw new Error(`Table ${tableKey} not found in local window`);
+    return table;
+  }
+  async save(_store, table) {
+    this.tables.set(table.id, table);
+  }
+  async replaceAll(_store, table) {
+    this.tables.set(table.id, table);
+  }
+  async loadPage(_store, tableKey, _page, _pageSize) {
+    const table = this.tables.get(tableKey);
+    return table ?? null;
+  }
+  /**
+   * RAM window: a switch replaces the window with the one returned by the
+   * IndexedDB layer, so nothing to persist here — just keep the new table.
+   */
+  async setActiveCollection(_store, tableKey, collection) {
+    const table = this.tables.get(tableKey);
+    if (!table) return null;
+    table.setActiveCollection(collection);
+    table.changePage(1);
+    return table;
+  }
+  async getAllRows(_store, tableKey, collectionScope = "active") {
+    const table = this.tables.get(tableKey);
+    if (!table) return [];
+    return table.getRows(collectionScope);
+  }
+  async getAllRowIds(_store, tableKey, collectionScope = "active") {
+    const rows = await this.getAllRows(_store, tableKey, collectionScope);
+    return rows.map((r) => r.id.value);
+  }
+  clearLocal(_store, tableKey) {
+    this.tables.delete(tableKey);
+  }
+  async flush() {
+  }
+  async delete(_store, tableKey) {
+    this.tables.delete(tableKey);
+  }
+  async resetTable(_store, tableKey) {
+    this.tables.delete(tableKey);
+  }
+  /**
+   * RAM window only — streams the current page's rows as a single batch.
+   * (The full dataset lives in IndexedDB, not here.)
+   */
+  async iterateRowRecords(_store, tableKey, collectionScope, onBatch) {
+    const table = this.tables.get(tableKey);
+    if (!table) return;
+    const rows = table.getRows(collectionScope);
+    const records = rows.map((r) => {
+      const cells = {};
+      for (const [colId, cell] of r.getCells().entries()) {
+        cells[colId] = { value: cell.getValue(), originalValue: cell.getOriginalValue().value, display: cell.getDisplay() };
+      }
+      return {
+        rowId: r.id.value,
+        collection: r.getCollection(),
+        sortIndex: Number(r.getCell("index")?.getValue() ?? 0),
+        rowState: r.rowState.value,
+        cells
+      };
+    });
+    await onBatch(records, 0);
+  }
+  async removeRows() {
+  }
+  /**
+   * RAM-window bulk delete (Memory Iron Rule compliant): only the current
+   * page's rows are mutated — Added hard-removed, others soft-deleted via
+   * domain Row state; already-Deleted untouched. Remaining counts come from
+   * pagination totals minus this operation's effects (no full-dataset scan).
+   */
+  async softDeleteRows(_store, tableKey, rowIds) {
+    const table = this.tables.get(tableKey);
+    if (!table || rowIds.length === 0) {
+      return { softDeleted: 0, hardRemoved: 0, remaining: 0 };
+    }
+    const wanted = new Set(rowIds);
+    let softDeleted = 0;
+    let hardRemoved = 0;
+    for (const col of table.getCollections().values()) {
+      for (const row of Array.from(col.getRows().values())) {
+        if (!wanted.has(row.id.value)) continue;
+        if (row.rowState.value === "Add" /* Added */) {
+          col.getRows().delete(row.id.value);
+          hardRemoved += 1;
+          continue;
+        }
+        if (row.rowState.value === "Delete" /* Deleted */) continue;
+        row.rowState = new RowState("Delete" /* Deleted */);
+        row.updateChangeFields(new ColumnId("RowState"));
+        softDeleted += 1;
+      }
+    }
+    const p = table.getPagination();
+    const remaining = Math.max(0, p.totalRows - softDeleted - hardRemoved);
+    table.setPagination(new Pagination(p.page, p.pageSize, remaining));
+    return { softDeleted, hardRemoved, remaining };
+  }
+};
+
+// infrastructure/Repositories/paged/PagedCachedTableRepository.ts
+function isValidTableKey(tableKey) {
+  return typeof tableKey === "string" && tableKey.length > 0;
+}
+var PagedCachedTableRepository = class {
+  constructor() {
+    this.persistChain = /* @__PURE__ */ new Map();
+    /** Tables closed by dispose — block further IDB rebuild/load until reopened */
+    this.closedKeys = /* @__PURE__ */ new Set();
+    this.localRepo = new PagedLocalTableRepository();
+    this.indexedRepo = new PagedIndexedDbTableRepository();
+  }
+  queueKey(store, tableKey) {
+    return `${store}::${tableKey}`;
+  }
+  isClosed(store, tableKey) {
+    return this.closedKeys.has(this.queueKey(store, tableKey));
+  }
+  reopen(store, tableKey) {
+    this.closedKeys.delete(this.queueKey(store, tableKey));
+  }
+  enqueuePersist(store, tableKey, task) {
+    const key = this.queueKey(store, tableKey);
+    const prev = this.persistChain.get(key) ?? Promise.resolve();
+    const next = prev.catch(() => void 0).then(async () => {
+      if (this.closedKeys.has(key)) return;
+      await task();
+    }).catch((err) => {
+      console.error("[PagedCachedTableRepository] IndexedDB persist failed", err);
+    });
+    this.persistChain.set(key, next);
+  }
+  async flush(store, tableKey) {
+    if (!isValidTableKey(tableKey)) return;
+    const key = this.queueKey(store, tableKey);
+    await (this.persistChain.get(key) ?? Promise.resolve());
+  }
+  async getById(store, tableKey) {
+    if (!isValidTableKey(tableKey)) {
+      throw new Error("[PagedCachedTableRepository] getById: invalid tableKey");
+    }
+    this.reopen(store, tableKey);
+    if (await this.localRepo.exists(store, tableKey)) {
+      return this.localRepo.getById(store, tableKey);
+    }
+    await this.flush(store, tableKey);
+    const table = await this.indexedRepo.getById(store, tableKey);
+    await this.localRepo.save(store, table);
+    return table;
+  }
+  async save(store, table) {
+    if (!isValidTableKey(table?.id)) {
+      console.warn("[PagedCachedTableRepository] save skipped: invalid table.id", table?.id);
+      return;
+    }
+    if (this.isClosed(store, table.id)) {
+      return;
+    }
+    await this.localRepo.save(store, table);
+    await this.indexedRepo.save(store, table);
+  }
+  async replaceAll(store, table) {
+    if (!isValidTableKey(table?.id)) {
+      console.warn("[PagedCachedTableRepository] replaceAll skipped: invalid table.id", table?.id);
+      return;
+    }
+    this.reopen(store, table.id);
+    await this.flush(store, table.id);
+    await this.indexedRepo.replaceAll(store, table);
+    const pageSize = table.getPagination().pageSize;
+    const pageTable = await this.indexedRepo.loadPage(store, table.id, 1, pageSize);
+    if (!pageTable) return;
+    this.restoreLiveColumns(table, pageTable);
+    await this.localRepo.save(store, pageTable);
+  }
+  async loadPage(store, tableKey, page, pageSize) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) {
+      return null;
+    }
+    await this.flush(store, tableKey);
+    let previous = null;
+    if (await this.localRepo.exists(store, tableKey)) {
+      previous = await this.localRepo.getById(store, tableKey);
+      await this.indexedRepo.save(store, previous);
+    }
+    const table = await this.indexedRepo.loadPage(store, tableKey, page, pageSize);
+    if (!table) {
+      return previous;
+    }
+    if (previous) {
+      this.restoreLiveColumns(previous, table);
+      const prevActive = previous.getActiveCollectionName();
+      const nextActive = table.getActiveCollectionName();
+      if (prevActive === nextActive) {
+        const prevTotal = previous.getPagination().totalRows;
+        const cur = table.getPagination();
+        if (prevTotal > cur.totalRows) {
+          table.setPagination(new Pagination(cur.page, cur.pageSize, prevTotal));
+          await this.indexedRepo.save(store, table);
+        }
+      }
+    }
+    await this.localRepo.save(store, table);
+    return table;
+  }
+  /**
+   * Collection switch: swap the RAM window with page 1 of the NEW collection
+   * (loaded from IndexedDB) and persist the switch in meta. Rows of other
+   * collections are never touched.
+   */
+  async setActiveCollection(store, tableKey, collection) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) return null;
+    await this.flush(store, tableKey);
+    let previous = null;
+    if (await this.localRepo.exists(store, tableKey)) {
+      previous = await this.localRepo.getById(store, tableKey);
+      await this.indexedRepo.save(store, previous);
+    }
+    const table = await this.indexedRepo.setActiveCollection(store, tableKey, collection);
+    if (!table) {
+      return previous;
+    }
+    if (previous) {
+      this.restoreLiveColumns(previous, table);
+    }
+    await this.localRepo.save(store, table);
+    return table;
+  }
+  /** ColumnSchema holds functions — never come back from IndexedDB; keep RAM handlers. */
+  restoreLiveColumns(from, to) {
+    for (const [name, col] of from.getCollections()) {
+      const target = to.getCollections().get(name);
+      if (!target) continue;
+      const dest = target.getColumns();
+      dest.clear();
+      for (const [field, schema] of col.getColumns()) {
+        dest.set(field, schema);
+      }
+    }
+  }
+  async getAllRows(store, tableKey, collectionScope) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) return [];
+    await this.flush(store, tableKey);
+    if (await this.localRepo.exists(store, tableKey)) {
+      const current = await this.localRepo.getById(store, tableKey);
+      await this.indexedRepo.save(store, current);
+    }
+    return this.indexedRepo.getAllRows(store, tableKey, collectionScope);
+  }
+  async getAllRowIds(store, tableKey, collectionScope) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) return [];
+    await this.flush(store, tableKey);
+    if (await this.localRepo.exists(store, tableKey)) {
+      const current = await this.localRepo.getById(store, tableKey);
+      await this.indexedRepo.save(store, current);
+    }
+    return this.indexedRepo.getAllRowIds(store, tableKey, collectionScope);
+  }
+  clearLocal(store, tableKey) {
+    if (!isValidTableKey(tableKey)) return;
+    const key = this.queueKey(store, tableKey);
+    this.closedKeys.add(key);
+    this.persistChain.set(key, Promise.resolve());
+    this.localRepo.clearLocal(store, tableKey);
+  }
+  async delete(store, tableKey) {
+    if (!isValidTableKey(tableKey)) return;
+    await this.flush(store, tableKey);
+    this.localRepo.clearLocal(store, tableKey);
+    this.closedKeys.add(this.queueKey(store, tableKey));
+    await this.indexedRepo.delete(store, tableKey);
+  }
+  async resetTable(store, tableKey) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) return;
+    await this.flush(store, tableKey);
+    await this.indexedRepo.resetTable(store, tableKey);
+    this.localRepo.clearLocal(store, tableKey);
+    const empty = await this.indexedRepo.loadPage(store, tableKey, 1);
+    if (empty) await this.localRepo.save(store, empty);
+  }
+  async exists(store, tableKey) {
+    if (!isValidTableKey(tableKey)) return false;
+    if (await this.localRepo.exists(store, tableKey)) return true;
+    return this.indexedRepo.exists(store, tableKey);
+  }
+  /** Stream row records in batches (never the whole dataset in heap). */
+  async iterateRowRecords(store, tableKey, collectionScope, onBatch, batchSize) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) return;
+    await this.flush(store, tableKey);
+    if (await this.localRepo.exists(store, tableKey)) {
+      const current = await this.localRepo.getById(store, tableKey);
+      await this.indexedRepo.save(store, current);
+    }
+    await this.indexedRepo.iterateRowRecords(store, tableKey, collectionScope, onBatch, batchSize);
+  }
+  async removeRows(store, tableKey, rowIds) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey)) return;
+    await this.flush(store, tableKey);
+    await this.indexedRepo.removeRows(store, tableKey, rowIds);
+  }
+  /**
+   * Bulk delete straight on IndexedDB records (Memory Iron Rule: no full
+   * hydration, no replaceAll). After the persisted delete, the RAM window is
+   * reloaded from IndexedDB so pagination/rows stay consistent.
+   */
+  async softDeleteRows(store, tableKey, rowIds) {
+    if (!isValidTableKey(tableKey) || this.isClosed(store, tableKey) || rowIds.length === 0) {
+      return { softDeleted: 0, hardRemoved: 0, remaining: 0 };
+    }
+    await this.flush(store, tableKey);
+    const result = await this.indexedRepo.softDeleteRows(store, tableKey, rowIds);
+    const pageTable = await this.indexedRepo.loadPage(store, tableKey, 1);
+    if (pageTable) await this.localRepo.save(store, pageTable);
+    return result;
+  }
+};
+
+export { PagedCachedTableRepository, PagedIndexedDbTableRepository, PagedLocalTableRepository };
+//# sourceMappingURL=chunk-J4XJ4UBC.js.map
+//# sourceMappingURL=chunk-J4XJ4UBC.js.map