diff --git a/docs/guides/migration.en.md b/docs/guides/migration.en.md
index 23d498a074..084e61db6e 100644
--- a/docs/guides/migration.en.md
+++ b/docs/guides/migration.en.md
@@ -1215,6 +1215,33 @@ Three fixes with nothing to migrate: the pane carries `role="tooltip"` and the t
 
 Reported by `tooltip-pointer-events-and-types`, which reports the _absence_ of the input: a file that renders `kbqTooltip` and never writes `ignoreTooltipPointerEvents` is exactly the file whose behavior changed.
 
+#### Tree
+
+The tree moved its inputs and its query members to signals. Six members that used to be writable are getters now — over a `computed()`, over an `InputSignal`, or over an `asObservable()` view of a `Subject`.
+
+**An unmigrated write does not merely stop compiling.** Assigning to a getter-only property throws `TypeError: Cannot set property … which has only a getter` in strict mode, and an ES module is always strict, so it throws at runtime in any build that skips type checking.
+
+| Member                                     | Was                            | Is                                     |
+| ------------------------------------------ | ------------------------------ | -------------------------------------- |
+| `KbqTreeNodeToggle.disabled`               | `@Input()` accessor pair       | getter over a `computed()`             |
+| `KbqTreeBase.nodeDefs`                     | `QueryList<KbqTreeNodeDef<T>>` | `Signal<readonly KbqTreeNodeDef<T>[]>` |
+| `KbqTreeNodePadding.indent`                | accessor pair                  | `InputSignal<number \| string>`        |
+| `KbqTreeNodePadding.indentUnits`           | writable field                 | getter derived from `indent`           |
+| `KbqTreeNodeToggleBaseDirective.recursive` | accessor pair                  | `InputSignalWithTransform<boolean, …>` |
+| `KbqTreeOption.onFocus` / `onBlur`         | `Subject<KbqTreeOptionEvent>`  | `Observable<KbqTreeOptionEvent>`       |
+
+| Pattern                                           | Manual migration                                                                   |
+| ------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| `<toggle>.disabled = …`                           | Bind the `disabled` attribute; it still reaches the toggle through `disabledInput` |
+| `<toggle>.recursive`                              | Read `recursive()`; bind `kbqTreeNodeToggleRecursive`                              |
+| `nodeDefs.changes` / `.length` / `.toArray()` / … | Read `nodeDefs()`; replace the subscription with an `effect`                       |
+| `<padding>.indent` / `.indentUnits`               | Read `indent()`; bind `kbqTreeNodePaddingIndent`                                   |
+| `<option>.onFocus.next(…)` / `onBlur.next(…)`     | Subscribe instead — the option emits on both streams itself                        |
+
+Two of the six are silent rather than loud. `KbqTreeBase` is exported and is the documented extension point for a custom tree: a subclass reading `this.nodeDefs.length` now gets `0` — the arity of the signal function — instead of the number of node definitions, and `this.nodeDefs.changes.subscribe(…)` throws. And `KbqTreeNodeToggle` kept `disabled` as the input alias (the input itself is declared as `disabledInput`), so every template binding keeps working and only imperative writes break.
+
+Reported by `tree-signals`. A project that renders a tree at all also gets a summary of all six members, because five of them are only visible at a call site that writes them — a consumer that merely reads one gets a value whose type changed under it and no diagnostic at all.
+
 #### Tree select
 
 The review typed the surface and dropped the members that only existed to feed the template.
