@genesislcap/grid-pro 14.483.1-alpha-aaddab2.0 → 14.483.2

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

@@ -10,6 +10,19 @@ import { BaseServerSideDatasource } from './server-side.resource-base';
 export class DataserverServerSideDatasource extends BaseServerSideDatasource {
     constructor(options) {
         super(options);
+        /**
+         * Blocks awaiting stream messages. Settled blocks remove themselves; destroy() cancels
+         * (fails) the rest so AG Grid's concurrent-request slots are always released.
+         * @internal
+         */
+        this.pendingBlocks = new Set();
+        /**
+         * Highest absolute row index already handed to AG Grid this session (non-pagination).
+         * Live DELETEs below this watermark must not remove cache entries - see
+         * handleCurrentStreamLoad.
+         * @internal
+         */
+        this.deliveredRowCount = 0;
         this.createDataserverStreamFunc = options.createDataserverStreamFunc;
     }
     refreshDatasource(params) {
@@ -18,18 +31,32 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         });
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            this.cancelAllPendingBlocks();
             (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
             this.dataserverStreamSubscription = undefined;
             this.dataserverStream = undefined;
+            this.deliveredRowCount = 0;
             yield _super.refreshDatasource.call(this, params);
         });
     }
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            // Use separated filtering and sorting setup
-            yield this.setupFiltering(params);
-            yield this.setupSorting(params);
+            // setupFiltering()/setupSorting() return true when they triggered a refresh: the
+            // datasource was re-initialized and AG Grid's SSRM cache purged, so getRows() is
+            // re-invoked with fresh params and this invocation is superseded. It must still resolve
+            // via params.fail() - AG Grid caps concurrent requests and only frees a slot on
+            // success()/fail(); a silent return leaks the slot until the grid stops issuing
+            // getRows() entirely. fail() is safe here: the purge already destroyed the cache this
+            // request belonged to.
+            if (yield this.setupFiltering(params)) {
+                params.fail();
+                return;
+            }
+            if (yield this.setupSorting(params)) {
+                params.fail();
+                return;
+            }
             if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
                 const requestFilter = JSON.stringify((_a = params.request.filterModel) !== null && _a !== void 0 ? _a : {});
                 const currentFilter = JSON.stringify((_b = this.currentFilterModel) !== null && _b !== void 0 ? _b : {});
@@ -41,7 +68,20 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             if (!this.dataserverStream) {
                 this.dataserverStream = yield this.createDataserverStreamFunc(this.resourceParams);
             }
+            const blockStartRow = Number.isFinite(Number(params.request.startRow))
+                ? Number(params.request.startRow)
+                : 0;
+            const blockEndRow = Number.isFinite(Number(params.request.endRow))
+                ? Number(params.request.endRow)
+                : blockStartRow + Number(this.maxRows);
+            // Infinite scroll keeps a session-cumulative row cache (see handleCurrentStreamLoad);
+            // 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.pagination &&
+                this.currentSequenceId >= 1 &&
+                (this.rowData.size >= blockEndRow || !this.moreRows);
             if (this.currentSequenceId >= 1 &&
+                !blockAlreadyCovered &&
                 (this.moreRows || params.request.startRow >= Number(this.maxRows))) {
                 if (this.pagination) {
                     const startRow = Number.isFinite(Number(params.request.startRow))
@@ -58,16 +98,96 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     this.connect.getMoreRows(this.sourceRef, viewNumber);
                 }
             }
+            // One shared stream subscription for the session; each getRows() registers a pending
+            // block instead of subscribing again (.unsubscribe() would send DATA_LOGOFF and kill
+            // the whole server-side session).
             let applyResult = true;
