@mudlet/mudlet-web 0.3.1 → 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/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/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/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/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

@@ -167,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). */

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 {};

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

@@ -0,0 +1,130 @@
+/**
+ * Find-in-output: scans the rendered scrollback for a query and tints every hit.
+ *
+ * This works purely on the rendered DOM rather than on the `AnsiAwareBuffer`
+ * model behind each line. Two reasons:
+ *
+ *  - Highlighting is transient. `buffer.applyFormat()` rewrites segment state,
+ *    so undoing a search highlight would mean snapshotting and restoring every
+ *    touched line's formatting — and a script that recolours a line mid-search
+ *    would lose its change. Wrapping text nodes in `<mark>` leaves the model
+ *    untouched, and unwrapping restores the DOM exactly.
+ *  - Offsets line up by construction. `appendCells` can substitute text on the
+ *    way to the DOM (tab-stop expansion, Mudlet control-character glyphs), so
+ *    `buffer.text` offsets do not always index the rendered line. Searching the
+ *    rendered text means we match what the player can actually see.
+ *
+ * The sticky split-view panel holds `cloneNode` copies of the last N lines, so
+ * it is not scanned — it lives outside the `.output-wrapper` scroller we walk.
+ * Re-populating it after highlighting copies the marks along with the lines.
+ */
+import type { MatchRange, SearchMatcher } from '../search/matcher';
+export declare const HIT_CLASS = "output-search-hit";
+export declare const CURRENT_HIT_CLASS = "output-search-hit--current";
+export interface OutputMatch {
+    /** The `.output-msg` line element containing this hit. */
+    line: HTMLElement;
+    /** Offsets into the line's rendered text — `[start, end)`. */
+    range: MatchRange;
+}
+/**
+ * Every match in the output, in document (i.e. chronological) order.
+ *
+ * Cheap enough to re-run on each keystroke: the per-line cost is one
+ * `textContent` read plus the matcher's scan, and only lines that actually hit
+ * get walked node-by-node later, in {@link applyHighlights}.
+ */
+export declare function scanOutput(container: HTMLElement, matcher: SearchMatcher): OutputMatch[];
+/**
+ * Tint every match, giving `matches[currentIndex]` the "current hit" treatment.
+ *
+ * Callers must {@link clearHighlights} first — marking an already-marked line
+ * would nest marks. Matches whose line has since been evicted from the DOM are
+ * skipped rather than treated as an error; the scrollback trims as new output
+ * arrives and a stale match is normal, not exceptional.
+ */
+export declare function applyHighlights(matches: OutputMatch[], currentIndex: number): void;
+/**
+ * Whether an Escape that reached the document should close the find bar.
+ *
+ * The bar's own input handles Escape directly, but the player usually leaves
+ * focus in the command line while reading results, and there Escape did nothing
+ * — the bar just stayed up. So the bar also listens on the document, in the
+ * BUBBLE phase, and defers to everything with a better claim on the key:
+ *
+ *  - `defaultPrevented` — someone already acted on it. Covers the bar's own
+ *    input, and layers correctly under CommandBar, which preventDefaults
+ *    Escape only while an autocomplete ghost is showing: first Escape dismisses
+ *    the ghost, a second one closes the bar.
+ *  - Modals (`useModalFocus`) stopPropagation on their own node, and
+ *    CaretReviewPanel uses capture + stopImmediatePropagation while focused, so
+ *    neither ever reaches a document bubble listener in the first place.
+ *  - The origin is then required to be inside `.app`, the profile-session shell
+ *    that owns the bar — toolbar, output, command line, docked panels. Floating
+ *    script windows portal to `<body>` instead (`.floating-window-root`), so
+ *    they fall outside it structurally and keep their own Escape.
+ *
+ * Pure apart from reading the event's target, so it is unit-testable.
+ */
+export declare function shouldCloseSearchOnEscape(e: KeyboardEvent): boolean;
+/**
+ * Which way `e` steps through search results — `1` for F3, `-1` for Shift+F3,
+ * or null when it isn't the search-step key at all. Mudlet's binding
+ * (`TConsole::setF3SearchEnabled` wires F3 to slot_searchBufferDown and
+ * Shift+F3 to slot_searchBufferUp).
+ *
+ * Any other modifier disqualifies it, so Ctrl+F3 / Alt+F3 / Cmd+F3 stay
+ * available to the browser and the OS. Pure — reads only `key` and the modifier
+ * flags — and shared by the bar (which steps) and the output area (which opens
+ * the bar when it's closed), so the two can never drift apart.
+ */
+export declare function searchStepDirection(e: KeyboardEvent): -1 | 1 | null;
+/**
+ * The rendered text of a whole matched line, for announcing a hit to a screen
+ * reader. Mudlet's `focusOnSearchResultAndAnnounce` speaks the entire buffer
+ * line rather than the matched fragment, so a listener hears the hit in context.
+ * Excludes the timestamp column, like {@link scanOutput}.
+ */
+export declare function matchLineText(match: OutputMatch): string;
+/**
+ * Park keyboard focus on the current hit so a screen reader's virtual cursor
+ * lands *on* the match in the live output — the reachable half of Mudlet's
+ * `focusOnSearchResultAndAnnounce`, which moves its caret to the found column.
+ *
+ * The mark is made programmatically focusable (`tabIndex = -1`), so it takes
+ * focus without joining the tab order. Scrolling is suppressed: `revealLine`
+ * has already centred the line, and the browser's own focus scroll would
+ * fight it. Returns false when there is no current hit to focus.
+ */
+export declare function focusCurrentHit(container: HTMLElement): boolean;
+/** Unwrap every mark this module added, restoring the pristine rendered line.
+ *  `normalize()` re-merges the text nodes `splitText` created so a subsequent
+ *  scan sees the same node layout it started with. */
+export declare function clearHighlights(container: HTMLElement): void;
+/**
+ * Scroll the output so `line` sits mid-viewport.
+ *
+ * Deliberately not `scrollIntoView` — that walks up and scrolls every scrollable
+ * ancestor, which in a docked layout drags the whole panel around. Measuring
+ * against the wrapper's own rect keeps the movement inside the output.
+ */
+export declare function revealLine(container: HTMLElement, line: HTMLElement): void;
+/**
+ * Index of the match nearest the current viewport — where a fresh search should
+ * start so the first Enter moves from what the player is looking at rather than
+ * from the top of a thousand-line scrollback. Falls back to the last (most
+ * recent) match when nothing is on screen.
+ */
+export declare function indexNearViewport(container: HTMLElement, matches: OutputMatch[]): number;
+/**
+ * Text to prefill the find box with — whatever the player has selected *in the
+ * output*, mirroring the browser's own find.
+ *
+ * Scoped to `container` on purpose. The command line keeps its last command
+ * selected after sending, and `window.getSelection()` can surface that, which
+ * would seed the box with the command the player just ran.
+ */
+export declare function seedFromSelection(container: HTMLElement | null): string;
+/** Locate `target` in a freshly rescanned match list, so incoming MUD output
+ *  does not move the player's place in the results. */
+export declare function findMatchIndex(matches: OutputMatch[], target: OutputMatch | null): number;

