ngwr 13.0.1 → 14.0.1

package/types/ngwr-dropdown.d.ts

@@ -80,14 +80,30 @@ declare class WrDropdown {
     private readonly destroyRef;
     /** @internal Public so host bindings can read it. */
     readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** The id used only when the consumer's element carries none of its own. */
+    private readonly fallbackId;
     /**
      * Id the menu names itself after. The trigger is the CONSUMER's own element, so
      * an `id` they already put there wins: overwriting it broke `<label for>`,
      * `document.getElementById` and any `aria-labelledby` aimed at that button from
      * elsewhere in their app. The generated one is only a fallback so the menu has
      * something to reference.
+     *
+     * A GETTER, read fresh by the host binding on every pass, rather than a field
+     * resolved in the constructor. A static `id="…"` is on the element before a
+     * directive is instantiated and so was already honoured; a BOUND `[id]` is
+     * not — it lands with the rest of the template's bindings, which run before
+     * host bindings but after construction, so the constructor read an empty
+     * string, fell through to the fallback, and the host binding then wrote that
+     * fallback over the value the template had just set. Everything bound was
+     * lost — `[id]`, `[attr.id]` and an interpolated `id="dd-{{ n }}"` alike —
+     * while the static form survived, which is the shape that makes it look like
+     * a naming convention rather than a defect.
+     *
+     * `.id` rather than `getAttribute`: it is always a string, and an empty one is
+     * no id at all, so it falls through to the fallback.
      */
-    protected readonly triggerId: string;
+    protected get triggerId(): string;
     private overlayRef;
     constructor();
     /** Open the menu. */
@@ -120,7 +136,7 @@ declare class WrDropdown {
     private focusItemAt;
     private readonly onOverlayMouseLeave;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDropdown, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrDropdown, "[wrDropdown]", never, { "menu": { "alias": "wrDropdown"; "required": true; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrDropdown, "[wrDropdown]", ["wrDropdown"], { "menu": { "alias": "wrDropdown"; "required": true; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
 }
 
 /**

package/types/ngwr-event-calendar-testing.d.ts

@@ -8,6 +8,13 @@ import { WrCalendarView } from 'ngwr/event-calendar';
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 
+/**
+ * An arrow key, by the direction a user would say out loud — the parameter type
+ * shared by `WrEventCalendarHarness.pressArrow` and the chip harness's `move`,
+ * `resize` and `pressArrow`, exported so a consumer's own test helper can name
+ * what it forwards.
+ */
+type WrEventCalendarArrowKey = 'left' | 'right' | 'up' | 'down';
 /** Narrows which `<wr-event-calendar>` a harness query matches. */
 interface WrEventCalendarHarnessFilters extends BaseHarnessFilters {
     /** Match the header title as printed — a string is an exact match, a RegExp is tested. */
@@ -35,8 +42,6 @@ interface WrEventCalendarChipHarnessFilters extends BaseHarnessFilters {
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 
-/** The arrow keys, by the direction a user would say out loud. */
-type Arrow$1 = 'left' | 'right' | 'up' | 'down';
 /**
  * Test harness for one event chip inside a {@link WrEventCalendarHarness}.
  *
@@ -122,16 +127,16 @@ declare class WrEventCalendarChipHarness extends ComponentHarness {
      * calendar without `editable` ignores the keys entirely — the same gate the pointer
      * path uses.
      */
-    move(arrow: Arrow$1): Promise<void>;
+    move(arrow: WrEventCalendarArrowKey): Promise<void>;
     /**
      * Resize the event — `Alt` + `Shift` + an arrow, which moves the END alone.
      *
      * A resize that would end at or before the start emits nothing rather than
      * inverting the event, which is the pointer path's rule too.
      */
-    resize(arrow: Arrow$1): Promise<void>;
+    resize(arrow: WrEventCalendarArrowKey): Promise<void>;
     /** Press a bare arrow — which the chip ignores, letting the grid's own navigation run. */
-    pressArrow(arrow: Arrow$1): Promise<void>;
+    pressArrow(arrow: WrEventCalendarArrowKey): Promise<void>;
     /** Press Escape — handing focus back to the cell the chip sits in. */
     sendEscape(): Promise<void>;
 }
@@ -143,8 +148,6 @@ declare class WrEventCalendarChipHarness extends ComponentHarness {
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 
-/** The arrow keys, by the direction a user would say out loud. */
-type Arrow = 'left' | 'right' | 'up' | 'down';
 /**
  * Test harness for `<wr-event-calendar>` — month, week and day in one component.
  *
@@ -279,7 +282,7 @@ declare class WrEventCalendarHarness extends ComponentHarness {
      * — the element carrying the keyboard should be the one that holds focus — and
      * anything originating inside a chip is deliberately let through untouched.
      */
-    pressArrow(arrow: Arrow): Promise<void>;
+    pressArrow(arrow: WrEventCalendarArrowKey): Promise<void>;
     /** Press Home on the cursor cell — the first day of its week. */
     pressHome(): Promise<void>;
     /** Press End on the cursor cell — the last day of its week. */
@@ -298,4 +301,4 @@ declare class WrEventCalendarHarness extends ComponentHarness {
 }
 
 export { WrEventCalendarChipHarness, WrEventCalendarHarness };
-export type { WrEventCalendarChipHarnessFilters, WrEventCalendarHarnessFilters };
+export type { WrEventCalendarArrowKey, WrEventCalendarChipHarnessFilters, WrEventCalendarHarnessFilters };

package/types/ngwr-file-upload.d.ts

@@ -17,8 +17,6 @@ interface WrFileUploadRejection {
     readonly reason: WrFileUploadRejectionReason;
 }
 
-/** Human-readable byte size (e.g. `1.2 MB`). */
-declare function formatBytes(bytes: number): string;
 /**
  * Drag-and-drop file upload zone. Click to browse, drag-and-drop to add,
  * with an optional file list + remove buttons.
@@ -101,7 +99,37 @@ declare class WrFileUpload implements FormValueControl<File | readonly File[] |
     protected readonly files: _angular_core.WritableSignal<readonly File[]>;
     protected readonly dragging: _angular_core.WritableSignal<boolean>;
     protected readonly classes: _angular_core.Signal<string>;
-    protected readonly formatBytes: typeof formatBytes;
+    /**
+     * Human-readable file size (e.g. `1.2 MB`).
+     *
+     * Every piece of this used to be English and unreachable: a module-level unit
+     * table with no catalog key, and `toFixed()`, which writes an ASCII decimal
+     * point whatever `LOCALE_ID` says. A Russian page showed translated drop-zone
+     * copy above `3.4 KB`. The number now goes through `Intl.NumberFormat` and the
+     * unit through the catalog, joined by a template the catalog also owns — so a
+     * locale controls the separator, the digits and whether a space sits before
+     * the unit.
+     *
+     * Not a `computed`: it is called per file, with the file's size as its
+     * argument. It still re-runs on a locale switch, because the formatters it
+     * calls are signals read during the same change detection that renders the row.
+     */
+    protected formatBytes(bytes: number): string;
+    /** `{{value}} {{unit}}` — the join, so a locale owns the space too. */
+    private readonly sizeText;
+    /**
+     * One resolved signal per binary unit, indexed by the power of 1024 the
+     * arithmetic lands on.
+     *
+     * Spelled out rather than built from a key list: `i18n.spec.ts` reads every
+     * catalog key the library asks for out of the SOURCE, by matching a quoted
+     * dotted string inside the call, so a key built by interpolation is invisible
+     * to it. That spec fails rather than passing quietly, but either way the key
+     * would stop being checked.
+     */
+    private readonly unitTexts;
+    private readonly locale;
+    private number;
     constructor();
     protected openPicker(): void;
     protected onZoneKey(event: KeyboardEvent): void;

package/types/ngwr-form-testing.d.ts

@@ -169,8 +169,9 @@ declare class WrFormFieldHarness extends ContentContainerComponentHarness {
      *
      * `null` does not mean the consumer set no hint: the error block takes the
      * hint's slot outright, so a field with a visible message has no hint in the DOM
-     * at all. Note also that the hint carries no id and is NOT referenced by the
-     * control's `aria-describedby` — see {@link getAnnouncedDescription}.
+     * at all — which is also why the hint's id stops being published at the same
+     * moment. Whether the CONTROL announces it is a separate question, and one this
+     * harness answers through {@link getAnnouncedDescription}.
      */
     getHint(): Promise<string | null>;
     /**
@@ -243,11 +244,16 @@ declare class WrFormFieldHarness extends ContentContainerComponentHarness {
     /**
      * The ids the projected control names in `aria-describedby`, in order.
      *
-     * The field points this at the error block and nothing else — the hint has no
-     * id — so an empty list while a hint is showing is correct rather than a bug.
-     * That is not an oversight to fix from a harness either: `[wrInput]` derives
-     * `aria-invalid` from the same signal, so describing the hint would announce
-     * every hinted field as invalid.
+     * Which id that is depends on the CONTROL, not on the field, and the answer is
+     * worth knowing before reading a result. A control that composes the pair with
+     * `useFormFieldAria()` names the error block while one is showing and the hint
+     * otherwise. A control that reads the field's `describedBy` on its own — the
+     * `[wrInput]` directive, `wr-segmented` and `wr-slider` — names the error block
+     * and nothing else, so an empty list beside a visible hint is that control's
+     * answer rather than a broken field.
+     *
+     * The two are separate because folding the hint into the one signal announced
+     * every hinted field as invalid: those three derive `aria-invalid` from it.
      */
     getDescribedByIds(): Promise<string[]>;
     /**

package/types/ngwr-form.d.ts

@@ -66,6 +66,20 @@ interface WrFormFieldContext {
     readonly errorKeys: Signal<readonly string[]>;
     /** Id of the element listing the visible messages, or `null` when there are none. */
     readonly describedBy: Signal<string | null>;
+    /**
+     * Id of the field's hint, or `null` when it is showing none — including while
+     * an error has replaced it, since the two never render together and an
+     * `aria-describedby` naming an absent element is an author error.
+     *
+     * Separate from {@link describedBy} rather than folded into it because the two
+     * carry different weight: a control keyed `aria-invalid` on "the field is
+     * describing me" would announce itself invalid for a plain hint. Compose the
+     * pair with `useFormFieldAria()` instead of reading either one directly.
+     *
+     * Optional so an app that provides its own `WR_FORM_FIELD` keeps compiling; a
+     * field without it simply describes nothing but its errors.
+     */
+    readonly hintId?: Signal<string | null>;
 }
 /** Present only inside a `<wr-form-field>`; inject with `{ optional: true }`. */
 declare const WR_FORM_FIELD: InjectionToken<WrFormFieldContext>;
@@ -187,6 +201,20 @@ declare class WrFormField implements WrFormFieldContext {
     readonly errorKeys: _angular_core.Signal<readonly string[]>;
     /** @internal Read by the projected control so a screen reader is pointed at the message. */
     readonly describedBy: _angular_core.Signal<string | null>;
+    /**
+     * @internal Read by the projected control so the hint is announced with the field.
+     *
+     * The hint used to carry no id at all, so the only thing `aria-describedby`
+     * could ever name was the error block: the sentence explaining what to type was
+     * on screen and reached a screen-reader user through no path whatsoever, and
+     * the one gate that could have said so does not exist — axe has no rule that
+     * visible help text must be programmatically associated.
+     *
+     * `null` while an error is showing, because the template swaps the hint out for
+     * the message; publishing the id anyway would point every control at an element
+     * that had just left the document.
+     */
+    readonly hintId: _angular_core.Signal<string | null>;
     /**
      * Render a catalog message for any error the markup does not already answer.
      *
@@ -223,24 +251,31 @@ declare class WrFormField implements WrFormFieldContext {
 
 /** What {@link useFormFieldAria} hands a control to bind on its own element. */
 interface WrFormFieldAria {
-    /** Id of the field's message block, or `null` when it is showing none. */
+    /**
+     * Id of the field's message block while it is showing one, of its hint
+     * otherwise, and `null` when it is showing neither.
+     */
     readonly describedBy: Signal<string | null>;
-    /** `'true'` while the field is showing a message, `null` otherwise. */
+    /** `'true'` while the field has a validation error, `null` otherwise. */
     readonly ariaInvalid: Signal<'true' | null>;
 }
 /**
- * The two attributes that make a `<wr-form-field>`'s visible error reach a
- * screen reader — bind both on whichever element carries the control's role.
+ * The two attributes that make a `<wr-form-field>`'s visible text — its error
+ * message, or its hint — reach a screen reader. Bind both on whichever element
+ * carries the control's role.
  *
- * Without them the messages the field renders are visible and nothing else: the
- * control announces itself as valid, and the message is associated with nothing.
- * No automated gate catches that — axe has no rule that a visible error must be
- * programmatically associated with its control — so this helper exists to make
- * the wiring one line per control rather than three, and the specs are the gate.
+ * Without them the copy the field renders is visible and nothing else: the
+ * control announces itself as valid, and the text is associated with nothing.
+ * No automated gate catches that — axe has no rule that a visible error or hint
+ * must be programmatically associated with its control — so this helper exists
+ * to make the wiring one line per control rather than three, and the specs are
+ * the gate.
  *
- * `aria-invalid` is keyed on the message EXISTING rather than on `errorKeys()`,
- * because the field only publishes an id once it is showing something —
- * announcing "invalid" while pointing at nothing is worse than staying quiet.
+ * The field renders an error OR a hint, never both, so `describedBy` names
+ * whichever is on screen and `aria-invalid` is keyed SEPARATELY, on the field's
+ * `errorKeys()`. Deriving it from `describedBy` instead — which is what every
+ * control did while a hint had no id to name — makes a field with a plain hint
+ * announce its control as invalid the moment the hint becomes describable.
  *
  * Must be called from an injection context (a field initialiser or a
  * constructor). Returns inert signals outside a `<wr-form-field>`.

package/types/ngwr-i18n.d.ts

@@ -19,9 +19,25 @@ type WrI18nParams = Readonly<Record<string, unknown>>;
 type WrI18nMissingHandler = (key: string, locale: string) => string;
 /** User-facing config for {@link provideWrI18n}. */
 interface WrI18nConfig {
-    /** BCP-47 tag used until the user calls `setLocale`. @default 'en' */
+    /**
+     * BCP-47 tag used until the user calls `use()`.
+     *
+     * Omitted, it is Angular's own `LOCALE_ID` — the app already states its
+     * locale there, and ngwr having a second, unrelated default is how a fully
+     * Russian app came to render an English calendar inside itself. See
+     * {@link WrI18n} for the whole precedence.
+     *
+     * @default LOCALE_ID
+     */
     readonly defaultLocale?: string;
-    /** Whitelisted locales — `setLocale` ignores anything outside this list. */
+    /**
+     * Whitelisted locales — `use()` ignores anything outside this list. Omitted,
+     * it is `[defaultLocale]`: it used to be a hardcoded `['en']`, so
+     * `provideWrI18n({ defaultLocale: 'ru' })` produced a service whose own
+     * default locale was not switchable back to.
+     *
+     * @default [defaultLocale]
+     */
     readonly availableLocales?: readonly string[];
     /**
      * Storage key for persisting the active locale (via `WrStorage`).
@@ -38,7 +54,11 @@ interface WrI18nConfigResolved {
     readonly storageKey: string | null;
     readonly missingHandler: WrI18nMissingHandler;
 }
-declare const DEFAULT_WR_I18N_CONFIG: WrI18nConfigResolved;
+/**
+ * Everything but the locale, which cannot be a constant: it is resolved from
+ * `LOCALE_ID` in an injection context. @internal
+ */
+declare const DEFAULT_WR_I18N_CONFIG: Omit<WrI18nConfigResolved, 'defaultLocale' | 'availableLocales'>;
 declare const WR_I18N_CONFIG: InjectionToken<WrI18nConfigResolved>;
 
 /**
@@ -56,9 +76,39 @@ declare const WR_I18N_CONFIG: InjectionToken<WrI18nConfigResolved>;
  * - a per-locale signal counter so every `translate()` reading the signal
  *   re-evaluates the moment a new catalog finishes loading
  *
- * Translations are looked up scope-first, then root. `t('forms.save', { ... })`
- * with `scope: 'forms'` will try the scoped catalog before falling back to
- * `forms.save` in the root catalog — useful for per-feature overrides.
+ * Translations are looked up scope-first then root, per locale, and the locale
+ * itself is tried as the full tag before the bare language underneath it — so
+ * an app running `ru-RU` resolves against a catalog registered as `ru`, and a
+ * regional catalog is never shadowed by a scope in the base language. For an
+ * app that spells its locale one way, which is every app that existed before
+ * the chain, the order is exactly what it always was.
+ *
+ * ## Which locale wins
+ *
+ * ngwr has three locale inputs and they used to be three unrelated answers — an
+ * app that set `LOCALE_ID: 'ru-RU'` correctly still rendered an English
+ * calendar, because the date token defaulted to `navigator.language`. The
+ * precedence is now stated, highest first:
+ *
+ * 1. **A subsystem's own explicit option.** `provideWrDateAdapter({ locale })`
+ *    pins dates; `provideWrI18n({ defaultLocale })` pins the catalog. The most
+ *    specific statement wins, because it can only have been deliberate.
+ * 2. **`WrI18n.locale()` — the runtime value.** The only one of the three that
+ *    can change without a reload, so it is what a language switcher writes.
+ * 3. **`LOCALE_ID`.** Angular's app-wide constant, and the seed for both of the
+ *    above when neither was given. One statement, one answer.
+ * 4. `'en-US'`, which is what `LOCALE_ID` itself falls back to.
+ *
+ * `navigator.language` is deliberately NOT in that list. It is the browser's
+ * preference, not the application's, and reading it made prerendered output and
+ * the hydrated page disagree.
+ *
+ * **What a runtime switch reaches, and what it does not.** `use()` repaints
+ * every catalog string. It does not move `LOCALE_ID`, which is a constant, so
+ * anything keyed on it — `wrDate` / `wrNumber` / `wrPlural`, `wr-input-number`,
+ * `wr-statistic`, `wr-counter` — and anything keyed on `WR_DATE_LOCALE` — the
+ * date adapter, and so `wr-calendar` and `wr-date-picker` — stays where it was.
+ * `use()` says so once in dev mode rather than leaving it to be discovered.
  *
  * @example
  * ```ts
@@ -76,6 +126,11 @@ declare class WrI18n {
     private readonly config;
     private readonly loader;
     private readonly storage;
+    /**
+     * Angular's own locale. Read for the dev-mode drift warning only — the
+     * resolved default already folded it in through `WR_I18N_CONFIG`. @internal
+     */
+    private readonly localeId;
     /**
      * Catalogs registered via `provideWrI18nBaseCatalogs()` — the floor under the
      * loader's own catalogs, so ngwr's built-in strings survive an app that only
@@ -94,7 +149,14 @@ declare class WrI18n {
     private readonly _locale;
     readonly locale: Signal<string>;
     constructor();
-    /** Switch active locale. Ignored when not whitelisted. */
+    /**
+     * Switch active locale. Ignored when not whitelisted.
+     *
+     * Text only — see the class docs for what a runtime switch cannot reach. The
+     * dev-mode warning below is the whole reporting of that limit; without it the
+     * failure is a screen showing German labels beside `3/15/2026`, with nothing
+     * anywhere saying why.
+     */
     use(locale: string): void;
     /** Available locales — pass-through from config. */
     available(): readonly string[];
@@ -118,6 +180,26 @@ declare class WrI18n {
      */
     private walkBase;
     private initialLocale;
+    /**
+     * Load a `(locale, scope)` catalog and, when the locale carries a region, the
+     * bare-language one under it. Both go in the cache; `t()` reads them in that
+     * order.
+     */
+    private loadChain;
+    /** One warning per service, not one per switch. @internal */
+    private warnedLocaleIdDrift;
+    /**
+     * Say once, in dev, that a runtime switch moved the text and nothing else.
+     *
+     * The mismatch is otherwise invisible in the way that costs the most time:
+     * the catalog strings all change, which reads as "the switch worked", and the
+     * dates and numbers beside them are still correct-looking output in the old
+     * locale. Silent when the new locale IS `LOCALE_ID`, because then nothing is
+     * out of step and a warning that fires when everything agrees is one people
+     * learn to ignore. Production builds drop the call entirely via `isDevMode()`
+     * tree-shaking.
+     */
+    private warnOnLocaleIdDrift;
     private loadCatalog;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrI18n, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WrI18n>;

package/types/ngwr-input-number.d.ts

@@ -53,7 +53,7 @@ declare class WrInputNumber implements FormValueControl<number | null> {
      */
     readonly rounded: _angular_core.InputSignalWithTransform<boolean | null, BooleanInput>;
     /**
-     * `size`, then the app config, then `md` — bound to the field's `[wrSize]`.
+     * `size`, then the app config, then `md` — bound to the field's `[size]`.
      *
      * The chrome this control is built from resolves the same pair for itself, so
      * the config lookup falls through to `input.*` rather than stopping at

package/types/ngwr-input-otp.d.ts

@@ -111,6 +111,9 @@ declare class WrInputOtp implements FormValueControl<string> {
     protected readonly cellRefs: _angular_core.Signal<readonly ElementRef<HTMLInputElement>[]>;
     constructor();
     protected onInput(event: Event, index: number): void;
+    /** @see onInput — this is where an IME's text finally arrives. */
+    protected onCompositionEnd(event: CompositionEvent, index: number): void;
+    private commitCell;
     protected onKeyDown(event: KeyboardEvent, index: number): void;
     protected onPaste(event: ClipboardEvent): void;
     protected onBlur(): void;

package/types/ngwr-input.d.ts

@@ -66,14 +66,22 @@ declare class WrInput {
      * invisible to a screen reader, which never learns the field is invalid or
      * what the message says.
      */
-    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
+    private readonly fieldAria;
     protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
     /**
-     * Control size. Named `wrSize` (not `size`) so it never clashes with the
-     * native `<input size>` attribute. Unset, it falls back to
+     * Control size. Unset, it falls back to
      * `provideWrConfig({ input: { size } })`. @default 'md'
+     *
+     * Called `wrSize` until v14, to dodge the native `<input size>` attribute —
+     * which measures the field in characters and which `.wr-input`'s `width: 100%`
+     * has always overridden, so the clash it guarded against was never observable.
+     * It made this the one size input in the catalog spelled differently from the
+     * other twenty-three. The cost of the change is that a consumer who wanted the
+     * NATIVE `size` on an ngwr input can no longer have it — but `width: 100%`
+     * meant they never did.
      */
-    readonly wrSize: _angular_core.InputSignal<WrInputSize | null>;
+    readonly size: _angular_core.InputSignal<WrInputSize | null>;
     /**
      * Pill-shaped corners. Unset, it falls back to
      * `provideWrConfig({ input: { rounded } })`; `[rounded]="false"` turns a
@@ -84,7 +92,7 @@ declare class WrInput {
     protected readonly resolvedRounded: _angular_core.Signal<boolean>;
     protected readonly classes: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrInput, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrInput, "input[wrInput], textarea[wrInput]", never, { "wrSize": { "alias": "wrSize"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrInput, "input[wrInput], textarea[wrInput]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**

package/types/ngwr-knob-testing.d.ts

@@ -7,6 +7,12 @@ import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 
+/**
+ * An arrow key, by the direction a user would say out loud — the parameter type
+ * of `WrKnobHarness.pressArrow`, exported so a consumer's own test helper can name
+ * what it forwards.
+ */
+type WrKnobArrowKey = 'left' | 'right' | 'up' | 'down';
 /** Narrows which `<wr-knob>` a harness query matches. */
 interface WrKnobHarnessFilters extends BaseHarnessFilters {
     /** Match the dial's accessible name — a string is an exact match, a RegExp is tested. */
@@ -26,8 +32,6 @@ interface WrKnobHarnessFilters extends BaseHarnessFilters {
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 
-/** The two arrow keys that raise the value, and the two that lower it. */
-type Arrow = 'left' | 'right' | 'up' | 'down';
 /**
  * Test harness for `<wr-knob>` — the radial dial.
  *
@@ -105,7 +109,7 @@ declare class WrKnobHarness extends ComponentHarness {
      * component, which has one axis and no mirroring to do. `shift` multiplies the step
      * by ten.
      */
-    pressArrow(arrow: Arrow, options?: {
+    pressArrow(arrow: WrKnobArrowKey, options?: {
         shift?: boolean;
     }): Promise<void>;
     /** Press Home — the bottom of the range. */
@@ -147,4 +151,4 @@ declare class WrKnobHarness extends ComponentHarness {
 }
 
 export { WrKnobHarness };
-export type { WrKnobHarnessFilters };
+export type { WrKnobArrowKey, WrKnobHarnessFilters };

package/types/ngwr-knob.d.ts

@@ -95,6 +95,24 @@ declare class WrKnob implements FormValueControl<number> {
      * template this one otherwise mirrors, emits on blur for exactly this reason.
      */
     protected onBlur(): void;
+    /**
+     * The APG slider keys, and they do NOT mirror under `dir="rtl"` — which is a
+     * decision, not an oversight, and the one place it is written down.
+     *
+     * `wr-slider` swaps ArrowLeft and ArrowRight in RTL because its TRACK mirrors:
+     * the thumb is placed with `inset-inline-start`, so the visual maximum moves to
+     * the left and a key naming a side has to move with it. This dial does not
+     * mirror. It is an SVG gauge drawn in a fixed 100×100 viewBox, and SVG content
+     * is not reordered by the reading direction — the arc sweeps clockwise from 7
+     * o'clock to 5 o'clock in every locale, the same way a clock face or a car's
+     * rev counter does. So ArrowRight still moves the handle toward the visually
+     * right-hand side of the arc in RTL, and swapping the keys would be the thing
+     * that broke the mapping.
+     *
+     * That is why nothing here injects `Directionality`, and why the stylesheet
+     * carries no `rtl-ok:` marker: there is no physical CSS in the value path at
+     * all, only fixed SVG geometry.
+     */
     protected onKeydown(event: KeyboardEvent): void;
     /**
      * Nearest step, measured FROM `min`. A grid anchored at zero offers values the

package/types/ngwr-loading-bar-router.d.ts

@@ -0,0 +1,35 @@
+import { EnvironmentProviders } from '@angular/core';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Drive {@link WrLoadingBar} from router navigations: `NavigationStart` takes a
+ * slot, and each of `NavigationEnd` / `NavigationCancel` / `NavigationError`
+ * releases one.
+ *
+ * @example
+ * ```ts
+ * import { provideWrLoadingBarRouter } from 'ngwr/loading-bar/router';
+ *
+ * bootstrapApplication(App, {
+ *   providers: [provideRouter(routes), provideWrLoadingBarRouter()],
+ * });
+ * ```
+ *
+ * **Why this is a call and not the default.** `WrLoadingBar` used to inject
+ * `Router` itself, so navigations drove the bar with no configuration — and
+ * every app that rendered `<wr-loading-bar>` paid 66.3 kB of `@angular/router`
+ * for it, two thirds of the entry point's total cost, whether or not it had
+ * routes. `{ optional: true }` does not help: an optional inject still names the
+ * class as the token, and it measured byte-for-byte identical to a required one.
+ * An automatic integration and a router-free bundle cannot both exist in a
+ * statically linked app, so the automatic half moved here.
+ */
+declare function provideWrLoadingBarRouter(): EnvironmentProviders;
+
+export { provideWrLoadingBarRouter };

package/types/ngwr-loading-bar.d.ts

@@ -5,12 +5,19 @@ import { Signal } from '@angular/core';
 type WrLoadingState = 'idle' | 'running' | 'completing';
 
 /**
- * Singleton state machine for a top-of-page progress indicator. Driven
- * by router events out of the box, plus a manual `start()` / `complete()`
- * API for HTTP-interceptor-style usage.
+ * Singleton state machine for a top-of-page progress indicator: a counter of
+ * in-flight tasks and a tween between 0 and 1, driven through `start()` /
+ * `complete()`.
  *
  * Pair with `<wr-loading-bar>` to render the bar at the top of your shell.
  *
+ * It knows nothing about the router on purpose. Naming `Router` here — even
+ * `{ optional: true }`, which is byte-for-byte identical to a required inject —
+ * put 66.3 kB of `@angular/router` into every app that rendered the bar,
+ * two thirds of what `ngwr/loading-bar` cost and 27× the component's own code.
+ * Call `provideWrLoadingBarRouter()` from `ngwr/loading-bar/router` to have
+ * navigations drive it.
+ *
  * @example
  * ```ts
  * // From an HttpInterceptor:
@@ -22,8 +29,6 @@ type WrLoadingState = 'idle' | 'running' | 'completing';
  * @see https://ngwr.dev/reference/services/loading-bar
  */
 declare class WrLoadingBar {
-    private readonly router;
-    private readonly destroyRef;
     private readonly isBrowser;
     /** Live count of pending "tasks" (manual + router). */
     private readonly count;
@@ -33,7 +38,6 @@ declare class WrLoadingBar {
     readonly state: Signal<WrLoadingState>;
     private timer;
     private holdTimer;
-    constructor();
     /** Reserve a slot. The bar starts trickling as long as `count > 0`. */
     start(): void;
     /** Release a slot. When the last one closes, the bar fast-forwards to 100% then resets. */
@@ -51,9 +55,15 @@ declare class WrLoadingBar {
 /**
  * Thin progress bar fixed to the top of the viewport.
  *
- * Drop one at the root of your shell. Reads the singleton {@link WrLoadingBar}
- * — every router navigation drives it automatically; HTTP interceptors
- * can call `start()` / `complete()` to add their own slots.
+ * Drop one at the root of your shell. Reads the singleton {@link WrLoadingBar},
+ * which is driven manually by `start()` / `complete()` — an HTTP interceptor, a
+ * long save, anything with a beginning and an end.
+ *
+ * Router navigations drive it too, but only once you add
+ * `provideWrLoadingBarRouter()` from `ngwr/loading-bar/router`. That is an opt-in
+ * because the subscription is what pulls `@angular/router` into the bundle: this
+ * component is 2.4 kB of its own code and used to carry 66 kB of router into
+ * apps that never routed.
  *
  * @example
  * ```html