ngwr 11.2.0 → 12.0.0

package/types/ngwr-table.d.ts

@@ -2,6 +2,57 @@ import * as _angular_core from '@angular/core';
 import { TemplateRef } from '@angular/core';
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
 
+/**
+ * @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
+ */
+/**
+ * One row handed to `wr-table` through `[items]`.
+ *
+ * **`object`, not `Record<string, unknown>`, and the difference is the whole
+ * reason this type exists.** TypeScript withholds the implicit index signature
+ * from an `interface`, because declaration merging can widen one later, so an
+ * interface is NOT assignable to `Record<string, unknown>` while a `type` alias
+ * describing the same shape IS:
+ *
+ * ```ts
+ * interface UserI { id: number }
+ * type UserT = { id: number };
+ *
+ * declare function take(rows: readonly Record<string, unknown>[]): void;
+ * take([] as UserI[]); // Index signature for type 'string' is missing in type 'UserI'
+ * take([] as UserT[]); // fine
+ * ```
+ *
+ * The table used to declare `[items]` as the record form, so `[items]="users"`
+ * compiled for one declaration of `User` and failed for the other — reported as
+ * "the table refuses my data", which is what it looks like from outside. Nothing
+ * about the row is read at bind time; the table reads cells by string key and
+ * hands back `unknown`, so the wider type costs nothing and accepts both.
+ *
+ * The row callbacks (`rowKey`, `groupBy`, `childrenKey`) do NOT take this type:
+ * their parameter is `Record<string, unknown>`, and it stays that way. A
+ * parameter is contravariant, so no signature short of a generic component can
+ * accept `(row: User) => row.id` — and widening it to `object` would reject the
+ * callbacks that do compile today (an explicit
+ * `(row: Record<string, unknown>) => …`) while making the row unindexable.
+ *
+ * Index the row instead — `(row) => row['id']` needs no cast at all — or, to
+ * reach your own type, `(row) => (row as unknown as User).id`. A single
+ * `as User` is not enough for an `interface`: TypeScript refuses that
+ * conversion outright (TS2352, "neither type sufficiently overlaps"), over the
+ * same missing index signature. `rowKey="id"` sidesteps all of it.
+ *
+ * `childrenKey` is the one callback that also RETURNS rows, and there the type
+ * IS this wide one — a return is covariant, so
+ * `(row) => (row as unknown as User).reports` needs no second assertion on the
+ * array. Declared narrow, it accepted a forest through `[items]` and refused to
+ * let the children back out.
+ */
+type WrTableRow = object;
+
 /**
  * @license
  *
@@ -248,8 +299,22 @@ type RenderRow = {
 declare class WrTable {
     /** Column definitions, keyed by row property name. */
     readonly columns: _angular_core.InputSignal<WrTableColumns>;
-    /** Row items. `null`/`undefined` renders the empty state; use `[loading]` for the spinner. */
-    readonly items: _angular_core.InputSignal<readonly Record<string, unknown>[] | null | undefined>;
+    /**
+     * Row items. `null`/`undefined` renders the empty state; use `[loading]` for
+     * the spinner.
+     *
+     * Typed `WrTableRow` (= `object`) rather than `Record<string, unknown>`, so an
+     * array of an `interface` binds as readily as an array of a `type` — see
+     * {@link WrTableRow} for why those two are not the same to TypeScript.
+     */
+    readonly items: _angular_core.InputSignal<readonly object[] | null | undefined>;
+    /**
+     * The rows as records, for everything downstream that reads a cell by key.
+     *
+     * One cast at the boundary: the INPUT is wide so any object shape binds, while
+     * the body keeps indexing rows the way it always has.
+     */
+    private readonly rows;
     /** Show the loading spinner overlay. @default false */
     readonly loading: _angular_core.InputSignalWithTransform<boolean, any>;
     /**
@@ -314,6 +379,14 @@ declare class WrTable {
      *
      * `pageSize` pages the ROOTS; a root brings its open descendants with it.
      *
+     * The function form RETURNS `WrTableRow`s, matching `[items]`: a return is
+     * covariant, so an array of `interface`-typed children satisfies it. Declared
+     * as records it did not, and a forest that bound to `[items]` could not hand
+     * its children back out. The PARAMETER stays `Record<string, unknown>` — that
+     * side is contravariant, and widening it would reject the callbacks that
+     * compile today while leaving `row['reports']` unindexable. See
+     * {@link WrTableRow}.
+     *
      * @example
      * ```html
      * <wr-table
@@ -326,7 +399,7 @@ declare class WrTable {
      * />
      * ```
      */