-            this.dataserverStreamSubscription = this.dataserverStream.subscribe((dataserverResult) => {
+            const clearSafetyTimer = (timer) => {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+            };
+            const pendingBlock = { handle: () => { }, cancel: () => { } };
+            const settleBlock = () => {
+                this.pendingBlocks.delete(pendingBlock);
+            };
+            const resolveBlock = (timer) => {
+                if (!applyResult) {
+                    return;
+                }
+                applyResult = false;
+                clearSafetyTimer(timer);
+                settleBlock();
+                if (!this.pagination) {
+                    this.deliveredRowCount = Math.max(this.deliveredRowCount, blockEndRow);
+                }
+                const allRows = Array.from(this.rowData.values());
+                const successRowData = {
+                    // Non-pagination: deliver only this block's slice of the cache - AG Grid SSRM
+                    // expects exactly the rows for its startRow..endRow range.
+                    rowData: this.pagination ? allRows : allRows.slice(blockStartRow, blockEndRow),
+                };
+                successRowData.rowCount = this.getCorrectRowCount(params);
+                this.lastSuccessRowData = successRowData;
+                params.success(successRowData);
+                this.notifyNoDataAvailableIfEmpty(params, successRowData);
+            };
+            const failBlock = (timer) => {
+                if (!applyResult) {
+                    return;
+                }
+                applyResult = false;
+                clearSafetyTimer(timer);
+                settleBlock();
+                params.fail();
+            };
+            if (blockAlreadyCovered) {
+                resolveBlock();
+                return;
+            }
+            // Safety valve: never leave a block pending forever if the stream goes quiet - resolve
+            // short with the accumulated rows so AG Grid ends the dataset there.
+            const safetyTimer = setTimeout(() => {
+                if (applyResult) {
+                    logger.warn(`SSRM block ${blockStartRow}-${blockEndRow} for ${this.resourceName} timed out waiting for a full batch; resolving with ${this.rowData.size} accumulated row(s).`);
+                    resolveBlock(safetyTimer);
+                }
+            }, DataserverServerSideDatasource.BLOCK_RESOLVE_TIMEOUT_MS);
+            pendingBlock.cancel = () => failBlock(safetyTimer);
+            pendingBlock.handle = (dataserverResult) => {
                 var _a;
-                const incomingRowCount = (_a = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) === null || _a === void 0 ? void 0 : _a.length;
-                const shouldApply = applyResult || (incomingRowCount > 0 && this.rowData.size === 0);
-                if (shouldApply) {
+                const messageType = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MESSAGE_TYPE;
+                if (messageType &&
+                    (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+                    if (this.errorHandlerFunc) {
+                        const errorMessage = messageType === MessageType.LOGOFF_ACK
+                            ? `Connection lost to ${this.resourceName}`
+                            : `Authentication failed for ${this.resourceName}`;
+                        this.errorHandlerFunc(errorMessage, 'connection');
+                    }
+                    failBlock(safetyTimer);
+                    return;
+                }
+                if (this.pagination) {
+                    const incomingRowCount = (_a = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) === null || _a === void 0 ? void 0 : _a.length;
+                    const shouldApply = applyResult || (incomingRowCount > 0 && this.rowData.size === 0);
+                    if (!shouldApply) {
+                        return;
+                    }
+                    // Paginated mode keeps the original behaviour: each message resolves the request
+                    // (page swap).
                     DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
                         var _a, _b;
+                        if (!applyResult && !(incomingRowCount > 0 && this.rowData.size === 0)) {
+                            return;
+                        }
+                        // Claim the block synchronously, before the await below, so a concurrently queued
+                        // update sees applyResult === false and bails - and so applyResult is never
+                        // reassigned based on a value read before an await (require-atomic-updates).
+                        applyResult = false;
+                        clearSafetyTimer(safetyTimer);
                         // TODO: this is a bit of hack, due GSF not returning a different ROWS_COUNT when there is a CRITERIA_MATCH
-                        if (this.resourceParams.CRITERIA_MATCH && this.pagination) {
+                        if (this.resourceParams.CRITERIA_MATCH && !this.criteriaRowCountResolved) {
                             const updatedInfo = yield this.connect.snapshot(this.resourceName, {
                                 MAX_ROWS: this.maxView,
                                 MAX_VIEW: this.maxView,
@@ -79,18 +199,95 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                                 this.clientRowsCount = 0;
                             }
                             else {
-                                this.serverRowsCount = this.resourceParams.CRITERIA_MATCH
-                                    ? ((_b = (_a = updatedInfo.ROW) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : updatedInfo.ROWS_COUNT)
-                                    : updatedInfo.ROWS_COUNT;
+                                // ROWS_COUNT ignores CRITERIA_MATCH and ROW.length is capped at page size;
+                                // Math.max may over-report (self-corrects when the stream ends) but never
+                                // under-reports, which would make AG Grid stop requesting blocks.
+                                const rowsCount = (_a = updatedInfo.ROWS_COUNT) !== null && _a !== void 0 ? _a : 0;
+                                const rowLength = (_b = updatedInfo.ROW) === null || _b === void 0 ? void 0 : _b.length;
+                                this.serverRowsCount =
+                                    rowLength !== undefined ? Math.max(rowsCount, rowLength) : rowsCount;
+                                this.criteriaRowCountResolved = true;
                             }
                         }
                         this.applyServerSideData(params, dataserverResult);
-                        applyResult = false;
+                        settleBlock();
                     }));
+                    return;
+                }
+                if (!applyResult) {
+                    return;
                 }
-            });
+                // Infinite scroll accumulation runs once in dispatchStreamMessage(); here we only
+                // decide whether this block is ready to resolve.
+                if (this.currentSequenceId === 0 && !(dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) && !this.moreRows) {
+                    // First response carries no rows - the criteria matches nothing; resolve as
+                    // empty instead of waiting for the timeout.
+                    applyResult = false;
+                    clearSafetyTimer(safetyTimer);
+                    settleBlock();
+                    this.completeEmptyResult(params);
+                    return;
+                }
+                if (this.rowData.size >= blockEndRow || !this.moreRows) {
+                    DOM.queueUpdate(() => resolveBlock(safetyTimer));
+                }
+            };
+            this.pendingBlocks.add(pendingBlock);
+            this.ensureStreamSubscription();
         });
     }
