@genesislcap/grid-pro 15.29.0 → 15.30.1

package/dist/esm/datasource/delivered-block.ledger.js

@@ -0,0 +1,52 @@
+/**
+ * Tracks which row ids each block has handed to AG Grid, so the host can learn when a re-read of
+ * a block no longer returns a row (it left the grid).
+ * @remarks Plain class shared by the infinite and SSRM resources - AG Grid does not report that
+ * event.
+ *
+ * Block eviction is deliberately **not** mirrored here. AG Grid evicts by last access
+ * (`InfiniteCache.purgeBlocksIfNeeded` sorts on `lastAccessed` and never evicts a displayed or
+ * focused block; the SSRM `LazyCache` purges by distance from the viewport), and a datasource is
+ * told about neither the accesses nor the evictions. Any eviction model built from delivery order
+ * alone diverges from the grid's as soon as the user scrolls back, which would drop a visible
+ * row from the held set and silence the pushes that follow. So the held set means "rows delivered
+ * since the last cache reset": a superset of what the grid holds, which keeps every push for a
+ * possibly-visible row flowing and costs only a re-delivered row being reported as unchanged
+ * rather than as an `add`.
+ * @internal
+ */
+export class DeliveredBlockLedger {
+    constructor(rowId) {
+        this.rowId = rowId;
+        /** Row ids per block start row. */
+        this.blocks = new Map();
+    }
+    /** Records the rows handed to the grid for the block at `startRow`. */
+    record(startRow, rows) {
+        const ids = new Set();
+        rows.forEach((row) => {
+            const id = row === null || row === void 0 ? void 0 : row[this.rowId];
+            if (id !== undefined && id !== null) {
+                ids.add(id);
+            }
+        });
+        const previous = this.blocks.get(startRow);
+        this.blocks.set(startRow, ids);
+        const withdrawnRowIds = previous
+            ? [...previous].filter((id) => !ids.has(id) && !this.isHeld(id))
+            : [];
+        return { withdrawnRowIds };
+    }
+    /** Forgets every block, for when the grid drops its whole cache (filter/sort change, destroy). */
+    clear() {
+        this.blocks.clear();
+    }
+    isHeld(id) {
+        for (const ids of this.blocks.values()) {
+            if (ids.has(id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -2,6 +2,7 @@ import { __awaiter, __decorate } from "tslib";
 import { Connect, ConnectEvents, Datasource, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
 import { LifecycleMixin } from '@genesislcap/foundation-utils';
 import { customElement, DOM, observable } from '@microsoft/fast-element';
+import { debounceTime, skip } from 'rxjs/operators';
 import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
 import { datasourceEventNames, } from '../grid-pro-genesis-datasource/datasource-events.types';
 import { logger } from '../utils';
@@ -9,6 +10,8 @@ import { GridProBaseDatasource } from './base.datasource';
 import { GenesisInfiniteDatasource } from './infinite.resource';
 import { getFilterByFieldType, getServerSideFilterParamsByFieldType, } from './server-side.grid-definitions';
 const criteriaDelimiter = ';';
+/** How long a burst of `setFilter()` calls is collapsed for, matching the client-side model. */
+const FILTER_DEBOUNCE_MS = 600;
 /**
  * A Genesis Datasource element for AG Grid's Infinite Row Model.
  * @remarks
@@ -40,12 +43,15 @@ const criteriaDelimiter = ';';
  * @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-loading-finished - Fired when the first block comes back with rows
+ * @fires datasource-no-data-available - Fired when the first block comes back empty
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
  */
 let GridProInfiniteDatasource = class GridProInfiniteDatasource extends LifecycleMixin(GridProBaseDatasource) {
@@ -61,6 +67,10 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 this.setDisconnected(true);
                 return;
             }
+            if (!this.isInfiniteSupportedForResource()) {
+                this.clearRowData();
+                return;
+            }
             this.$emit(gridProGenesisDatasourceEventNames.dataInit);
             this.setDisconnected(false);
             this.indexes = this.getResourceIndexes(this.datasource.availableIndexes, this.datasource.availableSortableFields);
@@ -78,15 +88,14 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 // VIEW_NUMBER 0 means "pagination disabled": the server continues from the cursor it
                 // holds on the last row it delivered, rather than re-seeking by offset.
                 getMoreRowsFunc: (sourceRef) => this.connect.getMoreRows(sourceRef, 0),
-                // A pushed INSERT/DELETE changes which rows exist or their order, so the rows are
-                // re-read (purge); a pushed MODIFY is already patched into the cache, so the grid only
-                // needs to re-render its blocks.
-                onRowsInvalidatedFunc: () => this.$emit(datasourceEventNames.refreshInfiniteCache, {
-                    purge: true,
-                }),
-                onRowsUpdatedFunc: () => this.$emit(datasourceEventNames.refreshInfiniteCache, {
-                    purge: false,
-                }),
+                onRowsDeliveredFunc: this.reportDeliveredRows.bind(this),
+                onRowsWithdrawnFunc: this.reportWithdrawnRows.bind(this),
+                // A filter or sort change drops every block: forget the rows and tell consumers.
+                onRowCacheResetFunc: () => this.clearRowData(false),
+                onRowsInvalidatedFunc: this.handleLiveRowsInvalidated.bind(this),
+                onRowsUpdatedFunc: this.handleLiveRowsUpdated.bind(this),
+                onNoDataAvailableFunc: () => this.$emit(datasourceEventNames.noDataAvailable),
+                onDataAvailableFunc: () => this.$emit(datasourceEventNames.loadingFinished),
                 errorHandlerFunc: this.handleErrors.bind(this),
                 resourceName: this.resourceName,
                 resourceParams: this.isRequestServer
@@ -96,8 +105,12 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 resourceColDefs: this.datasource.originalFieldDef,
                 maxRows: +this.maxRows,
                 rowId: this.rowId,
-                baseCriteria: this.criteria,
+                // The merged criteria, so a criteria added through setFilter() is read with the rows
+                // rather than dropped: the logon builder replaces CRITERIA_MATCH with what it is given.
+                baseCriteria: this.buildCriteria(),
                 isRequestServer: this.isRequestServer,
+                defaultOrderBy: this.orderBy,
+                defaultReverse: this.reverse,
             });
             // Emit event to set infinite datasource
             this.$emit(datasourceEventNames.setInfiniteDatasource, {
@@ -140,6 +153,7 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 return;
             this.init();
             this.subscribeToConnection();
+            this.subscribeToFilterChanges();
         });
     }
     disconnectedCallback() {
@@ -150,8 +164,34 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 return;
             yield this.destroy();
             this.unsubscribeFromConnection();
+            this.unsubscribeFromFilterChanges();
         }));
     }
