@genesislcap/grid-pro 15.30.0 → 15.30.1

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

@@ -1,11 +1,12 @@
 import { __awaiter, __decorate } from "tslib";
-import { dataServerResultFilter, Datasource, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
-import { JSONSerializer, LifecycleMixin } from '@genesislcap/foundation-utils';
+import { Datasource, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
+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';
 import { logger } from '../utils';
 import { GridProBaseDatasource } from './base.datasource';
+import { filterDataserverResult } from './dataserver-result.filter';
 import { getFilterByFieldType, getServerSideFilterParamsByFieldType, } from './server-side.grid-definitions';
 import { DataserverServerSideDatasource } from './server-side.resource-dataserver';
 import { ReqRepServerSideDatasource } from './server-side.resource-reqrep';
@@ -30,7 +31,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 +42,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 +92,8 @@ 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),
                     resourceName: this.resourceName,
                     resourceParams: this.datasource.requestOnlyParams,
                     resourceIndexes: this.indexes,
@@ -107,6 +110,8 @@ 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),
                     resourceName: this.resourceName,
                     resourceParams: this.datasource.dataserverOnlyParams,
                     resourceIndexes: this.indexes,
@@ -195,9 +200,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 +337,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 +481,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 +502,31 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                 removed: rowsToDelete.length,
                 totalInPoll: currentPollMap.size,
             });
+            // The poll has already classified the rows against the previous poll, so re-classify the
+            // inserts against the rows actually held: a row shifted into the polled page from a block
+            // above is new to the poll but not to the grid, and reporting it as `add` would duplicate
+            // it for consumers.
+            const transaction = this.resetTransaction();
+            rowsToInsert.forEach((row) => {
+                const rowId = row[this.rowId];
+                const known = this.rowData.get(rowId);
+                if (!known) {
+                    transaction.add.push(row);
+                }
+                else if (this.hasRowContentChanged(known, row)) {
+                    transaction.update.push(row);
+                }
+            });
+            transaction.update.push(...rowsToUpdate);
+            transaction.remove.push(...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(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;
+            }
             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,
                 },
             });
         }
@@ -563,9 +614,12 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     // a complete row — without this, unchanged columns are cleared on every update.
                     const rowData = this.ssrmDatasource.rowData;
                     const mergedRows = normalizedRows.map((row) => {
-                        var _a;
+                        var _a, _b;
                         const details = (_a = row.DETAILS) !== null && _a !== void 0 ? _a : {};
-                        const rowRef = details[this.rowId];
+                        // Genesis keys pushes by the default id. Under a custom `row-id` DETAILS carries no
+                        // custom id at all, so fall back to the held row that carries this ROW_REF.
+                        const defaultRowId = this.defaultRowIdByResourceType;
+                        const rowRef = ((_b = details[this.rowId]) !== null && _b !== void 0 ? _b : this.resolveRowId(Object.assign(Object.assign({}, row), { [defaultRowId]: details[defaultRowId] })));
                         const existingRow = rowRef != null ? rowData === null || rowData === void 0 ? void 0 : rowData.get(rowRef) : undefined;
                         if (!existingRow)
                             return row;
@@ -577,7 +631,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                         return Object.assign(Object.assign({}, merged), { DETAILS: details });
                     });
                     const normalizedMessage = Object.assign(Object.assign({}, rawMessage), { ROW: mergedRows });
