@zeniai/client-epic-state 5.1.56 → 5.1.57-betaDI0

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

@@ -64,117 +64,6 @@ export const getDateFilteredDeletedTransactionIds = (allParsedTransactions, stat
         !isStatementTransactionInPeriod(transaction.transactionDate, statementPeriod.statementStartDate, statementPeriod.statementEndDate))
         .map((transaction) => transaction.statementTransactionId);
 };
-const roundCurrency = (value) => Math.round(value * 100) / 100;
-const toApiDateString = (value) => {
-    if (value == null || value === '') {
-        return '';
-    }
-    return date(value).format('YYYY-MM-DD');
-};
-const computeStatementTransactionTotals = (transactions) => {
-    const totalDeposits = roundCurrency(transactions
-        .filter((txn) => txn.transactionDirection === 'credit')
-        .reduce((sum, txn) => sum + Math.abs(txn.amount ?? 0), 0));
-    const totalPayments = roundCurrency(transactions
-        .filter((txn) => txn.transactionDirection === 'debit')
-        .reduce((sum, txn) => sum + Math.abs(txn.amount ?? 0), 0));
-    return { totalDeposits, totalPayments };
-};
-const computeStatementClosingBalance = (openingBalance, totalDeposits, totalPayments, accountType) => roundCurrency(accountType === 'credit_card'
-    ? openingBalance + totalPayments - totalDeposits
-    : openingBalance + totalDeposits - totalPayments);
-const filterFormTransactionsInPeriod = (transactions, statementStartDate, statementEndDate) => {
-    if (statementStartDate === '' || statementEndDate === '') {
-        return transactions;
-    }
-    const periodStart = date(statementStartDate).startOf('day');
-    const periodEnd = date(statementEndDate).startOf('day');
-    return transactions.filter((txn) => {
-        if (txn.transactionDate === '') {
-            return true;
-        }
-        const txnDate = date(txn.transactionDate).startOf('day');
-        return (txnDate.isSameOrAfter(periodStart, 'day') &&
-            txnDate.isSameOrBefore(periodEnd, 'day'));
-    });
-};
-export const isStatementParseTransactionFieldChange = (changedField) => changedField === 'transactions' ||
-    changedField?.startsWith('transactions.') === true;
-const isStatementParseBalanceAffectingTransactionFieldChange = (changedField) => {
-    if (changedField === 'transactions') {
-        return true;
-    }
-    if (changedField?.startsWith('transactions.') !== true) {
-        return false;
-    }
-    return !changedField.endsWith('.transactionMemo');
-};
-export const isStatementParseManualBalanceField = (field) => field === 'totalDeposits' ||
-    field === 'totalPayments' ||
-    field === 'closingBalance';
-export const shouldRecalculateStatementParseBalances = (changedField) => isStatementParseBalanceAffectingTransactionFieldChange(changedField) ||
-    changedField === 'statementStartDate' ||
-    changedField === 'statementEndDate';
-export const resolveStatementParseBalanceFields = (formView, changedField, accountType) => {
-    const inPeriodTransactions = filterFormTransactionsInPeriod(formView.transactions, formView.statementStartDate, formView.statementEndDate);
-    const { totalDeposits, totalPayments } = computeStatementTransactionTotals(inPeriodTransactions);
-    if (!shouldRecalculateStatementParseBalances(changedField)) {
-        return {
-            openingBalance: formView.openingBalance,
-            closingBalance: formView.closingBalance,
-            totalDeposits: formView.totalDeposits,
-            totalPayments: formView.totalPayments,
-        };
-    }
-    return {
-        openingBalance: formView.openingBalance,
-        totalDeposits,
-        totalPayments,
-        closingBalance: computeStatementClosingBalance(formView.openingBalance, totalDeposits, totalPayments, accountType),
-    };
-};
-export const areStatementParseBalancesConsistent = (formView, accountType) => {
-    // Validate the four balance fields against each other (what the user sees),
-    // not against recomputed transaction totals. Manual deposits/payments edits
-    // are allowed as long as closing matches the account-type formula.
-    return (roundCurrency(formView.closingBalance) ===
-        computeStatementClosingBalance(formView.openingBalance, formView.totalDeposits, formView.totalPayments, accountType));
-};
-const mapParsedTransactionToFormRow = (transaction, index) => ({
-    id: transaction.statementTransactionId || `parsed-${index}`,
-    transactionDate: toApiDateString(transaction.transactionDate),
-    transactionMemo: transaction.transactionMemo,
-    amount: transaction.amount,
-    transactionDirection: transaction.transactionDirection,
-    statementTransactionId: transaction.statementTransactionId,
-});
-const mapLocalTransactionToFormRow = (transaction, id) => ({
-    id,
-    transactionDate: toApiDateString(transaction.transactionDate),
-    transactionMemo: transaction.transactionMemo,
-    amount: transaction.amount,
-    transactionDirection: transaction.transactionDirection,
-    statementTransactionId: transaction.statementTransactionId,
-});
-const buildStatementParseFormTransactions = (originalTransactions, localData) => {
-    const deletedIdSet = new Set(localData.statementTransactions?.deletedIds ?? []);
-    const updatedById = new Map((localData.statementTransactions?.updated ?? [])
-        .filter((transaction) => transaction.statementTransactionId != null)
-        .map((transaction) => [
-        transaction.statementTransactionId,
-        transaction,
-    ]));
-    const persistedTransactions = originalTransactions
-        .filter((transaction) => !deletedIdSet.has(transaction.statementTransactionId))
-        .map((transaction, index) => {
-        const updated = updatedById.get(transaction.statementTransactionId);
-        return updated != null
-            ? mapLocalTransactionToFormRow(updated, transaction.statementTransactionId)
-            : mapParsedTransactionToFormRow(transaction, index);
-    });
-    const addedTransactions = (localData.statementTransactions?.added ?? []).map((transaction, index) => mapLocalTransactionToFormRow(transaction, `added-${index}`));
-    return [...persistedTransactions, ...addedTransactions];
-};
 export const mergeStatementParseDeletedTransactionIds = (originalTransactions, statementPeriod, currentTransactionIds) => {
     const dateFilteredDeletedIds = getDateFilteredDeletedTransactionIds(originalTransactions, statementPeriod);
     const dateFilteredDeletedIdSet = new Set(dateFilteredDeletedIds);
@@ -185,116 +74,3 @@ export const mergeStatementParseDeletedTransactionIds = (originalTransactions, s
         .map((transaction) => transaction.statementTransactionId);
     return [...new Set([...userDeletedIds, ...dateFilteredDeletedIds])];
 };
-const resolveStatementMetaDates = (parsedStatementMeta, localMeta) => ({
-    statementStartDate: localMeta?.statementStartDate != null && localMeta.statementStartDate !== ''
-        ? localMeta.statementStartDate
-        : (parsedStatementMeta?.statementStartDate ?? ''),
-    statementEndDate: localMeta?.statementEndDate != null && localMeta.statementEndDate !== ''
-        ? localMeta.statementEndDate
-        : (parsedStatementMeta?.statementEndDate ?? ''),
-});
-export const getStatementParseFormView = ({ accountType, parsedStatementMeta, originalTransactions, statementUpdateLocalData, }) => {
-    const transactions = statementUpdateLocalData != null
-        ? buildStatementParseFormTransactions(originalTransactions, statementUpdateLocalData)
-        : originalTransactions.map(mapParsedTransactionToFormRow);
-    const localMeta = statementUpdateLocalData?.statementMeta;
-    const { statementStartDate, statementEndDate } = resolveStatementMetaDates(parsedStatementMeta, localMeta);
-    const { totalDeposits, totalPayments } = computeStatementTransactionTotals(filterFormTransactionsInPeriod(transactions, statementStartDate, statementEndDate));
-    const openingBalance = localMeta?.openingBalance ?? parsedStatementMeta?.openingBalance ?? 0;
-    const computedClosingBalance = computeStatementClosingBalance(openingBalance, totalDeposits, totalPayments, accountType);
-    return {
-        statementStartDate,
-        statementEndDate,
-        openingBalance,
-        closingBalance: localMeta?.closingBalance ?? computedClosingBalance,
-        totalDeposits: localMeta?.totalDeposits ?? totalDeposits,
-        totalPayments: localMeta?.totalPayments ?? totalPayments,
-        transactions: filterFormTransactionsInPeriod(transactions, statementStartDate, statementEndDate),
-    };
-};
-export const toStatementUpdateLocalDataFromFormView = ({ accountType, formView, parsedStatementMeta, originalTransactions, changedField, }) => {
-    const balanceFields = resolveStatementParseBalanceFields(formView, changedField, accountType);
-    const currentTransactionIds = new Set(formView.transactions
-        .map((transaction) => transaction.statementTransactionId)
-        .filter((id) => id != null && id !== ''));
-    const added = [];
-    const updated = [];
-    formView.transactions.forEach((transaction) => {
-        const transactionDate = toApiDateString(transaction.transactionDate);
-        if (transaction.statementTransactionId == null) {
-            if (transaction.transactionDirection != null) {
-                added.push({
-                    amount: transaction.amount,
-                    transactionDate,
-                    transactionDirection: transaction.transactionDirection,
-                    transactionMemo: transaction.transactionMemo,
-                });
-            }
-            return;
-        }
-        const original = originalTransactions.find((candidate) => candidate.statementTransactionId === transaction.statementTransactionId);
-        if (original != null &&
-            (original.amount !== transaction.amount ||
-                toApiDateString(original.transactionDate) !== transactionDate ||
-                original.transactionMemo !== transaction.transactionMemo)) {
-            updated.push({
-                amount: transaction.amount,
-                transactionDate,
-                transactionDirection: transaction.transactionDirection,
-                transactionMemo: transaction.transactionMemo,
-                statementTransactionId: transaction.statementTransactionId,
-            });
-        }
-    });
-    const statementPeriod = {
-        statementStartDate: toApiDateString(formView.statementStartDate),
-        statementEndDate: toApiDateString(formView.statementEndDate),
-    };
-    const deletedIds = mergeStatementParseDeletedTransactionIds(originalTransactions, statementPeriod, currentTransactionIds);
-    const deletedIdSet = new Set(deletedIds);
-    const inPeriodAdded = filterFormTransactionsInPeriod(added, statementPeriod.statementStartDate, statementPeriod.statementEndDate);
-    const inPeriodUpdated = updated.filter((transaction) => transaction.statementTransactionId != null &&
-        !deletedIdSet.has(transaction.statementTransactionId));
-    return {
-        statementMeta: {
-            closingBalance: balanceFields.closingBalance,
-            openingBalance: balanceFields.openingBalance,
-            statementDataStatus: parsedStatementMeta?.statementDataStatus ?? {
-                code: '',
-                label: '',
-            },
-            statementEndDate: statementPeriod.statementEndDate,
-            statementStartDate: statementPeriod.statementStartDate,
-            statementStatus: parsedStatementMeta?.statementStatus ?? {
-                code: '',
-                label: '',
-            },
-            statementUploadId: parsedStatementMeta?.statementUploadId ?? '',
-            totalDeposits: balanceFields.totalDeposits,
-            totalPayments: balanceFields.totalPayments,
-        },
-        statementTransactions: {
-            added: inPeriodAdded,
-            deletedIds,
-            updated: inPeriodUpdated,
-        },
-    };
-};
-export const applyStatementParseFormChange = ({ accountType, formView, changedField, parsedStatementMeta, originalTransactions, }) => {
-    const balanceFields = resolveStatementParseBalanceFields(formView, changedField, accountType);
-    const shouldRecalculate = shouldRecalculateStatementParseBalances(changedField);
-    const mergedFormView = shouldRecalculate
-        ? { ...formView, ...balanceFields }
-        : formView;
-    return {
-        didRecalculateBalances: shouldRecalculate,
-        formView: mergedFormView,
-        localData: toStatementUpdateLocalDataFromFormView({
-            accountType,
-            formView: mergedFormView,
-            parsedStatementMeta,
-            originalTransactions,
-            changedField,
-        }),
-    };
-};

package/lib/esm/view/notificationPreferencesView/epics/saveNotificationPreferencesEpic.js

@@ -0,0 +1,103 @@
+import { EMPTY, concat, of } from 'rxjs';
+import { catchError, debounceTime, filter, finalize, mergeMap, switchMap, withLatestFrom, } from 'rxjs/operators';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../responsePayload';
+import { notificationPreferencesUrl } from '../notificationPreferencesEndpoint';
+import { mapPreferencesToPayload, } from '../notificationPreferencesViewPayload';
+import { saveNotificationPreferences, saveNotificationPreferencesFailure, saveNotificationPreferencesSuccess, setGroupFrequency, toggleEventChannel, } from '../notificationPreferencesViewReducer';
+import { getNotificationLocalOverrides } from '../notificationPreferencesViewSelector';
+const DEBOUNCE_MS = 300;
+export const saveNotificationPreferencesEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter((action) => toggleEventChannel.match(action) || setGroupFrequency.match(action)), 
+// Coalesce bursts of toggles into a single PUT. Trade-off: rapid clickers
+// defer saves until they pause. Consider a max-wait wrapper if this
+// becomes a UX problem.
+debounceTime(DEBOUNCE_MS), withLatestFrom(state$), 
+// `switchMap` unsubscribes from any in-flight PUT observable when a new
+// debounced batch fires. The prior HTTP request has already left the
+// client — the network call is NOT cancelled — but its response is
+// ignored, so stale success/failure actions cannot clobber the newer
+// batch's state. Server-side ordering is arrival-order LWW.
+switchMap(([, state]) => {
+    const overrides = getNotificationLocalOverrides(state);
+    const preferencesPatch = mapPreferencesToPayload(overrides);
+    if (Object.keys(preferencesPatch).length === 0) {
+        // No diff → do not dispatch a synthetic success (that would wipe
+        // stored preferences via the reducer). Simply no-op.
+        return EMPTY;
+    }
+    // Snapshot the Cancel epoch at PUT-dispatch time. Every Cancel bumps
+    // `cancelEpoch`; the reducer compares the captured value on Success/
+    // Failure and skips the merge when the value has advanced (user
+    // pressed Cancel since this save started). See Cursor Bugbot 4aa021f7
+    // — the earlier counter model failed when `switchMap` abandoned an
+    // in-flight save's response (Success/Failure never dispatched, so
+    // the counter never drained and future saves got their merge dropped).
+    const cancelEpochAtDispatch = state.notificationPreferencesViewState.cancelEpoch;
+    const body = { task_checklist_preferences: preferencesPatch };
+    // Suppress the error snackbar when the response lands AFTER the user
+    // pressed Cancel — the Failure reducer already swallows the state
+    // update, so the toast would be a stale error for a save the user
+    // abandoned. `StateObservable#value` reads the current cancelEpoch at
+    // response time (not at dispatch time — that's what
+    // `cancelEpochAtDispatch` captures). Cursor Bugbot da2f4fe2 + Nikunj.
+    const errorSnackbar = openSnackbar({
+        messageSection: 'notification_settings_saved',
+        messageText: 'failed',
+        type: 'error',
+    });
+    const isCancelledSince = () => cancelEpochAtDispatch <
+        state$.value.notificationPreferencesViewState.cancelEpoch;
+    // Abort the in-flight HTTP request when `switchMap` disposes this
+    // observable (new debounced batch fires, tenant switch, unmount).
+    // Without an AbortSignal, `switchMap` would drop the response
+    // client-side but the older PUT would still land on the server —
+    // under patch-semantic LWW, a slower older PUT arriving after a
+    // newer one silently reverts the user's latest choice on the
+    // server. Cursor Bugbot e3861a76. `AbortController.abort()` is
+    // idempotent so it's safe if the request already completed.
+    const controller = new AbortController();
+    const request$ = zeniAPI
+        .putAndGetJSON(notificationPreferencesUrl(zeniAPI), body, undefined, controller.signal)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return of(saveNotificationPreferencesSuccess({
+                cancelEpochAtDispatch,
+                savedOverrides: overrides,
+                serverEcho: response.data?.task_checklist_preferences,
+            }));
+        }
+        const actions = [
+            saveNotificationPreferencesFailure({
+                cancelEpochAtDispatch,
+                error: response.status,
+            }),
+        ];
+        if (!isCancelledSince()) {
+            // Surface a user-visible error — without it the UI reverts to
+            // server truth after debounce and the failed toggle looks like
+            // a mystery UI bug.
+            actions.push(errorSnackbar);
+        }
+        return of(...actions);
+    }), catchError((error) => {
+        const actions = [
+            saveNotificationPreferencesFailure({
+                cancelEpochAtDispatch,
+                error: createZeniAPIStatus('Unexpected Error', 'Save notification preferences failed: ' +
+                    JSON.stringify(error)),
+            }),
+        ];
+        if (!isCancelledSince()) {
+            actions.push(errorSnackbar);
+        }
+        return of(...actions);
+    }), finalize(() => {
+        // switchMap disposal (new batch fires, cancel, unmount) → abort
+        // the still-in-flight HTTP request. No-op if the request has
+        // already completed successfully or errored.
+        controller.abort();
+    }));
+    // Flip savePreferencesState to In-Progress BEFORE the network call so
+    // any "saving…" UI can render.
+    return concat(of(saveNotificationPreferences()), request$);
+}));