+    /** @internal */
+    cancelAllPendingBlocks() {
+        const blocks = Array.from(this.pendingBlocks);
+        this.pendingBlocks.clear();
+        for (const block of blocks) {
+            block.cancel();
+        }
+    }
+    /**
+     * Lazily attaches the single stream subscription for this datasource session.
+     * @internal
+     */
+    ensureStreamSubscription() {
+        if (this.dataserverStreamSubscription) {
+            return;
+        }
+        this.dataserverStreamSubscription = this.dataserverStream.subscribe((dataserverResult) => this.dispatchStreamMessage(dataserverResult));
+    }
+    /**
+     * Fan-out: accumulate shared infinite-scroll state once, then notify each pending block.
+     * @internal
+     */
+    dispatchStreamMessage(dataserverResult) {
+        var _a;
+        const messageType = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MESSAGE_TYPE;
+        if (messageType &&
+            (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+            for (const block of this.pendingBlocks) {
+                block.handle(dataserverResult);
+            }
+            return;
+        }
+        if (!this.pagination) {
+            if ((dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MORE_ROWS) !== undefined) {
+                this.moreRows = dataserverResult.MORE_ROWS;
+            }
+            if (dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) {
+                const nextMessage = dataServerResultFilter(dataserverResult, this.rowId);
+                this.handleCurrentStreamLoad(nextMessage);
+                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;
+                    }
+                }
+            }
+        }
+        for (const block of this.pendingBlocks) {
+            block.handle(dataserverResult);
+        }
+    }
     applyServerSideData(params, result) {
         var _a;
         const messageType = result.MESSAGE_TYPE;
@@ -108,7 +305,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         }
         this.moreRows = result.MORE_ROWS;
         if (result.ROW) {
-            const nextMessage = dataServerResultFilter(result);
+            const nextMessage = dataServerResultFilter(result, this.rowId);
             this.handleCurrentStreamLoad(nextMessage);
         }
         else {
@@ -134,10 +331,9 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             if (this.serverRowsCount === 0) {
                 this.serverRowsCount = (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
             }
-            if (this.getResourceParam('CRITERIA_MATCH') && result.ROW) {
-                this.serverRowsCount = result.ROW.length;
-                this.clientRowsCount = result.ROW.length;
-            }
+            // Deliberately not overriding serverRowsCount with ROW.length under CRITERIA_MATCH:
+            // ROW.length is just the first batch's size and clobbered the corrected count from
+            // the snapshot() workaround in getRows().
         }
         const successRowData = {
             rowData: Array.from(this.rowData.values()),
@@ -153,7 +349,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
      */
     setupSorting(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c;
             const toBeAppliedSortModel = params.request.sortModel;
             if (((_a = this.currentSortModel) === null || _a === void 0 ? void 0 : _a.length) !== toBeAppliedSortModel.length ||
                 toBeAppliedSortModel.length > 0) {
@@ -163,31 +359,49 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     this.resourceParams.ORDER_BY = null;
                     this.resourceParams.REVERSE = null;
                     yield this.refreshDatasource(params);
-                    return;
+                    return true;
                 }
                 else if (toBeAppliedSortModel.length > 0) {
                     const coldIdBeingSorted = toBeAppliedSortModel[0].colId; // Not allowing multiple sorts by user
                     const sortTypeBeingApplied = toBeAppliedSortModel[0].sort;
                     const orderByAndToBeSortedColIds = this.getOrderByAndToBeSortedColIds(this.resourceIndexes, coldIdBeingSorted);
                     if (!orderByAndToBeSortedColIds) {
-                        this.calculatedRowsCount = 0;
                         const availableIndexes = getAvailableIndexes(this.resourceIndexes);
                         const availableIndexFields = getAvailableIndexFields(this.resourceIndexes);
-                        logger.warn(`The FIELD/column (${coldIdBeingSorted}) being sorted is not part of an INDEX, required for the [orderBy] operation. See https://learn.genesis.global/docs/database/data-types/index-entities/`);
+                        logger.warn(`The FIELD/column (${coldIdBeingSorted}) being sorted is not part of an INDEX, required for the [orderBy] operation - ignoring this sort and loading unsorted data. See https://learn.genesis.global/docs/database/data-types/index-entities/`);
                         logger.debug('Available indexes:', availableIndexes);
                         logger.debug('Columns that can be sorted with the available indexes:', availableIndexFields);
-                        params.fail();
-                        return;
+                        // Ignore the un-sortable sort instead of failing - failing killed the entire
+                        // first load when a restored workspace carried a sort on a non-indexed column.
+                        const sortModelChanged = JSON.stringify(toBeAppliedSortModel) !== JSON.stringify(this.currentSortModel);
+                        const hadPreviousSort = ((_c = (_b = this.currentSortModel) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0;
+                        const hasActiveOrderBy = this.resourceParams.ORDER_BY != null || this.resourceParams.REVERSE != null;
+                        // Remember the model so identical requests don't re-warn, and carry on unsorted.
+                        this.currentSortModel = toBeAppliedSortModel;
+                        // A previously applied (indexed) sort left ORDER_BY/REVERSE pointing at the old
+                        // column; clear them and reload once so the grid shows genuinely unsorted data
+                        // instead of the old column's order under the ignored new sort's header. Gated by
+                        // hadPreviousSort so a first-load restored sort still just carries on (no extra
+                        // reload), and by sortModelChanged so the post-refresh getRows() (same model) does
+                        // not loop.
+                        if (hadPreviousSort && sortModelChanged && hasActiveOrderBy) {
+                            this.resourceParams.ORDER_BY = null;
+                            this.resourceParams.REVERSE = null;
+                            yield this.refreshDatasource(params);
+                            return true;
+                        }
+                        return false;
                     }
                     else if (JSON.stringify(toBeAppliedSortModel) !== JSON.stringify(this.currentSortModel)) {
                         this.currentSortModel = toBeAppliedSortModel;
                         this.resourceParams.ORDER_BY = orderByAndToBeSortedColIds.orderBy;
                         this.resourceParams.REVERSE = sortTypeBeingApplied === 'desc' ? true : false;
                         yield this.refreshDatasource(params);
-                        return;
+                        return true;
                     }
                 }
             }
+            return false;
         });
     }
     destroy() {
@@ -196,21 +410,63 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         });
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            this.cancelAllPendingBlocks();
             this.dataserverStream = undefined;
             (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
             this.dataserverStreamSubscription = undefined;
+            this.deliveredRowCount = 0;
             yield _super.destroy.call(this);
         });
     }
     handleCurrentStreamLoad(result) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         if (!result)
             return;