-                    const nextMessage = dataServerResultFilter(normalizedMessage, this.rowId);
+                    const nextMessage = filterDataserverResult(normalizedMessage, this.rowId);
                     this.applyLiveServerSideUpdate(nextMessage);
                 });
                 const onError = (error) => {
@@ -611,9 +665,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,8 @@ export class BaseServerSideDatasource {
         this.errorHandlerFunc = options.errorHandlerFunc;
         this.onNoDataAvailableFunc = options.onNoDataAvailableFunc;
         this.onDataAvailableFunc = options.onDataAvailableFunc;
+        this.onRowsDeliveredFunc = options.onRowsDeliveredFunc;
+        this.onRowsWithdrawnFunc = options.onRowsWithdrawnFunc;
         this.resourceName = options.resourceName;
         this.resourceParams = options.resourceParams;
         this.originalCriteriaMatch = this.getResourceParam('CRITERIA_MATCH');
@@ -36,6 +45,7 @@ export class BaseServerSideDatasource {
         this.maxRows = options.maxRows;
         this.maxView = options.maxView;
         this.rowId = options.rowId;
+        this.ledger = new DeliveredBlockLedger(options.rowId);
     }
     /**
      * Gets a resource parameter, handling both REQUEST_SERVER (DETAILS structure) and DATASERVER (flat structure)
@@ -116,6 +126,7 @@ export class BaseServerSideDatasource {
         });
     }
     destroy() {
+        this.invalidatePendingLoads();
         this.rowData = new Map();
         this.clientRowsCount = 0;
         this.calculatedRowsCount = 0;
@@ -125,6 +136,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 +307,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 +318,22 @@ 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;
+        const delivered = rows !== null && rows !== void 0 ? rows : [];
+        const { withdrawnRowIds } = 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);
+        }
+    }
     /** 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

@@ -1,13 +1,24 @@
 import { __awaiter } from "tslib";
-import { MessageType, dataServerResultFilter, logger, } from '@genesislcap/foundation-comms';
+import { MessageType, logger, } from '@genesislcap/foundation-comms';
 import { DOM } from '@microsoft/fast-element';
 import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
+import { filterDataserverResult } from './dataserver-result.filter';
 import { BaseServerSideDatasource } from './server-side.resource-base';
 /**
  * The DATASERVER IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
  * @beta
  */
 export class DataserverServerSideDatasource extends BaseServerSideDatasource {
+    /**
+     * Whether the cache holds a change the grid's rows do not reflect (a tombstoned DELETE), in
+     * which case a block must not be served from it: the slice would hand back a deleted row.
+     * @remarks Derived rather than a flag of its own, so an INSERT that brings a tombstoned id
+     * back clears it along with the tombstone instead of leaving the cache marked stale forever.
+     * @internal
+     */
+    get cacheOutOfStep() {
+        return this.retainedDeletedRowIds.size > 0 || this.structuralPushPending;
+    }
     constructor(options) {
         super(options);
         /**
@@ -23,6 +34,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 a pushed INSERT landed after rows were handed to the grid, so the cache's insertion
+         * order no longer matches the grid's row indices. Cleared when the cache is rebuilt.
+         * @internal
+         */
+        this.structuralPushPending = false;
+        /** Whether the first batch of the current subscription has arrived. @internal */
+        this.streamStarted = false;
+        /** Whether a MORE_ROWS request is awaiting its batch. @internal */
+        this.moreRowsInFlight = false;
         this.createDataserverStreamFunc = options.createDataserverStreamFunc;
     }
     refreshDatasource(params) {
@@ -36,6 +65,10 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.dataserverStreamSubscription = undefined;
             this.dataserverStream = undefined;
             this.deliveredRowCount = 0;
+            this.retainedDeletedRowIds.clear();
+            this.structuralPushPending = false;
+            this.streamStarted = false;
+            this.moreRowsInFlight = false;
             yield _super.refreshDatasource.call(this, params);
         });
     }
@@ -69,6 +102,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))) {
@@ -76,6 +119,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     ? Number(this.resourceParams.VIEW_NUMBER)
                     : 0;
                 if (Number.isFinite(viewNumber)) {
+                    this.moreRowsInFlight = true;
                     this.connect.getMoreRows(this.sourceRef, viewNumber);
                 }
             }
