@mudlet/mudlet-web 0.3.0

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

@@ -0,0 +1,8 @@
+interface Props {
+    onClose: () => void;
+}
+/** Small "About" dialog reachable from the connection screen — wordmark,
+ *  tagline and description come from the active brand (stock mudix by
+ *  default) plus a link to the source repository when the brand sets one. */
+export declare function AboutModal({ onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,25 @@
+import type { LandingProps } from '../branding';
+export interface BrandLoginFieldsProps extends Pick<LandingProps, 'openProfile' | 'ensureBrandProfile'> {
+    /** Show the password field (default true). Set false for brands that only
+     *  need a character/profile name — e.g. an offline-only demo. */
+    showPassword?: boolean;
+    /** Show the "open offline" button (default true). */
+    showOffline?: boolean;
+    accountLabel?: string;
+    passwordLabel?: string;
+    connectLabel?: string;
+    offlineLabel?: string;
+    accountPlaceholder?: string;
+    passwordPlaceholder?: string;
+    /** Extra class appended to the root `<form>`. */
+    className?: string;
+    autoFocus?: boolean;
+}
+/**
+ * Unstyled login form for custom branded landings: account (+ optional
+ * password) input, Connect submit, optional Open-offline button. No CSS is
+ * applied — every element carries a stable `mudix-login-*` class for the
+ * brand's own stylesheet to target. Wraps `useBrandLogin`; for full control
+ * over markup, call that hook directly instead of using this component.
+ */
+export declare function BrandLoginFields({ openProfile, ensureBrandProfile, showPassword, showOffline, accountLabel, passwordLabel, connectLabel, offlineLabel, accountPlaceholder, passwordPlaceholder, className, autoFocus, }: BrandLoginFieldsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { type LandingProps } from '../branding';
+/**
+ * Built-in landing for branded builds: no profile creation or selection —
+ * just a login form for the brand's MUD. Used when the brand doesn't supply
+ * its own `Landing` component. Credentials are held in memory only (never
+ * persisted): they feed the same auto-login path as the connection editor
+ * (GMCP Char.Login, or typed at text-login prompts) for this page's lifetime,
+ * so a reload starts back at an empty form. See `useBrandLogin`/
+ * `BrandLoginFields` to reuse this behavior in a custom `Landing`.
+ */
+export declare function BrandLoginScreen({ openProfile, ensureBrandProfile, openSettings }: LandingProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,32 @@
+interface CharLoginModalProps {
+    /** Connection name, shown in the title for context. */
+    connectionName?: string;
+    /** Error from a previous failed attempt (Char.Login.Result success=false). */
+    error?: string;
+    /** Account/username to prefill (saved per-profile credential). */
+    initialAccount?: string;
+    /** Password to prefill (saved per-profile credential — plaintext). */
+    initialPassword?: string;
+    /** Initial state of the "remember on this device" checkbox. */
+    initialRemember?: boolean;
+    /** Show the "remember on this device" checkbox (default true). Branded
+     *  builds hide it — credentials are never persisted there, so `onSubmit`
+     *  always receives `remember=false`. */
+    allowRemember?: boolean;
+    /** Send `account` + `password` to the server (Char.Login.Credentials).
+     *  `remember` tells the caller whether to persist them for next time. */
+    onSubmit: (account: string, password: string, remember: boolean) => void;
+    /** Decline GMCP login — sends the empty reply so the server falls back to
+     *  its text login prompt. */
+    onCancel: () => void;
+}
+/**
+ * Credentials popup for GMCP `Char.Login` authentication. Rendered as a real
+ * `<form>` with `autocomplete="username"` / `autocomplete="current-password"`
+ * inputs so browser password managers offer to fill and save. Optionally
+ * remembers the account + password per profile (plaintext localStorage — see
+ * 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 {};

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

@@ -0,0 +1,27 @@
+export interface CmdLineMenuEntry {
+    /** Stable id used by removeCommandLineMenuEvent. */
+    uniqueName: string;
+    /** Event name passed to raiseEvent on click. */
+    eventName: string;
+    /** Label rendered in the context menu. Defaults to uniqueName. */
+    displayName: string;
+}
+/**
+ * Backs Mudlet's addCommandLineMenuEvent / removeCommandLineMenuEvent /
+ * getCommandLineMenuEvents. Right-clicking the command bar shows entries from
+ * this registry; clicking one raises the registered event with the current
+ * command-line text as the first argument.
+ */
+export declare class CmdLineMenuRegistry {
+    private entries;
+    private subscribers;
+    private dispatcher;
+    subscribe(cb: () => void): () => void;
+    private notify;
+    setDispatcher(fn: ((eventName: string, args: unknown[]) => void) | null): void;
+    add(uniqueName: string, eventName: string, displayName?: string): boolean;
+    remove(uniqueName: string): boolean;
+    list(): CmdLineMenuEntry[];
+    /** Raise the entry's event, passing the current command-line text. */
+    dispatch(uniqueName: string, cmdLineText: string): void;
+}

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

@@ -0,0 +1,19 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+export declare const EDITABLE_EXTENSIONS: Set<string>;
+interface Props {
+    content: string;
+    filename: string;
+    path: string;
+    vfs: ProfileVFS;
+    onDirtyChange?: (dirty: boolean) => void;
+    onSaved?: () => void;
+    /** Jump request. Bump `revision` to re-trigger on the same line. */
+    gotoLine?: {
+        line: number;
+        revision: number;
+    } | null;
+    /** Extra controls rendered inside the toolbar actions area (left of Revert/Save). */
+    toolbarExtra?: React.ReactNode;
+}
+export declare function CodeEditorPreview({ content, filename, path, vfs, onDirtyChange, onSaved, gotoLine, toolbarExtra }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import { type BufferWordIndex } from './bufferWords';
+import type { CmdLineMenuRegistry } from './CmdLineMenuRegistry';
+interface CommandBarProps {
+    command: string;
+    onCommandChange: (command: string) => void;
+    passwordMode?: boolean;
+    commandInputRef: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    onSubmit: () => void;
+    cmdLineMenu: CmdLineMenuRegistry;
+    /** Tab-completion suggestions added via Mudlet's addCmdLineSuggestion API.
+     *  Merged ahead of command history (dedup, case-insensitive). */
+    suggestions?: string[];
+    /** 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 {};

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

@@ -0,0 +1,13 @@
+import { type MudConnection } from '../storage';
+interface Props {
+    /** The connection to edit, or null to add a new one. */
+    connection: MudConnection | null;
+    /** Whether this is the very first connection (drives the title copy). */
+    firstConnection: boolean;
+    busy: boolean;
+    onAdd: (data: Omit<MudConnection, 'id'>) => string;
+    onUpdate: (id: string, data: Omit<MudConnection, 'id'>) => void;
+    onClose: () => void;
+}
+export declare function ConnectionFormModal({ connection, firstConnection, busy, onAdd, onUpdate, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import { type MudConnection } from '../storage';
+interface Props {
+    connections: MudConnection[];
+    connecting: boolean;
+    connectingId: string | null;
+    editingId: string | null;
+    onConnect: (c: MudConnection) => void;
+    onOpen: (c: MudConnection) => void;
+    onEdit: (c: MudConnection) => void;
+    onDelete: (c: MudConnection) => void;
+    onReorder: (orderedIds: string[]) => void;
+    onAddClick: () => void;
+}
+/** 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 {};

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

@@ -0,0 +1,14 @@
+import { type MudConnection } from '../storage';
+interface Props {
+    connections: MudConnection[];
+    connecting: boolean;
+    connectingId: string | null;
+    onConnect: (connection: MudConnection) => void;
+    onOpen: (connection: MudConnection) => void;
+    onAdd: (data: Omit<MudConnection, 'id'>) => string;
+    onUpdate: (id: string, data: Omit<MudConnection, 'id'>) => void;
+    onDelete: (id: string) => void;
+    onOpenSettings: () => void;
+}
+export declare function ConnectionScreen({ connections, connecting, connectingId, onConnect, onOpen, onAdd, onUpdate, onDelete, onOpenSettings }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,20 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+export interface VFSNode {
+    name: string;
+    path: string;
+    type: 'file' | 'dir';
+    children?: VFSNode[];
+    size?: number;
+}
+export declare function buildTree(vfs: ProfileVFS, dirPath: string, depth?: number): VFSNode[];
+interface FileBrowserModalProps {
+    connectionId: string;
+    vfs: ProfileVFS | null;
+    onClose: () => void;
+    initialPath?: string | null;
+    initialPathTick?: number;
+    initialLine?: number;
+    onPlayReplay?: (path: string) => void;
+}
+export declare function FileBrowserModal({ connectionId, vfs, onClose, initialPath, initialPathTick, initialLine, onPlayReplay }: FileBrowserModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,21 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+/**
+ * The Lua `invokeFileDialog(...)` picker. The calling Lua handler is parked on
+ * its coroutine until this resolves, so every exit path (Select, Cancel, the
+ * 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.
+ */
+interface FilePickerModalProps {
+    vfs: ProfileVFS | null;
+    mode: 'file' | 'folder';
+    title: string;
+    /** VFS path to reveal on open; '' or invalid falls back to the root. */
+    location: string;
+    onDone: (path: string) => void;
+}
+export declare function FilePickerModal({ vfs, mode, title, location, onDone }: FilePickerModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+interface Props {
+    name: string;
+    /** Re-request folder access (must run from this click — a user gesture). */
+    onGrant: () => void;
+    /** Drop the folder link; the profile opens from local storage instead. */
+    onUnlink: () => void;
+    onBack: () => void;
+}
+/**
+ * Shown when a linked Mudlet profile is opened but the browser hasn't granted
+ * access to its folder (typically on a fresh page load via a deep link, where
+ * there's no user gesture to prompt with). The user must decide — grant access
+ * or unlink — rather than silently falling through to an empty local copy.
+ */
+export declare function FolderPermissionScreen({ name, onGrant, onUnlink, onBack }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+interface Props {
+    content: string;
+    filename: string;
+    path: string;
+    vfs: ProfileVFS;
+    onDirtyChange?: (dirty: boolean) => void;
+    onSaved?: () => void;
+    gotoLine?: {
+        line: number;
+        revision: number;
+    } | null;
+}
+export declare function JsonPreview({ content, filename, path, vfs, onDirtyChange, onSaved, gotoLine }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+interface LogBrowserModalProps {
+    connectionId: string;
+    connectionName: string;
+    onClose: () => void;
+}
+export declare function LogBrowserModal({ connectionId, connectionName, onClose }: LogBrowserModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import type { WindowManager } from './windows/WindowManager';
+interface MapEditorModalProps {
+    connectionId: string;
+    connectionName: string;
+    manager: WindowManager;
+    onClose: () => void;
+}
+export declare function MapEditorModal({ connectionId, connectionName, manager, onClose }: MapEditorModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+interface Props {
+    content: string;
+    filename: string;
+    path: string;
+    vfs: ProfileVFS;
+    onDirtyChange?: (dirty: boolean) => void;
+    onSaved?: () => void;
+    gotoLine?: {
+        line: number;
+        revision: number;
+    } | null;
+}
+export declare function MarkdownPreview({ content, filename, path, vfs, onDirtyChange, onSaved, gotoLine }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import type { DiffResult, SideKind } from '../scripting/vfs/folderSync';
+interface MergeConflictModalProps {
+    /** Diff between the currently-mounted profile (local/IDB) and the linked folder. */
+    diff: DiffResult;
+    /** Display name shown in headers, e.g. the folder.name. */
+    folderName: string;
+    /** Cancel the link operation entirely. */
+    onCancel: () => void;
+    /**
+     * User confirmed. `resolutions` maps each conflicting path to the winning
+     * side. The caller copies winners into the folder (folder is the next
+     * mount's source of truth). Files in onlyLocal are unioned in automatically.
+     */
+    onApply: (resolutions: Map<string, SideKind>) => void;
+}
+export declare function MergeConflictModal({ diff, folderName, onCancel, onApply }: MergeConflictModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import type { MudletModuleRef } from '../import/mudletHost';
+export interface ModuleUpload {
+    key: string;
+    bytes: Uint8Array;
+}
+interface Props {
+    /** Modules whose external XML file couldn't be found in the imported tree. */
+    modules: MudletModuleRef[];
+    /** Called when every module has been decided — uploaded modules are folded
+     *  in, the rest dropped. */
+    onComplete: (uploads: ModuleUpload[]) => void;
+    /** Abort the whole import. */
+    onCancel: () => void;
+}
+/**
+ * After a Mudlet-profile import, modules that load from an external local XML
+ * file (which a browser can't read, and that wasn't found inside the profile)
+ * are listed here. For each, the user uploads its `.xml` or drops it. The import
+ * only proceeds once every module is decided.
+ */
+export declare function ModuleResolveModal({ modules, onComplete, onCancel }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,31 @@
+export interface MouseEventEntry {
+    /** Stable id used by removeMouseEvent and as the map key for getMouseEvents. */
+    uniqueName: string;
+    /** Event raised (via raiseEvent) when the menu item is clicked. */
+    eventName: string;
+    /** Label rendered in the context menu. Defaults to uniqueName. */
+    displayName: string;
+    /** Tooltip shown on hover. Empty string when none was given. */
+    tooltip: string;
+}
+/**
+ * Backs Mudlet's addMouseEvent / removeMouseEvent / getMouseEvents
+ * (Host::mConsoleActions). Right-clicking the main output area shows entries
+ * from this registry; clicking one raises the registered event. addMouseEvent
+ * refuses a duplicate uniqueName (matching Mudlet's warn-and-return-nil).
+ */
+export declare class MouseEventRegistry {
+    private entries;
+    private subscribers;
+    private dispatcher;
+    subscribe(cb: () => void): () => void;
+    private notify;
+    setDispatcher(fn: ((eventName: string, args: unknown[]) => void) | null): void;
+    /** Mudlet addMouseEvent — false when uniqueName/eventName is empty or the
+     *  uniqueName is already registered. */
+    add(uniqueName: string, eventName: string, displayName?: string, tooltip?: string): boolean;
+    remove(uniqueName: string): boolean;
+    list(): MouseEventEntry[];
+    /** Raise the entry's event. Mudlet passes the originating window name. */
+    dispatch(uniqueName: string): void;
+}

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

@@ -0,0 +1,12 @@
+interface Props {
+    name: string;
+    /** true = another tab owns the profile and we're queued behind it;
+     *  false = we're just acquiring a free lock (a brief, usually invisible moment). */
+    waiting: boolean;
+    onBack: () => void;
+}
+/** Shown while a profile can't yet be mounted because another browser tab holds
+ *  its single-owner lock. Auto-dismisses (the parent swaps in the session) the
+ *  moment the other tab releases it. */
+export declare function ProfileBusyScreen({ name, waiting, onBack }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import type { MudConnection } from '../storage/schema';
+interface Props {
+    connections: MudConnection[];
+    onClose: () => void;
+}
+export declare function ProfileExportModal({ connections, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+interface Props {
+    onClose: () => void;
+    onUseProxy: (wssUrl: string) => void;
+}
+export declare function ProxyInfoModal({ onClose, onUseProxy }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+interface Props {
+    onClose: () => void;
+    onHostYourOwn: () => void;
+}
+export declare function ProxyWhyModal({ onClose, onHostYourOwn }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+interface Props {
+    onClose: () => void;
+    onUseProxy: (wssUrl: string) => void;
+}
+export declare function ProxyWizardModal({ onClose, onUseProxy }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+interface QuickOpenPaletteProps {
+    vfs: ProfileVFS;
+    onPick: (path: string) => void;
+    onClose: () => void;
+}
+export declare function QuickOpenPalette({ vfs, onPick, onClose }: QuickOpenPaletteProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import type { ModalBounds } from '../storage/schema';
+interface ResizableModalProps {
+    title: string;
+    onClose: () => void;
+    savedBounds?: ModalBounds | null;
+    onBoundsChange?: (bounds: ModalBounds) => void;
+    minW?: number;
+    minH?: number;
+    defaultW: number;
+    defaultH: number;
+    headerExtra?: React.ReactNode;
+    className?: string;
+    bodyClassName?: string;
+    children: React.ReactNode;
+}
+export declare function ResizableModal({ title, onClose, savedBounds, onBoundsChange, minW, minH, defaultW, defaultH, headerExtra, className, bodyClassName, children, }: ResizableModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+import './ScriptingDocsModal.css';
+interface ScriptingDocsModalProps {
+    connectionId: string;
+    onClose: () => void;
+}
+/**
+ * A read-only browser for the Lua scripting API, sourced from the same
+ * REFERENCE_GROUPS catalogue that backs editor autocomplete — so the docs
+ * never drift from what the runtime actually exposes.
+ */
+export declare function ScriptingDocsModal({ connectionId, onClose }: ScriptingDocsModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+interface SettingsModalProps {
+    onClose: () => void;
+    /** Active profile id; null on the connection screen (only theme is editable). */
+    connectionId: string | null;
+    vfs?: ProfileVFS | null;
+}
+export declare function SettingsModal({ onClose, connectionId, vfs }: SettingsModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,29 @@
+import { type BrandToolbarContext } from '../branding';
+import type { SessionStatus } from '../mud/events';
+interface ToolbarProps {
+    connectionName: string;
+    status: SessionStatus;
+    ping: number | null;
+    onDisconnect: () => void;
+    onReconnect: () => void;
+    onNewConnection: () => void;
+    onOpenMap: () => void;
+    onOpenScripts: () => void;
+    onOpenFiles: () => void;
+    onOpenLogs: () => void;
+    onOpenDocs: () => void;
+    onOpenSettings: () => void;
+    /** Mudlet-format replay recording toggle state + handler. */
+    replayRecording: boolean;
+    onToggleReplayRecording: () => void;
+    /** Playback speed of the active replay, or null when none is playing —
+     *  the speed/stop controls only render mid-replay. */
+    replaySpeed: number | null;
+    onReplaySpeedChange: (direction: 1 | -1) => void;
+    onReplayStop: () => void;
+    onContextMenu?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    /** 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 {};

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

@@ -0,0 +1,38 @@
+import type { MudSession } from '../mud/MudSession';
+/**
+ * Maintains a bounded, recency-ordered set of words seen in session output.
+ * Subscribes to the `message` event — the single choke point every output line
+ * passes through (the same tap SessionLogger uses) — so it captures MUD text,
+ * script echoes, and trigger output alike. One instance per session.
+ */
+export declare class BufferWordIndex {
+    private readonly session;
+    private readonly words;
+    private unsubscribe;
+    constructor(session: MudSession);
+    start(): void;
+    stop(): void;
+    private ingest;
+    /** Words in recency order, newest first. */
+    getWords(): string[];
+}
+export interface ActiveWord {
+    /** Everything before the trailing word (unchanged by completion). */
+    prefix: string;
+    /** The trailing word the user is typing. */
+    word: string;
+}
+/** Splits the trailing word being typed from its leading text. Returns null when
+ *  the command is empty or ends in whitespace/punctuation (nothing to complete). */
+export declare function splitTrailingWord(command: string): ActiveWord | null;
+/** True when the trailing word is an *argument* (something precedes it), not the
+ *  command name. This is what routes Tab to buffer completion vs. history. */
+export declare function hasPrecedingWord(prefix: string): boolean;
+/**
+ * Prefix-matches `word` against several candidate lists, tried in priority order
+ * (e.g. suggestions, then history, then buffer words). Case-insensitive,
+ * de-duplicated across all lists, excludes the exact word already typed. Matching
+ * is **prefix-only** — never subsequence — so a completion always literally starts
+ * with what was typed. The returned order is the Tab cycle order.
+ */
+export declare function matchWordCandidates(word: string, lists: string[][], limit?: number): string[];

package/dist-lib/ui/buttons/ButtonsBar.d.ts

@@ -0,0 +1,21 @@
+import { type RefObject } from 'react';
+import type { ScriptingEngine } from '../../scripting/ScriptingEngine';
+import type { ProfileVFS } from '../../scripting/vfs/ProfileVFS';
+import './ButtonsBar.css';
+interface ButtonsLayerProps {
+    connectionId: string;
+    engineRef: RefObject<ScriptingEngine | null>;
+    vfs: ProfileVFS | null;
+}
+/**
+ * Returns the four edge strips of toolbars (top/bottom/left/right). The caller
+ * places each strip in the appropriate spot inside ContentLayout.
+ */
+export declare function useButtonStrips({ connectionId, engineRef, vfs }: ButtonsLayerProps): {
+    top: import("react/jsx-runtime").JSX.Element;
+    bottom: import("react/jsx-runtime").JSX.Element;
+    left: import("react/jsx-runtime").JSX.Element;
+    right: import("react/jsx-runtime").JSX.Element;
+    floating: import("react/jsx-runtime").JSX.Element;
+};
+export {};