@truenas/ui-components 0.5.3 → 0.6.2

package/types/truenas-ui-components.d.ts

@@ -1,7 +1,7 @@
 import * as _truenas_ui_components from '@truenas/ui-components';
 import * as _angular_core from '@angular/core';
-import { Signal, InjectionToken, Renderer2, OnDestroy, ElementRef, AfterViewInit, TemplateRef, AfterContentInit, Provider, ChangeDetectorRef, OnInit, TrackByFunction, OnChanges, DoCheck, SimpleChanges, PipeTransform, ViewContainerRef, AfterViewChecked, ComponentRef } from '@angular/core';
-import { ControlValueAccessor, NgControl, AbstractControl } from '@angular/forms';
+import { Signal, InjectionToken, Renderer2, OnDestroy, ElementRef, AfterViewInit, TemplateRef, AfterContentInit, Provider, DoCheck, ChangeDetectorRef, OnInit, TrackByFunction, OnChanges, SimpleChanges, PipeTransform, ViewContainerRef, AfterViewChecked, ComponentRef } from '@angular/core';
+import { ControlValueAccessor, NgControl, AbstractControl, ValidationErrors } from '@angular/forms';
 import { ComponentHarness, BaseHarnessFilters, HarnessPredicate, TestKey, HarnessLoader, ModifierKeys as ModifierKeys$1 } from '@angular/cdk/testing';
 import { SafeHtml, SafeResourceUrl, DomSanitizer } from '@angular/platform-browser';
 import { ComponentFixture } from '@angular/core/testing';
@@ -30,9 +30,16 @@ type TnTestIdValue = string | number | (string | number | null | undefined)[] |
  * collapse any run of non-alphanumeric characters to a single hyphen, and trim
  * leading/trailing hyphens.
  *
