@mudlet/mudlet-web 0.3.0 → 0.4.0

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

@@ -0,0 +1,21 @@
+import { type BundledGame } from '../mud/games/bundledGames';
+import type { MudConnection } from '../storage';
+/** The connection record a game turns into. Mudlet's catalogue is host/port, so
+ *  these are proxied `mud` profiles — the same thing the Add form builds. */
+export declare function connectionFromGame(game: BundledGame): Omit<MudConnection, 'id'>;
+interface Props {
+    /** Profiles that already exist, so a game someone has played is offered by
+     *  its profile tile above rather than a second time down here. */
+    connections: MudConnection[];
+    busy: boolean;
+    /** Create the profile and start playing. */
+    onPlay: (game: BundledGame) => void;
+}
+/**
+ * The games Mudlet ships with, offered the way Mudlet offers them: a browsable
+ * list you can start playing without filling in a form. Picking one is what
+ * turns it into a profile — until then nothing is stored, so the list is not a
+ * pile of empty profiles a player has to tidy up.
+ */
+export declare function BundledGameGrid({ connections, busy, onPlay }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -19,6 +19,10 @@ interface CharLoginModalProps {
     /** Decline GMCP login — sends the empty reply so the server falls back to
      *  its text login prompt. */
     onCancel: () => void;
+    /** Where focus goes once the popup closes. The server raised this dialog,
+     *  not a click, so there is no meaningful opener to return to — the caller
+     *  points this at the command line so the player can type straight away. */
+    restoreFocusTo?: () => HTMLElement | null | undefined;
 }
 /**
  * Credentials popup for GMCP `Char.Login` authentication. Rendered as a real
@@ -28,5 +32,5 @@ interface CharLoginModalProps {
  * the inline warning); the password is otherwise handed straight to `onSubmit`
  * and relayed to the server, never stored. Cancelling falls back to text login.
  */
-export declare function CharLoginModal({ connectionName, error, initialAccount, initialPassword, initialRemember, allowRemember, onSubmit, onCancel, }: CharLoginModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function CharLoginModal({ connectionName, error, initialAccount, initialPassword, initialRemember, allowRemember, onSubmit, onCancel, restoreFocusTo, }: CharLoginModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -10,8 +10,14 @@ interface CommandBarProps {
     /** Tab-completion suggestions added via Mudlet's addCmdLineSuggestion API.
      *  Merged ahead of command history (dedup, case-insensitive). */
     suggestions?: string[];
+    /** Words Mudlet's addCmdLineBlacklist API has taken out of Tab completion.
+     *  Subtractive across every source below, not just `suggestions`. */
+    blacklist?: string[];
+    /** Mudlet's per-command-line setSaveCommandHistory. False keeps the history
+     *  for this session but stops persisting it. */
+    saveHistory?: boolean;
     /** Recency-ordered words seen in output, for argument-word Tab completion. */
     bufferWords?: BufferWordIndex | null;
 }
-export declare function CommandBar({ command, onCommandChange, passwordMode, commandInputRef, onSubmit, cmdLineMenu, suggestions, bufferWords }: CommandBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function CommandBar({ command, onCommandChange, passwordMode, commandInputRef, onSubmit, cmdLineMenu, suggestions, blacklist, saveHistory, bufferWords }: CommandBarProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -4,6 +4,9 @@ interface Props {
     connecting: boolean;
     connectingId: string | null;
     editingId: string | null;
+    /** Ids already open in another browser tab — one tab per profile, so these
+     *  can't be opened here until that tab releases them. */
+    openIds: Set<string>;
     onConnect: (c: MudConnection) => void;
     onOpen: (c: MudConnection) => void;
     onEdit: (c: MudConnection) => void;
@@ -14,5 +17,5 @@ interface Props {
 /** Draggable, animated grid of profile cards. Reordering lifts the dragged tile
  *  into a floating clone, opens a dashed placeholder at the target slot, and
  *  slides the remaining tiles into their new positions with a FLIP animation. */
-export declare function ConnectionGrid({ connections, connecting, connectingId, editingId, onConnect, onOpen, onEdit, onDelete, onReorder, onAddClick, }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function ConnectionGrid({ connections, connecting, connectingId, editingId, openIds, onConnect, onOpen, onEdit, onDelete, onReorder, onAddClick, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,4 +1,5 @@
 import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+export declare function collectZipEntries(vfs: ProfileVFS, dirPath: string, prefix: string, out: Record<string, Uint8Array>, depth?: number): void;
 export interface VFSNode {
     name: string;
     path: string;

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

@@ -5,9 +5,9 @@ import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
  * header ✕) must call `onDone` — with the picked absolute VFS path, or '' for
  * cancel (Mudlet's return value for a dismissed dialog).
  *
- * `mode === 'file'` picks a file; `mode === 'folder'` picks a directory and
- * hides files entirely, mirroring QFileDialog::getOpenFileName vs
- * getExistingDirectory in Mudlet.
+ * The tree itself is VfsPickerModal, shared with the app's "pick from profile
+ * files" buttons; this wrapper only narrows it to the single-path contract Lua
+ * expects.
  */
 interface FilePickerModalProps {
     vfs: ProfileVFS | null;

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

@@ -0,0 +1,11 @@
+import './HelpModal.css';
+interface HelpModalProps {
+    /** Bounds are remembered per profile; omitted on the start screen, where
+     *  there is no active connection to key them by. */
+    connectionId?: string;
+    /** Topic to open on — defaults to the migration guide. */
+    initialTopic?: string;
+    onClose: () => void;
+}
+export declare function HelpModal({ connectionId, initialTopic, onClose }: HelpModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,7 +1,10 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
 interface LogBrowserModalProps {
     connectionId: string;
     connectionName: string;
+    /** Lets "Import…" read a log export the profile already holds. */
+    vfs?: ProfileVFS | null;
     onClose: () => void;
 }
-export declare function LogBrowserModal({ connectionId, connectionName, onClose }: LogBrowserModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function LogBrowserModal({ connectionId, connectionName, vfs, onClose }: LogBrowserModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,20 @@
+import { type MapperSettings } from '../storage';
+interface PlayerMarkerPreviewProps {
+    /** The profile's live mapper settings — the preview honours all of them
+     *  (room shape/size, borders, exit colour, background, grid), not just the
+     *  marker, so what it shows is what the map will look like. */
+    mapper: MapperSettings | undefined;
+}
+/**
+ * Live preview of the player-position marker, rendered by the *actual*
+ * `MapRenderer` against a five-room stub map.
+ *
+ * Deliberately not a hand-drawn SVG mock: the marker's geometry (size relative
+ * to `roomSize`, dash phase, the rect/circle switch driven by `matchRoomShape`
+ * + `roomShape`, the rounded-rectangle corner radius) all lives in the
+ * renderer, and a reimplementation here would drift silently the first time
+ * the library changes it. Konva is already in the bundle for MapPanel, so this
+ * costs a stage, not a chunk.
+ */
+export declare function PlayerMarkerPreview({ mapper }: PlayerMarkerPreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,9 +1,13 @@
 import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+import type { TlsStatus } from '../mud/events';
 interface SettingsModalProps {
     onClose: () => void;
     /** Active profile id; null on the connection screen (only theme is editable). */
     connectionId: string | null;
     vfs?: ProfileVFS | null;
+    /** TLS state of the live session, when there is one. Drives the certificate
+     *  box below the secure-connection reminder. */
+    tlsStatus?: TlsStatus | null;
 }
-export declare function SettingsModal({ onClose, connectionId, vfs }: SettingsModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function SettingsModal({ onClose, connectionId, vfs, tlsStatus }: SettingsModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,18 @@
+import type { TlsStatus } from '../mud/events';
+interface Props {
+    status: TlsStatus;
+    /** The plaintext port to fall back to, when one was remembered. */
+    revertPort?: number;
+    onRevert: () => void;
+    onDismiss: () => void;
+}
+/**
+ * Explains a TLS connection that didn't work, and offers the way back.
+ *
+ * Mudlet reacts to a certificate failure by opening Preferences on the
+ * connection tab with the offending checkbox highlighted; the browser
+ * equivalent is to say which setting would allow it and let the user undo the
+ * port change in one click.
+ */
+export declare function TlsAlertBanner({ status, revertPort, onRevert, onDismiss }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,20 @@
+import type { TlsCertInfo } from '../mud/events';
+interface Props {
+    cert: TlsCertInfo | null;
+    /** False when the proxy runtime cannot read peer certificates at all. */
+    certInspection: boolean;
+    protocol?: string;
+    cipher?: string;
+    /** Faults the profile's ignore-flags waved through, if any. */
+    acceptedDespite?: string[];
+}
+/**
+ * The certificate of the current secure connection.
+ *
+ * Shows the same four fields Mudlet surfaces in Preferences → Connection
+ * (issuer, issued-to, expiry, serial), plus the negotiated protocol. When the
+ * proxy can't inspect certificates it says so rather than rendering an empty
+ * box — "unknown" and "none" would look identical otherwise.
+ */
+export declare function TlsCertificateBox({ cert, certInspection, protocol, cipher, acceptedDespite }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,16 @@
+interface Props {
+    /** The secure port the server advertised via MSSP. */
+    port: number;
+    onAccept: () => void;
+    onDecline: () => void;
+}
+/**
+ * Offers the MSSP-advertised secure port. Wording follows Mudlet's prompt
+ * (cTelnet::promptTlsConnectionAvailable) so the choice reads the same to
+ * anyone arriving from the desktop client.
+ *
+ * Declining is permanent for the profile, so it is stated on the button's
+ * description rather than hidden behind a "don't ask again" checkbox.
+ */
+export declare function TlsUpgradeModal({ port, onAccept, onDecline }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -12,6 +12,7 @@ interface ToolbarProps {
     onOpenFiles: () => void;
     onOpenLogs: () => void;
     onOpenDocs: () => void;
+    onOpenHelp: () => void;
     onOpenSettings: () => void;
     /** Mudlet-format replay recording toggle state + handler. */
     replayRecording: boolean;
@@ -25,5 +26,5 @@ interface ToolbarProps {
     /** Capabilities handed to brand toolbar buttons (send / raiseEvent). */
     brandContext?: BrandToolbarContext;
 }
-export declare function Toolbar({ connectionName, status, ping, onDisconnect, onReconnect, onNewConnection, onOpenMap, onOpenScripts, onOpenFiles, onOpenLogs, onOpenDocs, onOpenSettings, replayRecording, onToggleReplayRecording, replaySpeed, onReplaySpeedChange, onReplayStop, onContextMenu, brandContext }: ToolbarProps): import("react/jsx-runtime").JSX.Element;
+export declare function Toolbar({ connectionName, status, ping, onDisconnect, onReconnect, onNewConnection, onOpenMap, onOpenScripts, onOpenFiles, onOpenLogs, onOpenDocs, onOpenHelp, onOpenSettings, replayRecording, onToggleReplayRecording, replaySpeed, onReplaySpeedChange, onReplayStop, onContextMenu, brandContext }: ToolbarProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,26 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+/**
+ * The profile-VFS file/folder picker. Backs both Lua's `invokeFileDialog`
+ * (single file or folder — see FilePickerModal) and the "pick from profile
+ * files" half of every place the app would otherwise only take an upload from
+ * the user's computer.
+ *
+ * `mode`:
+ *  - `file`   — one file (QFileDialog::getOpenFileName)
+ *  - `files`  — several files, checkbox per row
+ *  - `folder` — one directory, files hidden (getExistingDirectory)
+ */
+export type VfsPickerMode = 'file' | 'files' | 'folder';
+interface VfsPickerModalProps {
+    vfs: ProfileVFS | null;
+    mode: VfsPickerMode;
+    title?: string;
+    /** VFS path to reveal on open; '' or invalid falls back to the root. */
+    location?: string;
+    /** Filename filter — non-matching files are hidden (folders always show). */
+    accept?: RegExp;
+    /** Picked absolute VFS paths; an empty array means the user cancelled. */
+    onDone: (paths: string[]) => void;
+}
+export declare function VfsPickerModal({ vfs, mode, title, location, accept, onDone }: VfsPickerModalProps): import("react").ReactPortal;
+export {};

package/dist-lib/ui/components/FileSourceButton.d.ts

@@ -0,0 +1,47 @@
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+import type { ProfileVFS } from '../../scripting/vfs/ProfileVFS';
+export interface PickedFile {
+    file: File;
+    /** Absolute VFS path — set only when the file came from the profile. */
+    vfsPath?: string;
+}
+export interface FileSourceOptions {
+    vfs: ProfileVFS | null;
+    /** `accept` for the OS picker; also derives the VFS filter when `vfsAccept` is absent. */
+    accept?: string;
+    /** Filename filter for the VFS tree. Pass `null` to show every file. */
+    vfsAccept?: RegExp | null;
+    multiple?: boolean;
+    /** Start directory for the VFS picker. */
+    location?: string;
+    /** Title of the VFS picker window. */
+    pickerTitle?: string;
+    onPick: (files: PickedFile[]) => void | Promise<void>;
+    /** Surfaces a VFS read failure; falls back to console.warn when absent. */
+    onError?: (message: string) => void;
+}
+/**
+ * Turn an `accept` attribute into a filename filter for the VFS tree.
+ * Extensions and `type/*` wildcards translate; a concrete MIME type
+ * (`application/json`) doesn't, since VFS entries carry no content type — those
+ * contribute nothing, and an accept list of only such entries filters nothing
+ * rather than hiding every file.
+ */
+export declare function acceptToRegExp(accept?: string): RegExp | undefined;
+/**
+ * Headless half of the dual-source picker, for call sites whose trigger isn't a
+ * plain `Button` (the map overlay's own buttons, hamburger menu entries).
+ * Render `elements` anywhere in the subtree and call `open(triggerElement)`.
+ */
+export declare function useFileSource({ vfs, accept, vfsAccept, multiple, location, pickerTitle, onPick, onError, }: FileSourceOptions): {
+    open: (anchor: HTMLElement | DOMRect | null) => void;
+    elements: ReactNode;
+};
+type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'icon' | 'danger';
+interface FileSourceButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'onError'>, FileSourceOptions {
+    label: ReactNode;
+    variant?: ButtonVariant;
+    size?: 'sm' | 'md';
+}
+export declare function FileSourceButton({ vfs, label, accept, vfsAccept, multiple, location, pickerTitle, onPick, onError, variant, size, ...buttonProps }: FileSourceButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/components/index.d.ts

@@ -2,6 +2,7 @@ export { Button } from './Button';
 export { Input } from './Input';
 export { FormField, CheckField } from './FormField';
 export { ContextMenu } from './ContextMenu';
+export { FileSourceButton, useFileSource, acceptToRegExp, type PickedFile } from './FileSourceButton';
 export { ConfirmDialog, ConfirmProvider, useConfirm } from './ConfirmDialog';
 export type { ConfirmButton, ConfirmOptions } from './ConfirmDialog';
 export { FontPicker } from './FontPicker';

package/dist-lib/ui/components/useModalFocus.d.ts

@@ -14,5 +14,11 @@ export interface ModalFocusOptions {
     /** Close on Escape via `onClose`. Default true. Set false when the modal has
      *  its own Escape handling (then `onClose` may be omitted). */
     closeOnEscape?: boolean;
+    /** Where focus should land on close, instead of the opener. Use when the
+     *  dialog was raised by the game rather than by a click, so "the opener" is
+     *  either nothing or a control that has since gone away — the GMCP login
+     *  popup hands focus to the command line this way. Falls back to the opener
+     *  when it returns null. */
+    restoreFocusTo?: () => HTMLElement | null | undefined;
 }
 export declare function useModalFocus<T extends HTMLElement = HTMLDivElement>(onClose?: () => void, opts?: ModalFocusOptions): React.RefObject<T | null>;

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

@@ -0,0 +1,19 @@
+export interface HelpTopic {
+    /** Stable id used in state and (eventually) deep links. */
+    id: string;
+    /** Sidebar label. Kept short — the markdown's own H1 is the real title. */
+    title: string;
+    /** One line under the label, so the sidebar answers "which one do I want?" */
+    blurb: string;
+    /** Basename in docs/help/, for resolving relative links between topics. */
+    file: string;
+    markdown: string;
+}
+export declare const HELP_TOPICS: HelpTopic[];
+export declare const DEFAULT_HELP_TOPIC: string;
+/** Resolve a markdown link href to a topic id, or null if it isn't one of ours.
+ *  Handles `./storage.md`, `storage.md`, `docs/help/storage.md` and a `#anchor`
+ *  suffix — the shapes a relative link between these files can take. */
+export declare function topicForHref(href: string): string | null;
+/** Topics whose title, blurb or body mention `query`. Empty query = everything. */
+export declare function searchHelpTopics(query: string): HelpTopic[];

package/dist-lib/ui/labels/LabelManager.d.ts

@@ -70,6 +70,13 @@ export interface LabelState {
         visitedColor?: string;
         underline: boolean;
     };
+    /** Hrefs clicked in this label, tracked so `linkStyle.visitedColor` can be
+     *  applied explicitly — CSS `:visited` only ever matches real browser
+     *  history, so it never fires for the `send:`/`prompt:` pseudo-schemes label
+     *  links use. Mirrors Mudlet's `TLabel::mVisitedLinks`, which exists for the
+     *  same reason (Qt won't style them either). Only populated while a visited
+     *  color is set, as Mudlet does. */
+    visitedLinks?: Set<string>;
     /** Click handler installed by setLabelClickCallback. The event table mirrors
      *  Mudlet's `mudlet.mouse_button` shape: `{button, x, y, alt, ctrl, shift, meta}`. */
     onClick?: (event: LabelMouseEvent) => void;
@@ -117,11 +124,16 @@ export interface LabelWheelEvent extends LabelMouseEvent {
     };
 }
 type Listener = (labels: LabelState[]) => void;
+/** Runs the action behind an `<a href>` clicked inside a label — installed by
+ *  ScriptingAPI, which owns the send/prompt/openUrl/Lua machinery the schemes
+ *  map onto (see {@link LabelManager.setLinkActivator}). */
+type LinkActivator = (href: string) => void;
 export declare class LabelManager {
     readonly overlayZ: OverlayLayerOrder;
     private readonly labels;
     private readonly byParent;
     private readonly listeners;
+    private linkActivator;
     private indexAdd;
     private indexRemove;
     constructor(overlayZ?: OverlayLayerOrder);
@@ -155,6 +167,13 @@ export declare class LabelManager {
     /** Mudlet setMovie — install (or replace) the label's GIF player. */
     setMovie(name: string, player: MoviePlayer): boolean;
     getMovie(name: string): MoviePlayer | null;
+    /** Mudlet's `getProfileStats().gifs`: how many labels carry a movie, and
+     *  how many of those are actually running. Deleting a label takes its movie
+     *  out of both counts, since the label is where a movie lives. */
+    movieStats(): {
+        total: number;
+        active: number;
+    };
     /** Mudlet scaleMovie — autoscale tracks the label size (CSS 100%);
      *  autoscale=false freezes the scale at the label's current geometry.
      *  False when the label has no movie (matches Mudlet's warning case). */
@@ -175,6 +194,19 @@ export declare class LabelManager {
     setStyleSheet(name: string, css: string): boolean;
     /** Mudlet `setLinkStyle(labelName, linkColor, linkVisitedColor, underline)`. */
     setLinkStyle(name: string, color: string, visitedColor: string, underline: boolean): boolean;
+    /**
+     * Install the handler that runs a clicked label link (`<a href="send:…">`).
+     * The manager itself has no scripting access, so LabelOverlay routes clicks
+     * here and ScriptingAPI supplies the behaviour.
+     */
+    setLinkActivator(fn: LinkActivator | null): void;
+    /**
+     * A link inside `name`'s rich text was clicked. Records it as visited (when
+     * a visited color is configured) and runs the activator — Mudlet's
+     * `TLabel::slot_linkActivated`, which does the same two things in the same
+     * order.
+     */
+    activateLink(name: string, href: string): void;
     /** Mudlet `resetLinkStyle(labelName)` — drop any setLinkStyle override. */
     resetLinkStyle(name: string): boolean;
     /** Mudlet `getLabelStyleSheet(name)` — the Qt-style CSS last set via

package/dist-lib/ui/labels/labelLinks.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `<a href>` links inside a label's rich text — Mudlet's `TLabel::slot_linkActivated`
+ * (src/TLabel.cpp).
+ *
+ * Geyser packages build clickable UI by echoing anchors into a label:
+ *
+ *   myLabel:echo([[<a href="send:help topics">Help</a>]])
+ *
+ * and the href's scheme decides what a click does. The rules deliberately differ
+ * from the OSC 8 links the main window renders (`classifyHyperlinkUri`):
+ *
+ * - a scheme-less href is **Lua source** to run, not a dropped link;
+ * - only `send:`, `prompt:`, `http:` and `https:` are recognised (no `ftp:`);
+ * - the payload is **not** percent-decoded — Qt hands `linkActivated` the href
+ *   verbatim, so `send:cast fireball` reaches the MUD with its literal space.
+ *
+ * Any other scheme is ignored rather than falling through to the Lua branch,
+ * which is what stops a `javascript:`/`file:`/`data:` href from executing.
+ */
+export type LabelLinkAction = {
+    kind: 'send';
+    command: string;
+} | {
+    kind: 'prompt';
+    command: string;
+} | {
+    kind: 'url';
+    url: string;
+}
+/** No scheme at all — the whole href is a Lua chunk. */
+ | {
+    kind: 'lua';
+    code: string;
+};
+/**
+ * Classify a label link href. Returns null when the link does nothing (empty,
+ * or an unrecognised scheme).
+ *
+ * Like Mudlet, the split is on the first `:` rather than an RFC 3986 scheme
+ * match — so a scheme-less chunk that happens to contain a colon
+ * (`myTable:method()`) is treated as an unknown scheme and ignored.
+ */
+export declare function classifyLabelLink(href: string): LabelLinkAction | null;
+/**
+ * The href of the anchor an event target sits inside, or null when the click
+ * didn't land on a link.
+ *
+ * Read through `getAttribute` on purpose: the `.href` *property* resolves the
+ * value against the page URL and percent-encodes it, which would turn
+ * `send:help topics` into `send:help%20topics` and mangle the command.
+ */
+export declare function labelLinkHref(target: EventTarget | null): string | null;

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

@@ -1,4 +1,4 @@
-import type { DockSide, DragState } from '../windows/types';
+import type { DockSide, DragState, MxpTabPage } from '../windows/types';
 import type { WindowManager } from '../windows/WindowManager';
 interface ScriptWindowProps {
     id: string;
@@ -17,6 +17,15 @@ interface ScriptWindowProps {
     /** When true, dragging the titlebar still moves the window but never
      *  enters a dock zone — mirrors Mudlet's openUserWindow(..., autoDock=false). */
     lockFloating?: boolean;
+    /** MXP `<FRAME TITLE=…>` tab strip drawn above the content. The first page
+     *  is this window's own console; the rest are `DOCK`ed frames nested inside
+     *  its viewport. See MxpFrameManager. */
+    frameTabs?: {
+        pages: MxpTabPage[];
+        active: string;
+    };
+    /** Console backing an MXP `<FRAME>` — outlines it, like Mudlet does. */
+    isMxpFrame?: boolean;
     onFocus: () => void;
     onMoved: (x: number, y: number) => void;
     onResized: (w: number, h: number) => void;
@@ -25,5 +34,5 @@ interface ScriptWindowProps {
     onTitlebarContextMenu: (e: React.MouseEvent) => void;
     onHide: () => void;
 }
-export declare function ScriptWindow({ id, title, visible, x, y, width, height, zIndex, manager, isMiniConsole, lockFloating, onFocus, onMoved, onResized, onDock, onDragStateChange, onTitlebarContextMenu, onHide, }: ScriptWindowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ScriptWindow({ id, title, visible, x, y, width, height, zIndex, manager, isMiniConsole, lockFloating, frameTabs, isMxpFrame, onFocus, onMoved, onResized, onDock, onDragStateChange, onTitlebarContextMenu, onHide, }: ScriptWindowProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1 +1,10 @@
-export declare function renderMarkdown(src: string): string;
+interface RenderOptions {
+    /** Turn a single newline into a `<br>`. On for user-written notes, where
+     *  `gfm + breaks` matches the behavior most note apps render. Off for
+     *  hard-wrapped prose documents, where source line breaks are just wrapping
+     *  and rendering them would shred every paragraph — which is also how GitHub
+     *  renders a `.md` file. */
+    breaks?: boolean;
+}
+export declare function renderMarkdown(src: string, { breaks }?: RenderOptions): string;
+export {};

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

@@ -4,6 +4,16 @@ interface OutputAreaProps {
     session: MudSession;
     stickyLines?: number;
     commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    /** Extra insets claimed by edge-aligned MXP `<FRAME>`s, on top of the
+     *  profile's setBorder* sizes. Mudlet keeps the two apart the same way
+     *  (Host::mUserBorders + mMxpBorders) so a server layout and a script never
+     *  clobber each other's borders. */
+    mxpBorders?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
 }
-export declare function OutputArea({ session, stickyLines, commandInputRef }: OutputAreaProps): import("react/jsx-runtime").JSX.Element;
+export declare function OutputArea({ session, stickyLines, commandInputRef, mxpBorders }: OutputAreaProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -12,6 +12,8 @@ interface OutputContextMenuProps {
     onCopy: () => void;
     onCopyHtml: () => void;
     onCopyImage: () => void;
+    /** Opens the find bar — only the main console passes this. */
+    onFind?: () => void;
     /** Timestamp toggle — only the main console passes these. */
     showTimestamps?: boolean;
     onToggleTimestamps?: () => void;
@@ -19,5 +21,5 @@ interface OutputContextMenuProps {
     extraItems?: OutputMenuExtraItem[];
     onClose: () => void;
 }
-export declare function OutputContextMenu({ x, y, hasSelection, onSelectAll, onCopy, onCopyHtml, onCopyImage, showTimestamps, onToggleTimestamps, extraItems, onClose, }: OutputContextMenuProps): import("react/jsx-runtime").JSX.Element;
+export declare function OutputContextMenu({ x, y, hasSelection, onSelectAll, onCopy, onCopyHtml, onCopyImage, onFind, showTimestamps, onToggleTimestamps, extraItems, onClose, }: OutputContextMenuProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -47,6 +47,12 @@ type OutputHandlerOptions = {
     maxElements?: number | (() => number);
     trimSlack?: number;
     suppressSplitView?: (durationMs: number) => void;
+    /** Whether new output should scroll the view to the tail. True for a
+     *  scrollback; false for a console the writer rewrites wholesale — an MXP
+     *  frame written with `<DEST … EOF>` — where following the tail makes the
+     *  content slide as a multi-flush redraw lands. Read live on every write, so
+     *  a console can become top-anchored after it is already mounted. */
+    followTail?: () => boolean;
     /** Called once the cursor ops are ready; wire them to ScriptingAPI/session. */
     onCursorReady?: (ops: CursorOps) => void;
 };
@@ -60,5 +66,5 @@ export type OutputRendererControls = {
     push: (message: string | AnsiAwareBuffer, type?: string, timestamp?: number) => void;
     clear: () => void;
 };
-export declare function setupOutputRenderer(source: MessageSource | null, { outputWrapper, sentinel, stickyArea, isSplitView, stickyLines, maxElements, trimSlack, suppressSplitView, onCursorReady, }: OutputHandlerOptions): OutputRendererControls;
+export declare function setupOutputRenderer(source: MessageSource | null, { outputWrapper, sentinel, stickyArea, isSplitView, stickyLines, maxElements, trimSlack, suppressSplitView, followTail, onCursorReady, }: OutputHandlerOptions): OutputRendererControls;
 export {};

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

@@ -0,0 +1,25 @@
+import type React from 'react';
+import type { MudSession } from '../../mud/MudSession';
+import './OutputSearchBar.css';
+interface OutputSearchBarProps {
+    session: MudSession;
+    /** The `.output-wrapper` scroller holding the rendered scrollback. */
+    outputRef: React.RefObject<HTMLDivElement | null>;
+    /** Changes on every Ctrl+F. Re-focuses the box and re-seeds it from the
+     *  output selection, so pressing the shortcut again behaves like the
+     *  browser's find rather than doing nothing. */
+    focusNonce: number;
+    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. */
+    refreshSticky?: () => void;
+    /** Focus target once the bar closes, so the player can keep typing. */
+    commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    /** Mudlet's `f3SearchEnabled` — the accessibility mode for buffer search.
+     *  Turns each step into a screen-reader event: only the current hit stays
+     *  tinted, focus parks on it, and the whole matched line is announced.
+     *  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 {};

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

@@ -13,6 +13,8 @@ interface StickyOutputPanelProps {
     foreground?: string;
     showTimestamps?: boolean;
     onToggleTimestamps?: () => void;
+    /** Opens the find bar from the right-click menu — main console only. */
+    onFind?: () => void;
     /** Script-provided right-click entries (Mudlet addMouseEvent), evaluated
      *  lazily when the menu opens since the registry can change. */
     getMenuExtraItems?: () => OutputMenuExtraItem[];
@@ -20,9 +22,11 @@ interface StickyOutputPanelProps {
     className?: string;
     fontSize?: number;
     fontFamily?: string;
+    /** Rendered row height in px, overriding the stylesheet line-height. */
+    lineHeight?: number;
     wrapAt?: number;
     wrapIndent?: number;
     wrapHangingIndent?: number;
 }
-export declare function StickyOutputPanel({ outputRef, sentinelRef, stickyAreaRef, isSplitView, scrollToBottom, background, backgroundExtra, foreground, showTimestamps, onToggleTimestamps, getMenuExtraItems, commandInputRef, className, fontSize, fontFamily, 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, getMenuExtraItems, commandInputRef, className, fontSize, fontFamily, lineHeight, wrapAt, wrapIndent, wrapHangingIndent, }: StickyOutputPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};