@@ -12,6 +12,8 @@
 - **Nine theme keys** (additive; each defaults to exactly what the grid draws today, checked by the default-theme baseline in Chromium, Firefox and WebKit): `grid.checkboxCheckedBackground` (`--ogx-checkbox-checked-bg`, the fill and border of a checked or indeterminate checkbox, default the primary colour), `grid.checkboxCheckmark` (`--ogx-checkbox-checkmark`, default white), `grid.expandIconColor` / `expandIconHoverColor` (`--ogx-expand-icon-color` / `-hover-color`, the group and tree chevron, default header text / row text), and for menus `overlays.itemIndicatorColor` (`--ogx-overlay-item-indicator`, the selection dot, default the selected item text), `itemSelectedIcon` (`--ogx-overlay-item-selected-icon`, default primary), `iconColor` (`--ogx-overlay-icon`, default gray-400), `sectionLabelText` (`--ogx-overlay-section-label-text`, default gray-400) and `dividerColor` (`--ogx-overlay-divider`, default the overlay border).
 - **Theme Builder controls** for those keys and for existing keys it did not offer: a *Checkboxes* group (background, border, checked fill, check mark), a *Group and tree rows* group (chevron, chevron hover), *Selected row hover*, a *Toolbar and search box* group (toolbar text, search box background, text, border, focus border), and in *Column menu and panels* the item hover text, selected item text, selection dot, selected item icon, icons, section labels, dividers and danger item colours.
 
+- **`localeText` covers every built-in UI string** (196 optional keys, additive; without them the grid shows the same English as before): the column menu, toolbar and quick search, filter panel (including operator names), columns panel, pivot panel, AI assistant panel and its status line, pagination buttons, row and header checkboxes and handles, cell selection statistics, list view, loading and error overlays, the error cell and screen-reader announcements. The strings are resolved once per grid and shared through a context, so rows read them without a new prop. Components used outside a grid (`GridToolbar`, `ColumnVisibilityPanel`, `FilterPanel`) show English; their explicit props still win. Not covered: the AI assistant's change-chip texts, the grouping column's default header (`groupingColDef.headerName` sets it), and row data or file contents such as the pivot "Grand Total" row and export subtotals. An inline `localeText` object of strings keeps the rows memoised; function entries are compared by identity. See *Locale text for every UI string* in `docs/API_REFERENCE.md`; the Locale Text demo shows a French grid.
+
 ### Demo
 
 - **Sidebar reorganised by what developers look for first**: *Getting started* (with Basic Usage and the API reference), *Sorting & filtering*, *Editing*, *Pagination & server data*, *Export & clipboard*, *Grouping & aggregation*, *Selection & spreadsheet*, *Layout*, *Theming & customization*, *AI*, *Advanced*, *Tutorials*, then *Resources* (licensing, support, migration guides). Page URLs are unchanged. Text pages are marked `doc` (full width) instead of relying on their category.
 
