persian-data-grid 0.6.0 → 0.7.1

package/dist/{chunk-IIISFUW4.cjs → chunk-WTHTVKVI.cjs}

@@ -2,7 +2,7 @@
 
 var chunkMT3KLB2Q_cjs = require('./chunk-MT3KLB2Q.cjs');
 var chunkUC7PHDM6_cjs = require('./chunk-UC7PHDM6.cjs');
-var chunkDXRCYW42_cjs = require('./chunk-DXRCYW42.cjs');
+var chunk52LFOPXD_cjs = require('./chunk-52LFOPXD.cjs');
 var chunkKMRURD5J_cjs = require('./chunk-KMRURD5J.cjs');
 var chunkJOICD47Q_cjs = require('./chunk-JOICD47Q.cjs');
 var chunkDFFP7SJ6_cjs = require('./chunk-DFFP7SJ6.cjs');
@@ -1335,6 +1335,7 @@ var SparseRowIndex = class {
     this.orderedIds = [];
     /** id → position in `orderedIds` (PR-99). */
     this.posById = /* @__PURE__ */ new Map();
+    this.revisionCount = 0;
     for (const [id, value] of entries) {
       this.byId.set(id, value);
       this.posById.set(id, this.orderedIds.length);
@@ -1344,6 +1345,13 @@ var SparseRowIndex = class {
   get size() {
     return this.orderedIds.length;
   }
+  /**
+   * Bumped by every change of ids, order or values. O(1) change detection for
+   * subscribers (a sort keeps `size` but changes the order).
+   */
+  get revision() {
+    return this.revisionCount;
+  }
   getOrderedIds() {
     return this.orderedIds;
   }
@@ -1365,6 +1373,7 @@ var SparseRowIndex = class {
   }
   set(id, value) {
     const existed = this.byId.has(id);
+    this.revisionCount += 1;
     this.byId.set(id, value);
     if (!existed) {
       this.posById.set(id, this.orderedIds.length);
@@ -1373,6 +1382,7 @@ var SparseRowIndex = class {
   }
   /** Insert `id` at `pos` (0…size). Shifts later positions — O(n-pos). */
   insertAt(pos, id, value) {
+    this.revisionCount += 1;
     if (this.byId.has(id)) {
       this.byId.set(id, value);
       return;
@@ -1386,6 +1396,7 @@ var SparseRowIndex = class {
   }
   remove(id) {
     if (!this.byId.has(id)) return false;
+    this.revisionCount += 1;
     this.byId.delete(id);
     const pos = this.posById.get(id);
     this.posById.delete(id);
@@ -1398,6 +1409,7 @@ var SparseRowIndex = class {
   }
   /** Replace order without rebuilding payloads (e.g. after sort). */
   setOrder(orderedIds) {
+    this.revisionCount += 1;
     this.orderedIds = orderedIds.slice();
     this.posById.clear();
     for (let i = 0; i < this.orderedIds.length; i += 1) {
@@ -1406,6 +1418,7 @@ var SparseRowIndex = class {
   }
   /** Full replace of ids + values in one pass (PR-99 rebuild). */
   replaceAll(orderedIds, valueFor) {
+    this.revisionCount += 1;
     this.byId.clear();
     this.orderedIds = orderedIds.slice();
     this.posById.clear();
@@ -1416,6 +1429,7 @@ var SparseRowIndex = class {
     }
   }
   clear() {
+    this.revisionCount += 1;
     this.byId.clear();
     this.orderedIds = [];
     this.posById.clear();
@@ -3144,21 +3158,35 @@ var TableStore = class {
 var DEFAULT_CELL_EDIT_OPTIONS = {
   singleClickEdit: true,
   stopEditingWhenCellsLoseFocus: true,
-  editType: "cell"
+  editType: "cell",
+  commit: "deferred",
+  enterNavigation: "nextCell"
 };
+var sessionSeq = 0;
 function createCellEditSession(input) {
   const drafts = {};
   for (const [colId, cell] of Object.entries(input.baseline)) {
     drafts[colId] = { value: cell.value, display: cell.display };
   }
+  sessionSeq += 1;
   return {
     rowId: input.rowId,
     columnId: input.columnId,
     editType: input.editType,
     baseline: input.baseline,
-    drafts
+    drafts,
+    correlationId: `cell-edit-${Date.now()}-${sessionSeq}`
   };
 }
+function rebaseDraft(session, columnIds) {
+  if (columnIds.length === 0) return session;
+  const baseline = { ...session.baseline };
+  for (const colId of columnIds) {
+    const draft = session.drafts[colId];
+    if (draft) baseline[colId] = { value: draft.value, display: draft.display };
+  }
+  return { ...session, baseline };
+}
 function readDraft(session, rowId, columnId) {
   if (!session || session.rowId !== rowId) return null;
   return session.drafts[columnId] ?? null;
@@ -3183,8 +3211,8 @@ function patchDraft(session, columnId, patch) {
     drafts: {
       ...session.drafts,
       [columnId]: {
-        value: patch.value !== void 0 ? patch.value : prev.value,
-        display: patch.display !== void 0 ? patch.display : prev.display
+        value: "value" in patch ? patch.value : prev.value,
+        display: "display" in patch ? patch.display : prev.display
       }
     }
   };
@@ -4169,6 +4197,7 @@ var ViewStateBuilder = class {
 };
 
 // engine/tableEngine.ts
+var cellWriteKey = (kind, rowId, columnId) => `${kind}\0${rowId}\0${columnId}`;
 var TableEngine = class {
   constructor(app, repo, actor, audit, columnMeta) {
     this.app = app;
@@ -4176,6 +4205,15 @@ var TableEngine = class {
     this.actor = actor;
     this.columnMeta = columnMeta;
     this.cellEditOptions = { ...DEFAULT_CELL_EDIT_OPTIONS };
+    /**
+     * Cell writes coming from editors / host input, executed one at a time in
+     * arrival order. Consecutive values for the same cell coalesce (latest
+     * wins). Until a write landed, the queued value is what the cell shows.
+     */
+    this.cellWrites = /* @__PURE__ */ new Map();
+    this.cellWriteChain = Promise.resolve();
+    /** > 0 while a queued write executes (re-entrant settle must not wait on itself). */
+    this.cellWriteDepth = 0;
     this.errors = /* @__PURE__ */ new Map();
     this.searchResult = /* @__PURE__ */ new Map();
     this.asyncCellCache = /* @__PURE__ */ new Map();
@@ -4750,54 +4788,54 @@ var TableEngine = class {
     const next = command.sortModel.filter(
       (item) => item && typeof item.colId === "string" && item.colId.length > 0 && (item.sort === "asc" || item.sort === "desc")
     ).map((item) => ({ colId: item.colId, sort: item.sort }));
+    this.viewBuilder.invalidateUiRowIndex();
     store.setState((prev) => ({
       ...prev,
       sortModel: next
     }));
-    this.viewBuilder.invalidateUiRowIndex();
     this.notifyViewQueryChanged();
   }
   setQuickFilterText(command) {
     const store = this.getStore(command.tableKey);
     if (!store) return;
     const next = typeof command.quickFilterText === "string" ? command.quickFilterText : "";
+    this.viewBuilder.invalidateUiRowIndex();
     store.setState((prev) => ({
       ...prev,
       quickFilterText: next
     }));
-    this.viewBuilder.invalidateUiRowIndex();
   }
   setFilterModel(command) {
     const store = this.getStore(command.tableKey);
     if (!store) return;
     const next = command.filterModel && typeof command.filterModel === "object" ? { ...command.filterModel } : {};
+    this.viewBuilder.invalidateUiRowIndex();
     store.setState((prev) => ({
       ...prev,
       filterModel: next
     }));
-    this.viewBuilder.invalidateUiRowIndex();
     this.notifyViewQueryChanged();
   }
   setRowGroupColumns(command) {
     const store = this.getStore(command.tableKey);
     if (!store) return;
     const next = command.columns.filter((c) => typeof c === "string" && c.trim() !== "").map((c) => c.trim());
+    this.viewBuilder.invalidateUiRowIndex();
     store.setState((prev) => ({
       ...prev,
       rowGroupColumns: next,
       rowGroupExpanded: {}
     }));
-    this.viewBuilder.invalidateUiRowIndex();
   }
   setGroupDefaultExpanded(command) {
     const store = this.getStore(command.tableKey);
     if (!store) return;
+    this.viewBuilder.invalidateUiRowIndex();
     store.setState((prev) => ({
       ...prev,
       groupDefaultExpanded: Boolean(command.expanded),
       rowGroupExpanded: {}
     }));
-    this.viewBuilder.invalidateUiRowIndex();
   }
   toggleRowGroup(command) {
     const store = this.getStore(command.tableKey);
@@ -4808,6 +4846,7 @@ var TableEngine = class {
       state.rowGroupExpanded,
       key
     ) ? state.rowGroupExpanded[key] : state.groupDefaultExpanded;
+    this.viewBuilder.invalidateUiRowIndex();
     store.setState((prev) => ({
       ...prev,
       rowGroupExpanded: {
@@ -4815,7 +4854,6 @@ var TableEngine = class {
         [key]: !current
       }
     }));
-    this.viewBuilder.invalidateUiRowIndex();
   }
   /**
    * Server/infinite row model hooks (PR-96).
@@ -5084,6 +5122,7 @@ var TableEngine = class {
   async getFullSnapShot(store, collectionScope = "active") {
     if (!this.tableKey) return null;
     try {
+      await this.flushCellEdit();
       const rows = await this.loadAllRows(store, collectionScope);
       const { rowsToSnapshot } = await import('./memoryRecords-AWDKUJ2F.cjs');
       return rowsToSnapshot(rows);
@@ -5100,6 +5139,7 @@ var TableEngine = class {
   async iterateRowsFromDb(store, collectionScope, onBatch, batchSize) {
     if (!this.tableKey) return;
     try {
+      await this.flushCellEdit();
       if (isWindowedRepository(this.repo)) {
         await this.repo.iterateRowRecords(
           store,
@@ -5156,8 +5196,196 @@ var TableEngine = class {
   getCellEdit() {
     return this.tableStore?.getState().cellEdit ?? null;
   }
+  /**
+   * What the cell editor shows: the session draft, else a value that was
+   * typed but whose write has not reached the table yet (no flicker back to
+   * the old value while it is in flight). `null` = show the table value.
+   */
   getEditDraft(rowId, columnId) {
-    return readDraft(this.getCellEdit(), rowId, columnId);
+    const draft = readDraft(this.getCellEdit(), rowId, columnId);
+    if (draft) return draft;
+    const value = this.cellWrites.get(cellWriteKey("value", rowId, columnId));
+    const display = this.cellWrites.get(cellWriteKey("display", rowId, columnId));
+    if (!value && !display) return null;
+    const cell = this.viewBuilder.getCell(rowId, columnId);
+    return {
+      value: value ? value.write.value : cell?.getValue(),
+      display: display ? display.write.value : cell?.getDisplay()
+    };
+  }
+  /** Editor / host value for a cell (`UI_CELL_CHANGE`). Resolves once it is durable. */
+  inputCellValue(rowId, columnId, value) {
+    return this.inputCell(rowId, columnId, "value", value);
+  }
+  /** Editor / host display label for a cell (`UI_CELL_CHANGE_DISPLAY`). */
+  inputCellDisplay(rowId, columnId, display) {
+    return this.inputCell(rowId, columnId, "display", display);
+  }
+  async inputCell(rowId, columnId, kind, input) {
+    const store = this.tableStore;
+    if (!store) return;
+    const session = store.getState().cellEdit;
+    if (session && isEditingCell(session, rowId, columnId)) {
+      const immediate = this.cellEditOptions.commit === "immediate";
+      const patch = kind === "value" ? { value: input } : { display: input };
+      store.setState((prev) => {
+        if (!prev.cellEdit || prev.cellEdit.rowId !== rowId) return prev;
+        const patched = patchDraft(prev.cellEdit, columnId, patch);
+        return {
+          ...prev,
+          cellEdit: immediate ? rebaseDraft(patched, [columnId]) : patched
+        };
+      });
+      if (!immediate) return;
+      this.enqueueCellWrite({
+        rowId,
+        columnId,
+        kind,
+        value: input,
+        correlationId: session.correlationId
+      });
+    } else {
+      this.enqueueCellWrite({ rowId, columnId, kind, value: input });
+    }
+    await this.settleCellWrites();
+  }
+  enqueueCellWrite(write) {
+    const key = cellWriteKey(write.kind, write.rowId, write.columnId);
+    const pending = this.cellWrites.get(key);
+    if (pending?.queued) {
+      pending.write = write;
+      return;
+    }
+    const slot = { write, queued: true };
+    this.cellWrites.set(key, slot);
+    this.cellWriteChain = this.cellWriteChain.then(() => this.runCellWrite(key, slot));
+  }
+  async runCellWrite(key, slot) {
+    slot.queued = false;
+    const { write } = slot;
+    const commandStore = this.commandStore;
+    const tableKey = this.tableKey;
+    this.cellWriteDepth += 1;
+    try {
+      if (commandStore && tableKey && this.tableStore) {
+        await this.dispatch(
+          write.kind === "value" ? {
+            type: "CHANGE_CELL_VALUE",
+            store: commandStore,
+            tableKey,
+            rowId: write.rowId,
+            columnId: write.columnId,
+            newValue: write.value,
+            correlationId: write.correlationId
+          } : {
+            type: "CHANGE_CELL_DISPLAY_VALUE",
+            store: commandStore,
+            tableKey,
+            rowId: write.rowId,
+            columnId: write.columnId,
+            newValue: write.value == null ? "" : String(write.value),
+            correlationId: write.correlationId
+          }
+        );
+      }
+    } catch (e) {
+      this.errHandler.handle(e, "TableEngine.cellWrite");
+    } finally {
+      this.cellWriteDepth -= 1;
+      if (this.cellWrites.get(key) === slot && !slot.queued) {
+        this.cellWrites.delete(key);
+        const cell = this.viewBuilder.getCell(write.rowId, write.columnId);
+        const landed = write.kind === "value" ? cell?.getValue() : cell?.getDisplay();
+        if (landed !== write.value) this.tableStore?.setState((prev) => ({ ...prev }));
+      }
+    }
+  }
+  /**
+   * Resolves when every queued cell write reached the table. Called from inside
+   * a write (re-entrant) it returns at once instead of waiting on itself.
+   */
+  async settleCellWrites() {
+    if (this.cellWriteDepth > 0) return;
+    let chain;
+    do {
+      chain = this.cellWriteChain;
+      await chain;
+    } while (chain !== this.cellWriteChain);
+  }
+  /** Queues CHANGE_CELL_* for `columnIds` of `session`; returns the value writes. */
+  queueDraftWrites(session, columnIds) {
+    let writes = 0;
+    for (const colId of columnIds) {
+      const draft = session.drafts[colId];
+      if (!draft) continue;
+      const base = session.baseline[colId];
+      if (!base || draft.value !== base.value) {
+        this.enqueueCellWrite({
+          rowId: session.rowId,
+          columnId: colId,
+          kind: "value",
+          value: draft.value,
+          correlationId: session.correlationId
+        });
+        writes += 1;
+      }
+      if (!base || draft.display !== base.display) {
+        this.enqueueCellWrite({
+          rowId: session.rowId,
+          columnId: colId,
+          kind: "display",
+          value: draft.display,
+          correlationId: session.correlationId
+        });
+      }
+    }
+    return writes;
+  }
+  /**
+   * Make what the user typed durable WITHOUT ending the edit: dirty drafts are
+   * written and become the session baseline, then all queued writes settle.
+   * Every durable read (snapshot, row stream, export) calls this first, so a
+   * save never misses the value still in the editor.
+   */
+  async flushCellEdit() {
+    const store = this.tableStore;
+    const session = store?.getState().cellEdit;
+    if (store && session) {
+      const dirty = dirtyDraftColumns(session);
+      if (dirty.length > 0) {
+        store.setState(
+          (prev) => prev.cellEdit && prev.cellEdit.rowId === session.rowId ? { ...prev, cellEdit: rebaseDraft(prev.cellEdit, dirty) } : prev
+        );
+        this.queueDraftWrites(session, dirty);
+      }
+    }
+    await this.settleCellWrites();
+  }
+  /**
+   * Focus / pointer moved outside the grid. Deferred commit ends the edit per
+   * `stopEditingWhenCellsLoseFocus`; immediate commit has nothing pending and
+   * keeps the editor (legacy table behaviour).
+   */
+  async leaveGridFocus() {
+    if (!this.getCellEdit()) return;
+    if (this.cellEditOptions.commit !== "deferred") return;
+    if (!this.cellEditOptions.stopEditingWhenCellsLoseFocus) return;
+    await this.commitCellEdit();
+  }
+  /**
+   * Before dispose / unmount: commit (or drop, when
+   * `stopEditingWhenCellsLoseFocus` is false) the open edit and wait until
+   * every queued write is durable.
+   */
+  async settleEditsForTeardown() {
+    if (this.getCellEdit()) {
+      if (this.cellEditOptions.stopEditingWhenCellsLoseFocus) {
+        await this.commitCellEdit();
+      } else {
+        this.cancelCellEdit();
+      }
+    }
+    await this.settleCellWrites();
   }
   isEditingCell(rowId, columnId) {
     return isEditingCell(this.getCellEdit(), rowId, columnId);
@@ -5248,39 +5476,12 @@ var TableEngine = class {
    */
   async commitCellEdit() {
     const store = this.tableStore;
-    const commandStore = this.commandStore;
-    const tableKey = this.tableKey;
-    if (!store || !commandStore || !tableKey) return 0;
+    if (!store || !this.commandStore || !this.tableKey) return 0;
     const session = store.getState().cellEdit;
     if (!session) return 0;
-    const dirty = dirtyDraftColumns(session);
     store.setState((prev) => ({ ...prev, cellEdit: null }));
-    let writes = 0;
-    for (const colId of dirty) {
-      const draft = session.drafts[colId];
-      const base = session.baseline[colId];
-      if (!base || draft.value !== base.value) {
-        await this.dispatch({
-          type: "CHANGE_CELL_VALUE",
-          store: commandStore,
-          tableKey,
-          rowId: session.rowId,
-          columnId: colId,
-          newValue: draft.value
-        });
-        writes += 1;
-      }
-      if (!base || draft.display !== base.display) {
-        await this.dispatch({
-          type: "CHANGE_CELL_DISPLAY_VALUE",
-          store: commandStore,
-          tableKey,
-          rowId: session.rowId,
-          columnId: colId,
-          newValue: draft.display == null ? "" : String(draft.display)
-        });
-      }
-    }
+    const writes = this.queueDraftWrites(session, dirtyDraftColumns(session));
+    await this.settleCellWrites();
     return writes;
   }
   async transitionActiveCell(rowId, columnId) {
@@ -5469,16 +5670,15 @@ var TableEngine = class {
     if (syncError) return syncError;
     return this.applyAsyncValidators(value, schema, caption, rowId);
   }
-  finishValidation(cb, tableStore) {
+  finishValidation(cb, tableStore, errorsChanged) {
     cb({
       valid: this.errors.size === 0,
       errors: this.errors,
       data: this.getAllRows()
     });
-    tableStore.setState((prev) => ({
-      ...prev,
-      expandedRows: {}
-    }));
+    tableStore.setState(
+      (prev) => !errorsChanged && Object.keys(prev.expandedRows ?? {}).length === 0 ? prev : { ...prev, expandedRows: {} }
+    );
   }
   collectValidationJobs(table) {
     const jobs = [];
@@ -5497,11 +5697,23 @@ var TableEngine = class {
     });
     return jobs;
   }
+  /** Replaces the error map; true when the set of errors / messages changed. */
   applyValidationErrors(nextErrors) {
+    let changed = nextErrors.size !== this.errors.size;
+    if (!changed) {
+      for (const [cellId, error] of nextErrors) {
+        const prev = this.errors.get(cellId);
+        if (!prev || prev.message !== error.message || prev.rowId !== error.rowId) {
+          changed = true;
+          break;
+        }
+      }
+    }
     this.errors.clear();
     nextErrors.forEach((error, cellId) => {
       this.errors.set(cellId, error);
     });
+    return changed;
   }
   runValidationSync(table, cb, tableStore) {
     const nextErrors = /* @__PURE__ */ new Map();
@@ -5514,8 +5726,8 @@ var TableEngine = class {
       );
       if (error) nextErrors.set(job.cellId, error);
     }
-    this.applyValidationErrors(nextErrors);
-    this.finishValidation(cb, tableStore);
+    const changed = this.applyValidationErrors(nextErrors);
+    this.finishValidation(cb, tableStore, changed);
   }
   async runValidationAsync(table, cb, tableStore) {
     const nextErrors = /* @__PURE__ */ new Map();
@@ -5528,8 +5740,8 @@ var TableEngine = class {
       );
       if (error) nextErrors.set(job.cellId, error);
     }
-    this.applyValidationErrors(nextErrors);
-    this.finishValidation(cb, tableStore);
+    const changed = this.applyValidationErrors(nextErrors);
+    this.finishValidation(cb, tableStore, changed);
   }
   scheduleAsyncCellCheck(cellId, valueKey, value, schema, caption, rowId) {
     const seq = (this.asyncCellSeq.get(cellId) ?? 0) + 1;
@@ -5874,6 +6086,9 @@ async function openIndexedDbDatabase(dbName, storeNames, version = 1) {
     request.onsuccess = () => resolve(request.result);
   });
   return {
+    close() {
+      db.close();
+    },
     objectStore(name) {
       return {
         async get(key) {
@@ -5925,6 +6140,8 @@ var IndexedDbEventStore = class _IndexedDbEventStore {
     this.db = db;
     this.listeners = /* @__PURE__ */ new Map();
     this.globalListeners = /* @__PURE__ */ new Set();
+    this.closed = false;
+    this.inflight = /* @__PURE__ */ new Set();
     this.ready = Promise.resolve();
   }
   static async open(dbName = DEFAULT_EVENT_STORE_PREFIX) {
@@ -5935,7 +6152,36 @@ var IndexedDbEventStore = class _IndexedDbEventStore {
   static inMemory() {
     return new _IndexedDbEventStore(new MemoryKvDatabase());
   }
-  async append(streamId, events, expectedVersion) {
+  /**
+   * Release the IndexedDB connection (stored events are untouched). Waits for
+   * appends already in flight; appends started afterwards are dropped (they
+   * resolve `ok` without writing) because the owning grid is gone. Idempotent.
+   */
+  close() {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = (async () => {
+        await Promise.allSettled([...this.inflight]);
+        this.listeners.clear();
+        this.globalListeners.clear();
+        this.db.close?.();
+      })();
+    }
+    return this.closePromise;
+  }
+  append(streamId, events, expectedVersion) {
+    if (this.closed) {
+      return Promise.resolve({ ok: true, version: 0 });
+    }
+    const job = this.appendInternal(streamId, events, expectedVersion);
+    this.inflight.add(job);
+    const forget = () => {
+      this.inflight.delete(job);
+    };
+    job.then(forget, forget);
+    return job;
+  }
+  async appendInternal(streamId, events, expectedVersion) {
     await this.ready;
     const streamStore = this.db.objectStore(STREAMS);
     const globalStore = this.db.objectStore(GLOBAL);
@@ -5975,11 +6221,13 @@ var IndexedDbEventStore = class _IndexedDbEventStore {
     return { ok: true, version: record.events.length };
   }
   async read(streamId, fromVersion = 0) {
+    if (this.closed) return [];
     await this.ready;
     const record = await this.db.objectStore(STREAMS).get(streamId);
     return (record?.events ?? []).slice(fromVersion);
   }
   async readAll(fromPosition = 0) {
+    if (this.closed) return [];
     await this.ready;
     const globalStore = this.db.objectStore(GLOBAL);
     const keys = (await globalStore.getAllKeys()).map(Number).filter((n) => Number.isFinite(n)).sort((a, b) => a - b).filter((n) => n > fromPosition);
@@ -5991,6 +6239,7 @@ var IndexedDbEventStore = class _IndexedDbEventStore {
     return events;
   }
   subscribe(streamId, onEvent) {
+    if (this.closed) return () => void 0;
     if (!this.listeners.has(streamId)) {
       this.listeners.set(streamId, /* @__PURE__ */ new Set());
     }
@@ -6001,6 +6250,7 @@ var IndexedDbEventStore = class _IndexedDbEventStore {
     };
   }
   subscribeAll(onEvent) {
+    if (this.closed) return () => void 0;
     this.globalListeners.add(onEvent);
     return () => {
       this.globalListeners.delete(onEvent);
@@ -6049,6 +6299,8 @@ var OfflineStatus = class {
     this.syncedIds = /* @__PURE__ */ new Set();
     this.connectivityUnsub = null;
     this.storeUnsub = null;
+    /** Incremented by every stop(); invalidates an in-flight start(). */
+    this.lifecycle = 0;
     this.connectivityListeners = /* @__PURE__ */ new Set();
     this.pendingListeners = /* @__PURE__ */ new Set();
     this.online = options.connectivity.getOnline();
@@ -6056,11 +6308,14 @@ var OfflineStatus = class {
   }
   async start(eventStore) {
     this.stop();
+    const run2 = this.lifecycle;
     this.connectivityUnsub = this.options.connectivity.subscribe((online) => {
+      if (run2 !== this.lifecycle) return;
       this.online = online;
       this.emitConnectivity();
     });
     const past = await eventStore.readAll(0);
+    if (run2 !== this.lifecycle) return;
     for (const event of past) {
       this.consider(event);
     }
@@ -6069,7 +6324,14 @@ var OfflineStatus = class {
     });
     this.emitPending();
   }
+  /** Stop listening and drop all listeners. The instance is inert afterwards. */
+  dispose() {
+    this.stop();
+    this.connectivityListeners.clear();
+    this.pendingListeners.clear();
+  }
   stop() {
+    this.lifecycle += 1;
     this.connectivityUnsub?.();
     this.connectivityUnsub = null;
     this.storeUnsub?.();
@@ -6576,18 +6838,40 @@ var UITableController = class {
     return this.syncPort;
   }
   setSyncPort(port) {
+    if (this.releasePromise) {
+      port?.dispose?.();
+      return;
+    }
     this.syncPort = port;
   }
   getPresencePort() {
     return this.presencePort;
   }
   setPresencePort(port) {
+    if (this.releasePromise) {
+      port?.dispose();
+      return;
+    }
     this.presencePort = port;
   }
+  /**
+   * Composition root hook: the callback that releases every resource the grid
+   * created (subscriptions, projections, plugins, owned event store).
+   * Run once by {@link releaseResources}.
+   */
+  setResourceTeardown(teardown) {
+    this.resourceTeardown = teardown;
+  }
+  /** True once resources were released (via releaseResources or dispose). */
+  isReleased() {
+    return this.releasePromise !== void 0;
+  }
   getPresencePeers() {
     return this.presencePort?.getPeers() ?? [];
   }
   subscribePresencePeers(cb) {
+    if (this.isReleased()) return () => {
+    };
     if (!this.presencePort) {
       cb([]);
       return () => {
@@ -6612,6 +6896,8 @@ var UITableController = class {
     this.offlineStatus?.markSynced(eventIds);
   }
   subscribeConnectivity(cb) {
+    if (this.isReleased()) return () => {
+    };
     if (!this.offlineStatus) {
       cb("online");
       return () => {
@@ -6620,6 +6906,8 @@ var UITableController = class {
     return this.offlineStatus.subscribeConnectivity(cb);
   }
   subscribePendingChanges(cb) {
+    if (this.isReleased()) return () => {
+    };
     if (!this.offlineStatus) {
       cb([]);
       return () => {
@@ -6637,6 +6925,8 @@ var UITableController = class {
     return this.syncPort?.getOpenConflicts() ?? [];
   }
   subscribeSyncConflicts(cb) {
+    if (this.isReleased()) return () => {
+    };
     if (!this.syncPort) {
       cb([]);
       return () => {
@@ -6645,10 +6935,11 @@ var UITableController = class {
     return this.syncPort.subscribeConflicts(cb);
   }
   async syncNow() {
-    if (!this.syncPort) return null;
+    if (this.isReleased() || !this.syncPort) return null;
     return this.syncPort.sync();
   }
   async resolveSyncConflict(conflictId, choice) {
+    if (this.isReleased()) return;
     await this.syncPort?.resolveConflict(conflictId, choice);
   }
   /** Apply a remote cell value (used by SyncPort; dual-writes via engine). */
@@ -6697,24 +6988,17 @@ var UITableController = class {
   changePage(page) {
     this.engine.dispatch({ type: "CHANGE_PAGE", store: this.store, tableKey: this.tableKey, page });
   }
+  /** Editor of this cell → session draft (written per `cellEditCommit`); otherwise write-through. */
   onCellChange(rowId, columnId, value) {
-    if (this.engine.isEditingCell(rowId, columnId)) {
-      this.engine.patchCellEdit(rowId, columnId, { value });
-      return;
-    }
-    this.engine.dispatch({ type: "CHANGE_CELL_VALUE", store: this.store, tableKey: this.tableKey, rowId, columnId, newValue: value });
+    return this.engine.inputCellValue(rowId, columnId, value);
   }
   onDescriptionSave(rowId, flag) {
     this.engine.dispatch({ type: "SAVE_DESCRIPTION", store: this.store, tableKey: this.tableKey, rowId, flag });
   }
   onCellDisplayChange(rowId, columnId, value) {
-    if (this.engine.isEditingCell(rowId, columnId)) {
-      this.engine.patchCellEdit(rowId, columnId, { display: value });
-      return;
-    }
-    this.engine.dispatch({ type: "CHANGE_CELL_DISPLAY_VALUE", store: this.store, tableKey: this.tableKey, rowId, columnId, newValue: value });
+    return this.engine.inputCellDisplay(rowId, columnId, value);
   }
-  setActiveCell(rowId, columnId) {
+  async setActiveCell(rowId, columnId) {
     const prev = this.engine.getActiveCell();
     if (prev?.rowId === rowId && prev?.columnId === columnId) {
       if (this.engine.getCellEditOptions().singleClickEdit && !this.engine.getCellEdit()) {
@@ -6731,14 +7015,14 @@ var UITableController = class {
         rowId
       });
     }
-    this.engine.dispatch({ type: "ACTIVE_CELL", tableKey: this.tableKey, rowId, columnId });
     this.publishPresenceCell(rowId, columnId);
+    await this.engine.dispatch({ type: "ACTIVE_CELL", tableKey: this.tableKey, rowId, columnId });
   }
   setActiveRow(rowId) {
     this.engine.dispatch({ type: "ACTIVE_ROW", store: this.store, tableKey: this.tableKey, rowId });
   }
   moveActiveCellVertical(rowId, columnId, direction) {
-    this.engine.dispatch({ type: "MOVE_ACTIVE_CELL_VERTICAL", store: this.store, tableKey: this.tableKey, rowId, columnId, direction });
+    return this.engine.dispatch({ type: "MOVE_ACTIVE_CELL_VERTICAL", store: this.store, tableKey: this.tableKey, rowId, columnId, direction });
   }
   reorderRow(draggedRowId, droppedRowId, position) {
     this.engine.dispatch({ type: "ROW_REORDERED", store: this.store, tableKey: this.tableKey, draggedRowId, droppedRowId, position });
@@ -6814,7 +7098,7 @@ var UITableController = class {
     this.engine.dispatch({ type: "ACTIVATE_FIRST_CELL", tableKey: this.tableKey, rowId });
   }
   moveToNextCell(rowId, columnId, direction = "next") {
-    this.engine.dispatch({ type: "MOVE_ACTIVE_CELL", store: this.store, tableKey: this.tableKey, rowId, columnId, direction });
+    return this.engine.dispatch({ type: "MOVE_ACTIVE_CELL", store: this.store, tableKey: this.tableKey, rowId, columnId, direction });
   }
   async setTableAction(action) {
     await this.engine.dispatch({ type: "SET_TABLE_ACTION", store: this.store, tableKey: this.tableKey, action });
@@ -7082,7 +7366,7 @@ var UITableController = class {
     ) ?? 0;
   }
   subscribeChangelog(cb, filter = {}) {
-    if (!this.changelogProjection) return () => {
+    if (!this.changelogProjection || this.isReleased()) return () => {
     };
     return this.safe(
       () => this.changelogProjection.subscribe(cb, { tableId: this.tableKey, ...filter }),
@@ -7105,7 +7389,7 @@ var UITableController = class {
     ) ?? 0;
   }
   subscribeHistoryItems(cb, filter = {}) {
-    if (!this.historyPanelViewModel) return () => {
+    if (!this.historyPanelViewModel || this.isReleased()) return () => {
     };
     return this.safe(
       () => this.historyPanelViewModel.subscribe(cb, { tableId: this.tableKey, ...filter }),
@@ -7178,6 +7462,40 @@ var UITableController = class {
   commitCellEdit() {
     return this.safe(() => this.engine.commitCellEdit(), "commitCellEdit") ?? Promise.resolve(0);
   }
+  /**
+   * Write what is still in the cell editor (the edit stays open) and wait
+   * until every pending cell write is durable. `getFullSnapShot` /
+   * `iterateRowsFromDb` / exports already do this; call it before reading
+   * synchronous APIs (`getRowView`, `getSnapShot`) for a save.
+   */
+  flushCellEdit() {
+    return this.engine.flushCellEdit().catch((error) => {
+      this.audit.log({
+        type: "ERROR",
+        message: "UITableController.flushCellEdit failed",
+        payload: { error, tableKey: this.tableKey }
+      });
+    });
+  }
+  /** DataGrid: focus / pointer left the grid (see `stopEditingWhenCellsLoseFocus`). */
+  leaveGridFocus() {
+    return this.engine.leaveGridFocus().catch((error) => {
+      this.audit.log({
+        type: "ERROR",
+        message: "UITableController.leaveGridFocus failed",
+        payload: { error, tableKey: this.tableKey }
+      });
+    });
+  }
+  settleEditsForTeardown() {
+    return this.engine.settleEditsForTeardown().catch((error) => {
+      this.audit.log({
+        type: "ERROR",
+        message: "UITableController: committing the open edit before teardown failed",
+        payload: { error, tableKey: this.tableKey }
+      });
+    });
+  }
   getEditDraft(rowId, columnId) {
     return this.safe(
       () => this.engine.getEditDraft(rowId, columnId),
@@ -7298,12 +7616,68 @@ var UITableController = class {
     this.engine.addCellRange(range);
   }
   // ─── lifecycle ───────────────────────────────────────────────────────
+  /**
+   * Full dispose: `TABLE_DISPOSED` (windowed repo: drop the RAM page window,
+   * other repos: `repo.delete` — unchanged data semantics) followed by
+   * {@link releaseResources}. Idempotent; the promise settles once teardown
+   * finished and never rejects.
+   */
   dispose() {
-    if (this.disposed) return;
+    if (this.disposed) return this.releasePromise ?? this.releaseResources();
     this.disposed = true;
     this.presencePort?.dispose();
     this.presencePort = void 0;
-    void this.engine.dispatch({ type: "TABLE_DISPOSED", store: this.store, tableKey: this.tableKey });
+    const dispatched = this.settleEditsForTeardown().then(
+      () => this.engine.dispatch({ type: "TABLE_DISPOSED", store: this.store, tableKey: this.tableKey })
+    ).catch((error) => {
+      this.audit.log({
+        type: "ERROR",
+        message: "UITableController.dispose: TABLE_DISPOSED failed",
+        payload: { error, tableKey: this.tableKey }
+      });
+    });
+    return dispatched.then(() => this.releaseResources());
+  }
+  /**
+   * Resource-only teardown: stops subscriptions, projections, sync, presence,
+   * plugins, server row model and closes an event store the grid opened.
+   * Does NOT dispatch `TABLE_DISPOSED` — persisted table data is untouched.
+   * Idempotent (same promise on every call); never rejects.
+   */
+  releaseResources() {
+    if (!this.releasePromise) {
+      this.releasePromise = this.runResourceTeardown();
+    }
+    return this.releasePromise;
+  }
+  async runResourceTeardown() {
+    const fail = (what, error) => {
+      this.audit.log({
+        type: "ERROR",
+        message: `UITableController.releaseResources: ${what} failed`,
+        payload: { error, tableKey: this.tableKey }
+      });
+    };
+    await this.settleEditsForTeardown();
+    const presence = this.presencePort;
+    const sync = this.syncPort;
+    this.presencePort = void 0;
+    this.syncPort = void 0;
+    try {
+      presence?.dispose();
+    } catch (error) {
+      fail("presence dispose", error);
+    }
+    try {
+      sync?.dispose?.();
+    } catch (error) {
+      fail("sync dispose", error);
+    }
+    try {
+      await this.resourceTeardown?.();
+    } catch (error) {
+      fail("teardown", error);
+    }
   }
   // ─── main dispatch ───────────────────────────────────────────────────
   async dispatch(command) {
@@ -7327,13 +7701,13 @@ var UITableController = class {
         this.changePage(command.page);
         return;
       case "UI_CELL_CHANGE":
-        this.onCellChange(command.rowId, command.columnId, command.value);
+        await this.onCellChange(command.rowId, command.columnId, command.value);
         return;
       case "UI_DESCRIPTION_SAVE":
         this.onDescriptionSave(command.rowId, command.flag);
         return;
       case "UI_CELL_CHANGE_DISPLAY":
-        this.onCellDisplayChange(command.rowId, command.columnId, command.value);
+        await this.onCellDisplayChange(command.rowId, command.columnId, command.value);
         return;
       case "ADD_EMPTY_ROW":
         await this.addEmptyRow();
@@ -7373,13 +7747,13 @@ var UITableController = class {
           shiftKey: Boolean(command.shiftKey),
           ctrlKey: Boolean(command.ctrlKey)
         });
-        this.setActiveCell(command.rowId, command.columnId);
+        await this.setActiveCell(command.rowId, command.columnId);
         return;
       case "UI_MOVE_ACTIVE_CELL":
-        this.moveToNextCell(command.rowId, command.columnId, command.direction);
+        await this.moveToNextCell(command.rowId, command.columnId, command.direction);
         return;
       case "UI_MOVE_ACTIVE_CELL_VERTICAL":
-        this.moveActiveCellVertical(command.rowId, command.columnId, command.direction);
+        await this.moveActiveCellVertical(command.rowId, command.columnId, command.direction);
         return;
       case "UI_ACTIVE_ROW":
         this.setActiveRow(command.rowId);
@@ -7594,6 +7968,7 @@ var PluginHost = class {
     return this.plugins.some((p) => p.name === pluginName);
   }
   async requestExport(options) {
+    await this.deps.beforeRead?.();
     const bus = this.createBus();
     const correlationId = options.correlationId ?? createEventId();
     const pluginName = options.format === "pdf" ? "pdf-export" : options.format === "csv" ? "csv-export" : "excel-export";
@@ -8079,6 +8454,40 @@ var ConsoleAuditLogger = class {
   }
 };
 
+// infrastructure/eventStore/trackedEventStore.ts
+function trackEventStoreSubscriptions(inner) {
+  const open = /* @__PURE__ */ new Set();
+  let released = false;
+  const track = (subscribe) => {
+    if (released) return () => void 0;
+    const raw = subscribe();
+    let done = false;
+    const unsub = () => {
+      if (done) return;
+      done = true;
+      open.delete(unsub);
+      raw();
+    };
+    open.add(unsub);
+    return unsub;
+  };
+  const store = {
+    append: (streamId, events, expectedVersion) => inner.append(streamId, events, expectedVersion),
+    read: (streamId, fromVersion) => inner.read(streamId, fromVersion),
+    readAll: (fromPosition) => inner.readAll(fromPosition),
+    subscribe: (streamId, onEvent) => track(() => inner.subscribe(streamId, onEvent)),
+    subscribeAll: (onEvent) => track(() => inner.subscribeAll(onEvent))
+  };
+  return {
+    store,
+    release() {
+      released = true;
+      for (const unsub of [...open]) unsub();
+      open.clear();
+    }
+  };
+}
+
 // infrastructure/history/HistoryPanelViewModel.ts
 var HISTORY_CLASSIFICATIONS = {
   CELL_CHANGED: { category: "data", severity: "info" },
@@ -8290,6 +8699,8 @@ var ChangelogProjection = class {
     this.subscribers = /* @__PURE__ */ new Set();
     this.seenEventIds = /* @__PURE__ */ new Set();
     this.started = false;
+    /** Incremented by start() and stop(); invalidates an in-flight catch-up. */
+    this.run = 0;
   }
   /**
    * Catch up via readAll, then subscribe for live events.
@@ -8303,17 +8714,25 @@ var ChangelogProjection = class {
       this.seenEventIds.add(event.eventId);
       this.project(event);
     };
+    const run2 = ++this.run;
     this.unsubscribe = this.eventStore.subscribeAll(projectOnce);
     const past = await this.eventStore.readAll(0);
+    if (run2 !== this.run) return;
     for (const event of past) {
       projectOnce(event);
     }
   }
   stop() {
+    this.run += 1;
     this.unsubscribe?.();
     this.unsubscribe = null;
     this.started = false;
   }
+  /** Stop and drop all subscribers (grid teardown). Entries stay readable. */
+  dispose() {
+    this.stop();
+    this.subscribers.clear();
+  }
   query(filter = {}) {
     let result = this.entries;
     if (filter.tableId) {
@@ -8895,6 +9314,33 @@ function isCellEditorTarget(target) {
   if (!editor) return false;
   return Boolean(editor.closest('[role="gridcell"], [data-erp-cell-textarea]'));
 }
+var CELL_SELECTOR = '[role="gridcell"], [data-erp-cell-textarea]';
+function isGridCellTarget(target) {
+  if (!target || !(target instanceof Element)) return false;
+  if (target.closest('[role="menu"], [role="dialog"], .erp-table-modal')) {
+    return false;
+  }
+  return Boolean(target.closest(CELL_SELECTOR));
+}
+var TEXT_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "",
+  "text",
+  "search",
+  "number",
+  "tel",
+  "url",
+  "email",
+  "password"
+]);
+function isTextEditorTarget(target) {
+  if (!isCellEditorTarget(target)) return false;
+  const el = target;
+  if (el.isContentEditable || el.getAttribute("contenteditable") === "true") return true;
+  const tag = el.tagName;
+  if (tag === "TEXTAREA") return true;
+  if (tag !== "INPUT") return false;
+  return TEXT_INPUT_TYPES.has((el.getAttribute("type") ?? "").toLowerCase());
+}
 function closestGridRoot(target) {
   if (!target || !(target instanceof Element)) return null;
   return target.closest('[role="grid"], [role="treegrid"]');
@@ -8949,6 +9395,13 @@ var UITableKeyboardHandler = class {
   setPasteCells(handler) {
     this.pasteCells = handler;
   }
+  /** More than one cell selected (Shift+Arrow / drag): clipboard keys act on the grid. */
+  hasMultiCellRange() {
+    const ranges = this.engine.getCellRanges();
+    if (ranges.length > 1) return true;
+    const range = ranges[0];
+    return Boolean(range && (range.startRow !== range.endRow || range.colIds.length > 1));
+  }
   async handle(e, ctx2) {
     try {
       await this.handleInternal(e, ctx2);
@@ -8968,6 +9421,8 @@ var UITableKeyboardHandler = class {
     const { activeColumnId } = ctx2;
     const selectedRows = this.engine.getSelectedRows();
     const activeRowId = ctx2.activeRowId ?? this.engine.getActiveRow() ?? (selectedRows ? Number(Object.keys(selectedRows).find((id) => selectedRows[Number(id)])) || null : null);
+    const inTextEditor = isTextEditorTarget(e.target);
+    const clipboardToEditor = inTextEditor && !this.hasMultiCellRange();
     switch (code) {
       case "KeyN": {
         if (altKey) {
@@ -8999,7 +9454,7 @@ var UITableKeyboardHandler = class {
           });
           return;
         }
-        if (!ctrlKey && !shiftKey && !altKey && activeRowId && activeColumnId) {
+        if (!ctrlKey && !shiftKey && !altKey && !inTextEditor && activeRowId && activeColumnId) {
           e.preventDefault();
           await this.dispatchIntent({
             type: "JUMP_ACTIVE_CELL_ROW_EDGE",
@@ -9033,7 +9488,7 @@ var UITableKeyboardHandler = class {
           });
           return;
         }
-        if (!ctrlKey && !shiftKey && !altKey && activeRowId && activeColumnId) {
+        if (!ctrlKey && !shiftKey && !altKey && !inTextEditor && activeRowId && activeColumnId) {
           e.preventDefault();
           await this.dispatchIntent({
             type: "JUMP_ACTIVE_CELL_ROW_EDGE",
@@ -9061,28 +9516,28 @@ var UITableKeyboardHandler = class {
               type: "ACTIVATE_FIRST_CELL",
               rowId: activeRowId
             });
-          } else if (this.engine.getCellEdit()) {
+          } else if (!this.engine.getCellEdit() && !this.engine.getCellEditOptions().singleClickEdit) {
+            this.engine.startCellEdit(activeRowId, activeColumnId);
+          } else if (this.engine.getCellEditOptions().enterNavigation === "down") {
             await this.dispatchIntent({
               type: "MOVE_ACTIVE_CELL_VERTICAL",
               rowId: activeRowId,
               columnId: activeColumnId,
               direction: shiftKey ? "up" : "down"
             });
-          } else if (!this.engine.getCellEditOptions().singleClickEdit) {
-            this.engine.startCellEdit(activeRowId, activeColumnId);
           } else {
             await this.dispatchIntent({
-              type: "MOVE_ACTIVE_CELL_VERTICAL",
+              type: "MOVE_ACTIVE_CELL",
               rowId: activeRowId,
               columnId: activeColumnId,
-              direction: shiftKey ? "up" : "down"
+              direction: shiftKey ? "prev" : "next"
             });
           }
         }
         return;
       }
       case "Tab": {
-        if (!isCellEditorTarget(e.target)) {
+        if (!isGridCellTarget(e.target)) {
           return;
         }
         if (activeRowId && activeColumnId) {
@@ -9272,7 +9727,7 @@ var UITableKeyboardHandler = class {
         return;
       }
       case "KeyA": {
-        if (ctrlKey) {
+        if (ctrlKey && !inTextEditor) {
           e.preventDefault();
           await this.dispatchIntent({ type: "SELECT_ALL_CELLS" });
         }
@@ -9280,6 +9735,7 @@ var UITableKeyboardHandler = class {
       }
       case "KeyC": {
         if (ctrlKey && !altKey) {
+          if (clipboardToEditor) return;
           e.preventDefault();
           if (this.copyCells) {
             await this.copyCells();
@@ -9294,6 +9750,7 @@ var UITableKeyboardHandler = class {
       }
       case "KeyX": {
         if (ctrlKey && !altKey) {
+          if (clipboardToEditor) return;
           e.preventDefault();
           if (this.cutCells) {
             await this.cutCells();
@@ -9308,6 +9765,7 @@ var UITableKeyboardHandler = class {
       }
       case "KeyV": {
         if (ctrlKey && !altKey) {
+          if (clipboardToEditor) return;
           e.preventDefault();
           if (this.pasteCells) {
             await this.pasteCells();
@@ -9358,6 +9816,7 @@ var UITableKeyboardHandler = class {
         return;
       }
       case "KeyZ": {
+        if (inTextEditor) return;
         if (ctrlKey && !shiftKey) {
           e.preventDefault();
           await this.dispatchIntent({ type: "UNDO" });
@@ -9370,7 +9829,7 @@ var UITableKeyboardHandler = class {
         return;
       }
       case "KeyY": {
-        if (ctrlKey) {
+        if (ctrlKey && !inTextEditor) {
           e.preventDefault();
           await this.dispatchIntent({ type: "REDO" });
         }
@@ -11048,14 +11507,14 @@ function createPermissionPolicy(config, columnMeta, table, repo, audit) {
   };
 }
 function createTableAppService(repo, audit, permissionPolicy, { columnMeta, remoteApi }, eventStore) {
-  const changeCellHandler = new chunkDXRCYW42_cjs.ChangeCellValueHandler(repo, audit, permissionPolicy, { columnMeta, remoteApi });
-  const applyDynamicProjection = new chunkDXRCYW42_cjs.ApplyDynamicProjectionHandler(repo, audit, permissionPolicy, { columnMeta, remoteApi });
+  const changeCellHandler = new chunk52LFOPXD_cjs.ChangeCellValueHandler(repo, audit, permissionPolicy, { columnMeta, remoteApi });
+  const applyDynamicProjection = new chunk52LFOPXD_cjs.ApplyDynamicProjectionHandler(repo, audit, permissionPolicy, { columnMeta, remoteApi });
   let rowVisibilityHandler;
-  const applyRowVisibility = () => rowVisibilityHandler ?? (rowVisibilityHandler = import('./applyRowVisibilityHandler-LXCOGESZ.cjs').then(
+  const applyRowVisibility = () => rowVisibilityHandler ?? (rowVisibilityHandler = import('./applyRowVisibilityHandler-Q64ZFC7A.cjs').then(
     (m) => new m.ApplyRowVisibilityHandler(repo, audit, permissionPolicy, { columnMeta, remoteApi })
   ));
-  const changeCellDisplayHandler = new chunkDXRCYW42_cjs.ChangeCellDisplayValueHandler(repo, audit, permissionPolicy);
-  const saveDescriptionHandler = new chunkDXRCYW42_cjs.SaveDescriptionHandler(repo, audit, permissionPolicy);
+  const changeCellDisplayHandler = new chunk52LFOPXD_cjs.ChangeCellDisplayValueHandler(repo, audit, permissionPolicy);
+  const saveDescriptionHandler = new chunk52LFOPXD_cjs.SaveDescriptionHandler(repo, audit, permissionPolicy);
   const addNewRowHandler = new AddNewRowCommandHandler(repo, audit, permissionPolicy);
   const addNewRowsHandler = new AddNewRowsCommandHandler(repo, audit, permissionPolicy);
   const duplicateRowHandler = new DuplicateRowCommandHandler(repo, audit, permissionPolicy);
@@ -11108,14 +11567,39 @@ function createTableAppService(repo, audit, permissionPolicy, { columnMeta, remo
 
 // bootstrap/index.ts
 async function resolveEventStore(config, persist) {
-  if (config.eventStore) return config.eventStore;
-  if (config.persistence === "paged-idb") return new InMemoryEventStore();
+  if (config.eventStore) return { eventStore: config.eventStore };
+  if (config.persistence === "paged-idb") {
+    return { eventStore: new InMemoryEventStore() };
+  }
   if (persist && typeof indexedDB !== "undefined") {
-    return IndexedDbEventStore.open(
+    const opened = await IndexedDbEventStore.open(
       eventStoreDbName(config.store, config.eventStoreName)
     );
+    return { eventStore: opened, close: () => opened.close() };
   }
-  return new InMemoryEventStore();
+  return { eventStore: new InMemoryEventStore() };
+}
+function createDisposerRegistry() {
+  const disposers = [];
+  let running;
+  return {
+    add(disposer) {
+      disposers.push(disposer);
+    },
+    run() {
+      if (!running) {
+        running = (async () => {
+          for (const disposer of disposers.splice(0).reverse()) {
+            try {
+              await disposer();
+            } catch {
+            }
+          }
+        })();
+      }
+      return running;
+    }
+  };
 }
 function createInitialRows(collectionColumns) {
   const rows = [];
@@ -11147,6 +11631,15 @@ function resolveHostRows(config, columns) {
   );
 }
 async function assembleGrid(config) {
+  const registry = createDisposerRegistry();
+  try {
+    return await assembleGridInner(config, registry);
+  } catch (error) {
+    await registry.run();
+    throw error;
+  }
+}
+async function assembleGridInner(config, registry) {
   const { store, tableKey, actor, persist } = resolveCreateGridDefaults(config);
   const resolved = {
     ...config,
@@ -11162,8 +11655,14 @@ async function assembleGrid(config) {
   const windowed = isWindowedRepository(repo);
   const audit = config.audit ?? new ConsoleAuditLogger();
   const remoteApi = config.remoteApi ?? new NoopRemoteApi();
-  const eventStore = await resolveEventStore(resolved, persist);
-  const changelogProjection = new ChangelogProjection(eventStore);
+  const resolvedStore = await resolveEventStore(resolved, persist);
+  const { eventStore } = resolvedStore;
+  if (resolvedStore.close) registry.add(resolvedStore.close);
+  const tracked = trackEventStoreSubscriptions(eventStore);
+  registry.add(() => tracked.release());
+  const internalStore = tracked.store;
+  const changelogProjection = new ChangelogProjection(internalStore);
+  registry.add(() => changelogProjection.dispose());
   const historyPanelViewModel = new HistoryPanelViewModel(changelogProjection);
   const cellUndoStack = new CellUndoStack();
   await changelogProjection.start();
@@ -11172,11 +11671,12 @@ async function assembleGrid(config) {
     connectivity: config.connectivity ?? createBrowserConnectivity(),
     watermark: createLocalStorageWatermark(`pdg-sync-watermark:${store}:${tableKey}`)
   });
-  await offlineStatus.start(eventStore);
+  registry.add(() => offlineStatus.dispose());
+  await offlineStatus.start(internalStore);
   const engineRef = {};
   const snapshotStrategy = config.snapshotStore ? new SnapshotStrategy(
     config.snapshotStore,
-    eventStore,
+    internalStore,
     () => engineRef.current?.getSnapShot("active") ?? {
       rows: []
     },
@@ -11291,17 +11791,20 @@ async function assembleGrid(config) {
     remoteApi,
     offlineStatus
   );
+  controller.setResourceTeardown(() => registry.run());
   let syncPort;
   if (config.syncTransport) {
-    const { GridSyncService } = await import('./GridSyncService-TAPAHABV.cjs');
+    const { GridSyncService } = await import('./GridSyncService-3JQLEY65.cjs');
     syncPort = new GridSyncService({
       tableId: tableKey,
-      eventStore,
+      eventStore: internalStore,
       offlineStatus,
       transport: config.syncTransport,
       policy: config.syncConflictPolicy,
       applyCellValue: (rowId, columnId, value) => controller.applySyncedCellValue(rowId, columnId, value)
     });
+    const syncService = syncPort;
+    registry.add(() => syncService.dispose?.());
     controller.setSyncPort(syncPort);
   }
   let presencePort;
@@ -11316,6 +11819,8 @@ async function assembleGrid(config) {
       label: config.presenceLabel ?? actor.userId,
       transport: presenceTransport
     });
+    const presenceService = presencePort;
+    registry.add(() => presenceService.dispose());
     controller.setPresencePort(presencePort);
   }
   const { definitions: columnDefinitions, bindings: columnBindings } = mapColumnSchemas(hostColumns);
@@ -11333,7 +11838,11 @@ async function assembleGrid(config) {
   engine.setCellEditOptions({
     ...typeof config.singleClickEdit === "boolean" ? { singleClickEdit: config.singleClickEdit } : {},
     ...typeof config.stopEditingWhenCellsLoseFocus === "boolean" ? { stopEditingWhenCellsLoseFocus: config.stopEditingWhenCellsLoseFocus } : {},
-    ...config.editType === "cell" || config.editType === "fullRow" ? { editType: config.editType } : {}
+    ...config.editType === "cell" || config.editType === "fullRow" ? { editType: config.editType } : {},
+    // Page-window (document) grids keep the arianERP write-per-change
+    // contract; the event-sourced grid avoids one EventStore write per key.
+    commit: config.cellEditCommit === "immediate" || config.cellEditCommit === "deferred" ? config.cellEditCommit : pagedIdb ? "immediate" : "deferred",
+    ...config.enterNavigation === "nextCell" || config.enterNavigation === "down" ? { enterNavigation: config.enterNavigation } : {}
   });
   controller.configureClipboard({
     copyFormattedValue: config.copyFormattedValue,
@@ -11375,6 +11884,7 @@ async function assembleGrid(config) {
       maxBlocksInCache: config.maxBlocksInCache
     });
     refreshServerSide = () => handle.refreshServerSide();
+    registry.add(() => handle.dispose());
   }
   if (snapshotStrategy) {
     await snapshotStrategy.loadWithCatchUp(`table:${tableKey}`);
@@ -11382,10 +11892,12 @@ async function assembleGrid(config) {
   const pluginHost = new PluginHost({
     tableId: tableKey,
     actorId: actor.userId,
-    eventStore,
+    eventStore: internalStore,
     session,
-    query: createEngineGridQuery(engine)
+    query: createEngineGridQuery(engine),
+    beforeRead: () => engine.flushCellEdit()
   });
+  registry.add(() => pluginHost.dispose());
   if (config.plugins?.length) {
     pluginHost.register(config.plugins);
   }
@@ -11396,14 +11908,15 @@ async function assembleGrid(config) {
     getRowId: config.getRowId,
     refreshServerSide
   });
-  await attachColumnStatePersistence({
+  const detachColumnState = await attachColumnStatePersistence({
     api,
     controller,
     tableId: tableKey,
     actorId: actor.userId,
     stateKey: config.stateKey,
-    eventStore
+    eventStore: internalStore
   });
+  registry.add(detachColumnState);
   return {
     engine,
     controller,
@@ -11782,5 +12295,5 @@ exports.toColumnViewBinding = toColumnViewBinding;
 exports.toMinorUnits = toMinorUnits;
 exports.trapTabKey = trapTabKey;
 exports.writeSystemClipboard = writeSystemClipboard;
-//# sourceMappingURL=chunk-IIISFUW4.cjs.map
-//# sourceMappingURL=chunk-IIISFUW4.cjs.map
+//# sourceMappingURL=chunk-WTHTVKVI.cjs.map
+//# sourceMappingURL=chunk-WTHTVKVI.cjs.map