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

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) {

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

@@ -461,11 +461,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 });
@@ -578,7 +592,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 });
     }
     /**

package/dist/esm/grid-pro.js

@@ -414,7 +414,10 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     handleDataChanged(event) {
         var _a, _b, _c;
         const { changes } = event.detail;
-        if (!this.gridApi)
+        // Every datasource emits this for consumers, but row transactions are a client-side row
+        // model API: the server-side datasource drives the grid through apply-server-side-transaction,
+        // and applyTransaction on that model is a no-op that logs an AG Grid warning per event.
+        if (!this.gridApi || this.isServerSide)
             return;
         if (((_a = changes.add) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             if (this.asyncAdd) {

package/dist/grid-pro.api.json

@@ -4497,7 +4497,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "{\n        add?: any[];\n        remove?: any[];\n        update?: any[];\n        insertIndex?: number;\n    }"
+                  "text": "{\n        add?: any[];\n        remove?: any[];\n        update?: any[];\n        addIndex?: number;\n        insertIndex?: number;\n    }"
                 },
                 {
                   "kind": "Content",
@@ -17160,6 +17160,37 @@
               "isProtected": false,
               "isAbstract": false
             },
+            {
+              "kind": "Property",
+              "canonicalReference": "@genesislcap/grid-pro!GridProBaseDatasource#serializer:member",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "serializer: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "JSONSerializer",
+                  "canonicalReference": "@genesislcap/foundation-utils!JSONSerializer:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "serializer",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isStatic": false,
+              "isProtected": false,
+              "isAbstract": false
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/grid-pro!GridProBaseDatasource#setDisconnected:member(1)",
@@ -22864,7 +22895,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/grid-pro!GridProInfiniteDatasource:class",
-          "docComment": "/**\n * A Genesis Datasource element for AG Grid's Infinite Row Model.\n *\n * @remarks\n *\n * The Infinite Row Model is part of AG Grid Community (free) and provides: - Lazy loading of data as user scrolls - Server-side sorting and filtering - Simple infinite scroll without grouping/aggregation - Live updates for DATASERVER resources: the DATA_LOGON stream the grid pages over pushes every change, so no flag or second subscription is needed\n *\n * REQUEST_SERVER resources are read on demand only - a change on the server shows up when the grid re-reads (scroll, filter/sort change, or an explicit refresh), not live. The exception is a write made through this session: a commit ACK for an event listed in `pollTriggerEvents` re-reads the loaded blocks, so entity-management CRUD is reflected immediately.\n *\n * Like the other datasources, consumer options passed as `deferredGridOptions` (including via entity-management's `gridOptions` with `datasource-type=\"infinite\"`) are merged over this element's defaults in `init()`.\n *\n * Use this instead of Server-Side Row Model when you don't need Enterprise features like row grouping, aggregation, or pivoting.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the infinite grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`\n *\n * @fires\n *\n * refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * datasource-data-cleared - Fired when infinite row data is cleared. detail: `DataClearedEventDetail`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @see\n *\n * https://www.ag-grid.com/javascript-data-grid/infinite-scrolling/\n *\n * @beta\n */\n",
+          "docComment": "/**\n * A Genesis Datasource element for AG Grid's Infinite Row Model.\n *\n * @remarks\n *\n * The Infinite Row Model is part of AG Grid Community (free) and provides: - Lazy loading of data as user scrolls - Server-side sorting and filtering - Simple infinite scroll without grouping/aggregation - Live updates for DATASERVER resources: the DATA_LOGON stream the grid pages over pushes every change, so no flag or second subscription is needed\n *\n * REQUEST_SERVER resources are read on demand only - a change on the server shows up when the grid re-reads (scroll, filter/sort change, or an explicit refresh), not live. The exception is a write made through this session: a commit ACK for an event listed in `pollTriggerEvents` re-reads the loaded blocks, so entity-management CRUD is reflected immediately.\n *\n * Like the other datasources, consumer options passed as `deferredGridOptions` (including via entity-management's `gridOptions` with `datasource-type=\"infinite\"`) are merged over this element's defaults in `init()`.\n *\n * Use this instead of Server-Side Row Model when you don't need Enterprise features like row grouping, aggregation, or pivoting.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the infinite grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * datasource-data-changed - Fired when rows are delivered to the grid, a DATASERVER push changes them, or a re-read no longer returns them; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`\n *\n * @fires\n *\n * set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`\n *\n * @fires\n *\n * refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * 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`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @see\n *\n * https://www.ag-grid.com/javascript-data-grid/infinite-scrolling/\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -23706,7 +23737,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/grid-pro!GridProServerSideDatasource:class",
-          "docComment": "/**\n * A Genesis Datasource element, for server-side | SSRM-compatible data fetching and used exclusively by the GridPro element.\n *\n * @remarks\n *\n * Only supports Server-Side Row Model. Requires `@ag-grid-enterprise/server-side-row-model` setup and valid AG Grid Enterprise license.\n *\n * **Supported resources**: DATASERVER resources, and REQUEST_SERVER (req/rep) resources that declare `criteriaOnlyRequest`. A req/rep resource without it reports a `resource-type` error and no datasource is attached to the grid.\n *\n * **Custom Sort Indicators**: This datasource automatically applies custom sort indicators that are always visible (instead of only on hover). Sortable columns will show a subtle sort icon even when not sorted, and active sort indicators will be more prominent. The custom styling uses AG Grid's native icon font for consistency with the grid theme.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes\n *\n * @fires\n *\n * datasource-no-data-available - Fired when loading finishes with an empty row set\n *\n * @fires\n *\n * datasource-data-changed - Fired when row data changes from applied stream transactions. detail: `DataChangedEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`\n *\n * @fires\n *\n * set-server-side-datasource - Fired to attach or clear the server-side row model datasource\n *\n * @fires\n *\n * datasource-loading-started - Fired when a server-side load cycle starts\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (e.g. server-side styling). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove a CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off server-side grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the server-side grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @fires\n *\n * datasource-data-cleared - Fired when server-side row data is cleared. detail: `DataClearedEventDetail`\n *\n * @fires\n *\n * apply-server-side-transaction - Fired to apply a server-side row transaction\n *\n * @fires\n *\n * datasource-ready - Fired when the host grid is ready to start loading data\n *\n * @beta\n */\n",
+          "docComment": "/**\n * A Genesis Datasource element, for server-side | SSRM-compatible data fetching and used exclusively by the GridPro element.\n *\n * @remarks\n *\n * Only supports Server-Side Row Model. Requires `@ag-grid-enterprise/server-side-row-model` setup and valid AG Grid Enterprise license.\n *\n * **Supported resources**: DATASERVER resources, and REQUEST_SERVER (req/rep) resources that declare `criteriaOnlyRequest`. A req/rep resource without it reports a `resource-type` error and no datasource is attached to the grid.\n *\n * **Custom Sort Indicators**: This datasource automatically applies custom sort indicators that are always visible (instead of only on hover). Sortable columns will show a subtle sort icon even when not sorted, and active sort indicators will be more prominent. The custom styling uses AG Grid's native icon font for consistency with the grid theme.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes\n *\n * @fires\n *\n * datasource-no-data-available - Fired when loading finishes with an empty row set\n *\n * @fires\n *\n * 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`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`\n *\n * @fires\n *\n * set-server-side-datasource - Fired to attach or clear the server-side row model datasource\n *\n * @fires\n *\n * datasource-loading-started - Fired when a server-side load cycle starts\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (e.g. server-side styling). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove a CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off server-side grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the server-side grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @fires\n *\n * 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`\n *\n * @fires\n *\n * apply-server-side-transaction - Fired to apply a server-side row transaction\n *\n * @fires\n *\n * datasource-ready - Fired when the host grid is ready to start loading data\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -24233,37 +24264,6 @@
               "isOptional": false,
               "isAbstract": false,
               "name": "restart"
