diff --git a/dev/ag-grid-angular/src/main.ts b/dev/ag-grid-angular/src/main.ts
index 83c8ac1..895afcb 100644
--- a/dev/ag-grid-angular/src/main.ts
+++ b/dev/ag-grid-angular/src/main.ts
@@ -78,6 +78,24 @@ if (isDevMode()) {
                 path: 'row-actions',
                 loadComponent: async () => import('./tests/row-actions.ng').then((m) => m.DevRowActions)
             },
+            {
+                path: 'row-selection-state',
+                loadComponent: async () => import('./tests/row-selection-state.ng').then((m) => m.DevRowSelectionState)
+            },
+            {
+                path: 'row-selection-state-query-params',
+                loadComponent: async () =>
+                    import('./tests/row-selection-state.ng').then((m) => m.DevRowSelectionStateQueryParams)
+            },
+            {
+                path: 'row-focus-state',
+                loadComponent: async () => import('./tests/row-focus-state.ng').then((m) => m.DevRowFocusState)
+            },
+            {
+                path: 'row-focus-state-query-params',
+                loadComponent: async () =>
+                    import('./tests/row-focus-state.ng').then((m) => m.DevRowFocusStateQueryParams)
+            },
             {
                 path: 'column-menu',
                 loadComponent: async () => import('./tests/column-menu.ng').then((m) => m.DevColumnMenu)
diff --git a/dev/ag-grid-angular/src/tests/row-focus-state.ng.ts b/dev/ag-grid-angular/src/tests/row-focus-state.ng.ts
new file mode 100644
index 0000000..f5a98a5
--- /dev/null
+++ b/dev/ag-grid-angular/src/tests/row-focus-state.ng.ts
@@ -0,0 +1,100 @@
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import {
+    KbqAgGridRowFocusStateLocalStorageStore,
+    KbqAgGridRowFocusStateQueryParamsStore,
+    KbqAgGridThemeModule
+} from '@koobiq/ag-grid-angular-theme';
+import { AgGridModule } from 'ag-grid-angular';
+import { AllCommunityModule, ColDef, GetRowIdFunc, ModuleRegistry } from 'ag-grid-community';
+import { DevRowData, devInjectRowData } from '../row-data';
+
+ModuleRegistry.registerModules([AllCommunityModule]);
+
+const COLUMN_DEFS: ColDef[] = [
+    { field: 'athlete', headerName: 'Athlete' },
+    { field: 'age', headerName: 'Age' },
+    { field: 'country', headerName: 'Country' },
+    { field: 'year', headerName: 'Year' },
+    { field: 'date', headerName: 'Date' },
+    { field: 'sport', headerName: 'Sport' }
+];
+
+const DEFAULT_COL_DEF: ColDef = {
+    editable: true
+};
+
+const GET_ROW_ID: GetRowIdFunc<DevRowData> = (params) => params.data.id;
+
+const STATE_KEY = 'dev-ag-grid-row-focus-state';
+
+@Component({
+    standalone: true,
+    imports: [AgGridModule, KbqAgGridThemeModule],
+    selector: 'dev-row-focus-state',
+    template: `
+        <button type="button" (click)="rowFocusState.reset()">Reset state</button>
+        <ag-grid-angular
+            #rowFocusState="kbqAgGridRowFocusState"
+            data-testid="e2eScreenshotTarget"
+            kbqAgGridTheme
+            animateRows="false"
+            [getRowId]="getRowId"
+            [kbqAgGridRowFocusState]="stateKey"
+            [kbqAgGridRowFocusStateStore]="store"
+            [rowData]="rowData()"
+            [columnDefs]="columnDefs"
+            [defaultColDef]="defaultColDef"
+        />
+    `,
+    styles: `
+        ag-grid-angular {
+            height: 100%;
+            max-width: 2036px;
+        }
+    `,
+    changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class DevRowFocusState {
+    readonly rowData = devInjectRowData();
+    readonly store = inject(KbqAgGridRowFocusStateLocalStorageStore);
+    readonly stateKey = STATE_KEY;
+    readonly columnDefs = COLUMN_DEFS;
+    readonly defaultColDef = DEFAULT_COL_DEF;
+    readonly getRowId = GET_ROW_ID;
+}
+
+@Component({
+    standalone: true,
+    imports: [AgGridModule, KbqAgGridThemeModule],
+    selector: 'dev-row-focus-state-query-params',
+    template: `
+        <button type="button" (click)="rowFocusState.reset()">Reset state</button>
+        <ag-grid-angular
+            #rowFocusState="kbqAgGridRowFocusState"
+            data-testid="e2eScreenshotTarget"
+            kbqAgGridTheme
+            animateRows="false"
+            [getRowId]="getRowId"
+            [kbqAgGridRowFocusState]="stateKey"
+            [kbqAgGridRowFocusStateStore]="store"
+            [rowData]="rowData()"
+            [columnDefs]="columnDefs"
+            [defaultColDef]="defaultColDef"
+        />
+    `,
+    styles: `
+        ag-grid-angular {
+            height: 100%;
+            max-width: 2036px;
+        }
+    `,
+    changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class DevRowFocusStateQueryParams {
+    readonly rowData = devInjectRowData();
+    readonly store = inject(KbqAgGridRowFocusStateQueryParamsStore);
+    readonly stateKey = STATE_KEY;
+    readonly columnDefs = COLUMN_DEFS;
+    readonly defaultColDef = DEFAULT_COL_DEF;
+    readonly getRowId = GET_ROW_ID;
+}
diff --git a/dev/ag-grid-angular/src/tests/row-focus-state.playwright-spec.ts b/dev/ag-grid-angular/src/tests/row-focus-state.playwright-spec.ts
new file mode 100644
index 0000000..4facdb0
--- /dev/null
+++ b/dev/ag-grid-angular/src/tests/row-focus-state.playwright-spec.ts
@@ -0,0 +1,105 @@
+import { expect, Page, test } from '@playwright/test';
+import { getCell, isCellFocused } from './utils/helpers';
+
+const rowFocusStateStorageKey = 'dev-ag-grid-row-focus-state';
+const rowFocusStateQueryParamKey = 'dev-ag-grid-row-focus-state';
+
+type StoredRowFocusState = { rowId: string; colId: string };
+
+const clearRowFocusState = async (page: Page): Promise<void> => {
+    await page.evaluate((key: string) => localStorage.removeItem(key), rowFocusStateStorageKey);
+};
+
+const getRowFocusState = async (page: Page): Promise<StoredRowFocusState | null> => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return page.evaluate((key) => {
+        const stored = localStorage.getItem(key);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return stored ? JSON.parse(stored) : null;
+    }, rowFocusStateStorageKey);
+};
+
+const getRowFocusStateFromUrl = async (page: Page): Promise<StoredRowFocusState | null> => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return page.evaluate((key) => {
+        const item = new URLSearchParams(window.location.search).get(key);
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return JSON.parse(item);
+        } catch {
+            return null;
+        }
+    }, rowFocusStateQueryParamKey);
+};
+
+const buildStateUrl = (state: StoredRowFocusState): string => {
+    const encoded = encodeURIComponent(JSON.stringify(state));
+    return `/e2e/row-focus-state-query-params?${rowFocusStateQueryParamKey}=${encoded}`;
+};
+
+test.describe('KbqAgGridRowFocusState', () => {
+    test.describe('KbqAgGridRowFocusStateLocalStorageStore', () => {
+        test('saves the active cell to localStorage when a cell is clicked', async ({ page }) => {
+            await page.goto('/e2e/row-focus-state');
+            await clearRowFocusState(page);
+
+            await getCell(page, 0, 'athlete').click();
+
+            await expect.poll(async () => (await getRowFocusState(page))?.colId).toBe('athlete');
+        });
+
+        test('restores the active cell from localStorage on page reload', async ({ page }) => {
+            await page.goto('/e2e/row-focus-state');
+            await clearRowFocusState(page);
+
+            await getCell(page, 2, 'country').click();
+            await expect.poll(async () => (await getRowFocusState(page))?.colId).toBe('country');
+
+            await page.reload();
+
+            await expect.poll(async () => isCellFocused(page, 2, 'country')).toBe(true);
+        });
+
+        test('reset clears the active cell and stored state', async ({ page }) => {
+            await page.goto('/e2e/row-focus-state');
+            await clearRowFocusState(page);
+
+            await getCell(page, 0, 'athlete').click();
+            await expect.poll(async () => isCellFocused(page, 0, 'athlete')).toBe(true);
+
+            await page.getByRole('button', { name: 'Reset state' }).click();
+
+            await expect.poll(async () => isCellFocused(page, 0, 'athlete')).toBe(false);
+            await expect.poll(async () => getRowFocusState(page)).toBeNull();
+        });
+    });
+
+    test.describe('KbqAgGridRowFocusStateQueryParamsStore', () => {
+        test('saves the active cell to URL when a cell is clicked', async ({ page }) => {
+            await page.goto('/e2e/row-focus-state-query-params');
+
+            await getCell(page, 0, 'athlete').click();
+
+            await expect.poll(async () => (await getRowFocusStateFromUrl(page))?.colId).toBe('athlete');
+        });
+
+        test('restores the active cell from URL on page reload', async ({ page }) => {
+            await page.goto('/e2e/row-focus-state-query-params');
+
+            await getCell(page, 2, 'country').click();
+            await expect.poll(async () => (await getRowFocusStateFromUrl(page))?.colId).toBe('country');
+
+            await page.reload();
+
+            await expect.poll(async () => isCellFocused(page, 2, 'country')).toBe(true);
+        });
+
+        test('applies pre-existing active cell from URL on page load', async ({ page }) => {
+            await page.goto(buildStateUrl({ rowId: '4f32fc42-54ea-4afe-bcb3-d3e15fff11a5', colId: 'athlete' }));
+
+            await expect.poll(async () => isCellFocused(page, 0, 'athlete')).toBe(true);
+        });
+    });
+});
diff --git a/dev/ag-grid-angular/src/tests/row-group.playwright-spec.ts b/dev/ag-grid-angular/src/tests/row-group.playwright-spec.ts
index a8d9136..e74512a 100644
--- a/dev/ag-grid-angular/src/tests/row-group.playwright-spec.ts
+++ b/dev/ag-grid-angular/src/tests/row-group.playwright-spec.ts
@@ -51,6 +51,35 @@ const naturalCompare = (a: string, b: string): number => a.localeCompare(b, unde
 
 const getUseCustomCellContentCheckbox = (page: Page): Locator => page.getByTestId('useCustomCellContentCheckbox');
 
+const rowGroupCollapsedStateStorageKey = 'dev-ag-grid-row-group-collapsed-state';
+const rowGroupSelectionStateStorageKey = 'dev-ag-grid-row-group-selection-state';
+
+const clearRowGroupPersistedState = async (page: Page): Promise<void> => {
+    await page.evaluate(
+        ({ collapseKey, selectionKey }) => {
+            localStorage.removeItem(collapseKey);
+            localStorage.removeItem(selectionKey);
+        },
+        { collapseKey: rowGroupCollapsedStateStorageKey, selectionKey: rowGroupSelectionStateStorageKey }
+    );
+};
+
+const getStoredCollapsedPaths = async (page: Page): Promise<string[] | null> =>
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    page.evaluate((key) => {
+        const stored = localStorage.getItem(key);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return stored ? JSON.parse(stored) : null;
+    }, rowGroupCollapsedStateStorageKey);
+
+const getStoredSelectedIds = async (page: Page): Promise<string[] | null> =>
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    page.evaluate((key) => {
+        const stored = localStorage.getItem(key);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return stored ? JSON.parse(stored) : null;
+    }, rowGroupSelectionStateStorageKey);
+
 // The custom kbqAgGridRowGroupCellContent demo (DevRowGroupCustomCellContent) renders its own
 // count markup instead of the default `.kbq-ag-grid-group-cell-renderer__count` span.
 const getCustomCellContentCount = (page: Page, rowIndex: number): Locator =>
@@ -723,4 +752,91 @@ test.describe('KbqAgGridRowGroup', () => {
             await expect(getGroupCellInner(page, 0)).toHaveAttribute('aria-expanded', 'false');
         });
     });
+
+    test.describe('state persistence', () => {
+        test('persists collapse state to localStorage and restores it on reload', async ({ page }) => {
+            await page.goto('/e2e/row-group');
+            await clearRowGroupPersistedState(page);
+            await page.reload();
+            await waitForGroupsVisible(page);
+
+            // Expand the first top-level group — row 1 becomes its first (still-collapsed)
+            // nested Sport sub-group, not the *next* top-level country header.
+            const firstGroupKey =
+                (await page.locator('.kbq-ag-grid-group-cell-renderer__key').first().textContent()) ?? '';
+            await getGroupCellInner(page, 0).click();
+            await expect(page.locator('.ag-row[row-index="1"]')).toBeVisible();
+
+            await expect.poll(async () => getStoredCollapsedPaths(page)).not.toBeNull();
+
+            await page.reload();
+            await waitForGroupsVisible(page);
+
+            // The same top-level group must still be expanded after reload.
+            await expect(getGroupCellInner(page, 0)).toContainText(firstGroupKey);
+            await expect(getGroupCellInner(page, 0)).toHaveAttribute('aria-expanded', 'true');
+            await expect(page.locator('.ag-row[row-index="1"]')).toBeVisible();
+        });
+
+        test('reset group state clears the persisted collapse state', async ({ page }) => {
+            await page.goto('/e2e/row-group');
+            await clearRowGroupPersistedState(page);
+            await page.reload();
+            await waitForGroupsVisible(page);
+
+            await getGroupCellInner(page, 0).click();
+            await expect.poll(async () => getStoredCollapsedPaths(page)).not.toBeNull();
+
+            await page.getByTestId('resetRowGroupStateBtn').click();
+
+            await expect.poll(async () => getStoredCollapsedPaths(page)).toBeNull();
+        });
+
+        test('persists selection to localStorage and restores it on reload, even hidden inside a collapsed group', async ({
+            page
+        }) => {
+            await page.goto('/e2e/row-group');
+            await clearRowGroupPersistedState(page);
+            await page.reload();
+            await waitForGroupsVisible(page);
+
+            // Select Ilya Zakharov while Russia > Diving is still fully collapsed.
+            await page.getByTestId('selectIlyaZakharovBtn').click();
+            await expect(page.getByTestId('selectedCount')).toHaveText('1');
+            await expect.poll(async () => getStoredSelectedIds(page)).not.toBeNull();
+
+            await page.reload();
+            await waitForGroupsVisible(page);
+
+            // The full-dataset selection count is restored — including a row not yet loaded
+            // into AG's row model — once the (async-fetched) row data has arrived.
+            await expect(page.getByTestId('selectedCount')).toHaveText('1', { timeout: 10_000 });
+
+            // Expand down to the row — it comes back visually selected too.
+            await page.getByTestId('expandRussiaDivingBtn').click();
+            const athleteRow = getDataRowByText(page, 'Ilya Zakharov');
+            await expect(athleteRow).toBeVisible();
+            await expect(athleteRow).toHaveClass(/ag-row-selected/);
+        });
+
+        test('reset group state does not clear the persisted selection — selection is independent of grouping', async ({
+            page
+        }) => {
+            await page.goto('/e2e/row-group');
+            await clearRowGroupPersistedState(page);
+            await page.reload();
+            await waitForGroupsVisible(page);
+
+            await page.getByTestId('selectIlyaZakharovBtn').click();
+            await expect.poll(async () => getStoredSelectedIds(page)).not.toBeNull();
+
+            await page.getByTestId('resetRowGroupStateBtn').click();
+
+            // Collapse state is cleared by the reset...
+            await expect.poll(async () => getStoredCollapsedPaths(page)).toBeNull();
+            // ...but the selection itself — both in storage and in the reported count — remains.
+            await expect.poll(async () => getStoredSelectedIds(page)).not.toBeNull();
+            await expect(page.getByTestId('selectedCount')).toHaveText('1');
+        });
+    });
 });