-        const rows = new Map();
+        // Pagination replaces the buffer per message (page swap); infinite scroll accumulates a
+        // session-cumulative cache, as GSF splits batches across messages and later batches
+        // append. Map preserves insertion order, so the cache can be sliced by block range.
+        const rows = this.pagination ? new Map() : new Map(this.rowData);
         (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
             rows.set(insertData[this.rowId], insertData);
         });
-        this.clientRowsCount += (_b = result.inserts.length) !== null && _b !== void 0 ? _b : 0;
+        // 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.
+        (_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) {
+                return;
+            }
+            const existing = rows.get(key);
+            rows.set(key, existing ? Object.assign(Object.assign({}, existing), updateData) : updateData);
+        });
+        (_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) {
+                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.pagination && this.deliveredRowCount > 0) {
+                let index = 0;
+                for (const mapKey of rows.keys()) {
+                    if (mapKey === key) {
+                        if (index < this.deliveredRowCount) {
+                            return;
+                        }
+                        break;
+                    }
+                    index += 1;
+                }
+            }
+            rows.delete(key);
+        });
+        this.clientRowsCount += (_e = (_d = result.inserts) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
         this.rowData = rows;
     }
 }
+/**
+ * Max time a non-paginated SSRM block may stay pending before the safety valve in
+ * getRows() resolves it with the rows accumulated so far.
+ * @internal
+ */
+DataserverServerSideDatasource.BLOCK_RESOLVE_TIMEOUT_MS = 10000;

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

