@franzzemen/brokenstock-shell 0.10.3 → 0.10.5

package/types/franzzemen-brokenstock-shell.d.ts

@@ -1,27 +1,25 @@
-import { ZodType } from 'zod/v4';
-import * as _angular_core from '@angular/core';
-import { InjectionToken, EnvironmentProviders, ElementRef, OnInit, Signal, OnDestroy } from '@angular/core';
-import { CanActivateFn, Router } from '@angular/router';
-import { HttpInterceptorFn } from '@angular/common/http';
-import { Validator, AbstractControl, ValidationErrors } from '@angular/forms';
-import { BearerToken } from '@franzzemen/utility';
-import { UserSession, SessionSummary, Credentials } from '@franzzemen/identity';
-import * as _franzzemen_brokenstock_shell from '@franzzemen/brokenstock-shell';
-import { AutofillEvent } from '@angular/cdk/text-field';
-import { MatDialogRef, MatDialog } from '@angular/material/dialog';
-
-type Severity = 'error' | 'warning' | 'info';
-interface CommandResult {
-    success: boolean;
-    message: string;
-    timestamp: Date;
-    severity?: Severity;
-    isHelp?: boolean;
-}
-interface CommandHistoryEntry {
-    input: string;
-    result: CommandResult;
-    repeatCount?: number;
+import { ZodType } from "zod/v4";
+import * as i0 from "@angular/core";
+import { ElementRef, EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal } from "@angular/core";
+import { CanActivateFn, Router } from "@angular/router";
+import { HttpInterceptorFn } from "@angular/common/http";
+import { AbstractControl, ValidationErrors, Validator } from "@angular/forms";
+import { BearerToken } from "@franzzemen/utility";
+import { Credentials, SessionSummary, UserSession } from "@franzzemen/identity";
+import { AutofillEvent } from "@angular/cdk/text-field";
+import { MatDialog, MatDialogRef } from "@angular/material/dialog";
+export type Severity = 'error' | 'warning' | 'info';
+export interface CommandResult {
+  success: boolean;
+  message: string;
+  timestamp: Date;
+  severity?: Severity;
+  isHelp?: boolean;
+}
+export interface CommandHistoryEntry {
+  input: string;
+  result: CommandResult;
+  repeatCount?: number;
 }
 /**
  * An alternate name for a command. Mirrors `CommandAlias` in
@@ -39,9 +37,9 @@ interface CommandHistoryEntry {
  * The real name is what `help` lists; alternates are named in the command's own
  * usage text. The registry refuses a name already taken, real or alternate.
  */
-interface CommandAlias {
-    readonly name: string;
-    readonly prependArgs?: readonly string[];
+export interface CommandAlias {
+  readonly name: string;
+  readonly prependArgs?: readonly string[];
 }
 /**
  * Where a command belongs. Mirrors `@franzzemen/brokenstock-lexicon`'s
@@ -54,36 +52,36 @@ interface CommandAlias {
  *  - `'refuse'`: the command depends on state only its screen sets; typed
  *    anywhere else the shell refuses with a message naming the screen.
  */
-interface RouteScope {
-    /** "the Trades screen" — used verbatim in refusals and in `help`. */
-    readonly screen: string;
-    /** Route patterns; see {@link matchesRoute}. */
-    readonly routes: readonly string[];
-    readonly elsewhere: 'navigate' | 'refuse';
-}
-type CommandScope = 'global' | RouteScope;
+export interface RouteScope {
+  /** "the Trades screen" — used verbatim in refusals and in `help`. */
+  readonly screen: string;
+  /** Route patterns; see {@link matchesRoute}. */
+  readonly routes: readonly string[];
+  readonly elsewhere: 'navigate' | 'refuse';
+}
+export type CommandScope = 'global' | RouteScope;
 /**
  * Does `url` fall inside any of `patterns`? Query string and fragment are
  * stripped; a pattern matches when the path equals it or continues past it at
  * a `/`; a `:param` segment matches any one non-empty segment. Same rule as
  * the lexicon's `matchesRoute`, tested there and here.
  */
-declare function matchesRoute(url: string, patterns: readonly string[]): boolean;
+export declare function matchesRoute(url: string, patterns: readonly string[]): boolean;
 /**
  * Lexicon entry: the platform-agnostic definition of a command.
  * Execution is provided by each consumer (Angular app, CLI app, etc.).
  */
-interface CommandLexiconEntry {
-    readonly name: string;
-    readonly description: string;
-    readonly usage: string;
-    readonly requiresAuth: boolean;
-    readonly argsSchema: ZodType;
-    /** Where the command belongs. Required: every command declares it. */
-    readonly scope: CommandScope;
-    /** Alternate names for this command. See {@link CommandAlias}. */
-    readonly aliases?: readonly CommandAlias[];
-    sanitizeInput?(input: string): string;
+export interface CommandLexiconEntry {
+  readonly name: string;
+  readonly description: string;
+  readonly usage: string;
+  readonly requiresAuth: boolean;
+  readonly argsSchema: ZodType;
+  /** Where the command belongs. Required: every command declares it. */
+  readonly scope: CommandScope;
+  /** Alternate names for this command. See {@link CommandAlias}. */
+  readonly aliases?: readonly CommandAlias[];
+  sanitizeInput?(input: string): string;
 }
 /**
  * Result of a command's readiness check. `reason` is surfaced verbatim to the
@@ -91,86 +89,84 @@ interface CommandLexiconEntry {
  * at all for an empty message, which would look like the command silently did
  * nothing.
  */
-interface CommandAvailability {
-    ok: boolean;
-    reason?: string;
+export interface CommandAvailability {
+  ok: boolean;
+  reason?: string;
 }
 /**
  * Full command definition including execution.
  */
-interface CommandDefinition extends CommandLexiconEntry {
-    /**
-     * Declarative readiness gate, checked centrally before `execute`. Use for
-     * preconditions the user can act on (entitlement, onboarding state) rather
-     * than checking imperatively as the first statement of `execute` — the
-     * framework can only annotate `help` for gates it can see.
-     *
-     * A command that fails this check stays listed in `help` and in
-     * tab-completion, annotated with its reason. Hiding it would read as a broken
-     * CLI; an explained refusal reads as guidance.
-     *
-     * Omit for always-available.
-     */
-    isAvailable?(): CommandAvailability;
-    execute(args: string[]): CommandResult | Promise<CommandResult>;
-}
-
-interface MenuItem {
-    icon: string;
-    label: string;
-    route: string;
-    command?: string;
-    /**
-     * ENTITLEMENT: "your plan includes this". False hides the item entirely.
-     * Omit for always-visible.
-     */
-    visible?: () => boolean;
-    /**
-     * READINESS: "you have the data this screen needs". False renders the item
-     * greyed and inert rather than hiding it — the user keeps seeing that the
-     * feature exists, and `disabledReason` tells them how to unlock it.
-     *
-     * Deliberately a SIBLING to `visible`, never folded into it: entitlement and
-     * readiness are different axes, and collapsing them loses the
-     * hidden-vs-greyed distinction that makes a locked item self-explaining.
-     *
-     * Omit for always-enabled.
-     */
-    enabled?: () => boolean;
-    /**
-     * Tooltip shown in place of `label` while `enabled()` is false. Must name the
-     * prerequisite ("Create a portfolio first"), because it is the ONLY channel
-     * through which a user learns why the icon is dead.
-     */
-    disabledReason?: () => string;
-    /**
-     * ATTENTION: something on this screen is waiting for the user ("2 imports waiting for you to
-     * identify a security"). A count drawn on the icon, and `tooltip` replacing the label's tooltip.
-     * Null, or a count of 0, draws nothing. Read from the template, so a signal-backed count updates live.
-     *
-     * Omit for an item that never needs attention.
-     */
-    badge?: () => MenuBadge | null;
-}
-interface MenuBadge {
-    count: number;
-    tooltip: string;
-}
-
-interface ShellAuthUrls {
-    login: string;
-    logout: string;
-    refresh: string;
-}
-declare const SHELL_APP_NAME: InjectionToken<string>;
-declare const SHELL_MENU_ITEMS: InjectionToken<MenuItem[]>;
-declare const SHELL_AUTH_URLS: InjectionToken<ShellAuthUrls>;
+export interface CommandDefinition extends CommandLexiconEntry {
+  /**
+   * Declarative readiness gate, checked centrally before `execute`. Use for
+   * preconditions the user can act on (entitlement, onboarding state) rather
+   * than checking imperatively as the first statement of `execute` — the
+   * framework can only annotate `help` for gates it can see.
+   *
+   * A command that fails this check stays listed in `help` and in
+   * tab-completion, annotated with its reason. Hiding it would read as a broken
+   * CLI; an explained refusal reads as guidance.
+   *
+   * Omit for always-available.
+   */
+  isAvailable?(): CommandAvailability;
+  execute(args: string[]): CommandResult | Promise<CommandResult>;
+}
+export interface MenuItem {
+  icon: string;
+  label: string;
+  route: string;
+  command?: string;
+  /**
+   * ENTITLEMENT: "your plan includes this". False hides the item entirely.
+   * Omit for always-visible.
+   */
+  visible?: () => boolean;
+  /**
+   * READINESS: "you have the data this screen needs". False renders the item
+   * greyed and inert rather than hiding it — the user keeps seeing that the
+   * feature exists, and `disabledReason` tells them how to unlock it.
+   *
+   * Deliberately a SIBLING to `visible`, never folded into it: entitlement and
+   * readiness are different axes, and collapsing them loses the
+   * hidden-vs-greyed distinction that makes a locked item self-explaining.
+   *
+   * Omit for always-enabled.
+   */
+  enabled?: () => boolean;
+  /**
+   * Tooltip shown in place of `label` while `enabled()` is false. Must name the
+   * prerequisite ("Create a portfolio first"), because it is the ONLY channel
+   * through which a user learns why the icon is dead.
+   */
+  disabledReason?: () => string;
+  /**
+   * ATTENTION: something on this screen is waiting for the user ("2 imports waiting for you to
+   * identify a security"). A count drawn on the icon, and `tooltip` replacing the label's tooltip.
+   * Null, or a count of 0, draws nothing. Read from the template, so a signal-backed count updates live.
+   *
+   * Omit for an item that never needs attention.
+   */
+  badge?: () => MenuBadge | null;
+}
+export interface MenuBadge {
+  count: number;
+  tooltip: string;
+}
+export interface ShellAuthUrls {
+  login: string;
+  logout: string;
+  refresh: string;
+}
+export declare const SHELL_APP_NAME: InjectionToken<string>;
+export declare const SHELL_MENU_ITEMS: InjectionToken<MenuItem[]>;
+export declare const SHELL_AUTH_URLS: InjectionToken<ShellAuthUrls>;
 /**
  * App-specific commands to register alongside the built-in command set.
  * Provide via provideShellConfig().
  */
-declare const SHELL_COMMANDS: InjectionToken<CommandDefinition[]>;
-declare const SHELL_POST_LOGIN_ROUTE: InjectionToken<string>;
+export declare const SHELL_COMMANDS: InjectionToken<CommandDefinition[]>;
+export declare const SHELL_POST_LOGIN_ROUTE: InjectionToken<string>;
 /**
  * Whether this app shares one session across every window of the browser
  * (multiple-windows PRD D2/D7).
@@ -182,88 +178,87 @@ declare const SHELL_POST_LOGIN_ROUTE: InjectionToken<string>;
  * different exposure — extending this to them is a separate decision, not a
  * default.
  */
-declare const SHELL_SHARED_SESSION: InjectionToken<boolean>;
-
-interface ShellConfig {
-    appName: string;
-    menuItems: MenuItem[];
-    authUrls: ShellAuthUrls;
-    commands?: CommandDefinition[];
-    /**
-     * Share one session across every window of the browser. Defaults to false.
-     * See {@link SHELL_SHARED_SESSION} for why this is opt-in.
-     */
-    sharedSession?: boolean;
-}
-declare function provideShellConfig(config: ShellConfig): EnvironmentProviders;
-
-declare const authGuard: CanActivateFn;
-
-declare const guestGuard: CanActivateFn;
-
-declare const authInterceptor: HttpInterceptorFn;
-
-declare class RegexValidatorDirective implements Validator {
-    regex: _angular_core.InputSignal<RegExp>;
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RegexValidatorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RegexValidatorDirective, "[regexValidator]", never, { "regex": { "alias": "regex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
+export declare const SHELL_SHARED_SESSION: InjectionToken<boolean>;
+export interface ShellConfig {
+  appName: string;
+  menuItems: MenuItem[];
+  authUrls: ShellAuthUrls;
+  commands?: CommandDefinition[];
+  /**
+   * Share one session across every window of the browser. Defaults to false.
+   * See {@link SHELL_SHARED_SESSION} for why this is opt-in.
+   */
+  sharedSession?: boolean;
+}
+export declare function provideShellConfig(config: ShellConfig): EnvironmentProviders;
+export declare const authGuard: CanActivateFn;
+export declare const guestGuard: CanActivateFn;
+export declare const authInterceptor: HttpInterceptorFn;
+export declare class RegexValidatorDirective implements Validator {
+  regex: import("@angular/core").InputSignal<RegExp>;
+  validate(control: AbstractControl): ValidationErrors | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RegexValidatorDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RegexValidatorDirective, "[regexValidator]", never, {
+    "regex": {
+      "alias": "regex";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /**
  * Shared types for the FAQ help system.
  *
  * Manifest is generated by the build-time validator (E9) and read at runtime
  * by FaqContentLoader (E1) and FaqService (E2).
  */
-type FaqAudience = 'public' | 'authenticated';
-type FaqRenderContext = 'modal' | 'page';
+export type FaqAudience = 'public' | 'authenticated';
+export type FaqRenderContext = 'modal' | 'page';
 /** Raw frontmatter as authored in the `.md` file. */
-interface FaqFrontmatter {
-    title: string;
-    category: string;
-    order?: number;
-    audience?: FaqAudience;
-    'image-prefix'?: string;
-    description?: string;
-    'seo-ready'?: boolean;
+export interface FaqFrontmatter {
+  title: string;
+  category: string;
+  order?: number;
+  audience?: FaqAudience;
+  'image-prefix'?: string;
+  description?: string;
+  'seo-ready'?: boolean;
 }
 /** One row in the generated manifest — normalized form of frontmatter + file path. */
-interface FaqEntry {
-    /** Dot-notation key, e.g. "trade.segments". */
-    key: string;
-    title: string;
-    category: string;
-    order: number;
-    audience: FaqAudience;
-    description?: string;
-    seoReady: boolean;
-    imagePrefix?: string;
-    /**
-     * Path to the source file relative to `/assets/faq/`, without `.md`.
-     * Example: `trade/segments` (subdirs allowed; key path-separator is `.`,
-     * file path-separator is `/`).
-     */
-    file: string;
-}
-interface FaqManifest {
-    /** ISO timestamp set by the validator at generation time. */
-    generatedAt: string;
-    entries: FaqEntry[];
-}
-interface ParsedFaq {
-    frontmatter: FaqFrontmatter;
-    body: string;
-}
-interface FaqRenderOptions {
-    context: FaqRenderContext;
-    /**
-     * Optional override for the entry's `image-prefix` frontmatter.
-     * When set, relative image hrefs are prefixed with this string.
-     */
-    imagePrefix?: string;
-}
-
+export interface FaqEntry {
+  /** Dot-notation key, e.g. "trade.segments". */
+  key: string;
+  title: string;
+  category: string;
+  order: number;
+  audience: FaqAudience;
+  description?: string;
+  seoReady: boolean;
+  imagePrefix?: string;
+  /**
+   * Path to the source file relative to `/assets/faq/`, without `.md`.
+   * Example: `trade/segments` (subdirs allowed; key path-separator is `.`,
+   * file path-separator is `/`).
+   */
+  file: string;
+}
+export interface FaqManifest {
+  /** ISO timestamp set by the validator at generation time. */
+  generatedAt: string;
+  entries: FaqEntry[];
+}
+export interface ParsedFaq {
+  frontmatter: FaqFrontmatter;
+  body: string;
+}
+export interface FaqRenderOptions {
+  context: FaqRenderContext;
+  /**
+   * Optional override for the entry's `image-prefix` frontmatter.
+   * When set, relative image hrefs are prefixed with this string.
+   */
+  imagePrefix?: string;
+}
 /**
  * Pluggable content source for FAQ markdown + manifest.
  *
@@ -272,17 +267,16 @@ interface FaqRenderOptions {
  * may override (e.g. broken-stock-admin pulling from an internal source),
  * but most apps will just use the HTTP default.
  */
-interface FaqContentLoader {
-    /** Loads (and may cache) the manifest. Idempotent. */
-    loadManifest(): Promise<FaqManifest>;
-    /**
-     * Resolves the manifest entry for `key`, then loads its .md body.
-     * Returns `null` when the key is not in the manifest.
-     */
-    loadContent(key: string): Promise<string | null>;
-}
-declare const FAQ_CONTENT_LOADER: InjectionToken<FaqContentLoader>;
-
+export interface FaqContentLoader {
+  /** Loads (and may cache) the manifest. Idempotent. */
+  loadManifest(): Promise<FaqManifest>;
+  /**
+   * Resolves the manifest entry for `key`, then loads its .md body.
+   * Returns `null` when the key is not in the manifest.
+   */
+  loadContent(key: string): Promise<string | null>;
+}
+export declare const FAQ_CONTENT_LOADER: InjectionToken<FaqContentLoader>;
 /**
  * Stateless markdown renderer for FAQ content.
  *
@@ -299,14 +293,13 @@ declare const FAQ_CONTENT_LOADER: InjectionToken<FaqContentLoader>;
  * In page context, links are emitted as plain navigable anchors; the prerendered
  * static HTML can be clicked through directly.
  */
-declare class FaqMarkdownRendererService {
-    parse(raw: string): ParsedFaq;
-    render(body: string, opts: FaqRenderOptions): string;
-    private buildRenderer;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaqMarkdownRendererService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FaqMarkdownRendererService>;
-}
-
+export declare class FaqMarkdownRendererService {
+  parse(raw: string): ParsedFaq;
+  render(body: string, opts: FaqRenderOptions): string;
+  private buildRenderer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FaqMarkdownRendererService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * Default FaqContentLoader. Reads the build-generated manifest from
  * `/assets/faq/manifest.json` and lazy-fetches individual `.md` files
@@ -314,32 +307,31 @@ declare class FaqMarkdownRendererService {
  *
  * Manifest is cached after first load; .md fetches are cached per key.
  */
-declare class HttpFaqContentLoader implements FaqContentLoader {
-    private readonly http;
-    private manifestPromise;
-    private readonly contentCache;
-    loadManifest(): Promise<FaqManifest>;
-    loadContent(key: string): Promise<string | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpFaqContentLoader, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HttpFaqContentLoader>;
-}
-
-interface FaqRegistrationHandle {
-    /** Call from the component's destroy hook (or DestroyRef) to clear the registration. */
-    deregister(): void;
-}
-interface FaqResolution {
-    /** The key that produced a content match, or `null` when nothing matched. */
-    key: string | null;
-    /** Raw .md content for `key`, or `null` when nothing matched. */
-    content: string | null;
-    /** The entry whose content was returned, or `null` when nothing matched. */
-    entry: FaqEntry | null;
-    /**
-     * The chain of keys actually attempted, in order
-     * (e.g. `["trade.segments", "trade", "index"]`).
-     */
-    attempted: string[];
+export declare class HttpFaqContentLoader implements FaqContentLoader {
+  private readonly http;
+  private manifestPromise;
+  private readonly contentCache;
+  loadManifest(): Promise<FaqManifest>;
+  loadContent(key: string): Promise<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HttpFaqContentLoader, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export interface FaqRegistrationHandle {
+  /** Call from the component's destroy hook (or DestroyRef) to clear the registration. */
+  deregister(): void;
+}
+export interface FaqResolution {
+  /** The key that produced a content match, or `null` when nothing matched. */
+  key: string | null;
+  /** Raw .md content for `key`, or `null` when nothing matched. */
+  content: string | null;
+  /** The entry whose content was returned, or `null` when nothing matched. */
+  entry: FaqEntry | null;
+  /**
+   * The chain of keys actually attempted, in order
+   * (e.g. `["trade.segments", "trade", "index"]`).
+   */
+  attempted: string[];
 }
 /**
  * Central FAQ state + resolution service.
@@ -351,82 +343,81 @@ interface FaqResolution {
  *  - Resolve a dot-notation key against the manifest with parent fallback,
  *    audience filtering, and `index` as the terminal fallback.
  */
-declare class FaqService {
-    private readonly loader;
-    private readonly history;
-    private readonly auth;
-    private readonly router;
-    private readonly _currentFaqKey;
-    /** Component-set current key. Bare `faq` opens at this key. */
-    readonly currentFaqKey: _angular_core.Signal<string | null>;
-    private readonly _manifest;
-    readonly manifest: _angular_core.Signal<FaqManifest | null>;
-    readonly entries: _angular_core.Signal<FaqEntry[]>;
-    private readonly _modalOpen;
-    readonly modalOpen: _angular_core.Signal<boolean>;
-    private readonly _activeEntry;
-    readonly activeEntry: _angular_core.Signal<FaqEntry | null>;
-    private readonly _activeContent;
-    readonly activeContent: _angular_core.Signal<string | null>;
-    private readonly _activeAttempted;
-    readonly activeAttempted: _angular_core.Signal<string[]>;
-    private readonly _navigating;
-    readonly navigating: _angular_core.Signal<boolean>;
-    private readonly _initialSearchTerm;
-    readonly initialSearchTerm: _angular_core.Signal<string | null>;
-    /** Called by the search UI once it has consumed the pre-fill term. */
-    consumeInitialSearchTerm(): void;
-    readonly canGoBack: _angular_core.Signal<boolean>;
-    readonly canGoForward: _angular_core.Signal<boolean>;
-    private manifestPromise;
-    /**
-     * Triggers manifest load if not already loaded. Idempotent. Subsequent
-     * calls return the cached promise.
-     */
-    ensureManifest(): Promise<FaqManifest>;
-    /**
-     * Walks the dot-notation fallback chain (`a.b.c` → `a.b` → `a` → `index`)
-     * and returns the first entry whose audience allows the caller and whose
-     * content loads. Audience filtering: unauthenticated callers only see
-     * `audience: public` entries.
-     */
-    resolveKey(key: string | null, isAuthenticated: boolean): Promise<FaqResolution>;
-    /**
-     * Component registration. Sets `currentFaqKey`; on `deregister()` the
-     * key is cleared only if it still matches (so a sibling tab activating
-     * mid-teardown doesn't get its key clobbered).
-     */
-    register(key: string): FaqRegistrationHandle;
-    /**
-     * E3 — Open the FAQ modal. If `initialKey` is omitted, falls back to
-     * `currentFaqKey` and then to `'index'`. Resolves the key, loads content,
-     * and starts an E8 history session so subsequent in-modal nav uses
-     * `history.pushState`.
-     */
-    openModal(initialKey?: string, opts?: {
-        searchTerm?: string;
-    }): Promise<void>;
-    /**
-     * Programmatic in-modal nav. Pushes a new history entry and loads `key`
-     * into the active slot. Use this for click handlers on `faq:` links and
-     * for the TOC sidebar.
-     */
-    navigateTo(key: string): Promise<void>;
-    back(): void;
-    forward(): void;
-    /**
-     * Close button / Esc / backdrop close. Unwinds the FAQ history entries
-     * so the underlying app route is left untouched.
-     */
-    closeModal(): void;
-    private finalizeClose;
-    private loadIntoActive;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaqService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FaqService>;
-}
-declare function buildFallbackChain(key: string | null): string[];
-declare function audienceAllowed(audience: FaqAudience, isAuthenticated: boolean): boolean;
-
+export declare class FaqService {
+  private readonly loader;
+  private readonly history;
+  private readonly auth;
+  private readonly router;
+  private readonly _currentFaqKey;
+  /** Component-set current key. Bare `faq` opens at this key. */
+  readonly currentFaqKey: import("@angular/core").Signal<string | null>;
+  private readonly _manifest;
+  readonly manifest: import("@angular/core").Signal<FaqManifest | null>;
+  readonly entries: import("@angular/core").Signal<FaqEntry[]>;
+  private readonly _modalOpen;
+  readonly modalOpen: import("@angular/core").Signal<boolean>;
+  private readonly _activeEntry;
+  readonly activeEntry: import("@angular/core").Signal<FaqEntry | null>;
+  private readonly _activeContent;
+  readonly activeContent: import("@angular/core").Signal<string | null>;
+  private readonly _activeAttempted;
+  readonly activeAttempted: import("@angular/core").Signal<string[]>;
+  private readonly _navigating;
+  readonly navigating: import("@angular/core").Signal<boolean>;
+  private readonly _initialSearchTerm;
+  readonly initialSearchTerm: import("@angular/core").Signal<string | null>;
+  /** Called by the search UI once it has consumed the pre-fill term. */
+  consumeInitialSearchTerm(): void;
+  readonly canGoBack: import("@angular/core").Signal<boolean>;
+  readonly canGoForward: import("@angular/core").Signal<boolean>;
+  private manifestPromise;
+  /**
+   * Triggers manifest load if not already loaded. Idempotent. Subsequent
+   * calls return the cached promise.
+   */
+  ensureManifest(): Promise<FaqManifest>;
+  /**
+   * Walks the dot-notation fallback chain (`a.b.c` → `a.b` → `a` → `index`)
+   * and returns the first entry whose audience allows the caller and whose
+   * content loads. Audience filtering: unauthenticated callers only see
+   * `audience: public` entries.
+   */
+  resolveKey(key: string | null, isAuthenticated: boolean): Promise<FaqResolution>;
+  /**
+   * Component registration. Sets `currentFaqKey`; on `deregister()` the
+   * key is cleared only if it still matches (so a sibling tab activating
+   * mid-teardown doesn't get its key clobbered).
+   */
+  register(key: string): FaqRegistrationHandle;
+  /**
+   * E3 — Open the FAQ modal. If `initialKey` is omitted, falls back to
+   * `currentFaqKey` and then to `'index'`. Resolves the key, loads content,
+   * and starts an E8 history session so subsequent in-modal nav uses
+   * `history.pushState`.
+   */
+  openModal(initialKey?: string, opts?: {
+    searchTerm?: string;
+  }): Promise<void>;
+  /**
+   * Programmatic in-modal nav. Pushes a new history entry and loads `key`
+   * into the active slot. Use this for click handlers on `faq:` links and
+   * for the TOC sidebar.
+   */
+  navigateTo(key: string): Promise<void>;
+  back(): void;
+  forward(): void;
+  /**
+   * Close button / Esc / backdrop close. Unwinds the FAQ history entries
+   * so the underlying app route is left untouched.
+   */
+  closeModal(): void;
+  private finalizeClose;
+  private loadIntoActive;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FaqService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare function buildFallbackChain(key: string | null): string[];
+export declare function audienceAllowed(audience: FaqAudience, isAuthenticated: boolean): boolean;
 /**
  * E8 — In-modal navigation history.
  *
@@ -446,57 +437,56 @@ declare function audienceAllowed(audience: FaqAudience, isAuthenticated: boolean
  *   to unwind our entries; suppress in-flight popstates while unwinding;
  *   finalize close once we've seen the expected number of popstates.
  */
-declare class FaqHistoryService {
-    private readonly _stack;
-    private readonly _position;
-    readonly stack: _angular_core.Signal<string[]>;
-    readonly position: _angular_core.Signal<number>;
-    /** True when popstate is processing the unwind kicked off by closeAndUnwind(). */
-    private unwinding;
-    private unwindRemaining;
-    private onUnwindComplete;
-    private popstateListener;
-    private onInModalNav;
-    private onExitModal;
-    /**
-     * Begin a new FAQ history session. Pushes the initial state entry and
-     * starts listening for popstate. Callbacks fire for in-modal navs and
-     * for popping out of FAQ entirely.
-     */
-    begin(initialKey: string, onNav: (key: string) => void, onExit: () => void): void;
-    /** Push a new key onto the stack. Truncates any forward history. */
-    navigate(key: string): void;
-    canGoBack(): boolean;
-    canGoForward(): boolean;
-    /** Programmatic back — triggers a real browser back so popstate handles UI. */
-    back(): void;
-    forward(): void;
-    /** Currently rendered key. */
-    currentKey(): string | null;
-    /**
-     * Close the modal cleanly by unwinding our FAQ history entries so the
-     * underlying app route is left exactly where it was before the modal opened.
-     * `onComplete` fires after the unwind settles.
-     */
-    closeAndUnwind(onComplete: () => void): void;
-    private teardown;
-    private pushHistoryState;
-    private attachListener;
-    private detachListener;
-    private handlePopState;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaqHistoryService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FaqHistoryService>;
-}
-
+export declare class FaqHistoryService {
+  private readonly _stack;
+  private readonly _position;
+  readonly stack: import("@angular/core").Signal<string[]>;
+  readonly position: import("@angular/core").Signal<number>;
+  /** True when popstate is processing the unwind kicked off by closeAndUnwind(). */
+  private unwinding;
+  private unwindRemaining;
+  private onUnwindComplete;
+  private popstateListener;
+  private onInModalNav;
+  private onExitModal;
+  /**
+   * Begin a new FAQ history session. Pushes the initial state entry and
+   * starts listening for popstate. Callbacks fire for in-modal navs and
+   * for popping out of FAQ entirely.
+   */
+  begin(initialKey: string, onNav: (key: string) => void, onExit: () => void): void;
+  /** Push a new key onto the stack. Truncates any forward history. */
+  navigate(key: string): void;
+  canGoBack(): boolean;
+  canGoForward(): boolean;
+  /** Programmatic back — triggers a real browser back so popstate handles UI. */
+  back(): void;
+  forward(): void;
+  /** Currently rendered key. */
+  currentKey(): string | null;
+  /**
+   * Close the modal cleanly by unwinding our FAQ history entries so the
+   * underlying app route is left exactly where it was before the modal opened.
+   * `onComplete` fires after the unwind settles.
+   */
+  closeAndUnwind(onComplete: () => void): void;
+  private teardown;
+  private pushHistoryState;
+  private attachListener;
+  private detachListener;
+  private handlePopState;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FaqHistoryService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 interface TocGroup {
-    category: string;
-    entries: FaqEntry[];
+  category: string;
+  entries: FaqEntry[];
 }
 interface SearchResult {
-    key: string;
-    title: string;
-    category: string;
-    snippet: string;
+  key: string;
+  title: string;
+  category: string;
+  snippet: string;
 }
 /**
  * E3 — FAQ modal. Two-pane layout (TOC sidebar + content pane), 80% viewport.
@@ -509,53 +499,52 @@ interface SearchResult {
  * returnUrl-aware `authGuard` funnels unauthenticated users through
  * `/login?returnUrl=...`, and `Login` honors returnUrl on success.
  */
-declare class FaqModal {
-    readonly devMode: boolean;
-    private readonly faq;
-    private readonly renderer;
-    private readonly auth;
-    private readonly router;
-    private readonly loader;
-    readonly open: _angular_core.Signal<boolean>;
-    readonly navigating: _angular_core.Signal<boolean>;
-    readonly activeEntry: _angular_core.Signal<FaqEntry | null>;
-    readonly attempted: _angular_core.Signal<string[]>;
-    readonly canGoBack: _angular_core.Signal<boolean>;
-    readonly canGoForward: _angular_core.Signal<boolean>;
-    readonly sidebarCollapsed: _angular_core.WritableSignal<boolean>;
-    readonly searchMode: _angular_core.WritableSignal<boolean>;
-    readonly searchQuery: _angular_core.WritableSignal<string>;
-    readonly searchLoading: _angular_core.WritableSignal<boolean>;
-    readonly searchResults: _angular_core.WritableSignal<SearchResult[]>;
-    private fuse;
-    private fuseBuild;
-    readonly renderedHtml: _angular_core.Signal<string>;
-    readonly toc: _angular_core.Signal<TocGroup[]>;
-    contentPaneRef?: ElementRef<HTMLDivElement>;
-    constructor();
-    onEscape(): void;
-    close(): void;
-    onBackdropClick(): void;
-    stopPropagation(event: Event): void;
-    toggleSidebar(): void;
-    goBack(): void;
-    goForward(): void;
-    goIndex(): void;
-    toggleSearch(): void;
-    onSearchInput(event: Event): void;
-    onSearchResultClick(key: string): void;
-    onTocClick(key: string): void;
-    private ensureSearchIndex;
-    private runSearch;
-    /**
-     * Event-delegated click handler for the rendered content pane.
-     * Intercepts our sentinel anchors emitted by FaqMarkdownRendererService.
-     */
-    onContentClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaqModal, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FaqModal, "faq-modal", never, {}, {}, never, never, true, never>;
-}
-
+export declare class FaqModal {
+  readonly devMode: boolean;
+  private readonly faq;
+  private readonly renderer;
+  private readonly auth;
+  private readonly router;
+  private readonly loader;
+  readonly open: import("@angular/core").Signal<boolean>;
+  readonly navigating: import("@angular/core").Signal<boolean>;
+  readonly activeEntry: import("@angular/core").Signal<FaqEntry | null>;
+  readonly attempted: import("@angular/core").Signal<string[]>;
+  readonly canGoBack: import("@angular/core").Signal<boolean>;
+  readonly canGoForward: import("@angular/core").Signal<boolean>;
+  readonly sidebarCollapsed: import("@angular/core").WritableSignal<boolean>;
+  readonly searchMode: import("@angular/core").WritableSignal<boolean>;
+  readonly searchQuery: import("@angular/core").WritableSignal<string>;
+  readonly searchLoading: import("@angular/core").WritableSignal<boolean>;
+  readonly searchResults: import("@angular/core").WritableSignal<SearchResult[]>;
+  private fuse;
+  private fuseBuild;
+  readonly renderedHtml: import("@angular/core").Signal<string>;
+  readonly toc: import("@angular/core").Signal<TocGroup[]>;
+  contentPaneRef?: ElementRef<HTMLDivElement>;
+  constructor();
+  onEscape(): void;
+  close(): void;
+  onBackdropClick(): void;
+  stopPropagation(event: Event): void;
+  toggleSidebar(): void;
+  goBack(): void;
+  goForward(): void;
+  goIndex(): void;
+  toggleSearch(): void;
+  onSearchInput(event: Event): void;
+  onSearchResultClick(key: string): void;
+  onTocClick(key: string): void;
+  private ensureSearchIndex;
+  private runSearch;
+  /**
+   * Event-delegated click handler for the rendered content pane.
+   * Intercepts our sentinel anchors emitted by FaqMarkdownRendererService.
+   */
+  onContentClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FaqModal, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FaqModal, "faq-modal", never, {}, {}, never, never, true, never>;
+}
 /**
  * Gate for the dev-only FAQ authoring panel (E11).
  *
@@ -567,21 +556,20 @@ declare class FaqModal {
  * The panel is loaded via dynamic `import()` and lives in its own lazy chunk;
  * builds where this resolves to `false` never request the chunk.
  */
-declare const FAQ_DEV_MODE: InjectionToken<boolean>;
+export declare const FAQ_DEV_MODE: InjectionToken<boolean>;
 /**
  * Optional absolute filesystem root of the consuming app's workspace (e.g.
  * `/Users/foo/dev/broken-stock`). When set, the authoring panel emits
  * `webstorm://open?file=<root>/<relative-path>` deeplinks pointing at the
  * exact source file. When unset, the panel falls back to a relative path.
  */
-declare const FAQ_DEV_WORKSPACE_ROOT: InjectionToken<string>;
+export declare const FAQ_DEV_WORKSPACE_ROOT: InjectionToken<string>;
 /**
  * Editor URL scheme for the "Open in editor" deeplink. Defaults to WebStorm.
  * Set to `'vscode'` (or any custom scheme handler) per consuming app.
  */
-type FaqDevEditor = 'webstorm' | 'vscode';
-declare const FAQ_DEV_EDITOR: InjectionToken<FaqDevEditor>;
-
+export type FaqDevEditor = 'webstorm' | 'vscode';
+export declare const FAQ_DEV_EDITOR: InjectionToken<FaqDevEditor>;
 /**
  * E11 — Dev-only FAQ authoring panel.
  *
@@ -594,45 +582,65 @@ declare const FAQ_DEV_EDITOR: InjectionToken<FaqDevEditor>;
  * The panel never imports `environment.*` directly — gating is the modal's
  * responsibility (via the FAQ_DEV_MODE token + dynamic import).
  */
-declare class FaqAuthoringPanel {
-    private readonly faq;
-    private readonly workspaceRoot;
-    private readonly editor;
-    /** `'missing'` shows the full scaffold; `'existing'` shows the collapsed strip. */
-    readonly mode: _angular_core.InputSignal<"missing" | "existing">;
-    /**
-     * The dot-notation key actually being authored. For `missing` mode this is
-     * the deepest attempted key (chain[0]); for `existing` it's the resolved key.
-     */
-    readonly key: _angular_core.InputSignal<string>;
-    /** Fallback chain that was attempted. For `missing` every entry is missing. */
-    readonly attempted: _angular_core.InputSignal<string[]>;
-    /** Resolved entry — only set in `existing` mode. */
-    readonly entry: _angular_core.InputSignal<FaqEntry | null>;
-    readonly expanded: _angular_core.WritableSignal<boolean>;
-    readonly showAllFiles: _angular_core.WritableSignal<boolean>;
-    readonly copyState: _angular_core.WritableSignal<string | null>;
-    readonly relPath: _angular_core.Signal<string>;
-    readonly absPath: _angular_core.Signal<string>;
-    readonly editorHref: _angular_core.Signal<string>;
-    readonly editorLabel: _angular_core.Signal<"Open in VS Code" | "Open in WebStorm">;
-    readonly scaffoldCmd: _angular_core.Signal<string>;
-    readonly frontmatterScaffold: _angular_core.Signal<string>;
-    readonly allEntries: _angular_core.Signal<FaqEntry[]>;
-    readonly missedChain: _angular_core.Signal<{
-        key: string;
-        present: boolean;
-    }[]>;
-    toggleExpanded(): void;
-    toggleAllFiles(): void;
-    copy(text: string, label: string): Promise<void>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaqAuthoringPanel, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FaqAuthoringPanel, "faq-authoring-panel", never, { "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "attempted": { "alias": "attempted"; "required": false; "isSignal": true; }; "entry": { "alias": "entry"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
+export declare class FaqAuthoringPanel {
+  private readonly faq;
+  private readonly workspaceRoot;
+  private readonly editor;
+  /** `'missing'` shows the full scaffold; `'existing'` shows the collapsed strip. */
+  readonly mode: import("@angular/core").InputSignal<"missing" | "existing">;
+  /**
+   * The dot-notation key actually being authored. For `missing` mode this is
+   * the deepest attempted key (chain[0]); for `existing` it's the resolved key.
+   */
+  readonly key: import("@angular/core").InputSignal<string>;
+  /** Fallback chain that was attempted. For `missing` every entry is missing. */
+  readonly attempted: import("@angular/core").InputSignal<string[]>;
+  /** Resolved entry — only set in `existing` mode. */
+  readonly entry: import("@angular/core").InputSignal<FaqEntry | null>;
+  readonly expanded: import("@angular/core").WritableSignal<boolean>;
+  readonly showAllFiles: import("@angular/core").WritableSignal<boolean>;
+  readonly copyState: import("@angular/core").WritableSignal<string | null>;
+  readonly relPath: import("@angular/core").Signal<string>;
+  readonly absPath: import("@angular/core").Signal<string>;
+  readonly editorHref: import("@angular/core").Signal<string>;
+  readonly editorLabel: import("@angular/core").Signal<"Open in VS Code" | "Open in WebStorm">;
+  readonly scaffoldCmd: import("@angular/core").Signal<string>;
+  readonly frontmatterScaffold: import("@angular/core").Signal<string>;
+  readonly allEntries: import("@angular/core").Signal<FaqEntry[]>;
+  readonly missedChain: import("@angular/core").Signal<{
+    key: string;
+    present: boolean;
+  }[]>;
+  toggleExpanded(): void;
+  toggleAllFiles(): void;
+  copy(text: string, label: string): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FaqAuthoringPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FaqAuthoringPanel, "faq-authoring-panel", never, {
+    "mode": {
+      "alias": "mode";
+      "required": true;
+      "isSignal": true;
+    };
+    "key": {
+      "alias": "key";
+      "required": true;
+      "isSignal": true;
+    };
+    "attempted": {
+      "alias": "attempted";
+      "required": false;
+      "isSignal": true;
+    };
+    "entry": {
+      "alias": "entry";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 interface CategoryGroup$1 {
-    category: string;
-    entries: FaqEntry[];
+  category: string;
+  entries: FaqEntry[];
 }
 /**
  * Public, SEO-targeted FAQ index. Prerendered at build time on the
@@ -644,23 +652,22 @@ interface CategoryGroup$1 {
  * JSON-LD (E18): emits a schema.org CollectionPage referencing
  * each child entry as an ItemList.
  */
-declare class PublicFaqIndex implements OnInit {
-    private readonly loader;
-    private readonly title;
-    private readonly meta;
-    private readonly siteBase;
-    private readonly publisher;
-    private readonly _entries;
-    readonly loading: _angular_core.WritableSignal<boolean>;
-    readonly visibleEntries: _angular_core.Signal<FaqEntry[]>;
-    readonly groups: _angular_core.Signal<CategoryGroup$1[]>;
-    readonly jsonLd: _angular_core.Signal<string | null>;
-    ngOnInit(): Promise<void>;
-    private applyMeta;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PublicFaqIndex, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PublicFaqIndex, "public-faq-index", never, {}, {}, never, never, true, never>;
-}
-
+export declare class PublicFaqIndex implements OnInit {
+  private readonly loader;
+  private readonly title;
+  private readonly meta;
+  private readonly siteBase;
+  private readonly publisher;
+  private readonly _entries;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly visibleEntries: import("@angular/core").Signal<FaqEntry[]>;
+  readonly groups: import("@angular/core").Signal<CategoryGroup$1[]>;
+  readonly jsonLd: import("@angular/core").Signal<string | null>;
+  ngOnInit(): Promise<void>;
+  private applyMeta;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PublicFaqIndex, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PublicFaqIndex, "public-faq-index", never, {}, {}, never, never, true, never>;
+}
 /**
  * Public, SEO-targeted FAQ page. Prerendered at build time per
  * qualifying manifest entry (e.g. /help/landing, /help/trade/segments).
@@ -675,31 +682,30 @@ declare class PublicFaqIndex implements OnInit {
  * raw JSON has `<` escaped to `<` so a stray `</script>` inside
  * data won't break the surrounding tag.
  */
-declare class PublicFaqPage implements OnInit {
-    private readonly route;
-    private readonly loader;
-    private readonly renderer;
-    private readonly title;
-    private readonly meta;
-    private readonly siteBase;
-    private readonly publisher;
-    readonly entry: _angular_core.WritableSignal<FaqEntry | null>;
-    readonly body: _angular_core.WritableSignal<string>;
-    readonly loading: _angular_core.WritableSignal<boolean>;
-    readonly activeFile: _angular_core.Signal<string | undefined>;
-    readonly renderedHtml: _angular_core.Signal<string>;
-    readonly jsonLd: _angular_core.Signal<string | null>;
-    ngOnInit(): Promise<void>;
-    private applyMeta;
-    private applyNotFoundMeta;
-    private canonicalUrl;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PublicFaqPage, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PublicFaqPage, "public-faq-page", never, {}, {}, never, never, true, never>;
-}
-
+export declare class PublicFaqPage implements OnInit {
+  private readonly route;
+  private readonly loader;
+  private readonly renderer;
+  private readonly title;
+  private readonly meta;
+  private readonly siteBase;
+  private readonly publisher;
+  readonly entry: import("@angular/core").WritableSignal<FaqEntry | null>;
+  readonly body: import("@angular/core").WritableSignal<string>;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly activeFile: import("@angular/core").Signal<string | undefined>;
+  readonly renderedHtml: import("@angular/core").Signal<string>;
+  readonly jsonLd: import("@angular/core").Signal<string | null>;
+  ngOnInit(): Promise<void>;
+  private applyMeta;
+  private applyNotFoundMeta;
+  private canonicalUrl;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PublicFaqPage, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PublicFaqPage, "public-faq-page", never, {}, {}, never, never, true, never>;
+}
 interface CategoryGroup {
-    category: string;
-    entries: FaqEntry[];
+  category: string;
+  entries: FaqEntry[];
 }
 /**
  * Shared TOC sidebar for the public /help pages. Lists every
@@ -710,17 +716,22 @@ interface CategoryGroup {
  * because the index page (`/help`) and entry pages
  * (`/help/<file>`) all share this sidebar.
  */
-declare class PublicFaqToc implements OnInit {
-    private readonly loader;
-    /** Currently-active entry file path (e.g. `landing`). Empty/undefined on the index. */
-    readonly activeFile: _angular_core.InputSignal<string | undefined>;
-    private readonly _entries;
-    readonly groups: _angular_core.Signal<CategoryGroup[]>;
-    ngOnInit(): Promise<void>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PublicFaqToc, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PublicFaqToc, "public-faq-toc", never, { "activeFile": { "alias": "activeFile"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
+export declare class PublicFaqToc implements OnInit {
+  private readonly loader;
+  /** Currently-active entry file path (e.g. `landing`). Empty/undefined on the index. */
+  readonly activeFile: import("@angular/core").InputSignal<string | undefined>;
+  private readonly _entries;
+  readonly groups: import("@angular/core").Signal<CategoryGroup[]>;
+  ngOnInit(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PublicFaqToc, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PublicFaqToc, "public-faq-toc", never, {
+    "activeFile": {
+      "alias": "activeFile";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /**
  * Canonical public base URL (no trailing slash) used for OpenGraph,
  * Twitter, JSON-LD canonical URLs, and sitemap entries on the
@@ -728,86 +739,81 @@ declare class PublicFaqToc implements OnInit {
  * `og:url` etc. when unset, which is fine for previewing but
  * suboptimal for production SEO. Consumer apps should override.
  */
-declare const FAQ_PUBLIC_SITE_BASE_URL: InjectionToken<string>;
+export declare const FAQ_PUBLIC_SITE_BASE_URL: InjectionToken<string>;
 /**
  * Publisher / author Organization embedded in schema.org JSON-LD on
  * public FAQ pages. `logo` is optional — Google's validator warns but
  * does not error when omitted. Add it later via a one-line provider
  * override.
  */
-interface FaqPublicPublisher {
-    name: string;
-    url?: string;
-    logo?: string;
-}
-declare const FAQ_PUBLIC_PUBLISHER: InjectionToken<FaqPublicPublisher>;
-
-declare class ThinkingService {
-    #private;
-    readonly isThinking: _angular_core.Signal<boolean>;
-    startThinking(): void;
-    stopThinking(): void;
-    reset(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThinkingService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThinkingService>;
-}
-
+export interface FaqPublicPublisher {
+  name: string;
+  url?: string;
+  logo?: string;
+}
+export declare const FAQ_PUBLIC_PUBLISHER: InjectionToken<FaqPublicPublisher>;
+export declare class ThinkingService {
+  #private;
+  readonly isThinking: import("@angular/core").Signal<boolean>;
+  startThinking(): void;
+  stopThinking(): void;
+  reset(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ThinkingService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /** Deliberately outside `bs.pref.` — see the header. */
-declare const SESSION_TOKEN_KEY = "bs.auth.token";
-declare class SessionTokenStore {
-    #private;
-    get available(): boolean;
-    /**
-     * The stored token, or undefined.
-     *
-     * A stored value that is not a well-formed bearer is treated as absent and
-     * removed. It cannot be authenticated with, and leaving it there would make
-     * every later read fail the same way with nothing to explain it.
-     */
-    read(): BearerToken | undefined;
-    /**
-     * Stores the token. THROWS on failure — see the header.
-     *
-     * @throws if the value is not a bearer token, or the write does not stick.
-     */
-    write(token: BearerToken): void;
-    clear(): void;
-    /**
-     * Calls back when ANOTHER window changes the token.
-     *
-     * `storage` does not fire in the window that made the change, which is
-     * correct — that window is the one doing it and has already acted.
-     *
-     * ⚠ `event.key === null` is what `localStorage.clear()` produces, and it means
-     * everything went, this key included. Treating it as "not our key" is how a
-     * whole-storage clear silently fails to sign the user out.
-     */
-    onExternalChange(handler: (token: BearerToken | undefined) => void): () => void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SessionTokenStore, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SessionTokenStore>;
-}
-
-type RenewalDecision = 
+export declare const SESSION_TOKEN_KEY = "bs.auth.token";
+export declare class SessionTokenStore {
+  #private;
+  get available(): boolean;
+  /**
+   * The stored token, or undefined.
+   *
+   * A stored value that is not a well-formed bearer is treated as absent and
+   * removed. It cannot be authenticated with, and leaving it there would make
+   * every later read fail the same way with nothing to explain it.
+   */
+  read(): BearerToken | undefined;
+  /**
+   * Stores the token. THROWS on failure — see the header.
+   *
+   * @throws if the value is not a bearer token, or the write does not stick.
+   */
+  write(token: BearerToken): void;
+  clear(): void;
+  /**
+   * Calls back when ANOTHER window changes the token.
+   *
+   * `storage` does not fire in the window that made the change, which is
+   * correct — that window is the one doing it and has already acted.
+   *
+   * ⚠ `event.key === null` is what `localStorage.clear()` produces, and it means
+   * everything went, this key included. Treating it as "not our key" is how a
+   * whole-storage clear silently fails to sign the user out.
+   */
+  onExternalChange(handler: (token: BearerToken | undefined) => void): () => void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SessionTokenStore, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type RenewalDecision =
 /** The token is gone: the window that renewed failed permanently, or signed out. */
-'sign-out'
+'sign-out' |
 /** Another window renewed while we queued. Take its token; do NOT rotate again. */
- | 'adopt'
+'adopt' |
 /** Nothing has moved. This window performs the renewal itself. */
- | 'renew';
+'renew';
 /**
  * @param before  the token this window held immediately BEFORE asking for the lock
  * @param current the token in shared storage now that this window can act
  */
-declare function decideRenewal(before: BearerToken | undefined, current: BearerToken | undefined): RenewalDecision;
-
-type ThemeMode = 'dark';
-declare class ThemeService {
-    readonly mode: _angular_core.WritableSignal<"dark">;
-    readonly isDark: _angular_core.Signal<boolean>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
-}
-
+export declare function decideRenewal(before: BearerToken | undefined, current: BearerToken | undefined): RenewalDecision;
+export type ThemeMode = 'dark';
+export declare class ThemeService {
+  readonly mode: import("@angular/core").WritableSignal<"dark">;
+  readonly isDark: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * Asks the command box to take the cursor. Called by the shell after most
  * actions (rail choices, Log Out, ?, ⧉, Escape, sign-in) and by apps.
@@ -819,14 +825,13 @@ declare class ThemeService {
  * is refused. Refusing it at the source also means a request made on a phone is
  * not left counted up, to be acted on after a rotation to a wider screen.
  */
-declare class TerminalFocusService {
-    #private;
-    readonly focusRequested: _angular_core.WritableSignal<number>;
-    requestFocus(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TerminalFocusService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TerminalFocusService>;
-}
-
+export declare class TerminalFocusService {
+  #private;
+  readonly focusRequested: import("@angular/core").WritableSignal<number>;
+  requestFocus(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TerminalFocusService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * Controls visibility of the command terminal at the bottom of the shell.
  *
@@ -868,21 +873,20 @@ declare class TerminalFocusService {
  * a toggle while a screen has it hidden shows it again, and saves nothing, because the saved
  * choice was "visible" all along.
  */
-declare class TerminalVisibilityService {
-    #private;
-    /** Read-only on purpose — see the header. */
-    readonly visible: Signal<boolean>;
-    toggle(): void;
-    /**
-     * Hides the terminal while a screen needs the room, without changing what is saved. Returns the
-     * release; call it when the screen no longer needs it hidden (and on destroy). Releasing twice,
-     * or after ☰ already showed it, does nothing.
-     */
-    hideForScreen(): () => void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TerminalVisibilityService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TerminalVisibilityService>;
-}
-
+export declare class TerminalVisibilityService {
+  #private;
+  /** Read-only on purpose — see the header. */
+  readonly visible: Signal<boolean>;
+  toggle(): void;
+  /**
+   * Hides the terminal while a screen needs the room, without changing what is saved. Returns the
+   * release; call it when the screen no longer needs it hidden (and on destroy). Releasing twice,
+   * or after ☰ already showed it, does nothing.
+   */
+  hideForScreen(): () => void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TerminalVisibilityService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * Below this width the frame is in its phone layout: no icon column, a ☰ menu
  * button in the top bar, a one-line top bar.
@@ -895,26 +899,25 @@ declare class TerminalVisibilityService {
  * a media query cannot read a TypeScript constant. phone-layout.service.spec.ts
  * fails if any of them drifts from this value.
  */
-declare const SHELL_PHONE_MEDIA_QUERY = "(max-width: 819.98px)";
+export declare const SHELL_PHONE_MEDIA_QUERY = "(max-width: 819.98px)";
 /**
  * Whether the frame is in its phone layout, and whether the phone menu is open.
  *
  * Desktop never sees any of this: `isPhone` is false there, the menu cannot open,
  * and the rail renders exactly as before.
  */
-declare class PhoneLayoutService {
-    #private;
-    /** True below 820px. Always false where there is no window (server rendering). */
-    readonly isPhone: Signal<boolean>;
-    /** The ☰ menu's open state. Only ever true while `isPhone` is true. */
-    readonly menuOpen: Signal<boolean>;
-    constructor();
-    toggleMenu(): void;
-    closeMenu(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneLayoutService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PhoneLayoutService>;
-}
-
+export declare class PhoneLayoutService {
+  #private;
+  /** True below 820px. Always false where there is no window (server rendering). */
+  readonly isPhone: Signal<boolean>;
+  /** The ☰ menu's open state. Only ever true while `isPhone` is true. */
+  readonly menuOpen: Signal<boolean>;
+  constructor();
+  toggleMenu(): void;
+  closeMenu(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PhoneLayoutService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * A key binding a screen registers while it is mounted.
  *
@@ -926,134 +929,131 @@ declare class PhoneLayoutService {
  * work and then breaks on any non-US keyboard. `code: 'Digit1'` is the physical
  * key and is layout-independent.
  */
-interface ShortcutRegistration {
-    /** Displayed in the help overlay, and matched against `event.key` unless `code` is set. */
-    key: string;
-    /**
-     * Match `event.code` instead — the PHYSICAL key, independent of layout and of
-     * what modifiers do to the character produced. Use for anything shifted.
-     */
-    code?: string;
-    modifier?: 'Alt' | 'Shift';
-    action: () => void;
-    description: string;
-}
-declare class KeyboardShortcutService {
-    #private;
-    readonly helpVisible: _angular_core.WritableSignal<boolean>;
-    /**
-     * True while unmodified shortcuts are being suppressed — the user is typing,
-     * or a dialog is open.
-     *
-     * Exposed because a screen binding BARE keys needs to tell the user whether the
-     * next keystroke acts or types, and that indicator must read the service's own
-     * dispatch state. A screen keeping its own boolean will eventually disagree
-     * with the service, and an indicator that lies about whether a keystroke sells
-     * a thousand shares is worse than no indicator at all.
-     */
-    readonly suppressed: _angular_core.WritableSignal<boolean>;
-    readonly activeShortcuts: _angular_core.Signal<{
-        groupId: string;
-        shortcuts: ShortcutRegistration[];
-    } | null>;
-    constructor();
-    registerGroup(groupId: string, shortcuts: ShortcutRegistration[]): void;
-    unregisterGroup(groupId: string): void;
-    toggleHelp(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyboardShortcutService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KeyboardShortcutService>;
-}
-
+export interface ShortcutRegistration {
+  /** Displayed in the help overlay, and matched against `event.key` unless `code` is set. */
+  key: string;
+  /**
+   * Match `event.code` instead — the PHYSICAL key, independent of layout and of
+   * what modifiers do to the character produced. Use for anything shifted.
+   */
+  code?: string;
+  modifier?: 'Alt' | 'Shift';
+  action: () => void;
+  description: string;
+}
+export declare class KeyboardShortcutService {
+  #private;
+  readonly helpVisible: import("@angular/core").WritableSignal<boolean>;
+  /**
+   * True while unmodified shortcuts are being suppressed — the user is typing,
+   * or a dialog is open.
+   *
+   * Exposed because a screen binding BARE keys needs to tell the user whether the
+   * next keystroke acts or types, and that indicator must read the service's own
+   * dispatch state. A screen keeping its own boolean will eventually disagree
+   * with the service, and an indicator that lies about whether a keystroke sells
+   * a thousand shares is worse than no indicator at all.
+   */
+  readonly suppressed: import("@angular/core").WritableSignal<boolean>;
+  readonly activeShortcuts: import("@angular/core").Signal<{
+    groupId: string;
+    shortcuts: ShortcutRegistration[];
+  } | null>;
+  constructor();
+  registerGroup(groupId: string, shortcuts: ShortcutRegistration[]): void;
+  unregisterGroup(groupId: string): void;
+  toggleHelp(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardShortcutService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /** A key combination: the physical key and the modifiers that must be held, exactly. */
-interface ScreenKeyCombo {
-    readonly code: string;
-    readonly ctrl: boolean;
-    readonly shift: boolean;
-    readonly alt: boolean;
-}
-interface ScreenKeyRegistration {
-    /** The routes it is live on. */
-    readonly routes: readonly string[];
-    /** Called for each eligible keydown. Return true to take the key (the browser's action is prevented). */
-    handle(event: KeyboardEvent): boolean;
+export interface ScreenKeyCombo {
+  readonly code: string;
+  readonly ctrl: boolean;
+  readonly shift: boolean;
+  readonly alt: boolean;
+}
+export interface ScreenKeyRegistration {
+  /** The routes it is live on. */
+  readonly routes: readonly string[];
+  /** Called for each eligible keydown. Return true to take the key (the browser's action is prevented). */
+  handle(event: KeyboardEvent): boolean;
 }
 /** The class the command terminal's input carries; keys typed there still reach a screen's keys. */
-declare const TERMINAL_INPUT_CLASS = "terminal-input";
+export declare const TERMINAL_INPUT_CLASS = "terminal-input";
 /** True when the key is typed into a box other than the command terminal. */
-declare function isTypingElsewhere(target: EventTarget | null): boolean;
+export declare function isTypingElsewhere(target: EventTarget | null): boolean;
 /** Exactly this combination: the key, and these modifiers and no others. */
-declare function comboMatches(combo: ScreenKeyCombo, e: Pick<KeyboardEvent, 'code' | 'ctrlKey' | 'shiftKey' | 'altKey' | 'metaKey'>): boolean;
+export declare function comboMatches(combo: ScreenKeyCombo, e: Pick<KeyboardEvent, 'code' | 'ctrlKey' | 'shiftKey' | 'altKey' | 'metaKey'>): boolean;
 /** Whether a keydown may reach a screen's keys at all. */
-declare function isEligibleKey(e: Pick<KeyboardEvent, 'repeat' | 'isComposing' | 'target'>): boolean;
-declare class ScreenKeysService {
-    #private;
-    constructor();
-    /** Registers keys for a screen; returns the function that removes them. */
-    register(registration: ScreenKeyRegistration): () => void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScreenKeysService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScreenKeysService>;
-}
-
+export declare function isEligibleKey(e: Pick<KeyboardEvent, 'repeat' | 'isComposing' | 'target'>): boolean;
+export declare class ScreenKeysService {
+  #private;
+  constructor();
+  /** Registers keys for a screen; returns the function that removes them. */
+  register(registration: ScreenKeyRegistration): () => void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ScreenKeysService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /** The `reason` the auth worker puts on every authenticator refusal. */
-type AuthenticatorReason = 'code-required' | 'invalid-code' | 'too-many-attempts' | 'authenticator-not-set-up' | 'setup-required' | 'passkey-refused';
+export type AuthenticatorReason = 'code-required' | 'invalid-code' | 'too-many-attempts' | 'authenticator-not-set-up' | 'setup-required' | 'passkey-refused';
 /** Which extra step the sign-in screen is on, after the password was accepted. */
-type SignInCodeStep = 'none' | 'code' | 'setup';
+export type SignInCodeStep = 'none' | 'code' | 'setup';
 /** GET {login}/authenticator. */
-type AuthenticatorStatus = {
-    enrolled: boolean;
-    recoveryCodesLeft: number;
-    /** Yes/no only — the server never sends when it ends (D12). */
-    bypassActive: boolean;
-    codeRequired: boolean;
+export type AuthenticatorStatus = {
+  enrolled: boolean;
+  recoveryCodesLeft: number;
+  /** Yes/no only — the server never sends when it ends (D12). */
+  bypassActive: boolean;
+  codeRequired: boolean;
 };
 /** What a code-bearing request carries: a 6-digit code or a recovery code. */
-type CodeEntry = {
-    code?: string;
-    recoveryCode?: string;
+export type CodeEntry = {
+  code?: string;
+  recoveryCode?: string;
 };
 /** The QR shown once during setup, and the same secret as text for typing in by hand. */
-type SetupChallenge = {
-    qr: string;
-    key: string;
+export type SetupChallenge = {
+  qr: string;
+  key: string;
 };
 /**
  * The one message for a pause (D8). The server sends no time and the screen invents none.
  */
-declare const TOO_MANY_ATTEMPTS = "Too many attempts.";
+export declare const TOO_MANY_ATTEMPTS = "Too many attempts.";
 /** Plain words for each refusal, shown on the sign-in screen and in the code dialog. */
-declare function authenticatorMessage(reason: AuthenticatorReason | undefined): string;
+export declare function authenticatorMessage(reason: AuthenticatorReason | undefined): string;
 /** The text file the Download button saves (D7). */
-declare function recoveryCodesFile(appName: string, username: string | undefined, codes: readonly string[], now?: Date): string;
+export declare function recoveryCodesFile(appName: string, username: string | undefined, codes: readonly string[], now?: Date): string;
 /** One of the user's passkeys, as GET {login}/passkeys lists it (passkey-sign-in.prd.md D13, D17). */
-type PasskeySummary = {
-    credentialId: string;
-    name: string;
-    addedAtEpoch: number;
-    lastUsedAtEpoch: number | null;
-    /** What the browser reported: synced between devices (D17). */
-    backedUp: boolean;
+export type PasskeySummary = {
+  credentialId: string;
+  name: string;
+  addedAtEpoch: number;
+  lastUsedAtEpoch: number | null;
+  /** What the browser reported: synced between devices (D17). */
+  backedUp: boolean;
 };
 /**
  * What proves you are at the keyboard right now, for adding or removing a passkey (D14, D15):
  * password + code (or recovery code), a code alone (removing only), or one of your passkeys.
  */
-type PasskeyProof = (CodeEntry & {
-    password?: string;
+export type PasskeyProof = (CodeEntry & {
+  password?: string;
 }) | 'passkey';
-
 /**
  * A refusal from an authenticator route, carrying the server's `reason`
  * (authenticator-sign-in.prd.md). `message` is plain words for the screen.
  */
-declare class AuthenticatorError extends Error {
-    readonly reason: AuthenticatorReason | undefined;
-    readonly status: number;
-    constructor(reason: AuthenticatorReason | undefined, message: string, status: number);
+export declare class AuthenticatorError extends Error {
+  readonly reason: AuthenticatorReason | undefined;
+  readonly status: number;
+  constructor(reason: AuthenticatorReason | undefined, message: string, status: number);
 }
 /** Sign-in rejected because the next step is a code (or setting one up), not because anything failed. */
-declare const CODE_STEP = "code-step";
+export declare const CODE_STEP = "code-step";
 /** The user dismissed the passkey prompt — nothing failed, nothing to say. */
-declare const PASSKEY_CANCELLED = "passkey-cancelled";
+export declare const PASSKEY_CANCELLED = "passkey-cancelled";
 /**
  * What the user decided about sessions they already hold, sent on the SECOND
  * sign-in attempt (multiple-devices D2/D6).
@@ -1062,14 +1062,14 @@ declare const PASSKEY_CANCELLED = "passkey-cancelled";
  * over everything is `force` on the call itself, signing in beside them is
  * `additional`, and ending a chosen few is `endSessionIds`.
  */
-type LoginChoice = {
-    additional?: boolean;
-    /** Identifiers read off the refusal. The server acts on them only after the password verifies, and only for that user's own sessions. */
-    endSessionIds?: string[];
-    /** The 6-digit authenticator code (authenticator-sign-in.prd.md). */
-    code?: string;
-    /** A one-time recovery code, in place of `code`. */
-    recoveryCode?: string;
+export type LoginChoice = {
+  additional?: boolean;
+  /** Identifiers read off the refusal. The server acts on them only after the password verifies, and only for that user's own sessions. */
+  endSessionIds?: string[];
+  /** The 6-digit authenticator code (authenticator-sign-in.prd.md). */
+  code?: string;
+  /** A one-time recovery code, in place of `code`. */
+  recoveryCode?: string;
 };
 /**
  * The sign-in request body, exactly as sent (multiple-devices E8, authenticator-sign-in.prd.md).
@@ -1079,593 +1079,606 @@ type LoginChoice = {
  * meant. A code typed now wins; otherwise a ticket from a 409 that followed a
  * correct code stands in for it (the server accepts a code only once, D20).
  */
-declare function buildLoginBody(credentials: Credentials, force: boolean, options: LoginChoice, signInTicket?: string): Record<string, unknown>;
-declare class AuthenticationService {
-    #private;
-    readonly authenticated: _angular_core.WritableSignal<boolean>;
-    readonly authenticating: _angular_core.WritableSignal<boolean>;
-    readonly userSession: _angular_core.WritableSignal<UserSession | undefined>;
-    readonly conflictSessions: _angular_core.WritableSignal<SessionSummary[] | undefined>;
-    /**
-     * Whether this app lets you sign in ALONGSIDE the sessions listed in
-     * `conflictSessions` (multiple-devices D3).
-     *
-     * ⚠ READ FROM THE SERVER'S REFUSAL, NEVER DECIDED HERE. This component is
-     * shared by the trading app and both admin consoles, which have different
-     * rules. Deciding it locally would put the policy in two places, and the one
-     * a reader would find is not the one that enforces it — an admin screen would
-     * happily offer a button the server refuses.
-     */
-    readonly additionalSignInAllowed: _angular_core.WritableSignal<boolean>;
-    readonly pendingCredentials: _angular_core.WritableSignal<Credentials | undefined>;
-    /** The extra step the sign-in screen is on after the password was accepted. */
-    readonly codeStep: _angular_core.WritableSignal<SignInCodeStep>;
-    /** Inside an AWS-opened setup window: the QR and key to show (D9, D10). */
-    readonly setupChallenge: _angular_core.WritableSignal<SetupChallenge | undefined>;
-    /** New recovery codes to show ONCE, with a Download button (D7). Cleared when acknowledged. */
-    readonly recoveryCodesToShow: _angular_core.WritableSignal<string[] | undefined>;
-    /** Recovery codes left, from the last sign-in or status read. */
-    readonly recoveryCodesLeft: _angular_core.WritableSignal<number | undefined>;
-    /**
-     * Whether the AWS-set bypass is on for this account (D12). Drives the banner on
-     * every screen. Yes/no only: the server never says when it ends.
-     */
-    readonly bypassActive: _angular_core.WritableSignal<boolean>;
-    /**
-     * The open "already signed in elsewhere" choice came from a passkey sign-in, so its retry goes
-     * to the passkey route with the ticket, not to /login with a password (passkey-sign-in.prd.md D8).
-     */
-    readonly pendingPasskey: _angular_core.WritableSignal<boolean>;
-    constructor();
-    /**
-     * The bearer for outbound calls.
-     *
-     * READ-THROUGH, not a cached copy, whenever the session is shared across
-     * windows (PRD D2/D10). A copy is only as fresh as the last `storage` event
-     * delivered, and the consumer that matters most is outside the request path:
-     * the market-tape socket re-presents this token on a sixty-second heartbeat,
-     * and the server closes the socket with a code the client does NOT retry if it
-     * is stale. A window that was frozen when the event fired would lose its live
-     * prices permanently. Reading through removes the question of which window
-     * holds which token.
-     */
-    get auth(): BearerToken;
-    refresh(): Promise<boolean>;
-    clearConflict(): void;
-    /** Back to the password form from the code or setup step. */
-    cancelCodeStep(): void;
-    /** The new recovery codes have been seen (and, we hope, downloaded). */
-    acknowledgeRecoveryCodes(): void;
-    /**
-     * The session is gone and cannot be recovered — renewal failed permanently,
-     * or another window signed out.
-     *
-     * ⚠ THIS EXISTS BECAUSE THERE ARE TWO SIGN-OUT PATHS AND ONLY ONE USED TO
-     * CLEAR THE TOKEN. `logout()` went through `#clearSession()`; the 401
-     * interceptor set the signals and navigated but left `#auth` alone. Harmless
-     * while the token lived only in memory and died with the tab — but once it is
-     * in storage, a dead token left behind means every later window marks itself
-     * signed in, passes the guard, renders, 401s and bounces to the login screen.
-     * The reload fix would have become "the app flashes, then throws me out",
-     * which is harder to diagnose than the behaviour it replaced.
-     */
-    sessionLost(): void;
-    logout(): void;
-    /**
-     * Signs in, and — on a second attempt — says what to do about the sessions
-     * already held (multiple-devices D2/D6).
-     *
-     * `force` and `additional` are different answers, not synonyms: `force` ends
-     * every session in this app, `additional` leaves them all running.
-     * `endSessionIds` ends the ones the user picked and leaves the rest. None of
-     * the three appears on a first attempt — they exist because the server
-     * refused once and said what was live.
-     */
-    login(credentials: Credentials, force?: boolean, options?: LoginChoice): Promise<void>;
-    /**
-     * Sign in with a passkey: no username, password or code. `conditional` waits quietly for the user
-     * to pick a passkey from the username box's suggestions (D9); abort `signal` when the screen goes.
-     * Rejects with PASSKEY_CANCELLED when the user dismissed the prompt, 'conflict' on a 409 (retry
-     * with `retryPasskeySignIn`), or a plain-words message.
-     */
-    loginWithPasskey(opts?: {
-        conditional?: boolean;
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /** The answer to "already signed in elsewhere" after a passkey sign-in: the ticket stands in for the passkey (D8). */
-    retryPasskeySignIn(force: boolean, choice?: Pick<LoginChoice, 'additional' | 'endSessionIds'>): Promise<void>;
-    /** This user's passkeys. */
-    listPasskeys(): Promise<PasskeySummary[]>;
-    /**
-     * Add a passkey (D13, D14). `proof` is password + code (or recovery code), or 'passkey' to prove
-     * with one already added. Opens the browser's passkey prompt; resolves with the new passkey.
-     */
-    addPasskey(name: string, proof: PasskeyProof): Promise<PasskeySummary>;
-    /** Remove one of your passkeys (D15), proved with a code, a recovery code, or a passkey. */
-    removePasskey(credentialId: string, proof: PasskeyProof): Promise<boolean>;
-    /**
-     * The on-demand check with a passkey (D11) — the passkey twin of `verifyCode`. Opens the
-     * browser's prompt (fingerprint or PIN, always) and, on success, the server records it on this
-     * session exactly as a code would. `purpose` is a label for the log, e.g. 'arm-trading'.
-     * Resolves with when it was recorded; rejects with an AuthenticatorError (cancelled, refused, or
-     * no passkey on this account — reason 'passkey-refused').
-     */
-    verifyWithPasskey(purpose?: string): Promise<number>;
-    /** Whether an authenticator is set up, codes left, and whether the bypass is on. Refreshes the banner. */
-    authenticatorStatus(): Promise<AuthenticatorStatus>;
-    /** Begin setting up (or replacing) the authenticator: the password again, plus a current code when replacing (D5). */
-    startAuthenticatorSetup(password: string, current?: CodeEntry): Promise<SetupChallenge>;
-    /** Finish setup with the first code from the newly scanned app. Returns the 10 recovery codes, once. */
-    confirmAuthenticatorSetup(code: string): Promise<string[]>;
-    /** Ten new recovery codes; the old ones stop working (D7). Needs a current code. */
-    reissueRecoveryCodes(code: string): Promise<string[]>;
-    /**
-     * The on-demand check (D15): proves the code again on this session and returns
-     * when it was recorded. `purpose` is a short label for the log, e.g.
-     * 'arm-live-trading' — it changes nothing. The bypass never satisfies this.
-     */
-    verifyCode(entry: CodeEntry, purpose?: string): Promise<number>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthenticationService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthenticationService>;
-}
-
-declare function passkeysSupported(): boolean;
+export declare function buildLoginBody(credentials: Credentials, force: boolean, options: LoginChoice, signInTicket?: string): Record<string, unknown>;
+export declare class AuthenticationService {
+  #private;
+  readonly authenticated: import("@angular/core").WritableSignal<boolean>;
+  readonly authenticating: import("@angular/core").WritableSignal<boolean>;
+  readonly userSession: import("@angular/core").WritableSignal<UserSession | undefined>;
+  readonly conflictSessions: import("@angular/core").WritableSignal<SessionSummary[] | undefined>;
+  /**
+   * Whether this app lets you sign in ALONGSIDE the sessions listed in
+   * `conflictSessions` (multiple-devices D3).
+   *
+   * ⚠ READ FROM THE SERVER'S REFUSAL, NEVER DECIDED HERE. This component is
+   * shared by the trading app and both admin consoles, which have different
+   * rules. Deciding it locally would put the policy in two places, and the one
+   * a reader would find is not the one that enforces it — an admin screen would
+   * happily offer a button the server refuses.
+   */
+  readonly additionalSignInAllowed: import("@angular/core").WritableSignal<boolean>;
+  readonly pendingCredentials: import("@angular/core").WritableSignal<Credentials | undefined>;
+  /** The extra step the sign-in screen is on after the password was accepted. */
+  readonly codeStep: import("@angular/core").WritableSignal<SignInCodeStep>;
+  /** Inside an AWS-opened setup window: the QR and key to show (D9, D10). */
+  readonly setupChallenge: import("@angular/core").WritableSignal<SetupChallenge | undefined>;
+  /** New recovery codes to show ONCE, with a Download button (D7). Cleared when acknowledged. */
+  readonly recoveryCodesToShow: import("@angular/core").WritableSignal<string[] | undefined>;
+  /** Recovery codes left, from the last sign-in or status read. */
+  readonly recoveryCodesLeft: import("@angular/core").WritableSignal<number | undefined>;
+  /**
+   * Whether the AWS-set bypass is on for this account (D12). Drives the banner on
+   * every screen. Yes/no only: the server never says when it ends.
+   */
+  readonly bypassActive: import("@angular/core").WritableSignal<boolean>;
+  /**
+   * The open "already signed in elsewhere" choice came from a passkey sign-in, so its retry goes
+   * to the passkey route with the ticket, not to /login with a password (passkey-sign-in.prd.md D8).
+   */
+  readonly pendingPasskey: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  /**
+   * The bearer for outbound calls.
+   *
+   * READ-THROUGH, not a cached copy, whenever the session is shared across
+   * windows (PRD D2/D10). A copy is only as fresh as the last `storage` event
+   * delivered, and the consumer that matters most is outside the request path:
+   * the market-tape socket re-presents this token on a sixty-second heartbeat,
+   * and the server closes the socket with a code the client does NOT retry if it
+   * is stale. A window that was frozen when the event fired would lose its live
+   * prices permanently. Reading through removes the question of which window
+   * holds which token.
+   */
+  get auth(): BearerToken;
+  refresh(): Promise<boolean>;
+  clearConflict(): void;
+  /** Back to the password form from the code or setup step. */
+  cancelCodeStep(): void;
+  /** The new recovery codes have been seen (and, we hope, downloaded). */
+  acknowledgeRecoveryCodes(): void;
+  /**
+   * The session is gone and cannot be recovered — renewal failed permanently,
+   * or another window signed out.
+   *
+   * ⚠ THIS EXISTS BECAUSE THERE ARE TWO SIGN-OUT PATHS AND ONLY ONE USED TO
+   * CLEAR THE TOKEN. `logout()` went through `#clearSession()`; the 401
+   * interceptor set the signals and navigated but left `#auth` alone. Harmless
+   * while the token lived only in memory and died with the tab — but once it is
+   * in storage, a dead token left behind means every later window marks itself
+   * signed in, passes the guard, renders, 401s and bounces to the login screen.
+   * The reload fix would have become "the app flashes, then throws me out",
+   * which is harder to diagnose than the behaviour it replaced.
+   */
+  sessionLost(): void;
+  logout(): void;
+  /**
+   * Signs in, and — on a second attempt — says what to do about the sessions
+   * already held (multiple-devices D2/D6).
+   *
+   * `force` and `additional` are different answers, not synonyms: `force` ends
+   * every session in this app, `additional` leaves them all running.
+   * `endSessionIds` ends the ones the user picked and leaves the rest. None of
+   * the three appears on a first attempt — they exist because the server
+   * refused once and said what was live.
+   */
+  login(credentials: Credentials, force?: boolean, options?: LoginChoice): Promise<void>;
+  /**
+   * Sign in with a passkey: no username, password or code. `conditional` waits quietly for the user
+   * to pick a passkey from the username box's suggestions (D9); abort `signal` when the screen goes.
+   * Rejects with PASSKEY_CANCELLED when the user dismissed the prompt, 'conflict' on a 409 (retry
+   * with `retryPasskeySignIn`), or a plain-words message.
+   */
+  loginWithPasskey(opts?: {
+    conditional?: boolean;
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /** The answer to "already signed in elsewhere" after a passkey sign-in: the ticket stands in for the passkey (D8). */
+  retryPasskeySignIn(force: boolean, choice?: Pick<LoginChoice, 'additional' | 'endSessionIds'>): Promise<void>;
+  /** This user's passkeys. */
+  listPasskeys(): Promise<PasskeySummary[]>;
+  /**
+   * Add a passkey (D13, D14). `proof` is password + code (or recovery code), or 'passkey' to prove
+   * with one already added. Opens the browser's passkey prompt; resolves with the new passkey.
+   */
+  addPasskey(name: string, proof: PasskeyProof): Promise<PasskeySummary>;
+  /** Remove one of your passkeys (D15), proved with a code, a recovery code, or a passkey. */
+  removePasskey(credentialId: string, proof: PasskeyProof): Promise<boolean>;
+  /**
+   * The on-demand check with a passkey (D11) — the passkey twin of `verifyCode`. Opens the
+   * browser's prompt (fingerprint or PIN, always) and, on success, the server records it on this
+   * session exactly as a code would. `purpose` is a label for the log, e.g. 'arm-trading'.
+   * Resolves with when it was recorded; rejects with an AuthenticatorError (cancelled, refused, or
+   * no passkey on this account — reason 'passkey-refused').
+   */
+  verifyWithPasskey(purpose?: string): Promise<number>;
+  /** Whether an authenticator is set up, codes left, and whether the bypass is on. Refreshes the banner. */
+  authenticatorStatus(): Promise<AuthenticatorStatus>;
+  /** Begin setting up (or replacing) the authenticator: the password again, plus a current code when replacing (D5). */
+  startAuthenticatorSetup(password: string, current?: CodeEntry): Promise<SetupChallenge>;
+  /** Finish setup with the first code from the newly scanned app. Returns the 10 recovery codes, once. */
+  confirmAuthenticatorSetup(code: string): Promise<string[]>;
+  /** Ten new recovery codes; the old ones stop working (D7). Needs a current code. */
+  reissueRecoveryCodes(code: string): Promise<string[]>;
+  /**
+   * The on-demand check (D15): proves the code again on this session and returns
+   * when it was recorded. `purpose` is a short label for the log, e.g.
+   * 'arm-live-trading' — it changes nothing. The bypass never satisfies this.
+   */
+  verifyCode(entry: CodeEntry, purpose?: string): Promise<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare function passkeysSupported(): boolean;
 /** Whether the browser can offer passkeys in the username box's suggestions (D9). */
-declare function passkeyAutofillSupported(): Promise<boolean>;
-
+export declare function passkeyAutofillSupported(): Promise<boolean>;
 /**
  * What a typed word resolves to: the command it names, plus any words the
  * alternate name carries with it (see {@link CommandAlias}).
  */
-interface ResolvedCommand {
-    readonly command: CommandDefinition;
-    readonly prependArgs: readonly string[];
-}
-declare class CommandRegistryService {
-    #private;
-    private readonly commands;
-    private readonly aliases;
-    constructor();
-    /**
-     * Register a command and claim its names.
-     *
-     * ⭐ THROWS on a name already taken — real name or alternate. It used to be a
-     * bare `set`, which meant a clash silently overwrote whichever command
-     * registered first, and the constructor's "built-ins first so an app cannot
-     * shadow them" comment was not actually true of the map. A shadowed command
-     * is indistinguishable from a broken one, and this is the map dispatch reads,
-     * so the failure belongs at startup where it cannot be missed
-     * (scanner-command-speed.prd.md D4).
-     */
-    register(command: CommandDefinition): void;
-    /**
-     * Resolve a word the user typed to the command it names — real name or
-     * alternate. `prependArgs` is empty except for an alternate that carries a
-     * subcommand.
-     *
-     * Use this wherever a TYPED word is being looked up. {@link get} deliberately
-     * stays blind to alternates so callers that mean "the command called X" keep
-     * meaning exactly that.
-     */
-    resolve(name: string): ResolvedCommand | undefined;
-    get(name: string): CommandDefinition | undefined;
-    getAll(): CommandDefinition[];
-    /**
-     * Returns command name suggestions for tab-completion.
-     * Built-ins (clear, help) are included when authenticated.
-     */
-    getSuggestions(prefix: string, isAuthenticated: boolean): string[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandRegistryService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CommandRegistryService>;
-}
-
-interface PendingPrompt {
-    /** The question, shown in the terminal and as the input's placeholder. */
-    readonly question: string;
-    /** Mask what is typed (a code), in the input and in the history. */
-    readonly masked?: boolean;
-    /**
-     * The answer: the line typed, trimmed — `''` for a bare Enter. The command decides what counts
-     * as yes. It may ask again by calling `ask` from inside.
-     */
-    answer(text: string): CommandResult | Promise<CommandResult>;
-    /** Esc, or a new question replacing this one. */
-    cancel?(): void;
+export interface ResolvedCommand {
+  readonly command: CommandDefinition;
+  readonly prependArgs: readonly string[];
+}
+export declare class CommandRegistryService {
+  #private;
+  private readonly commands;
+  private readonly aliases;
+  constructor();
+  /**
+   * Register a command and claim its names.
+   *
+   * ⭐ THROWS on a name already taken — real name or alternate. It used to be a
+   * bare `set`, which meant a clash silently overwrote whichever command
+   * registered first, and the constructor's "built-ins first so an app cannot
+   * shadow them" comment was not actually true of the map. A shadowed command
+   * is indistinguishable from a broken one, and this is the map dispatch reads,
+   * so the failure belongs at startup where it cannot be missed
+   * (scanner-command-speed.prd.md D4).
+   */
+  register(command: CommandDefinition): void;
+  /**
+   * Resolve a word the user typed to the command it names — real name or
+   * alternate. `prependArgs` is empty except for an alternate that carries a
+   * subcommand.
+   *
+   * Use this wherever a TYPED word is being looked up. {@link get} deliberately
+   * stays blind to alternates so callers that mean "the command called X" keep
+   * meaning exactly that.
+   */
+  resolve(name: string): ResolvedCommand | undefined;
+  get(name: string): CommandDefinition | undefined;
+  getAll(): CommandDefinition[];
+  /**
+   * Returns command name suggestions for tab-completion.
+   * Built-ins (clear, help) are included when authenticated.
+   */
+  getSuggestions(prefix: string, isAuthenticated: boolean): string[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<CommandRegistryService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export interface PendingPrompt {
+  /** The question, shown in the terminal and as the input's placeholder. */
+  readonly question: string;
+  /** Mask what is typed (a code), in the input and in the history. */
+  readonly masked?: boolean;
+  /**
+   * The answer: the line typed, trimmed — `''` for a bare Enter. The command decides what counts
+   * as yes. It may ask again by calling `ask` from inside.
+   */
+  answer(text: string): CommandResult | Promise<CommandResult>;
+  /** Esc, or a new question replacing this one. */
+  cancel?(): void;
 }
 /** True for the answers that mean yes: a bare Enter, `y`, `yes`. */
-declare function isYes(text: string): boolean;
+export declare function isYes(text: string): boolean;
 /** What the history shows for an answer: the text, a masked run, or "(Enter)". */
-declare function answerEcho(prompt: PendingPrompt, text: string): string;
+export declare function answerEcho(prompt: PendingPrompt, text: string): string;
 /** Holds at most one open question. Asking again cancels the one before it. */
-declare class PendingPromptState {
-    #private;
-    get current(): PendingPrompt | null;
-    ask(prompt: PendingPrompt): void;
-    /**
-     * Takes the open question and closes it, so an answer that asks again opens a fresh one rather
-     * than being closed afterwards.
-     */
-    take(): PendingPrompt | null;
-    cancel(): boolean;
-}
-
-declare class CommandService {
-    #private;
-    readonly history: _angular_core.WritableSignal<CommandHistoryEntry[]>;
-    readonly currentInput: _angular_core.WritableSignal<string>;
-    readonly isProcessing: _angular_core.WritableSignal<boolean>;
-    readonly helpOverlay: _angular_core.WritableSignal<string | null>;
-    /**
-     * The question a command left open, or null (live-trading-foundation.prd.md D24). While set, the
-     * next line — a bare Enter included — is its answer, not a command; Esc cancels.
-     */
-    readonly pending: _angular_core.WritableSignal<PendingPrompt | null>;
-    private readonly authService;
-    private readonly registry;
-    private readonly router;
-    constructor();
-    readonly lastResult: _angular_core.Signal<CommandResult | null>;
-    dismissHelp(): void;
-    /** Leaves a question open; the next line typed answers it. A question already open is cancelled. */
-    ask(prompt: PendingPrompt): void;
-    /** Esc: closes the open question, if any. True when there was one. */
-    cancelPending(): boolean;
-    echoCommand(input: string): void;
-    pushNotification(notification: {
-        message: string;
-        severity: Severity;
-    }): void;
-    execute(rawInput: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CommandService>;
-}
-
+export declare class PendingPromptState {
+  #private;
+  get current(): PendingPrompt | null;
+  ask(prompt: PendingPrompt): void;
+  /**
+   * Takes the open question and closes it, so an answer that asks again opens a fresh one rather
+   * than being closed afterwards.
+   */
+  take(): PendingPrompt | null;
+  cancel(): boolean;
+}
+export declare class CommandService {
+  #private;
+  readonly history: import("@angular/core").WritableSignal<CommandHistoryEntry[]>;
+  readonly currentInput: import("@angular/core").WritableSignal<string>;
+  readonly isProcessing: import("@angular/core").WritableSignal<boolean>;
+  readonly helpOverlay: import("@angular/core").WritableSignal<string | null>;
+  /**
+   * The question a command left open, or null (live-trading-foundation.prd.md D24). While set, the
+   * next line — a bare Enter included — is its answer, not a command; Esc cancels.
+   */
+  readonly pending: import("@angular/core").WritableSignal<PendingPrompt | null>;
+  private readonly authService;
+  private readonly registry;
+  private readonly router;
+  constructor();
+  readonly lastResult: import("@angular/core").Signal<CommandResult | null>;
+  dismissHelp(): void;
+  /** Leaves a question open; the next line typed answers it. A question already open is cancelled. */
+  ask(prompt: PendingPrompt): void;
+  /** Esc: closes the open question, if any. True when there was one. */
+  cancelPending(): boolean;
+  echoCommand(input: string): void;
+  pushNotification(notification: {
+    message: string;
+    severity: Severity;
+  }): void;
+  execute(rawInput: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CommandService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * Quote-aware command tokenizer. Treats "..." as single tokens and strips enclosing quotes.
  */
-declare function tokenize(input: string): string[];
-declare const CLEAR_USAGE: string;
-declare const HELP_USAGE: string;
-
-declare class Shell {
-    #private;
-    readonly isThinking: _angular_core.Signal<boolean>;
-    readonly isAuthenticated: _angular_core.WritableSignal<boolean>;
-    readonly helpOverlay: _angular_core.WritableSignal<string | null>;
-    readonly terminalVisible: _angular_core.Signal<boolean>;
-    /** Below 820px the icon column is replaced by the ☰ menu (scanner-phone-display D9). */
-    readonly isPhone: _angular_core.Signal<boolean>;
-    readonly phoneMenuOpen: _angular_core.Signal<boolean>;
-    /**
-     * Whether the command box takes the cursor when the console appears: on a
-     * desktop yes, on a phone never (scanner-phone-display D10, Franz 2026-10-17).
-     *
-     * The console is shown on a phone again (reversing 0.8.1), but nothing may
-     * put the cursor in its box there — the on-screen keyboard would cover the
-     * screen. That includes the user turning the console ON from the ☰ menu: a
-     * show is not a request to type, and the keyboard rising over the console the
-     * moment it appears would hide the output the user wanted to see. Tapping the
-     * box is the only way it gets the cursor on a phone.
-     *
-     * Rotating across 820px never mounts or unmounts the console (its visibility
-     * is the user's choice alone), so this is only read when the user turns it on
-     * or at start-up. CommandTerminal.focusInput also refuses on a phone, as a
-     * second guard.
-     */
-    readonly consoleFocusOnAppear: _angular_core.Signal<boolean>;
-    /** "Sign-in code check is off." on every screen while the bypass is on (D12). */
-    readonly bypassActive: _angular_core.WritableSignal<boolean>;
-    closePhoneMenu(): void;
-    dismissHelp(): void;
-    readonly terminalHeight: _angular_core.WritableSignal<string>;
-    readonly isDragging: _angular_core.WritableSignal<boolean>;
-    onResizeStart(event: MouseEvent): void;
-    onResizeTouchStart(event: TouchEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Shell, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Shell, "shell-root", never, {}, {}, never, ["*"], true, never>;
-}
-
-declare class SideMenu {
-    #private;
-    readonly hasShortcuts: _angular_core.Signal<{
-        groupId: string;
-        shortcuts: _franzzemen_brokenstock_shell.ShortcutRegistration[];
-    } | null>;
-    readonly terminalVisible: _angular_core.Signal<boolean>;
-    /**
-     * Phone-menu rendering (scanner-phone-display D9): the same items as the icon
-     * column, each with its label as visible text — a tooltip needs a hover a
-     * touch screen does not have.
-     *
-     * ⚠ The keyboard-shortcuts button (Alt+?) is left out here. It opens a list of
-     * Alt-key bindings, and a phone has no Alt key. The shortcuts themselves are
-     * untouched — they are document-level listeners and work from a hardware
-     * keyboard whatever the layout.
-     *
-     * The console show/hide button stays (Franz, 2026-10-17: the console is back
-     * on phones, reversing 0.8.1). Turning the console ON from here does not put
-     * the cursor in the command box on a phone — see CommandTerminal.focusOnAppear.
-     */
-    readonly drawer: _angular_core.InputSignal<boolean>;
-    readonly menuItems: _angular_core.Signal<MenuItem[]>;
-    /**
-     * Readiness, not entitlement — an unentitled item never reaches here, having
-     * been filtered out by `visible` above. Read from the template so the
-     * predicate's signal reads are tracked and the strip regreys live when the
-     * user's state changes.
-     */
-    isEnabled(item: MenuItem): boolean;
-    disabledReasonFor(item: MenuItem): string;
-    /** The item's attention badge, or null when there is nothing to draw (no badge, or a count of 0). */
-    badgeFor(item: MenuItem): MenuBadge | null;
-    onMenuClick(item: MenuItem): void;
-    toggleHelp(): void;
-    toggleTerminal(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideMenu, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SideMenu, "shell-side-menu", never, { "drawer": { "alias": "drawer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class StatusBar {
-    #private;
-    readonly isAuthenticated: _angular_core.WritableSignal<boolean>;
-    /** The ☰ button: phones only, and only when there is a menu to open (signed in). */
-    readonly showMenuButton: _angular_core.Signal<boolean>;
-    readonly menuOpen: _angular_core.Signal<boolean>;
-    /**
-     * Whether a second window is offered at all (multiple-windows PRD D14).
-     *
-     * ⚠ GATED ON SHARED SESSIONS, and this is a correctness gate rather than a
-     * tidiness one. Without a session shared across windows, the new window starts
-     * with no token, goes to the login screen, and signing in there ends the
-     * session THIS window is using. A pop-out button in an app without sharing is
-     * a button that signs you out — the exact failure the multiple-windows work
-     * exists to remove.
-     */
-    readonly canPopOut: _angular_core.Signal<boolean>;
-    readonly loginStatus: _angular_core.Signal<"Authenticating..." | "Logged in" | "Not logged in">;
-    logout(): void;
-    /**
-     * Open the screen you are on in a second, sized window.
-     *
-     * There is no mechanism by which this differs from the browser's own
-     * "Duplicate tab": every window is a separate copy of the app started at some
-     * address. It exists for the sizing and because it is discoverable — Ctrl+T,
-     * a bookmark and dragging a tab out all work equally well once the session is
-     * shared.
-     *
-     * `noopener` is deliberate. The new window needs nothing from this one — it
-     * reads the session from storage — and leaving the opener reachable would give
-     * two windows script access to each other for no purpose.
-     */
-    popOut(): void;
-    toggleMenu(): void;
-    openFaq(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusBar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusBar, "shell-status-bar", never, {}, {}, never, ["*"], true, never>;
-}
-
-declare class MainContent {
-    #private;
-    readonly isThinking: _angular_core.Signal<boolean>;
-    readonly shortcutHelpVisible: _angular_core.WritableSignal<boolean>;
-    readonly activeShortcuts: _angular_core.Signal<{
-        groupId: string;
-        shortcuts: _franzzemen_brokenstock_shell.ShortcutRegistration[];
-    } | null>;
-    formatKey(key: string): string;
-    closeShortcutHelp(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MainContent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MainContent, "shell-main-content", never, {}, {}, never, never, true, never>;
-}
-
-declare class CommandTerminal {
-    #private;
-    private readonly commandService;
-    private readonly registry;
-    private readonly authService;
-    private readonly terminalFocusService;
-    /**
-     * Whether the command box takes the cursor when the console first appears.
-     *
-     * True for a standalone console. The shell passes false on a phone (below
-     * 820px), including when the user turns the console on from the ☰ menu:
-     * showing the console is not a request to type, and focusing the box would
-     * raise the on-screen keyboard over it (scanner-phone-display D10). On a
-     * phone, focusInput() refuses anyway; this keeps the intent explicit.
-     */
-    readonly focusOnAppear: _angular_core.InputSignal<boolean>;
-    readonly history: _angular_core.Signal<_franzzemen_brokenstock_shell.CommandHistoryEntry[]>;
-    readonly currentInput: _angular_core.WritableSignal<string>;
-    readonly isProcessing: _angular_core.WritableSignal<boolean>;
-    /** The question a command left open (D24): the input answers it; Esc cancels. */
-    readonly pending: _angular_core.WritableSignal<_franzzemen_brokenstock_shell.PendingPrompt | null>;
-    private readonly inputEl;
-    private tabCycleIndex;
-    private lastTabPrefix;
-    readonly ghostText: _angular_core.Signal<string>;
-    constructor();
-    onSubmit(): void;
-    onInputChange(value: string): void;
-    dismissHelp(): void;
-    /** Esc: cancels an open question first, otherwise closes the help overlay. */
-    onEscape(): void;
-    onTab(event: KeyboardEvent): void;
-    getSeverityClass(result: CommandResult): string;
-    /**
-     * ⚠ A no-op on a phone (scanner-phone-display D10/E11). The console is shown
-     * there, but only the user tapping the box may give it the cursor; every
-     * programmatic path (first appearance, a finished command, a focus request,
-     * an app calling this) ends here and is refused, so nothing on a phone can
-     * raise the on-screen keyboard unasked.
-     */
-    focusInput(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandTerminal, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandTerminal, "shell-command-terminal", never, { "focusOnAppear": { "alias": "focusOnAppear"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class Login implements OnInit, OnDestroy {
-    #private;
-    protected authenticationService: AuthenticationService;
-    protected router: Router;
-    model: Credentials;
-    submitted: boolean;
-    hide: _angular_core.WritableSignal<boolean>;
-    errors: {
-        ndx: number;
-        message: string;
-    }[];
-    /**
-     * Session identifiers the user has ticked for ending (multiple-devices D7).
-     *
-     * ⚠ THE TAKEOVER CHECKBOX THAT USED TO LIVE ON THIS FORM IS GONE, and its
-     * removal is the point rather than a tidy-up. It defaulted to ON and sat on
-     * the FIRST form, before anything was known about what was live — so once a
-     * user deliberately holds sessions on two machines, one absent-minded submit
-     * ended the session on the machine in the other room. The choice belongs
-     * here, on the screen that lists what is actually running.
-     */
-    readonly selected: _angular_core.WritableSignal<ReadonlySet<string>>;
-    /** The code or recovery code typed on the code step (authenticator-sign-in.prd.md). */
-    codeText: string;
-    /** Typing a recovery code instead of the 6-digit code. */
-    readonly useRecovery: _angular_core.WritableSignal<boolean>;
-    protected readonly USERNAME_REGEX: RegExp;
-    protected readonly PASSWORD_REGEX: RegExp;
-    protected readonly appName: string;
-    /** Whether this browser can sign in with a passkey at all; the button is hidden otherwise (passkey D2). */
-    protected readonly passkeys: boolean;
-    /**
-     * Shown when the passkey prompt closed without a passkey: most often this device has none (a
-     * passkey lives on the device or account that made it). Plain advice, not an error.
-     */
-    protected readonly passkeyHint: _angular_core.WritableSignal<boolean>;
-    constructor(authenticationService: AuthenticationService, router: Router);
-    /** Safe on the server: the support check is false wherever there is no browser. */
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /** "Sign in with a passkey". The quiet wait must stop first: a browser runs one passkey prompt at a time. */
-    onPasskey(): Promise<void>;
-    onAutofill(event: AutofillEvent, inputEl: HTMLInputElement): void;
-    clickEvent(event: MouseEvent): void;
-    onSubmit(event: Event): void;
-    /** Whether individual sessions can be ticked: only when the server named them. */
-    canEndIndividually(): boolean;
-    isSelected(session: SessionSummary): boolean;
-    toggleSelected(session: SessionSummary, checked: boolean): void;
-    selectedCount(): number;
-    /**
-     * What to call a session on screen.
-     *
-     * Falls back to the application name, which is what this screen showed before
-     * devices were recorded, and then to something plainly non-committal. It never
-     * invents a device: a session that predates the column genuinely has none, and
-     * guessing would make two machines look like one.
-     */
-    deviceLabel(session: SessionSummary): string;
-    onTakeOver(): void;
-    onSignInAsWell(): void;
-    onEndSelected(): void;
-    /** The code step: the 6-digit code (or a recovery code), with the credentials already accepted. */
-    onSubmitCode(event: Event): void;
-    onToggleRecovery(): void;
-    /** Back to the password form. */
-    onCancelCode(): void;
-    /** New recovery codes were shown after sign-in; now go where sign-in was going. */
-    onRecoveryCodesSaved(): void;
-    onCancelConflict(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Login, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Login, "shell-login", never, {}, {}, never, never, true, never>;
-}
-
-declare class RecoveryCodes {
-    readonly codes: _angular_core.InputSignal<readonly string[]>;
-    readonly appName: _angular_core.InputSignal<string>;
-    readonly username: _angular_core.InputSignal<string | undefined>;
-    readonly done: _angular_core.OutputEmitterRef<void>;
-    protected readonly copied: _angular_core.WritableSignal<boolean>;
-    download(): void;
-    copy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecoveryCodes, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RecoveryCodes, "shell-recovery-codes", never, { "codes": { "alias": "codes"; "required": true; "isSignal": true; }; "appName": { "alias": "appName"; "required": false; "isSignal": true; }; "username": { "alias": "username"; "required": false; "isSignal": true; }; }, { "done": "done"; }, never, never, true, never>;
-}
-
+export declare function tokenize(input: string): string[];
+export declare const CLEAR_USAGE: string;
+export declare const HELP_USAGE: string;
+export declare class Shell {
+  #private;
+  readonly isThinking: import("@angular/core").Signal<boolean>;
+  readonly isAuthenticated: import("@angular/core").WritableSignal<boolean>;
+  readonly helpOverlay: import("@angular/core").WritableSignal<string | null>;
+  readonly terminalVisible: import("@angular/core").Signal<boolean>;
+  /** Below 820px the icon column is replaced by the ☰ menu (scanner-phone-display D9). */
+  readonly isPhone: import("@angular/core").Signal<boolean>;
+  readonly phoneMenuOpen: import("@angular/core").Signal<boolean>;
+  /**
+   * Whether the command box takes the cursor when the console appears: on a
+   * desktop yes, on a phone never (scanner-phone-display D10, Franz 2026-10-17).
+   *
+   * The console is shown on a phone again (reversing 0.8.1), but nothing may
+   * put the cursor in its box there — the on-screen keyboard would cover the
+   * screen. That includes the user turning the console ON from the ☰ menu: a
+   * show is not a request to type, and the keyboard rising over the console the
+   * moment it appears would hide the output the user wanted to see. Tapping the
+   * box is the only way it gets the cursor on a phone.
+   *
+   * Rotating across 820px never mounts or unmounts the console (its visibility
+   * is the user's choice alone), so this is only read when the user turns it on
+   * or at start-up. CommandTerminal.focusInput also refuses on a phone, as a
+   * second guard.
+   */
+  readonly consoleFocusOnAppear: import("@angular/core").Signal<boolean>;
+  /** "Sign-in code check is off." on every screen while the bypass is on (D12). */
+  readonly bypassActive: import("@angular/core").WritableSignal<boolean>;
+  closePhoneMenu(): void;
+  dismissHelp(): void;
+  readonly terminalHeight: import("@angular/core").WritableSignal<string>;
+  readonly isDragging: import("@angular/core").WritableSignal<boolean>;
+  onResizeStart(event: MouseEvent): void;
+  onResizeTouchStart(event: TouchEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Shell, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Shell, "shell-root", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class SideMenu {
+  #private;
+  readonly hasShortcuts: import("@angular/core").Signal<{
+    groupId: string;
+    shortcuts: import("@franzzemen/brokenstock-shell").ShortcutRegistration[];
+  } | null>;
+  readonly terminalVisible: import("@angular/core").Signal<boolean>;
+  /**
+   * Phone-menu rendering (scanner-phone-display D9): the same items as the icon
+   * column, each with its label as visible text — a tooltip needs a hover a
+   * touch screen does not have.
+   *
+   * ⚠ The keyboard-shortcuts button (Alt+?) is left out here. It opens a list of
+   * Alt-key bindings, and a phone has no Alt key. The shortcuts themselves are
+   * untouched — they are document-level listeners and work from a hardware
+   * keyboard whatever the layout.
+   *
+   * The console show/hide button stays (Franz, 2026-10-17: the console is back
+   * on phones, reversing 0.8.1). Turning the console ON from here does not put
+   * the cursor in the command box on a phone — see CommandTerminal.focusOnAppear.
+   */
+  readonly drawer: import("@angular/core").InputSignal<boolean>;
+  readonly menuItems: import("@angular/core").Signal<MenuItem[]>;
+  /**
+   * Readiness, not entitlement — an unentitled item never reaches here, having
+   * been filtered out by `visible` above. Read from the template so the
+   * predicate's signal reads are tracked and the strip regreys live when the
+   * user's state changes.
+   */
+  isEnabled(item: MenuItem): boolean;
+  disabledReasonFor(item: MenuItem): string;
+  /** The item's attention badge, or null when there is nothing to draw (no badge, or a count of 0). */
+  badgeFor(item: MenuItem): MenuBadge | null;
+  onMenuClick(item: MenuItem): void;
+  toggleHelp(): void;
+  toggleTerminal(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SideMenu, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SideMenu, "shell-side-menu", never, {
+    "drawer": {
+      "alias": "drawer";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class StatusBar {
+  #private;
+  readonly isAuthenticated: import("@angular/core").WritableSignal<boolean>;
+  /** The ☰ button: phones only, and only when there is a menu to open (signed in). */
+  readonly showMenuButton: import("@angular/core").Signal<boolean>;
+  readonly menuOpen: import("@angular/core").Signal<boolean>;
+  /**
+   * Whether a second window is offered at all (multiple-windows PRD D14).
+   *
+   * ⚠ GATED ON SHARED SESSIONS, and this is a correctness gate rather than a
+   * tidiness one. Without a session shared across windows, the new window starts
+   * with no token, goes to the login screen, and signing in there ends the
+   * session THIS window is using. A pop-out button in an app without sharing is
+   * a button that signs you out — the exact failure the multiple-windows work
+   * exists to remove.
+   */
+  readonly canPopOut: import("@angular/core").Signal<boolean>;
+  readonly loginStatus: import("@angular/core").Signal<"Authenticating..." | "Logged in" | "Not logged in">;
+  logout(): void;
+  /**
+   * Open the screen you are on in a second, sized window.
+   *
+   * There is no mechanism by which this differs from the browser's own
+   * "Duplicate tab": every window is a separate copy of the app started at some
+   * address. It exists for the sizing and because it is discoverable — Ctrl+T,
+   * a bookmark and dragging a tab out all work equally well once the session is
+   * shared.
+   *
+   * `noopener` is deliberate. The new window needs nothing from this one — it
+   * reads the session from storage — and leaving the opener reachable would give
+   * two windows script access to each other for no purpose.
+   */
+  popOut(): void;
+  toggleMenu(): void;
+  openFaq(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StatusBar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StatusBar, "shell-status-bar", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class MainContent {
+  #private;
+  readonly isThinking: import("@angular/core").Signal<boolean>;
+  readonly shortcutHelpVisible: import("@angular/core").WritableSignal<boolean>;
+  readonly activeShortcuts: import("@angular/core").Signal<{
+    groupId: string;
+    shortcuts: import("@franzzemen/brokenstock-shell").ShortcutRegistration[];
+  } | null>;
+  formatKey(key: string): string;
+  closeShortcutHelp(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MainContent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MainContent, "shell-main-content", never, {}, {}, never, never, true, never>;
+}
+export declare class CommandTerminal {
+  #private;
+  private readonly commandService;
+  private readonly registry;
+  private readonly authService;
+  private readonly terminalFocusService;
+  /**
+   * Whether the command box takes the cursor when the console first appears.
+   *
+   * True for a standalone console. The shell passes false on a phone (below
+   * 820px), including when the user turns the console on from the ☰ menu:
+   * showing the console is not a request to type, and focusing the box would
+   * raise the on-screen keyboard over it (scanner-phone-display D10). On a
+   * phone, focusInput() refuses anyway; this keeps the intent explicit.
+   */
+  readonly focusOnAppear: import("@angular/core").InputSignal<boolean>;
+  readonly history: import("@angular/core").Signal<import("@franzzemen/brokenstock-shell").CommandHistoryEntry[]>;
+  readonly currentInput: import("@angular/core").WritableSignal<string>;
+  readonly isProcessing: import("@angular/core").WritableSignal<boolean>;
+  /** The question a command left open (D24): the input answers it; Esc cancels. */
+  readonly pending: import("@angular/core").WritableSignal<import("@franzzemen/brokenstock-shell").PendingPrompt | null>;
+  private readonly inputEl;
+  private tabCycleIndex;
+  private lastTabPrefix;
+  readonly ghostText: import("@angular/core").Signal<string>;
+  constructor();
+  onSubmit(): void;
+  onInputChange(value: string): void;
+  dismissHelp(): void;
+  /** Esc: cancels an open question first, otherwise closes the help overlay. */
+  onEscape(): void;
+  onTab(event: KeyboardEvent): void;
+  getSeverityClass(result: CommandResult): string;
+  /**
+   * ⚠ A no-op on a phone (scanner-phone-display D10/E11). The console is shown
+   * there, but only the user tapping the box may give it the cursor; every
+   * programmatic path (first appearance, a finished command, a focus request,
+   * an app calling this) ends here and is refused, so nothing on a phone can
+   * raise the on-screen keyboard unasked.
+   */
+  focusInput(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CommandTerminal, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CommandTerminal, "shell-command-terminal", never, {
+    "focusOnAppear": {
+      "alias": "focusOnAppear";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class Login implements OnInit, OnDestroy {
+  #private;
+  protected authenticationService: AuthenticationService;
+  protected router: Router;
+  model: Credentials;
+  submitted: boolean;
+  hide: import("@angular/core").WritableSignal<boolean>;
+  errors: {
+    ndx: number;
+    message: string;
+  }[];
+  /**
+   * Session identifiers the user has ticked for ending (multiple-devices D7).
+   *
+   * ⚠ THE TAKEOVER CHECKBOX THAT USED TO LIVE ON THIS FORM IS GONE, and its
+   * removal is the point rather than a tidy-up. It defaulted to ON and sat on
+   * the FIRST form, before anything was known about what was live — so once a
+   * user deliberately holds sessions on two machines, one absent-minded submit
+   * ended the session on the machine in the other room. The choice belongs
+   * here, on the screen that lists what is actually running.
+   */
+  readonly selected: import("@angular/core").WritableSignal<ReadonlySet<string>>;
+  /** The code or recovery code typed on the code step (authenticator-sign-in.prd.md). */
+  codeText: string;
+  /** Typing a recovery code instead of the 6-digit code. */
+  readonly useRecovery: import("@angular/core").WritableSignal<boolean>;
+  protected readonly USERNAME_REGEX: RegExp;
+  protected readonly PASSWORD_REGEX: RegExp;
+  protected readonly appName: string;
+  /** Whether this browser can sign in with a passkey at all; the button is hidden otherwise (passkey D2). */
+  protected readonly passkeys: boolean;
+  /**
+   * Shown when the passkey prompt closed without a passkey: most often this device has none (a
+   * passkey lives on the device or account that made it). Plain advice, not an error.
+   */
+  protected readonly passkeyHint: import("@angular/core").WritableSignal<boolean>;
+  constructor(authenticationService: AuthenticationService, router: Router);
+  /** Safe on the server: the support check is false wherever there is no browser. */
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  /** "Sign in with a passkey". The quiet wait must stop first: a browser runs one passkey prompt at a time. */
+  onPasskey(): Promise<void>;
+  onAutofill(event: AutofillEvent, inputEl: HTMLInputElement): void;
+  clickEvent(event: MouseEvent): void;
+  onSubmit(event: Event): void;
+  /** Whether individual sessions can be ticked: only when the server named them. */
+  canEndIndividually(): boolean;
+  isSelected(session: SessionSummary): boolean;
+  toggleSelected(session: SessionSummary, checked: boolean): void;
+  selectedCount(): number;
+  /**
+   * What to call a session on screen.
+   *
+   * Falls back to the application name, which is what this screen showed before
+   * devices were recorded, and then to something plainly non-committal. It never
+   * invents a device: a session that predates the column genuinely has none, and
+   * guessing would make two machines look like one.
+   */
+  deviceLabel(session: SessionSummary): string;
+  onTakeOver(): void;
+  onSignInAsWell(): void;
+  onEndSelected(): void;
+  /** The code step: the 6-digit code (or a recovery code), with the credentials already accepted. */
+  onSubmitCode(event: Event): void;
+  onToggleRecovery(): void;
+  /** Back to the password form. */
+  onCancelCode(): void;
+  /** New recovery codes were shown after sign-in; now go where sign-in was going. */
+  onRecoveryCodesSaved(): void;
+  onCancelConflict(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Login, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Login, "shell-login", never, {}, {}, never, never, true, never>;
+}
+export declare class RecoveryCodes {
+  readonly codes: import("@angular/core").InputSignal<readonly string[]>;
+  readonly appName: import("@angular/core").InputSignal<string>;
+  readonly username: import("@angular/core").InputSignal<string | undefined>;
+  readonly done: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly copied: import("@angular/core").WritableSignal<boolean>;
+  download(): void;
+  copy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecoveryCodes, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecoveryCodes, "shell-recovery-codes", never, {
+    "codes": {
+      "alias": "codes";
+      "required": true;
+      "isSignal": true;
+    };
+    "appName": {
+      "alias": "appName";
+      "required": false;
+      "isSignal": true;
+    };
+    "username": {
+      "alias": "username";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "done": "done";
+  }, never, never, true, never>;
+}
 type Mode = 'view' | 'password' | 'scan' | 'reissue' | 'codes' | 'passkey-add' | 'passkey-remove';
-declare class AuthenticatorSettings implements OnInit {
-    #private;
-    protected readonly appName: string;
-    protected readonly status: _angular_core.WritableSignal<AuthenticatorStatus | undefined>;
-    protected readonly mode: _angular_core.WritableSignal<Mode>;
-    protected readonly busy: _angular_core.WritableSignal<boolean>;
-    protected readonly error: _angular_core.WritableSignal<string | undefined>;
-    protected readonly challenge: _angular_core.WritableSignal<SetupChallenge | undefined>;
-    protected readonly codes: _angular_core.WritableSignal<string[] | undefined>;
-    protected readonly useRecovery: _angular_core.WritableSignal<boolean>;
-    /** Whether this browser can make and use passkeys at all. */
-    protected readonly passkeys: boolean;
-    protected readonly passkeyList: _angular_core.WritableSignal<PasskeySummary[] | undefined>;
-    /** The passkey being removed, while its confirmation is on screen. */
-    protected readonly removing: _angular_core.WritableSignal<PasskeySummary | undefined>;
-    password: string;
-    code: string;
-    passkeyName: string;
-    ngOnInit(): void;
-    beginAddPasskey(): void;
-    beginRemovePasskey(passkey: PasskeySummary): void;
-    /** Add, proved with password + code (or recovery code) — or with a passkey already added. */
-    addPasskey(event: Event | undefined, withPasskey?: boolean): Promise<void>;
-    /** Remove, proved with a code or recovery code — or with a passkey. */
-    removePasskey(event: Event | undefined, withPasskey?: boolean): Promise<void>;
-    begin(mode: 'password' | 'reissue'): void;
-    cancel(): void;
-    toggleRecovery(): void;
-    /** Password (and current code when replacing) → QR. */
-    start(event: Event): Promise<void>;
-    /** The first code from the newly scanned app → recovery codes. */
-    confirm(event: Event): Promise<void>;
-    reissue(event: Event): Promise<void>;
-    codesSaved(): Promise<void>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthenticatorSettings, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthenticatorSettings, "shell-authenticator-settings", never, {}, {}, never, never, true, never>;
-}
-
-interface CodeDialogData {
-    title: string;
-    /** One line under the title saying what the code is for. */
-    message?: string;
-    /** Short lowercase label for the log, e.g. 'arm-live-trading' (D17). Changes nothing. */
-    purpose?: string;
-    confirmLabel?: string;
-}
-declare class CodeDialog {
-    #private;
-    readonly data: CodeDialogData;
-    readonly dialogRef: MatDialogRef<any, any>;
-    text: string;
-    protected readonly useRecovery: _angular_core.WritableSignal<boolean>;
-    protected readonly busy: _angular_core.WritableSignal<boolean>;
-    protected readonly error: _angular_core.WritableSignal<string | undefined>;
-    toggleRecovery(): void;
-    submit(event: Event): Promise<void>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeDialog, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeDialog, "shell-code-dialog", never, {}, {}, never, never, true, never>;
+export declare class AuthenticatorSettings implements OnInit {
+  #private;
+  protected readonly appName: string;
+  protected readonly status: import("@angular/core").WritableSignal<AuthenticatorStatus | undefined>;
+  protected readonly mode: import("@angular/core").WritableSignal<Mode>;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<string | undefined>;
+  protected readonly challenge: import("@angular/core").WritableSignal<SetupChallenge | undefined>;
+  protected readonly codes: import("@angular/core").WritableSignal<string[] | undefined>;
+  protected readonly useRecovery: import("@angular/core").WritableSignal<boolean>;
+  /** Whether this browser can make and use passkeys at all. */
+  protected readonly passkeys: boolean;
+  protected readonly passkeyList: import("@angular/core").WritableSignal<PasskeySummary[] | undefined>;
+  /** The passkey being removed, while its confirmation is on screen. */
+  protected readonly removing: import("@angular/core").WritableSignal<PasskeySummary | undefined>;
+  password: string;
+  code: string;
+  passkeyName: string;
+  ngOnInit(): void;
+  beginAddPasskey(): void;
+  beginRemovePasskey(passkey: PasskeySummary): void;
+  /** Add, proved with password + code (or recovery code) — or with a passkey already added. */
+  addPasskey(event: Event | undefined, withPasskey?: boolean): Promise<void>;
+  /** Remove, proved with a code or recovery code — or with a passkey. */
+  removePasskey(event: Event | undefined, withPasskey?: boolean): Promise<void>;
+  begin(mode: 'password' | 'reissue'): void;
+  cancel(): void;
+  toggleRecovery(): void;
+  /** Password (and current code when replacing) → QR. */
+  start(event: Event): Promise<void>;
+  /** The first code from the newly scanned app → recovery codes. */
+  confirm(event: Event): Promise<void>;
+  reissue(event: Event): Promise<void>;
+  codesSaved(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticatorSettings, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AuthenticatorSettings, "shell-authenticator-settings", never, {}, {}, never, never, true, never>;
+}
+export interface CodeDialogData {
+  title: string;
+  /** One line under the title saying what the code is for. */
+  message?: string;
+  /** Short lowercase label for the log, e.g. 'arm-live-trading' (D17). Changes nothing. */
+  purpose?: string;
+  confirmLabel?: string;
+}
+export declare class CodeDialog {
+  #private;
+  readonly data: CodeDialogData;
+  readonly dialogRef: MatDialogRef<any, any>;
+  text: string;
+  protected readonly useRecovery: import("@angular/core").WritableSignal<boolean>;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<string | undefined>;
+  toggleRecovery(): void;
+  submit(event: Event): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CodeDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CodeDialog, "shell-code-dialog", never, {}, {}, never, never, true, never>;
 }
 /** Opens the dialog; resolves with the recorded time (epoch ms), or undefined when cancelled. */
-declare function openCodeDialog(dialog: MatDialog, data: CodeDialogData): Promise<number | undefined>;
-
-interface ConfirmDialogData {
-    title: string;
-    message: string;
-    warningMessage?: string;
-    confirmLabel?: string;
-    cancelLabel?: string;
-}
-declare class ConfirmDialog {
-    readonly data: ConfirmDialogData;
-    readonly dialogRef: MatDialogRef<any, any>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialog, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialog, "shell-confirm-dialog", never, {}, {}, never, never, true, never>;
-}
-
-export { AuthenticationService, AuthenticatorError, AuthenticatorSettings, CLEAR_USAGE, CODE_STEP, CodeDialog, CommandRegistryService, CommandService, CommandTerminal, ConfirmDialog, FAQ_CONTENT_LOADER, FAQ_DEV_EDITOR, FAQ_DEV_MODE, FAQ_DEV_WORKSPACE_ROOT, FAQ_PUBLIC_PUBLISHER, FAQ_PUBLIC_SITE_BASE_URL, FaqAuthoringPanel, FaqHistoryService, FaqMarkdownRendererService, FaqModal, FaqService, HELP_USAGE, HttpFaqContentLoader, KeyboardShortcutService, Login, MainContent, PASSKEY_CANCELLED, PendingPromptState, PhoneLayoutService, PublicFaqIndex, PublicFaqPage, PublicFaqToc, RecoveryCodes, RegexValidatorDirective, SESSION_TOKEN_KEY, SHELL_APP_NAME, SHELL_AUTH_URLS, SHELL_COMMANDS, SHELL_MENU_ITEMS, SHELL_PHONE_MEDIA_QUERY, SHELL_POST_LOGIN_ROUTE, SHELL_SHARED_SESSION, ScreenKeysService, SessionTokenStore, Shell, SideMenu, StatusBar, TERMINAL_INPUT_CLASS, TOO_MANY_ATTEMPTS, TerminalFocusService, TerminalVisibilityService, ThemeService, ThinkingService, answerEcho, audienceAllowed, authGuard, authInterceptor, authenticatorMessage, buildFallbackChain, buildLoginBody, comboMatches, decideRenewal, guestGuard, isEligibleKey, isTypingElsewhere, isYes, matchesRoute, openCodeDialog, passkeyAutofillSupported, passkeysSupported, provideShellConfig, recoveryCodesFile, tokenize };
-export type { AuthenticatorReason, AuthenticatorStatus, CodeDialogData, CodeEntry, CommandAlias, CommandAvailability, CommandDefinition, CommandHistoryEntry, CommandLexiconEntry, CommandResult, CommandScope, ConfirmDialogData, FaqAudience, FaqContentLoader, FaqDevEditor, FaqEntry, FaqFrontmatter, FaqManifest, FaqPublicPublisher, FaqRegistrationHandle, FaqRenderContext, FaqRenderOptions, FaqResolution, LoginChoice, MenuBadge, MenuItem, ParsedFaq, PasskeyProof, PasskeySummary, PendingPrompt, RenewalDecision, ResolvedCommand, RouteScope, ScreenKeyCombo, ScreenKeyRegistration, SetupChallenge, Severity, ShellAuthUrls, ShellConfig, ShortcutRegistration, SignInCodeStep, ThemeMode };
-//# sourceMappingURL=franzzemen-brokenstock-shell.d.ts.map
+export declare function openCodeDialog(dialog: MatDialog, data: CodeDialogData): Promise<number | undefined>;
+export interface ConfirmDialogData {
+  title: string;
+  message: string;
+  warningMessage?: string;
+  confirmLabel?: string;
+  cancelLabel?: string;
+}
+export declare class ConfirmDialog {
+  readonly data: ConfirmDialogData;
+  readonly dialogRef: MatDialogRef<any, any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialog, "shell-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+export {};
+//# sourceMappingURL=franzzemen-brokenstock-shell.d.ts.map