diff --git a/dev/ag-grid-angular/src/tests/row-group.ts b/dev/ag-grid-angular/src/tests/row-group.ts
index 827158d..2f06a9e 100644
--- a/dev/ag-grid-angular/src/tests/row-group.ts
+++ b/dev/ag-grid-angular/src/tests/row-group.ts
@@ -1,11 +1,13 @@
-import { ChangeDetectionStrategy, Component, computed, input, model, signal, viewChild } from '@angular/core';
+import { ChangeDetectionStrategy, Component, computed, inject, input, model, signal, viewChild } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 import {
     KbqAgGridRowGroup,
     KbqAgGridRowGroupCellContent,
+    KbqAgGridRowGroupCollapsedStateLocalStorageStore,
     kbqAgGridRowGroupColOptionsProvider,
     KbqAgGridRowGroupInfo,
     KbqAgGridRowGroupRowId,
+    KbqAgGridRowGroupSelectionStateLocalStorageStore,
     KbqAgGridThemeModule
 } from '@koobiq/ag-grid-angular-theme';
 import { AgGridModule } from 'ag-grid-angular';
@@ -101,6 +103,9 @@ class DevRowGroupCustomCellContent implements KbqAgGridRowGroupCellContent {
             <button type="button" data-testid="clearGroupColSortBtn" (click)="clearGroupColSort()">
                 Clear group column sort
             </button>
+            <button type="button" data-testid="resetRowGroupStateBtn" (click)="resetGroupState()">
+                Reset group state
+            </button>
             <label>
                 <input type="checkbox" data-testid="useCustomCellContentCheckbox" [(ngModel)]="useCustomCellContent" />
                 Use custom group cell content
@@ -117,6 +122,10 @@ class DevRowGroupCustomCellContent implements KbqAgGridRowGroupCellContent {
             [columnDefs]="columnDefs"
             [(kbqAgGridRowGroupCols)]="groupCols"
             [kbqAgGridRowGroupCellContent]="cellContent()"
+            [kbqAgGridRowGroupCollapsedState]="collapsedStateKey"
+            [kbqAgGridRowGroupCollapsedStateStore]="collapsedStateStore"
+            [kbqAgGridRowGroupSelectionState]="selectionStateKey"
+            [kbqAgGridRowGroupSelectionStateStore]="selectionStateStore"
             [defaultColDef]="defaultColDef"
             [rowSelection]="rowSelection"
             [animateRows]="false"
@@ -144,8 +153,16 @@ export class DevRowGroup {
     protected readonly groupCols = signal<string[]>(['country', 'sport']);
     protected readonly rowSelection = { mode: 'multiRow', checkboxes: true } as const;
     protected readonly selectedRows = signal<Record<string, unknown>[]>([]);
+    protected readonly collapsedStateKey = 'dev-ag-grid-row-group-collapsed-state';
+    protected readonly collapsedStateStore = inject(KbqAgGridRowGroupCollapsedStateLocalStorageStore);
+    protected readonly selectionStateKey = 'dev-ag-grid-row-group-selection-state';
+    protected readonly selectionStateStore = inject(KbqAgGridRowGroupSelectionStateLocalStorageStore);
     private readonly group = viewChild.required(KbqAgGridRowGroup);
 
+    protected resetGroupState(): void {
+        this.group().clearGroupColumns();
+    }
+
     protected expandAll(): void {
         this.group().expandAll();
     }
diff --git a/dev/ag-grid-angular/src/tests/row-selection-state.ng.ts b/dev/ag-grid-angular/src/tests/row-selection-state.ng.ts
new file mode 100644
index 0000000..2faebd9
--- /dev/null
+++ b/dev/ag-grid-angular/src/tests/row-selection-state.ng.ts
@@ -0,0 +1,102 @@
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import {
+    KbqAgGridRowSelectionStateLocalStorageStore,
+    KbqAgGridRowSelectionStateQueryParamsStore,
+    KbqAgGridThemeModule
+} from '@koobiq/ag-grid-angular-theme';
+import { AgGridModule } from 'ag-grid-angular';
+import { AllCommunityModule, ColDef, GetRowIdFunc, ModuleRegistry, RowSelectionOptions } from 'ag-grid-community';
+import { DevRowData, devInjectRowData } from '../row-data';
+
+ModuleRegistry.registerModules([AllCommunityModule]);
+
+const COLUMN_DEFS: ColDef[] = [
+    { field: 'athlete', headerName: 'Athlete' },
+    { field: 'age', headerName: 'Age' },
+    { field: 'country', headerName: 'Country' },
+    { field: 'year', headerName: 'Year' },
+    { field: 'date', headerName: 'Date' },
+    { field: 'sport', headerName: 'Sport' }
+];
+
+const ROW_SELECTION: RowSelectionOptions = {
+    mode: 'multiRow',
+    checkboxes: true,
+    headerCheckbox: true
+};
+
+const GET_ROW_ID: GetRowIdFunc<DevRowData> = (params) => params.data.id;
+
+const STATE_KEY = 'dev-ag-grid-row-selection-state';
+
+@Component({
+    standalone: true,
+    imports: [AgGridModule, KbqAgGridThemeModule],
+    selector: 'dev-row-selection-state',
+    template: `
+        <button type="button" (click)="rowSelectionState.reset()">Reset state</button>
+        <ag-grid-angular
+            #rowSelectionState="kbqAgGridRowSelectionState"
+            data-testid="e2eScreenshotTarget"
+            kbqAgGridTheme
+            animateRows="false"
+            [getRowId]="getRowId"
+            [kbqAgGridRowSelectionState]="stateKey"
+            [kbqAgGridRowSelectionStateStore]="store"
+            [rowData]="rowData()"
+            [columnDefs]="columnDefs"
+            [rowSelection]="rowSelection"
+        />
+    `,
+    styles: `
+        ag-grid-angular {
+            height: 100%;
+            max-width: 2036px;
+        }
+    `,
+    changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class DevRowSelectionState {
+    readonly rowData = devInjectRowData();
+    readonly store = inject(KbqAgGridRowSelectionStateLocalStorageStore);
+    readonly stateKey = STATE_KEY;
+    readonly columnDefs = COLUMN_DEFS;
+    readonly rowSelection = ROW_SELECTION;
+    readonly getRowId = GET_ROW_ID;
+}
+
+@Component({
+    standalone: true,
+    imports: [AgGridModule, KbqAgGridThemeModule],
+    selector: 'dev-row-selection-state-query-params',
+    template: `
+        <button type="button" (click)="rowSelectionState.reset()">Reset state</button>
+        <ag-grid-angular
+            #rowSelectionState="kbqAgGridRowSelectionState"
+            data-testid="e2eScreenshotTarget"
+            kbqAgGridTheme
+            animateRows="false"
+            [getRowId]="getRowId"
+            [kbqAgGridRowSelectionState]="stateKey"
+            [kbqAgGridRowSelectionStateStore]="store"
+            [rowData]="rowData()"
+            [columnDefs]="columnDefs"
+            [rowSelection]="rowSelection"
+        />
+    `,
+    styles: `
+        ag-grid-angular {
+            height: 100%;
+            max-width: 2036px;
+        }
+    `,
+    changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class DevRowSelectionStateQueryParams {
+    readonly rowData = devInjectRowData();
+    readonly store = inject(KbqAgGridRowSelectionStateQueryParamsStore);
+    readonly stateKey = STATE_KEY;
+    readonly columnDefs = COLUMN_DEFS;
+    readonly rowSelection = ROW_SELECTION;
+    readonly getRowId = GET_ROW_ID;
+}
diff --git a/dev/ag-grid-angular/src/tests/row-selection-state.playwright-spec.ts b/dev/ag-grid-angular/src/tests/row-selection-state.playwright-spec.ts
new file mode 100644
index 0000000..5973a23
--- /dev/null
+++ b/dev/ag-grid-angular/src/tests/row-selection-state.playwright-spec.ts
@@ -0,0 +1,115 @@
+import { expect, Page, test } from '@playwright/test';
+import { isRowSelected, toggleRowSelection, waitForRowSelected } from './utils/helpers';
+
+const rowSelectionStateStorageKey = 'dev-ag-grid-row-selection-state';
+const rowSelectionStateQueryParamKey = 'dev-ag-grid-row-selection-state';
+
+const clearRowSelectionState = async (page: Page): Promise<void> => {
+    await page.evaluate((key: string) => localStorage.removeItem(key), rowSelectionStateStorageKey);
+};
+
+const getRowSelectionState = async (page: Page): Promise<string[] | null> => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return page.evaluate((key) => {
+        const stored = localStorage.getItem(key);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return stored ? JSON.parse(stored) : null;
+    }, rowSelectionStateStorageKey);
+};
+
+const getRowSelectionStateFromUrl = async (page: Page): Promise<string[] | null> => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return page.evaluate((key) => {
+        const item = new URLSearchParams(window.location.search).get(key);
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return JSON.parse(item);
+        } catch {
+            return null;
+        }
+    }, rowSelectionStateQueryParamKey);
+};
+
+const buildStateUrl = (ids: string[]): string => {
+    const encoded = encodeURIComponent(JSON.stringify(ids));
+    return `/e2e/row-selection-state-query-params?${rowSelectionStateQueryParamKey}=${encoded}`;
+};
+
+test.describe('KbqAgGridRowSelectionState', () => {
+    test.describe('KbqAgGridRowSelectionStateLocalStorageStore', () => {
+        test('saves selection to localStorage when a row is selected', async ({ page }) => {
+            await page.goto('/e2e/row-selection-state');
+            await clearRowSelectionState(page);
+
+            await toggleRowSelection(page, 0);
+
+            await expect.poll(async () => getRowSelectionState(page)).not.toBeNull();
+        });
+
+        test('restores selection from localStorage on page reload', async ({ page }) => {
+            await page.goto('/e2e/row-selection-state');
+            await clearRowSelectionState(page);
+
+            await toggleRowSelection(page, 2);
+            await expect.poll(async () => getRowSelectionState(page)).not.toBeNull();
+
+            await page.reload();
+
+            await waitForRowSelected(page, 2);
+        });
+
+        test('removes stored selection when the row is deselected', async ({ page }) => {
+            await page.goto('/e2e/row-selection-state');
+            await clearRowSelectionState(page);
+
+            await toggleRowSelection(page, 0);
+            await expect.poll(async () => getRowSelectionState(page)).not.toBeNull();
+
+            await toggleRowSelection(page, 0);
+
+            await expect.poll(async () => getRowSelectionState(page)).toBeNull();
+        });
+
+        test('reset clears selection and stored state', async ({ page }) => {
+            await page.goto('/e2e/row-selection-state');
+            await clearRowSelectionState(page);
+
+            await toggleRowSelection(page, 0);
+            await expect.poll(async () => isRowSelected(page, 0)).toBe(true);
+
+            await page.getByRole('button', { name: 'Reset state' }).click();
+
+            await expect.poll(async () => isRowSelected(page, 0)).toBe(false);
+            await expect.poll(async () => getRowSelectionState(page)).toBeNull();
+        });
+    });
+
+    test.describe('KbqAgGridRowSelectionStateQueryParamsStore', () => {
+        test('saves selection to URL when a row is selected', async ({ page }) => {
+            await page.goto('/e2e/row-selection-state-query-params');
+
+            await toggleRowSelection(page, 0);
+
+            await expect.poll(async () => getRowSelectionStateFromUrl(page)).not.toBeNull();
+        });
+
+        test('restores selection from URL on page reload', async ({ page }) => {
+            await page.goto('/e2e/row-selection-state-query-params');
+
+            await toggleRowSelection(page, 2);
+            await expect.poll(async () => getRowSelectionStateFromUrl(page)).not.toBeNull();
+
+            await page.reload();
+
+            await waitForRowSelected(page, 2);
+        });
+
+        test('applies pre-existing selection from URL on page load', async ({ page }) => {
+            await page.goto(buildStateUrl(['4f32fc42-54ea-4afe-bcb3-d3e15fff11a5']));
+
+            await waitForRowSelected(page, 0);
+        });
+    });
+});
diff --git a/packages/ag-grid-angular-theme/index.ts b/packages/ag-grid-angular-theme/index.ts
index 150208c..480aa27 100644
--- a/packages/ag-grid-angular-theme/index.ts
+++ b/packages/ag-grid-angular-theme/index.ts
@@ -8,7 +8,9 @@ export * from './src/loading-overlay.ng';
 export * from './src/module.ng';
 export * from './src/quick-filter-state.ng';
 export * from './src/row-actions.ng';
+export * from './src/row-focus-state.ng';
 export * from './src/row-group.ng';
+export * from './src/row-selection-state.ng';
 export * from './src/select-all-rows-by-ctrl-a.ng';
 export * from './src/select-rows-by-ctrl-click.ng';
 export * from './src/select-rows-by-shift-arrow.ng';
diff --git a/packages/ag-grid-angular-theme/src/module.ng.ts b/packages/ag-grid-angular-theme/src/module.ng.ts
index e7088ec..67eeb37 100644
--- a/packages/ag-grid-angular-theme/src/module.ng.ts
+++ b/packages/ag-grid-angular-theme/src/module.ng.ts
@@ -8,7 +8,9 @@ import { KbqAgGridInfiniteSelection } from './infinite-selection.ng';
 import { KbqAgGridLoadingOverlay } from './loading-overlay.ng';
 import { KbqAgGridQuickFilterState } from './quick-filter-state.ng';
 import { KbqAgGridRowActions } from './row-actions.ng';
+import { KbqAgGridRowFocusState } from './row-focus-state.ng';
 import { KbqAgGridRowGroup } from './row-group.ng';
+import { KbqAgGridRowSelectionState } from './row-selection-state.ng';
 import { KbqAgGridSelectAllRowsByCtrlA } from './select-all-rows-by-ctrl-a.ng';
 import { KbqAgGridSelectRowsByCtrlClick } from './select-rows-by-ctrl-click.ng';
 import { KbqAgGridSelectRowsByShiftArrow } from './select-rows-by-shift-arrow.ng';
@@ -36,7 +38,9 @@ const COMPONENTS = [
     KbqAgGridQuickFilterState,
     KbqAgGridExternalFilterState,
     KbqAgGridLoadingOverlay,
-    KbqAgGridRowGroup
+    KbqAgGridRowGroup,
+    KbqAgGridRowSelectionState,
+    KbqAgGridRowFocusState
 ];
 
 @NgModule({
diff --git a/packages/ag-grid-angular-theme/src/row-focus-state.ng.ts b/packages/ag-grid-angular-theme/src/row-focus-state.ng.ts
new file mode 100644
index 0000000..abed446
--- /dev/null
+++ b/packages/ag-grid-angular-theme/src/row-focus-state.ng.ts
@@ -0,0 +1,224 @@
+import { DestroyRef, Directive, inject, Injectable, InjectionToken, input, Provider, Type } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Router } from '@angular/router';
+import { AgGridAngular } from 'ag-grid-angular';
+import { AgEventListener, GridApi } from 'ag-grid-community';
+import { KbqAgGridStateStore } from './state-store';
+
+/** Identifies the active (focused) cell by row id and column id. */
+export type KbqAgGridRowFocusStateValue = {
+    rowId: string;
+    colId: string;
+};
+
+/**
+ * Storage interface for persisting and retrieving ag-grid active cell state.
+ *
+ * Supports both synchronous and Promise-based implementations.
+ */
+export type KbqAgGridRowFocusStateStore = KbqAgGridStateStore<KbqAgGridRowFocusStateValue>;
+
+/**
+ * {@link KbqAgGridRowFocusStateStore} implementation backed by `localStorage`.
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowFocusStateLocalStorageStore implements KbqAgGridRowFocusStateStore {
+    // TODO: Should use KBQ_WINDOW token
+    private readonly localStorage = window.localStorage;
+
+    getItem(key: string): KbqAgGridRowFocusStateValue | null {
+        const item = this.localStorage.getItem(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as KbqAgGridRowFocusStateValue;
+        } catch {
+            return null;
+        }
+    }
+
+    setItem(key: string, value: KbqAgGridRowFocusStateValue): void {
+        this.localStorage.setItem(key, JSON.stringify(value));
+    }
+
+    removeItem(key: string): void {
+        this.localStorage.removeItem(key);
+    }
+}
+
+/**
+ * {@link KbqAgGridRowFocusStateStore} implementation backed by URL query parameters.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowFocusStateStoreProvider(KbqAgGridRowFocusStateQueryParamsStore)]
+ * ```
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowFocusStateQueryParamsStore implements KbqAgGridRowFocusStateStore {
+    private readonly router = inject(Router);
+    // TODO: Should use KBQ_WINDOW token
+    private readonly location = window.location;
+
+    getItem(key: string): KbqAgGridRowFocusStateValue | null {
+        const item = new URLSearchParams(this.location.search).get(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as KbqAgGridRowFocusStateValue;
+        } catch {
+            return null;
+        }
+    }
+
+    async setItem(key: string, value: KbqAgGridRowFocusStateValue): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: JSON.stringify(value) },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+
+    async removeItem(key: string): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: null },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+}
+
+/**
+ * Injection token for {@link KbqAgGridRowFocusStateStore}.
+ *
+ * Defaults to {@link KbqAgGridRowFocusStateLocalStorageStore}.
+ * Override it with {@link kbqAgGridRowFocusStateStoreProvider}.
+ */
+export const KBQ_AG_GRID_ROW_FOCUS_STATE_STORE = new InjectionToken<KbqAgGridRowFocusStateStore>(
+    'KBQ_AG_GRID_ROW_FOCUS_STATE_STORE',
+    { factory: (): KbqAgGridRowFocusStateStore => inject(KbqAgGridRowFocusStateLocalStorageStore) }
+);
+
+/**
+ * Creates an Angular {@link Provider} that binds {@link KBQ_AG_GRID_ROW_FOCUS_STATE_STORE}
+ * to the given store class or instance.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowFocusStateStoreProvider(KbqAgGridRowFocusStateQueryParamsStore)]
+ * ```
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowFocusStateStoreProvider(myCustomStoreInstance)]
+ * ```
+ */
+export const kbqAgGridRowFocusStateStoreProvider = (
+    store: Type<KbqAgGridRowFocusStateStore> | KbqAgGridRowFocusStateStore
+): Provider => {
+    return store instanceof Type
+        ? { provide: KBQ_AG_GRID_ROW_FOCUS_STATE_STORE, useClass: store }
+        : { provide: KBQ_AG_GRID_ROW_FOCUS_STATE_STORE, useValue: store };
+};
+
+/**
+ * Directive that persists and restores ag-grid's active (focused) cell
+ * using a configurable {@link KbqAgGridRowFocusStateStore}.
+ *
+ * Requires `getRowId` to be set in `gridOptions` so row identity survives a page reload —
+ * without it, ag-grid assigns row ids internally and a restored row id will not match any row.
+ *
+ * @example
+ * ```html
+ * <ag-grid-angular kbqAgGridTheme
+ *                  [getRowId]="getRowId"
+ *                  [kbqAgGridRowFocusState]="'row-focus-state'"
+ *                  [kbqAgGridRowFocusStateStore]="myRowFocusStore" />
+ * ```
+ */
+@Directive({
+    standalone: true,
+    selector: 'ag-grid-angular[kbqAgGridRowFocusState]',
+    exportAs: 'kbqAgGridRowFocusState'
+})
+export class KbqAgGridRowFocusState {
+    private readonly grid = inject(AgGridAngular);
+    private readonly destroyRef = inject(DestroyRef);
+
+    /** Key under which the active cell state is stored. Must be unique per grid. */
+    readonly key = input.required<string>({ alias: 'kbqAgGridRowFocusState' });
+
+    /** Store used to persist and restore the active cell state. Defaults to {@link KBQ_AG_GRID_ROW_FOCUS_STATE_STORE}. */
+    readonly store = input(inject(KBQ_AG_GRID_ROW_FOCUS_STATE_STORE), { alias: 'kbqAgGridRowFocusStateStore' });
+
+    constructor() {
+        this.grid.gridReady.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(({ api }) => this.init(api));
+    }
+
+    /** Removes the stored active cell state for the current key and clears grid focus. */
+    reset(): void {
+        const store = this.store();
+        const key = this.key();
+
+        void store.removeItem(key);
+        this.grid.api.clearFocusedCell();
+    }
+
+    private init(api: GridApi): void {
+        const key = this.key();
+        const store = this.store();
+
+        // Restoring focus needs a resolvable row index, which only exists once row nodes have
+        // actually been rendered — so this waits for `firstDataRendered` rather than `gridReady`.
+        let restoring = false;
+
+        const restore: AgEventListener = () => {
+            void (async (): Promise<void> => {
+                const item = await store.getItem(key);
+
+                if (!item) return;
+
+                const node = api.getRowNode(item.rowId);
+
+                if (node?.rowIndex === null || node?.rowIndex === undefined) return;
+
+                restoring = true;
+                api.setFocusedCell(node.rowIndex, item.colId);
+                restoring = false;
+            })();
+        };
+
+        api.addEventListener('firstDataRendered', restore);
+
+        const save: AgEventListener<unknown, unknown, 'cellFocused'> = (event) => {
+            // Skips saves triggered by our own restore call to avoid redundant writes.
+            if (restoring) return;
+
+            if (event.rowIndex === null || event.column === null || event.rowPinned) {
+                void store.removeItem(key);
+                return;
+            }
+
+            const rowId = api.getDisplayedRowAtIndex(event.rowIndex)?.id;
+
+            if (rowId === undefined) {
+                void store.removeItem(key);
+                return;
+            }
+
+            const colId = typeof event.column === 'string' ? event.column : event.column.getColId();
+
+            void store.setItem(key, { rowId, colId });
+        };
+
+        api.addEventListener('cellFocused', save);
+
+        this.destroyRef.onDestroy(() => {
+            api.removeEventListener('firstDataRendered', restore);
+            api.removeEventListener('cellFocused', save);
+        });
+    }
+}
diff --git a/packages/ag-grid-angular-theme/src/row-group.ng.ts b/packages/ag-grid-angular-theme/src/row-group.ng.ts
index 482e150..950826f 100644
--- a/packages/ag-grid-angular-theme/src/row-group.ng.ts
+++ b/packages/ag-grid-angular-theme/src/row-group.ng.ts
@@ -8,6 +8,7 @@ import {
     effect,
     ElementRef,
     inject,
+    Injectable,
     InjectionToken,
     input,
     InputSignal,
@@ -21,6 +22,7 @@ import {
     viewChild
 } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Router } from '@angular/router';
 import { AgGridAngular, ICellRendererAngularComp, IHeaderAngularComp } from 'ag-grid-angular';
 import {
     CellRendererSelectorResult,
@@ -36,6 +38,7 @@ import {
     SelectionColumnDef,
     SortDirection
 } from 'ag-grid-community';
+import { KbqAgGridStateStore } from './state-store';
 
 /** A plain input data row — any object with string keys. */
 type RowData = Record<string, unknown>;
@@ -662,6 +665,240 @@ class KbqAgGridRowGroupSelectAllHeaderCellRenderer implements IHeaderAngularComp
     }
 }
 
+/**
+ * Storage interface for persisting and retrieving `KbqAgGridRowGroup`'s collapsed-group state
+ * (see `kbqAgGridRowGroupCollapsedState`) — a list of opaque group `path` tokens (see `collapsedPaths`).
+ *
+ * Supports both synchronous and Promise-based implementations.
+ */
+export type KbqAgGridRowGroupCollapsedStateStore = KbqAgGridStateStore<readonly string[]>;
+
+/**
+ * {@link KbqAgGridRowGroupCollapsedStateStore} implementation backed by `localStorage`.
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowGroupCollapsedStateLocalStorageStore implements KbqAgGridRowGroupCollapsedStateStore {
+    // TODO: Should use KBQ_WINDOW token
+    private readonly localStorage = window.localStorage;
+
+    getItem(key: string): readonly string[] | null {
+        const item = this.localStorage.getItem(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as string[];
+        } catch {
+            return null;
+        }
+    }
+
+    setItem(key: string, value: readonly string[]): void {
+        this.localStorage.setItem(key, JSON.stringify(value));
+    }
+
+    removeItem(key: string): void {
+        this.localStorage.removeItem(key);
+    }
+}
+
+/**
+ * {@link KbqAgGridRowGroupCollapsedStateStore} implementation backed by URL query parameters.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowGroupCollapsedStateStoreProvider(KbqAgGridRowGroupCollapsedStateQueryParamsStore)]
+ * ```
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowGroupCollapsedStateQueryParamsStore implements KbqAgGridRowGroupCollapsedStateStore {
+    private readonly router = inject(Router);
+    // TODO: Should use KBQ_WINDOW token
+    private readonly location = window.location;
+
+    getItem(key: string): readonly string[] | null {
+        const item = new URLSearchParams(this.location.search).get(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as string[];
+        } catch {
+            return null;
+        }
+    }
+
+    async setItem(key: string, value: readonly string[]): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: JSON.stringify(value) },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+
+    async removeItem(key: string): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: null },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+}
+
+/**
+ * Injection token for {@link KbqAgGridRowGroupCollapsedStateStore}.
+ *
+ * Defaults to {@link KbqAgGridRowGroupCollapsedStateLocalStorageStore}.
+ * Override it with {@link kbqAgGridRowGroupCollapsedStateStoreProvider}.
+ */
+export const KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE = new InjectionToken<KbqAgGridRowGroupCollapsedStateStore>(
+    'KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE',
+    { factory: (): KbqAgGridRowGroupCollapsedStateStore => inject(KbqAgGridRowGroupCollapsedStateLocalStorageStore) }
+);
+
+/**
+ * Creates an Angular {@link Provider} that binds {@link KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE}
+ * to the given store class or instance.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowGroupCollapsedStateStoreProvider(KbqAgGridRowGroupCollapsedStateQueryParamsStore)]
+ * ```
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowGroupCollapsedStateStoreProvider(myCustomStoreInstance)]
+ * ```
+ */
+export const kbqAgGridRowGroupCollapsedStateStoreProvider = (
+    store: Type<KbqAgGridRowGroupCollapsedStateStore> | KbqAgGridRowGroupCollapsedStateStore
+): Provider => {
+    return store instanceof Type
+        ? { provide: KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE, useClass: store }
+        : { provide: KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE, useValue: store };
+};
+
+/**
+ * Storage interface for persisting and retrieving `KbqAgGridRowGroup`'s row selection (see
+ * `kbqAgGridRowGroupSelectionState`) — the ids (see `kbqAgGridRowGroupRowId`) of every selected
+ * data row, independent of which are currently visible/materialized as AG Grid row nodes.
+ *
+ * Not interchangeable with `KbqAgGridRowSelectionState` (the standalone directive) — that one
+ * reads AG Grid's own `getSelectedNodes()`, which only reports currently-materialized rows and
+ * so misses anything hidden inside a collapsed group. This store is fed from
+ * `KbqAgGridRowGroup`'s own `selectedRowIds`, which is not subject to that limitation.
+ *
+ * Supports both synchronous and Promise-based implementations.
+ */
+export type KbqAgGridRowGroupSelectionStateStore = KbqAgGridStateStore<readonly string[]>;
+
+/**
+ * {@link KbqAgGridRowGroupSelectionStateStore} implementation backed by `localStorage`.
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowGroupSelectionStateLocalStorageStore implements KbqAgGridRowGroupSelectionStateStore {
+    // TODO: Should use KBQ_WINDOW token
+    private readonly localStorage = window.localStorage;
+
+    getItem(key: string): readonly string[] | null {
+        const item = this.localStorage.getItem(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as string[];
+        } catch {
+            return null;
+        }
+    }
+
+    setItem(key: string, value: readonly string[]): void {
+        this.localStorage.setItem(key, JSON.stringify(value));
+    }
+
+    removeItem(key: string): void {
+        this.localStorage.removeItem(key);
+    }
+}
+
+/**
+ * {@link KbqAgGridRowGroupSelectionStateStore} implementation backed by URL query parameters.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowGroupSelectionStateStoreProvider(KbqAgGridRowGroupSelectionStateQueryParamsStore)]
+ * ```
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowGroupSelectionStateQueryParamsStore implements KbqAgGridRowGroupSelectionStateStore {
+    private readonly router = inject(Router);
+    // TODO: Should use KBQ_WINDOW token
+    private readonly location = window.location;
+
+    getItem(key: string): readonly string[] | null {
+        const item = new URLSearchParams(this.location.search).get(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as string[];
+        } catch {
+            return null;
+        }
+    }
+
+    async setItem(key: string, value: readonly string[]): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: JSON.stringify(value) },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+
+    async removeItem(key: string): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: null },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+}
+
+/**
+ * Injection token for {@link KbqAgGridRowGroupSelectionStateStore}.
+ *
+ * Defaults to {@link KbqAgGridRowGroupSelectionStateLocalStorageStore}.
+ * Override it with {@link kbqAgGridRowGroupSelectionStateStoreProvider}.
+ */
+export const KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE = new InjectionToken<KbqAgGridRowGroupSelectionStateStore>(
+    'KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE',
+    { factory: (): KbqAgGridRowGroupSelectionStateStore => inject(KbqAgGridRowGroupSelectionStateLocalStorageStore) }
+);
+
+/**
+ * Creates an Angular {@link Provider} that binds {@link KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE}
+ * to the given store class or instance.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowGroupSelectionStateStoreProvider(KbqAgGridRowGroupSelectionStateQueryParamsStore)]
+ * ```
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowGroupSelectionStateStoreProvider(myCustomStoreInstance)]
+ * ```
+ */
+export const kbqAgGridRowGroupSelectionStateStoreProvider = (
+    store: Type<KbqAgGridRowGroupSelectionStateStore> | KbqAgGridRowGroupSelectionStateStore
+): Provider => {
+    return store instanceof Type
+        ? { provide: KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE, useClass: store }
+        : { provide: KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE, useValue: store };
+};
+
 /**
  * Directive that implements client-side row grouping without AG Grid Enterprise.
  *
@@ -701,6 +938,32 @@ class KbqAgGridRowGroupSelectAllHeaderCellRenderer implements IHeaderAngularComp
  *   a prior manual visibility change) is left exactly as-is — grouping by it never makes it
  *   visible, and un-grouping it never un-hides it either.
  *
+ * **Persisting collapsed/expanded state:**
+ * - Set `[kbqAgGridRowGroupCollapsedState]` to a storage key to persist and restore which groups are
+ *   collapsed, using a configurable {@link KbqAgGridRowGroupCollapsedStateStore} (defaults to
+ *   `localStorage`; override via `[kbqAgGridRowGroupCollapsedStateStore]`).
+ * - A group `path` (see `collapsedPaths`) is derived from the raw values of its `groupCols`
+ *   fields, not from row identity — unlike `[kbqAgGridRowGroupRowId]`-based selection tracking,
+ *   restoring collapse state does NOT require a stable row id to survive a page reload.
+ * - This does NOT persist `groupCols` itself (which fields are grouped by) — restore that
+ *   yourself via `[(kbqAgGridRowGroupCols)]` before/at grid init. A restored path only matches
+ *   an existing group once `groupCols` again equals whatever it was when the path was saved;
+ *   otherwise it's silently ignored until `groupCols` catches up (or discarded the next time the
+ *   grouping structure actually changes).
+ * - `clearGroupColumns()` also removes the stored state — with no grouping there's nothing
+ *   meaningful for a collapsed path to refer to.
+ *
+ * **Persisting row selection:**
+ * - Set `[kbqAgGridRowGroupSelectionState]` to a storage key to persist and restore which data
+ *   rows are selected, using a configurable {@link KbqAgGridRowGroupSelectionStateStore}
+ *   (defaults to `localStorage`; override via `[kbqAgGridRowGroupSelectionStateStore]`).
+ * - This is a separate feature from `KbqAgGridRowSelectionState` (the standalone directive) —
+ *   that one reads AG Grid's own `getSelectedNodes()`, which only reports currently-visible
+ *   rows and so misses anything hidden inside a collapsed group. This one persists from the
+ *   directive's own `selectedRowIds`, which tracks the full selection regardless of collapse
+ *   state, and requires `[kbqAgGridRowGroupRowId]` for the same reason selection tracking does
+ *   in general (see the class-level `**Recommended**` note).
+ *
  * @example
  * ```html
  * <ag-grid-angular
@@ -753,6 +1016,34 @@ export class KbqAgGridRowGroup {
         }
     );
 
+    /**
+     * Key under which collapsed/expanded group state is stored. Must be unique per grid.
+     * Omit to disable persistence (the default) — see the class-level
+     * `**Persisting collapsed/expanded state**` note.
+     */
+    readonly collapsedStateKey = input<string | undefined>(undefined, { alias: 'kbqAgGridRowGroupCollapsedState' });
+
+    /** Store used to persist and restore collapsed/expanded group state. Defaults to
+     * {@link KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE}. */
+    readonly collapsedStateStore = input(inject(KBQ_AG_GRID_ROW_GROUP_COLLAPSED_STATE_STORE), {
+        alias: 'kbqAgGridRowGroupCollapsedStateStore'
+    });
+
+    /**
+     * Key under which selected row ids are stored. Must be unique per grid.
+     * Omit to disable persistence (the default) — see the class-level
+     * `**Persisting row selection**` note.
+     */
+    readonly selectionStateKey = input<string | undefined>(undefined, {
+        alias: 'kbqAgGridRowGroupSelectionState'
+    });
+
+    /** Store used to persist and restore selected row ids. Defaults to
+     * {@link KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE}. */
+    readonly selectionStateStore = input(inject(KBQ_AG_GRID_ROW_GROUP_SELECTION_STATE_STORE), {
+        alias: 'kbqAgGridRowGroupSelectionStateStore'
+    });
+
     /**
      * Custom component rendered in place of the default group-cell key-only markup — see
      * {@link KbqAgGridRowGroupCellContent}. Leaves the chevron icon, expand/collapse toggle
@@ -925,6 +1216,9 @@ export class KbqAgGridRowGroup {
     private readonly programmaticallySetNodes = new WeakSet();
     /** Deferred collapse: set on gridReady when groupCols is non-empty; cleared once data is available. */
     private needsInitialCollapse = false;
+    /** Selection restored from kbqAgGridRowGroupSelectionState, staged in onGridReady and
+     * applied once data() is non-empty — see the "update rowData" effect below. */
+    private pendingRestoredSelectedIds: readonly string[] | null = null;
     /** Previous groupCols reference — compared by identity to detect structural changes. */
     private prevGroupCols: string[] | null = null;
     private warnedMissingRowId = false;
@@ -981,6 +1275,19 @@ export class KbqAgGridRowGroup {
                 }
                 this.lastRebuildInputs = { data, groupCols, collapsedPaths, sort };
 
+                // Applies a selection restored from kbqAgGridRowGroupSelectionState once real
+                // data is available — mirrors needsInitialCollapse above: rowData() can still be
+                // [] here (e.g. an async HTTP fetch hasn't resolved yet) when onGridReady staged
+                // this, so applying it there directly could resolve rowIdMap() against no rows
+                // and silently produce nothing. Deferring the resolution to this point, where
+                // data is confirmed non-empty, is what emitSelectionChanged() below relies on.
+                let justRestoredSelection = false;
+                if (this.pendingRestoredSelectedIds && data.length > 0) {
+                    this.selectedRowIds.set(new Set(this.pendingRestoredSelectedIds));
+                    this.pendingRestoredSelectedIds = null;
+                    justRestoredSelection = true;
+                }
+
                 // Restore native AG selection for every visible data row from selectedRowIds —
                 // the definitive source of truth, independent of collapse state. Read untracked:
                 // this effect must only re-run on data/groupCols/collapsedPaths/groupColSort
@@ -1007,6 +1314,8 @@ export class KbqAgGridRowGroup {
                         true
                     );
                 }
+
+                if (justRestoredSelection) this.emitSelectionChanged();
             },
             { allowSignalWrites: true }
         );
@@ -1073,63 +1382,53 @@ export class KbqAgGridRowGroup {
             api.refreshHeader();
         });
 