diff --git a/docs/guides/migration.ru.md b/docs/guides/migration.ru.md
index fd5efcd8f5..509c86c3dd 100644
--- a/docs/guides/migration.ru.md
+++ b/docs/guides/migration.ru.md
@@ -1219,6 +1219,33 @@ class MyToast extends KbqToastComponent {
 
 Сообщает `tooltip-pointer-events-and-types` — причём сообщает об _отсутствии_ входа: файл, который отрисовывает `kbqTooltip` и нигде не пишет `ignoreTooltipPointerEvents`, и есть тот файл, поведение которого изменилось.
 
+#### Tree
+
+Дерево перевело свои входы и запросы к содержимому на сигналы. Шесть членов, в которые раньше можно было писать, стали геттерами — поверх `computed()`, поверх `InputSignal` либо поверх `asObservable()`-представления `Subject`.
+
+**Запись, которую не поправили, не просто перестаёт компилироваться.** Присваивание в свойство, у которого есть только геттер, бросает `TypeError: Cannot set property … which has only a getter` в strict-режиме, а ES-модуль всегда strict, — то есть падение произойдёт в рантайме в любой сборке без проверки типов.
+
+| Член                                       | Было                            | Стало                                  |
+| ------------------------------------------ | ------------------------------- | -------------------------------------- |
+| `KbqTreeNodeToggle.disabled`               | пара геттер/сеттер с `@Input()` | геттер поверх `computed()`             |
+| `KbqTreeBase.nodeDefs`                     | `QueryList<KbqTreeNodeDef<T>>`  | `Signal<readonly KbqTreeNodeDef<T>[]>` |
+| `KbqTreeNodePadding.indent`                | пара геттер/сеттер              | `InputSignal<number \| string>`        |
+| `KbqTreeNodePadding.indentUnits`           | поле для записи                 | геттер, выводимый из `indent`          |
+| `KbqTreeNodeToggleBaseDirective.recursive` | пара геттер/сеттер              | `InputSignalWithTransform<boolean, …>` |
+| `KbqTreeOption.onFocus` / `onBlur`         | `Subject<KbqTreeOptionEvent>`   | `Observable<KbqTreeOptionEvent>`       |
+
+| Что было                                          | Что делать вручную                                                                           |
+| ------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `<toggle>.disabled = …`                           | Привязать атрибут `disabled` — он по-прежнему доходит до переключателя через `disabledInput` |
+| `<toggle>.recursive`                              | Читать `recursive()`; привязывать `kbqTreeNodeToggleRecursive`                               |
+| `nodeDefs.changes` / `.length` / `.toArray()` / … | Читать `nodeDefs()`; подписку заменить на `effect`                                           |
+| `<padding>.indent` / `.indentUnits`               | Читать `indent()`; привязывать `kbqTreeNodePaddingIndent`                                    |
+| `<option>.onFocus.next(…)` / `onBlur.next(…)`     | Подписываться, а не отправлять — опция сама публикует значения в оба потока                  |
+
+Два случая из шести проявляются молча. `KbqTreeBase` экспортируется и является задокументированной точкой расширения для собственного дерева: наследник, читающий `this.nodeDefs.length`, получит `0` — арность функции-сигнала — вместо количества определений узлов, а `this.nodeDefs.changes.subscribe(…)` бросит исключение. А `KbqTreeNodeToggle` сохранил `disabled` как алиас входа (сам вход объявлен как `disabledInput`), поэтому все привязки в шаблонах продолжают работать и ломаются только программные записи.
+
+Сообщает `tree-signals`. Проект, который вообще отрисовывает дерево, получает ещё и сводку по всем шести членам: пять из них видны только там, где в них пишут, а потребитель, который просто читает один из них, получает значение с изменившимся типом и вообще никакой диагностики.
+
 #### Tree select
 
 Ревью типизировало публичную поверхность и убрало члены, которые существовали только ради шаблона.
diff --git a/packages/components/core/locales/en-US.ts b/packages/components/core/locales/en-US.ts
index 25a6542c12..233dd2a797 100644
--- a/packages/components/core/locales/en-US.ts
+++ b/packages/components/core/locales/en-US.ts
@@ -15,7 +15,8 @@ export const enUSLocaleData = {
         showPassword: 'Show password',
         hidePassword: 'Hide password',
         resizeColumns: 'Resize columns',
-        toastRegion: 'Notifications'
+        toastRegion: 'Notifications',
+        optionActions: 'Actions'
     },
     select: { hiddenItemsText: '+{{ number }}', selectAll: 'Select all' },
     datepicker: {
diff --git a/packages/components/core/locales/es-LA.ts b/packages/components/core/locales/es-LA.ts
index f40c5c8133..3a1eca4f46 100644
--- a/packages/components/core/locales/es-LA.ts
+++ b/packages/components/core/locales/es-LA.ts
@@ -15,7 +15,8 @@ export const esLALocaleData = {
         showPassword: 'Mostrar la contraseña',
         hidePassword: 'Ocultar la contraseña',
         resizeColumns: 'Redimensionar columnas',
-        toastRegion: 'Notificaciones'
+        toastRegion: 'Notificaciones',
+        optionActions: 'Acciones'
     },
     select: {
         hiddenItemsText: '+{{ number }}',
diff --git a/packages/components/core/locales/pt-BR.ts b/packages/components/core/locales/pt-BR.ts
index c5ef7fc1d9..c3db6142ec 100644
--- a/packages/components/core/locales/pt-BR.ts
+++ b/packages/components/core/locales/pt-BR.ts
@@ -15,7 +15,8 @@ export const ptBRLocaleData = {
         showPassword: 'Mostrar a senha',
         hidePassword: 'Ocultar a senha',
         resizeColumns: 'Redimensionar colunas',
-        toastRegion: 'Notificações'
+        toastRegion: 'Notificações',
+        optionActions: 'Ações'
     },
     select: {
         hiddenItemsText: '+{{ number }}',
diff --git a/packages/components/core/locales/ru-RU.ts b/packages/components/core/locales/ru-RU.ts
index 0f277869e0..fbfbc52a5e 100644
--- a/packages/components/core/locales/ru-RU.ts
+++ b/packages/components/core/locales/ru-RU.ts
@@ -15,7 +15,8 @@ export const ruRULocaleData = {
         showPassword: 'Показать пароль',
         hidePassword: 'Скрыть пароль',
         resizeColumns: 'Изменить ширину колонок',
-        toastRegion: 'Уведомления'
+        toastRegion: 'Уведомления',
+        optionActions: 'Действия'
     },
     select: { hiddenItemsText: '+{{ number }}', selectAll: 'Выбрать все' },
     datepicker: {
diff --git a/packages/components/core/locales/tk-TM.ts b/packages/components/core/locales/tk-TM.ts
index 7d36e18db1..7e65b87721 100644
--- a/packages/components/core/locales/tk-TM.ts
+++ b/packages/components/core/locales/tk-TM.ts
@@ -15,7 +15,8 @@ export const tkTMLocaleData = {
         showPassword: 'Paroly görkez',
         hidePassword: 'Paroly gizle',
         resizeColumns: 'Sütünleriň giňligini üýtget',
-        toastRegion: 'Bildirişler'
+        toastRegion: 'Bildirişler',
+        optionActions: 'Hereketler'
     },
     select: {
         hiddenItemsText: '+{{ number }}',
diff --git a/packages/components/core/locales/types.ts b/packages/components/core/locales/types.ts
index ae406a8f85..b6af2593c9 100644
--- a/packages/components/core/locales/types.ts
+++ b/packages/components/core/locales/types.ts
@@ -43,6 +43,8 @@ export type KbqA11yLocaleConfiguration = {
     resizeColumns: string;
     /** Region holding the stack of toast notifications. */
     toastRegion: string;
+    /** Trailing action button of a list or tree option. */
+    optionActions: string;
 };
 
 /** Locale configuration for `KbqCodeBlockModule`. */
diff --git a/packages/components/core/option/action.ts b/packages/components/core/option/action.ts
index b8631da14c..02319b787b 100644
--- a/packages/components/core/option/action.ts
+++ b/packages/components/core/option/action.ts
@@ -9,11 +9,13 @@ import {
     inject,
     InjectionToken,
     Input,
+    input,
     OnDestroy,
     ViewEncapsulation
 } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { ENTER, SPACE, TAB } from '../keycodes';
+import { kbqInjectA11yLocaleConfiguration } from '../locales';
 import { kbqInjectNativeElement } from '../utils';
 
 export interface KbqOptionActionParent {
@@ -45,9 +47,12 @@ export const KBQ_OPTION_ACTION_PARENT = new InjectionToken<KbqOptionActionParent
     encapsulation: ViewEncapsulation.None,
     host: {
         class: 'kbq-option-action',
+        role: 'button',
         '[class.kbq-expanded]': 'false',
         '[class.kbq-disabled]': 'disabled',
         '[attr.disabled]': 'disabled || null',
+        '[attr.aria-disabled]': 'disabled || null',
+        '[attr.aria-label]': 'resolvedAriaLabel',
         '[attr.tabIndex]': '-1',
         '(click)': 'onClick($event)',
         '(keydown)': 'onKeyDown($event)'
@@ -58,6 +63,28 @@ export class KbqOptionActionComponent implements AfterViewInit, OnDestroy {
     private readonly nativeElement = kbqInjectNativeElement();
     private readonly focusMonitor = inject(FocusMonitor);
     private readonly option = inject(KBQ_OPTION_ACTION_PARENT);
+    private readonly a11yConfiguration = kbqInjectA11yLocaleConfiguration();
+
+    /**
+     * Accessible name of the button. The rendered content is an icon, so without a name the button
+     * is announced as unlabelled; defaults to the localized "option actions" text.
+     */
+    readonly ariaLabel = input<string>(undefined!, { alias: 'aria-label' });
+
+    /**
+     * Accessible name written to the host.
+     *
+     * The host is the very element the consumer writes, and a host binding runs after their own
+     * `[attr.aria-label]` binding on that element — which never reaches the aliased input. Falling
+     * straight through to the localized default would replace the specific name they set ("Delete
+     * file") with the generic one, so a name already on the element outranks the default.
+     * @docs-private
+     */
+    protected get resolvedAriaLabel(): string {
+        return (
+            this.ariaLabel() || this.nativeElement.getAttribute('aria-label') || this.a11yConfiguration().optionActions
+        );
+    }
 
     // TODO: Skipped for migration because:
     //  Accessor inputs cannot be migrated as they are too complex.
diff --git a/packages/components/core/utils/dom.ts b/packages/components/core/utils/dom.ts
index 82708ebad1..69a77ceb69 100644
--- a/packages/components/core/utils/dom.ts
+++ b/packages/components/core/utils/dom.ts
@@ -32,3 +32,14 @@ export const kbqFocusAndReveal = (element: HTMLElement, skipReveal = false): voi
 
     element.scrollIntoView?.({ block: 'nearest', inline: 'nearest' });
 };
+
+/**
+ * Rendered height of an element, or `0` when it has no box.
+ *
+ * `getClientRects()` returns an empty list on the server and for elements that are not laid out, so
+ * the first rect is read defensively rather than through `getBoundingClientRect()`, whose zeroes are
+ * indistinguishable from a genuinely collapsed element.
+ */
+export const kbqGetElementHeight = (element: Element): number => {
+    return element.getClientRects()[0]?.height ?? 0;
+};
diff --git a/packages/components/tree-select/tree-select.component.ts b/packages/components/tree-select/tree-select.component.ts
index 175201e676..a012f8eaed 100644
--- a/packages/components/tree-select/tree-select.component.ts
+++ b/packages/components/tree-select/tree-select.component.ts
@@ -1750,6 +1750,10 @@ export class KbqTreeSelect
         // delegates, so the tree must not also act on the same event from its own host listener.
         tree.ownsKeyboard = false;
 
+        // `panelKeydownHandler` forwards every unhandled key to the tree's key manager, and the search
+        // field sits inside the panel — so its query would otherwise drive the tree's type-ahead.
+        tree.typeAhead = !this.search();
+
         tree.keyManager.change.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
             const treeValue = this.tree()!;
 
diff --git a/packages/components/tree/control/flat-tree-control.filters.spec.ts b/packages/components/tree/control/flat-tree-control.filters.spec.ts
new file mode 100644
index 0000000000..5f6eb911e9
--- /dev/null
+++ b/packages/components/tree/control/flat-tree-control.filters.spec.ts
@@ -0,0 +1,145 @@
+import { FlatTreeControl } from './flat-tree-control';
+import {
+    FilterByValues,
+    FilterByViewValue,
+    FilterParentsForNodes,
+    kbqTreeSelectAllValue
+} from './flat-tree-control.filters';
+
+/**
+ * root
+ *   documents
+ *     draft
+ *   images
+ * other
+ */
+interface Node {
+    name: string;
+    level: number;
+    expandable: boolean;
+    value?: string;
+}
+
+describe('FlatTreeControl filters', () => {
+    let control: FlatTreeControl<Node>;
+    let nodes: Node[];
+
+    const names = (result: Node[]): string[] => result.map((node) => node.name);
+
+    beforeEach(() => {
+        nodes = [
+            { name: 'root', level: 0, expandable: true },
+            { name: 'documents', level: 1, expandable: true },
+            { name: 'draft', level: 2, expandable: false },
+            { name: 'images', level: 1, expandable: false },
+            { name: 'other', level: 0, expandable: false }
+        ];
+
+        control = new FlatTreeControl<Node>(
+            (node) => node.level,
+            (node) => node.expandable,
+            (node) => node.name,
+            (node) => node.name
+        );
+        control.dataNodes = nodes;
+    });
+
+    describe('FilterByViewValue', () => {
+        it('should keep the nodes whose view value contains the query', () => {
+            expect(names(new FilterByViewValue(control).handle('o'))).toEqual(['root', 'documents', 'other']);
+        });
+
+        it('should be case insensitive', () => {
+            expect(names(new FilterByViewValue(control).handle('DRAFT'))).toEqual(['draft']);
+        });
+
+        it('should always keep the select-all row', () => {
+            nodes.unshift({ name: 'select all', level: 0, expandable: false, value: kbqTreeSelectAllValue });
+
+            expect(names(new FilterByViewValue(control).handle('draft'))).toEqual(['select all', 'draft']);
+        });
+
+        it('should drop the select-all row when it is the only thing left', () => {
+            nodes.unshift({ name: 'select all', level: 0, expandable: false, value: kbqTreeSelectAllValue });
+
+            expect(new FilterByViewValue(control).handle('nothing matches this')).toEqual([]);
+        });
+
+        it('should expose the last result on `result`', () => {
+            const filter = new FilterByViewValue(control);
+
+            filter.handle('draft');
+
+            expect(names(filter.result)).toEqual(['draft']);
+        });
+    });
+
+    describe('FilterParentsForNodes', () => {
+        it('should re-add the ancestors of every match, in tree order', () => {
+            const previous = new FilterByViewValue(control);
+
+            previous.handle('draft');
+
+            expect(names(new FilterParentsForNodes(control).handle(null, previous))).toEqual([
+                'root',
+                'documents',
+                'draft'
+            ]);
+        });
+
+        it('should not repeat an ancestor shared by two matches', () => {
+            const previous = new FilterByViewValue(control);
+
+            previous.handle('a');
+
+            expect(names(new FilterParentsForNodes(control).handle(null, previous))).toEqual([
+                'root',
+                'documents',
+                'draft',
+                'images'
+            ]);
+        });
+
+        it('should return nothing when the previous stage is missing', () => {
+            expect(new FilterParentsForNodes(control).handle(null, null as never)).toEqual([]);
+        });
+    });
+
+    describe('FilterByValues', () => {
+        it('should add the nodes carrying the configured values', () => {
+            const filter = new FilterByValues(control);
+
+            filter.setValues(['images']);
+
+            expect(names(filter.handle(null))).toEqual(['images']);
+        });
+
+        it('should keep what the previous stage matched', () => {
+            const previous = new FilterByViewValue(control);
+            const filter = new FilterByValues(control);
+
+            previous.handle('draft');
+            filter.setValues(['images']);
+
+            expect(names(filter.handle(null, previous))).toEqual(['draft', 'images']);
+        });
+
+        it('should not repeat a node the previous stage already matched', () => {
+            const previous = new FilterByViewValue(control);
+            const filter = new FilterByValues(control);
+
+            previous.handle('draft');
+            filter.setValues(['draft']);
+
+            expect(names(filter.handle(null, previous))).toEqual(['draft']);
+        });
+
+        it('should report the values it was given', () => {
+            const filter = new FilterByValues(control);
+
+            filter.setValues(['draft', 'images']);
+
+            expect(filter.getValues()).toEqual(['draft', 'images']);
+        });
+    });
+});
diff --git a/packages/components/tree/control/flat-tree-control.filters.ts b/packages/components/tree/control/flat-tree-control.filters.ts
index bb38f71593..109e8f872b 100644
--- a/packages/components/tree/control/flat-tree-control.filters.ts
+++ b/packages/components/tree/control/flat-tree-control.filters.ts
@@ -8,6 +8,10 @@ export interface FlatTreeControlFilter<T> {
     handle(value: string | null, prevFilter?: FlatTreeControlFilter<T> | null): T[];
 }
 
+/**
+ * Default first stage of the filter pipeline: keeps the nodes whose view value matches the query.
+ * @docs-private
+ */
 export class FilterByViewValue<T> implements FlatTreeControlFilter<T> {
     result: T[];
 
@@ -30,6 +34,11 @@ export class FilterByViewValue<T> implements FlatTreeControlFilter<T> {
     }
 }
 
+/**
+ * Default last stage of the filter pipeline: re-adds the ancestors of every matched node so the
+ * matches stay reachable in the rendered hierarchy.
+ * @docs-private
+ */
 export class FilterParentsForNodes<T> implements FlatTreeControlFilter<T> {
     result: T[];
 
diff --git a/packages/components/tree/control/flat-tree-control.spec.ts b/packages/components/tree/control/flat-tree-control.spec.ts
index 7968a4a7ea..a313e02fb0 100644
--- a/packages/components/tree/control/flat-tree-control.spec.ts
+++ b/packages/components/tree/control/flat-tree-control.spec.ts
@@ -126,8 +126,168 @@ describe('FlatTreeControl', () => {
             expect(treeControl.expansionModel.selected.length).toBe(totalNumber);
         });
     });
+
+    describe('lookups over flattened data', () => {
+        let control: FlatTreeControl<FlatNode>;
+        let nodes: FlatNode[];
+
+        beforeEach(() => {
+            nodes = buildFlatNodes();
+            control = new FlatTreeControl<FlatNode>(
+                (node) => node.level,
+                (node) => node.expandable,
+                (node) => node.name,
+                (node) => node.name
+            );
+            control.dataNodes = nodes;
+        });
+
+        describe('getDescendants', () => {
+            it('should return the whole subtree of a branch', () => {
+                expect(control.getDescendants(byName(nodes, 'documents')).map((node) => node.name)).toEqual([
+                    'specs',
+                    'draft',
+                    'readme'
+                ]);
+            });
+
+            it('should return nothing for a leaf', () => {
+                expect(control.getDescendants(byName(nodes, 'readme'))).toEqual([]);
+            });
+        });
+
+        describe('getParents', () => {
+            it('should return the ancestors outermost first', () => {
+                expect(control.getParents(byName(nodes, 'draft')).map((node) => node.name)).toEqual([
+                    'root',
+                    'documents',
+                    'specs'
+                ]);
+            });
+
+            it('should return nothing for a root node', () => {
+                expect(control.getParents(byName(nodes, 'root'))).toEqual([]);
+            });
+
+            it('should resolve nodes that carry no parent back-reference', () => {
+                const draft = byName(nodes, 'draft');
+
+                expect(draft.parent).toBeUndefined();
+                expect(control.getParents(draft).map((node) => node.name)).toEqual(['root', 'documents', 'specs']);
+            });
+
+            it('should prepend to the collector it is given', () => {
+                const collector = [byName(nodes, 'other')];
+
+                expect(control.getParents(byName(nodes, 'images'), collector).map((node) => node.name)).toEqual([
+                    'root',
+                    'other'
+                ]);
+            });
+
+            it('should return the collector unchanged for a node outside the data', () => {
+                const stranger: FlatNode = { name: 'stranger', level: 2, expandable: false };
+
+                expect(control.getParents(stranger)).toEqual([]);
+            });
+        });
+
+        describe('hasValue', () => {
+            it('should find the node carrying the value', () => {
+                expect(control.hasValue('specs')).toBe(byName(nodes, 'specs'));
+            });
+
+            it('should return undefined for an unknown value', () => {
+                expect(control.hasValue('nothing')).toBeUndefined();
+            });
+        });
+
+        describe('filterNodes', () => {
+            it('should keep the matches together with their ancestors', () => {
+                control.filterNodes('draft');
+
+                expect(control.filterModel.selected.map((node) => node.name)).toEqual([
+                    'root',
+                    'documents',
+                    'specs',
+                    'draft'
+                ]);
+            });
+
+            it('should expand every expandable node it kept', () => {
+                control.filterNodes('draft');
+
+                expect(control.expansionModel.selected.map((node) => node.name)).toEqual([
+                    'root',
+                    'documents',
+                    'specs'
+                ]);
+            });
+
+            it('should publish the query on filterValue', async () => {
+                control.filterNodes('draft');
+
+                await Promise.resolve();
+
+                expect(control.filterValue.value).toBe('draft');
+            });
+
+            it('should remember the expansion state the filter replaced', () => {
+                control.expand(byName(nodes, 'images'));
+
+                control.filterNodes('draft');
+
+                expect(control.expandedItemsBeforeFiltration.map((node) => node.name)).toEqual(['images']);
+            });
+
+            it('should restore the remembered expansion state once the query is dropped', async () => {
+                control.expand(byName(nodes, 'images'));
+
+                control.filterNodes('draft');
+                await Promise.resolve();
+
+                control.filterNodes('');
+                await Promise.resolve();
+
+                expect(control.expansionModel.selected.map((node) => node.name)).toEqual(['images']);
+            });
+        });
+    });
 });
 
+/** Flat node in the depth-first order the flattener produces, with 0-based levels. */
+interface FlatNode {
+    name: string;
+    level: number;
+    expandable: boolean;
+    parent?: FlatNode;
+}
+
+/**
+ * root
+ *   documents
+ *     specs
+ *       draft
+ *     readme
+ *   images
+ * other
+ */
+function buildFlatNodes(): FlatNode[] {
+    return [
+        { name: 'root', level: 0, expandable: true },
+        { name: 'documents', level: 1, expandable: true },
+        { name: 'specs', level: 2, expandable: true },
+        { name: 'draft', level: 3, expandable: false },
+        { name: 'readme', level: 2, expandable: false },
+        { name: 'images', level: 1, expandable: false },
+        { name: 'other', level: 0, expandable: false }
+    ];
+}
+
+function byName(nodes: FlatNode[], name: string): FlatNode {
+    return nodes.find((node) => node.name === name)!;
+}
+
 export class TestData {
     a: string;
     b: string;
diff --git a/packages/components/tree/control/flat-tree-control.ts b/packages/components/tree/control/flat-tree-control.ts
index 3e83e4f942..42dc9deb7b 100644
--- a/packages/components/tree/control/flat-tree-control.ts
+++ b/packages/components/tree/control/flat-tree-control.ts
@@ -81,14 +81,38 @@ export class FlatTreeControl<T> extends BaseTreeControl<T> {
         this.expansionModel.select(...this.dataNodes);
     }
 
-    getParents(node: any, result: T[]): T[] {
-        if (node.parent) {
-            result.unshift(node.parent);
+    /**
+     * Ancestors of a data node, outermost first.
+     *
+     * Derived from `dataNodes` rather than from a `parent` back-reference: the flattened nodes are in
+     * depth-first order, so scanning backwards from the node, the first node of a smaller level is its
+     * parent, and repeating with that level yields the whole chain. A data node whose shape carries no
+     * `parent` therefore resolves just as well as one that does.
+     *
+     * @param result Collector the ancestors are prepended to. Provided so callers can accumulate into
+     * an existing array; a fresh one is used when omitted.
+     */
+    getParents(node: T, result: T[] = []): T[] {
+        const startIndex = this.dataNodes?.indexOf(node) ?? -1;
 
-            return this.getParents(node.parent, result);
-        } else {
+        if (startIndex === -1) {
             return result;
         }
+
+        let level = this.getLevel(node);
+
+        for (let i = startIndex - 1; i >= 0 && level > 0; i--) {
+            const candidate = this.dataNodes[i];
+            const candidateLevel = this.getLevel(candidate);
+
+            if (candidateLevel < level) {
+                result.unshift(candidate);
+
+                level = candidateLevel;
+            }
+        }
+
+        return result;
     }
 
     hasValue(value: string): T | undefined {
diff --git a/packages/components/tree/control/nested-tree-control.ts b/packages/components/tree/control/nested-tree-control.ts
index ccc0a25dc5..1d0f6c88b4 100644
--- a/packages/components/tree/control/nested-tree-control.ts
+++ b/packages/components/tree/control/nested-tree-control.ts
@@ -4,7 +4,13 @@ import { BaseTreeControl } from './base-tree-control';
 
 /** Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type. */
 export class NestedTreeControl<T> extends BaseTreeControl<T> {
-    /** Construct with nested tree function getChildren. */
+    /**
+     * Construct with nested tree function getChildren.
+     *
+     * @param getChildren Must emit **synchronously** (e.g. `of(children)` or a `BehaviorSubject`).
+     * `getDescendants` walks the tree with `take(1)` and returns as soon as the recursion unwinds, so
+     * an asynchronous source yields an incomplete — usually empty — descendant list.
+     */
     constructor(public getChildren: (dataNode: T) => Observable<T[]>) {
         super();
     }
diff --git a/packages/components/tree/data-source/flat-data-source.spec.ts b/packages/components/tree/data-source/flat-data-source.spec.ts
new file mode 100644
index 0000000000..ba129fb747
--- /dev/null
+++ b/packages/components/tree/data-source/flat-data-source.spec.ts
@@ -0,0 +1,201 @@
+import { CollectionViewer } from '@angular/cdk/collections';
+import { BehaviorSubject, Observable, of } from 'rxjs';
+import { FlatTreeControl } from '../control/flat-tree-control';
+import { KbqTreeFlatDataSource, KbqTreeFlattener } from './flat-data-source';
+
+interface Node {
+    name: string;
+    children?: Node[];
+}
+
+interface FlatNode {
+    name: string;
+    level: number;
+    expandable: boolean;
+    parent: FlatNode | null;
+}
+
+/**
+ * root
+ *   documents
+ *     draft
+ *   images
+ * other
+ */
+const buildData = (): Node[] => [
+    {
+        name: 'root',
+        children: [{ name: 'documents', children: [{ name: 'draft' }] }, { name: 'images' }]
+    },
+    { name: 'other' }
+];
+
+const transformer = (node: Node, level: number, parent: FlatNode | null): FlatNode => ({
+    name: node.name,
+    level,
+    expandable: !!node.children?.length,
+    parent
+});
+
+const getLevel = (node: FlatNode) => node.level;
+const isExpandable = (node: FlatNode) => node.expandable;
+const getValue = (node: FlatNode) => node.name;
+
+const names = (nodes: FlatNode[]): string[] => nodes.map((node) => node.name);
+
+const byName = (nodes: FlatNode[], name: string): FlatNode => nodes.find((node) => node.name === name)!;
+
+describe('KbqTreeFlattener', () => {
+    const createFlattener = (getChildren: (node: Node) => Observable<Node[]> | Node[] | undefined) =>
+        new KbqTreeFlattener<Node, FlatNode>(transformer, getLevel, isExpandable, getChildren);
+
+    it('should flatten a nested structure depth first', () => {
+        const flattener = createFlattener((node) => node.children);
+
+        expect(names(flattener.flattenNodes(buildData()))).toEqual([
+            'root',
+            'documents',
+            'draft',
+            'images',
+            'other'
+        ]);
+    });
+
+    it('should assign a level per nesting depth, starting at zero', () => {
+        const flattener = createFlattener((node) => node.children);
+        const flat = flattener.flattenNodes(buildData());
+
+        expect(flat.map((node) => node.level)).toEqual([0, 1, 2, 1, 0]);
+    });
+
+    it('should hand every node its flattened parent', () => {
+        const flattener = createFlattener((node) => node.children);
+        const flat = flattener.flattenNodes(buildData());
+
+        expect(byName(flat, 'root').parent).toBeNull();
+        expect(byName(flat, 'documents').parent).toBe(byName(flat, 'root'));
+        expect(byName(flat, 'draft').parent).toBe(byName(flat, 'documents'));
+    });
+
+    it('should accept children delivered as an observable', () => {
+        const flattener = createFlattener((node) => of(node.children ?? []));
+
+        expect(names(flattener.flattenNodes(buildData()))).toEqual([
+            'root',
+            'documents',
+            'draft',
+            'images',
+            'other'
+        ]);
+    });
+
+    describe('expandFlattenedNodes', () => {
+        let flattener: KbqTreeFlattener<Node, FlatNode>;
+        let control: FlatTreeControl<FlatNode>;
+        let flat: FlatNode[];
+
+        beforeEach(() => {
+            flattener = createFlattener((node) => node.children);
+            control = new FlatTreeControl<FlatNode>(getLevel, isExpandable, getValue, getValue);
+            flat = flattener.flattenNodes(buildData());
+            control.dataNodes = flat;
+        });
+
+        it('should keep only the root level while nothing is expanded', () => {
+            expect(names(flattener.expandFlattenedNodes(flat, control))).toEqual(['root', 'other']);
+        });
+
+        it('should reveal the children of an expanded node', () => {
+            control.expand(byName(flat, 'root'));
+
+            expect(names(flattener.expandFlattenedNodes(flat, control))).toEqual([
+                'root',
+                'documents',
+                'images',
+                'other'
+            ]);
+        });
+
+        it('should keep a grandchild hidden while its own parent is collapsed', () => {
+            control.expand(byName(flat, 'documents'));
+
+            expect(names(flattener.expandFlattenedNodes(flat, control))).toEqual(['root', 'other']);
+        });
+    });
+});
+
+describe('KbqTreeFlatDataSource', () => {
+    let control: FlatTreeControl<FlatNode>;
+    let flattener: KbqTreeFlattener<Node, FlatNode>;
+    let dataSource: KbqTreeFlatDataSource<Node, FlatNode>;
+    let collectionViewer: CollectionViewer;
+
+    beforeEach(() => {
+        control = new FlatTreeControl<FlatNode>(getLevel, isExpandable, getValue, getValue);
+        flattener = new KbqTreeFlattener<Node, FlatNode>(transformer, getLevel, isExpandable, (node) => node.children);
+        dataSource = new KbqTreeFlatDataSource(control, flattener);
+        collectionViewer = { viewChange: new BehaviorSubject({ start: 0, end: Number.MAX_VALUE }) };
+    });
+
+    it('should flatten the data it is given and hand it to the tree control', () => {
+        dataSource.data = buildData();
+
+        expect(names(dataSource.flattenedData.value)).toEqual(['root', 'documents', 'draft', 'images', 'other']);
+        expect(control.dataNodes).toBe(dataSource.flattenedData.value);
+    });
+
+    it('should report the data it was last given', () => {
+        const data = buildData();
+
+        dataSource.data = data;
+
+        expect(dataSource.data).toBe(data);
+    });
+
+    it('should emit the expanded nodes on connect', () => {
+        const emissions: string[][] = [];
+
+        dataSource.data = buildData();
+        dataSource.connect(collectionViewer).subscribe((nodes) => emissions.push(names(nodes)));
+
+        expect(emissions[emissions.length - 1]).toEqual(['root', 'other']);
+    });
+
+    it('should re-emit when a node is expanded', () => {
+        const emissions: string[][] = [];
+
+        dataSource.data = buildData();
+        dataSource.connect(collectionViewer).subscribe((nodes) => emissions.push(names(nodes)));
+
+        control.expand(byName(control.dataNodes, 'root'));
+
+        expect(emissions[emissions.length - 1]).toEqual(['root', 'documents', 'images', 'other']);
+    });
+
+    it('should emit the filter result while a filter is active', async () => {
+        const emissions: string[][] = [];
+
+        dataSource.data = buildData();
+        dataSource.connect(collectionViewer).subscribe((nodes) => emissions.push(names(nodes)));
+
+        control.filterNodes('draft');
+        await Promise.resolve();
+
+        expect(emissions[emissions.length - 1]).toEqual(['root', 'documents', 'draft']);
+    });
+
+    it('should go back to the expansion state once the filter is dropped', async () => {
+        const emissions: string[][] = [];
+
+        dataSource.data = buildData();
+        dataSource.connect(collectionViewer).subscribe((nodes) => emissions.push(names(nodes)));
+
+        control.filterNodes('draft');
+        await Promise.resolve();
+
+        control.filterNodes('');
+        await Promise.resolve();
+
+        expect(emissions[emissions.length - 1]).toEqual(['root', 'other']);
+    });
+});
diff --git a/packages/components/tree/data-source/flat-data-source.ts b/packages/components/tree/data-source/flat-data-source.ts
index 04c7a3a87a..a98863f8dc 100644
--- a/packages/components/tree/data-source/flat-data-source.ts
+++ b/packages/components/tree/data-source/flat-data-source.ts
@@ -46,6 +46,7 @@ export class KbqTreeFlattener<T, F> {
         public getChildren: (node: T) => Observable<T[]> | T[] | undefined | null
     ) {}
 
+    /** @docs-private */
     flattenNode(node: T, level: number, resultNodes: F[], parent: F | null): F[] {
         const flatNode = this.transformFunction(node, level, parent);
 
@@ -68,6 +69,7 @@ export class KbqTreeFlattener<T, F> {
         return resultNodes;
     }
 
+    /** @docs-private */
     flattenChildren(children: T[], level: number, resultNodes: F[], parent: F | null): void {
         children.forEach((child) => {
             this.flattenNode(child, level + 1, resultNodes, parent);
@@ -126,7 +128,7 @@ enum KbqTreeDataSourceChangeTypes {
  * Data source for flat tree.
  * The data source need to handle expansion/collapsion of the tree node and change the data feed
  * to `KbqTree`.
- * The nested tree nodes of type `T` are flattened through `MсTreeFlattener`, and converted
+ * The nested tree nodes of type `T` are flattened through `KbqTreeFlattener`, and converted
  * to type `F` for `KbqTree` to consume.
  */
 export class KbqTreeFlatDataSource<T, F> extends DataSource<F> {
diff --git a/packages/components/tree/padding.directive.spec.ts b/packages/components/tree/padding.directive.spec.ts
new file mode 100644
index 0000000000..747ea59f80
--- /dev/null
+++ b/packages/components/tree/padding.directive.spec.ts
@@ -0,0 +1,175 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { EMPTY } from 'rxjs';
+import { FlatTreeControl } from './control/flat-tree-control';
+import { KbqTreeFlatDataSource, KbqTreeFlattener } from './data-source/flat-data-source';
+import { KbqTreeModule } from './tree.module';
+
+interface Node {
+    name: string;
+    children?: Node[];
+}
+
+interface FlatNode {
+    name: string;
+    level: number;
+    expandable: boolean;
+}
+
+/**
+ * root
+ *   child
+ *     grandchild
+ */
+const DATA: Node[] = [{ name: 'root', children: [{ name: 'child', children: [{ name: 'grandchild' }] }] }];
+
+abstract class TreeParams {
+    treeControl = new FlatTreeControl<FlatNode>(
+        (node) => node.level,
+        (node) => node.expandable,
+        (node) => node.name,
+        (node) => node.name
+    );
+
+    treeFlattener = new KbqTreeFlattener<Node, FlatNode>(
+        (node, level) => ({ name: node.name, level, expandable: !!node.children?.length }),
+        (node) => node.level,
+        (node) => node.expandable,
+        (node) => node.children
+    );
+
+    dataSource = new KbqTreeFlatDataSource(this.treeControl, this.treeFlattener);
+
+    indent: number | string = 12;
+
+    constructor() {
+        this.dataSource.data = DATA;
+    }
+}
+
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection [dataSource]="dataSource" [treeControl]="treeControl">
+            <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding [kbqTreeNodePaddingIndent]="indent">
+                <kbq-tree-node-toggle />
+
+                {{ node.name }}
+            </kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeWithToggle extends TreeParams {}
+
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection [dataSource]="dataSource" [treeControl]="treeControl">
+            <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding [kbqTreeNodePaddingIndent]="indent">
+                {{ node.name }}
+            </kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeWithoutToggle extends TreeParams {}
+
+describe('KbqTreeNodePadding', () => {
+    /** Width the directive reserves for a toggle a row does not render itself. */
+    const iconWidth = 24;
+    /** The first level gives up two pixels to the focus outline the option draws around itself. */
+    const firstLevelBorder = 2;
+
+    const configure = (providers: any[] = []) =>
+        TestBed.configureTestingModule({ imports: [KbqTreeModule], providers }).compileComponents();
+
+    const paddings = (
+        fixture: ComponentFixture<unknown>,
+        property: 'paddingLeft' | 'paddingRight' = 'paddingLeft'
+    ): string[] =>
+        Array.from<HTMLElement>(fixture.nativeElement.querySelectorAll('.kbq-tree-option')).map(
+            (node) => node.style[property]
+        );
+
+    const render = <T extends TreeParams>(type: new (...args: any[]) => T, indent?: number | string) => {
+        const fixture = TestBed.createComponent(type);
+
+        if (indent !== undefined) {
+            fixture.componentInstance.indent = indent;
+        }
+
+        fixture.detectChanges();
+        fixture.componentInstance.treeControl.expandAll();
+        fixture.detectChanges();
+
+        return fixture;
+    };
+
+    describe('with a toggle in the default place', () => {
+        beforeEach(() => configure());
+
+        it('should indent every level by the default indent', () => {
+            expect(paddings(render(TreeWithToggle))).toEqual([
+                `${12 - firstLevelBorder}px`,
+                `${12 + 12}px`,
+                `${2 * 12 + 12}px`
+            ]);
+        });
+
+        it('should honour a custom numeric indent', () => {
+            expect(paddings(render(TreeWithToggle, 28))).toEqual([
+                `${28 - firstLevelBorder}px`,
+                `${28 + 28}px`,
+                `${2 * 28 + 28}px`
+            ]);
+        });
+
+        it('should honour the units of a string indent', () => {
+            expect(paddings(render(TreeWithToggle, '10em'))).toEqual([
+                `${10 - firstLevelBorder}em`,
+                `${10 + 10}em`,
+                `${2 * 10 + 10}em`
+            ]);
+        });
+
+        it('should re-apply the padding when the indent changes', () => {
+            const fixture = render(TreeWithToggle);
+
+            fixture.componentInstance.indent = 40;
+            fixture.detectChanges();
+
+            expect(paddings(fixture)).toEqual([
+                `${40 - firstLevelBorder}px`,
+                `${40 + 40}px`,
+                `${2 * 40 + 40}px`
+            ]);
+        });
+    });
+
+    describe('without a toggle', () => {
+        beforeEach(() => configure());
+
+        it('should reserve the toggle width so the labels still line up', () => {
+            expect(paddings(render(TreeWithoutToggle))).toEqual([
+                `${iconWidth + 12 - firstLevelBorder}px`,
+                `${iconWidth + 12 + 12}px`,
+                `${iconWidth + 2 * 12 + 12}px`
+            ]);
+        });
+    });
+
+    describe('in a right-to-left layout', () => {
+        beforeEach(() => configure([{ provide: Directionality, useValue: { value: 'rtl', change: EMPTY } }]));
+
+        it('should indent from the right instead', () => {
+            const fixture = render(TreeWithToggle);
+
+            expect(paddings(fixture, 'paddingRight')).toEqual([
+                `${12 - firstLevelBorder}px`,
+                `${12 + 12}px`,
+                `${2 * 12 + 12}px`
+            ]);
+            expect(paddings(fixture, 'paddingLeft')).toEqual(['', '', '']);
+        });
+    });
+});
diff --git a/packages/components/tree/padding.directive.ts b/packages/components/tree/padding.directive.ts
index c61a9c8130..f347e31dc4 100644
--- a/packages/components/tree/padding.directive.ts
+++ b/packages/components/tree/padding.directive.ts
@@ -1,6 +1,6 @@
 import { Directionality } from '@angular/cdk/bidi';
 import { coerceNumberProperty } from '@angular/cdk/coercion';
-import { AfterViewInit, Directive, ElementRef, Input, Renderer2, inject } from '@angular/core';
+import { AfterViewInit, computed, Directive, effect, ElementRef, inject, input, Renderer2 } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { KbqTreeBase, KbqTreeNode } from './tree-base';
 import { KbqTreeOption } from './tree-option.component';
@@ -17,7 +17,8 @@ export class KbqTreeNodePadding<T> implements AfterViewInit {
     protected tree = inject<KbqTreeBase<T>>(KbqTreeBase);
     private renderer = inject(Renderer2);
     private element = inject<ElementRef<HTMLElement>>(ElementRef);
-    private option = inject(KbqTreeOption);
+    // Optional so the directive also works on a bare `kbq-tree-node`, which has no option around it.
+    private option = inject(KbqTreeOption, { optional: true });
     private dir = inject(Directionality, { optional: true });
     get level(): number {
         return this._level;
@@ -29,41 +30,60 @@ export class KbqTreeNodePadding<T> implements AfterViewInit {
 
     private _level: number;
 
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input('kbqTreeNodePaddingIndent')
-    get indent(): number | string {
-        return this._indent;
-    }
+    /** Indentation added per nesting level. Accepts a bare number (px) or a value with CSS units. */
+    readonly indent = input<number | string>(12, { alias: 'kbqTreeNodePaddingIndent' });
 
-    set indent(indent: number | string) {
-        this.setIndentInput(indent);
-    }
+    private readonly parsedIndent = computed(() => {
+        const indent = this.indent();
+
+        if (typeof indent !== 'string') {
+            return { value: coerceNumberProperty(indent), units: 'px' };
+        }
+
+        const [value, units] = indent.split(cssUnitPattern);
 
-    private _indent: number = 12;
+        return { value: coerceNumberProperty(value), units: units || 'px' };
+    });
 
     get leftPadding(): number {
-        return (this.withIcon ? 0 : this.iconWidth) + this._indent;
+        return (this.withIcon ? 0 : this.iconWidth) + this.parsedIndent().value;
     }
 
     get leftPaddingForFirstLevel(): number {
         const border = 2;
 
-        return (this.withIcon ? 0 : this.iconWidth) + this._indent - border;
+        return (this.withIcon ? 0 : this.iconWidth) + this.parsedIndent().value - border;
     }
 
     /** CSS units used for the indentation value. */
-    indentUnits = 'px';
+    get indentUnits(): string {
+        return this.parsedIndent().units;
+    }
 
     withIcon: boolean;
+    /**
+     * Horizontal room a toggle takes up in a row: its own 16px box plus the option's 8px `gap`. A node
+     * without a toggle reserves the same amount so its content lines up with a sibling that has one —
+     * which is why widening the toggle itself pushes every branch row out of line.
+     */
     iconWidth: number = 24;
 
     constructor() {
         this.dir?.change?.pipe(takeUntilDestroyed()).subscribe(() => this.setPadding());
+
+        // The node the padding was computed from is gone once its view is reused, and the replacement
+        // can sit at a different level.
+        this.treeNode.refreshed.pipe(takeUntilDestroyed()).subscribe(() => this.setPadding());
+
+        effect(() => {
+            this.parsedIndent();
+
+            this.setPadding();
+        });
     }
 
     ngAfterViewInit(): void {
-        this.withIcon = this.option.isToggleInDefaultPlace;
+        this.withIcon = this.option?.isToggleInDefaultPlace ?? false;
         this.setPadding();
     }
 
@@ -72,8 +92,9 @@ export class KbqTreeNodePadding<T> implements AfterViewInit {
         const nodeLevel = this.treeNode.data && treeControl.getLevel ? treeControl.getLevel(this.treeNode.data) : 0;
 
         const level = this.level || nodeLevel;
+        const { value, units } = this.parsedIndent();
 
-        return level > 0 ? `${level * this._indent + this.leftPadding}px` : `${this.leftPaddingForFirstLevel}px`;
+        return level > 0 ? `${level * value + this.leftPadding}${units}` : `${this.leftPaddingForFirstLevel}${units}`;
     }
 
     /**
@@ -90,28 +111,6 @@ export class KbqTreeNodePadding<T> implements AfterViewInit {
         this.setPadding();
     }
 
-    /**
-     * This has been extracted to a util because of TS 4 and VE.
-     * View Engine doesn't support property rename inheritance.
-     * TS 4.0 doesn't allow properties to override accessors or vice-versa.
-     * @docs-private
-     */
-    private setIndentInput(indent: number | string) {
-        let value = indent;
-        let units = 'px';
-
-        if (typeof indent === 'string') {
-            const parts = indent.split(cssUnitPattern);
-
-            value = parts[0];
-            units = parts[1] || units;
-        }
-
-        this.indentUnits = units;
-        this._indent = coerceNumberProperty(value);
-        this.setPadding();
-    }
-
     private setPadding() {
         const padding = this.paddingIndent();
         const paddingProp = this.dir?.value === 'rtl' ? 'paddingRight' : 'paddingLeft';
diff --git a/packages/components/tree/toggle.scss b/packages/components/tree/toggle.scss
index 17a2812960..97aed360d0 100644
--- a/packages/components/tree/toggle.scss
+++ b/packages/components/tree/toggle.scss
@@ -1,8 +1,11 @@
 @use '../core/styles/common/tokens' as *;
 
-@use './tree-theme' as *;
-
+// The tree theme is emitted once, from `tree-selection.scss`. Every rule in it is scoped to
+// `.kbq-tree-selection` or `.kbq-tree-option`, and a toggle only ever renders inside one of those.
 .kbq-tree-node-toggle {
+    // No horizontal padding here: the box is the chevron's own 16px, and `KbqTreeNodePadding` reserves
+    // exactly that plus the option's 8px `gap` for a node that has none. Widening the toggle pushes
+    // every branch row out of line with its leaf siblings.
     display: flex;
     align-items: center;
     justify-content: center;
@@ -10,10 +13,6 @@
 
     height: 100%;
 
-    // FIXME: default token doesn't exist
-    padding-left: var(--kbq-tree-size-toggle-padding);
-    padding-right: var(--kbq-tree-size-toggle-padding);
-
     cursor: pointer;
 
     & .kbq-icon {
@@ -34,6 +33,3 @@
         }
     }
 }
-
-@include kbq-tree-theme();
-@include kbq-tree-typography();
diff --git a/packages/components/tree/toggle.spec.ts b/packages/components/tree/toggle.spec.ts
new file mode 100644
index 0000000000..e4784d2f7a
--- /dev/null
+++ b/packages/components/tree/toggle.spec.ts
@@ -0,0 +1,193 @@
+import { Component, ViewChild } from '@angular/core';
+import { ComponentFixture, TestBed, fakeAsync, flush, tick } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { FlatTreeControl } from './control/flat-tree-control';
+import { KbqTreeFlatDataSource, KbqTreeFlattener } from './data-source/flat-data-source';
+import { KbqTreeNodeToggleComponent } from './toggle';
+import { KbqTreeSelection } from './tree-selection.component';
+import { KbqTreeModule } from './tree.module';
+
+interface Node {
+    name: string;
+    children?: Node[];
+}
+
+interface FlatNode {
+    name: string;
+    level: number;
+    expandable: boolean;
+}
+
+/**
+ * src
+ *   cdk
+ *     a11y
+ *   README
+ * tests
+ */
+const DATA: Node[] = [
+    { name: 'src', children: [{ name: 'cdk', children: [{ name: 'a11y' }] }, { name: 'README' }] },
+    { name: 'tests' }
+];
+
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection [dataSource]="dataSource" [treeControl]="treeControl">
+            <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding>
+                <kbq-tree-node-toggle
+                    [node]="node"
+                    [disabled]="disabledToggles.includes(node.name)"
+                    [kbqTreeNodeToggleRecursive]="recursive"
+                />
+
+                {{ node.name }}
+            </kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeWithToggle {
+    treeControl = new FlatTreeControl<FlatNode>(
+        (node) => node.level,
+        (node) => node.expandable,
+        (node) => node.name,
+        (node) => node.name
+    );
+
+    treeFlattener = new KbqTreeFlattener<Node, FlatNode>(
+        (node, level) => ({ name: node.name, level, expandable: !!node.children?.length }),
+        (node) => node.level,
+        (node) => node.expandable,
+        (node) => node.children
+    );
+
+    dataSource = new KbqTreeFlatDataSource(this.treeControl, this.treeFlattener);
+
+    recursive = false;
+    disabledToggles: string[] = [];
+
+    @ViewChild(KbqTreeSelection, { static: false }) tree: KbqTreeSelection;
+
+    constructor() {
+        this.dataSource.data = DATA;
+    }
+}
+
+describe('KbqTreeNodeToggle', () => {
+    let fixture: ComponentFixture<TreeWithToggle>;
+    let component: TreeWithToggle;
+
+    const rows = (): HTMLElement[] =>
+        Array.from<HTMLElement>(fixture.nativeElement.querySelectorAll('.kbq-tree-option'));
+
+    const labels = (): string[] => rows().map((row) => row.querySelector('.kbq-option-text')!.textContent!.trim());
+
+    const clickToggleOf = (name: string) => {
+        const row = rows().find((item) => item.querySelector('.kbq-option-text')!.textContent!.trim() === name)!;
+
+        (row.querySelector('kbq-tree-node-toggle') as HTMLElement).click();
+        fixture.detectChanges();
+    };
+
+    const toggleOf = (name: string): KbqTreeNodeToggleComponent<FlatNode> =>
+        fixture.debugElement
+            .queryAll(By.directive(KbqTreeNodeToggleComponent))
+            .find(
+                (debugElement) =>
+                    debugElement.nativeElement.parentElement.querySelector('.kbq-option-text').textContent.trim() ===
+                    name
+            )!.componentInstance;
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({ imports: [KbqTreeModule] }).compileComponents();
+
+        fixture = TestBed.createComponent(TreeWithToggle);
+        component = fixture.componentInstance;
+
+        fixture.detectChanges();
+    });
+
+    it('should expand the node it belongs to', () => {
+        expect(labels()).toEqual(['src', 'tests']);
+
+        clickToggleOf('src');
+
+        expect(labels()).toEqual(['src', 'cdk', 'README', 'tests']);
+    });
+
+    it('should collapse the node again', () => {
+        clickToggleOf('src');
+        clickToggleOf('src');
+
+        expect(labels()).toEqual(['src', 'tests']);
+    });
+
+    it('should not select the row it sits in', () => {
+        clickToggleOf('src');
+
+        expect(component.tree.selectionModel.selected.length).toBe(0);
+    });
+
+    it('should expand the whole subtree when recursive', () => {
+        component.recursive = true;
+        fixture.detectChanges();
+
+        clickToggleOf('src');
+
+        expect(labels()).toEqual(['src', 'cdk', 'a11y', 'README', 'tests']);
+    });
+
+    it('should reflect the expanded state on the host', () => {
+        expect(rows()[0].querySelector('kbq-tree-node-toggle')!.classList).not.toContain('kbq-expanded');
+
+        clickToggleOf('src');
+
+        expect(rows()[0].querySelector('kbq-tree-node-toggle')!.classList).toContain('kbq-expanded');
+    });
+
+    it('should do nothing while it is disabled', () => {
+        component.disabledToggles = ['src'];
+        fixture.detectChanges();
+
+        clickToggleOf('src');
+
+        expect(labels()).toEqual(['src', 'tests']);
+    });
+
+    it('should mark itself disabled once a filter is active', fakeAsync(() => {
+        expect(toggleOf('src').disabled).toBe(false);
+
+        component.treeControl.filterNodes('a11y');
+        tick();
+        fixture.detectChanges();
+
+        expect(toggleOf('src').disabled).toBe(true);
+
+        flush();
+    }));
+
+    it('should combine the disabled input with the filter state', fakeAsync(() => {
+        component.disabledToggles = ['src'];
+        fixture.detectChanges();
+
+        expect(toggleOf('src').disabled).toBe(true);
+
+        component.treeControl.filterNodes('a11y');
+        tick();
+        fixture.detectChanges();
+
+        expect(toggleOf('src').disabled).toBe(true);
+
+        flush();
+    }));
+
+    it('should stop listening to the filter stream once the tree is gone', () => {
+        const filterValue = component.treeControl.filterValue as unknown as { observers: unknown[] };
+
+        expect(filterValue.observers.length).toBeGreaterThan(0);
+
+        fixture.destroy();
+
+        expect(filterValue.observers.length).toBe(0);
+    });
+});
diff --git a/packages/components/tree/toggle.ts b/packages/components/tree/toggle.ts
index 62f6fe3bd4..0c8fa0a744 100644
--- a/packages/components/tree/toggle.ts
+++ b/packages/components/tree/toggle.ts
@@ -1,14 +1,15 @@
-import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import {
     booleanAttribute,
     ChangeDetectionStrategy,
     Component,
+    computed,
     Directive,
     inject,
-    Input,
     input,
+    signal,
     ViewEncapsulation
 } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { KbqIcon } from '@koobiq/components/icon';
 import { KbqTreeBase, KbqTreeNode } from './tree-base';
 
@@ -20,46 +21,39 @@ export class KbqTreeNodeToggleBaseDirective<T> {
 
     readonly node = input<T>(undefined!);
 
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input('kbqTreeNodeToggleRecursive')
-    get recursive(): boolean {
-        return this._recursive;
-    }
+    /** Whether toggling expands or collapses the whole subtree instead of the node alone. */
+    readonly recursive = input(false, { alias: 'kbqTreeNodeToggleRecursive', transform: booleanAttribute });
 
-    set recursive(value: any) {
-        this._recursive = coerceBooleanProperty(value);
-    }
+    /**
+     * Backing input of `disabled`. Bind through the `disabled` attribute; read the `disabled` getter,
+     * which also reports the toggle disabled while a filter is active.
+     * @docs-private
+     */
+    readonly disabledInput = input(false, { alias: 'disabled', transform: booleanAttribute });
 
-    private _recursive = false;
+    /** Set while a filter is active: filtering already decides what is expanded. */
+    private readonly filterDisabled = signal(false);
 
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input({ transform: booleanAttribute })
-    get disabled(): boolean {
-        return this._disabled;
-    }
+    private readonly disabledState = computed(() => this.disabledInput() || this.filterDisabled());
 
-    set disabled(value: boolean) {
-        if (value !== this.disabled) {
-            this._disabled = value;
-        }
+    get disabled(): boolean {
+        return this.disabledState();
     }
 
-    private _disabled: boolean = false;
-
     get iconState(): boolean {
         return this.tree.treeControl.isExpanded(this.node());
     }
 
     constructor() {
-        this.tree.treeControl.filterValue.subscribe((value) => (this.disabled = !!value?.length));
+        this.tree.treeControl.filterValue
+            .pipe(takeUntilDestroyed())
+            .subscribe((value) => this.filterDisabled.set(!!value?.length));
     }
 
     toggle(event: Event): void {
         if (this.disabled) return;
 
-        if (this.recursive) {
+        if (this.recursive()) {
             this.tree.treeControl.toggleDescendants(this.treeNode.data);
         } else {
             this.tree.treeControl.toggle(this.treeNode.data);
@@ -82,14 +76,21 @@ export class KbqTreeNodeToggleBaseDirective<T> {
     encapsulation: ViewEncapsulation.None,
     host: {
         class: 'kbq-tree-node-toggle',
+        // The expanded state is announced on the owning `treeitem` through `aria-expanded`, and the
+        // Left/Right arrow keys drive it, so exposing the chevron as a second control would only add
+        // a duplicate stop for assistive tech.
+        'aria-hidden': 'true',
         '[class.kbq-expanded]': 'iconState',
         '[attr.disabled]': 'disabled || null',
+        '[attr.aria-disabled]': 'disabled || null',
         '(click)': 'toggle($event)'
     },
     exportAs: 'kbqTreeNodeToggle'
 })
 export class KbqTreeNodeToggleComponent<T> extends KbqTreeNodeToggleBaseDirective<T> {}
 
+// No ARIA on this host: the directive is routinely applied to the `kbq-tree-option` element itself,
+// where the option already owns `role`, `aria-disabled` and the rest of the treeitem semantics.
 @Directive({
     selector: '[kbq-tree-node-toggle], [kbqTreeNodeToggle]',
     host: {
diff --git a/packages/components/tree/tree-base.ts b/packages/components/tree/tree-base.ts
index ce8f83ece7..5a771091d8 100644
--- a/packages/components/tree/tree-base.ts
+++ b/packages/components/tree/tree-base.ts
@@ -2,20 +2,21 @@
 import {
     AfterContentChecked,
     ChangeDetectorRef,
-    ContentChildren,
     DestroyRef,
     Directive,
     ElementRef,
+    EmbeddedViewRef,
     Input,
     IterableChangeRecord,
     IterableDiffer,
     IterableDiffers,
     OnDestroy,
     OnInit,
-    QueryList,
+    Signal,
     TrackByFunction,
     ViewChild,
     ViewContainerRef,
+    contentChildren,
     inject,
     input
 } from '@angular/core';
@@ -32,6 +33,14 @@ import {
     getTreeNoValidDataSourceError
 } from './tree-errors';
 
+/**
+ * Rendering core of the tree.
+ *
+ * Originally forked from `@angular/cdk/tree` and maintained independently since: the node/outlet
+ * contract, the option-based selection model and the filtering pipeline have all diverged, so
+ * `@angular/cdk/tree` is deliberately not a dependency of this package and upstream fixes have to be
+ * ported by hand.
+ */
 @Directive()
 export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {
     protected differs = inject(IterableDiffers);
@@ -48,6 +57,9 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
      * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data
      * relative to the function to know if a node should be added/removed/moved.
      * Accepts a function that takes two parameters, `index` and `item`.
+     *
+     * Views are reused for nodes the function reports as unchanged, which a data source that rebuilds
+     * its node objects on every emission — a flattener among them — otherwise cannot get.
      */
     readonly trackBy = input<TrackByFunction<T>>(undefined!);
 
@@ -55,13 +67,15 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
     @ViewChild(KbqTreeNodeOutlet, { static: true }) nodeOutlet: KbqTreeNodeOutlet;
 
     /** The tree node template for the tree */
-    @ContentChildren(KbqTreeNodeDef) nodeDefs: QueryList<KbqTreeNodeDef<T>>;
+    readonly nodeDefs: Signal<readonly KbqTreeNodeDef<T>[]> = contentChildren(KbqTreeNodeDef);
 
-    // TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.
-    //     Remove the MAX_VALUE in viewChange
     /**
      * Stream containing the latest information on what rows are being displayed on screen.
      * Can be used by the data source to as a heuristic of what data should be provided.
+     *
+     * The tree renders every expanded node eagerly, so the window is the whole data set; a data source
+     * cannot use it to page or virtualize. Windowing would have to emit a real range from a scroll
+     * listener here first.
      */
     viewChange = new BehaviorSubject<{ start: number; end: number }>({ start: 0, end: Number.MAX_VALUE });
 
@@ -77,34 +91,45 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
     /** Level of nodes */
     private levels: Map<T, number> = new Map<T, number>();
 
+    /** Most recently constructed node of this tree, see `registerNode`. */
+    private recentNode: KbqTreeNode<T> | null = null;
+
+    /** Node rendered for a given outlet context, so a reused view can be handed its new data. */
+    private readonly nodesByContext = new WeakMap<KbqTreeNodeOutletContext<T>, KbqTreeNode<T>>();
+
     /**
      * Provides a stream containing the latest data array to render. Influenced by the tree's
      * stream of view window (what dataNodes are currently on screen).
      * Data source can be an observable of data array, or a data array to render.
      */
     // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
+    //  The setter switches the data subscription, which an `input()` cannot express on its own.
     @Input()
-    get dataSource(): DataSource<T> | Observable<T[]> | T[] {
+    get dataSource(): DataSource<T> | Observable<T[]> | T[] | null {
         return this._dataSource;
     }
 
-    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {
+    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[] | null) {
         if (this._dataSource !== dataSource) {
             this.switchDataSource(dataSource);
         }
     }
 
-    private _dataSource: DataSource<T> | Observable<T[]> | T[];
+    private _dataSource: DataSource<T> | Observable<T[]> | T[] | null;
 
     protected readonly destroyRef = inject(DestroyRef);
 
+    /** Whether `ngOnInit` has run, i.e. every initial input binding has been applied. */
+    private initialized = false;
+
     ngOnInit() {
-        this.dataDiffer = this.differs.find([]).create(this.trackBy());
+        this.dataDiffer = this.createDataDiffer();
 
         if (!this.treeControl) {
             throw getTreeControlMissingError();
         }
+
+        this.initialized = true;
     }
 
     ngOnDestroy() {
@@ -121,7 +146,7 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
     }
 
     ngAfterContentChecked() {
-        const defaultNodeDefs = this.nodeDefs.filter((def) => !def.when);
+        const defaultNodeDefs = this.nodeDefs().filter((def) => !def.when);
 
         if (defaultNodeDefs.length > 1) {
             throw getTreeMultipleDefaultNodeDefsError();
@@ -129,7 +154,7 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
 
         this.defaultNodeDef = defaultNodeDefs[0];
 
-        if (this.dataSource && this.nodeDefs && !this.dataSubscription) {
+        if (this.dataSource && this.nodeDefs().length && !this.dataSubscription) {
             this.observeRenderChanges();
         }
     }
@@ -141,10 +166,27 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
         viewContainer: ViewContainerRef = this.nodeOutlet.viewContainer,
         parentData?: T
     ) {
+        if (this.applyNodeChanges(data, dataDiffer, viewContainer, parentData)) {
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+
+    /**
+     * Applies the data changes to the view container without running change detection, and reports
+     * whether anything moved. Split out of `renderNodeChanges` so a subclass can update the state its
+     * own template reads before the single change-detection pass, instead of running a second one.
+     * @docs-private
+     */
+    protected applyNodeChanges(
+        data: T[] | ReadonlyArray<T>,
+        dataDiffer: IterableDiffer<T>,
+        viewContainer: ViewContainerRef,
+        parentData?: T
+    ): boolean {
         const changes = dataDiffer.diff(data);
 
         if (!changes) {
-            return;
+            return false;
         }
 
         changes.forEachOperation(
@@ -162,7 +204,38 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
             }
         );
 
-        this.changeDetectorRef.detectChanges();
+        // A node kept its identity but is a different object — what a data source that rebuilds its
+        // nodes on every emission produces, a flattener among them. The view is reused, so the object
+        // it and its `KbqTreeNode` still hold is gone from `dataNodes`, and every lookup keyed on the
+        // node reference (`getDescendants`, `isExpanded`, the selection) would miss it.
+        changes.forEachIdentityChange((record: IterableChangeRecord<T>) => {
+            this.refreshNodeData(viewContainer, record.currentIndex!, record.item);
+        });
+
+        return true;
+    }
+
+    private refreshNodeData(viewContainer: ViewContainerRef, index: number, nodeData: T): void {
+        const view = viewContainer.get(index) as EmbeddedViewRef<KbqTreeNodeOutletContext<T>> | null;
+
+        if (!view) {
+            return;
+        }
+
+        const { context } = view;
+        const previousData = context.$implicit;
+
+        context.$implicit = nodeData;
+
+        this.levels.delete(previousData);
+        this.levels.set(nodeData, context.level);
+
+        const node = this.nodesByContext.get(context);
+
+        if (node) {
+            node.data = nodeData;
+            node.refresh();
+        }
     }
 
     /**
@@ -172,11 +245,13 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
      * definition.
      */
     getNodeDef(data: T, i: number): KbqTreeNodeDef<T> {
-        if (this.nodeDefs.length === 1) {
-            return this.nodeDefs.first;
+        const nodeDefs = this.nodeDefs();
+
+        if (nodeDefs.length === 1) {
+            return nodeDefs[0];
         }
 
-        const nodeDef = this.nodeDefs.find((def) => def.when && def.when(i, data)) || this.defaultNodeDef;
+        const nodeDef = nodeDefs.find((def) => def.when && def.when(i, data)) || this.defaultNodeDef;
 
         if (!nodeDef) {
             throw getTreeMissingMatchingNodeDefError();
@@ -214,14 +289,24 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
 
         container.createEmbeddedView(node.template, context, index);
 
-        // Set the data to just created `KbqTreeNode`.
-        // The `KbqTreeNode` created from `createEmbeddedView` will be saved in static variable
-        //     `mostRecentTreeNode`. We get it from static variable and pass the node data to it.
-        if (KbqTreeNode.mostRecentTreeNode) {
-            KbqTreeNode.mostRecentTreeNode.data = nodeData;
+        // The `KbqTreeNode` instantiated by `createEmbeddedView` registers itself here on construction,
+        // which is the only handle onto it — the embedded view exposes its context, not its directives.
+        // It is remembered against that context so a later re-render can reach it again.
+        if (this.recentNode) {
+            this.recentNode.data = nodeData;
+            this.nodesByContext.set(context, this.recentNode);
+            this.recentNode = null;
         }
     }
 
+    /**
+     * Called by a `KbqTreeNode` while it is being constructed, so `insertNode` can hand it its data.
+     * @docs-private
+     */
+    registerNode(node: KbqTreeNode<T>): void {
+        this.recentNode = node;
+    }
+
     /** Set up a subscription for the data provided by the data source. */
     private observeRenderChanges() {
         let dataStream: Observable<T[] | ReadonlyArray<T>> | undefined;
@@ -250,7 +335,7 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
      * render change subscription if one exists. If the data source is null, interpret this by
      * clearing the node outlet. Otherwise start listening for new data.
      */
-    private switchDataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {
+    private switchDataSource(dataSource: DataSource<T> | Observable<T[]> | T[] | null) {
         if (this._dataSource && typeof (this._dataSource as DataSource<T>).disconnect === 'function') {
             (this.dataSource as DataSource<T>).disconnect(this);
         }
@@ -260,21 +345,46 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
             this.dataSubscription = null;
         }
 
-        // Remove the all dataNodes if there is now no data source
-        if (!dataSource) {
-            this.nodeOutlet.viewContainer.clear();
-        }
+        // Every rendered node belongs to the previous source, so none of them survives the switch. The
+        // differ is reset below and no longer reports them as removals, which makes these two the only
+        // things that drop the old nodes — for a null source and for a replacement source alike. Left
+        // to the differ, `levels` would keep an entry, and with it a strong reference, for every node
+        // of every source the tree has ever been given.
+        this.nodeOutlet.viewContainer.clear();
+        this.levels.clear();
 
         this._dataSource = dataSource;
 
-        if (this.nodeDefs) {
+        // The differ remembers the nodes of the previous source. Left in place, the first diff against
+        // the new source is computed as a delta from data that is no longer rendered, so views are
+        // reused for unrelated nodes or dropped entirely.
+        this.dataDiffer = this.createDataDiffer();
+
+        // Not before `ngOnInit`: inputs are set one by one, and a template binding `dataSource` ahead of
+        // `treeControl` would have this subscribe — and render — while `treeControl` is still undefined.
+        // The first emission would then throw inside the node directives and take the subscription down
+        // with it, leaving the tree permanently empty. The initial render is picked up by
+        // `ngAfterContentChecked`; a later source swap is observed here right away.
+        if (dataSource && this.initialized && this.nodeDefs().length) {
             this.observeRenderChanges();
         }
     }
+
+    private createDataDiffer(): IterableDiffer<T> {
+        return this.differs.find([]).create(this.trackBy());
+    }
 }
 
+// `KbqTree` declares `role="tree"`, whose owned elements have to be `treeitem`s — and a bare
+// `kbq-tree-node` is the only kind of row it can render, since `KbqTreeOption` needs a parent only
+// `KbqTreeSelection` provides. The nodes are rendered flat into a single outlet, so the depth an AT
+// reports comes from `aria-level` rather than from the DOM.
 @Directive({
     selector: 'kbq-tree-node',
+    host: {
+        role: 'treeitem',
+        '[attr.aria-level]': 'level + 1'
+    },
     exportAs: 'kbqTreeNode'
 })
 export class KbqTreeNode<T> implements IFocusableOption, OnDestroy {
@@ -282,13 +392,23 @@ export class KbqTreeNode<T> implements IFocusableOption, OnDestroy {
     tree = inject<KbqTreeBase<T>>(KbqTreeBase);
 
     /**
-     * The most recently created `KbqTreeNode`. We save it in static variable so we can retrieve it
-     * in `KbqTree` and set the data to it.
+     * The most recently created `KbqTreeNode`, across every tree on the page.
+     *
+     * @deprecated Kept for backwards compatibility only — the tree hands a node its data through
+     * `KbqTreeBase.registerNode`, which is scoped to the tree that owns the node. Will be removed in
+     * version 20.
      */
     static mostRecentTreeNode: KbqTreeNode<any> | null = null;
 
     protected destroyed = new Subject<void>();
 
+    /**
+     * Emits after the tree reused this node's view for a different data object, so a directive on the
+     * same element can re-derive what it computed from the previous one.
+     * @docs-private
+     */
+    readonly refreshed = new Subject<void>();
+
     get data(): T {
         return this._data;
     }
@@ -311,11 +431,24 @@ export class KbqTreeNode<T> implements IFocusableOption, OnDestroy {
 
     constructor() {
         KbqTreeNode.mostRecentTreeNode = this;
+
+        this.tree.registerNode(this);
     }
 
     ngOnDestroy() {
         this.destroyed.next();
         this.destroyed.complete();
+
+        this.refreshed.complete();
+    }
+
+    /**
+     * Called by the tree once `data` has been replaced on a reused view. State a subclass derived from
+     * the previous node — its value, its level — is stale at this point and has to be recomputed.
+     * @docs-private
+     */
+    refresh(): void {
+        this.refreshed.next();
     }
 
     focus(): void {
diff --git a/packages/components/tree/tree-errors.ts b/packages/components/tree/tree-errors.ts
index 8ab7b5cb8f..e54bfd3cbc 100644
--- a/packages/components/tree/tree-errors.ts
+++ b/packages/components/tree/tree-errors.ts
@@ -30,14 +30,6 @@ export function getTreeControlMissingError() {
     return Error(`Could not find a tree control for the tree.`);
 }
 
-/**
- * Returns an error to be thrown when tree control did not implement functions for flat/nested node.
- * @docs-private
- */
-export function getTreeControlFunctionsMissingError() {
-    return Error(`Could not find functions for nested/flat tree in tree control.`);
-}
-
 /**
  * Returns an error to be thrown when the selection mode of a tree is changed while its `SelectionModel`
  * belongs to a host `KbqTreeSelect`.
diff --git a/packages/components/tree/tree-option.component.ts b/packages/components/tree/tree-option.component.ts
index c8f9b65b36..967a83b424 100644
--- a/packages/components/tree/tree-option.component.ts
+++ b/packages/components/tree/tree-option.component.ts
@@ -1,5 +1,6 @@
-import { FocusOrigin } from '@angular/cdk/a11y';
-import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';
+import { SelectionModel } from '@angular/cdk/collections';
 import {
     AfterContentInit,
     booleanAttribute,
@@ -16,6 +17,8 @@ import {
     input,
     NgZone,
     output,
+    QueryList,
+    signal,
     ViewChild,
     ViewEncapsulation
 } from '@angular/core';
@@ -26,6 +29,7 @@ import {
     KbqActionContainer,
     kbqFocusAndReveal,
     kbqFocusOptionActionOnTab,
+    kbqGetElementHeight,
     KbqOptionActionComponent,
     KbqPseudoCheckbox,
     KbqPseudoCheckboxState,
@@ -33,17 +37,45 @@ import {
 } from '@koobiq/components/core';
 import { KbqDropdownTrigger } from '@koobiq/components/dropdown';
 import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
-import { Subject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 import { take } from 'rxjs/operators';
+import { FlatTreeControl } from './control/flat-tree-control';
 import { KbqTreeNodeToggleBaseDirective, KbqTreeNodeToggleComponent, KbqTreeNodeToggleDirective } from './toggle';
-import { KbqTreeNode } from './tree-base';
+import { KbqTreeBase, KbqTreeNode } from './tree-base';
 
 export interface KbqTreeOptionEvent {
     option: KbqTreeOption;
 }
 
+/**
+ * The part of the tree an option talks to.
+ *
+ * Declared as an interface rather than as `KbqTreeSelection` so the token stays free of a circular
+ * import, and so anything embedding options only has to provide these members.
+ */
+export interface KbqTreeOptionParent {
+    /** Whether the whole tree is disabled. */
+    disabled: boolean;
+    /** Whether more than one option can be selected at a time. */
+    multiple: boolean;
+    /** Whether the options render a checkbox. */
+    showCheckbox: boolean;
+    /** Whether the tree is rendered inside a select panel, which makes hovering an option focus it. */
+    inSelect: boolean;
+    /** Whether an option keeps focus while the tree loses it, as a select with a search field needs. */
+    optionShouldHoldFocusOnBlur: boolean;
+    /** State of the tree-level "select all" checkbox. */
+    selectAllState: KbqPseudoCheckboxState;
+    treeControl: FlatTreeControl<any>;
+    selectionModel: SelectionModel<any>;
+    unorderedOptions: QueryList<KbqTreeOption>;
+    setSelectedOptionsByClick(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
+}
+
 /** Injection token used to provide the parent component to options. */
-export const KBQ_TREE_OPTION_PARENT_COMPONENT = new InjectionToken<any>('KBQ_TREE_OPTION_PARENT_COMPONENT');
+export const KBQ_TREE_OPTION_PARENT_COMPONENT = new InjectionToken<KbqTreeOptionParent>(
+    'KBQ_TREE_OPTION_PARENT_COMPONENT'
+);
 
 /**
  * Represents a change event for a tree option.
@@ -52,10 +84,12 @@ export const KBQ_TREE_OPTION_PARENT_COMPONENT = new InjectionToken<any>('KBQ_TRE
  * @param isUserInput - DEPRECATED Will be removed in version 20.
  */
 export class KbqTreeOptionChange {
+    /** @deprecated Will be removed in version 20. */
     isUserInput: boolean;
 
     constructor(
         public source: KbqTreeOption,
+        /** @deprecated Will be removed in version 20. */
         isUserInput = false
     ) {
         this.isUserInput = isUserInput;
@@ -81,6 +115,9 @@ let uniqueIdCounter: number = 0;
     encapsulation: ViewEncapsulation.None,
     host: {
         class: 'kbq-tree-option',
+        // The "select all" row is a treeitem too: `role="checkbox"` would be an invalid child of
+        // `role="tree"`, and `aria-checked` already carries its state.
+        role: 'treeitem',
         '[class.kbq-tree-option_multiple]': 'tree.multiple',
         '[class.kbq-selected]': 'selected',
         '[class.kbq-focused]': 'hasFocus',
@@ -88,7 +125,11 @@ let uniqueIdCounter: number = 0;
         '[class.kbq-action-button-focused]': 'actionButton()?.active',
         '[attr.id]': 'id',
         '[attr.tabindex]': '-1',
-        '[attr.disabled]': 'disabled || null',
+        '[attr.aria-disabled]': 'disabled || null',
+        '[attr.aria-expanded]': 'ariaExpanded',
+        '[attr.aria-level]': 'level + 1',
+        '[attr.aria-checked]': 'ariaChecked',
+        '[attr.aria-selected]': 'ariaSelected',
         '(focusin)': 'focus()',
         '(mouseenter)': 'onMouseenter()',
         '(blur)': 'blur()',
@@ -100,11 +141,19 @@ let uniqueIdCounter: number = 0;
 export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterContentInit, KbqTitleTextRef {
     private changeDetectorRef = inject(ChangeDetectorRef);
     private ngZone = inject(NgZone);
-    tree: any;
+    // Intersected with the rendering base because `KbqTreeNode` resolves its level and expansion state
+    // through it; the option itself only ever touches the `KbqTreeOptionParent` half.
+    override tree: KbqTreeOptionParent & KbqTreeBase<any>;
+
+    private readonly focusEvents = new Subject<KbqTreeOptionEvent>();
+
+    private readonly blurEvents = new Subject<KbqTreeOptionEvent>();
 
-    readonly onFocus = new Subject<KbqTreeOptionEvent>();
+    /** Emits when the option takes focus. */
+    readonly onFocus: Observable<KbqTreeOptionEvent> = this.focusEvents.asObservable();
 
-    readonly onBlur = new Subject<KbqTreeOptionEvent>();
+    /** Emits when the option loses focus. */
+    readonly onBlur: Observable<KbqTreeOptionEvent> = this.blurEvents.asObservable();
 
     preventBlur: boolean = false;
 
@@ -146,15 +195,15 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     // TODO: Skipped for migration because:
     //  Accessor inputs cannot be migrated as they are too complex.
     @Input()
-    get disabled() {
+    get disabled(): boolean {
         if (this.selectAllRow()) {
-            return this._disabled || this.tree!.disabled;
+            return this._disabled || this.tree.disabled;
         }
 
-        return this._disabled || this.tree!.disabled || this.tree.treeControl.isDisabled(this.data);
+        return this._disabled || this.tree.disabled || this.tree.treeControl.isDisabled(this.data);
     }
 
-    set disabled(value: any) {
+    set disabled(value: BooleanInput) {
         const newValue = coerceBooleanProperty(value);
 
         if (newValue !== this._disabled) {
@@ -186,17 +235,24 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     // TODO: Skipped for migration because:
     //  Accessor inputs cannot be migrated as they are too complex.
     @Input()
-    get showCheckbox() {
+    get showCheckbox(): boolean {
         return this._showCheckbox !== undefined ? this._showCheckbox : this.tree.showCheckbox;
     }
 
-    set showCheckbox(value: any) {
+    set showCheckbox(value: BooleanInput) {
         this._showCheckbox = coerceBooleanProperty(value);
     }
 
     private _showCheckbox: boolean;
 
-    readonly onSelectionChange = output<KbqTreeOptionChange>();
+    /** Emits whenever the selected state of the option changes. */
+    readonly selectionChange = output<KbqTreeOptionChange>();
+
+    /** @deprecated Use `selectionChange` instead. Will be removed in version 20. */
+    readonly onSelectionChange = output<KbqTreeOptionChange>({ alias: 'onSelectionChange' });
+
+    // Not an `output()`: `KbqTreeSelect` merges this stream with rxjs, which an `OutputEmitterRef`
+    // cannot feed without wrapping every call site in `outputToObservable`.
     readonly userInteraction = new EventEmitter<void>();
 
     get selected(): boolean {
@@ -224,7 +280,15 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
         return (this.getHostElement().textContent || '').trim();
     }
 
-    hasFocus: boolean = false;
+    get hasFocus(): boolean {
+        return this.focused();
+    }
+
+    set hasFocus(value: boolean) {
+        this.focused.set(value);
+    }
+
+    private readonly focused = signal(false);
 
     get isExpandable(): boolean {
         if (this.selectAllRow()) {
@@ -247,10 +311,50 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
         return !!(this.toggleElementDirective() || this.toggleElementComponent());
     }
 
-    checkboxState: KbqPseudoCheckboxState;
+    get checkboxState(): KbqPseudoCheckboxState {
+        return this.checkbox();
+    }
+
+    set checkboxState(value: KbqPseudoCheckboxState) {
+        this.checkbox.set(value);
+    }
+
+    private readonly checkbox = signal<KbqPseudoCheckboxState>('unchecked');
+
+    /**
+     * `aria-expanded` of the row, reported for every branch and omitted on a leaf.
+     *
+     * Deliberately not `isExpandable`, which also asks whether the toggle is operable: filtering
+     * disables every toggle while leaving the matched branches expanded, and a branch that stops
+     * reporting `aria-expanded` is announced as a leaf while its children are on screen.
+     */
+    protected get ariaExpanded(): boolean | null {
+        if (this.selectAllRow()) {
+            return null;
+        }
+
+        return this.tree.treeControl.isExpandable(this.data) ? this.isExpanded : null;
+    }
+
+    /**
+     * `aria-checked` of the row: tri-state for a checkbox option, and the "select all" state for the
+     * row that drives it. `null` for a plain option, which reports `aria-selected` instead.
+     */
+    protected get ariaChecked(): string | null {
+        if (this.selectAllRow()) {
+            return this.toAriaChecked(this.tree.selectAllState);
+        }
+
+        return this.showCheckbox ? this.toAriaChecked(this.checkboxState) : null;
+    }
+
+    /** `aria-selected` of the row. Options with a checkbox report `aria-checked` instead. */
+    protected get ariaSelected(): boolean | null {
+        return this.selectAllRow() || this.showCheckbox ? null : this.selected;
+    }
 
     constructor() {
-        const tree = inject(KBQ_TREE_OPTION_PARENT_COMPONENT);
+        const tree = inject(KBQ_TREE_OPTION_PARENT_COMPONENT) as KbqTreeOptionParent & KbqTreeBase<any>;
 
         super();
 
@@ -265,6 +369,22 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
         this.value = this.tree.treeControl.getValue(this.data);
     }
 
+    /**
+     * The value and the checkbox state were derived from the node this view held before it was reused,
+     * and `ngAfterContentInit` does not run again. A stale `value` drops the row out of the tree's
+     * `renderedOptions`, so it renders but can no longer be focused, selected or copied.
+     * @docs-private
+     */
+    override refresh(): void {
+        super.refresh();
+
+        if (this.selectAllRow()) return;
+
+        this.value = this.tree.treeControl.getValue(this.data);
+
+        this.markForCheck();
+    }
+
     descendantsAllSelected(): boolean {
         const descendants = this.tree.treeControl.getDescendants(this.data);
 
@@ -289,9 +409,14 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
         if (this.selectAllRow()) return;
 
         if (this.checkboxThirdState() && this.isExpandable) {
-            if (this.descendantsAllSelected()) {
+            // One descendant walk, not two: `getDescendants` is a linear scan of the whole data set, and
+            // the roll-up below repeats this method for every ancestor.
+            const descendants = this.tree.treeControl.getDescendants(this.data);
+            const selectedCount = descendants.filter((child) => this.tree.selectionModel.isSelected(child)).length;
+
+            if (selectedCount === descendants.length) {
                 this.checkboxState = 'checked';
-            } else if (this.descendantsPartiallySelected()) {
+            } else if (selectedCount > 0) {
                 this.checkboxState = 'indeterminate';
             } else {
                 this.checkboxState = this.selected ? 'checked' : 'unchecked';
@@ -334,7 +459,7 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
         kbqFocusAndReveal(this.elementRef.nativeElement, focusOrigin === 'mouse');
 
         if (!this.hasFocus) {
-            this.onFocus.next({ option: this });
+            this.focusEvents.next({ option: this });
 
             Promise.resolve().then(() => {
                 this.hasFocus = true;
@@ -364,14 +489,25 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
 
                     this.hasFocus = false;
 
-                    this.onBlur.next({ option: this });
+                    this.blurEvents.next({ option: this });
                 });
             });
     }
 
     /** @docs-private */
     getHeight(): number {
-        return this.elementRef.nativeElement.getClientRects()[0]?.height ?? 0;
+        return kbqGetElementHeight(this.elementRef.nativeElement);
+    }
+
+    /**
+     * Label the key manager's type-ahead matches against.
+     *
+     * The "select all" row is navigable but is not a data node, and its label is a localized phrase —
+     * answering type-ahead with it would hijack every query starting with that letter.
+     * @docs-private
+     */
+    getLabel(): string {
+        return this.selectAllRow() ? '' : this.viewValue;
     }
 
     select(setFocus = true): void {
@@ -424,7 +560,10 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     }
 
     emitSelectionChangeEvent(): void {
-        this.onSelectionChange.emit(new KbqTreeOptionChange(this));
+        const event = new KbqTreeOptionChange(this);
+
+        this.selectionChange.emit(event);
+        this.onSelectionChange.emit(event);
     }
 
     getHostElement(): HTMLElement {
@@ -445,4 +584,8 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
 
         this.focus('mouse');
     }
+
+    private toAriaChecked(state: KbqPseudoCheckboxState): string {
+        return state === 'indeterminate' ? 'mixed' : `${state === 'checked'}`;
+    }
 }
diff --git a/packages/components/tree/tree-option.scss b/packages/components/tree/tree-option.scss
index 0ddd3a4f19..71d33fc6ec 100644
--- a/packages/components/tree/tree-option.scss
+++ b/packages/components/tree/tree-option.scss
@@ -43,9 +43,6 @@
         display: inline-block;
 
         @include common.kbq-truncate-line();
-
-        padding-top: var(--kbq-list-size-text-padding-vertical, 0);
-        padding-bottom: var(--kbq-list-size-text-padding-vertical, 0);
     }
 
     // Two-line options only: align leading content to the center of the FIRST line.
diff --git a/packages/components/tree/tree-selection.component.spec.ts b/packages/components/tree/tree-selection.component.spec.ts
index 114ed86bf0..3b88b80f0b 100644
--- a/packages/components/tree/tree-selection.component.spec.ts
+++ b/packages/components/tree/tree-selection.component.spec.ts
@@ -10,21 +10,30 @@ import {
     C,
     createKeyboardEvent,
     createMouseEvent,
+    D,
     dispatchEvent,
     dispatchFakeEvent,
     dispatchKeyboardEvent,
     DOWN_ARROW,
+    END,
+    ENTER,
+    HOME,
     KbqMultipleInput,
     KbqOptionActionComponent,
     KbqOptionModule,
     LEFT_ARROW,
     MultipleMode,
+    RIGHT_ARROW,
     SPACE,
+    T,
     TAB,
+    UP_ARROW,
     wrappedErrorMessage
 } from '@koobiq/components/core';
 import { KbqDropdownModule } from '@koobiq/components/dropdown';
 import { KbqTitleDirective, KbqTitleModule } from '@koobiq/components/title';
+import { axe } from 'jest-axe';
+import { BehaviorSubject } from 'rxjs';
 import { AsyncScheduler } from 'rxjs/internal/scheduler/AsyncScheduler';
 import { TestScheduler } from 'rxjs/testing';
 import {
@@ -1390,20 +1399,854 @@ describe('KbqTreeSelection', () => {
             }));
         });
 
+        describe('after a dataSource swap', () => {
+            let fixture: ComponentFixture<SimpleKbqTreeApp>;
+            let component: SimpleKbqTreeApp;
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(SimpleKbqTreeApp);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            /** The level cache is private, and keyed by the node objects it would otherwise pin. */
+            const levelsOf = (tree: KbqTreeSelection) => (tree as unknown as { levels: Map<unknown, number> }).levels;
+
+            it('should drop the level cache of the previous data source', fakeAsync(() => {
+                tick();
+
+                expect(levelsOf(component.tree()).size).toBe(5);
+
+                const nextDataSource = new KbqTreeFlatDataSource(component.treeControl, component.treeFlattener);
+
+                nextDataSource.data = buildFileTree(DATA_OBJECT, 0);
+
+                component.dataSource = nextDataSource;
+                fixture.detectChanges();
+                tick();
+                fixture.detectChanges();
+
+                expect(levelsOf(component.tree()).size).toBe(5);
+            }));
+
+            it('should render the new data source instead of appending it to the old one', fakeAsync(() => {
+                tick();
+
+                expect(getNodes(treeElement).length).toBe(5);
+
+                const nextDataSource = new KbqTreeFlatDataSource(component.treeControl, component.treeFlattener);
+
+                nextDataSource.data = buildFileTree(DATA_OBJECT, 0);
+
+                component.dataSource = nextDataSource;
+                fixture.detectChanges();
+                tick();
+                fixture.detectChanges();
+
+                expect(getNodes(treeElement).length).toBe(5);
+                expect(component.tree().nodesCount).toBe(5);
+            }));
+
+            it('should clear the outlet when the data source is set to null', fakeAsync(() => {
+                tick();
+
+                expect(getNodes(treeElement).length).toBe(5);
+
+                expect(() => (component.tree().dataSource = null)).not.toThrow();
+
+                expect(getNodes(treeElement).length).toBe(0);
+                expect(levelsOf(component.tree()).size).toBe(0);
+            }));
+        });
+
+        describe('with a trackBy function', () => {
+            let fixture: ComponentFixture<TreeWithTrackBy>;
+            let component: TreeWithTrackBy;
+
+            const options = (): KbqTreeOption[] =>
+                fixture.debugElement
+                    .queryAll(By.directive(KbqTreeOption))
+                    .map((debugElement) => debugElement.componentInstance as KbqTreeOption);
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(TreeWithTrackBy);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should re-derive the value and the indentation of a reused row', fakeAsync(() => {
+                tick();
+                fixture.detectChanges();
+
+                const [root, child] = options();
+
+                expect(root.value).toBe('src');
+                expect(child.getHostElement().style.paddingLeft).toBe('48px');
+
+                component.emit([
+                    { id: 1, name: 'source', level: 0, expandable: false },
+                    { id: 2, name: 'docs', level: 2, expandable: false }
+                ]);
+                fixture.detectChanges();
+                tick();
+                fixture.detectChanges();
+
+                // Same instances: the point of the test is the row that was reused rather than rebuilt.
+                expect(options()[0]).toBe(root);
+                expect(options()[1]).toBe(child);
+
+                expect(root.value).toBe('source');
+                expect(child.getHostElement().style.paddingLeft).toBe('60px');
+            }));
+        });
+
         describe('selection with CTRL + A', () => {
             let fixture: ComponentFixture<KbqTreeAppMultiple>;
             let component: KbqTreeAppMultiple;
             let testScheduler: TestScheduler;
 
-            const selectAllKeyEvent = createKeyboardEvent('keydown', A);
+            const selectAllKeyEvent = createKeyboardEvent('keydown', A);
+
+            Object.defineProperty(selectAllKeyEvent, 'ctrlKey', { get: () => true });
+
+            beforeEach(() => {
+                testScheduler = new TestScheduler((act, exp) => expect(exp).toEqual(act));
+
+                configureKbqTreeTestingModule([{ provide: AsyncScheduler, useValue: testScheduler }]);
+                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should select all visible options and values', fakeAsync(() => {
+                expect(component.modelValue.length).toBe(0);
+
+                const onSelectionChange = jest.spyOn(component, 'onSelectionChange');
+                const onSelectAll = jest.spyOn(component, 'onSelectAll');
+
+                component.tree.onKeyDown(selectAllKeyEvent);
+                fixture.detectChanges();
+
+                expect(component.savedSelectionChangeEvent!.option.selected).toBe(false);
+                expect(onSelectionChange).toHaveBeenCalled();
+                expect(component.savedSelectionChangeEvent!.options!.length).toBe(5);
+                expect(onSelectAll).toHaveBeenCalled();
+                expect(component.savedSelectAllEvent!.options.length).toBe(5);
+                expect(component.modelValue.length).toBe(17);
+            }));
+
+            it('should deselect all visible options and values', fakeAsync(() => {
+                component.selectAllToggle = true;
+                fixture.detectChanges();
+
+                component.tree.onKeyDown(selectAllKeyEvent);
+                fixture.detectChanges();
+
+                component.savedSelectionChangeEvent = undefined;
+                component.savedSelectAllEvent = undefined;
+
+                expect(component.modelValue.length).toBe(17);
+
+                component.tree.onKeyDown(selectAllKeyEvent);
+                fixture.detectChanges();
+
+                expect(component.savedSelectionChangeEvent!.options!.length).toBe(5);
+                expect(component.savedSelectAllEvent!.options.length).toBe(5);
+                expect(component.modelValue.length).toBe(0);
+            }));
+
+            it('should select only the matches while a filter is active', fakeAsync(() => {
+                component.treeControl.filterNodes('Sun');
+                tick();
+                fixture.detectChanges();
+
+                component.tree.onKeyDown(selectAllKeyEvent);
+                fixture.detectChanges();
+
+                // `FilterParentsForNodes` keeps the match's ancestors visible, so they take part too.
+                expect(component.modelValue).toEqual(['Pictures', 'Sun']);
+            }));
+
+            it('should not emit selectionChange with an undefined option on a no-op CTRL + A (default)', fakeAsync(() => {
+                // first press selects everything (default: selectAllToggle off)
+                component.tree.onKeyDown(selectAllKeyEvent);
+                fixture.detectChanges();
+
+                const onSelectionChange = jest.spyOn(component, 'onSelectionChange');
+
+                component.savedSelectionChangeEvent = undefined;
+
+                // second press is a no-op: everything is already selected and allowDeselect is off
+                component.tree.onKeyDown(selectAllKeyEvent);
+                fixture.detectChanges();
+
+                expect(onSelectionChange).not.toHaveBeenCalled();
+                expect(component.savedSelectionChangeEvent).toBeUndefined();
+            }));
+        });
+
+        describe('selectAll (standalone kbq-tree-selection, no kbq-tree-select wrapper)', () => {
+            let fixture: ComponentFixture<KbqTreeAppMultiple>;
+            let component: KbqTreeAppMultiple;
+
+            /** All 17 nodes of `DATA_OBJECT`; the 4 branches start out collapsed, so only 5 are rendered. */
+            const ALL_NODES_COUNT = 17;
+
+            const getSelectAllRow = (): HTMLElement | null =>
+                fixture.nativeElement.querySelector('.kbq-tree-option_select-all');
+
+            const clickSelectAll = () => {
+                getSelectAllRow()!.click();
+                fixture.detectChanges();
+            };
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+                component = fixture.componentInstance;
+                component.selectAllEnabled = true;
+                fixture.detectChanges();
+            });
+
+            it('should render the row above the nodes with the locale label', () => {
+                const row = getSelectAllRow();
+
+                expect(row).not.toBeNull();
+                expect(row!.textContent!.trim()).toBe('Выбрать все');
+            });
+
+            it('should not render the row when selectAll is off', () => {
+                component.selectAllEnabled = false;
+                fixture.detectChanges();
+
+                expect(getSelectAllRow()).toBeNull();
+            });
+
+            it('should lead the list the key manager navigates', () => {
+                expect(component.tree.renderedOptions.first).toBe(component.tree.selectAllOption());
+            });
+
+            it('should be unchecked when nothing is selected', () => {
+                expect(component.tree.selectAllState).toBe('unchecked');
+            });
+
+            it('should report an empty state instead of throwing before treeControl is assigned', () => {
+                // `treeControl` is an `@Input`, so a consumer reading these off a template reference —
+                // e.g. to swap the trigger for a "select all" label — gets here on the very pass that
+                // assigns it, while it is still undefined.
+                const uninitialized = Object.create(KbqTreeSelection.prototype) as KbqTreeSelection;
+
+                expect(() => uninitialized.allOptionsSelected).not.toThrow();
+                expect(uninitialized.allOptionsSelected).toBe(false);
+                expect(uninitialized.selectAllState).toBe('unchecked');
+            });
+
+            it('should be indeterminate when only some nodes are selected', () => {
+                component.tree.selectionModel.select(component.tree.treeControl.hasValue('Sun'));
+                fixture.detectChanges();
+
+                expect(component.tree.selectAllState).toBe('indeterminate');
+            });
+
+            it('should be checked when every node is selected', () => {
+                clickSelectAll();
+
+                expect(component.tree.selectAllState).toBe('checked');
+            });
+
+            it('should select every node on click, collapsed branches included', () => {
+                clickSelectAll();
+
+                expect(component.modelValue.length).toBe(ALL_NODES_COUNT);
+            });
+
+            it('should deselect every node on a second click', () => {
+                clickSelectAll();
+                clickSelectAll();
+
+                expect(component.modelValue.length).toBe(0);
+            });
+
+            it('should leave unselectable nodes untouched', () => {
+                component.unselectableNodes = ['Pictures'];
+                fixture.detectChanges();
+
+                clickSelectAll();
+
+                expect(component.modelValue).not.toContain('Pictures');
+            });
+
+            it('should emit onSelectAll on click', () => {
+                clickSelectAll();
+
+                expect(component.savedSelectAllEvent).toBeDefined();
+            });
+
+            it('should do nothing while the tree is disabled', () => {
+                component.treeDisabled = true;
+                fixture.detectChanges();
+
+                clickSelectAll();
+
+                expect(component.modelValue.length).toBe(0);
+            });
+        });
+
+        describe('keyboard navigation with RIGHT_ARROW', () => {
+            let fixture: ComponentFixture<KbqTreeAppDeepData>;
+            let component: KbqTreeAppDeepData;
+
+            const pressKey = (keyCode: number) => {
+                component.tree.onKeyDown(createKeyboardEvent('keydown', keyCode));
+                fixture.detectChanges();
+                flush();
+            };
+
+            const getActiveValue = () => component.tree.keyManager.activeItem?.value;
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(KbqTreeAppDeepData);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should expand a collapsed option without moving the focus', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+
+                expect(getActiveValue()).toBe('src');
+
+                pressKey(RIGHT_ARROW);
+
+                // docs, src, assets, cdk, README, tests
+                expect(getNodes(treeElement).length).toBe(6);
+                expect(getActiveValue()).toBe('src');
+            }));
+
+            it('should move the focus to the first child of an already expanded option', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+                pressKey(RIGHT_ARROW);
+
+                expect(getActiveValue()).toBe('src');
+
+                pressKey(RIGHT_ARROW);
+
+                expect(getActiveValue()).toBe('assets');
+                expect(getNodes(treeElement).length).toBe(6);
+            }));
+
+            it('should do nothing on a leaf', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+
+                expect(getActiveValue()).toBe('docs');
+
+                pressKey(RIGHT_ARROW);
+
+                expect(getActiveValue()).toBe('docs');
+                expect(getNodes(treeElement).length).toBe(3);
+            }));
+
+            it('should skip a disabled first child', fakeAsync(() => {
+                component.disabledNodes = ['assets'];
+                fixture.detectChanges();
+
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+                pressKey(RIGHT_ARROW);
+                pressKey(RIGHT_ARROW);
+
+                expect(getActiveValue()).toBe('cdk');
+            }));
+
+            it('should stay put when every child is disabled', fakeAsync(() => {
+                component.disabledNodes = ['assets', 'cdk', 'README'];
+                fixture.detectChanges();
+
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+                pressKey(RIGHT_ARROW);
+                pressKey(RIGHT_ARROW);
+
+                expect(getActiveValue()).toBe('src');
+            }));
+        });
+
+        describe('keyboard navigation with the remaining keys', () => {
+            let fixture: ComponentFixture<KbqTreeAppDeepData>;
+            let component: KbqTreeAppDeepData;
+
+            /** Matches the default debounce `FocusKeyManager.withTypeAhead` applies to the letter stream. */
+            const typeAheadDebounce = 200;
+
+            const pressKey = (keyCode: number, key?: string) => {
+                component.tree.onKeyDown(createKeyboardEvent('keydown', keyCode, undefined, key));
+                fixture.detectChanges();
+                flush();
+            };
+
+            const getActiveValue = () => component.tree.keyManager.activeItem?.value;
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(KbqTreeAppDeepData);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should step back with UP_ARROW', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+
+                expect(getActiveValue()).toBe('src');
+
+                pressKey(UP_ARROW);
+
+                expect(getActiveValue()).toBe('docs');
+            }));
+
+            it('should jump to the first option with HOME', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+                pressKey(HOME);
+
+                expect(getActiveValue()).toBe('docs');
+            }));
+
+            it('should jump to the last option with END', fakeAsync(() => {
+                pressKey(END);
+
+                expect(getActiveValue()).toBe('tests');
+            }));
+
+            it('should select the active option with ENTER', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(ENTER);
+
+                expect(component.tree.keyManager.activeItem!.selected).toBe(true);
+            }));
+
+            it('should move to the option whose name starts with the typed character', fakeAsync(() => {
+                pressKey(T, 't');
+
+                tick(typeAheadDebounce);
+                fixture.detectChanges();
+                flush();
+
+                expect(getActiveValue()).toBe('tests');
+            }));
+
+            it('should ignore typed characters once type-ahead is turned off', fakeAsync(() => {
+                component.tree.typeAhead = false;
+                fixture.detectChanges();
+
+                pressKey(T, 't');
+
+                tick(typeAheadDebounce);
+                fixture.detectChanges();
+                flush();
+
+                expect(getActiveValue()).toBeUndefined();
+            }));
+
+            it('should not answer a Ctrl/Cmd/Alt shortcut with type-ahead', fakeAsync(() => {
+                const event = createKeyboardEvent('keydown', T, undefined, 't');
+
+                Object.defineProperty(event, 'ctrlKey', { get: () => true });
+
+                component.tree.onKeyDown(event);
+                fixture.detectChanges();
+                flush();
+
+                tick(typeAheadDebounce);
+                fixture.detectChanges();
+                flush();
+
+                expect(getActiveValue()).toBeUndefined();
+            }));
+
+            it('should not answer type-ahead with the select-all row', fakeAsync(() => {
+                const multipleFixture = TestBed.createComponent(KbqTreeAppMultiple);
+
+                multipleFixture.componentInstance.selectAllEnabled = true;
+                multipleFixture.detectChanges();
+                flush();
+
+                // The row's label is "Выбрать все", so an English query cannot match it either way —
+                // `getLabel` reports an empty label for it, which is what keeps it out of every query.
+                expect(multipleFixture.componentInstance.tree.renderedOptions.first.getLabel()).toBe('');
+
+                multipleFixture.componentInstance.tree.onKeyDown(createKeyboardEvent('keydown', D, undefined, 'd'));
+                multipleFixture.detectChanges();
+
+                tick(typeAheadDebounce);
+                multipleFixture.detectChanges();
+                flush();
+
+                expect(multipleFixture.componentInstance.tree.keyManager.activeItem?.value).toBe('Documents');
+            }));
+        });
+
+        describe('tri-state checkbox', () => {
+            let fixture: ComponentFixture<TreeWithThirdStateCheckbox>;
+            let component: TreeWithThirdStateCheckbox;
+
+            const optionFor = (value: string): KbqTreeOption =>
+                component.tree.renderedOptions.find((option) => option.value === value)!;
+
+            const nodeFor = (value: string): HTMLElement => getNodeByText(treeElement, value);
+
+            // `tick()`, not `flush()`: the option-sync pass is scheduled through rxjs `delay(0, scheduler)`,
+            // which schedules on `setInterval` and therefore counts as a periodic task, and `flush()` stops
+            // as soon as only periodic tasks are left in the queue.
+            const settle = () => {
+                fixture.detectChanges();
+                tick();
+                fixture.detectChanges();
+            };
+
+            const clickNode = (value: string) => {
+                dispatchEvent(nodeFor(value), createMouseEvent('click'));
+                settle();
+            };
+
+            const toggleNode = (value: string) => {
+                (nodeFor(value).querySelector('kbq-tree-node-toggle') as HTMLElement).click();
+                settle();
+            };
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(TreeWithThirdStateCheckbox);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should start out unchecked', fakeAsync(() => {
+                flush();
+
+                expect(optionFor('Pictures').checkboxState).toBe('unchecked');
+            }));
+
+            it('should become indeterminate when only some descendants are selected', fakeAsync(() => {
+                toggleNode('Pictures');
+                clickNode('Sun');
+
+                expect(optionFor('Pictures').checkboxState).toBe('indeterminate');
+            }));
+
+            it('should become checked when every descendant is selected', fakeAsync(() => {
+                toggleNode('Pictures');
+                clickNode('Sun');
+                clickNode('Woods');
+                clickNode('PhotoBoothLibrary');
+
+                expect(optionFor('Pictures').checkboxState).toBe('checked');
+            }));
+
+            it('should fall back to indeterminate when a descendant is deselected again', fakeAsync(() => {
+                toggleNode('Pictures');
+                clickNode('Sun');
+                clickNode('Woods');
+                clickNode('PhotoBoothLibrary');
+                clickNode('Sun');
+
+                expect(optionFor('Pictures').checkboxState).toBe('indeterminate');
+            }));
+
+            it('should go back to unchecked once nothing is selected', fakeAsync(() => {
+                toggleNode('Pictures');
+                clickNode('Sun');
+                clickNode('Sun');
+
+                expect(optionFor('Pictures').checkboxState).toBe('unchecked');
+            }));
+
+            it('should keep the rolled-up state while the branch is collapsed', fakeAsync(() => {
+                toggleNode('Pictures');
+                clickNode('Sun');
+                toggleNode('Pictures');
+
+                expect(getNodes(treeElement).length).toBe(5);
+                expect(optionFor('Pictures').checkboxState).toBe('indeterminate');
+            }));
+
+            it('should report the tri-state through aria-checked', fakeAsync(() => {
+                toggleNode('Pictures');
+
+                expect(nodeFor('Pictures').getAttribute('aria-checked')).toBe('false');
+
+                clickNode('Sun');
+
+                expect(nodeFor('Pictures').getAttribute('aria-checked')).toBe('mixed');
+
+                clickNode('Woods');
+                clickNode('PhotoBoothLibrary');
+
+                expect(nodeFor('Pictures').getAttribute('aria-checked')).toBe('true');
+            }));
+
+            it('should check the whole branch through setStateChildren', fakeAsync(() => {
+                toggleNode('Pictures');
+
+                component.tree.setStateChildren(optionFor('Pictures'), true);
+                settle();
+
+                expect(optionFor('Pictures').checkboxState).toBe('checked');
+                expect(optionFor('Sun').selected).toBe(true);
+                expect(optionFor('Woods').selected).toBe(true);
+            }));
+
+            it('should clear the whole branch through setStateChildren', fakeAsync(() => {
+                toggleNode('Pictures');
+
+                component.tree.setStateChildren(optionFor('Pictures'), true);
+                settle();
+
+                // The branch has to actually reach the checked state first: asserting only the cleared one
+                // would pass against the field initialisers, with or without `setStateChildren`.
+                expect(optionFor('Pictures').checkboxState).toBe('checked');
+                expect(optionFor('Sun').selected).toBe(true);
+
+                component.tree.setStateChildren(optionFor('Pictures'), false);
+                settle();
+
+                expect(optionFor('Pictures').checkboxState).toBe('unchecked');
+                expect(optionFor('Sun').selected).toBe(false);
+            }));
+        });
+
+        describe('disabled options', () => {
+            let fixture: ComponentFixture<TreeMultipleWithDisabledNodes>;
+            let component: TreeMultipleWithDisabledNodes;
+
+            // The model is declared over `SelectionModelOption`, but what it actually holds is whatever the
+            // consumer's tree control produced — here a `FileFlatNode`. The cast documents that gap rather
+            // than pretending the declared shape is what comes back out.
+            const selectedValues = () =>
+                component.tree.selectionModel.selected.map((node) =>
+                    component.treeControl.getValue(node as unknown as FileFlatNode)
+                );
+
+            const pressKey = (keyCode: number, modifier?: 'ctrlKey' | 'shiftKey') => {
+                const event = createKeyboardEvent('keydown', keyCode);
+
+                if (modifier) {
+                    Object.defineProperty(event, modifier, { get: () => true });
+                }
+
+                component.tree.onKeyDown(event);
+                fixture.detectChanges();
+                flush();
+            };
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(TreeMultipleWithDisabledNodes);
+
+                component = fixture.componentInstance;
+                component.disabledNodes = ['Documents'];
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should not select a disabled option on click', fakeAsync(() => {
+                dispatchEvent(getNodeByText(treeElement, 'Documents'), createMouseEvent('click'));
+                fixture.detectChanges();
+                flush();
+
+                expect(selectedValues()).toEqual([]);
+            }));
+
+            it('should report the disabled state through aria-disabled', () => {
+                expect(getNodeByText(treeElement, 'Documents').getAttribute('aria-disabled')).toBe('true');
+                expect(getNodeByText(treeElement, 'Pictures').hasAttribute('aria-disabled')).toBe(false);
+            });
+
+            it('should leave a disabled option out of CTRL + A', fakeAsync(() => {
+                pressKey(A, 'ctrlKey');
+
+                expect(selectedValues()).toContain('Pictures');
+                expect(selectedValues()).not.toContain('Documents');
+            }));
+
+            it('should skip a disabled option inside a shift range', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW, 'shiftKey');
+                pressKey(DOWN_ARROW, 'shiftKey');
+                pressKey(DOWN_ARROW, 'shiftKey');
+
+                expect(selectedValues()).toContain('Downloads');
+                expect(selectedValues()).not.toContain('Documents');
+            }));
+        });
+
+        describe('noUnselectLast', () => {
+            let fixture: ComponentFixture<KbqTreeAppMultiple>;
+            let component: KbqTreeAppMultiple;
+
+            // `tick()`, not `flush()`: the option-sync pass is scheduled through rxjs `delay(0, scheduler)`,
+            // which schedules on `setInterval` and therefore counts as a periodic task, and `flush()` stops
+            // as soon as only periodic tasks are left in the queue.
+            const ctrlClick = (index: number) => {
+                const event = createMouseEvent('click');
+
+                Object.defineProperty(event, 'ctrlKey', { get: () => true });
+
+                dispatchEvent(getNodes(treeElement)[index], event);
+                fixture.detectChanges();
+                tick();
+                fixture.detectChanges();
+            };
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should be on by default in keyboard mode', () => {
+                expect(component.tree.noUnselectLast).toBe(true);
+            });
+
+            it('should be off by default in checkbox mode', () => {
+                const checkboxFixture = TestBed.createComponent(KbqTreeAppMultipleCheckbox);
+
+                checkboxFixture.detectChanges();
+
+                expect(checkboxFixture.componentInstance.tree.noUnselectLast).toBe(false);
+            });
+
+            it('should keep the last selected option on a ctrl click', fakeAsync(() => {
+                ctrlClick(0);
+
+                expect(component.tree.selectionModel.selected.length).toBe(1);
+
+                ctrlClick(0);
+
+                expect(component.tree.selectionModel.selected.length).toBe(1);
+            }));
+
+            it('should release the last selected option once it is off', fakeAsync(() => {
+                component.tree.noUnselectLast = false;
+                fixture.detectChanges();
+
+                ctrlClick(0);
+                ctrlClick(0);
+
+                expect(component.tree.selectionModel.selected.length).toBe(0);
+            }));
+
+            it('should keep the last selected option on SPACE', fakeAsync(() => {
+                ctrlClick(0);
+
+                component.tree.onKeyDown(createKeyboardEvent('keydown', SPACE));
+                fixture.detectChanges();
+                tick();
+
+                expect(component.tree.selectionModel.selected.length).toBe(1);
+            }));
+        });
+
+        describe('value accessor', () => {
+            let fixture: ComponentFixture<KbqTreeAppMultiple>;
+            let component: KbqTreeAppMultiple;
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+
+                component = fixture.componentInstance;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
+                fixture.detectChanges();
+            });
+
+            it('should reject a non-array value in multiple mode', () => {
+                expect(() => component.tree.writeValue('Pictures')).toThrow(
+                    'Value must be an array in multiple-selection mode.'
+                );
+            });
+
+            it('should select the options matching the written values', () => {
+                component.tree.writeValue(['Pictures', 'Documents']);
+
+                expect(component.tree.getSelectedValues()).toEqual(['Pictures', 'Documents']);
+            });
+
+            it('should ignore a value with no matching node', () => {
+                component.tree.writeValue(['Pictures', 'nothing']);
+
+                expect(component.tree.getSelectedValues()).toEqual(['Pictures']);
+            });
+
+            it('should clear the selection when written an empty value', () => {
+                component.tree.writeValue(['Pictures']);
+                component.tree.writeValue(null);
+
+                expect(component.tree.getSelectedValues()).toEqual([]);
+            });
+
+            it('should hand the selected values to the registered change callback', () => {
+                const changes: any[] = [];
+
+                component.tree.registerOnChange((value) => changes.push(value));
+                component.tree.setOptionsFromValues(['Pictures']);
+
+                expect(changes[changes.length - 1]).toEqual(['Pictures']);
+            });
+
+            it('should notify the touched callback on blur', () => {
+                const onTouched = jest.fn();
 
-            Object.defineProperty(selectAllKeyEvent, 'ctrlKey', { get: () => true });
+                component.tree.registerOnTouched(onTouched);
+                component.tree.blur();
 
-            beforeEach(() => {
-                testScheduler = new TestScheduler((act, exp) => expect(exp).toEqual(act));
+                expect(onTouched).toHaveBeenCalled();
+            });
 
-                configureKbqTreeTestingModule([{ provide: AsyncScheduler, useValue: testScheduler }]);
-                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+            it('should disable the tree through setDisabledState', () => {
+                component.tree.setDisabledState(true);
+                fixture.detectChanges();
+
+                expect(component.tree.disabled).toBe(true);
+                expect(treeElement.getAttribute('aria-disabled')).toBe('true');
+            });
+        });
+
+        describe('teardown', () => {
+            let fixture: ComponentFixture<KbqTreeAppDeepData>;
+            let component: KbqTreeAppDeepData;
+
+            beforeEach(() => {
+                configureKbqTreeTestingModule();
+                fixture = TestBed.createComponent(KbqTreeAppDeepData);
 
                 component = fixture.componentInstance;
                 treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
@@ -1411,177 +2254,247 @@ describe('KbqTreeSelection', () => {
                 fixture.detectChanges();
             });
 
-            it('should select all visible options and values', fakeAsync(() => {
-                expect(component.modelValue.length).toBe(0);
+            it('should stop rendering the data source it was connected to', () => {
+                expect(treeElement.querySelectorAll('.kbq-tree-option').length).toBe(3);
 
-                const onSelectionChange = jest.spyOn(component, 'onSelectionChange');
-                const onSelectAll = jest.spyOn(component, 'onSelectAll');
+                fixture.destroy();
 
-                component.tree.onKeyDown(selectAllKeyEvent);
-                fixture.detectChanges();
+                // A live subscription would render the new data straight back into the outlet the tree
+                // just cleared — and run change detection over a destroyed view while doing it.
+                component.dataSource.data = buildFileTree(DEEP_DATA_OBJECT, 0);
 
-                expect(component.savedSelectionChangeEvent!.option.selected).toBe(false);
-                expect(onSelectionChange).toHaveBeenCalled();
-                expect(component.savedSelectionChangeEvent!.options!.length).toBe(5);
-                expect(onSelectAll).toHaveBeenCalled();
-                expect(component.savedSelectAllEvent!.options.length).toBe(5);
-                expect(component.modelValue.length).toBe(17);
-            }));
+                expect(treeElement.querySelectorAll('.kbq-tree-option').length).toBe(0);
+            });
 
-            it('should deselect all visible options and values', fakeAsync(() => {
-                component.selectAllToggle = true;
-                fixture.detectChanges();
+            it('should drop the per-option focus subscriptions', fakeAsync(() => {
+                const tree = component.tree;
 
-                component.tree.onKeyDown(selectAllKeyEvent);
+                tree.onKeyDown(createKeyboardEvent('keydown', DOWN_ARROW));
                 fixture.detectChanges();
+                flush();
 
-                component.savedSelectionChangeEvent = undefined;
-                component.savedSelectAllEvent = undefined;
-
-                expect(component.modelValue.length).toBe(17);
+                expect(tree['optionFocusSubscription']).not.toBeNull();
+                expect(tree['optionBlurSubscription']).not.toBeNull();
 
-                component.tree.onKeyDown(selectAllKeyEvent);
-                fixture.detectChanges();
+                fixture.destroy();
 
-                expect(component.savedSelectionChangeEvent!.options!.length).toBe(5);
-                expect(component.savedSelectAllEvent!.options.length).toBe(5);
-                expect(component.modelValue.length).toBe(0);
+                expect(tree['optionFocusSubscription']).toBeNull();
+                expect(tree['optionBlurSubscription']).toBeNull();
             }));
 
-            it('should select only the matches while a filter is active', fakeAsync(() => {
-                component.treeControl.filterNodes('Sun');
-                tick();
-                fixture.detectChanges();
+            it('should not restore the tab index after the tree is gone', fakeAsync(() => {
+                const tree = component.tree;
 
-                component.tree.onKeyDown(selectAllKeyEvent);
+                tree.onKeyDown(createKeyboardEvent('keydown', TAB));
                 fixture.detectChanges();
 
-                // `FilterParentsForNodes` keeps the match's ancestors visible, so they take part too.
-                expect(component.modelValue).toEqual(['Pictures', 'Sun']);
-            }));
+                expect(tree.tabIndex).toBe(-1);
 
-            it('should not emit selectionChange with an undefined option on a no-op CTRL + A (default)', fakeAsync(() => {
-                // first press selects everything (default: selectAllToggle off)
-                component.tree.onKeyDown(selectAllKeyEvent);
-                fixture.detectChanges();
+                fixture.destroy();
+                flush();
 
-                const onSelectionChange = jest.spyOn(component, 'onSelectionChange');
+                expect(tree.tabIndex).toBe(-1);
+            }));
 
-                component.savedSelectionChangeEvent = undefined;
+            it('should stop monitoring the host', () => {
+                const stopMonitoring = jest.spyOn(TestBed.inject(FocusMonitor), 'stopMonitoring');
 
-                // second press is a no-op: everything is already selected and allowDeselect is off
-                component.tree.onKeyDown(selectAllKeyEvent);
-                fixture.detectChanges();
+                fixture.destroy();
 
-                expect(onSelectionChange).not.toHaveBeenCalled();
-                expect(component.savedSelectionChangeEvent).toBeUndefined();
-            }));
+                expect(stopMonitoring).toHaveBeenCalled();
+            });
         });
 
-        describe('selectAll (standalone kbq-tree-selection, no kbq-tree-select wrapper)', () => {
-            let fixture: ComponentFixture<KbqTreeAppMultiple>;
-            let component: KbqTreeAppMultiple;
-
-            /** All 17 nodes of `DATA_OBJECT`; the 4 branches start out collapsed, so only 5 are rendered. */
-            const ALL_NODES_COUNT = 17;
+        describe('accessibility', () => {
+            let fixture: ComponentFixture<KbqTreeAppDeepData>;
+            let component: KbqTreeAppDeepData;
 
-            const getSelectAllRow = (): HTMLElement | null =>
-                fixture.nativeElement.querySelector('.kbq-tree-option_select-all');
+            const nodeFor = (value: string): HTMLElement => getNodeByText(treeElement, value);
 
-            const clickSelectAll = () => {
-                getSelectAllRow()!.click();
+            const settle = () => {
+                fixture.detectChanges();
+                flush();
                 fixture.detectChanges();
             };
 
+            const pressKey = (keyCode: number) => {
+                component.tree.onKeyDown(createKeyboardEvent('keydown', keyCode));
+                settle();
+            };
+
+            const expandSrc = () => {
+                (nodeFor('src').querySelector('kbq-tree-node-toggle') as HTMLElement).click();
+                settle();
+            };
+
             beforeEach(() => {
                 configureKbqTreeTestingModule();
-                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+                fixture = TestBed.createComponent(KbqTreeAppDeepData);
+
                 component = fixture.componentInstance;
-                component.selectAllEnabled = true;
+                treeElement = fixture.nativeElement.querySelector('kbq-tree-selection');
+
                 fixture.detectChanges();
             });
 
-            it('should render the row above the nodes with the locale label', () => {
-                const row = getSelectAllRow();
+            it('should expose the container as a tree', () => {
+                expect(treeElement.getAttribute('role')).toBe('tree');
+            });
 
-                expect(row).not.toBeNull();
-                expect(row!.textContent!.trim()).toBe('Выбрать все');
+            it('should expose every row as a treeitem', () => {
+                expect(getNodes(treeElement).every((node) => node.getAttribute('role') === 'treeitem')).toBe(true);
             });
 
-            it('should not render the row when selectAll is off', () => {
-                component.selectAllEnabled = false;
-                fixture.detectChanges();
+            it('should report the nesting depth on aria-level', fakeAsync(() => {
+                expandSrc();
 
-                expect(getSelectAllRow()).toBeNull();
-            });
+                expect(nodeFor('src').getAttribute('aria-level')).toBe('1');
+                expect(nodeFor('cdk').getAttribute('aria-level')).toBe('2');
+            }));
 
-            it('should lead the list the key manager navigates', () => {
-                expect(component.tree.renderedOptions.first).toBe(component.tree.selectAllOption());
+            it('should report the expanded state of expandable rows only', fakeAsync(() => {
+                expect(nodeFor('src').getAttribute('aria-expanded')).toBe('false');
+                expect(nodeFor('docs').hasAttribute('aria-expanded')).toBe(false);
+
+                expandSrc();
+
+                expect(nodeFor('src').getAttribute('aria-expanded')).toBe('true');
+            }));
+
+            it('should keep reporting the expanded state while a filter disables the toggles', fakeAsync(() => {
+                component.treeControl.filterNodes('a11y');
+                settle();
+
+                // Filtering disables every toggle and expands the matched branches: the rows are still
+                // branches, and dropping `aria-expanded` would announce them as leaves.
+                expect(nodeFor('src').querySelector('kbq-tree-node-toggle')!.hasAttribute('disabled')).toBe(true);
+                expect(nodeFor('src').getAttribute('aria-expanded')).toBe('true');
+                expect(nodeFor('cdk').getAttribute('aria-expanded')).toBe('true');
+            }));
+
+            it('should hide the toggle from assistive technology', () => {
+                expect(nodeFor('src').querySelector('kbq-tree-node-toggle')!.getAttribute('aria-hidden')).toBe('true');
             });
 
-            it('should be unchecked when nothing is selected', () => {
-                expect(component.tree.selectAllState).toBe('unchecked');
+            it('should report the selection through aria-selected when there is no checkbox', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+
+                expect(nodeFor('docs').getAttribute('aria-selected')).toBe('true');
+                expect(nodeFor('src').getAttribute('aria-selected')).toBe('false');
+            }));
+
+            it('should advertise the active option through aria-activedescendant', fakeAsync(() => {
+                expect(treeElement.hasAttribute('aria-activedescendant')).toBe(false);
+
+                pressKey(DOWN_ARROW);
+
+                expect(treeElement.getAttribute('aria-activedescendant')).toBe(nodeFor('docs').id);
+
+                pressKey(DOWN_ARROW);
+
+                expect(treeElement.getAttribute('aria-activedescendant')).toBe(nodeFor('src').id);
+            }));
+
+            it('should move real focus onto the option the arrow keys land on', fakeAsync(() => {
+                pressKey(DOWN_ARROW);
+                pressKey(DOWN_ARROW);
+
+                expect(document.activeElement).toBe(nodeFor('src'));
+            }));
+
+            it('should not announce a single-selection tree as multiselectable', () => {
+                expect(treeElement.hasAttribute('aria-multiselectable')).toBe(false);
             });
 
-            it('should report an empty state instead of throwing before treeControl is assigned', () => {
-                // `treeControl` is an `@Input`, so a consumer reading these off a template reference —
-                // e.g. to swap the trigger for a "select all" label — gets here on the very pass that
-                // assigns it, while it is still undefined.
-                const uninitialized = Object.create(KbqTreeSelection.prototype) as KbqTreeSelection;
+            it('should announce a multiple-selection tree as multiselectable', () => {
+                const multipleFixture = TestBed.createComponent(KbqTreeAppMultiple);
 
-                expect(() => uninitialized.allOptionsSelected).not.toThrow();
-                expect(uninitialized.allOptionsSelected).toBe(false);
-                expect(uninitialized.selectAllState).toBe('unchecked');
+                multipleFixture.detectChanges();
+
+                expect(
+                    multipleFixture.nativeElement
+                        .querySelector('kbq-tree-selection')
+                        .getAttribute('aria-multiselectable')
+                ).toBe('true');
             });
 
-            it('should be indeterminate when only some nodes are selected', () => {
-                component.tree.selectionModel.select(component.tree.treeControl.hasValue('Sun'));
-                fixture.detectChanges();
+            it('should take an accessible name from aria-label', () => {
+                const labelled = TestBed.createComponent(TreeWithAriaLabel);
 
-                expect(component.tree.selectAllState).toBe('indeterminate');
+                labelled.detectChanges();
+
+                expect(labelled.nativeElement.querySelector('kbq-tree-selection').getAttribute('aria-label')).toBe(
+                    'Project files'
+                );
             });
 
-            it('should be checked when every node is selected', () => {
-                clickSelectAll();
+            it('should keep the select-all row a treeitem carrying aria-checked', () => {
+                const multipleFixture = TestBed.createComponent(KbqTreeAppMultiple);
 
-                expect(component.tree.selectAllState).toBe('checked');
+                multipleFixture.componentInstance.selectAllEnabled = true;
+                multipleFixture.detectChanges();
+
+                const row = multipleFixture.nativeElement.querySelector('.kbq-tree-option_select-all');
+
+                expect(row.getAttribute('role')).toBe('treeitem');
+                expect(row.getAttribute('aria-checked')).toBe('false');
             });
+        });
 
-            it('should select every node on click, collapsed branches included', () => {
-                clickSelectAll();
+        describe('accessibility (axe)', () => {
+            let fixture: ComponentFixture<any>;
 
-                expect(component.modelValue.length).toBe(ALL_NODES_COUNT);
+            const attach = (type: any): ComponentFixture<any> => {
+                fixture = TestBed.createComponent(type);
+                fixture.detectChanges();
+                document.body.appendChild(fixture.nativeElement);
+
+                return fixture;
+            };
+
+            beforeEach(() => configureKbqTreeTestingModule());
+
+            afterEach(() => {
+                if (fixture?.nativeElement?.parentNode === document.body) {
+                    document.body.removeChild(fixture.nativeElement);
+                }
             });
 
-            it('should deselect every node on a second click', () => {
-                clickSelectAll();
-                clickSelectAll();
+            it('has no violations with every branch collapsed', async () => {
+                attach(KbqTreeAppDeepData);
 
-                expect(component.modelValue.length).toBe(0);
+                expect(await axe(fixture.nativeElement)).toHaveNoViolations();
             });
 
-            it('should leave unselectable nodes untouched', () => {
-                component.unselectableNodes = ['Pictures'];
-                fixture.detectChanges();
+            it('has no violations with an expanded branch', async () => {
+                attach(KbqTreeAppDeepData);
 
-                clickSelectAll();
+                fixture.componentInstance.treeControl.expandAll();
+                fixture.detectChanges();
 
-                expect(component.modelValue).not.toContain('Pictures');
+                expect(await axe(fixture.nativeElement)).toHaveNoViolations();
             });
 
-            it('should emit onSelectAll on click', () => {
-                clickSelectAll();
+            it('has no violations with tri-state checkboxes', async () => {
+                attach(TreeWithThirdStateCheckbox);
 
-                expect(component.savedSelectAllEvent).toBeDefined();
+                expect(await axe(fixture.nativeElement)).toHaveNoViolations();
             });
 
-            it('should do nothing while the tree is disabled', () => {
-                component.treeDisabled = true;
+            it('has no violations with the select-all row', async () => {
+                fixture = TestBed.createComponent(KbqTreeAppMultiple);
+                fixture.componentInstance.selectAllEnabled = true;
                 fixture.detectChanges();
+                document.body.appendChild(fixture.nativeElement);
 
-                clickSelectAll();
+                expect(fixture.nativeElement.querySelector('.kbq-tree-option_select-all')).not.toBeNull();
+                expect(await axe(fixture.nativeElement)).toHaveNoViolations();
+            });
 
-                expect(component.modelValue.length).toBe(0);
+            it('has no violations with an action button', async () => {
+                attach(TreeWithActionButtonApp);
+
+                expect(await axe(fixture.nativeElement)).toHaveNoViolations();
             });
         });
     });
@@ -1736,6 +2649,13 @@ function getNodes(treeElement: Element): Element[] {
     return [].slice.call(treeElement.querySelectorAll('.kbq-tree-option'))!;
 }
 
+/** Locates a row by its label, so a test does not have to track rendering indexes across expansions. */
+function getNodeByText(treeElement: Element, text: string): HTMLElement {
+    return getNodes(treeElement).find(
+        (node) => node.querySelector('.kbq-option-text')!.textContent!.trim() === text
+    ) as HTMLElement;
+}
+
 function expectFlatTreeToMatch(treeElement: Element, expectedPaddingIndent: number = 28, ...expectedTree: any[]) {
     const missedExpectations: string[] = [];
 
@@ -2158,6 +3078,112 @@ class KbqTreeAppDeepData extends TreeParams {
     }
 }
 
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection multiple="checkbox" [dataSource]="dataSource" [treeControl]="treeControl">
+            <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding [checkboxThirdState]="true">
+                {{ node.name }}
+            </kbq-tree-option>
+
+            <kbq-tree-option *kbqTreeNodeDef="let node; when: hasChild" kbqTreeNodePadding [checkboxThirdState]="true">
+                <kbq-tree-node-toggle />
+
+                {{ node.name }}
+            </kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeWithThirdStateCheckbox extends TreeParams {
+    @ViewChild(KbqTreeSelection, { static: false }) tree: KbqTreeSelection;
+}
+
+/** Node identified by its `id`, so a rename or a re-level reuses the view instead of rebuilding it. */
+interface TrackedNode {
+    id: number;
+    name: string;
+    level: number;
+    expandable: boolean;
+}
+
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection [dataSource]="dataSource" [treeControl]="treeControl" [trackBy]="trackById">
+            <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding>
+                {{ node.name }}
+            </kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeWithTrackBy {
+    // A plain stream rather than a `KbqTreeFlatDataSource`: the nodes have to be replaced through the same
+    // subscription, which is what keeps the differ — and with it the identity-change path — in play.
+    readonly dataSource = new BehaviorSubject<TrackedNode[]>([]);
+
+    readonly treeControl = new FlatTreeControl<TrackedNode>(
+        (node) => node.level,
+        (node) => node.expandable,
+        (node) => node.name,
+        (node) => node.name
+    );
+
+    trackById = (_: number, node: TrackedNode) => node.id;
+
+    constructor() {
+        this.emit([
+            { id: 1, name: 'src', level: 0, expandable: false },
+            { id: 2, name: 'docs', level: 1, expandable: false }
+        ]);
+    }
+
+    emit(nodes: TrackedNode[]): void {
+        this.treeControl.dataNodes = nodes;
+        this.dataSource.next(nodes);
+    }
+}
+
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection multiple="keyboard" [dataSource]="dataSource" [treeControl]="treeControl">
+            <kbq-tree-option
+                *kbqTreeNodeDef="let node"
+                kbqTreeNodePadding
+                [disabled]="disabledNodes.includes(node.name)"
+            >
+                {{ node.name }}
+            </kbq-tree-option>
+
+            <kbq-tree-option
+                *kbqTreeNodeDef="let node; when: hasChild"
+                kbqTreeNodePadding
+                [disabled]="disabledNodes.includes(node.name)"
+            >
+                <kbq-tree-node-toggle />
+
+                {{ node.name }}
+            </kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeMultipleWithDisabledNodes extends TreeParams {
+    disabledNodes: string[] = [];
+    @ViewChild(KbqTreeSelection, { static: false }) tree: KbqTreeSelection;
+}
+
+@Component({
+    imports: [KbqTreeModule],
+    template: `
+        <kbq-tree-selection aria-label="Project files" [dataSource]="dataSource" [treeControl]="treeControl">
+            <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding>{{ node.name }}</kbq-tree-option>
+        </kbq-tree-selection>
+    `
+})
+class TreeWithAriaLabel extends TreeParams {
+    @ViewChild(KbqTreeSelection, { static: false }) tree: KbqTreeSelection;
+}
+
 @Component({
     imports: [
         KbqTreeModule
diff --git a/packages/components/tree/tree-selection.component.ts b/packages/components/tree/tree-selection.component.ts
index 91ff22ecbe..af31de8c0b 100644
--- a/packages/components/tree/tree-selection.component.ts
+++ b/packages/components/tree/tree-selection.component.ts
@@ -21,6 +21,7 @@ import {
     OnDestroy,
     Output,
     output,
+    Provider,
     QueryList,
     signal,
     viewChild,
@@ -43,6 +44,7 @@ import {
     isSelectAll,
     isVerticalMovement,
     KBQ_SELECT_LOCALE_CONFIGURATION,
+    kbqGetElementHeight,
     kbqInjectLocaleConfiguration,
     KbqMultipleInput,
     KbqPseudoCheckbox,
@@ -70,12 +72,15 @@ import { KbqTreeBase } from './tree-base';
 import { getKbqTreeSelectionOwnedMultipleError } from './tree-errors';
 import { KBQ_TREE_OPTION_PARENT_COMPONENT, KbqTreeOption, KbqTreeOptionEvent } from './tree-option.component';
 
-export const KBQ_SELECTION_TREE_VALUE_ACCESSOR: any = {
+export const KBQ_SELECTION_TREE_VALUE_ACCESSOR: Provider = {
     provide: NG_VALUE_ACCESSOR,
     useExisting: forwardRef(() => KbqTreeSelection),
     multi: true
 };
 
+/** How long the key manager collects keystrokes before matching them against the option labels. */
+const typeAheadDebounce = 200;
+
 export class KbqTreeSelectAllEvent<T> {
     constructor(
         public source: KbqTreeSelection,
@@ -131,21 +136,20 @@ interface SelectionModelOption {
     // which is exactly where the row belongs: aligned with the root nodes below it.
     template: `
         @if (showSelectAll) {
-            <!-- Every read of selectAllState re-filters the rendered nodes against the data set, and
-                 allOptionsSelected is that same walk asking whether the state is "checked" — one read
-                 covers all four. -->
+            <!-- Every read of selectAllState re-filters the rendered nodes against the data set, so the
+                 two bindings below share one through @let. The row's own aria-checked host binding walks
+                 it a second time: Ivy evaluates that binding after this template, and the option reads
+                 the state through KBQ_TREE_OPTION_PARENT_COMPONENT rather than from here. -->
             @let selectAllCheckboxState = selectAllState;
 
+            <!-- role and aria-checked come from the option's own host bindings: a host binding runs
+                 after the parent template's, so an override here would be the one that loses. -->
             <kbq-tree-option
                 class="kbq-tree-option_select-all"
                 kbqTreeNodePadding
                 [selectAllRow]="true"
                 [selectable]="false"
                 [class.kbq-selected]="selectAllCheckboxState === 'checked'"
-                [attr.role]="'checkbox'"
-                [attr.aria-checked]="
-                    selectAllCheckboxState === 'indeterminate' ? 'mixed' : selectAllCheckboxState === 'checked'
-                "
                 (click)="toggleSelectAll()"
             >
                 <kbq-pseudo-checkbox [state]="selectAllCheckboxState" />
@@ -164,8 +168,16 @@ interface SelectionModelOption {
     encapsulation: ViewEncapsulation.None,
     host: {
         class: 'kbq-tree-selection',
+        role: 'tree',
         '[attr.tabindex]': 'tabIndex',
         '[attr.disabled]': 'disabled || null',
+        '[attr.aria-disabled]': 'disabled || null',
+        '[attr.aria-multiselectable]': 'multiple || null',
+        '[attr.aria-label]': 'resolvedAriaLabel',
+        '[attr.aria-labelledby]': 'resolvedAriaLabelledby',
+        // The active option takes real DOM focus (`KbqTreeOption.focus`) and is advertised here on top
+        // of that, so an AT that follows either model reports the same row.
+        '[attr.aria-activedescendant]': 'keyManager?.activeItem?.id',
         '(blur)': 'blur()',
         '(focus)': 'focus($event)',
         '(keydown)': 'onKeyDown($event)',
@@ -195,6 +207,32 @@ export class KbqTreeSelection
 
     keyManager: FocusKeyManager<KbqTreeOption>;
 
+    /**
+     * Accessible name of the tree. Set it whenever the tree has no visible label of its own; a tree
+     * embedded in a `kbq-tree-select` is labelled by the select instead.
+     */
+    readonly ariaLabel = input<string>(undefined!, { alias: 'aria-label' });
+
+    /** Id of the element that labels the tree, for when the label is rendered next to it. */
+    readonly ariaLabelledby = input<string>(undefined!, { alias: 'aria-labelledby' });
+
+    /**
+     * Accessible name written to the host.
+     *
+     * The host is the very element the consumer writes, and a host binding runs after their own
+     * `[attr.aria-label]` binding on that element — an unset input reporting `null` would erase the name
+     * they just set, because `[attr.]` never reaches the aliased input. Whatever is already on the
+     * element therefore stands in for an unset input.
+     */
+    protected get resolvedAriaLabel(): string | null {
+        return this.ariaLabel() || this.elementRef.nativeElement.getAttribute('aria-label');
+    }
+
+    /** Labelling element of the host. Falls back to the element's own attribute, see `resolvedAriaLabel`. */
+    protected get resolvedAriaLabelledby(): string | null {
+        return this.ariaLabelledby() || this.elementRef.nativeElement.getAttribute('aria-labelledby');
+    }
+
     /**
      * Model backing the selection.
      *
@@ -230,10 +268,24 @@ export class KbqTreeSelection
 
     readonly navigationChange = output<KbqTreeNavigationChange<KbqTreeOption>>();
 
+    // Not an `output()`: `KbqTreeSelect` pipes this stream with rxjs, which an `OutputEmitterRef`
+    // cannot feed without wrapping every call site in `outputToObservable`.
     @Output() readonly selectionChange = new EventEmitter<KbqTreeSelectionChange<KbqTreeOption>>();
 
-    readonly onSelectAll = output<KbqTreeSelectAllEvent<KbqTreeOption>>();
+    /** Emits after "select all" ran, with the options it could act on. */
+    readonly selectAllChange = output<KbqTreeSelectAllEvent<KbqTreeOption>>();
+
+    /** @deprecated Use `selectAllChange` instead. Will be removed in version 20. */
+    readonly onSelectAll = output<KbqTreeSelectAllEvent<KbqTreeOption>>({ alias: 'onSelectAll' });
 
+    /**
+     * Emits when the active option is copied with Ctrl/Cmd + C. Subscribing replaces the built-in
+     * clipboard handler, so the event has to stay an `EventEmitter`: the decision is made by reading
+     * `observed`, which `OutputEmitterRef` does not have.
+     */
+    @Output() readonly copyChange = new EventEmitter<KbqTreeCopyEvent<KbqTreeOption>>();
+
+    /** @deprecated Use `copyChange` instead. Will be removed in version 20. */
     @Output() readonly onCopy = new EventEmitter<KbqTreeCopyEvent<KbqTreeOption>>();
 
     private sortedNodes: KbqTreeOption[] = [];
@@ -328,6 +380,29 @@ export class KbqTreeSelection
     /** `null` while the consumer has not set the input, i.e. while the value is derived from the mode. */
     private _noUnselectLast: boolean | null = null;
 
+    /**
+     * Whether typing printable characters moves the focus to the next option whose label starts with
+     * them. On by default.
+     *
+     * Turn it off wherever the tree shares its keystrokes with a text field: an embedder such as
+     * `KbqTreeSelect` routes everything the user types — the search query included — into this key
+     * manager, and type-ahead would move the active option out from under the query.
+     */
+    // Written imperatively by `KbqTreeSelect`, like `autoSelect` and `noUnselectLast`, so it cannot be a
+    // signal input.
+    @Input({ transform: booleanAttribute })
+    get typeAhead(): boolean {
+        return this._typeAhead;
+    }
+
+    set typeAhead(value: boolean) {
+        this._typeAhead = value;
+
+        this.applyTypeAhead();
+    }
+
+    private _typeAhead = true;
+
     /** When `true`, a repeated Ctrl/Cmd+A deselects all options. Off by default (Ctrl+A only selects). */
     readonly selectAllToggle = input(false, { transform: booleanAttribute });
 
@@ -384,7 +459,7 @@ export class KbqTreeSelection
      * is on screen. Without a filter the whole data set qualifies, collapsed branches included.
      */
     // `any`, not `unknown`: `treeControl`/`selectionModel` are themselves `any`-typed data-node generics
-    // pre-dating this feature (`KbqTreeBase<any>`, `SelectionModel<SelectionModelOption>`), so `unknown`
+    // pre-dating this feature (`KbqTreeBase<any>`, `SelectionModel<any>`), so `unknown`
     // here would only relocate the unsafety into a cast at every call site, not remove it.
     private get selectAllTargets(): any[] {
         // `treeControl` is an `@Input`, so it is still unset on the change-detection pass that sets it:
@@ -478,6 +553,9 @@ export class KbqTreeSelection
 
     private selectionModelSubscription: Subscription | null = null;
 
+    /** Pending restore of the tab index after the key manager tabbed out, see `allowFocusEscape`. */
+    private restoreTabIndexTimeout: ReturnType<typeof setTimeout> | undefined;
+
     /** Whether a value report is already queued for the end of the current tick. */
     private pendingValueReport = false;
 
@@ -620,14 +698,22 @@ export class KbqTreeSelection
 
     ngAfterContentInit(): void {
         if (this.platform.isBrowser) {
-            this.unorderedOptions.changes.subscribe(this.updateRenderedOptions);
+            this.unorderedOptions.changes
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe(this.updateRenderedOptions);
         }
 
         this.keyManager = new FocusKeyManager<KbqTreeOption>(this.renderedOptions)
             .withVerticalOrientation(true)
             .withHorizontalOrientation(null);
 
+        this.applyTypeAhead();
+
         this.keyManager.change.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            // `aria-activedescendant` is bound to the active option, and nothing else in this view
+            // changes when the key manager moves.
+            this.changeDetectorRef.markForCheck();
+
             if (this.keyManager.activeItem) {
                 this.emitNavigationEvent(this.keyManager.activeItem);
 
@@ -688,6 +774,10 @@ export class KbqTreeSelection
     ngOnDestroy(): void {
         super.ngOnDestroy();
 
+        clearTimeout(this.restoreTabIndexTimeout);
+
+        this.dropSubscriptions();
+
         this.focusMonitor.stopMonitoring(this.elementRef);
     }
 
@@ -707,8 +797,20 @@ export class KbqTreeSelection
         this.keyManager.setFocusOrigin('program');
     }
 
+    /** @docs-private */
     highlightSelectedOption(): void {
-        this.renderedOptions.find((item) => item.data === this.selectionModel.selected[0])?.focus();
+        // The selection can hold nodes that are not rendered — collapsed branches, or references left
+        // over from a data replacement. Falling back keeps `focus()` from ending with nothing focused
+        // at all, since it already took the branch that skips `setFirstItemActive`.
+        const target =
+            this.renderedOptions.find((item) => item.data === this.selectionModel.selected[0]) ??
+            this.keyManager.activeItem;
+
+        if (target) {
+            target.focus();
+        } else {
+            this.keyManager.setFirstItemActive();
+        }
     }
 
     blur() {
@@ -764,8 +866,14 @@ export class KbqTreeSelection
             }
 
             return;
-        } else if (keyCode === RIGHT_ARROW && this.keyManager.activeItem?.isExpandable) {
-            this.treeControl.expand(this.keyManager.activeItem.data as KbqTreeOption);
+        } else if (keyCode === RIGHT_ARROW && this.keyManager.activeItem) {
+            const activeItem = this.keyManager.activeItem;
+
+            if (activeItem.isExpandable && !activeItem.isExpanded) {
+                this.treeControl.expand(activeItem.data as KbqTreeOption);
+            } else if (activeItem.isExpandable) {
+                this.setActiveFirstChildOption(activeItem);
+            }
 
             return;
         } else if (keyCode === DOWN_ARROW) {
@@ -784,6 +892,19 @@ export class KbqTreeSelection
             this.keyManager.setPreviousPageItemActive();
         } else if (keyCode === PAGE_DOWN) {
             this.keyManager.setNextPageItemActive();
+        } else {
+            // Whatever is left is either a printable character, which the key manager turns into a
+            // type-ahead query, or a key nothing here reacts to. Every key handled above returns or is
+            // matched before this point, so the manager only ever sees the leftovers.
+            //
+            // Ctrl/Cmd/Alt combinations are the application's shortcuts, not text: the key manager feeds
+            // its letter stream from the `default` branch without a modifier guard of its own, so Ctrl+S
+            // would otherwise type-ahead to the first option starting with "S" and move focus there.
+            if (!hasModifierKey(event, 'ctrlKey', 'metaKey', 'altKey')) {
+                this.keyManager.onKeydown(event);
+            }
+
+            return;
         }
 
         if (this.keyManager.activeItem && isVerticalMovement(event)) {
@@ -796,6 +917,7 @@ export class KbqTreeSelection
         }
     }
 
+    /** @docs-private */
     updateScrollSize(): void {
         if (!this.renderedOptions.first) {
             return;
@@ -804,6 +926,7 @@ export class KbqTreeSelection
         this.keyManager.withScrollSize(Math.floor(this.getHeight() / this.renderedOptions.first.getHeight()));
     }
 
+    /** @docs-private */
     setSelectedOptionsByKey(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void {
         if (shiftKey && this.multiple) {
             this.selectActiveOptions();
@@ -821,6 +944,7 @@ export class KbqTreeSelection
         }
     }
 
+    /** @docs-private */
     setSelectedOptionsByClick(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void {
         if (option.disabled || !option.selectable()) {
             return;
@@ -849,7 +973,8 @@ export class KbqTreeSelection
         this.emitChangeEvent(option);
     }
 
-    selectActiveOptions(): void {
+    /** @docs-private */
+    protected selectActiveOptions(): void {
         const options = this.renderedOptions.toArray();
 
         let fromIndex = this.keyManager.previousActiveItemIndex;
@@ -881,11 +1006,13 @@ export class KbqTreeSelection
             });
     }
 
-    setFocusedOption(option: KbqTreeOption): void {
+    /** @docs-private */
+    protected setFocusedOption(option: KbqTreeOption): void {
         this.keyManager.setActiveItem(option);
     }
 
-    toggleFocusedOption(): void {
+    /** @docs-private */
+    protected toggleFocusedOption(): void {
         const focusedOption = this.keyManager.activeItem;
 
         // The row is not selectable, so nothing below would act on it. Handling it here covers both focus
@@ -904,24 +1031,30 @@ export class KbqTreeSelection
         }
     }
 
+    /** @docs-private */
     renderNodeChanges(
         data: KbqTreeOption[],
         dataDiffer: IterableDiffer<KbqTreeOption> = this.dataDiffer,
         viewContainer: ViewContainerRef = this.nodeOutlet.viewContainer,
         parentData?: KbqTreeOption
     ): void {
-        super.renderNodeChanges(data, dataDiffer, viewContainer, parentData);
+        // Not `super.renderNodeChanges`: that would run change detection over this very view before
+        // `sortedNodes` is refreshed, so the "select all" row — which is rendered off `isEmpty` — would
+        // need a second pass to catch up. One pass, after the state its template reads is current.
+        this.applyNodeChanges(data, dataDiffer, viewContainer, parentData);
 
         this.sortedNodes = this.getSortedNodes(viewContainer);
 
-        this.nodeOutlet.changeDetectorRef.detectChanges();
+        this.changeDetectorRef.detectChanges();
     }
 
-    emitNavigationEvent(option: KbqTreeOption): void {
+    /** @docs-private */
+    protected emitNavigationEvent(option: KbqTreeOption): void {
         this.navigationChange.emit(new KbqTreeNavigationChange(this, option));
     }
 
-    emitChangeEvent(option: KbqTreeOption): void {
+    /** @docs-private */
+    protected emitChangeEvent(option: KbqTreeOption): void {
         this.selectionChange.emit(new KbqTreeSelectionChange(this, option, [option]));
     }
 
@@ -971,7 +1104,10 @@ export class KbqTreeSelection
             this.selectionChange.emit(new KbqTreeSelectionChange(this, changedOptions[0], changedOptions));
         }
 
-        this.onSelectAll.emit(new KbqTreeSelectAllEvent(this, selectableOptions));
+        const selectAllEvent = new KbqTreeSelectAllEvent(this, selectableOptions);
+
+        this.selectAllChange.emit(selectAllEvent);
+        this.onSelectAll.emit(selectAllEvent);
     }
 
     copyActiveOption(event: KeyboardEvent): void {
@@ -981,8 +1117,11 @@ export class KbqTreeSelection
 
         option.preventBlur = true;
 
-        if (this.onCopy.observed) {
-            this.onCopy.emit(new KbqTreeCopyEvent(this, this.keyManager.activeItem as KbqTreeOption, event));
+        if (this.copyChange.observed || this.onCopy.observed) {
+            const copyEvent = new KbqTreeCopyEvent(this, this.keyManager.activeItem as KbqTreeOption, event);
+
+            this.copyChange.emit(copyEvent);
+            this.onCopy.emit(copyEvent);
         } else {
             this.onCopyDefaultHandler();
 
@@ -1014,8 +1153,7 @@ export class KbqTreeSelection
     /** `View -> model callback called when select has been touched` */
     onTouched = () => {};
 
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    registerOnTouched(fn: () => {}): void {
+    registerOnTouched(fn: () => void): void {
         this.onTouched = fn;
     }
 
@@ -1027,6 +1165,7 @@ export class KbqTreeSelection
         this.changeDetectorRef.markForCheck();
     }
 
+    /** @docs-private */
     setOptionsFromValues(values: any[]): void {
         this.selectionModel.clear();
 
@@ -1077,13 +1216,15 @@ export class KbqTreeSelection
         this.selectionModel.setSelection(...reconciled);
     }
 
+    /** @docs-private */
     getSelectedValues(): any[] {
         const selectedValues = this.selectionModel.selected.map((selected) => this.treeControl.getValue(selected));
 
         return this.multiple ? selectedValues : selectedValues[0];
     }
 
-    getItemHeight(): number {
+    /** @docs-private */
+    protected getItemHeight(): number {
         return this.renderedOptions.first ? this.renderedOptions.first.getHeight() : 0;
     }
 
@@ -1136,8 +1277,39 @@ export class KbqTreeSelection
         }
     }
 
+    /** `-1` is the key manager's way of keeping the letter stream running but never matching on it. */
+    private applyTypeAhead(): void {
+        this.keyManager?.withTypeAhead(typeAheadDebounce, this._typeAhead ? 0 : -1);
+    }
+
+    /**
+     * Moves focus to the first child of an already-expanded option — ArrowRight on an expanded node.
+     *
+     * The mirror of `setActiveParentOption`: the first rendered option after the active one is its
+     * first child whenever its level is greater, so nothing has to be re-derived from `treeControl`.
+     * A disabled child cannot take focus, so the walk continues while the options stay inside the
+     * subtree, and stops as soon as the level falls back to the active option's own.
+     */
+    private setActiveFirstChildOption(activeOption: KbqTreeOption): void {
+        const options = this.renderedOptions.toArray();
+
+        for (let index = this.keyManager.activeItemIndex + 1; index < options.length; index++) {
+            const option = options[index];
+
+            if (option.level <= activeOption.level) {
+                return;
+            }
+
+            if (!option.disabled) {
+                this.keyManager.setActiveItem(index);
+
+                return;
+            }
+        }
+    }
+
     private getHeight(): number {
-        return this.elementRef.nativeElement.getClientRects()[0]?.height ?? 0;
+        return kbqGetElementHeight(this.elementRef.nativeElement);
     }
 
     private updateTabIndex(): void {
@@ -1186,7 +1358,9 @@ export class KbqTreeSelection
         if (this._tabIndex !== -1) {
             this._tabIndex = -1;
 
-            setTimeout(() => {
+            clearTimeout(this.restoreTabIndexTimeout);
+
+            this.restoreTabIndexTimeout = setTimeout(() => {
                 this._tabIndex = this.userTabIndex || 0;
                 this.changeDetectorRef.markForCheck();
             });
@@ -1221,7 +1395,16 @@ export class KbqTreeSelection
             }
         });
 
-        this.optionBlurSubscription = this.optionBlurChanges.subscribe(() => this.blur());
+        // Moving the active option blurs the one being left, so an option blur alone does not mean the
+        // tree lost the focus — and `blur()` would reset the active option the key manager has just set,
+        // because `KbqTreeOption.hasFocus` is cleared synchronously but only raised a microtask later, so
+        // `hasFocusedOption()` reports nothing focused for the whole move. Only a blur of the option the
+        // key manager still points at is the focus actually leaving the tree.
+        this.optionBlurSubscription = this.optionBlurChanges.subscribe(({ option }) => {
+            if (option === this.keyManager.activeItem) {
+                this.blur();
+            }
+        });
     }
 
     /**
diff --git a/packages/components/tree/tree-tokens.scss b/packages/components/tree/tree-tokens.scss
index 41378277f9..7104566c96 100644
--- a/packages/components/tree/tree-tokens.scss
+++ b/packages/components/tree/tree-tokens.scss
@@ -4,8 +4,9 @@
     --kbq-tree-size-container-padding-right: var(--kbq-size-s);
     --kbq-tree-size-container-padding-vertical: var(--kbq-size-xxs);
     --kbq-tree-size-container-content-gap-horizontal: var(--kbq-size-s);
-    --kbq-tree-size-container-content-gap-vertical: 0px;
     --kbq-tree-size-container-focus-outline-width: var(--kbq-size-3xs);
+    /* Not applied to `.kbq-option-text`: 2px above and below every line grows two-line rows and drops
+       the text below the chevron and the checkbox beside it. Applying it is a design decision. */
     --kbq-tree-size-text-padding-vertical: var(--kbq-size-3xs);
     --kbq-tree-option-border-radius: var(--kbq-size-border-radius);
     /* THEME TOKENS */
diff --git a/packages/components/tree/tree.en.md b/packages/components/tree/tree.en.md
index 43d372a0d6..bd98c0b3f0 100644
--- a/packages/components/tree/tree.en.md
+++ b/packages/components/tree/tree.en.md
@@ -81,7 +81,7 @@ There are several variants for multiple item selection. [See in examples](/en/co
 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | <span class="docs-hot-key-button">Tab</span>                                                                                                                                                         | If focus is on the component preceding the tree in tab order → Move to the first tree row or the selected row<br />If focus is on any tree item and it has no additional actions → Move to the next component in tab order after the tree<br />If focus is on any tree item and it has additional actions → Move to the first additional action<br />If focus is on an item's additional action → Move to the next additional action (if one exists), otherwise move to the next component in tab order after the tree |
 | <span class="docs-hot-key-button">Shift</span> + <span class="docs-hot-key-button">Tab</span>                                                                                                        | If focus is on any tree item → Move to the previous component in tab order before the tree<br />If focus is on the component following the tree in tab order → Move to the first tree row or the selected row                                                                                                                                                                                                                                                                                                          |
-| <span class="docs-hot-key-button">→</span>                                                                                                                                                           | If focus is on a non-leaf item → Expand the nested items of that item<br />If focus is on a leaf item → Nothing happens                                                                                                                                                                                                                                                                                                                                                                                                |
+| <span class="docs-hot-key-button">→</span>                                                                                                                                                           | If focus is on a collapsed non-leaf item → Expand the nested items of that item<br />If focus is on an expanded non-leaf item → Move to its first nested item<br />If focus is on a leaf item → Nothing happens                                                                                                                                                                                                                                                                                                        |
 | <span class="docs-hot-key-button">←</span>                                                                                                                                                           | If focus is on an expanded non-leaf item → Collapse the nested items of that item<br />If focus is on a collapsed non-leaf item → Move to its parent item<br />If focus is on a leaf item → Move to its parent item<br />If focus is on a top-level item → Nothing happens                                                                                                                                                                                                                                             |
 | <span class="docs-hot-key-button">↵</span>                                                                                                                                                           | If focus is on a tree item → Trigger the primary action of that item<br />If focus is on a tree item with a checkbox → Nothing happens<br />If focus is on an additional action → Apply that additional action                                                                                                                                                                                                                                                                                                         |
 | <span class="docs-hot-key-button">Space</span>                                                                                                                                                       | If focus is on a tree item with a checkbox → Select that tree item (and all nested items, if any)<br />If focus is on a tree item → Nothing happens<br />If focus is on an additional action → Apply that additional action                                                                                                                                                                                                                                                                                            |
@@ -94,3 +94,32 @@ There are several variants for multiple item selection. [See in examples](/en/co
 | <span class="docs-hot-key-button">Shift</span> + <span class="docs-hot-key-button">↓</span> <br /><br /> <span class="docs-hot-key-button">Shift</span> + <span class="docs-hot-key-button">↑</span> | If focus is on a tree item → Multiple selection of the next / previous tree items (if the row is the first or last — nothing happens)                                                                                                                                                                                                                                                                                                                                                                                  |
 | <span class="docs-hot-key-button">Ctrl</span> + <span class="docs-hot-key-button">C</span>                                                                                                           | If focus is on tree items → Copy the content of the items<br />By default, item names are copied. The separator between items is a line break                                                                                                                                                                                                                                                                                                                                                                          |
 | <span class="docs-hot-key-button">Ctrl</span> + <span class="docs-hot-key-button">A</span>                                                                                                           | If focus is on any tree item → Select all tree items (including unloaded ones)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| Printable characters                                                                                                                                                                                 | Move focus to the next item whose name starts with the typed characters. Typing several characters in quick succession matches them as one word                                                                                                                                                                                                                                                                                                                                                                        |
+
+### Accessibility
+
+The tree exposes the structure it renders to assistive technology, so a screen reader announces an
+item's nesting depth and whether it is expanded, selected or checked.
+
+- The tree is a `role="tree"`, each row a `role="treeitem"`.
+- The tab stop stays on the tree itself and the rows stay at `tabindex="-1"`, but the row the arrow
+  keys land on does take real focus, and is advertised through `aria-activedescendant` on top of that.
+- Branch rows carry `aria-expanded` — including while a filter is active, which disables the chevrons
+  without turning the branches into leaves — and every row carries `aria-level`.
+- Rows with a checkbox report `aria-checked`, including `mixed` for a partially selected branch; rows
+  without one report `aria-selected`.
+- Expand/collapse chevrons are hidden from assistive technology: their state is already on the row, and
+  the ← and → keys drive them.
+- The tree has no visible label of its own, so give it an accessible name with `aria-label`, or point
+  `aria-labelledby` at the element that labels it. A tree inside a `kbq-tree-select` is labelled by the
+  select and needs neither.
+
+### Rendering
+
+Every expanded item is rendered, with no windowing — a collapsed branch costs nothing, an expanded one
+costs a DOM row per item. A tree that shows thousands of rows at once should keep its branches
+collapsed or narrow the data with the search field.
+
+Nodes are tracked by identity by default, so a data source that rebuilds its node objects on every
+emission — a flattener among them — rebuilds every row. Pass a `trackBy` function returning a stable
+key to have the rows re-used across data updates instead.
diff --git a/packages/components/tree/tree.ru.md b/packages/components/tree/tree.ru.md
index fea159a318..458f1304eb 100644
--- a/packages/components/tree/tree.ru.md
+++ b/packages/components/tree/tree.ru.md
@@ -80,7 +80,7 @@
 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | <span class="docs-hot-key-button">Tab</span>                                                                                                                                                         | Если фокус установлен на предыдущем компоненте в таб-последовательности по отношению к дереву → Переход к первой строке дерева или к выделенной строке<br />Если фокус установлен на любом элементе дерева и у него нет доп. действий → Переход к следующему компоненту в таб-последовательности по отношению к дереву<br />Если фокус установлен на любом элементе дерева и у него есть доп. действия → Переход к первому доп. действию <br />Если фокус установлен на доп. действии элемента → Переход к следующему доп. действию (если оно есть), иначе переход к следующему компоненту в таб-последовательности по отношению к дереву |
 | <span class="docs-hot-key-button">Shift</span> + <span class="docs-hot-key-button">Tab</span>                                                                                                        | Если фокус установлен на любом элементе дерева → Переход к предыдущему компоненту в таб-последовательности по отношению к дереву <br /> Если фокус установлен на следующем компоненте в таб-последовательности по отношению к дереву → Переход к первой строке дерева или к выделенной строке                                                                                                                                                                                                                                                                                                                                             |
-| <span class="docs-hot-key-button">→</span>                                                                                                                                                           | Если фокус установлен на нелистовом элементе → Раскрытие вложенных элементов этого элемента <br /> Если фокус установлен на листовом элементе → Ничего не происходит                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| <span class="docs-hot-key-button">→</span>                                                                                                                                                           | Если фокус установлен на закрытом нелистовом элементе → Раскрытие вложенных элементов этого элемента <br /> Если фокус установлен на раскрытом нелистовом элементе → Переход к первому вложенному элементу <br /> Если фокус установлен на листовом элементе → Ничего не происходит                                                                                                                                                                                                                                                                                                                                                       |
 | <span class="docs-hot-key-button">←</span>                                                                                                                                                           | Если фокус установлен на раскрытом нелистовом элементе → Закрытие вложенных элементов этого элемента <br /> Если фокус установлен на закрытом нелистовом элементе → Переход к родительскому элементу <br /> Если фокус установлен на листовом элементе → Переход к родительскому элементу <br /> Если фокус установлен на элементе верхнего уровня → Ничего не происходит                                                                                                                                                                                                                                                                 |
 | <span class="docs-hot-key-button">↵</span>                                                                                                                                                           | Если фокус установлен на элементе дерева → Запуск основного действия этого элемента <br /> Если фокус установлен на элементе дерева с чекбоксом → Ничего не происходит <br /> Если фокус установлен на доп. действии → применение этого доп. действия                                                                                                                                                                                                                                                                                                                                                                                     |
 | <span class="docs-hot-key-button">Space</span>                                                                                                                                                       | Если фокус установлен на элементе дерева с чекбоксом → Выбрать этот элемент дерева (и все вложенные, если есть) <br /> Если фокус установлен на элементе дерева → Ничего не происходит <br /> Если фокус установлен на доп. действии → применение этого доп. действия                                                                                                                                                                                                                                                                                                                                                                     |
@@ -93,3 +93,32 @@
 | <span class="docs-hot-key-button">Shift</span> + <span class="docs-hot-key-button">↓</span> <br /><br /> <span class="docs-hot-key-button">Shift</span> + <span class="docs-hot-key-button">↑</span> | Если фокус установлен на элементе дерева → Множественный выбор следующих / предыдущих элементов дерева (если строка первая или последняя — ничего не происходит)                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | <span class="docs-hot-key-button">Ctrl</span> + <span class="docs-hot-key-button">C</span>                                                                                                           | Если фокус установлен на элементах дерева → Копирование содержимого элементов <br /> По умолчанию копируются названия элементов. Разделитель между элементами — перенос строки                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | <span class="docs-hot-key-button">Ctrl</span> + <span class="docs-hot-key-button">A</span>                                                                                                           | Если фокус установлен на любом элементе дерева → Выбрать все элементы дерева (включая незагруженные)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| Печатные символы                                                                                                                                                                                     | Переход к следующему элементу, название которого начинается с введённых символов. Несколько символов, набранных подряд, ищутся как одно слово                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+
+### Доступность
+
+Дерево передаёт вспомогательным технологиям структуру, которую отрисовывает, поэтому скринридер
+сообщает уровень вложенности элемента и то, раскрыт ли он, выбран ли и отмечен ли.
+
+- Дерево — это `role="tree"`, каждая строка — `role="treeitem"`.
+- Табуляция останавливается на самом дереве, а строки остаются с `tabindex="-1"`, но строка, на которую
+  переходят стрелки, получает настоящий фокус и вдобавок сообщается через `aria-activedescendant`.
+- У строк-веток есть `aria-expanded` — в том числе при активном фильтре, который отключает стрелки
+  раскрытия, но не превращает ветки в листья, — а у каждой строки есть `aria-level`.
+- Строки с чекбоксом сообщают `aria-checked`, в том числе `mixed` для частично выбранной ветки; строки
+  без чекбокса — `aria-selected`.
+- Стрелки раскрытия скрыты от вспомогательных технологий: их состояние уже есть на строке, а управляют
+  ими клавиши ← и →.
+- У дерева нет собственной видимой подписи, поэтому задайте ему доступное имя через `aria-label` или
+  укажите в `aria-labelledby` элемент, который его подписывает. Дереву внутри `kbq-tree-select` не
+  нужно ни то, ни другое — его подписывает сам селект.
+
+### Отрисовка
+
+Отрисовываются все раскрытые элементы, без виртуализации: закрытая ветка не стоит ничего, раскрытая —
+по строке DOM на элемент. Дерево, показывающее тысячи строк сразу, стоит держать закрытым или сужать
+данные поиском.
+
+По умолчанию узлы отслеживаются по идентичности, поэтому источник данных, который пересоздаёт объекты
+узлов на каждой эмиссии — например, flattener, — пересоздаёт и все строки. Чтобы строки
+переиспользовались между обновлениями данных, передайте функцию `trackBy`, возвращающую стабильный ключ.
diff --git a/packages/components/tree/tree.scss b/packages/components/tree/tree.scss
index 5f03f18c8e..c3805b43fa 100644
--- a/packages/components/tree/tree.scss
+++ b/packages/components/tree/tree.scss
@@ -1,8 +1,6 @@
-@use './tree-theme' as *;
-
+// The tree theme is emitted once, from `tree-selection.scss`. It styles `.kbq-tree-selection` and
+// `.kbq-tree-option`, and an option is only ever rendered by a `kbq-tree-selection` — the parent
+// token it depends on has no other provider.
 .kbq-tree {
     display: block;
 }
-
-@include kbq-tree-theme();
-@include kbq-tree-typography();
diff --git a/packages/components/tree/tree.ts b/packages/components/tree/tree.ts
index 4337277b28..9f9778b748 100644
--- a/packages/components/tree/tree.ts
+++ b/packages/components/tree/tree.ts
@@ -14,7 +14,8 @@ import { KbqTreeBase } from './tree-base';
     changeDetection: ChangeDetectionStrategy.OnPush,
     encapsulation: ViewEncapsulation.None,
     host: {
-        class: 'kbq-tree'
+        class: 'kbq-tree',
+        role: 'tree'
     },
     exportAs: 'kbqTree'
 })
diff --git a/packages/docs-examples/components/tree/tree-action-button/tree-action-button-example.ts b/packages/docs-examples/components/tree/tree-action-button/tree-action-button-example.ts
index 2df715691f..25e425b702 100644
--- a/packages/docs-examples/components/tree/tree-action-button/tree-action-button-example.ts
+++ b/packages/docs-examples/components/tree/tree-action-button/tree-action-button-example.ts
@@ -120,7 +120,7 @@ export const DATA_OBJECT = {
             [dataSource]="dataSource"
             [treeControl]="treeControl"
             [(ngModel)]="modelValue"
-            (onSelectAll)="onSelectAll($event)"
+            (selectAllChange)="onSelectAllChange($event)"
         >
             <kbq-tree-option *kbqTreeNodeDef="let node" kbqTreeNodePadding [disabled]="node.name === 'tests'">
                 <i kbq-icon="kbq-circle-info_16"></i>
@@ -191,7 +191,7 @@ export class TreeActionButtonExample {
         return nodeData.expandable;
     }
 
-    onSelectAll($event) {
+    onSelectAllChange($event) {
         console.log('All items selected', $event);
     }
 
diff --git a/packages/schematics/src/collection.json b/packages/schematics/src/collection.json
index 1d087ea482..8e49979a7d 100644
--- a/packages/schematics/src/collection.json
+++ b/packages/schematics/src/collection.json
@@ -168,6 +168,11 @@
             "description": "Reports the KbqTreeSelect members that became signal-backed, protected or disappeared in the tree-select review: the removed valueChange output (declared as the other half of a two-way binding on a value input that does not exist, and never emitted, so a (valueChange) binding never fired), the removed getPanelClasses/getPanelTheme/isRtl/transformOrigin template helpers, hiddenItemsText and hiddenItemsTextFormatter as signal inputs, hiddenItems as a WritableSignal and colorForState as a computed, and the options/tags/overlayDir/triggerRect/panelDoneAnimatingStream/changeDetectorRef plumbing that became protected. Warn-only. Notes the parts with no call site: KbqTreeSelectChange is generic with a typed value, the embedded tree is initialised through KbqTreeSelection.initializeForEmbedding() instead of a second manual ngAfterContentInit() that left duplicate subscriptions on the search-filtering hot path, the dead { provide: KbqTree, useExisting: KbqTreeSelect } provider is gone, and the component renders a host id so the form field label no longer dangles.",
             "factory": "./migrations/tree-select-signals/index",
             "schema": "./migrations/tree-select-signals/schema.json"
+        },
+        "tree-signals": {
+            "description": "Reports the six members of the tree that became read-only — KbqTreeNodeToggle.disabled, KbqTreeBase.nodeDefs, KbqTreeNodePadding.indent/indentUnits, KbqTreeNodeToggleBaseDirective.recursive and KbqTreeOption.onFocus/onBlur — with the call sites that write or read them; assigning any of them now throws",
+            "factory": "./migrations/tree-signals/index",
+            "schema": "./migrations/tree-signals/schema.json"
         }
     }
 }
diff --git a/packages/schematics/src/migrations.json b/packages/schematics/src/migrations.json
index 3f4751f42c..667583b9b4 100644
--- a/packages/schematics/src/migrations.json
+++ b/packages/schematics/src/migrations.json
@@ -130,6 +130,11 @@
             "version": "20.3.0-0",
             "description": "Reports the KbqTreeSelect members that became signal-backed, protected or disappeared in the tree-select review: the removed valueChange output (declared as the other half of a two-way binding on a value input that does not exist, and never emitted, so a (valueChange) binding never fired), the removed getPanelClasses/getPanelTheme/isRtl/transformOrigin template helpers, hiddenItemsText and hiddenItemsTextFormatter as signal inputs, hiddenItems as a WritableSignal and colorForState as a computed, and the options/tags/overlayDir/triggerRect/panelDoneAnimatingStream/changeDetectorRef plumbing that became protected. Warn-only. Notes the parts with no call site: KbqTreeSelectChange is generic with a typed value, the embedded tree is initialised through KbqTreeSelection.initializeForEmbedding() instead of a second manual ngAfterContentInit() that left duplicate subscriptions on the search-filtering hot path, the dead { provide: KbqTree, useExisting: KbqTreeSelect } provider is gone, and the component renders a host id so the form field label no longer dangles.",
             "factory": "./migrations/tree-select-signals/index"
+        },
+        "tree-signals": {
+            "version": "20.3.0-0",
+            "description": "Reports the six members of @koobiq/components/tree that became read-only in the tree review: KbqTreeNodeToggle.disabled (accessor pair → getter over a computed; the input is declared as disabledInput and still aliased `disabled`, so templates are unaffected), KbqTreeBase.nodeDefs (QueryList → Signal<readonly KbqTreeNodeDef<T>[]>, so an external subclass reading nodeDefs.length silently gets 0 — a Signal is a function — and nodeDefs.changes.subscribe throws), KbqTreeNodePadding.indent (accessor pair → InputSignal) and indentUnits (writable field → getter), KbqTreeNodeToggleBaseDirective.recursive (accessor pair → InputSignalWithTransform) and KbqTreeOption.onFocus/onBlur (Subject → Observable via asObservable, so .next is gone at runtime as well as in the types). Assigning any of them throws a TypeError in an ES module rather than only failing to compile. Warn-only: what replaces a write is a template binding or a different member, and neither can be derived from the assignment.",
+            "factory": "./migrations/tree-signals/index"
         }
     }
 }
diff --git a/packages/schematics/src/migrations/tree-signals/README.md b/packages/schematics/src/migrations/tree-signals/README.md
new file mode 100644
index 0000000000..b805cf6c0f
--- /dev/null
+++ b/packages/schematics/src/migrations/tree-signals/README.md
@@ -0,0 +1,61 @@
+# tree-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@20`
+(registered for `20.3.0-0`). Reports the six public members of `@koobiq/components/tree` that
+became read-only in the tree review. It never writes to the tree.
+
+## Background
+
+The tree moved its inputs and its query members to signals. Six members that used to be writable
+are now getters — over a `computed()`, over an `InputSignal`, or over an `asObservable()` view of a
+`Subject`. Assigning to a getter-only property throws `TypeError: Cannot set property … which has
+only a getter` in strict mode, and an ES module is always strict, so an unmigrated write does not
+merely stop compiling: it throws at runtime in any build that skips type checking.
+
+| Member                                     | Was                            | Is                                     |
+| ------------------------------------------ | ------------------------------ | -------------------------------------- |
+| `KbqTreeNodeToggle.disabled`               | `@Input()` accessor pair       | getter over a `computed()`             |
+| `KbqTreeBase.nodeDefs`                     | `QueryList<KbqTreeNodeDef<T>>` | `Signal<readonly KbqTreeNodeDef<T>[]>` |
+| `KbqTreeNodePadding.indent`                | accessor pair                  | `InputSignal<number \| string>`        |
+| `KbqTreeNodePadding.indentUnits`           | writable field                 | getter derived from `indent`           |
+| `KbqTreeNodeToggleBaseDirective.recursive` | accessor pair                  | `InputSignalWithTransform<boolean, …>` |
+| `KbqTreeOption.onFocus` / `onBlur`         | `Subject<KbqTreeOptionEvent>`  | `Observable<KbqTreeOptionEvent>`       |
+
+Two of them are silent rather than loud:
+
+- `KbqTreeBase` is exported and is the documented extension point for a custom tree. A subclass
+  reading `this.nodeDefs.length` now gets `0` — the arity of the signal function — instead of the
+  number of node definitions, and `this.nodeDefs.changes.subscribe(…)` throws.
+- `KbqTreeNodeToggle` kept `disabled` as the input alias (the input is declared as `disabledInput`),
+  so every template binding keeps working. Only imperative writes break, and the class itself
+  performed one before the review: the filter state is now OR-ed in by the computed instead.
+
+## What it does
+
+Walks every `.ts` and `.html` file under the project root — the whole workspace when `--project` is
+omitted, which is how `ng update` invokes it — skipping `node_modules` and `dist`, and logs the
+files that hold a call site one of the narrowings breaks:
+
+| Reported                                          | Manual migration                                                                   |
+| ------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| `<toggle>.disabled = …`                           | Bind the `disabled` attribute; it still reaches the toggle through `disabledInput` |
+| `<toggle>.recursive`                              | Read `recursive()`; bind `kbqTreeNodeToggleRecursive`                              |
+| `nodeDefs.changes` / `.length` / `.toArray()` / … | Read `nodeDefs()`; replace the subscription with an `effect`                       |
+| `<padding>.indent` / `.indentUnits`               | Read `indent()`; bind `kbqTreeNodePaddingIndent`                                   |
+| `<option>.onFocus.next(…)` / `onBlur.next(…)`     | Subscribe instead — the option emits on both streams itself                        |
+
+Each pattern is scoped to files that also name its owner, so a `.disabled =` write in a file that
+never mentions a tree toggle stays quiet. A project that renders a tree at all also gets a summary
+of all six members, because five of the six are only visible at a call site that writes them — a
+consumer that merely reads one gets a value whose type changed under it and no diagnostic at all.
+
+## What it does _not_ do (manual)
+
+Nothing is rewritten. What replaces a write is a template binding or a different member, neither of
+which can be derived from the assignment, and a read cannot be mechanically suffixed with `()`
+either: `nodeDefs` returns a plain array rather than a `QueryList`, and `indentUnits` is derived
+from `indent` rather than stored. The report is the migration.
+
+Receivers are matched by the identifiers in the file rather than by resolved types, so a member
+reached through an `any`-typed or structurally-typed receiver in a file that names no tree type is
+not reported.
diff --git a/packages/schematics/src/migrations/tree-signals/data.ts b/packages/schematics/src/migrations/tree-signals/data.ts
new file mode 100644
index 0000000000..2430657a91
--- /dev/null
+++ b/packages/schematics/src/migrations/tree-signals/data.ts
@@ -0,0 +1,93 @@
+/**
+ * Data for the `tree-signals` migration.
+ *
+ * Six public members of `@koobiq/components/tree` became read-only when the tree moved to signals:
+ *
+ * - `KbqTreeNodeToggle.disabled`        — accessor pair → getter over a `computed()` (the input is
+ *   declared as `disabledInput` and still aliased `disabled`, so templates are unaffected)
+ * - `KbqTreeBase.nodeDefs`              — `QueryList<KbqTreeNodeDef<T>>` → `Signal<readonly KbqTreeNodeDef<T>[]>`
+ * - `KbqTreeNodePadding.indent`         — accessor pair → `InputSignal<number | string>`
+ * - `KbqTreeNodePadding.indentUnits`    — writable field → getter derived from `indent`
+ * - `KbqTreeNodeToggleBaseDirective.recursive` — accessor pair → `InputSignalWithTransform`
+ * - `KbqTreeOption.onFocus` / `onBlur`  — `Subject` → `Observable` via `asObservable()`
+ *
+ * Nothing is rewritten. What replaces a write is a template binding or a different member, and
+ * neither can be derived from the assignment; a read of a signal-backed member has to be checked
+ * against its new value rather than mechanically suffixed with `()`.
+ */
+
+/** Import specifier that marks a file as a tree consumer. */
+export const TREE_PACKAGE = '@koobiq/components/tree';
+
+/** Identifier shape that marks a file as a tree consumer without an import (e.g. a re-export). */
+export const TREE_TYPE = '\\bKbqTree\\w*\\b';
+
+export interface WarnPattern {
+    /** Owner of the member. The pattern is only evaluated for files that also name it. */
+    anchor: string;
+    /** The call sites the narrowing breaks. */
+    pattern: string;
+    message: string;
+}
+
+const TOGGLE_ANCHOR = '\\bKbqTreeNodeToggle\\w*\\b';
+
+/**
+ * Reported with the file they were found in, in every mode — the migration only ever warns.
+ * Scoped by `anchor` so a plain `.disabled =` in a file that never mentions a toggle stays quiet.
+ */
+export const warnPatterns: WarnPattern[] = [
+    {
+        anchor: TOGGLE_ANCHOR,
+        pattern: '\\.disabled\\s*=(?!=)',
+        message:
+            'KbqTreeNodeToggle.disabled is a read-only getter over a computed (the `disabled` input OR-ed with ' +
+            'the filter state), so an assignment throws `TypeError: Cannot set property disabled`. Bind the ' +
+            '`disabled` attribute instead — it still reaches the toggle, through the `disabledInput` input.'
+    },
+    {
+        anchor: TOGGLE_ANCHOR,
+        pattern: '\\.recursive\\b',
+        message:
+            'KbqTreeNodeToggleBaseDirective.recursive is an InputSignalWithTransform: read it as `recursive()`, ' +
+            'and set it through the `kbqTreeNodeToggleRecursive` binding — assigning to it throws.'
+    },
+    {
+        anchor: TREE_TYPE,
+        pattern: '\\bnodeDefs\\s*\\.\\s*(?:changes|first|last|toArray|notifyOnChanges|reset|length)\\b',
+        message:
+            'KbqTreeBase.nodeDefs is a Signal<readonly KbqTreeNodeDef<T>[]> instead of a QueryList. ' +
+            '`nodeDefs.changes` no longer exists, and `nodeDefs.length` is the arity of the signal function — ' +
+            'always 0. Read the array as `nodeDefs()` and use `toSignal`/`effect` where you subscribed.'
+    },
+    {
+        anchor: '\\bKbqTreeNodePadding\\b',
+        pattern: '\\.indent(?:Units)?\\b',
+        message:
+            'KbqTreeNodePadding.indent is an InputSignal — read it as `indent()` and set it through the ' +
+            '`kbqTreeNodePaddingIndent` binding — and `indentUnits` is a read-only getter derived from it. ' +
+            'Assigning to either throws.'
+    },
+    {
+        anchor: '\\bKbqTreeOption\\b',
+        pattern: '\\.(?:onFocus|onBlur)\\s*\\.\\s*(?:next|complete|error)\\b',
+        message:
+            'KbqTreeOption.onFocus and onBlur are Observables now (`asObservable()`), so `.next()` is gone at ' +
+            'runtime as well as in the types. Subscribe to them; the option emits on them itself.'
+    }
+];
+
+/**
+ * Printed once for every project that renders a tree, because five of the six narrowings are only
+ * visible at a call site that writes the member — a consumer that merely reads one gets a value
+ * whose type changed under it and no diagnostic at all.
+ */
+export const SUMMARY: string[] = [
+    '',
+    'These members of @koobiq/components/tree became read-only and cannot be assigned:',
+    '  - KbqTreeNodeToggle.disabled (bind `disabled`; the input is declared as `disabledInput`)',
+    '  - KbqTreeBase.nodeDefs (Signal<readonly KbqTreeNodeDef<T>[]>, no longer a QueryList)',
+    '  - KbqTreeNodePadding.indent (InputSignal) and KbqTreeNodePadding.indentUnits (getter)',
+    '  - KbqTreeNodeToggleBaseDirective.recursive (InputSignalWithTransform)',
+    '  - KbqTreeOption.onFocus and KbqTreeOption.onBlur (Observable, not Subject)'
+];
diff --git a/packages/schematics/src/migrations/tree-signals/index.spec.ts b/packages/schematics/src/migrations/tree-signals/index.spec.ts
new file mode 100644
index 0000000000..27cbed2cb3
--- /dev/null
+++ b/packages/schematics/src/migrations/tree-signals/index.spec.ts
@@ -0,0 +1,167 @@
+import { workspaces } from '@angular-devkit/core';
+import { Tree } from '@angular-devkit/schematics';
+import { SchematicTestRunner } from '@angular-devkit/schematics/testing';
+import { getWorkspace } from '@schematics/angular/utility/workspace';
+import * as path from 'path';
+import { createTestApp } from '../../utils/testing';
+import { Schema } from './schema';
+
+const collectionPath = path.join(__dirname, '../../collection.json');
+const migrationsPath = path.join(__dirname, '../../migrations.json');
+const SCHEMATIC_NAME = 'tree-signals';
+
+describe(SCHEMATIC_NAME, () => {
+    let runner: SchematicTestRunner;
+    let appTree: Tree;
+    let projects: workspaces.ProjectDefinitionCollection;
+
+    beforeEach(async () => {
+        runner = new SchematicTestRunner('schematics', collectionPath);
+        appTree = await createTestApp(runner, { style: 'scss' });
+        const workspace = await getWorkspace(appTree);
+
+        projects = workspace.projects as unknown as workspaces.ProjectDefinitionCollection;
+    });
+
+    function paths(project: workspaces.ProjectDefinition) {
+        // The exact file names from @schematics/angular:application vary across versions
+        // (app.ts vs app.component.ts), so discover them from the tree.
+        const root = `/${project.root}/src/app`;
+
+        return { ts: appTree.exists(`${root}/app.ts`) ? `${root}/app.ts` : `${root}/app.component.ts` };
+    }
+
+    function run(project: string) {
+        return runner.runSchematic(SCHEMATIC_NAME, { project } satisfies Schema, appTree);
+    }
+
+    function collectLogs(): string[] {
+        const messages: string[] = [];
+
+        runner.logger.subscribe((entry) => messages.push(entry.message));
+
+        return messages;
+    }
+
+    it('reports a write to the now read-only toggle disabled', async () => {
+        const [first] = projects.keys();
+        const { ts } = paths(projects.get(first)!);
+        const messages = collectLogs();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqTreeNodeToggleComponent } from '@koobiq/components/tree';\n" +
+                'export class App { lock(toggle: KbqTreeNodeToggleComponent<unknown>) { toggle.disabled = true; } }\n'
+        );
+
+        await run(first);
+
+        expect(messages.join('\n')).toContain('KbqTreeNodeToggle.disabled is a read-only getter');
+    });
+
+    it('reports the QueryList API lost by nodeDefs', async () => {
+        const [first] = projects.keys();
+        const { ts } = paths(projects.get(first)!);
+        const messages = collectLogs();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqTreeSelection } from '@koobiq/components/tree';\n" +
+                'export class App { watch(tree: KbqTreeSelection) { tree.nodeDefs.changes.subscribe(); } }\n'
+        );
+
+        await run(first);
+
+        expect(messages.join('\n')).toContain('nodeDefs.changes` no longer exists');
+    });
+
+    it('reports pushing into the option focus streams', async () => {
+        const [first] = projects.keys();
+        const { ts } = paths(projects.get(first)!);
+        const messages = collectLogs();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqTreeOption } from '@koobiq/components/tree';\n" +
+                'export class App { emit(option: KbqTreeOption) { option.onFocus.next({ option }); } }\n'
+        );
+
+        await run(first);
+
+        expect(messages.join('\n')).toContain('onFocus and onBlur are Observables now');
+    });
+
+    it('stays quiet for a file that writes an unrelated disabled', async () => {
+        const [first] = projects.keys();
+        const { ts } = paths(projects.get(first)!);
+        const messages = collectLogs();
+
+        appTree.overwrite(ts, 'export class App { lock(button: { disabled: boolean }) { button.disabled = true; } }\n');
+
+        await run(first);
+
+        expect(messages.join('\n')).not.toContain(SCHEMATIC_NAME);
+    });
+
+    it('never writes to the tree', async () => {
+        const [first] = projects.keys();
+        const { ts } = paths(projects.get(first)!);
+        const original =
+            "import { KbqTreeNodeToggleComponent } from '@koobiq/components/tree';\n" +
+            'export class App { lock(toggle: KbqTreeNodeToggleComponent<unknown>) { toggle.disabled = true; } }\n';
+
+        appTree.overwrite(ts, original);
+
+        expect((await run(first)).readText(ts)).toBe(original);
+    });
+
+    it('summarises the read-only members for a project that renders a tree', async () => {
+        const [first] = projects.keys();
+        const { ts } = paths(projects.get(first)!);
+        const messages = collectLogs();
+
+        appTree.overwrite(ts, "import { KbqTreeModule } from '@koobiq/components/tree';\nexport class App {}\n");
+
+        await run(first);
+
+        expect(messages.join('\n')).toContain('became read-only and cannot be assigned');
+    });
+
+    it('leaves the second project unreported when scoped to the first', async () => {
+        const [first, second] = projects.keys();
+        const { ts: secondTs } = paths(projects.get(second)!);
+        const messages = collectLogs();
+
+        appTree.overwrite(
+            secondTs,
+            "import { KbqTreeOption } from '@koobiq/components/tree';\n" +
+                'export class App { emit(option: KbqTreeOption) { option.onFocus.next({ option }); } }\n'
+        );
+
+        await run(first);
+
+        expect(messages.join('\n')).not.toContain(secondTs);
+    });
+
+    describe('ng update entry point', () => {
+        it('runs when invoked without options', async () => {
+            const [first] = projects.keys();
+            const { ts } = paths(projects.get(first)!);
+            const messages = collectLogs();
+
+            appTree.overwrite(
+                ts,
+                "import { KbqTreeNodePadding } from '@koobiq/components/tree';\n" +
+                    'export class App { read(padding: KbqTreeNodePadding<unknown>) { return padding.indentUnits; } }\n'
+            );
+
+            const runnerFromMigrations = new SchematicTestRunner('migrations', migrationsPath);
+
+            runnerFromMigrations.logger.subscribe((entry) => messages.push(entry.message));
+
+            await runnerFromMigrations.runSchematic(SCHEMATIC_NAME, {}, appTree);
+
+            expect(messages.join('\n')).toContain('KbqTreeNodePadding.indent is an InputSignal');
+        });
+    });
+});
diff --git a/packages/schematics/src/migrations/tree-signals/index.ts b/packages/schematics/src/migrations/tree-signals/index.ts
new file mode 100644
index 0000000000..ecca859c7a
--- /dev/null
+++ b/packages/schematics/src/migrations/tree-signals/index.ts
@@ -0,0 +1,58 @@
+import { Path } from '@angular-devkit/core';
+import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
+import { logMessage } from '../../utils/messages';
+import { setupOptions } from '../../utils/package-config';
+import { SUMMARY, TREE_PACKAGE, TREE_TYPE, warnPatterns } from './data';
+import { Schema } from './schema';
+
+const LABEL = '[tree-signals]';
+const EXTENSIONS = ['.ts', '.html'];
+
+/** A file is a tree consumer if it imports the package, names one of its types, or renders one. */
+function referencesTree(content: string): boolean {
+    return content.includes(TREE_PACKAGE) || new RegExp(TREE_TYPE).test(content) || content.includes('kbq-tree');
+}
+
+/**
+ * Reports the six members of `@koobiq/components/tree` that became read-only, with the files that
+ * write or read them. Never writes: see `data.ts` for why none of them can be rewritten mechanically.
+ */
+export default function treeSignals(options: Schema): Rule {
+    return async (tree: Tree, context: SchematicContext) => {
+        const { project } = options;
+        const projectDefinition = await setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root as Path) : tree.root;
+
+        let consumers = 0;
+        let reported = 0;
+
+        rootDir.visit((filePath: Path, entry) => {
+            if (filePath.includes('node_modules') || filePath.includes('/dist/')) return;
+            if (!EXTENSIONS.some((extension) => filePath.endsWith(extension))) return;
+
+            const content = entry?.content.toString();
+
+            if (!content || !referencesTree(content)) return;
+
+            consumers++;
+
+            for (const { anchor, pattern, message } of warnPatterns) {
+                if (!new RegExp(anchor).test(content) || !new RegExp(pattern).test(content)) continue;
+
+                reported++;
+
+                logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+            }
+        });
+
+        // Nothing here renders a tree, so the summary would only be noise.
+        if (consumers === 0) return;
+
+        logMessage(context.logger, [
+            `${LABEL} processed tree under "${root || '<workspace root>'}", ` +
+                `${consumers} file(s) reference the tree, ${reported} call site(s) reported.`,
+            ...SUMMARY
+        ]);
+    };
+}
diff --git a/packages/schematics/src/migrations/tree-signals/schema.json b/packages/schematics/src/migrations/tree-signals/schema.json
new file mode 100644
index 0000000000..1edf4d6873
--- /dev/null
+++ b/packages/schematics/src/migrations/tree-signals/schema.json
@@ -0,0 +1,15 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-tree-signals",
+    "title": "Koobiq components tree review migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to inspect. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        }
+    }
+}
diff --git a/packages/schematics/src/migrations/tree-signals/schema.ts b/packages/schematics/src/migrations/tree-signals/schema.ts
new file mode 100644
index 0000000000..21f2e52bd6
--- /dev/null
+++ b/packages/schematics/src/migrations/tree-signals/schema.ts
@@ -0,0 +1,4 @@
+export interface Schema {
+    /** Name of the project to inspect. If omitted, the whole tree is inspected. */
+    project?: string;
+}
diff --git a/tools/check-public-api-any/baseline.json b/tools/check-public-api-any/baseline.json
index 2f66ea201f..b32315bbaa 100644
--- a/tools/check-public-api-any/baseline.json
+++ b/tools/check-public-api-any/baseline.json
@@ -51,7 +51,7 @@
     "toggle": 6,
     "tooltip": 6,
     "top-bar": 1,
-    "tree": 44,
+    "tree": 40,
     "tree-select": 23,
     "username": 5
 }
diff --git a/tools/cspell-locales/en.json b/tools/cspell-locales/en.json
index 9336568075..774c92d9a4 100644
--- a/tools/cspell-locales/en.json
+++ b/tools/cspell-locales/en.json
@@ -36,6 +36,7 @@
         "minimatch",
         "mouseleave",
         "multiselectable",
+        "narrowings",
         "neutralise",
         "neutralising",
         "noborder",
diff --git a/tools/cspell-locales/ru.json b/tools/cspell-locales/ru.json
index ddf768b28a..6c573c3499 100644
--- a/tools/cspell-locales/ru.json
+++ b/tools/cspell-locales/ru.json
@@ -143,9 +143,12 @@
         "отрисовывается",
         "отрисовывал",
         "отрисовывались",
+        "отрисовываются",
         "отрисуется",
         "пайплайном",
+        "переиспользовались",
         "переиспользует",
+        "переиспользуются",
         "пересоберите",
         "плейсхолдер",
         "плейсхолдере",
diff --git a/tools/public_api_guard/components/core.api.md b/tools/public_api_guard/components/core.api.md
index 4647d50765..339835179e 100644
--- a/tools/public_api_guard/components/core.api.md
+++ b/tools/public_api_guard/components/core.api.md
@@ -457,6 +457,7 @@ export const enUSLocaleData: {
         hidePassword: string;
         resizeColumns: string;
         toastRegion: string;
+        optionActions: string;
     };
     select: {
         hiddenItemsText: string;
@@ -729,6 +730,7 @@ export const esLALocaleData: {
         hidePassword: string;
         resizeColumns: string;
         toastRegion: string;
+        optionActions: string;
     };
     select: {
         hiddenItemsText: string;
@@ -1261,6 +1263,7 @@ export function KBQ_DEFAULT_LOCALE_DATA_FACTORY(): {
             hidePassword: string;
             resizeColumns: string;
             toastRegion: string;
+            optionActions: string;
         };
         select: {
             hiddenItemsText: string;
@@ -1508,6 +1511,7 @@ export function KBQ_DEFAULT_LOCALE_DATA_FACTORY(): {
             hidePassword: string;
             resizeColumns: string;
             toastRegion: string;
+            optionActions: string;
         };
         select: {
             hiddenItemsText: string;
@@ -1750,6 +1754,7 @@ export function KBQ_DEFAULT_LOCALE_DATA_FACTORY(): {
             hidePassword: string;
             resizeColumns: string;
             toastRegion: string;
+            optionActions: string;
         };
         select: {
             hiddenItemsText: string;
@@ -1997,6 +2002,7 @@ export function KBQ_DEFAULT_LOCALE_DATA_FACTORY(): {
             hidePassword: string;
             resizeColumns: string;
             toastRegion: string;
+            optionActions: string;
         };
         select: {
             hiddenItemsText: string;
@@ -2241,6 +2247,7 @@ export function KBQ_DEFAULT_LOCALE_DATA_FACTORY(): {
             hidePassword: string;
             resizeColumns: string;
             toastRegion: string;
+            optionActions: string;
         };
         select: {
             hiddenItemsText: string;
@@ -2554,6 +2561,7 @@ export type KbqA11yLocaleConfiguration = {
     hidePassword: string;
     resizeColumns: string;
     toastRegion: string;
+    optionActions: string;
 };
 
 // @public
@@ -3152,6 +3160,9 @@ export class KbqFormsModule {
     static ɵmod: i0.ɵɵNgModuleDeclaration<KbqFormsModule, never, [typeof KbqForm, typeof KbqFormElement], [typeof KbqForm, typeof KbqFormElement]>;
 }
 
+// @public
+export const kbqGetElementHeight: (element: Element) => number;
+
 // @public
 export function kbqGetPanelWidthOrigin(origin: KbqPanelWidthOrigin): number;
 
@@ -3570,6 +3581,7 @@ export class KbqOption extends KbqOptionBase implements AfterViewChecked, OnDest
 export class KbqOptionActionComponent implements AfterViewInit, OnDestroy {
     // (undocumented)
     get active(): boolean;
+    readonly ariaLabel: i0.InputSignal<string>;
     // (undocumented)
     get disabled(): boolean;
     set disabled(value: boolean);
@@ -3587,8 +3599,9 @@ export class KbqOptionActionComponent implements AfterViewInit, OnDestroy {
     onClick($event: any): void;
     // (undocumented)
     onKeyDown($event: any): void;
+    protected get resolvedAriaLabel(): string;
     // (undocumented)
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqOptionActionComponent, "kbq-option-action", ["kbqOptionAction"], { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["[kbq-icon]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqOptionActionComponent, "kbq-option-action", ["kbqOptionAction"], { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["[kbq-icon]"], true, never>;
     // (undocumented)
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqOptionActionComponent, never>;
 }
@@ -4904,6 +4917,7 @@ export const ptBRLocaleData: {
         hidePassword: string;
         resizeColumns: string;
         toastRegion: string;
+        optionActions: string;
     };
     select: {
         hiddenItemsText: string;
@@ -5367,6 +5381,7 @@ export const ruRULocaleData: {
         hidePassword: string;
         resizeColumns: string;
         toastRegion: string;
+        optionActions: string;
     };
     select: {
         hiddenItemsText: string;
@@ -5732,6 +5747,7 @@ export const tkTMLocaleData: {
         hidePassword: string;
         resizeColumns: string;
         toastRegion: string;
+        optionActions: string;
     };
     select: {
         hiddenItemsText: string;
diff --git a/tools/public_api_guard/components/tree.api.md b/tools/public_api_guard/components/tree.api.md
index 55bacb8e70..06973ab5bd 100644
--- a/tools/public_api_guard/components/tree.api.md
+++ b/tools/public_api_guard/components/tree.api.md
@@ -8,6 +8,7 @@ import { AfterContentChecked } from '@angular/core';
 import { AfterContentInit } from '@angular/core';
 import { AfterViewInit } from '@angular/core';
 import { BehaviorSubject } from 'rxjs';
+import { BooleanInput } from '@angular/cdk/coercion';
 import { ChangeDetectorRef } from '@angular/core';
 import { CollectionViewer } from '@angular/cdk/collections';
 import { ControlValueAccessor } from '@angular/forms';
@@ -36,9 +37,11 @@ import { MultipleMode } from '@koobiq/components/core';
 import { Observable } from 'rxjs';
 import { OnDestroy } from '@angular/core';
 import { OnInit } from '@angular/core';
+import { Provider } from '@angular/core';
 import { QueryList } from '@angular/core';
 import { SelectionChange } from '@angular/cdk/collections';
 import { SelectionModel } from '@angular/cdk/collections';
+import { Signal } from '@angular/core';
 import { Subject } from 'rxjs';
 import { TemplateRef } from '@angular/core';
 import { TrackByFunction } from '@angular/core';
@@ -87,7 +90,7 @@ export class FilterByValues<T> implements FlatTreeControlFilter<T> {
     setValues: (values: string[]) => void;
 }
 
-// @public (undocumented)
+// @public
 export class FilterByViewValue<T> implements FlatTreeControlFilter<T> {
     constructor(control: FlatTreeControl<T>);
     // (undocumented)
@@ -96,7 +99,7 @@ export class FilterByViewValue<T> implements FlatTreeControlFilter<T> {
     result: T[];
 }
 
-// @public (undocumented)
+// @public
 export class FilterParentsForNodes<T> implements FlatTreeControlFilter<T> {
     constructor(control: FlatTreeControl<T>);
     // (undocumented)
@@ -125,8 +128,7 @@ export class FlatTreeControl<T> extends BaseTreeControl<T> {
     getFilters(): FlatTreeControlFilter<T>[];
     // (undocumented)
     getLevel: (dataNode: T) => number;
-    // (undocumented)
-    getParents(node: any, result: T[]): T[];
+    getParents(node: T, result?: T[]): T[];
     getValue: (dataNode: T) => any;
     getViewValue: (dataNode: T) => string;
     // (undocumented)
@@ -147,10 +149,10 @@ export interface FlatTreeControlFilter<T> {
 }
 
 // @public (undocumented)
-export const KBQ_SELECTION_TREE_VALUE_ACCESSOR: any;
+export const KBQ_SELECTION_TREE_VALUE_ACCESSOR: Provider;
 
 // @public
-export const KBQ_TREE_OPTION_PARENT_COMPONENT: InjectionToken<any>;
+export const KBQ_TREE_OPTION_PARENT_COMPONENT: InjectionToken<KbqTreeOptionParent>;
 
 // @public (undocumented)
 export class KbqTree extends KbqTreeBase<any> {
@@ -160,13 +162,14 @@ export class KbqTree extends KbqTreeBase<any> {
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTree, never>;
 }
 
-// @public (undocumented)
+// @public
 export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {
+    protected applyNodeChanges(data: T[] | ReadonlyArray<T>, dataDiffer: IterableDiffer<T>, viewContainer: ViewContainerRef, parentData?: T): boolean;
     // (undocumented)
     protected changeDetectorRef: ChangeDetectorRef;
     protected dataDiffer: IterableDiffer<T>;
-    get dataSource(): DataSource<T> | Observable<T[]> | T[];
-    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]);
+    get dataSource(): DataSource<T> | Observable<T[]> | T[] | null;
+    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[] | null);
     // (undocumented)
     protected readonly destroyRef: DestroyRef;
     // (undocumented)
@@ -179,9 +182,10 @@ export class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, On
     ngOnDestroy(): void;
     // (undocumented)
     ngOnInit(): void;
-    nodeDefs: QueryList<KbqTreeNodeDef<T>>;
+    readonly nodeDefs: Signal<readonly KbqTreeNodeDef<T>[]>;
     // (undocumented)
     nodeOutlet: KbqTreeNodeOutlet;
+    registerNode(node: KbqTreeNode<T>): void;
     renderNodeChanges(data: T[] | ReadonlyArray<T>, dataDiffer?: IterableDiffer<T>, viewContainer?: ViewContainerRef, parentData?: T): void;
     readonly trackBy: i0.InputSignal<TrackByFunction<T>>;
     // (undocumented)
@@ -233,9 +237,7 @@ export class KbqTreeFlatDataSource<T, F> extends DataSource<F> {
 export class KbqTreeFlattener<T, F> {
     constructor(transformFunction: (node: T, level: number, parent: F | null) => F, getLevel: (node: F) => number, isExpandable: (node: F) => boolean, getChildren: (node: T) => Observable<T[]> | T[] | undefined | null);
     expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F>): F[];
-    // (undocumented)
     flattenChildren(children: T[], level: number, resultNodes: F[], parent: F | null): void;
-    // (undocumented)
     flattenNode(node: T, level: number, resultNodes: F[], parent: F | null): F[];
     flattenNodes(structuredData: T[]): F[];
     // (undocumented)
@@ -294,9 +296,12 @@ export class KbqTreeNode<T> implements IFocusableOption, OnDestroy {
     get isExpanded(): boolean;
     // (undocumented)
     get level(): number;
+    // @deprecated
     static mostRecentTreeNode: KbqTreeNode<any> | null;
     // (undocumented)
     ngOnDestroy(): void;
+    refresh(): void;
+    readonly refreshed: Subject<void>;
     // (undocumented)
     tree: KbqTreeBase<T>;
     // (undocumented)
@@ -342,12 +347,9 @@ export class KbqTreeNodeOutletContext<T> {
 // @public (undocumented)
 export class KbqTreeNodePadding<T> implements AfterViewInit {
     constructor();
-    // (undocumented)
     iconWidth: number;
-    // (undocumented)
-    get indent(): number | string;
-    set indent(indent: number | string);
-    indentUnits: string;
+    readonly indent: i0.InputSignal<string | number>;
+    get indentUnits(): string;
     // (undocumented)
     get leftPadding(): number;
     // (undocumented)
@@ -366,7 +368,7 @@ export class KbqTreeNodePadding<T> implements AfterViewInit {
     // (undocumented)
     withIcon: boolean;
     // (undocumented)
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodePadding<any>, "[kbqTreeNodePadding]", ["kbqTreeNodePadding"], { "indent": { "alias": "kbqTreeNodePaddingIndent"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodePadding<any>, "[kbqTreeNodePadding]", ["kbqTreeNodePadding"], { "indent": { "alias": "kbqTreeNodePaddingIndent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
     // (undocumented)
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodePadding<any>, never>;
 }
@@ -376,20 +378,16 @@ export class KbqTreeNodeToggleBaseDirective<T> {
     constructor();
     // (undocumented)
     get disabled(): boolean;
-    set disabled(value: boolean);
+    readonly disabledInput: i0.InputSignalWithTransform<boolean, unknown>;
     // (undocumented)
     get iconState(): boolean;
     // (undocumented)
-    static ngAcceptInputType_disabled: unknown;
-    // (undocumented)
     readonly node: i0.InputSignal<T>;
-    // (undocumented)
-    get recursive(): boolean;
-    set recursive(value: any);
+    readonly recursive: i0.InputSignalWithTransform<boolean, unknown>;
     // (undocumented)
     toggle(event: Event): void;
     // (undocumented)
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodeToggleBaseDirective<any>, never, never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "recursive": { "alias": "kbqTreeNodeToggleRecursive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodeToggleBaseDirective<any>, never, never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "recursive": { "alias": "kbqTreeNodeToggleRecursive"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
     // (undocumented)
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodeToggleBaseDirective<any>, never>;
 }
@@ -415,10 +413,14 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     constructor();
     // (undocumented)
     readonly actionButton: i0.Signal<KbqOptionActionComponent | undefined>;
+    protected get ariaChecked(): string | null;
+    protected get ariaExpanded(): boolean | null;
+    protected get ariaSelected(): boolean | null;
     // (undocumented)
     blur(): void;
     // (undocumented)
-    checkboxState: KbqPseudoCheckboxState;
+    get checkboxState(): KbqPseudoCheckboxState;
+    set checkboxState(value: KbqPseudoCheckboxState);
     // (undocumented)
     readonly checkboxThirdState: i0.InputSignal<boolean>;
     // (undocumented)
@@ -428,8 +430,8 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     // (undocumented)
     deselect(): void;
     // (undocumented)
-    get disabled(): any;
-    set disabled(value: any);
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
     // (undocumented)
     dropdownTrigger?: KbqDropdownTrigger;
     // (undocumented)
@@ -441,8 +443,10 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     getHeight(): number;
     // (undocumented)
     getHostElement(): HTMLElement;
+    getLabel(): string;
     // (undocumented)
-    hasFocus: boolean;
+    get hasFocus(): boolean;
+    set hasFocus(value: boolean);
     // (undocumented)
     get id(): string;
     // (undocumented)
@@ -454,14 +458,12 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     markForCheck(): void;
     // (undocumented)
     ngAfterContentInit(): void;
-    // (undocumented)
-    readonly onBlur: Subject<KbqTreeOptionEvent>;
-    // (undocumented)
-    readonly onFocus: Subject<KbqTreeOptionEvent>;
+    readonly onBlur: Observable<KbqTreeOptionEvent>;
+    readonly onFocus: Observable<KbqTreeOptionEvent>;
     // (undocumented)
     onKeydown($event: any): void;
     protected onMouseenter(): void;
-    // (undocumented)
+    // @deprecated (undocumented)
     readonly onSelectionChange: i0.OutputEmitterRef<KbqTreeOptionChange>;
     // (undocumented)
     parentTextElement: ElementRef;
@@ -469,6 +471,7 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     preventBlur: boolean;
     // (undocumented)
     readonly pseudoCheckbox: i0.Signal<KbqPseudoCheckbox | undefined>;
+    refresh(): void;
     // (undocumented)
     select(setFocus?: boolean): void;
     readonly selectable: i0.InputSignalWithTransform<boolean, unknown>;
@@ -476,13 +479,14 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     // (undocumented)
     get selected(): boolean;
     set selected(value: boolean);
+    readonly selectionChange: i0.OutputEmitterRef<KbqTreeOptionChange>;
     // (undocumented)
     selectViaInteraction($event?: KeyboardEvent): void;
     // (undocumented)
     setSelected(selected: boolean): void;
     // (undocumented)
-    get showCheckbox(): any;
-    set showCheckbox(value: any);
+    get showCheckbox(): boolean;
+    set showCheckbox(value: BooleanInput);
     // (undocumented)
     get textElement(): ElementRef;
     // (undocumented)
@@ -496,7 +500,7 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     // (undocumented)
     tooltipTrigger?: KbqTooltipTrigger;
     // (undocumented)
-    tree: any;
+    tree: KbqTreeOptionParent & KbqTreeBase<any>;
     // (undocumented)
     updateCheckboxState: () => void;
     // (undocumented)
@@ -509,15 +513,16 @@ export class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterCo
     // (undocumented)
     get viewValue(): string;
     // (undocumented)
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeOption, "kbq-tree-option", ["kbqTreeOption"], { "checkboxThirdState": { "alias": "checkboxThirdState"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selectAllRow": { "alias": "selectAllRow"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, ["toggleElementDirective", "toggleElementComponent", "pseudoCheckbox", "actionButton", "tooltipTrigger", "dropdownTrigger"], ["kbq-tree-node-toggle, [kbq-tree-node-toggle], [kbqTreeNodeToggle]", "kbq-pseudo-checkbox", "kbq-checkbox", "[kbq-icon]", "kbq-progress-spinner", "*", "kbq-option-action"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeOption, "kbq-tree-option", ["kbqTreeOption"], { "checkboxThirdState": { "alias": "checkboxThirdState"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selectAllRow": { "alias": "selectAllRow"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; }, { "selectionChange": "selectionChange"; "onSelectionChange": "onSelectionChange"; }, ["toggleElementDirective", "toggleElementComponent", "pseudoCheckbox", "actionButton", "tooltipTrigger", "dropdownTrigger"], ["kbq-tree-node-toggle, [kbq-tree-node-toggle], [kbqTreeNodeToggle]", "kbq-pseudo-checkbox", "kbq-checkbox", "[kbq-icon]", "kbq-progress-spinner", "*", "kbq-option-action"], true, never>;
     // (undocumented)
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeOption, never>;
 }
 
 // @public
 export class KbqTreeOptionChange {
-    constructor(source: KbqTreeOption, isUserInput?: boolean);
-    // (undocumented)
+    constructor(source: KbqTreeOption,
+    isUserInput?: boolean);
+    // @deprecated (undocumented)
     isUserInput: boolean;
     // (undocumented)
     source: KbqTreeOption;
@@ -529,6 +534,24 @@ export interface KbqTreeOptionEvent {
     option: KbqTreeOption;
 }
 
+// @public
+export interface KbqTreeOptionParent {
+    disabled: boolean;
+    inSelect: boolean;
+    multiple: boolean;
+    optionShouldHoldFocusOnBlur: boolean;
+    selectAllState: KbqPseudoCheckboxState;
+    // (undocumented)
+    selectionModel: SelectionModel<any>;
+    // (undocumented)
+    setSelectedOptionsByClick(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
+    showCheckbox: boolean;
+    // (undocumented)
+    treeControl: FlatTreeControl<any>;
+    // (undocumented)
+    unorderedOptions: QueryList<KbqTreeOption>;
+}
+
 // @public (undocumented)
 export class KbqTreeSelectAllEvent<T> {
     constructor(source: KbqTreeSelection, options: T[]);
@@ -545,29 +568,27 @@ export const kbqTreeSelectAllValue = "selectAll";
 export class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAccessor, AfterContentInit, AfterViewInit, OnDestroy {
     constructor();
     get allOptionsSelected(): boolean;
+    readonly ariaLabel: i0.InputSignal<string>;
+    readonly ariaLabelledby: i0.InputSignal<string>;
     get autoSelect(): boolean;
     set autoSelect(value: boolean);
     // (undocumented)
     blur(): void;
     // (undocumented)
     copyActiveOption(event: KeyboardEvent): void;
+    readonly copyChange: EventEmitter<KbqTreeCopyEvent<KbqTreeOption>>;
     // (undocumented)
     get disabled(): boolean;
     set disabled(rawValue: boolean);
-    // (undocumented)
-    emitChangeEvent(option: KbqTreeOption): void;
-    // (undocumented)
-    emitNavigationEvent(option: KbqTreeOption): void;
+    protected emitChangeEvent(option: KbqTreeOption): void;
+    protected emitNavigationEvent(option: KbqTreeOption): void;
     // (undocumented)
     focus($event: any): void;
     // (undocumented)
     protected readonly focusMonitor: FocusMonitor;
-    // (undocumented)
-    getItemHeight(): number;
-    // (undocumented)
+    protected getItemHeight(): number;
     getSelectedValues(): any[];
     handleKeydown(event: KeyboardEvent): void;
-    // (undocumented)
     highlightSelectedOption(): void;
     initializeForEmbedding(selectionModel: SelectionModel<SelectionModelOption>): void;
     inSelect: boolean;
@@ -584,6 +605,8 @@ export class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAc
     // (undocumented)
     static ngAcceptInputType_selectAll: unknown;
     // (undocumented)
+    static ngAcceptInputType_typeAhead: unknown;
+    // (undocumented)
     ngAfterContentInit(): void;
     // (undocumented)
     ngAfterViewInit(): void;
@@ -595,10 +618,10 @@ export class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAc
     get noUnselectLast(): boolean;
     set noUnselectLast(value: boolean);
     onChange: (value: any) => void;
-    // (undocumented)
+    // @deprecated (undocumented)
     readonly onCopy: EventEmitter<KbqTreeCopyEvent<KbqTreeOption>>;
     onKeyDown(event: KeyboardEvent): void;
-    // (undocumented)
+    // @deprecated (undocumented)
     readonly onSelectAll: i0.OutputEmitterRef<KbqTreeSelectAllEvent<KbqTreeOption>>;
     onTouched: () => void;
     // (undocumented)
@@ -611,17 +634,18 @@ export class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAc
     // (undocumented)
     registerOnChange(fn: (value: any) => void): void;
     // (undocumented)
-    registerOnTouched(fn: () => {}): void;
+    registerOnTouched(fn: () => void): void;
     // (undocumented)
     renderedOptions: QueryList<KbqTreeOption>;
-    // (undocumented)
     renderNodeChanges(data: KbqTreeOption[], dataDiffer?: IterableDiffer<KbqTreeOption>, viewContainer?: ViewContainerRef, parentData?: KbqTreeOption): void;
     // (undocumented)
     resetFocusedItemOnBlur: boolean;
-    // (undocumented)
-    selectActiveOptions(): void;
+    protected get resolvedAriaLabel(): string | null;
+    protected get resolvedAriaLabelledby(): string | null;
+    protected selectActiveOptions(): void;
     get selectAll(): boolean;
     set selectAll(value: boolean);
+    readonly selectAllChange: i0.OutputEmitterRef<KbqTreeSelectAllEvent<KbqTreeOption>>;
     get selectAllHandler(): (event: KeyboardEvent, tree: KbqTreeSelection) => void;
     set selectAllHandler(fn: (event: KeyboardEvent, tree: KbqTreeSelection) => void);
     readonly selectAllOption: i0.Signal<KbqTreeOption | undefined>;
@@ -635,13 +659,9 @@ export class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAc
     // Warning: (ae-forgotten-export) The symbol "SelectionModelOption" needs to be exported by the entry point index.d.ts
     selectionModel: SelectionModel<SelectionModelOption>;
     setDisabledState(isDisabled: boolean): void;
-    // (undocumented)
-    setFocusedOption(option: KbqTreeOption): void;
-    // (undocumented)
+    protected setFocusedOption(option: KbqTreeOption): void;
     setOptionsFromValues(values: any[]): void;
-    // (undocumented)
     setSelectedOptionsByClick(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
-    // (undocumented)
     setSelectedOptionsByKey(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
     // (undocumented)
     setStateChildren(option: KbqTreeOption, state: boolean): void;
@@ -651,21 +671,21 @@ export class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAc
     // (undocumented)
     get tabIndex(): any;
     set tabIndex(value: any);
-    // (undocumented)
-    toggleFocusedOption(): void;
+    protected toggleFocusedOption(): void;
     protected toggleSelectAll(): void;
     // (undocumented)
     treeControl: FlatTreeControl<any>;
+    get typeAhead(): boolean;
+    set typeAhead(value: boolean);
     // (undocumented)
     unorderedOptions: QueryList<KbqTreeOption>;
-    // (undocumented)
     updateScrollSize(): void;
     // (undocumented)
     userTabIndex: number | null;
     // (undocumented)
     writeValue(value: any): void;
     // (undocumented)
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelection, "kbq-tree-selection", ["kbqTreeSelection"], { "treeControl": { "alias": "treeControl"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "noUnselectLast": { "alias": "noUnselectLast"; "required": false; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "selectAll": { "alias": "selectAll"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelection, "kbq-tree-selection", ["kbqTreeSelection"], { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "treeControl": { "alias": "treeControl"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "noUnselectLast": { "alias": "noUnselectLast"; "required": false; }; "typeAhead": { "alias": "typeAhead"; "required": false; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "selectAll": { "alias": "selectAll"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "selectAllChange": "selectAllChange"; "onSelectAll": "onSelectAll"; "copyChange": "copyChange"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, true, never>;
     // (undocumented)
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelection, never>;
 }