-    readonly childrenKey: _angular_core.InputSignal<string | ((row: Record<string, unknown>) => readonly Record<string, unknown>[] | null | undefined) | null>;
+    readonly childrenKey: _angular_core.InputSignal<string | ((row: Record<string, unknown>) => readonly WrTableRow[] | null | undefined) | null>;
     /**
      * Which column carries the indent and the expand toggle. Keyed, not
      * positional, so it survives a `columnOrder` drag. Defaults to whichever
@@ -476,9 +549,17 @@ declare class WrTable {
     private readonly pins;
     constructor();
     private measurePins;
-    /** Sticky `left` offset (px) for a left-pinned column, else `null`. */
+    /**
+     * Sticky `inset-inline-start` offset (px) for a `pin: 'left'` column, else `null`.
+     *
+     * The input keeps its physical name — it is public API — but the offset it
+     * produces is LOGICAL. `measurePins()` accumulates in DOM order, which is
+     * start-to-end semantics, and under `dir="rtl"` the column order mirrors: a
+     * `pin: 'left'` column then sits at the physical right, where a `left: 0`
+     * sticky inset can never catch it and the column just scrolls away.
+     */
     protected leftPin(key: string): number | null;
-    /** Sticky `right` offset (px) for a right-pinned column, else `null`. */
+    /** Sticky `inset-inline-end` offset (px) for a `pin: 'right'` column, else `null`. See {@link leftPin}. */
     protected rightPin(key: string): number | null;
     /** Whether `key` is the inner-edge pinned column on `side` (carries the shadow). */
     protected isPinEdge(key: string, side: 'left' | 'right'): boolean;
