feat: add manual bank card screens

Add cards, operations, refunds, categories and monthly summaries with Mantine date controls. Derive banking types from runtime OpenAPI. Cover recovery and session isolation.
2026-09-12 18:34:41 +03:00
parent 427ca23a43
commit ff4e88edbe
50 changed files with 7795 additions and 10 deletions
@@ -37,6 +37,7 @@ describe("AppRoutes", () => {
 		["/accounts/demo", "Вход"],
 		["/accounts/demo/operations", "Вход"],
 		["/settings", "Вход"],
+		["/cards?month=2026-08", "Вход"],
 		["/unknown", "Страница не найдена"],
 	])("renders %s with its page title", async (path, title) => {
 		renderRoutes(path);
@@ -94,6 +95,41 @@ describe("AppRoutes", () => {
 		});
 	});

+	it("returns after login to cards with the selected month without T-Bank", async () => {
+		server.use(
+			http.get("*/api/v1/bank-cards/categories", () => HttpResponse.json([])),
+			http.post("*/api/v1/auth/login", () =>
+				HttpResponse.json({
+					accessToken: "test",
+					user: { id: "user-1", email: "user@example.com" },
+				}),
+			),
+			http.get("*/api/v1/bank-cards", () => HttpResponse.json([])),
+			http.get("*/api/v1/bank-cards/summary", () =>
+				HttpResponse.json({
+					month: "2026-08",
+					cardId: null,
+					expenses: { currency: "RUB", value: "0" },
+					refunds: { currency: "RUB", value: "0" },
+					net: { currency: "RUB", value: "0" },
+					categories: [],
+				}),
+			),
+		);
+		renderRoutes("/cards?month=2026-08");
+		await screen.findByRole("heading", { name: "Вход" });
+		fireEvent.change(screen.getByLabelText("Email"), {
+			target: { value: "user@example.com" },
+		});
+		fireEvent.change(screen.getByLabelText("Пароль"), {
+			target: { value: "a secure password" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Вход" }));
+		await screen.findByRole("heading", { name: "Добавьте первую карту" });
+		expect(screen.getByLabelText("Месяц")).toHaveTextContent("August 2026");
+		expect(document.title).toBe("Карты — WealthLedger");
+	});
+
 	it("lazy-loads the protected shell for an authenticated accounts route", async () => {
 		server.use(
 			http.post("*/api/v1/auth/refresh", () =>
@@ -4,6 +4,14 @@ import { Navigate, Route, Routes } from "react-router";
 import { LazyPage } from "./RouteFallback";
 import { Protected, Public } from "./RouteGuards";

+const CardPage = lazy(async () => {
+	const { CardPage } = await import("@/pages/card");
+	return { default: CardPage };
+});
+const CardsPage = lazy(async () => {
+	const { CardsPage } = await import("@/pages/cards");
+	return { default: CardsPage };
+});
 const BondPage = lazy(async () => {
 	const { BondPage } = await import("@/pages/bond");
 	return { default: BondPage };
@@ -93,6 +101,22 @@ const AppRoutes: FC = () => (
 				</Protected>
 			}
 		>
+			<Route
+				path="/cards/:cardId"
+				element={
+					<LazyPage variant="content">
+						<CardPage />
+					</LazyPage>
+				}
+			/>
+			<Route
+				path="/cards"
+				element={
+					<LazyPage variant="content">
+						<CardsPage />
+					</LazyPage>
+				}
+			/>
 			<Route
 				path="/bonds"
 				element={
@@ -2,6 +2,7 @@ import { useDocumentTitle } from "@mantine/hooks";
 import type { FC } from "react";
 import { useTranslation } from "react-i18next";
 import { useMatch } from "react-router";
+import { useBankCard } from "@/entities/bank-card";
 import { useBond } from "@/entities/bond";
 import { useBrokerageAccounts } from "@/entities/brokerage-account";
 import { useStock } from "@/entities/stock";
@@ -52,14 +53,23 @@ const StockDocumentTitle: FC<InstrumentDocumentTitleProps> = (props) => {
 	return <DocumentTitle title={data?.name ?? t("stock.share")} />;
 };

+const CardDocumentTitle: FC<InstrumentDocumentTitleProps> = (props) => {
+	const { t } = useTranslation();
+	const { data } = useBankCard(props.identifier);
+	return <DocumentTitle title={data?.name ?? t("bank.card")} />;
+};
+
 const ProtectedDocumentTitle: FC = () => {
 	const { t } = useTranslation();
 	const account = useMatch("/accounts/:accountId/:section?");
 	const bond = useMatch("/bonds/:bondId");
 	const stock = useMatch("/stocks/:stockId");
+	const card = useMatch("/cards/:cardId");
+	const cards = useMatch("/cards");
 	const bonds = useMatch("/bonds");
 	const stocks = useMatch("/stocks");
 	const settings = useMatch("/settings");
+	if (card) return <CardDocumentTitle identifier={card.params.cardId ?? ""} />;
 	if (account)
 		return (
 			<AccountDocumentTitle
@@ -73,13 +83,15 @@ const ProtectedDocumentTitle: FC = () => {
 	return (
 		<DocumentTitle
 			title={t(
-				bonds
-					? "navigation.bonds"
-					: stocks
-						? "navigation.stocks"
-						: settings
-							? "navigation.settings"
-							: "navigation.accounts",
+				cards
+					? "navigation.cards"
+					: bonds
+						? "navigation.bonds"
+						: stocks
+							? "navigation.stocks"
+							: settings
+								? "navigation.settings"
+								: "navigation.accounts",
 			)}
 		/>
 	);
@@ -22,8 +22,16 @@ const Protected: FC<PropsWithChildren> = (props) => {
 const Public: FC<PropsWithChildren> = (props) => {
 	const { children } = props;
 	const { user, ready } = useAuth();
+	const location = useLocation();
+	const requested = (location.state as { returnTo?: string } | null)?.returnTo;
+	const returnTo =
+		typeof requested === "string" &&
+		requested.startsWith("/") &&
+		!requested.startsWith("//")
+			? requested
+			: "/accounts";
 	if (!ready) return <RouteSkeleton variant="shell" />;
-	return user ? <Navigate to="/accounts" replace /> : children;
+	return user ? <Navigate to={returnTo} replace /> : children;
 };

 export { Protected, Public };
@@ -6,6 +6,7 @@ import { AccountBreadcrumbs } from "./AccountBreadcrumbs";
 import { AccountScopeSwitch } from "./AccountScopeSwitch";
 import { BondBreadcrumbs } from "./BondBreadcrumbs";
 import { BreadcrumbTrail } from "./BreadcrumbTrail";
+import { CardBreadcrumbs } from "./CardBreadcrumbs";
 import { StockBreadcrumbs } from "./StockBreadcrumbs";

 const AppBreadcrumbs: FC = () => {
@@ -17,6 +18,8 @@ const AppBreadcrumbs: FC = () => {
 	const events = useMatch({ path: "/accounts/:accountId/events", end: true });
 	const income = useMatch({ path: "/accounts/:accountId/income", end: true });
 	const account = useMatch({ path: "/accounts/:accountId", end: true });
+	const card = useMatch("/cards/:cardId");
+	const cards = useMatch("/cards");
 	const accounts = useMatch({ path: "/accounts", end: true });
 	const settings = useMatch({ path: "/settings", end: true });

@@ -71,6 +74,8 @@ const AppBreadcrumbs: FC = () => {
 				<AccountScopeSwitch accountId={account.params.accountId ?? ""} />
 			</Stack>
 		);
+	if (card) return <CardBreadcrumbs identifier={card.params.cardId ?? ""} />;
+	if (cards) return <BreadcrumbTrail items={[{ label: t("bank.title") }]} />;
 	if (accounts)
 		return <BreadcrumbTrail items={[{ label: t("breadcrumbs.accounts") }]} />;
 	if (settings)
@@ -0,0 +1,20 @@
+import type { FC } from "react";
+import { useTranslation } from "react-i18next";
+import { useBankCard } from "@/entities/bank-card";
+import { BreadcrumbTrail } from "./BreadcrumbTrail";
+
+type CardBreadcrumbsProps = { identifier: string };
+const CardBreadcrumbs: FC<CardBreadcrumbsProps> = (props) => {
+	const { data } = useBankCard(props.identifier);
+	const { t } = useTranslation();
+	return (
+		<BreadcrumbTrail
+			items={[
+				{ label: t("bank.title"), to: "/cards" },
+				{ label: data?.name ?? t("bank.card") },
+			]}
+		/>
+	);
+};
+
+export { CardBreadcrumbs };
@@ -0,0 +1,384 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { apiClient, configureAuthClient } from "@/shared/api";
+import { createQueryWrapper } from "@/test/query";
+import { server } from "@/test/server";
+import { useBankMutations } from "./mutations";
+import {
+	type BankCard,
+	type CreateBankOperation,
+	useBankCard,
+	useBankCards,
+	useBankCategories,
+	useBankExpenses,
+	useBankOperation,
+	useBankOperations,
+	useBankSummary,
+} from "./queries";
+
+const card: BankCard = {
+	id: "a",
+	name: "Daily",
+	bankName: null,
+	lastFour: null,
+	openingBalance: { currency: "RUB", value: "100" },
+	openingDate: "2026-09-01",
+	balance: { currency: "RUB", value: "100" },
+	archivedAt: null,
+	version: 1,
+};
+const transfer: CreateBankOperation = {
+	id: "4e6caa65-dd52-4629-81e2-ce8a139a0612",
+	kind: "transfer",
+	cardId: "a",
+	targetCardId: "b",
+	amount: { currency: "RUB", value: "90071992547409.93" },
+	date: "2026-09-12",
+};
+
+function authenticate() {
+	configureAuthClient({
+		accessToken: () => "token",
+		refresh: async () => true,
+		clear: vi.fn(),
+	});
+}
+
+function readHandlers(counts: Map<string, number>, categoryName = "Food") {
+	return [
+		http.get("*/api/v1/bank-cards", ({ request }) => {
+			const key = new URL(request.url).pathname + new URL(request.url).search;
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+			return HttpResponse.json([card]);
+		}),
+		http.get("*/api/v1/bank-cards/*", ({ request }) => {
+			const url = new URL(request.url);
+			const key = url.pathname + url.search;
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+			if (url.pathname.endsWith("/categories"))
+				return HttpResponse.json([
+					{ id: "food", name: categoryName, isDefault: true, version: 1 },
+				]);
+			if (url.pathname.endsWith("/summary"))
+				return HttpResponse.json({
+					month: url.searchParams.get("month"),
+					cardId: url.searchParams.get("cardId"),
+					expenses: { currency: "RUB", value: "0" },
+					refunds: { currency: "RUB", value: "0" },
+					net: { currency: "RUB", value: "0" },
+					categories: [],
+				});
+			if (
+				url.pathname.endsWith("/operations") ||
+				url.pathname.endsWith("/expenses")
+			)
+				return HttpResponse.json({
+					items: [],
+					page: 1,
+					total: 0,
+					hasNext: false,
+				});
+			if (url.pathname.includes("/operations/"))
+				return HttpResponse.json({ ...transfer, version: 1 });
+			return HttpResponse.json({ ...card, id: url.pathname.split("/").at(-1) });
+		}),
+	];
+}
+
+function useReadModels() {
+	const cards = useBankCards(true);
+	const a = useBankCard("a");
+	const b = useBankCard("b");
+	const categories = useBankCategories();
+	const history = useBankOperations("a", {
+		month: "2026-09",
+		page: 2,
+		limit: 20,
+	});
+	const expenses = useBankExpenses("a", { page: 1 });
+	const september = useBankSummary("2026-09");
+	const august = useBankSummary("2026-08", "b");
+	const original = useBankOperation("original");
+	return {
+		reads: [
+			cards,
+			a,
+			b,
+			categories,
+			history,
+			expenses,
+			september,
+			august,
+			original,
+		],
+		mutations: useBankMutations(),
+	};
+}
+
+describe("banking API", () => {
+	beforeEach(authenticate);
+
+	it("uses session-aware banking endpoints and explicit month/page without T-Bank", async () => {
+		const counts = new Map<string, number>();
+		server.use(...readHandlers(counts));
+		const { result } = renderHook(useReadModels, {
+			wrapper: createQueryWrapper().wrapper,
+		});
+		await waitFor(() =>
+			expect(result.current.reads.every((read) => read.isSuccess)).toBe(true),
+		);
+		expect([...counts.keys()]).toContain(
+			"/api/v1/bank-cards?includeArchived=true",
+		);
+		expect([...counts.keys()]).toContain(
+			"/api/v1/bank-cards/a/operations?month=2026-09&page=2&limit=20",
+		);
+		expect([...counts.keys()]).toContain(
+			"/api/v1/bank-cards/summary?month=2026-08&cardId=b",
+		);
+		expect(counts.size).toBe(9);
+	});
+
+	it("replays the exact UUID and large Money string once across shared auth refresh", async () => {
+		let token = "expired";
+		const refresh = vi.fn(async () => {
+			token = "renewed";
+			return true;
+		});
+		configureAuthClient({ accessToken: () => token, refresh, clear: vi.fn() });
+		const bodies: unknown[] = [];
+		const headers: (string | null)[] = [];
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				bodies.push(await request.json());
+				headers.push(request.headers.get("Authorization"));
+				return bodies.length === 1
+					? HttpResponse.json({ code: "UNAUTHORIZED" }, { status: 401 })
+					: HttpResponse.json({ ...transfer, version: 1 });
+			}),
+		);
+		const { result } = renderHook(useBankMutations, {
+			wrapper: createQueryWrapper().wrapper,
+		});
+		await act(() => result.current.createOperation.mutateAsync(transfer));
+		expect(bodies).toEqual([transfer, transfer]);
+		expect(headers).toEqual(["Bearer expired", "Bearer renewed"]);
+		expect(refresh).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not automatically retry a network failure and preserves the form-supplied intent on repeat", async () => {
+		const bodies: unknown[] = [];
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				bodies.push(await request.json());
+				return bodies.length === 1
+					? HttpResponse.error()
+					: HttpResponse.json({ ...transfer, version: 1 });
+			}),
+		);
+		const { result } = renderHook(useBankMutations, {
+			wrapper: createQueryWrapper().wrapper,
+		});
+		await act(async () => {
+			await expect(
+				result.current.createOperation.mutateAsync(transfer),
+			).rejects.toThrow();
+		});
+		expect(bodies).toEqual([transfer]);
+		await act(() => result.current.createOperation.mutateAsync(transfer));
+		expect(bodies).toEqual([transfer, transfer]);
+	});
+
+	it("keeps the confirmed balance while a mutation is pending or fails, and on refetch failure", async () => {
+		server.use(...readHandlers(new Map()));
+		let finish: () => void = () => {};
+		const pending = new Promise<void>((resolve) => {
+			finish = resolve;
+		});
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async () => {
+				await pending;
+				return HttpResponse.json({ code: "INTERNAL_ERROR" }, { status: 500 });
+			}),
+		);
+		const { result } = renderHook(
+			() => ({ query: useBankCard("a"), mutations: useBankMutations() }),
+			{ wrapper: createQueryWrapper().wrapper },
+		);
+		await waitFor(() => expect(result.current.query.isSuccess).toBe(true));
+		let saving: Promise<unknown>;
+		act(() => {
+			saving = result.current.mutations.createOperation
+				.mutateAsync(transfer)
+				.catch(() => undefined);
+		});
+		await waitFor(() =>
+			expect(result.current.mutations.createOperation.isPending).toBe(true),
+		);
+		expect(result.current.query.data?.balance.value).toBe("100");
+		await act(async () => {
+			finish();
+			await saving;
+		});
+		expect(result.current.query.data?.balance.value).toBe("100");
+		server.use(
+			http.get("*/api/v1/bank-cards/a", () =>
+				HttpResponse.json({ code: "INTERNAL_ERROR" }, { status: 500 }),
+			),
+		);
+		await act(() => result.current.query.refetch());
+		expect(result.current.query.isError).toBe(true);
+		expect(result.current.query.data?.balance.value).toBe("100");
+	});
+
+	it("refetches both cards, every month, categories, journal and source expenses after a transfer without invalidating brokerage", async () => {
+		const counts = new Map<string, number>();
+		server.use(
+			...readHandlers(counts),
+			http.post("*/api/v1/bank-cards/operations", () =>
+				HttpResponse.json({ ...transfer, version: 1 }),
+			),
+		);
+		const { wrapper, queryClient } = createQueryWrapper();
+		const brokerKey = ["get", "/api/v1/brokerage-accounts"];
+		queryClient.setQueryData(brokerKey, []);
+		const { result } = renderHook(useReadModels, { wrapper });
+		await waitFor(() =>
+			expect(result.current.reads.every((read) => read.isSuccess)).toBe(true),
+		);
+		await act(() =>
+			result.current.mutations.createOperation.mutateAsync(transfer),
+		);
+		expect([...counts.values()]).toEqual(Array(9).fill(2));
+		expect(queryClient.getQueryState(brokerKey)?.isInvalidated).toBe(false);
+	});
+
+	it.each([
+		"BANK_VERSION_CONFLICT",
+		"BANK_INTENT_CONFLICT",
+		"BANK_REFUND_LIMIT",
+	])("fetches current state after %s", async (code) => {
+		let reads = 0;
+		server.use(
+			http.get("*/api/v1/bank-cards/a", () =>
+				HttpResponse.json({ ...card, version: ++reads }),
+			),
+			http.patch("*/api/v1/bank-cards/a", () =>
+				HttpResponse.json({ code }, { status: 409 }),
+			),
+		);
+		const { result } = renderHook(
+			() => ({ card: useBankCard("a"), mutations: useBankMutations() }),
+			{ wrapper: createQueryWrapper().wrapper },
+		);
+		await waitFor(() => expect(result.current.card.data?.version).toBe(1));
+		await act(async () => {
+			await expect(
+				result.current.mutations.updateCard.mutateAsync({
+					id: "a",
+					body: { name: "changed", version: 1 },
+				}),
+			).rejects.toEqual({ code });
+		});
+		await waitFor(() => expect(result.current.card.data?.version).toBe(2));
+	});
+
+	it("sends edit/delete versions and refreshes category names without optimistic updates", async () => {
+		const requests: unknown[] = [];
+		let name = "Food";
+		server.use(
+			http.get("*/api/v1/bank-cards/categories", () =>
+				HttpResponse.json([{ id: "food", name, isDefault: true, version: 1 }]),
+			),
+			http.patch("*/api/v1/bank-cards/categories/food", async ({ request }) => {
+				const body = await request.json();
+				requests.push(body);
+				name = "Groceries";
+				return HttpResponse.json({
+					id: "food",
+					name,
+					isDefault: true,
+					version: 2,
+				});
+			}),
+			http.patch(
+				"*/api/v1/bank-cards/operations/original",
+				async ({ request }) => {
+					requests.push(await request.json());
+					return HttpResponse.json({ ...transfer, version: 2 });
+				},
+			),
+			http.delete("*/api/v1/bank-cards/operations/original", ({ request }) => {
+				requests.push(new URL(request.url).searchParams.get("version"));
+				return new HttpResponse(null, { status: 204 });
+			}),
+		);
+		const { result } = renderHook(
+			() => ({
+				categories: useBankCategories(),
+				mutations: useBankMutations(),
+			}),
+			{ wrapper: createQueryWrapper().wrapper },
+		);
+		await waitFor(() =>
+			expect(result.current.categories.data?.[0].name).toBe("Food"),
+		);
+		await act(() =>
+			result.current.mutations.updateCategory.mutateAsync({
+				id: "food",
+				body: { name: "Groceries", version: 1 },
+			}),
+		);
+		await waitFor(() =>
+			expect(result.current.categories.data?.[0].name).toBe("Groceries"),
+		);
+		await act(() =>
+			result.current.mutations.updateOperation.mutateAsync({
+				id: "original",
+				body: { description: "corrected", version: 1 },
+			}),
+		);
+		await act(() =>
+			result.current.mutations.deleteOperation.mutateAsync({
+				id: "original",
+				version: 2,
+			}),
+		);
+		expect(requests).toEqual([
+			{ name: "Groceries", version: 1 },
+			{ description: "corrected", version: 1 },
+			"2",
+		]);
+	});
+
+	it("disables reads after session removal and retains banking data across a T-Bank API mutation", async () => {
+		const counts = new Map<string, number>();
+		server.use(
+			...readHandlers(counts),
+			http.put("*/api/v1/tbank-connection", () =>
+				HttpResponse.json({
+					connected: true,
+					connectedAt: "2026-09-12T00:00:00Z",
+				}),
+			),
+		);
+		const { wrapper, queryClient } = createQueryWrapper();
+		const { result, rerender } = renderHook(() => useBankCard("a"), {
+			wrapper,
+		});
+		await waitFor(() => expect(result.current.data?.balance.value).toBe("100"));
+		await apiClient.PUT("/api/v1/tbank-connection", {
+			body: { token: "synthetic" },
+		});
+		expect(result.current.data?.balance.value).toBe("100");
+		act(() => {
+			configureAuthClient(null);
+			queryClient.clear();
+		});
+		rerender();
+		await waitFor(() => expect(result.current.fetchStatus).toBe("idle"));
+		expect(result.current.data).toBeUndefined();
+		expect(counts.get("/api/v1/bank-cards/a")).toBe(1);
+	});
+});
@@ -0,0 +1,111 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient, apiErrorCode } from "@/shared/api";
+import type {
+	CreateBankCard,
+	CreateBankOperation,
+	CreateExpenseCategory,
+	UpdateBankCard,
+	UpdateBankOperation,
+	UpdateExpenseCategory,
+} from "./queries";
+
+async function mutationData<T>(
+	request: Promise<{ data?: T; error?: unknown }>,
+) {
+	const { data, error } = await request;
+	if (error) throw error;
+	return data;
+}
+
+function useBankMutations() {
+	const queryClient = useQueryClient();
+	const invalidate = () =>
+		queryClient.invalidateQueries({
+			predicate: ({ queryKey: [method, path] }) =>
+				method === "get" &&
+				typeof path === "string" &&
+				(path === "/api/v1/bank-cards" ||
+					path.startsWith("/api/v1/bank-cards/")),
+		});
+	const options = {
+		retry: false,
+		onSuccess: invalidate,
+		onError: (error: unknown) => {
+			if (
+				[
+					"BANK_VERSION_CONFLICT",
+					"BANK_WRITE_CONFLICT",
+					"BANK_INTENT_CONFLICT",
+					"BANK_REFUND_LIMIT",
+					"BANK_DEPENDENT_REFUNDS",
+				].includes(apiErrorCode(error) ?? "")
+			)
+				return invalidate();
+		},
+	} as const;
+	const createCard = useMutation({
+		...options,
+		mutationFn: (body: CreateBankCard) =>
+			mutationData(apiClient.POST("/api/v1/bank-cards", { body })),
+	});
+	const updateCard = useMutation({
+		...options,
+		mutationFn: ({ id, body }: { id: string; body: UpdateBankCard }) =>
+			mutationData(
+				apiClient.PATCH("/api/v1/bank-cards/{id}", {
+					params: { path: { id } },
+					body,
+				}),
+			),
+	});
+	const createOperation = useMutation({
+		...options,
+		mutationFn: (body: CreateBankOperation) =>
+			mutationData(apiClient.POST("/api/v1/bank-cards/operations", { body })),
+	});
+	const updateOperation = useMutation({
+		...options,
+		mutationFn: ({ id, body }: { id: string; body: UpdateBankOperation }) =>
+			mutationData(
+				apiClient.PATCH("/api/v1/bank-cards/operations/{id}", {
+					params: { path: { id } },
+					body,
+				}),
+			),
+	});
+	const deleteOperation = useMutation({
+		...options,
+		mutationFn: ({ id, version }: { id: string; version: number }) =>
+			mutationData(
+				apiClient.DELETE("/api/v1/bank-cards/operations/{id}", {
+					params: { path: { id }, query: { version } },
+				}),
+			),
+	});
+	const createCategory = useMutation({
+		...options,
+		mutationFn: (body: CreateExpenseCategory) =>
+			mutationData(apiClient.POST("/api/v1/bank-cards/categories", { body })),
+	});
+	const updateCategory = useMutation({
+		...options,
+		mutationFn: ({ id, body }: { id: string; body: UpdateExpenseCategory }) =>
+			mutationData(
+				apiClient.PATCH("/api/v1/bank-cards/categories/{id}", {
+					params: { path: { id } },
+					body,
+				}),
+			),
+	});
+	return {
+		createCard,
+		updateCard,
+		createOperation,
+		updateOperation,
+		deleteOperation,
+		createCategory,
+		updateCategory,
+	};
+}
+
+export { useBankMutations };
@@ -0,0 +1,117 @@
+import {
+	apiQueryClient,
+	type paths,
+	useAuthenticatedQuery,
+} from "@/shared/api";
+
+type BankCard =
+	paths["/api/v1/bank-cards/{id}"]["get"]["responses"][200]["content"]["application/json"];
+type BankOperation =
+	paths["/api/v1/bank-cards/operations/{id}"]["get"]["responses"][200]["content"]["application/json"];
+type BankSummary =
+	paths["/api/v1/bank-cards/summary"]["get"]["responses"][200]["content"]["application/json"];
+type ExpenseCategory =
+	paths["/api/v1/bank-cards/categories"]["get"]["responses"][200]["content"]["application/json"][number];
+type CreateBankCard =
+	paths["/api/v1/bank-cards"]["post"]["requestBody"]["content"]["application/json"];
+type UpdateBankCard =
+	paths["/api/v1/bank-cards/{id}"]["patch"]["requestBody"]["content"]["application/json"];
+type CreateBankOperation =
+	paths["/api/v1/bank-cards/operations"]["post"]["requestBody"]["content"]["application/json"];
+type UpdateBankOperation =
+	paths["/api/v1/bank-cards/operations/{id}"]["patch"]["requestBody"]["content"]["application/json"];
+type CreateExpenseCategory =
+	paths["/api/v1/bank-cards/categories"]["post"]["requestBody"]["content"]["application/json"];
+type UpdateExpenseCategory =
+	paths["/api/v1/bank-cards/categories/{id}"]["patch"]["requestBody"]["content"]["application/json"];
+
+function useBankCards(includeArchived = false) {
+	return useAuthenticatedQuery(
+		apiQueryClient.queryOptions("get", "/api/v1/bank-cards", {
+			params: {
+				query: { includeArchived: includeArchived ? "true" : "false" },
+			},
+		}),
+	);
+}
+
+function useBankCard(id: string | undefined) {
+	return useAuthenticatedQuery({
+		...apiQueryClient.queryOptions("get", "/api/v1/bank-cards/{id}", {
+			params: { path: { id: id ?? "" } },
+		}),
+		enabled: Boolean(id),
+	});
+}
+
+function useBankCategories() {
+	return useAuthenticatedQuery(
+		apiQueryClient.queryOptions("get", "/api/v1/bank-cards/categories"),
+	);
+}
+
+function useBankOperations(
+	id: string | undefined,
+	query: { month: string; page: number; limit?: number },
+) {
+	return useAuthenticatedQuery({
+		...apiQueryClient.queryOptions(
+			"get",
+			"/api/v1/bank-cards/{id}/operations",
+			{ params: { path: { id: id ?? "" }, query } },
+		),
+		enabled: Boolean(id && query.month),
+	});
+}
+
+function useBankExpenses(
+	id: string | undefined,
+	query: { page: number; limit?: number },
+) {
+	return useAuthenticatedQuery({
+		...apiQueryClient.queryOptions("get", "/api/v1/bank-cards/{id}/expenses", {
+			params: { path: { id: id ?? "" }, query },
+		}),
+		enabled: Boolean(id),
+	});
+}
+
+function useBankSummary(month: string, cardId?: string) {
+	return useAuthenticatedQuery({
+		...apiQueryClient.queryOptions("get", "/api/v1/bank-cards/summary", {
+			params: { query: { month, cardId } },
+		}),
+		enabled: Boolean(month),
+	});
+}
+
+function useBankOperation(id: string | undefined) {
+	return useAuthenticatedQuery({
+		...apiQueryClient.queryOptions(
+			"get",
+			"/api/v1/bank-cards/operations/{id}",
+			{ params: { path: { id: id ?? "" } } },
+		),
+		enabled: Boolean(id),
+	});
+}
+
+export {
+	type BankCard,
+	type BankOperation,
+	type BankSummary,
+	type CreateBankCard,
+	type CreateBankOperation,
+	type CreateExpenseCategory,
+	type ExpenseCategory,
+	type UpdateBankCard,
+	type UpdateBankOperation,
+	type UpdateExpenseCategory,
+	useBankCard,
+	useBankCards,
+	useBankCategories,
+	useBankExpenses,
+	useBankOperation,
+	useBankOperations,
+	useBankSummary,
+};
@@ -0,0 +1,25 @@
+export { useBankMutations } from "./api/mutations";
+export {
+	type BankCard,
+	type BankOperation,
+	useBankCard,
+	useBankCards,
+	useBankCategories,
+	useBankExpenses,
+	useBankOperation,
+	useBankOperations,
+	useBankSummary,
+} from "./api/queries";
+export {
+	bankDateSchema,
+	bankMoneyValue,
+	bankMonth,
+	bankToday,
+	moneyCents,
+	positiveMoneySchema,
+} from "./model/form-validation";
+export { BankCardForm } from "./ui/BankCardForm";
+export { BankFeedback } from "./ui/BankFeedback";
+export { BankSummaryView } from "./ui/BankSummary.view";
+export { CategoryManager } from "./ui/CategoryManager";
+export { useBankFormFocus } from "./ui/useBankFormFocus";
@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	bankCardSchema,
+	bankDateSchema,
+	bankMoneyValue,
+	bankMonth,
+	bankToday,
+	positiveMoneySchema,
+} from "./form-validation";
+
+afterEach(() => vi.useRealTimers());
+describe("bank form input", () => {
+	it("keeps input bounds exact without rounding and canonicalizes leading zeros", () => {
+		expect(positiveMoneySchema.safeParse("92233720368547758.07").success).toBe(
+			true,
+		);
+		for (const invalid of [
+			"92233720368547758.08",
+			"1.001",
+			"0",
+			"-1",
+			"abc",
+			"1e3",
+		]) {
+			expect(positiveMoneySchema.safeParse(invalid).success).toBe(false);
+		}
+		expect(bankMoneyValue(" -00010,20 ")).toBe("-10.20");
+		const values = {
+			name: "A",
+			bankName: "",
+			lastFour: "",
+			openingBalance: "-92233720368547758.08",
+			openingDate: "2026-01-01",
+		};
+		expect(bankCardSchema.safeParse(values).success).toBe(true);
+		expect(
+			bankCardSchema.safeParse({
+				...values,
+				openingBalance: "-92233720368547758.09",
+			}).success,
+		).toBe(false);
+		expect(
+			bankCardSchema.safeParse({ ...values, lastFour: "123" }).success,
+		).toBe(false);
+	});
+	it("uses Moscow date and refuses nonexistent or future calendar days", () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-08-31T21:30:00Z"));
+		expect(bankToday()).toBe("2026-09-01");
+		expect(bankMonth(null)).toBe("2026-09");
+		expect(bankMonth("2026-13")).toBe("2026-09");
+		expect(bankDateSchema.safeParse("2026-09-01").success).toBe(true);
+		expect(bankDateSchema.safeParse("2026-09-02").success).toBe(false);
+		expect(bankDateSchema.safeParse("2026-02-30").success).toBe(false);
+	});
+});
@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { validationMessage } from "@/shared/i18n";
+
+function bankToday() {
+	return new Intl.DateTimeFormat("en-CA", {
+		timeZone: "Europe/Moscow",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+	}).format(new Date());
+}
+function bankMonth(value: string | null) {
+	return value && /^\d{4}-(0[1-9]|1[0-2])$/.test(value)
+		? value
+		: bankToday().slice(0, 7);
+}
+function bankMoneyValue(value: string) {
+	return value
+		.trim()
+		.replace(",", ".")
+		.replace(/^(-?)0+(?=\d)/, "$1");
+}
+function moneyCents(value: string): bigint | null {
+	const normalized = value.trim().replace(",", ".");
+	if (!/^-?\d+(\.\d{1,2})?$/.test(normalized)) return null;
+	const [whole, fraction = ""] = normalized.replace("-", "").split(".");
+	return (
+		BigInt(`${whole}${fraction.padEnd(2, "0")}`) *
+		(normalized.startsWith("-") ? -1n : 1n)
+	);
+}
+const moneySchema = z.string().refine((value) => {
+	const cents = moneyCents(value);
+	return (
+		cents !== null &&
+		cents >= -9223372036854775808n &&
+		cents <= 9223372036854775807n
+	);
+}, validationMessage("bank.validation.money"));
+const positiveMoneySchema = moneySchema.refine((value) => {
+	const cents = moneyCents(value);
+	return cents === null || cents > 0n;
+}, validationMessage("bank.validation.positive"));
+const bankDateSchema = z
+	.string()
+	.refine(
+		(value) =>
+			/^\d{4}-\d{2}-\d{2}$/.test(value) &&
+			value >= "0001-01-01" &&
+			!Number.isNaN(Date.parse(`${value}T00:00:00Z`)) &&
+			new Date(`${value}T00:00:00Z`).toISOString().slice(0, 10) === value &&
+			value <= bankToday(),
+		validationMessage("bank.validation.date"),
+	);
+const bankCardSchema = z.object({
+	name: z
+		.string()
+		.trim()
+		.min(1, validationMessage("bank.validation.name")(undefined))
+		.max(100, validationMessage("bank.validation.name")(undefined)),
+	bankName: z
+		.string()
+		.trim()
+		.max(100, validationMessage("bank.validation.bankName")(undefined)),
+	lastFour: z
+		.string()
+		.refine(
+			(value) => !value || /^\d{4}$/.test(value),
+			validationMessage("bank.validation.lastFour"),
+		),
+	openingBalance: moneySchema,
+	openingDate: bankDateSchema,
+});
+type BankCardValues = z.infer<typeof bankCardSchema>;
+
+export {
+	type BankCardValues,
+	bankCardSchema,
+	bankDateSchema,
+	bankMoneyValue,
+	bankMonth,
+	bankToday,
+	moneyCents,
+	positiveMoneySchema,
+};
@@ -0,0 +1,44 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { FormProvider, useForm } from "react-hook-form";
+import type { BankCardValues } from "../model/form-validation";
+import { BankCardFields } from "./BankCardForm.view";
+
+const meta = {
+	title: "Product/BankCards/CardFields",
+	component: BankCardFields,
+	tags: ["autodocs"],
+	args: { archived: false },
+	decorators: [
+		(Story) => {
+			const methods = useForm<BankCardValues>({
+				defaultValues: {
+					name: "Учебная повседневная карта",
+					bankName: "Вымышленный банк",
+					lastFour: "1234",
+					openingBalance: "-92233720368547758.08",
+					openingDate: "2026-08-01",
+				},
+			});
+			return (
+				<FormProvider {...methods}>
+					<Story />
+				</FormProvider>
+			);
+		},
+	],
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Поля ручной дебетовой карты на вымышленных данных. Сохранения и обращения к API нет. Архив оставляет описательные сведения доступными, а финансовые поля — только для чтения.",
+			},
+		},
+	},
+} satisfies Meta<typeof BankCardFields>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export const Active: Story = { name: "Независимая карта в рублях" };
+export const Archived: Story = {
+	name: "Финансовые поля архивной карты",
+	args: { archived: true },
+};
@@ -0,0 +1,122 @@
+import { MantineProvider } from "@mantine/core";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { describe, expect, it, vi } from "vitest";
+import { configureAuthClient } from "@/shared/api";
+import { createTestQueryClient } from "@/test/query";
+import { server } from "@/test/server";
+import type { BankCard } from "../api/queries";
+import { BankCardForm } from "./BankCardForm";
+
+const card: BankCard = {
+	id: "a",
+	name: "Основная",
+	bankName: "Банк",
+	lastFour: "1234",
+	openingBalance: { currency: "RUB", value: "100" },
+	balance: { currency: "RUB", value: "50" },
+	openingDate: "2026-01-01",
+	archivedAt: null,
+	version: 1,
+};
+function setup(value: BankCard) {
+	configureAuthClient({
+		accessToken: () => "test",
+		refresh: async () => false,
+		clear: () => {},
+	});
+	server.use(http.get("*/api/v1/bank-cards/a", () => HttpResponse.json(value)));
+	const close = vi.fn();
+	render(
+		<QueryClientProvider client={createTestQueryClient()}>
+			<MantineProvider env="test">
+				<BankCardForm card={value} onClose={close} />
+			</MantineProvider>
+		</QueryClientProvider>,
+	);
+	return close;
+}
+describe("BankCardForm", () => {
+	it("clears optional metadata on archive while omitting protected financial fields", async () => {
+		const close = setup({ ...card, archivedAt: "2026-09-01" });
+		expect(screen.getByLabelText(/Начальный остаток/)).toHaveAttribute(
+			"readonly",
+		);
+		expect(screen.getByLabelText(/Дата начала/)).toHaveAttribute("readonly");
+		fireEvent.change(screen.getByLabelText(/Банк/), { target: { value: "" } });
+		fireEvent.change(screen.getByLabelText(/Последние четыре/), {
+			target: { value: "" },
+		});
+		let body: unknown;
+		server.use(
+			http.patch("*/api/v1/bank-cards/a", async ({ request }) => {
+				body = await request.json();
+				return HttpResponse.json(card);
+			}),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(body).toEqual({
+			version: 1,
+			name: "Основная",
+			bankName: null,
+			lastFour: null,
+		});
+	});
+	it("retains an invalid opening date draft and explains conflict with saved history", async () => {
+		const close = setup(card);
+		fireEvent.change(screen.getByLabelText(/Дата начала/), {
+			target: { value: "2026-08-01" },
+		});
+		server.use(
+			http.patch("*/api/v1/bank-cards/a", () =>
+				HttpResponse.json(
+					{ code: "BANK_OPENING_DATE_CONFLICT" },
+					{ status: 400 },
+				),
+			),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText(
+			"Дата начала противоречит сохранённой истории карты.",
+		);
+		expect(screen.getByLabelText(/Дата начала/)).toHaveValue("2026-08-01");
+		expect(close).not.toHaveBeenCalled();
+	});
+	it("keeps card edit version until explicit refresh adoption", async () => {
+		const close = setup(card);
+		let version = 1;
+		const bodies: Record<string, unknown>[] = [];
+		server.use(
+			http.get("*/api/v1/bank-cards/a", () =>
+				HttpResponse.json({ ...card, version }),
+			),
+			http.patch("*/api/v1/bank-cards/a", async ({ request }) => {
+				const body = (await request.json()) as Record<string, unknown>;
+				bodies.push(body);
+				version = 2;
+				return body.version === 1
+					? HttpResponse.json(
+							{ code: "BANK_VERSION_CONFLICT" },
+							{ status: 409 },
+						)
+					: HttpResponse.json(card);
+			}),
+		);
+		fireEvent.change(screen.getByLabelText(/Название карты/), {
+			target: { value: "Мой черновик" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText(/Запись уже изменена/);
+		fireEvent.click(screen.getByRole("button", { name: "Перечитать запись" }));
+		const adopt = await screen.findByRole("button", {
+			name: "Использовать актуальную версию 2",
+		});
+		expect(screen.getByLabelText(/Название карты/)).toHaveValue("Мой черновик");
+		fireEvent.click(adopt);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(bodies.map((b) => b.version)).toEqual([1, 2]);
+	});
+});
@@ -0,0 +1,144 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Button, Group, Modal, Stack, Text } from "@mantine/core";
+import { type FC, useState } from "react";
+import { FormProvider, useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { useBankMutations } from "../api/mutations";
+import { type BankCard, useBankCard } from "../api/queries";
+import {
+	type BankCardValues,
+	bankCardSchema,
+	bankMoneyValue,
+	bankToday,
+} from "../model/form-validation";
+import { BankCardFields } from "./BankCardForm.view";
+import { BankFeedback } from "./BankFeedback";
+import classes from "./BankForms.module.css";
+import { useBankFormFocus } from "./useBankFormFocus";
+
+type BankCardFormProps = { card?: BankCard; onClose: () => void };
+const BankCardForm: FC<BankCardFormProps> = (props) => {
+	useBankFormFocus();
+	const { t } = useTranslation();
+	const [intent] = useState(() => crypto.randomUUID());
+	const [version, setVersion] = useState(props.card?.version ?? 1);
+	const [error, setError] = useState<unknown>();
+	const [latest, setLatest] = useState<BankCard>();
+	const fresh = useBankCard(props.card?.id);
+	const mutation = useBankMutations();
+	const methods = useForm<BankCardValues>({
+		resolver: zodResolver(bankCardSchema),
+		defaultValues: {
+			name: props.card?.name ?? "",
+			bankName: props.card?.bankName ?? "",
+			lastFour: props.card?.lastFour ?? "",
+			openingBalance: props.card?.openingBalance.value ?? "0",
+			openingDate: props.card?.openingDate ?? bankToday(),
+		},
+	});
+	const pending =
+		methods.formState.isSubmitting || (fresh.isFetching && Boolean(error));
+	return (
+		<Modal
+			opened
+			onClose={() => !pending && props.onClose()}
+			title={t(props.card ? "bank.editCard" : "bank.addCard")}
+			closeButtonProps={{ "aria-label": t("bank.close"), disabled: pending }}
+			closeOnClickOutside={!pending}
+			closeOnEscape={!pending}
+		>
+			<FormProvider {...methods}>
+				<form
+					onSubmit={methods.handleSubmit(async (values) => {
+						setError(undefined);
+						try {
+							const metadata = {
+								name: values.name,
+								bankName: values.bankName || null,
+								lastFour: values.lastFour || null,
+							};
+							const financial = {
+								openingBalance: {
+									currency: "RUB" as const,
+									value: bankMoneyValue(values.openingBalance),
+								},
+								openingDate: values.openingDate,
+							};
+							if (props.card)
+								await mutation.updateCard.mutateAsync({
+									id: props.card.id,
+									body: {
+										...metadata,
+										...(!props.card.archivedAt ? financial : {}),
+										version,
+									},
+								});
+							else
+								await mutation.createCard.mutateAsync({
+									id: intent,
+									...metadata,
+									...financial,
+								});
+							props.onClose();
+						} catch (failure) {
+							setError(failure);
+						}
+					})}
+				>
+					<fieldset className={classes.fieldset} disabled={pending}>
+						<Stack>
+							<BankCardFields archived={Boolean(props.card?.archivedAt)} />
+							{error ? (
+								<>
+									<BankFeedback error={error} />
+									{props.card && (
+										<Button
+											variant="default"
+											onClick={async () => {
+												const response = await fresh.refetch();
+												if (response.data && !response.error)
+													setLatest(response.data);
+												else setError(response.error);
+											}}
+										>
+											{t("bank.reloadRecord")}
+										</Button>
+									)}
+								</>
+							) : null}
+							{latest && (
+								<>
+									<Text>
+										{t("bank.versionHint", {
+											details: `${latest.name} · ${latest.openingBalance.value} RUB · ${latest.openingDate}`,
+										})}
+									</Text>
+									<Button
+										variant="default"
+										onClick={() => {
+											setVersion(latest.version);
+											setLatest(undefined);
+											setError(undefined);
+										}}
+									>
+										{t("bank.adoptVersion", { version: latest.version })}
+									</Button>
+								</>
+							)}
+							<Group>
+								<Button type="submit" loading={pending}>
+									{t("bank.save")}
+								</Button>
+								<Button variant="default" onClick={props.onClose}>
+									{t("bank.cancel")}
+								</Button>
+							</Group>
+						</Stack>
+					</fieldset>
+				</form>
+			</FormProvider>
+		</Modal>
+	);
+};
+
+export { BankCardForm };
@@ -0,0 +1,87 @@
+import { Stack, Text, TextInput } from "@mantine/core";
+import { DateInput } from "@mantine/dates";
+import type { FC } from "react";
+import { Controller, useFormContext } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import {
+	type BankCardValues,
+	bankDateSchema,
+	bankToday,
+} from "../model/form-validation";
+
+type BankCardFieldsProps = { archived: boolean };
+const BankCardFields: FC<BankCardFieldsProps> = (props) => {
+	const {
+		control,
+		register,
+		formState: { errors },
+	} = useFormContext<BankCardValues>();
+	const { t } = useTranslation();
+	return (
+		<Stack>
+			<TextInput
+				label={t("bank.name")}
+				required
+				{...register("name")}
+				error={errors.name?.message}
+			/>
+			<TextInput
+				label={t("bank.bankName")}
+				{...register("bankName")}
+				error={errors.bankName?.message}
+			/>
+			<TextInput
+				label={t("bank.lastFour")}
+				inputMode="numeric"
+				{...register("lastFour")}
+				error={errors.lastFour?.message}
+			/>
+			<TextInput
+				label={t("bank.openingBalance")}
+				required
+				inputMode="decimal"
+				readOnly={props.archived}
+				{...register("openingBalance")}
+				error={errors.openingBalance?.message}
+			/>
+			<Controller
+				control={control}
+				name="openingDate"
+				render={({ field }) => (
+					<DateInput
+						{...field}
+						label={t("bank.openingDate")}
+						required
+						valueFormat="YYYY-MM-DD"
+						value={
+							bankDateSchema.safeParse(field.value).success ? field.value : null
+						}
+						dateParser={(value) =>
+							bankDateSchema.safeParse(value).success ? value : null
+						}
+						fixOnBlur={false}
+						onInput={(event) => field.onChange(event.currentTarget.value)}
+						onChange={(value) => field.onChange(value ?? "")}
+						onBlur={(event) => {
+							field.onChange(event.currentTarget.value);
+							field.onBlur();
+						}}
+						maxDate={bankToday()}
+						popoverProps={{
+							withinPortal: false,
+							middlewares: { shift: { crossAxis: true } },
+						}}
+						readOnly={props.archived}
+						error={errors.openingDate?.message}
+					/>
+				)}
+			/>
+			<Text size="sm" c="dimmed">
+				{t("bank.openingHint")}
+			</Text>
+			{props.archived && <Text>{t("bank.archiveHint")}</Text>}
+		</Stack>
+	);
+};
+
+export { BankCardFields };
@@ -0,0 +1,37 @@
+import { Alert, Button, Group, Text } from "@mantine/core";
+import type { FC } from "react";
+import { useTranslation } from "react-i18next";
+import { apiErrorCode } from "@/shared/api";
+
+type BankFeedbackProps = {
+	error: unknown;
+	retry?: () => void;
+	cached?: boolean;
+	loadingError?: boolean;
+};
+const BankFeedback: FC<BankFeedbackProps> = (props) => {
+	const { t } = useTranslation();
+	const code = apiErrorCode(props.error);
+	return (
+		<Alert color="orange" role="alert">
+			<Group>
+				<Text>
+					{props.cached
+						? t("bank.refreshError")
+						: t(`bank.errors.${code}` as "bank.errors.BANK_INVALID_INPUT", {
+								defaultValue: t(
+									props.loadingError ? "bank.error" : "bank.requestError",
+								),
+							})}
+				</Text>
+				{props.retry && (
+					<Button variant="default" onClick={props.retry}>
+						{t("bank.retry")}
+					</Button>
+				)}
+			</Group>
+		</Alert>
+	);
+};
+
+export { BankFeedback };
@@ -0,0 +1,6 @@
+.fieldset {
+	border: 0;
+	padding: 0;
+	margin: 0;
+	min-width: 0;
+}
@@ -0,0 +1,102 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { BankSummaryView } from "./BankSummary.view";
+
+const money = (value: string) => ({ currency: "RUB", value });
+const meta = {
+	title: "Product/BankCards/Summary",
+	component: BankSummaryView,
+	tags: ["autodocs"],
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Месячные расходы ручного учёта. Вымышленные суммы, без API и сохранения. Возвраты учитываются отдельно; отрицательный итог не превращается в процентную диаграмму.",
+			},
+		},
+	},
+	args: {
+		loading: false,
+		error: false,
+		fetching: false,
+		retry: () => {},
+		data: {
+			month: "2026-09",
+			cardId: null,
+			expenses: money("8500"),
+			refunds: money("1000"),
+			net: money("7500"),
+			categories: [
+				{
+					categoryId: "food",
+					categoryName: "Продукты",
+					expenses: money("8500"),
+					refunds: money("1000"),
+					net: money("7500"),
+				},
+			],
+		},
+	},
+} satisfies Meta<typeof BankSummaryView>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export const Loaded: Story = { name: "Расходы и возвраты" };
+export const RefundMonth: Story = {
+	name: "Возврат покупки прошлого месяца",
+	args: {
+		data: {
+			month: "2026-09",
+			cardId: null,
+			expenses: money("0"),
+			refunds: money("600"),
+			net: money("-600"),
+			categories: [
+				{
+					categoryId: "shopping",
+					categoryName:
+						"Покупки с длинным пользовательским названием категории",
+					expenses: money("0"),
+					refunds: money("600"),
+					net: money("-600"),
+				},
+			],
+		},
+	},
+};
+export const Empty: Story = {
+	name: "Известные нули",
+	args: {
+		data: {
+			month: "2026-09",
+			cardId: null,
+			expenses: money("0"),
+			refunds: money("0"),
+			net: money("0"),
+			categories: [],
+		},
+	},
+};
+export const Loading: Story = {
+	name: "Начальная загрузка",
+	args: { data: undefined, loading: true },
+};
+export const Failed: Story = {
+	name: "Ошибка без данных",
+	args: { data: undefined, error: true },
+};
+export const CachedError: Story = {
+	name: "Сохранённые суммы при ошибке обновления",
+	args: { error: true },
+};
+export const LongAmounts: Story = {
+	name: "Точный итог длиннее предела отдельного ввода",
+	args: {
+		data: {
+			month: "2026-09",
+			cardId: null,
+			expenses: money("184467440737095516.14"),
+			refunds: money("0"),
+			net: money("184467440737095516.14"),
+			categories: [],
+		},
+	},
+};
@@ -0,0 +1,90 @@
+import {
+	Button,
+	Group,
+	Paper,
+	SimpleGrid,
+	Skeleton,
+	Stack,
+	Text,
+	Title,
+} from "@mantine/core";
+import type { FC } from "react";
+import { useTranslation } from "react-i18next";
+import { formatMoney } from "@/shared/lib";
+import { LoadingSkeleton } from "@/shared/ui";
+import type { BankSummary } from "../api/queries";
+
+type BankSummaryViewProps = {
+	data?: BankSummary;
+	loading: boolean;
+	error: boolean;
+	fetching: boolean;
+	retry: () => void;
+	all?: boolean;
+};
+const BankSummaryView: FC<BankSummaryViewProps> = (props) => {
+	const { t } = useTranslation();
+	return (
+		<Paper p="md" withBorder>
+			<Stack>
+				<Title order={2}>
+					{t(props.all ? "bank.allSummary" : "bank.summary")}
+				</Title>
+				{props.data ? (
+					<>
+						<SimpleGrid cols={{ base: 1, sm: 3 }}>
+							{(["expenses", "refunds", "net"] as const).map((key) => (
+								<div key={key}>
+									<Text c="dimmed">{t(`bank.${key}`)}</Text>
+									<Text size="xl" fw={650} style={{ overflowWrap: "anywhere" }}>
+										{formatMoney(props.data?.[key] ?? null)}
+									</Text>
+								</div>
+							))}
+						</SimpleGrid>
+						<Text size="sm" c="dimmed">
+							{t("bank.summaryHint")}
+						</Text>
+						{props.data.categories.length ? (
+							props.data.categories.map((category) => (
+								<Paper p="sm" key={category.categoryId} withBorder>
+									<Text fw={600}>{category.categoryName}</Text>
+									<Group>
+										{(["expenses", "refunds", "net"] as const).map((key) => (
+											<Text key={key} style={{ overflowWrap: "anywhere" }}>
+												{t(`bank.${key}`)}: {formatMoney(category[key])}
+											</Text>
+										))}
+									</Group>
+								</Paper>
+							))
+						) : (
+							<Text>{t("bank.noExpenses")}</Text>
+						)}
+					</>
+				) : props.loading ? (
+					<LoadingSkeleton label={t("bank.loading")}>
+						<SimpleGrid cols={3}>
+							<Skeleton h={60} />
+							<Skeleton h={60} />
+							<Skeleton h={60} />
+						</SimpleGrid>
+					</LoadingSkeleton>
+				) : null}
+				{props.error && (
+					<Group role="alert">
+						<Text>{t(props.data ? "bank.refreshError" : "bank.error")}</Text>
+						<Button variant="default" onClick={props.retry}>
+							{t("bank.retry")}
+						</Button>
+					</Group>
+				)}
+				{props.data && props.fetching && (
+					<Text role="status">{t("bank.refreshing")}</Text>
+				)}
+			</Stack>
+		</Paper>
+	);
+};
+
+export { BankSummaryView };
@@ -0,0 +1,74 @@
+import { MantineProvider } from "@mantine/core";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { describe, expect, it } from "vitest";
+import { configureAuthClient } from "@/shared/api";
+import { createTestQueryClient } from "@/test/query";
+import { server } from "@/test/server";
+import { CategoryManager } from "./CategoryManager";
+
+describe("CategoryManager", () => {
+	it("rejects duplicate case-insensitive and too long names then renames default identity", async () => {
+		configureAuthClient({
+			accessToken: () => "test",
+			refresh: async () => false,
+			clear: () => {},
+		});
+		let category = {
+			id: "default",
+			name: "Другое",
+			isDefault: true,
+			version: 1,
+		};
+		let creates = 0;
+		let body: unknown;
+		server.use(
+			http.get("*/api/v1/bank-cards/categories", () =>
+				HttpResponse.json([category]),
+			),
+			http.post("*/api/v1/bank-cards/categories", () => {
+				creates++;
+				return HttpResponse.json({});
+			}),
+			http.patch(
+				"*/api/v1/bank-cards/categories/default",
+				async ({ request }) => {
+					body = await request.json();
+					category = { ...category, name: "Остальное", version: 2 };
+					return HttpResponse.json(category);
+				},
+			),
+		);
+		render(
+			<QueryClientProvider client={createTestQueryClient()}>
+				<MantineProvider env="test">
+					<CategoryManager onClose={() => {}} />
+				</MantineProvider>
+			</QueryClientProvider>,
+		);
+		await screen.findByText("Другое");
+		fireEvent.change(screen.getByLabelText(/Название категории/), {
+			target: { value: " другое " },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Добавить категорию" }));
+		await screen.findByText("Категория с таким названием уже есть.");
+		fireEvent.change(screen.getByLabelText(/Название категории/), {
+			target: { value: "a".repeat(81) },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Добавить категорию" }));
+		await screen.findByText("Введите название от 1 до 80 символов.");
+		expect(creates).toBe(0);
+		fireEvent.click(screen.getByRole("button", { name: "Переименовать" }));
+		fireEvent.input(screen.getByLabelText(/Название категории/), {
+			target: { value: "Остальное" },
+		});
+		fireEvent.blur(screen.getByLabelText(/Название категории/));
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText("Остальное");
+		await waitFor(() =>
+			expect(body).toEqual({ name: "Остальное", version: 1 }),
+		);
+		expect(screen.getByText("По умолчанию")).toBeInTheDocument();
+	});
+});
@@ -0,0 +1,215 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import {
+	Badge,
+	Button,
+	Group,
+	Modal,
+	Stack,
+	Text,
+	TextInput,
+} from "@mantine/core";
+import { type FC, useState } from "react";
+import {
+	Controller,
+	FormProvider,
+	useForm,
+	useFormContext,
+} from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { z } from "zod";
+import { validationMessage } from "@/shared/i18n";
+import { useBankMutations } from "../api/mutations";
+import { type ExpenseCategory, useBankCategories } from "../api/queries";
+import { BankFeedback } from "./BankFeedback";
+import classes from "./BankForms.module.css";
+import { useBankFormFocus } from "./useBankFormFocus";
+
+type CategoryManagerProps = {
+	onClose: () => void;
+	onCreated?: (id: string) => void;
+};
+type CategoryValues = { name: string };
+const CategoryFields: FC = () => {
+	const { t } = useTranslation();
+	const {
+		control,
+		formState: { errors },
+	} = useFormContext<CategoryValues>();
+	return (
+		<Controller
+			control={control}
+			name="name"
+			render={({ field }) => (
+				<TextInput
+					label={t("bank.categoryName")}
+					required
+					{...field}
+					error={errors.name?.message}
+				/>
+			)}
+		/>
+	);
+};
+const CategoryManager: FC<CategoryManagerProps> = (props) => {
+	useBankFormFocus();
+	const { t } = useTranslation();
+	const categories = useBankCategories();
+	const mutation = useBankMutations();
+	const [editing, setEditing] = useState<ExpenseCategory>();
+	const [error, setError] = useState<unknown>();
+	const [latest, setLatest] = useState<ExpenseCategory>();
+	const methods = useForm<CategoryValues>({
+		resolver: zodResolver(
+			z.object({
+				name: z
+					.string()
+					.trim()
+					.refine(
+						(value) => value.length > 0 && value.length <= 80,
+						validationMessage("bank.validation.category"),
+					)
+					.refine(
+						(value) =>
+							!categories.data?.some(
+								(c) =>
+									c.id !== editing?.id &&
+									c.name.toLocaleLowerCase("ru-RU") ===
+										value.toLocaleLowerCase("ru-RU"),
+							),
+						validationMessage("bank.validation.duplicate"),
+					),
+			}),
+		),
+		defaultValues: { name: "" },
+	});
+	const pending = methods.formState.isSubmitting;
+	return (
+		<Modal
+			opened
+			onClose={() => !pending && props.onClose()}
+			title={t("bank.categories")}
+			closeOnClickOutside={!pending}
+			closeOnEscape={!pending}
+			closeButtonProps={{ "aria-label": t("bank.close"), disabled: pending }}
+		>
+			<FormProvider {...methods}>
+				<form
+					onSubmit={methods.handleSubmit(async (values) => {
+						setError(undefined);
+						try {
+							if (editing)
+								await mutation.updateCategory.mutateAsync({
+									id: editing.id,
+									body: { name: values.name, version: editing.version },
+								});
+							else {
+								const result = await mutation.createCategory.mutateAsync({
+									name: values.name,
+								});
+								if (result) props.onCreated?.(result.id);
+							}
+							setEditing(undefined);
+							methods.reset({ name: "" });
+						} catch (failure) {
+							setError(failure);
+						}
+					})}
+				>
+					<fieldset disabled={pending} className={classes.fieldset}>
+						<Stack>
+							{categories.data?.map((category) => (
+								<Group justify="space-between" key={category.id}>
+									<Group gap="xs">
+										<Text>{category.name}</Text>
+										{category.isDefault && (
+											<Badge>{t("bank.defaultCategory")}</Badge>
+										)}
+									</Group>
+									<Button
+										variant="subtle"
+										onClick={() => {
+											setEditing(category);
+											methods.reset({ name: category.name });
+											setError(undefined);
+											setLatest(undefined);
+										}}
+									>
+										{t("bank.rename")}
+									</Button>
+								</Group>
+							))}
+							{categories.isLoading && (
+								<Text role="status">{t("bank.loading")}</Text>
+							)}
+							{categories.isError && (
+								<BankFeedback
+									loadingError
+									error={categories.error}
+									cached={Boolean(categories.data)}
+									retry={() => void categories.refetch()}
+								/>
+							)}
+							<CategoryFields />
+							{error ? (
+								<>
+									<BankFeedback error={error} />
+									{editing && (
+										<Button
+											variant="default"
+											onClick={async () => {
+												const response = await categories.refetch();
+												if (response.error) setError(response.error);
+												else
+													setLatest(
+														response.data?.find((c) => c.id === editing.id),
+													);
+											}}
+										>
+											{t("bank.reloadRecord")}
+										</Button>
+									)}
+								</>
+							) : null}
+							{latest && (
+								<>
+									<Text>{t("bank.versionHint", { details: latest.name })}</Text>
+									<Button
+										onClick={() => {
+											setEditing(latest);
+											setLatest(undefined);
+											setError(undefined);
+										}}
+									>
+										{t("bank.adoptVersion", { version: latest.version })}
+									</Button>
+								</>
+							)}
+							<Group>
+								<Button type="submit" loading={pending}>
+									{t(editing ? "bank.save" : "bank.addCategory")}
+								</Button>
+								{editing && (
+									<Button
+										variant="default"
+										onClick={() => {
+											setEditing(undefined);
+											methods.reset({ name: "" });
+											setError(undefined);
+										}}
+									>
+										{t("bank.cancel")}
+									</Button>
+								)}
+								<Button variant="default" onClick={props.onClose}>
+									{t("bank.close")}
+								</Button>
+							</Group>
+						</Stack>
+					</fieldset>
+				</form>
+			</FormProvider>
+		</Modal>
+	);
+};
+
+export { CategoryManager };
@@ -0,0 +1,16 @@
+import { useEffect, useState } from "react";
+
+function useBankFormFocus() {
+	const [trigger] = useState(() => document.activeElement);
+	useEffect(
+		() => () => {
+			queueMicrotask(() => {
+				if (trigger instanceof HTMLElement && trigger.isConnected)
+					trigger.focus();
+			});
+		},
+		[trigger],
+	);
+}
+
+export { useBankFormFocus };
@@ -8,6 +8,10 @@ import { createTestQueryClient } from "@/test/query";
 import { server } from "@/test/server";
 import { AuthProvider, useAuth } from "./auth";

+const bankCardsKey = apiQueryClient.queryOptions("get", "/api/v1/bank-cards", {
+	params: { query: { includeArchived: "false" } },
+}).queryKey;
+
 describe("AuthProvider", () => {
 	it("authorizes requests after restoring the initial session", async () => {
 		let authorization: string | null = null;
@@ -54,6 +58,7 @@ describe("AuthProvider", () => {
 		server.use(http.post("*/api/v1/auth/refresh", () => HttpResponse.error()));
 		const queryClient = createTestQueryClient();
 		queryClient.setQueryData(["cached-query"], { value: "stale" });
+		queryClient.setQueryData(bankCardsKey, [{ id: "bank-card-1" }]);
 		const wrapper: FC<PropsWithChildren> = (props) => {
 			const { children } = props;

@@ -70,6 +75,7 @@ describe("AuthProvider", () => {
 		expect(result.current.user).toBeNull();
 		expect(result.current.accessToken).toBeNull();
 		expect(queryClient.getQueryData(["cached-query"])).toBeUndefined();
+		expect(queryClient.getQueryData(bankCardsKey)).toBeUndefined();
 	});

 	it("keeps the original protected 401 when serialized refresh has a transport error", async () => {
@@ -90,6 +96,7 @@ describe("AuthProvider", () => {
 		);
 		const queryClient = createTestQueryClient();
 		queryClient.setQueryData(["cached-query"], { value: "stale" });
+		queryClient.setQueryData(bankCardsKey, [{ id: "bank-card-1" }]);
 		const wrapper: FC<PropsWithChildren> = (props) => {
 			const { children } = props;

@@ -110,6 +117,7 @@ describe("AuthProvider", () => {
 		await waitFor(() => expect(result.current.user).toBeNull());
 		expect(result.current.accessToken).toBeNull();
 		expect(queryClient.getQueryData(["cached-query"])).toBeUndefined();
+		expect(queryClient.getQueryData(bankCardsKey)).toBeUndefined();
 	});

 	it("clears connection status and financial cache independently on logout", async () => {
@@ -136,6 +144,7 @@ describe("AuthProvider", () => {
 			connectedAt: "2026-08-14T00:00:00Z",
 		});
 		queryClient.setQueryData(portfolioKey, { source: "current-connection" });
+		queryClient.setQueryData(bankCardsKey, [{ id: "bank-card-1" }]);
 		const wrapper: FC<PropsWithChildren> = (props) => {
 			const { children } = props;
 			return (
@@ -147,11 +156,15 @@ describe("AuthProvider", () => {
 		const { result } = renderHook(() => useAuth(), { wrapper });
 		await waitFor(() => expect(result.current.accessToken).toBe("test-token"));

+		expect(queryClient.getQueryData(bankCardsKey)).toEqual([
+			{ id: "bank-card-1" },
+		]);
 		await act(() => result.current.logout());

 		expect(result.current.user).toBeNull();
 		expect(result.current.accessToken).toBeNull();
 		expect(queryClient.getQueryData(statusKey)).toBeUndefined();
 		expect(queryClient.getQueryData(portfolioKey)).toBeUndefined();
+		expect(queryClient.getQueryData(bankCardsKey)).toBeUndefined();
 	});
 });
@@ -32,6 +32,13 @@ const bondQueryKey = apiQueryClient.queryOptions(
 	"/api/v1/bonds/{uid}/position",
 	{ params: { path: { uid: "e6123145-9665-43e0-8413-cd61b8aa9b13" } } },
 ).queryKey;
+const bankCardsQueryKey = apiQueryClient.queryOptions(
+	"get",
+	"/api/v1/bank-cards",
+	{
+		params: { query: { includeArchived: "false" } },
+	},
+).queryKey;
 const unrelatedQueryKey = apiQueryClient.queryOptions(
 	"get",
 	"/api/v1/auth/me",
@@ -66,6 +73,7 @@ function seededClient() {
 	client.setQueryData(stockQueryKey, { source: "previous-connection" });
 	client.setQueryData(bondQueryKey, { source: "previous-connection" });
 	client.setQueryData(unrelatedQueryKey, { id: "user-1" });
+	client.setQueryData(bankCardsQueryKey, [{ id: "bank-card-1" }]);
 	return client;
 }

@@ -86,6 +94,10 @@ describe("TbankConnectionSection", () => {
 			).toBeInTheDocument(),
 		);
 		expect(client.getQueryData(brokerageAccountsQueryKey)).toBeUndefined();
+		expect(client.getQueryData(bankCardsQueryKey)).toEqual([
+			{ id: "bank-card-1" },
+		]);
+		expect(client.getQueryState(bankCardsQueryKey)?.isInvalidated).toBe(false);
 		expect(client.getQueryData(portfolioQueryKey)).toBeUndefined();
 		expect(client.getQueryData(stockQueryKey)).toBeUndefined();
 		expect(client.getQueryData(bondQueryKey)).toBeUndefined();
@@ -114,6 +126,10 @@ describe("TbankConnectionSection", () => {
 			expect(client.getQueryData(portfolioQueryKey)).toBeUndefined(),
 		);
 		expect(client.getQueryData(brokerageAccountsQueryKey)).toBeUndefined();
+		expect(client.getQueryData(bankCardsQueryKey)).toEqual([
+			{ id: "bank-card-1" },
+		]);
+		expect(client.getQueryState(bankCardsQueryKey)?.isInvalidated).toBe(false);
 	});

 	it("commits disconnected status and resets financial queries after deleting", async () => {
@@ -139,6 +155,10 @@ describe("TbankConnectionSection", () => {
 			).toBeInTheDocument(),
 		);
 		expect(client.getQueryData(brokerageAccountsQueryKey)).toBeUndefined();
+		expect(client.getQueryData(bankCardsQueryKey)).toEqual([
+			{ id: "bank-card-1" },
+		]);
+		expect(client.getQueryState(bankCardsQueryKey)?.isInvalidated).toBe(false);
 		expect(client.getQueryData(portfolioQueryKey)).toBeUndefined();
 		expect(client.getQueryData(stockQueryKey)).toBeUndefined();
 		expect(client.getQueryData(bondQueryKey)).toBeUndefined();
@@ -0,0 +1 @@
+export { CardPage } from "./ui/CardPage";
@@ -0,0 +1,19 @@
+.wrap {
+	overflow-wrap: anywhere;
+	min-width: 0;
+}
+.operation {
+	min-width: 0;
+}
+.operation p {
+	white-space: normal;
+	overflow-wrap: anywhere;
+}
+.operation > div > div {
+	min-width: 0;
+}
+@media (min-width: 36em) {
+	.operation > div:first-child {
+		grid-template-columns: auto minmax(0, 1fr) minmax(0, 40%);
+	}
+}
@@ -0,0 +1,231 @@
+import { MantineProvider } from "@mantine/core";
+import { QueryClientProvider } from "@tanstack/react-query";
+import {
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+	within,
+} from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { MemoryRouter, Route, Routes } from "react-router";
+import { describe, expect, it } from "vitest";
+import { configureAuthClient } from "@/shared/api";
+import { createTestQueryClient } from "@/test/query";
+import { server } from "@/test/server";
+import { CardPage } from "./CardPage";
+
+const money = (value: string) => ({ currency: "RUB", value });
+const card = {
+	id: "a",
+	name: "Повседневная",
+	bankName: null,
+	lastFour: null,
+	balance: money("10000"),
+	openingBalance: money("10000"),
+	openingDate: "2026-01-01",
+	archivedAt: null,
+	version: 1,
+};
+const operation = {
+	id: "transfer",
+	kind: "transfer",
+	cardId: "a",
+	cardName: "Повседневная",
+	targetCardId: "b",
+	targetCardName: "Запасная",
+	categoryId: null,
+	categoryName: null,
+	originalExpenseId: null,
+	amount: money("50.01"),
+	availableRefund: null,
+	date: "2026-08-03",
+	description: null,
+	version: 1,
+	createdAt: "2026-08-03T00:00:00Z",
+};
+function setup(
+	options: {
+		missing?: boolean;
+		summaryError?: boolean;
+		cardsError?: boolean;
+	} = {},
+) {
+	configureAuthClient({
+		accessToken: () => "test",
+		refresh: async () => false,
+		clear: () => {},
+	});
+	const requests: string[] = [];
+	server.use(
+		http.get("*/api/v1/bank-cards/a", () =>
+			options.missing
+				? HttpResponse.json({ code: "BANK_NOT_FOUND" }, { status: 404 })
+				: HttpResponse.json(card),
+		),
+		http.get("*/api/v1/bank-cards", () =>
+			options.cardsError
+				? HttpResponse.error()
+				: HttpResponse.json([card, { ...card, id: "b", name: "Запасная" }]),
+		),
+		http.get("*/api/v1/bank-cards/a/operations", ({ request }) => {
+			requests.push(new URL(request.url).search);
+			return HttpResponse.json({
+				items: [operation],
+				page: 1,
+				total: 2,
+				hasNext: true,
+			});
+		}),
+		http.get("*/api/v1/bank-cards/summary", () =>
+			options.summaryError
+				? HttpResponse.error()
+				: HttpResponse.json({
+						month: "2026-08",
+						cardId: "a",
+						expenses: money("0"),
+						refunds: money("50"),
+						net: money("-50"),
+						categories: [],
+					}),
+		),
+	);
+	const client = createTestQueryClient();
+	render(
+		<QueryClientProvider client={client}>
+			<MantineProvider>
+				<MemoryRouter initialEntries={["/cards/a?month=2026-08"]}>
+					<Routes>
+						<Route path="/cards/:cardId" element={<CardPage />} />
+					</Routes>
+				</MemoryRouter>
+			</MantineProvider>
+		</QueryClientProvider>,
+	);
+	return { requests, client };
+}
+describe("CardPage", () => {
+	it("shares month with history, pages the journal and keeps current balance", async () => {
+		const { requests } = setup();
+		await screen.findByRole("heading", { name: "Повседневная" });
+		expect(
+			await screen.findByText("Перевод на «Запасная»"),
+		).toBeInTheDocument();
+		expect(screen.getByText("−50,01 ₽")).toBeInTheDocument();
+		expect(screen.getByText("-50 ₽")).toBeInTheDocument();
+		fireEvent.click(screen.getByRole("button", { name: "Далее" }));
+		await waitFor(() =>
+			expect(requests.some((v) => v.includes("page=2"))).toBe(true),
+		);
+		fireEvent.click(screen.getByLabelText("Месяц"));
+		fireEvent.click(await screen.findByRole("button", { name: "Jul" }));
+		await waitFor(() =>
+			expect(
+				requests.some(
+					(v) => v.includes("month=2026-07") && v.includes("page=1"),
+				),
+			).toBe(true),
+		);
+		expect(screen.getByText(/10\s000 ₽/)).toBeInTheDocument();
+	});
+	it("keeps card and journal when summary fails", async () => {
+		setup({ summaryError: true });
+		await screen.findByRole("heading", { name: "Повседневная" });
+		await screen.findByRole("alert");
+		expect(
+			await screen.findByText("Перевод на «Запасная»"),
+		).toBeInTheDocument();
+		expect(screen.queryByText("0 ₽")).not.toBeInTheDocument();
+	});
+	it("keeps cached card and history after refetch failure", async () => {
+		const { client } = setup();
+		await screen.findByText("Перевод на «Запасная»");
+		server.use(
+			http.get("*/api/v1/bank-cards/a", () => HttpResponse.error()),
+			http.get("*/api/v1/bank-cards/a/operations", () => HttpResponse.error()),
+		);
+		await client.invalidateQueries();
+		await screen.findAllByRole("alert");
+		expect(
+			screen.getByRole("heading", { name: "Повседневная" }),
+		).toBeInTheDocument();
+		expect(screen.getByText("Перевод на «Запасная»")).toBeInTheDocument();
+	});
+	it("handles inaccessible card neutrally", async () => {
+		setup({ missing: true });
+		await screen.findByRole("heading", { name: "Карта не найдена" });
+		expect(screen.getByRole("link", { name: "К картам" })).toHaveAttribute(
+			"href",
+			"/cards",
+		);
+		expect(screen.queryByText(/10\s000 ₽/)).not.toBeInTheDocument();
+	});
+	it("archives without deleting history and restores financial actions", async () => {
+		setup();
+		await screen.findByText("Перевод на «Запасная»");
+		let current = card;
+		const bodies: unknown[] = [];
+		server.use(
+			http.get("*/api/v1/bank-cards/a", () => HttpResponse.json(current)),
+			http.get("*/api/v1/bank-cards", () =>
+				HttpResponse.json([current, { ...card, id: "b", name: "Запасная" }]),
+			),
+			http.patch("*/api/v1/bank-cards/a", async ({ request }) => {
+				const body = (await request.json()) as {
+					version: number;
+					archived: boolean;
+				};
+				bodies.push(body);
+				current = {
+					...current,
+					version: current.version + 1,
+					archivedAt: body.archived ? "2026-09-01" : null,
+				} as typeof card;
+				return HttpResponse.json(current);
+			}),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Убрать в архив" }));
+		await screen.findByRole("button", { name: "Вернуть из архива" });
+		expect(
+			screen.getByRole("button", { name: "Добавить операцию" }),
+		).toBeDisabled();
+		expect(screen.getByRole("button", { name: "Изменить" })).toBeDisabled();
+		expect(screen.getByText("Перевод на «Запасная»")).toBeInTheDocument();
+		fireEvent.click(screen.getByRole("button", { name: "Вернуть из архива" }));
+		await screen.findByRole("button", { name: "Убрать в архив" });
+		expect(
+			screen.getByRole("button", { name: "Добавить операцию" }),
+		).toBeEnabled();
+		expect(bodies).toEqual([
+			{ version: 1, archived: true },
+			{ version: 2, archived: false },
+		]);
+	});
+	it("recovers the prerequisite card list while preserving the visible balance and journal", async () => {
+		setup({ cardsError: true });
+		await screen.findByText("Перевод на «Запасная»");
+		expect(await screen.findByRole("alert")).toHaveTextContent(
+			"Не удалось загрузить данные карт.",
+		);
+		expect(
+			screen.getByRole("button", { name: "Добавить операцию" }),
+		).toBeDisabled();
+		server.use(
+			http.get("*/api/v1/bank-cards", () =>
+				HttpResponse.json([card, { ...card, id: "b", name: "Запасная" }]),
+			),
+		);
+		fireEvent.click(
+			within(screen.getByRole("alert")).getByRole("button", {
+				name: "Повторить",
+			}),
+		);
+		await waitFor(() =>
+			expect(
+				screen.getByRole("button", { name: "Добавить операцию" }),
+			).toBeEnabled(),
+		);
+		expect(screen.getByText("Перевод на «Запасная»")).toBeInTheDocument();
+		expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+	});
+});
@@ -0,0 +1,37 @@
+import type { FC } from "react";
+import { BankCardForm } from "@/entities/bank-card";
+import { CardPageView } from "./CardPage.view";
+import { useCardPageVm } from "./CardPage.vm";
+import { DeleteOperation } from "./DeleteOperation";
+import { OperationForm } from "./OperationForm";
+
+const CardPage: FC = () => {
+	const vm = useCardPageVm();
+	return (
+		<>
+			<CardPageView vm={vm} />
+			{vm.editingCard && vm.card.data && (
+				<BankCardForm
+					card={vm.card.data}
+					onClose={() => vm.setEditingCard(false)}
+				/>
+			)}
+			{vm.operation && vm.card.data && vm.cards.data && (
+				<OperationForm
+					card={vm.card.data}
+					cards={vm.cards.data}
+					operation={vm.operation === "new" ? undefined : vm.operation}
+					onClose={() => vm.setOperation(null)}
+				/>
+			)}
+			{vm.deleting && (
+				<DeleteOperation
+					operation={vm.deleting}
+					onClose={() => vm.setDeleting(null)}
+				/>
+			)}
+		</>
+	);
+};
+
+export { CardPage };
@@ -0,0 +1,226 @@
+import {
+	Anchor,
+	Badge,
+	Button,
+	Group,
+	Paper,
+	Skeleton,
+	Stack,
+	Text,
+	Title,
+} from "@mantine/core";
+import { MonthPickerInput } from "@mantine/dates";
+import type { FC } from "react";
+import { useTranslation } from "react-i18next";
+import { Link } from "react-router";
+import { BankFeedback, BankSummaryView } from "@/entities/bank-card";
+import { formatMoney } from "@/shared/lib";
+import { EntryCard, LoadingSkeleton, StateView } from "@/shared/ui";
+import classes from "./CardPage.module.css";
+import type { CardPageVm } from "./CardPage.vm";
+
+type CardPageViewProps = { vm: CardPageVm };
+const CardPageView: FC<CardPageViewProps> = (props) => {
+	const { vm } = props;
+	const { t } = useTranslation();
+	const card = vm.card.data;
+	if (!card) {
+		if (vm.card.isLoading)
+			return (
+				<LoadingSkeleton label={t("bank.loading")}>
+					<Stack>
+						<Skeleton h={130} />
+						<Skeleton h={160} />
+						<Skeleton h={90} />
+						<Skeleton h={90} />
+					</Stack>
+				</LoadingSkeleton>
+			);
+		return (
+			<StateView
+				error
+				title={t(vm.notFound ? "bank.notFound" : "bank.error")}
+				text={t("bank.back")}
+				action={
+					<Group>
+						<Button component={Link} to="/cards">
+							{t("bank.back")}
+						</Button>
+						{!vm.notFound && (
+							<Button onClick={() => void vm.card.refetch()}>
+								{t("bank.retry")}
+							</Button>
+						)}
+					</Group>
+				}
+			/>
+		);
+	}
+	return (
+		<Stack gap="lg">
+			<Paper p="md" withBorder>
+				<Stack>
+					<Group justify="space-between">
+						<Title order={1} className={classes.wrap}>
+							{card.name}
+						</Title>
+						{card.archivedAt && (
+							<Badge color="gray">{t("bank.archived")}</Badge>
+						)}
+					</Group>
+					<Text c="dimmed">
+						{card.bankName}
+						{card.lastFour ? ` · •• ${card.lastFour}` : ""}
+					</Text>
+					<Text size="xl" fw={700} className={classes.wrap}>
+						{formatMoney(card.balance)}
+					</Text>
+					<Text c="dimmed">{t("bank.manualBalance")}</Text>
+					<Group>
+						<Button
+							disabled={Boolean(card.archivedAt) || !vm.cards.data}
+							onClick={() => vm.setOperation("new")}
+						>
+							{t("bank.addOperation")}
+						</Button>
+						<Button variant="default" onClick={() => vm.setEditingCard(true)}>
+							{t("bank.editCard")}
+						</Button>
+						<Button
+							variant="default"
+							loading={vm.archivePending}
+							onClick={() => void vm.toggleArchive()}
+						>
+							{t(card.archivedAt ? "bank.restore" : "bank.archive")}
+						</Button>
+					</Group>
+					{vm.archiveError ? (
+						<BankFeedback
+							error={vm.archiveError}
+							retry={() => void vm.card.refetch()}
+						/>
+					) : null}
+					{card.archivedAt && <Text>{t("bank.archiveHint")}</Text>}
+				</Stack>
+			</Paper>
+			{vm.card.isError && (
+				<Group role="alert">
+					<Text>{t("bank.refreshError")}</Text>
+					<Button onClick={() => void vm.card.refetch()}>
+						{t("bank.retry")}
+					</Button>
+				</Group>
+			)}
+			{vm.card.isFetching && <Text role="status">{t("bank.refreshing")}</Text>}
+			{vm.cards.isError && (
+				<BankFeedback
+					loadingError
+					error={vm.cards.error}
+					cached={Boolean(vm.cards.data)}
+					retry={() => void vm.cards.refetch()}
+				/>
+			)}
+			<MonthPickerInput
+				label={t("bank.month")}
+				value={`${vm.month}-01`}
+				onChange={(value) => {
+					if (value) vm.setMonth(value.slice(0, 7));
+				}}
+				popoverProps={{ middlewares: { shift: { crossAxis: true } } }}
+			/>
+			<BankSummaryView
+				data={vm.summary.data}
+				loading={vm.summary.isLoading}
+				fetching={vm.summary.isFetching}
+				error={vm.summary.isError}
+				retry={() => void vm.summary.refetch()}
+			/>
+			<Title order={2}>{t("bank.operations")}</Title>
+			{vm.rows ? (
+				vm.rows.length ? (
+					vm.rows.map((row) => (
+						<section
+							key={row.item.id}
+							className={classes.operation}
+							aria-label={`${row.title} ${row.item.date}`}
+						>
+							<EntryCard
+								title={row.title}
+								metadata={row.metadata}
+								initial={row.title[0]}
+								value={row.value}
+								valueLabel={t(`bank.kinds.${row.item.kind}`)}
+								tone={row.tone}
+								details={
+									row.otherCard ? (
+										<Anchor
+											component={Link}
+											to={`/cards/${row.otherCard}?month=${vm.month}`}
+										>
+											{t("bank.card")}
+										</Anchor>
+									) : null
+								}
+							/>
+							<Group mt="xs">
+								<Button
+									variant="subtle"
+									disabled={!row.editable || Boolean(card.archivedAt)}
+									onClick={() => vm.setOperation(row.item)}
+								>
+									{t("bank.edit")}
+								</Button>
+								<Button
+									variant="subtle"
+									color="red"
+									disabled={!row.editable || Boolean(card.archivedAt)}
+									onClick={() => vm.setDeleting(row.item)}
+								>
+									{t("bank.delete")}
+								</Button>
+							</Group>
+						</section>
+					))
+				) : (
+					<Text>{t("bank.noOperations")}</Text>
+				)
+			) : vm.history.isLoading ? (
+				<LoadingSkeleton label={t("bank.loadingHistory")}>
+					<Stack>
+						<Skeleton h={90} />
+						<Skeleton h={90} />
+					</Stack>
+				</LoadingSkeleton>
+			) : null}
+			{vm.history.isError && (
+				<Group role="alert">
+					<Text>{t(vm.rows ? "bank.refreshError" : "bank.error")}</Text>
+					<Button onClick={() => void vm.history.refetch()}>
+						{t("bank.retry")}
+					</Button>
+				</Group>
+			)}
+			{vm.history.data && (
+				<Group>
+					<Button
+						variant="default"
+						disabled={vm.page === 1 || vm.history.isFetching}
+						onClick={() => vm.setPage(vm.page - 1)}
+					>
+						{t("bank.previous")}
+					</Button>
+					<Text>{t("bank.page", { page: vm.page })}</Text>
+					<Button
+						variant="default"
+						disabled={!vm.history.data.hasNext || vm.history.isFetching}
+						onClick={() => vm.setPage(vm.page + 1)}
+					>
+						{t("bank.next")}
+					</Button>
+				</Group>
+			)}
+		</Stack>
+	);
+};
+
+export { CardPageView };
@@ -0,0 +1,103 @@
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { useParams, useSearchParams } from "react-router";
+import {
+	type BankOperation,
+	bankMonth,
+	useBankCard,
+	useBankCards,
+	useBankMutations,
+	useBankOperations,
+	useBankSummary,
+} from "@/entities/bank-card";
+import { apiErrorCode } from "@/shared/api";
+import { formatMoney } from "@/shared/lib";
+
+function useCardPageVm() {
+	const { cardId } = useParams();
+	const [params, setParams] = useSearchParams();
+	const { t } = useTranslation();
+	const month = bankMonth(params.get("month"));
+	const rawPage = Number(params.get("page") ?? 1);
+	const page = Number.isSafeInteger(rawPage) && rawPage > 0 ? rawPage : 1;
+	const card = useBankCard(cardId);
+	const { updateCard } = useBankMutations();
+	const [archiveError, setArchiveError] = useState<unknown>();
+	const cards = useBankCards(true);
+	const history = useBankOperations(cardId, { month, page });
+	const summary = useBankSummary(month, cardId);
+	const [editingCard, setEditingCard] = useState(false);
+	const [operation, setOperation] = useState<BankOperation | "new" | null>(
+		null,
+	);
+	const [deleting, setDeleting] = useState<BankOperation | null>(null);
+	const rows = history.data?.items.map((item) => {
+		const outgoing =
+			item.kind === "expense" ||
+			(item.kind === "transfer" && item.cardId === cardId);
+		return {
+			item,
+			title:
+				item.kind === "transfer"
+					? t(outgoing ? "bank.transferTo" : "bank.transferFrom", {
+							name: outgoing ? item.targetCardName : item.cardName,
+						})
+					: t(`bank.kinds.${item.kind}`),
+			metadata: [item.date, item.categoryName, item.description]
+				.filter(Boolean)
+				.join(" · "),
+			value: `${outgoing ? "−" : "+"}${formatMoney(item.amount)}`,
+			tone: outgoing ? ("negative" as const) : ("positive" as const),
+			otherCard:
+				item.kind === "transfer"
+					? outgoing
+						? item.targetCardId
+						: item.cardId
+					: null,
+			editable:
+				Boolean(cards.data) &&
+				!cards.data?.some(
+					(c) =>
+						(c.id === item.cardId || c.id === item.targetCardId) &&
+						c.archivedAt,
+				),
+		};
+	});
+	return {
+		card,
+		cards,
+		archiveError,
+		archivePending: updateCard.isPending,
+		toggleArchive: async () => {
+			if (!card.data) return;
+			setArchiveError(undefined);
+			try {
+				await updateCard.mutateAsync({
+					id: card.data.id,
+					body: { version: card.data.version, archived: !card.data.archivedAt },
+				});
+			} catch (failure) {
+				setArchiveError(failure);
+			}
+		},
+		history,
+		summary,
+		month,
+		page,
+		rows,
+		editingCard,
+		setEditingCard,
+		operation,
+		setOperation,
+		deleting,
+		setDeleting,
+		notFound: apiErrorCode(card.error) === "BANK_NOT_FOUND",
+		setMonth: (value: string) => {
+			if (value) setParams({ month: bankMonth(value) });
+		},
+		setPage: (value: number) => setParams({ month, page: String(value) }),
+	};
+}
+type CardPageVm = ReturnType<typeof useCardPageVm>;
+
+export { type CardPageVm, useCardPageVm };
@@ -0,0 +1,76 @@
+import { MantineProvider } from "@mantine/core";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { describe, expect, it, vi } from "vitest";
+import type { BankOperation } from "@/entities/bank-card";
+import { configureAuthClient } from "@/shared/api";
+import { createTestQueryClient } from "@/test/query";
+import { server } from "@/test/server";
+import { DeleteOperation } from "./DeleteOperation";
+
+const transfer: BankOperation = {
+	id: "transfer",
+	kind: "transfer",
+	cardId: "a",
+	cardName: "Основная",
+	targetCardId: "b",
+	targetCardName: "Запасная",
+	categoryId: null,
+	categoryName: null,
+	originalExpenseId: null,
+	amount: { currency: "RUB", value: "100" },
+	availableRefund: null,
+	date: "2026-08-01",
+	description: null,
+	version: 1,
+	createdAt: "2026-08-01T00:00:00Z",
+};
+describe("DeleteOperation", () => {
+	it("names both sides and requires a deliberate fresh version after conflict", async () => {
+		configureAuthClient({
+			accessToken: () => "test",
+			refresh: async () => false,
+			clear: () => {},
+		});
+		const versions: string[] = [];
+		server.use(
+			http.get("*/api/v1/bank-cards/operations/transfer", () =>
+				HttpResponse.json({ ...transfer, version: 2 }),
+			),
+			http.delete("*/api/v1/bank-cards/operations/transfer", ({ request }) => {
+				const version = new URL(request.url).searchParams.get("version") ?? "";
+				versions.push(version);
+				return version === "1"
+					? HttpResponse.json(
+							{ code: "BANK_VERSION_CONFLICT" },
+							{ status: 409 },
+						)
+					: new HttpResponse(null, { status: 204 });
+			}),
+		);
+		const close = vi.fn();
+		render(
+			<QueryClientProvider client={createTestQueryClient()}>
+				<MantineProvider env="test">
+					<DeleteOperation operation={transfer} onClose={close} />
+				</MantineProvider>
+			</QueryClientProvider>,
+		);
+		expect(screen.getByText(/«Основная» → «Запасная»/)).toHaveTextContent(
+			"Обе стороны перевода будут удалены.",
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Удалить" }));
+		await screen.findByText(/Запись уже изменена/);
+		expect(close).not.toHaveBeenCalled();
+		fireEvent.click(screen.getByRole("button", { name: "Перечитать запись" }));
+		fireEvent.click(
+			await screen.findByRole("button", {
+				name: "Использовать актуальную версию 2",
+			}),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Удалить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(versions).toEqual(["1", "2"]);
+	});
+});
@@ -0,0 +1,111 @@
+import { Button, Group, Modal, Stack, Text } from "@mantine/core";
+import { type FC, useState } from "react";
+import { useTranslation } from "react-i18next";
+import {
+	BankFeedback,
+	type BankOperation,
+	useBankFormFocus,
+	useBankMutations,
+	useBankOperation,
+} from "@/entities/bank-card";
+import { formatMoney } from "@/shared/lib";
+
+type DeleteOperationProps = { operation: BankOperation; onClose: () => void };
+const DeleteOperation: FC<DeleteOperationProps> = (props) => {
+	useBankFormFocus();
+	const { t } = useTranslation();
+	const [record, setRecord] = useState(props.operation);
+	const [latest, setLatest] = useState<BankOperation>();
+	const [error, setError] = useState<unknown>();
+	const query = useBankOperation(record.id);
+	const { deleteOperation } = useBankMutations();
+	const pending =
+		deleteOperation.isPending || (query.isFetching && Boolean(error));
+	return (
+		<Modal
+			opened
+			onClose={() => !pending && props.onClose()}
+			title={t("bank.deleteTitle")}
+			closeOnEscape={!pending}
+			closeOnClickOutside={!pending}
+			closeButtonProps={{ "aria-label": t("bank.close"), disabled: pending }}
+		>
+			<Stack>
+				<Text>
+					{record.kind === "transfer"
+						? t("bank.deleteTransfer", {
+								amount: formatMoney(record.amount),
+								source: record.cardName,
+								target: record.targetCardName,
+							})
+						: t("bank.deleteHint", {
+								kind: t(`bank.kinds.${record.kind}`),
+								amount: formatMoney(record.amount),
+								card: record.cardName,
+							})}
+				</Text>
+				{error ? (
+					<>
+						<BankFeedback error={error} />
+						<Button
+							variant="default"
+							disabled={pending}
+							onClick={async () => {
+								const result = await query.refetch();
+								if (result.data && !result.error) setLatest(result.data);
+								else setError(result.error);
+							}}
+						>
+							{t("bank.reloadRecord")}
+						</Button>
+					</>
+				) : null}
+				{latest && (
+					<>
+						<Text>
+							{t("bank.versionHint", {
+								details: `${latest.date} · ${formatMoney(latest.amount)} · ${latest.description ?? ""}`,
+							})}
+						</Text>
+						<Button
+							variant="default"
+							disabled={pending}
+							onClick={() => {
+								setRecord(latest);
+								setLatest(undefined);
+								setError(undefined);
+							}}
+						>
+							{t("bank.adoptVersion", { version: latest.version })}
+						</Button>
+					</>
+				)}
+				<Group>
+					<Button
+						color="red"
+						loading={pending}
+						onClick={async () => {
+							setError(undefined);
+							try {
+								await deleteOperation.mutateAsync({
+									id: record.id,
+									version: record.version,
+								});
+								props.onClose();
+							} catch (failure) {
+								setError(failure);
+							}
+						}}
+					>
+						{t("bank.delete")}
+					</Button>
+					<Button variant="default" disabled={pending} onClick={props.onClose}>
+						{t("bank.cancel")}
+					</Button>
+				</Group>
+			</Stack>
+		</Modal>
+	);
+};
+
+export { DeleteOperation };
@@ -0,0 +1,6 @@
+.fieldset {
+	border: 0;
+	margin: 0;
+	padding: 0;
+	min-width: 0;
+}
@@ -0,0 +1,458 @@
+import { MantineProvider } from "@mantine/core";
+import { QueryClientProvider } from "@tanstack/react-query";
+import {
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+	within,
+} from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { describe, expect, it, vi } from "vitest";
+import type { BankCard, BankOperation } from "@/entities/bank-card";
+import { configureAuthClient } from "@/shared/api";
+import { createTestQueryClient } from "@/test/query";
+import { server } from "@/test/server";
+import { OperationForm } from "./OperationForm";
+
+const money = (value: string) => ({ currency: "RUB", value });
+const card: BankCard = {
+	id: "a",
+	name: "Повседневная",
+	bankName: null,
+	lastFour: null,
+	balance: money("0"),
+	openingBalance: money("0"),
+	openingDate: "2026-01-01",
+	archivedAt: null,
+	version: 1,
+};
+function setup(operation?: BankOperation) {
+	configureAuthClient({
+		accessToken: () => "test",
+		refresh: async () => false,
+		clear: () => {},
+	});
+	server.use(
+		http.get("*/api/v1/bank-cards/categories", () =>
+			HttpResponse.json([
+				{ id: "default", name: "Остальное", isDefault: true, version: 2 },
+			]),
+		),
+	);
+	const close = vi.fn();
+	render(
+		<QueryClientProvider client={createTestQueryClient()}>
+			<MantineProvider env="test">
+				<OperationForm
+					operation={operation}
+					card={card}
+					cards={[
+						card,
+						{ ...card, id: "b", name: "Запасная", openingDate: "2026-08-01" },
+						{
+							...card,
+							id: "archived",
+							name: "Архивная",
+							archivedAt: "2026-01-02",
+						},
+					]}
+					onClose={close}
+				/>
+			</MantineProvider>
+		</QueryClientProvider>,
+	);
+	return close;
+}
+async function select(label: string, value: string | RegExp) {
+	fireEvent.click(screen.getByRole("combobox", { name: new RegExp(label) }));
+	fireEvent.click(await screen.findByRole("option", { name: value }));
+}
+describe("OperationForm", () => {
+	it("uses renamed default category and exact maximum positive money despite zero balance", async () => {
+		const close = setup();
+		await waitFor(() =>
+			expect(screen.getByRole("combobox", { name: /Категория/ })).toHaveValue(
+				"Остальное",
+			),
+		);
+		let body: unknown;
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				body = await request.json();
+				return HttpResponse.json({}, { status: 201 });
+			}),
+		);
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "92233720368547758,07" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(body).toMatchObject({
+			categoryId: "default",
+			amount: money("92233720368547758.07"),
+		});
+	});
+	it("checks both transfer opening dates, excludes archive and reuses intent after a lost response", async () => {
+		setup();
+		await select("Вид операции", "Перевод");
+		await select("Карта-получатель", "Запасная");
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "0" },
+		});
+		fireEvent.change(screen.getByLabelText(/Дата операции/), {
+			target: { value: "2026-07-31" },
+		});
+		const bodies: unknown[] = [];
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				bodies.push(await request.json());
+				return bodies.length === 1
+					? HttpResponse.error()
+					: HttpResponse.json({}, { status: 201 });
+			}),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		expect(
+			await screen.findByText("Сумма операции должна быть больше нуля."),
+		).toBeInTheDocument();
+		expect(screen.getByText(/Дата не может быть раньше/)).toBeInTheDocument();
+		expect(bodies).toHaveLength(0);
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "150,01" },
+		});
+		fireEvent.change(screen.getByLabelText(/Дата операции/), {
+			target: { value: "2026-08-02" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText(/Не удалось подтвердить сохранение/);
+		expect(screen.getByLabelText(/Сумма/)).toHaveValue("150,01");
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(bodies).toHaveLength(2));
+		expect(bodies[0]).toEqual(bodies[1]);
+		expect(bodies[0]).toMatchObject({
+			kind: "transfer",
+			cardId: "a",
+			targetCardId: "b",
+			amount: money("150.01"),
+		});
+	});
+	it("topup omits categories and preserves entered description", async () => {
+		setup();
+		await select("Вид операции", "Пополнение");
+		expect(
+			screen.queryByRole("combobox", { name: /Категория/ }),
+		).not.toBeInTheDocument();
+		let body: unknown;
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				body = await request.json();
+				return HttpResponse.json({}, { status: 201 });
+			}),
+		);
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "0.10" },
+		});
+		fireEvent.change(screen.getByLabelText(/Описание/), {
+			target: { value: "Внесение" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(body).toBeDefined());
+		expect(body).toMatchObject({
+			kind: "topup",
+			amount: money("0.10"),
+			description: "Внесение",
+		});
+		expect(body).not.toHaveProperty("categoryId");
+	});
+	it("finds a previous-month purchase across pages, checks remaining refund and retains the complete-refund intent", async () => {
+		const purchase: BankOperation = {
+			id: "purchase",
+			kind: "expense",
+			cardId: "a",
+			cardName: card.name,
+			targetCardId: null,
+			targetCardName: null,
+			categoryId: "default",
+			categoryName: "Остальное",
+			originalExpenseId: null,
+			amount: money("500"),
+			availableRefund: money("500"),
+			date: "2026-07-01",
+			description: "Прошлая покупка",
+			version: 1,
+			createdAt: "2026-07-01T00:00:00Z",
+		};
+		server.use(
+			http.get("*/api/v1/bank-cards/a/expenses", ({ request }) => {
+				return HttpResponse.json({
+					items:
+						new URL(request.url).searchParams.get("page") === "2"
+							? [purchase]
+							: [],
+					page: 1,
+					total: 1,
+					hasNext: new URL(request.url).searchParams.get("page") !== "2",
+				});
+			}),
+			http.get("*/api/v1/bank-cards/operations/purchase", () =>
+				HttpResponse.json(purchase),
+			),
+		);
+		const close = setup();
+		await select("Вид операции", "Возврат");
+		await waitFor(() =>
+			expect(screen.getByRole("button", { name: "Далее" })).toBeEnabled(),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Далее" }));
+		await waitFor(() =>
+			expect(screen.getByRole("button", { name: "Назад" })).toBeEnabled(),
+		);
+		await select("Исходная покупка", /Прошлая покупка/);
+		await screen.findByText("Доступно к возврату: 500 ₽");
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "500.01" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText("Сумма превышает доступный возврат.");
+		const bodies: unknown[] = [];
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				bodies.push(await request.json());
+				purchase.availableRefund = money("0");
+				return bodies.length === 1
+					? HttpResponse.error()
+					: HttpResponse.json({}, { status: 201 });
+			}),
+		);
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "500" },
+		});
+		fireEvent.change(screen.getByLabelText(/Дата операции/), {
+			target: { value: "2026-08-01" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText(/Не удалось подтвердить сохранение/);
+		fireEvent.click(screen.getByRole("button", { name: "Перечитать запись" }));
+		await screen.findByText("Доступно к возврату: 0 ₽");
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(bodies[0]).toEqual(bodies[1]);
+		expect(bodies[0]).toMatchObject({
+			kind: "refund",
+			originalExpenseId: "purchase",
+			date: "2026-08-01",
+		});
+	});
+	it("edits a full refund with its own amount excluded from the limit and immutable purchase", async () => {
+		const refund: BankOperation = {
+			id: "refund",
+			kind: "refund",
+			cardId: "a",
+			cardName: card.name,
+			targetCardId: null,
+			targetCardName: null,
+			categoryId: "default",
+			categoryName: "Остальное",
+			originalExpenseId: "purchase",
+			amount: money("500"),
+			availableRefund: money("500"),
+			date: "2026-08-01",
+			description: "",
+			version: 2,
+			createdAt: "2026-08-01T00:00:00Z",
+		};
+		const purchase = {
+			...refund,
+			id: "purchase",
+			kind: "expense",
+			date: "2026-07-01",
+			availableRefund: money("0"),
+		};
+		server.use(
+			http.get("*/api/v1/bank-cards/a/expenses", () =>
+				HttpResponse.json({
+					items: [purchase],
+					page: 1,
+					total: 1,
+					hasNext: false,
+				}),
+			),
+			http.get("*/api/v1/bank-cards/operations/purchase", () =>
+				HttpResponse.json(purchase),
+			),
+			http.get("*/api/v1/bank-cards/operations/refund", () =>
+				HttpResponse.json(refund),
+			),
+		);
+		const close = setup(refund);
+		await screen.findByText("Доступно к возврату: 500 ₽");
+		expect(
+			screen.getByRole("combobox", { name: /Исходная покупка/ }),
+		).toBeDisabled();
+		expect(
+			screen.getByRole("combobox", { name: /Вид операции/ }),
+		).toBeDisabled();
+		fireEvent.change(screen.getByLabelText(/Описание/), {
+			target: { value: "Полностью возвращено" },
+		});
+		let body: unknown;
+		server.use(
+			http.patch(
+				"*/api/v1/bank-cards/operations/refund",
+				async ({ request }) => {
+					body = await request.json();
+					return HttpResponse.json(refund);
+				},
+			),
+		);
+		await waitFor(() =>
+			expect(screen.getByRole("button", { name: "Сохранить" })).toBeEnabled(),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(body).toMatchObject({
+			version: 2,
+			amount: money("500"),
+			originalExpenseId: "purchase",
+			description: "Полностью возвращено",
+		});
+	});
+
+	it("keeps edit draft and stale version until explicit adoption after conflict", async () => {
+		const operation: BankOperation = {
+			id: "expense",
+			kind: "expense",
+			cardId: "a",
+			cardName: card.name,
+			targetCardId: null,
+			targetCardName: null,
+			categoryId: "default",
+			categoryName: "Остальное",
+			originalExpenseId: null,
+			amount: money("100"),
+			availableRefund: money("100"),
+			date: "2026-08-01",
+			description: "Первое",
+			version: 1,
+			createdAt: "2026-08-01T00:00:00Z",
+		};
+		let readVersion = 1;
+		const bodies: Record<string, unknown>[] = [];
+		server.use(
+			http.get("*/api/v1/bank-cards/operations/expense", () =>
+				HttpResponse.json({
+					...operation,
+					version: readVersion,
+					description: readVersion === 1 ? "Первое" : "Другое исправление",
+				}),
+			),
+			http.patch(
+				"*/api/v1/bank-cards/operations/expense",
+				async ({ request }) => {
+					const body = (await request.json()) as Record<string, unknown>;
+					bodies.push(body);
+					readVersion = 2;
+					return body.version === 1
+						? HttpResponse.json(
+								{ code: "BANK_VERSION_CONFLICT" },
+								{ status: 409 },
+							)
+						: HttpResponse.json({ ...operation, ...body });
+				},
+			),
+		);
+		const close = setup(operation);
+		fireEvent.change(screen.getByLabelText(/Описание/), {
+			target: { value: "Мой черновик" },
+		});
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "150" },
+		});
+		await waitFor(() =>
+			expect(screen.getByRole("button", { name: "Сохранить" })).toBeEnabled(),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await screen.findByText(/Запись уже изменена/);
+		expect(screen.getByLabelText(/Описание/)).toHaveValue("Мой черновик");
+		fireEvent.click(screen.getByRole("button", { name: "Перечитать запись" }));
+		await screen.findByRole("button", {
+			name: "Использовать актуальную версию 2",
+		});
+		expect(screen.getByLabelText(/Сумма/)).toHaveValue("150");
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(bodies).toHaveLength(2));
+		expect(bodies[1].version).toBe(1);
+		fireEvent.click(
+			screen.getByRole("button", { name: "Использовать актуальную версию 2" }),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(close).toHaveBeenCalled());
+		expect(bodies[2]).toMatchObject({
+			version: 2,
+			description: "Мой черновик",
+			amount: money("150"),
+		});
+	});
+	it("creates a category inside expense without losing operation fields", async () => {
+		setup();
+		fireEvent.change(screen.getByLabelText(/Сумма/), {
+			target: { value: "001.20" },
+		});
+		fireEvent.change(screen.getByLabelText(/Описание/), {
+			target: { value: "Черновик расхода" },
+		});
+		fireEvent.click(screen.getByRole("button", { name: "Добавить категорию" }));
+		const dialog = screen.getByRole("dialog", { name: "Категории" });
+		fireEvent.change(within(dialog).getByLabelText(/Название категории/), {
+			target: { value: " кафе " },
+		});
+		let created = false;
+		server.use(
+			http.post("*/api/v1/bank-cards/categories", () => {
+				created = true;
+				return HttpResponse.json(
+					{ id: "new", name: "кафе", version: 1, isDefault: false },
+					{ status: 201 },
+				);
+			}),
+			http.get("*/api/v1/bank-cards/categories", () =>
+				HttpResponse.json([
+					{ id: "default", name: "Остальное", isDefault: true, version: 2 },
+					...(created
+						? [{ id: "new", name: "кафе", isDefault: false, version: 1 }]
+						: []),
+				]),
+			),
+		);
+		fireEvent.click(
+			within(dialog).getByRole("button", { name: "Добавить категорию" }),
+		);
+		await waitFor(() =>
+			expect(
+				screen.queryByRole("dialog", { name: "Категории" }),
+			).not.toBeInTheDocument(),
+		);
+		expect(screen.getByLabelText(/Сумма/)).toHaveValue("001.20");
+		expect(screen.getByLabelText(/Описание/)).toHaveValue("Черновик расхода");
+		await waitFor(() =>
+			expect(screen.getByRole("combobox", { name: /Категория/ })).toHaveValue(
+				"кафе",
+			),
+		);
+		let body: unknown;
+		server.use(
+			http.post("*/api/v1/bank-cards/operations", async ({ request }) => {
+				body = await request.json();
+				return HttpResponse.json({}, { status: 201 });
+			}),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(body).toBeDefined());
+		expect(body).toMatchObject({
+			categoryId: "new",
+			description: "Черновик расхода",
+			amount: money("1.20"),
+		});
+	});
+});
@@ -0,0 +1,417 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Button, Group, Modal, Stack, Text } from "@mantine/core";
+import { type FC, useState } from "react";
+import { FormProvider, useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { z } from "zod";
+import {
+	type BankCard,
+	BankFeedback,
+	type BankOperation,
+	bankDateSchema,
+	bankMoneyValue,
+	bankToday,
+	CategoryManager,
+	moneyCents,
+	positiveMoneySchema,
+	useBankCategories,
+	useBankExpenses,
+	useBankFormFocus,
+	useBankMutations,
+	useBankOperation,
+} from "@/entities/bank-card";
+import { validationMessage } from "@/shared/i18n";
+import { formatMoney } from "@/shared/lib";
+import classes from "./OperationForm.module.css";
+import type { OperationValues } from "./OperationForm.types";
+import { OperationFields, RefundFields } from "./OperationForm.view";
+
+const operationSchema = z.object({
+	kind: z.enum(["expense", "topup", "transfer", "refund"]),
+	cardId: z.string(),
+	targetCardId: z.string(),
+	categoryId: z.string(),
+	originalExpenseId: z.string(),
+	amount: positiveMoneySchema,
+	date: bankDateSchema,
+	description: z
+		.string()
+		.max(500, validationMessage("bank.validation.description")(undefined)),
+});
+
+type OperationFormProps = {
+	card: BankCard;
+	cards: BankCard[];
+	operation?: BankOperation;
+	onClose: () => void;
+};
+const OperationForm: FC<OperationFormProps> = (props) => {
+	useBankFormFocus();
+	const { t } = useTranslation();
+	const [categoriesOpen, setCategoriesOpen] = useState(false);
+	const [version, setVersion] = useState(props.operation?.version ?? 1);
+	const [latest, setLatest] = useState<BankOperation>();
+	const [sourcePage, setSourcePage] = useState(1);
+	const [sourceId, setSourceId] = useState(
+		props.operation?.originalExpenseId ?? "",
+	);
+	const sourceQuery = useBankOperation(sourceId || undefined);
+	const currentQuery = useBankOperation(props.operation?.id);
+	const [refundLimit, setRefundLimit] = useState(
+		props.operation?.availableRefund,
+	);
+	const [intent] = useState(() => crypto.randomUUID());
+	const [submittedValues, setSubmittedValues] = useState<OperationValues>();
+	const [error, setError] = useState<unknown>();
+	const categories = useBankCategories();
+	const mutation = useBankMutations();
+	const methods = useForm<OperationValues>({
+		resolver: zodResolver(
+			operationSchema.superRefine((values, ctx) => {
+				// Repeated intent reaches server idempotency even after its source changed.
+				if (
+					submittedValues &&
+					JSON.stringify(values) === JSON.stringify(submittedValues)
+				)
+					return;
+				const source = props.cards.find((c) => c.id === values.cardId);
+				const target = props.cards.find((c) => c.id === values.targetCardId);
+				if (!source || source.archivedAt)
+					ctx.addIssue({
+						code: "custom",
+						path: ["cardId"],
+						...validationMessage("bank.validation.required")(undefined),
+					});
+				if (
+					values.kind === "transfer" &&
+					(!target || target.archivedAt || target.id === values.cardId)
+				)
+					ctx.addIssue({
+						code: "custom",
+						path: ["targetCardId"],
+						...validationMessage("bank.validation.destination")(undefined),
+					});
+				if (
+					(source && values.date < source.openingDate) ||
+					(values.kind === "transfer" &&
+						target &&
+						values.date < target.openingDate)
+				)
+					ctx.addIssue({
+						code: "custom",
+						path: ["date"],
+						...validationMessage("bank.validation.start")(undefined),
+					});
+				if (values.kind === "refund") {
+					const expense = sourceQuery.data;
+					if (!expense || expense.cardId !== values.cardId)
+						ctx.addIssue({
+							code: "custom",
+							path: ["originalExpenseId"],
+							...validationMessage("bank.validation.required")(undefined),
+						});
+					if (expense && values.date < expense.date)
+						ctx.addIssue({
+							code: "custom",
+							path: ["date"],
+							...validationMessage("bank.validation.start")(undefined),
+						});
+					const limit = props.operation
+						? refundLimit
+						: expense?.availableRefund;
+					const amount = moneyCents(values.amount);
+					if (
+						limit &&
+						amount !== null &&
+						amount > (moneyCents(limit.value) ?? 0n)
+					)
+						ctx.addIssue({
+							code: "custom",
+							path: ["amount"],
+							...validationMessage("bank.validation.refund")(undefined),
+						});
+				}
+				if (
+					values.kind === "expense" &&
+					!categories.data?.some(
+						(c) =>
+							c.id ===
+							(values.categoryId ||
+								categories.data?.find((c) => c.isDefault)?.id),
+					)
+				)
+					ctx.addIssue({
+						code: "custom",
+						path: ["categoryId"],
+						...validationMessage("bank.validation.required")(undefined),
+					});
+			}),
+		),
+		defaultValues: {
+			kind: props.operation?.kind ?? "expense",
+			cardId: props.operation?.cardId ?? props.card.id,
+			targetCardId: props.operation?.targetCardId ?? "",
+			categoryId: props.operation?.categoryId ?? "",
+			originalExpenseId: props.operation?.originalExpenseId ?? "",
+			amount: props.operation?.amount.value ?? "",
+			date: props.operation?.date ?? bankToday(),
+			description: props.operation?.description ?? "",
+		},
+	});
+	const kind = methods.watch("kind");
+	const expenses = useBankExpenses(
+		kind === "refund" ? props.card.id : undefined,
+		{ page: sourcePage },
+	);
+	const source = methods.watch("cardId");
+	const pending = methods.formState.isSubmitting;
+	const options = props.cards
+		.filter((c) => !c.archivedAt)
+		.map((c) => ({ value: c.id, label: c.name }));
+	return (
+		<>
+			<Modal
+				opened
+				onClose={() => !pending && !categoriesOpen && props.onClose()}
+				title={t(props.operation ? "bank.editOperation" : "bank.addOperation")}
+				closeOnEscape={!pending && !categoriesOpen}
+				closeOnClickOutside={!pending && !categoriesOpen}
+				closeButtonProps={{ "aria-label": t("bank.close"), disabled: pending }}
+			>
+				<FormProvider {...methods}>
+					<form
+						onSubmit={methods.handleSubmit(async (values) => {
+							setSubmittedValues(values);
+							setError(undefined);
+							try {
+								const body = {
+									kind: values.kind,
+									cardId: values.cardId,
+									...(values.kind === "transfer"
+										? { targetCardId: values.targetCardId }
+										: {}),
+									...(values.kind === "expense"
+										? {
+												categoryId:
+													values.categoryId ||
+													categories.data?.find((c) => c.isDefault)?.id,
+											}
+										: {}),
+									...(values.kind === "refund"
+										? { originalExpenseId: values.originalExpenseId }
+										: {}),
+									amount: {
+										currency: "RUB" as const,
+										value: bankMoneyValue(values.amount),
+									},
+									date: values.date,
+									description: values.description,
+								};
+								if (props.operation)
+									await mutation.updateOperation.mutateAsync({
+										id: props.operation.id,
+										body: { ...body, version },
+									});
+								else
+									await mutation.createOperation.mutateAsync({
+										id: intent,
+										...body,
+									});
+								props.onClose();
+							} catch (failure) {
+								setError(failure);
+							}
+						})}
+					>
+						<fieldset disabled={pending} className={classes.fieldset}>
+							<Stack>
+								<OperationFields
+									refundCardId={props.card.id}
+									editing={Boolean(props.operation)}
+									kind={kind}
+									cards={options}
+									targets={options.filter((c) => c.value !== source)}
+									categories={
+										categories.data?.map((c) => ({
+											value: c.id,
+											label: c.name,
+										})) ?? []
+									}
+									defaultCategory={
+										categories.data?.find((c) => c.isDefault)?.id ?? ""
+									}
+								/>
+								{kind === "refund" && (
+									<>
+										<RefundFields
+											editing={Boolean(props.operation)}
+											expenses={
+												expenses.data?.items.map((item) => ({
+													value: item.id,
+													label: t("bank.expenseChoice", {
+														date: item.date,
+														name: item.description || item.categoryName,
+														amount: formatMoney(item.amount),
+														available: formatMoney(item.availableRefund),
+													}),
+												})) ?? []
+											}
+											selected={
+												sourceQuery.data
+													? {
+															value: sourceQuery.data.id,
+															label: t("bank.expenseChoice", {
+																date: sourceQuery.data.date,
+																name:
+																	sourceQuery.data.description ||
+																	sourceQuery.data.categoryName,
+																amount: formatMoney(sourceQuery.data.amount),
+																available: formatMoney(
+																	sourceQuery.data.availableRefund,
+																),
+															}),
+														}
+													: undefined
+											}
+											onSelect={setSourceId}
+											limit={
+												props.operation
+													? refundLimit
+													: sourceQuery.data?.availableRefund
+											}
+										/>
+										{expenses.isLoading && (
+											<Text role="status">{t("bank.loadingHistory")}</Text>
+										)}
+										{expenses.data &&
+											!expenses.data.items.length &&
+											!props.operation && <Text>{t("bank.noPurchases")}</Text>}
+										{!props.operation && (
+											<Group>
+												<Button
+													variant="default"
+													disabled={sourcePage === 1 || expenses.isFetching}
+													onClick={() => setSourcePage(sourcePage - 1)}
+												>
+													{t("bank.previous")}
+												</Button>
+												<Text>{t("bank.page", { page: sourcePage })}</Text>
+												<Button
+													variant="default"
+													disabled={
+														!expenses.data?.hasNext || expenses.isFetching
+													}
+													onClick={() => setSourcePage(sourcePage + 1)}
+												>
+													{t("bank.next")}
+												</Button>
+											</Group>
+										)}
+										{expenses.isError && (
+											<BankFeedback
+												loadingError
+												error={expenses.error}
+												retry={() => void expenses.refetch()}
+											/>
+										)}{" "}
+										{sourceQuery.isError && (
+											<BankFeedback
+												loadingError
+												error={sourceQuery.error}
+												retry={() => void sourceQuery.refetch()}
+											/>
+										)}
+									</>
+								)}
+								{kind === "expense" && (
+									<Button
+										variant="subtle"
+										onClick={() => setCategoriesOpen(true)}
+									>
+										{t("bank.addCategory")}
+									</Button>
+								)}
+								{categories.isError && (
+									<BankFeedback
+										loadingError
+										error={categories.error}
+										retry={() => void categories.refetch()}
+									/>
+								)}
+								{error ? (
+									<>
+										<BankFeedback error={error} />
+										{(props.operation || sourceId) && (
+											<Button
+												variant="default"
+												onClick={async () => {
+													const query = props.operation
+														? currentQuery
+														: sourceQuery;
+													const result = await query.refetch();
+													if (result.data && !result.error) {
+														if (props.operation) {
+															setLatest(result.data);
+															setRefundLimit(result.data.availableRefund);
+														} else setError(undefined);
+													} else setError(result.error);
+												}}
+											>
+												{t("bank.reloadRecord")}
+											</Button>
+										)}
+									</>
+								) : null}
+								{latest && (
+									<>
+										<Text>
+											{t("bank.versionHint", {
+												details: `${latest.date} · ${formatMoney(latest.amount)} · ${latest.description ?? ""}`,
+											})}
+										</Text>
+										<Button
+											variant="default"
+											onClick={() => {
+												setVersion(latest.version);
+												setLatest(undefined);
+												setError(undefined);
+											}}
+										>
+											{t("bank.adoptVersion", { version: latest.version })}
+										</Button>
+									</>
+								)}
+								<Group>
+									<Button
+										type="submit"
+										loading={pending}
+										disabled={
+											(kind === "expense" && !categories.data) ||
+											(kind === "refund" && !sourceQuery.data)
+										}
+									>
+										{t("bank.save")}
+									</Button>
+									<Button variant="default" onClick={props.onClose}>
+										{t("bank.cancel")}
+									</Button>
+								</Group>
+							</Stack>
+						</fieldset>
+					</form>
+				</FormProvider>
+			</Modal>
+			{categoriesOpen && (
+				<CategoryManager
+					onClose={() => setCategoriesOpen(false)}
+					onCreated={(id) => {
+						methods.setValue("categoryId", id);
+						setCategoriesOpen(false);
+					}}
+				/>
+			)}
+		</>
+	);
+};
+
+export { OperationForm };
@@ -0,0 +1,14 @@
+import type { BankOperation } from "@/entities/bank-card";
+
+type OperationValues = {
+	kind: BankOperation["kind"];
+	cardId: string;
+	targetCardId: string;
+	categoryId: string;
+	originalExpenseId: string;
+	amount: string;
+	date: string;
+	description: string;
+};
+
+export type { OperationValues };
@@ -0,0 +1,198 @@
+import { Select, Stack, Text, Textarea, TextInput } from "@mantine/core";
+import { DateInput } from "@mantine/dates";
+import type { FC } from "react";
+import { Controller, useFormContext } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import {
+	type BankOperation,
+	bankDateSchema,
+	bankToday,
+} from "@/entities/bank-card";
+import { formatMoney } from "@/shared/lib";
+import type { OperationValues } from "./OperationForm.types";
+
+type Choice = { value: string; label: string };
+type OperationFieldsProps = {
+	editing: boolean;
+	refundCardId: string;
+	kind: OperationValues["kind"];
+	cards: Choice[];
+	targets: Choice[];
+	categories: Choice[];
+	defaultCategory: string;
+};
+const OperationFields: FC<OperationFieldsProps> = (props) => {
+	const { t } = useTranslation();
+	const {
+		control,
+		register,
+		setValue,
+		formState: { errors, isSubmitting },
+	} = useFormContext<OperationValues>();
+	return (
+		<Stack>
+			<Controller
+				control={control}
+				name="kind"
+				render={({ field }) => (
+					<Select
+						label={t("bank.kind")}
+						required
+						data={(["expense", "topup", "transfer", "refund"] as const).map(
+							(value) => ({ value, label: t(`bank.kinds.${value}`) }),
+						)}
+						{...field}
+						disabled={isSubmitting || props.editing}
+						onChange={(value) => {
+							field.onChange(value ?? "expense");
+							if (value === "refund") setValue("cardId", props.refundCardId);
+						}}
+					/>
+				)}
+			/>
+			<Controller
+				control={control}
+				name="cardId"
+				render={({ field }) => (
+					<Select
+						label={t(
+							props.kind === "transfer" ? "bank.source" : "bank.operationCard",
+						)}
+						required
+						data={props.cards}
+						{...field}
+						disabled={isSubmitting || props.kind === "refund"}
+						error={errors.cardId?.message}
+					/>
+				)}
+			/>
+			{props.kind === "transfer" && (
+				<Controller
+					control={control}
+					name="targetCardId"
+					render={({ field }) => (
+						<Select
+							label={t("bank.destination")}
+							required
+							data={props.targets}
+							{...field}
+							disabled={isSubmitting}
+							error={errors.targetCardId?.message}
+						/>
+					)}
+				/>
+			)}
+			<TextInput
+				label={t("bank.amount")}
+				required
+				inputMode="decimal"
+				{...register("amount")}
+				error={errors.amount?.message}
+			/>
+			<Controller
+				control={control}
+				name="date"
+				render={({ field }) => (
+					<DateInput
+						{...field}
+						label={t("bank.date")}
+						required
+						valueFormat="YYYY-MM-DD"
+						value={
+							bankDateSchema.safeParse(field.value).success ? field.value : null
+						}
+						dateParser={(value) =>
+							bankDateSchema.safeParse(value).success ? value : null
+						}
+						fixOnBlur={false}
+						onInput={(event) => field.onChange(event.currentTarget.value)}
+						onChange={(value) => field.onChange(value ?? "")}
+						onBlur={(event) => {
+							field.onChange(event.currentTarget.value);
+							field.onBlur();
+						}}
+						maxDate={bankToday()}
+						popoverProps={{
+							withinPortal: false,
+							middlewares: { shift: { crossAxis: true } },
+						}}
+						error={errors.date?.message}
+					/>
+				)}
+			/>
+			{props.kind === "expense" && (
+				<Controller
+					control={control}
+					name="categoryId"
+					render={({ field }) => (
+						<Select
+							label={t("bank.category")}
+							required
+							data={props.categories}
+							{...field}
+							value={field.value || props.defaultCategory}
+							disabled={isSubmitting}
+							error={errors.categoryId?.message}
+						/>
+					)}
+				/>
+			)}
+			<Textarea
+				label={t("bank.description")}
+				{...register("description")}
+				error={errors.description?.message}
+			/>
+		</Stack>
+	);
+};
+type RefundFieldsProps = {
+	editing: boolean;
+	expenses: Choice[];
+	selected?: Choice;
+	onSelect: (id: string) => void;
+	limit: BankOperation["availableRefund"] | undefined;
+};
+const RefundFields: FC<RefundFieldsProps> = (props) => {
+	const { t } = useTranslation();
+	const {
+		control,
+		formState: { errors, isSubmitting },
+	} = useFormContext<OperationValues>();
+	return (
+		<Stack>
+			<Controller
+				control={control}
+				name="originalExpenseId"
+				render={({ field }) => (
+					<Select
+						label={t("bank.expense")}
+						required
+						data={
+							props.selected &&
+							!props.expenses.some(
+								(item) => item.value === props.selected?.value,
+							)
+								? [props.selected, ...props.expenses]
+								: props.expenses
+						}
+						{...field}
+						onChange={(value) => {
+							field.onChange(value ?? "");
+							props.onSelect(value ?? "");
+						}}
+						disabled={isSubmitting || props.editing}
+						error={errors.originalExpenseId?.message}
+					/>
+				)}
+			/>
+			{props.limit && (
+				<Text>
+					{t("bank.availableRefund", { amount: formatMoney(props.limit) })}
+				</Text>
+			)}
+			{props.editing && <Text>{t("bank.purchaseImmutable")}</Text>}
+		</Stack>
+	);
+};
+
+export { OperationFields, RefundFields };
@@ -0,0 +1 @@
+export { CardsPage } from "./ui/CardsPage";
@@ -0,0 +1,10 @@
+.card {
+	text-decoration: none;
+	color: inherit;
+	min-width: 0;
+	overflow-wrap: anywhere;
+}
+.card:focus-visible {
+	outline: 2px solid var(--mantine-primary-color-filled);
+	outline-offset: 3px;
+}
@@ -0,0 +1,185 @@
+import { MantineProvider } from "@mantine/core";
+import { QueryClientProvider } from "@tanstack/react-query";
+import {
+	fireEvent,
+	render,
+	screen,
+	waitFor,
+	within,
+} from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { MemoryRouter } from "react-router";
+import { describe, expect, it } from "vitest";
+import { configureAuthClient } from "@/shared/api";
+import { createTestQueryClient } from "@/test/query";
+import { server } from "@/test/server";
+import { CardsPage } from "./CardsPage";
+
+const money = (value: string) => ({ currency: "RUB", value });
+function renderCards(fail = false, categoryFail = false) {
+	configureAuthClient({
+		accessToken: () => "test",
+		refresh: async () => false,
+		clear: () => {},
+	});
+	server.use(
+		http.get("*/api/v1/bank-cards/categories", () =>
+			categoryFail ? HttpResponse.error() : HttpResponse.json([]),
+		),
+		http.get("*/api/v1/bank-cards", () =>
+			fail ? HttpResponse.error() : HttpResponse.json([]),
+		),
+		http.get("*/api/v1/bank-cards/summary", () =>
+			HttpResponse.json({
+				month: "2026-09",
+				cardId: null,
+				expenses: money("0"),
+				refunds: money("0"),
+				net: money("0"),
+				categories: [],
+			}),
+		),
+	);
+	return render(
+		<QueryClientProvider client={createTestQueryClient()}>
+			<MantineProvider>
+				<MemoryRouter initialEntries={["/cards?month=2026-09"]}>
+					<CardsPage />
+				</MemoryRouter>
+			</MantineProvider>
+		</QueryClientProvider>,
+	);
+}
+describe("CardsPage", () => {
+	it("preserves exact negative opening amount and the creation intent through unknown failure", async () => {
+		renderCards();
+		await screen.findByRole("heading", { name: "Добавьте первую карту" });
+		fireEvent.click(
+			screen.getAllByRole("button", { name: "Добавить карту" })[0],
+		);
+		const dialog = screen.getByRole("dialog");
+		const submitted: Record<string, unknown>[] = [];
+		let resolve: (() => void) | undefined;
+		server.use(
+			http.post("*/api/v1/bank-cards", async ({ request }) => {
+				submitted.push((await request.json()) as Record<string, unknown>);
+				if (submitted.length === 1) {
+					await new Promise<void>((r) => {
+						resolve = r;
+					});
+					return HttpResponse.error();
+				}
+				return HttpResponse.json({ id: submitted[0].id }, { status: 201 });
+			}),
+		);
+		fireEvent.change(within(dialog).getByLabelText(/Название карты/), {
+			target: { value: " Повседневная " },
+		});
+		fireEvent.change(within(dialog).getByLabelText(/Начальный остаток/), {
+			target: { value: "1,001" },
+		});
+		fireEvent.click(within(dialog).getByRole("button", { name: "Сохранить" }));
+		expect(
+			await screen.findByText(/Введите сумму в допустимом диапазоне/),
+		).toBeInTheDocument();
+		expect(submitted).toHaveLength(0);
+		fireEvent.change(within(dialog).getByLabelText(/Начальный остаток/), {
+			target: { value: "-92233720368547758,08" },
+		});
+		fireEvent.change(within(dialog).getByLabelText(/Дата начала учёта/), {
+			target: { value: "2026-01-01" },
+		});
+		fireEvent.click(within(dialog).getByRole("button", { name: "Сохранить" }));
+		await waitFor(() => expect(submitted).toHaveLength(1));
+		expect(
+			within(dialog).getByRole("button", { name: "Отмена" }),
+		).toBeDisabled();
+		expect(
+			within(dialog).getByRole("button", { name: "Закрыть" }),
+		).toBeDisabled();
+		resolve?.();
+		await screen.findByText(/Не удалось подтвердить сохранение/);
+		expect(within(dialog).getByLabelText(/Начальный остаток/)).toHaveValue(
+			"-92233720368547758,08",
+		);
+		fireEvent.click(within(dialog).getByRole("button", { name: "Сохранить" }));
+		await waitFor(() =>
+			expect(screen.queryByRole("dialog")).not.toBeInTheDocument(),
+		);
+		expect(submitted[0]).toEqual(submitted[1]);
+		expect(submitted[0]).toMatchObject({
+			name: "Повседневная",
+			bankName: null,
+			lastFour: null,
+			openingBalance: money("-92233720368547758.08"),
+		});
+	});
+	it("uses archive only for card list and keeps all-card summary including negative net", async () => {
+		renderCards();
+		const requests: string[] = [];
+		server.use(
+			http.get("*/api/v1/bank-cards", ({ request }) => {
+				requests.push(new URL(request.url).search);
+				return HttpResponse.json([
+					{
+						id: "demo",
+						name: "Запасная",
+						bankName: null,
+						lastFour: null,
+						balance: money("0"),
+						archivedAt: "2026-09-01",
+						version: 1,
+						openingBalance: money("0"),
+						openingDate: "2026-01-01",
+					},
+				]);
+			}),
+		);
+		fireEvent.click(screen.getByLabelText("Показать архив"));
+		await screen.findByText("Запасная");
+		expect(requests).toContain("?includeArchived=true");
+		expect(screen.getByLabelText("Месяц")).toHaveTextContent("September 2026");
+		expect(screen.getByRole("link", { name: /Запасная/ })).toHaveAttribute(
+			"href",
+			"/cards/demo?month=2026-09",
+		);
+	});
+	it("shows retry after failure instead of presenting an empty list", async () => {
+		renderCards(true);
+		// Mount starts asynchronously; this handler owns the request.
+		expect(await screen.findByRole("alert")).toHaveTextContent(
+			"Не удалось загрузить данные карт.",
+		);
+		expect(
+			screen.queryByRole("heading", { name: "Добавьте первую карту" }),
+		).not.toBeInTheDocument();
+		server.use(http.get("*/api/v1/bank-cards", () => HttpResponse.json([])));
+		fireEvent.click(
+			within(screen.getByRole("alert")).getByRole("button", {
+				name: "Повторить",
+			}),
+		);
+		await screen.findByRole("heading", { name: "Добавьте первую карту" });
+	});
+	it("makes failed category loading recoverable without hiding successful cards data", async () => {
+		renderCards(false, true);
+		await screen.findByRole("heading", { name: "Добавьте первую карту" });
+		expect(await screen.findByRole("alert")).toHaveTextContent(
+			"Не удалось загрузить данные карт.",
+		);
+		server.use(
+			http.get("*/api/v1/bank-cards/categories", () =>
+				HttpResponse.json([
+					{ id: "default", name: "Другое", version: 1, isDefault: true },
+				]),
+			),
+		);
+		fireEvent.click(
+			within(screen.getByRole("alert")).getByRole("button", {
+				name: "Повторить",
+			}),
+		);
+		await screen.findByRole("button", { name: "Категории" });
+		expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+	});
+});
@@ -0,0 +1,19 @@
+import type { FC } from "react";
+import { BankCardForm, CategoryManager } from "@/entities/bank-card";
+import { CardsPageView } from "./CardsPage.view";
+import { useCardsPageVm } from "./CardsPage.vm";
+
+const CardsPage: FC = () => {
+	const vm = useCardsPageVm();
+	return (
+		<>
+			<CardsPageView vm={vm} />
+			{vm.adding && <BankCardForm onClose={() => vm.setAdding(false)} />}
+			{vm.managingCategories && (
+				<CategoryManager onClose={() => vm.setManagingCategories(false)} />
+			)}
+		</>
+	);
+};
+
+export { CardsPage };
@@ -0,0 +1,137 @@
+import {
+	Badge,
+	Button,
+	Group,
+	Paper,
+	SimpleGrid,
+	Skeleton,
+	Stack,
+	Switch,
+	Text,
+	Title,
+} from "@mantine/core";
+import { MonthPickerInput } from "@mantine/dates";
+import type { FC } from "react";
+import { useTranslation } from "react-i18next";
+import { Link } from "react-router";
+import { BankFeedback, BankSummaryView } from "@/entities/bank-card";
+import { formatMoney } from "@/shared/lib";
+import { LoadingSkeleton, StateView } from "@/shared/ui";
+import classes from "./CardsPage.module.css";
+import type { CardsPageVm } from "./CardsPage.vm";
+
+type CardsPageViewProps = { vm: CardsPageVm };
+const CardsPageView: FC<CardsPageViewProps> = (props) => {
+	const { vm } = props;
+	const { t } = useTranslation();
+	return (
+		<Stack gap="lg">
+			<Group justify="space-between">
+				<Title order={1}>{t("bank.title")}</Title>
+				<Button onClick={() => vm.setAdding(true)}>{t("bank.addCard")}</Button>
+			</Group>
+			<Text c="dimmed">{t("bank.manualBalance")}</Text>
+			<Switch
+				label={t("bank.showArchive")}
+				checked={vm.archive}
+				onChange={(event) => vm.setArchive(event.currentTarget.checked)}
+			/>
+			{vm.items ? (
+				vm.items.length ? (
+					<SimpleGrid cols={{ base: 1, sm: 2 }}>
+						{vm.items.map((card) => (
+							<Paper
+								key={card.id}
+								component={Link}
+								to={card.to}
+								withBorder
+								p="md"
+								className={classes.card}
+							>
+								<Stack gap="xs">
+									<Group>
+										<Text fw={600} size="lg">
+											{card.name}
+										</Text>
+										{card.archivedAt && (
+											<Badge color="gray">{t("bank.archived")}</Badge>
+										)}
+									</Group>
+									<Text c="dimmed">
+										{card.bankName}
+										{card.lastFour ? ` · •• ${card.lastFour}` : ""}
+									</Text>
+									<Text size="xl" fw={650}>
+										{formatMoney(card.balance)}
+									</Text>
+								</Stack>
+							</Paper>
+						))}
+					</SimpleGrid>
+				) : (
+					<StateView
+						title={t("bank.empty")}
+						text={t(vm.archive ? "bank.emptyHint" : "bank.noActive")}
+						action={
+							<Button onClick={() => vm.setAdding(true)}>
+								{t("bank.addCard")}
+							</Button>
+						}
+					/>
+				)
+			) : vm.cards.isLoading ? (
+				<LoadingSkeleton label={t("bank.loading")}>
+					<SimpleGrid cols={{ base: 1, sm: 2 }}>
+						<Skeleton h={120} />
+						<Skeleton h={120} />
+					</SimpleGrid>
+				</LoadingSkeleton>
+			) : null}
+			{vm.cards.isError && (
+				<Group role="alert">
+					<Text>{t(vm.items ? "bank.refreshError" : "bank.error")}</Text>
+					<Button variant="default" onClick={() => void vm.cards.refetch()}>
+						{t("bank.retry")}
+					</Button>
+				</Group>
+			)}
+			{vm.cards.data && vm.cards.isFetching && (
+				<Text role="status">{t("bank.refreshing")}</Text>
+			)}
+			<MonthPickerInput
+				label={t("bank.month")}
+				value={`${vm.month}-01`}
+				onChange={(value) => {
+					if (value) vm.setMonth(value.slice(0, 7));
+				}}
+				popoverProps={{ middlewares: { shift: { crossAxis: true } } }}
+			/>
+			<BankSummaryView
+				all
+				data={vm.summary.data}
+				loading={vm.summary.isLoading}
+				error={vm.summary.isError}
+				fetching={vm.summary.isFetching}
+				retry={() => void vm.summary.refetch()}
+			/>
+			{vm.categories.isError && (
+				<BankFeedback
+					loadingError
+					error={vm.categories.error}
+					cached={Boolean(vm.categories.data)}
+					retry={() => void vm.categories.refetch()}
+				/>
+			)}
+			{Boolean(vm.categories.data?.length || vm.cards.data?.length) && (
+				<Button
+					variant="default"
+					onClick={() => vm.setManagingCategories(true)}
+				>
+					{t("bank.categories")}
+				</Button>
+			)}
+		</Stack>
+	);
+};
+
+export { CardsPageView };
@@ -0,0 +1,41 @@
+import { useState } from "react";
+import { useSearchParams } from "react-router";
+import {
+	bankMonth,
+	useBankCards,
+	useBankCategories,
+	useBankSummary,
+} from "@/entities/bank-card";
+
+function useCardsPageVm() {
+	const [params, setParams] = useSearchParams();
+	const month = bankMonth(params.get("month"));
+	const [archive, setArchive] = useState(false);
+	const categories = useBankCategories();
+	const [managingCategories, setManagingCategories] = useState(false);
+	const [adding, setAdding] = useState(false);
+	const cards = useBankCards(archive);
+	const summary = useBankSummary(month);
+	return {
+		categories,
+		managingCategories,
+		setManagingCategories,
+		month,
+		archive,
+		setArchive,
+		adding,
+		setAdding,
+		cards,
+		summary,
+		setMonth: (value: string) => {
+			if (value) setParams({ month: bankMonth(value) });
+		},
+		items: cards.data?.map((card) => ({
+			...card,
+			to: `/cards/${card.id}?month=${month}`,
+		})),
+	};
+}
+type CardsPageVm = ReturnType<typeof useCardsPageVm>;
+
+export { type CardsPageVm, useCardsPageVm };
@@ -2,6 +2,7 @@ const ru = {
 	translation: {
 		appName: "WealthLedger",
 		navigation: {
+			cards: "Карты",
 			accounts: "Счета",
 			stocks: "Акции",
 			bonds: "Облигации",
@@ -16,6 +17,142 @@ const ru = {
 			events: "Будущие события",
 			settings: "Настройки",
 		},
+		bank: {
+			title: "Карты",
+			card: "Карта",
+			addCard: "Добавить карту",
+			editCard: "Изменить карту",
+			manualBalance: "Баланс по внесённым операциям",
+			openingHint:
+				"Остаток до операций с выбранной даты. Валюта — рубли (RUB).",
+			name: "Название карты",
+			bankName: "Банк (необязательно)",
+			lastFour: "Последние четыре цифры (необязательно)",
+			openingBalance: "Начальный остаток, ₽",
+			openingDate: "Дата начала учёта",
+			showArchive: "Показать архив",
+			archived: "В архиве",
+			archive: "Убрать в архив",
+			restore: "Вернуть из архива",
+			archiveHint:
+				"История и деньги сохраняются. Для финансовых изменений верните карту из архива.",
+			empty: "Добавьте первую карту",
+			emptyHint: "Укажите начальный остаток и вносите расходы вручную.",
+			noActive: "Нет активных карт. Включите показ архива.",
+			loading: "Загрузка банковских карт",
+			loadingHistory: "Загрузка операций",
+			error: "Не удалось загрузить данные карт.",
+			retry: "Повторить",
+			refreshing: "Обновляем данные…",
+			refreshError:
+				"Не удалось обновить данные. Показаны последние полученные.",
+			save: "Сохранить",
+			cancel: "Отмена",
+			close: "Закрыть",
+			summary: "Расходы за месяц",
+			allSummary: "Расходы по всем картам",
+			month: "Месяц",
+			expenses: "Потрачено",
+			refunds: "Возвращено",
+			net: "После возвратов",
+			summaryHint:
+				"Возвраты учитываются в месяце получения. Итог может быть отрицательным.",
+			noExpenses: "Расходов и возвратов за месяц нет.",
+			categories: "Категории",
+			category: "Категория",
+			categoryName: "Название категории",
+			addCategory: "Добавить категорию",
+			rename: "Переименовать",
+			defaultCategory: "По умолчанию",
+			notFound: "Карта не найдена",
+			back: "К картам",
+			operations: "Операции",
+			noOperations: "Операций за месяц нет.",
+			addOperation: "Добавить операцию",
+			editOperation: "Изменить операцию",
+			kind: "Вид операции",
+			kinds: {
+				expense: "Расход",
+				topup: "Пополнение",
+				transfer: "Перевод",
+				refund: "Возврат",
+			},
+			source: "Карта-источник",
+			destination: "Карта-получатель",
+			operationCard: "Карта операции",
+			amount: "Сумма, ₽",
+			date: "Дата операции",
+			description: "Описание (необязательно)",
+			expense: "Исходная покупка за любой период",
+			availableRefund: "Доступно к возврату: {{amount}}",
+			expenseChoice:
+				"{{date}} · {{name}} · {{amount}} · доступно {{available}}",
+			noPurchases:
+				"На этой странице нет покупок. Проверьте другие страницы истории.",
+			purchaseImmutable: "Исходная покупка и карта возврата не изменяются.",
+			previous: "Назад",
+			next: "Далее",
+			page: "Страница {{page}}",
+			transferTo: "Перевод на «{{name}}»",
+			transferFrom: "Перевод с «{{name}}»",
+			edit: "Изменить",
+			delete: "Удалить",
+			deleteTitle: "Удалить операцию?",
+			deleteHint:
+				"{{kind}} · {{amount}} · {{card}}. Денежное влияние будет отменено.",
+			deleteTransfer:
+				"Перевод {{amount}}: «{{source}}» → «{{target}}». Обе стороны перевода будут удалены.",
+			reloadRecord: "Перечитать запись",
+			adoptVersion: "Использовать актуальную версию {{version}}",
+			versionHint:
+				"Актуальные данные: {{details}}. Черновик сохранён; проверьте его перед повторной отправкой.",
+			requestError:
+				"Не удалось подтвердить сохранение. Ввод сохранён; повтор использует то же намерение.",
+			errors: {
+				BANK_VERSION_CONFLICT:
+					"Запись уже изменена. Перечитайте её и проверьте черновик перед повторным сохранением.",
+				BANK_WRITE_CONFLICT:
+					"Данные изменяются другим запросом. Перечитайте запись и повторите действие.",
+				BANK_DUPLICATE_CATEGORY: "Категория с таким названием уже есть.",
+				BANK_NOT_FOUND: "Запись не найдена или недоступна.",
+				BANK_INTENT_CONFLICT:
+					"Это намерение уже сохранено с другим содержимым. Закройте форму и проверьте историю перед новым действием.",
+				BANK_CARD_ARCHIVED:
+					"Затронутая карта в архиве. Сначала верните её из архива.",
+				BANK_REFUND_LIMIT:
+					"Сумма превышает доступный возврат. Перечитайте покупку.",
+				BANK_DEPENDENT_REFUNDS:
+					"Изменению мешают связанные возвраты. Сначала исправьте или удалите их.",
+				BANK_OPENING_DATE_CONFLICT:
+					"Дата начала противоречит сохранённой истории карты.",
+				BANK_INVALID_DATE:
+					"Проверьте дату операции и даты начала учёта обеих карт.",
+				BANK_INVALID_MONEY: "Введите допустимую сумму с точностью до копеек.",
+				BANK_INVALID_INPUT: "Проверьте поля и связанные карты.",
+				BANK_INVALID_REFUND: "Исходная покупка недоступна для этого возврата.",
+				BANK_IMMUTABLE_OPERATION:
+					"Вид операции и исходную покупку возврата изменить нельзя.",
+				BANK_OPERATION_DELETED:
+					"Операция уже удалена. Она не будет создана повторно.",
+			},
+			validation: {
+				name: "Введите название от 1 до 100 символов.",
+				bankName: "Не более 100 символов.",
+				lastFour: "Укажите ровно четыре цифры или оставьте поле пустым.",
+				money:
+					"Введите сумму в допустимом диапазоне, не более двух знаков после запятой.",
+				positive: "Сумма операции должна быть больше нуля.",
+				date: "Укажите существующую дату не позже сегодняшнего дня по Москве.",
+				start:
+					"Дата не может быть раньше начала учёта затронутых карт или исходной покупки.",
+				required: "Выберите значение.",
+				destination: "Выберите другую активную карту.",
+				description: "Не более 500 символов.",
+				category: "Введите название от 1 до 80 символов.",
+				duplicate: "Категория с таким названием уже есть.",
+				refund: "Сумма превышает доступный возврат.",
+			},
+		},
 		bond: {
 			instrument: "Облигация",
 			searching: "Ищем облигации",
@@ -98,7 +98,14 @@
 		display: flex;
 		justify-content: space-around;
 		left: 0;
-		padding: var(--mantine-spacing-sm);
+		padding: var(--mantine-spacing-xs) 2px;
+		gap: 2px;
+		font-size: 11px;
+		& a {
+			min-width: 0;
+			padding: 8px 2px;
+			text-align: center;
+		}
 		position: fixed;
 		right: 0;
 		z-index: 200;
@@ -21,6 +21,11 @@ const AppShell: FC<AppShellProps> = (props) => {
 				<path d="M8 6V4h8v2M3 10h18M9 10v3h6v-3M5 6h14a2 2 0 0 1 2 2v11H3V8a2 2 0 0 1 2-2Z" />
 			),
 		},
+		{
+			to: "/cards",
+			label: t("navigation.cards"),
+			icon: <path d="M3 5h18v14H3V5Zm0 4h18M6 15h4" />,
+		},
 		{
 			to: "/stocks",
 			label: t("navigation.stocks"),
				`@@ -0,0 +1 @@`
				`export { CardsPage } from "./ui/CardsPage";`