package/lib/esm/view/notificationPreferencesView/notificationPreferencesEndpoint.js

@@ -0,0 +1,5 @@
+// Shared endpoint used by both the GET (envelope refresh in
+// `fetchNotificationSettingsEpic`) and the PUT (patch in
+// `saveNotificationPreferencesEpic`). Kept as a helper so an endpoint rename
+// can't drift between the two callers.
+export const notificationPreferencesUrl = (zeniAPI) => `${zeniAPI.apiEndPoints.notificationMicroServiceBaseUrl}/1.0/notification-preferences`;

package/lib/esm/view/notificationPreferencesView/notificationPreferencesViewPayload.js

@@ -0,0 +1,36 @@
+import { toNotificationChannel, toNotificationFrequency, } from '../../entity/notificationRegistry/notificationRegistryState';
+const mapEventEnabledByChannel = (raw) => {
+    if (raw == null) {
+        return {};
+    }
+    const out = {};
+    Object.entries(raw).forEach(([eventId, channelMap]) => {
+        const mapped = {};
+        Object.entries(channelMap).forEach(([channel, enabled]) => {
+            mapped[toNotificationChannel(channel)] = enabled;
+        });
+        out[eventId] = mapped;
+    });
+    return out;
+};
+export const mapPayloadToPreferences = (payload) => {
+    const groupFrequencyRaw = payload?.group_frequency_by_group_id ?? {};
+    const groupFrequencyByGroupId = Object.fromEntries(Object.entries(groupFrequencyRaw).map(([groupId, frequency]) => [
+        groupId,
+        toNotificationFrequency(frequency),
+    ]));
+    return {
+        eventEnabledByChannel: mapEventEnabledByChannel(payload?.event_enabled_by_channel),
+        groupFrequencyByGroupId,
+    };
+};
+export const mapPreferencesToPayload = (preferences) => {
+    const payload = {};
+    if (Object.keys(preferences.eventEnabledByChannel).length > 0) {
+        payload.event_enabled_by_channel = preferences.eventEnabledByChannel;
+    }
+    if (Object.keys(preferences.groupFrequencyByGroupId).length > 0) {
+        payload.group_frequency_by_group_id = preferences.groupFrequencyByGroupId;
+    }
+    return payload;
+};

