@mudlet/mudlet-web 0.3.0

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

@@ -0,0 +1,57 @@
+import type React from 'react';
+export declare function cssTextToStyle(css: string): React.CSSProperties;
+export interface QtMargin {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface CssParts {
+    inline: React.CSSProperties;
+    scoped: Array<{
+        pseudo: string;
+        declarations: string;
+    }>;
+    margin?: QtMargin;
+}
+export declare function cssTextToParts(css: string): CssParts;
+export declare function userWindowQssToScopedCss(qss: string, scope: string): string;
+export declare function cmdLineQssToScopedCss(qss: string, scope: string): string;
+/** Qt objectNames (from Mudlet's `.ui` files) that mudix mirrors onto a DOM node
+ *  via `data-qt-object`, so package stylesheets addressing them keep working.
+ *  Reference these instead of writing the raw string at the render site. */
+export declare const QT_OBJECT_NAMES: {
+    /** dlgMapper's collapsible control bar — area picker, z-level buttons,
+     *  options menu (`mapper.ui`: `widget_panel`). */
+    readonly mapperPanel: "widget_panel";
+    /** The arrow that shows/hides that bar (`mapper.ui`: `toolButton_togglePanel`). */
+    readonly mapperPanelToggle: "toolButton_togglePanel";
+    /** Area selector (`mapper.ui`: `comboBox_showArea`). */
+    readonly mapperAreaSelector: "comboBox_showArea";
+    /** Z-level up / down buttons (`mapper.ui`: `toolButton_shiftZup/down`). */
+    readonly mapperShiftZup: "toolButton_shiftZup";
+    readonly mapperShiftZdown: "toolButton_shiftZdown";
+    /** The mapper's hamburger / options button (`mapper.ui`: `toolButton_mapperMenu`). */
+    readonly mapperMenu: "toolButton_mapperMenu";
+};
+/**
+ * Rewrite the Qt selectors in an app/profile-level stylesheet — objectName forms
+ * (`QWidget#widget_panel`) and mapped widget types (`QDockWidget::title`) — onto
+ * the DOM they correspond to in mudix. Returns the input unchanged when it holds
+ * no Qt selector at all, which is the common case for CSS written against
+ * mudix's own `.mudix-*` classes.
+ *
+ * A rule whose selector we rewrote also gets its *declarations* translated
+ * (`qtDeclarationsToCss`): that body was written for Qt, so it may carry
+ * `QLinearGradient(…)`, Qt's 0–255 `rgba()` alpha, or unitless lengths. Rules we
+ * left alone keep their declarations verbatim. Comments are stripped up front —
+ * they're inert, and an unbalanced brace or stray `#` inside one would otherwise
+ * confuse the scan.
+ */
+export declare function rewriteQtSelectors(qss: string): string;
+export declare function cssEscape(s: string): string;
+export declare function patchStyleSheetBackgroundColor(styleSheet: string, r: number, g: number, b: number, a: number): string;
+export declare function qtDeclarationsToCss(css: string, important?: boolean): string;
+export declare function qtAlignmentToFlex(val: string): Record<string, string>;
+export declare function extractQtAlignment(css: string): string | undefined;
+export declare function extractQtScaledContents(css: string): boolean | undefined;

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

@@ -0,0 +1,19 @@
+import type { MudSession } from '../../mud/MudSession';
+import type { WindowManager } from '../windows/WindowManager';
+import type { ScriptingEngine } from '../../scripting/ScriptingEngine';
+import type { ProfileVFS } from '../../scripting/vfs/ProfileVFS';
+import './ScriptWindow.css';
+interface ContentLayoutProps {
+    session: MudSession;
+    manager: WindowManager;
+    connectionId: string;
+    stickyLines?: number;
+    commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    commandBar?: React.ReactNode;
+    contextMenuHandlerRef?: React.RefObject<((e: React.MouseEvent) => void) | null>;
+    /** Live ref so button clicks reach the engine even though the ref is set after initial render. */
+    scriptingEngineRef?: React.RefObject<ScriptingEngine | null>;
+    vfs?: ProfileVFS | null;
+}
+export declare function ContentLayout({ session, manager, connectionId, stickyLines, commandInputRef, commandBar, contextMenuHandlerRef, scriptingEngineRef, vfs, }: ContentLayoutProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import type { DockSide, DragState, ScriptWindowRenderData } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface DockAreaProps {
+    side: DockSide;
+    windows: ScriptWindowRenderData[];
+    extent: number;
+    dragState: DragState | null;
+    manager: WindowManager;
+    onSetExtent: (side: DockSide, n: number) => void;
+    onDragStateChange: (ds: DragState | null) => void;
+    onTitlebarContextMenu: (e: React.MouseEvent) => void;
+}
+export declare function DockArea({ side, windows, extent, dragState, manager, onSetExtent, onDragStateChange, onTitlebarContextMenu }: DockAreaProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+import type { DragState } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface DockedPanelProps {
+    id: string;
+    title: string;
+    kind: 'text' | 'html' | 'map';
+    manager: WindowManager;
+    onHide: () => void;
+    onDragStateChange: (ds: DragState | null) => void;
+    onTitlebarContextMenu: (e: React.MouseEvent) => void;
+}
+export declare function DockedPanel({ id, title, manager, onHide, onDragStateChange, onTitlebarContextMenu }: DockedPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { DragState, ScriptWindowRenderData } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface FloatingWindowLayerProps {
+    windows: ScriptWindowRenderData[];
+    manager: WindowManager;
+    onDragStateChange: (ds: DragState | null) => void;
+    onTitlebarContextMenu: (e: React.MouseEvent) => void;
+}
+export declare function FloatingWindowLayer({ windows, manager, onDragStateChange, onTitlebarContextMenu }: FloatingWindowLayerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import type { MudSession } from '../../mud/MudSession';
+import type { ScriptWindowRenderData } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface MobileLayoutProps {
+    session: MudSession;
+    manager: WindowManager;
+    /** Already filtered to non-popped-out windows by ContentLayout. */
+    windows: ScriptWindowRenderData[];
+    stickyLines?: number;
+    commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    commandBar?: React.ReactNode;
+}
+/**
+ * Phone layout: a single column showing one view at a time — the main MUD
+ * output or one script panel — flipped via a bottom switcher bar. The desktop
+ * dock/float chrome (drag, splitters, floating frames) is bypassed entirely;
+ * panel *content* is reused untouched by re-parenting the same stable
+ * portal-target divs WindowManager already maintains (same trick as the
+ * desktop TabGroupPanel), so panels stay live in the background.
+ */
+export declare function MobileLayout({ session, manager, windows, stickyLines, commandInputRef, commandBar }: MobileLayoutProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,35 @@
+import type { WindowManager } from '../windows/WindowManager';
+interface PopoutWindowProps {
+    id: string;
+    title: string;
+    width: number;
+    height: number;
+    manager: WindowManager;
+    /** Called when the popout should be re-docked into the main window — either
+     *  because the user closed the child window, or the browser blocked it. */
+    onClosed: () => void;
+}
+/**
+ * Detaches a panel into a separate browser window.
+ *
+ * The whole window system is built on a single persistent portal-target div per
+ * panel (WindowManager.getOrCreatePortalTarget) that physically moves between
+ * dock slots and floating frames while the React component rendered into it
+ * never unmounts. A popout is just one more place to move that div: into a
+ * `window.open()` child document. Because the component stays mounted in the
+ * main React tree, scrollback, buffered writes, and the live renderer/viewport
+ * registrations all survive the move.
+ *
+ * Cross-window events: React 19 attaches its event delegation to the root
+ * container passed to createRoot — which lives in the main window — so synthetic
+ * events never reach panel content sitting in another window. We fix this by
+ * mounting a throwaway React root on the child window's body and appending the
+ * portal target as a descendant (the same appendChild-into-a-ref'd-div pattern
+ * DockedPanel/ScriptWindow use). The throwaway root registers React's listeners
+ * on the child document; when a native event fires there, React resolves the
+ * target node's fiber (the `__reactFiber$` key matches because both roots share
+ * the one React bundle) and dispatches synthetic events up the *main* tree, so
+ * the panel's existing onChange/onKeyDown/onClick handlers fire normally.
+ */
+export declare function PopoutWindow({ id, title, width, height, manager, onClosed }: PopoutWindowProps): null;
+export {};

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

@@ -0,0 +1,29 @@
+import type { DockSide, DragState } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface ScriptWindowProps {
+    id: string;
+    title: string;
+    kind: 'text' | 'html' | 'map';
+    visible: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+    manager: WindowManager;
+    /** Miniconsoles render bare: no titlebar, no border, no drag, no resize.
+     *  Position and size are script-controlled. */
+    isMiniConsole?: boolean;
+    /** When true, dragging the titlebar still moves the window but never
+     *  enters a dock zone — mirrors Mudlet's openUserWindow(..., autoDock=false). */
+    lockFloating?: boolean;
+    onFocus: () => void;
+    onMoved: (x: number, y: number) => void;
+    onResized: (w: number, h: number) => void;
+    onDock: (side: DockSide, slotIndex: number, stackTargetId?: string, splitTargetId?: string, splitBefore?: boolean) => void;
+    onDragStateChange: (ds: DragState | null) => void;
+    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 {};

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

@@ -0,0 +1,17 @@
+import type { DockSide, DragState, ScriptWindowRenderData } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface SplitGroupPanelProps {
+    side: DockSide;
+    panels: ScriptWindowRenderData[];
+    splitGroupId: string;
+    manager: WindowManager;
+    onDragStateChange: (ds: DragState | null) => void;
+    onTitlebarContextMenu: (e: React.MouseEvent) => void;
+    /** Panel ID hovered for a tab-stack drop — highlights only that sub-panel. */
+    stackTargetId?: string;
+    /** Panel ID targeted for a within-split insert — shows ghost between members. */
+    splitTargetId?: string;
+    splitBefore?: boolean;
+}
+export declare function SplitGroupPanel({ side, panels, manager, onDragStateChange, onTitlebarContextMenu, stackTargetId, splitTargetId, splitBefore }: SplitGroupPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+import type { DockSide, DragState, ScriptWindowRenderData } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface TabGroupPanelProps {
+    side: DockSide;
+    panels: ScriptWindowRenderData[];
+    activeId: string;
+    manager: WindowManager;
+    onDragStateChange: (ds: DragState | null) => void;
+    onTitlebarContextMenu: (e: React.MouseEvent) => void;
+}
+export declare function TabGroupPanel({ side, panels, activeId, manager, onDragStateChange, onTitlebarContextMenu }: TabGroupPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import type { ScriptWindowRenderData } from '../windows/types';
+import type { WindowManager } from '../windows/WindowManager';
+interface WindowContextMenuProps {
+    windows: ScriptWindowRenderData[];
+    manager: WindowManager;
+    x: number;
+    y: number;
+    onClose: () => void;
+}
+export declare function WindowContextMenu({ windows, manager, x, y, onClose }: WindowContextMenuProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,26 @@
+import type { DockSide } from '../windows/types';
+/**
+ * 5-zone drop detection per slot.
+ *
+ * For a horizontal dock area (top/bottom):
+ *   ┌────────────────────────────────┐
+ *   │        SPLIT ABOVE 25%         │
+ *   ├────┬──────────────────────┬────┤
+ *   │bef │      tab stack       │aft │  (middle 50% cross-axis)
+ *   │20% │      center 60%      │20% │
+ *   ├────┴──────────────────────┴────┤
+ *   │        SPLIT BELOW 25%         │
+ *   └────────────────────────────────┘
+ *
+ * Ghost-slot hysteresis: when the cursor is inside the ghost slot that appears
+ * on a before/after drop, we merge the ghost + adjacent real panel into one
+ * bounding box for zone detection.  This keeps the center/split zones reachable
+ * without having to drag all the way across the ghost to reach the shifted panel.
+ */
+export declare function detectDock(mx: number, my: number): {
+    side: DockSide | null;
+    slotIndex: number;
+    stackTargetId?: string;
+    splitTargetId?: string;
+    splitBefore?: boolean;
+};

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

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ *
+ * ## Why flat (and not a container tree)
+ *
+ * In real Mudlet, `raiseWindow`/`lowerWindow` operate on ONE flat stack per
+ * console/userwindow. Geyser containers (Adjustable.Container, VBox/HBox, a
+ * flyout menu, a gauge's labels) are pure Lua geometry helpers — they never
+ * reparent the real QWidgets, which all stay siblings of the console. So
+ * `raise` brings a widget to the front of EVERY widget in that window, and
+ * z-order is simply most-recently-raised-wins, flat, per real viewport.
+ * (An earlier version of this file modelled Geyser containers as a real tree
+ * and ranked by a pre-order walk; that diverged from Mudlet — it buried a
+ * freshly-raised widget beneath its container's stale position — and is why
+ * 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
+ * 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
+ * FloatingWindowLayer / OutputArea — the nested-window layer is portaled into
+ * that same wrapper, NOT a separate sibling, precisely so a window's z and a
+ * label's z compare in one context.
+ *
+ * ## Bounded ranks
+ *
+ * `getZ` returns a small ordinal (0..N-1 among the widgets under one viewport),
+ * NOT the raw monotonic `order`. The `order` keys grow unboundedly over a
+ * session (every raise/lower, including the ones Geyser fires on each reflow,
+ * bumps one), and feeding that straight into a CSS z-index risks it eventually
+ * exceeding fixed "always on top" bands elsewhere (e.g. the map's right-click
+ * menu at z:1000 — which regressed exactly this way once). Ranking into a range
+ * bounded by the live widget count keeps the output far below any such band.
+ */
+export type OverlayLayerKind = 'windows' | 'labels' | 'cmdlines' | 'scrollboxes';
+type Listener = () => void;
+export declare class OverlayLayerOrder {
+    private seq;
+    private negSeq;
+    private widgets;
+    private listeners;
+    /** Viewports whose widgets' `rank` fields are stale and must be re-sorted
+     *  on the next getZ(). Only the viewport actually mutated is marked, so a
+     *  reflow storm under one window never re-sorts the others, and a drag —
+     *  which re-renders via move()'s notify() but never mutates this registry —
+     *  leaves every parent clean, so getZ() is a plain field read per widget. */
+    private dirty;
+    private static widgetKey;
+    private upsert;
+    /** A widget was created / reparented / raised under `parentId` — bring it
+     *  to the front of that viewport's flat stack. */
+    touch(parentId: string, kind: OverlayLayerKind, id: string): void;
+    /** A widget was lowered under `parentId` (lowerWindow / lowerLabel) — drop
+     *  it below every other widget in that viewport's stack. */
+    sink(parentId: string, kind: OverlayLayerKind, id: string): void;
+    /** Stop tracking a destroyed widget, so a later widget re-using the same
+     *  id starts fresh and dead entries don't accumulate. */
+    forget(parentId: string, kind: OverlayLayerKind, id: string): void;
+    private emit;
+    /** Front-to-back rank (0 = back) for one widget under `parentId`, ranked
+     *  among every widget of any kind in that viewport by most-recent raise.
+     *  Re-sorts the viewport's widgets only when it's dirty; otherwise this is
+     *  a couple of Map lookups plus a field read. */
+    getZ(parentId: string, kind: OverlayLayerKind, id: string): number;
+    /** Re-render trigger for a viewport's overlay wrapper components. */
+    subscribe(parentId: string, cb: Listener): () => void;
+}
+export {};

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

@@ -0,0 +1 @@
+export declare function renderMarkdown(src: string): string;

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

@@ -0,0 +1,22 @@
+import type React from 'react';
+import type { MudSession } from '../../mud/MudSession';
+/**
+ * Caret mode / reading cursor (Mudlet's caret mode, web-native).
+ *
+ * When the user's configured `caretShortcut` is pressed, a focusable review
+ * panel mirrors the main output's rendered lines (text + working links) and
+ * takes focus, so a screen reader can navigate the scrollback by char/word/line
+ * with its own virtual cursor — and reach links — without the live output's
+ * additions-only ARIA region getting in the way. Escape, the close button, or
+ * the toggle key again exits and returns focus to the command line.
+ *
+ * The mirror is kept live by a MutationObserver on the main output: appends and
+ * evictions are reflected as they happen, so the panel never goes stale while
+ * open. We clone the already-rendered DOM (rather than re-deriving from the
+ * Console model) because the DOM is the faithful "what's on screen" source —
+ * blank lines and inline command echoes included.
+ */
+export declare function CaretReviewPanel({ session, commandInputRef, }: {
+    session: MudSession;
+    commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,9 @@
+import type React from 'react';
+import type { MudSession } from '../../mud/MudSession';
+interface OutputAreaProps {
+    session: MudSession;
+    stickyLines?: number;
+    commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+}
+export declare function OutputArea({ session, stickyLines, commandInputRef }: OutputAreaProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,23 @@
+export interface OutputMenuExtraItem {
+    label: string;
+    tooltip?: string;
+    onClick: () => void;
+}
+interface OutputContextMenuProps {
+    x: number;
+    y: number;
+    /** Whether the selection touches this window (gates the copy actions). */
+    hasSelection: boolean;
+    onSelectAll: () => void;
+    onCopy: () => void;
+    onCopyHtml: () => void;
+    onCopyImage: () => void;
+    /** Timestamp toggle — only the main console passes these. */
+    showTimestamps?: boolean;
+    onToggleTimestamps?: () => void;
+    /** Script-provided entries (Mudlet addMouseEvent). */
+    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 {};

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

@@ -0,0 +1,64 @@
+import { AnsiAwareBuffer } from "../../mud/text/FormatState";
+export declare const elementBuffers: WeakMap<Element, AnsiAwareBuffer>;
+type MessageListener = (message?: string | AnsiAwareBuffer, type?: string, timestamp?: number, isPrompt?: boolean) => void;
+export type MessageSource = {
+    on(event: 'message', listener: MessageListener): () => void;
+    on(event: 'script.deleteline', listener: () => void): () => void;
+    on(event: 'script.clearwindow', listener: () => void): () => void;
+    on(event: 'script.movecursorup', listener: () => void): () => void;
+    on(event: 'script.movecursordown', listener: () => void): () => void;
+};
+export type CursorOps = {
+    /** Plain text of the line at the current cursor position. */
+    getLine: () => string;
+    /** AnsiAwareBuffer of the line at the current cursor position, for in-place coloring. */
+    getBuffer: () => AnsiAwareBuffer | null;
+    /** Remove the line at the current cursor position. */
+    deleteLine: () => void;
+    /** Move the cursor one line toward older output. */
+    moveUp: () => void;
+    /** Move the cursor one line toward newer output. */
+    moveDown: () => void;
+    /** Move the cursor to an absolute line number (1 = oldest, getLineCount() = newest). */
+    moveTo: (line: number) => void;
+    /** 1-indexed line number of the cursor from the top of the buffer. */
+    getLineNumber: () => number;
+    /** Total number of lines currently in the output buffer. */
+    getLineCount: () => number;
+    /** Plain text of lines [from..to] (1-indexed, inclusive) as a JS string array. */
+    getLines: (from: number, to: number) => string[];
+};
+/**
+ * Creates cursor ops for a plain line container (text/miniconsole windows).
+ * The container holds `div` line elements appended via appendChild — no sentinel.
+ * Returns the ops plus an `onLineAppended` callback that must be called each
+ * time a new line element is added, so the cursor resets to the latest line.
+ */
+export declare function createWindowCursorOps(container: HTMLElement): {
+    ops: CursorOps;
+    onLineAppended: (el: Element) => void;
+};
+type OutputHandlerOptions = {
+    outputWrapper: HTMLElement;
+    sentinel: HTMLElement;
+    stickyArea: HTMLElement;
+    isSplitView: () => boolean;
+    stickyLines: number;
+    maxElements?: number | (() => number);
+    trimSlack?: number;
+    suppressSplitView?: (durationMs: number) => void;
+    /** Called once the cursor ops are ready; wire them to ScriptingAPI/session. */
+    onCursorReady?: (ops: CursorOps) => void;
+};
+export type OutputRendererControls = {
+    teardown: () => void;
+    areTimestampsVisible: () => boolean;
+    setTimestampVisibility: (visible: boolean) => void;
+    toggleTimestampVisibility: () => void;
+    populateStickyArea: () => void;
+    clearStickyArea: () => void;
+    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 {};

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

@@ -0,0 +1,23 @@
+import type { MudSession } from '../../mud/MudSession';
+import { AnsiAwareBuffer } from '../../mud/text/FormatState';
+export declare const MAX_LINES = 60;
+/**
+ * The plain text a `message` line should announce, or null when it must be
+ * skipped: interim `script-partial` cecho output (superseded by the finalized
+ * line), missing text, or blank/whitespace-only lines (no speech, only churn).
+ * Raw strings carry ANSI, so they route through an {@link AnsiAwareBuffer} for
+ * the plain text; an `AnsiAwareBuffer` payload already exposes `.text`. Pure.
+ */
+export declare function screenReaderPlainText(text?: string | AnsiAwareBuffer, type?: string): string | null;
+/**
+ * Append a batch of lines to the live `region` as ONE node (a wrapper div with
+ * a child per line) so the screen reader announces the whole burst once — the
+ * way Mudlet coalesces a buffer update into a single announcement — instead of
+ * once per line. Per-line child divs keep the line boundaries in the a11y tree.
+ * Then cap the region to `maxLines` batches. Returns true when a batch was
+ * appended. Exported for testing.
+ */
+export declare function flushScreenReaderLines(region: HTMLElement, lines: string[], maxLines?: number): boolean;
+export declare function ScreenReaderLog({ session }: {
+    session: MudSession;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,28 @@
+import type React from 'react';
+import { type OutputMenuExtraItem } from './OutputContextMenu';
+interface StickyOutputPanelProps {
+    outputRef: React.RefObject<HTMLDivElement | null>;
+    sentinelRef: React.RefObject<HTMLDivElement | null>;
+    stickyAreaRef: React.RefObject<HTMLDivElement | null>;
+    isSplitView: boolean;
+    scrollToBottom: () => void;
+    background?: string;
+    /** Extra CSS layered on top of `background` — used to add background-image
+     *  / border-image properties from Mudlet setBackgroundImage. */
+    backgroundExtra?: React.CSSProperties;
+    foreground?: string;
+    showTimestamps?: boolean;
+    onToggleTimestamps?: () => void;
+    /** Script-provided right-click entries (Mudlet addMouseEvent), evaluated
+     *  lazily when the menu opens since the registry can change. */
+    getMenuExtraItems?: () => OutputMenuExtraItem[];
+    commandInputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    className?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    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 {};

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

@@ -0,0 +1,17 @@
+import type React from 'react';
+export interface BackgroundImageSpec {
+    /** Resolved image URL (for modes 1-3) or raw CSS stylesheet (mode 4). */
+    url: string;
+    /** Mudlet BgImageMode: 1=border (stretched via border-image), 2=center,
+     *  3=tile, 4=raw stylesheet (url field is the stylesheet body). */
+    mode: number;
+}
+/**
+ * Translates a Mudlet background-image spec into inline React CSS, mirroring
+ * the QSS produced by TConsole::setConsoleBackgroundImage in Mudlet's C++ so
+ * imported scripts look the same. Mode 4 takes the user-authored stylesheet
+ * body and parses its declarations through the same path setLabelStyleSheet
+ * uses, so multi-property CSS strings (with their own `url(...)` refs) layer
+ * cleanly. Returns null for unsupported modes — the caller leaves the element
+ * style untouched. */
+export declare function backgroundImageStyle(spec: BackgroundImageSpec | undefined): React.CSSProperties | null;

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

@@ -0,0 +1,40 @@
+/**
+ * Caret mode / reading cursor — keyboard-navigable review of the scrollback for
+ * screen-reader users (Mudlet's caret mode, ported web-natively).
+ *
+ * Rather than reimplement Mudlet's painted caret + boundary-finding over a
+ * custom-drawn widget, we mirror the already-rendered output DOM into a
+ * focusable review surface and let the browser + assistive tech provide real
+ * char/word/line navigation and announcements for free (the `CaretReviewPanel`
+ * component). This module holds the surface-independent, DOM-level helpers so
+ * they're unit-testable without React.
+ */
+/** The toggle key the `caretShortcut` config selects. `none` disables the
+ *  feature; the rest mirror Mudlet's Host::CaretShortcut enum. */
+export type CaretShortcut = 'none' | 'tab' | 'ctrltab' | 'f6';
+/** True when `e` is the configured caret-mode toggle. Bare Tab / Ctrl+Tab / F6
+ *  each require no *other* modifiers so they don't fire on Shift+Tab, Alt+F6,
+ *  etc. `none` (or any unknown value) never matches. Pure — reads only `key`
+ *  and the modifier flags. */
+export declare function matchCaretToggle(e: KeyboardEvent, shortcut: CaretShortcut): boolean;
+/** The rendered line elements under the main output wrapper, in order. Each
+ *  logical line is one `div.output-msg`; the height:0 sticky sentinel and any
+ *  other children are skipped (mirrors WindowManager.lineElements). */
+export declare function outputLineElements(outputEl: HTMLElement): HTMLElement[];
+/**
+ * Clone one rendered output line for the review surface and revive its links.
+ *
+ * `cloneNode(true)` copies the text and inline colour styles faithfully but NOT
+ * the per-element click/contextmenu listeners (they're attached imperatively in
+ * FormatState, closing over the link descriptor). So for each clickable run we
+ * re-dispatch the clone's click/context-menu to the *original* element — which
+ * still owns the real send/prompt/url/spoiler action — and tag it `role="link"`
+ * so assistive tech announces and reaches it. Original and clone share document
+ * order within the line, so pairing by index is stable.
+ */
+export declare function cloneOutputLine(orig: HTMLElement): HTMLElement;
+/** Whether a scroll container is within `threshold` px of its bottom — used to
+ *  decide if the review surface should follow new output to the end (Mudlet's
+ *  "auto-scroll only when the caret is already at the end") or hold position so
+ *  the user can keep reading where they are. */
+export declare function isNearBottom(el: HTMLElement, threshold?: number): boolean;

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

@@ -0,0 +1,29 @@
+/**
+ * Keyboard navigation and activation for output hyperlinks — OSC 8, MXP, and
+ * scripted links alike (Mudlet's Ctrl+] / Ctrl+[ plus Enter/Space activation).
+ *
+ * Ctrl+] focuses the next clickable link in the output, Ctrl+[ the previous,
+ * wrapping at the ends. With nothing focused, Ctrl+] starts at the first link
+ * and Ctrl+[ at the last. Links are made focusable (`tabIndex = -1`) by the
+ * renderer, so they take focus programmatically without joining the Tab order.
+ *
+ * With a link focused: Enter/Space activates it (same as a left-click — fires
+ * the send/prompt/url action, reveals a spoiler, toggles selection, arms
+ * visibility); the Menu key or Shift+F10 opens its context menu. Mirrors
+ * Mudlet's TTextEdit key handling.
+ */
+/**
+ * One representative element per logical link under `root`, in document order.
+ * A multicolour link is rendered as several spans (one per colour run) sharing
+ * a `data-link-group` key — only the first run of each group is a navigation
+ * stop, so Ctrl+]/Ctrl+[ moves link-to-link, not run-to-run. Concealed (hidden)
+ * links are skipped.
+ */
+export declare function navigableLinks(root: ParentNode): HTMLElement[];
+/** Move focus to the link `dir` steps from the currently-focused one (wrapping).
+ *  Returns the newly-focused link, or null when there are no links. */
+export declare function focusAdjacentLink(root: ParentNode, dir: 1 | -1): HTMLElement | null;
+/** Handle a keydown for link navigation/activation. Returns true when it acted. */
+export declare function handleLinkNavKeydown(e: KeyboardEvent, root: ParentNode): boolean;
+/** Install the link navigation/activation key listener for `root`. Returns a remover. */
+export declare function installLinkNavigation(root: ParentNode): () => void;

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

@@ -0,0 +1,16 @@
+/**
+ * Right-click context menu for OSC 8 hyperlinks (Mudlet's `config.menu`).
+ *
+ * Pure DOM — no scripting/session dependencies — so the renderer can build and
+ * show it and tests can exercise it without the full engine. `run` executes a
+ * selected item's action URI (the caller maps it to send/prompt/openUrl).
+ */
+import type { MenuItem, LinkTitle } from "../../mud/text/hyperlinkConfig";
+/**
+ * Open the link's context menu at the event position. `menu` entries are either
+ * separators (`{ separator: true }`) or `{ label, action }` pairs; `title`, when
+ * present, is shown as an (optionally styled) header. Selecting an item runs its
+ * action via `run` and closes the menu. Any open menu is replaced; clicking
+ * outside dismisses it.
+ */
+export declare function openOsc8Menu(ev: MouseEvent, menu: MenuItem[], title: LinkTitle | undefined, run: (uri: string) => void): void;