@@ -109,6 +153,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) => {
@@ -191,7 +236,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
      * @internal
      */
     dispatchStreamMessage(dataserverResult) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const messageType = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MESSAGE_TYPE;
         if (messageType &&
             (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
@@ -204,13 +249,28 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.moreRows = dataserverResult.MORE_ROWS;
         }
         if (dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) {
-            const nextMessage = dataServerResultFilter(dataserverResult, this.rowId);
-            this.handleCurrentStreamLoad(nextMessage);
+            const nextMessage = filterDataserverResult(dataserverResult, this.rowId);
+            // A DATASERVER subscription is live by definition, so every batch is either the page a
+            // block asked for or a change the server pushed. Replies only ever carry view rows
+            // (INSERTs), so a batch holding a MODIFY or a DELETE is a push whenever it arrives.
+            // Otherwise the batch is the reply we are waiting on: a request is outstanding
+            // (`moreRowsInFlight`), a block is pending, or this is the logon batch.
+            //
+            // `pendingBlocks.size === 0` alone is not enough: the 10s safety valve settles a block
+            // short while its MORE_ROWS is still outstanding, and GSF splits one reply across
+            // messages, so the real page can arrive with no block waiting. Treating that as a push
+            // prepended it to the cache and shifted every later block's slice against the grid.
+            const carriesPushedChanges = ((_b = (_a = nextMessage.updates) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 || ((_d = (_c = nextMessage.deletes) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+            const solicited = !carriesPushedChanges &&
+                (this.moreRowsInFlight || this.pendingBlocks.size > 0 || !this.streamStarted);
+            this.moreRowsInFlight = false;
+            this.streamStarted = true;
+            this.handleCurrentStreamLoad(nextMessage, solicited);
             this.currentSequenceId = dataserverResult.SEQUENCE_ID;
             if (this.currentSequenceId === 1) {
                 this.sourceRef = dataserverResult.SOURCE_REF;
                 if (this.serverRowsCount === 0) {
-                    this.serverRowsCount = (_a = dataserverResult.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+                    this.serverRowsCount = (_e = dataserverResult.ROWS_COUNT) !== null && _e !== void 0 ? _e : this.rowData.size;
                 }
             }
         }
@@ -290,22 +350,40 @@ 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.structuralPushPending = false;
+            this.streamStarted = false;
+            this.moreRowsInFlight = false;
             yield _super.destroy.call(this);
         });
     }
-    handleCurrentStreamLoad(result) {
+    handleCurrentStreamLoad(result, solicited) {
         var _a, _b, _c, _d, _e;
         if (!result)
             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.
+        // sliced by block range - which only works while the cache and the grid agree on where
+        // every delivered row sits, so a pushed change below the delivered watermark is kept out of
+        // the delivered region and deferred to a refresh.
         const rows = new Map(this.rowData);
         (_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);
+            // A key the cache already holds keeps its slot, so nothing shifts - that is how a DELETE
+            // that was tombstoned and then re-inserted puts the cache back in step with the grid.
+            const isNewToCache = !rows.has(key);
+            rows.set(key, insertData);
+            if (!solicited && isNewToCache && this.deliveredRowCount > 0) {
+                // A page appends in view order, so it keeps the cache and the grid aligned. A push does
+                // not: nothing in the batch says where the server sorts the new row, and the host puts
+                // it at the top of a live grid, so from here on the cache cannot be sliced against the
+                // grid's indices. Mark it, and let the next read of a covered block refresh instead.
+                this.structuralPushPending = true;
+            }
         });
         // 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 +394,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) {
+                // 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.
+                //
+                // Whether the host also removed it from the grid is not knowable here: the host applies
+                // live updates from a second, independent DATA_LOGON whose view is not paged with this
+                // one, so a delete this stream sees need not have reached the grid at all. Keeping the
+                // slot is correct either way - the refresh reconciles both.
+                this.retainedDeletedRowIds.add(key);
+                return;
             }
             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,13 +128,18 @@ 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) {
         let rowCount;
         if (this.moreRows) {
-            // More data available, return -1 to indicate unknown total
-            rowCount = -1;
+            // More data may follow, so the total is not known yet. It has to be left undefined:
+            // `rowCount` is a row count, not the infinite row model's `lastRow`, so -1 is taken
+            // literally. A store told it holds -1 rows never reaches the block it just received,
+            // so AG Grid asks for the same blocks again as fast as it can - a request loop that
+            // pins the main thread and floods the server with REQUEST_SERVER snapshots.
+            rowCount = undefined;
         }
         else {
             // Use discovered total if available, otherwise calculate from current position
@@ -281,7 +297,13 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         return {
             CRITERIA_MATCH: this.resourceParams.DETAILS.CRITERIA_MATCH,
             MAX_ROWS: this.resourceParams.DETAILS.MAX_ROWS,
-            ORDER_BY: this.resourceParams.DETAILS.ORDER_BY,
+            // Fall back to the row id when the user has not sorted, as the infinite datasource does.
+            // OFFSET paging is only correct over a stable order: an unsorted req/rep returns rows in
+            // an unspecified order that differs between requests, so consecutive pages overlap and
+            // skip. AG Grid then receives the same row id in two blocks, refuses the store it just
+            // built, and re-requests both blocks - a loop that runs as fast as the server can answer.
+            // The row id is unique and always sortable, giving every page a deterministic window.
+            ORDER_BY: this.resourceParams.DETAILS.ORDER_BY || `${this.rowId} ASC`,
             OFFSET: this.resourceParams.DETAILS.OFFSET,
         };
     }

package/dist/esm/grid-pro-beta.js

@@ -484,11 +484,25 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     handleDataChanged(event) {
         const { changes } = event.detail;
-        if (!this.gridApi)
+        // Every datasource emits this for consumers, but only the client-side row model takes row
+        // transactions: the infinite and server-side datasources drive the grid through
+        // refresh-infinite-cache / apply-server-side-transaction, and applyTransaction on those
+        // models is a no-op that logs an AG Grid warning per event.
+        if (!this.gridApi || !this.isClientSideRowModel)
             return;
         const result = this.gridApi.applyTransaction(changes);
         this.flashAddedCells(result === null || result === void 0 ? void 0 : result.add);
     }
+    /**
+     * Whether the live grid runs AG Grid's client-side row model (the default when the datasource
+     * set no `rowModelType`).
+     * @internal
+     */
+    get isClientSideRowModel() {
+        var _a, _b, _c;
+        const rowModelType = (_c = (_b = (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.getGridOption) === null || _b === void 0 ? void 0 : _b.call(_a, 'rowModelType')) !== null && _c !== void 0 ? _c : 'clientSide';
+        return rowModelType === 'clientSide';
+    }
     flashAddedCells(rowNodes) {
         if (this.enableRowFlashing && (rowNodes === null || rowNodes === void 0 ? void 0 : rowNodes.length)) {
             this.gridApi.flashCells({ rowNodes });
@@ -601,7 +615,11 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         if (includeSchema) {
             this.gridApi.setGridOption('columnDefs', []);
         }
-        this.gridApi.setGridOption('rowData', []);
+        // rowData belongs to the client-side row model; the infinite and server-side caches are
+        // cleared by their own refresh / transaction events.
+        if (this.isClientSideRowModel) {
+            this.gridApi.setGridOption('rowData', []);
+        }
         this.gridApi.refreshCells({ force: true });
     }
     /**