-        this.grid.gridReady.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(({ api }) => {
-            this.originalColDefs = api.getColumnDefs() ?? [];
-            this.dataColIdToField = collectDataColIdToField(this.originalColDefs);
+        // Persists collapsedPaths whenever it changes (see kbqAgGridRowGroupCollapsedState). Gated on
+        // `api()` being set — same as every other effect above — so this never fires with the
+        // pre-restore default collapsedPaths before onGridReady has applied a stored value: by
+        // the time api() becomes non-null, restore has already run (see onGridReady).
+        effect(() => {
+            const api = this.api();
+            if (!api) return;
 
-            // Group rows are non-selectable — their state lives in groupSelectionState.
-            // Prefer the non-deprecated rowSelection object form when available; fall back
-            // to the legacy setGridOption('isRowSelectable') only for string / absent config.
-            const rowSelection = api.getGridOption('rowSelection');
-            if (rowSelection && typeof rowSelection !== 'string') {
-                // Merge into the existing rowSelection object so user-supplied options are preserved.
-                // checkboxes:false for group rows suppresses AG Grid's own native selection-column
-                // checkbox entirely (rather than just disabling it), so only our custom
-                // group-cell-renderer checkbox is shown in that cell. headerCheckbox:false does the
-                // same for the header "select all" checkbox — AG's own only knows about currently
-                // visible rows and disables itself while any group is collapsed; our own custom one
-                // (see makeSelectionColumnDef) accounts for the full, uncollapsed dataset instead.
-                const originalCheckboxes = rowSelection.checkboxes;
-                const mergedSelection = {
-                    ...rowSelection,
-                    isRowSelectable: ((node: IRowNode<Row>) =>
-                        !isGroupHeaderRow(node.data)) as typeof rowSelection.isRowSelectable,
-                    checkboxes: ((params: CheckboxSelectionCallbackParams<Row>) => {
-                        if (isGroupHeaderRow(params.data)) return false;
-                        return typeof originalCheckboxes === 'function'
-                            ? originalCheckboxes(params)
-                            : (originalCheckboxes ?? true);
-                    }) as typeof rowSelection.checkboxes,
-                    hideDisabledCheckboxes: true,
-                    // headerCheckbox only exists on multiRow selection options.
-                    ...(rowSelection.mode === 'multiRow' ? { headerCheckbox: false } : {})
-                };
-                api.setGridOption('rowSelection', mergedSelection);
+            const key = this.collapsedStateKey();
+            if (!key) return;
+
+            // Nothing meaningful for a collapsed path to refer to without a grouping structure
+            // — and clearGroupColumns() already removes any previously-stored state itself.
+            if (this.groupCols().length === 0) return;
+
+            void this.collapsedStateStore().setItem(key, [...this.collapsedPaths()]);
+        });
+
+        // Persists selectedRowIds whenever it changes (see kbqAgGridRowGroupSelectionState).
+        // Unlike the collapsedPaths persist effect above, gating on `api()` alone isn't enough
+        // here: onGridReady only *stages* a restored selection in pendingRestoredSelectedIds —
+        // applying it is deferred to the "update rowData" effect until data() is non-empty (see
+        // there). If this effect ran in between (api() set, but data() still []), it would see
+        // the still-default-empty selectedRowIds() and call removeItem(key), wiping the very
+        // selection that's waiting to be applied — permanently, for a URL-based store, if data
+        // never actually arrives. Deferring this effect the same way sidesteps that entirely.
+        effect(() => {
+            const api = this.api();
+            if (!api) return;
+
+            const key = this.selectionStateKey();
+            if (!key) return;
+
+            if (this.pendingRestoredSelectedIds !== null) return;
+
+            const selected = this.selectedRowIds();
+            if (selected.size === 0) {
+                void this.selectionStateStore().removeItem(key);
             } else {
-                api.setGridOption('isRowSelectable', (node: IRowNode<Row>) => !isGroupHeaderRow(node.data));
+                void this.selectionStateStore().setItem(key, [...selected]);
             }
-            // Render the custom group checkbox in the shared selection column so it lines up
-            // with the native row-selection checkboxes instead of sitting inside the group cell.
-            // Merged onto whatever's already there (the consumer's own [selectionColumnDef]
-            // input, or KbqAgGridTheme's default width) rather than replacing it outright, so
-            // neither is silently discarded regardless of which directive's gridReady handler
-            // runs first — see KbqAgGridTheme.applyDefaultSelectionColumnWidth for the other half.
-            api.setGridOption('selectionColumnDef', {
-                ...api.getGridOption('selectionColumnDef'),
-                ...this.makeSelectionColumnDef()
-            });
-            // Group rows are never truly selected via AG Grid's own API (isRowSelectable is
-            // false for them), so apply AG's `ag-row-selected` row class ourselves, driven by
-            // groupSelectionState, to get the same visual highlight as real selected rows.
-            api.setGridOption('rowClassRules', this.makeRowClassRules());
-            queueMicrotask(() => {
-                if (this.groupCols().length > 0) {
-                    this.needsInitialCollapse = true;
-                }
-                this.api.set(api);
-            });
         });
 
+        this.grid.gridReady
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(({ api }) => void this.onGridReady(api));
+
         this.grid.rowSelected.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(({ node }) => {
             // Skip events caused by our own programmatic setSelected calls.
             if (this.programmaticallySetNodes.has(node)) {
@@ -1206,6 +1505,84 @@ export class KbqAgGridRowGroup {
         });
     }
 
+    /** Runs once per grid instance on `gridReady` — sets up group-aware row selection, the
+     * shared selection column's group checkbox, group row styling, and (if
+     * `kbqAgGridRowGroupCollapsedState` is set) restores previously-collapsed groups before the initial
+     * rowData build. See the class-level `**Persisting collapsed/expanded state**` note. */
+    private async onGridReady(api: GridApi): Promise<void> {
+        this.originalColDefs = api.getColumnDefs() ?? [];
+        this.dataColIdToField = collectDataColIdToField(this.originalColDefs);
+
+        // Group rows are non-selectable — their state lives in groupSelectionState.
+        // Prefer the non-deprecated rowSelection object form when available; fall back
+        // to the legacy setGridOption('isRowSelectable') only for string / absent config.
+        const rowSelection = api.getGridOption('rowSelection');
+        if (rowSelection && typeof rowSelection !== 'string') {
+            // Merge into the existing rowSelection object so user-supplied options are preserved.
+            // checkboxes:false for group rows suppresses AG Grid's own native selection-column
+            // checkbox entirely (rather than just disabling it), so only our custom
+            // group-cell-renderer checkbox is shown in that cell. headerCheckbox:false does the
+            // same for the header "select all" checkbox — AG's own only knows about currently
+            // visible rows and disables itself while any group is collapsed; our own custom one
+            // (see makeSelectionColumnDef) accounts for the full, uncollapsed dataset instead.
+            const originalCheckboxes = rowSelection.checkboxes;
+            const mergedSelection = {
+                ...rowSelection,
+                isRowSelectable: ((node: IRowNode<Row>) =>
+                    !isGroupHeaderRow(node.data)) as typeof rowSelection.isRowSelectable,
+                checkboxes: ((params: CheckboxSelectionCallbackParams<Row>) => {
+                    if (isGroupHeaderRow(params.data)) return false;
+                    return typeof originalCheckboxes === 'function'
+                        ? originalCheckboxes(params)
+                        : (originalCheckboxes ?? true);
+                }) as typeof rowSelection.checkboxes,
+                hideDisabledCheckboxes: true,
+                // headerCheckbox only exists on multiRow selection options.
+                ...(rowSelection.mode === 'multiRow' ? { headerCheckbox: false } : {})
+            };
+            api.setGridOption('rowSelection', mergedSelection);
+        } else {
+            api.setGridOption('isRowSelectable', (node: IRowNode<Row>) => !isGroupHeaderRow(node.data));
+        }
+        // Render the custom group checkbox in the shared selection column so it lines up
+        // with the native row-selection checkboxes instead of sitting inside the group cell.
+        // Merged onto whatever's already there (the consumer's own [selectionColumnDef]
+        // input, or KbqAgGridTheme's default width) rather than replacing it outright, so
+        // neither is silently discarded regardless of which directive's gridReady handler
+        // runs first — see KbqAgGridTheme.applyDefaultSelectionColumnWidth for the other half.
+        api.setGridOption('selectionColumnDef', {
+            ...api.getGridOption('selectionColumnDef'),
+            ...this.makeSelectionColumnDef()
+        });
+        // Group rows are never truly selected via AG Grid's own API (isRowSelectable is
+        // false for them), so apply AG's `ag-row-selected` row class ourselves, driven by
+        // groupSelectionState, to get the same visual highlight as real selected rows.
+        api.setGridOption('rowClassRules', this.makeRowClassRules());
+
+        // Load any previously-persisted collapse/selection state before the first rowData build
+        // (below, via api.set(api)) — a no-op (stays null) when the respective key isn't set, so
+        // these awaits are skipped entirely and the rest of this method still runs synchronously.
+        const key = this.collapsedStateKey();
+        const restoredPaths = key ? await this.collapsedStateStore().getItem(key) : null;
+
+        const selectionKey = this.selectionStateKey();
+        const restoredSelectedIds = selectionKey ? await this.selectionStateStore().getItem(selectionKey) : null;
+
+        queueMicrotask(() => {
+            if (restoredPaths) {
+                this._collapsedPaths.set(new Set(restoredPaths));
+            } else if (this.groupCols().length > 0) {
+                this.needsInitialCollapse = true;
+            }
+            // Staged rather than applied directly — data() can still be [] here (e.g. an async
+            // HTTP fetch feeding [kbqAgGridRowGroupRowData] hasn't resolved yet), and the
+            // "update rowData" effect applies this once data is confirmed non-empty (see
+            // pendingRestoredSelectedIds there).
+            this.pendingRestoredSelectedIds = restoredSelectedIds;
+            this.api.set(api);
+        });
+    }
+
     /** Returns `true` if the group at `path` is currently collapsed. */
     isCollapsed(path: string): boolean {
         return this.collapsedPaths().has(path);
@@ -1392,10 +1769,15 @@ export class KbqAgGridRowGroup {
         this.groupCols.set(cols);
     }
 
-    /** Removes all group columns, returning the grid to a flat (ungrouped) view. */
+    /** Removes all group columns, returning the grid to a flat (ungrouped) view. Also removes
+     * any persisted collapse state (see `kbqAgGridRowGroupCollapsedState`) — with no grouping structure
+     * there's nothing meaningful left for a stored collapsed path to refer to. */
     clearGroupColumns(): void {
         this.groupCols.set([]);
         this._collapsedPaths.set(new Set());
+
+        const key = this.collapsedStateKey();
+        if (key) void this.collapsedStateStore().removeItem(key);
     }
 
     private makeGroupColDef(): ColDef {
diff --git a/packages/ag-grid-angular-theme/src/row-selection-state.ng.ts b/packages/ag-grid-angular-theme/src/row-selection-state.ng.ts
new file mode 100644
index 0000000..f149c07
--- /dev/null
+++ b/packages/ag-grid-angular-theme/src/row-selection-state.ng.ts
@@ -0,0 +1,227 @@
+import { DestroyRef, Directive, inject, Injectable, InjectionToken, input, Provider, Type } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Router } from '@angular/router';
+import { AgGridAngular } from 'ag-grid-angular';
+import { AgEventListener, GridApi, IRowNode } from 'ag-grid-community';
+import { KbqAgGridStateStore } from './state-store';
+
+/**
+ * Storage interface for persisting and retrieving ag-grid row selection state.
+ *
+ * Supports both synchronous and Promise-based implementations.
+ */
+export type KbqAgGridRowSelectionStateStore = KbqAgGridStateStore<string[]>;
+
+/**
+ * {@link KbqAgGridRowSelectionStateStore} implementation backed by `localStorage`.
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowSelectionStateLocalStorageStore implements KbqAgGridRowSelectionStateStore {
+    // TODO: Should use KBQ_WINDOW token
+    private readonly localStorage = window.localStorage;
+
+    getItem(key: string): string[] | null {
+        const item = this.localStorage.getItem(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as string[];
+        } catch {
+            return null;
+        }
+    }
+
+    setItem(key: string, value: string[]): void {
+        this.localStorage.setItem(key, JSON.stringify(value));
+    }
+
+    removeItem(key: string): void {
+        this.localStorage.removeItem(key);
+    }
+}
+
+/**
+ * {@link KbqAgGridRowSelectionStateStore} implementation backed by URL query parameters.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowSelectionStateStoreProvider(KbqAgGridRowSelectionStateQueryParamsStore)]
+ * ```
+ */
+@Injectable({ providedIn: 'root' })
+export class KbqAgGridRowSelectionStateQueryParamsStore implements KbqAgGridRowSelectionStateStore {
+    private readonly router = inject(Router);
+    // TODO: Should use KBQ_WINDOW token
+    private readonly location = window.location;
+
+    getItem(key: string): string[] | null {
+        const item = new URLSearchParams(this.location.search).get(key);
+
+        if (!item) return null;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(item) as string[];
+        } catch {
+            return null;
+        }
+    }
+
+    async setItem(key: string, value: string[]): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: JSON.stringify(value) },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+
+    async removeItem(key: string): Promise<void> {
+        await this.router.navigate([], {
+            queryParams: { [key]: null },
+            queryParamsHandling: 'merge',
+            replaceUrl: true
+        });
+    }
+}
+
+/**
+ * Injection token for {@link KbqAgGridRowSelectionStateStore}.
+ *
+ * Defaults to {@link KbqAgGridRowSelectionStateLocalStorageStore}.
+ * Override it with {@link kbqAgGridRowSelectionStateStoreProvider}.
+ */
+export const KBQ_AG_GRID_ROW_SELECTION_STATE_STORE = new InjectionToken<KbqAgGridRowSelectionStateStore>(
+    'KBQ_AG_GRID_ROW_SELECTION_STATE_STORE',
+    { factory: (): KbqAgGridRowSelectionStateStore => inject(KbqAgGridRowSelectionStateLocalStorageStore) }
+);
+
+/**
+ * Creates an Angular {@link Provider} that binds {@link KBQ_AG_GRID_ROW_SELECTION_STATE_STORE}
+ * to the given store class or instance.
+ *
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowSelectionStateStoreProvider(KbqAgGridRowSelectionStateQueryParamsStore)]
+ * ```
+ * @example
+ * ```typescript
+ * providers: [kbqAgGridRowSelectionStateStoreProvider(myCustomStoreInstance)]
+ * ```
+ */
+export const kbqAgGridRowSelectionStateStoreProvider = (
+    store: Type<KbqAgGridRowSelectionStateStore> | KbqAgGridRowSelectionStateStore
+): Provider => {
+    return store instanceof Type
+        ? { provide: KBQ_AG_GRID_ROW_SELECTION_STATE_STORE, useClass: store }
+        : { provide: KBQ_AG_GRID_ROW_SELECTION_STATE_STORE, useValue: store };
+};
+
+/**
+ * Directive that persists and restores ag-grid row selection state
+ * using a configurable {@link KbqAgGridRowSelectionStateStore}.
+ *
+ * Requires `getRowId` to be set in `gridOptions` so row identity survives a page reload —
+ * without it, ag-grid assigns row ids internally and restored ids will not match any row.
+ *
+ * @example
+ * ```html
+ * <ag-grid-angular kbqAgGridTheme
+ *                  [getRowId]="getRowId"
+ *                  [kbqAgGridRowSelectionState]="'rows-selection-state'"
+ *                  [kbqAgGridRowSelectionStateStore]="myRowSelectionStore" />
+ * ```
+ */
+@Directive({
+    standalone: true,
+    selector: 'ag-grid-angular[kbqAgGridRowSelectionState]',
+    exportAs: 'kbqAgGridRowSelectionState'
+})
+export class KbqAgGridRowSelectionState {
+    private readonly grid = inject(AgGridAngular);
+    private readonly destroyRef = inject(DestroyRef);
+
+    /** Key under which row selection state is stored. Must be unique per grid. */
+    readonly key = input.required<string>({ alias: 'kbqAgGridRowSelectionState' });
+
+    /** Store used to persist and restore row selection state. Defaults to {@link KBQ_AG_GRID_ROW_SELECTION_STATE_STORE}. */
+    readonly store = input(inject(KBQ_AG_GRID_ROW_SELECTION_STATE_STORE), {
+        alias: 'kbqAgGridRowSelectionStateStore'
+    });
+
+    constructor() {
+        this.grid.gridReady.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(({ api }) => this.init(api));
+    }
+
+    /** Removes the stored row selection state for the current key and clears the current selection. */
+    reset(): void {
+        const store = this.store();
+        const key = this.key();
+
+        void store.removeItem(key);
+        this.grid.api.deselectAll();
+    }
+
+    private init(api: GridApi): void {
+        const key = this.key();
+        const store = this.store();
+
+        const restore: AgEventListener = () => void this.restore(api, key, store);
+
+        // Row nodes only exist once data has actually been rendered, so restoring selection has
+        // to wait for `firstDataRendered` rather than running straight after `gridReady`.
+        api.addEventListener('firstDataRendered', restore);
+
+        const save: AgEventListener<unknown, unknown, 'selectionChanged'> = (event) => {
+            // Skips saves triggered by our own restore call to avoid redundant writes.
+            if (event.source === 'api') return;
+
+            const ids = api
+                .getSelectedNodes()
+                .map((node) => node.id)
+                .filter((id): id is string => id !== undefined);
+
+            if (ids.length === 0) {
+                void store.removeItem(key);
+            } else {
+                void store.setItem(key, ids);
+            }
+        };
+
+        api.addEventListener('selectionChanged', save);
+
+        this.destroyRef.onDestroy(() => {
+            api.removeEventListener('firstDataRendered', restore);
+            api.removeEventListener('selectionChanged', save);
+        });
+    }
+
+    private async restore(api: GridApi, key: string, store: KbqAgGridRowSelectionStateStore): Promise<void> {
+        const ids = await store.getItem(key);
+        const idSet = new Set(ids ?? []);
+
+        // Persisted selection is the source of truth — reconcile the grid's current selection to
+        // match it exactly, rather than only adding matches. Only adding would leave any
+        // pre-existing selection (e.g. a default rowSelection config, or a click that raced ahead
+        // of firstDataRendered) stuck selected alongside the restored rows.
+        const toSelect: IRowNode[] = [];
+        const toDeselect: IRowNode[] = [];
+
+        api.forEachNode((node) => {
+            const shouldBeSelected = node.id !== undefined && idSet.has(node.id);
+            if (shouldBeSelected && !node.isSelected()) {
+                toSelect.push(node);
+            } else if (!shouldBeSelected && node.isSelected()) {
+                toDeselect.push(node);
+            }
+        });
+
+        if (toDeselect.length > 0) {
+            api.setNodesSelected({ nodes: toDeselect, newValue: false, source: 'api' });
+        }
+        if (toSelect.length > 0) {
+            api.setNodesSelected({ nodes: toSelect, newValue: true, source: 'api' });
+        }
+    }
+}
diff --git a/packages/ag-grid-angular-theme/tests/row-focus-state.ng.spec.ts b/packages/ag-grid-angular-theme/tests/row-focus-state.ng.spec.ts
new file mode 100644
index 0000000..cb37055
--- /dev/null
+++ b/packages/ag-grid-angular-theme/tests/row-focus-state.ng.spec.ts
@@ -0,0 +1,308 @@
+import { Component, Directive, forwardRef, viewChild } from '@angular/core';
+import { render, waitFor } from '@testing-library/angular';
+import { AgGridAngular } from 'ag-grid-angular';
+import { AgEventType, GridApi, IRowNode } from 'ag-grid-community';
+import { Subject } from 'rxjs';
+import {
+    KbqAgGridRowFocusState,
+    KbqAgGridRowFocusStateStore,
+    KbqAgGridRowFocusStateValue
+} from '../src/row-focus-state.ng';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyEventHandler = (event?: any) => void;
+
+const makeNode = (id: string, rowIndex: number | null): IRowNode => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return { id, rowIndex } as unknown as IRowNode;
+};
+
+const createApiMock = (
+    nodesById: Record<string, IRowNode> = {},
+    nodesByIndex: Record<number, IRowNode> = {}
+): {
+    api: GridApi;
+    dispatch: (eventName: AgEventType, event?: object) => void;
+} => {
+    const listeners = new Map<AgEventType, AnyEventHandler[]>();
+
+    const api = {
+        addEventListener: jest.fn((eventName: AgEventType, handler: AnyEventHandler) => {
+            const eventListeners = listeners.get(eventName) ?? [];
+            eventListeners.push(handler);
+            listeners.set(eventName, eventListeners);
+        }),
+        removeEventListener: jest.fn((eventName: AgEventType, handler: AnyEventHandler) => {
+            const eventListeners = listeners.get(eventName) ?? [];
+            listeners.set(
+                eventName,
+                eventListeners.filter((listener) => listener !== handler)
+            );
+        }),
+        getRowNode: jest.fn((id: string) => nodesById[id]),
+        getDisplayedRowAtIndex: jest.fn((index: number) => nodesByIndex[index]),
+        setFocusedCell: jest.fn(),
+        clearFocusedCell: jest.fn()
+    };
+
+    const dispatch = (eventName: AgEventType, event?: object): void => {
+        const eventListeners = listeners.get(eventName) ?? [];
+        eventListeners.forEach((listener) => listener(event));
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return { api: api as unknown as GridApi, dispatch };
+};
+
+@Directive({
+    selector: 'ag-grid-angular',
+    standalone: true,
+    providers: [{ provide: AgGridAngular, useExisting: forwardRef(() => TestAgGridAngularStub) }]
+})
+class TestAgGridAngularStub {
+    readonly gridReady = new Subject<{ api: GridApi }>();
+    readonly api = createApiMock().api;
+
+    emitGridReady(api: GridApi = this.api): void {
+        this.gridReady.next({ api });
+    }
+}
+
+@Component({
+    selector: 'test-row-focus-state-grid',
+    standalone: true,
+    template: `
+        <ag-grid-angular [kbqAgGridRowFocusState]="key" [kbqAgGridRowFocusStateStore]="store" />
+    `,
+    imports: [TestAgGridAngularStub, KbqAgGridRowFocusState]
+})
+class TestRowFocusStateGrid {
+    key = 'row-focus';
+    store: KbqAgGridRowFocusStateStore = {
+        getItem: () => null,
+        setItem: () => undefined,
+        removeItem: () => undefined
+    };
+
+    readonly grid = viewChild.required(TestAgGridAngularStub);
+    readonly directive = viewChild.required(KbqAgGridRowFocusState);
+}
+
+describe(KbqAgGridRowFocusState.name, () => {
+    it('restores saved active cell from store on firstDataRendered', async () => {
+        const savedValue: KbqAgGridRowFocusStateValue = { rowId: 'b', colId: 'athlete' };
+        const nodeB = makeNode('b', 1);
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => savedValue),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock({ b: nodeB });
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-1', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(store.getItem).toHaveBeenCalledWith('grid-row-focus-1');
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.setFocusedCell).toHaveBeenCalledWith(1, 'athlete');
+        });
+    });
+
+    it('does not focus anything when store returns null', async () => {
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock();
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-2', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(store.getItem).toHaveBeenCalledWith('grid-row-focus-2');
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.setFocusedCell).not.toHaveBeenCalled();
+        });
+    });
+
+    it('does not restore when the saved row id no longer resolves to a row index', async () => {
+        const savedValue: KbqAgGridRowFocusStateValue = { rowId: 'missing', colId: 'athlete' };
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => savedValue),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock();
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-3', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(store.getItem).toHaveBeenCalledWith('grid-row-focus-3');
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.setFocusedCell).not.toHaveBeenCalled();
+        });
+    });
+
+    it('saves the active cell on cellFocused', async () => {
+        const nodeA = makeNode('a', 0);
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock({}, { 0: nodeA });
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-4', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('cellFocused', expect.any(Function));
+        });
+
+        apiMock.dispatch('cellFocused', {
+            rowIndex: 0,
+            rowPinned: null,
+            column: { getColId: () => 'athlete' }
+        });
+
+        await waitFor(() => {
+            expect(store.setItem).toHaveBeenCalledWith('grid-row-focus-4', { rowId: 'a', colId: 'athlete' });
+        });
+    });
+
+    it('removes stored state when focus moves to a pinned row', async () => {
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock();
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-5', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('cellFocused', expect.any(Function));
+        });
+
+        apiMock.dispatch('cellFocused', {
+            rowIndex: 0,
+            rowPinned: 'top',
+            column: { getColId: () => 'athlete' }
+        });
+
+        await waitFor(() => {
+            expect(store.removeItem).toHaveBeenCalledWith('grid-row-focus-5');
+            expect(store.setItem).not.toHaveBeenCalled();
+        });
+    });
+
+    it('does not resave the cell focused as a result of its own restore call', async () => {
+        const savedValue: KbqAgGridRowFocusStateValue = { rowId: 'b', colId: 'athlete' };
+        const nodeB = makeNode('b', 1);
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => savedValue),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock({ b: nodeB }, { 1: nodeB });
+
+        // setFocusedCell dispatches `cellFocused` synchronously, mirroring real ag-grid behavior.
+        jest.spyOn(apiMock.api, 'setFocusedCell').mockImplementation((rowIndex, colKey) => {
+            apiMock.dispatch('cellFocused', { rowIndex, rowPinned: null, column: { getColId: () => colKey } });
+        });
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-6', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.setFocusedCell).toHaveBeenCalledWith(1, 'athlete');
+        });
+
+        expect(store.setItem).not.toHaveBeenCalled();
+    });
+
+    it('reset removes stored state and clears grid focus', async () => {
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-7', store }
+        });
+
+        fixture.componentInstance.directive().reset();
+
+        expect(store.removeItem).toHaveBeenCalledWith('grid-row-focus-7');
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(fixture.componentInstance.grid().api.clearFocusedCell).toHaveBeenCalled();
+    });
+
+    it('removes all event listeners on destroy', async () => {
+        const store: KbqAgGridRowFocusStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock();
+
+        const { fixture } = await render(TestRowFocusStateGrid, {
+            componentProperties: { key: 'grid-row-focus-8', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('cellFocused', expect.any(Function));
+        });
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-type-assertion
+        const addEventListenerMock = apiMock.api.addEventListener as unknown as jest.MockedFunction<
+            typeof apiMock.api.addEventListener
+        >;
+
+        const getHandler = (eventName: AgEventType): AnyEventHandler | undefined =>
+            addEventListenerMock.mock.calls.find(([name]) => name === eventName)?.[1];
+
+        fixture.destroy();
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(apiMock.api.removeEventListener).toHaveBeenCalledWith(
+            'firstDataRendered',
+            getHandler('firstDataRendered')
+        );
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(apiMock.api.removeEventListener).toHaveBeenCalledWith('cellFocused', getHandler('cellFocused'));
+    });
+});
diff --git a/packages/ag-grid-angular-theme/tests/row-group.ng.spec.ts b/packages/ag-grid-angular-theme/tests/row-group.ng.spec.ts
index d855f8f..4bb2d4e 100644
--- a/packages/ag-grid-angular-theme/tests/row-group.ng.spec.ts
+++ b/packages/ag-grid-angular-theme/tests/row-group.ng.spec.ts
@@ -6,8 +6,10 @@ import { Subject } from 'rxjs';
 import {
     KbqAgGridRowGroup,
     KbqAgGridRowGroupCellContent,
+    KbqAgGridRowGroupCollapsedStateStore,
     KbqAgGridRowGroupInfo,
-    KbqAgGridRowGroupRowId
+    KbqAgGridRowGroupRowId,
+    KbqAgGridRowGroupSelectionStateStore
 } from '../src/row-group.ng';
 
 /** Shared row id extractor bound on every test host below — resolves each row's `id` field. */