-            },
-            {
-              "kind": "Property",
-              "canonicalReference": "@genesislcap/grid-pro!GridProServerSideDatasource#serializer:member",
-              "docComment": "",
-              "excerptTokens": [
-                {
-                  "kind": "Content",
-                  "text": "serializer: "
-                },
-                {
-                  "kind": "Reference",
-                  "text": "JSONSerializer",
-                  "canonicalReference": "@genesislcap/foundation-utils!JSONSerializer:interface"
-                },
-                {
-                  "kind": "Content",
-                  "text": ";"
-                }
-              ],
-              "isReadonly": false,
-              "isOptional": false,
-              "releaseTag": "Beta",
-              "name": "serializer",
-              "propertyTypeTokenRange": {
-                "startIndex": 1,
-                "endIndex": 2
-              },
-              "isStatic": false,
-              "isProtected": false,
-              "isAbstract": false
             }
           ],
           "extendsTokenRange": {
@@ -33344,7 +33344,7 @@
             },
             {
               "kind": "Content",
-              "text": "<void>;\n    errorHandlerFunc?: (message: string, type: string) => void;\n    onNoDataAvailableFunc?: () => void;\n    onDataAvailableFunc?: () => void;\n    resourceName: string;\n    resourceParams?: "
+              "text": "<void>;\n    errorHandlerFunc?: (message: string, type: string) => void;\n    onNoDataAvailableFunc?: () => void;\n    onDataAvailableFunc?: () => void;\n    onRowsDeliveredFunc?: (rows: any[]) => void;\n    onRowsWithdrawnFunc?: (rowIds: string[]) => void;\n    onRowsEvictedFunc?: (rowIds: string[]) => void;\n    maxBlocksInCache?: number;\n    gridReceivesLiveUpdates?: boolean;\n    resourceName: string;\n    resourceParams?: "
             },
             {
               "kind": "Reference",

package/dist/grid-pro.d.ts

@@ -825,8 +825,12 @@ export declare const csvExportParams: CsvExportParams;
 export declare interface DataChangedEventDetail {
     changes: {
         add?: any[];
+        /** Row-id-only objects (`{ [rowId]: id }`) for the rows that left the grid. */
         remove?: any[];
         update?: any[];
+        /** Where `add` rows were inserted, as AG Grid's `RowDataTransaction.addIndex`. */
+        addIndex?: number;
+        /** @deprecated Never populated; the emitted field is `addIndex`. */
         insertIndex?: number;
     };
 }
@@ -2001,12 +2005,7 @@ declare const GenesisGridDatasourceElement_base: new () => {
     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options
-    /**
-    * Optional parameter that allows you to select a subset of fields from the query if the client is not interested in receiving all of them.
-    * @remarks DATASERVER only.
-    */
-    ?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     readonly attributes: NamedNodeMap;
     get classList(): DOMTokenList;
     set classList(value: string): any;
@@ -2071,7 +2070,15 @@ declare const GenesisGridDatasourceElement_base: new () => {
     removeAttribute(qualifiedName: string): void;
     removeAttributeNS(namespace: string | null, localName: string): void;
     removeAttributeNode(attr: Attr): Attr;
-    requestFullscreen(options?: FullscreenOptions): Promise<void>;
+    requestFullscreen(options
+    /**
+    * Returns whether the `row-id` attribute is the default one, depending on the resource type.
+    * @internal
+    */
+    ? /**
+    * Returns whether the `row-id` attribute is the default one, depending on the resource type.
+    * @internal
+    */: FullscreenOptions): Promise<void>;
     requestPointerLock(options?: PointerLockOptions): Promise<void>;
     scroll(options?: ScrollToOptions): void;
     scroll(x: number, y: number): void;
@@ -2352,17 +2359,57 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * Called when an unsolicited batch changes which rows exist or their order (an INSERT or a
      * DELETE). The cache cannot be patched in place for those - a created row arrives at the end
      * rather than in sort position, and a delete below the delivered watermark is skipped to keep
-     * slice offsets stable - so the rows have to be re-read.
+     * slice offsets stable - so the rows have to be re-read. Receives the pushed change so the
+     * host can report it before the re-read.
      * @internal
      */
     private onRowsInvalidatedFunc?;
     /**
      * Called when an unsolicited batch only modified rows already held. The cache is patched in
-     * place, so the grid just needs to re-render its blocks.
+     * place, so the grid just needs to re-render its blocks. Receives the pushed change so the
+     * host can report it.
      * @internal
      */
     private onRowsUpdatedFunc?;
+    /**
+     * Called with the rows just handed to AG Grid for a block, on either transport. This is the
+     * only point at which rows leave the datasource, so it is where the host learns which rows
+     * the grid holds (a re-read after a refresh delivers the same rows again).
+     * @internal
+     */
+    private onRowsDeliveredFunc?;
+    /**
+     * Called with the ids of rows a re-read of a block no longer returned: they left the grid
+     * (deleted on the server, or moved into a block that reports them again).
+     * @internal
+     */
+    private onRowsWithdrawnFunc?;
+    /**
+     * Called with the ids of rows whose block the grid evicted from its cache (`maxBlocksInCache`),
+     * so the host stops treating them as held.
+     * @internal
+     */
+    private onRowsEvictedFunc?;
+    /**
+     * Called when a filter or sort change drops every row the grid held, on either transport, so
+     * the host forgets them too. AG Grid purges its own cache on those changes.
+     * @internal
+     */
+    private onRowCacheResetFunc?;
     private errorHandlerFunc;
+    /** Which rows each delivered block carried, for withdrawal and eviction reporting. @internal */
+    private ledger;
+    /**
+     * Bumped whenever the rows this datasource was reading for are dropped (a teardown, or a
+     * filter/sort change). A REQUEST_SERVER reply that resolves for an earlier generation was read
+     * for a cache the grid no longer has.
+     * @remarks Deliberately a generation rather than a "destroyed" flag: AG Grid calls `destroy()`
+     * on the datasource bean it then keeps using (`InfiniteRowModel.start()` re-applies the
+     * `datasource` grid option, and `setDatasource` destroys the previous one first), so a sticky
+     * flag would disable the instance the grid is still driving.
+     * @internal
+     */
+    private loadGeneration;
     /**
      * Max time a DATASERVER block may stay pending before the safety valve resolves it with the
      * rows accumulated so far.
@@ -2385,8 +2432,10 @@ declare class GenesisInfiniteDatasource implements IDatasource {
     private dataserverStreamSubscription;
     private sourceRef;
     /**
-     * Identifies the CRITERIA_MATCH/ORDER_BY the current subscription was opened with; a change
-     * means the subscription has to be re-opened, as those are DATA_LOGON parameters.
+     * Identifies the CRITERIA_MATCH/ORDER_BY the current rows were read with. A change means AG
+     * Grid has dropped every block (it purges on filter/sort changes): on DATASERVER the
+     * subscription has to be re-opened, as those are DATA_LOGON parameters, and on both transports
+     * the host is told its held rows are gone.
      * @internal
      */
     private subscriptionKey;
@@ -2424,14 +2473,20 @@ declare class GenesisInfiniteDatasource implements IDatasource {
         createSnapshotFunc: (params?: any) => Promise<RequestServerResult | FilteredDataServerResult>;
         createDataserverStreamFunc?: (params?: any) => SocketObservable<FilteredDataServerResult>;
         getMoreRowsFunc?: (sourceRef: string) => Promise<unknown>;
-        onRowsInvalidatedFunc?: () => void;
-        onRowsUpdatedFunc?: () => void;
+        onRowsInvalidatedFunc?: (change: FilteredDataServerResult) => void;
+        onRowsUpdatedFunc?: (change: FilteredDataServerResult) => void;
+        onRowsDeliveredFunc?: (rows: any[]) => void;
+        onRowsWithdrawnFunc?: (rowIds: string[]) => void;
+        onRowsEvictedFunc?: (rowIds: string[]) => void;
+        onRowCacheResetFunc?: () => void;
         errorHandlerFunc: (message: string, type: string) => void;
         resourceName: string;
         resourceParams: any;
         resourceIndexes: Map<string, string[]>;
         resourceColDefs: MetadataDetail[];
         maxRows: number;
+        /** AG Grid's `maxBlocksInCache`, so eviction can be mirrored; unset keeps every block. */
+        maxBlocksInCache?: number;
         rowId: string;
         baseCriteria?: string;
         isRequestServer: boolean;
@@ -2468,6 +2523,14 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * 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
+     */
+    private noteRequestKey;
     private getDataserverRows;
     /**
      * Keeps pulling batches while blocks are still waiting.
@@ -2516,6 +2579,12 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * @internal
      */
     private settleBlock;
+    /**
+     * 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
+     */
+    private deliverRows;
     /**
      * Warns when the view filled up before the data ran out.
      * @remarks The server stops sending at MAX_VIEW rows and reports MORE_ROWS false, which is
@@ -2541,6 +2610,13 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * @internal
      */
     private teardownDataserverSubscription;
+    /**
+     * Drops the subscription and the cached rows.
+     * @remarks AG Grid calls this on the bean it then keeps using (`InfiniteRowModel.start()`
+     * re-applies the `datasource` grid option, and `setDatasource` destroys the previous one
+     * first), and it can land while a block request is in flight. So it must leave the datasource
+     * able to serve that reply and the next `getRows`: it drops the subscription, not the instance.
+     */
     destroy?(): void;
 }
 
@@ -3606,19 +3682,78 @@ declare const GridPro_base: (new (...args: any[]) => {
 }) & typeof FoundationElement;
 
 export declare class GridProBaseDatasource extends GenesisGridDatasourceElement {
+    serializer: JSONSerializer;
     protected dataSubWasLoggedOff: boolean;
     keepColDefsOnClearRowData: boolean;
     rowData: Map<string, any>;
     protected transactionData: TransactionData;
+    /** So rows without a row id are warned about once per element, not once per block. @internal */
+    private missingRowIdWarned;
     protected connectionSub: Subscription | undefined;
     protected subscribeToConnection(): void;
     protected unsubscribeFromConnection(): void;
     protected generateColumnDefsFromMetadata(fieldsMetadata: FieldMetadata[], getFilterParamsByFieldType: (field: FieldMetadata) => ColDef['filterParams'] | any, getFilterByFieldType: (type: FieldTypeEnum) => string): ColDef[];
     protected handleStreamInserts(insertedRows: any[], addIndex?: number): void;
+    /**
+     * Resolves the id of the held row a stream row refers to.
+     * @remarks Under a custom `row-id` a DATASERVER push may carry only the default id
+     * (`ROW_REF`), so the held row with that default id supplies the custom one. Returns
+     * `undefined` when neither id is present - callers skip the row rather than matching
+     * `undefined === undefined` against the first held row.
+     * @internal
+     */
+    protected resolveRowId(row: any): string | undefined;
     protected handleStreamDeletes(deletedRows: any[]): void;
     protected handleStreamUpdates(updatedRows: any[]): void;
     protected applyAllTransactions(): void;
     private applyMappedTransaction;
+    /**
+     * Reports rows a block-based row model (server-side, infinite) has just handed to the grid.
+     * Rows not held before are reported as `add`; rows already held (a block re-read after a
+     * refresh, or a req/rep re-read after a commit or poll) are reported as `update` only when
+     * their content changed, so a plain re-read is silent.
+     * @remarks `rowData` mirrors the rows the grid holds: the resource reports rows a re-read no
+     * longer returned (`reportWithdrawnRows`) and blocks the grid evicted from its cache
+     * (`forgetRows`), and `clearRowData` empties it when the grid drops its cache.
+     * @internal
+     */
+    protected reportDeliveredRows(rows: any[]): void;
+    /**
+     * Reports rows a block re-read no longer returned: they left the grid (deleted on the server,
+     * or moved into a block that reports them again). Rows already reported removed - a DATASERVER
+     * push, say - are skipped.
+     * @internal
+     */
+    protected reportWithdrawnRows(rowIds: string[]): void;
+    /**
+     * Forgets rows the grid evicted from its block cache. They still exist on the server, so
+     * nothing is emitted; a later re-read reports them as `add`, as the grid did not hold them.
+     * @internal
+     */
+    protected forgetRows(rowIds: string[]): void;
+    /**
+     * Starts a fresh transaction and returns it, so a caller can keep working on the object it
+     * built even if a consumer's `datasource-data-changed` handler resets the element meanwhile.
+     * @internal
+     */
+    protected resetTransaction(): TransactionData & {
+        add: any[];
+        remove: any[];
+        update: any[];
+    };
+    /**
+     * Whether two versions of a row differ in content. Identity and a key-order-insensitive
+     * field comparison come first, so a re-read of unchanged rows costs no serialization; nested
+     * values fall back to the serializer.
+     * @internal
+     */
+    protected hasRowContentChanged(known: any, row: any): boolean;
+    /** Emits `datasource-data-changed` for `transaction` when it is non-empty. @internal */
+    protected emitTransaction(transaction: TransactionData | undefined): void;
+    /** Emits `datasource-data-changed` for the current transaction when it is non-empty. @internal */
+    protected emitPendingTransaction(): void;
+    /** @internal */
+    private warnMissingRowIdOnce;
     /**
      * Builds the index map used for server-side sorting from the resource's metadata.
      * @remarks Real DATASERVER indexes keep their names; when the resource also (or only) reports
@@ -3863,6 +3998,12 @@ export declare class GridProBeta extends GridProBeta_base {
      * @internal
      */
     private handleDataChanged;
+    /**
+     * Whether the live grid runs AG Grid's client-side row model (the default when the datasource
+     * set no `rowModelType`).
+     * @internal
+     */
+    private get isClientSideRowModel();
     private flashAddedCells;
     /**
      * Handles schema updates from datasource
@@ -5746,12 +5887,13 @@ export declare const gridProGenesisDatasourceEventNames: {
  * @fires datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`
  * @fires datasource-init - Fired when the infinite grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a DATASERVER push changes them, or a re-read no longer returns them; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`
  * @fires refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`
  * @fires add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`
  * @fires remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
- * @fires datasource-data-cleared - Fired when infinite 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 datasource-filters-restored - Fired when persisted filters are reapplied
  */
 export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource_base {
@@ -5763,6 +5905,8 @@ export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource
     private infiniteDatasource;
     /** Unsubscribes the commit-response listener behind `pollTriggerEvents`. @internal */
     private commitResponseUnsubscribe?;
+    /** The `maxBlocksInCache` the grid was initialised with, so eviction can be mirrored. @internal */
+    private maxBlocksInCache?;
     resourceNameChanged(oldValue: string, newValue: string): void;
     criteriaChanged(oldCriteria: string, newCriteria: string): void;
     connectedCallback(): void;
@@ -5779,8 +5923,37 @@ export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource
     private clearReadyListener;
     /** @internal */
     private onDatasourceReady;
+    /**
+     * A pushed INSERT/DELETE changes which rows exist or their order, so the change is reported
+     * and then the rows are re-read (purge).
+     * @internal
+     */
+    private handleLiveRowsInvalidated;
+    /**
+     * A pushed MODIFY is already patched into the paging cache, so the change is reported and the
+     * grid only needs to re-render its blocks.
+     * @internal
+     */
+    private handleLiveRowsUpdated;
+    /**
+     * Turns a DATASERVER push into the same transaction the client-side datasource reports:
+     * inserts of held rows become updates, partial MODIFY rows are merged into the held row, and
+     * a remove carries just the row id.
+     * @remarks Unlike the client-side model, a pushed row need not be held here - it may sit
+     * beyond the loaded blocks. A MODIFY for such a row is not reported (the block that delivers
+     * it reports it as `add`); a DELETE is reported by the id it carries, and one that cannot be
+     * resolved to an id is skipped with a warning rather than matched against the wrong row.
+     * @internal
+     */
+    private reportLiveChange;
     destroy(): Promise<void>;
     restart(): Promise<void>;
+    /**
+     * 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
+     */
     private clearRowData;
     /**
      * Honours `pollTriggerEvents` without polling: a commit ACK for one of the listed events
@@ -6217,7 +6390,7 @@ export declare enum GridProRendererTypes {
  * @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
@@ -6228,13 +6401,18 @@ export declare enum GridProRendererTypes {
  * @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
  */
 export declare class GridProServerSideDatasource extends GridProServerSideDatasource_base {
-    serializer: JSONSerializer;
     pollingDatasource: Datasource;
+    /**
+     * 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
+     */
+    private get gridMaxBlocksInCache();
     /**
      * Enable live updates for the grid.
      * @remarks Only works with DATASERVER resources (StreamDatasource) right now.
@@ -6270,6 +6448,12 @@ export declare class GridProServerSideDatasource extends GridProServerSideDataso
     private onDatasourceReady;
     destroy(): Promise<void>;
     restart(): Promise<void>;
+    /**
+     * 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
+     */
     private clearRowData;
     /**
      * Checks whether the resolved resource can be served through the Server-Side Row Model.
@@ -8148,6 +8332,33 @@ export declare type ServerSideDatasourceOptions = {
     onNoDataAvailableFunc?: () => void;
     /** Called when a server-side load finishes with one or more rows. */
     onDataAvailableFunc?: () => void;
+    /**
+     * Called with the rows just handed to AG Grid for a block. This is the only point at which
+     * rows leave the datasource, so it is where the host learns which rows the grid holds.
+     */
+    onRowsDeliveredFunc?: (rows: any[]) => void;
+    /**
+     * Called with the ids of rows a re-read of a block no longer returned - they left the grid
+     * (deleted on the server, or moved to a block that reports them again).
+     */
+    onRowsWithdrawnFunc?: (rowIds: string[]) => void;
+    /**
+     * Called with the ids of rows whose block AG Grid evicted from its cache (`maxBlocksInCache`),
+     * so the host stops treating them as held. Nothing changed on the server.
+     */
+    onRowsEvictedFunc?: (rowIds: string[]) => void;
+    /**
+     * AG Grid's `maxBlocksInCache`, when the consumer set one, so the datasource can mirror the
+     * grid's block eviction. Unset means the grid keeps every block.
+     */
+    maxBlocksInCache?: number;
+    /**
+     * Whether the host applies pushed INSERTs and DELETEs to the grid as transactions
+     * (`live-updates`). The paging subscription receives every push either way; this decides
+     * whether the row cache mirrors the grid's re-indexing or treats the grid as a snapshot that
+     * only a refresh brings up to date.
+     */
+    gridReceivesLiveUpdates?: boolean;
     resourceName: string;
     resourceParams?: DataserverParams | RequestParams;
     resourceIndexes?: Map<string, string[]>;