package/lib/esm/view/notificationPreferencesView/notificationPreferencesViewReducer.js

@@ -0,0 +1,222 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { mapPayloadToPreferences, } from './notificationPreferencesViewPayload';
+import { emptyNotificationPreferences, } from './notificationPreferencesViewState';
+export const initialState = {
+    cancelEpoch: 0,
+    localOverrides: emptyNotificationPreferences(),
+    preferences: emptyNotificationPreferences(),
+    saveEpoch: 0,
+    savePreferencesState: { fetchState: 'Not-Started' },
+};
+const mergePreferences = (base, patch) => {
+    const eventEnabledByChannel = {
+        ...base.eventEnabledByChannel,
+    };
+    Object.entries(patch.eventEnabledByChannel).forEach(([eventId, channels]) => {
+        eventEnabledByChannel[eventId] = {
+            ...(base.eventEnabledByChannel[eventId] ?? {}),
+            ...channels,
+        };
+    });
+    return {
+        eventEnabledByChannel,
+        groupFrequencyByGroupId: {
+            ...base.groupFrequencyByGroupId,
+            ...patch.groupFrequencyByGroupId,
+        },
+    };
+};
+// Remove only the (eventId, channel) and groupId keys that were actually saved
+// to the server from `localOverrides` — AND whose current value still equals
+// what was saved. Any new edits the user added while the PUT was in flight
+// (either new keys not present in `saved`, OR same keys the user flipped back
+// to a different value) are preserved so the next debounce cycle picks them up.
+//
+// Presence-only subtraction (the prior implementation) silently dropped a
+// same-key re-edit that landed AFTER debounce fired but BEFORE the response
+// returned. Concrete case:
+//   1. toggle evt1.email = false → localOverrides = {evt1:{email:false}}
+//   2. debounce PUT #1 fires with savedOverrides = {evt1:{email:false}}
+//   3. user re-toggles evt1.email = true → localOverrides = {evt1:{email:true}}
+//   4. PUT #1 success → subtract dropped `email` on presence, so the true
+//      re-edit disappeared and next-debounce found nothing to send.
+const subtractSavedOverrides = (current, saved) => {
+    const eventEnabledByChannel = {};
+    Object.entries(current.eventEnabledByChannel).forEach(([eventId, channels]) => {
+        const savedChannels = saved.eventEnabledByChannel[eventId];
+        if (savedChannels == null) {
+            eventEnabledByChannel[eventId] = channels;
+            return;
+        }
+        const remainingChannels = {};
+        Object.keys(channels).forEach((channel) => {
+            // Preserve the key when it's a new channel OR when the user's
+            // current value differs from what was saved (same-key re-edit).
+            if (!(channel in savedChannels) ||
+                channels[channel] !== savedChannels[channel]) {
+                remainingChannels[channel] = channels[channel];
+            }
+        });
+        if (Object.keys(remainingChannels).length > 0) {
+            eventEnabledByChannel[eventId] = remainingChannels;
+        }
+    });
+    const groupFrequencyByGroupId = {};
+    Object.entries(current.groupFrequencyByGroupId).forEach(([groupId, frequency]) => {
+        if (saved.groupFrequencyByGroupId[groupId] !== frequency) {
+            groupFrequencyByGroupId[groupId] = frequency;
+        }
+    });
+    return { eventEnabledByChannel, groupFrequencyByGroupId };
+};
+const notificationPreferencesView = createSlice({
+    name: 'notificationPreferencesView',
+    initialState,
+    reducers: {
+        clearAllNotificationPreferencesView(draft) {
+            // Reset everything EXCEPT `cancelEpoch`, which must stay monotonic
+            // across the lifetime of the app instance. `initialState.cancelEpoch`
+            // is `0`; returning `initialState` verbatim would rewind the counter
+            // to zero, and any in-flight save whose `cancelEpochAtDispatch` was
+            // captured pre-clearAll (>0) would then satisfy the "captured >=
+            // current" epoch guard and merge stale edits into fresh preferences.
+            // Bumping instead of resetting also invalidates the abandoned save
+            // for free — Cursor Bugbot bc7876f1 followup.
+            const nextCancelEpoch = draft.cancelEpoch + 1;
+            // saveEpoch must also stay monotonic across clearAll for the same
+            // reason (Cursor Bugbot 3632510237). Rewinding to 0 would let a
+            // stale-in-flight GET whose `saveEpochAtDispatch` was captured >0
+            // satisfy the "captured >= current" epoch guard and clobber fresh
+            // preferences on any subsequent save.
+            const nextSaveEpoch = draft.saveEpoch + 1;
+            return {
+                ...initialState,
+                cancelEpoch: nextCancelEpoch,
+                saveEpoch: nextSaveEpoch,
+            };
+        },
+        clearNotificationPreferencesLocalOverrides(draft) {
+            // Discards in-flight per-event/per-group edits held in `localOverrides`
+            // without touching the fetched `preferences` snapshot. Used by the
+            // settings-page Cancel affordance so the effective preferences revert
+            // to the last server-known state without triggering a refetch race.
+            //
+            // Cancel/in-flight-save race: every Cancel bumps `cancelEpoch`
+            // monotonically. Any save that captured a lower epoch value at
+            // dispatch time is treated as stale by the Success/Failure reducer
+            // — its merge is skipped. Unconditional bump (vs the earlier
+            // counter model) survives switchMap abandonment and double-Cancel
+            // (Cursor Bugbot 4aa021f7): even if the abandoned save's
+            // Success/Failure never dispatches, subsequent legitimate saves
+            // still work because their captured epoch matches the current one.
+            draft.cancelEpoch += 1;
+            draft.localOverrides = emptyNotificationPreferences();
+            // Also drop `savePreferencesState` back to Not-Started so any
+            // "Saving…" affordance bound to `getNotificationPreferencesSaveState`
+            // clears on Cancel. Without this, a Cancel-during-save whose stale
+            // Success/Failure never fires (switchMap abandonment) leaves the
+            // selector reporting In-Progress forever — Cursor Bugbot bc7876f1.
+            draft.savePreferencesState = { fetchState: 'Not-Started' };
+        },
+        fetchNotificationPreferencesSuccess(draft, action) {
+            // Piggybacks on the settings-envelope fetch. The GET response is a full
+            // snapshot of the server-known preferences (empty maps included), so
+            // REPLACE `preferences` rather than merging — merging would leak keys
+            // the server has since removed. DO NOT touch `localOverrides`: a refetch
+            // that fires while the user has in-flight edits (pre-debounce) must not
+            // silently drop them; the save-success path is the only clearer.
+            // A `null`/`undefined` payload isn't a snapshot at all (e.g. the
+            // envelope key was omitted); no-op instead of wiping preferences.
+            if (action.payload.preferences == null) {
+                return;
+            }
+            // Stale-GET guard (Cursor Bugbot 3632510237): if the fetch epic
+            // captured a `saveEpoch` lower than the current one, a save has
+            // succeeded since this GET dispatched — the response is carrying
+            // the pre-PUT snapshot and would clobber the just-saved server
+            // truth back to the pre-edit state until the next refetch. Skip
+            // the replace; the store already reflects the fresher save.
+            if (action.payload.saveEpochAtDispatch < draft.saveEpoch) {
+                return;
+            }
+            draft.preferences = mapPayloadToPreferences(action.payload.preferences);
+        },
+        saveNotificationPreferences(draft) {
+            draft.savePreferencesState = { fetchState: 'In-Progress' };
+        },
+        saveNotificationPreferencesFailure(draft, action) {
+            // Stale failure from a cancelled-since save — swallow silently so
+            // the UI doesn't surface an error banner for a save the user
+            // already abandoned.
+            if (action.payload.cancelEpochAtDispatch < draft.cancelEpoch) {
+                return;
+            }
+            // Preserve `localOverrides` so the user's in-flight edits survive a
+            // transient network blip. UI should surface an error affordance and
+            // allow retry.
+            draft.savePreferencesState = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        saveNotificationPreferencesSuccess(draft, action) {
+            // Preserve-on-partial: PUT /preferences is patch-semantic. The response
+            // echoes only the fields that changed, so merge into `preferences`
+            // instead of replacing — otherwise a single-channel toggle would wipe
+            // every other stored preference.
+            //
+            // Rollback invariant (F5): `serverEcho` may be `undefined` if the server
+            // rolls back to an older shape that omits the echo entirely. In that
+            // case fall back to merging `savedOverrides` into `preferences` — the
+            // PUT succeeded (2xx), so the values we sent are now server truth. If
+            // we merged an empty patch instead, `subtractSavedOverrides` would
+            // still strip the just-saved keys from `localOverrides`, leaving the
+            // effective preferences (preferences ∪ localOverrides) reverted to the
+            // pre-edit server snapshot until the next refetch.
+            //
+            // In-flight-edit invariant: `savedOverrides` is the exact snapshot the
+            // epic PUT to the server. Subtracting those keys from `localOverrides`
+            // (instead of clearing it wholesale) preserves any edits the user
+            // added AFTER the debounce fired but BEFORE the response landed. The
+            // next debounce cycle will pick them up. Clearing wholesale drops
+            // in-flight edits from both UI (once server echo lands) and server.
+            // Cancel/in-flight-save race: `cancelEpoch` monotonically increases
+            // on every Cancel. If the save captured a lower epoch at dispatch,
+            // the user has pressed Cancel since — skip the `preferences` merge
+            // and the `localOverrides` subtract (Cancel already emptied it).
+            // Do NOT flip fetchState so a subsequent legit save can still show
+            // its own In-Progress → Completed lifecycle. The server itself has
+            // accepted the write — reverting server-side is out of FE scope; UI
+            // reflects the cancelled intention until the next refetch merges
+            // whatever the server persisted.
+            if (action.payload.cancelEpochAtDispatch < draft.cancelEpoch) {
+                return;
+            }
+            // Bump `saveEpoch` so any settings-envelope GET that was in flight
+            // BEFORE this PUT resolved is treated as stale. Its captured epoch
+            // will be lower than the new value, so its reducer branch will
+            // skip the `preferences` replace. Cursor Bugbot 3632510237.
+            draft.saveEpoch += 1;
+            draft.savePreferencesState = { fetchState: 'Completed' };
+            const patch = action.payload.serverEcho == null
+                ? action.payload.savedOverrides
+                : mapPayloadToPreferences(action.payload.serverEcho);
+            draft.preferences = mergePreferences(draft.preferences, patch);
+            draft.localOverrides = subtractSavedOverrides(draft.localOverrides, action.payload.savedOverrides);
+        },
+        setGroupFrequency(draft, action) {
+            draft.localOverrides.groupFrequencyByGroupId[action.payload.groupId] =
+                action.payload.frequency;
+        },
+        toggleEventChannel(draft, action) {
+            const { channel, enabled, eventId } = action.payload;
+            const eventMap = {
+                ...(draft.localOverrides.eventEnabledByChannel[eventId] ?? {}),
+            };
+            eventMap[channel] = enabled;
+            draft.localOverrides.eventEnabledByChannel[eventId] = eventMap;
+        },
+    },
+});
+export const { clearAllNotificationPreferencesView, clearNotificationPreferencesLocalOverrides, fetchNotificationPreferencesSuccess, saveNotificationPreferences, saveNotificationPreferencesFailure, saveNotificationPreferencesSuccess, setGroupFrequency, toggleEventChannel, } = notificationPreferencesView.actions;
+export default notificationPreferencesView.reducer;

package/lib/esm/view/notificationPreferencesView/notificationPreferencesViewSelector.js

@@ -0,0 +1,25 @@
+const getView = (state) => state.notificationPreferencesViewState;
+export const getNotificationPreferencesSaveState = (state) => getView(state).savePreferencesState;
+export const getEffectiveNotificationPreferences = (state) => {
+    const view = getView(state);
+    const mergedEventEnabledByChannel = { ...view.preferences.eventEnabledByChannel };
+    Object.entries(view.localOverrides.eventEnabledByChannel).forEach(([eventId, channels]) => {
+        mergedEventEnabledByChannel[eventId] = {
+            ...(view.preferences.eventEnabledByChannel[eventId] ?? {}),
+            ...channels,
+        };
+    });
+    return {
+        eventEnabledByChannel: mergedEventEnabledByChannel,
+        groupFrequencyByGroupId: {
+            ...view.preferences.groupFrequencyByGroupId,
+            ...view.localOverrides.groupFrequencyByGroupId,
+        },
+    };
+};
+export const getNotificationLocalOverrides = (state) => getView(state).localOverrides;
+export const hasUnsavedNotificationPreferences = (state) => {
+    const overrides = getView(state).localOverrides;
+    return (Object.keys(overrides.eventEnabledByChannel).length > 0 ||
+        Object.keys(overrides.groupFrequencyByGroupId).length > 0);
+};

package/lib/esm/view/notificationPreferencesView/notificationPreferencesViewState.js

@@ -0,0 +1,4 @@
+export const emptyNotificationPreferences = () => ({
+    eventEnabledByChannel: {},
+    groupFrequencyByGroupId: {},
+});