@@ -295,6 +297,74 @@ const setupWithGroups = async () => {
     return result;
 };
 
+@Component({
+    selector: 'test-row-group-state-grid',
+    standalone: true,
+    template: `
+        <ag-grid-angular
+            kbqAgGridRowGroup
+            [kbqAgGridRowGroupRowData]="rowData()"
+            [kbqAgGridRowGroupRowId]="testRowId"
+            [kbqAgGridRowGroupCollapsedState]="collapsedStateKey"
+            [kbqAgGridRowGroupCollapsedStateStore]="store"
+            [kbqAgGridRowGroupSelectionState]="selectionStateKey"
+            [kbqAgGridRowGroupSelectionStateStore]="selectionStore"
+            [(kbqAgGridRowGroupCols)]="groupCols"
+        />
+    `,
+    imports: [TestAgGridAngularStub, KbqAgGridRowGroup]
+})
+class TestRowGroupStateGrid {
+    collapsedStateKey = 'row-group-state';
+    store: KbqAgGridRowGroupCollapsedStateStore = {
+        getItem: () => null,
+        setItem: () => undefined,
+        removeItem: () => undefined
+    };
+    selectionStateKey: string | undefined = undefined;
+    selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+        getItem: () => null,
+        setItem: () => undefined,
+        removeItem: () => undefined
+    };
+    readonly rowData = signal<Record<string, unknown>[]>([]);
+    readonly groupCols = signal<string[]>([]);
+    readonly grid = viewChild.required(TestAgGridAngularStub);
+    readonly directive = viewChild.required(KbqAgGridRowGroup);
+    protected readonly testRowId = testRowId;
+}
+
+/** Mirrors `setup()`, but for `TestRowGroupStateGrid` — lets each test configure `collapsedStateKey`,
+ * `store`, and pre-gridReady `groupCols` (simulating the consumer having already restored
+ * grouping fields themselves, as the class-level `**Persisting collapsed/expanded state**`
+ * note recommends) before `emitGridReady()` fires. */
+const setupWithState = async (params: {
+    data?: Record<string, unknown>[];
+    key?: string;
+    store: KbqAgGridRowGroupCollapsedStateStore;
+    selectionKey?: string;
+    selectionStore?: KbqAgGridRowGroupSelectionStateStore;
+    groupCols?: string[];
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+}) => {
+    const { fixture } = await render(TestRowGroupStateGrid, {
+        componentProperties: {
+            collapsedStateKey: params.key ?? 'row-group-state',
+            store: params.store,
+            ...(params.selectionKey !== undefined ? { selectionStateKey: params.selectionKey } : {}),
+            ...(params.selectionStore ? { selectionStore: params.selectionStore } : {})
+        }
+    });
+    fixture.componentInstance.rowData.set(params.data ?? DATA);
+    if (params.groupCols) fixture.componentInstance.groupCols.set(params.groupCols);
+    // Propagate the two-way `[(kbqAgGridRowGroupCols)]` binding into the directive's own model
+    // signal before gridReady — the host/directive signals only sync during change detection.
+    fixture.detectChanges();
+    const grid = fixture.componentInstance.grid();
+    grid.emitGridReady();
+    return { fixture, grid, directive: fixture.componentInstance.directive() };
+};
+
 describe(KbqAgGridRowGroup.name, () => {
     afterEach(() => {
         testColDefs = INITIAL_COL_DEFS;
@@ -1875,4 +1945,370 @@ describe(KbqAgGridRowGroup.name, () => {
             expect(emitted.map((row) => String(row.id))).toEqual(['1']);
         });
     });
+
+    describe('collapsed state persistence', () => {
+        it('restores collapsed paths from the store on init when groupCols already matches', async () => {
+            const storedPaths = [groupPath('USA')];
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => storedPaths),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive } = await setupWithState({
+                key: 'grid-row-group-state-1',
+                store,
+                groupCols: ['country']
+            });
+
+            await waitFor(() => {
+                expect(store.getItem).toHaveBeenCalledWith('grid-row-group-state-1');
+                expect(directive.collapsedPaths()).toEqual(new Set(storedPaths));
+            });
+        });
+
+        it('falls back to the default top-level auto-collapse when the store returns null', async () => {
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive, grid, fixture } = await setupWithState({
+                key: 'grid-row-group-state-2',
+                store,
+                groupCols: ['country']
+            });
+
+            await waitFor(() => expect(store.getItem).toHaveBeenCalledWith('grid-row-group-state-2'));
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => isGroupHeader(n.data)));
+
+            expect(directive.collapsedPaths()).toEqual(new Set([groupPath('USA'), groupPath('GBR')]));
+        });
+
+        it('a restored path is inert once groupCols no longer matches what it was saved under', async () => {
+            const storedPaths = [groupPath('USA')];
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => storedPaths),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            // groupCols is left at its default ([]) — simulates a consumer that restores
+            // collapsedPaths via the store but doesn't also restore the grouping fields
+            // themselves (see the class-level "Persisting collapsed/expanded state" note).
+            const { directive, grid } = await setupWithState({ key: 'grid-row-group-state-x', store });
+
+            await waitFor(() => {
+                expect(store.getItem).toHaveBeenCalled();
+                expect(directive.collapsedPaths()).toEqual(new Set(storedPaths));
+            });
+            // With no matching grouping structure, rows pass through flat — the restored path
+            // has nothing to apply to.
+            expect(grid.mock.nodes.every((n) => !isGroupHeader(n.data))).toBe(true);
+        });
+
+        it('saves collapsedPaths to the store when a group is toggled', async () => {
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive, grid, fixture } = await setupWithState({
+                key: 'grid-row-group-state-3',
+                store,
+                groupCols: ['country']
+            });
+            // groupCols was already set at gridReady, so the default top-level auto-collapse
+            // (no stored value to restore) starts every top-level group collapsed — expand
+            // everything first so the toggle below has an unambiguous, single-path effect.
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => isGroupHeader(n.data)));
+            directive.expandAll();
+
+            directive.toggleCollapse(groupPath('USA'));
+
+            await waitFor(() => {
+                expect(store.setItem).toHaveBeenCalledWith('grid-row-group-state-3', [groupPath('USA')]);
+            });
+        });
+
+        it('persists an empty array when everything is expanded, rather than removing the item', async () => {
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive, grid, fixture } = await setupWithState({
+                key: 'grid-row-group-state-4',
+                store,
+                groupCols: ['country']
+            });
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => isGroupHeader(n.data)));
+
+            directive.expandAll();
+
+            await waitFor(() => {
+                expect(store.setItem).toHaveBeenCalledWith('grid-row-group-state-4', []);
+            });
+            expect(store.removeItem).not.toHaveBeenCalled();
+        });
+
+        it('does not persist while ungrouped', async () => {
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            await setupWithState({ key: 'grid-row-group-state-5', store });
+
+            await waitFor(() => expect(store.getItem).toHaveBeenCalled());
+            expect(store.setItem).not.toHaveBeenCalled();
+        });
+
+        it('clearGroupColumns removes the stored state', async () => {
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive, grid, fixture } = await setupWithState({
+                key: 'grid-row-group-state-6',
+                store,
+                groupCols: ['country']
+            });
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => isGroupHeader(n.data)));
+
+            directive.clearGroupColumns();
+
+            expect(store.removeItem).toHaveBeenCalledWith('grid-row-group-state-6');
+        });
+
+        it('supports async store methods', async () => {
+            const storedPaths = [groupPath('USA')];
+            const store: KbqAgGridRowGroupCollapsedStateStore = {
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                getItem: jest.fn(() => Promise.resolve(storedPaths)),
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                setItem: jest.fn(() => Promise.resolve(undefined)),
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                removeItem: jest.fn(() => Promise.resolve(undefined))
+            };
+
+            const { directive } = await setupWithState({
+                key: 'grid-row-group-state-7',
+                store,
+                groupCols: ['country']
+            });
+
+            await waitFor(() => {
+                expect(directive.collapsedPaths()).toEqual(new Set(storedPaths));
+            });
+        });
+    });
+
+    describe('selection persistence', () => {
+        const noopStateStore: KbqAgGridRowGroupCollapsedStateStore = {
+            getItem: () => null,
+            setItem: () => undefined,
+            removeItem: () => undefined
+        };
+
+        it('restores selected row ids from the store on init, including native node selection', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                getItem: jest.fn(() => ['1']),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive, grid, fixture } = await setupWithState({
+                key: 'grid-row-group-selection-1',
+                store: noopStateStore,
+                selectionKey: 'grid-row-group-selection-1-sel',
+                selectionStore,
+                groupCols: ['country']
+            });
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => isGroupHeader(n.data)));
+
+            expect(selectionStore.getItem).toHaveBeenCalledWith('grid-row-group-selection-1-sel');
+            expect(directive.overallSelectionState()).toBe('indeterminate');
+
+            // The default top-level auto-collapse (see "collapsed state persistence") hides row
+            // '1' inside a collapsed "USA" group initially — expand to materialize it as an AG
+            // node and confirm the restored selection was synced onto it.
+            directive.expandAll();
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => !isGroupHeader(n.data)));
+            const row1 = grid.mock.nodes.find((n) => n.data.id === '1')!;
+            expect(row1.isSelected()).toBe(true);
+        });
+
+        it('saves selectedRowIds to the store when setRowSelected is called', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive } = await setupWithState({
+                key: 'grid-row-group-selection-2',
+                store: noopStateStore,
+                selectionKey: 'grid-row-group-selection-2-sel',
+                selectionStore
+            });
+            await waitFor(() => expect(selectionStore.getItem).toHaveBeenCalled());
+
+            directive.setRowSelected('1', true);
+
+            await waitFor(() => {
+                expect(selectionStore.setItem).toHaveBeenCalledWith('grid-row-group-selection-2-sel', ['1']);
+            });
+        });
+
+        it('removes stored selection once everything is deselected', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive } = await setupWithState({
+                key: 'grid-row-group-selection-3',
+                store: noopStateStore,
+                selectionKey: 'grid-row-group-selection-3-sel',
+                selectionStore
+            });
+            await waitFor(() => expect(selectionStore.getItem).toHaveBeenCalled());
+
+            directive.setRowSelected('1', true);
+            await waitFor(() => expect(selectionStore.setItem).toHaveBeenCalled());
+
+            directive.setRowSelected('1', false);
+
+            await waitFor(() => {
+                expect(selectionStore.removeItem).toHaveBeenCalledWith('grid-row-group-selection-3-sel');
+            });
+        });
+
+        it('does not persist selection when no [kbqAgGridRowGroupSelectionState] key is bound', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            // selectionKey intentionally omitted — the directive's own default (undefined).
+            const { directive } = await setupWithState({
+                key: 'grid-row-group-selection-6',
+                store: noopStateStore,
+                selectionStore
+            });
+
+            directive.setRowSelected('1', true);
+
+            expect(selectionStore.getItem).not.toHaveBeenCalled();
+            expect(selectionStore.setItem).not.toHaveBeenCalled();
+        });
+
+        it('clearGroupColumns does not clear the persisted selection — selection is independent of grouping', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                getItem: jest.fn(() => null),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { directive, grid, fixture } = await setupWithState({
+                key: 'grid-row-group-selection-4',
+                store: noopStateStore,
+                selectionKey: 'grid-row-group-selection-4-sel',
+                selectionStore,
+                groupCols: ['country']
+            });
+            await waitForNodes(grid, fixture, (nodes) => nodes.some((n) => isGroupHeader(n.data)));
+
+            directive.setRowSelected('1', true);
+            await waitFor(() =>
+                expect(selectionStore.setItem).toHaveBeenCalledWith('grid-row-group-selection-4-sel', ['1'])
+            );
+
+            // removeItem legitimately fires once already on mount (empty selection at init,
+            // before setRowSelected above) — clear that baseline call so the assertion below
+            // is only about what clearGroupColumns() itself does.
+            jest.mocked(selectionStore.removeItem).mockClear();
+
+            directive.clearGroupColumns();
+
+            expect(selectionStore.removeItem).not.toHaveBeenCalled();
+        });
+
+        it('supports async selection store methods', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                getItem: jest.fn(() => Promise.resolve(['1', '2'])),
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                setItem: jest.fn(() => Promise.resolve(undefined)),
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                removeItem: jest.fn(() => Promise.resolve(undefined))
+            };
+
+            const { directive } = await setupWithState({
+                key: 'grid-row-group-selection-5',
+                store: noopStateStore,
+                selectionKey: 'grid-row-group-selection-5-sel',
+                selectionStore,
+                groupCols: ['country']
+            });
+
+            // DATA has 3 rows total; ids '1' and '2' (both 'USA') restored as selected — the
+            // third ('3', 'GBR') is not, so the overall selection is partial.
+            await waitFor(() => {
+                expect(directive.overallSelectionState()).toBe('indeterminate');
+            });
+        });
+
+        it('restores selection even when data arrives after gridReady, and notifies rowSelectionChanged once it does', async () => {
+            const selectionStore: KbqAgGridRowGroupSelectionStateStore = {
+                getItem: jest.fn(() => ['1']),
+                setItem: jest.fn(),
+                removeItem: jest.fn()
+            };
+
+            const { fixture } = await render(TestRowGroupStateGrid, {
+                componentProperties: {
+                    collapsedStateKey: 'grid-row-group-selection-late',
+                    store: noopStateStore,
+                    selectionStateKey: 'grid-row-group-selection-late-sel',
+                    selectionStore
+                }
+            });
+            const directive = fixture.componentInstance.directive();
+            const emitSpy = jest.spyOn(directive.rowSelectionChanged, 'emit');
+
+            // Emit gridReady BEFORE rowData is available — simulates an async HTTP response
+            // (e.g. devInjectRowData()) arriving after the grid has already initialized.
+            fixture.componentInstance.grid().emitGridReady();
+
+            // waitFor's macrotask-based polling flushes every pending microtask in between
+            // checks, so by the time this resolves onGridReady's queueMicrotask (which stages
+            // pendingRestoredSelectedIds) is guaranteed to have already run too.
+            await waitFor(() => expect(selectionStore.getItem).toHaveBeenCalled());
+            expect(emitSpy).not.toHaveBeenCalled();
+            // The persist effect must not treat the still-empty selectedRowIds() (data() is []
+            // at this point) as "nothing selected" and wipe the restore that's staged but not
+            // yet applied — this is the exact race the pendingRestoredSelectedIds guard prevents.
+            expect(selectionStore.removeItem).not.toHaveBeenCalled();
+
+            // Data arrives after the microtask (simulates the HTTP response resolving)
+            fixture.componentInstance.rowData.set(DATA);
+            fixture.detectChanges();
+
+            await waitFor(() => {
+                expect(emitSpy).toHaveBeenCalledTimes(1);
+                const [[emitted]] = emitSpy.mock.calls;
+                expect(emitted.map((row) => String(row.id))).toEqual(['1']);
+            });
+        });
+    });
 });