@@ -41,9 +41,14 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
     }
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Use custom filtering and sorting setup for req-rep
-            yield this.setupFiltering(params);
-            yield this.setupSorting(params);
+            if (yield this.setupFiltering(params)) {
+                params.fail();
+                return;
+            }
+            if (yield this.setupSorting(params)) {
+                params.fail();
+                return;
+            }
             if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
                 params.success(this.lastSuccessRowData);
                 return;
@@ -255,7 +260,7 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
                     this.currentSortModel = null;
                     this.resourceParams.DETAILS.ORDER_BY = undefined;
                     yield this.refreshDatasource(params);
-                    return;
+                    return true;
                 }
                 else if (toBeAppliedSortModel.length > 0) {
                     const coldIdBeingSorted = toBeAppliedSortModel[0].colId; // Not allowing multiple sorts by user
@@ -266,10 +271,11 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
                         this.resourceParams.DETAILS.ORDER_BY =
                             coldIdBeingSorted + (sortTypeBeingApplied === 'desc' ? ' DESC' : ' ASC'); // Use the column directly
                         yield this.refreshDatasource(params);
-                        return;
+                        return true;
                     }
                 }
             }
+            return false;
         });
     }
     refreshDatasource(params) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/grid-pro",
   "description": "Genesis Foundation AG Grid",
-  "version": "14.483.1-alpha-aaddab2.0",
+  "version": "14.483.2",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -40,20 +40,20 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/genx": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/rollup-builder": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/ts-builder": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/uvu-playwright-builder": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/vite-builder": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/webpack-builder": "14.483.1-alpha-aaddab2.0"
+    "@genesislcap/foundation-testing": "14.483.2",
+    "@genesislcap/genx": "14.483.2",
+    "@genesislcap/rollup-builder": "14.483.2",
+    "@genesislcap/ts-builder": "14.483.2",
+    "@genesislcap/uvu-playwright-builder": "14.483.2",
+    "@genesislcap/vite-builder": "14.483.2",
+    "@genesislcap/webpack-builder": "14.483.2"
   },
   "dependencies": {
-    "@genesislcap/foundation-comms": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/foundation-criteria": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/foundation-logger": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/foundation-ui": "14.483.1-alpha-aaddab2.0",
-    "@genesislcap/foundation-utils": "14.483.1-alpha-aaddab2.0",
+    "@genesislcap/foundation-comms": "14.483.2",
+    "@genesislcap/foundation-criteria": "14.483.2",
+    "@genesislcap/foundation-logger": "14.483.2",
+    "@genesislcap/foundation-ui": "14.483.2",
+    "@genesislcap/foundation-utils": "14.483.2",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -91,5 +91,5 @@
       "require": "./dist/react.cjs"
     }
   },
-  "gitHead": "7cd35e0383007a499b423cbc84fd968a29507fa5"
+  "gitHead": "a4347351b733c1f31b234a7f2a668f6b8166723b"
 }