ngwr 15.0.1 → 15.2.0

package/types/ngwr-window.d.ts

@@ -1,9 +1,35 @@
 import * as i0 from "@angular/core";
-import { ComponentRef, InjectionToken, Signal, WritableSignal } from "@angular/core";
-import { WrClassInput } from "ngwr/utils";
+import { ComponentRef, ElementRef, InjectionToken, Signal, TemplateRef, WritableSignal } from "@angular/core";
+import { WrClassInput, WrFeature } from "ngwr/utils";
 import { ComponentType } from "@angular/cdk/portal";
 import { OverlayRef } from "@angular/cdk/overlay";
-import { ReplaySubject, Subject } from "rxjs";
+import { Observable, ReplaySubject, Subject } from "rxjs";
+import { WrDropdown } from "ngwr/dropdown";
+/**
+ * Space to keep clear at each edge of the viewport, in CSS pixels — an app
+ * header, a side rail, a status strip. Physical edges, like every window
+ * coordinate: `x` and `left` are screen positions, not reading-order ones.
+ */
+interface WrWindowInsets {
+  readonly top?: number;
+  readonly right?: number;
+  readonly bottom?: number;
+  readonly left?: number;
+}
+/**
+ * The work area: the rectangle that maximize, snapping, `keepInViewport` and
+ * the opening cascade all keep a window inside.
+ *
+ * - `'viewport'` (the default) — the whole viewport.
+ * - an inset object — the viewport minus that much at each edge.
+ * - an element (or an `ElementRef`) — that element's box, for a desktop that
+ *   lives inside a panel. It is measured again when it resizes, when the
+ *   viewport resizes and when the page scrolls.
+ *
+ * A `<wr-window-taskbar>` on the page reserves its own strip on top of any of
+ * these while it shows tabs, so a maximized window stops short of it.
+ */
+type WrWindowBounds = 'viewport' | WrWindowInsets | HTMLElement | ElementRef<HTMLElement>;
 /**
  * @license
  *
@@ -38,17 +64,20 @@ type WrWindowChromeSize = 'sm' | 'md';
  * - `auto` (default) — read the user's OS from the browser and pick
  *   `macos` / `windows` / `linux`. Unknown platforms fall back to
  *   `windows`. SSR-safe (resolves to `windows` on the server).
- * - `macos` — traffic-light dots on the LEFT (red close, yellow minimize,
- *   green maximize). Glyphs (×, −, +) appear when the cluster is hovered.
- * - `windows` — monochrome glyph buttons on the RIGHT.
- * - `linux` — close-only on the right, the GNOME convention. That is a DEFAULT
- *   and not a rule: `showMinimize` / `showMaximize` set to `true` put the
- *   buttons back, which is what a Linux user needs before a window can be
- *   minimized into `<wr-window-taskbar>`.
+ * - `macos` — traffic lights on the LEFT (red close, yellow minimize, green
+ *   zoom). Their glyphs (×, −, and the full-screen arrows, pointing in once
+ *   the window is maximized) appear while the cluster is hovered or focused.
+ * - `windows` — Windows 11 caption buttons on the RIGHT: full-height, 46px
+ *   wide, flush with the frame, with a red close on hover.
+ * - `linux` — GNOME's round buttons on the right, close-only by convention.
+ *   That is a DEFAULT and not a rule: `showMinimize` / `showMaximize` set to
+ *   `true` put the buttons back, which is what a Linux user needs before a
+ *   window can be minimized into `<wr-window-taskbar>`.
+ *
+ * Every preset moves to the other edge in a right-to-left page, as each of
+ * the three platforms does in a right-to-left UI.
  */
 type WrWindowOs = 'auto' | 'macos' | 'windows' | 'linux';
-/** Resolved OS — what `'auto'` collapses to. */
-type WrWindowResolvedOs = Exclude<WrWindowOs, 'auto'>;
 /**
  * @license
  *
@@ -64,6 +93,402 @@ type WrWindowResolvedOs = Exclude<WrWindowOs, 'auto'>;
  * - `lg` — 720 × 480
  */
 type WrWindowSize = 'sm' | 'md' | 'lg';