diff --git a/packages/ag-grid-angular-theme/tests/row-selection-state.ng.spec.ts b/packages/ag-grid-angular-theme/tests/row-selection-state.ng.spec.ts
new file mode 100644
index 0000000..43550a0
--- /dev/null
+++ b/packages/ag-grid-angular-theme/tests/row-selection-state.ng.spec.ts
@@ -0,0 +1,334 @@
+import { Component, Directive, forwardRef, viewChild } from '@angular/core';
+import { render, waitFor } from '@testing-library/angular';
+import { AgGridAngular } from 'ag-grid-angular';
+import { AgEventType, GridApi, IRowNode } from 'ag-grid-community';
+import { Subject } from 'rxjs';
+import { KbqAgGridRowSelectionState, KbqAgGridRowSelectionStateStore } from '../src/row-selection-state.ng';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyEventHandler = (event?: any) => void;
+
+const makeNode = (id: string, selected = false): IRowNode => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return {
+        id,
+        isSelected: () => selected,
+        setSelected: (value: boolean) => (selected = value)
+    } as unknown as IRowNode;
+};
+
+const createApiMock = (
+    nodes: IRowNode[] = []
+): {
+    api: GridApi;
+    dispatch: (eventName: AgEventType, event?: object) => void;
+} => {
+    const listeners = new Map<AgEventType, AnyEventHandler[]>();
+
+    const api = {
+        addEventListener: jest.fn((eventName: AgEventType, handler: AnyEventHandler) => {
+            const eventListeners = listeners.get(eventName) ?? [];
+            eventListeners.push(handler);
+            listeners.set(eventName, eventListeners);
+        }),
+        removeEventListener: jest.fn((eventName: AgEventType, handler: AnyEventHandler) => {
+            const eventListeners = listeners.get(eventName) ?? [];
+            listeners.set(
+                eventName,
+                eventListeners.filter((listener) => listener !== handler)
+            );
+        }),
+        forEachNode: jest.fn((callback: (node: IRowNode, index: number) => void) => {
+            nodes.forEach((node, index) => callback(node, index));
+        }),
+        setNodesSelected: jest.fn(({ nodes: selectedNodes, newValue }: { nodes: IRowNode[]; newValue: boolean }) => {
+            selectedNodes.forEach((node) => node.setSelected(newValue));
+        }),
+        getSelectedNodes: jest.fn(() => nodes.filter((node) => node.isSelected())),
+        deselectAll: jest.fn(() => nodes.forEach((node) => node.setSelected(false)))
+    };
+
+    const dispatch = (eventName: AgEventType, event?: object): void => {
+        const eventListeners = listeners.get(eventName) ?? [];
+        eventListeners.forEach((listener) => listener(event));
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return { api: api as unknown as GridApi, dispatch };
+};
+
+@Directive({
+    selector: 'ag-grid-angular',
+    standalone: true,
+    providers: [{ provide: AgGridAngular, useExisting: forwardRef(() => TestAgGridAngularStub) }]
+})
+class TestAgGridAngularStub {
+    readonly gridReady = new Subject<{ api: GridApi }>();
+    readonly api = createApiMock().api;
+
+    emitGridReady(api: GridApi = this.api): void {
+        this.gridReady.next({ api });
+    }
+}
+
+@Component({
+    selector: 'test-row-selection-state-grid',
+    standalone: true,
+    template: `
+        <ag-grid-angular [kbqAgGridRowSelectionState]="key" [kbqAgGridRowSelectionStateStore]="store" />
+    `,
+    imports: [TestAgGridAngularStub, KbqAgGridRowSelectionState]
+})
+class TestRowSelectionStateGrid {
+    key = 'row-selection';
+    store: KbqAgGridRowSelectionStateStore = {
+        getItem: () => null,
+        setItem: () => undefined,
+        removeItem: () => undefined
+    };
+
+    readonly grid = viewChild.required(TestAgGridAngularStub);
+    readonly directive = viewChild.required(KbqAgGridRowSelectionState);
+}
+
+describe(KbqAgGridRowSelectionState.name, () => {
+    it('restores saved selection from store on firstDataRendered', async () => {
+        const nodeA = makeNode('a');
+        const nodeB = makeNode('b');
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => ['b']),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock([nodeA, nodeB]);
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-1', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(store.getItem).toHaveBeenCalledWith('grid-row-selection-1');
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.setNodesSelected).toHaveBeenCalledWith({
+                nodes: [nodeB],
+                newValue: true,
+                source: 'api'
+            });
+        });
+    });
+
+    it('deselects a node that is selected but not in the persisted set', async () => {
+        // Simulates a default rowSelection config, or a click that raced ahead of
+        // firstDataRendered — either way, a node selected before restore runs that isn't part
+        // of the persisted set must not survive the restore.
+        const nodeA = makeNode('a', true);
+        const nodeB = makeNode('b');
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => ['b']),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock([nodeA, nodeB]);
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-stale', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(nodeA.isSelected()).toBe(false);
+            expect(nodeB.isSelected()).toBe(true);
+        });
+    });
+
+    it('clears a pre-existing selection when nothing is persisted', async () => {
+        const nodeA = makeNode('a', true);
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock([nodeA]);
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-clear', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(nodeA.isSelected()).toBe(false);
+        });
+    });
+
+    it('does not select anything when store returns null', async () => {
+        const nodeA = makeNode('a');
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock([nodeA]);
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-2', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+        apiMock.dispatch('firstDataRendered');
+
+        await waitFor(() => {
+            expect(store.getItem).toHaveBeenCalledWith('grid-row-selection-2');
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.setNodesSelected).not.toHaveBeenCalled();
+        });
+    });
+
+    it('saves selected row ids on non-api selectionChanged events', async () => {
+        const nodeA = makeNode('a', true);
+        const nodeB = makeNode('b');
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock([nodeA, nodeB]);
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-3', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('selectionChanged', expect.any(Function));
+        });
+
+        apiMock.dispatch('selectionChanged', { source: 'rowClicked' });
+
+        await waitFor(() => {
+            expect(store.setItem).toHaveBeenCalledWith('grid-row-selection-3', ['a']);
+        });
+    });
+
+    it('removes stored selection when selectionChanged produces no selected rows', async () => {
+        const nodeA = makeNode('a');
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock([nodeA]);
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-4', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('selectionChanged', expect.any(Function));
+        });
+
+        apiMock.dispatch('selectionChanged', { source: 'rowClicked' });
+
+        await waitFor(() => {
+            expect(store.removeItem).toHaveBeenCalledWith('grid-row-selection-4');
+            expect(store.setItem).not.toHaveBeenCalled();
+        });
+    });
+
+    it('ignores selectionChanged events triggered by api source', async () => {
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock();
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-5', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('selectionChanged', expect.any(Function));
+        });
+
+        apiMock.dispatch('selectionChanged', { source: 'api' });
+
+        await waitFor(() => {
+            expect(store.setItem).not.toHaveBeenCalled();
+            expect(store.removeItem).not.toHaveBeenCalled();
+        });
+    });
+
+    it('reset removes stored state and clears grid selection', async () => {
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-6', store }
+        });
+
+        fixture.componentInstance.directive().reset();
+
+        expect(store.removeItem).toHaveBeenCalledWith('grid-row-selection-6');
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(fixture.componentInstance.grid().api.deselectAll).toHaveBeenCalled();
+    });
+
+    it('removes all event listeners on destroy', async () => {
+        const store: KbqAgGridRowSelectionStateStore = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(),
+            removeItem: jest.fn()
+        };
+        const apiMock = createApiMock();
+
+        const { fixture } = await render(TestRowSelectionStateGrid, {
+            componentProperties: { key: 'grid-row-selection-7', store }
+        });
+
+        fixture.componentInstance.grid().emitGridReady(apiMock.api);
+
+        await waitFor(() => {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(apiMock.api.addEventListener).toHaveBeenCalledWith('selectionChanged', expect.any(Function));
+        });
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-type-assertion
+        const addEventListenerMock = apiMock.api.addEventListener as unknown as jest.MockedFunction<
+            typeof apiMock.api.addEventListener
+        >;
+
+        const getHandler = (eventName: AgEventType): AnyEventHandler | undefined =>
+            addEventListenerMock.mock.calls.find(([name]) => name === eventName)?.[1];
+
+        fixture.destroy();
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(apiMock.api.removeEventListener).toHaveBeenCalledWith(
+            'firstDataRendered',
+            getHandler('firstDataRendered')
+        );
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(apiMock.api.removeEventListener).toHaveBeenCalledWith(
+            'selectionChanged',
+            getHandler('selectionChanged')
+        );
+    });
+});