@zeniai/client-epic-state 5.1.60-betaAK0 → 5.1.60-betaDI1

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveNotificationPreferencesEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const snackbarReducer_1 = require("../../../entity/snackbar/snackbarReducer");
+const responsePayload_1 = require("../../../responsePayload");
+const notificationPreferencesEndpoint_1 = require("../notificationPreferencesEndpoint");
+const notificationPreferencesViewPayload_1 = require("../notificationPreferencesViewPayload");
+const notificationPreferencesViewReducer_1 = require("../notificationPreferencesViewReducer");
+const notificationPreferencesViewSelector_1 = require("../notificationPreferencesViewSelector");
+const DEBOUNCE_MS = 300;
+const saveNotificationPreferencesEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)((action) => notificationPreferencesViewReducer_1.toggleEventChannel.match(action) || notificationPreferencesViewReducer_1.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.
+(0, operators_1.debounceTime)(DEBOUNCE_MS), (0, operators_1.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.
+(0, operators_1.switchMap)(([, state]) => {
+    const overrides = (0, notificationPreferencesViewSelector_1.getNotificationLocalOverrides)(state);
+    const preferencesPatch = (0, notificationPreferencesViewPayload_1.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 rxjs_1.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 = (0, snackbarReducer_1.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((0, notificationPreferencesEndpoint_1.notificationPreferencesUrl)(zeniAPI), body, undefined, controller.signal)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            return (0, rxjs_1.of)((0, notificationPreferencesViewReducer_1.saveNotificationPreferencesSuccess)({
+                cancelEpochAtDispatch,
+                savedOverrides: overrides,
+                serverEcho: response.data?.task_checklist_preferences,
+            }));
+        }
+        const actions = [
+            (0, notificationPreferencesViewReducer_1.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 (0, rxjs_1.of)(...actions);
+    }), (0, operators_1.catchError)((error) => {
+        const actions = [
+            (0, notificationPreferencesViewReducer_1.saveNotificationPreferencesFailure)({
+                cancelEpochAtDispatch,
+                error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Save notification preferences failed: ' +
+                    JSON.stringify(error)),
+            }),
+        ];
+        if (!isCancelledSince()) {
+            actions.push(errorSnackbar);
+        }
+        return (0, rxjs_1.of)(...actions);
+    }), (0, operators_1.finalize)(() => {
+        // switchMap disposal (new batch fires, unmount) OR the takeUntil
+        // below (Cancel fires) → abort the still-in-flight HTTP request.
+        // No-op if the request has already completed successfully or
+        // errored. Without this, the pre-Cancel PUT would still land on
+        // the server; under patch-semantic LWW, a slower older PUT
+        // arriving after Cancel silently reverts the user's just-cleared
+        // overrides on the server.
+        controller.abort();
+    }), 
+    // Cancel and tenant-switch/logout do not flow through the outer
+    // `filter`, so switchMap would never dispose this observable on
+    // either. `takeUntil` completes request$ on Cancel OR clear-all,
+    // which triggers finalize above (aborts the in-flight HTTP
+    // request). Without matching clear-all, a tenant switch during
+    // an in-flight PUT would let the older PUT land on the server
+    // under patch-semantic LWW. Cursor Bugbot 3637969823 + 3641372002.
+    (0, operators_1.takeUntil)(actions$.pipe((0, operators_1.filter)((action) => notificationPreferencesViewReducer_1.clearNotificationPreferencesLocalOverrides.match(action) ||
+        notificationPreferencesViewReducer_1.clearAllNotificationPreferencesView.match(action)))));
+    // Flip savePreferencesState to In-Progress BEFORE the network call so
+    // any "saving…" UI can render.
+    return (0, rxjs_1.concat)((0, rxjs_1.of)((0, notificationPreferencesViewReducer_1.saveNotificationPreferences)()), request$);
+}));
+exports.saveNotificationPreferencesEpic = saveNotificationPreferencesEpic;

package/lib/view/notificationPreferencesView/notificationPreferencesEndpoint.d.ts

@@ -0,0 +1,2 @@
+import { ZeniAPI } from '../../zeniAPI';
+export declare const notificationPreferencesUrl: (zeniAPI: ZeniAPI) => string;

