@griddo/ax 12.6.0 → 12.6.1

package/src/__tests__/store/persist.test.ts

@@ -0,0 +1,47 @@
+import { dropBlacklistedAreas } from "../../GlobalStore";
+
+/**
+ * The blacklist alone does not stop a rehydration, and that asymmetry is the whole
+ * reason `dropBlacklistedAreas` exists: redux-persist filters keys when it WRITES
+ * (`createPersistoid`), but `getStoredState` returns every key an earlier release
+ * stored and `autoMergeLevel1` hard-sets them all back into the tree.
+ *
+ * So on the first boot after the deploy — before any write has replaced the blob —
+ * the areas that just left the persist (ADR 0002) would come back from it, which is
+ * exactly the stale state the ADR removes: another site's data, in a screen that then
+ * PUTs it back to the server.
+ */
+const persistedBlob = (areas: Record<string, unknown>) =>
+	({ _persist: { version: -1, rehydrated: true }, ...areas }) as never;
+
+describe("dropping the de-persisted areas on rehydrate", () => {
+	it("drops the areas that left the persist from a blob written by an earlier release", async () => {
+		const stored = persistedBlob({
+			sites: { currentSiteInfo: { id: 3 } },
+			domains: { robots: [{ id: 1, content: "stale" }] },
+			redirects: { items: [{ id: 9 }] },
+			activityLog: { activityLog: { totalItems: 4, items: [] } },
+		});
+
+		const migrated = (await dropBlacklistedAreas(stored)) as unknown as Record<string, unknown>;
+
+		expect(Object.keys(migrated).sort()).toEqual(["_persist", "sites"]);
+		// The areas still in the persist are untouched: dropping them would be the
+		// opposite bug, since their consumers have no other loader.
+		expect(migrated.sites).toEqual({ currentSiteInfo: { id: 3 } });
+	});
+
+	it("keeps the areas that are still persisted, `social` and `analytics` among them", async () => {
+		const stored = persistedBlob({
+			social: { twitter: "https://x.com/griddo" },
+			analytics: { scriptCode: "<script>ga</script>", groups: [] },
+			pageEditor: { editorContent: {} },
+		});
+
+		expect(await dropBlacklistedAreas(stored)).toEqual(stored);
+	});
+
+	it("passes an empty storage through, so a first-ever visit rehydrates nothing", async () => {
+		expect(await dropBlacklistedAreas(undefined)).toBeUndefined();
+	});
+});

package/src/__tests__/store/redirects.test.ts