@@ -1021,7 +1021,7 @@ Since v3.9 every built-in string of the grid goes through `localeText`: the tool
 - The strings reach portalled menus and panels through React context, so a custom toolbar slot that renders the built-in `GridToolbar` is translated too.
 - Components used outside a grid (`ColumnVisibilityPanel`, `GridToolbar`, `FilterPanel`, `Pagination`, `QuickFilter`) show English. Their own props (`placeholder`, `aiAssistantLabel`, `Pagination`'s `localeText`) still win.
 - Not covered: the grouping column's default header (`'Group'`, set `groupingColDef.headerName`), pivot's `'Grand Total'` row label, export file contents, the AI change chips' labels, and developer console warnings.
-- Pass a stable object (a module constant or `useMemo`): the grid resolves the strings once per `localeText` object.
+- An inline object of strings is fine: while it holds the same entries as on the previous render (records such as `filterPanelOperators` compared one level deep), the grid keeps the resolved strings and the rows are not re-rendered. Functions are compared by identity, so define function entries (`rowSelectLabel: id => …`) outside the render, or keep the whole object in a module constant or `useMemo`.
 
 ### `GridRowMeta`
 
 
@@ -47,7 +47,7 @@ Baselines (Chromium, M1, 1M rows): edit 508 ms · paste/undo/redo ~790 ms · fil
 | R4 | Reduce ~41 `as unknown as` casts (internal column type) | L | ⬜ | |
 | R5 | Split files >600 lines (`GridToolbar.tsx` 855, …) | M each | ⬜ | |
 | R6 | Narrow wide hook interfaces (keyboard nav: 31 params) | L | ⬜ | |
-| R7 | Route ~70 hard-coded English strings through `localeText` | M | ⬜ | new public keys → minor release |
+| R7 | Route ~70 hard-coded English strings through `localeText` | M | ✅ | 196 keys (more than the ~70 estimated: pivot/toolbar/AI status included), `GridLocaleContext`, `useShallowStableValue`. Not covered: AI chip texts, grouping column default header, file/row contents |
 | R8 | Document 24 exports missing from `docs/API_REFERENCE.md` | S | ✅ | All 23 missing exports documented in `API_REFERENCE.md` |
 
 ## Log
@@ -68,3 +68,4 @@ Baselines (Chromium, M1, 1M rows): edit 508 ms · paste/undo/redo ~790 ms · fil
 - 2026-10-13 — Branch `release/3.9.0`: 9 theme keys + Theme Builder controls (user request), sidebar reorganised by developer priority (user request), demo version label from package.json.
 - 2026-10-13 — Flaky tests fixed (reorder, header-filter scroll, PDF heartbeat, tree-data ratio). R7 (localeText for ~120 strings) delegated to an agent in a worktree; P8 waits for it (same files).
 - 2026-10-13 — P8 done (row memoisation), regression test proven to fail without the fixes.
+- 2026-10-13 — R7 done (agent, reviewed): 196 localeText keys via GridLocaleContext; added useShallowStableValue so an inline localeText of strings keeps rows memoised. Unit 1972, browser 585/585 in 3 engines.
@@ -1,5 +1,6 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import { render, fireEvent, act, cleanup } from '@testing-library/react';
+import { useState } from 'react';
 import { DataGrid } from './DataGrid';
 import type { GridColDef } from '../../types';
 
@@ -41,4 +42,29 @@ describe('row memoisation', () => {
         expect(renders.get(0) ?? 0).toBe(0);
         expect(renders.get(3) ?? 0).toBe(0);
     });
+
+    it('an inline localeText object of plain strings keeps rows memoised', () => {
+        const renders = new Map<number, number>();
+        const isCellEditable = ({ row }: { row: Row }) => {
+            renders.set(row.id, (renders.get(row.id) ?? 0) + 1);
+            return true;
+        };
+        const columns: GridColDef<Row>[] = [{ field: 'name', editable: true }];
+        let bump = () => {};
+        function Parent() {
+            const [n, setN] = useState(0);
+            bump = () => setN(n + 1);
+            return (
+                <div data-n={n}>
+                    <DataGrid<Row> rows={ROWS} columns={columns} height={400} isCellEditable={isCellEditable}
+                        localeText={{ noRowsLabel: 'Keine Daten', columnMenuUnsort: 'Unsortiert' }} />
+                </div>
+            );
+        }
+        render(<Parent />);
+        renders.clear();
+        act(() => { bump(); });
+        expect(renders.get(0) ?? 0).toBe(0);
+        expect(renders.get(4) ?? 0).toBe(0);
+    });
 });
@@ -1,6 +1,7 @@
 import React, { useMemo } from 'react';
 import { GridLocaleContext } from './gridLocaleContext';
 import { resolveGridLocale } from '../../utils/gridLocale';
