@genesislcap/grid-pro 15.24.2 → 15.25.0-FUI-2611.1

package/dist/esm/datasource/infinite.resource.js

@@ -1,6 +1,7 @@
 import { __awaiter } from "tslib";
 import { dataServerResultFilter, MessageType, } from '@genesislcap/foundation-comms';
 import { logger } from '../utils';
+import { DeliveredBlockLedger } from './delivered-block.ledger';
 import { convertFilterModelToCriteria } from './filter.utils';
 /**
  * Converts an AG Grid sort model to the Genesis ORDER_BY form the resource expects.
@@ -45,6 +46,8 @@ export function convertSortModelToOrderBy(sortModel, resourceIndexes, isRequestS
  */
 export class GenesisInfiniteDatasource {
     constructor(options) {
+        /** Set by destroy(); a reply that resolves afterwards belongs to a dropped cache. @internal */
+        this.destroyed = false;
         /**
          * Session-cumulative row cache, keyed by row id. A Map preserves insertion order, so the
          * cache can be sliced by block range; Genesis splits batches across messages and later
@@ -69,7 +72,12 @@ export class GenesisInfiniteDatasource {
         this.getMoreRowsFunc = options.getMoreRowsFunc;
         this.onRowsInvalidatedFunc = options.onRowsInvalidatedFunc;
         this.onRowsUpdatedFunc = options.onRowsUpdatedFunc;
+        this.onRowsDeliveredFunc = options.onRowsDeliveredFunc;
+        this.onRowsWithdrawnFunc = options.onRowsWithdrawnFunc;
+        this.onRowsEvictedFunc = options.onRowsEvictedFunc;
+        this.onRowCacheResetFunc = options.onRowCacheResetFunc;
         this.errorHandlerFunc = options.errorHandlerFunc;
+        this.ledger = new DeliveredBlockLedger(options.rowId, options.maxBlocksInCache);
         this.resourceName = options.resourceName;
         this.resourceParams = Object.assign({}, options.resourceParams);
         this.resourceIndexes = options.resourceIndexes;
@@ -164,6 +172,7 @@ export class GenesisInfiniteDatasource {
                 const combinedCriteria = [this.baseCriteria, filterCriteria].filter(Boolean).join(' && ');
                 // Build sort config
                 const sortConfig = convertSortModelToOrderBy(params.sortModel, this.resourceIndexes, this.isRequestServer);
+                this.noteRequestKey(combinedCriteria, sortConfig);
                 // DATASERVER pages through a persistent subscription; REQUEST_SERVER is stateless and
                 // pages by OFFSET on a fresh request each time.
                 if (!this.isRequestServer) {
@@ -173,6 +182,13 @@ export class GenesisInfiniteDatasource {
                 const requestParams = this.buildRequestServerParams(params.startRow, combinedCriteria, sortConfig);
                 logger.debug('Infinite datasource request params', requestParams);
                 const result = yield this.createSnapshotFunc(requestParams);
+                // A reply that lands after destroy() belongs to a cache the grid has already dropped
+                // (reloadResourceData purges it); AG Grid ignores the callback, and the host must not
+                // learn of rows the grid will never hold.
+                if (this.destroyed) {
+                    logger.debug('Infinite REQUEST_SERVER reply discarded: the datasource was destroyed');
+                    return;
+                }
                 if (!result) {
                     params.failCallback();
                     return;
@@ -181,6 +197,7 @@ export class GenesisInfiniteDatasource {
                     const rowData = result.REPLY;
                     const lastRow = this.getLastRow(result, params.startRow, rowData.length, Boolean(combinedCriteria));
                     params.successCallback(rowData, lastRow);
+                    this.deliverRows(params.startRow, rowData);
                     return;
                 }
                 // Fallback - empty result
@@ -202,20 +219,31 @@ export class GenesisInfiniteDatasource {
      * outstanding at once, and each settles as soon as the cache covers its range.
      * @internal
      */
+    /**
+     * Notes the CRITERIA_MATCH/ORDER_BY a block is being read with. A change means AG Grid has
+     * purged its cache and restarted from block 0: on DATASERVER the subscription is re-opened
+     * (those are DATA_LOGON parameters), and on both transports the host is told the rows it held
+     * are gone, so the rows read under the new filter or sort are reported as new.
+     * @internal
+     */
+    noteRequestKey(criteria, sortConfig) {
+        var _a;
+        const key = JSON.stringify(Object.assign({ criteria }, sortConfig));
+        if (this.subscriptionKey !== undefined && this.subscriptionKey !== key) {
+            if (!this.isRequestServer) {
+                this.teardownDataserverSubscription();
+            }
+            this.ledger.clear();
+            (_a = this.onRowCacheResetFunc) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        this.subscriptionKey = key;
+    }
     getDataserverRows(params, criteria, sortConfig) {
         if (!this.createDataserverStreamFunc || !this.getMoreRowsFunc) {
             logger.error('Infinite DATASERVER paging requires a stream and a getMoreRows function');
             params.failCallback();
             return;
         }
-        // CRITERIA_MATCH and ORDER_BY are DATA_LOGON parameters, so a filter or sort change needs a
-        // fresh subscription and a fresh cache. AG Grid purges its own cache on those changes and
-        // restarts from block 0, so nothing is lost.
-        const key = JSON.stringify(Object.assign({ criteria }, sortConfig));
-        if (this.subscriptionKey !== undefined && this.subscriptionKey !== key) {
-            this.teardownDataserverSubscription();
-        }
-        this.subscriptionKey = key;
         const startRow = Number.isFinite(Number(params.startRow)) ? Number(params.startRow) : 0;
         const endRow = Number.isFinite(Number(params.endRow))
             ? Number(params.endRow)
@@ -380,7 +408,7 @@ export class GenesisInfiniteDatasource {
                 deletes: (_k = (_j = result.deletes) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0,
             });
             this.reset();
-            (_l = this.onRowsInvalidatedFunc) === null || _l === void 0 ? void 0 : _l.call(this);
+            (_l = this.onRowsInvalidatedFunc) === null || _l === void 0 ? void 0 : _l.call(this, result);
             return;
         }
         if (modified) {
@@ -388,7 +416,7 @@ export class GenesisInfiniteDatasource {
             logger.debug('Infinite DATASERVER live update patched into the cache', {
                 updates: (_o = (_m = result.updates) === null || _m === void 0 ? void 0 : _m.length) !== null && _o !== void 0 ? _o : 0,
             });
-            (_p = this.onRowsUpdatedFunc) === null || _p === void 0 ? void 0 : _p.call(this);
+            (_p = this.onRowsUpdatedFunc) === null || _p === void 0 ? void 0 : _p.call(this, result);
         }
     }
     /**
@@ -506,6 +534,25 @@ export class GenesisInfiniteDatasource {
             lastRow,
         });
         block.success(rows, lastRow);
+        this.deliverRows(block.startRow, rows);
+    }
+    /**
+     * Reports rows handed to the grid for a block, then the rows a re-read of that block no longer
+     * carries and the rows whose block the grid evicted.
+     * @internal
+     */
+    deliverRows(startRow, rows) {
+        var _a, _b, _c;
+        const { withdrawnRowIds, evictedRowIds } = this.ledger.record(startRow, rows);
+        if (rows.length > 0) {
+            (_a = this.onRowsDeliveredFunc) === null || _a === void 0 ? void 0 : _a.call(this, rows);
+        }
+        if (withdrawnRowIds.length > 0) {
+            (_b = this.onRowsWithdrawnFunc) === null || _b === void 0 ? void 0 : _b.call(this, withdrawnRowIds);
+        }
+        if (evictedRowIds.length > 0) {
+            (_c = this.onRowsEvictedFunc) === null || _c === void 0 ? void 0 : _c.call(this, evictedRowIds);
+        }
     }
     /**
      * Warns when the view filled up before the data ran out.
@@ -567,7 +614,9 @@ export class GenesisInfiniteDatasource {
         this.moreRowsInFlight = false;
     }
     destroy() {
+        this.destroyed = true;
         this.teardownDataserverSubscription();
+        this.ledger.clear();
         logger.debug('GenesisInfiniteDatasource destroyed');
     }
 }

package/dist/esm/datasource/server-side.datasource.js

@@ -1,6 +1,6 @@
 import { __awaiter, __decorate } from "tslib";
 import { dataServerResultFilter, Datasource, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
-import { JSONSerializer, LifecycleMixin } from '@genesislcap/foundation-utils';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
 import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
 import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
 import { datasourceEventNames, } from '../grid-pro-genesis-datasource/datasource-events.types';
@@ -30,7 +30,7 @@ const withoutColumnDefs = null;
  * @fires base-datasource-connected - Fired when error state is cleared after connection succeeds
  * @fires datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes
  * @fires datasource-no-data-available - Fired when loading finishes with an empty row set
- * @fires datasource-data-changed - Fired when row data changes from applied stream transactions. detail: `DataChangedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a live stream pushes a change, a poll detects one, or a re-read no longer returns a row; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
  * @fires refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`
  * @fires set-server-side-datasource - Fired to attach or clear the server-side row model datasource
@@ -41,7 +41,7 @@ const withoutColumnDefs = null;
  * @fires datasource-init - Fired when the server-side grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
- * @fires datasource-data-cleared - Fired when server-side row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
  * @fires apply-server-side-transaction - Fired to apply a server-side row transaction
  * @fires datasource-ready - Fired when the host grid is ready to start loading data
  */
@@ -91,6 +91,10 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     errorHandlerFunc: this.handleErrors.bind(this),
                     onNoDataAvailableFunc: () => this.$emit(datasourceEventNames.noDataAvailable),
                     onDataAvailableFunc: () => this.$emit(datasourceEventNames.loadingFinished),
+                    onRowsDeliveredFunc: this.reportDeliveredRows.bind(this),
+                    onRowsWithdrawnFunc: this.reportWithdrawnRows.bind(this),
+                    onRowsEvictedFunc: this.forgetRows.bind(this),
+                    maxBlocksInCache: this.gridMaxBlocksInCache,
                     resourceName: this.resourceName,
                     resourceParams: this.datasource.requestOnlyParams,
                     resourceIndexes: this.indexes,
@@ -107,6 +111,11 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     errorHandlerFunc: this.handleErrors.bind(this),
                     onNoDataAvailableFunc: () => this.$emit(datasourceEventNames.noDataAvailable),
                     onDataAvailableFunc: () => this.$emit(datasourceEventNames.loadingFinished),
+                    onRowsDeliveredFunc: this.reportDeliveredRows.bind(this),
+                    onRowsWithdrawnFunc: this.reportWithdrawnRows.bind(this),
+                    onRowsEvictedFunc: this.forgetRows.bind(this),
+                    maxBlocksInCache: this.gridMaxBlocksInCache,
+                    gridReceivesLiveUpdates: this.liveUpdates,
                     resourceName: this.resourceName,
                     resourceParams: this.datasource.dataserverOnlyParams,
                     resourceIndexes: this.indexes,
@@ -145,6 +154,16 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
          */
         this.hasCapturedFirstPollResult = false;
     }
+    /**
+     * The `maxBlocksInCache` the consumer gave the grid, if any, so block eviction can be mirrored
+     * in the held-row bookkeeping. The server-side defaults set none, so AG Grid keeps every block.
+     * @internal
+     */
+    get gridMaxBlocksInCache() {
+        var _a;
+        const value = Number((_a = this.deferredGridOptions) === null || _a === void 0 ? void 0 : _a.maxBlocksInCache);
+        return Number.isFinite(value) && value > 0 ? value : undefined;
+    }
     resourceNameChanged(oldValue, newValue) {
         if (!oldValue || oldValue === newValue)
             return;
@@ -195,9 +214,12 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
      */
     reloadResourceData(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c;
             this.datasource.destroy();
-            (_a = this.liveUpdatesStream) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            // A block request still in flight was read for the cache being dropped here; its reply must
+            // not be reported as rows the grid holds.
+            (_b = (_a = this.ssrmDatasource) === null || _a === void 0 ? void 0 : _a.invalidatePendingLoads) === null || _b === void 0 ? void 0 : _b.call(_a);
+            (_c = this.liveUpdatesStream) === null || _c === void 0 ? void 0 : _c.unsubscribe();
             this.liveUpdatesStream = undefined;
             // Emit event to cache current filter model before clearing data
             this.$emit(datasourceEventNames.cacheFilterConfig);
@@ -329,20 +351,22 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             yield this.init();
         });
     }
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     clearRowData(withColumnDefs = true) {
         this.rowData = new Map();
-        if (withColumnDefs) {
-            // Emit event to clear column definitions
-            this.$emit(datasourceEventNames.dataCleared, {
-                includeSchema: true,
-            });
-        }
-        this.transactionData = { remove: [] };
+        this.resetTransaction();
+        this.$emit(datasourceEventNames.dataCleared, {
+            includeSchema: Boolean(withColumnDefs),
+        });
         // Emit event to apply server side transaction for removing all data
         this.$emit(datasourceEventNames.applyServerSideTransaction, {
-            transaction: this.transactionData,
+            transaction: { remove: [] },
         });
-        this.transactionData = undefined;
     }
     /**
      * Checks whether the resolved resource can be served through the Server-Side Row Model.
@@ -471,7 +495,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             const rowId = row[this.rowId];
             if (this.previousPollResult.has(rowId)) {
                 const previousRow = this.previousPollResult.get(rowId);
-                if (this.serializer.serialize(previousRow) !== this.serializer.serialize(row)) {
+                if (this.hasRowContentChanged(previousRow, row)) {
                     rowsToUpdate.push(row);
                 }
             }
@@ -492,6 +516,17 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                 removed: rowsToDelete.length,
                 totalInPoll: currentPollMap.size,
             });
+            // The poll has already classified the rows, so report them as they are (the same shape
+            // the client-side model emits: a remove carries just the row id) and keep the held rows
+            // in step so a later block re-read is classified correctly.
+            this.transactionData = {
+                add: rowsToInsert,
+                update: rowsToUpdate,
+                remove: rowsToDelete.map((row) => ({ [this.rowId]: row[this.rowId] })),
+            };
+            [...rowsToInsert, ...rowsToUpdate].forEach((row) => this.rowData.set(row[this.rowId], row));
+            rowsToDelete.forEach((row) => this.rowData.delete(row[this.rowId]));
+            this.emitTransaction(this.transactionData);
             this.$emit(datasourceEventNames.applyServerSideTransaction, {
                 transaction: {
                     add: rowsToInsert,
@@ -514,25 +549,41 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             this.ssrmDatasource.serverRowsCount += netRowChange;
             this.ssrmDatasource.clientRowsCount += netRowChange;
         }
-        this.transactionData = { add: [], remove: [], update: [] };
+        const transaction = this.resetTransaction();
         this.handleStreamInserts(inserts);
         this.handleStreamUpdates(updates);
         this.handleStreamDeletes(deletes);
-        if (this.transactionData.add.length > 0) {
+        // A MODIFY for a row this element has not seen delivered is not reported to consumers (they
+        // do not hold it), but it still goes to the grid, which ignores rows outside its store: the
+        // stream pre-merge above made it a full row, and the grid may hold it from a block loaded
+        // before this element started mirroring deliveries.
+        const gridOnlyUpdates = updates.filter((row) => {
+            const rowId = row === null || row === void 0 ? void 0 : row[this.rowId];
+            return rowId !== undefined && rowId !== null && !this.rowData.has(rowId);
+        });
+        // Consumers hear the change first; the grid transactions below then catch the grid up.
+        this.emitTransaction(transaction);
+        // A consumer's handler may have reloaded or destroyed this datasource synchronously; the
+        // grid is then being purged and the transaction belongs to rows it no longer holds.
+        if (this.transactionData !== transaction) {
+            return;
+        }
+        if (transaction.add.length > 0) {
             this.$emit(datasourceEventNames.applyServerSideTransaction, {
                 transaction: {
                     route: [],
-                    add: this.transactionData.add,
-                    addIndex: this.reverse ? 0 : this.transactionData.addIndex,
+                    add: transaction.add,
+                    addIndex: this.reverse ? 0 : transaction.addIndex,
                 },
             });
         }
-        if (this.transactionData.update.length > 0 || this.transactionData.remove.length > 0) {
+        const gridUpdates = [...transaction.update, ...gridOnlyUpdates];
+        if (gridUpdates.length > 0 || transaction.remove.length > 0) {
             this.$emit(datasourceEventNames.applyServerSideTransaction, {
                 transaction: {
                     route: [],
-                    update: this.transactionData.update,
-                    remove: this.transactionData.remove,
+                    update: gridUpdates,
+                    remove: transaction.remove,
                 },
             });
         }
@@ -611,9 +662,6 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         throw new Error('loadMore() method is not supported for server-side datasource');
     }
 };
-__decorate([
-    JSONSerializer
-], GridProServerSideDatasource.prototype, "serializer", void 0);
 __decorate([
     Datasource
 ], GridProServerSideDatasource.prototype, "pollingDatasource", void 0);

package/dist/esm/datasource/server-side.resource-base.js

@@ -1,6 +1,7 @@
 import { __awaiter, __decorate } from "tslib";
 import { Auth, Connect } from '@genesislcap/foundation-comms';
 import { UUID } from '@genesislcap/foundation-utils';
+import { DeliveredBlockLedger } from './delivered-block.ledger';
 import { convertDateFilterToCriteria, convertNumberFilterToCriteria, convertSetFilterToCriteria, convertTextFilterToCriteria, } from './filter.utils';
 /**
  * Base class for server-side resource datasources used in Grid Pro SSRM implementations.
@@ -11,6 +12,12 @@ import { convertDateFilterToCriteria, convertNumberFilterToCriteria, convertSetF
 export class BaseServerSideDatasource {
     constructor(options) {
         this.rowData = new Map();
+        /**
+         * Bumped whenever the rows the grid holds are dropped (destroy, refresh, reload). A req/rep
+         * reply that resolves for an earlier generation belongs to a cache the grid no longer has.
+         * @internal
+         */
+        this.loadGeneration = 0;
         /**
          * The number of rows in the grid. THIS DO NOT CONSIDER CRITERIA_MATCH scenarios.
          * @internal
@@ -28,6 +35,9 @@ export class BaseServerSideDatasource {
         this.errorHandlerFunc = options.errorHandlerFunc;
         this.onNoDataAvailableFunc = options.onNoDataAvailableFunc;
         this.onDataAvailableFunc = options.onDataAvailableFunc;
+        this.onRowsDeliveredFunc = options.onRowsDeliveredFunc;
+        this.onRowsWithdrawnFunc = options.onRowsWithdrawnFunc;
+        this.onRowsEvictedFunc = options.onRowsEvictedFunc;
         this.resourceName = options.resourceName;
         this.resourceParams = options.resourceParams;
         this.originalCriteriaMatch = this.getResourceParam('CRITERIA_MATCH');
@@ -36,6 +46,7 @@ export class BaseServerSideDatasource {
         this.maxRows = options.maxRows;
         this.maxView = options.maxView;
         this.rowId = options.rowId;
+        this.ledger = new DeliveredBlockLedger(options.rowId, options.maxBlocksInCache);
     }
     /**
      * Gets a resource parameter, handling both REQUEST_SERVER (DETAILS structure) and DATASERVER (flat structure)
@@ -116,6 +127,7 @@ export class BaseServerSideDatasource {
         });
     }
     destroy() {
+        this.invalidatePendingLoads();
         this.rowData = new Map();
         this.clientRowsCount = 0;
         this.calculatedRowsCount = 0;
@@ -125,6 +137,15 @@ export class BaseServerSideDatasource {
         this.sourceRef = undefined;
         this.lastSuccessRowData = undefined;
     }
+    /**
+     * Marks every block request still in flight as stale: the grid is dropping the cache they were
+     * read for, so their replies must not be handed to the host as held rows.
+     * @internal
+     */
+    invalidatePendingLoads() {
+        this.loadGeneration += 1;
+        this.ledger.clear();
+    }
     refreshDatasource(params) {
         return __awaiter(this, void 0, void 0, function* () {
             this.destroy();
@@ -287,6 +308,9 @@ export class BaseServerSideDatasource {
     completeEmptyResult(params) {
         var _a, _b;
         if ((_b = (_a = this.lastSuccessRowData) === null || _a === void 0 ? void 0 : _a.rowData) === null || _b === void 0 ? void 0 : _b.length) {
+            // Re-serving the previous block's snapshot keeps the SSRM request from hanging; it is not a
+            // delivery of new rows, so it is not reported - the snapshot may predate a poll that has
+            // since reported those rows changed or removed.
             params.success(this.lastSuccessRowData);
             return;
         }
@@ -295,6 +319,25 @@ export class BaseServerSideDatasource {
         params.success(successRowData);
         this.notifyNoDataAvailableIfEmpty(params, successRowData);
     }
+    /**
+     * Reports rows handed to the grid for the block at `startRow`, then the rows a re-read of that
+     * block no longer carries and the rows whose block the grid evicted.
+     * @internal
+     */
+    deliverRows(startRow, rows) {
+        var _a, _b, _c;
+        const delivered = rows !== null && rows !== void 0 ? rows : [];
+        const { withdrawnRowIds, evictedRowIds } = this.ledger.record(startRow, delivered);
+        if (delivered.length > 0) {
+            (_a = this.onRowsDeliveredFunc) === null || _a === void 0 ? void 0 : _a.call(this, delivered);
+        }
+        if (withdrawnRowIds.length > 0) {
+            (_b = this.onRowsWithdrawnFunc) === null || _b === void 0 ? void 0 : _b.call(this, withdrawnRowIds);
+        }
+        if (evictedRowIds.length > 0) {
+            (_c = this.onRowsEvictedFunc) === null || _c === void 0 ? void 0 : _c.call(this, evictedRowIds);
+        }
+    }
     /** Invokes `onNoDataAvailableFunc` when the first SSRM block has no rows. @internal */
     notifyNoDataAvailableIfEmpty(params, successRowData) {
         var _a;

package/dist/esm/datasource/server-side.resource-dataserver.js

@@ -9,6 +9,7 @@ import { BaseServerSideDatasource } from './server-side.resource-base';
  */
 export class DataserverServerSideDatasource extends BaseServerSideDatasource {
     constructor(options) {
+        var _a;
         super(options);
         /**
          * Blocks awaiting stream messages. Settled blocks remove themselves; destroy() cancels
@@ -23,7 +24,24 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
          * @internal
          */
         this.deliveredRowCount = 0;
+        /**
+         * Ids of rows the server deleted that stay in the cache because the grid was not told
+         * (`live-updates` off) and they sit below the delivered watermark - see
+         * handleCurrentStreamLoad. They are not reported to the host as rows the grid holds, and
+         * their presence marks the cache out of step, so a re-read purges rather than serves them.
+         * @internal
+         */
+        this.retainedDeletedRowIds = new Set();
+        /**
+         * Set when the cache holds a change the grid's rows do not reflect (a tombstoned DELETE). The
+         * blocks AG Grid holds are still consistent with what it was given, but a re-read of one of
+         * them must not be served from the cache: it would hand back stale content, so the datasource
+         * refreshes instead and the grid re-reads everything from the server.
+         * @internal
+         */
+        this.cacheOutOfStep = false;
         this.createDataserverStreamFunc = options.createDataserverStreamFunc;
+        this.gridReceivesLiveUpdates = (_a = options.gridReceivesLiveUpdates) !== null && _a !== void 0 ? _a : false;
     }
     refreshDatasource(params) {
         const _super = Object.create(null, {
@@ -36,6 +54,8 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.dataserverStreamSubscription = undefined;
             this.dataserverStream = undefined;
             this.deliveredRowCount = 0;
+            this.retainedDeletedRowIds.clear();
+            this.cacheOutOfStep = false;
             yield _super.refreshDatasource.call(this, params);
         });
     }
@@ -69,6 +89,16 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             // when it already covers this block, or the stream ended, no further stream messages
             // will arrive for this request - resolve it synchronously from the cache.
             const blockAlreadyCovered = this.currentSequenceId >= 1 && (this.rowData.size >= blockEndRow || !this.moreRows);
+            // A re-read is the moment the grid asks for current rows. When the cache holds a change the
+            // grid never saw (a DELETE it was not told about), serving the slice would hand back the
+            // deleted row, so refresh instead: the grid drops every block and re-reads from the server.
+            // fail() releases the request slot, as for a superseded filter or sort change above.
+            if (blockAlreadyCovered && this.cacheOutOfStep) {
+                logger.debug(`SSRM block ${blockStartRow}-${blockEndRow} for ${this.resourceName} re-read while the cache is out of step with the grid; refreshing`);
+                yield this.refreshDatasource(params);
+                params.fail();
+                return;
+            }
             if (this.currentSequenceId >= 1 &&
                 !blockAlreadyCovered &&
                 (this.moreRows || params.request.startRow >= Number(this.maxRows))) {
@@ -109,6 +139,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                 successRowData.rowCount = this.getCorrectRowCount(params);
                 this.lastSuccessRowData = successRowData;
                 params.success(successRowData);
+                this.deliverRows(blockStartRow, successRowData.rowData.filter((row) => !this.retainedDeletedRowIds.has(row === null || row === void 0 ? void 0 : row[this.rowId])));
                 this.notifyNoDataAvailableIfEmpty(params, successRowData);
             };
             const failBlock = (timer) => {
@@ -290,6 +321,8 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
             this.dataserverStreamSubscription = undefined;
             this.deliveredRowCount = 0;
+            this.retainedDeletedRowIds.clear();
+            this.cacheOutOfStep = false;
             yield _super.destroy.call(this);
         });
     }
@@ -299,13 +332,31 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             return;
         // Infinite scroll accumulates a session-cumulative cache, as GSF splits batches across
         // messages and later batches append. Map preserves insertion order, so the cache can be
-        // sliced by block range.
-        const rows = new Map(this.rowData);
+        // sliced by block range - which only works while the cache and the grid agree on where
+        // every delivered row sits, so pushed changes below the delivered watermark are mirrored the
+        // way the grid applies them, or deferred to a refresh when the grid is not told.
+        let rows = new Map(this.rowData);
+        // Rows arriving while a block is pending are the page that block asked for and append in
+        // view order. With no block waiting they are a push; the host inserts those at the top of
+        // a live grid (its transaction uses addIndex 0), so the cache puts them there too. (A push
+        // that lands during a page load is indistinguishable from the page and appends.)
+        const pushed = this.pendingBlocks.size === 0 && this.deliveredRowCount > 0;
+        const prepended = new Map();
         (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
-            rows.set(insertData[this.rowId], insertData);
+            const key = insertData[this.rowId];
+            this.retainedDeletedRowIds.delete(key);
+            if (pushed && this.gridReceivesLiveUpdates && !rows.has(key)) {
+                prepended.set(key, insertData);
+                return;
+            }
+            rows.set(key, insertData);
         });
+        if (prepended.size > 0) {
+            rows = new Map([...prepended, ...rows]);
+            this.deliveredRowCount += prepended.size;
+        }
         // Live QUERY_UPDATE messages can arrive while a block is pending: MODIFY rows may be
-        // partial, so merge into the cached row instead of clobbering it; DELETE rows drop out.
+        // partial, so merge into the cached row instead of clobbering it.
         (_b = result.updates) === null || _b === void 0 ? void 0 : _b.forEach((updateData) => {
             const key = updateData === null || updateData === void 0 ? void 0 : updateData[this.rowId];
             if (key === undefined) {
@@ -316,28 +367,37 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         });
         (_c = result.deletes) === null || _c === void 0 ? void 0 : _c.forEach((deleteData) => {
             const key = deleteData === null || deleteData === void 0 ? void 0 : deleteData[this.rowId];
-            if (key === undefined) {
+            if (key === undefined || !rows.has(key)) {
                 return;
             }
-            // Rows already handed to AG Grid sit at fixed absolute indices; removing them from
-            // the cumulative cache would shift slice() offsets for later blocks.
-            if (this.deliveredRowCount > 0) {
-                let index = 0;
-                for (const mapKey of rows.keys()) {
-                    if (mapKey === key) {
-                        if (index < this.deliveredRowCount) {
-                            return;
-                        }
-                        break;
-                    }
-                    index += 1;
+            const index = this.cacheIndexOf(rows, key);
+            if (index < this.deliveredRowCount) {
+                if (!this.gridReceivesLiveUpdates) {
+                    // The grid still shows the row at this index. Dropping it would shift every later
+                    // block's slice against the grid, so keep its slot and let the next re-read refresh.
+                    this.retainedDeletedRowIds.add(key);
+                    this.cacheOutOfStep = true;
+                    return;
                 }
+                // The host's remove transaction re-indexes the grid past this row; follow it.
+                this.deliveredRowCount -= 1;
             }
             rows.delete(key);
         });
         this.clientRowsCount += (_e = (_d = result.inserts) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
         this.rowData = rows;
     }
+    /** Position of a key in the cache's insertion order. @internal */
+    cacheIndexOf(rows, key) {
+        let index = 0;
+        for (const mapKey of rows.keys()) {
+            if (mapKey === key) {
+                return index;
+            }
+            index += 1;
+        }
+        return -1;
+    }
 }
 /**
  * Max time a non-paginated SSRM block may stay pending before the safety valve in

package/dist/esm/datasource/server-side.resource-reqrep.js

@@ -39,6 +39,9 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
     }
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Taken before the first await: a reload that lands anywhere between here and the reply
+            // means the block cache this request was read for is gone.
+            const generation = this.loadGeneration;
             if (yield this.setupFiltering(params)) {
                 params.fail();
                 return;
@@ -54,6 +57,14 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
                 DETAILS: this.buildRequestDetails(),
             };
             const requestResult = yield this.createReqRepRequestFunc(requestParams);
+            // The cache this block was read for was dropped while the request was in flight (a filter,
+            // sort or criteria change): the reply must not be handed to the host as rows the grid holds.
+            // fail() still frees AG Grid's concurrent-request slot; the purge already dropped the block.
+            if (generation !== this.loadGeneration) {
+                logger.debug('SSRM req/rep reply discarded: the block cache was reset while it was in flight');
+                params.fail();
+                return;
+            }
             // Apply the result to the grid
             this.applyServerSideData(params, requestResult);
             // If polling enabled, schedule stream creation after user stops scrolling
@@ -117,6 +128,7 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         successRowData.rowCount = this.getCorrectRowCount(params);
         this.lastSuccessRowData = successRowData;
         params.success(successRowData);
+        this.deliverRows(params.request.startRow, successRowData.rowData);
         this.notifyNoDataAvailableIfEmpty(params, successRowData);
     }
     getCorrectRowCount(params) {