package/dist-lib/ui/search/matcher.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The query compiler shared by every search bar in the app (the script editor's
+ * `ScriptSearch`, the output find bar). Turns a raw query plus the case/regex
+ * toggles into something that hands back match ranges for any string.
+ */
+/** Half-open `[start, end)` character offsets of one match. */
+export type MatchRange = [number, number];
+export interface SearchMatcher {
+    /** False when `useRegex` was set and the pattern failed to compile — the
+     *  caller shows the input as invalid rather than reporting "no results". */
+    valid: boolean;
+    ranges: (s: string) => MatchRange[];
+}
+/** Compile a search bar query into a matcher honouring the case / regex flags. */
+export declare function buildMatcher(pattern: string, matchCase: boolean, useRegex: boolean): SearchMatcher;

package/dist-lib/ui/search/useDebounced.d.ts

@@ -0,0 +1,3 @@
+/** Return `value` delayed by `delay` ms — collapses bursts of keystrokes so an
+ *  expensive scan runs at most once per pause in typing. */
+export declare function useDebounced<T>(value: T, delay: number): T;

package/dist-lib/ui/tts/TtsManager.d.ts

@@ -64,5 +64,8 @@ export declare class TtsManager {
     private advance;
     private beginUtterance;
     private setState;
+    /** Text of the most recent ttsSpeechStarted, so speaking over a running
+     *  utterance can tell a genuinely new one from a repeat. */
+    private lastStarted;
 }
 export {};

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

@@ -1,7 +1,9 @@
 /** Reactive MRU command history wrapper around localStorage. History is scoped
  *  to `connectionId` so each profile keeps its own. `saveSize` caps how many
- *  entries are persisted (Mudlet's `commandLineHistorySaveSize`). */
-export declare function useCommandHistory(connectionId: string | null, saveSize?: number): {
+ *  entries are persisted (Mudlet's `commandLineHistorySaveSize`); `persist`
+ *  is Mudlet's per-command-line `setSaveCommandHistory`, which stops the writing
+ *  without touching the history this session already has. */
+export declare function useCommandHistory(connectionId: string | null, saveSize?: number, persist?: boolean): {
     history: string[];
     add: (item: string) => void;
 };

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

@@ -0,0 +1,26 @@
+/**
+ * Connection ids currently open in *another* browser tab.
+ *
+ * Every open profile holds an exclusive Web Lock named `mudix:profile:<id>`
+ * (see profileLock.ts), and `navigator.locks.query()` lists held locks across
+ * all same-origin tabs — so the held profile locks are exactly the open set.
+ * The connection screen renders with no profile active, so this tab holds no
+ * profile lock of its own and every hit belongs to someone else; no
+ * self-filtering is needed.
+ *
+ * Polled, because Web Locks has no change event. The refresh is also driven by
+ * focus/visibility so returning to the launcher tab after closing a profile
+ * elsewhere updates immediately instead of waiting out the interval.
+ *
+ * Returns an empty set where the API is unavailable (legacy browser, insecure
+ * context, test env) — the same "can't tell, so don't claim anything" fallback
+ * the lock itself uses.
+ */
+/** The profile ids among a `navigator.locks.query()` held-lock list. Non-profile
+ *  locks (any other feature using Web Locks) and unnamed entries are ignored. */
+export declare function openProfileIds(held: readonly {
+    name?: string;
+}[] | undefined): Set<string>;
+/** Whether two id sets hold the same members — used to skip no-op state updates. */
+export declare const sameIds: (a: ReadonlySet<string>, b: ReadonlySet<string>) => boolean;
+export declare function useOpenProfiles(enabled?: boolean, refreshMs?: number): Set<string>;