+import { useShallowStableValue } from '../../hooks/core/useShallowStableValue';
 import { GridToolbarHostContext } from '../../hooks/core/gridToolbarHostContext';
 import { GridToolbarSlot } from './GridToolbarSlot';
 import { GridAiAssistantArea } from '../AiAssistant/GridAiAssistantArea';
@@ -97,7 +98,8 @@ export function GridRoot<R extends GridRowModel>(props: GridRootProps<R>) {
     // body shows skeletons or the loading overlay instead, and infinite scroll appends skeleton rows.
     const showLoadingOverRows = effectiveLoading && allRenderableRows.length > 0 && paginationMode !== 'infinite';
     const ToolbarSlot = slots?.toolbar;
-    const locale = useMemo(() => resolveGridLocale(localeText), [localeText]);
+    const stableLocaleText = useShallowStableValue(localeText);
+    const locale = useMemo(() => resolveGridLocale(stableLocaleText), [stableLocaleText]);
 
     return (
         <GridLocaleContext.Provider value={locale}>
 
@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useShallowStableValue } from './useShallowStableValue';
+
+describe('useShallowStableValue', () => {
+    it('keeps the first object while new ones hold the same entries', () => {
+        const fn = () => 'x';
+        const first = { a: 'A', ops: { contains: 'enthält' }, f: fn };
+        const { result, rerender } = renderHook(({ v }) => useShallowStableValue(v), { initialProps: { v: first } });
+        rerender({ v: { a: 'A', ops: { contains: 'enthält' }, f: fn } });
+        expect(result.current).toBe(first);
+    });
+
+    it('takes a new object when an entry changes, including a new function', () => {
+        const first = { a: 'A', f: () => 'x' };
+        const { result, rerender } = renderHook(({ v }) => useShallowStableValue(v), { initialProps: { v: first } });
+        const changed = { a: 'B', f: first.f };
+        rerender({ v: changed });
+        expect(result.current).toBe(changed);
+        const newFn = { a: 'B', f: () => 'x' };
+        rerender({ v: newFn });
+        expect(result.current).toBe(newFn);
+    });
+
+    it('handles undefined and swaps between object and undefined', () => {
+        const initialProps: { v: { a: string } | undefined } = { v: undefined };
+        const { result, rerender } = renderHook(({ v }) => useShallowStableValue(v), { initialProps });
+        expect(result.current).toBeUndefined();
+        const obj = { a: 'x' };
+        rerender({ v: obj });
+        expect(result.current).toBe(obj);
+        rerender({ v: undefined });
+        expect(result.current).toBeUndefined();
+    });
+});
@@ -0,0 +1,29 @@
+import { useState } from 'react';
+
+/** Equal when both hold the same keys with `Object.is`-equal values, one level of plain records deep. */
+function isShallowEqual(a: unknown, b: unknown, depth = 1): boolean {
+    if (Object.is(a, b)) return true;
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object' || Array.isArray(a) || Array.isArray(b)) return false;
+    const ra = a as Record<string, unknown>;
+    const rb = b as Record<string, unknown>;
+    const keys = Object.keys(ra);
+    if (keys.length !== Object.keys(rb).length) return false;
+    return keys.every(key => Object.prototype.hasOwnProperty.call(rb, key)
+        && (Object.is(ra[key], rb[key]) || (depth > 0 && isShallowEqual(ra[key], rb[key], depth - 1))));
+}
+
+/**
+ * `value`, or the previous one while the new one holds the same entries. A consumer passing an
+ * inline object (`localeText={{ … }}`) then keeps one identity across renders, so what is memoised
+ * on it (the resolved locale, and every row that reads it) does not update needlessly. Functions
+ * inside are compared by identity: an inline function still counts as a change.
+ */
+export function useShallowStableValue<T>(value: T): T {
+    const [stable, setStable] = useState(value);
+    if (stable !== value && !isShallowEqual(stable, value)) {
+        // Adjusting state while rendering (React's documented pattern for derived state).
+        setStable(value);
+        return value;
+    }
+    return stable;
+}