package/lib/view/notificationPreferencesView/notificationPreferencesEndpoint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationPreferencesUrl = void 0;
+// 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.
+const notificationPreferencesUrl = (zeniAPI) => `${zeniAPI.apiEndPoints.notificationMicroServiceBaseUrl}/1.0/notification-preferences`;
+exports.notificationPreferencesUrl = notificationPreferencesUrl;

package/lib/view/notificationPreferencesView/notificationPreferencesViewPayload.d.ts

@@ -0,0 +1,7 @@
+import { NotificationPreferences } from './notificationPreferencesViewState';
+export interface NotificationPreferencesPayload {
+    event_enabled_by_channel?: Record<string, Record<string, boolean>>;
+    group_frequency_by_group_id?: Record<string, string>;
+}
+export declare const mapPayloadToPreferences: (payload?: NotificationPreferencesPayload) => NotificationPreferences;
+export declare const mapPreferencesToPayload: (preferences: NotificationPreferences) => Record<string, unknown>;

package/lib/view/notificationPreferencesView/notificationPreferencesViewPayload.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPreferencesToPayload = exports.mapPayloadToPreferences = void 0;
+const notificationRegistryState_1 = require("../../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[(0, notificationRegistryState_1.toNotificationChannel)(channel)] = enabled;
+        });
+        out[eventId] = mapped;
+    });
+    return out;
+};
+const mapPayloadToPreferences = (payload) => {
+    const groupFrequencyRaw = payload?.group_frequency_by_group_id ?? {};
+    const groupFrequencyByGroupId = Object.fromEntries(Object.entries(groupFrequencyRaw).map(([groupId, frequency]) => [
+        groupId,
+        (0, notificationRegistryState_1.toNotificationFrequency)(frequency),
+    ]));
+    return {
+        eventEnabledByChannel: mapEventEnabledByChannel(payload?.event_enabled_by_channel),
+        groupFrequencyByGroupId,
+    };
+};
+exports.mapPayloadToPreferences = mapPayloadToPreferences;
+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;
+};
+exports.mapPreferencesToPayload = mapPreferencesToPayload;

package/lib/view/notificationPreferencesView/notificationPreferencesViewReducer.d.ts

@@ -0,0 +1,30 @@
+import { NotificationChannel, NotificationFrequency } from '../../entity/notificationRegistry/notificationRegistryState';
+import { ZeniAPIStatus } from '../../responsePayload';
+import { NotificationPreferencesPayload } from './notificationPreferencesViewPayload';
+import { NotificationPreferences, NotificationPreferencesViewState } from './notificationPreferencesViewState';
+export declare const initialState: NotificationPreferencesViewState;
+export interface SetFrequencyPayload {
+    frequency: NotificationFrequency;
+    groupId: string;
+}
+export interface TogglePreferencePayload {
+    channel: NotificationChannel;
+    enabled: boolean;
+    eventId: string;
+}
+export interface FetchNotificationPreferencesSuccessPayload {
+    preferences: NotificationPreferencesPayload | undefined;
+    saveEpochAtDispatch: number;
+}
+export interface SaveNotificationPreferencesSuccessPayload {
+    cancelEpochAtDispatch: number;
+    savedOverrides: NotificationPreferences;
+    serverEcho: NotificationPreferencesPayload | undefined;
+}
+export interface SaveNotificationPreferencesFailurePayload {
+    cancelEpochAtDispatch: number;
+    error?: ZeniAPIStatus;
+}
+export declare const clearAllNotificationPreferencesView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"notificationPreferencesView/clearAllNotificationPreferencesView">, clearNotificationPreferencesLocalOverrides: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"notificationPreferencesView/clearNotificationPreferencesLocalOverrides">, fetchNotificationPreferencesSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<FetchNotificationPreferencesSuccessPayload, "notificationPreferencesView/fetchNotificationPreferencesSuccess">, saveNotificationPreferences: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"notificationPreferencesView/saveNotificationPreferences">, saveNotificationPreferencesFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<SaveNotificationPreferencesFailurePayload, "notificationPreferencesView/saveNotificationPreferencesFailure">, saveNotificationPreferencesSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<SaveNotificationPreferencesSuccessPayload, "notificationPreferencesView/saveNotificationPreferencesSuccess">, setGroupFrequency: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetFrequencyPayload, "notificationPreferencesView/setGroupFrequency">, toggleEventChannel: import("@reduxjs/toolkit").ActionCreatorWithPayload<TogglePreferencePayload, "notificationPreferencesView/toggleEventChannel">;
+declare const _default: import("redux").Reducer<NotificationPreferencesViewState>;
+export default _default;