+    /**
+     * Reloads when `setFilter()` or `removeFilter()` changes the criteria.
+     * @remarks The criteria a block is read with is captured when the resource is built, so a
+     * filter added later reaches nothing until the rows are re-read. The `criteria` attribute
+     * already reloads through `criteriaChanged`; this gives the programmatic API the same
+     * behaviour instead of silently doing nothing.
+     * @internal
+     */
+    subscribeToFilterChanges() {
+        this.unsubscribeFromFilterChanges();
+        // Same shape as the client-side datasource: `update` is a BehaviorSubject, so skip(1) drops
+        // the value it replays on subscribe (the state init() is already reading), and the debounce
+        // collapses a burst of setFilter calls into one reload.
+        this.filterSub = this.update.pipe(skip(1), debounceTime(FILTER_DEBOUNCE_MS)).subscribe(() => {
+            if (!this.infiniteDatasource)
+                return;
+            this.reloadResourceData();
+        });
+    }
+    /** @internal */
+    unsubscribeFromFilterChanges() {
+        var _a;
+        (_a = this.filterSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.filterSub = undefined;
+    }
     deepClone() {
         const copy = super.deepClone();
         copy.deferredGridOptions = structuredClone(this.deferredGridOptions);
@@ -169,7 +209,10 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
             // The paging DATA_LOGON is opened through connect.stream, not this.datasource, so destroying
             // the comms datasource below does not close it. Dispose the IDatasource explicitly or every
             // criteria change (e.g. a bound search box) leaks a live subscription and its block timers.
-            (_b = (_a = this.infiniteDatasource) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+            // detach(), not destroy(): AG Grid keeps calling this bean until the replacement is attached
+            // a round trip later, and the purge below re-requests blocks immediately. destroy() alone
+            // would leave it reading with the old criteria and reporting those rows as delivered.
+            (_b = (_a = this.infiniteDatasource) === null || _a === void 0 ? void 0 : _a.detach) === null || _b === void 0 ? void 0 : _b.call(_a);
             this.infiniteDatasource = undefined;
             this.datasource.destroy();
             // Emit event to cache current filter model before clearing data
@@ -225,6 +268,69 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
     clearReadyListener() {
         this.removeEventListener(datasourceEventNames.ready, this.onDatasourceReady);
     }
+    /**
+     * Whether the infinite row model can drive this resource.
+     * @remarks It pages a req/rep by sending CRITERIA_MATCH, ORDER_BY and OFFSET in DETAILS, which
+     * a request reply only accepts when it is declared `criteriaOnlyRequest`
+     * (`CRITERIA_ONLY_REQUEST` in its metadata). Without it the server expects its inputs in
+     * `REQUEST` instead and rejects every block, which on this row model surfaces as a grid that
+     * simply never fills. Report it once, up front, as the server-side model does.
+     * @returns `true` when the infinite model can be used, `false` after reporting a
+     * `resource-type` error.
+     * @internal
+     */
+    isInfiniteSupportedForResource() {
+        if (!this.isRequestServer || this.datasource.criteriaOnlyRequest) {
+            return true;
+        }
+        this.handleErrors(`Infinite row model is not supported for the REQUEST_SERVER resource '${this.resourceName}' because it does not support criteria-only requests. Set 'criteriaOnlyRequest = true' on the request reply definition, or use a client-side datasource for this resource.`, 'resource-type');
+        return false;
+    }
+    /**
+     * 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
+     */
+    handleLiveRowsInvalidated(change) {
+        this.reportLiveChange(change);
+        this.$emit(datasourceEventNames.refreshInfiniteCache, {
+            purge: true,
+        });
+    }
+    /**
+     * 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
+     */
+    handleLiveRowsUpdated(change) {
+        this.reportLiveChange(change);
+        this.$emit(datasourceEventNames.refreshInfiniteCache, {
+            purge: false,
+        });
+    }
+    /**
+     * Turns a DATASERVER push into the same transaction the client-side datasource reports:
+     * 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, in which case the grid will never show it.
+     *
+     * So a pushed INSERT is deliberately not reported: nothing here says where the new row sorts,
+     * and reporting an `add` for a row that lands at position 40,000 of an unscrolled grid would
+     * contradict the event's contract and leave the row held forever, since no block re-read ever
+     * delivers (or withdraws) it. Every INSERT is followed by a purge and re-read, which reports
+     * the row as `add` if and when it actually reaches the grid.
+     *
+     * A MODIFY for a row that is not held is skipped for the same reason; 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
+     */
+    reportLiveChange(change) {
+        const transaction = this.resetTransaction();
+        this.handleStreamUpdates(change.updates);
+        this.handleStreamDeletes(change.deletes);
+        this.emitTransaction(transaction);
+    }
     destroy() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -237,7 +343,9 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
             this.datasource.destroy();
             this.clearRowData();
             if (this.infiniteDatasource) {
-                (_b = (_a = this.infiniteDatasource).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+                // The host is done with this bean for good, so detach rather than destroy - see
+                // reloadResourceData.
+                (_b = (_a = this.infiniteDatasource).detach) === null || _b === void 0 ? void 0 : _b.call(_a);
                 this.infiniteDatasource = undefined;
             }
             // Emit events instead of direct grid access
@@ -252,15 +360,18 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
             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: withColumnDefs,
+        });
     }
     /**
      * Honours `pollTriggerEvents` without polling: a commit ACK for one of the listed events

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

@@ -1,6 +1,8 @@
 import { __awaiter } from "tslib";
-import { dataServerResultFilter, MessageType, } from '@genesislcap/foundation-comms';
+import { MessageType, } from '@genesislcap/foundation-comms';
 import { logger } from '../utils';
+import { filterDataserverResult } from './dataserver-result.filter';
+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.
@@ -39,12 +41,71 @@ export function convertSortModelToOrderBy(sortModel, resourceIndexes, isRequestS
     logger.warn(`Column '${colId}' is not part of any named INDEX. Server-side sorting is not available for this column.`);
     return { orderBy: null, reverse: false };
 }
+/**
+ * Turns whatever a rejected resource read produced into a message worth showing.
+ * @remarks Genesis rejects with a message object (`{ ERROR: [{ TEXT }], MESSAGE_TYPE }`), not an
+ * `Error`, so stringifying it naively yields "[object Object]" in the grid's error dialog.
+ * @internal
+ */
+export function describeResourceError(error) {
+    var _a, _b, _c;
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    const details = error;
+    for (const candidate of [details, details === null || details === void 0 ? void 0 : details.receivedMessage]) {
+        const texts = (_a = candidate === null || candidate === void 0 ? void 0 : candidate.ERROR) === null || _a === void 0 ? void 0 : _a.map((entry) => entry === null || entry === void 0 ? void 0 : entry.TEXT).filter(Boolean);
+        if (texts === null || texts === void 0 ? void 0 : texts.length) {
+            return texts.join('; ');
+        }
+    }
+    if (typeof (details === null || details === void 0 ? void 0 : details.message) === 'string' && details.message) {
+        return details.message;
+    }
+    const messageType = (_b = details === null || details === void 0 ? void 0 : details.MESSAGE_TYPE) !== null && _b !== void 0 ? _b : (_c = details === null || details === void 0 ? void 0 : details.receivedMessage) === null || _c === void 0 ? void 0 : _c.MESSAGE_TYPE;
+    if (messageType) {
+        return messageType;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch (_d) {
+        return String(error);
+    }
+}
 /**
  * AG Grid Infinite Row Model datasource implementation.
  * This class implements the IDatasource interface required by AG Grid's Infinite Row Model.
  */
 export class GenesisInfiniteDatasource {
     constructor(options) {
+        var _a;
+        /** The `reverse` attribute, applied alongside `defaultOrderBy` on DATASERVER. @internal */
+        this.defaultReverse = false;
+        /**
+         * 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
+         */
+        this.loadGeneration = 0;
+        /**
+         * Set once the host has dropped this instance for a replacement (a criteria change, a resource
+         * change, teardown). AG Grid keeps calling the bean it was given until the new one is attached,
+         * and its purge re-requests blocks immediately, so without this the replaced instance keeps
+         * reading with its captured criteria and reporting those rows to the host as delivered.
+         * @remarks Distinct from `destroy()`, which AG Grid itself calls on a bean it then keeps using;
+         * only the host calls `detach()`, and only when it will never use this instance again.
+         * @internal
+         */
+        this.detached = 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 +130,11 @@ export class GenesisInfiniteDatasource {
         this.getMoreRowsFunc = options.getMoreRowsFunc;
         this.onRowsInvalidatedFunc = options.onRowsInvalidatedFunc;
         this.onRowsUpdatedFunc = options.onRowsUpdatedFunc;
+        this.onRowsDeliveredFunc = options.onRowsDeliveredFunc;
+        this.onRowsWithdrawnFunc = options.onRowsWithdrawnFunc;
+        this.onRowCacheResetFunc = options.onRowCacheResetFunc;
         this.errorHandlerFunc = options.errorHandlerFunc;
+        this.ledger = new DeliveredBlockLedger(options.rowId);
         this.resourceName = options.resourceName;
         this.resourceParams = Object.assign({}, options.resourceParams);
         this.resourceIndexes = options.resourceIndexes;
@@ -78,6 +143,10 @@ export class GenesisInfiniteDatasource {
         this.rowId = options.rowId;
         this.baseCriteria = options.baseCriteria || '';
         this.isRequestServer = options.isRequestServer;
+        this.defaultOrderBy = options.defaultOrderBy || undefined;
+        this.defaultReverse = (_a = options.defaultReverse) !== null && _a !== void 0 ? _a : false;
+        this.onNoDataAvailableFunc = options.onNoDataAvailableFunc;
+        this.onDataAvailableFunc = options.onDataAvailableFunc;
     }
     /**
      * Builds request parameters for REQUEST_SERVER resources.
@@ -153,6 +222,15 @@ export class GenesisInfiniteDatasource {
      */
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // The host has replaced this instance; the grid is only still asking because the replacement
+            // has not been attached yet. Reading would use this instance's captured criteria and report
+            // rows the grid will drop. fail() releases AG Grid's request slot for the new datasource.
+            if (this.detached) {
+                logger.debug('Infinite getRows ignored: the datasource was detached by its host');
+                params.failCallback();
+                return;
+            }
             logger.debug('Infinite getRows called', {
                 startRow: params.startRow,
                 endRow: params.endRow,
@@ -163,7 +241,8 @@ export class GenesisInfiniteDatasource {
                 const filterCriteria = convertFilterModelToCriteria(params.filterModel, this.resourceColDefs);
                 const combinedCriteria = [this.baseCriteria, filterCriteria].filter(Boolean).join(' && ');
                 // Build sort config
-                const sortConfig = convertSortModelToOrderBy(params.sortModel, this.resourceIndexes, this.isRequestServer);
+                const sortConfig = this.resolveSortConfig(params.sortModel);
+                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) {
@@ -172,25 +251,51 @@ export class GenesisInfiniteDatasource {
                 }
                 const requestParams = this.buildRequestServerParams(params.startRow, combinedCriteria, sortConfig);
                 logger.debug('Infinite datasource request params', requestParams);
+                // Taken after noteRequestKey, so this is the generation the request belongs to: only a
+                // reset that lands while it is in flight invalidates the reply.
+                const generation = this.loadGeneration;
                 const result = yield this.createSnapshotFunc(requestParams);
+                // The rows this block was read for have since been dropped (a filter or sort change): AG
+                // Grid has purged the block, and the host must not learn of rows the grid will never hold.
+                // The block is still failed rather than left hanging - AG Grid caps concurrent requests
+                // and frees a slot only on success or fail, so a silent return stops it ever asking again.
+                if (generation !== this.loadGeneration) {
+                    logger.debug('Infinite REQUEST_SERVER reply discarded: the block cache was reset');
+                    params.failCallback();
+                    return;
+                }
                 if (!result) {
                     params.failCallback();
                     return;
                 }
+                // A rejected request answers with a message, not a REPLY. Settling it as an empty block
+                // would tell the grid the dataset simply ends here, so the user sees a short grid with no
+                // indication that anything failed.
+                const messageType = result.MESSAGE_TYPE;
+                if (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK) {
+                    const message = messageType === MessageType.LOGOFF_ACK
+                        ? `Connection lost to ${this.resourceName}`
+                        : `Request rejected by ${this.resourceName}`;
+                    logger.error(`Infinite REQUEST_SERVER block failed: ${message}`, result);
+                    (_a = this.errorHandlerFunc) === null || _a === void 0 ? void 0 : _a.call(this, message, 'connection');
+                    params.failCallback();
+                    return;
+                }
                 if ('REPLY' in result && Array.isArray(result.REPLY)) {
                     const rowData = result.REPLY;
                     const lastRow = this.getLastRow(result, params.startRow, rowData.length, Boolean(combinedCriteria));
                     params.successCallback(rowData, lastRow);
+                    this.deliverRows(params.startRow, rowData);
+                    this.notifyDataAvailability(params.startRow, rowData.length);
                     return;
                 }
                 // Fallback - empty result
                 params.successCallback([], params.startRow);
+                this.notifyDataAvailability(params.startRow, 0);
             }
             catch (error) {
                 logger.error('Error in infinite getRows:', error);
-                if (this.errorHandlerFunc) {
-                    this.errorHandlerFunc(error instanceof Error ? error.message : String(error), 'unknown');
-                }
+                (_b = this.errorHandlerFunc) === null || _b === void 0 ? void 0 : _b.call(this, describeResourceError(error), 'unknown');
                 params.failCallback();
             }
         });
@@ -202,20 +307,57 @@ 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
+     */
+    /**
+     * The sort a block is read with: the grid's own sort model when the user has sorted, and the
+     * `order-by` / `reverse` attributes otherwise.
+     * @remarks Without the fallback those attributes reached the comms datasource but were then
+     * dropped, because the logon builder removes ORDER_BY and REVERSE whenever the grid is
+     * unsorted. Sorting from the grid still wins, as it is the more specific instruction.
+     * @internal
+     */
+    resolveSortConfig(sortModel) {
+        const fromGrid = convertSortModelToOrderBy(sortModel, this.resourceIndexes, this.isRequestServer);
+        if (fromGrid.orderBy || !this.defaultOrderBy) {
+            return fromGrid;
+        }
+        return { orderBy: this.defaultOrderBy, reverse: this.defaultReverse };
+    }
+    noteRequestKey(criteria, sortConfig) {
+        var _a;
+        const key = JSON.stringify(Object.assign({ criteria }, sortConfig));
+        // Tracked separately from `subscriptionKey`, which a teardown clears: `reset()` tears the
+        // subscription down on every structural push, and a filter change landing between that and
+        // the next block read would otherwise look like the very first request - leaving the host
+        // holding every row read under the old filter.
+        if (this.rowCacheKey !== undefined && this.rowCacheKey !== key) {
+            // Whatever is in flight was read for the old filter or sort.
+            this.loadGeneration += 1;
+            this.ledger.clear();
+            (_a = this.onRowCacheResetFunc) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        this.rowCacheKey = key;
+        // CRITERIA_MATCH and ORDER_BY are DATA_LOGON parameters, so a change needs a fresh
+        // subscription. A teardown has already left `subscriptionKey` undefined.
+        if (!this.isRequestServer &&
+            this.subscriptionKey !== undefined &&
+            this.subscriptionKey !== key) {
+            this.teardownDataserverSubscription();
+        }
+        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)
@@ -318,7 +460,7 @@ export class GenesisInfiniteDatasource {
             return;
         }
         this.sourceRef = (_b = message === null || message === void 0 ? void 0 : message.SOURCE_REF) !== null && _b !== void 0 ? _b : this.sourceRef;
-        const filtered = (message === null || message === void 0 ? void 0 : message.ROW) ? dataServerResultFilter(message, this.rowId) : undefined;
+        const filtered = (message === null || message === void 0 ? void 0 : message.ROW) ? filterDataserverResult(message, this.rowId) : undefined;
         // A DATASERVER subscription is live by definition: batches answering the logon or a
         // MORE_ROWS carry the rows we asked for, and anything else is a change pushed by the server.
         // Replies only ever deliver view rows (INSERT operations), so a batch carrying a MODIFY or
@@ -380,7 +522,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 +530,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 +648,46 @@ export class GenesisInfiniteDatasource {
             lastRow,
         });
         block.success(rows, lastRow);
+        this.deliverRows(block.startRow, rows);
+        this.notifyDataAvailability(block.startRow, rows.length);
+    }
+    /**
+     * Raises the no-data / data-available hooks for the first block, as the server-side resource
+     * does. Later blocks say nothing: the question is whether the resource has any rows at all,
+     * and the answer cannot change once the first block has been served.
+     * @internal
+     */
+    notifyDataAvailability(startRow, rowCount) {
+        var _a, _b;
+        if (startRow !== 0 || this.detached) {
+            return;
+        }
+        if (rowCount === 0) {
+            (_a = this.onNoDataAvailableFunc) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        else {
+            (_b = this.onDataAvailableFunc) === null || _b === void 0 ? void 0 : _b.call(this);
+        }
+    }
+    /**
+     * 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;
+        // A reply that resolves after the host dropped this instance belongs to a cache the grid no
+        // longer has; reporting it would tell consumers about rows the grid will never show.
+        if (this.detached) {
+            return;
+        }
+        const { withdrawnRowIds } = 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);
+        }
     }
     /**
      * Warns when the view filled up before the data ran out.
@@ -566,10 +748,33 @@ export class GenesisInfiniteDatasource {
         this.moreRows = undefined;
         this.moreRowsInFlight = false;
     }
+    /**
+     * 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() {
         this.teardownDataserverSubscription();
+        this.ledger.clear();
         logger.debug('GenesisInfiniteDatasource destroyed');
     }
+    /**
+     * Drops this instance for good: the host is replacing it, so it must stop serving the grid and
+     * stop reporting rows, even though AG Grid still holds it as its `datasource` until the
+     * replacement is attached.
+     * @remarks Deliberately separate from `destroy()`, which AG Grid calls on a bean it then keeps
+     * using (`InfiniteRowModel.start()` re-applies the `datasource` grid option, and `setDatasource`
+     * destroys the previous one first).
+     */
+    detach() {
+        this.detached = true;
+        this.loadGeneration += 1;
+        this.rowCacheKey = undefined;
+        this.destroy();
+        logger.debug('GenesisInfiniteDatasource detached by its host');
+    }
 }
 /**
  * Max time a DATASERVER block may stay pending before the safety valve resolves it with the