@@ -0,0 +1,313 @@
+import { redirects } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { redirectsActions, redirectsReducer } from "@ax/containers/Redirects";
+import { type ISitesState, sitesInitialState, sitesReducer } from "@ax/containers/Sites/reducer";
+import type { IRedirect, ISite } from "@ax/types";
+
+import { configureStore, type Reducer, type UnknownAction } from "@reduxjs/toolkit";
+import type { MockInstance } from "vitest";
+
+/**
+ * Characterisation tests for the `redirects` area — the URL redirect manager behind
+ * `/settings/redirects` (UC-AX-manage-redirects). The area had **zero** tests, so this
+ * file is written against the legacy `actions.tsx` + `reducer.tsx` first and must keep
+ * passing against the slice.
+ *
+ * The five thunks are dispatched through the one-line adapters below instead of inline.
+ * createAsyncThunk takes exactly ONE argument, so all five change call shape when the
+ * area migrates (docs/RTK-MIGRATION.md §5) — routing them through adapters means the
+ * migration edits five lines and **not a single assertion**, which is what makes the
+ * "passes unchanged" claim checkable rather than a slogan.
+ *
+ * Behaviours here that a rewrite loses quietly:
+ *
+ *   - `getRedirects` **empties the list before asking**, so the table blanks instead of
+ *     showing the previous page under a spinner.
+ *   - every write reloads through `getRedirects`, and the filter it reloads with depends
+ *     on scope: `&sites={id}` when a site is loaded, otherwise whatever filter the caller
+ *     passed. Import is the exception — it reloads unfiltered.
+ *   - a **409 on create is not an error**: it means "this `from` already exists" and drives
+ *     the overwrite flow, so it must NOT reach the error toast.
+ */
+
+const SITE_ID = 7;
+
+const PARAMS = { page: 1, itemsPerPage: 50, pagination: true, query: "", filterBy: "" };
+// What every write reloads with — `DEFAULT_PARAMS` in the area's constants.
+const RELOAD_PARAMS = { page: 1, itemsPerPage: 50, pagination: true };
+const SITE_FILTER = `&sites=${SITE_ID}`;
+
+const REDIRECT: IRedirect = { id: 1, from: "/old", to: { url: "/new" }, date: "2026-08-10" };
+const OTHER: IRedirect = { id: 2, from: "/older", to: { url: "/newer" }, date: "2026-08-09" };
+const FORM = { from: "/old", to: "/new" };
+
+// `ReturnType<…>` rather than naming the state type: it lives in `reducer.tsx` today and in
+// `slice.ts` afterwards, and this file must not have to follow it. The casts are the ones
+// GlobalStore uses — RTK types reducers against redux 5's UnknownAction (§8.3).
+type RedirectsState = ReturnType<typeof redirectsReducer>;
+
+const makeStore = (currentSiteInfo: ISite | null = null) =>
+	configureStore({
+		reducer: {
+			redirects: redirectsReducer as unknown as Reducer<RedirectsState, UnknownAction>,
+			sites: sitesReducer as Reducer<ISitesState, UnknownAction>,
+		},
+		preloadedState: { sites: { ...sitesInitialState, currentSiteInfo } },
+	});
+
+type Store = ReturnType<typeof makeStore>;
+const stateOf = (store: Store) => store.getState().redirects;
+
+// The adapters. One line each; the migration rewrote these and nothing else.
+//
+// Two things changed here and nowhere else in this file: the single-argument rule turned
+// every call into an object, and `addRedirect`'s 409 callback became part of the RESULT
+// (`isOriginTaken`) instead of an argument — a function in `meta.arg` would trip the
+// serializableCheck (docs/RTK-MIGRATION.md §5). So `create` unwraps and calls the hook
+// itself, which keeps every assertion below untouched.
+const load = (store: Store, filters?: string) =>
+	store.dispatch(redirectsActions.getRedirects({ params: PARAMS, filters }));
+const create = async (store: Store, onIsBeingUsed: () => void, force?: boolean, filter?: string) => {
+	const { isOriginTaken } = await store
+		.dispatch(redirectsActions.addRedirect({ redirect: FORM, force, filter }))
+		.unwrap();
+	if (isOriginTaken) onIsBeingUsed();
+};
+const edit = (store: Store, redirectID: number, filter?: string) =>
+	store.dispatch(redirectsActions.updateRedirect({ redirect: FORM, redirectID, filter }));
+const remove = (store: Store, redirectID: number | number[], filter?: string) =>
+	store.dispatch(redirectsActions.deleteRedirect({ redirectID, filter })).unwrap();
+const bulkImport = (store: Store, rows: { from: string; to: string }[], check: boolean) =>
+	store.dispatch(redirectsActions.importRedirects({ rows, check })).unwrap();
+
+const listOk = (items: IRedirect[]) => ({ status: 200, data: { items, totalItems: items.length } });
+const ok = { status: 200, data: {} };
+
+let handleError: MockInstance;
+
+beforeEach(() => {
+	handleError = vi.spyOn(appActions, "handleError").mockReturnValue((() => undefined) as never);
+});
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+describe("[UC-AX-manage-redirects] the redirect list", () => {
+	it("AC1 · starts empty, with nothing imported", () => {
+		expect(stateOf(makeStore())).toEqual({ redirects: [], totalItems: 0, totalImports: 0, imports: null });
+	});
+
+	it("AC1 · loading asks for the requested page and stores the items with the total", async () => {
+		const store = makeStore();
+		const get = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT, OTHER]) as never);
+
+		await load(store, SITE_FILTER);
+
+		expect(get).toHaveBeenCalledWith(PARAMS, SITE_FILTER);
+		expect(stateOf(store).redirects).toEqual([REDIRECT, OTHER]);
+		expect(stateOf(store).totalItems).toBe(2);
+	});
+
+	it("AC1 · empties the list before asking, so the table blanks instead of showing the previous page", async () => {
+		const store = makeStore();
+		vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT, OTHER]) as never);
+		await load(store);
+		expect(stateOf(store).redirects).toHaveLength(2);
+
+		let listWhenAsked: IRedirect[] | undefined;
+		vi.spyOn(redirects, "getRedirects").mockImplementation((async () => {
+			listWhenAsked = stateOf(store).redirects;
+			return listOk([REDIRECT]);
+		}) as never);
+
+		await load(store);
+
+		expect(listWhenAsked).toEqual([]);
+		expect(stateOf(store).redirects).toEqual([REDIRECT]);
+	});
+
+	it("AC1 · a failed load routes through the error channel and leaves the list empty", async () => {
+		const store = makeStore();
+		vi.spyOn(redirects, "getRedirects").mockResolvedValue({ status: 500, data: {} } as never);
+
+		await load(store);
+
+		expect(handleError).toHaveBeenCalled();
+		expect(stateOf(store).redirects).toEqual([]);
+	});
+});
+
+describe("[UC-AX-manage-redirects] creating a redirect", () => {
+	const onIsBeingUsed = vi.fn();
+
+	beforeEach(() => {
+		onIsBeingUsed.mockClear();
+	});
+
+	it("AC2 · posts the redirect and reloads the list filtered by the current site", async () => {
+		const store = makeStore({ id: SITE_ID } as ISite);
+		const post = vi.spyOn(redirects, "createRedirect").mockResolvedValue(ok as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
+
+		await create(store, onIsBeingUsed);
+
+		expect(post).toHaveBeenCalledWith(FORM, undefined);
+		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, SITE_FILTER);
+	});
+
+	it("AC2 · in global scope it reloads with the filter it was given instead of a site", async () => {
+		const store = makeStore();
+		vi.spyOn(redirects, "createRedirect").mockResolvedValue(ok as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
+
+		await create(store, onIsBeingUsed, undefined, "&sites=global");
+
+		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, "&sites=global");
+	});
+
+	it("AC3 · a 409 means the origin is taken: it drives the overwrite flow, not the error toast", async () => {
+		const store = makeStore();
+		vi.spyOn(redirects, "createRedirect").mockResolvedValue({ status: 409, data: {} } as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
+
+		await create(store, onIsBeingUsed);
+
+		expect(onIsBeingUsed).toHaveBeenCalled();
+		expect(handleError).not.toHaveBeenCalled();
+		expect(reload).not.toHaveBeenCalled();
+	});
+
+	it("AC3 · confirming the overwrite posts again with force", async () => {
+		const store = makeStore();
+		const post = vi.spyOn(redirects, "createRedirect").mockResolvedValue(ok as never);
+		vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
+
+		await create(store, onIsBeingUsed, true);
+
+		expect(post).toHaveBeenCalledWith(FORM, true);
+	});
+
+	it("AC2 · any other failure goes through the error channel and leaves the overwrite flow alone", async () => {
+		const store = makeStore();
+		const response = { status: 400, data: { message: "Invalid url" } };
+		vi.spyOn(redirects, "createRedirect").mockResolvedValue(response as never);
+
+		await create(store, onIsBeingUsed);
+
+		expect(handleError).toHaveBeenCalledWith(response);
+		expect(onIsBeingUsed).not.toHaveBeenCalled();
+	});
+});
+
+describe("[UC-AX-manage-redirects] editing and deleting", () => {
+	it("AC4 · editing puts the redirect and reloads the list", async () => {
+		const store = makeStore({ id: SITE_ID } as ISite);
+		const put = vi.spyOn(redirects, "updateRedirect").mockResolvedValue(ok as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
+
+		await edit(store, 1);
+
+		expect(put).toHaveBeenCalledWith(FORM, 1);
+		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, SITE_FILTER);
+	});
+
+	it("AC4 · deleting one goes to the single endpoint, reloads, and reports that it deleted", async () => {
+		const store = makeStore({ id: SITE_ID } as ISite);
+		const single = vi.spyOn(redirects, "deleteRedirect").mockResolvedValue(ok as never);
+		const bulk = vi.spyOn(redirects, "deleteRedirectsBulk").mockResolvedValue(ok as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
+
+		const deleted = await remove(store, 1);
+
+		expect(single).toHaveBeenCalledWith(1);
+		expect(bulk).not.toHaveBeenCalled();
+		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, SITE_FILTER);
+		// The screen only shows the "Redirect deleted" toast off this boolean.
+		expect(deleted).toBe(true);
+	});
+
+	it("AC4 · deleting several goes to the bulk endpoint with the ids", async () => {
+		const store = makeStore();
+		const bulk = vi.spyOn(redirects, "deleteRedirectsBulk").mockResolvedValue(ok as never);
+		const single = vi.spyOn(redirects, "deleteRedirect").mockResolvedValue(ok as never);
+		vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
+
+		await remove(store, [1, 2]);
+
+		expect(bulk).toHaveBeenCalledWith([1, 2]);
+		expect(single).not.toHaveBeenCalled();
+	});
+
+	it("AC4 · a bulk delete failing with several messages reports the count and does not reload", async () => {
+		const store = makeStore();
+		const response = { status: 400, data: { message: ["in use", "not found", "forbidden"] } };
+		vi.spyOn(redirects, "deleteRedirectsBulk").mockResolvedValue(response as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
+
+		const deleted = await remove(store, [1, 2]);
+
+		expect(handleError).toHaveBeenCalledWith(response, true, "The delete action failed due to 3 errors.");
+		expect(reload).not.toHaveBeenCalled();
+		expect(deleted).toBe(false);
+	});
+
+	it("AC4 · a delete failing with a single message goes through the standard error channel", async () => {
+		const store = makeStore();
+		const response = { status: 400, data: { message: ["in use"] } };
+		vi.spyOn(redirects, "deleteRedirect").mockResolvedValue(response as never);
+
+		await remove(store, 1);
+
+		expect(handleError).toHaveBeenCalledWith(response, false, undefined);
+	});
+});
+
+describe("[UC-AX-manage-redirects] importing from CSV", () => {
+	const ROWS = [
+		{ from: "/a", to: "/b" },
+		{ from: "/c", to: "/d" },
+	];
+
+	it("AC5 · the check phase stores the three buckets and the total, without reloading the list", async () => {
+		const store = makeStore();
+		const buckets = { total: 2, error: [], existing: [OTHER], ok: [REDIRECT] };
+		const check = vi.spyOn(redirects, "createRedirectsBulkCheck").mockResolvedValue({
+			status: 200,
+			data: buckets,
+		} as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([]) as never);
+
+		const checked = await bulkImport(store, ROWS, true);
+
+		expect(check).toHaveBeenCalledWith(ROWS);
+		expect(stateOf(store).imports).toEqual({ error: [], existing: [OTHER], ok: [REDIRECT] });
+		expect(stateOf(store).totalImports).toBe(2);
+		expect(reload).not.toHaveBeenCalled();
+		expect(checked).toBe(true);
+	});
+
+	it("AC5 · confirming posts the bulk and reloads the list unfiltered", async () => {
+		const store = makeStore({ id: SITE_ID } as ISite);
+		const post = vi.spyOn(redirects, "createRedirectsBulk").mockResolvedValue(ok as never);
+		const reload = vi.spyOn(redirects, "getRedirects").mockResolvedValue(listOk([REDIRECT]) as never);
+
+		await bulkImport(store, ROWS, false);
+
+		expect(post).toHaveBeenCalledWith(ROWS);
+		// Unfiltered even with a site loaded — the only write that ignores the scope.
+		expect(reload).toHaveBeenCalledWith(RELOAD_PARAMS, undefined);
+	});
+
+	it("AC5 · an import failing with several messages reports the count", async () => {
+		const store = makeStore();
+		const response = { status: 400, data: { message: ["row 1 invalid", "row 2 invalid"] } };
+		vi.spyOn(redirects, "createRedirectsBulkCheck").mockResolvedValue(response as never);
+
+		const checked = await bulkImport(store, ROWS, true);
+
+		expect(handleError).toHaveBeenCalledWith(response, true, "The import action failed due to 2 errors.");
+		expect(stateOf(store).imports).toBeNull();
+		expect(checked).toBe(false);
+	});
+});

package/src/__tests__/store/social.test.ts

@@ -0,0 +1,165 @@
+import { social } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { socialActions, socialReducer } from "@ax/containers/Settings";
+import { type ISitesState, sitesInitialState, sitesReducer } from "@ax/containers/Sites/reducer";
+import type { ISite, ISocialState } from "@ax/types";
+
+import { configureStore, type Reducer, type UnknownAction } from "@reduxjs/toolkit";
+import type { MockInstance } from "vitest";
+
+/**
+ * Characterisation tests for the `social` area — the per-site social profile URLs
+ * behind `/sites/settings/social` (UC-AX-configure-social-networks).
+ *
+ * Written against the PUBLIC surface (the store and the exported action creators),
+ * never against reducer internals or action type constants, so this file must keep
+ * passing unchanged once the area becomes a slice. If it needs an edit, the shape
+ * changed and that is a finding, not an adjustment.
+ *
+ * Two behaviours here are load-bearing and easy to lose in a rewrite:
+ *
+ *   - `setSocial` REPLACES the map, it does not merge — the opposite of its
+ *     `analytics` sibling. The legacy reducer returned `{ ...payload }`, and the
+ *     screen depends on it: "removing" a network means emptying its field and
+ *     saving, so a key the server drops has to drop out of the store too.
+ *   - the site is read from `sites.currentSiteInfo`, not passed in, which is why
+ *     that reducer is mounted below. It is the seam this area has with `sites`.
+ *
+ * Going to the slice needed exactly two edits, and both are type-level or known:
+ *
+ *   - the two `expect(saved)` assertions gained `.unwrap()`. `dispatch(thunk())` used
+ *     to resolve to `handleRequest`'s boolean; a createAsyncThunk resolves to the
+ *     fulfilled action and hands the value over through `.unwrap()`. Same finding as
+ *     Domains — docs/RTK-MIGRATION.md §5.
+ *   - the casts that let a redux 4 reducer and action creator into an RTK store went
+ *     away on their own (§8.3). `sites` still needs its own, being still legacy.
+ *
+ * Every request, resulting state and error-channel assertion below came over from the
+ * legacy run untouched. No argument churn: both thunks already took exactly one
+ * argument, so createAsyncThunk's single-argument rule cost nothing here.
+ */
+
+const SITE_ID = 42;
+
+const SOCIALS: ISocialState = {
+	instagram: "https://instagram.com/griddo",
+	twitter: "https://x.com/griddo",
+};
+
+// Mirrors how GlobalStore mounts this area, minus persistence. `sites` is still
+// legacy, so it needs the cast GlobalStore uses — RTK types reducers against redux 5's
+// UnknownAction (docs/RTK-MIGRATION.md §8.3).
+const makeStore = () =>
+	configureStore({
+		reducer: {
+			social: socialReducer,
+			sites: sitesReducer as Reducer<ISitesState, UnknownAction>,
+		},
+		preloadedState: {
+			sites: { ...sitesInitialState, currentSiteInfo: { id: SITE_ID } as ISite },
+		},
+	});
+
+type Store = ReturnType<typeof makeStore>;
+const socialsOf = (store: Store) => store.getState().social;
+
+const ok = (data: ISocialState) => ({ status: 200, data });
+
+describe("[UC-AX-configure-social-networks] social state", () => {
+	let store: Store;
+	let handleError: MockInstance;
+
+	beforeEach(() => {
+		store = makeStore();
+		handleError = vi.spyOn(appActions, "handleError").mockReturnValue((() => undefined) as never);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("AC2 · starts with no networks configured", () => {
+		expect(socialsOf(store)).toEqual({});
+	});
+
+	it("AC2 · setSocial replaces the whole map instead of merging onto it", () => {
+		store.dispatch(socialActions.setSocial(SOCIALS));
+
+		store.dispatch(socialActions.setSocial({ instagram: SOCIALS.instagram }));
+
+		// `twitter` is gone, not kept: the payload is the server's whole map.
+		expect(socialsOf(store)).toEqual({ instagram: SOCIALS.instagram });
+	});
+
+	it("AC2 · loading asks the current site for its networks and stores them", async () => {
+		const get = vi.spyOn(social, "getSocial").mockResolvedValue(ok(SOCIALS) as never);
+
+		await store.dispatch(socialActions.getSocial());
+
+		expect(get).toHaveBeenCalledWith(SITE_ID);
+		expect(socialsOf(store)).toEqual(SOCIALS);
+	});
+
+	it("AC2 · a failed load leaves the map untouched and logs instead of showing a toast", async () => {
+		store.dispatch(socialActions.setSocial(SOCIALS));
+		vi.spyOn(social, "getSocial").mockResolvedValue({ status: 500, data: {} } as never);
+		// Asserted rather than merely allowed: the read side's ONLY error channel is this
+		// console.log, so spying on it both pins the wart and keeps it out of the suite output.
+		const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+
+		await store.dispatch(socialActions.getSocial());
+
+		// The failure reaches the console and nothing else, so the screen keeps whatever it had.
+		// Documented as a wart in the UC: a failed load is invisible to the user.
+		expect(log).toHaveBeenCalledWith("Error en getSocial");
+		expect(handleError).not.toHaveBeenCalled();
+		expect(socialsOf(store)).toEqual(SOCIALS);
+	});
+});
+
+describe("[UC-AX-configure-social-networks] social writes", () => {
+	let store: Store;
+	let handleError: MockInstance;
+
+	beforeEach(() => {
+		store = makeStore();
+		handleError = vi.spyOn(appActions, "handleError").mockReturnValue((() => undefined) as never);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("AC6 · saving puts the whole form to the current site and takes the response as the new state", async () => {
+		const update = vi.spyOn(social, "updateSocial").mockResolvedValue(ok(SOCIALS) as never);
+
+		const saved = await store.dispatch(socialActions.saveSocial(SOCIALS)).unwrap();
+
+		expect(update).toHaveBeenCalledWith(SITE_ID, SOCIALS);
+		expect(saved).toBe(true);
+		expect(socialsOf(store)).toEqual(SOCIALS);
+	});
+
+	it("AC6 · an emptied network goes out as an empty string — that is how one is removed", async () => {
+		const form = { ...SOCIALS, twitter: "" };
+		const update = vi.spyOn(social, "updateSocial").mockResolvedValue(ok(form) as never);
+
+		await store.dispatch(socialActions.saveSocial(form));
+
+		expect(update).toHaveBeenCalledWith(SITE_ID, form);
+		expect(socialsOf(store)).toEqual(form);
+	});
+
+	it("AC6 · a failed save routes through the error channel and reports it did not save", async () => {
+		const response = { status: 400, data: { message: "Invalid URL" } };
+		vi.spyOn(social, "updateSocial").mockResolvedValue(response as never);
+
+		const saved = await store.dispatch(socialActions.saveSocial(SOCIALS)).unwrap();
+
+		expect(handleError).toHaveBeenCalledWith(response);
+		// The screen keys `resetDirty()` off this boolean, so losing it means the form
+		// silently forgets unsaved changes.
+		expect(saved).toBe(false);
+		expect(socialsOf(store)).toEqual({});
+	});
+});

package/src/components/MainWrapper/index.tsx

@@ -6,12 +6,12 @@ import AppBar, { type IAppBarProps } from "./AppBar";
 import * as S from "./style";
 
 const MainWrapper = (props: IWrapperProps): JSX.Element => {
-	const { children, fixedAppBar, fullWidth, hasAnimation } = props;
+	const { children, fixedAppBar, fullWidth, hasAnimation, screen } = props;
 
 	const { isOnline } = useNetworkStatus();
 
 	return (
-		<S.Wrapper fixedAppBar={fixedAppBar} data-testid="main-wrapper">
+		<S.Wrapper fixedAppBar={fixedAppBar} data-testid="main-wrapper" data-screen={screen}>
 			{hasAnimation && <S.BackgroundAnimation />}
 			<AppBar {...props} />
 			<S.Main fullWidth={fullWidth} data-testid="main-component" id="main-component">
@@ -30,6 +30,18 @@ const MainWrapper = (props: IWrapperProps): JSX.Element => {
 export interface IWrapperProps extends IAppBarProps {
 	children?: any[] | JSX.Element;
 	fullWidth?: boolean;
+	/**
+	 * Stable per-screen identifier for e2e, emitted as `data-screen`. Separate from
+	 * `data-testid="main-wrapper"`, which is the same on all 32 screens and is already
+	 * consumed by tests here and in griddo-qa's `identifiers.ts`.
+	 *
+	 * It exists because nothing else identifies a screen: `title` is display copy and
+	 * is not even unique — Robots and Redirects are both "SEO Settings", and the global
+	 * and the site Analytics screens are both "Analytics Settings". The e2e specs had
+	 * to assert on `location.pathname` with exact equality, and `/settings/analytics`
+	 * is a substring of `/sites/settings/analytics`.
+	 */
+	screen?: string;
 }
 
 export default MainWrapper;

package/src/containers/ActivityLog/index.tsx

@@ -1,4 +1,17 @@
-import * as activityLogActions from "./actions";
-import { activityLogReducer } from "./reducer";
+import { setListMode } from "./slice";
+import { downloadActivityLog, getActivityLog, getActivityLogByUser, goToLogContent } from "./thunks";
 
-export { activityLogActions, activityLogReducer };
+// `setActivityLog` stays private, as it was: the legacy `actions.tsx` did not export it
+// either — only the thunks write the page.
+const activityLogActions = {
+	getActivityLog,
+	getActivityLogByUser,
+	setListMode,
+	downloadActivityLog,
+	goToLogContent,
+};
+
+export { activityLogActions };
+
+export type { IActivityLogState } from "./slice";
+export { activityLogInitialState, activityLogReducer } from "./slice";

package/src/containers/ActivityLog/slice.ts

@@ -0,0 +1,45 @@
+import type { ILogItemsByDay, ILogItemsByUser } from "@ax/types";
+
+import { createSlice, type PayloadAction } from "@reduxjs/toolkit";
+
+/**
+ * The `activityLog` area holds ONE page of the audit trail plus how it is grouped
+ * (UC-AX-view-activity-log). There is a single slot for the page: switching between the
+ * timeline and the grouped-by-user view overwrites it, which is why the screen refetches
+ * whenever the mode changes.
+ *
+ * `activityLog` is a union because the two endpoints answer with differently shaped groups —
+ * by day or by user — and the view picks its renderer off `listMode`, not off the data.
+ *
+ * Out of redux-persist since this migration (ADR 0002).
+ */
+export interface IActivityLogState {
+	activityLog: ILogItemsByDay | ILogItemsByUser;
+	listMode: string;
+}
+
+export const initialState: IActivityLogState = {
+	activityLog: { totalItems: 0, items: [] },
+	listMode: "default",
+};
+
+const activityLogSlice = createSlice({
+	name: "activityLog",
+	initialState,
+	// The legacy reducer had both action types share one `return { ...state, ...payload }`
+	// branch, which worked because each payload carried exactly one key. One reducer per field
+	// says the same thing without the indirection.
+	reducers: {
+		setActivityLog(state, action: PayloadAction<ILogItemsByDay | ILogItemsByUser>) {
+			state.activityLog = action.payload;
+		},
+		setListMode(state, action: PayloadAction<string>) {
+			state.listMode = action.payload;
+		},
+	},
+});
+
+export const { setActivityLog, setListMode } = activityLogSlice.actions;
+
+export { initialState as activityLogInitialState };
+export const activityLogReducer = activityLogSlice.reducer;