@mudlet/mudlet-web 0.5.0 → 1.0.1

package/dist-lib/ui/launcher/launcherModel.d.ts

@@ -0,0 +1,72 @@
+import type { BundledGame } from '../../mud/games/bundledGames';
+import { type MudConnection } from '../../storage';
+/**
+ * The launcher's non-visual logic: ordering profiles by when they were last
+ * played, the colours a profile with no icon is drawn in, and the "Where to?"
+ * search. Kept free of React so each rule is testable on its own.
+ */
+/** Profiles most recently played first. Never-played profiles follow, in their
+ *  stored order — so a player upgrading from the drag-ordered launcher sees
+ *  their own arrangement until they start playing, rather than a shuffle. */
+export declare function sortByLastPlayed(connections: readonly MudConnection[]): MudConnection[];
+/** "just now", "5 minutes ago", "yesterday", "3 weeks ago" — coarse on purpose:
+ *  it orients ("which one did I play last?"), it isn't a log. Null when the
+ *  profile has never been played. */
+export declare function formatLastPlayed(ts: number | undefined, now?: number): string | null;
+export interface Aurora {
+    /** Near-black background tinted toward the main hue. */
+    base: string;
+    /** The swept colours: main hue, a neighbour, and a contrasting accent. */
+    colors: [string, string, string];
+    /** Where the conic sweep starts, in degrees. */
+    angle: number;
+    /** Centre of the sweep, as percentages of the box. */
+    at: [number, number];
+}
+/** The aurora a profile with no icon is drawn with. Derived from the name
+ *  alone, so a profile looks the same on every visit and in every tab, and
+ *  nothing has to be stored. */
+export declare function auroraFor(name: string): Aurora;
+/** CSS `background` for an aurora, ready for an inline style. */
+export declare function auroraBackground(a: Aurora): string;
+/** A server typed straight into the search box. */
+export type TypedAddress = {
+    mode: 'mud';
+    host: string;
+    port: number;
+    label: string;
+} | {
+    mode: 'websocket';
+    url: string;
+    label: string;
+};
+/**
+ * Read `host`, `host:port` or a `ws(s)://` URL out of the search box. A bare
+ * word is only taken as a host when it is `localhost` — otherwise every name
+ * typed while searching ("achaea") would also be offered as a server.
+ */
+export declare function parseTypedAddress(query: string): TypedAddress | null;
+export interface LauncherResults {
+    profiles: MudConnection[];
+    games: BundledGame[];
+    address: TypedAddress | null;
+}
+export declare const SEARCH_GROUP_LIMIT = 5;
+/**
+ * What the "Where to?" box offers for `query`: the player's profiles, catalogue
+ * games, and the text itself as a server address when it reads as one.
+ * Descriptions are deliberately not searched — "dark" would match half the
+ * catalogue, and the box is for going somewhere, not browsing.
+ */
+export declare function searchLauncher(query: string, connections: readonly MudConnection[], games: readonly BundledGame[]): LauncherResults;
+/** The profile the "Continue playing" banner features: the one played most
+ *  recently, or — before anything has been played — the first in the
+ *  player's own order. */
+export declare function pickHero(connections: readonly MudConnection[]): MudConnection | null;
+/**
+ * Fold a new order of the grid's profiles back into the full stored order.
+ * The banner's profile isn't in the grid, so it keeps the slot it had —
+ * otherwise every drag would shove it to the end, and it would reappear
+ * there once another profile took the banner.
+ */
+export declare function mergeGridOrder(allIds: readonly string[], gridIds: readonly string[]): string[];

package/dist-lib/ui/layout/overlayLayerOrder.d.ts