+/**
+ * A rectangle in viewport pixels — the work area, a snap region, a window's box.
+ *
+ * @internal
+ */
+interface WrWindowRect {
+  readonly left: number;
+  readonly top: number;
+  readonly width: number;
+  readonly height: number;
+}
+/** @internal A window's free-floating geometry: where it is when it is neither maximized nor snapped. */
+interface WrWindowGeometry {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * Every option a window reads after it opens, with its default applied. The
+ * ones `WrWindowRef.update()` may change are signals of this object, so an
+ * update reaches the chrome and the drag code alike.
+ *
+ * @internal
+ */
+interface WrWindowOptions {
+  readonly os: WrWindowOs;
+  readonly chromeSize: WrWindowChromeSize;
+  readonly animations: boolean;
+  readonly minWidth: number;
+  readonly minHeight: number;
+  readonly maxWidth: number;
+  readonly maxHeight: number;
+  readonly movable: boolean;
+  readonly resizable: boolean;
+  readonly keepInViewport: boolean;
+  readonly snap: WrWindowSnap;
+  readonly restoreOnDrag: boolean;
+  readonly dragHandle: string | null;
+  readonly showMinimize: boolean | null;
+  readonly showMaximize: boolean | null;
+  readonly showClose: boolean;
+  readonly closeOnEscape: boolean;
+  readonly keyboard: boolean;
+  readonly keyboardStep: number;
+}
+/** @internal How a window was set up when it opened. */
+interface WrWindowModelInit {
+  readonly options: WrWindowOptions;
+  readonly title?: string;
+  readonly geometry?: WrWindowGeometry;
+  readonly state?: WrWindowState;
+  readonly snap?: WrWindowSnapTarget | null;
+  readonly z?: number;
+  readonly workArea: Signal<WrWindowRect>;
+}
+/** @internal A half or a quarter: what `snap` can hold. `top` is the maximized state instead. */
+type WrWindowSnapRegion = Exclude<WrWindowSnapTarget, 'top'>;
+/** @internal What `startKeyboard` hands back for the announcement. */
+type WrWindowKeyboardMode = 'move' | 'resize';
+/**
+ * One window's state and geometry, and the rules for changing them.
+ *
+ * Created by `WrWindowManager.open()` before anything renders, so the ref's
+ * signals are right from the first read and a call made before the first render
+ * — `ref.maximize()` in the same tick as `open()`, `ref.setTitle()` from the
+ * body's constructor — lands instead of being dropped. The component only draws
+ * it and turns pointer and key events into calls on it.
+ *
+ * The raw `x` / `y` / `width` / `height` are the geometry the USER chose. A
+ * maximized or snapped window shows something else (`rect`), and goes back to
+ * the raw geometry when it leaves that state; nothing has to be saved on the
+ * way in, so a `moveTo()` made while maximized is where restore lands.
+ *
+ * @internal
+ */
+declare class WrWindowModel {
+  readonly options: WritableSignal<WrWindowOptions>;
+  readonly title: WritableSignal<string>;
+  readonly state: WritableSignal<WrWindowState>;
+  /** The half or quarter the window occupies while `normal`. `top` is never stored: it is `maximized`. */
+  readonly snap: WritableSignal<WrWindowSnapRegion | null>;
+  readonly x: WritableSignal<number>;
+  readonly y: WritableSignal<number>;
+  readonly width: WritableSignal<number>;
+  readonly height: WritableSignal<number>;
+  readonly z: WritableSignal<number>;
+  /** Written by the manager: whether this is the window that has the keyboard. */
+  readonly isActive: WritableSignal<boolean>;
+  readonly keyboardMode: WritableSignal<WrWindowKeyboardMode | null>;
+  /** The snap region a drag in progress would land in, for the hint. */
+  readonly dragTarget: WritableSignal<WrWindowSnapTarget | null>;
+  readonly workArea: Signal<WrWindowRect>;
+  readonly moved: Subject<{
+    readonly x: number;
+    readonly y: number;
+  }>;
+  readonly resized: Subject<{
+    readonly width: number;
+    readonly height: number;
+  }>;
+  readonly stateChanges: Subject<WrWindowState>;
+  /** Set by the component: the `<wr-window>` element, for the focus checks. */
+  element: HTMLElement | null;
+  /** Set by the container: the window was minimized while it held focus. */
+  onMinimizedWithFocus: (() => void) | null;
+  /** What leaving `minimized` goes back to — a window minimized while maximized comes back maximized. */
+  private restoreTo;
+  /** The geometry keyboard mode started from, after it restored the window: what a commit compares against. */
+  private keyboardStart;
+  /** Everything keyboard mode changed on entry, so Escape can put back a maximized or snapped window too. */
+  private keyboardOrigin;
+  /** The box on screen: the raw geometry, or what the state imposes on it. */
+  readonly rect: Signal<WrWindowRect>;
+  /** Where the drag in progress would land, for the snap hint. */
+  readonly previewRect: Signal<WrWindowRect | null>;
+  constructor(init: WrWindowModelInit);
+  /** The one place a state is written, so `stateChanges` hears every change and only real ones. */
+  setState(next: WrWindowState): void;
+  /** Toggle: minimize, or come back to the state it was minimized from. */
+  minimize(): void;
+  /** Leave `minimized` for the state the window was minimized from. A no-op otherwise. */
+  unminimize(): void;
+  /** Toggle: maximize, or restore down to where it was — a snapped half included. */
+  maximize(): void;
+  /** Back to the free-floating geometry: not minimized, not maximized, not snapped. */
+  restore(): void;
+  /** Snap to a region of the work area; `top` maximizes, `null` un-snaps. */
+  snapTo(target: WrWindowSnapTarget | null): void;
+  /** Write the raw geometry, in whole pixels — a touch drag hands out fractions. */
+  setRaw(g: Partial<WrWindowGeometry>): void;
+  /**
+   * A snapped window that is moved or resized by hand leaves the snap and
+   * keeps the box it had, the way a desktop does — otherwise the write would
+   * land in the raw geometry and nothing would visibly move.
+   */
+  unsnapInPlace(): void;
+  moveTo(x: number, y: number): void;
+  resizeTo(width: number, height: number): void;
+  center(): void;
+  /**
+   * Keep enough of the window inside the work area to grab it again. Reads the
+   * work area, so a resized viewport pulls a window back into reach.
+   */
+  clamp(): void;
+  /** Change options on an open window. New bounds re-clamp the size the window has now. */
+  update(patch: WrWindowUpdate): void;
+  /** The box a maximized window takes: the work area, capped at the maximum size and centred in it. */
+  maximizedRect(): WrWindowRect;
+  /**
+   * The box a half or a quarter takes, held to the window's own bounds: a
+   * window that cannot be that narrow keeps its minimum and stays against the
+   * edge it was snapped to, and the box is kept inside the work area.
+   */
+  snapRect(target: WrWindowSnapRegion): WrWindowRect;
+  /** Where a snap target puts the window. */
+  targetRect(target: WrWindowSnapTarget): WrWindowRect;
+  /**
+   * Enter keyboard move or resize. A maximized window is restored down first
+   * and a snapped one keeps its box, so the arrows move what the user sees.
+   * Returns `false` when the option forbids it.
+   */
+  startKeyboard(mode: WrWindowKeyboardMode): boolean;
+  /** One arrow key in keyboard move. */
+  nudge(dx: number, dy: number): void;
+  /**
+   * One arrow key in keyboard resize. The edge that moves is the inline END —
+   * the left one in a right-to-left page — so growing never moves the edge the
+   * window reads from.
+   */
+  grow(dw: number, dh: number, rtl: boolean): void;
+  /** Keep what keyboard mode did. Returns the mode it ended, for the announcement and the stream. */
+  commitKeyboard(): WrWindowKeyboardMode | null;
+  /**
+   * Put the window back the way keyboard mode found it: the geometry, and the
+   * maximized state or the snapped half it restored on entry. Without the last
+   * two, Escape on a maximized window left it restored down.
+   */
+  cancelKeyboard(): WrWindowKeyboardMode | null;
+  /** Whether focus is inside the window. */
+  hasFocus(): boolean;
+  /** The window closed: no stream may outlive it. */
+  complete(): void;
+}
+/**
+ * What a ref needs from the manager that opened it.
+ *
+ * @internal
+ */
+interface WrWindowRefHost {
+  /** Raise the window, mark it active and, unless told otherwise, move focus into it. */
+  _activate(ref: WrWindowRef<unknown, unknown>, options?: {
+    readonly focus?: boolean;
+  }): void;
+  /** Raise the window without touching focus. */
+  _raise(ref: WrWindowRef<unknown, unknown>): void;
+}
+/**
+ * Handle returned by `WrWindowManager.open()`.
+ *
+ * Wraps the underlying overlay, exposes signals for the live geometry,
+ * and gives the consumer programmatic control over the window
+ * (focus, move, resize, minimize, maximize, close).
+ *
+ * Every signal is right from the moment `open()` returns, and every call works
+ * from then on too — including from the body component's constructor.
+ *
+ * @example
+ * ```ts
+ * const ref = manager.open(EditorComponent, {
+ *   title: 'Untitled.md',
+ *   storage: { key: 'editor', prefix: 'app' },
+ * });
+ *
+ * ref.beforeClose(async () => {
+ *   if (!isDirty) return true;
+ *   return await confirmDiscard();
+ * });
+ *
+ * const saved = await ref.afterClosed(); // resolves with whatever the
+ *                                        // component passed to ref.close(value)
+ * ```
+ */
+export declare class WrWindowRef<C, R = unknown> {
+  readonly _overlayRef: OverlayRef;
+  /** Stable id — used by the taskbar, workspace save, and DI. */
+  readonly id: string;
+  /**
+   * @internal — emits the close result once and completes.
+   *
+   * A `ReplaySubject`, not a plain `Subject`, so the result survives a late
+   * subscriber — the same reasoning `WrDialogRef` already carries. A caller
+   * that holds the ref and awaits `afterClosed()` after any intervening
+   * `await` subscribes to an already-completed stream, and a plain Subject
+   * hands it nothing but `complete`: the promise resolved `undefined` and a
+   * saved result was indistinguishable from a dismissal.
+   */
+  readonly _closed: ReplaySubject<R | undefined>;
+  /** @internal — the window's state and geometry; the signals below read through it. */
+  readonly _model: WrWindowModel;
+  /** @internal — emits whenever the state changes; `stateChanges` is its public face. */
+  readonly _stateChanged: Subject<WrWindowState>;
+  /** @internal — set by the container right after attach. */
+  componentRef: ComponentRef<C> | null;
+  /** @internal — whether this window opts into the taskbar list. */
+  taskbarVisible: boolean;
+  /** @internal — the manager that opened the window. */
+  _host: WrWindowRefHost | null;
+  /** @internal — close the overlay and settle the result; wired by the manager. */
+  _doClose: ((result: R | undefined) => void) | null;
+  /**
+   * @internal — move focus into the window after the next render: to the control
+   * it had last (`'last'`, falling back to the first one) or to the first one.
+   * Wired by the container once the window is on the page.
+   */
+  _focusWindow: ((mode: 'initial' | 'last') => void) | null;
+  /** @internal — enter keyboard move / resize; wired by the container. */
+  _startKeyboard: ((mode: WrWindowKeyboardMode) => void) | null;
+  /** @internal — a keyboard mode asked for before the window was on the page. */
+  _pendingKeyboard: WrWindowKeyboardMode | null;
+  /**
+   * @internal — what had focus when `open()` was called, and where closing the
+   * window sends it back. `null` when focus was on nothing.
+   */
+  _returnFocus: HTMLElement | null;
+  /** Window state. A snapped window is `normal`; read {@link snap} for which half. */
+  readonly state: Signal<WrWindowState>;
+  /** Left edge on screen, in px — the work area's while maximized. */
+  readonly x: Signal<number>;
+  /** Top edge on screen, in px. */
+  readonly y: Signal<number>;
+  /** Width on screen, in px. */
+  readonly width: Signal<number>;
+  /** Height on screen, in px. */
+  readonly height: Signal<number>;
+  /** Stack z-index. */
+  readonly z: Signal<number>;
+  /** Live title. */
+  readonly title: Signal<string>;
+  /** The half or quarter the window is snapped to, or `null` (since v15.1). Maximized reads `null`. */
+  readonly snap: Signal<WrWindowSnapTarget | null>;
+  /** Whether this is the active window — the one that has the keyboard (since v15.1). */
+  readonly isActive: Signal<boolean>;
+  /** Emits the close result once, then completes — the stream `WrDialogRef.closed` is (since v15.1). */
+  readonly closed: Observable<R | undefined>;
+  /**
+   * Emits where the user moved the window: once when a title-bar drag or a
+   * keyboard move ends, and when a drag snaps it. Calls from code are silent —
+   * the caller knows where it put the window (since v15.1).
+   */
+  readonly moved: Observable<{
+    readonly x: number;
+    readonly y: number;
+  }>;
+  /**
+   * Emits the size the user gave the window: once when an edge drag or a
+   * keyboard resize ends, and when a drag snaps it to a half or a quarter.
+   * Calls from code are silent (since v15.1).
+   */
+  readonly resized: Observable<{
+    readonly width: number;
+    readonly height: number;
+  }>;
+  /** Emits every state change, from the user or from code (since v15.1). */
+  readonly stateChanges: Observable<WrWindowState>;
+  private _beforeCloseHook;
+  /**
+   * A ref built by hand — a test double for `WR_WINDOW_REF`. It answers every
+   * call with a window of its own that nothing renders.
+   */
+  constructor(id: string, _overlayRef: OverlayRef);
+  /** @internal The manager's form: the window's model, built before anything renders. */
+  constructor(id: string, _overlayRef: OverlayRef, model: WrWindowModel);
+  /** 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
+   * cancels the close.
+   */
+  close(result?: R): Promise<void>;
+  /** Toggle the minimized state. Leaving it returns to the state it was minimized from. */
+  minimize(): void;
+  /** Toggle the maximized state. Restoring down returns to where the window was, a snapped half included. */
+  maximize(): void;
+  /** Back to `normal` at the window's own geometry — from minimized, maximized or snapped. */
+  restore(): void;
+  /**
+   * Bring this window to the top of the stack. Only RAISES it: focus stays
+   * where it is. Use {@link activate} to switch to the window.
+   */
+  focus(): void;
+  /**
+   * Switch to the window: bring it back from the taskbar if it is minimized,
+   * raise it, make it the active window, and move focus to the control it had
+   * last (its first control when it never had one) (since v15.1).
+   */
+  activate(): void;
+  /**
+   * Move the window to `(x, y)`, held to the work area while `keepInViewport`.
+   * While maximized it moves the geometry restore lands on; a snapped window
+   * leaves the snap.
+   */
+  moveTo(x: number, y: number): void;
+  /** Resize the window, held to `minWidth`…`maxWidth` and `minHeight`…`maxHeight`. */
+  resizeTo(width: number, height: number): void;
+  /** Re-position the window so it sits centered in its work area. */
+  center(): void;
+  /** Snap to a half or a quarter of the work area; `'top'` maximizes, `null` un-snaps (since v15.1). */
+  snapTo(target: WrWindowSnapTarget | null): void;
+  /** Update the title-bar text, and with it the window's accessible name. */
+  setTitle(title: string): void;
+  /**
+   * Change options on an open window — lock it while it saves, take its close
+   * button away while a task runs. New bounds re-clamp its current size
+   * (since v15.1).
+   */
+  update(patch: WrWindowUpdate): void;
+  /**
+   * Move the window from the keyboard: the arrow keys step it, Shift by one
+   * pixel, Enter keeps the result and Escape puts it back. Moves focus into the
+   * window so the keys arrive. Bind it to a menu item or a button to offer
+   * moving without a drag (since v15.1).
+   */
+  startMove(): void;
+  /** Resize the window from the keyboard, the same way as {@link startMove} (since v15.1). */
+  startResize(): void;
+  private startKeyboard;
+  /**
+   * Register a guard that runs before `close()`. Return `false` (or a
+   * Promise resolving to false) to veto. Only one hook per ref —
+   * subsequent calls replace the previous.
+   */
+  beforeClose(hook: WrWindowBeforeCloseHook<R>): void;
+  /** Resolves with the result passed to `close()` (or `undefined`). */
+  afterClosed(): Promise<R | undefined>;
+  /** The same promise as {@link afterClosed}, under the name `WrDialogRef` uses (since v15.1). */
+  awaitClose(): Promise<R | undefined>;
+  /** Escape hatch — the underlying CDK overlay ref. */
+  get overlayRef(): OverlayRef;
+}
+/**
+ * What a `titleExtra` or `statusBar` template receives: the window's own ref
+ * as `$implicit`, so `<ng-template let-ref>` can read its title, state or
+ * geometry.
+ */
+interface WrWindowSlotContext {
+  readonly $implicit: WrWindowRef<unknown, unknown>;
+}
+/**
+ * Content for one of the window's own slots: a template, or a component. A
+ * component is created with the window's injector, so it can
+ * `inject(WR_WINDOW_REF)` and `inject(WR_WINDOW_DATA)` like the body can.
+ */
+type WrWindowSlotContent = TemplateRef<WrWindowSlotContext> | ComponentType<unknown>;
 /**
  * @license
  *
@@ -72,14 +497,17 @@ type WrWindowSize = 'sm' | 'md' | 'lg';
  */
 /**
  * Edge / corner snap behaviour. Activated by dragging the title bar
- * close to a viewport edge.
+ * close to an edge of the work area.
  *
  * - `none` — no snapping.
  * - `edges` — left / right / top edges snap to halves; top snaps to maximise.
  * - `all` — adds the four corners → quarter-screen snaps.
  */
 type WrWindowSnap = 'none' | 'edges' | 'all';
-/** Internal snap target — resolved by the drag handler. */
+/**
+ * A region of the work area a window can snap to: a half, a quarter, or `top`,
+ * which maximizes. Read it from `WrWindowRef.snap()`, set it with `snapTo()`.
+ */
 type WrWindowSnapTarget = 'left' | 'right' | 'top' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 /** What slice of geometry the storage layer should keep in sync. */
 type WrWindowPersistMode = 'position' | 'size' | 'all';
@@ -109,25 +537,59 @@ interface WrWindowStorageConfig {
  * with the standard chrome at the cascaded position.
  */
 interface WrWindowConfig<D = unknown> {
-  /** Stable identifier — used by the taskbar, workspace save, and DI. */
+  /**
+   * Stable identifier — used by the taskbar, workspace save, and DI. A second
+   * `open()` with an id that is already open brings that window back instead of
+   * opening another. Generated when omitted.
+   */
   readonly id?: string;
+  /**
+   * Title-bar text, and the window's accessible name. A window without one is
+   * named by the catalog's "Untitled", in the title bar and in the taskbar.
+   * @default ''
+   */
   readonly title?: string;
+  /** Chrome style: `'auto'` follows the visitor's platform. @default 'auto' */
   readonly os?: WrWindowOs;
-  /** Initial size preset. Ignored when `width` / `height` are passed. */
+  /** Initial size preset. Ignored when `width` / `height` are passed. @default 'md' */
   readonly size?: WrWindowSize;
   /** Title-bar density. @default 'md' */
   readonly chromeSize?: WrWindowChromeSize;
+  /** Opening left edge, in viewport pixels. Omit to cascade from the work area's start edge. */
   readonly x?: number;
+  /** Opening top edge, in viewport pixels. Omit to cascade. */
   readonly y?: number;
+  /** Opening width in pixels, over the `size` preset. Capped at the work area while `keepInViewport`. */
   readonly width?: number;
+  /** Opening height in pixels, over the `size` preset. Capped at the work area while `keepInViewport`. */
   readonly height?: number;
+  /** Narrowest the window may be dragged, snapped or opened. @default 220 */
   readonly minWidth?: number;
+  /** Shortest the window may be dragged, snapped or opened. @default 140 */
   readonly minHeight?: number;
+  /** Widest the window may be dragged, snapped, maximized or opened. @default Infinity */
   readonly maxWidth?: number;
+  /** Tallest the window may be dragged, snapped, maximized or opened. @default Infinity */
   readonly maxHeight?: number;
+  /** Allow moving the window, by the title bar or from the keyboard. @default true */
   readonly movable?: boolean;
+  /** Allow resizing the window, by its edges or from the keyboard. @default true */
   readonly resizable?: boolean;
+  /**
+   * Keep enough of the window inside the work area to grab it again, and open
+   * it wholly inside when it fits. `false` lets it go anywhere. @default true
+   */
   readonly keepInViewport?: boolean;
+  /**
+   * The rectangle maximize, snapping, `keepInViewport` and the cascade keep the
+   * window inside. Falls back to `withWindows({ bounds })`, then the viewport.
+   * @default 'viewport'
+   */
+  readonly bounds?: WrWindowBounds;
+  /**
+   * Close on Escape — when focus is inside the window, or when focus is on
+   * nothing and this is the active window. @default true
+   */
   readonly closeOnEscape?: boolean;
   /**
    * Move focus into the window when it opens (since v15): to the element
@@ -146,21 +608,59 @@ interface WrWindowConfig<D = unknown> {
   /** Snap-on-drag mode. @default 'none' */
   readonly snap?: WrWindowSnap;
   /**
-   * Show the minimize control. Omit to follow the chrome — every OS but Linux
-   * shows it, and the Linux preset is close-only by convention. Pass `true` to
-   * override that, which is what a Linux user needs before a window can reach
-   * `<wr-window-taskbar>`.
+   * Dragging the title bar of a maximized or snapped window restores its own
+   * size under the pointer, as desktop window managers do. `false` keeps a
+   * maximized window still and moves a snapped one at its snapped size.
+   * @default true
+   */
+  readonly restoreOnDrag?: boolean;
+  /**
+   * Keyboard move and resize: Alt+F7 moves the window and Alt+F8 resizes it
+   * with the arrow keys, Enter keeps the result and Escape puts it back. The
+   * same modes start from `WrWindowRef.startMove()` / `startResize()`.
+   * @default true
+   */
+  readonly keyboard?: boolean;
+  /** Pixels per arrow key in keyboard move and resize; Shift steps 1px. @default 10 */
+  readonly keyboardStep?: number;
+  /**
+   * Show the minimize control. Omit to follow the chrome: every OS but Linux
+   * shows it, and the Linux chrome is close-only by convention. Pass `true` to
+   * show it there, which is what puts a Linux window within reach of
+   * `<wr-window-taskbar>`. A minimized window is hidden until something brings
+   * it back, so a page that offers minimize also needs the taskbar or a dock of
+   * its own over `WrWindowManager.minimized()`.
    */
   readonly showMinimize?: boolean;
-  /** Show the maximize control. Omit to follow the chrome, as with {@link showMinimize}. */
+  /** Show the maximize control. Omit to follow the chrome: every OS but Linux shows it. */
   readonly showMaximize?: boolean;
-  /** Show the close control. Every chrome closes, so this is not per-OS. */
+  /** Show the close control. Every chrome closes, so this is not per-OS. @default true */
   readonly showClose?: boolean;
-  /** Show in `<wr-window-taskbar>` when minimized. @default true */
+  /**
+   * Content for the title bar, between the title and the buttons — a badge, a
+   * menu button. A template receives the ref as `$implicit`.
+   */
+  readonly titleExtra?: WrWindowSlotContent;
+  /** Content for a status bar under the body. A template receives the ref as `$implicit`. */
+  readonly statusBar?: WrWindowSlotContent;
+  /** List the window in `<wr-window-taskbar>`. @default true */
   readonly taskbar?: boolean;
+  /**
+   * The window's own open animation and transitions. Off under
+   * `prefers-reduced-motion`; the body's own animations are never touched.
+   * @default true
+   */
   readonly animations?: boolean;
-  /** CSS selector inside the projected content that restricts the move-grab area. */
+  /**
+   * CSS selector for the parts of the window that start a move. Matched in the
+   * body as well as the title bar, and replaces the title bar as the grab area —
+   * include `.wr-window__chrome` to keep it. A double-click on a match maximizes,
+   * as one on the title bar always does. Buttons, fields and links inside a match
+   * never start a drag. Give a body handle `touch-action: none` so a touch drag
+   * moves the window instead of scrolling the page.
+   */
   readonly dragHandle?: string;
+  /** Save the geometry to `WrStorage` as it changes and open there next time. */
   readonly storage?: WrWindowStorageConfig;
   /**
    * Extra CSS classes for the window's overlay pane. The pane is only a mount
@@ -168,8 +668,17 @@ interface WrWindowConfig<D = unknown> {
    * chrome reads `.my-class .wr-window`.
    */
   readonly panelClass?: WrClassInput;
+  /** Payload for the body component, read with `inject(WR_WINDOW_DATA)`. */
   readonly data?: D;
 }
+/** App-wide window defaults, passed to `provideWr(withWindows(...))`. */
+interface WrWindowDefaults {
+  /**
+   * The work area every window keeps inside, unless its own
+   * `WrWindowConfig.bounds` says otherwise. @default 'viewport'
+   */
+  readonly bounds?: WrWindowBounds;
+}
 /**
  * @license
  *
@@ -178,15 +687,15 @@ interface WrWindowConfig<D = unknown> {
  */
 /**
  * Visual state of a `<wr-window>`:
- * - `normal` — free-floating, drag / resize allowed
- * - `minimized` — collapsed to a small bar (only the header is shown)
- * - `maximized` — pinned to the full viewport, drag / resize disabled
+ * - `normal` — free-floating, drag / resize allowed (a snapped window is `normal` too; see `WrWindowRef.snap`)
+ * - `minimized` — hidden, and listed in `<wr-window-taskbar>` to come back from
+ * - `maximized` — fills the work area, up to `maxWidth` / `maxHeight`, with no resize handles
  */
 type WrWindowState = 'normal' | 'minimized' | 'maximized';
 /**
  * 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.
+ * window really had, not the geometry it happens to be showing while maximized,
+ * snapped 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.
@@ -199,162 +708,67 @@ interface WrWindowLayoutSnapshot {
   readonly width: number;
   readonly height: number;
   readonly title: string;
+  /** The half or quarter the window was snapped to, if any (since v15.1). */
+  readonly snap?: WrWindowSnapTarget | null;
 }
-/** Hook signature for `WrWindowRef.beforeClose()`. Return falsy to veto. */
-type WrWindowBeforeCloseHook<R> = (result: R | undefined) => boolean | Promise<boolean>;
 /**
- * Handle returned by `WrWindowManager.open()`.
- *
- * Wraps the underlying overlay, exposes signals for the live geometry,
- * and gives the consumer programmatic control over the window
- * (focus, move, resize, minimize, maximize, close).
- *
- * @example
- * ```ts
- * const ref = manager.open(EditorComponent, {
- *   title: 'Untitled.md',
- *   storage: { key: 'editor', prefix: 'app' },
- * });
+ * @license
  *
- * ref.beforeClose(async () => {
- *   if (!isDirty) return true;
- *   return await confirmDiscard();
- * });
+ * 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
+ */
+/**
+ * Which windows `<wr-window-taskbar>` lists.
  *
- * const saved = await ref.afterClosed(); // resolves with whatever the
- *                                        // component passed to ref.close(value)
- * ```
+ * - `minimized` (default) — only the minimized ones, as a strip of restore tabs.
+ * - `all` — every open window, with the active one marked: a tab switches to
+ *   its window, and the active window's tab minimizes it.
  */
-export declare class WrWindowRef<C, R = unknown> {
-  readonly _overlayRef: OverlayRef;
-  /** Stable id — used by the taskbar, workspace save, and DI. */
-  readonly id: string;
-  /** @internal — emits the close result once and completes. */
-  /**
-   * A `ReplaySubject`, not a plain `Subject`, so the result survives a late
-   * subscriber — the same reasoning `WrDialogRef` already carries. A caller
-   * that holds the ref and awaits `afterClosed()` after any intervening
-   * `await` subscribes to an already-completed stream, and a plain Subject
-   * hands it nothing but `complete`: the promise resolved `undefined` and a
-   * saved result was indistinguishable from a dismissal.
-   */
-  readonly _closed: ReplaySubject<R | undefined>;
-  /** @internal — emits whenever the visual state changes. */
-  readonly _stateChanged: Subject<WrWindowState>;
-  /** @internal — set by the container right after attach. */
-  componentRef: ComponentRef<C> | null;
-  /** @internal — whether this window opts into the taskbar list. */
-  taskbarVisible: boolean;
-  /**
-   * @internal — non-`normal` state to apply right after the container
-   * wires its bridges (so `restoreLayout` can land a window straight
-   * into `minimized` / `maximized` even though it just opened).
-   */
-  pendingStateOnMount: WrWindowState | null;
-  /** @internal */ readonly _state: WritableSignal<WrWindowState>;
-  /** @internal */ readonly _x: WritableSignal<number>;
-  /** @internal */ readonly _y: WritableSignal<number>;
-  /** @internal */ readonly _width: WritableSignal<number>;
-  /** @internal */ readonly _height: WritableSignal<number>;
-  /** @internal */ readonly _z: WritableSignal<number>;
-  /**
-   * The geometry the USER chose, as opposed to the one the current state
-   * imposes. `_x` and friends mirror the window's EFFECTIVE values — a
-   * maximized window reports the viewport, a minimized one reports its
-   * collapsed header height — which is right for anything drawing the window
-   * and wrong for anything persisting it.
-   *
-   * @internal
-   */
-  readonly _rawX: WritableSignal<number>;
-  /** @internal */ readonly _rawY: WritableSignal<number>;
-  /** @internal */ readonly _rawWidth: WritableSignal<number>;
-  /** @internal */ readonly _rawHeight: WritableSignal<number>;
-  /** @internal */ readonly _title: WritableSignal<string>;
-  /** Window state. */
-  readonly state: Signal<WrWindowState>;
-  /** Live X. */
-  readonly x: Signal<number>;
-  /** Live Y. */
-  readonly y: Signal<number>;
-  /** Live width. */
-  readonly width: Signal<number>;
-  /** Live height. */
-  readonly height: Signal<number>;
-  /** Stack z-index. */
-  readonly z: Signal<number>;
-  /** Live title. */
-  readonly title: Signal<string>;
-  private _beforeCloseHook;
-  /** @internal */ _doClose: ((result: R | undefined) => void) | null;
-  /** @internal */ _doMinimize: (() => void) | null;
-  /** @internal */ _doMaximize: (() => void) | null;
-  /** @internal */ _doRestore: (() => void) | null;
-  /** @internal */ _doFocus: (() => void) | null;
-  /** @internal */ _doMoveTo: ((x: number, y: number) => void) | null;
-  /** @internal */ _doResizeTo: ((w: number, h: number) => void) | null;
-  /** @internal */ _doCenter: (() => void) | null;
-  /** @internal */ _doSetTitle: ((title: string) => void) | null;
-  /** @internal — move focus into the window after the next render. */
-  _doFocusInitial: (() => void) | null;
-  /**
-   * @internal — what had focus when `open()` was called, and where closing the
-   * window sends it back. `null` when focus was on nothing.
-   */
-  _returnFocus: HTMLElement | null;
-  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
-   * cancels the close.
-   */
-  close(result?: R): Promise<void>;
-  /** Toggle the minimized state. */
-  minimize(): void;
-  /** Toggle the maximized state. */
-  maximize(): void;
-  /** Force-restore from minimized / maximized to `normal`. */
-  restore(): void;
-  /** Bring this window to the top of the stack. */
-  focus(): void;
-  moveTo(x: number, y: number): void;
-  resizeTo(width: number, height: number): void;
-  /** Re-position the window so it sits centered in the current viewport. */
-  center(): void;
-  setTitle(title: string): void;
-  /**
-   * Register a guard that runs before `close()`. Return `false` (or a
-   * Promise resolving to false) to veto. Only one hook per ref —
-   * subsequent calls replace the previous.
-   */
-  beforeClose(hook: WrWindowBeforeCloseHook<R>): void;
-  /** Resolves with the result passed to `close()` (or `undefined`). */
-  afterClosed(): Promise<R | undefined>;
-  /** Escape hatch — the underlying CDK overlay ref. */
-  get overlayRef(): OverlayRef;
-}
+type WrWindowTaskbarShow = 'minimized' | 'all';
+/**
+ * The options `WrWindowRef.update()` can change on an open window. Everything
+ * else in `WrWindowConfig` is read once, when the window opens.
+ */
+type WrWindowUpdate = Partial<Pick<WrWindowConfig, 'title' | 'movable' | 'resizable' | 'snap' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight' | 'showMinimize' | 'showMaximize' | 'showClose' | 'closeOnEscape'>>;
+/** Hook signature for `WrWindowRef.beforeClose()`. Return falsy to veto. */
+type WrWindowBeforeCloseHook<R> = (result: R | undefined) => boolean | Promise<boolean>;
 /** Resolves to the active `WrWindowRef` inside a programmatically-opened window's content tree. */
 export declare const WR_WINDOW_REF: InjectionToken<WrWindowRef<unknown, unknown>>;
 /** Resolves to the `data` passed in `WrWindowConfig.data`. */
 export declare const WR_WINDOW_DATA: InjectionToken<unknown>;
+type AnyRef$1 = WrWindowRef<unknown, unknown>;
 /**
  * What `WrWindowManager` needs from a `<wr-window-taskbar>` on the page: the
  * row a window's tab sits in, so focus can land on it when the window is
- * minimized and be recognised there when the window is closed from it.
+ * minimized and be recognised there when the window is closed from it, and
+ * the strip it covers, so maximized windows stop short of it.
  *
  * @internal
  */
 interface WrWindowTaskbarTabs {
-  /** The `.wr-window-taskbar__tab` row for `ref`, or `null` when this taskbar does not list it. */
-  tabFor(ref: WrWindowRef<unknown, unknown>): HTMLElement | null;
+  /**
+   * The `.wr-window-taskbar__tab` row for `ref`, the "+N" button when its tab is
+   * folded under one, or `null` when this taskbar does not list it.
+   */
+  tabFor(ref: AnyRef$1): HTMLElement | null;
+  /**
+   * Whether `ref`'s place in the rail is still moving: its tab has not been
+   * measured yet, or the render that folds or unfolds it has not happened. Focus
+   * waits for it rather than landing on a tab about to hide or a "+N" not drawn.
+   */
+  settling(ref: AnyRef$1): boolean;
+  /** Whether `node` is inside this taskbar. */
+  contains(node: Node): boolean;
+  /** The strip of the viewport this taskbar covers while it shows tabs, in px from each edge. */
+  readonly reserve: Signal<{
+    readonly top: number;
+    readonly bottom: number;
+  }>;
 }
 /**
- * Owns the open `<wr-window>` stack, hands out z-indexes, cascades the
- * default spawn position, and opens programmatic windows that wrap a
- * consumer component.
+ * Owns the open window stack, hands out z-indexes, tracks the active window,
+ * cascades the default spawn position, and opens windows that wrap a consumer
+ * component.
  *
  * Inject the singleton and call `open(component, config)` for a
  * dialog-style flow:
@@ -371,37 +785,65 @@ interface WrWindowTaskbarTabs {
  * const saved = await ref.afterClosed();
  * ```
  *
- * Declarative `<wr-window [(open)]="...">` instances also register with
- * the manager on focus, so both styles share the same stack ordering.
+ * There is no declarative `<wr-window>`: `open()` is the only way in, so every
+ * window shares this one stack.
  */
-export declare class WrWindowManager {
+export declare class WrWindowManager implements WrWindowRefHost {
   private readonly overlay;
   private readonly parentInjector;
   private readonly storage;
   private readonly isBrowser;
   private readonly dir;
+  private readonly defaults;
+  private readonly destroyRef;
   private readonly baseZ;
   private topZ;
   private openCount;
-  /** All open windows opened via `open()` — declarative `<wr-window>` is not tracked here. */
+  /** All open windows, in the order they opened. */
   private readonly _windows;
+  /** The window that has the keyboard, or `null`. */
+  private readonly _active;
   /**
    * Filled by `restoreLayout` right before it invokes the consumer's
    * opener callback. The next `open()` call with a matching `config.id`
-   * pops the entry and uses it as the initial geometry (so the seed
-   * lands at the saved coords instead of the cascade default) and
-   * applies any non-`normal` state after the bridges are wired.
+   * pops the entry and uses it as the initial geometry and state.
    */
   private readonly pendingRestores;
   /** The taskbars on the page, registered by each `<wr-window-taskbar>` for its lifetime. */
   private readonly taskbars;
-  /** All currently-open programmatic windows. */
+  /**
+   * ONE viewport for every window, kept by one `resize` listener. Each window
+   * used to add its own — twenty listeners for twenty windows, each writing its
+   * own copy of the same two numbers.
+   */
+  private readonly viewport;
+  /** Bumped when an element used as `bounds` may have moved: it resized, or something scrolled. */
+  private readonly layoutTick;
+  private listening;
+  private boundsObserver;
+  private readonly boundElements;
+  private readonly bumpLayout;
+  /** The strip the taskbars cover, edge by edge. */
+  private readonly reserve;
+  /** All currently-open windows, in the order they opened. */
   readonly windows: Signal<readonly WrWindowRef<unknown, unknown>[]>;
-  /** Programmatic windows that are minimized AND opted into the taskbar. */
+  /**
+   * The active window — the one that has the keyboard: the last one focused,
+   * clicked, opened with focus or switched to (since v15.1). `null` once focus
+   * moves to something on the page outside every window, and while the active
+   * window is minimized.
+   */
+  readonly active: Signal<WrWindowRef<unknown, unknown> | null>;
+  /** Windows that are minimized AND opted into the taskbar. */
   readonly minimized: Signal<WrWindowRef<unknown, unknown>[]>;
   /** Reserve the next z-index. Strictly increasing across the app's lifetime. */
   bringToFront(): number;
-  /** Cascade offset for new windows, so two opens don't perfectly overlap. */
+  /**
+   * Cascade offset for new windows, so two opens don't perfectly overlap: 30px
+   * a step from the work area's start edge, back to the start after ten, and
+   * each lap of ten shifted 15px along so window eleven does not land exactly
+   * on window one.
+   */
   nextStartOffset(): {
     readonly x: number;
     readonly y: number;
@@ -412,31 +854,62 @@ export declare class WrWindowManager {
    * its result.
    *
    * **Singleton by id** — if `config.id` is set and a window with that
-   * id is already open, the existing ref is restored (if minimized),
-   * brought to the front, and returned. No duplicate window is
+   * id is already open, that window is switched to (back from the taskbar,
+   * raised, focused) and its ref returned. No duplicate window is
    * created. Use this to coalesce repeated open() calls (e.g. a
    * "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>;
+  /**
+   * Switch to `ref`: back from the taskbar, raised, active, and — unless told
+   * otherwise — focused on the control it had last.
+   *
+   * @internal
+   */
+  _activate(ref: AnyRef$1, options?: {
+    readonly focus?: boolean;
+  }): void;
+  /**
+   * Put `ref` on top of the stack. A window already on top keeps its z: every
+   * click in a window used to take a new one, so the number climbed with each
+   * press and every press re-wrote the host's style.
+   *
+   * @internal
+   */
+  _raise(ref: AnyRef$1): void;
+  private setActive;
+  /**
+   * Focus decides the active window wherever it comes from: Tab into a window,
+   * a click on a field in it, a script calling `focus()`. A window that gains
+   * focus is raised too — a focused window hidden behind another is a window
+   * the user is typing into blind. Focus on a taskbar, or in another overlay,
+   * leaves the active window as it was; focus anywhere else on the page means
+   * none is.
+   */
+  private readonly onFocusIn;
+  /** Install the shared listeners, once, on the first open in a browser. */
+  private listen;
+  private boundsElement;
+  /**
+   * The work area for one window: its bounds, cut to the viewport, minus the
+   * strip a taskbar covers.
+   */
+  private workAreaFor;
+  /** Keep an element used as `bounds` measured while a window uses it. Returns the release. */
+  private observeBounds;
   /**
    * 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.
+   * The window holding real DOM focus owns the key. When focus is on NOTHING —
+   * `<body>`, which is where a click on a window's own text used to leave it —
+   * the active window owns it if it is on screen, else the front-most window on
+   * screen. When focus is anywhere else on the page, no window owns it: an
+   * Escape pressed in the page's own search field closed a window the reader
+   * was not in. That is the rule the non-modal drawer has always followed.
    *
    * A MINIMIZED window never owns a key it did not receive through focus, and
-   * never counts as being in front: it is `display: none`, so an Escape pressed
-   * on the page closed a window the user could not see — and threw away its
-   * taskbar entry with it — while the visible one stayed put.
-   *
-   * Focus on a taskbar tab is the minimized window's (as `holdsFocus` reads
-   * it), so NO window owns that key: a tab lists only minimized windows, and
-   * handing the key to the front-most one closed a window the reader was not
-   * in, right after minimizing had put them on the tab.
+   * never counts as being in front: it is `display: none`. Focus on a taskbar
+   * tab is on the page, so no window owns that key either.
    */
   private ownsKeyboard;
   /**
@@ -454,12 +927,41 @@ export declare class WrWindowManager {
    *
    * @internal
    */
-  _focusAfterMinimize(ref: WrWindowRef<unknown, unknown>): void;
+  _focusAfterMinimize(ref: AnyRef$1, attempt?: number): void;
   private taskbarTab;
   /** The focused element, or `null` when that is `<body>` or nothing. */
   private focusedElement;
   /** Whether focus is `ref`'s to hand back: inside it, on its taskbar tab, or nowhere. */
   private holdsFocus;
+  /** Windows on screen — not minimized. */
+  private onScreen;
+  /**
+   * Restore every window on screen and stack them down from the start edge of
+   * their work area, 30px apart, keeping each one's size and their order front
+   * to back (since v15.1).
+   */
+  cascade(): void;
+  /**
+   * Restore every window on screen and share the work area between them, in
+   * the order they opened: a grid (the default), side by side in columns, or
+   * stacked in rows. A row of a grid with fewer windows spreads them across its
+   * whole width. In a right-to-left page the first window takes the right
+   * (since v15.1).
+   */
+  tile(mode?: 'grid' | 'columns' | 'rows'): void;
+  /** Minimize every window on screen (since v15.1). */
+  minimizeAll(): void;
+  /** Bring every minimized window back, each to the state it was minimized from (since v15.1). */
+  restoreAll(): void;
+  /**
+   * Switch to the next window, in the order they opened, wrapping at the end —
+   * minimized windows included, which come back. Bind it to a hotkey from
+   * `ngwr/hotkey`, such as Ctrl+F6 (since v15.1).
+   */
+  activateNext(): void;
+  /** Switch to the previous window, the other way round from {@link activateNext} (since v15.1). */
+  activatePrevious(): void;
+  private cycle;
   /** Close every programmatically-opened window. */
   closeAll(): void;
   /** Look up an open window by its `config.id`. Returns `null` when no match. */
@@ -486,8 +988,9 @@ export declare class WrWindowManager {
    * matches, the geometry / state / title is re-applied immediately.
    * For misses, the optional `open` callback is invoked so the consumer
    * can re-open the right component for that id — the freshly-opened
-   * window then seeds straight to the saved geometry (no cascade flicker)
-   * and the saved state lands once the bridges are wired.
+   * window opens straight at the saved geometry and in the saved state, with
+   * no cascade flicker — fitted into the work area when this viewport is
+   * smaller than the one the layout was saved on.
    *
    * ```ts
    * manager.restoreLayout('default', (id, snap) => {
@@ -506,45 +1009,137 @@ export declare class WrWindowManager {
   static ɵfac: i0.ɵɵFactoryDeclaration<WrWindowManager, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+type AnyRef = WrWindowRef<unknown, unknown>;
 /**
  * OS-style window taskbar. Drop one anywhere in the app — typically
- * fixed to the bottom of the viewport — and it lists every window
- * `WrWindowManager.open()` has handed out that's currently
- * `minimized`. Clicking a tab restores the window; clicking the close
- * glyph dismisses it without restoring.
+ * fixed to the bottom of the viewport — and it lists the windows
+ * `WrWindowManager.open()` has handed out: the minimized ones by default,
+ * every open one with `show="all"`. Clicking a tab switches to its window;
+ * with `show="all"`, clicking the active window's tab minimizes it. The close
+ * glyph dismisses a window without restoring it.
+ *
+ * The rail is one Tab stop, a toolbar: the arrow keys move between its
+ * buttons, Home and End jump to the ends.
  *
  * Focus follows the window in and out of the rail: minimizing a window
  * that holds focus puts focus on its tab here, and restoring it from the
  * tab moves focus into the window.
  *
+ * While it shows tabs, the rail reserves its strip of the viewport, so a
+ * maximized or snapped window stops short of it.
+ *
+ * The rail stays one row. A tab is as wide as its title, up to
+ * `--wr-window-taskbar-tab-max-width`, and the tabs that do not fit — or every
+ * one past `maxTabs` — fold under a "+N" button at the end, which opens them as
+ * a menu. In `show="all"` the active window's tab is never folded.
+ *
  * Windows opted out via `config.taskbar = false` never show up here.
  *
  * @example
  * ```html
  * <wr-window-taskbar />
  * <wr-window-taskbar position="top" />
+ * <wr-window-taskbar show="all" />
+ * <wr-window-taskbar show="all" [maxTabs]="6" />
  * ```
  *
  * @see https://ngwr.dev/reference/components/window
  */
 export declare class WrWindowTaskbar {
-  /** @internal */ protected readonly railLabel: import("@angular/core").Signal<string>;
+  private readonly minimizedLabel;
+  private readonly allLabel;
   /** @internal */ protected readonly closeLabel: import("@angular/core").Signal<string>;
   /** @internal */ protected readonly untitled: import("@angular/core").Signal<string>;
   /** @internal */ protected readonly restoreLabel: (params?: import("ngwr/i18n").WrI18nParams) => string;
+  /** @internal */ protected readonly moreLabel: (params?: import("ngwr/i18n").WrI18nParams) => string;
   /** Edge the taskbar pins itself to. @default 'bottom' */
   readonly position: import("@angular/core").InputSignal<"top" | "bottom">;
+  /**
+   * Which windows the rail lists: the minimized ones, or every open one with
+   * the active window marked (since v15.1). @default 'minimized'
+   */
+  readonly show: import("@angular/core").InputSignal<WrWindowTaskbarShow>;
+  /**
+   * The most tabs the rail shows; the rest fold under a "+N" button that opens
+   * them as a menu (since v15.1). The width folds tabs too, whatever this says:
+   * the tabs that do not fit beside the button at their own width go under it.
+   * `null` leaves it to the width alone.
+   * @default null
+   */
+  readonly maxTabs: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
   private readonly manager;
-  /** @internal — minimized windows that haven't opted out via `taskbar: false`. */
+  private readonly host;
+  private readonly dir;
+  /** @internal */ protected readonly railLabel: import("@angular/core").Signal<string>;
+  /** @internal — the windows the rail lists, in the order they opened. */
   protected readonly items: import("@angular/core").Signal<WrWindowRef<unknown, unknown>[]>;
+  /** What the rail has to fit its tabs into — see {@link Room}. */
+  private readonly room;
+  /**
+   * The tabs the rail draws, in opening order: all of them while they fit and
+   * `maxTabs` allows it, otherwise the most that fit beside the "+N" button,
+   * never more than `maxTabs` and never fewer than one. The active window's tab
+   * takes the last place when it would otherwise fold, so the one tab
+   * `show="all"` marks is always in reach. A tab not measured yet counts as
+   * nothing, and the pass after its first render corrects that.
+   */
+  protected readonly visible: import("@angular/core").Signal<WrWindowRef<unknown, unknown>[]>;
+  /** @internal — each listed window's place among the drawn tabs, absent while it is folded. */
+  protected readonly slots: import("@angular/core").Signal<Map<WrWindowRef<unknown, unknown>, number>>;
+  /** @internal — the windows under the "+N" button, in opening order. */
+  protected readonly folded: import("@angular/core").Signal<WrWindowRef<unknown, unknown>[]>;
+  /** The "+N" menu opens away from the edge the rail is pinned to. */
+  protected readonly menuPosition: import("@angular/core").Signal<"top-end" | "bottom-end">;
   protected readonly classes: import("@angular/core").Signal<string>;
-  /** One row per entry of `items()`, in the same order. */
+  /**
+   * One row per entry of `items()`, in the same order. A folded window keeps its
+   * tab, laid out but hidden, which is how the rail knows its width.
+   */
   private readonly tabs;
+  private readonly more;
+  /**
+   * The rail's one Tab stop, as an index into its buttons: two per drawn tab,
+   * restore then close, and the "+N" button last.
+   */
+  private readonly rovingIndex;
+  private readonly stop;
+  /** The strip of the viewport the rail covers while it shows tabs. */
+  private readonly reserve;
   constructor();
   /** A window with no title still needs a name in the rail. */
-  protected tabTitle(ref: WrWindowRef<unknown, unknown>): string;
-  protected restore(ref: WrWindowRef<unknown, unknown>): void;
-  protected close(ref: WrWindowRef<unknown, unknown>, event: Event): void;
+  protected tabTitle(ref: AnyRef): string;
+  /** Whether `ref` is the active window and on screen — what `show="all"` marks. */
+  protected isCurrent(ref: AnyRef): boolean;
+  /** A minimized window's tab restores it; in `show="all"` the others' tabs switch to their window. */
+  protected tabLabel(ref: AnyRef): string;
+  protected tabIndex(button: number): number;
+  protected press(ref: AnyRef): void;
+  /** A window picked from the "+N" menu: the menu closes and the window comes forward, as from its tab. */
+  protected pick(ref: AnyRef, menu: WrDropdown): void;
+  protected close(ref: AnyRef, event: Event): void;
+  /** The toolbar pattern: arrows between buttons, Home and End to the ends, mirrored in RTL. */
+  protected onKeydown(event: KeyboardEvent): void;
+  /** A click or a script that focuses a button moves the Tab stop with it. */
+  protected onFocusIn(event: FocusEvent): void;
+  /** The drawn buttons in order — a folded tab's are hidden and out of the toolbar. */
+  private buttons;
+  private measure;
+  /**
+   * Read what the rail has to fit into. The host spans the viewport between its
+   * insets, so its width is the most the rail can take, and the gap comes from
+   * the stylesheet, so a consumer's hook is what the arithmetic uses.
+   *
+   * A tab's width is the one its title asks for, capped by its `max-width`. Every
+   * tab is laid out, a folded one too, so each can be read — and a tab drawn
+   * narrower than its title, squeezed as the only one left, is as wide as it is
+   * plus the part of the title it clips. That keeps the reading the same however
+   * the row is drawn, so a pass never feeds the next one a different answer.
+   *
+   * The "+N" button is measured once it is drawn — until then a tab's height
+   * stands in for its width, and the next pass corrects it. That converges: a
+   * wider button folds more, which can only keep its count's digits or add one.
+   */
+  private measureRoom;
   static ɵfac: i0.ɵɵFactoryDeclaration<WrWindowTaskbar, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<WrWindowTaskbar, "wr-window-taskbar", never, {
     "position": {
@@ -552,6 +1147,35 @@ export declare class WrWindowTaskbar {
       "required": false;
       "isSignal": true;
     };
+    "show": {
+      "alias": "show";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxTabs": {
+      "alias": "maxTabs";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, never, never, true, never>;
 }
-export type { WrWindowBeforeCloseHook, WrWindowChromeSize, WrWindowConfig, WrWindowLayoutSnapshot, WrWindowOs, WrWindowPersistMode, WrWindowSize, WrWindowSnap, WrWindowState, WrWindowStorageConfig };
+/**
+ * App-wide window defaults, as a feature of `provideWr()` — today the work area
+ * every window keeps inside, so maximized windows stop short of an app header.
+ * A window's own `WrWindowConfig.bounds` still wins.
+ *
+ * Bootstrap only: `WrWindowManager` is root-provided and reads it once, from
+ * the root injector, so in a route's `providers` it changes nothing.
+ *
+ * @example
+ * ```ts
+ * import { provideWr } from 'ngwr';
+ * import { withWindows } from 'ngwr/window';
+ *
+ * bootstrapApplication(App, {
+ *   providers: [provideWr(withWindows({ bounds: { top: 64 } }))],
+ * });
+ * ```
+ */
+export declare function withWindows(defaults: WrWindowDefaults): WrFeature<'windows'>;
+export type { WrWindowBeforeCloseHook, WrWindowBounds, WrWindowChromeSize, WrWindowConfig, WrWindowDefaults, WrWindowInsets, WrWindowLayoutSnapshot, WrWindowOs, WrWindowPersistMode, WrWindowSize, WrWindowSlotContent, WrWindowSlotContext, WrWindowSnap, WrWindowSnapTarget, WrWindowState, WrWindowStorageConfig, WrWindowTaskbarShow, WrWindowUpdate };