@@ -569,7 +650,7 @@ declare class WrTable {
      * that is every VISIBLE node — a collapsed subtree is not on screen and is not
      * swept in, which keeps the checkbox honest about what it just did.
      */
-    private readonly pageRowKeys;
+    protected readonly pageRowKeys: _angular_core.Signal<readonly unknown[]>;
     protected isRowSelected(row: Record<string, unknown>): boolean;
     /** Every current-page row selected (drives the header checkbox). */
     protected readonly allSelected: _angular_core.Signal<boolean>;
@@ -633,9 +714,9 @@ declare class WrTable {
     /**
      * The flat `<tbody>` render list. Ungrouped it is exactly today's rows in
      * order (the rendered elements are unchanged; only the `@for` track identity
-     * moves to a stable id). Returns `[]` for both no-rows and loading — the
-     * template's `@if (visibleItems())` guard keeps the loading case from showing
-     * the empty row.
+     * moves to a stable id). Returns `[]` for nullish rows, and reads nothing about
+     * `loading()` — suppressing the "no data" row under the spinner is the
+     * template's job, not this one's.
      */
     protected readonly renderRows: _angular_core.Signal<readonly RenderRow[]>;
     /** Default band label — the primitive as text, `'—'` for empty, JSON for objects. */
@@ -793,8 +874,20 @@ declare class WrTableFilter {
     readonly filterLabel: _angular_core.InputSignal<string | null>;
     /** Text shown when the search finds nothing. Falls back to `table.noMatches`. */
     readonly noMatchesLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * Placeholder AND accessible name of the search box. Falls back to `table.search`.
+     *
+     * One string for both because the box has no visible label: the placeholder was
+     * its only name, so a hard-coded literal left the control unnamed in every other
+     * language rather than merely untranslated.
+     */
+    readonly searchLabel: _angular_core.InputSignal<string | null>;
+    /** Label of the clear-selection button. Falls back to `table.reset`. */
+    readonly resetLabel: _angular_core.InputSignal<string | null>;
     protected readonly resolvedFilterLabel: _angular_core.Signal<string>;
     protected readonly resolvedNoMatchesLabel: _angular_core.Signal<string>;
+    protected readonly resolvedSearchLabel: _angular_core.Signal<string>;
+    protected readonly resolvedResetLabel: _angular_core.Signal<string>;
     readonly items: _angular_core.InputSignal<readonly WrTableFilterItem<unknown>[]>;
     /** Fires whenever the selection changes. */
     readonly selectionChange: _angular_core.OutputEmitterRef<readonly WrTableFilterItem<unknown>[]>;
@@ -818,8 +911,8 @@ declare class WrTableFilter {
     protected onReset(): void;
     private emitSelected;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTableFilter, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTableFilter, "wr-table-filter", never, { "filterLabel": { "alias": "filterLabel"; "required": false; "isSignal": true; }; "noMatchesLabel": { "alias": "noMatchesLabel"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTableFilter, "wr-table-filter", never, { "filterLabel": { "alias": "filterLabel"; "required": false; "isSignal": true; }; "noMatchesLabel": { "alias": "noMatchesLabel"; "required": false; "isSignal": true; }; "searchLabel": { "alias": "searchLabel"; "required": false; "isSignal": true; }; "resetLabel": { "alias": "resetLabel"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
 }
 
 export { WrTable, WrTableCell, WrTableExpand, WrTableFilter, WrTableGroupHeader, WrTableSort };
-export type { WrTableCellContext, WrTableColumn, WrTableColumns, WrTableCsvOptions, WrTableExpandContext, WrTableFilterChange, WrTableFilterItem, WrTableGroupContext, WrTableSortDirection, WrTableSortState, WrTableSummary };
+export type { WrTableCellContext, WrTableColumn, WrTableColumns, WrTableCsvOptions, WrTableExpandContext, WrTableFilterChange, WrTableFilterItem, WrTableGroupContext, WrTableRow, WrTableSortDirection, WrTableSortState, WrTableSummary };

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

@@ -111,12 +111,12 @@ declare class WrTabHarness extends ContentContainerComponentHarness {
      * Whether this is the strip's selected tab.
      *
      * `aria-selected` first, because that is the state a screen reader acts on and
-     * the `--active` class is only what it looks like. A ROUTER tab carries no
-     * `aria-selected` at all — the router paints the class through
-     * `routerLinkActive` and nothing announces the selection — so the class is the
-     * fallback rather than the first choice, and the two branches are not
-     * interchangeable: reading the class first would report a content tab as selected
-     * while `aria-selected="false"` told assistive tech otherwise.
+     * the `--active` class is only what it looks like. Both shapes carry it now — a
+     * router tab publishes it off the same `routerLinkActive` that paints the class —
+     * so the class is a fallback for a tab that has neither yet, not a second reading
+     * of the same thing. The order is not interchangeable: reading the class first
+     * would report a tab as selected while `aria-selected="false"` told assistive tech
+     * otherwise.
      */
     isSelected(): Promise<boolean>;
     /**
@@ -243,10 +243,11 @@ declare class WrTabHarness extends ContentContainerComponentHarness {
  *   the tab they move to, the APG's automatic-activation pattern. `<wr-tabs>`
  *   renders exactly one panel: the selected tab's.
  * - **Router** — one `routerLink` on any child switches the whole strip over. The
- *   tabs become `<a role="tab">`s, they announce no `aria-selected` at all (the
- *   router paints `--active` and nothing else), the strip renders NO panel, and it
- *   stops being one tab stop — every enabled tab is a Tab stop of its own. The
- *   arrow keys still move focus, but they select nothing: the route does that.
+ *   tabs become `<a role="tab">`s whose `aria-selected` follows the resolved route
+ *   (the same `routerLinkActive` that paints `--active`), the strip renders NO
+ *   panel, and it stops being one tab stop — every enabled tab is a Tab stop of its
+ *   own. The arrow keys still move focus, but they select nothing: the route does
+ *   that.
  *
  * So {@link getSelectedLabel} and {@link getFocusedLabel} are two different
  * questions, and {@link getTabStopLabels} is a third. They coincide in content mode

package/types/ngwr-tabs.d.ts

@@ -123,6 +123,8 @@ declare class WrTabs implements WrTabsContext {
     /** Recompute which edges can scroll, from the strip's scroll metrics. @internal */
     protected updateFades(): void;
     protected onTabClick(tab: WrTab): void;
+    /** Per-instance prefix, so keys only have to be unique within one group. */
+    private readonly uid;
     /** Header id for `aria-labelledby` on the panel. @internal */
     headerId(key: string): string;
     /** Panel id for `aria-controls` on the tab header. @internal */

package/types/ngwr-theme.d.ts

@@ -45,6 +45,87 @@ declare const WR_COLORS: readonly ["primary", "secondary", "success", "warning",
  */
 type WrColor = (typeof WR_COLORS)[number];
 
+/**
+ * @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
+ */
+/**
+ * The palette recipe, in TypeScript.
+ *
+ * `theme/styles/_colors.scss` derives seven tokens per intent from one hex, and
+ * until now that arithmetic existed only in Sass — so a theme picked at RUNTIME
+ * (a builder, a tenant colour from an API, a preset fetched from a registry)
+ * could not reproduce it. The showcase had half of it copied by hand for its
+ * own primary-colour switcher, which is the copy that drifts.
+ *
+ * **Seven tokens, not twelve, and that is not an omission.** The tint and ink
+ * layer is written in terms of `var()`:
+ *
+ * ```css
+ * --wr-color-primary-soft: rgba(var(--wr-color-primary-rgb), 0.12);
+ * --wr-color-primary-ink: color-mix(in srgb, var(--wr-color-primary) 78%, var(--wr-color-dark));
+ * ```
+ *
+ * so redefining the base and its channels re-resolves `-soft`, `-soft-border`,
+ * `-soft-contrast`, `-active` and `-ink` for free. A preset that also emitted
+ * those would be freezing values the stylesheet is meant to keep deriving.
+ *
+ * **`-contrast` IS re-derived, and must be.** It picks whichever of black and
+ * white scores higher against the fill, so a re-tuned intent keeps the label of
+ * the colour it replaced unless something recomputes it — that is how the dark
+ * theme once put white text on its lightened primary at 3.36:1.
+ *
+ * The LIGHT recipe only. `_dark.scss` is hand-tuned rather than derived — its
+ * `dark-light` uses `color.scale(…, 70%)` where the light block uses
+ * `color.adjust(…, 5%)`, and `light-light` goes -2.5% — so a generator claiming
+ * to reproduce it would be lying. Feed dark seeds through the same recipe if you
+ * want a derived dark theme; you will get a consistent one, not the shipped one.
+ *
+ * `pnpm check:theme` compiles nothing and trusts nothing: it reads the BUILT
+ * stylesheet and asserts this module reproduces every one of those tokens for
+ * the nine shipped intents.
+ *
+ * @example
+ * ```ts
+ * import { wrThemeTokens } from 'ngwr/theme';
+ *
+ * const tokens = wrThemeTokens({ primary: '#41598f' });
+ * for (const [name, value] of Object.entries(tokens)) {
+ *   document.documentElement.style.setProperty(name, value);
+ * }
+ * ```
+ */
+
+/**
+ * The readable label ON a filled intent — whichever of black and white scores
+ * higher, the SCSS `_contrast()`.
+ *
+ * It PICKS, it does not blend, so those two values are the ceiling for every
+ * intent. The comparison is `>=`, so a colour exactly at the flip point
+ * (√21 ≈ 4.58 against both) takes the dark label, matching the SCSS.
+ */
+declare function wrContrastFor(hex: string): string;
+/**
+ * The seven `--wr-color-<name>*` tokens one seed produces.
+ *
+ * Returns an empty record for a hex it cannot parse rather than a palette built
+ * on black — a silently black theme is harder to notice than a missing one.
+ *
+ * `name` is a shipped intent rather than any string: a token layer the
+ * stylesheet never declares has nothing reading it, and a typo would otherwise
+ * emit `--wr-color-primry-*` and paint nothing.
+ */
+declare function wrIntentTokens(name: WrColor, seed: string): Record<string, string>;
+/**
+ * Every token a theme preset needs, for as many intents as it re-tunes.
+ *
+ * Intents left out keep the values the stylesheet compiled, so a preset that
+ * only moves `primary` writes seven declarations and nothing else.
+ */
+declare function wrThemeTokens(seeds: Partial<Record<WrColor, string>>): Record<string, string>;
+
 /**
  * @license
  *
@@ -132,5 +213,5 @@ declare class WrTheme {
  */
 declare function provideWrTheme(config?: Partial<WrThemeConfig>): EnvironmentProviders;
 
-export { DEFAULT_WR_THEME_CONFIG, WR_COLORS, WR_THEME_CONFIG, WrTheme, provideWrTheme };
+export { DEFAULT_WR_THEME_CONFIG, WR_COLORS, WR_THEME_CONFIG, WrTheme, provideWrTheme, wrContrastFor, wrIntentTokens, wrThemeTokens };
 export type { WrColor, WrResolvedTheme, WrThemeConfig, WrThemeMode };

package/types/ngwr-tour.d.ts

@@ -74,6 +74,7 @@ declare class WrTour {
     /** The step being shown, or `null` when idle. */
     readonly step: _angular_core.Signal<WrTourStep | null>;
     private readonly noStepAfter;
+    private readonly noStepBefore;
     /**
      * Whether this is the last step the user will see. Not `index() === total() - 1`:
      * a trailing step whose target is missing is skipped, so comparing against the
@@ -81,6 +82,14 @@ declare class WrTour {
      * ending the tour when it was pressed.
      */
     readonly isLast: _angular_core.Signal<boolean>;
+    /**
+     * Whether this is the first step the user will see. Not `index() === 0`, for the
+     * mirror of the reason above: a LEADING step whose target is missing is skipped,
+     * so the tour opens on a later index and the raw one put a Back button on the
+     * first card — one that did nothing at all, because `prev()` walks off the start
+     * and returns without moving.
+     */
+    readonly isFirst: _angular_core.Signal<boolean>;
     constructor();
     /**
      * Begin a tour. Restarts if one is already running. A no-op under SSR — a
@@ -102,6 +111,8 @@ declare class WrTour {
     private goTo;
     /** Whether the tour has a step past `index` that can actually be shown. */
     private anyResolvableAfter;
+    /** Whether the tour has a step before `index` that can actually be shown. */
+    private anyResolvableBefore;
     private resolve;
     private openStep;
     private placeSpotlight;
@@ -129,6 +140,13 @@ interface WrTourController {
      * skipped and the raw count would call the final card "Next".
      */
     readonly isLast: () => boolean;
+    /**
+     * Whether this is the first step the user will actually see — the service looks
+     * BEHIND for a reachable one, for the mirror reason: a leading step whose target
+     * is missing gets skipped, so the tour opens on a later index and the raw one
+     * would put a Back button on the very first card.
+     */
+    readonly isFirst: () => boolean;
     next(): void;
     prev(): void;
     stop(): void;
@@ -141,10 +159,10 @@ interface WrTourController {
  */
 declare class WrTourPopup {
     protected readonly tour: WrTourController;
-    protected readonly nextLabel: string;
-    protected readonly backLabel: string;
-    protected readonly doneLabel: string;
-    protected readonly skipLabel: string;
+    protected readonly nextLabel: _angular_core.Signal<string>;
+    protected readonly backLabel: _angular_core.Signal<string>;
+    protected readonly doneLabel: _angular_core.Signal<string>;
+    protected readonly skipLabel: _angular_core.Signal<string>;
     /** `Step {{current}} of {{total}}` — also the dialog's accessible name. */
     protected readonly progress: (params?: ngwr_i18n.WrI18nParams) => string;
     protected readonly isLast: _angular_core.Signal<boolean>;

package/types/ngwr-tree.d.ts

@@ -158,6 +158,7 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
     private readonly scrollStrategies;
     private readonly destroyRef;
     private readonly platformId;
+    private readonly injector;
     /**
      * Ambient reading direction. Optional so a bare `TestBed` — or a consumer who
      * never set a direction — needs no provider; `Directionality` is root-provided
@@ -179,10 +180,10 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
      * `flat[i]` is undefined.
      */
     protected readonly cursorIndex: _angular_core.Signal<number>;
-    /** Resolved ARIA labels — resolved once at construction, so a runtime locale switch needs a re-create. */
-    protected readonly clearLabel: string;
-    protected readonly expandLabel: string;
-    protected readonly collapseLabel: string;
+    /** Resolved ARIA labels — signals, so they follow both a late catalog and a locale switch. */
+    protected readonly clearLabel: _angular_core.Signal<string>;
+    protected readonly expandLabel: _angular_core.Signal<string>;
+    protected readonly collapseLabel: _angular_core.Signal<string>;
     protected readonly chipRemoveLabel: (params?: ngwr_i18n.WrI18nParams) => string;
     /** Flattened list of currently visible nodes — what the template renders. */
     protected readonly flat: _angular_core.Signal<readonly FlatNode<TId>[]>;

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

@@ -108,6 +108,16 @@ declare class WrTypewriterHarness extends ComponentHarness {
     static with(options?: WrTypewriterHarnessFilters): HarnessPredicate<WrTypewriterHarness>;
     private readonly content;
     private readonly cursor;
+    /**
+     * One custom property off the host's `style` ATTRIBUTE.
+     *
+     * Not `getCssValue()`, which is `getComputedStyle`: with the entry point's own
+     * stylesheet loaded that resolves the sheet's declaration, so the method
+     * answers plausibly at exactly the moment the host binding — the thing under
+     * test — is what broke. The sibling reader below already says this; the
+     * blink duration was reading the computed value anyway.
+     */
+    private inlineVar;
     /**
      * What has been typed so far — a FRAGMENT while the machine is running.
      *

package/types/ngwr-utils.d.ts

@@ -381,8 +381,11 @@ declare function throttle<TArgs extends readonly unknown[]>(fn: (...args: TArgs)
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 /**
- * Canonical `KeyboardEvent.key` values used across ngwr components.
- * Use these constants instead of magic strings so refactors are searchable.
+ * Canonical `KeyboardEvent.key` values for your own `keydown` handlers.
+ *
+ * The spec spellings are easy to get wrong — arrows are `ArrowUp`, space is a
+ * literal `' '` — and a typo like `'Esacpe'` never matches and never errors.
+ * These give you autocomplete and the {@link WrKey} union to match against.
  */
 declare const KEYS: {
     readonly ENTER: "Enter";

package/types/ngwr-version.d.ts

@@ -16,7 +16,7 @@ import { InjectionToken } from '@angular/core';
  * Distinct from `Version` exported by `@angular/core`, which reports the
  * loaded Angular runtime version (e.g. `'22.0.0'`), not ngwr's.
  */
-declare const NGWR_VERSION = "11.2.0";
+declare const NGWR_VERSION = "12.0.0";
 
 /**
  * @license

package/types/ngwr-window.d.ts

@@ -166,6 +166,31 @@ interface WrWindowConfig<D = unknown> {
  */
 type WrWindowState = 'normal' | 'minimized' | 'maximized';
 
+/**
+ * @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
+ */
+
+/**
+ * One window as `WrWindowManager.saveLayout()` recorded it — the geometry the
+ * window really had, not the geometry it happens to be showing while maximized
+ * or minimized.
+ *
+ * Public because `readLayout()` returns an array of these; a consumer that
+ * stores or forwards that result has to be able to name the element type.
+ */
+interface WrWindowLayoutSnapshot {
+    readonly id: string;
+    readonly state: WrWindowState;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly title: string;
+}
+
 /** Hook signature for `WrWindowRef.beforeClose()`. Return falsy to veto. */
 type WrWindowBeforeCloseHook<R> = (result: R | undefined) => boolean | Promise<boolean>;
 
@@ -272,6 +297,7 @@ declare class WrWindowRef<C, R = unknown> {
     constructor(id: string, _overlayRef: OverlayRef);
     /** Resolved instance of the projected component. */
     get componentInstance(): C;
+    private isClosed;
     /**
      * Close the window, optionally returning a result. If a `beforeClose`
      * hook is registered it is consulted first — a falsy resolution
@@ -315,15 +341,6 @@ declare const WR_WINDOW_REF: InjectionToken<WrWindowRef<unknown, unknown>>;
 /** Resolves to the `data` passed in `WrWindowConfig.data`. */
 declare const WR_WINDOW_DATA: InjectionToken<unknown>;
 
-interface RestoreSnapshot {
-    readonly id: string;
-    readonly state: WrWindowState;
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-    readonly title: string;
-}
 /**
  * Owns the open `<wr-window>` stack, hands out z-indexes, cascades the
  * default spawn position, and opens programmatic windows that wrap a
@@ -388,6 +405,17 @@ declare class WrWindowManager {
      * "Settings" menu item that should always re-focus the same window).
      */
     open<C, R = unknown, D = unknown>(component: ComponentType<C>, config?: WrWindowConfig<D>): WrWindowRef<C, R>;
+    /**
+     * Whether a keyboard event routed to `ref`'s overlay is actually meant for it.
+     *
+     * The window holding real DOM focus owns the key. When focus is outside every
+     * window — the common case, since a window is not modal and traps nothing —
+     * the FRONT-most one does, by the manager's own z stack rather than by attach
+     * order. A tie (nothing has ever been focused, so no z has been handed out
+     * yet) leaves every window willing, and the dispatcher's newest-first walk
+     * settles it as before.
+     */
+    private ownsKeyboard;
     /** Close every programmatically-opened window. */
     closeAll(): void;
     /** Look up an open window by its `config.id`. Returns `null` when no match. */
@@ -406,7 +434,7 @@ declare class WrWindowManager {
      */
     saveLayout(name: string): void;
     /** Read a saved workspace. Returns `null` when no snapshot is found. */
-    readLayout(name: string): readonly RestoreSnapshot[] | null;
+    readLayout(name: string): readonly WrWindowLayoutSnapshot[] | null;
     /**
      * Apply a saved workspace.
      *
@@ -472,4 +500,4 @@ declare class WrWindowTaskbar {
 }
 
 export { WR_WINDOW_DATA, WR_WINDOW_REF, WrWindowManager, WrWindowRef, WrWindowTaskbar };
-export type { WrWindowBeforeCloseHook, WrWindowChromeSize, WrWindowConfig, WrWindowOs, WrWindowPersistMode, WrWindowSize, WrWindowSnap, WrWindowState, WrWindowStorageConfig };
+export type { WrWindowBeforeCloseHook, WrWindowChromeSize, WrWindowConfig, WrWindowLayoutSnapshot, WrWindowOs, WrWindowPersistMode, WrWindowSize, WrWindowSnap, WrWindowState, WrWindowStorageConfig };

package/typography/styles/_index.scss

@@ -86,7 +86,7 @@
 
   &--code {
     padding: 0.0625rem 0.375rem;
-    background: rgba(var(--wr-color-outline-rgb), 0.6);
+    background: var(--wr-color-fill-strong);
     border-radius: var(--wr-border-radius-sm);
     font-size: 0.875em;
   }