@@ -1,7 +1,7 @@
 /**
  * Flat per-viewport z-order for every kind of overlay content: nested windows /
  * mini-consoles (including the embedded mapper), labels, overlay command lines,
- * and scroll boxes. This is the mudix analogue of Mudlet's Qt widget stack.
+ * and scroll boxes. This is the Mudlet Web analogue of Mudlet's Qt widget stack.
  *
  * ## Why flat (and not a container tree)
  *
@@ -17,7 +17,7 @@
  * an opened config menu rendered *under* a sibling mapper. Flat is correct.)
  *
  * Correct z-order alone is not enough: every overlay leaf must also render into
- * the SAME CSS stacking context for these ranks to take visual effect. mudix
+ * the SAME CSS stacking context for these ranks to take visual effect. Mudlet Web
  * ensures that by rendering all four overlay kinds under one wrapper per
  * viewport (`.main-overlay-root` for main; the panel viewport for a userwindow)
  * whose descendants' inline z-indices all compete directly. See

package/dist-lib/ui/menu/MenuBar.d.ts

@@ -0,0 +1,31 @@
+import type { MenuNode, TopMenu } from './menuModel';
+import './MenuBar.css';
+interface MenuListProps {
+    items: MenuNode[];
+    /** Dismiss the whole bar — what running an entry does. */
+    onCloseAll: () => void;
+    /** Dismiss this list only, handing focus back to whatever opened it.
+     *  Absent on a top-level dropdown, where Escape belongs to the bar. */
+    onCloseSelf?: () => void;
+    /** Put focus on the first entry — set when the list was opened from the
+     *  keyboard. A list opened by pointer leaves focus alone, as Qt does. */
+    autoFocus?: boolean;
+    /** A flyout opens beside its parent entry; a dropdown under its title. */
+    flyout?: boolean;
+    /**
+     * The control this list drops from — a menu title, a split button. Given
+     * one, the list is portaled to that element's document body and placed
+     * against its rect, the way Qt opens a menu as its own top-level window.
+     * Without it (a flyout, which opens inside a list that is already portaled)
+     * the list stays where it is written and positions itself in CSS.
+     */
+    anchor?: HTMLElement | null;
+}
+export declare function MenuList({ items, onCloseAll, onCloseSelf, autoFocus, flyout, anchor }: MenuListProps): import("react/jsx-runtime").JSX.Element;
+interface MenuBarProps {
+    menus: TopMenu[];
+    /** Accessible name for the bar. */
+    label?: string;
+}
+export declare function MenuBar({ menus, label }: MenuBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/menu/SplitButton.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Qt's `QToolButton::MenuButtonPopup` — a button with an arrow beside it.
+ *
+ * Mudlet's toolbar uses it for the things that are one action most of the time
+ * and a short list of related ones occasionally: Connect (with Disconnect and
+ * Close profile behind the arrow), Mute, the package managers. Pressing the
+ * button half runs the default action; pressing the arrow half opens the rest.
+ * The two halves are separate controls on purpose — a player reaching for
+ * Connect should never open a menu by accident.
+ */
+import { type ReactNode } from 'react';
+import type { MenuNode } from './menuModel';
+interface SplitButtonProps {
+    /** The default action's face — icon and label, as any other toolbar button. */
+    children: ReactNode;
+    title?: string;
+    /** The default action: what the button half does. */
+    onClick: () => void;
+    /** Drawn pressed, for a default action that is a state rather than a verb
+     *  (Mudlet's Mute button is its "Mute all media" action, checkable). */
+    checked?: boolean;
+    /** Everything behind the arrow, including the default action itself — Qt
+     *  lists it there too, and a menu missing the thing the button does reads
+     *  as if the button were something else. */
+    items: MenuNode[];
+    /** Accessible name for the arrow half, e.g. "Connection actions". */
+    menuLabel: string;
+    /**
+     * Lay the whole thing out as siblings instead: the default action, then
+     * each entry as its own full-width button. For the hamburger, where a popup
+     * inside a popup is not a menu anyone can drive.
+     */
+    stacked?: boolean;
+    /** Run after any of these actions — the hamburger closes itself with it.
+     *  Stacked layout only; the popup closes on its own. */
+    onAnyAction?: () => void;
+}
+export declare function SplitButton({ children, title, onClick, checked, items, menuLabel, stacked, onAnyAction, }: SplitButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/menu/anchoredPopup.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Placing a popup against the control that opened it.
+ *
+ * In Qt a menu is its own top-level window: it is placed at a screen position
+ * and paints over everything, and nothing about the widget that opened it can
+ * trap it. The web has no such thing — a dropdown written inside the bar that
+ * owns it is stuck in that bar's stacking context, which is what forced the
+ * menu bar above the floating windows and cost every click on a window drawn
+ * in its strip (issue #145).
+ *
+ * So the popups portal to `<body>` and are placed here instead, against the
+ * rect of their anchor. Same idea as ResizableModal's portal, one step further:
+ * the modal only needed to escape, a menu also has to land somewhere.
+ */
+import { type RefObject } from 'react';
+export interface AnchorRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface PopupSize {
+    width: number;
+    height: number;
+}
+export interface ViewportSize {
+    width: number;
+    height: number;
+}
+export interface Placement {
+    left: number;
+    top: number;
+}
+/** Which of the popup's edges lines up with the same edge of its anchor. */
+export type PopupAlign = 'start' | 'end';
+/**
+ * Where a popup of `size` goes when hung off `anchor` inside `viewport`.
+ *
+ * Below the anchor by default, flipping above it when there is no room; aligned
+ * on the `align` edge, flipping to the other one when it would overrun. Always
+ * clamped into the viewport afterwards, because on a small enough window a
+ * popup overruns whichever way it is flipped and a menu half off the screen is
+ * a menu with entries nobody can reach.
+ *
+ * Pure, and in viewport coordinates — the popup is `position: fixed`.
+ */
+export declare function placePopup(anchor: AnchorRect, size: PopupSize, viewport: ViewportSize, align?: PopupAlign): Placement;
+/**
+ * Live placement for a portaled popup: null until it has been measured, so the
+ * caller can keep it out of sight for the one frame before it knows where it
+ * goes. Re-measures on resize and on any scroll (capture phase — the anchor may
+ * ride inside a scroller that is not the document).
+ *
+ * `deps` re-runs the measurement when the popup's own contents change size.
+ */
+export declare function useAnchoredPopup(anchor: HTMLElement | null | undefined, popupRef: RefObject<HTMLElement | null>, align?: PopupAlign, deps?: unknown): Placement | null;
+/**
+ * Style for a portaled popup, before and after it has been measured.
+ *
+ * Rendered hidden rather than not at all: it has to be in the document for its
+ * size to be measurable, and `useAnchoredPopup` measures in a layout effect, so
+ * the unplaced frame never reaches the screen.
+ */
+export declare function anchoredStyle(placement: Placement | null): React.CSSProperties;
+/**
+ * Did a pointer event land on the control or on a popup it opened?
+ *
+ * The dismiss-on-outside-click handlers used to answer this with
+ * `root.contains(target)`. A portaled popup is no longer a descendant of the
+ * control that owns it, so containment alone now reports every click on the
+ * menu's own entries as "outside" — the menu would unmount on pointerdown and
+ * the entry's click never fire.
+ */
+export declare function inPopupSurface(root: HTMLElement | null | undefined, target: EventTarget | null): boolean;

package/dist-lib/ui/menu/appMenus.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The client's own menus — Mudlet's menu bar (main_window.ui) as far as a
+ * browser tab has anything to put under it.
+ *
+ * The titles and their order are Mudlet's: Games, Toolbox, Options, Window,
+ * Help, About. What hangs under them is not, and deliberately so — Mudlet's
+ * "Reattach detached windows", "Always on top" and "Minimize" describe a
+ * desktop window this client does not own, and an entry that cannot work is
+ * worse than an absent one. What is here is what the toolbar already does,
+ * reachable a second way, plus the two things the toolbar has no room for
+ * (timestamps, About).
+ *
+ * A brand can hide any stock toolbar button; the same decision hides the menu
+ * entry, so a brand that removed a feature does not find it again in a menu.
+ * Menus that empty out that way are dropped rather than drawn blank.
+ */
+import type { StockToolbarButton } from '../../branding';
+import type { AppCommandId } from '../commands/appShortcuts';
+import type { MenuNode, TopMenu } from './menuModel';
+export interface AppMenuContext {
+    /** The brand's stock-button filter, shared with the toolbar row. */
+    show: (id: StockToolbarButton) => boolean;
+    appName: string;
+    /** The Games menu's entries — the same list the toolbar's Connect split
+     *  button holds, passed in rather than rebuilt here. The two are one
+     *  control on two surfaces. */
+    connectionItems: MenuNode[];
+    replayRecording: boolean;
+    /** Playback speed of the running replay, or null when none is playing. */
+    replaySpeed: number | null;
+    /** The document is in real fullscreen, and whether the browser allows it. */
+    fullscreen: boolean;
+    fullscreenAvailable: boolean;
+    /** Mudlet's main-toolbar visibility. The menu bar's own switch is NOT here:
+     *  an entry that hides the menu it is in leaves no way back to itself, so
+     *  that one lives in the settings only. */
+    showToolbar: boolean;
+    showTimestamps: boolean;
+    /** Mudlet's three media mute entries — the same list the toolbar's Mute
+     *  split button holds, passed in rather than rebuilt so the two surfaces
+     *  cannot come to describe the gates differently. */
+    muteItems: MenuNode[];
+    /** The key bound to a command right now, for the menu to draw beside its
+     *  label — the entry ids below ARE the command ids, so the lookup needs no
+     *  second table to go wrong. */
+    shortcutFor: (id: AppCommandId) => string | undefined;
+    onOpenScripts: () => void;
+    onOpenMap: () => void;
+    /** setConfig("mapperButton", "disabled") is in force. */
+    mapDisabled?: boolean;
+    onOpenFiles: () => void;
+    onOpenNotepad: () => void;
+    onOpenLogs: () => void;
+    onToggleReplayRecording: () => void;
+    onReplayStop: () => void;
+    onOpenSettings: () => void;
+    onToggleTimestamps: () => void;
+    onToggleFullscreen: () => void;
+    onToggleToolbar: () => void;
+    onOpenDocs: () => void;
+    onOpenHelp: () => void;
+    onOpenAbout: () => void;
+    onReportBug: () => void;
+}
+export declare function buildAppMenus(ctx: AppMenuContext): TopMenu[];

package/dist-lib/ui/menu/menuModel.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The shape of the client's own menu bar, and where a package's menu commands
+ * land in it.
+ *
+ * Mudlet shows a command in two places: on the toolbar and on the menu bar. The
+ * toolbar half has been here since addCommand landed; this is the other half,
+ * and it is the reason `menuPath` exists at all — a path with nowhere to lead
+ * was accepted and then quietly dropped.
+ *
+ * The menus themselves mirror main_window.ui (Games, Toolbox, Options, Window,
+ * Help, About) as far as a browser tab has anything to put under them. Entries
+ * Mudlet has and a web client cannot (always-on-top, minimise, reattach
+ * detached windows, IRC) are absent rather than present-and-dead.
+ */
+import type { ReactNode } from 'react';
+/**
+ * A command asking to be placed, from whichever source. Packages place them
+ * with `addCommand` from Lua and a host app with the exported `commands`
+ * registry; by the time they reach here the difference is gone, which is the
+ * point — a white-label client's own command should sit in a menu exactly the
+ * way a package's does.
+ */
+export interface PlacedCommand {
+    /** Unique across sources, so the two cannot collide: `lua:3`, `host:7`. */
+    id: string;
+    name: string;
+    /** An image URL from a package's setCommandIcon, or any node a host app
+     *  passed. */
+    icon?: ReactNode;
+    tooltip?: string;
+    /** Where on the menu bar. Empty means {@link DEFAULT_ADDON_MENU}. */
+    menuPath?: string;
+    shortcut?: string;
+    enabled?: boolean;
+    checked?: boolean;
+    run: () => void;
+}
+export interface MenuAction {
+    kind: 'action';
+    /** Stable within its menu — the React key, and what the tests match on. */
+    id: string;
+    label: string;
+    /** Qt-style key sequence, drawn right-aligned. Display only: the registry
+     *  reserves a package's key, but nothing dispatches it yet. */
+    shortcut?: string;
+    /** Drawn with a tick. `undefined` means the entry is not checkable at all,
+     *  which is not the same as unchecked — only the first gets no tick column
+     *  reserved by the screen reader. */
+    checked?: boolean;
+    disabled?: boolean;
+    /** A package's icon path, or a node from a host app or a brand. Sized to
+     *  the label by the stylesheet either way. */
+    icon?: ReactNode;
+    run: () => void;
+}
+export interface MenuSeparator {
+    kind: 'separator';
+    id: string;
+}
+export interface MenuSubmenu {
+    kind: 'submenu';
+    id: string;
+    label: string;
+    items: MenuNode[];
+}
+export type MenuNode = MenuAction | MenuSeparator | MenuSubmenu;
+export interface TopMenu {
+    id: string;
+    label: string;
+    items: MenuNode[];
+}
+/**
+ * Where a menu command with no path of its own goes. Toolbox is where Mudlet
+ * keeps the things packages bring (the package and module managers, the script
+ * editor), so a command that named no menu is at least among its own kind
+ * rather than opening a top-level menu holding one entry.
+ */
+export declare const DEFAULT_ADDON_MENU = "Toolbox";
+/**
+ * The menu bar with `commands` placed in it, leaving `menus` untouched.
+ *
+ * A path's first segment names a top-level menu — an existing one when the
+ * title matches, a new one at the end of the bar otherwise — and each further
+ * segment a submenu under it. Commands arrive in placement order, which is the
+ * order they are drawn in: a package that adds three commands gets them in the
+ * order it added them, under or beside whatever was already there.
+ */
+export declare function placeCommands(menus: TopMenu[], commands: readonly PlacedCommand[]): TopMenu[];

package/dist-lib/ui/menu/toolbarModel.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The button row as data, so a brand can rearrange it.
+ *
+ * The row used to be a fixed run of JSX with a `hide` list threaded through it,
+ * which let a brand subtract and append and nothing else — no reordering, no
+ * renaming, no putting its own command between two stock ones. A white-label
+ * client is somebody else's product wearing this client's engine, and the shape
+ * of its chrome is theirs to decide, so the row is now a list they are handed
+ * and hand back.
+ *
+ * The menu bar's counterpart is `TopMenu[]` in `menuModel.ts`; the two
+ * transforms in `BrandToolbarConfig` take and return these.
+ */
+import type { ReactNode } from 'react';
+import type { MenuNode } from './menuModel';
+/** A plain button. */
+export interface ToolbarButtonItem {
+    kind: 'button';
+    /** Stable across renders — the React key, and what a brand matches on to
+     *  find an item in the stock list. Stock ids are the `StockToolbarButton`
+     *  names; a package's are `lua:<n>`, a host app's `host:<n>`. */
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    title?: string;
+    /** Drawn pressed. */
+    checked?: boolean;
+    disabled?: boolean;
+    /** Extra class, for the few stock buttons with a look of their own (the
+     *  recorder's pulsing dot, a package command's pulse). */
+    className?: string;
+    /** Custom properties, for a package's `setCommandPulse` colours. */
+    style?: React.CSSProperties;
+    run: () => void;
+}
+/** Qt's split button: a default action with the rest behind an arrow. */
+export interface ToolbarSplitItem {
+    kind: 'split';
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    title?: string;
+    checked?: boolean;
+    /** Accessible name for the arrow half. */
+    menuLabel: string;
+    items: MenuNode[];
+    run: () => void;
+}
+/** Anything that is not a button — the replay speed controls, or whatever a
+ *  brand wants to drop into the row. Rendered as given. */
+export interface ToolbarCustomItem {
+    kind: 'custom';
+    id: string;
+    node: ReactNode;
+}
+export type ToolbarItem = ToolbarButtonItem | ToolbarSplitItem | ToolbarCustomItem;

package/dist-lib/ui/notepad.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Mudlet's Notepad (`dlgNotepad`) — the per-profile scratch pad on the main
+ * toolbar, as a set of named tabs.
+ *
+ * Kept where and how desktop keeps it, so a profile moved between the two
+ * keeps its notes: `notes.json` in the profile's home directory
+ * (`getMudletHomeDir() .. "/notes.json"`), shaped
+ * `{ version: 1, tabs: [{ name, content }], activeTab }`. Before tabs, desktop
+ * kept one plain-text note in `notes_utf8.txt` (and before that `notes.txt`);
+ * with no `notes.json` the first of those found becomes a tab named "Notes",
+ * as `dlgNotepad::migrateOldNotesFile` does. The old file is left in place.
+ */
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+export declare const NOTES_FILE = "notes.json";
+/** Desktop's pre-tab files, newest first — the order `migrateOldNotesFile` tries them. */
+export declare const LEGACY_NOTES_FILES: readonly ["notes_utf8.txt", "notes.txt"];
+/** Name of the tab a fresh, unreadable or migrated notepad starts with. */
+export declare const DEFAULT_TAB_NAME = "Notes";
+/** Name of a tab added with + or Ctrl+T. */
+export declare const NEW_TAB_NAME = "New Note";
+/**
+ * How long typing must pause before the notes are written. Desktop saves on a
+ * two-minute timer and on close, which is safe there because closing the
+ * window is the only way out; a browser tab can be closed, reloaded or
+ * discarded with the dialog open, so the wait is short here.
+ */
+export declare const NOTES_SAVE_DELAY_MS = 1000;
+/** Desktop's `mSendTimer` interval: one line every 300ms, the first after the
+ *  first tick, so a pasted list doesn't flood the game. */
+export declare const NOTES_SEND_INTERVAL_MS = 300;
+export interface NoteTab {
+    name: string;
+    content: string;
+}
+export interface NotepadData {
+    tabs: NoteTab[];
+    activeTab: number;
+}
+export declare function notesPath(vfs: ProfileVFS, file?: string): string;
+/**
+ * `notes.json`'s text as a notepad, with desktop's `restore()` leniency: a
+ * file that is not JSON, not an object, or has no tabs opens as one empty
+ * "Notes" tab rather than failing, and an out-of-range `activeTab` is ignored.
+ */
+export declare function parseNotepad(json: string): NotepadData;
+/** What `dlgNotepad::save()` writes (Qt's indented JSON is four spaces). */
+export declare function serializeNotepad(data: NotepadData): string;
+/** The profile's notes: `notes.json`, else a migrated single note, else one empty tab. */
+export declare function loadNotepad(vfs: ProfileVFS): NotepadData;
+export declare function saveNotepad(vfs: ProfileVFS, data: NotepadData): void;
+/** Moves the tab at `from` to `to` (tabs are drag-movable, as desktop's are),
+ *  keeping the same tab active. */
+export declare function moveTab(data: NotepadData, from: number, to: number): NotepadData;
+/** Closes a tab; the last one cannot be closed (`dlgNotepad::closeTab`). */
+export declare function closeTab(data: NotepadData, index: number): NotepadData;
+/**
+ * The next case-insensitive occurrence of `query` from the selection, wrapping
+ * around the end (or the start, going backwards) — `QPlainTextEdit::find`,
+ * retried from the other end as `slot_findNext`/`slot_findPrevious` do.
+ * Forward search starts after the selection, so a repeated Find steps on
+ * rather than finding the match already selected. Null when there is none.
+ */
+export declare function findInNotes(text: string, query: string, selStart: number, selEnd: number, backwards?: boolean): {
+    start: number;
+    end: number;
+} | null;
+/** How many times `query` occurs (case-insensitively), for the find bar. */
+export declare function countInNotes(text: string, query: string): number;
+/** The line the caret is on (`QTextCursor::LineUnderCursor`), without its newline. */
+export declare function lineAt(text: string, caret: number): string;
+/**
+ * What a send queue actually sends: each line with the prepend text in front,
+ * blank lines skipped (`slot_sendNextLine` passes over them, though they still
+ * take their 300ms turn — the caller keeps that pacing).
+ */
+export declare function lineToSend(line: string, prepend: string): string | null;

package/dist-lib/ui/openSignInPage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Open a sign-in page in a new tab without asking, as Mudlet does with
+ * `QDesktopServices::openUrl`. A page may only open a tab while it holds
+ * transient user activation — a few seconds after a click or key press — and
+ * a GMCP `Char.Login.URL` usually lands well inside that window, because it
+ * answers the menu choice the player just typed. Outside it the browser would
+ * block the popup, so this returns false without trying and the caller falls
+ * back to the sign-in dialog, whose button is a gesture of its own.
+ *
+ * Opened blank first, so whether the browser allowed it is known (a
+ * `noopener` open always returns null), then cut off from us before it
+ * navigates: the provider's page gets no handle back on ours.
+ */
+export declare function openSignInPage(url: string, win?: Window): boolean;

package/dist-lib/ui/output/OutputContextMenu.d.ts

@@ -8,10 +8,20 @@ interface OutputContextMenuProps {
     y: number;
     /** Whether the selection touches this window (gates the copy actions). */
     hasSelection: boolean;
+    /** Whether this console holds any line at all. "Copy as image" needs only
+     *  this, since it falls back to the visible area. */
+    hasContent: boolean;
     onSelectAll: () => void;
     onCopy: () => void;
     onCopyHtml: () => void;
     onCopyImage: () => void;
+    /** Display name of the configured web-search engine, e.g. "Google". */
+    searchEngine: string;
+    onSearchOnline: () => void;
+    /** Mudlet's "Analyse characters" — omitted unless the profile's "Enable
+     *  text analyzer" preference is on, exactly as desktop gates it
+     *  (TTextEdit::contextMenuEvent, src/TTextEdit.cpp:2482). */
+    onAnalyseText?: () => void;
     /** Opens the find bar — only the main console passes this. */
     onFind?: () => void;
     /** Timestamp toggle — only the main console passes these. */
@@ -19,7 +29,10 @@ interface OutputContextMenuProps {
     onToggleTimestamps?: () => void;
     /** Script-provided entries (Mudlet addMouseEvent). */
     extraItems?: OutputMenuExtraItem[];
+    /** Where focus goes when the menu closes — the command line, not the console
+     *  that the right-click focused. See {@link ContextMenu}. */
+    returnFocusTo?: () => HTMLElement | null | undefined;
     onClose: () => void;
 }
-export declare function OutputContextMenu({ x, y, hasSelection, onSelectAll, onCopy, onCopyHtml, onCopyImage, onFind, showTimestamps, onToggleTimestamps, extraItems, onClose, }: OutputContextMenuProps): import("react/jsx-runtime").JSX.Element;
+export declare function OutputContextMenu({ x, y, hasSelection, hasContent, onSelectAll, onCopy, onCopyHtml, onCopyImage, searchEngine, onSearchOnline, onAnalyseText, onFind, showTimestamps, onToggleTimestamps, extraItems, returnFocusTo, onClose, }: OutputContextMenuProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist-lib/ui/output/OutputRenderer.d.ts

@@ -63,6 +63,11 @@ export type OutputRendererControls = {
     clearStickyArea: () => void;
     push: (message: string | AnsiAwareBuffer, type?: string, timestamp?: number) => void;
     clear: () => void;
+    /** True while a tail scroll is queued for the next frame — lines have
+     *  landed that the view is about to follow. A scroll event seen in that
+     *  window measures the view against content it has not caught up with
+     *  yet, so it is not the reader scrolling away (#456). */
+    isTailScrollQueued: () => boolean;
 };
 export declare function setupOutputRenderer(source: MessageSource | null, { outputWrapper, sentinel, stickyArea, isSplitView, stickyLines, suppressSplitView, followTail, onCursorReady, }: OutputHandlerOptions): OutputRendererControls;
 export {};

package/dist-lib/ui/output/OutputSearchBar.d.ts

@@ -9,6 +9,10 @@ interface OutputSearchBarProps {
      *  output selection, so pressing the shortcut again behaves like the
      *  browser's find rather than doing nothing. */
     focusNonce: number;
+    /** Whether that open moves focus into the box (default true). False for
+     *  the F3 that `f3SearchEnabled` lets open the bar: it must leave focus on
+     *  the command line, as desktop's toolbar search does. */
+    takeFocus?: boolean;
     onClose: () => void;
     /** Rebuilds the split-view panel from the (now highlighted) source lines —
      *  its contents are clones, so marks only reach it via a re-populate. */
@@ -21,5 +25,5 @@ interface OutputSearchBarProps {
      *  See docs/config-api.md. */
     a11ySearch?: boolean;
 }
-export declare function OutputSearchBar({ session, outputRef, focusNonce, onClose, refreshSticky, commandInputRef, a11ySearch, }: OutputSearchBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function OutputSearchBar({ session, outputRef, focusNonce, takeFocus, onClose, refreshSticky, commandInputRef, a11ySearch, }: OutputSearchBarProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist-lib/ui/output/StickyOutputPanel.d.ts

@@ -1,5 +1,6 @@
 import type React from 'react';
 import { type OutputMenuExtraItem } from './OutputContextMenu';
+import { type SelectionBounds } from './outputCopy';
 interface StickyOutputPanelProps {
     outputRef: React.RefObject<HTMLDivElement | null>;
     sentinelRef: React.RefObject<HTMLDivElement | null>;
@@ -15,10 +16,23 @@ interface StickyOutputPanelProps {
     onToggleTimestamps?: () => void;
     /** Opens the find bar from the right-click menu — main console only. */
     onFind?: () => void;
+    /** What to call this console in a copied HTML document's title — the
+     *  profile name for the main console, the window name for a script one. */
+    sourceName?: string;
     /** Script-provided right-click entries (Mudlet addMouseEvent), evaluated
-     *  lazily when the menu opens since the registry can change. */
-    getMenuExtraItems?: () => OutputMenuExtraItem[];
+     *  lazily when the menu opens since the registry can change. Given the
+     *  console's selection as it stood when the menu opened, which is what
+     *  the entry's handler is passed. */
+    getMenuExtraItems?: (selection: SelectionBounds) => OutputMenuExtraItem[];
     commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    /** When set, the scrollback becomes a named, Tab-reachable landmark — an id
+     *  a skip link can target, a region role, and an explicit tab stop rather
+     *  than Chrome's "focusable scrollable region" behaviour, which the other
+     *  browsers do not all provide. Only the main console passes these: a script
+     *  window already sits inside its own labelled region (TextPanel), and
+     *  nesting a second one there would only add noise to the landmark list. */
+    regionId?: string;
+    regionLabel?: string;
     className?: string;
     fontSize?: number;
     fontFamily?: string;
@@ -28,5 +42,5 @@ interface StickyOutputPanelProps {
     wrapIndent?: number;
     wrapHangingIndent?: number;
 }
-export declare function StickyOutputPanel({ outputRef, sentinelRef, stickyAreaRef, isSplitView, scrollToBottom, background, backgroundExtra, foreground, showTimestamps, onToggleTimestamps, onFind, getMenuExtraItems, commandInputRef, className, fontSize, fontFamily, lineHeight, wrapAt, wrapIndent, wrapHangingIndent, }: StickyOutputPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function StickyOutputPanel({ outputRef, sentinelRef, stickyAreaRef, isSplitView, scrollToBottom, background, backgroundExtra, foreground, showTimestamps, onToggleTimestamps, onFind, sourceName, getMenuExtraItems, commandInputRef, regionId, regionLabel, className, fontSize, fontFamily, lineHeight, wrapAt, wrapIndent, wrapHangingIndent, }: StickyOutputPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};