@zeniai/client-epic-state 5.0.52 → 5.0.53-betaML3

package/lib/esm/view/expenseAutomationView/helpers/transactionCategorizationLocalDataHelper.js

@@ -183,6 +183,7 @@ const buildLineItemById = (transaction, uncategorizedIncomeExpense, recommendati
             const lineId = line.id;
             record.account = accountLine.account;
             record.class = accountLine.class;
+            record.project = accountLine.project;
             record.vendor =
                 accountLine.vendor != null
                     ? {
@@ -305,7 +306,7 @@ const buildLineItemById = (transaction, uncategorizedIncomeExpense, recommendati
     });
     return lineItemData;
 };
-export const toSetAllLineItemsToCategoryClass = (draft, transaction, transactionId, transactionLineId, transactionDetailLocalData, updatedItem, uncategorizedAccounts, selectedTab, vendorId, customerId, selectedAccount, selectedClassBase, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) => {
+export const toSetAllLineItemsToCategoryClass = (draft, transaction, transactionId, transactionLineId, transactionDetailLocalData, updatedItem, uncategorizedAccounts, selectedTab, vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) => {
     let newLineItems = {};
     let selectedCheckBoxTransactionIds = draft.selectedCheckBoxTransactionIds;
     let similarTransactionUpdated = false;
@@ -325,7 +326,7 @@ export const toSetAllLineItemsToCategoryClass = (draft, transaction, transaction
                     const record = {
                         ...transactionDetailLocalData.lineItemById[lineId],
                     };
-                    // if the line is the one that is being updated, then set the account and class
+                    // if the line is the one that is being updated, then set the account, class, and project
                     if (transactionId === record.transactionId &&
                         transactionLineId === lineId) {
                         if (selectedAccount != null) {
@@ -334,6 +335,9 @@ export const toSetAllLineItemsToCategoryClass = (draft, transaction, transaction
                         if (selectedClassBase != null) {
                             record.class = selectedClassBase;
                         }
+                        if (selectedProjectBase != null) {
+                            record.project = selectedProjectBase;
+                        }
                         const isClassSatisfied = isAccountingClassesEnabled === false || record.class != null;
                         if (isClassSatisfied && record.account != null) {
                             if (selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
@@ -385,6 +389,10 @@ export const toSetAllLineItemsToCategoryClass = (draft, transaction, transaction
                                     selectedCheckBoxTransactionIds.push(transaction.id);
                                 }
                             }
+                            // Project intentionally does NOT propagate to other rows of
+                            // the same vendor: each line can carry a different project,
+                            // and auto-filling siblings (the way class does) leads to
+                            // unexpected bulk selection.
                         }
                     }
                     if (line.type === 'transaction_with_product_or_service_line') {
@@ -514,6 +522,7 @@ export const setEntityRecommendationForLineIdInLocalData = (draft, transaction,
             ...newLineItem,
             class: matchingRecord.class,
             account: matchingRecord.account,
+            project: matchingRecord.project,
             lineEntity: matchingRecord.lineEntity,
         };
     }

package/lib/esm/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -1,6 +1,7 @@
 import { createSlice } from '@reduxjs/toolkit';
 import recordGet from 'lodash/get';
 import uniq from 'lodash/uniq';
+import { fetchEntityRecommendationsForCategorization, setCategoryClassRecommendationsForCategorizationFailure, } from '../../recommendation/recommendationReducer';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { isVendorTransaction } from '../../../entity/transaction/stateTypes/vendorTransaction';
 import { MAX_SELECTION_LIMIT, checkIfAllLineItemsAreCategoryClassFilled, filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
@@ -282,7 +283,7 @@ const expenseAutomationTransactionsView = createSlice({
         },
         setAllItemsToCategoryClassInLocalDataForCategorization: {
             reducer(draft, action) {
-                const { vendorId, customerId, selectedAccount, selectedClassBase, transactions, transactionId, lineId, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+                const { vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, transactions, transactionId, lineId, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
                 const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                     .transactionReviewLocalDataById, transactionId, undefined);
                 const existingAccount = transactionLocalData?.transactionReviewLocalData.lineItemById[lineId]
@@ -296,6 +297,7 @@ const expenseAutomationTransactionsView = createSlice({
                                 ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
                                 account: selectedAccount,
                                 class: selectedClassBase,
+                                project: selectedProjectBase,
                             },
                         },
                     };
@@ -324,9 +326,16 @@ const expenseAutomationTransactionsView = createSlice({
                         const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                             .transactionReviewLocalDataById, transaction.id, undefined);
                         if (transactionLocalData != null) {
-                            const { localData, similarTransactionUpdated } = toSetAllLineItemsToCategoryClass(draft.transactionCategorizationView[selectedTab], transaction, transactionId, lineId, transactionLocalData.transactionReviewLocalData, existingAccount?.accountId !== selectedAccount?.accountId
+                            const existingClassId = transactionLocalData.transactionReviewLocalData.lineItemById[lineId]?.class?.classId;
+                            const existingProjectId = transactionLocalData.transactionReviewLocalData.lineItemById[lineId]?.project?.projectId;
+                            const updatedItem = existingAccount?.accountId !== selectedAccount?.accountId
                                 ? 'category'
-                                : 'class', uncategorizedAccounts, selectedTab, vendorId, customerId, selectedAccount, selectedClassBase, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
+                                : existingClassId !== selectedClassBase?.classId
+                                    ? 'class'
+                                    : existingProjectId !== selectedProjectBase?.projectId
+                                        ? 'project'
+                                        : 'class';
+                            const { localData, similarTransactionUpdated } = toSetAllLineItemsToCategoryClass(draft.transactionCategorizationView[selectedTab], transaction, transactionId, lineId, transactionLocalData.transactionReviewLocalData, updatedItem, uncategorizedAccounts, selectedTab, vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
                             draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
                                 transactionId: transaction.id,
                                 transactionReviewLocalData: localData,
@@ -345,7 +354,7 @@ const expenseAutomationTransactionsView = createSlice({
                     ...dirtyIds,
                 ]);
             },
-            prepare(selectedTab, transactionId, lineId, transactions, uncategorizedAccounts, vendorId, customerId, selectedAccount, selectedClassBase, lineEntity, recommendations, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) {
+            prepare(selectedTab, transactionId, lineId, transactions, uncategorizedAccounts, vendorId, customerId, selectedAccount, selectedClassBase, lineEntity, recommendations, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled, selectedProjectBase) {
                 return {
                     payload: {
                         selectedTab,
@@ -357,6 +366,7 @@ const expenseAutomationTransactionsView = createSlice({
                         lineEntity,
                         selectedAccount,
                         selectedClassBase,
+                        selectedProjectBase,
                         recommendations,
                         uncategorizedAccounts,
                         isAccountingClassesEnabled,
@@ -387,9 +397,25 @@ const expenseAutomationTransactionsView = createSlice({
                 const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                     .transactionReviewLocalDataById, transactionId.id, undefined);
                 if (transactionLocalData != null) {
+                    const newLocalData = setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
+                    // Flip the per-line "fetching" flag to Completed for the lines this
+                    // fetch covered. Reads as the success arm of the
+                    // fetchEntityRecommendationsForCategorization → epic → reducer cycle.
+                    lineIds.forEach((lineId) => {
+                        const lineItem = newLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            newLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Completed',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
                     draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
                         transactionId: transaction.id,
-                        transactionReviewLocalData: setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled),
+                        transactionReviewLocalData: newLocalData,
                     };
                     // Mark transaction as dirty (autofill happened)
                     if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transaction.id)) {
@@ -444,7 +470,13 @@ const expenseAutomationTransactionsView = createSlice({
                 action.payload.status;
         },
         updateSelectedCustomerForTransaction(draft, action) {
-            const { transactionId, lineId, updatedCustomer, selectedTransaction, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+            const { transactionId, lineId, updatedCustomer, selectedTransaction, selectedTab,
+            // uncategorizedAccounts, isAccountingClassesEnabled, and
+            // isUncategorizedExpenseCategoryEnabled remain in the payload type for
+            // backward compatibility but are no longer read here — the post-fetch
+            // success reducer (setEntityRecommendationForLineIdsForCategorization)
+            // owns the all-fields-filled check that drives auto-selection.
+             } = action.payload;
             const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                 .transactionReviewLocalDataById, transactionId, undefined);
             if (transactionLocalData != null) {
@@ -493,18 +525,13 @@ const expenseAutomationTransactionsView = createSlice({
                     transactionReviewLocalData: newTransactionLocalData,
                     transactionId,
                 };
-                const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                    .selectedCheckBoxTransactionIds;
-                if (newTransactionLocalData.customer != null &&
-                    newTransactionLocalData.customer.id != null &&
-                    checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
-                    selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
-                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                        transactionId,
-                    ];
-                }
+                // Auto-selection of the row checkbox is intentionally deferred to
+                // setEntityRecommendationForLineIdsForCategorization (success path of
+                // the recommendations fetch). On a payee change the existing
+                // category/class are stale, so auto-selecting against them would
+                // either trigger save flows on the wrong data or rely on a later
+                // recommendations write to fix it. Letting the success reducer do the
+                // auto-add keeps "checkbox flips on" aligned with "fresh recs are in".
                 // Mark transaction as dirty (customer updated)
                 if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transactionId)) {
                     draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
@@ -516,7 +543,11 @@ const expenseAutomationTransactionsView = createSlice({
             }
         },
         updateSelectedVendorForTransaction(draft, action) {
-            const { transactionId, lineId, updatedVendor, selectedTransaction, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+            const { transactionId, lineId, updatedVendor, selectedTransaction, selectedTab,
+            // See updateSelectedCustomerForTransaction for why
+            // uncategorizedAccounts, isAccountingClassesEnabled, and
+            // isUncategorizedExpenseCategoryEnabled are no longer destructured.
+             } = action.payload;
             const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                 .transactionReviewLocalDataById, transactionId, undefined);
             if (transactionLocalData != null) {
@@ -569,18 +600,8 @@ const expenseAutomationTransactionsView = createSlice({
                     },
                     transactionId,
                 };
-                const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                    .selectedCheckBoxTransactionIds;
-                if (newTransactionLocalData.vendor != null &&
-                    newTransactionLocalData.vendor.id != null &&
-                    checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
-                    selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
-                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                        transactionId,
-                    ];
-                }
+                // See updateSelectedCustomerForTransaction above for why auto-select
+                // is deferred to setEntityRecommendationForLineIdsForCategorization.
                 // Mark transaction as dirty (vendor updated)
                 if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transactionId)) {
                     draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
@@ -793,6 +814,54 @@ const expenseAutomationTransactionsView = createSlice({
             },
         },
     },
+    extraReducers: (builder) => {
+        // Start arm of the categorization-only recommendations fetch. Marks every
+        // affected line's per-line flag as In-Progress. The epic uses
+        // groupBy(transactionId+lineIds) + switchMap, so concurrent fetches for
+        // distinct (transaction, lineIds-set) targets do not cancel each other —
+        // there's no need for a global cleanup sweep here.
+        builder.addCase(fetchEntityRecommendationsForCategorization, (draft, action) => {
+            const { selectedTab, transactionDetails } = action.payload;
+            const { transactionId, lineIds } = transactionDetails;
+            const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
+                .transactionReviewLocalDataById, transactionId.id, undefined);
+            if (transactionLocalData != null) {
+                lineIds.forEach((lineId) => {
+                    const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
+                    if (lineItem != null) {
+                        transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
+                            ...lineItem,
+                            categoryClassRecommendationsFetchState: {
+                                fetchState: 'In-Progress',
+                                error: undefined,
+                            },
+                        };
+                    }
+                });
+            }
+        });
+        // Failure arm. Flips the affected lines' per-line flag to Error so the
+        // skeleton resolves and the queued checkbox re-evaluation drops the entry.
+        builder.addCase(setCategoryClassRecommendationsForCategorizationFailure, (draft, action) => {
+            const { selectedTab, transactionId, lineIds, error } = action.payload;
+            const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
+                .transactionReviewLocalDataById, transactionId.id, undefined);
+            if (transactionLocalData != null) {
+                lineIds.forEach((lineId) => {
+                    const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
+                    if (lineItem != null) {
+                        transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
+                            ...lineItem,
+                            categoryClassRecommendationsFetchState: {
+                                fetchState: 'Error',
+                                error,
+                            },
+                        };
+                    }
+                });
+            }
+        });
+    },
 });
 export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
 export default expenseAutomationTransactionsView.reducer;

package/lib/esm/view/expenseAutomationView/selectors/transactionCategorizationSelector.js

@@ -1,14 +1,15 @@
 import omit from 'lodash/omit';
 import { reduceAllFetchState, reduceAnyFetchState, } from '../../../commonStateTypes/reduceFetchState';
 import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
-import { getIsAccountingClassesEnabled, getCurrentTenant, } from '../../../entity/tenant/tenantSelector';
+import { getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, } from '../../../entity/tenant/tenantSelector';
 import { getTransactionWithCOT } from '../../../entity/transaction/transactionHelper';
 import { getSupportedTransactionsByIds } from '../../../entity/transaction/transactionSelector';
 import { getAccountList, getNestedAccountListHierarchy, getUncategorizedAccounts, } from '../../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
+import { getProjectList } from '../../projectList/projectListSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationTransactionView(state) {
-    const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
+    const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, projectState, projectListState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
     const { selectedTransactionCategorizationTab } = expenseAutomationTransactionsViewState;
     const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = getUncategorizedAccounts(accountState, accountListState, 'accountList');
@@ -17,6 +18,8 @@ export function getExpenseAutomationTransactionView(state) {
     const allClasses = classList.classes.map((classData) => {
         return omit(classData, ['accountIds', 'key']);
     });
+    const projectList = getProjectList(projectState, projectListState);
+    const isAccountingProjectsEnabled = getIsAccountingProjectsEnabled(state);
     const accountsHierarchyList = getNestedAccountListHierarchy(accountListState, 'accountList');
     const classHierarchyList = getNestedClassListHierarchy(classListState);
     const currentTenant = getCurrentTenant(state);
@@ -39,6 +42,11 @@ export function getExpenseAutomationTransactionView(state) {
         return null;
     })
         .filter((transaction) => transaction != null);
+    // True if any visible line is currently fetching category/class
+    // recommendations because the user changed the payee. Used to disable Save
+    // and to defer manual checkbox selection.
+    const hasInFlightCategoryClassRecommendations = transactionLocalData.some((transaction) => Object.values(transaction.transactionReviewLocalData.lineItemById).some((lineItem) => lineItem.categoryClassRecommendationsFetchState?.fetchState ===
+        'In-Progress'));
     const transactions = getSupportedTransactionsByIds(transactionState, transactionIds);
     const transactionsWithCOT = transactions.map((transaction) => getTransactionWithCOT(transaction));
     const monthEndFetchState = monthYearPeriodId != null
@@ -96,6 +104,8 @@ export function getExpenseAutomationTransactionView(state) {
         classList: allClasses,
         accountsHierarchyList,
         classHierarchyList,
+        isAccountingProjectsEnabled,
+        projectList,
         transactionLocalData,
         uiState,
         refreshStatus,
@@ -107,5 +117,6 @@ export function getExpenseAutomationTransactionView(state) {
         uploadReceiptStatusById,
         selectedTransactionId,
         selectedTransactionLineId,
+        hasInFlightCategoryClassRecommendations,
     };
 }

package/lib/esm/view/expenseAutomationView/types/transactionsViewState.js

@@ -8,6 +8,7 @@ const TRANSACTIONS_SORT_KEYS = [
     'date',
     'category',
     'class',
+    'project',
     'memo_and_receipt',
 ];
 export const toTransactionsSortKey = (v) => stringToUnion(v, TRANSACTIONS_SORT_KEYS);

package/lib/esm/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -115,6 +115,50 @@ function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmou
         },
     };
 }
+/**
+ * Sum balances across descendant accounts (recursive).
+ *
+ * Parent rows in the horizontal pivot only carry their own direct postings
+ * (zero for "container" accounts), so callers rendering "Total {parent}" rows
+ * must aggregate from descendants to get the real per-class totals.
+ *
+ * Returns one `COABalance` per class column + total (same shape as the
+ * enriched `balancesInTimeframe.balances`), with `amount` summed and `type`
+ * set to `default_with_null_balance` for zeros. Returns `[]` when no
+ * descendants have enriched data.
+ */
+export function aggregateHorizontalDescendantBalances(accounts, childIndices, childrenByParent) {
+    let template;
+    const sums = new Map();
+    const walk = (idx) => {
+        const childRow = accounts[idx];
+        const childBalances = childRow?.accountReportData?.balancesInTimeframe.balances;
+        if (childBalances != null) {
+            if (template == null) {
+                template = childBalances;
+            }
+            childBalances.forEach((b, i) => {
+                sums.set(i, (sums.get(i) ?? 0) + (b.balance.amount ?? 0));
+            });
+        }
+        // Always recurse — a missing intermediate node should not prune its
+        // descendants from the aggregate.
+        const grandChildren = childrenByParent[idx] ?? [];
+        grandChildren.forEach(walk);
+    };
+    childIndices.forEach(walk);
+    if (template == null) {
+        return [];
+    }
+    return template.map((tpl, i) => {
+        const amount = sums.get(i) ?? 0;
+        return {
+            ...tpl,
+            balance: { ...tpl.balance, amount },
+            type: amount === 0 ? 'default_with_null_balance' : 'default',
+        };
+    });
+}
 /**
  * Parent index per DFS row — O(n). Matches the scan in the former
  * `findHorizontalAccountParentIndex` (depth <= 2 rows have no parent).

package/lib/esm/view/projectList/fetchProjectListEpic.js

@@ -0,0 +1,38 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap, withLatestFrom, } from 'rxjs/operators';
+import { updateProjects } from '../../entity/project/projectReducer';
+import { getIsAccountingProjectsEnabled } from '../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { fetchProjectList, updateProjectList, updateProjectListFailure, } from './projectListReducer';
+const buildProjectListQuery = (isIncludeDeleted) => {
+    const query = {
+        is_deleted: isIncludeDeleted,
+        sort_by: 'project_name',
+        sort_order: 'asc',
+        is_full: true,
+    };
+    return `?query=${encodeURIComponent(JSON.stringify(query))}`;
+};
+export const fetchProjectListEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchProjectList.match), withLatestFrom(state$), switchMap(([action, state]) => {
+    if (!getIsAccountingProjectsEnabled(state)) {
+        return of(updateProjectList({
+            status: createZeniAPIStatus('Success', ''),
+            data: { projects: [] },
+        }));
+    }
+    const { isIncludeDeleted } = action.payload;
+    const queryParams = buildProjectListQuery(isIncludeDeleted);
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/projects${queryParams}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return of(updateProjects(response.data?.projects ?? []), updateProjectList(response));
+        }
+        else {
+            return of(updateProjectListFailure(response.status));
+        }
+    }), catchError((error) => {
+        return of(updateProjectListFailure(createZeniAPIStatus('Unexpected Error', 'Fetch Projects REST API call errored out' +
+            JSON.stringify(error))));
+    }));
+}));

package/lib/esm/view/projectList/projectListPayload.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/projectList/projectListReducer.js

@@ -0,0 +1,39 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    projectIds: [],
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const projectList = createSlice({
+    name: 'projectList',
+    initialState,
+    reducers: {
+        fetchProjectList: {
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+                draft.error = undefined;
+            },
+            prepare(isIncludeDeleted) {
+                return { payload: { isIncludeDeleted: isIncludeDeleted ?? false } };
+            },
+        },
+        updateProjectList(draft, action) {
+            draft.projectIds =
+                action.payload.data?.projects?.map((project) => project.zeni_project_id) ?? [];
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateProjectListFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.error = action.payload;
+        },
+        clearProjectList(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchProjectList, updateProjectList, updateProjectListFailure, clearProjectList, } = projectList.actions;
+export default projectList.reducer;

package/lib/esm/view/projectList/projectListSelector.js

@@ -0,0 +1,9 @@
+import { getProjectsByIds } from '../../entity/project/projectSelector';
+export const getProjectList = (projectState, projectListState) => {
+    return {
+        projects: getProjectsByIds(projectState, projectListState.projectIds),
+        fetchState: projectListState.fetchState,
+        error: projectListState.error,
+        version: 0,
+    };
+};

package/lib/esm/view/projectList/projectListState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/recommendation/fetchEntityRecommendationsForCategorizationEpic.js

@@ -0,0 +1,83 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, groupBy, mergeMap, switchMap } from 'rxjs/operators';
+import { getIsAccountingClassesEnabled } from '../../entity/tenant/tenantSelector';
+import { getTransactionWithCOT, getTransactionWithCOTFromRecommendations, } from '../../entity/transaction/transactionHelper';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { setEntityRecommendationForLineIdsForCategorization } from '../../view/expenseAutomationView/reducers/transactionsViewReducer';
+import { getUncategorizedAccounts } from '../accountList/accountListSelector';
+import { getActualTransactionID } from '../transactionDetail/transactionDetailState';
+import { getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT, getRecommendationFromRecommendationPayload, } from './recommendationHelper';
+import { fetchEntityRecommendationsForCategorization, setCategoryClassRecommendationsForCategorizationFailure, updateRecommendationForEntity, } from './recommendationReducer';
+// Categorization-list-only recommendations fetch.
+//
+// Concurrency model: groupBy on (transactionId.id, sorted lineIds) → switchMap
+// inside each group → mergeMap to flatten groups. This means:
+//   • Same target (same transaction + same lineIds-set) — newer fetch cancels
+//     the prior in-flight fetch. Avoids the same-line stale-response race.
+//   • Different targets — run fully in parallel. Avoids the silent
+//     "stuck spinner" cancellation that the global-switchMap epic suffers
+//     from when the user moves between rows or JE lines mid-flight.
+//
+// The transactionsViewReducer's per-line categoryClassRecommendationsFetchState
+// flag is set to In-Progress when the action enters this epic (start arm in
+// extraReducers), Completed via setEntityRecommendationForLineIdsForCategorization,
+// or Error via setCategoryClassRecommendationsForCategorizationFailure.
+export const fetchEntityRecommendationsForCategorizationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchEntityRecommendationsForCategorization.match), groupBy((action) => {
+    const { transactionId, lineIds } = action.payload.transactionDetails;
+    return `${transactionId.id}|${[...lineIds].sort().join('|')}`;
+}), mergeMap((group$) => group$.pipe(switchMap((action) => {
+    const { entity, amount, transactionDetails, isFetchCOT, selectedTab, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+    const query = {
+        amount,
+        transaction_id: getActualTransactionID(transactionDetails.transactionId.id),
+        transaction_type: transactionDetails.transaction.type,
+        line_ids: transactionDetails.lineIds,
+    };
+    if (isFetchCOT === true) {
+        query.include_cot = true;
+    }
+    const entityQuery = {
+        entity_name: entity.name,
+        entity_type: entity.type,
+    };
+    const recommendationUrl = entity.qboId === entity.name // entity id null case
+        ? `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/recommendations?query=${encodeURIComponent(JSON.stringify(entityQuery))}`
+        : `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/${toEntityTypeURL(entity.type)}/${entity.qboId}/recommendations?query=${encodeURIComponent(JSON.stringify(query))}`;
+    return zeniAPI
+        .getJSON(recommendationUrl)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const actions = [];
+            const { transactionId, transaction, lineIds } = transactionDetails;
+            const recommendationWithCOTByLineId = getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT(response.data.recommendations, lineIds);
+            const recommendations = getRecommendationFromRecommendationPayload(response.data.recommendations);
+            const transactionWithCOT = isFetchCOT === true &&
+                recommendationWithCOTByLineId != null
+                ? getTransactionWithCOTFromRecommendations(transaction, recommendationWithCOTByLineId)
+                : getTransactionWithCOT(transaction);
+            actions.push(updateRecommendationForEntity({
+                entityId: entity.id,
+                entityType: entity.type,
+                recommendations,
+            }));
+            if (recommendationWithCOTByLineId != null) {
+                const uncategorizedIncomeExpense = getUncategorizedAccounts(state$.value.accountState, state$.value.accountListState, 'accountList');
+                actions.push(setEntityRecommendationForLineIdsForCategorization(selectedTab, transactionId, transactionWithCOT, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled, getIsAccountingClassesEnabled(state$.value)));
+            }
+            else {
+                // Successful HTTP but no per-line recommendations — still
+                // need to clear the In-Progress flag, otherwise the
+                // skeleton sticks. Treat as a "no recommendations" success
+                // by firing the failure action with a benign error so the
+                // line flag flips out of In-Progress.
+                actions.push(setCategoryClassRecommendationsForCategorizationFailure(selectedTab, transactionId, lineIds, createZeniAPIStatus('Unexpected Error', 'Recommendations response missing per-line data')));
+            }
+            return from(actions);
+        }
+        else {
+            return of(setCategoryClassRecommendationsForCategorizationFailure(selectedTab, transactionDetails.transactionId, transactionDetails.lineIds, response.status));
+        }
+    }), catchError((error) => of(setCategoryClassRecommendationsForCategorizationFailure(selectedTab, transactionDetails.transactionId, transactionDetails.lineIds, createZeniAPIStatus('Unexpected Error', 'Fetch recommendations for categorization REST API call errored out' +
+        JSON.stringify(error))))));
+}))));
+const toEntityTypeURL = (entityType) => `${entityType}s`;

package/lib/esm/view/recommendation/recommendationReducer.js

@@ -106,12 +106,63 @@ const recommendation = createSlice({
                 };
             },
         },
+        // Categorization-list-only fetch action. Mirrors the
+        // fetchEntityRecommendationsByTransactionId payload but is observed by a
+        // separate epic (with groupBy + switchMap, keyed on
+        // transactionId+lineIds-set) so concurrent fetches for distinct targets do
+        // not cancel each other. Reducer hooks in transactionsViewReducer use this
+        // to drive the per-line categoryClassRecommendationsFetchState flag.
+        fetchEntityRecommendationsForCategorization: {
+            reducer(draft, action) {
+                const { entity } = action.payload;
+                const key = getEntityRecommendationKey(entity.type, entity.id);
+                const existingRecommendation = draft.recommendationByEntity[key];
+                if (existingRecommendation == null) {
+                    draft.recommendationByEntity[key] = {
+                        ...initialEntityRecommendationState,
+                        fetchState: 'In-Progress',
+                    };
+                }
+            },
+            prepare(entity, amount, transactionDetails, selectedTab, isFetchCOT = false, isUncategorizedExpenseCategoryEnabled) {
+                return {
+                    payload: {
+                        entity,
+                        amount,
+                        transactionDetails,
+                        selectedTab,
+                        isFetchCOT,
+                        isUncategorizedExpenseCategoryEnabled,
+                    },
+                };
+            },
+        },
+        setCategoryClassRecommendationsForCategorizationFailure: {
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // The transactionsViewReducer handles the per-line flag flip; this
+                // reducer slice has no recommendation cache to update for the failure.
+            },
+            prepare(selectedTab, transactionId, lineIds, error) {
+                return {
+                    payload: {
+                        selectedTab,
+                        transactionId,
+                        lineIds,
+                        error,
+                    },
+                };
+            },
+        },
         clearRecommendation(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchEntityRecommendationsByTransactionId, fetchRecommendationByEntityName, fetchRecommendationByEntityId, updateRecommendationForEntity, updateRecommendationForEntityFailure, indicateReadyToInitializeRecommendation, clearRecommendation, } = recommendation.actions;
+export const { fetchEntityRecommendationsByTransactionId, fetchEntityRecommendationsForCategorization, setCategoryClassRecommendationsForCategorizationFailure, fetchRecommendationByEntityName, fetchRecommendationByEntityId, updateRecommendationForEntity, updateRecommendationForEntityFailure, indicateReadyToInitializeRecommendation, clearRecommendation, } = recommendation.actions;
 export default recommendation.reducer;
 const doUpdateRecommendationForEntity = (draft, entityId, entityType, payload) => {
     const key = getEntityRecommendationKey(entityType, entityId);