package/lib/view/notificationPreferencesView/notificationPreferencesViewReducer.js

@@ -0,0 +1,226 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleEventChannel = exports.setGroupFrequency = exports.saveNotificationPreferencesSuccess = exports.saveNotificationPreferencesFailure = exports.saveNotificationPreferences = exports.fetchNotificationPreferencesSuccess = exports.clearNotificationPreferencesLocalOverrides = exports.clearAllNotificationPreferencesView = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const notificationPreferencesViewPayload_1 = require("./notificationPreferencesViewPayload");
+const notificationPreferencesViewState_1 = require("./notificationPreferencesViewState");
+exports.initialState = {
+    cancelEpoch: 0,
+    localOverrides: (0, notificationPreferencesViewState_1.emptyNotificationPreferences)(),
+    preferences: (0, notificationPreferencesViewState_1.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 = (0, toolkit_1.createSlice)({
+    name: 'notificationPreferencesView',
+    initialState: exports.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 {
+                ...exports.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 = (0, notificationPreferencesViewState_1.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 = (0, notificationPreferencesViewPayload_1.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
+                : (0, notificationPreferencesViewPayload_1.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;
+        },
+    },
+});
+_a = notificationPreferencesView.actions, exports.clearAllNotificationPreferencesView = _a.clearAllNotificationPreferencesView, exports.clearNotificationPreferencesLocalOverrides = _a.clearNotificationPreferencesLocalOverrides, exports.fetchNotificationPreferencesSuccess = _a.fetchNotificationPreferencesSuccess, exports.saveNotificationPreferences = _a.saveNotificationPreferences, exports.saveNotificationPreferencesFailure = _a.saveNotificationPreferencesFailure, exports.saveNotificationPreferencesSuccess = _a.saveNotificationPreferencesSuccess, exports.setGroupFrequency = _a.setGroupFrequency, exports.toggleEventChannel = _a.toggleEventChannel;
+exports.default = notificationPreferencesView.reducer;

package/lib/view/notificationPreferencesView/notificationPreferencesViewSelector.d.ts

@@ -0,0 +1,7 @@
+import { FetchStateAndError } from '../../commonStateTypes/common';
+import { RootState } from '../../reducer';
+import { NotificationPreferences } from './notificationPreferencesViewState';
+export declare const getNotificationPreferencesSaveState: (state: RootState) => FetchStateAndError;
+export declare const getEffectiveNotificationPreferences: (state: RootState) => NotificationPreferences;
+export declare const getNotificationLocalOverrides: (state: RootState) => NotificationPreferences;
+export declare const hasUnsavedNotificationPreferences: (state: RootState) => boolean;

package/lib/view/notificationPreferencesView/notificationPreferencesViewSelector.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUnsavedNotificationPreferences = exports.getNotificationLocalOverrides = exports.getEffectiveNotificationPreferences = exports.getNotificationPreferencesSaveState = void 0;
+const getView = (state) => state.notificationPreferencesViewState;
+const getNotificationPreferencesSaveState = (state) => getView(state).savePreferencesState;
+exports.getNotificationPreferencesSaveState = getNotificationPreferencesSaveState;
+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,
+        },
+    };
+};
+exports.getEffectiveNotificationPreferences = getEffectiveNotificationPreferences;
+const getNotificationLocalOverrides = (state) => getView(state).localOverrides;
+exports.getNotificationLocalOverrides = getNotificationLocalOverrides;
+const hasUnsavedNotificationPreferences = (state) => {
+    const overrides = getView(state).localOverrides;
+    return (Object.keys(overrides.eventEnabledByChannel).length > 0 ||
+        Object.keys(overrides.groupFrequencyByGroupId).length > 0);
+};
+exports.hasUnsavedNotificationPreferences = hasUnsavedNotificationPreferences;

package/lib/view/notificationPreferencesView/notificationPreferencesViewState.d.ts

@@ -0,0 +1,14 @@
+import { FetchStateAndError } from '../../commonStateTypes/common';
+import { NotificationChannel, NotificationFrequency } from '../../entity/notificationRegistry/notificationRegistryState';
+export interface NotificationPreferences {
+    eventEnabledByChannel: Record<string, Partial<Record<NotificationChannel, boolean>>>;
+    groupFrequencyByGroupId: Record<string, NotificationFrequency>;
+}
+export interface NotificationPreferencesViewState {
+    cancelEpoch: number;
+    localOverrides: NotificationPreferences;
+    preferences: NotificationPreferences;
+    saveEpoch: number;
+    savePreferencesState: FetchStateAndError;
+}
+export declare const emptyNotificationPreferences: () => NotificationPreferences;

package/lib/view/notificationPreferencesView/notificationPreferencesViewState.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyNotificationPreferences = void 0;
+const emptyNotificationPreferences = () => ({
+    eventEnabledByChannel: {},
+    groupFrequencyByGroupId: {},
+});
+exports.emptyNotificationPreferences = emptyNotificationPreferences;

package/lib/view/onboardingView/cockpitView/epic/initializeOnboardingCustomerViewUpdateDataEpic.js

@@ -126,7 +126,11 @@ const getSelectedProducts = (isDebitCardFlagEnabled, tenant) => {
         return [];
     }
     else if (isBookkeepingEnabled) {
-        return ['bookkeeping', 'zeni_bill_pay', 'zeni_reimbursements'];
+        return [
+            'bookkeeping',
+            'zeni_bill_pay',
+            'zeni_reimbursements',
+        ];
     }
     else if (isOtherProductsEnabled) {
         const selectedProducts = [];

package/lib/view/onboardingView/customerView/epic/customerDetails/updateOnboardingCustomerViewLocalStoreDataEpic.js

@@ -84,8 +84,9 @@ const updateOnboardingCustomerViewLocalStoreDataEpic = (actions$, state$) => act
                 companyView?.company.company.companyOnboardingInfo
                     .subscriptionBillingAddressId != null) {
                 updatedCurrentStep = 'connect_ledger';
-                const isOnboardingAiActivationViewed = companyOnboardingInfo?.onboardingInfo?.onboardingAiActivationInfo
-                    ?.isOnboardingAiActivationViewed ?? false;
+                const isOnboardingAiActivationViewed = companyOnboardingInfo?.onboardingInfo
+                    ?.onboardingAiActivationInfo?.isOnboardingAiActivationViewed ??
+                    false;
                 // Past the ledger step we always sit on connect_data_source —
                 // it has many integrations, so we treat it as never auto-complete
                 // and only advance to verification on an explicit user dispatch.
@@ -119,9 +120,7 @@ const updateOnboardingCustomerViewLocalStoreDataEpic = (actions$, state$) => act
             // stale subStep (e.g. 'default' carried over from another step)
             // leaves verification rendering an empty form.
             if (updatedCurrentStep !== onboardingCustomerViewState.currentStep) {
-                const targetSubStep = updatedCurrentStep === 'verification'
-                    ? 'unlock-stack'
-                    : 'default';
+                const targetSubStep = updatedCurrentStep === 'verification' ? 'unlock-stack' : 'default';
                 fetchActions.push((0, onboardingCustomerViewReducer_1.updateCurrentSubStep)({ subStep: targetSubStep }));
             }
         }

package/lib/view/settingsView/epic/fetchNotificationSettingsEpic.d.ts

@@ -1,8 +1,10 @@
 import { ActionsObservable, StateObservable } from 'redux-observable';
+import { updateNotificationRegistry } from '../../../entity/notificationRegistry/notificationRegistryReducer';
 import { RootState } from '../../../reducer';
 import { ZeniAPI } from '../../../zeniAPI';
+import { fetchNotificationPreferencesSuccess } from '../../notificationPreferencesView/notificationPreferencesViewReducer';
 import { fetchNotificationSettings, updateNotificationSettingsOnFailure, updateNotificationSettingsOnSuccess } from '../settingsViewReducer';
-export type ActionType = ReturnType<typeof fetchNotificationSettings> | ReturnType<typeof updateNotificationSettingsOnSuccess> | ReturnType<typeof updateNotificationSettingsOnFailure>;
+export type ActionType = ReturnType<typeof fetchNotificationSettings> | ReturnType<typeof updateNotificationSettingsOnSuccess> | ReturnType<typeof updateNotificationSettingsOnFailure> | ReturnType<typeof updateNotificationRegistry> | ReturnType<typeof fetchNotificationPreferencesSuccess>;
 export declare const fetchNotificationSettingsEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
     payload: undefined;
     type: "settings/fetchNotificationSettings";
@@ -15,4 +17,10 @@ export declare const fetchNotificationSettingsEpic: (actions$: ActionsObservable
 } | {
     payload: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
     type: "settings/updateNotificationSettingsOnFailure";
+} | {
+    payload: import("../../../entity/notificationRegistry/notificationRegistryReducer").UpdateNotificationRegistryPayload;
+    type: "notificationRegistry/updateNotificationRegistry";
+} | {
+    payload: import("../../notificationPreferencesView/notificationPreferencesViewReducer").FetchNotificationPreferencesSuccessPayload;
+    type: "notificationPreferencesView/fetchNotificationPreferencesSuccess";
 }>;

package/lib/view/settingsView/epic/fetchNotificationSettingsEpic.js

@@ -3,20 +3,52 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchNotificationSettingsEpic = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
+const notificationRegistryReducer_1 = require("../../../entity/notificationRegistry/notificationRegistryReducer");
 const responsePayload_1 = require("../../../responsePayload");
+const notificationPreferencesEndpoint_1 = require("../../notificationPreferencesView/notificationPreferencesEndpoint");
+const notificationPreferencesViewReducer_1 = require("../../notificationPreferencesView/notificationPreferencesViewReducer");
 const settingsViewReducer_1 = require("../settingsViewReducer");
 const fetchNotificationSettingsEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(settingsViewReducer_1.fetchNotificationSettings.match), (0, operators_1.switchMap)(() => {
     const state = state$.value;
-    const URL = `${zeniAPI.apiEndPoints.notificationMicroServiceBaseUrl}/1.0/notification-preferences`;
     const userEmail = state.tenantState.loggedInUser?.userEmail;
     if (userEmail == null) {
         return (0, rxjs_1.from)([]);
     }
-    return zeniAPI.getJSON(URL).pipe((0, operators_1.mergeMap)((response) => {
+    // Snapshot the save epoch at GET-dispatch time. The reducer compares
+    // the captured value against the current `saveEpoch` on response and
+    // skips the `preferences` replace when a save has landed in the
+    // meantime — the GET is carrying the pre-PUT snapshot and would
+    // otherwise clobber the fresh save. Cursor Bugbot 3632510237.
+    const saveEpochAtDispatch = state.notificationPreferencesViewState.saveEpoch;
+    // Snapshot the registry clear epoch at GET-dispatch time (same idiom as
+    // `saveEpochAtDispatch` above). The registry reducer compares it against
+    // the current `registryEpoch` and skips its write when a
+    // `clearAllNotificationRegistry` (tenant switch) has landed since — the
+    // GET is carrying the prior tenant's snapshot. Cursor Bugbot 67d6918e.
+    const registryEpochAtDispatch = state.notificationRegistryState.registryEpoch;
+    return zeniAPI
+        .getJSON((0, notificationPreferencesEndpoint_1.notificationPreferencesUrl)(zeniAPI))
+        .pipe((0, operators_1.mergeMap)((response) => {
         if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
             const updateActions = [
                 (0, settingsViewReducer_1.updateNotificationSettingsOnSuccess)(response.data, userEmail),
             ];
+            // Always dispatch — an absent `task_checklist_registry` (gate
+            // off) must CLEAR the prior tenant's registry, not leave it in
+            // place. The reducer clears on `undefined` and full-replaces
+            // otherwise, both guarded by the registry epoch so a stale GET
+            // that lands after a tenant switch is skipped. Cursor Bugbot
+            // 67d6918e.
+            updateActions.push((0, notificationRegistryReducer_1.updateNotificationRegistry)({
+                registry: response.data.task_checklist_registry ?? undefined,
+                registryEpochAtDispatch,
+            }));
+            if (response.data.task_checklist_preferences != null) {
+                updateActions.push((0, notificationPreferencesViewReducer_1.fetchNotificationPreferencesSuccess)({
+                    preferences: response.data.task_checklist_preferences,
+                    saveEpochAtDispatch,
+                }));
+            }
             return (0, rxjs_1.of)(...updateActions);
         }
         else {