- * Mirrors the normalization webui's legacy `ixTest` directive applied via
- * lodash `kebabCase`, so migrated values stay stable (`sshPort` → `ssh-port`,
- * `addr_trtype` → `addr-trtype`, `'My Label'` → `my-label`).
+ * Follows webui's legacy `ixTest` directive (lodash `kebabCase`) for the cases
+ * that matter to migrated values — `sshPort` → `ssh-port`, `addr_trtype` →
+ * `addr-trtype`, `'My Label'` → `my-label` — but deliberately not for the
+ * letter↔digit boundary, which lodash splits and this does not: `nvme0n1` stays
+ * `nvme0n1` rather than becoming `nvme-0-n-1`, and `ipv4` stays `ipv4`. Device
+ * and protocol names read better whole, and they are exactly the strings that
+ * end up in ids. A consumer that must reproduce a legacy lodash-derived id
+ * byte-for-byte pre-normalizes the dynamic part itself before handing it over
+ * (webui's `normalizeTestIdString` does this); the result then passes through
+ * here unchanged.
  */
 declare function kebabTestSegment(part: string | number): string;
 /**
@@ -133,14 +140,29 @@ interface TnOptionTestIdSource {
  * `[tnTestId]` with `tnTestIdType="option"`. The component's resolved base
  * (explicit `testId`, else the bound control name) scopes a per-option
  * discriminator so ids stay unique across instances: base `user` + option
- * value `jane-doe` → `option-user-jane-doe`; with no base → `option-jane-doe`.
+ * label `Jane Doe` → `option-user-jane-doe`; with no base → `option-jane-doe`.
  *
  * The discriminator comes from `extractor` when provided (a component's
- * `optionTestIdKey` input), else the option's primitive `value`, else its
- * `label`. Shared by `tn-select` and `tn-autocomplete` so the derivation
- * rules can't drift between dropdown components; synthetic rows with fixed
- * discriminators (e.g. select's `allowEmpty` option) are handled by the
+ * `optionTestIdKey` input), else the option's **`label`** — the text actually
+ * on screen — falling back to a primitive `value` only for the labelless
+ * option. Shared by `tn-select`, `tn-autocomplete` and `tn-chip-input` so the
+ * derivation rules can't drift between dropdown components; synthetic rows with
+ * fixed discriminators (e.g. select's `allowEmpty` option) are handled by the
  * caller before delegating here.
+ *
+ * **Why the label and not the value.** An option's value is frequently opaque
+ * to everyone but the code that owns it — an enum ordinal, a record id, a
+ * protocol constant — so keying ids off it yields `option-sshconnectmode-0` or
+ * `option-user-1734`: not unique in any way a test author can predict, and
+ * silently renumbered whenever the enum or the records change. The label is the
+ * one part of an option that both the person writing the test and the person
+ * reading the page can see, so it is the useful default. What it trades away is
+ * uniqueness by construction: a value is unique within a control (it is the
+ * model value the control round-trips) where a label is not, so an option set
+ * with a repeated display name now produces repeated ids, silently — nothing
+ * validates label uniqueness. Where that happens, or an id must be stable
+ * across locales, or an id-per-record is genuinely wanted, `extractor`
+ * (`[optionTestIdKey]`) still overrides it — that is what the input is for.
  */
 declare function optionTestId<O extends TnOptionTestIdSource>(base: TnTestIdValue, option: O, extractor?: (option: O) => string | number | null | undefined): (string | number | null | undefined)[];
 
@@ -236,6 +258,33 @@ interface TnSelectOptionGroup<T = unknown> {
     options: TnSelectOption<T>[];
     disabled?: boolean;
 }
+/**
+ * Copy rendered inside `tn-select` that is the same for every select in an app.
+ *
+ * Binding these per call site means repeating the identical string on every
+ * `<tn-select>` in the codebase — an app with translated copy ends up with two
+ * extra attribute rows on each one. Provide {@link TN_SELECT_LABELS} at the app
+ * root instead; inputs on `<tn-select>` still win where a particular select
+ * needs its own wording.
+ */
+interface TnSelectLabels {
+    /** Trigger text shown while nothing is selected. */
+    placeholder: string;
+    /** Message shown inside the dropdown when there are no options to list. */
+    noOptions: string;
+    /** Label of the "select all" row rendered when `showSelectAll` is set. */
+    selectAll: string;
+}
+/** English defaults used when no `TN_SELECT_LABELS` provider is registered. */
+declare const TN_SELECT_DEFAULT_LABELS: TnSelectLabels;
+/**
+ * DI token for app-wide default labels. Provide either a static object or a
+ * `Signal<TnSelectLabels>` — the latter lets every select react to language
+ * changes when the consumer wires it up to an i18n service.
+ *
+ * Explicit input bindings on `<tn-select>` still win over these defaults.
+ */
+declare const TN_SELECT_LABELS: InjectionToken<TnSelectLabels | Signal<TnSelectLabels>>;
 /**
  * A keyboard-navigable row in the open dropdown. Either the synthetic
  * "select all" action (multiple mode with `showSelectAll`) or a real option.
@@ -252,7 +301,13 @@ type TnSelectNavEntry<T> = {
 declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, OnDestroy {
     options: _angular_core.InputSignal<TnSelectOption<T>[]>;
     optionGroups: _angular_core.InputSignal<TnSelectOptionGroup<T>[]>;
-    placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Label inputs are nullable on purpose: the component reads the resolved
+     * `resolved*` computeds below, which fall back to the DI-provided defaults
+     * (a signal — so language changes propagate live). An explicit input binding
+     * always wins.
+     */
+    placeholder: _angular_core.InputSignal<string | undefined>;
     /**
      * Explicit accessible label for the select trigger. When set, this is used as
      * the trigger's `aria-label` instead of the visible `placeholder` — useful in
@@ -268,18 +323,23 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
      * invalid, required). All-null when standalone or when `ariaLabel` overrides.
      */
     protected readonly fieldAria: _truenas_ui_components.TnFormFieldAriaBindings;
+    private readonly defaultLabels;
+    /** Resolved labels: an explicit input takes precedence over the DI default. */
+    protected readonly resolvedPlaceholder: Signal<string>;
+    protected readonly resolvedNoOptionsLabel: Signal<string>;
+    protected readonly resolvedSelectAllLabel: Signal<string>;
     /**
      * `aria-label` for the trigger. An explicit `ariaLabel` always wins; the
      * `placeholder` fallback only applies while no form-field label is wired via
      * `aria-labelledby`, so the trigger never advertises two names at once.
      */
-    protected triggerAriaLabel: _angular_core.Signal<string | null>;
+    protected triggerAriaLabel: Signal<string | null>;
     /**
      * Message shown inside the dropdown when no options (and no option groups)
-     * are available. Defaults to the English `'No options available'`; consumers
-     * with i18n requirements can pass a translated string.
+     * are available. Falls back to {@link TN_SELECT_LABELS}, so an app with i18n
+     * wiring provides it once rather than per call site.
      */
-    noOptionsLabel: _angular_core.InputSignal<string>;
+    noOptionsLabel: _angular_core.InputSignal<string | undefined>;
     /**
      * When `true` (single-select mode only), prepends a synthetic "empty"
      * option to the dropdown so users can unset a chosen value: picking it
@@ -301,15 +361,15 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
      */
     showSelectAll: _angular_core.InputSignal<boolean>;
     /** Label of the select-all row rendered when `showSelectAll` is set. */
-    selectAllLabel: _angular_core.InputSignal<string>;
+    selectAllLabel: _angular_core.InputSignal<string | undefined>;
     testId: _angular_core.InputSignal<TnTestIdValue>;
     /** Test-id base, falling back to the bound control name when `testId` is unset. */
-    protected resolvedTestId: _angular_core.Signal<TnTestIdValue>;
+    protected resolvedTestId: Signal<TnTestIdValue>;
     multiple: _angular_core.InputSignal<boolean>;
     /**
-     * Optional extractor for the per-option test-id discriminator. Defaults to
-     * the option's `value` (when a string/number) or its `label`. Provide this
-     * when option values are objects, or to pick a more stable/unique key —
+     * Optional extractor for the per-option test-id discriminator. Defaults to the
+     * option's `label`, the text actually on screen — provide this to key off a
+     * locale-independent field instead, or where an id per record is wanted —
      * mirrors webui's `[ixTest]="[controlName, option.<field>]"` discriminator.
      *
      * @example
@@ -355,17 +415,17 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
      * instances; otherwise falls back to a per-instance counter so two
      * `<tn-select>`s on the same page never collide on `aria-controls`/group ids.
      */
-    protected idNamespace: _angular_core.Signal<string>;
-    isDisabled: _angular_core.Signal<boolean>;
+    protected idNamespace: Signal<string>;
+    isDisabled: Signal<boolean>;
     /**
      * The synthetic clear-selection option (`allowEmpty`, single mode only).
      * Its value is `null` cast to `T` so it flows through the same selection
      * path as real options — `selectedValue`/`writeValue` already model "no
      * selection" as `null`, so picking it clears the field for free.
      */
-    protected emptyOption: _angular_core.Signal<TnSelectOption<T> | null>;
+    protected emptyOption: Signal<TnSelectOption<T> | null>;
     /** Ungrouped options as rendered: the empty option (when enabled) first. */
-    protected displayOptions: _angular_core.Signal<TnSelectOption<T>[]>;
+    protected displayOptions: Signal<TnSelectOption<T>[]>;
     /** Whether `option` is the synthetic `allowEmpty` clear option. */
     protected isEmptyOption(option: TnSelectOption<T>): boolean;
     /**
@@ -373,9 +433,9 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
      * then groups). Used by keyboard navigation so we can skip disabled
      * entries and group headers without a separate filter pass.
      */
-    navigableOptions: _angular_core.Signal<TnSelectNavEntry<T>[]>;
+    navigableOptions: Signal<TnSelectNavEntry<T>[]>;
     /** Stable DOM id of the currently-highlighted option, for aria-activedescendant. */
-    focusedOptionId: _angular_core.Signal<string | null>;
+    focusedOptionId: Signal<string | null>;
     /** Stable DOM id for an option; matches what navigableOptions() assigns. */
     optionId(option: TnSelectOption<T>): string | null;
     /** Whether `option` is the keyboard-highlighted item. */
@@ -437,9 +497,9 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
     selectOption(option: TnSelectOption<T>): void;
     private toggleOption;
     isOptionSelected(option: TnSelectOption<T>): boolean;
-    protected displayText: _angular_core.Signal<string>;
+    protected displayText: Signal<string>;
     private findOptionByValue;
-    protected hasAnyOptions: _angular_core.Signal<boolean>;
+    protected hasAnyOptions: Signal<boolean>;
     /**
      * Values of every selectable (non-disabled) option, across ungrouped options
      * and enabled groups. This is the set the select-all row operates on —
@@ -450,15 +510,15 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
      * ungrouped and inside a group isn't pushed twice — that would make
      * select-all diverge from `toggleOption()`, which never produces duplicates.
      */
-    protected selectableValues: _angular_core.Signal<T[]>;
+    protected selectableValues: Signal<T[]>;
     /** Whether the select-all row is shown (multiple mode, opted in, with options). */
-    protected showSelectAllRow: _angular_core.Signal<boolean>;
+    protected showSelectAllRow: Signal<boolean>;
     /** Stable DOM id of the select-all row, for aria-activedescendant. */
-    protected selectAllId: _angular_core.Signal<string>;
+    protected selectAllId: Signal<string>;
     /** True when every selectable option is currently selected. */
-    protected allSelected: _angular_core.Signal<boolean>;
+    protected allSelected: Signal<boolean>;
     /** True when some — but not all — selectable options are selected. */
-    protected selectAllIndeterminate: _angular_core.Signal<boolean>;
+    protected selectAllIndeterminate: Signal<boolean>;
     /** Test-id segments for the select-all row; mirrors ix-select's `[name, 'select-all']`. */
     protected selectAllTestIdParts(): (string | number | null | undefined)[];
     /**
@@ -523,6 +583,30 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
  * sources feed both dropdown components.
  */
 type TnAutocompleteOption<T = unknown> = TnSelectOption<T>;
+/**
+ * Copy rendered inside `tn-autocomplete` that is the same for every instance in
+ * an app. Provide {@link TN_AUTOCOMPLETE_LABELS} at the app root rather than
+ * repeating the identical strings on each call site; inputs on
+ * `<tn-autocomplete>` still win where one instance needs its own wording.
+ */
+interface TnAutocompleteLabels {
+    /** Placeholder shown in the text field while it is empty. */
+    placeholder: string;
+    /** Text shown next to the spinner while `loading` is set. */
+    loading: string;
+    /** Text shown when no option matches the search term. */
+    noResults: string;
+}
+/** English defaults used when no `TN_AUTOCOMPLETE_LABELS` provider is registered. */
+declare const TN_AUTOCOMPLETE_DEFAULT_LABELS: TnAutocompleteLabels;
+/**
+ * DI token for app-wide default labels. Provide either a static object or a
+ * `Signal<TnAutocompleteLabels>` — the latter lets every autocomplete react to
+ * language changes when the consumer wires it up to an i18n service.
+ *
+ * Explicit input bindings on `<tn-autocomplete>` still win over these defaults.
+ */
+declare const TN_AUTOCOMPLETE_LABELS: InjectionToken<TnAutocompleteLabels | Signal<TnAutocompleteLabels>>;
 declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccessor, OnDestroy {
     private readonly elementRef;
     private readonly overlay;
@@ -543,8 +627,13 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * Mirrors `tn-select`'s `compareWith`.
      */
     compareWith: _angular_core.InputSignal<((a: T | null, b: T | null) => boolean) | undefined>;
-    /** Placeholder text for the input */
-    placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Placeholder text for the input. Label inputs are nullable on purpose: the
+     * component reads the `resolved*` computeds below, which fall back to
+     * {@link TN_AUTOCOMPLETE_LABELS} (a signal — so language changes propagate
+     * live). An explicit input binding always wins.
+     */
+    placeholder: _angular_core.InputSignal<string | undefined>;
     /** Whether the input is disabled */
     disabled: _angular_core.InputSignal<boolean>;
     /** Require the user to select from the dropdown — reverts on blur if no match */
@@ -563,11 +652,11 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      */
     loading: _angular_core.InputSignal<boolean>;
     /** Text shown next to the spinner while `loading` is set. */
-    loadingText: _angular_core.InputSignal<string>;
+    loadingText: _angular_core.InputSignal<string | undefined>;
     /** Custom filter function. Defaults to case-insensitive includes on the option label */
     filterFn: _angular_core.InputSignal<((option: TnAutocompleteOption<T>, searchTerm: string) => boolean) | undefined>;
     /** Text shown when no options match the search */
-    noResultsText: _angular_core.InputSignal<string>;
+    noResultsText: _angular_core.InputSignal<string | undefined>;
     /**
      * Maximum number of options to render.
      *
@@ -594,11 +683,11 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
     /** Test ID attribute */
     testId: _angular_core.InputSignal<TnTestIdValue>;
     /** Test-id base, falling back to the bound control name when `testId` is unset. */
-    protected resolvedTestId: _angular_core.Signal<TnTestIdValue>;
+    protected resolvedTestId: Signal<TnTestIdValue>;
     /**
-     * Optional extractor for the per-option test-id discriminator. Defaults to
-     * the option's `value` (when a string/number) or its `label`. Provide this
-     * when option values are objects, or to pick a more stable/unique key —
+     * Optional extractor for the per-option test-id discriminator. Defaults to the
+     * option's `label`, the text actually on screen — provide this to key off a
+     * locale-independent field instead, or where an id per record is wanted —
      * mirrors `tn-select`'s input of the same name.
      *
      * @example
@@ -612,6 +701,11 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * invalid, required). All-null when standalone or when `ariaLabel` overrides.
      */
     protected readonly fieldAria: _truenas_ui_components.TnFormFieldAriaBindings;
+    private readonly defaultLabels;
+    /** Resolved labels: an explicit input takes precedence over the DI default. */
+    protected readonly resolvedPlaceholder: Signal<string>;
+    protected readonly resolvedLoadingText: Signal<string>;
+    protected readonly resolvedNoResultsText: Signal<string>;
     /** Emits the full option (label + value) when one is selected */
     optionSelected: _angular_core.OutputEmitterRef<TnAutocompleteOption<T>>;
     /**
@@ -638,11 +732,11 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      */
     opened: _angular_core.OutputEmitterRef<void>;
     /** Reference to the input element */
-    inputEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    inputEl: Signal<ElementRef<HTMLInputElement> | undefined>;
     /** Template for the dropdown panel, portaled into a CDK overlay on open. */
     private dropdownTemplate;
     /** Normalized panel max-height as a CSS length string. */
-    protected panelMaxHeightValue: _angular_core.Signal<string>;
+    protected panelMaxHeightValue: Signal<string>;
     /** Current search term typed by the user */
     protected searchTerm: _angular_core.WritableSignal<string>;
     /** Whether the dropdown is open */
@@ -654,11 +748,11 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
     /** CVA disabled state from the form */
     private formDisabled;
     /** Combined disabled state */
-    isDisabled: _angular_core.Signal<boolean>;
+    isDisabled: Signal<boolean>;
     /** Filtered and capped options */
-    protected filteredOptions: _angular_core.Signal<TnAutocompleteOption<T>[]>;
+    protected filteredOptions: Signal<TnAutocompleteOption<T>[]>;
     /** Whether there are any results to show */
-    protected hasResults: _angular_core.Signal<boolean>;
+    protected hasResults: Signal<boolean>;
     private onChange;
     private onTouched;
     /** Live overlay holding the dropdown panel, or undefined when closed. */
@@ -961,8 +1055,55 @@ interface AutocompleteHarnessFilters extends BaseHarnessFilters {
 
 type TnDrawerMode = 'side' | 'over';
 type TnDrawerPosition = 'start' | 'end';
+/**
+ * The accessible name a drawer falls back to when the caller names neither
+ * `ariaLabel` nor `ariaLabelledby` (#214).
+ *
+ * `ariaLabel` defaults to `undefined`, so the DEFAULT rendering in `over` mode
+ * was a `role="dialog"` with `aria-modal="true"` and no name — measured as an
+ * `aria-dialog-name` violation. In `side` mode the same omission leaves a
+ * `role="navigation"` landmark unnamed, which axe does not report while there is
+ * only one of them on the page, and which stops telling them apart the moment
+ * there are two.
+ *
+ * One fallback for both modes rather than one per mode: the drawer is the same
+ * surface either way, the name answers the same question ("what is this?"), and
+ * a rule that changes with the mode is one more thing for a caller to be wrong
+ * about. A generic name is still a poor one, so it is paired with the dev-mode
+ * warning `tnAccessibleName` raises.
+ *
+ * Exported so specs assert against it by name rather than by a copied literal.
+ */
+declare const TN_DRAWER_DEFAULT_LABEL = "Drawer";
+/**
+ * A drawer, which is two different things by `mode`: in `side` it is
+ * persistent navigation beside the page's content, and in `over` it is a modal
+ * dialog with focus trapped in it.
+ *
+ * FOCUS ON OPEN, IN `over` MODE ONLY
+ * ----------------------------------
+ * An `over` drawer moves focus to the panel container when it opens, whatever
+ * you projected into it, so that a screen reader announces the dialog it has
+ * just entered before any control in it. A `side` drawer does not: navigation
+ * that appears beside the content must not take focus from the page.
+ *
+ * **`[cdkFocusInitial]` is not honoured** (#227). It used to be, through the
+ * CDK auto-capture this replaced, and `cdkTrapFocus` is still on the panel — so
+ * the marker looks like it should work and does not. To focus a control of your
+ * own, focus it yourself once the drawer is open; the component leaves focus
+ * alone as soon as it is inside the panel. `lib/a11y/initial-focus.ts` holds
+ * the reasoning for capturing the container rather than a control.
+ */
 declare class TnDrawerComponent implements OnDestroy {
     private readonly document;
+    /**
+     * The host, which contains the `side`-mode panel. The `over`-mode one is
+     * portaled out to `document.body`, so "does this drawer hold focus" is a
+     * question about both this and `overlayRef`.
+     */
+    private readonly hostRef;
+    /** For the `afterNextRender` an effect below schedules, outside injection context. */
+    private readonly injector;
     /** Whether the drawer sits alongside content ('side') or overlays it ('over') */
     mode: _angular_core.InputSignal<TnDrawerMode>;
     /** Whether the drawer is open. Two-way bindable via [(opened)] */
@@ -975,29 +1116,100 @@ declare class TnDrawerComponent implements OnDestroy {
     position: _angular_core.InputSignal<TnDrawerPosition>;
     /** Accessible label for the drawer panel */
     ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** IDREF naming the drawer panel from visible text elsewhere on the page */
+    ariaLabelledby: _angular_core.InputSignal<string | null>;
     /**
      * Test-id applied to the drawer panel. Rendered under whichever attribute name is
      * configured via `TN_TEST_ATTR` (default `data-testid`).
      */
     testId: _angular_core.InputSignal<TnTestIdValue>;
-    /** Fires after the open transition completes */
+    /**
+     * Fires once the drawer has finished opening.
+     *
+     * "Finished" means the open transition ended, OR that it was going to take
+     * longer than `TN_TRANSITION_FALLBACK_MS` to say so — which is what a user
+     * with `prefers-reduced-motion: reduce` gets, since this component's own
+     * stylesheet removes the transition for them and one that does not run fires
+     * no `transitionend` (#218). A consumer may assume the drawer has reached its
+     * open state and that `opened()` is true; it may NOT assume the animation is
+     * visually complete, because for that user there was none.
+     */
     openedComplete: _angular_core.OutputEmitterRef<void>;
-    /** Fires after the close transition completes */
+    /**
+     * Fires once the drawer has finished closing. Same guarantee as
+     * `openedComplete`, and the same caveat: it reports the state, not the
+     * animation.
+     *
+     * Focus restoration does NOT hang off this — it happens as soon as the drawer
+     * closes (#214). See the effect in the constructor.
+     */
     closed: _angular_core.OutputEmitterRef<void>;
     /** Whether the component has rendered (prevents transition flash on load) */
     protected initialized: _angular_core.WritableSignal<boolean>;
     /** Reference to the overlay element (portaled to body in over mode) */
     protected overlayRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    /**
+     * The `over`-mode panel, which is what focus moves to when a modal drawer
+     * opens. Optional rather than required: it lives inside an `@if` on the mode,
+     * so a `side` drawer never renders it.
+     */
+    private overPanelRef;
+    /**
+     * Whichever panel is currently rendered — the `side` one or the `over` one.
+     *
+     * Both template branches carry `#panel` and the `@if` on `mode` renders
+     * exactly one, so this is "the drawer's panel" without the caller having to
+     * ask which mode it is in. A drawer whose `mode` changes at runtime destroys
+     * one element and builds the other, and this query re-answers with it.
+     */
+    private panelRef;
+    /**
+     * Whether the panel carries a real tab stop rather than its resting `-1`
+     * (#270).
+     *
+     * `.tn-drawer__panel` is the element with `overflow-y: auto`, so a drawer
+     * whose projected content is taller than it is scrolls here — and until this
+     * ticket nothing about it was reachable from a keyboard unless the caller
+     * happened to project a tabbable control. The measurement, the observers that
+     * keep it current and the rule that decides when the tab stop may be given
+     * back are `tnScrollableRegion`'s; see `../a11y/scrollable-region.ts`, which
+     * is also where the reasoning for holding it on while the panel has focus is
+     * set out.
+     *
+     * A field initializer rather than the constructor, because it registers an
+     * `effect` and so needs an injection context.
+     */
+    protected panelKeyboardReachable: _angular_core.Signal<boolean>;
     /** Focus trap should be active only in 'over' mode when open */
     protected trapFocus: _angular_core.Signal<boolean>;
     /** Role depends on mode: navigation for side, dialog for over */
     protected panelRole: _angular_core.Signal<"dialog" | "navigation">;
+    /**
+     * The name to render as `aria-label`, or `null` to render none — and the
+     * dev-mode warning when the caller named neither input.
+     *
+     * Both halves live in `../a11y/accessible-name`, shared with `tn-side-panel`
+     * and the three progressbars, where the reasoning for each branch is set out:
+     * why an explicit `ariaLabel` always survives, and why the generic fallback is
+     * withheld beside an `ariaLabelledby`.
+     *
+     * A field initializer rather than the constructor, because it registers an
+     * `effect` and so needs an injection context.
+     */
+    protected resolvedAriaLabel: _angular_core.Signal<string | null>;
     /** Whether to show the backdrop */
     protected showBackdrop: _angular_core.Signal<boolean>;
     /** CSS classes for the drawer panel */
     protected drawerClasses: _angular_core.Signal<string[]>;
     /** Previous focus element for restoration (only captured in over mode) */
     private previousFocus;
+    /**
+     * Decides when an open or a close counts as finished, so that the outputs
+     * above fire exactly once per change whether or not a transition ran. A field
+     * initializer rather than the constructor, because it registers an `effect`
+     * and so needs an injection context.
+     */
+    private lifecycle;
     constructor();
     ngOnDestroy(): void;
     /** Open the drawer */
@@ -1014,21 +1226,116 @@ declare class TnDrawerComponent implements OnDestroy {
      * to dismiss them. The header toggle button is the intended control.
      */
     protected onKeydown(event: KeyboardEvent): void;
-    /** Handle transition end — emit events and restore focus after animation completes */
+    /**
+     * Handle transition end — report the open/close early, since the animation is
+     * demonstrably over. Focus restoration is NOT here; it happens as soon as the
+     * drawer closes, because this event does not fire under
+     * `prefers-reduced-motion` — and neither, for the same reason, does the
+     * emission depend on it any more (#218).
+     *
+     * Which output to emit is `lifecycle`'s to decide, from the state the change
+     * it is tracking settled into — NOT from `opened()` read here. The two differ
+     * exactly when this event is late: a drawer reopened while the close was still
+     * animating reads `opened() === true` on the stale close's event.
+     */
     protected onTransitionEnd(event: TransitionEvent): void;
     private restoreFocus;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnDrawerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDrawerComponent, "tn-drawer", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "opened": { "alias": "opened"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "opened": "openedChange"; "openedComplete": "openedComplete"; "closed": "closed"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDrawerComponent, "tn-drawer", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "opened": { "alias": "opened"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "opened": "openedChange"; "openedComplete": "openedComplete"; "closed": "closed"; }, never, ["*"], true, never>;
 }
 
+/**
+ * The flex row that lays a `tn-drawer` out beside a `tn-drawer-content`.
+ *
+ * WHY IT CARRIES NO ROLE, NO LANDMARK AND NO NAME (#214)
+ * -----------------------------------------------------
+ * #214 reported axe evaluating ZERO rules against this component, which is true
+ * and is not a defect in it: the container renders `<ng-content />` and a
+ * stylesheet, so scanned on its own there is nothing there to have a role. The
+ * scan in the report was the childless case, the same way #204's turned out to
+ * be a stepper with no steps.
+ *
+ * The surface a user perceives is `tn-drawer`, and that is where the model is
+ * declared — `role="navigation"` in `side` mode, `role="dialog"` with
+ * `aria-modal` and a focus trap in `over` mode. Giving the container a role of
+ * its own would put a second, unnamed thing in the accessibility tree between a
+ * listener and that surface, describing a layout box.
+ *
+ * `role="main"` on `tn-drawer-content` is the other tempting one, and it belongs
+ * to the application rather than to this library: a page decides where its main
+ * landmark is, and a component library that claims it makes two `main`s the
+ * moment an app has its own.
+ *
+ * Guarded by `drawer-a11y.spec.ts`, which asserts the drawer inside the
+ * container is what axe attributes its results to.
+ */
 declare class TnDrawerContainerComponent {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnDrawerContainerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDrawerContainerComponent, "tn-drawer-container", never, {}, {}, never, ["*"], true, never>;
 }
 
+/**
+ * The name this region takes when it becomes focusable (#270).
+ *
+ * A focusable element with no accessible name is announced as a bare "group",
+ * which tells a listener that something has been reached and nothing about what
+ * it is.
+ *
+ * "Content" rather than "Main content", and `role="group"` rather than
+ * `role="main"`: the landmark belongs to the application, not to this library —
+ * `drawer-container.component.ts` sets out why, and a component that claimed it
+ * would give a page two `main`s the moment the page declared its own. A group
+ * is not summarised in a landmarks list, so this names the scroll region
+ * without competing with the page's own structure.
+ *
+ * Overridable through `ariaLabel`, on the same reasoning as
+ * `TN_SIDE_PANEL_CONTENT_LABEL`: a string this library renders into a
+ * consumer's UI has to be translatable, and a consumer who knows what the
+ * region holds can say so. Exported so specs assert against it by name rather
+ * than by a copied literal.
+ */
+declare const TN_DRAWER_CONTENT_LABEL = "Content";
+/**
+ * The page content that sits beside a `tn-drawer` inside a
+ * `tn-drawer-container`.
+ *
+ * WHY IT CARRIES A TAB STOP SOMETIMES AND NO LANDMARK EVER (#270)
+ * --------------------------------------------------------------
+ * The host is `overflow: auto`, so everything an application puts beside its
+ * drawer scrolls in this element — and axe's `scrollable-region-focusable`
+ * reports a scroll container that is neither in the tab order nor holds
+ * anything that is. That is not a technicality here: this is the element that
+ * holds a page, so content below its fold is most of the page, and a keyboard
+ * user with no pointer could not reach it.
+ *
+ * The tab stop follows the measurement rather than being permanent, because
+ * this component wraps every page that uses a drawer and a stop that announces
+ * a group and does nothing would land on all of them. `tnScrollableRegion`
+ * holds the measurement, the observers that keep it current, and the rule that
+ * decides when it may be taken away again; see `../a11y/scrollable-region.ts`.
+ *
+ * The role is still not a landmark. `drawer-container.component.ts` explains
+ * why `role="main"` belongs to the application rather than to this library, and
+ * nothing about needing a tab stop changes that — see
+ * `TN_DRAWER_CONTENT_LABEL`.
+ */
 declare class TnDrawerContentComponent {
+    private readonly hostRef;
+    /**
+     * Accessible name for the scrolling region, which is named only while it is
+     * focusable — see `TN_DRAWER_CONTENT_LABEL`. Override it to translate it, or
+     * to say what the region holds ("Pool details").
+     */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Whether the region carries the tab stop, its role and its name — which is
+     * NOT the same question as whether it currently overflows. All three are
+     * gated together, and held on while the region has focus; the reasoning for
+     * both is in `../a11y/scrollable-region.ts`.
+     */
+    protected keyboardReachable: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnDrawerContentComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDrawerContentComponent, "tn-drawer-content", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDrawerContentComponent, "tn-drawer-content", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -1152,11 +1459,15 @@ declare class TnBannerComponent {
     /**
      * Get the appropriate icon name based on banner type
      */
-    iconName: _angular_core.Signal<"information" | "alert" | "alert-circle" | "check-circle">;
+    iconName: _angular_core.Signal<"alert" | "information" | "alert-circle" | "check-circle">;
     /**
-     * Get ARIA role based on banner type
-     * Error/warning use 'alert' for immediate attention
-     * Info/success use 'status' for polite announcements
+     * The live-region role, which is also the only thing declaring how urgently
+     * the banner is announced: `alert` implies `aria-live="assertive"` and
+     * `status` implies `polite`. The template carries no `aria-live`, because an
+     * explicit one would override this.
+     *
+     * The mapping is shared with toast rather than restated here — see
+     * `../a11y/live-region.ts` for which severities interrupt and why.
      */
     ariaRole: _angular_core.Signal<"alert" | "status">;
     /**
@@ -1167,9 +1478,101 @@ declare class TnBannerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnBannerComponent, "tn-banner", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; }, {}, ["actionContent"], ["*", "[tnBannerAction]"], true, never>;
 }
 
+/**
+ * Harness for a single action projected into a `tn-banner`'s action slot.
+ *
+ * Reach these through `TnBannerHarness.getActions()` / `clickAction()` rather
+ * than loading them directly — on their own they would also match a
+ * `[tnBannerAction]` element that some other component projects.
+ *
+ * `[tnBannerAction]` is an attribute directive with no element restriction, so
+ * an action is whatever the caller projected: a `tn-button`, a plain `<a>`, a
+ * native `<button>`. This harness covers all of them rather than assuming
+ * `tn-button`, which is why `TnBannerHarness` does not simply locate
+ * `TnButtonHarness` the way `TnDialogHarness` does — a dialog's footer takes
+ * `tn-button`s, a banner's action slot takes anything.
+ *
+ * @example
+ * ```typescript
+ * const banner = await loader.getHarness(TnBannerHarness);
+ * const actions = await banner.getActions();
+ * expect(await actions[0].getLabel()).toBe('Retry');
+ * await actions[0].click();
+ * ```
+ */
+declare class TnBannerActionHarness extends ComponentHarness {
+    /**
+     * The selector for the host element of a banner action.
+     */
+    static hostSelector: string;
+    private _buttonLabel;
+    private _innerControl;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a banner action
+     * with a specific label.
+     *
+     * Scope it to the action slot when composing a locator by hand — unscoped, it
+     * matches any `[tnBannerAction]` element on the page, which is why
+     * `TnBannerHarness` always passes an `ancestor`.
+     *
+     * @param options Options for filtering which action instances are considered a match.
+     * @returns A `HarnessPredicate` configured with the given options.
+     *
+     * @example
+     * ```typescript
+     * const retry = await loader.getHarness(
+     *   TnBannerActionHarness.with({ label: 'Retry', ancestor: '.tn-banner__action' })
+     * );
+     * ```
+     */
+    static with(options?: BannerActionHarnessFilters): HarnessPredicate<TnBannerActionHarness>;
+    /**
+     * Gets the action's label text.
+     *
+     * For a projected `tn-button` this is the button's own label, read from its
+     * label span so a rendered icon's sprite-fallback glyphs never leak in — the
+     * same rule `TnButtonHarness.getLabel()` follows. For anything else it is the
+     * element's trimmed text content.
+     *
+     * @returns Promise resolving to the action's label, trimmed of whitespace.
+     *
+     * @example
+     * ```typescript
+     * const [action] = await banner.getActions();
+     * expect(await action.getLabel()).toBe('Learn more');
+     * ```
+     */
+    getLabel(): Promise<string>;
+    /**
+     * Clicks the action.
+     *
+     * Clicks the inner `button`/`a` when the action is a component that renders
+     * one — a `tn-button` listens on that inner element, and a click dispatched
+     * at the `tn-button` host would not reach it. Otherwise clicks the projected
+     * element itself.
+     *
+     * @returns Promise that resolves when the click action is complete.
+     *
+     * @example
+     * ```typescript
+     * const [action] = await banner.getActions();
+     * await action.click();
+     * ```
+     */
+    click(): Promise<void>;
+}
+/**
+ * A set of criteria that can be used to filter a list of `TnBannerActionHarness` instances.
+ */
+interface BannerActionHarnessFilters extends BaseHarnessFilters {
+    /** Filters by the action's label text. Supports string or regex matching. */
+    label?: string | RegExp;
+}
+
 /**
  * Harness for interacting with tn-banner in tests.
- * Provides simple text-based querying for existence checks.
+ * Provides text-based querying for existence checks, and access to the actions
+ * the banner projects into its action slot.
  *
  * @example
  * ```typescript
@@ -1185,6 +1588,9 @@ declare class TnBannerComponent {
  * const hasBanner = await loader.hasHarness(
  *   TnBannerHarness.with({ textContains: /success/i })
  * );
+ *
+ * // Press one of the banner's actions
+ * await errorBanner.clickAction('Retry');
  * ```
  */
 declare class TnBannerHarness extends ComponentHarness {
@@ -1192,6 +1598,7 @@ declare class TnBannerHarness extends ComponentHarness {
      * The selector for the host element of an `TnBannerComponent` instance.
      */
     static hostSelector: string;
+    private _actions;
     /**
      * Gets a `HarnessPredicate` that can be used to search for a banner
      * with specific text content.
@@ -1226,6 +1633,47 @@ declare class TnBannerHarness extends ComponentHarness {
      * ```
      */
     getText(): Promise<string>;
+    /**
+     * Gets every action the banner projects into its action slot, in DOM order.
+     *
+     * Actions are not necessarily `tn-button`s — `[tnBannerAction]` is an
+     * attribute directive that takes any element — so these come back as
+     * `TnBannerActionHarness`, which reads a label and clicks whatever was
+     * projected. Nothing is filtered out by element type.
+     *
+     * @returns Promise resolving to an array of `TnBannerActionHarness` instances.
+     *
+     * @example
+     * ```typescript
+     * const banner = await loader.getHarness(TnBannerHarness);
+     * const actions = await banner.getActions();
+     * expect(actions).toHaveLength(2);
+     * expect(await actions[0].getLabel()).toBe('Retry');
+     * ```
+     */
+    getActions(): Promise<TnBannerActionHarness[]>;
+    /**
+     * Clicks one of the banner's actions by its label, matching the first in DOM
+     * order. Only matches inside the `.tn-banner__action` slot, not controls in
+     * the banner's default content.
+     *
+     * Named `clickAction` rather than `TnDialogHarness`'s `clickActionButton`
+     * because a banner action need not be a button: a projected `<a
+     * tnBannerAction>` is reached by this method exactly as a `tn-button` is.
+     *
+     * @param label The action label to match. Supports string or regex.
+     * @throws Error naming the label, and the labels actually present, if nothing matches.
+     *
+     * @example
+     * ```typescript
+     * const banner = await loader.getHarness(
+     *   TnBannerHarness.with({ textContains: 'network error' })
+     * );
+     * await banner.clickAction('Retry');
+     * await banner.clickAction(/learn more/i);
+     * ```
+     */
+    clickAction(label: string | RegExp): Promise<void>;
 }
 /**
  * A set of criteria that can be used to filter a list of `TnBannerHarness` instances.
@@ -1266,7 +1714,7 @@ declare class TnButtonComponent implements AfterViewInit {
      * form's `(submit)`/`(ngSubmit)` handler; a `(onClick)` binding alone does
      * not. Ignored in anchor mode (`href`/`routerLink`).
      */
-    type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    type: _angular_core.InputSignal<"button" | "reset" | "submit">;
     /**
      * Semantic test-id base for the rendered element. The library prepends the
      * element type (`button`) and renders the result under whichever attribute
@@ -1514,12 +1962,61 @@ declare class TnTooltipDirective implements AfterViewInit, OnDestroy {
     showDelay: _angular_core.InputSignal<number>;
     hideDelay: _angular_core.InputSignal<number>;
     tooltipClass: _angular_core.InputSignal<string>;
+    /**
+     * Allows the tooltip to be pinned ("stuck") open so its content can be interacted with —
+     * needed for tooltips that contain links or other controls.
+     *
+     * UPGRADING: this defaults to `true`, so an existing tooltip whose message happens to contain a
+     * link changes behaviour with no code change on your side — it stops appearing on hover and on
+     * keyboard focus, and the host's click opens it instead. Nothing else about the host changes.
+     * Anything that forwards a caller-supplied message to a `<button>` is a candidate: inside this
+     * library that is `<tn-form-field [tooltip]>`, `<tn-form-section [tooltip]>`, `<tn-card>`'s
+     * title and action tooltips and `<tn-icon-button [tooltip]>`, all of which render a button and
+     * pass the message straight through. Each re-exports this as a `tooltipSticky` input, so
+     * `[tooltipSticky]="false"` on any of them keeps the old hover behaviour, at the cost of the
+     * link staying out of reach.
+     *
+     * A host whose click is already spoken for wants that opt-out permanently, not on upgrade: a
+     * `tnMenuTrigger` would raise the panel over the menu the same click opens, and lose the hover
+     * hint doing it. `<tn-card>`'s kebab-menu trigger passes `false` for exactly that reason, which
+     * is why it is not in the list above.
+     *
+     * This only narrows the rule in `_isPinnable`, it cannot widen it: plain help text is never
+     * pinnable however this is set, and neither is a message on a host that cannot deliver the
+     * click - see `_isHostClickBlocked`. Setting it to false forces a message that does hold a
+     * link back into plain hover behaviour, where the link is unreachable.
+     *
+     * Pinning is not a second stage layered on hover: a tooltip that can be pinned is opened by
+     * clicking the host and by nothing else, because a tooltip that appeared on hover and then had
+     * to be clicked made the user chase a target that was already on screen. See `_isPinnable`
+     * for which tooltips this applies to.
+     *
+     * While pinned the tooltip renders a dismiss button and ignores `mouseleave` and blur; it
+     * closes on a second click of the host, on the dismiss button, on an outside click, or on
+     * Escape.
+     *
+     * The pinning click is additive, not exclusive: the host's own click handler still runs, so a
+     * `<tn-button (click)="save()">` carrying a message with a link both saves and pins. Suppressing
+     * the host's action would be worse — a menu trigger or a toggle that silently stopped working
+     * because someone put a link in its tooltip — but a host that navigates away should either keep
+     * its tooltip plain or set this to false.
+     */
+    stickyEnabled: _angular_core.InputSignal<boolean>;
+    /** Accessible name for the dismiss button rendered in sticky mode. */
+    closeAriaLabel: _angular_core.InputSignal<string>;
+    /** Accessible name for the panel itself once pinned, where it is announced as a dialog. */
+    panelAriaLabel: _angular_core.InputSignal<string>;
     private _overlayRef;
     private _tooltipInstance;
     private _showTimeout;
     private _hideTimeout;
     private _isTooltipVisible;
+    private _isSticky;
     private _positionSub;
+    private _repositionSub;
+    private _escapeSub;
+    private _outsideClickSub;
+    private _dismissSub;
     private _focusSub;
     private _tooltipId;
     private _overlay;
@@ -1527,18 +2024,58 @@ declare class TnTooltipDirective implements AfterViewInit, OnDestroy {
     private _viewContainerRef;
     private _overlayPositionBuilder;
     private _ariaDescriber;
+    private _scrollDispatcher;
+    private _viewportRuler;
     private _focusMonitor;
     private _ngZone;
     private _viewInitialized;
     private _describedTarget;
     private _describedMessage;
     private _innerObserver;
+    private _popupStateTarget;
+    private _popupStateWritten;
+    private _popupStateSelfWrites;
     /**
-     * Re-sync the description (see ngAfterViewInit) when the inputs change. The initial
+     * Which disclosure attributes the host has been seen writing for itself, per element.
+     *
+     * Per element for the same reason `_popupStateSelfWrites` is, and then some: ownership is a
+     * fact about the element that carries the attribute, and the target moves (`<tn-button>`
+     * swapping between `<a>` and `<button>` through an `@if`). Held as bare names it outlived the
+     * element it was learned from and denied the disclosure state to a replacement carrying no
+     * attributes of its own — permanently, since the yielded state leaves `_popupStateTarget`
+     * null and so hid the target change from the reset in `_writeHostPopupState`. Keyed by
+     * element, the replacement starts owning nothing because it does, and the fact survives for
+     * as long as the element it is about.
+     */
+    private _popupStateHostOwned;
+    private _cachedArrowInset;
+    /**
+     * Whether this tooltip is opened by a click and pinned, rather than shown on hover.
+     *
+     * Only messages carrying content the reader can reach earn the click interaction, because they
+     * are the ones a hover tooltip cannot serve — it disappears on the way to the link. Plain help
+     * text, which is the overwhelming majority, keeps the hover behaviour and never pins: pinning
+     * it would cost a click and buy the reader nothing.
+     *
+     * `hasInteractiveContent` is deliberately strict about what counts, since the message is
+     * sanitized before it renders — see `REACHABLE_CONTENT_SELECTOR`.
+     */
+    private readonly _isPinnable;
+    /**
+     * Keeps a panel that is already on screen in step with its inputs.
+     *
+     * `_attachTooltip` seeds these once, which was enough while every panel was a hover panel that
+     * lived for a second. A pinned panel stays up until the user dismisses it, so a message that
+     * changes underneath it would leave the rendered text — and the link the user is about to
+     * click — disagreeing with the description `_syncAriaDescription` has already moved on to.
+     */
+    private readonly _syncPanelInputs;
+    /**
+     * Re-sync the ARIA attributes (see ngAfterViewInit) when the inputs change. The initial
      * write cannot happen here: on the first run the host's child components (e.g.
      * tn-button's inner `<button>`) have not rendered yet.
      */
-    private readonly _syncDescriptionOnInputChange;
+    private readonly _syncAriaOnInputChange;
     /**
      * Expose the message to assistive tech via CDK's AriaDescriber: it keeps the text in
      * a persistent visually-hidden element (so `aria-describedby` never dangles — the
@@ -1549,31 +2086,295 @@ declare class TnTooltipDirective implements AfterViewInit, OnDestroy {
      * because screen readers read descriptions off the focused control, not wrappers.
      */
     ngAfterViewInit(): void;
+    private _syncAria;
+    /**
+     * Watches the host for the things `_syncAria` reads out of the DOM rather than out of a signal,
+     * for as long as any of them can still change the answer.
+     *
+     * Three things move underneath it. The inner control can render after view init (`@if` branches
+     * inside the wrapper swapping, deferred content). `disabled`/`aria-disabled` can be toggled on
+     * it at any time, which decides whether the pinning click can arrive at all, and so whether the
+     * host advertises itself as a disclosure control; `tabindex` and `href` read the same way,
+     * through `_isHostKeyboardOperable` and through `_ariaTarget`'s `INTERACTIVE_SELECTOR` match —
+     * both selectors say `a[href]`, so an anchor dropping its `href` stops being activatable
+     * exactly as one taking `tabindex="-1"` does, and the disclosure state has to come off it. The
+     * disclosure attributes are watched for a different reason: to notice the host writing one of
+     * them itself. See `_absorbPopupStateRecords`, which also keeps our own writes of them from
+     * retriggering this. `aria-describedby` stays outside the filter, so `AriaDescriber` cannot
+     * loop it.
+     *
+     * None of that can matter on a host that is itself the control (`<button tnTooltip>`,
+     * `tn-icon-button`'s inner button — the overwhelming majority) while its tooltip is a plain
+     * hover one: `_ariaTarget` is the host whatever the subtree does, and the rest is read only on
+     * the way to pinning something. A table rendering hundreds of tooltip'd action buttons would
+     * otherwise carry hundreds of live subtree observers with nothing to report, so those hosts go
+     * unobserved until their message turns pinnable — or until `stick()` pins one anyway, which it
+     * will do on a message the host click never would have.
+     */
+    private _observeHost;
+    private _disconnectHostObserver;
+    /**
+     * The element the tooltip's ARIA attributes belong on: the host when it is itself a control,
+     * otherwise its single interactive descendant (e.g. `<tn-button>`'s inner `<button>`), because
+     * screen readers read descriptions and states off the focused control, not off wrappers.
+     *
+     * A container holding several controls keeps them on the host — annotating an arbitrary first
+     * control would attach the text to the wrong element.
+     */
+    private _ariaTarget;
+    /**
+     * Whether the host is in a state where the click that pins the tooltip cannot be relied on.
+     *
+     * A disabled control is: a native disabled `<button>` fires no click at all, and
+     * `<tn-button [disabled]>` swallows the retargeted one in a capture-phase listener before this
+     * directive's host binding runs. `aria-disabled` is the exception that keeps this a rule about
+     * intent rather than about event plumbing — it is advisory, so the element still dispatches
+     * clicks normally. `_onClick` therefore declines to pin for any host this reports, rather than
+     * relying on the click not showing up. Suppressing hover for a pinnable message would then leave the
+     * tooltip with no way in whatsoever — and a disabled control with a tooltip explaining why,
+     * docs link included, is a normal thing to build. Those fall back to plain hover behaviour,
+     * which is what they did before pinning existed: the link stays out of reach, but the
+     * explanation does not.
+     */
+    private _isHostClickBlocked;
+    /**
+     * Whether the element carrying the tooltip's ARIA state can be operated from the keyboard.
+     *
+     * The click is the only way into a pinned panel, so a host that cannot produce one from the
+     * keyboard would put the tooltip out of reach of keyboard users entirely — and would write
+     * `aria-expanded`, advertising a disclosure they cannot operate. Two host shapes fail that way:
+     *
+     * - `_ariaTarget` falls back to the bare host when it is not a control and holds no single
+     *   interactive descendant — `<span [tnTooltip]="'… <a href>…'">` is exactly that. It can be
+     *   clicked with a pointer, so nothing in `_isHostClickBlocked` catches it, but it cannot be
+     *   focused or activated at all, and `aria-expanded` is invalid on its implicit `generic` role.
+     *   A host wearing `role="button"` is the same case: the role renames it for assistive tech
+     *   without making the browser synthesise a click for it.
+     * - A text control (`<input>`, `<select>`, `<textarea>`) is focusable but not *activatable*:
+     *   Enter submits the form and Space types a space, so no click ever arrives. On top of that,
+     *   every pointer click into the field — placing the caret — would toggle the panel.
+     *
+     * The question is therefore "does a click on this element mean *activate me*", which is what
+     * `KEYBOARD_ACTIVATABLE_SELECTOR` answers; `INTERACTIVE_SELECTOR` answers the broader "is this
+     * the element ARIA belongs on" and is too wide to stand in for it. Both shapes fall back to
+     * plain hover, which is what they did before pinning existed.
+     *
+     * `tabindex="-1"` does not count: it makes an element a focus target without putting it in the
+     * tab order, and `_restoreFocusTarget` leaves one behind on hosts it had to focus by hand.
+     */
+    private _isHostKeyboardOperable;
+    /**
+     * Whether this tooltip is opened by clicking its host, rather than on hover.
+     *
+     * `_isPinnable` is the message's half of that decision; the host has the other half, and both
+     * have to agree. A host that cannot deliver the pinning click, or cannot be operated from the
+     * keyboard at all, goes back to being a hover tooltip.
+     */
+    private _pinsOnClick;
+    /**
+     * Marks a pinnable host as the disclosure control for its tooltip.
+     *
+     * Nothing about a plain button says "clicking me reveals something", so the host has to carry
+     * the state that does: `aria-expanded` for whether the panel is currently up, `aria-haspopup`
+     * for what kind of thing it opens (a pinned panel is a `dialog` — see `TnTooltipComponent`'s
+     * `sticky`), and `aria-controls` pointing at the panel while it exists, so assistive tech can
+     * jump to it. A hover tooltip reveals nothing on activation and carries none of this.
+     */
+    private _syncHostPopupState;
+    /**
+     * Writes the disclosure attributes, remembering the exact value written for each.
+     *
+     * A host that carries any of them keeps all three, and this directive never removes or
+     * overwrites a value it did not itself put there. Hosts own these legitimately and mean
+     * something else by them: a `tnMenuTrigger` is `aria-haspopup="menu"`, a `<tn-select>` points
+     * `aria-controls` at its own listbox, and `<tn-icon-button [ariaExpanded]>` binds
+     * `aria-expanded` to the same inner `<button>` a `tnTooltip` on it would land on. There is only
+     * one of each attribute to go around, and the host's click is what they describe — a tooltip is
+     * the lesser claim.
+     *
+     * Ownership is not re-derived from the current value each time, because a value comparison
+     * cannot tell "the host wrote nothing" from "the host wrote the same string we did" — and
+     * `aria-expanded="false"` is exactly that string. `<tn-icon-button [ariaExpanded]="expanded()">`
+     * with `expanded()` starting `undefined` walks straight into it: the attribute is absent at the
+     * first sync so the tooltip claims it, the consumer later sets `false`, Angular writes the same
+     * `"false"` the tooltip wrote, and on pin the host's collapsed popup would be announced as
+     * expanded. So a write the tooltip did not make is recorded as a fact when it happens — see
+     * `_absorbPopupStateRecords` — and the host keeps the attribute from then on.
+     *
+     * And it is decided for the group, not per attribute: the three describe one popup between
+     * them, so yielding them one at a time would leave the host describing two. A menu trigger
+     * carrying its own `aria-expanded="true"` would keep that value and still take
+     * `aria-haspopup="dialog"` and an `aria-controls` pointing at the tooltip panel, announcing
+     * "expanded dialog controlling tn-tooltip-xxx" for a panel that may well be closed. So if any
+     * one of them is spoken for, the tooltip writes none of them and the host keeps the coherent
+     * state it owns. Nothing about reaching the panel depends on them: it still opens on the host
+     * click and closes on Escape, an outside click or the dismiss button.
+     */
+    private _writeHostPopupState;
+    /**
+     * Whether the attribute is free to write: never written by the host, and either absent or still
+     * holding the value written for it.
+     */
+    private _ownsHostAttribute;
+    /**
+     * Separates the observer records caused by this directive's own writes from the rest, and
+     * returns whether what is left is worth a re-sync.
+     *
+     * Every mutation of a disclosure attribute arrives here, including the ones `_writeHostPopupState`
+     * just made — which is why `attributeFilter` can list them without looping. Each write registers
+     * itself in `_popupStateSelfWrites` first, and one write produces exactly one record, so the
+     * counter cancels them out one for one. Anything left over came from the host, and that is the
+     * fact worth keeping: the value it wrote may well be the one already there.
+     */
+    private _absorbPopupStateRecords;
+    private _setPopupStateAttribute;
+    /** Removing an attribute that is not there mutates nothing, so it must not be counted either. */
+    private _removePopupStateAttribute;
+    /**
+     * Registers a write of our own so `_absorbPopupStateRecords` can cancel out the record it
+     * produces. Only writes made while the observer is connected produce one — the first
+     * `_syncAria` runs before `ngAfterViewInit` has created it, and counting that one would leave a
+     * credit behind for the host's first write to spend.
+     *
+     * Kept per element rather than per attribute name, because a write and the record it produces
+     * can come apart when the element does. A wrapper swapping its inner control (`<tn-button>`
+     * moving between `<a>` and `<button>` through an `@if`) has `_clearHostPopupState` write to the
+     * outgoing element, which is detached by then and so is no longer observed: no record is ever
+     * queued for it. A single shared ledger would carry those credits over to the incoming element
+     * and absorb the host's own writes there as if they were ours. Per element, they are stranded
+     * on a node nothing consults again, and the WeakMap lets it go.
+     */
+    private _countPopupStateWrite;
+    private _clearHostPopupState;
     private _syncAriaDescription;
-    /**
-     * The overlay tooltip renders its message as HTML (`[innerHTML]`), but AriaDescriber
-     * writes the description as plain text — strip any markup so screen readers never
-     * announce literal tags. DOMParser parses inert markup (no script execution).
-     */
-    private _plainTextMessage;
     private _removeAriaDescription;
     ngOnDestroy(): void;
     _onMouseEnter(): void;
     _onMouseLeave(): void;
+    _onClick(event: MouseEvent): void;
     _onKeydown(event: KeyboardEvent): void;
     /** Shows the tooltip */
     show(delay?: number): void;
-    /** Hides the tooltip */
+    /** Hides the tooltip, unpinning it if it was sticky */
     hide(delay?: number): void;
-    /** Toggle the tooltip visibility */
+    /**
+     * Toggles the tooltip, opening it the way its host's own click would.
+     *
+     * Routed through `_pinsOnClick` for the same reason `_onClick` is: `show()` on a pinnable
+     * message puts up a decorative, `aria-hidden` panel with `pointer-events: none`, so the link
+     * inside it cannot be clicked and `mouseleave` takes it away again — the unreachable state pinning exists
+     * to replace, which a public method should not be able to produce either.
+     */
     toggle(): void;
+    /** Whether the tooltip is currently pinned open */
+    isSticky(): boolean;
+    /**
+     * Pins the tooltip open. Shows it first if it isn't visible yet, so it works both as a
+     * follow-up to hover and on its own (e.g. a keyboard-activated host).
+     *
+     * This is the imperative escape hatch: it pins any tooltip with a message, ignoring both
+     * `tnTooltipSticky` and the interactive-content rule that decide whether the *host click* pins
+     * one. A tooltip pinned this way behaves like any other pinned tooltip — dismiss button,
+     * Escape, outside click, and a host click all close it again.
+     *
+     * @param options.focusTooltip Move focus into the tooltip, so its content is reachable
+     * without a pointer.
+     */
+    stick(options?: {
+        focusTooltip?: boolean;
+    }): void;
+    /**
+     * Unpins and hides the tooltip.
+     *
+     * @param restoreFocus Move focus back to the host. Used when the tooltip is dismissed from
+     * the keyboard, where focus would otherwise be lost with the removed element.
+     */
+    unstick(restoreFocus?: boolean): void;
+    /**
+     * Drops the pinned flag and re-advertises the host without it.
+     *
+     * Shared by `unstick()` and `_destroyTooltip` rather than done in either, so the flag and the
+     * disclosure state it drives cannot come apart: whichever gets there first does both halves,
+     * and the other finds nothing left to do. Closing routes that do not go through `unstick()` —
+     * Escape on the host, a disabled input, `ngOnDestroy` — still arrive here through the teardown.
+     */
+    private _releaseSticky;
+    /**
+     * Where focus goes when a pinned tooltip is dismissed from the keyboard.
+     *
+     * A non-focusable host never pins on its own click (see `_isHostKeyboardOperable`), but
+     * `stick()` pins whatever it is called on — `<span tnTooltip="… <a href>…">` included — so
+     * focusing the host blindly is a no-op there, and tearing the panel down straight after drops
+     * focus to `<body>`. Prefer the element that would carry the tooltip's
+     * ARIA state, and if even that cannot hold focus, make the host able to: `tabindex="-1"` keeps
+     * it out of the tab order while letting it be a focus target, and is left in place because
+     * removing it again would drop the focus it was added to catch.
+     */
+    private _restoreFocusTarget;
     private _createOverlay;
+    /**
+     * Points the speech-bubble arrow at the host rather than at the panel's own centre.
+     *
+     * The two only coincide when the panel is perfectly centred on its origin. They come apart
+     * whenever the panel is nudged sideways to stay inside the viewport, or when it is resized
+     * after being placed (entering sticky mode), which used to leave the arrow pointing at empty
+     * space next to the control it belongs to.
+     */
+    private _updateArrowOffset;
+    /**
+     * How far the arrow has to stay from the panel's edge: its own half-base plus the corner
+     * radius. Both are read off the rendered panel, so a change in the stylesheet cannot leave a
+     * stale number behind here.
+     *
+     * Cached for as long as the panel is attached. Only the stylesheet can move these, while the
+     * caller runs on every reposition — which, with the reposition scroll strategy, is every 20ms
+     * for as long as the user keeps scrolling; a `getComputedStyle` per frame to re-read two
+     * constants is not worth it.
+     */
+    private _arrowInset;
     private _resolvePosition;
     private _attachTooltip;
+    /**
+     * Keeps the arrow pointing at the host across re-placements that `positionChanges` does not
+     * report.
+     *
+     * CDK emits `positionChanges` from `_applyPosition` behind
+     * `position !== this._lastPosition || scrollVisibility changed` (cdk 21.1.0), so a panel
+     * re-placed at the *same* position with different coordinates — viewport clamping, which is the
+     * case the arrow offset exists for — emits nothing at all. Listening to the events that drive
+     * those re-placements covers it; the side-placement specs in `tooltip.directive.spec.ts` fail
+     * without this. On a genuine flip both paths run, which is two rect reads either way since the
+     * inset is cached.
+     *
+     * Subscribed here rather than in `_createOverlay`, and deliberately after
+     * `this._overlayRef.attach()`, because the arrow has to be measured against the pane's *new*
+     * position. `RepositionScrollStrategy.enable()` reaches `_scrollDispatcher.scrolled()` through
+     * the same shared subject and the same audit window that this does, so the two run in
+     * subscription order — and `enable()` is called from inside `attach()`. Subscribing before it
+     * put `_updateArrowOffset` first on every scroll tick, reading the pane rect from before the
+     * re-placement: on a pinned side-placed panel, a vertical scroll moved `hostRect.top` while
+     * `panelRect.top` still held the previous value, and since a same-position re-placement emits
+     * no `positionChanges` nothing came along to correct it.
+     *
+     * Re-attaching re-runs the CDK's subscriptions too, so this has to be renewed per attach rather
+     * than held for the lifetime of the overlay - hence the teardown in `_destroyTooltip`.
+     */
+    private _subscribeToReposition;
+    /**
+     * Listens for Escape only while the tooltip is pinned. The CDK keyboard dispatcher hands the
+     * event to the top-most overlay that has subscribers and stops there, so a permanent
+     * subscription would let a plain hover tooltip swallow the Escape meant for the dialog it
+     * sits in.
+     */
+    private _subscribeToEscape;
+    /** Dismisses a pinned tooltip when the user clicks anything else on the page. */
+    private _subscribeToOutsideClicks;
+    private _destroyTooltip;
+    private _isFocusInsideTooltip;
     private _getPositions;
     private _clearTimeouts;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTooltipDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnTooltipDirective, "[tnTooltip]", never, { "message": { "alias": "tnTooltip"; "required": false; "isSignal": true; }; "position": { "alias": "tnTooltipPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "tnTooltipDisabled"; "required": false; "isSignal": true; }; "showDelay": { "alias": "tnTooltipShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "tnTooltipHideDelay"; "required": false; "isSignal": true; }; "tooltipClass": { "alias": "tnTooltipClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnTooltipDirective, "[tnTooltip]", never, { "message": { "alias": "tnTooltip"; "required": false; "isSignal": true; }; "position": { "alias": "tnTooltipPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "tnTooltipDisabled"; "required": false; "isSignal": true; }; "showDelay": { "alias": "tnTooltipShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "tnTooltipHideDelay"; "required": false; "isSignal": true; }; "tooltipClass": { "alias": "tnTooltipClass"; "required": false; "isSignal": true; }; "stickyEnabled": { "alias": "tnTooltipSticky"; "required": false; "isSignal": true; }; "closeAriaLabel": { "alias": "tnTooltipCloseAriaLabel"; "required": false; "isSignal": true; }; "panelAriaLabel": { "alias": "tnTooltipAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TnIconButtonComponent implements AfterViewInit {
@@ -1596,6 +2397,16 @@ declare class TnIconButtonComponent implements AfterViewInit {
     tooltip: _angular_core.InputSignal<string | undefined>;
     /** Position of the styled tooltip relative to the button. */
     tooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    /**
+     * Whether a tooltip message holding a link may be pinned open by clicking the button (see
+     * `tnTooltipSticky`). On by default, like the directive.
+     *
+     * It does not make plain tooltips pinnable — an icon button's tooltip is nearly always a label
+     * for its action, and those keep hovering and never touch the click. Set it to false only to
+     * force a message that does hold a link back to hover behaviour, accepting that the link is
+     * then unreachable.
+     */
+    tooltipSticky: _angular_core.InputSignal<boolean>;
     library: _angular_core.InputSignal<IconLibraryType | undefined>;
     /** Extra class(es) applied to the inner icon, e.g. for animations or state colors. */
     iconClass: _angular_core.InputSignal<string>;
@@ -1612,7 +2423,7 @@ declare class TnIconButtonComponent implements AfterViewInit {
     focus(options?: FocusOptions): void;
     ngAfterViewInit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnIconButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnIconButtonComponent, "tn-icon-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaExpanded": { "alias": "ariaExpanded"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "library": { "alias": "library"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnIconButtonComponent, "tn-icon-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaExpanded": { "alias": "ariaExpanded"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipSticky": { "alias": "tooltipSticky"; "required": false; "isSignal": true; }; "library": { "alias": "library"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; }, never, ["*"], true, never>;
 }
 
 /**
@@ -1764,20 +2575,6 @@ interface IconButtonHarnessFilters extends BaseHarnessFilters {
     size?: string;
 }
 
-declare enum InputType {
-    Email = "email",
-    Number = "number",
-    Password = "password",
-    PlainText = "text",
-    /**
-     * Data-size field: the form model holds a raw byte count (a number), while the
-     * field displays/accepts a human-readable string (e.g. `2 GiB`, `500M`, `2 TB`).
-     * See `tn-input`'s `sizeStandard` / `sizeDefaultUnit` inputs to tune formatting
-     * and bare-number parsing.
-     */
-    Size = "size"
-}
-
 /**
  * Unit standard used to format and parse data sizes.
  *
@@ -1813,20 +2610,112 @@ declare function formatSize(bytes: number | string | null | undefined, standard?
  * @param standard Unit standard (defaults to IEC base-2).
  */
 declare function parseSize(raw: string | number | null | undefined, defaultUnit?: string, standard?: SizeStandard): number | null;
+/**
+ * The pieces {@link parseSize} recognized, for a caller that needs the unit the
+ * text was written in and not just the byte count it denotes.
+ *
+ * @internal
+ */
+interface ParsedSize {
+    /** The byte count the text denotes. */
+    bytes: number;
+    /** The number as it was written, without the unit — `'1500'`, `'1.755'`. */
+    digits: string;
+    /** Power of the base the unit carries (B = 0, K = 1, M = 2, ...). */
+    exponent: number;
+}
+/**
+ * {@link parseSize}, keeping the parts rather than collapsing them to a byte
+ * count. The unit matters when the text has to be re-rendered: the number the
+ * user wrote and the unit they wrote it in always denote their byte count
+ * exactly, which a rounded rendering may not.
+ *
+ * @internal
+ */
+declare function parseSizeParts(raw: string | number | null | undefined, defaultUnit?: string, standard?: SizeStandard): ParsedSize | null;
+/**
+ * Renders a byte count in the largest unit that expresses it EXACTLY within
+ * `round` decimals, or `null` when no suitable unit does.
+ *
+ * The point is a field the user types into. `formatSize` always picks the
+ * natural unit and rounds to fit — 1 572 864 000 becomes `1.46 GiB`, which is a
+ * fine way to READ a size but a lie to hand back to someone who typed
+ * `1500 MiB`: it no longer denotes the value the field holds. One unit down
+ * usually does denote it exactly, so this looks there.
+ *
+ * It looks exactly one step down and no further, which is what keeps the result
+ * readable: a value that is exact in neither its own unit nor the next is
+ * always exact in bytes, and `1567663063 B` helps nobody. Such a value has no
+ * exact spelling worth showing, so this returns `null` and the caller falls
+ * back to the rounded rendering.
+ *
+ * @param bytes The byte count to render. Non-integer and unsafe magnitudes
+ *              return `null` — a byte count is a whole number, and past
+ *              `MAX_SAFE_INTEGER` "exactly" stops meaning anything.
+ * @param standard Unit standard (defaults to IEC base-2).
+ * @param round Decimal places the rendering may use (defaults to 2).
+ * @internal
+ */
+declare function formatSizeExact(bytes: number, standard?: SizeStandard, round?: number): string | null;
+/**
+ * Formats a byte count for a field the user edits: {@link formatSizeExact} when
+ * some unit states the value exactly, and {@link formatSize}'s rounded
+ * rendering when none does.
+ *
+ * @param bytes The byte count to format.
+ * @param standard Unit standard (defaults to IEC base-2).
+ * @param round Decimal places to round to (defaults to 2).
+ * @internal
+ */
+declare function formatSizeForEditing(bytes: number | string | null | undefined, standard?: SizeStandard, round?: number): string;
+/**
+ * Tidies a size the user typed into its canonical spelling, without ever
+ * restating it as a value it does not denote.
+ *
+ * `2048 KiB` becomes `2 MiB` and `200tib` becomes `200 TiB`, because both
+ * renderings are exact. `1500` becomes `1500 MiB` rather than `1.46 GiB`, and
+ * `1.755 GiB` is left at `1.755 GiB`: where no unit expresses the value within
+ * `round` decimals, the number and unit the user wrote do, so those are kept
+ * and only the spelling is normalized.
+ *
+ * Returns `null` for text {@link parseSize} cannot read, which the caller leaves
+ * on screen for its validators to flag.
+ *
+ * @param raw The text to canonicalize.
+ * @param defaultUnit Unit assumed when the input carries no unit (defaults to `MiB`).
+ * @param standard Unit standard (defaults to IEC base-2).
+ * @param round Decimal places a rendering may use (defaults to 2).
+ * @internal
+ */
+declare function canonicalizeSize(raw: string | number | null | undefined, defaultUnit?: string, standard?: SizeStandard, round?: number): string | null;
 
-declare class TnInputComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {
-    inputEl: _angular_core.Signal<ElementRef<HTMLInputElement | HTMLTextAreaElement>>;
-    inputType: _angular_core.InputSignal<InputType>;
-    placeholder: _angular_core.InputSignal<string>;
-    testId: _angular_core.InputSignal<TnTestIdValue>;
-    /** Test-id base, falling back to the bound control name when `testId` is unset. */
-    protected resolvedTestId: _angular_core.Signal<TnTestIdValue>;
-    disabled: _angular_core.InputSignal<boolean>;
-    multiline: _angular_core.InputSignal<boolean>;
-    rows: _angular_core.InputSignal<number>;
-    /**
-     * Explicit accessible name for the control. Rendered as `aria-label` on the
-     * input/textarea. Inside a `tn-form-field` the field's label is associated
+declare enum InputType {
+    Email = "email",
+    Number = "number",
+    Password = "password",
+    PlainText = "text",
+    /**
+     * Data-size field: the form model holds a raw byte count (a number), while the
+     * field displays/accepts a human-readable string (e.g. `2 GiB`, `500M`, `2 TB`).
+     * See `tn-input`'s `sizeStandard` / `sizeDefaultUnit` inputs to tune formatting
+     * and bare-number parsing.
+     */
+    Size = "size"
+}
+
+declare class TnInputComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    inputEl: _angular_core.Signal<ElementRef<HTMLInputElement | HTMLTextAreaElement>>;
+    inputType: _angular_core.InputSignal<InputType>;
+    placeholder: _angular_core.InputSignal<string>;
+    testId: _angular_core.InputSignal<TnTestIdValue>;
+    /** Test-id base, falling back to the bound control name when `testId` is unset. */
+    protected resolvedTestId: _angular_core.Signal<TnTestIdValue>;
+    disabled: _angular_core.InputSignal<boolean>;
+    multiline: _angular_core.InputSignal<boolean>;
+    rows: _angular_core.InputSignal<number>;
+    /**
+     * Explicit accessible name for the control. Rendered as `aria-label` on the
+     * input/textarea. Inside a `tn-form-field` the field's label is associated
      * automatically (via `aria-labelledby`), so leave this unset there unless the
      * announced name must differ from the visible label — when set, it wins. Set
      * it for standalone usage so the control isn't unnamed in the a11y tree.
@@ -1894,6 +2783,12 @@ declare class TnInputComponent implements AfterViewInit, OnDestroy, ControlValue
     /**
      * Decimal places used when formatting a `Size` field's value for display
      * (e.g. `1.5 GiB`). Ignored unless `inputType` is `Size`.
+     *
+     * Display only: the form model always holds the exact byte count the typed
+     * text denotes, and is never re-read from the display. The display avoids
+     * rounding where it can — `1500M` shows as `1500 MiB`, not as a `1.46 GiB`
+     * that means 1 567 663 063 — and where a value fits no unit exactly (a size
+     * read back from the server, say) it is rounded for reading only.
      */
     sizeRound: _angular_core.InputSignal<number>;
     /**
@@ -2598,6 +3493,16 @@ declare class TnChipComponent implements AfterViewInit, OnDestroy {
     classes: _angular_core.Signal<string[]>;
     handleClick(event: MouseEvent): void;
     handleClose(event: MouseEvent): void;
+    /**
+     * Handles the chip's Delete/Backspace dismiss shortcut. Bound to both the
+     * body and the close button so the shortcut works wherever focus sits inside
+     * the chip; the wrapper between them carries no role and is not focusable,
+     * so it is not a legitimate place to hang a key handler.
+     *
+     * Enter and Space are deliberately absent: the body is a native `<button>`,
+     * which already turns both into a `click`. Handling them here as well would
+     * emit `onClick` twice per keypress.
+     */
     handleKeyDown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnChipComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnChipComponent, "tn-chip", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; "onClick": "onClick"; }, never, never, true, never>;
@@ -2627,6 +3532,7 @@ declare class TnChipHarness extends ComponentHarness {
      */
     static hostSelector: string;
     private _chip;
+    private _body;
     private _label;
     private _icon;
     private _closeButton;
@@ -2863,6 +3769,20 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     testId: _angular_core.InputSignal<TnTestIdValue>;
     /** Test-id base, falling back to the bound control name when `testId` is unset. */
     protected resolvedTestId: _angular_core.Signal<TnTestIdValue>;
+    /**
+     * Optional extractor for the per-option test-id discriminator, applied to both
+     * a suggestion row and the chip it becomes. Defaults to the option's `label`,
+     * the text actually on screen — provide this to key off a locale-independent
+     * field instead, or where two options share a display name and the derived ids
+     * would otherwise collide. Free-text chips have no option to extract from and
+     * stay named by their own value.
+     *
+     * @example
+     * ```html
+     * <tn-chip-input testId="users" [optionTestIdKey]="(o) => o.value.id" ... />
+     * ```
+     */
+    optionTestIdKey: _angular_core.InputSignal<((option: TnChipInputOption<T>) => string | number | null | undefined) | undefined>;
     /** Emits the committed value whenever a chip is added. */
     chipAdded: _angular_core.OutputEmitterRef<T>;
     /** Emits the removed value whenever a chip is removed. */
@@ -2924,19 +3844,27 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     /**
      * Scopes a per-chip test id beneath the component's base.
      *
-     * The discriminator is the value itself when primitive, else the matching
-     * option's label — `String(value)` on an object is `[object Object]`, which
-     * would stamp an identical id on every chip. Duplicates are worse than
-     * absence for automation, so an object value with no option to name it yet
-     * (options still loading) stays attribute-free rather than colliding. A primitive
-     * that normalizes away is dropped for the same reason — see
-     * {@link discriminatedTestId}.
+     * A chip backed by an option goes through the same {@link optionTestId}
+     * derivation as the suggestion row that created it, so the two carry the same
+     * discriminator by construction rather than one naming the label and the other
+     * the value — including whatever fallback that shared rule settles on, and any
+     * `optionTestIdKey` override.
+     *
+     * A value with no matching option is named by itself when it is a primitive:
+     * either a free-text chip, which is its own text, or an option-backed value
+     * whose options have not arrived yet — an async `[options]` load moves such a
+     * chip's id from the value to the resolved label once it does. An object value
+     * with no match cannot stand in for itself, because `String(value)` on an
+     * object is `[object Object]` and would stamp an identical id on every chip.
+     * Duplicates are worse than absence for automation, so that chip stays
+     * attribute-free rather than colliding. A primitive that normalizes away is
+     * dropped for the same reason — see {@link discriminatedTestId}.
      */
     protected chipTestId(value: T): TnTestIdValue;
     /**
      * Scopes a per-suggestion test id beneath the component's base, via the shared
      * dropdown-option derivation. Unlike `tn-select` / `tn-autocomplete`, which
-     * emit an unscoped `option-<value>` when they have no base, an unidentified
+     * emit an unscoped `option-<label>` when they have no base, an unidentified
      * chip-input stays attribute-free — its rows carry no page-unique id, so
      * emitting one would invite collisions between inputs.
      */
@@ -2958,6 +3886,24 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     private commitText;
     /** Commits a resolved value, honouring duplicate and cap rules. */
     private commitValue;
+    /**
+     * The option a committed value came from, or `undefined` for a free-text chip.
+     *
+     * Both the chip's label and its test id need this lookup, and both are called
+     * from the template — once per chip per change-detection cycle — so a linear
+     * scan of the options would be quadratic in (chips × options) on every cycle.
+     * With the default identity comparator, {@link optionIndex} answers in constant
+     * time; a custom `compareWith` can't be indexed (only it knows what equality
+     * means for the value), so that path keeps the scan.
+     */
+    private optionFor;
+    /**
+     * Value → option, rebuilt only when the option list changes. First entry wins,
+     * matching the `find` it replaces where a value is repeated across options.
+     * Keys compare by `Map` identity, which agrees with the `===` this stands in
+     * for on every value a form control can hold.
+     */
+    private optionIndex;
     private valuesIncludes;
     private valueMatches;
     private clearInput;
@@ -2974,7 +3920,7 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     private attachOverlay;
     private detachOverlay;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnChipInputComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnChipInputComponent<any>, "tn-chip-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "separatorKeys": { "alias": "separatorKeys"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "maxChips": { "alias": "maxChips"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "chipAdded": "chipAdded"; "chipRemoved": "chipRemoved"; "searchChange": "searchChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnChipInputComponent<any>, "tn-chip-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "separatorKeys": { "alias": "separatorKeys"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "maxChips": { "alias": "maxChips"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "optionTestIdKey": { "alias": "optionTestIdKey"; "required": false; "isSignal": true; }; }, { "chipAdded": "chipAdded"; "chipRemoved": "chipRemoved"; "searchChange": "searchChange"; }, never, never, true, never>;
 }
 
 /**
@@ -3266,6 +4212,28 @@ declare class TnCardComponent {
      */
     titleTooltipAriaLabel: _angular_core.InputSignal<string | undefined>;
     protected readonly resolvedTitleTooltipAriaLabel: _angular_core.Signal<string>;
+    /**
+     * Whether a tooltip message holding a link may be pinned open by clicking its host (see
+     * `tnTooltipSticky`). On by default, like the directive, and it reaches the title help button
+     * and the footer actions.
+     *
+     * The help button has no other use for the click, so there pinning is all the click does. A
+     * footer action does have one: pinning is additive there, exactly as `tnTooltipSticky` describes
+     * it — one click on a `TnCardAction` whose `tooltip` holds a link both runs `handler()` and pins
+     * the panel. That is fine for a handler that leaves the card in place, and worth a second look
+     * for one that navigates away or closes it, since the panel it pinned goes with the card. Set
+     * this to false for such a card.
+     *
+     * The kebab-menu trigger is deliberately out of scope. Its click already opens the menu, so a
+     * pinnable tooltip there would put a panel over the menu from that same click and take the hint
+     * off hover to do it; `headerMenuTriggerTooltip` therefore always hovers, and this flag does not
+     * reach it.
+     *
+     * It does not make plain tooltips pinnable — card help and action hints are nearly always plain
+     * text, and those keep hovering. Set it to false only to force a message that does hold a link
+     * back to hover behaviour, accepting that the link is then unreachable.
+     */
+    tooltipSticky: _angular_core.InputSignal<boolean>;
     elevation: _angular_core.InputSignal<"none" | "low" | "medium" | "high">;
     padding: _angular_core.InputSignal<"small" | "large" | "medium">;
     padContent: _angular_core.InputSignal<boolean>;
@@ -3301,6 +4269,10 @@ declare class TnCardComponent {
     /**
      * Hover tooltip for the kebab-menu trigger. Defaults to `headerMenuTriggerAriaLabel`, so setting
      * a single translated string covers both the accessible name and the visible hint.
+     *
+     * Hover is all it ever is: unlike the card's other tooltips this one is never pinnable, because
+     * the trigger's click belongs to the menu — see `tooltipSticky`. A message holding a link works
+     * here, but the link stays out of reach.
      */
     headerMenuTriggerTooltip: _angular_core.InputSignal<string | undefined>;
     protected readonly resolvedHeaderMenuAriaLabel: _angular_core.Signal<string>;
@@ -3329,7 +4301,7 @@ declare class TnCardComponent {
     onHeaderMenuItemClick(_item: TnMenuItem): void;
     getStatusClass(type?: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnCardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnCardComponent, "tn-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "titleLink": { "alias": "titleLink"; "required": false; "isSignal": true; }; "titleRouterLink": { "alias": "titleRouterLink"; "required": false; "isSignal": true; }; "titleQueryParams": { "alias": "titleQueryParams"; "required": false; "isSignal": true; }; "titleTooltip": { "alias": "titleTooltip"; "required": false; "isSignal": true; }; "titleTooltipAriaLabel": { "alias": "titleTooltipAriaLabel"; "required": false; "isSignal": true; }; "elevation": { "alias": "elevation"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "padContent": { "alias": "padContent"; "required": false; "isSignal": true; }; "fillHeight": { "alias": "fillHeight"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; "headerStatus": { "alias": "headerStatus"; "required": false; "isSignal": true; }; "headerControl": { "alias": "headerControl"; "required": false; "isSignal": true; }; "headerMenu": { "alias": "headerMenu"; "required": false; "isSignal": true; }; "headerMenuTriggerTestId": { "alias": "headerMenuTriggerTestId"; "required": false; "isSignal": true; }; "headerMenuTriggerAriaLabel": { "alias": "headerMenuTriggerAriaLabel"; "required": false; "isSignal": true; }; "headerMenuTriggerTooltip": { "alias": "headerMenuTriggerTooltip"; "required": false; "isSignal": true; }; "primaryAction": { "alias": "primaryAction"; "required": false; "isSignal": true; }; "secondaryAction": { "alias": "secondaryAction"; "required": false; "isSignal": true; }; "footerLink": { "alias": "footerLink"; "required": false; "isSignal": true; }; }, {}, ["projectedHeader", "headerActions", "footerActions"], ["[tnCardHeader]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnCardComponent, "tn-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "titleLink": { "alias": "titleLink"; "required": false; "isSignal": true; }; "titleRouterLink": { "alias": "titleRouterLink"; "required": false; "isSignal": true; }; "titleQueryParams": { "alias": "titleQueryParams"; "required": false; "isSignal": true; }; "titleTooltip": { "alias": "titleTooltip"; "required": false; "isSignal": true; }; "titleTooltipAriaLabel": { "alias": "titleTooltipAriaLabel"; "required": false; "isSignal": true; }; "tooltipSticky": { "alias": "tooltipSticky"; "required": false; "isSignal": true; }; "elevation": { "alias": "elevation"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "padContent": { "alias": "padContent"; "required": false; "isSignal": true; }; "fillHeight": { "alias": "fillHeight"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; "headerStatus": { "alias": "headerStatus"; "required": false; "isSignal": true; }; "headerControl": { "alias": "headerControl"; "required": false; "isSignal": true; }; "headerMenu": { "alias": "headerMenu"; "required": false; "isSignal": true; }; "headerMenuTriggerTestId": { "alias": "headerMenuTriggerTestId"; "required": false; "isSignal": true; }; "headerMenuTriggerAriaLabel": { "alias": "headerMenuTriggerAriaLabel"; "required": false; "isSignal": true; }; "headerMenuTriggerTooltip": { "alias": "headerMenuTriggerTooltip"; "required": false; "isSignal": true; }; "primaryAction": { "alias": "primaryAction"; "required": false; "isSignal": true; }; "secondaryAction": { "alias": "secondaryAction"; "required": false; "isSignal": true; }; "footerLink": { "alias": "footerLink"; "required": false; "isSignal": true; }; }, {}, ["projectedHeader", "headerActions", "footerActions"], ["[tnCardHeader]", "*"], true, never>;
 }
 
 /**
@@ -4265,7 +5237,6 @@ declare class TnSlideToggleComponent implements AfterViewInit, OnDestroy, Contro
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     onToggleChange(event: Event): void;
-    onLabelClick(): void;
     classes: _angular_core.Signal<string[]>;
     effectiveAriaLabel: _angular_core.Signal<string | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnSlideToggleComponent, never>;
@@ -4361,6 +5332,20 @@ declare class TnTabComponent implements AfterContentInit {
     selected: _angular_core.OutputEmitterRef<void>;
     iconContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
     index: _angular_core.WritableSignal<number>;
+    /**
+     * Id namespace, set by the parent `tn-tabs` so that both ends of the tab↔panel wiring
+     * agree. The default is unique per instance rather than a constant, so a `tn-tab`
+     * rendered outside a `tn-tabs` still renders an `id` that collides with nothing.
+     */
+    groupId: _angular_core.WritableSignal<string>;
+    /**
+     * Whether the parent has a panel at this tab's index, which is what decides whether
+     * `aria-controls` is rendered at all. `tn-tabs` walks its tabs and its panels
+     * independently, so a group given more tabs than panels — or a `tn-tab` used outside a
+     * `tn-tabs`, which is why this starts false — would otherwise point `aria-controls` at
+     * an id no element in the document carries.
+     */
+    hasPanel: _angular_core.WritableSignal<boolean>;
     isActive: _angular_core.WritableSignal<boolean>;
     tabsComponent?: {
         onKeydown: (event: KeyboardEvent, index: number) => void;
@@ -4373,20 +5358,92 @@ declare class TnTabComponent implements AfterContentInit {
     onKeydown(event: KeyboardEvent): void;
     classes: _angular_core.Signal<string>;
     tabIndex: _angular_core.Signal<-1 | 0>;
+    /** This tab's own id, which its panel points back at with `aria-labelledby`. */
+    tabId: _angular_core.Signal<string>;
+    /** The id of the panel this tab controls, for `aria-controls`. */
+    panelId: _angular_core.Signal<string>;
     hasIcon: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTabComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTabComponent, "tn-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconTemplate": { "alias": "iconTemplate"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, ["iconContent"], ["*"], true, never>;
 }
 
+/**
+ * The name the scrolling content region takes when it becomes focusable and the
+ * panel has no `label` to name it from (#270).
+ *
+ * A focusable element with no accessible name is announced as a bare "group".
+ * A panel rendered outside a `tn-tabs`, or one whose caller left `label` empty,
+ * has no better name available — so this is the last resort rather than the
+ * usual case, and `contentLabel` prefers the label every time there is one.
+ *
+ * Exported so specs assert against it by name rather than by a copied literal.
+ */
+declare const TN_TAB_PANEL_CONTENT_LABEL = "Tab panel content";
 declare class TnTabPanelComponent {
     label: _angular_core.InputSignal<string>;
     lazyLoad: _angular_core.InputSignal<boolean>;
     testId: _angular_core.InputSignal<TnTestIdValue>;
     content: _angular_core.Signal<TemplateRef<unknown>>;
+    /**
+     * The scrolling content region, which is `.tn-tab-panel__content` — the
+     * element the stylesheet gives `overflow: auto`, not the `role="tabpanel"`
+     * wrapper around it. Optional because it lives inside `@if (shouldRender())`,
+     * so a lazy panel that has never been active does not render it.
+     *
+     * The template ref is `#contentRegion` and not `#content`, which is taken:
+     * the `content` query above asks for a `TemplateRef` under that name, and
+     * naming a real element `#content` would hand it an `ElementRef` instead.
+     */
+    private contentRef;
+    /**
+     * Whether the content region carries the tab stop, its role and its name —
+     * and, conversely, whether the `role="tabpanel"` wrapper gives its own up.
+     *
+     * `.tn-tab-panel__content` is what scrolls, so it is what a keyboard user
+     * has to be able to stand on to read past the fold (#270). The measurement,
+     * the observers behind it and the rule that holds the answer true while the
+     * region has focus are `tnScrollableRegion`'s; the template says why the two
+     * elements trade one tab stop rather than carrying two.
+     */
+    protected contentKeyboardReachable: _angular_core.Signal<boolean>;
     index: _angular_core.WritableSignal<number>;
+    /**
+     * Id namespace, set by the parent `tn-tabs` so that both ends of the tab↔panel wiring
+     * agree. Unique per instance by default, for the same reason as on `tn-tab`: a panel
+     * rendered outside a `tn-tabs` still renders an `id`, and one colliding with another
+     * group's panel would be worse than one nothing points at.
+     */
+    groupId: _angular_core.WritableSignal<string>;
+    /**
+     * Whether the parent has a tab at this panel's index, which is what decides whether
+     * `aria-labelledby` is rendered. The mirror of `hasPanel` on `tn-tab`, and for the same
+     * reason: more panels than tabs, or a panel outside a `tn-tabs`, would otherwise leave
+     * this pointing at an id nothing carries — which is what `aria-labelledby="tab-0"` did
+     * unconditionally before #232.
+     */
+    hasTab: _angular_core.WritableSignal<boolean>;
     isActive: _angular_core.WritableSignal<boolean>;
     hasBeenActive: _angular_core.WritableSignal<boolean>;
     elementRef: ElementRef<any>;
+    /** This panel's own id, which its tab points at with `aria-controls`. */
+    panelId: _angular_core.Signal<string>;
+    /** The id of the tab that labels this panel, for `aria-labelledby`. */
+    tabId: _angular_core.Signal<string>;
+    /**
+     * What the scrolling content region is named while it carries the tab stop.
+     *
+     * The panel's own `label` where there is one, because that is what its tab
+     * says and a listener arriving from the tab hears the same words for the
+     * region it opened. `aria-labelledby` pointing at the tab would be the other
+     * way to say it and is not used here: the tab lives in a sibling component,
+     * so the IDREF resolves only inside a `tn-tabs`, and a panel rendered on its
+     * own would be left unnamed by exactly the route that was supposed to name
+     * it — the `--tn-error-text` hazard in another shape.
+     *
+     * Trimmed, because a whitespace-only label names the region with nothing,
+     * which is the state `TN_TAB_PANEL_CONTENT_LABEL` exists to prevent.
+     */
+    protected contentLabel: _angular_core.Signal<string>;
     classes: _angular_core.Signal<string>;
     shouldRender: _angular_core.Signal<boolean>;
     onActivate(): void;
@@ -4407,10 +5464,17 @@ declare class TnTabsComponent implements AfterContentInit, AfterViewInit, OnDest
     orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
     highlightPosition: _angular_core.InputSignal<"bottom" | "top" | "left" | "right">;
     /**
-     * Test-id applied to the tablist root element. Rendered under whichever attribute name
-     * is configured via `TN_TEST_ATTR` (default `data-testid`).
+     * Test-id applied to the root element — the wrapper around the tablist and the panels,
+     * not the tablist itself, which is the header inside it. Rendered under whichever
+     * attribute name is configured via `TN_TEST_ATTR` (default `data-testid`).
      */
     testId: _angular_core.InputSignal<TnTestIdValue>;
+    /**
+     * Namespace for the ids this group hands to its tabs and panels, so that two `tn-tabs`
+     * on one page cannot both mint `tab-0` and cross-wire each other's `aria-controls` and
+     * `aria-labelledby`. See `tab-ids.ts`.
+     */
+    private readonly groupId;
     selectedIndexChange: _angular_core.OutputEmitterRef<number>;
     tabChange: _angular_core.OutputEmitterRef<TabChangeEvent>;
     private internalSelectedIndex;
@@ -5045,6 +6109,18 @@ declare class TnKeyboardShortcutComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnKeyboardShortcutComponent, "tn-keyboard-shortcut", never, { "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; "platform": { "alias": "platform"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/** What a host binds its template and its dismiss handler to. @internal */
+interface DismissibleErrorState {
+    /** The host's own list when it has one, otherwise the app-wide default. */
+    resolvedDismissibleErrors: Signal<readonly string[]>;
+    /** Whether the shown message renders a close button beside it. */
+    showDismiss: Signal<boolean>;
+    /** Accessible name for that button. */
+    resolvedDismissAriaLabel: Signal<string>;
+    /** Hover hint for that button. */
+    resolvedDismissTooltip: Signal<string>;
+}
+
 /**
  * Contract between `tn-form-field` and its projected form control, published
  * over DI so the control can wire its ARIA attributes to the field's chrome
@@ -5143,6 +6219,21 @@ declare class TnFormFieldComponent implements AfterContentInit, TnFormFieldConte
     tooltip: _angular_core.InputSignal<string>;
     /** Placement of the tooltip relative to its help icon. */
     tooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    /**
+     * Whether a tooltip message holding a link may be pinned open by clicking the help button (see
+     * `tnTooltipSticky`). On by default, like the directive.
+     *
+     * It does not make plain tooltips pinnable — field help is nearly always plain text, and that
+     * keeps hovering. Set it to false only to force a message that does hold a link back to hover
+     * behaviour, accepting that the link is then unreachable.
+     */
+    tooltipSticky: _angular_core.InputSignal<boolean>;
+    /**
+     * Accessible name for the help button, which is icon-only and so has nothing else to be named
+     * by. The message is what the button is for, but it may hold markup — a link is the whole point
+     * of `tooltipSticky` — and `aria-label` takes plain text, so the tags come off first.
+     */
+    protected readonly tooltipAriaLabel: _angular_core.Signal<string>;
     /**
      * Per-field overrides for validation messages, keyed by error key. Values may
      * be a string or a function that receives the error's detail value. Takes
@@ -5150,7 +6241,56 @@ declare class TnFormFieldComponent implements AfterContentInit, TnFormFieldConte
      * built-in defaults.
      */
     errorMessages: _angular_core.InputSignal<Partial<Record<string, _truenas_ui_components.TnFormFieldErrorMessage>>>;
+    /**
+     * Error keys whose message renders with a dismiss button beside it — in
+     * practice a failure the user cannot fix by editing the value, so the message
+     * would otherwise stick until the control changes: a server-side rejection an
+     * error handler attached to the control, or an async validator that judged the
+     * value the user already picked.
+     *
+     * Only the error actually being shown gets the button. A control carrying both
+     * a dismissible key and `required` shows the `required` message, undismissable,
+     * because that is the message on screen.
+     *
+     * Dismissing deletes these keys from the control's errors — listing them here
+     * is what grants that, since a message the user can close but that does not go
+     * away would be worse than no button. Every listed key the control carries goes
+     * at once, not just the one behind the message: an app that spreads one failure
+     * across sibling keys (a flag, its message, a legacy alias) would otherwise see
+     * the message reappear from a sibling. Unlisted errors are left alone, and
+     * {@link dismiss} reports which message went.
+     *
+     * Left unset, the app-wide {@link TN_FORM_FIELD_DISMISSIBLE_ERRORS} default
+     * applies; pass `[]` to opt this field out of it.
+     */
+    dismissibleErrors: _angular_core.InputSignal<readonly string[] | undefined>;
+    /**
+     * Accessible name for the dismiss button, which is icon-only and so has
+     * nothing else to be named by. The library cannot translate its own
+     * `'Dismiss this error'` default, so a consumer with an i18n layer passes an
+     * already-translated string here.
+     */
+    dismissAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Hover tooltip for the dismiss button. Defaults to the resolved
+     * `dismissAriaLabel`, so one translated string covers both the accessible name
+     * and the visible hint.
+     */
+    dismissTooltip: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Emits the error key the user dismissed, after it has been removed — the key
+     * of the message that was on screen, so a consumer listing several dismissible
+     * keys knows which one went.
+     */
+    dismiss: _angular_core.OutputEmitterRef<string>;
     control: _angular_core.Signal<NgControl | undefined>;
+    private host;
+    /**
+     * `read: ElementRef` because the ref sits on `tn-icon-button`, and a component
+     * ref resolves to the instance by default — the element is what the focus
+     * check needs.
+     */
+    private dismissButton;
     private destroyRef;
     /**
      * App-wide message resolver, captured once at construction. Unlike the
@@ -5187,6 +6327,28 @@ declare class TnFormFieldComponent implements AfterContentInit, TnFormFieldConte
     protected showInlineExtras: _angular_core.Signal<boolean>;
     protected hasError: _angular_core.Signal<boolean>;
     protected errorMessage: _angular_core.Signal<string>;
+    /**
+     * The error key the shown message came from. Same pick `resolveErrorMessage`
+     * makes, so the dismiss button can never belong to an error other than the one
+     * being read.
+     */
+    protected activeError: _angular_core.Signal<string | null>;
+    /**
+     * Which list applies, whether the button shows, and what it is called — shared
+     * with `tn-form-errors` so a field message and a group message beside it can
+     * never decide dismissibility by different rules.
+     */
+    protected dismissible: DismissibleErrorState;
+    /**
+     * Drops the dismissed error, then puts focus back on the control rather than
+     * letting it fall to `<body>` with the button — dismissing a server-side error
+     * means "let me try again", and the control is where trying again happens.
+     *
+     * Focus only moves if it was on the button to begin with: a dismiss triggered
+     * from anywhere else (a Safari mouse click, which leaves the button unfocused)
+     * has no focus to lose and should not steal any.
+     */
+    protected dismissError(): void;
     ngAfterContentInit(): void;
     private syncControlState;
     /**
@@ -5194,14 +6356,12 @@ declare class TnFormFieldComponent implements AfterContentInit, TnFormFieldConte
      * `errorMessages` input (and the injected resolver), so it is reactive: the
      * displayed message updates when either the control errors or the overrides
      * change — e.g. a runtime locale switch.
+     *
+     * The ladder itself lives in `./form-field.errors`, shared with
+     * `tn-form-errors` so a group-level message reads exactly like the
+     * field-level one it sits beside.
      */
     private resolveErrorMessage;
-    /**
-     * Runs a caller-supplied message provider, swallowing any throw so a buggy
-     * override or resolver cannot break change detection. Logs in dev mode and
-     * returns null so resolution falls through to the next layer.
-     */
-    private runGuarded;
     showError: _angular_core.Signal<boolean>;
     showHint: _angular_core.Signal<boolean>;
     protected showSubscript: _angular_core.Signal<boolean>;
@@ -5218,7 +6378,7 @@ declare class TnFormFieldComponent implements AfterContentInit, TnFormFieldConte
     /** Forced or validator-inferred required state, for `aria-required`. */
     requiredState: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnFormFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormFieldComponent, "tn-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, {}, ["control"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormFieldComponent, "tn-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipSticky": { "alias": "tooltipSticky"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "dismissibleErrors": { "alias": "dismissibleErrors"; "required": false; "isSignal": true; }; "dismissAriaLabel": { "alias": "dismissAriaLabel"; "required": false; "isSignal": true; }; "dismissTooltip": { "alias": "dismissTooltip"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, ["control"], ["*"], true, never>;
 }
 
 /**
@@ -5275,6 +6435,59 @@ type TnFormFieldErrorResolver = (errorKey: string, errorValue: unknown, control:
  * ```
  */
 declare const TN_FORM_FIELD_ERRORS: InjectionToken<TnFormFieldErrorResolver>;
+/**
+ * App-wide default for which error keys carry a dismiss button, for apps whose
+ * server-side failures always land under the same keys. A field's
+ * `dismissibleErrors` input overrides it — including with `[]`, to opt one field
+ * out of the default.
+ *
+ * Listing a key here grants permission to delete it: dismissing removes it from
+ * the control's errors, since a message the user can close but that will not go
+ * away is worse than no button at all.
+ *
+ * @example
+ * ```ts
+ * providers: [
+ *   {
+ *     provide: TN_FORM_FIELD_DISMISSIBLE_ERRORS,
+ *     useValue: ['manualValidateError', 'manualValidateErrorMsg'],
+ *   },
+ * ];
+ * ```
+ */
+declare const TN_FORM_FIELD_DISMISSIBLE_ERRORS: InjectionToken<readonly string[]>;
+/** What {@link resolveErrorMessage} needs to answer for one control. */
+interface ResolveErrorMessageOptions {
+    /** The control's current errors — the caller has already checked it has some. */
+    errors: ValidationErrors;
+    /** Per-instance overrides, keyed by error key. Consulted first. */
+    errorMessages?: TnFormFieldErrorMessages;
+    /** The app-wide resolver from {@link TN_FORM_FIELD_ERRORS}, if one is provided. */
+    resolver?: TnFormFieldErrorResolver | null;
+    /** The failing control, passed through to the resolver. */
+    control?: AbstractControl | null;
+    /**
+     * Who is asking, used only to attribute the dev-mode `console.error` this
+     * logs when a caller-supplied message provider throws. Optional: the library's
+     * own components pass their selector so the log names the element on screen,
+     * and an outside caller has nothing useful to put here.
+     */
+    selector?: string;
+}
+/**
+ * Resolves a user-facing message for a control's active error, in the order
+ * `tn-form-field` has always used:
+ *
+ * 1. a per-instance `errorMessages` override (string or factory),
+ * 2. the app-wide {@link TN_FORM_FIELD_ERRORS} resolver,
+ * 3. {@link defaultErrorMessage} for Angular's standard validators,
+ * 4. the error value itself, when a custom validator returned its own string,
+ * 5. the raw error key.
+ *
+ * Shared with `tn-form-errors` so a group-level message reads exactly like the
+ * field-level one it sits beside.
+ */
+declare function resolveErrorMessage(options: ResolveErrorMessageOptions): string;
 
 /**
  * Harness for interacting with `tn-form-field` in tests.
@@ -5308,6 +6521,7 @@ declare class TnFormFieldHarness extends ComponentHarness {
     private _error;
     private _hint;
     private _tooltip;
+    private _dismiss;
     /**
      * Gets a `HarnessPredicate` that can be used to search for a form field
      * with specific attributes.
@@ -5364,6 +6578,37 @@ declare class TnFormFieldHarness extends ComponentHarness {
      * ```
      */
     hasError(): Promise<boolean>;
+    /**
+     * Checks whether the shown error carries a dismiss button — true only when the
+     * active error key is one of the field's `dismissibleErrors`.
+     *
+     * @returns Promise resolving to true if the dismiss button is present.
+     *
+     * @example
+     * ```typescript
+     * const field = await loader.getHarness(TnFormFieldHarness.with({ label: 'Image' }));
+     * expect(await field.isErrorDismissible()).toBe(true);
+     * ```
+     */
+    isErrorDismissible(): Promise<boolean>;
+    /**
+     * Clicks the dismiss button, as a user clearing a server-side error would.
+     *
+     * The field clears the error itself — every key in its `dismissibleErrors`
+     * that the control carries — puts focus back on the control, and then emits
+     * `dismiss` with the key that was on screen, so the message is gone by the
+     * time this resolves.
+     *
+     * @throws If the shown error is not dismissible.
+     *
+     * @example
+     * ```typescript
+     * const field = await loader.getHarness(TnFormFieldHarness.with({ label: 'Image' }));
+     * await field.dismissError();
+     * expect(await field.hasError()).toBe(false);
+     * ```
+     */
+    dismissError(): Promise<void>;
     /**
      * Gets the hint text, if visible.
      *
@@ -5391,6 +6636,9 @@ declare class TnFormFieldHarness extends ComponentHarness {
     /**
      * Gets the tooltip message (read from the trigger's accessible label).
      *
+     * A message holding markup — a link, say — comes back as the text a screen reader hears, since
+     * that is what the label carries; assert against the message's text, not its tags.
+     *
      * @returns Promise resolving to the tooltip text, or null if no tooltip.
      *
      * @example
@@ -5472,6 +6720,455 @@ interface FormFieldHarnessFilters extends BaseHarnessFilters {
     testId?: string;
 }
 
+/**
+ * Renders the validation message for a control that is NOT projected into a
+ * `tn-form-field` — in practice a `FormGroup` or `FormArray`, whose errors
+ * belong to the group as a whole and so have no single field to sit under.
+ *
+ * `tn-form-field` covers the ordinary case and should still be preferred: it
+ * owns the label, the `aria-describedby` wiring and the subscript slot. Reach
+ * for this component only where there is no field to own the message —
+ * a cross-field validator on a group, a `minArrayLength` on a form array, a
+ * server-side error attached to a group by an error handler.
+ *
+ * The message comes from the same ladder `tn-form-field` uses (per-instance
+ * `errorMessages`, then the app-wide {@link TN_FORM_FIELD_ERRORS} resolver,
+ * then the built-in defaults), so a group message reads exactly like the field
+ * messages around it. Like `tn-form-field`, it shows ONE message — the active
+ * error, chosen by the same priority — rather than every error at once.
+ *
+ * @example
+ * ```html
+ * <tn-form-errors [control]="form.controls.schedule" />
+ * ```
+ */
+declare class TnFormErrorsComponent {
+    /** The control whose errors are rendered. Usually a group or an array. */
+    control: _angular_core.InputSignal<AbstractControl<any, any, any>>;
+    /**
+     * Per-instance overrides, keyed by error key. Take precedence over the
+     * app-wide resolver, exactly as on `tn-form-field`.
+     */
+    errorMessages: _angular_core.InputSignal<Partial<Record<string, _truenas_ui_components.TnFormFieldErrorMessage>>>;
+    /**
+     * Show the message before the user has touched or dirtied the control.
+     *
+     * Off by default, so a freshly opened form does not greet the user with
+     * errors. Turn it on where the invalid value did not come from the user —
+     * an edit form populated from an API, or a group an error handler has just
+     * attached a server-side failure to.
+     */
+    showWhenUntouched: _angular_core.InputSignal<boolean>;
+    /**
+     * Test-id base for the message element (`error-` prefixed). There is no
+     * fallback: an `AbstractControl` does not know its own name, so a message
+     * that needs to be addressable in a test has to be named here.
+     */
+    testId: _angular_core.InputSignal<TnTestIdValue>;
+    /**
+     * Error keys whose message renders with a dismiss button beside it — in
+     * practice a failure the user cannot fix by editing a field, so the message
+     * would otherwise stick: a server-side rejection an error handler attached to
+     * the group.
+     *
+     * Only the error actually being shown gets the button, since that is the
+     * message the button belongs to.
+     *
+     * Dismissing deletes these keys from the group's errors — listing them here is
+     * what grants that. Every listed key the group carries goes at once, not just
+     * the one behind the message, so a failure spread across sibling keys cannot
+     * reappear from a sibling. Unlike `tn-form-field` there is no control to hand
+     * focus back to once the button goes away, so a consumer who cares where focus
+     * lands should move it in the {@link dismiss} handler.
+     *
+     * Left unset, the app-wide {@link TN_FORM_FIELD_DISMISSIBLE_ERRORS} default
+     * applies; pass `[]` to opt this message out of it.
+     */
+    dismissibleErrors: _angular_core.InputSignal<readonly string[] | undefined>;
+    /**
+     * Accessible name for the dismiss button, which is icon-only and so has
+     * nothing else to be named by. The library cannot translate its own
+     * `'Dismiss this error'` default, so a consumer with an i18n layer passes an
+     * already-translated string here.
+     */
+    dismissAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Hover tooltip for the dismiss button. Defaults to the resolved
+     * `dismissAriaLabel`, so one translated string covers both the accessible name
+     * and the visible hint.
+     */
+    dismissTooltip: _angular_core.InputSignal<string | undefined>;
+    /** Emits the error key whose message the user dismissed, after it is removed. */
+    dismiss: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Id of the message element, so a caller can point a control's
+     * `aria-describedby` at a group message it is covered by.
+     */
+    readonly errorId: string;
+    private errorResolver;
+    private state;
+    protected errorMessage: _angular_core.Signal<string>;
+    /**
+     * Whether to render. A control can be invalid with no message to show — a
+     * group whose only error resolves to blank — so the message is part of the
+     * condition rather than something the template renders empty.
+     */
+    protected show: _angular_core.Signal<boolean>;
+    /**
+     * The id when there is a message to point at, and null when there is not — so
+     * a caller can bind this straight to `aria-describedby` without ever naming
+     * an element that is not on screen.
+     */
+    readonly describedBy: _angular_core.Signal<string | null>;
+    /**
+     * The error key the shown message came from. Same pick `resolveErrorMessage`
+     * makes, so the dismiss button can never belong to an error other than the one
+     * being read.
+     */
+    protected activeError: _angular_core.Signal<string | null>;
+    /**
+     * Which list applies, whether the button shows, and what it is called — shared
+     * with `tn-form-field` so a group message and the field messages beside it can
+     * never decide dismissibility by different rules.
+     */
+    protected dismissible: DismissibleErrorState;
+    protected dismissError(): void;
+    constructor();
+    private sync;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnFormErrorsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormErrorsComponent, "tn-form-errors", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "showWhenUntouched": { "alias": "showWhenUntouched"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "dismissibleErrors": { "alias": "dismissibleErrors"; "required": false; "isSignal": true; }; "dismissAriaLabel": { "alias": "dismissAriaLabel"; "required": false; "isSignal": true; }; "dismissTooltip": { "alias": "dismissTooltip"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+/**
+ * A set of criteria that can be used to filter a list of
+ * `TnFormErrorsHarness` instances.
+ */
+interface TnFormErrorsHarnessFilters extends BaseHarnessFilters {
+    /** Filters by the rendered message. Supports string or regex matching. */
+    textContains?: string | RegExp;
+}
+/**
+ * Harness for `tn-form-errors`.
+ *
+ * The host renders nothing while the control is valid, untouched, or has no
+ * message to show, so `hasMessage()` — not the presence of the harness — is
+ * what tells you whether an error is visible.
+ *
+ * @example
+ * ```typescript
+ * const errors = await loader.getHarness(TnFormErrorsHarness);
+ * expect(await errors.getMessage()).toBe('Select at least one day');
+ * ```
+ */
+declare class TnFormErrorsHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` for finding a `tn-form-errors` by its message.
+     *
+     * @param options Options for filtering which instances are considered a match.
+     */
+    static with(options?: TnFormErrorsHarnessFilters): HarnessPredicate<TnFormErrorsHarness>;
+    private message;
+    private dismissButton;
+    /** Whether a message is currently rendered. */
+    hasMessage(): Promise<boolean>;
+    /** The rendered message, or `''` when none is shown. */
+    getMessage(): Promise<string>;
+    /**
+     * Whether the shown message carries a dismiss button — true only when the
+     * active error key is one of the host's `dismissibleErrors`.
+     */
+    isDismissible(): Promise<boolean>;
+    /**
+     * Clicks the dismiss button, as a user clearing a server-side error would.
+     *
+     * The component clears the error itself — every key in its `dismissibleErrors`
+     * that the control carries — and then emits `dismiss` with the key that was on
+     * screen, so the message is gone by the time this resolves. The handler is for
+     * what the app does next, such as moving focus.
+     *
+     * @throws If the shown message is not dismissible.
+     */
+    dismiss(): Promise<void>;
+}
+
+/**
+ * What a `tn-form-list-item` needs to know about the list it was projected
+ * into. Published over DI rather than passed as an input, so that locking a
+ * list is one binding on the list and not one on every entry the consumer
+ * writes inside its `@for`.
+ *
+ * A projected entry's element injector chains through the `tn-form-list` it is
+ * declared inside, the same way a control projected into `tn-form-field` reaches
+ * {@link TN_FORM_FIELD_CONTEXT}. An entry used on its own injects nothing and
+ * falls back to its own defaults.
+ *
+ * Its own file, and not `form-list.component.ts`, because the list already
+ * imports the item to count its entries — a token declared beside either
+ * component would make that import cycle.
+ */
+interface TnFormListContext {
+    /** Whether the enclosing list is locked, so an entry can disable its remove button. */
+    disabled: Signal<boolean>;
+}
+/** DI token under which `tn-form-list` exposes its {@link TnFormListContext}. */
+declare const TN_FORM_LIST_CONTEXT: InjectionToken<TnFormListContext>;
+
+/**
+ * The editor for a repeating group of fields — a `FormArray` the user grows
+ * and shrinks, rendered as a labelled group of {@link TnFormListItemComponent}
+ * cards with an Add control in the header.
+ *
+ * Not to be confused with `tn-list`, which DISPLAYS a list of items. This one
+ * edits one, and owns none of the array: the consumer holds the `FormArray`,
+ * renders an item per element, and does the pushing and splicing in response
+ * to `(add)` and each item's `(delete)`. That keeps the item's shape — which
+ * only the consumer knows — out of the library.
+ *
+ * @example
+ * ```html
+ * <tn-form-list label="ACL entries" [control]="form.controls.entries" (add)="addEntry()">
+ *   @for (entry of form.controls.entries.controls; track entry; let i = $index) {
+ *     <tn-form-list-item label="ACL entry" (delete)="removeEntry(i)">
+ *       <!-- the entry's own fields -->
+ *     </tn-form-list-item>
+ *   }
+ * </tn-form-list>
+ * ```
+ */
+declare class TnFormListComponent implements TnFormListContext {
+    /**
+     * The `FormArray` being edited. Optional, and used only to render an error
+     * that belongs to the array as a whole — a minimum or maximum length. The
+     * component neither reads the elements nor writes to it.
+     */
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
+    /**
+     * What the list is called, in the plural ('ACL entries'). Names the group,
+     * so a screen reader announces which list a field is inside. Supports the
+     * same lightweight markup as `tn-form-field` labels.
+     */
+    label: _angular_core.InputSignal<string>;
+    /**
+     * Optional help tooltip, shown via an icon in the header — next to the label
+     * where there is one, and on its own where there is not.
+     */
+    tooltip: _angular_core.InputSignal<string>;
+    /** Placement of the tooltip relative to its help icon. */
+    tooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    /** Marks the list as required — at least one entry. Renders the asterisk. */
+    required: _angular_core.InputSignal<boolean>;
+    /** Whether the Add control renders. Turn it off at a maximum length. */
+    canAdd: _angular_core.InputSignal<boolean>;
+    /**
+     * Locks the list, for one the user may not edit yet: the group reports itself
+     * `aria-disabled`, the entries are dimmed and stop taking pointer events, and
+     * Add and every remove button are disabled.
+     *
+     * It does NOT disable the fields inside the entries — those are projected
+     * content the consumer owns, so locking them is `entries.disable()` on the
+     * `FormArray`, which is also what keeps their values out of `form.value`. This
+     * input deliberately does not reach them by going `inert` instead: the entries
+     * stay on screen, and `inert` would drop what a sighted user can still read out
+     * of the accessibility tree entirely.
+     */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Text of the Add control. English by default — pass a translated string. */
+    addLabel: _angular_core.InputSignal<string>;
+    /** Shown in place of the entries while there are none. */
+    emptyMessage: _angular_core.InputSignal<string>;
+    /**
+     * Overrides the derived empty state. Set it to `false` while the entries are
+     * still being fetched, so a list that is merely not loaded yet does not
+     * announce itself as empty and then fill in.
+     */
+    empty: _angular_core.InputSignal<boolean | undefined>;
+    /** Per-error overrides for the array-level message, as on `tn-form-field`. */
+    errorMessages: _angular_core.InputSignal<Partial<Record<string, _truenas_ui_components.TnFormFieldErrorMessage>>>;
+    /**
+     * Show the array-level message before the user has touched the array — for a
+     * list populated from an API, or one an error handler has just attached a
+     * server-side failure to. Passed straight to `tn-form-errors`.
+     */
+    showErrorWhenUntouched: _angular_core.InputSignal<boolean>;
+    /**
+     * Error keys whose array-level message renders with a close button, and which
+     * dismissing deletes. Unset takes the app-wide
+     * `TN_FORM_FIELD_DISMISSIBLE_ERRORS` default; `[]` opts this list out. Passed
+     * straight to `tn-form-errors`, which is where the reasoning lives.
+     */
+    dismissibleErrors: _angular_core.InputSignal<readonly string[] | undefined>;
+    /** Accessible name for that close button. Pass it already translated. */
+    dismissAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Hover hint for that close button. Defaults to `dismissAriaLabel`. */
+    dismissTooltip: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Test-id base for the group (`form-list-` prefixed). Also names the
+     * array-level message, which gets it `error-` prefixed.
+     */
+    testId: _angular_core.InputSignal<TnTestIdValue>;
+    /** Emitted when Add is pressed. Appending the element is the consumer's. */
+    add: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emitted with the error key when the user closes the array-level message,
+     * after it has been removed. `tn-form-errors` has no control to hand focus
+     * back to, so a consumer who cares where focus lands moves it here.
+     */
+    dismiss: _angular_core.OutputEmitterRef<string>;
+    /**
+     * The projected entries. Counted rather than derived from the `FormArray`,
+     * so the empty state follows what is actually on screen — a consumer may
+     * filter or page the elements it renders, and `control` is optional anyway.
+     */
+    private items;
+    protected isEmpty: _angular_core.Signal<boolean>;
+    /**
+     * The array-level message, queried rather than reached through a template
+     * reference: it renders inside an `@if`, and a reference declared in a block
+     * is scoped to that block.
+     */
+    private errors;
+    /**
+     * Points the group at its own message. `role="alert"` covers the moment the
+     * error appears; it says nothing to a screen reader that tabs into the list
+     * afterwards, which would otherwise hear the label and never learn the array
+     * is in error. Null while there is no message, so this never names an element
+     * that is not on screen.
+     */
+    protected describedBy: _angular_core.Signal<string | null>;
+    /**
+     * Accessible name for the Add control, which reads as a bare 'Add' beside
+     * every other list on a long form. Names the list it adds to.
+     */
+    protected addAriaLabel: _angular_core.Signal<string>;
+    protected tooltipAriaLabel: _angular_core.Signal<string>;
+    /**
+     * Stable id naming the group from the label text alone. Without it the
+     * group's accessible name would also absorb the tooltip button and the Add
+     * control, announcing both on every field inside the list.
+     */
+    protected readonly labelId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnFormListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormListComponent, "tn-form-list", never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "canAdd": { "alias": "canAdd"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "addLabel": { "alias": "addLabel"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "showErrorWhenUntouched": { "alias": "showErrorWhenUntouched"; "required": false; "isSignal": true; }; "dismissibleErrors": { "alias": "dismissibleErrors"; "required": false; "isSignal": true; }; "dismissAriaLabel": { "alias": "dismissAriaLabel"; "required": false; "isSignal": true; }; "dismissTooltip": { "alias": "dismissTooltip"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "add": "add"; "dismiss": "dismiss"; }, ["items"], ["*"], true, never>;
+}
+
+/**
+ * One entry of a {@link TnFormListComponent} — a bordered card holding the
+ * controls for a single element of the form array, with the control that
+ * removes it.
+ *
+ * The item owns only the frame and the remove button; the controls inside are
+ * the consumer's, bound to that element's `FormGroup`.
+ */
+declare class TnFormListItemComponent {
+    /**
+     * Whether this entry can be removed. Turn it off for an entry the form
+     * requires — the button disappears rather than being disabled, since a
+     * permanently disabled control tells the user nothing about why.
+     */
+    canDelete: _angular_core.InputSignal<boolean>;
+    /**
+     * What one entry is called, in the singular ('ACL entry', 'Portal'). Used to
+     * name the remove button, which is icon-only and has nothing else to be
+     * named by. Pass it already translated.
+     */
+    label: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the remove button. Defaults to `Remove <label>`, or
+     * plain `Remove` when there is no label. Set it to translate the wording —
+     * the library ships English only.
+     */
+    removeAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Disables the remove button — the entry stays readable, the control just
+     * stops working, the way a native disabled control does.
+     *
+     * Left unset it follows the enclosing `tn-form-list`'s own `disabled`, so
+     * locking a list is one binding on the list rather than one per entry. Set it
+     * explicitly to lock a single entry inside an otherwise editable list.
+     */
+    disabled: _angular_core.InputSignal<boolean | undefined>;
+    /** Test-id base for the remove button (`icon-button-` prefixed). */
+    testId: _angular_core.InputSignal<TnTestIdValue>;
+    /** Emitted when the remove button is pressed. Removing is the consumer's. */
+    delete: _angular_core.OutputEmitterRef<void>;
+    /** Absent when the entry is used outside a `tn-form-list`. */
+    private list;
+    protected resolvedDisabled: _angular_core.Signal<boolean>;
+    protected resolvedRemoveAriaLabel: _angular_core.Signal<string>;
+    protected resolvedTestId: _angular_core.Signal<string | number | (string | number | null | undefined)[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnFormListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormListItemComponent, "tn-form-list-item", never, { "canDelete": { "alias": "canDelete"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "removeAriaLabel": { "alias": "removeAriaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, { "delete": "delete"; }, never, ["*"], true, never>;
+}
+
+/** Criteria for filtering `TnFormListHarness` instances. */
+interface TnFormListHarnessFilters extends BaseHarnessFilters {
+    /** Filters by the list's label. Supports string or regex matching. */
+    label?: string | RegExp;
+}
+/** Criteria for filtering `TnFormListItemHarness` instances. */
+type TnFormListItemHarnessFilters = BaseHarnessFilters;
+/**
+ * Harness for one entry of a `tn-form-list`.
+ *
+ * @example
+ * ```typescript
+ * const [first] = await list.getItems();
+ * await first.remove();
+ * ```
+ */
+declare class TnFormListItemHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: TnFormListItemHarnessFilters): HarnessPredicate<TnFormListItemHarness>;
+    private removeButton;
+    /** Whether this entry offers a remove control. */
+    canRemove(): Promise<boolean>;
+    /**
+     * Whether the remove control is disabled — true for an entry inside a
+     * `disabled` list, or one given its own `disabled`. `false` when the entry
+     * offers no remove control at all; ask `canRemove()` to tell the two apart.
+     */
+    isRemoveDisabled(): Promise<boolean>;
+    /** Presses the remove control. Throws when the entry has none. */
+    remove(): Promise<void>;
+}
+/**
+ * Harness for `tn-form-list`, the editor for a repeating group of fields.
+ *
+ * @example
+ * ```typescript
+ * const list = await loader.getHarness(TnFormListHarness.with({ label: 'ACL entries' }));
+ * expect(await list.getItemCount()).toBe(0);
+ * expect(await list.isEmpty()).toBe(true);
+ *
+ * await list.add();
+ * expect(await list.getItemCount()).toBe(1);
+ * ```
+ */
+declare class TnFormListHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: TnFormListHarnessFilters): HarnessPredicate<TnFormListHarness>;
+    private labelEl;
+    private addButton;
+    private emptyEl;
+    /** The list's label, or `''` when it has none. */
+    getLabel(): Promise<string>;
+    /** Whether the Add control renders. */
+    canAdd(): Promise<boolean>;
+    /** Whether the Add control is disabled. */
+    isAddDisabled(): Promise<boolean>;
+    /** Presses Add. Throws when the list offers no Add control. */
+    add(): Promise<void>;
+    /** The entries currently rendered. */
+    getItems(): Promise<TnFormListItemHarness[]>;
+    /** How many entries are rendered. */
+    getItemCount(): Promise<number>;
+    /** Whether the empty message is showing. */
+    isEmpty(): Promise<boolean>;
+    /** The empty message, or `''` when the list has entries. */
+    getEmptyMessage(): Promise<string>;
+}
+
 /**
  * Semantic grouping for a related set of form fields. Renders a native
  * `<fieldset>` with an optional `<legend>` heading and help tooltip, and
@@ -5488,6 +7185,21 @@ declare class TnFormSectionComponent {
     tooltip: _angular_core.InputSignal<string>;
     /** Placement of the tooltip relative to its help icon. */
     tooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    /**
+     * Whether a tooltip message holding a link may be pinned open by clicking the help button (see
+     * `tnTooltipSticky`). On by default, like the directive.
+     *
+     * It does not make plain tooltips pinnable — section help is nearly always plain text, and that
+     * keeps hovering. Set it to false only to force a message that does hold a link back to hover
+     * behaviour, accepting that the link is then unreachable.
+     */
+    tooltipSticky: _angular_core.InputSignal<boolean>;
+    /**
+     * Accessible name for the help button, which is icon-only and so has nothing else to be named
+     * by. The message is what the button is for, but it may hold markup — a link is the whole point
+     * of `tooltipSticky` — and `aria-label` takes plain text, so the tags come off first.
+     */
+    protected readonly tooltipAriaLabel: _angular_core.Signal<string>;
     /** Test id applied to the host for harness/e2e selection. */
     testId: _angular_core.InputSignal<TnTestIdValue>;
     /**
@@ -5498,7 +7210,7 @@ declare class TnFormSectionComponent {
      */
     protected readonly headingId: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnFormSectionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormSectionComponent, "tn-form-section", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnFormSectionComponent, "tn-form-section", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipSticky": { "alias": "tooltipSticky"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -6233,8 +7945,78 @@ declare class TnListItemComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnListItemComponent, "tn-list-item", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, ["leadingIcons", "leadingAvatars", "secondaryLines", "secondaryTexts", "trailing"], ["[tnListIcon], [tnListAvatar]", "[tnListItemTitle], [tnListItemPrimary]", "*", "[tnListItemLine], [tnListItemSecondary]", "[tnListItemTrailing]"], true, never>;
 }
 
-declare class TnListSubheaderComponent {
+/**
+ * A section heading inside a list.
+ *
+ * A container role can forbid its children's roles, so a heading between two
+ * rows invalidates the container — axe's `aria-required-children`, and the
+ * defect fixed in #237 and #259. The heading is not dropped for that; it is
+ * moved, and where the HOST goes depends on what owns it. See `ariaOwnerRole`
+ * for what "owns" means here.
+ *
+ * | Owner | Host | The element around the text |
+ * |---|---|---|
+ * | `role="list"` | `listitem` | `heading`, level 3 |
+ * | `role="listbox"` | `group`, named by the text below | an ordinary span |
+ * | anything else | `heading`, level 3 | an ordinary span |
+ *
+ * Inside a LIST the host becomes the `listitem` the list requires and the
+ * heading goes one level in — `<li><h3>Pools</h3></li>` in plain HTML, which
+ * keeps the section heading in the accessibility tree at the level it always
+ * had. The cost is that the list counts one more item per section, which is the
+ * same count a browser reports for that HTML.
+ *
+ * Inside a LISTBOX neither of those is available. `listitem` is not an allowed
+ * child of a listbox either, so it trades one `aria-required-children` violation
+ * for another; and the heading cannot move one level in the way it does for a
+ * list, because axe reads THROUGH a `group` when it collects what a listbox
+ * owns — measured, a `group` wrapping a `role="heading"` reports the same
+ * violation, now naming the heading. So the section survives as a `group` with
+ * the subheader's own text as its accessible name, via `aria-labelledby` to the
+ * unmarked span: the text is still in the accessibility tree and still
+ * announced, as a named section rather than as a heading.
+ *
+ * That group holds the text and NOT the rows that follow it: a subheader is
+ * projected content and is a sibling of the rows it introduces, so it can name
+ * a section without enclosing one. Genuinely nesting the options is markup for
+ * the consumer to write.
+ *
+ * Outside either — or nested inside a row of one, where a heading is already
+ * legal — the host carries the heading itself and the inner element is an
+ * ordinary span.
+ */
+declare class TnListSubheaderComponent implements DoCheck {
     inset: _angular_core.InputSignal<boolean>;
+    private readonly owner;
+    /**
+     * Id of the inner span, so that the `group` form can be named by the text.
+     *
+     * Allocated per instance rather than per render, and emitted only when the
+     * group needs it — see the template.
+     */
+    protected readonly textId: string;
+    /**
+     * Which of the three containers in the class docblock this is sitting in.
+     *
+     * Only the two that prescribe their children are named; every other owner,
+     * `null` included, leaves the heading on the host where it has always been.
+     */
+    private readonly ownerKind;
+    /** The role the host carries. See the table in the class docblock. */
+    protected readonly hostRole: _angular_core.Signal<"heading" | "listitem" | "group">;
+    /** Whether the heading is on the HOST, which is where `aria-level` follows it. */
+    protected readonly headingOnHost: _angular_core.Signal<boolean>;
+    /**
+     * Whether the heading has moved one level in, onto the span.
+     *
+     * `list` alone, and never both this and {@link headingOnHost}: one section is
+     * one heading, and a host that is both a `listitem` and a heading is what
+     * #237 removed.
+     */
+    protected readonly headingInside: _angular_core.Signal<boolean>;
+    /** Whether the host is a `group` that the span below has to name. */
+    protected readonly namesGroup: _angular_core.Signal<boolean>;
+    ngDoCheck(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnListSubheaderComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnListSubheaderComponent, "tn-list-subheader", never, { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -6303,14 +8085,53 @@ declare class TnListItemTrailingDirective {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnListItemTrailingDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnListItemTrailingDirective, "[tnListItemTrailing]", never, {}, {}, never, never, true, never>;
 }
-declare class TnDividerDirective {
+/**
+ * Makes an element that is already something else read as a divider.
+ *
+ * Same ARIA as `TnDividerComponent` and for the same reason (#237):
+ * `role="separator"`, unless a `role="list"` is what owns it, where a separator
+ * is not an allowed child and invalidates the list.
+ *
+ * **It no longer matches `tn-divider` as well, which is a breaking change**:
+ * code that writes `<tn-divider>` while importing only this directive now has
+ * no match for that element and stops compiling. Import `TnDividerComponent`
+ * for the element form — it is what declares the element, and what every use of
+ * `<tn-divider>` in this repository already imports.
+ *
+ * On `tn-divider` this only ever restated what the component declares, and once
+ * the role varies by context, a second source for it is a second answer waiting
+ * to disagree — two instances of the tracking that decides it, on one element,
+ * writing one attribute.
+ */
+declare class TnDividerDirective implements DoCheck {
+    private readonly owner;
+    protected readonly role: _angular_core.Signal<"presentation" | "separator">;
+    ngDoCheck(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnDividerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnDividerDirective, "tn-divider, [tnDivider]", never, {}, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnDividerDirective, "[tnDivider]", never, {}, {}, never, never, true, never>;
 }
 
-declare class TnDividerComponent {
+/**
+ * A rule between things.
+ *
+ * `role="separator"`, except where the element that owns it is a container
+ * whose children are prescribed — a `role="list"` owns only `listitem`, so a
+ * separator between two rows invalidates the list it sits in (#237). Owned by a
+ * ROW of that list — a divider inside a `tn-list-item` — it is a separator like
+ * anywhere else. See `ariaOwnerRole` for what "owns" means and why the DOM
+ * decides it rather than DI.
+ */
+declare class TnDividerComponent implements DoCheck {
     vertical: _angular_core.InputSignal<boolean>;
     inset: _angular_core.InputSignal<boolean>;
+    private readonly owner;
+    /**
+     * `presentation` rather than no role at all: both are invisible to assistive
+     * technology and satisfy the container, and this one says in the DOM that the
+     * rule is decoration on purpose.
+     */
+    protected readonly role: _angular_core.Signal<"presentation" | "separator">;
+    ngDoCheck(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnDividerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDividerComponent, "tn-divider", never, { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -6330,14 +8151,95 @@ declare class TnListOptionComponent implements AfterContentInit {
     internalDisabled: _angular_core.WritableSignal<boolean | null>;
     internalColor: _angular_core.WritableSignal<"primary" | "warn" | "accent" | null>;
     effectiveSelected: _angular_core.Signal<boolean>;
+    /**
+     * Whether the parent `tn-selection-list` is disabled as a whole, pushed down
+     * by the listbox (#221). `false` when there is no parent.
+     *
+     * Kept apart from `internalDisabled` rather than written into it, because the
+     * two answer different questions and a single slot cannot hold both. The list
+     * disabling itself must not erase an option the consumer disabled on its own,
+     * and re-enabling the list is exactly where a shared slot loses that: the
+     * parent has no record of what the option's own state was before it wrote
+     * over it, so `[disabled]="true"` on the option never comes back. That is not
+     * hypothetical — it is what `setDisabledState()` did to a per-option
+     * `[disabled]` on every `control.enable()` before this signal existed.
+     *
+     * A plain boolean rather than the nullable this sits beside: absent and
+     * not-disabled are the same thing for a parent's opinion, whereas
+     * `internalDisabled` needs `null` to mean "the input still speaks".
+     */
+    listDisabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * Disabled if EITHER source says so — the list as a whole, or this option.
+     *
+     * Not a precedence: a disabled list cannot be overridden by an enabled
+     * option, and a list that is enabled has nothing to say about an option that
+     * disabled itself. Only the second half is a fallback chain, and it is the
+     * one that already existed: `internalDisabled` outranks the input when it has
+     * been written. Nothing in the library writes it any more — `setDisabledState()`
+     * was its only writer and now stops at `listDisabled` — so it is kept for the
+     * public surface it has always been part of, alongside `internalSelected` and
+     * `internalColor`, rather than because a path in here still uses it.
+     */
     effectiveDisabled: _angular_core.Signal<boolean>;
     effectiveColor: _angular_core.Signal<"primary" | "warn" | "accent">;
+    /**
+     * The tabindex a parent `tn-selection-list` has assigned, or `null` when this
+     * option is standalone.
+     *
+     * Set by the listbox's roving tabindex (#216): 0 on the one option that is
+     * the list's single tab stop, -1 on the rest. `null` is not "no tab stop" but
+     * "no parent" — it is what keeps a `tn-list-option` used on its own behaving
+     * as #213 left it, and it is why this is a nullable number rather than a
+     * number defaulting to -1.
+     */
+    rovingTabindex: _angular_core.WritableSignal<number | null>;
+    /**
+     * -1 rather than a removed attribute for a disabled option under a roving
+     * tabindex, which is the one place these two paths disagree. An element with
+     * no `tabindex` cannot be focused programmatically either, so dropping the
+     * attribute would leave the listbox's arrow keys with nothing to move focus
+     * to — and the listbox deliberately visits disabled options, so that they can
+     * be perceived rather than silently skipped. Standalone, where every stop
+     * costs a Tab press, the disabled option is still left out entirely.
+     */
+    effectiveTabindex: _angular_core.Signal<number | null>;
     protected hasLeadingContent: _angular_core.WritableSignal<boolean>;
     protected hasSecondaryTextContent: _angular_core.WritableSignal<boolean>;
     protected hasPrimaryTextDirective: _angular_core.WritableSignal<boolean>;
     ngAfterContentInit(): void;
     private checkContentProjection;
+    /**
+     * Move real DOM focus to this option.
+     *
+     * Called by the parent listbox as the arrow keys move (#216). Focus lands on
+     * the host, which is both the element carrying the roving tabindex and the
+     * element `:host(:focus-visible)` draws the #215 focus ring on — the two
+     * reasons the listbox moves focus rather than pointing at the option with
+     * `aria-activedescendant`.
+     */
+    focus(): void;
     onClick(_event: Event): void;
+    /**
+     * The key is swallowed BEFORE the disabled guard, not after it.
+     *
+     * Declining to toggle is not the same as declining the key. Space scrolls the
+     * page on any element that is neither a form control nor a scroller, and the
+     * option host is neither — so bailing out first hands the browser a Space
+     * with its default action intact, on an element the user deliberately focused
+     * and got nothing from. Nothing upstream saves it either: the listbox's own
+     * handler falls through for Space on purpose, so that the key reaches here.
+     *
+     * Only reachable under a parent `tn-selection-list` (#216), whose roving
+     * tabindex is what makes a disabled option focusable — standalone it carries
+     * no `tabindex`, so it cannot hold focus and this never fires on it.
+     *
+     * Which is safe only because the key has to have been pressed on the host
+     * itself. A host listener hears whatever bubbles out of projected content, so
+     * a consumer's `<input>` inside an option would otherwise have its Space
+     * swallowed by the `preventDefault()` above — and, on an enabled option,
+     * toggle the option as well as typing.
+     */
     onKeydown(event: Event): void;
     toggle(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnListOptionComponent, never>;
@@ -6353,21 +8255,238 @@ declare class TnSelectionListComponent implements ControlValueAccessor {
     disabled: _angular_core.InputSignal<boolean>;
     multiple: _angular_core.InputSignal<boolean>;
     color: _angular_core.InputSignal<"primary" | "warn" | "accent">;
+    /**
+     * Explicit accessible name for the listbox. Inside a `tn-form-field` with a
+     * label this is unnecessary — the field names the list automatically — but a
+     * list with neither is announced as an unlabelled listbox.
+     *
+     * ALIASED to the attribute name, unlike the plain `ariaLabel` most controls in
+     * this library take, and the divergence is forced rather than chosen: this
+     * component's `role="listbox"` is on the HOST, so `<tn-selection-list
+     * aria-label="Mailboxes">` is valid markup that named the list before this
+     * input existed. The host binding below rewrites that attribute on every
+     * change-detection pass, so an unaliased input would silently STRIP a name
+     * that used to work. The alias makes the same markup set the input instead,
+     * and the binding writes it straight back.
+     */
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Id of visible text naming the listbox. Wins over `ariaLabel` where it resolves. */
+    ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    /**
+     * ARIA wiring from an enclosing `tn-form-field`, read for `labelledby` alone:
+     * #235 is about the listbox having no accessible name, and the field's
+     * `describedby`/`invalid`/`required` are a separate question this list has
+     * never answered either way.
+     *
+     * Called with NO argument, so it reports the field's label id unconditioned.
+     * Handing it the `ariaLabel` input would have it suppress the field itself —
+     * on truthiness, so a whitespace-only label would cancel the field while being
+     * dropped as no name, leaving nothing — and it would only do so while this
+     * field is initialised after the one it reads, since a signal captured before
+     * its own initialiser runs arrives as `undefined` and is swallowed by an
+     * optional call. The suppression is applied below instead, where the rest of
+     * the precedence is.
+     */
+    private readonly fieldAria;
+    /**
+     * The `aria-label` this component supplies, or `null` when it supplies none.
+     *
+     * Blank is not a name: `aria-label=""` names the listbox as emptily as no
+     * attribute at all, while satisfying axe's `aria-input-field-name` rule — a
+     * green check on a control a screen reader announces as "listbox".
+     */
+    private readonly resolvedAriaLabel;
+    /**
+     * The explicit `ariaLabelledby` input, blank normalised away, or `null`.
+     *
+     * Kept apart from the field's label because the two rank differently against
+     * a name the consumer wrote on the host — see {@link hostAriaLabelledby}.
+     */
+    private readonly explicitAriaLabelledby;
+    private readonly hostElement;
+    /**
+     * The value this component last wrote for each naming attribute, so that it
+     * can tell its own from the consumer's. See {@link claim}.
+     */
+    private readonly written;
     selectionChange: _angular_core.OutputEmitterRef<TnSelectionChange>;
     options: _angular_core.Signal<readonly TnListOptionComponent[]>;
     private formDisabled;
     isDisabled: _angular_core.Signal<boolean>;
+    /**
+     * The option the user has moved to, and the slot it occupied at the time —
+     * or `null` while they have not moved yet.
+     *
+     * Kept separate from `activeIndex` rather than seeded with a starting value,
+     * because "where the user last was" and "where a user who has not arrived yet
+     * would land" are different questions and only the second one should follow
+     * the selection around. See `activeIndex`.
+     *
+     * The OPTION and not merely its index, because the options are content
+     * children and the caller can add or remove them ABOVE the one the user is
+     * standing on. An index survives that edit while quietly changing meaning —
+     * it names whichever option shifted into the slot — so the tab stop and the
+     * arrow keys' starting point both come away from the option holding focus,
+     * and one ArrowDown lands two options from where the user is. A reference
+     * cannot drift that way. The index rides along only as the fallback for the
+     * one case a reference cannot answer: the option itself being removed.
+     */
+    private visited;
+    /**
+     * Which option carries the listbox's single tab stop.
+     *
+     * Before the user has touched the list this tracks the first selected option,
+     * which is what APG asks for — tabbing into a list that already has a
+     * selection should land where the user left off rather than at the top. Once
+     * they have moved, `visited` pins it and the selection no longer drags the
+     * tab stop around underneath them.
+     *
+     * Resolved against the current options on every read rather than stored, so
+     * that a list edited underneath the user still points at the option they were
+     * on. Only once that option has left the list is there nothing to resolve,
+     * and the remembered slot is the best answer left — clamped, because an index
+     * held across a removal otherwise reads past the end of the array.
+     */
+    private activeIndex;
+    /**
+     * The option host that currently holds DOM focus, or `null`.
+     *
+     * Held as an element rather than an index, because the whole point of it is
+     * to outlive the option: an index still resolves after a removal, to whatever
+     * option moved into that slot.
+     */
+    private focusedOptionElement;
     private onChange;
     private onTouched;
     constructor();
+    /**
+     * ArrowUp / ArrowDown / Home / End — unmodified, and pressed on an option
+     * host — and deliberately nothing else.
+     *
+     * Space and Enter are absent because `tn-list-option` has handled them since
+     * before this component had any keyboard handling at all, and its keydown
+     * bubbles up to here. Toggling from both places would toggle twice — select
+     * then immediately deselect — which reads as the key doing nothing rather
+     * than as a bug, so it is worth stating why it is missing rather than leaving
+     * a later reader to add it.
+     *
+     * Every other key is left alone, Tab included: `preventDefault()` on an
+     * unrecognised key is how a widget traps a keyboard user inside it.
+     *
+     * Navigation is not gated on `isDisabled()`, because moving focus selects
+     * nothing: a disabled list a user can still read through is the same
+     * reasoning that has the arrow keys visit disabled options at all.
+     *
+     * That is a statement about NAVIGATION only, and deliberately not the wider
+     * claim that a disabled list can be toggled. It cannot: `isDisabled()` is
+     * pushed onto every option's `listDisabled` by the effect in the constructor
+     * (#221), so the option's own guard refuses the toggle whichever route asked
+     * for it — mouse, Space, Enter or a reactive form. What a disabled list still
+     * allows is moving through it, which selects nothing.
+     *
+     * Only keys pressed ON an option host are the listbox's. The handler is on
+     * the host and hears everything that bubbles through it, so without that test
+     * a consumer who projects a focusable control into an option — a text input,
+     * a slider — would have Home and End taken off its caret and the arrows taken
+     * off its value, and get a `preventDefault()` for it. Nothing in this library
+     * projects such a control today, which is why this is a target check rather
+     * than a redesign.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * Keep the tab stop under whichever option actually holds focus.
+     *
+     * Covers the routes into the list that are not the arrow keys — a click, and
+     * a Tab that lands here — so that leaving the list and coming back returns to
+     * the option the user was last on, rather than to the one the arrow keys
+     * happened to leave the index at.
+     *
+     * `contains` rather than an identity check on the target, because focus can
+     * land on something projected into the option rather than on the option host.
+     */
+    onFocusIn(event: FocusEvent): void;
+    /**
+     * Forget the focused option once focus leaves it under its own steam.
+     *
+     * Guarded on the option still being in the document, because a `focusout`
+     * fired BY a removal — Firefox fires one, Chrome does not — is exactly the
+     * case the restore in the constructor exists for, and clearing on it would
+     * defeat that restore in one browser and not the other.
+     */
+    onFocusOut(event: FocusEvent): void;
+    /**
+     * The `aria-label` the host should carry.
+     *
+     * A METHOD rather than a signal, and that is the load-bearing part of this
+     * whole arrangement: a host binding re-evaluates on every change-detection
+     * pass, while a `computed` re-runs only when a signal it read has changed.
+     * These two answers depend on the host's CURRENT attributes, which are not
+     * signals — a consumer's `[attr.aria-label]` bound in the parent template
+     * never reaches an input and never notifies anything. Asked once per pass,
+     * the answer stays true; asked from a `computed`, it goes stale the moment
+     * the consumer's binding changes, and the list is left announcing the wrong
+     * name or no name at all.
+     */
+    protected hostAriaLabel(): string | null;
+    /**
+     * The `aria-labelledby` the host should carry — and the one place the naming
+     * precedence is decided.
+     *
+     * Most specific first: the `ariaLabelledby` input, then any name the consumer
+     * put on the host by another route, then the enclosing `tn-form-field`'s
+     * label. The field comes last because it is chrome the consumer did not write
+     * on this element, and it is WITHHELD rather than rendered alongside: ARIA
+     * prefers `aria-labelledby` wherever it resolves, so a field reference emitted
+     * beside a consumer's `aria-label` does not merely coexist with it — it
+     * outranks it, and the list announces the field's label instead.
+     *
+     * With none of the three, a list stays unnamed — deliberately: a generic
+     * fallback ("List") would satisfy axe while announcing nothing the user can
+     * act on, and only the consumer knows what this list holds.
+     */
+    protected hostAriaLabelledby(): string | null;
+    /** Whether the host already carries a non-blank name this component did not write. */
+    private namedByConsumer;
+    /**
+     * What to bind `attribute` to: this component's own `value` where it has one,
+     * and otherwise whatever is already on the host — so that a name the consumer
+     * set is preserved rather than overwritten by the `null` that means "nothing
+     * to say".
+     *
+     * That distinction is the reason this exists. `[attr.x]="null"` REMOVES the
+     * attribute, and the role is on the HOST here, so `<tn-selection-list
+     * aria-label="…">` and `[attr.aria-labelledby]="…"` are valid markup that
+     * named this list before it had any naming input at all. Measured on Angular
+     * 21, a plain host binding of these attributes ran after the parent's and left
+     * the element with NEITHER — named to unnamed, silently, with the parent's
+     * value reappearing only on a later pass and only for the one whose bound
+     * value had changed.
+     *
+     * Ownership is tracked by value rather than by a flag, so it also lapses
+     * correctly: an attribute this component wrote and something else has since
+     * changed is no longer this component's to rewrite or take away.
+     */
+    private claim;
     writeValue(value: unknown[]): void;
     registerOnChange(fn: (value: unknown[]) => void): void;
     registerOnTouched(fn: () => void): void;
+    /**
+     * Records the form's state and stops there — the effect in the constructor is
+     * what reaches the options, via `isDisabled()`.
+     *
+     * It used to also write each `option.internalDisabled` directly, which is the
+     * only reason this route enforced anything while `[disabled]` enforced
+     * nothing. Two problems, both fixed by routing it through the same signal the
+     * input uses: the two paths could disagree, and `internalDisabled` is the
+     * slot an option's own `[disabled]` input falls back to — so `control.enable()`
+     * wrote `false` over an option the consumer had disabled independently, and
+     * never gave it back.
+     */
     setDisabledState(isDisabled: boolean): void;
     onOptionSelectionChange(): void;
     get selectedOptions(): TnListOptionComponent[];
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnSelectionListComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnSelectionListComponent, "tn-selection-list", never, { "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, ["options"], ["*"], true, [{ directive: typeof TnTestIdDirective; inputs: { "tnTestId": "testId"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnSelectionListComponent, "tn-selection-list", never, { "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, ["options"], ["*"], true, [{ directive: typeof TnTestIdDirective; inputs: { "tnTestId": "testId"; }; outputs: {}; }]>;
 }
 
 declare class TnHeaderCellDefDirective {
@@ -6392,6 +8511,26 @@ declare class TnTableColumnDirective {
      * overrides the card field label. Falls back to the column `name` when unset.
      */
     label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Renders the header label for screen readers only, leaving the header cell
+     * visually blank. For a column whose purpose is obvious from its contents and
+     * whose heading would only add noise — a row-actions or icon column.
+     *
+     * A blank header is not the same thing as an unlabelled one: `<th>` with no
+     * text at all fails axe's `empty-table-header`, and a screen-reader user
+     * moving across the header row hears nothing where a column exists (#246). So
+     * the label is still rendered, inside the table's own `.cdk-visually-hidden`
+     * — the same treatment the built-in `__expand` and row-actions headers get.
+     *
+     * The text is `label`, falling back to the column `name`. A `tnHeaderCellDef`
+     * template is NOT rendered when this is set: the point is that nothing shows,
+     * and the class that hides it is scoped to the table's own view, so a
+     * consumer's projected markup could not use it anyway.
+     *
+     * Header-only. Card mode has no header row; use `cardHidden` to keep a column
+     * off the card.
+     */
+    hideLabel: _angular_core.InputSignal<boolean>;
     /**
      * Relative importance of this column in card mode (see `mobileLayout` on
      * `tn-table`). Higher numbers render first; fields ranked beyond
@@ -6428,7 +8567,7 @@ declare class TnTableColumnDirective {
     headerTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
     cellTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTableColumnDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnTableColumnDirective, "[tnColumnDef]", ["tnColumnDef"], { "name": { "alias": "tnColumnDef"; "required": true; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "cardPriority": { "alias": "cardPriority"; "required": false; "isSignal": true; }; "cardTitle": { "alias": "cardTitle"; "required": false; "isSignal": true; }; "cardHidden": { "alias": "cardHidden"; "required": false; "isSignal": true; }; "cardLabel": { "alias": "cardLabel"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate", "cellTemplate"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnTableColumnDirective, "[tnColumnDef]", ["tnColumnDef"], { "name": { "alias": "tnColumnDef"; "required": true; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "cardPriority": { "alias": "cardPriority"; "required": false; "isSignal": true; }; "cardTitle": { "alias": "cardTitle"; "required": false; "isSignal": true; }; "cardHidden": { "alias": "cardHidden"; "required": false; "isSignal": true; }; "cardLabel": { "alias": "cardLabel"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate", "cellTemplate"], never, true, never>;
 }
 /**
  * Directive to define the expandable detail row template.
@@ -6475,6 +8614,25 @@ declare class TnRowActionsDefDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnRowActionsDefDirective, "[tnRowActionsDef]", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * The name the table's scroll region falls back to when the consumer has not
+ * said what the table holds (#270).
+ *
+ * A focusable element with no accessible name is announced as a bare "group",
+ * which tells a listener that something has been reached and nothing about what
+ * it is. "Table" is a poor name and is deliberately the fallback rather than
+ * the expectation — `scrollRegionAriaLabel` is how a consumer says something
+ * useful, and it is the one input on this component whose default is worth
+ * overriding on sight.
+ *
+ * No dev-mode warning goes with it, unlike `tnAccessibleName`'s fallbacks: this
+ * name is rendered only on a table that is WIDER THAN ITS CONTAINER, which
+ * depends on the consumer's layout rather than on their markup, so the warning
+ * would fire on a viewport rather than on a mistake.
+ *
+ * Exported so specs assert against it by name rather than by a copied literal.
+ */
+declare const TN_TABLE_SCROLL_REGION_LABEL = "Table";
 interface TnTableDataSource<T = unknown> {
     data?: T[];
     connect?(): T[];
@@ -6511,7 +8669,46 @@ interface TnSortEvent {
  * Above the breakpoint both modes render the regular table.
  */
 type TnTableMobileLayout = 'cards' | 'scroll';
+/**
+ * Chrome copy `tn-table` renders itself. These were baked into the template as English literals,
+ * which a consumer could not translate at all — there was no input to bind. Provide
+ * {@link TN_TABLE_LABELS} at the app root to wire them to an i18n service.
+ */
+interface TnTableLabels {
+    /** Accessible name for the card-mode sort control. */
+    sortBy: string;
+    /** Card-mode sort option that clears the sort. */
+    unsorted: string;
+    /** Toggle that reveals the columns card mode collapsed. */
+    moreFields: string;
+    /** Card-mode button that opens a row's detail panel. */
+    details: string;
+    /**
+     * Card-mode direction toggle while unsorted or sorted descending — the label names the
+     * ACTION, and `toggleSortDirection()` starts at ascending from both of those states.
+     */
+    sortAscending: string;
+    /** Card-mode direction toggle while sorted ascending. */
+    sortDescending: string;
+    /** Visually-hidden name for the row-expand COLUMN's header cell, not the per-row control. */
+    expand: string;
+    /** Per-row expand control while its detail row is collapsed. */
+    expandRow: string;
+    /** Per-row expand control while its detail row is open. */
+    collapseRow: string;
+    /** Visually-hidden name for the row actions column. */
+    actions: string;
+}
+/** English defaults used when no `TN_TABLE_LABELS` provider is registered. */
+declare const TN_TABLE_DEFAULT_LABELS: TnTableLabels;
+/**
+ * DI token for app-wide table chrome labels. Provide either a static object or a
+ * `Signal<TnTableLabels>` — the latter lets every table react to language changes when the
+ * consumer wires it up to an i18n service.
+ */
+declare const TN_TABLE_LABELS: InjectionToken<TnTableLabels | Signal<TnTableLabels>>;
 declare class TnTableComponent<T = unknown> implements OnInit {
+    protected readonly labels: Signal<TnTableLabels>;
     private destroyRef;
     private elementRef;
     private injector;
@@ -6523,6 +8720,39 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * loads — was dropped to `<body>` and had to tab back from the top of the document.
      */
     private focusBeforeLoading;
+    /**
+     * Whether the host carries a tab stop, `role="group"` and a name because it
+     * is currently scrolling (#270).
+     *
+     * `:host` is `overflow-x: auto` — the stylesheet says why the scrollport is
+     * the host and not `.tn-table__table` — so a table wider than its container
+     * scrolls HERE, and axe's `scrollable-region-focusable` reports a scroll
+     * container that is neither in the tab order nor holds anything that is.
+     *
+     * Which this table is depends entirely on how it was configured: sortable
+     * headers and clickable rows are `tabindex="0"`, so a table with either
+     * satisfies the rule through its content, and a plain read-only one — the
+     * default of every input on this component — satisfies nothing and leaves its
+     * trailing columns unreachable from a keyboard.
+     *
+     * Gated on the measurement rather than on `isScrollMode()`: that class says
+     * which LAYOUT the container's width selected, and this asks whether the
+     * content actually exceeds the box, which is a different question and the one
+     * axe asks. The measurement, the observers behind it and the rule that holds
+     * the answer true while the host has focus are `tnScrollableRegion`'s.
+     *
+     * A field initializer rather than the constructor, because it registers an
+     * `effect` and so needs an injection context.
+     */
+    protected scrollKeyboardReachable: Signal<boolean>;
+    /**
+     * The scroll region's name, falling back when a consumer passes whitespace.
+     *
+     * Blank is not a name: an `aria-label=" "` names the group as emptily as no
+     * label at all, and axe agrees — the same rule `tnAccessibleName` applies to
+     * every other name in this library.
+     */
+    protected resolvedScrollRegionLabel: Signal<string>;
     dataSource: _angular_core.InputSignal<TnTableDataSource<T> | T[]>;
     displayedColumns: _angular_core.InputSignal<string[]>;
     trackBy: _angular_core.InputSignal<((index: number, item: T) => unknown) | undefined>;
@@ -6534,6 +8764,17 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      */
     emptyDescription: _angular_core.InputSignal<string>;
     emptyIcon: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the table's own scroll region, used only while the host
+     * actually scrolls — see `scrollKeyboardReachable` and
+     * `TN_TABLE_SCROLL_REGION_LABEL`.
+     *
+     * Set it to say what the table holds ("Storage pools"). It names the SCROLL
+     * REGION rather than the table: a table's own structure is announced from its
+     * rows and headers, and this is the box around it that a keyboard user stands
+     * on to scroll sideways.
+     */
+    scrollRegionAriaLabel: _angular_core.InputSignal<string>;
     selectable: _angular_core.InputSignal<boolean>;
     expandable: _angular_core.InputSignal<boolean>;
     bordered: _angular_core.InputSignal<boolean>;
@@ -6620,6 +8861,10 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * rows the `isRowExpandable` predicate rejects are unaffected, since `toggleRowExpansion` gates
      * on it. `rowClick` still emits, so a consumer can both expand and react to the click.
      *
+     * In table mode the expanded state is announced by the chevron, not by the row: `aria-expanded`
+     * is a `treegrid`-row attribute and a plain `table` row cannot hold it (#246). The row points at
+     * the open panel with `aria-controls`, which every role permits.
+     *
      * Applies in card mode too, where activating the card toggles its detail section. Both controls
      * report the state: the card carries `aria-expanded` while it is the trigger (`listitem` does
      * permit it, unlike `aria-selected`), and the "Details" button carries it unconditionally,
@@ -6670,7 +8915,7 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      */
     minWidth: _angular_core.InputSignal<string>;
     /** The floor actually applied to the table — explicit if given, else derived, else none. */
-    protected readonly resolvedMinWidth: _angular_core.Signal<string | null>;
+    protected readonly resolvedMinWidth: Signal<string | null>;
     /**
      * How the table adapts when its container is narrower than `cardBreakpoint`.
      * See {@link TnTableMobileLayout}. Defaults to `scroll`, which preserves the
@@ -6708,9 +8953,9 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * button inside the row, as the file picker does for entering directories.
      */
     rowDoubleClick: _angular_core.OutputEmitterRef<T>;
-    columnDefs: _angular_core.Signal<readonly TnTableColumnDirective[]>;
-    detailRowDef: _angular_core.Signal<TnDetailRowDefDirective | undefined>;
-    rowActionsDef: _angular_core.Signal<TnRowActionsDefDirective | undefined>;
+    columnDefs: Signal<readonly TnTableColumnDirective[]>;
+    detailRowDef: Signal<TnDetailRowDefDirective | undefined>;
+    rowActionsDef: Signal<TnRowActionsDefDirective | undefined>;
     /** Observed host width in px; drives the switch into card mode. */
     private containerWidth;
     private resizeObserver?;
@@ -6748,21 +8993,50 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     private measureContainer;
     ngOnInit(): void;
     /** True when the layout should collapse rows into cards. */
-    isCardMode: _angular_core.Signal<boolean>;
+    isCardMode: Signal<boolean>;
     /** True when the layout should keep the table but pin edge columns and scroll. */
-    isScrollMode: _angular_core.Signal<boolean>;
-    data: _angular_core.Signal<T[]>;
-    effectiveDisplayedColumns: _angular_core.Signal<string[]>;
+    isScrollMode: Signal<boolean>;
+    data: Signal<T[]>;
+    effectiveDisplayedColumns: Signal<string[]>;
     /**
      * Every column the table actually renders, including the trailing actions column, which
      * `effectiveDisplayedColumns` does not track because it comes from a content template rather
      * than `displayedColumns`. Used for the detail row's `colspan`, so a detail row spans the full
      * width no matter which structural columns are on.
      */
-    totalColumnCount: _angular_core.Signal<number>;
-    isAllSelected: _angular_core.Signal<boolean>;
-    isIndeterminate: _angular_core.Signal<boolean>;
-    trackByFn: _angular_core.Signal<(index: number, item: T) => unknown>;
+    totalColumnCount: Signal<number>;
+    /**
+     * How many rows a select-all can actually select.
+     *
+     * `SelectionModel` stores selections in a `Set`, so `selection.selected.length`
+     * counts DISTINCT rows while `data().length` counts array entries. A `dataSource`
+     * holding the same row reference twice makes the two disagree, and every comparison
+     * of a selection count against a row count has to use this one to stay honest —
+     * see {@link isAllSelected}.
+     */
+    private distinctRowCount;
+    isAllSelected: Signal<boolean>;
+    isIndeterminate: Signal<boolean>;
+    /**
+     * Whether the select-all control has anything to act on.
+     *
+     * Disabling it on an empty table is a correctness guard, not a nicety. Since #236
+     * the checkbox is a real control the user can click, and its `checked` binding is
+     * one-way: the DOM follows `isAllSelected()`, and Angular only writes the attribute
+     * back when that value CHANGES. With no rows, `isAllSelected()` is pinned false —
+     * selecting nothing leaves the count at zero — so a click would flip the input in
+     * the DOM, change no bound value, and leave a checked-looking box over an empty
+     * selection until something else re-rendered it.
+     *
+     * The hit area around the checkbox stands down for the same reason, so the two
+     * cannot disagree about whether the control is live.
+     *
+     * An empty table is the only case that has to be disabled rather than fixed: a
+     * repeated row reference produces the same DOM-versus-model divergence, and
+     * {@link distinctRowCount} resolves that one by making the control work.
+     */
+    canSelectAll: Signal<boolean>;
+    trackByFn: Signal<(index: number, item: T) => unknown>;
     onSortClick(column: string): void;
     isSorted(column: string): boolean;
     /**
@@ -6776,11 +9050,17 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     toggleRowExpansion(row: T): void;
     isRowExpanded(row: T): boolean;
     /**
-     * Whether the row element itself acts as the expand/collapse control, which is what makes an
-     * `aria-expanded` on it meaningful: a screen-reader user who focuses the row and presses Enter
-     * otherwise gets no announcement that anything expanded, since only the chevron carries the
-     * state. Also requires `clickable` — without it the row isn't activatable and
-     * {@link onRowClick} returns before toggling anything.
+     * Whether the row element itself acts as the expand/collapse control. Requires `clickable` —
+     * without it the row isn't activatable and {@link onRowClick} returns before toggling anything.
+     *
+     * A table row does NOT get `aria-expanded` from this. That attribute is only supported on a
+     * `treegrid` row; on a plain `table` it is ignored, so the state it seemed to publish reached
+     * nobody (#246). The chevron in the `__expand` cell carries it instead, on a `button`, where it
+     * is valid and where a screen-reader user lands by tabbing. What the row does take from this is
+     * `aria-controls`, which is global rather than role-conditional.
+     *
+     * Card mode is the case where the trigger element CAN hold the state — see
+     * {@link isCardExpandTrigger}.
      */
     isRowExpandTrigger(row: T): boolean;
     /**
@@ -6788,8 +9068,8 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * template. Card mode renders no expansion affordance at all without one, so `aria-expanded`
      * on the card would advertise a state change that produces nothing.
      *
-     * Table mode deliberately keeps the looser check: its rows are asserted to carry
-     * `aria-expanded` from `expandOnRowClick` alone, and that predates this layout.
+     * `listitem` permits `aria-expanded`, which is what lets the card hold the state its table-row
+     * equivalent cannot.
      */
     isCardExpandTrigger(row: T): boolean;
     /** DOM id for a row's detail panel, so the expand trigger can point `aria-controls` at it. */
@@ -6855,14 +9135,55 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      */
     onSortHeaderClick(column: string, event: Event): void;
     /**
-     * Keyboard counterpart of {@link onSortHeaderClick}.
+     * Keyboard counterpart of {@link onSortHeaderClick}.
+     *
+     * Takes `Event` rather than `KeyboardEvent` because Angular types `$event` as `Event` for
+     * the `keydown.enter` / `keydown.space` pseudo-events; narrowing happens here.
+     */
+    onSortHeaderKeydown(column: string, event: Event): void;
+    /** Handles the card-mode sort `<select>` change. */
+    onSortSelectChange(event: Event): void;
+    /**
+     * Whether an event started inside a selection checkbox rather than on the hit area
+     * around it.
+     *
+     * Matched on the component's host class rather than through
+     * {@link isControlTarget}, because the element clicked is usually neither the input
+     * nor the host: `tn-checkbox` renders a `<label>` wrapping the input and its
+     * checkmark, and a click on the checkmark activates the input as the label's default
+     * action. `closest('input')` says no to that click, and the toggle would then happen
+     * twice — once here, once from the label's own activation.
+     *
+     * @param event The DOM event; its `currentTarget` is the hit area.
+     */
+    private isSelectionCheckboxTarget;
+    /**
+     * Click on the hit area around a select-all checkbox, in either layout.
+     *
+     * @param event The originating click.
+     */
+    onSelectAllHitAreaClick(event: Event): void;
+    /**
+     * Enter on the select-all checkbox.
+     *
+     * A native checkbox answers to Space and not to Enter, and the `<th>` this replaced
+     * handled both. Bound on the header's checkbox only, which is where that behaviour
+     * existed — card mode's select-all never had it.
+     *
+     * @param event The originating keydown; typed as `Event` because Angular types
+     *   `$event` that way for the `keydown.enter` pseudo-event.
+     */
+    onSelectAllEnter(event: Event): void;
+    /**
+     * Click on the hit area around a row's selection checkbox, in either layout.
      *
-     * Takes `Event` rather than `KeyboardEvent` because Angular types `$event` as `Event` for
-     * the `keydown.enter` / `keydown.space` pseudo-events; narrowing happens here.
+     * Propagation stops whichever path activates the checkbox: a row is clickable and a
+     * card is activatable, and selecting is not activating.
+     *
+     * @param event The originating click.
+     * @param row The row the cell or card belongs to.
      */
-    onSortHeaderKeydown(column: string, event: Event): void;
-    /** Handles the card-mode sort `<select>` change. */
-    onSortSelectChange(event: Event): void;
+    onRowSelectHitAreaClick(event: Event, row: T): void;
     toggleSelectAll(): void;
     toggleRowSelection(row: T): void;
     isRowSelected(row: T): boolean;
@@ -6873,17 +9194,17 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * most prominent slot. Falls back to the first displayed column only when every
      * column is hidden, since a card still needs a title.
      */
-    cardTitleColumn: _angular_core.Signal<string>;
+    cardTitleColumn: Signal<string>;
     /**
      * Columns rendered as label/value fields in a card, ordered by descending
      * `cardPriority` (ties keep `displayedColumns` order). Excludes the title column
      * and any `cardHidden` columns.
      */
-    cardFieldColumns: _angular_core.Signal<string[]>;
+    cardFieldColumns: Signal<string[]>;
     /** Fields shown directly on the card (up to `cardPrimaryCount`). */
-    cardPrimaryColumns: _angular_core.Signal<string[]>;
+    cardPrimaryColumns: Signal<string[]>;
     /** Fields tucked behind the "More fields" disclosure. */
-    cardSecondaryColumns: _angular_core.Signal<string[]>;
+    cardSecondaryColumns: Signal<string[]>;
     /**
      * Displayed columns that are sortable — populates the card-mode sort menu.
      *
@@ -6897,7 +9218,7 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * The title column stays eligible: it is excluded from the *fields*, but it is
      * displayed, so sorting by it is meaningful.
      */
-    sortableColumns: _angular_core.Signal<string[]>;
+    sortableColumns: Signal<string[]>;
     /**
      * Whether the active sort column is one the table can actually sort by.
      *
@@ -6907,7 +9228,7 @@ declare class TnTableComponent<T = unknown> implements OnInit {
      * non-sortable header does nothing, so the direction toggle is hidden — and
      * {@link toggleSortDirection} refuses — for the same column.
      */
-    protected readonly canSortActiveColumn: _angular_core.Signal<boolean>;
+    protected readonly canSortActiveColumn: Signal<boolean>;
     /**
      * Sets (or clears, when passed `''`) the active sort column for card mode.
      * Switching columns resets to ascending, and clearing emits an empty `column` —
@@ -6931,7 +9252,7 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     getCardLabel(column: string): string;
     getCellValue(row: T, column: string): unknown;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTableComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTableComponent<any>, "tn-table", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; "isSignal": true; }; "emptyIcon": { "alias": "emptyIcon"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "isRowExpandable": { "alias": "isRowExpandable"; "required": false; "isSignal": true; }; "activeRow": { "alias": "activeRow"; "required": false; "isSignal": true; }; "activeWhen": { "alias": "activeWhen"; "required": false; "isSignal": true; }; "activeBg": { "alias": "activeBg"; "required": false; "isSignal": true; }; "activeIndicator": { "alias": "activeIndicator"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "expandOnRowClick": { "alias": "expandOnRowClick"; "required": false; "isSignal": true; }; "singleExpand": { "alias": "singleExpand"; "required": false; "isSignal": true; }; "fixedLayout": { "alias": "fixedLayout"; "required": false; "isSignal": true; }; "minColumnWidth": { "alias": "minColumnWidth"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "mobileLayout": { "alias": "mobileLayout"; "required": false; "isSignal": true; }; "cardBreakpoint": { "alias": "cardBreakpoint"; "required": false; "isSignal": true; }; "cardPrimaryCount": { "alias": "cardPrimaryCount"; "required": false; "isSignal": true; }; "sortColumn": { "alias": "sortColumn"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "selectionChange": "selectionChange"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "sortColumn": "sortColumnChange"; "sortDirection": "sortDirectionChange"; }, ["columnDefs", "detailRowDef", "rowActionsDef"], never, true, [{ directive: typeof TnTestIdDirective; inputs: { "tnTestId": "testId"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTableComponent<any>, "tn-table", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; "isSignal": true; }; "emptyIcon": { "alias": "emptyIcon"; "required": false; "isSignal": true; }; "scrollRegionAriaLabel": { "alias": "scrollRegionAriaLabel"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "isRowExpandable": { "alias": "isRowExpandable"; "required": false; "isSignal": true; }; "activeRow": { "alias": "activeRow"; "required": false; "isSignal": true; }; "activeWhen": { "alias": "activeWhen"; "required": false; "isSignal": true; }; "activeBg": { "alias": "activeBg"; "required": false; "isSignal": true; }; "activeIndicator": { "alias": "activeIndicator"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "expandOnRowClick": { "alias": "expandOnRowClick"; "required": false; "isSignal": true; }; "singleExpand": { "alias": "singleExpand"; "required": false; "isSignal": true; }; "fixedLayout": { "alias": "fixedLayout"; "required": false; "isSignal": true; }; "minColumnWidth": { "alias": "minColumnWidth"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "mobileLayout": { "alias": "mobileLayout"; "required": false; "isSignal": true; }; "cardBreakpoint": { "alias": "cardBreakpoint"; "required": false; "isSignal": true; }; "cardPrimaryCount": { "alias": "cardPrimaryCount"; "required": false; "isSignal": true; }; "sortColumn": { "alias": "sortColumn"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "selectionChange": "selectionChange"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "sortColumn": "sortColumnChange"; "sortDirection": "sortDirectionChange"; }, ["columnDefs", "detailRowDef", "rowActionsDef"], never, true, [{ directive: typeof TnTestIdDirective; inputs: { "tnTestId": "testId"; }; outputs: {}; }]>;
 }
 
 /**
@@ -7471,11 +9792,6 @@ declare class TnTablePagerComponent {
      * `TnTestIdValue` testId.
      */
     protected childTestId(suffix: string): string;
-    /**
-     * Normalize the injected token into a Signal so consumers can supply either
-     * a plain object or a reactive signal (e.g. derived from a TranslateService's
-     * onLangChange) and the pager re-renders when labels change.
-     */
     private readonly defaultLabels;
     /** 1-based index of the currently displayed page. */
     currentPage: _angular_core.ModelSignal<number>;
@@ -7509,7 +9825,27 @@ declare class TnTablePagerComponent {
     previousPageLabel: _angular_core.InputSignal<string | undefined>;
     nextPageLabel: _angular_core.InputSignal<string | undefined>;
     lastPageLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Accessible name for the pager's `navigation` landmark — what a screen
+     * reader user picking this pager out of a landmark list hears.
+     *
+     * **Name every pager on a page that has more than one.** Two pagers both
+     * announcing the DI default are one landmark repeated as far as that list is
+     * concerned, which is what #249 was: `landmark-unique` fails and the user has
+     * nothing to choose between them.
+     */
     tablePaginationLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * IDREF naming the pager from text already on the page — the heading over the
+     * table it pages, typically, which is the name the user can see.
+     *
+     * Wins over the `aria-label` in the ARIA name computation while it resolves,
+     * so pass one or the other rather than both. The `aria-label` is rendered
+     * beside it either way and is what the pager falls back to if the IDREF is
+     * typo'd or names an element that has not rendered yet — see
+     * `resolvedTablePaginationLabel`.
+     */
+    ariaLabelledby: _angular_core.InputSignal<string | undefined>;
     /** Resolved labels: explicit input takes precedence over the DI default. */
     protected resolvedItemsPerPageLabel: Signal<string>;
     protected resolvedOfLabel: Signal<string>;
@@ -7517,7 +9853,57 @@ declare class TnTablePagerComponent {
     protected resolvedPreviousPageLabel: Signal<string>;
     protected resolvedNextPageLabel: Signal<string>;
     protected resolvedLastPageLabel: Signal<string>;
-    protected resolvedTablePaginationLabel: Signal<string>;
+    /**
+     * The landmark name a pager falls back to when the consumer sets no
+     * `tablePaginationLabel` — the DI default, scoped by `testId` when there is
+     * one.
+     *
+     * The scoping is what stops the DEFAULT from being the same string on every
+     * pager, which is the shape #249 reported: two pagers, both announcing "Table
+     * pagination", indistinguishable in a landmark list. `testId` is the only
+     * per-instance identity the pager already has, and a page with two pagers
+     * needs distinct ones anyway — without them the pagers' own child controls
+     * collide on `select-page-size` / `button-first-page` (see the **Multiple
+     * Pagers** story), so the multi-pager case that trips this rule is exactly the
+     * case that already sets it.
+     *
+     * **It is a fallback and not the good answer.** A test id is a developer-facing
+     * token: it is not translated, and `storage` reads as the word rather than as
+     * "Storage pools". A pager whose name matters names itself with
+     * `tablePaginationLabel`, or points at the table's visible heading with
+     * `ariaLabelledby`; this only keeps the unnamed case from being ambiguous as
+     * well as generic.
+     *
+     * Appended in parentheses rather than woven into the sentence, because the
+     * base string comes from `TN_TABLE_PAGER_LABELS` and may be in any language —
+     * there is no word order here to get right, only a translated name and a
+     * scope after it.
+     */
+    private defaultTablePaginationLabel;
+    /**
+     * The name rendered as `aria-label`, always — the explicit
+     * `tablePaginationLabel` when there is one, the scoped default otherwise.
+     *
+     * **It is emitted beside an `ariaLabelledby` rather than withheld under it**,
+     * which is where this differs from `../a11y/accessible-name`, the shared rule
+     * the progressbars and the dialogs take. That rule drops the generic fallback
+     * when the caller supplies an IDREF, so a dangling IDREF surfaces as an
+     * unnamed element instead of being masked by a name that says nothing. The
+     * trade is only worth making where "unnamed" is itself caught: a progressbar
+     * fails `aria-progressbar-name`, an `over` drawer fails `aria-dialog-name`,
+     * and a `side` drawer — a landmark, like this — rests on that module's
+     * dev-mode warning instead. This pager has neither. `landmark-unique` compares
+     * landmarks against each other, so one unnamed pager violates nothing at all;
+     * and the warning is one it cannot take, because the fallback here is a name
+     * the consumer configures through `TN_TABLE_PAGER_LABELS` rather than one
+     * someone forgot, so it would fire on the ordinary case.
+     *
+     * Withholding here would therefore turn a typo in `ariaLabelledby` into a
+     * pager that announces nothing and reports nothing — a worse version of the
+     * defect #249 opened on. So the pager keeps a name it can always fall back to,
+     * and accepts that a dangling IDREF is masked by a generic one.
+     */
+    protected resolvedTablePaginationLabel: Signal<string | undefined>;
     /** Emits the new 1-based page number whenever the user navigates. */
     pageChange: _angular_core.OutputEmitterRef<number>;
     /** Emits the new page-size value when the dropdown changes. */
@@ -7562,7 +9948,7 @@ declare class TnTablePagerComponent {
     /** Forwards the current page/size to the data provider, if one is bound. */
     private pushToProvider;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTablePagerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTablePagerComponent, "tn-table-pager", never, { "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "dataProvider": { "alias": "dataProvider"; "required": false; "isSignal": true; }; "itemsPerPageLabel": { "alias": "itemsPerPageLabel"; "required": false; "isSignal": true; }; "ofLabel": { "alias": "ofLabel"; "required": false; "isSignal": true; }; "firstPageLabel": { "alias": "firstPageLabel"; "required": false; "isSignal": true; }; "previousPageLabel": { "alias": "previousPageLabel"; "required": false; "isSignal": true; }; "nextPageLabel": { "alias": "nextPageLabel"; "required": false; "isSignal": true; }; "lastPageLabel": { "alias": "lastPageLabel"; "required": false; "isSignal": true; }; "tablePaginationLabel": { "alias": "tablePaginationLabel"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "pageSize": "pageSizeChange"; "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTablePagerComponent, "tn-table-pager", never, { "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "dataProvider": { "alias": "dataProvider"; "required": false; "isSignal": true; }; "itemsPerPageLabel": { "alias": "itemsPerPageLabel"; "required": false; "isSignal": true; }; "ofLabel": { "alias": "ofLabel"; "required": false; "isSignal": true; }; "firstPageLabel": { "alias": "firstPageLabel"; "required": false; "isSignal": true; }; "previousPageLabel": { "alias": "previousPageLabel"; "required": false; "isSignal": true; }; "nextPageLabel": { "alias": "nextPageLabel"; "required": false; "isSignal": true; }; "lastPageLabel": { "alias": "lastPageLabel"; "required": false; "isSignal": true; }; "tablePaginationLabel": { "alias": "tablePaginationLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "pageSize": "pageSizeChange"; "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
 }
 
 /**
@@ -8561,6 +10947,26 @@ declare const QuickShortcuts: {
     alt(key: string, platform?: PlatformType): string;
 };
 
+/**
+ * Reads a label token and hands back a Signal, whichever of the two shapes the app provided.
+ *
+ * Every `TN_*_LABELS` token in this library is declared as `T | Signal<T>` so a consumer can
+ * pass a plain object (the common case — one static bundle for a single-language app) or a
+ * Signal derived from an i18n service, in which case a language switch re-renders the chrome
+ * live instead of needing a reload. Components only ever want the Signal, so normalizing at
+ * the injection point keeps that union from leaking into every read site.
+ *
+ * @param token The label token to inject.
+ * @returns A Signal of the provided labels; a plain object is wrapped in a constant Signal.
+ *
+ * @example
+ * ```typescript
+ * private readonly labels = injectTnLabels(TN_TABLE_LABELS);
+ * // template: {{ labels().sortBy }}
+ * ```
+ */
+declare function injectTnLabels<T>(token: InjectionToken<T | Signal<T>>): Signal<T>;
+
 declare class FileSizePipe implements PipeTransform {
     transform(value: number): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileSizePipe, never>;
@@ -8618,6 +11024,20 @@ declare function labelMarkupToHtml(value: string): string;
 declare function labelMarkupToText(value: string): string;
 
 type SpinnerMode = 'determinate' | 'indeterminate';
+/**
+ * The accessible name a spinner falls back to when the caller names neither
+ * `ariaLabel` nor `ariaLabelledby` (#202). Same reasoning as
+ * `TN_PROGRESS_BAR_DEFAULT_LABEL`, and the case is sharper here: the spinner
+ * defaults to indeterminate mode, so its unnamed default rendering reached
+ * assistive technology as a progressbar with neither a name nor a value.
+ *
+ * `branded-spinner.component.ts` in this folder already fell back this way —
+ * `ariaLabel() || "Loading..."` inline — so a fallback is the shape this
+ * library had already settled on; what it lacked was the warning. It has both
+ * since #206, through the same `tnAccessibleName` this component uses, which is
+ * why the two constants sit side by side and differ.
+ */
+declare const TN_SPINNER_DEFAULT_LABEL = "Loading";
 declare class TnSpinnerComponent {
     mode: _angular_core.InputSignal<SpinnerMode>;
     value: _angular_core.InputSignal<number>;
@@ -8625,6 +11045,18 @@ declare class TnSpinnerComponent {
     strokeWidth: _angular_core.InputSignal<number>;
     ariaLabel: _angular_core.InputSignal<string | null>;
     ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /**
+     * The name to render, or `null` to render no `aria-label` attribute — and the
+     * dev-mode warning when the caller named neither input.
+     *
+     * Both halves live in `../a11y/accessible-name`, shared with `tn-progress-bar`
+     * and `tn-branded-spinner` (#206), where the reasoning for each is set out:
+     * an explicit `ariaLabel` always survives, because `aria-labelledby` only wins
+     * the name calculation while its IDREF resolves; the generic fallback is
+     * withheld beside one, because there it would mask a dangling IDREF with a
+     * name that says nothing.
+     */
+    resolvedAriaLabel: _angular_core.Signal<string | null>;
     radius: _angular_core.Signal<number>;
     circumference: _angular_core.Signal<number>;
     strokeDasharray: _angular_core.Signal<string>;
@@ -8634,8 +11066,35 @@ declare class TnSpinnerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnSpinnerComponent, "tn-spinner", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * The name this spinner falls back to when the caller names neither `ariaLabel`
+ * nor `ariaLabelledby`. Same reasoning as `TN_SPINNER_DEFAULT_LABEL` and
+ * `TN_PROGRESS_BAR_DEFAULT_LABEL`.
+ *
+ * It differs from `TN_SPINNER_DEFAULT_LABEL` — `"Loading..."` against
+ * `"Loading"` — only because this is the string the component already rendered,
+ * inline in its host binding, before #206 gave it the shared resolver. Aligning
+ * the two would change what a screen reader announces for every unnamed branded
+ * spinner already in the wild, which is a louder change than the consistency
+ * fix it would be part of. Exported so specs assert against it by name rather
+ * than by a copied string literal.
+ */
+declare const TN_BRANDED_SPINNER_DEFAULT_LABEL = "Loading...";
 declare class TnBrandedSpinnerComponent implements OnInit, OnDestroy, AfterViewInit {
     ariaLabel: _angular_core.InputSignal<string | null>;
+    ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /**
+     * The name to render, or `null` to render no `aria-label` attribute — and the
+     * dev-mode warning when the caller named neither input.
+     *
+     * This component is why `../a11y/accessible-name` exists (#206). It carried a
+     * fallback inline in its host binding, so it never failed
+     * `aria-progressbar-name` and the two fixes that gave the other progressbars
+     * an `ariaLabelledby` input and a warning both passed it by. Routing it
+     * through the shared resolver is what makes it named by the same rule rather
+     * than by a third one nobody chose.
+     */
+    resolvedAriaLabel: _angular_core.Signal<string | null>;
     private paths;
     private animationId;
     private isAnimating;
@@ -8651,16 +11110,48 @@ declare class TnBrandedSpinnerComponent implements OnInit, OnDestroy, AfterViewI
     private animateSequence;
     private tween;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnBrandedSpinnerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnBrandedSpinnerComponent, "tn-branded-spinner", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnBrandedSpinnerComponent, "tn-branded-spinner", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type ProgressBarMode = 'determinate' | 'indeterminate' | 'buffer';
+/**
+ * The accessible name a bar falls back to when the caller names neither
+ * `ariaLabel` nor `ariaLabelledby` (#202).
+ *
+ * Deliberately generic, and deliberately not silent: the host carries
+ * `role="progressbar"` unconditionally, so without a fallback the default
+ * rendering is a progressbar assistive technology announces with no name at all
+ * — "progress bar, 40%", with nothing to say what is progressing. The
+ * alternative fix, withholding the role until there is a name for it, trades
+ * that for no announcement whatever, which is worse: a screen reader would not
+ * learn that anything is in progress, and on a determinate bar it would lose
+ * the value too.
+ *
+ * A generic name is still a poor one, so it is paired with the dev-mode warning
+ * `tnAccessibleName` raises. Exported so specs assert against it by name rather
+ * than by a copied string literal.
+ */
+declare const TN_PROGRESS_BAR_DEFAULT_LABEL = "Progress";
 declare class TnProgressBarComponent {
     mode: _angular_core.InputSignal<ProgressBarMode>;
     value: _angular_core.InputSignal<number>;
     bufferValue: _angular_core.InputSignal<number>;
     ariaLabel: _angular_core.InputSignal<string | null>;
     ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /**
+     * The name to render, or `null` to render no `aria-label` attribute — and the
+     * dev-mode warning when the caller named neither input.
+     *
+     * Both halves live in `../a11y/accessible-name`, shared with `tn-spinner` and
+     * `tn-branded-spinner` (#206), where the reasoning for each is set out: why an
+     * explicit `ariaLabel` always survives, and why the generic fallback is
+     * withheld beside an `ariaLabelledby`.
+     *
+     * A field initializer rather than the constructor, because it registers an
+     * `effect` and so needs an injection context; this is one, and it keeps the
+     * signal beside the inputs it reads.
+     */
+    resolvedAriaLabel: _angular_core.Signal<string | null>;
     /**
      * Gets the transform value for the primary progress bar
      */
@@ -8680,13 +11171,113 @@ declare class TnProgressBarComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnProgressBarComponent, "tn-progress-bar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "bufferValue": { "alias": "bufferValue"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * The accessible name this bar falls back to when the caller names neither
+ * `ariaLabel` nor `ariaLabelledby` (#209).
+ *
+ * The same string and the same reasoning as `TN_PROGRESS_BAR_DEFAULT_LABEL`
+ * next door, and deliberately a separate constant rather than an import of it:
+ * `tnAccessibleName` takes a fallback PER COMPONENT because the least-bad
+ * generic name differs by what the component is ("Progress" for a bar,
+ * "Loading" for a spinner), and sharing the binding would make a future
+ * divergence in one a silent change to the other. Exported so specs assert
+ * against it by name rather than by a copied string literal.
+ */
+declare const TN_PARTICLE_PROGRESS_BAR_DEFAULT_LABEL = "Progress";
+/**
+ * THE DECISION #209 ASKED FOR: THIS IS A PROGRESSBAR, NOT DECORATION
+ * ------------------------------------------------------------------
+ * Both readings were open. Before the change the host carried a class and
+ * nothing else — no role, no name, no value — and because it never claimed
+ * `role="progressbar"` it could not fail `aria-progressbar-name` either, so
+ * every axe-based check in this library was silent on it by construction.
+ * Measured on the unchanged component under jsdom, sweeping `svg-img-alt` and
+ * the four rules `particle-progress-bar-a11y.spec.ts` keeps: 0 violations, 0
+ * passes, 0 incomplete, on every one of them. Not clean — unexamined. That
+ * spec keeps the measurement as its first test.
+ *
+ * It is a progressbar because it is a WHOLE indicator rather than an overlay on
+ * someone else's. The SVG draws its own background track and its own fill rect,
+ * and `fill` sizes the second against the first; that is a determinate progress
+ * value, whatever the particles on top of it are doing. The alternative reading
+ * — an ambient flourish shown BESIDE a real indicator, where a role would be
+ * the redundant second announcement #203 was about — needs the real indicator
+ * to exist, and nothing here provides one.
+ *
+ * The usage evidence points the same way, weakly but only in one direction. Its
+ * only consumer in this repository is its own Storybook story: it has never
+ * been placed next to a `tn-progress-bar`, so the redundancy risk is
+ * hypothetical. It IS exported from `public-api.ts`, so consumers outside this
+ * repository may already be showing it as the only progress on a screen — and
+ * that asymmetry is what settles it. Choosing `aria-hidden` would assert a
+ * usage constraint the library cannot enforce, and when that assertion is wrong
+ * a screen-reader user gets nothing at all where a sighted user sees a bar
+ * filling — strictly worse than the unnamed progressbars #202/#205/#206 fixed.
+ * Choosing the role when the component really is ambient costs a redundant
+ * announcement a consumer can silence with `aria-hidden` on its own wrapper.
+ * The two errors are not the same size.
+ *
+ * The canvas IS decoration, and that is a separate question from what the host
+ * is. It draws particles and carries no information the fill rect does not, so
+ * the whole drawing is hidden and the ARIA value is what conveys the progress —
+ * see the `aria-hidden` on the `<svg>` in the template.
+ *
+ * WHY THE VALUE IS A PERCENTAGE AND `fill` IS NOT
+ * ----------------------------------------------
+ * `fill` is a px length along the track, not a percentage — the story's control
+ * runs it 0–600 while `width` runs 200–800, so the same `fill` means different
+ * progress at different widths. `aria-valuenow` is reported on 0–100 instead,
+ * matching `tn-progress-bar`, so that two bars from one library do not announce
+ * on two different scales and no layout px reaches the accessibility tree.
+ * Assistive technology derives the percentage from the range either way; what
+ * this fixes is which range a consumer reads in the DOM.
+ */
 declare class TnParticleProgressBarComponent implements AfterViewInit, OnDestroy {
     speed: _angular_core.InputSignal<"medium" | "slow" | "fast" | "ludicrous">;
     color: _angular_core.InputSignal<string>;
     height: _angular_core.InputSignal<number>;
     width: _angular_core.InputSignal<number>;
     fill: _angular_core.InputSignal<number>;
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    ariaLabelledby: _angular_core.InputSignal<string | null>;
     canvasRef: _angular_core.Signal<ElementRef<HTMLCanvasElement>>;
+    /** Exposed to the template so the rects and the ARIA value share one inset. */
+    readonly trackInset = 50;
+    /**
+     * The name to render, or `null` to render no `aria-label` at all — and the
+     * dev-mode warning when the caller named neither input.
+     *
+     * Both halves live in `../a11y/accessible-name`, shared with the other three
+     * progressbars in this library (#206), where the reasoning for each is set
+     * out: why an explicit `ariaLabel` always survives, and why the generic
+     * fallback is withheld beside an `ariaLabelledby`. Routed through that helper
+     * rather than given a rule of its own, which is what #209 asked for — a
+     * fourth naming rule is how `tn-branded-spinner` ended up divergent.
+     *
+     * A field initializer rather than the constructor, because it registers an
+     * `effect` and so needs an injection context; this is one, and it keeps the
+     * signal beside the inputs it reads.
+     */
+    resolvedAriaLabel: _angular_core.Signal<string | null>;
+    /** The drawable length of the track: the SVG width less the inset at each end. */
+    trackLength: _angular_core.Signal<number>;
+    /**
+     * `fill` as a percentage of the track, or `null` when there is no track to
+     * measure against.
+     *
+     * Clamped, because `fill` is not: the story alone can drive it to 600 against
+     * a 500px track, where the fill rect simply overflows. `aria-valuenow` may not
+     * exceed `aria-valuemax`, and 100 is also what such a bar visually reads as —
+     * a track filled end to end. The clamp is on the announcement only; nothing
+     * here changes what is drawn.
+     *
+     * `null` on a non-positive track — `width` at or below twice the inset — is
+     * what makes the host announce as an INDETERMINATE progressbar rather than
+     * carrying a value derived from a division by zero or a negative range. The
+     * role stays either way, because "something is in progress" is true even when
+     * how far is not answerable.
+     */
+    valuePercent: _angular_core.Signal<number | null>;
     private ctx;
     private particles;
     private shades;
@@ -8714,7 +11305,7 @@ declare class TnParticleProgressBarComponent implements AfterViewInit, OnDestroy
      */
     private generateDarkerShades;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnParticleProgressBarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnParticleProgressBarComponent, "tn-particle-progress-bar", never, { "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnParticleProgressBarComponent, "tn-particle-progress-bar", never, { "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface DateRange {
@@ -9769,8 +12360,9 @@ declare class TnSliderThumbDirective implements ControlValueAccessor, OnInit, On
         value: () => number;
         labelPrefix: () => string;
         labelSuffix: () => string;
-        ariaLabel: () => string | undefined;
-        ariaLabelledby: () => string | undefined;
+        resolvedAriaLabel: () => string | null;
+        explicitAriaLabelledby: () => string | null;
+        fieldAriaLabelledby: () => string | null;
         updateValue: (value: number) => void;
         markTouched: () => void;
         getSliderRect: () => DOMRect;
@@ -9817,12 +12409,29 @@ declare class TnSliderThumbDirective implements ControlValueAccessor, OnInit, On
     private onGlobalTouchEnd;
     private updateValueFromPosition;
     /**
-     * Resolve the accessible name for the range input: the parent slider's
-     * `aria-label`/`aria-labelledby` input when set, otherwise a value placed
-     * directly on the `<input tnSliderThumb>`. Returning the fallback keeps the
-     * host binding from wiping a directly-set label. Null removes the attribute.
+     * The `aria-label` for the range input: the parent slider's input when set,
+     * otherwise a value placed directly on the `<input tnSliderThumb>`. Returning
+     * the fallback keeps the host binding from wiping a directly-set label. Null
+     * removes the attribute.
      */
     ariaLabel(): string | null;
+    /**
+     * The `aria-labelledby` for the range input — and the one place the precedence
+     * between an explicit name and an inherited one is decided.
+     *
+     * An explicit reference comes first, from the slider's input or from this
+     * input itself. **An enclosing `tn-form-field`'s label comes last, and only
+     * when nothing has named the control directly.** That ordering is the point:
+     * `aria-labelledby` beats `aria-label` in the ARIA name calculation whenever
+     * it resolves, so emitting the field's label beside an `aria-label` written on
+     * this input would render both attributes and announce the FIELD's label —
+     * silently replacing the name the consumer wrote on the control (#235).
+     *
+     * The slider's own `ariaLabel` input needs no such check here, because
+     * `injectTnFormFieldAria` already withholds the field's label whenever it is
+     * set; this covers the label that is written past the slider, onto the
+     * projected input, which the slider's inputs never see.
+     */
     ariaLabelledby(): string | null;
     /**
      * Commit a value that originated outside the native input (a thumb drag).
@@ -9860,13 +12469,63 @@ declare class TnSliderComponent implements ControlValueAccessor, OnDestroy, Afte
     /**
      * Accessible name forwarded to the inner range input — the focusable element
      * screen readers actually announce. Set this (or `aria-labelledby`) when the
-     * slider isn't already labelled by a `tn-form-field`/`<label>`, otherwise a
+     * slider isn't already inside a labelled `tn-form-field`, otherwise a
      * standalone `<tn-slider><input tnSliderThumb></tn-slider>` announces only
-     * "slider". A label set directly on the `input[tnSliderThumb]` is used as a
-     * fallback when neither is provided here.
+     * "slider".
+     *
+     * Precedence is per attribute: each of `aria-label` and `aria-labelledby` is
+     * taken from the matching input here, else from one written directly on the
+     * `input[tnSliderThumb]`. Between the two attributes, ARIA's own rule decides
+     * — `aria-labelledby` wins wherever it resolves.
+     *
+     * An enclosing `tn-form-field`'s label comes after all of those, and only when
+     * nothing above has named the control: it is chrome the consumer did not write
+     * on the control. See `TnSliderThumbDirective.ariaLabelledby`, where the
+     * ordering is applied.
      */
     ariaLabel: _angular_core.InputSignal<string | undefined>;
     ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    /**
+     * ARIA wiring from an enclosing `tn-form-field`, read for `labelledby` alone:
+     * #235 is about the range input having no accessible name, and the field's
+     * `describedby`/`invalid`/`required` are a separate question this slider has
+     * never answered either way.
+     *
+     * Called with NO argument, so it reports the field's label id unconditioned.
+     * Handing it the `ariaLabel` input would have it suppress the field itself —
+     * on truthiness, so a whitespace-only label would cancel the field while being
+     * dropped as no name, leaving nothing — and it would only do so while this
+     * field is initialised after the one it reads, since a signal captured before
+     * its own initialiser runs arrives as `undefined` and is swallowed by an
+     * optional call. The suppression is the thumb's, where the rest of the
+     * precedence already lives and where it is visible.
+     */
+    private readonly fieldAria;
+    /**
+     * The `aria-label` the thumb should render, or `null` for none.
+     *
+     * Blank is not a name: `aria-label=""` names the input as emptily as no
+     * attribute at all, while satisfying axe's `label` rule — a green check on a
+     * control a screen reader announces as "slider" (#235). Same reasoning as
+     * `a11y/accessible-name.ts`, which the three progressbars share.
+     */
+    readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
+    /**
+     * The `ariaLabelledby` INPUT, blank normalised away, or `null` when unset.
+     *
+     * Kept separate from {@link fieldAriaLabelledby} rather than folded into one
+     * resolved value, because the two rank differently against a label written on
+     * the projected input — see `TnSliderThumbDirective.ariaLabelledby`.
+     */
+    readonly explicitAriaLabelledby: _angular_core.Signal<string | null>;
+    /**
+     * The enclosing `tn-form-field`'s label id, or `null` outside one.
+     *
+     * With no field and no input, a slider stays unnamed — deliberately: a
+     * generic fallback ("Slider") would satisfy axe while announcing nothing the
+     * user can act on, and only the consumer knows what this slider controls.
+     */
+    readonly fieldAriaLabelledby: _angular_core.Signal<string | null>;
     thumbDirective: _angular_core.Signal<TnSliderThumbDirective>;
     sliderContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     private onChange;
@@ -10175,11 +12834,243 @@ interface ButtonToggleHarnessFilters extends BaseHarnessFilters {
     label?: string | RegExp;
 }
 
+/**
+ * The visual half of `tnTooltip`, and — while it is only shown on hover — only the visual half
+ * (#203).
+ *
+ * WHY THE HOVER PANEL IS `aria-hidden` AND CARRIES NO ROLE
+ * --------------------------------------------------------
+ * The accessible text is `TnTooltipDirective`'s job, and it routes it through
+ * CDK's `AriaDescriber` — a persistent visually-hidden element referenced by
+ * `aria-describedby` on the interactive control, so the reference never dangles
+ * while this overlay comes and goes. That is one tooltip, described once.
+ *
+ * This node used to ALSO claim `role="tooltip"`, which put a second tooltip in
+ * the accessibility tree for the same message: the describer's (named, and
+ * referenced by the control) and this one (named by nothing when the message is
+ * empty or markup-only). axe scores that `aria-tooltip-name`, WCAG 4.1.2.
+ * Of the two models the ticket set out — make the overlay the accessible
+ * tooltip, or make it decorative — decorative is the one the rest of the
+ * directive is already built for, and it is what `pointer-events: none` on
+ * `:host` already says: this element cannot be hovered, clicked or interacted
+ * with. Hiding it removes the duplicate rather than moving the name onto it.
+ *
+ * `aria-hidden="true"` is bound to `sticky` rather than to a visibility signal.
+ * The node is exposed in no state a hover tooltip can be in, so there is no
+ * visibility for it to reflect — the old hard-coded `aria-hidden="false"` was
+ * the bug, because that value DID depend on state it was not tracking.
+ *
+ * AND WHY A PINNED ONE IS THE OPPOSITE
+ * ------------------------------------
+ * `sticky` is the one state where the panel is more than decoration: it takes
+ * pointer events, holds focusable content, and renders a dismiss button, so
+ * hiding it would put focusable nodes inside an `aria-hidden` subtree and make
+ * the very content pinning exists to reach unreachable. A pinned panel is
+ * therefore an exposed, named `dialog` (see `sticky`), and the describer's
+ * description on the host stands alongside it rather than in place of it.
+ */
 declare class TnTooltipComponent {
     message: _angular_core.InputSignal<string>;
+    /**
+     * Optional DOM id for the rendered element. Omitted entirely when empty
+     * rather than rendered as `id=""`, which no `aria-describedby` or selector can
+     * reference — a silently dangling hook.
+     */
     id: _angular_core.InputSignal<string>;
+    /**
+     * Pinned ("sticky") mode. The tooltip stops being click-through so its content can be
+     * interacted with, and a dismiss button is rendered next to the message.
+     *
+     * It also changes what the panel *is* for assistive tech: ARIA's `tooltip` role is specified as
+     * non-focusable, non-interactive content that something else is described by, so a screen
+     * reader may flatten it to a text description and never expose the link or the dismiss button -
+     * exactly what pinning exists to make reachable. A pinned panel is therefore a `dialog`, named
+     * by `panelAriaLabel`.
+     *
+     * It is a *non-modal* dialog and deliberately traps nothing: Tab past the dismiss button leaves
+     * the panel while it stays open. Where focus lands next is wherever the panel sits in the tab
+     * order, which is the end of it - CDK appends its overlay container as the last child of
+     * `<body>` - so in practice Tab leaves the document for the browser's own chrome rather than
+     * continuing after the host. Not trapping is the right shape for a popup the user can also
+     * leave by Escape or by clicking outside, and it keeps a tooltip from holding the keyboard
+     * hostage.
+     */
+    sticky: _angular_core.InputSignal<boolean>;
+    /** Accessible name for the dismiss button, so consumers can localize it. */
+    closeAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the pinned panel (see `sticky`), so consumers can localize it.
+     *
+     * A short static name rather than the message: a screen reader reads a dialog's name on entry
+     * and then its content, so naming it after the message would announce that message twice —
+     * three times counting the host's own description.
+     */
+    panelAriaLabel: _angular_core.InputSignal<string>;
+    /** Emitted when the user activates the dismiss button. */
+    onDismiss: _angular_core.OutputEmitterRef<void>;
+    private panel;
+    /**
+     * Moves focus onto the tooltip panel. Used when sticky mode is entered from the keyboard, so
+     * the tooltip's content is reachable without a pointer: from the panel, Tab walks the message
+     * (links included) and then the dismiss button. The panel is only focusable in sticky mode,
+     * so this is a no-op otherwise.
+     */
+    focusPanel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTooltipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTooltipComponent, "tn-tooltip", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTooltipComponent, "tn-tooltip", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "closeAriaLabel": { "alias": "closeAriaLabel"; "required": false; "isSignal": true; }; "panelAriaLabel": { "alias": "panelAriaLabel"; "required": false; "isSignal": true; }; }, { "onDismiss": "onDismiss"; }, never, never, true, never>;
+}
+
+/**
+ * Harness for interacting with a tooltip rendered by `tnTooltip` in tests.
+ *
+ * Tooltips render in a CDK overlay **outside** the component tree, so the regular
+ * `TestbedHarnessEnvironment.loader(fixture)` won't find them. Use
+ * `TnTooltipTesting.rootLoader(fixture)` instead — it searches the whole document.
+ *
+ * @example
+ * ```typescript
+ * import { TnTooltipHarness, TnTooltipTesting } from '@truenas/ui-components';
+ *
+ * const rootLoader = TnTooltipTesting.rootLoader(fixture);
+ *
+ * // Hover tooltip: show it, then read it
+ * host.dispatchEvent(new MouseEvent('mouseenter'));
+ * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+ * expect(await tooltip.getText()).toBe('Pool is online');
+ *
+ * // Sticky tooltip: click the host to pin it, then dismiss it
+ * host.click();
+ * const pinned = await rootLoader.getHarness(TnTooltipHarness);
+ * expect(await pinned.isSticky()).toBe(true);
+ * await pinned.dismiss();
+ * ```
+ */
+declare class TnTooltipHarness extends ComponentHarness {
+    /**
+     * The selector for the host element of a `TnTooltipComponent` instance.
+     */
+    static hostSelector: string;
+    private _panel;
+    private _message;
+    private _closeButton;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tooltip with specific
+     * attributes. Useful when more than one tooltip is on screen — a pinned one plus a hover
+     * one, for instance.
+     *
+     * @param options Options for filtering which tooltip instances are considered a match.
+     * @returns A `HarnessPredicate` configured with the given options.
+     *
+     * @example
+     * ```typescript
+     * // Find a tooltip by its text
+     * const tooltip = await rootLoader.getHarness(TnTooltipHarness.with({ text: 'Pool is online' }));
+     *
+     * // Find only the pinned one
+     * const pinned = await rootLoader.getHarness(TnTooltipHarness.with({ sticky: true }));
+     * ```
+     */
+    static with(options?: TooltipHarnessFilters): HarnessPredicate<TnTooltipHarness>;
+    /**
+     * Gets the tooltip's text content, with any markup in the message stripped.
+     *
+     * @returns Promise resolving to the tooltip's text.
+     *
+     * @example
+     * ```typescript
+     * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+     * expect(await tooltip.getText()).toBe('Pool is online');
+     * ```
+     */
+    getText(): Promise<string>;
+    /**
+     * Checks whether the tooltip is pinned open (sticky mode), i.e. interactive and dismissible
+     * rather than tied to the pointer.
+     *
+     * @returns Promise resolving to true if the tooltip is pinned.
+     *
+     * @example
+     * ```typescript
+     * host.click();
+     * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+     * expect(await tooltip.isSticky()).toBe(true);
+     * ```
+     */
+    isSticky(): Promise<boolean>;
+    /**
+     * Gets the accessible name of the dismiss button, or null when the tooltip isn't pinned.
+     *
+     * @returns Promise resolving to the dismiss button's aria-label.
+     *
+     * @example
+     * ```typescript
+     * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+     * expect(await tooltip.getDismissLabel()).toBe('Close tooltip');
+     * ```
+     */
+    getDismissLabel(): Promise<string | null>;
+    /**
+     * Clicks the tooltip's dismiss button. Throws if the tooltip isn't pinned, since the button
+     * only exists in sticky mode.
+     *
+     * @returns Promise that resolves when the tooltip has been dismissed.
+     *
+     * @example
+     * ```typescript
+     * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+     * await tooltip.dismiss();
+     * ```
+     */
+    dismiss(): Promise<void>;
+    /**
+     * Clicks an element inside the tooltip's message — a link, typically. Only meaningful in
+     * sticky mode, where the tooltip stops being click-through.
+     *
+     * @param selector CSS selector of the element to click, relative to the message.
+     * @returns Promise that resolves when the click action is complete.
+     *
+     * @example
+     * ```typescript
+     * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+     * await tooltip.clickContent('a');
+     * ```
+     */
+    clickContent(selector: string): Promise<void>;
+}
+/**
+ * A set of criteria that can be used to filter a list of `TnTooltipHarness` instances.
+ */
+interface TooltipHarnessFilters extends BaseHarnessFilters {
+    /** Filters by the tooltip's text. Supports string or regex matching. */
+    text?: string | RegExp;
+    /** Filters by whether the tooltip is pinned open (sticky mode). */
+    sticky?: boolean;
+}
+
+/**
+ * Test utilities for working with `TnTooltipHarness`.
+ *
+ * Tooltips are portaled into the CDK overlay outside the component tree, so a regular
+ * `TestbedHarnessEnvironment.loader()` won't find them. Use `TnTooltipTesting.rootLoader()`
+ * to get a loader that can.
+ *
+ * @example
+ * ```typescript
+ * import { TnTooltipTesting, TnTooltipHarness } from '@truenas/ui-components';
+ *
+ * const rootLoader = TnTooltipTesting.rootLoader(fixture);
+ * const tooltip = await rootLoader.getHarness(TnTooltipHarness);
+ * ```
+ */
+declare class TnTooltipTesting {
+    /**
+     * Creates a `HarnessLoader` that searches the entire document, including the CDK overlays
+     * that tooltips are rendered into.
+     *
+     * @param fixture The component fixture for the test.
+     * @returns A `HarnessLoader` capable of finding tooltip harnesses.
+     */
+    static rootLoader(fixture: ComponentFixture<unknown>): HarnessLoader;
 }
 
 interface TnConfirmDialogData {
@@ -10234,7 +13125,56 @@ declare class TnDialog {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<TnDialog>;
 }
 
+/**
+ * Chrome copy `tn-dialog-shell` renders itself. These were baked into the template as English
+ * literals, which a consumer could not translate at all — there was no input to bind. Provide
+ * {@link TN_DIALOG_CHROME_LABELS} at the app root to wire them to an i18n service.
+ *
+ * "Chrome" rather than plain `TnDialogLabels` to keep this bundle a clear letter apart from
+ * {@link TN_DIALOG_SHELL_DEFAULT_LABEL}, which is a different thing entirely — the fallback
+ * accessible name for the dialog surface itself, not copy the header renders.
+ */
+interface TnDialogChromeLabels {
+    /** Accessible name for the header close (X) button. */
+    close: string;
+    /** Accessible name for the fullscreen toggle while the dialog is windowed. */
+    enterFullscreen: string;
+    /** Accessible name for the fullscreen toggle while the dialog is fullscreen. */
+    exitFullscreen: string;
+}
+/** English defaults used when no `TN_DIALOG_CHROME_LABELS` provider is registered. */
+declare const TN_DIALOG_DEFAULT_CHROME_LABELS: TnDialogChromeLabels;
+/**
+ * DI token for app-wide dialog chrome labels. Provide either a static object or a
+ * `Signal<TnDialogChromeLabels>` — the latter lets every dialog react to language changes when
+ * the consumer wires it up to an i18n service.
+ */
+declare const TN_DIALOG_CHROME_LABELS: InjectionToken<TnDialogChromeLabels | Signal<TnDialogChromeLabels>>;
+/**
+ * The accessible name a dialog falls back to when it renders no `title` and the
+ * caller named it through neither this component nor the `DialogConfig` (#219).
+ *
+ * `title` defaults to `''`, so the DEFAULT rendering of this component put an
+ * empty `<h2>` in the header and left the CDK container with no naming
+ * attribute at all — measured as `empty-heading` on the heading and
+ * `aria-dialog-name` on the dialog. A dialog with no name is announced as
+ * "dialog" and nothing else, which is the whole of what a screen-reader user is
+ * told about a surface that just took over the page and trapped their focus.
+ *
+ * "Dialog" is a poor name, and says almost exactly what the role already says.
+ * It is still better than the two alternatives: leaving the surface unnamed, or
+ * withholding `role="dialog"` until there is a name — the latter would move a
+ * listener into a focus trap with no announcement that anything had opened. So
+ * it is paired with the dev-mode warning `tnAccessibleName` raises, which is
+ * what keeps the fallback from becoming a quiet way to ship a nameless dialog.
+ *
+ * Exported so specs assert against it by name rather than by a copied literal.
+ */
+declare const TN_DIALOG_SHELL_DEFAULT_LABEL = "Dialog";
 declare class TnDialogShellComponent implements OnInit {
+    protected readonly labels: Signal<TnDialogChromeLabels>;
+    /** Accessible name for the fullscreen toggle, following its current state. */
+    protected readonly fullscreenLabel: Signal<string>;
     title: _angular_core.InputSignal<string>;
     showFullscreenButton: _angular_core.InputSignal<boolean>;
     /**
@@ -10260,6 +13200,22 @@ declare class TnDialogShellComponent implements OnInit {
      * provided (useful when more than one dialog can be open).
      */
     testId: _angular_core.InputSignal<TnTestIdValue>;
+    /**
+     * Accessible name for the dialog itself, for a dialog that renders no `title`.
+     *
+     * A `title` outranks it: the heading is what the user can see, and
+     * `aria-labelledby` wins the ARIA name calculation while it resolves. The
+     * attribute is still rendered beside the heading rather than suppressed — see
+     * `tnAccessibleName`, which owns that rule for every component in this
+     * library, and the reason it is safer than the alternative.
+     */
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * IDREF naming the dialog from text elsewhere on the page, for a dialog that
+     * renders no `title`. Same precedence: a `title` wins, because it is the
+     * visible heading.
+     */
+    ariaLabelledby: _angular_core.InputSignal<string | null>;
     /**
      * The `testId` base normalized to a flat segment array. Nothing is dropped
      * here — `composeTestId` (via the `[tnTestId]` directive) filters falsy
@@ -10276,9 +13232,9 @@ declare class TnDialogShellComponent implements OnInit {
      * close-button ids and lets automation target "all close buttons" with one
      * selector.
      */
-    protected closeTestId: _angular_core.Signal<(string | number | null | undefined)[]>;
+    protected closeTestId: Signal<(string | number | null | undefined)[]>;
     /** Role-first test-id segments for the fullscreen button: `button-fullscreen[-<base>]`. */
-    protected fullscreenTestId: _angular_core.Signal<(string | number | null | undefined)[]>;
+    protected fullscreenTestId: Signal<(string | number | null | undefined)[]>;
     /** Stable id for the title heading, referenced by the dialog's aria-labelledby. */
     readonly titleId: string;
     isFullscreen: _angular_core.WritableSignal<boolean>;
@@ -10287,14 +13243,52 @@ declare class TnDialogShellComponent implements OnInit {
     private document;
     private host;
     private data;
+    /**
+     * Whether there is a heading to render, and to name the dialog from.
+     *
+     * Trimmed, because a whitespace-only title renders a heading that looks empty
+     * to a sighted user and names the dialog with nothing — which is the state
+     * this ticket fixed, arriving by a second route.
+     */
+    protected hasTitle: Signal<boolean>;
+    /**
+     * What the dialog is named by, in the order ARIA resolves: the visible
+     * heading when there is one, then the caller's IDREF, then one passed to
+     * `TnDialog.open` in the `DialogConfig`.
+     *
+     * The config is consulted so that the fallback below cannot overwrite a name
+     * the opener supplied through CDK's own route. Reading it back through
+     * `ref.config` rather than leaving CDK's binding to render it, because this
+     * component writes both attributes onto that element and would otherwise
+     * clear one it did not set.
+     *
+     * Guarded, even though `DialogRef.config` is non-optional: a shell rendered
+     * directly in a consumer's test gets its `DialogRef` from a mock provider,
+     * which supplies the methods but no config. Naming then falls back to the
+     * component's own inputs, which is what such a test is exercising anyway.
+     */
+    private resolvedAriaLabelledby;
+    /** An explicit label, from this component's input or from the `DialogConfig`. */
+    private explicitAriaLabel;
+    /**
+     * The name to render as `aria-label`, or `null` to render none — and the
+     * dev-mode warning when the dialog has no name from any route.
+     *
+     * Both halves live in `../a11y/accessible-name`, shared with `tn-side-panel`,
+     * `tn-drawer` and the three progressbars, where the reasoning for each branch
+     * is set out. `title` reaches it as the `ariaLabelledby` above, so a titled
+     * dialog is named, takes no fallback and raises no warning.
+     */
+    private resolvedAriaLabel;
     constructor();
+    private applyName;
     ngOnInit(): void;
     close(result?: unknown): void;
     toggleFullscreen(): void;
     private enterFullscreen;
     private exitFullscreen;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnDialogShellComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDialogShellComponent, "tn-dialog-shell", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showFullscreenButton": { "alias": "showFullscreenButton"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "hideContent": { "alias": "hideContent"; "required": false; "isSignal": true; }; "hideActions": { "alias": "hideActions"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[tnDialogAction]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnDialogShellComponent, "tn-dialog-shell", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showFullscreenButton": { "alias": "showFullscreenButton"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "hideContent": { "alias": "hideContent"; "required": false; "isSignal": true; }; "hideActions": { "alias": "hideActions"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[tnDialogAction]"], true, never>;
 }
 
 /**
@@ -10346,7 +13340,9 @@ declare class TnDialogHarness extends ComponentHarness {
      */
     static with(options?: DialogHarnessFilters): HarnessPredicate<TnDialogHarness>;
     /**
-     * Gets the dialog's title text.
+     * Gets the dialog's title text, or `''` for a dialog opened with no title —
+     * which renders no heading at all (#219), and is named by `ariaLabel` or
+     * `ariaLabelledby` instead.
      *
      * @returns Promise resolving to the dialog title.
      *
@@ -10436,8 +13432,11 @@ declare class TnDialogHarness extends ComponentHarness {
      */
     toggleFullscreen(): Promise<void>;
     /**
-     * Whether the dialog is currently in fullscreen mode.
-     * Checks the aria-label of the fullscreen button.
+     * Whether the dialog is currently in fullscreen mode, read from the fullscreen toggle's
+     * `data-fullscreen`. Deliberately not derived from the button's `aria-label`: that label is
+     * app-configurable through `TN_DIALOG_CHROME_LABELS`, so matching display text would report
+     * `false` forever the moment a consumer translated the chrome — silently, in exactly the apps
+     * the token exists for. Same call `TnTableHarness.getCardSortDirection` makes.
      *
      * @returns Promise resolving to true if fullscreen, false if not or if no fullscreen button.
      */
@@ -10488,6 +13487,53 @@ declare class TnDialogTesting {
     static rootLoader(fixture: ComponentFixture<unknown>): HarnessLoader;
 }
 
+/**
+ * The accessible name an open panel falls back to when it has no `title` and the
+ * caller named neither `ariaLabel` nor `ariaLabelledby` (#214).
+ *
+ * `title` defaults to `''`, so the DEFAULT rendering of this component was a
+ * `role="dialog"` with `aria-labelledby` pointing at an empty `<h2>` — measured
+ * as an `aria-dialog-name` violation, alongside `empty-heading`. A dialog with no
+ * name is announced as "dialog" and nothing else, which is the whole of what a
+ * screen-reader user gets told about a surface that just covered the page.
+ *
+ * Withholding `role="dialog"` until there is a name would be the other way to
+ * clear the rule, and it is worse: the panel traps focus either way, so a
+ * listener would be moved into a region with no announcement that anything had
+ * opened. A generic name is still a poor one, so it is paired with the dev-mode
+ * warning `tnAccessibleName` raises.
+ *
+ * Exported so specs assert against it by name rather than by a copied literal.
+ */
+declare const TN_SIDE_PANEL_DEFAULT_LABEL = "Side panel";
+/**
+ * The name given to the scrolling content region once it becomes focusable
+ * (#248).
+ *
+ * A focusable element with no accessible name is announced as a bare "group",
+ * which tells a listener that something has been reached and nothing about what
+ * it is. It names the region rather than repeating the panel's own title: the
+ * dialog announces that on entry, so a second copy of it here would say the
+ * same words twice and still not distinguish the part that scrolls.
+ *
+ * Overridable through `contentAriaLabel`, on the same reasoning as
+ * `closeButtonAriaLabel` — a string this library renders into a consumer's UI
+ * has to be translatable. Exported so specs assert against it by name rather
+ * than by a copied literal.
+ */
+declare const TN_SIDE_PANEL_CONTENT_LABEL = "Panel content";
+/**
+ * How far the content has to exceed the region before the region counts as
+ * scrolling (#248).
+ *
+ * **This is now `TN_SCROLLABLE_REGION_TOLERANCE_PX`**, which is axe's own 13px
+ * buffer and lives with the measurement it belongs to (#270). The alias stays
+ * because it is what `side-panel-scrollable-content.spec.ts` pins against axe
+ * from both sides, and that spec is a guard on this component rather than on
+ * the helper — see `../a11y/scrollable-region.ts` for what the number is and
+ * why it is copied from the rule at all.
+ */
+declare const TN_SIDE_PANEL_OVERFLOW_TOLERANCE_PX = 13;
 /**
  * Directive to mark an element as a side-panel footer action.
  *
@@ -10517,12 +13563,49 @@ declare class TnSidePanelHeaderActionDirective {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnSidePanelHeaderActionDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TnSidePanelHeaderActionDirective, "[tnSidePanelHeaderAction]", never, {}, {}, never, never, true, never>;
 }
+/**
+ * A modal side panel: `role="dialog"` with `aria-modal="true"`, focus trapped
+ * while it is open and restored to the opener when it closes.
+ *
+ * FOCUS ON OPEN
+ * -------------
+ * Opening moves focus to the panel container, whatever you projected into it,
+ * so that a screen reader announces the dialog it has just entered before any
+ * control in it. The first Tab then reaches the close button.
+ *
+ * **`[cdkFocusInitial]` is not honoured** (#227). It used to be, through the
+ * CDK auto-capture this replaced, and `cdkTrapFocus` is still on the panel — so
+ * the marker looks like it should work and does not. To focus a control of your
+ * own, focus it yourself once the panel is open; the component leaves focus
+ * alone as soon as it is inside the panel. `lib/a11y/initial-focus.ts` holds
+ * the reasoning for capturing the container rather than a control.
+ */
 declare class TnSidePanelComponent implements OnDestroy {
     private iconRegistry;
     private document;
     private destroyRef;
     private overlayRef;
+    private panelRef;
+    private contentRef;
     protected initialized: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the content region carries the tab stop, its role and its name
+     * (#248) — which is NOT the same question as whether it currently overflows.
+     *
+     * The measurement, the two observers that keep it current and the focus rule
+     * that decides when the attributes may be taken off again are all
+     * `tnScrollableRegion`'s (#270); this component decides only what to put on
+     * the element, which is the part that differs between the five regions in
+     * this library that scroll. `../a11y/scrollable-region.ts` sets out why the
+     * answer is held true while the region has focus, and why `role` and
+     * `aria-label` are gated on the same signal as `tabindex` rather than left on.
+     *
+     * Read in `afterNextRender`, which is where the helper takes its first
+     * measurement — before the overlay is portaled to `<body>` below, which does
+     * not affect it: `.tn-side-panel__overlay` is `position: fixed; inset: 0`, so
+     * its size comes from the viewport rather than from its parent.
+     */
+    protected contentKeyboardReachable: _angular_core.Signal<boolean>;
     open: _angular_core.ModelSignal<boolean>;
     title: _angular_core.InputSignal<string>;
     width: _angular_core.InputSignal<string>;
@@ -10552,13 +13635,83 @@ declare class TnSidePanelComponent implements OnDestroy {
      * of context otherwise hears only "Dismiss".
      */
     closeButtonAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the scrolling content region, which is named only while
+     * it is focusable — see `TN_SIDE_PANEL_CONTENT_LABEL`. Override it to
+     * translate it, or to say what the region holds ("Dataset properties").
+     */
+    contentAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the panel itself, for a panel that renders no `title`.
+     *
+     * A `title` outranks it: the heading is what the user can see, and
+     * `aria-labelledby` wins the ARIA name calculation while it resolves. The
+     * attribute is still rendered beside the heading rather than suppressed — see
+     * `tnAccessibleName`, which owns that rule for every component in this
+     * library, and the reason it is safer than the alternative.
+     */
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * IDREF naming the panel from text elsewhere on the page, for a panel that
+     * renders no `title`. Same precedence: a `title` wins, because it is the
+     * visible heading.
+     */
+    ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /**
+     * Fires once the panel has finished opening.
+     *
+     * "Finished" means the open transition ended, OR that it was going to take
+     * longer than `TN_TRANSITION_FALLBACK_MS` to say so — which is what a user
+     * with `prefers-reduced-motion: reduce` gets, since this component's own
+     * stylesheet zeroes the duration for them and a transition that does not run
+     * fires no `transitionend` (#218). A consumer may assume the panel has
+     * reached its open state and that `open()` is true; it may NOT assume the
+     * animation is visually complete, because for that user there was none.
+     */
     opened: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Fires once the panel has finished closing. Same guarantee as `opened`, and
+     * the same caveat: it reports the state, not the animation.
+     *
+     * Focus restoration does NOT hang off this — it happens as soon as the panel
+     * closes (#214). See the effect in the constructor.
+     */
     closed: _angular_core.OutputEmitterRef<void>;
     private actionContent;
     protected hasActions: _angular_core.Signal<boolean>;
     readonly panelId: string;
     readonly titleId: string;
+    /**
+     * Whether there is a heading to render, and to name the dialog from.
+     *
+     * Trimmed, because a whitespace-only title renders a heading that looks empty
+     * to a sighted user and names the dialog with nothing — which is the state
+     * that failed `aria-dialog-name` before #214, arriving by a second route.
+     */
+    protected hasTitle: _angular_core.Signal<boolean>;
+    /**
+     * What the dialog is named by, in the order ARIA resolves: the visible heading
+     * when there is one, the caller's IDREF otherwise.
+     */
+    protected resolvedAriaLabelledby: _angular_core.Signal<string | null>;
+    /**
+     * The name to render as `aria-label`, or `null` to render none — and the
+     * dev-mode warning when the panel has no name from any route.
+     *
+     * Both halves live in `../a11y/accessible-name`, shared with the three
+     * progressbars, where the reasoning for each branch is set out. `title` reaches
+     * it as the `ariaLabelledby` above, so a titled panel is named, takes no
+     * fallback and raises no warning.
+     */
+    protected resolvedAriaLabel: _angular_core.Signal<string | null>;
     private previouslyFocusedElement;
+    /**
+     * Decides when an open or a close counts as finished, so that the outputs
+     * above fire exactly once per change whether or not a transition ran. A field
+     * initializer rather than the constructor, because it registers an `effect`
+     * and so needs an injection context.
+     */
+    private lifecycle;
     constructor();
     ngOnDestroy(): void;
     protected dismiss(): void;
@@ -10568,7 +13721,7 @@ declare class TnSidePanelComponent implements OnDestroy {
     private restoreFocus;
     private registerMdiIcons;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnSidePanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnSidePanelComponent, "tn-side-panel", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeGuard": { "alias": "closeGuard"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "closeButtonTestId": { "alias": "closeButtonTestId"; "required": false; "isSignal": true; }; "closeButtonAriaLabel": { "alias": "closeButtonAriaLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "opened": "opened"; "closed": "closed"; }, ["actionContent"], ["[tnSidePanelHeaderAction]", "*", "[tnSidePanelAction]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnSidePanelComponent, "tn-side-panel", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeGuard": { "alias": "closeGuard"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "closeButtonTestId": { "alias": "closeButtonTestId"; "required": false; "isSignal": true; }; "closeButtonAriaLabel": { "alias": "closeButtonAriaLabel"; "required": false; "isSignal": true; }; "contentAriaLabel": { "alias": "contentAriaLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "opened": "opened"; "closed": "closed"; }, ["actionContent"], ["[tnSidePanelHeaderAction]", "*", "[tnSidePanelAction]"], true, never>;
 }
 
 interface SidePanelHarnessFilters extends BaseHarnessFilters {
@@ -10594,7 +13747,17 @@ declare class TnSidePanelHarness extends ComponentHarness {
      * Uses the data-tn-panel attribute to correlate the host with its overlay.
      */
     private getOverlay;
-    /** Get the panel title text. */
+    /**
+     * Get the panel title text, or `''` for a panel that renders no title.
+     *
+     * `locatorForOptional`, not `locatorFor`: since #214 a panel with no `title`
+     * renders no heading element at all — an `<h2>` with nothing in it is an
+     * `empty-heading` violation — and `locatorFor` throws on a selector that
+     * matches nothing. That would turn `getTitle()` into an error rather than an
+     * empty string, and would make `TnSidePanelHarness.with({title})` REJECT on an
+     * untitled panel instead of simply not matching it, so a filter aimed at one
+     * panel would fail on the presence of another.
+     */
     getTitle(): Promise<string>;
     /** Whether the panel is currently open. */
     isOpen(): Promise<boolean>;
@@ -10618,6 +13781,17 @@ declare class TnStepComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnStepComponent, "tn-step", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+/**
+ * Screen-reader text for a step whose header shows the error glyph.
+ *
+ * Exported so specs assert by name rather than by a copied literal, the same
+ * reason `TN_SPINNER_DEFAULT_LABEL` is. It is not an override point — nothing
+ * reads a token or an input in its place, so a consumer cannot change what the
+ * stepper says here.
+ */
+declare const TN_STEPPER_STATUS_ERROR = "Error";
+/** Screen-reader text for a step whose header shows the completed state. */
+declare const TN_STEPPER_STATUS_COMPLETED = "Completed";
 declare class TnStepperComponent {
     orientation: _angular_core.InputSignal<"auto" | "horizontal" | "vertical">;
     linear: _angular_core.InputSignal<boolean>;
@@ -10645,6 +13819,7 @@ declare class TnStepperComponent {
     isVertical: _angular_core.Signal<boolean>;
     readonly stepEditable: _angular_core.Signal<boolean[]>;
     readonly stepGated: _angular_core.Signal<boolean[]>;
+    readonly stepStatusText: _angular_core.Signal<(string | null)[]>;
     selectStep(index: number): void;
     canSelectStep(index: number): boolean;
     next(): void;
@@ -11569,7 +14744,11 @@ declare enum TnToastPosition {
     Bottom = "bottom"
 }
 interface TnToastConfig {
-    /** Auto-dismiss duration in milliseconds. Default: 4000. Set to 0 to disable. */
+    /**
+     * How long the toast stays on screen, in milliseconds, counted from when it
+     * appears rather than from the `open()` call. Default: 4000. Set to 0 to
+     * disable auto-dismissal.
+     */
     duration?: number;
     /** Visual style of the toast. Default: TnToastType.Info. */
     type?: TnToastType;
@@ -11591,12 +14770,46 @@ declare class TnToastComponent {
     position: _angular_core.WritableSignal<TnToastPosition>;
     visible: _angular_core.WritableSignal<boolean>;
     icon: _angular_core.Signal<string>;
+    /**
+     * The live-region role, which is also the only thing declaring how urgently the
+     * toast is announced: `alert` implies `aria-live="assertive"` and `status`
+     * implies `polite`.
+     *
+     * The template carried `role="alert"` and `aria-live="polite"` together (#190).
+     * An explicit `aria-live` overrides the role's implicit one, so every toast was
+     * announced politely — including `error`, the one type that needs to interrupt.
+     * Deriving the role from the type and leaving `aria-live` off keeps a single
+     * source: there is no second attribute left to disagree with this one.
+     *
+     * WHICH types get `alert` is shared with banner rather than decided here
+     * (#194): #190 mapped `warning` to `status` while banner mapped it to
+     * `alert`, and `../a11y/live-region.ts` is now the one place that answers it.
+     */
+    role: _angular_core.Signal<"alert" | "status">;
     onAction: () => void;
     onDismiss: () => void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnToastComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnToastComponent, "tn-toast", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * How long the live region is left attached and empty before the message is
+ * written into it, in milliseconds.
+ *
+ * WHY A TIMER AND NOT THE ANIMATION FRAME THE TRANSITION RIDES
+ * -----------------------------------------------------------
+ * A `requestAnimationFrame` callback runs BEFORE that frame's style, layout and
+ * accessibility-tree update. Attaching the region in one task and populating it
+ * from the next frame's callback therefore commits both mutations in a single
+ * accessibility-tree update — which is the already-populated insertion this
+ * deferral exists to avoid, still there and harder to see. The region needs a
+ * rendering pass of its own, which means yielding past one.
+ *
+ * 100ms is what `@angular/cdk`'s `LiveAnnouncer` waits before writing into its
+ * own region — a dependency of this project already, and the closest thing to a
+ * measured number available.
+ */
+declare const TN_TOAST_ANNOUNCE_DELAY_MS = 100;
 declare class TnToastRef {
     private readonly _onAction;
     private readonly _afterDismissed;
@@ -11619,6 +14832,12 @@ declare class TnToastService {
     /**
      * Opens a toast notification.
      *
+     * The toast is attached synchronously, but its message and its enter
+     * transition both land `TN_TOAST_ANNOUNCE_DELAY_MS` later — the delay is what
+     * makes the text a *change* to a live region a screen reader is already
+     * watching. A test reading `.tn-toast__message` must let that elapse; one
+     * asserting on the call rather than the DOM should use `TnToastMock`.
+     *
      * @param message The message to display.
      * @param actionOrConfig Optional action button text, or config object.
      * @param config Optional config when action is provided as second arg.
@@ -12001,5 +15220,5 @@ declare const TN_THEME_DEFINITIONS: readonly TnThemeDefinition[];
  */
 declare const THEME_MAP: Map<TnTheme, TnThemeDefinition>;
 
-export { CommonShortcuts, DEFAULT_THEME, DiskIconComponent, DiskType, FileSizePipe, InputType, LIGHT_THEME, LabelMarkupPipe, LabelTextPipe, LinuxModifierKeys, LinuxShortcuts, ModifierKeys, QuickShortcuts, ShortcutBuilder, THEME_MAP, THEME_STORAGE_KEY, TN_CALENDAR_INTL, TN_CALENDAR_INTL_DEFAULTS, TN_FORM_FIELD_CONTEXT, TN_FORM_FIELD_ERRORS, TN_RADIO_GROUP, TN_TABLE_PAGER_DEFAULT_LABELS, TN_TABLE_PAGER_LABELS, TN_TEST_ATTR, TN_THEME_DEFINITIONS, TnAutocompleteComponent, TnAutocompleteHarness, TnBannerActionDirective, TnBannerComponent, TnBannerHarness, TnBrandedSpinnerComponent, TnButtonComponent, TnButtonHarness, TnButtonToggleComponent, TnButtonToggleGroupComponent, TnButtonToggleGroupHarness, TnButtonToggleHarness, TnCalendarCellHarness, TnCalendarComponent, TnCalendarHarness, TnCalendarHeaderComponent, TnCardComponent, TnCardFooterActionsDirective, TnCardHeaderActionsDirective, TnCardHeaderDirective, TnCellDefDirective, TnCheckboxComponent, TnCheckboxHarness, TnCheckboxLabelDirective, TnChipComponent, TnChipHarness, TnChipInputComponent, TnChipInputHarness, TnConfirmDialogComponent, TnDateInputComponent, TnDateInputHarness, TnDateRangeInputComponent, TnDateRangeInputHarness, TnDetailRowDefDirective, TnDialog, TnDialogHarness, TnDialogShellComponent, TnDialogTesting, TnDividerComponent, TnDividerDirective, TnDrawerComponent, TnDrawerContainerComponent, TnDrawerContainerHarness, TnDrawerContentComponent, TnDrawerHarness, TnEmptyComponent, TnEmptyHarness, TnExpansionPanelComponent, TnExpansionPanelHarness, TnFileInputComponent, TnFileInputHarness, TnFilePickerComponent, TnFilePickerHarness, TnFilePickerPopupComponent, TnFormFieldComponent, TnFormFieldHarness, TnFormSectionComponent, TnFormSectionHarness, TnHeaderCellDefDirective, TnIconButtonComponent, TnIconButtonHarness, TnIconComponent, TnIconHarness, TnIconRegistryService, TnIconTesting, TnInputComponent, TnInputDirective, TnInputHarness, TnKeyboardShortcutComponent, TnKeyboardShortcutService, TnListAvatarDirective, TnListComponent, TnListIconDirective, TnListItemComponent, TnListItemLineDirective, TnListItemPrimaryDirective, TnListItemSecondaryDirective, TnListItemTitleDirective, TnListItemTrailingDirective, TnListOptionComponent, TnListSubheaderComponent, TnMenuActivateHoverDirective, TnMenuComponent, TnMenuHarness, TnMenuItemComponent, TnMenuTesting, TnMenuTriggerDirective, TnMonthViewComponent, TnMultiYearViewComponent, TnNestedTreeDataSource, TnNestedTreeNodeComponent, TnParticleProgressBarComponent, TnProgressBarComponent, TnRadioComponent, TnRadioGroupComponent, TnRadioGroupHarness, TnRadioHarness, TnRowActionsDefDirective, TnSelectComponent, TnSelectHarness, TnSelectionListComponent, TnSidePanelActionDirective, TnSidePanelComponent, TnSidePanelHarness, TnSidePanelHeaderActionDirective, TnSlideToggleComponent, TnSlideToggleHarness, TnSliderComponent, TnSliderThumbDirective, TnSliderWithLabelDirective, TnSpinnerComponent, TnSpriteLoaderService, TnStepComponent, TnStepperComponent, TnStepperHarness, TnStepperNextDirective, TnStepperPreviousDirective, TnTabComponent, TnTabHarness, TnTabPanelComponent, TnTabPanelHarness, TnTableColumnDirective, TnTableComponent, TnTableHarness, TnTablePagerComponent, TnTablePagerHarness, TnTableTesting, TnTabsComponent, TnTabsHarness, TnTestIdDirective, TnTheme, TnThemeService, TnTimeInputComponent, TnToastComponent, TnToastMock, TnToastPosition, TnToastRef, TnToastService, TnToastTesting, TnToastType, TnTooltipComponent, TnTooltipDirective, TnTreeComponent, TnTreeFlatDataSource, TnTreeFlattener, TnTreeHarness, TnTreeNodeComponent, TnTreeNodeHarness, TnTreeNodeOutletDirective, TnTreeVirtualScrollNodeOutletDirective, TnTreeVirtualScrollViewComponent, TnTreeVirtualScrollViewHarness, TruncatePathPipe, WindowsModifierKeys, WindowsShortcuts, allowsCurrentDirectorySelection, composeTestId, controlTestId, createFlatTreeControl, createLucideLibrary, createNestedTreeControl, createShortcut, defaultSpriteBasePath, defaultSpriteConfigPath, defaultTreeItemSize, formatSize, getSelectableTypes, injectTnCalendarIntl, injectTnFormFieldAria, isPathWithinRoot, kebabTestSegment, labelMarkupToHtml, labelMarkupToText, libIconMarker, normalizeRootPath, optionTestId, parseLabelMarkup, parseSize, registerLucideIcons, scopeTestId, setupLucideIntegration, tnIconMarker, writeTestId };
-export type { AutocompleteHarnessFilters, BannerHarnessFilters, ButtonHarnessFilters, ButtonToggleHarnessFilters, CalendarCell, CalendarCellFill, CalendarCellHarnessFilters, CalendarHarnessFilters, CheckboxHarnessFilters, ChipColor, ChipHarnessFilters, DateInputHarnessFilters, DateRange, DateRangeInputHarnessFilters, DialogHarnessFilters, EmptyHarnessFilters, ExpansionPanelHarnessFilters, FileInputHarnessFilters, FilePickerCallbacks, FilePickerCreateAction, FilePickerCreateActionEvent, FilePickerError, FilePickerHarnessFilters, FilePickerMode, FileSystemItem, FileSystemItemType, FlatTreeControlOptions, FormFieldHarnessFilters, FormSectionHarnessFilters, IconButtonHarnessFilters, IconHarnessFilters, IconLibrary, IconLibraryType, IconResult, IconSize, IconSource, IconTestingMockOverrides, InputHarnessFilters, KeyCombination, LabelMarkupSegment, LabelMarkupSegmentType, LabelType, LucideIconOptions, MenuHarnessFilters, MockIconRegistry, MockSpriteLoader, NestedTreeControlOptions, PathSegment, PlatformType, ProgressBarMode, RadioGroupHarnessFilters, RadioHarnessFilters, ResolvedIcon, SelectHarnessFilters, ShortcutHandler, SidePanelHarnessFilters, SizeStandard, SlideToggleColor, SlideToggleHarnessFilters, SpinnerMode, SpriteConfig, StepperHarnessFilters, SubscriptSizing, TabChangeEvent, TabHarnessFilters, TabPanelHarnessFilters, TabsHarnessFilters, TnAutocompleteOption, TnBannerType, TnButtonToggleType, TnCalendarIntl, TnCalendarIntlInput, TnCalendarView, TnCardAction, TnCardControl, TnCardFooterLink, TnCardHeaderStatus, TnChipInputHarnessFilters, TnChipInputOption, TnConfirmDialogData, TnDialogDefaults, TnDialogOpenTarget, TnDrawerMode, TnDrawerPosition, TnEmptySize, TnFlatTreeNode, TnFormFieldAriaBindings, TnFormFieldContext, TnFormFieldErrorMessage, TnFormFieldErrorMessages, TnFormFieldErrorResolver, TnMenuItem, TnOptionTestIdSource, TnRadioGroupApi, TnRadioOption, TnSelectOption, TnSelectOptionGroup, TnSelectionChange, TnSortEvent, TnTableDataProvider, TnTableDataSource, TnTableHarnessFilters, TnTableMobileLayout, TnTablePagerHarnessFilters, TnTablePagerLabels, TnTablePagination, TnTestAttrName, TnTestIdValue, TnThemeDefinition, TnToastCall, TnToastConfig, TnTreeExpansion, TnTreeHarnessFilters, TnTreeNodeHarnessFilters, TnTreeVirtualNodeData, TnTreeVirtualScrollViewHarnessFilters, TooltipPosition, YearCell };
+export { CommonShortcuts, DEFAULT_THEME, DiskIconComponent, DiskType, FileSizePipe, InputType, LIGHT_THEME, LabelMarkupPipe, LabelTextPipe, LinuxModifierKeys, LinuxShortcuts, ModifierKeys, QuickShortcuts, ShortcutBuilder, THEME_MAP, THEME_STORAGE_KEY, TN_AUTOCOMPLETE_DEFAULT_LABELS, TN_AUTOCOMPLETE_LABELS, TN_BRANDED_SPINNER_DEFAULT_LABEL, TN_CALENDAR_INTL, TN_CALENDAR_INTL_DEFAULTS, TN_DIALOG_CHROME_LABELS, TN_DIALOG_DEFAULT_CHROME_LABELS, TN_DIALOG_SHELL_DEFAULT_LABEL, TN_DRAWER_CONTENT_LABEL, TN_DRAWER_DEFAULT_LABEL, TN_FORM_FIELD_CONTEXT, TN_FORM_FIELD_DISMISSIBLE_ERRORS, TN_FORM_FIELD_ERRORS, TN_FORM_LIST_CONTEXT, TN_PARTICLE_PROGRESS_BAR_DEFAULT_LABEL, TN_PROGRESS_BAR_DEFAULT_LABEL, TN_RADIO_GROUP, TN_SELECT_DEFAULT_LABELS, TN_SELECT_LABELS, TN_SIDE_PANEL_CONTENT_LABEL, TN_SIDE_PANEL_DEFAULT_LABEL, TN_SIDE_PANEL_OVERFLOW_TOLERANCE_PX, TN_SPINNER_DEFAULT_LABEL, TN_STEPPER_STATUS_COMPLETED, TN_STEPPER_STATUS_ERROR, TN_TABLE_DEFAULT_LABELS, TN_TABLE_LABELS, TN_TABLE_PAGER_DEFAULT_LABELS, TN_TABLE_PAGER_LABELS, TN_TABLE_SCROLL_REGION_LABEL, TN_TAB_PANEL_CONTENT_LABEL, TN_TEST_ATTR, TN_THEME_DEFINITIONS, TN_TOAST_ANNOUNCE_DELAY_MS, TnAutocompleteComponent, TnAutocompleteHarness, TnBannerActionDirective, TnBannerActionHarness, TnBannerComponent, TnBannerHarness, TnBrandedSpinnerComponent, TnButtonComponent, TnButtonHarness, TnButtonToggleComponent, TnButtonToggleGroupComponent, TnButtonToggleGroupHarness, TnButtonToggleHarness, TnCalendarCellHarness, TnCalendarComponent, TnCalendarHarness, TnCalendarHeaderComponent, TnCardComponent, TnCardFooterActionsDirective, TnCardHeaderActionsDirective, TnCardHeaderDirective, TnCellDefDirective, TnCheckboxComponent, TnCheckboxHarness, TnCheckboxLabelDirective, TnChipComponent, TnChipHarness, TnChipInputComponent, TnChipInputHarness, TnConfirmDialogComponent, TnDateInputComponent, TnDateInputHarness, TnDateRangeInputComponent, TnDateRangeInputHarness, TnDetailRowDefDirective, TnDialog, TnDialogHarness, TnDialogShellComponent, TnDialogTesting, TnDividerComponent, TnDividerDirective, TnDrawerComponent, TnDrawerContainerComponent, TnDrawerContainerHarness, TnDrawerContentComponent, TnDrawerHarness, TnEmptyComponent, TnEmptyHarness, TnExpansionPanelComponent, TnExpansionPanelHarness, TnFileInputComponent, TnFileInputHarness, TnFilePickerComponent, TnFilePickerHarness, TnFilePickerPopupComponent, TnFormErrorsComponent, TnFormErrorsHarness, TnFormFieldComponent, TnFormFieldHarness, TnFormListComponent, TnFormListHarness, TnFormListItemComponent, TnFormListItemHarness, TnFormSectionComponent, TnFormSectionHarness, TnHeaderCellDefDirective, TnIconButtonComponent, TnIconButtonHarness, TnIconComponent, TnIconHarness, TnIconRegistryService, TnIconTesting, TnInputComponent, TnInputDirective, TnInputHarness, TnKeyboardShortcutComponent, TnKeyboardShortcutService, TnListAvatarDirective, TnListComponent, TnListIconDirective, TnListItemComponent, TnListItemLineDirective, TnListItemPrimaryDirective, TnListItemSecondaryDirective, TnListItemTitleDirective, TnListItemTrailingDirective, TnListOptionComponent, TnListSubheaderComponent, TnMenuActivateHoverDirective, TnMenuComponent, TnMenuHarness, TnMenuItemComponent, TnMenuTesting, TnMenuTriggerDirective, TnMonthViewComponent, TnMultiYearViewComponent, TnNestedTreeDataSource, TnNestedTreeNodeComponent, TnParticleProgressBarComponent, TnProgressBarComponent, TnRadioComponent, TnRadioGroupComponent, TnRadioGroupHarness, TnRadioHarness, TnRowActionsDefDirective, TnSelectComponent, TnSelectHarness, TnSelectionListComponent, TnSidePanelActionDirective, TnSidePanelComponent, TnSidePanelHarness, TnSidePanelHeaderActionDirective, TnSlideToggleComponent, TnSlideToggleHarness, TnSliderComponent, TnSliderThumbDirective, TnSliderWithLabelDirective, TnSpinnerComponent, TnSpriteLoaderService, TnStepComponent, TnStepperComponent, TnStepperHarness, TnStepperNextDirective, TnStepperPreviousDirective, TnTabComponent, TnTabHarness, TnTabPanelComponent, TnTabPanelHarness, TnTableColumnDirective, TnTableComponent, TnTableHarness, TnTablePagerComponent, TnTablePagerHarness, TnTableTesting, TnTabsComponent, TnTabsHarness, TnTestIdDirective, TnTheme, TnThemeService, TnTimeInputComponent, TnToastComponent, TnToastMock, TnToastPosition, TnToastRef, TnToastService, TnToastTesting, TnToastType, TnTooltipComponent, TnTooltipDirective, TnTooltipHarness, TnTooltipTesting, TnTreeComponent, TnTreeFlatDataSource, TnTreeFlattener, TnTreeHarness, TnTreeNodeComponent, TnTreeNodeHarness, TnTreeNodeOutletDirective, TnTreeVirtualScrollNodeOutletDirective, TnTreeVirtualScrollViewComponent, TnTreeVirtualScrollViewHarness, TruncatePathPipe, WindowsModifierKeys, WindowsShortcuts, allowsCurrentDirectorySelection, canonicalizeSize, composeTestId, controlTestId, createFlatTreeControl, createLucideLibrary, createNestedTreeControl, createShortcut, defaultSpriteBasePath, defaultSpriteConfigPath, defaultTreeItemSize, formatSize, formatSizeExact, formatSizeForEditing, getSelectableTypes, injectTnCalendarIntl, injectTnFormFieldAria, injectTnLabels, isPathWithinRoot, kebabTestSegment, labelMarkupToHtml, labelMarkupToText, libIconMarker, normalizeRootPath, optionTestId, parseLabelMarkup, parseSize, parseSizeParts, registerLucideIcons, resolveErrorMessage, scopeTestId, setupLucideIntegration, tnIconMarker, writeTestId };
+export type { AutocompleteHarnessFilters, BannerActionHarnessFilters, BannerHarnessFilters, ButtonHarnessFilters, ButtonToggleHarnessFilters, CalendarCell, CalendarCellFill, CalendarCellHarnessFilters, CalendarHarnessFilters, CheckboxHarnessFilters, ChipColor, ChipHarnessFilters, DateInputHarnessFilters, DateRange, DateRangeInputHarnessFilters, DialogHarnessFilters, EmptyHarnessFilters, ExpansionPanelHarnessFilters, FileInputHarnessFilters, FilePickerCallbacks, FilePickerCreateAction, FilePickerCreateActionEvent, FilePickerError, FilePickerHarnessFilters, FilePickerMode, FileSystemItem, FileSystemItemType, FlatTreeControlOptions, FormFieldHarnessFilters, FormSectionHarnessFilters, IconButtonHarnessFilters, IconHarnessFilters, IconLibrary, IconLibraryType, IconResult, IconSize, IconSource, IconTestingMockOverrides, InputHarnessFilters, KeyCombination, LabelMarkupSegment, LabelMarkupSegmentType, LabelType, LucideIconOptions, MenuHarnessFilters, MockIconRegistry, MockSpriteLoader, NestedTreeControlOptions, ParsedSize, PathSegment, PlatformType, ProgressBarMode, RadioGroupHarnessFilters, RadioHarnessFilters, ResolveErrorMessageOptions, ResolvedIcon, SelectHarnessFilters, ShortcutHandler, SidePanelHarnessFilters, SizeStandard, SlideToggleColor, SlideToggleHarnessFilters, SpinnerMode, SpriteConfig, StepperHarnessFilters, SubscriptSizing, TabChangeEvent, TabHarnessFilters, TabPanelHarnessFilters, TabsHarnessFilters, TnAutocompleteLabels, TnAutocompleteOption, TnBannerType, TnButtonToggleType, TnCalendarIntl, TnCalendarIntlInput, TnCalendarView, TnCardAction, TnCardControl, TnCardFooterLink, TnCardHeaderStatus, TnChipInputHarnessFilters, TnChipInputOption, TnConfirmDialogData, TnDialogChromeLabels, TnDialogDefaults, TnDialogOpenTarget, TnDrawerMode, TnDrawerPosition, TnEmptySize, TnFlatTreeNode, TnFormErrorsHarnessFilters, TnFormFieldAriaBindings, TnFormFieldContext, TnFormFieldErrorMessage, TnFormFieldErrorMessages, TnFormFieldErrorResolver, TnFormListContext, TnFormListHarnessFilters, TnFormListItemHarnessFilters, TnMenuItem, TnOptionTestIdSource, TnRadioGroupApi, TnRadioOption, TnSelectLabels, TnSelectOption, TnSelectOptionGroup, TnSelectionChange, TnSortEvent, TnTableDataProvider, TnTableDataSource, TnTableHarnessFilters, TnTableLabels, TnTableMobileLayout, TnTablePagerHarnessFilters, TnTablePagerLabels, TnTablePagination, TnTestAttrName, TnTestIdValue, TnThemeDefinition, TnToastCall, TnToastConfig, TnTreeExpansion, TnTreeHarnessFilters, TnTreeNodeHarnessFilters, TnTreeVirtualNodeData, TnTreeVirtualScrollViewHarnessFilters, TooltipHarnessFilters, TooltipPosition, YearCell };