@mudlet/mudlet-web 0.5.0 → 1.0.1

package/dist-lib/ui/windows/WindowManager.d.ts

@@ -4,6 +4,7 @@ import type { AnsiAwareBuffer } from '../../mud/text/FormatState';
 import type { DockSide, MxpTabPage, WindowHandle, WindowOpenOptions, ScriptWindowRenderData } from './types';
 import { MapStore } from '../../map/MapStore';
 import { OverlayLayerOrder } from '../layout/overlayLayerOrder';
+import { SubCommandLine, type CmdLineHost } from '../cmdline/subCommandLine';
 /** Live handle onto a mounted map renderer, registered by MapPanel. Backs the
  *  Lua getMapZoom/setMapZoom/updateMap APIs, which need to read and drive the
  *  renderer state that lives inside the React component. */
@@ -80,6 +81,8 @@ export declare class WindowManager {
     private portalHolding;
     private readonly resizeObservers;
     private readonly lastEmittedSize;
+    /** User windows opened but not yet reported by {@link pumpCreatedSizes}. */
+    private readonly createdSizesDue;
     /** Per-window last reported character grid (cols, rows) — used to gate
      *  sysConsoleSizeChanged so the event fires only on actual grid changes. */
     private readonly lastEmittedGrid;
@@ -92,6 +95,18 @@ export declare class WindowManager {
     private readonly cmdLineState;
     private readonly mapCallbacks;
     private readonly mapControls;
+    /** See {@link hasMapper}. */
+    private mapperCreated;
+    /** The area the map widget shows, and whether a centerview has run since
+     *  it opened (or its map went away) — what sysMapAreaChanged is worked out
+     *  from (centerviewAreaChange). Kept here, not in MapPanel, because desktop
+     *  builds the widget synchronously: a centerview straight after
+     *  openMapWidget raises the event even though the panel has not mounted. */
+    private mapShownArea;
+    private mapCentered;
+    /** A repaint of the map widget was asked for and has not run its map info
+     *  contributors yet — see {@link pumpMapPaint}. */
+    private mapPaintDue;
     /** Per-window teardown for the mousedown/mouseup listeners observeMouse
      *  attaches. Keyed by window id ('main' for the central output). */
     private readonly mouseCleanups;
@@ -110,8 +125,15 @@ export declare class WindowManager {
      *  awaits the map before applying scripts, Mudlet parity) and MapPanel on
      *  mount call into this; whichever lands first triggers the work. */
     private mapBootstrapInflight;
+    /** Backing store for {@link lastMapLoadError}. */
+    private lastMapLoadFailure;
     private mapSaveTimer;
     private mapSavePending;
+    /** MapStore version that matches what is persisted (or was just loaded).
+     *  Any other version means the map has unsaved edits — Mudlet's
+     *  TMap::mUnsavedMap, which drives both Host::autoSaveMap and the save in
+     *  TMainConsole::closeEvent. */
+    private mapCleanVersion;
     /** MMP map URL announced by the game via GMCP `Client.Map` (Mudlet
      *  TMap::mMmpMapLocation). Lives here rather than on ScriptingEngine so it
      *  survives script reloads, like Mudlet's TMap does. */
@@ -138,6 +160,17 @@ export declare class WindowManager {
     private nextDockOrder;
     private readonly dockExtents;
     constructor(overlayZ?: OverlayLayerOrder);
+    /** How long unsaved map edits wait before they are autosaved. Not reset by
+     *  further edits, so a player mapping continuously still gets saved. */
+    static readonly MAP_AUTOSAVE_DELAY_MS = 10000;
+    /** The map now matches what is stored — nothing to autosave. */
+    private markMapClean;
+    /** Record unsaved map edits and arm an autosave, unless one is already
+     *  armed: unlike {@link scheduleMapSave} this does not push a pending save
+     *  back, so a steady stream of edits cannot starve it. */
+    private markMapUnsaved;
+    /** True when the map has edits not yet written to storage. */
+    hasUnsavedMap(): boolean;
     /** Resolves the same "nested under which parent" id FloatingWindowLayer's
      *  resolveParent uses: an explicit non-'main' parent, else 'main' when this
      *  is a mini-console (createMiniConsole/createMapper without an explicit
@@ -178,6 +211,11 @@ export declare class WindowManager {
     /** Bridge to the Lua speedwalk entry point (Mudlet Host::startSpeedWalk),
      *  wired by ScriptingEngine. Driven by {@link startSpeedWalk}. */
     onStartSpeedWalk?: (from: number, to: number) => void;
+    /** Bridge to Mudlet's `postMessage` (cTelnet::postMessage, src/ctelnet.cpp:4436):
+     *  a client message for the player, written onto the main console. Wired by
+     *  ScriptingEngine, which applies the prefix colouring. Used by the map
+     *  loaders to explain a refused map file instead of failing silently. */
+    onSystemMessage?: (text: string) => void;
     /** The MMP map URL from GMCP `Client.Map`, or '' when none announced. */
     get mmpMapLocation(): string;
     /** Record the game-announced map URL (Mudlet TMap::setMmpMapLocation). */
@@ -215,6 +253,15 @@ export declare class WindowManager {
         hints: Record<string, WindowOpenOptions>;
         dockExtents: Record<string, number>;
     }): void;
+    /**
+     * Raise the resize events for windows a layout load just placed, before the
+     * load returns. Desktop's restoreState resizes each dock there and then, so
+     * a sysUserWindowResizeEvent handler runs INSIDE loadWindowLayout() — which
+     * is what lets saveWindowLayout refuse to run mid-load, and openUserWindow
+     * notice a window a handler deleted as the layout loaded. Left to the
+     * ResizeObserver, those events would arrive a turn later, after the load.
+     */
+    private reportLayoutSizes;
     /** Returns the stable portal-target div for a window, creating it on first call.
      *  This div is physically moved between dock slots and floating frames — the
      *  panel component rendered into it never unmounts during transitions. */
@@ -252,6 +299,42 @@ export declare class WindowManager {
      */
     registerMainViewport(element: HTMLElement | null): void;
     getMainViewportElement(): HTMLElement | null;
+    /**
+     * The box the main window's size is read from: the `.main-viewport` host,
+     * which the console viewport spans (`inset: 0`) but which carries none of
+     * its padding. The borders are that padding, and desktop's borders are
+     * insets inside a console whose size they leave alone — measuring the
+     * padded viewport instead let a border wider than the console widen the
+     * "window" (setBorderRight(1000000) answered a window a million pixels
+     * wide), which every attached Adjustable.Container then took for a resize.
+     */
+    getMainSizeElement(): HTMLElement | null;
+    /** The `.main-viewport` box the console viewport and the overlay root both
+     *  span (`inset: 0`). It is the one element that can be given a size — the
+     *  two inside it are absolutely positioned against it, so sizing either of
+     *  those alone would move the console out from under the labels. */
+    private mainViewportHostEl;
+    private mainViewportSize;
+    registerMainViewportHost(element: HTMLElement | null): void;
+    /** The `.content-layout` column — button bars, docks, the console and the
+     *  command bar — which stands in for desktop's application window: what
+     *  setMainWindowSize sizes, the console taking what the rest leaves. */
+    private mainWindowFrameEl;
+    registerMainWindowFrame(element: HTMLElement | null): void;
+    private applyMainViewportSize;
+    private applyMainWindowFrameSize;
+    /**
+     * Mudlet `setMainWindowSize(width, height)`. Desktop resizes the application
+     * window; a browser tab cannot resize itself — `window.resizeTo` is refused
+     * for anything the script did not open — so what is sized is the column
+     * that stands in for that window ({@link registerMainWindowFrame}): the
+     * console in it is what `getMainWindowSize` measures, and the command bar
+     * and button bars take their room from it as they grow, as on desktop.
+     * Before that column has mounted, the console's own box is sized.
+     *
+     * Returns false only when there is no viewport to size (before mount).
+     */
+    setMainWindowSize(width: number, height: number): boolean;
     /**
      * The DOM element main-parented nested windows (mini-consoles, embedded
      * mapper) portal into. This is `.main-overlay-root` — the SAME wrapper the
@@ -326,6 +409,35 @@ export declare class WindowManager {
      *  sysUserWindowResizeEvent plus the console-grid and overflow events when
      *  the size actually changed since last reported. */
     private measureAndEmitResize;
+    /** Raise sysWindowResizeEvent/sysUserWindowResizeEvent for `id` at w×h,
+     *  unless that is the size last reported for it. */
+    private emitWindowSize;
+    /**
+     * The arguments of a main-window `sysWindowResizeEvent` for a main viewport
+     * of `w`×`h` — Mudlet's TConsole::raiseMudletSysWindowResizeEvent: the size
+     * of the console area left once the setBorder* insets are taken out, then
+     * the console's name. The viewport measured here already stops short of the
+     * command line, which desktop subtracts as well. getMainWindowSize() still
+     * reports the whole viewport, borders included — the two differ in Mudlet
+     * too.
+     */
+    mainResizeEventArgs(w: number, h: number): [number, number, string];
+    /**
+     * Mudlet raises sysUserWindowResizeEvent as a new user window is first laid
+     * out, so a handler registered before openUserWindow() hears the size the
+     * window arrives at. Here that report would wait for the panel to mount and
+     * its ResizeObserver to tick — which a script that blocks the event loop
+     * (a busted run, a pumpEvents() wait) never lets happen. So opening a window
+     * queues a report of its own, delivered on the next turn or by
+     * {@link pumpCreatedSizes}, whichever comes first. It carries the size
+     * getUserWindowSize() gives at that moment, the mounted box or the stored
+     * one, and the dedup in emitWindowSize keeps the observer's own first tick
+     * from repeating it. resizeWindow() queues one the same way, for the size
+     * a script just gave the window.
+     */
+    announceCreatedSize(id: string): void;
+    /** Deliver the reports {@link announceCreatedSize} queued. */
+    pumpCreatedSizes(): boolean;
     /** Measure one monospace cell (px) by probing `el` with its own inherited
      *  font — the same technique getColumnCount uses, so the NAWS grid and
      *  getColumnCount agree. Falls back to a fontSize estimate when the probe
@@ -337,6 +449,12 @@ export declare class WindowManager {
      *  resize observer last reported — which on a fast/mobile connect may be
      *  stale or not yet fired. No-op when the main element isn't mounted, or
      *  when the size is unchanged (the dedup guard in emitConsoleGridIfChanged). */
+    /** Apply the profile's setBorder* insets to the main viewport now and
+     *  re-measure the char grid inside them, raising sysConsoleSizeChanged if
+     *  it moved. Host::setBorders resizes the console — and with it the text
+     *  pane, whose resize raises that event — before it raises
+     *  sysWindowResizeEvent, so a border change reports the grid first. */
+    applyMainBorders(): void;
     remeasureMainGrid(): void;
     /** Compute the rendered char-grid for `id` and emit sysConsoleSizeChanged
      *  when (cols, rows) changes. Metrics are measured against the registered
@@ -348,17 +466,74 @@ export declare class WindowManager {
      *  which probes the same element. Falls back to the viewport box when the
      *  text element isn't mounted yet. */
     private emitConsoleGridIfChanged;
-    /** Mudlet sysWindowOverflowEvent(name, overflowLines). Fires when a console
-     *  whose scrolling is disabled has more content than fits in the viewport.
-     *  scrollHeight − clientHeight gives the pixel overflow; dividing by the
-     *  estimated line height converts it to lines for the event payload. */
-    private emitWindowOverflowIfPresent;
+    /**
+     * Raise sysConsoleSizeChanged(name, columns, rows, gutter) for a console
+     * whose character grid is now `cols` × `rows`, unless that is the grid it
+     * last reported — TConsole::raiseMudletResizeEvent compares against what
+     * it reported before. Called by the resize path above, and by a timestamp
+     * column being shown or hidden, which reports a grid that a font change
+     * (which reports nothing on its own) left unreported.
+     */
+    reportConsoleGrid(id: string, cols: number, rows: number): void;
+    /**
+     * Mudlet sysWindowOverflowEvent(name, overflowLines) — raised when a console
+     * that is not allowed to scroll holds more lines than its pane can show, so
+     * a script laying out fixed panels can react to text it has pushed out of
+     * sight. `lineCount` and `rows` are counted the way TConsole does it:
+     * lineCount includes the line the cursor is on, and the payload is how many
+     * lines are past the bottom.
+     *
+     * Driven from the append path (ScriptingAPI.drainWindowConsole), because
+     * that is where Mudlet raises it — TBuffer::append and translateToPlainText
+     * both call handleLinesOverflowEvent once they have added their text. It
+     * used to be measured here instead, off scrollHeight vs clientHeight on a
+     * ResizeObserver tick, which never fired for the case the event exists for:
+     * content growing inside an element does not resize that element, so a
+     * console could overflow indefinitely without a single event.
+     *
+     * The counts come from `measure`, called only for a console that cannot
+     * scroll: counting rows reads the pane's computed style and height, which
+     * forces a layout of everything the console holds. Measured up front on
+     * every write, that made each line written to a chat window cost more the
+     * fuller it was — and a console that scrolls, the default, never uses it
+     * (mudlet-web#439).
+     */
+    noteLineOverflow(id: string, measure: () => {
+        lineCount: number;
+        rows: number;
+    }): void;
     /** Raise Mudlet's sysWindowMousePress/ReleaseEvent for clicks anywhere on a
      *  window's box. Args mirror Mudlet: (button, x, y, name) where button is
      *  1=left, 2=right, 3=middle, 4=back, 5=forward (0 = anything else), x/y are
      *  pixel coordinates relative to the window, and name is the window id
-     *  ('main' for the central output). */
+     *  ('main' for the central output).
+     *
+     *  Desktop's ordering is what shapes the wiring:
+     *  - The press is raised before anything inside the console acts on it — a
+     *    link runs between the press and release events (TConsole raises the
+     *    press, then TTextEdit::mousePressEvent runs the link), so the press
+     *    listens in the capture phase, ahead of the link's own handler.
+     *  - Qt gives the release to the widget the press went to (its implicit
+     *    mouse grab), wherever the pointer is let go, so the release is raised
+     *    for the window that took the press, from a document listener.
+     *  - A press on a label or a nested window belongs to that widget: labels
+     *    pass on only what they have no callback for (see
+     *    {@link raiseUnhandledMouse}), and a nested window raises its own. */
     private observeMouse;
+    /** The window holding Qt's implicit mouse grab: the one the last press
+     *  went to, until every button is up again. */
+    private mouseGrab;
+    private mouseReleaseListener;
+    private installMouseReleaseListener;
+    private raiseWindowMouse;
+    /**
+     * A press or release a label had no callback for. TLabel::mousePressEvent
+     * and mouseReleaseEvent hand an event they don't use on to the widget
+     * under them — the label's window — which raises it as its own
+     * sysWindowMousePressEvent / sysWindowMouseReleaseEvent, at the pointer's
+     * position in that window.
+     */
+    raiseUnhandledMouse(kind: 'press' | 'release', windowId: string, e: MouseEvent): void;
     /** Mudlet `sysDropEvent(filepath, suffix, x, y, name)` and
      *  `sysDropUrlEvent(url, schema, x, y, name)` — fired when the user drags
      *  a file or URL onto a window. We only acknowledge drops we can identify
@@ -368,7 +543,40 @@ export declare class WindowManager {
     private observeDrop;
     registerMapCallback(id: string, cb: (roomId: number) => void): void;
     unregisterMapCallback(id: string): void;
-    centerView(roomId: number): boolean;
+    /**
+     * Mudlet `centerview(roomID [, viewID])`.
+     *
+     * With a view id it centres THAT window and returns; the player is not
+     * moved. Only the primary mapper's form writes mRoomIdHash — a secondary
+     * view is somewhere the player is looking, not somewhere they are, and
+     * T2DMap::centerview returns before the block that records a position.
+     */
+    centerView(roomId: number, viewId?: number): boolean | string;
+    /**
+     * Run the map info contributors as a paint of the map widget would
+     * (T2DMap::paintEvent → dlgMapper::paintMapInfo), for the paint that
+     * updateMap() or a centerview asked for. MapPanel does this on its own
+     * render, but a script that blocks the event loop (a busted run, a
+     * pumpEvents() wait) never lets React render — where desktop's
+     * pumpEvents delivers the queued repaint. So the busted pump calls this,
+     * and a contributor runs as it would on desktop: with the selection's
+     * centre or else the player's room, and not at all without one.
+     */
+    pumpMapPaint(): boolean;
+    /** Whether a map widget (not a secondary map view) is open. */
+    private hasMapWidget;
+    /** MapPanel reports the area it switched to (the area picker, or the view
+     *  restored on open), so the next centerview's sysMapAreaChanged names it
+     *  as the previous area. */
+    noteMapArea(areaId: number): void;
+    /** The map went away (deleteMap, a failed load): whatever map comes next is
+     *  shown fresh, so its first centerview reports -2 as the previous area. */
+    resetMapArea(): void;
+    /** The area a map view is showing, or a refusal when there is no such view.
+     *  A view ignores the areaID a caller hands setMapZoom/getMapZoom and uses
+     *  this one — TMapView::setZoom throws the argument away and passes
+     *  getCurrentAreaId(). */
+    mapViewArea(viewId: number): number | string;
     /**
      * Mudlet `T2DMap::initiateSpeedWalk` — start a speedwalk from the player's
      * current room to `targetRoomId`, the room the user double-clicked on the
@@ -384,9 +592,15 @@ export declare class WindowManager {
      */
     startSpeedWalk(targetRoomId: number): boolean;
     registerMapControl(id: string, ctrl: MapControl): void;
+    /** Whether a mapper has been created this session — Mudlet's
+     *  `mpMap->mpMapper`, which getPlayerRoom requires before it reports a
+     *  room at all. Desktop makes one when the map is first shown (the Map
+     *  button, openMapWidget, createMapper) or loaded (loadMap), and keeps it,
+     *  hidden, when the dock is closed — so this latches. */
+    hasMapper(): boolean;
     unregisterMapControl(id: string): void;
     /** Live zoom of the displayed 2D map, or null when no map panel is mounted.
-     *  mudix shows one area at a time through a single shared renderer, so the
+     *  Mudlet Web shows one area at a time through a single shared renderer, so the
      *  Mudlet `areaID` argument has no per-area analogue here — callers get the
      *  current view's zoom regardless. */
     getMapZoom(): number | null;
@@ -459,11 +673,37 @@ export declare class WindowManager {
      * Parse a Mudlet `.dat` buffer and apply it to this session's MapStore.
      * Rooms / areas / hashes / labels / env colours / map-level user data all
      * land in {@link MapStore} via {@link MapStore.loadFromBinary}; the
-     * renderer reads it back through the live {@link MudixMapReader}. Throws
+     * renderer reads it back through the live {@link MudletMapReader}. Throws
      * on parse failure so callers can surface the error (the file-upload path
      * in MapPanel turns it into status='error'; bootstrap logs and moves on).
      */
-    ingestMapBuffer(buf: ArrayBuffer): void;
+    ingestMapBuffer(buf: ArrayBuffer, source?: string): void;
+    /**
+     * Report a failed map load the way Mudlet does: an unreadable format
+     * version gets its explanation on the main console (TMap::readMap posts
+     * every out-of-range case through postMessage, src/TMap.cpp:1531-1573)
+     * rather than being swallowed into a console.warn the player never sees.
+     * Everything else stays a developer-facing warning.
+     */
+    private reportMapLoadFailure;
+    /** Reason the most recent map load failed, or null when the last one
+     *  succeeded. The map panel shows this in its error slot — "Failed to parse
+     *  map file" alone leaves a rejected format version looking like corruption. */
+    get lastMapLoadError(): string | null;
+    /** How many audit lines one load is allowed to put on the console. A map
+     *  with a systematic fault has one per room, and thousands of them would
+     *  push the game's own output out of the scrollback — which is the thing the
+     *  player was reading when they turned the option on. */
+    private static readonly MAX_MAP_ISSUES_POSTED;
+    /**
+     * Mudlet's "report map issues on screen" (`mudlet::showMapAuditErrors`,
+     * consulted at every `postMessage` in TRoom/TRoomDB/TMap's audit).
+     *
+     * Called after a load has finished. Every load path audits and repairs the
+     * map as Mudlet's TMap::audit does (MapStore.auditMap), so the report is
+     * already collected; this only decides whether the player sees it.
+     */
+    private reportMapIssues;
     /**
      * Async sibling of {@link ingestMapBuffer} that parses in a worker so the
      * main thread stays free for paint. `buf` is transferred — callers that
@@ -478,7 +718,7 @@ export declare class WindowManager {
      * Batch progress is published on {@link subscribeMapLoadProgress} for the
      * map panel's progress bar; `onProgress` is an extra per-call hook.
      */
-    ingestMapBufferAsync(buf: ArrayBuffer, onProgress?: (loaded: number, total: number) => void): Promise<void>;
+    ingestMapBufferAsync(buf: ArrayBuffer, onProgress?: (loaded: number, total: number) => void, source?: string): Promise<void>;
     /**
      * Mudlet parity: a map is available to scripts before `sysLoadEvent` fires.
      * ScriptingEngine awaits this in its start() path so the initial script
@@ -494,12 +734,13 @@ export declare class WindowManager {
      * into the manager/store, and any open MapPanel is asked to re-render.
      * Without a buffer the panel is told to reload from cache. Returns false
      * on synchronous parse failure; the IndexedDB write is fire-and-forget
-     * (failures appear in console.warn). Fires sysMapLoadEvent on success.
+     * (failures appear in console.warn). Raises no event: desktop has no
+     * sysMapLoadEvent, so a script waiting on one would never run there.
      */
-    loadMap(buf?: ArrayBuffer): boolean;
+    loadMap(buf?: ArrayBuffer, source?: string): boolean;
     /**
      * Async sibling of {@link loadMap} with identical effects — IndexedDB
-     * persistence, store ingest, panel re-render, `sysMapLoadEvent` — but the
+     * persistence, store ingest, panel re-render — but the
      * parse runs in the worker and streams into the store, publishing progress
      * as it goes.
      *
@@ -511,7 +752,7 @@ export declare class WindowManager {
      *
      * `buf` is transferred to the worker and must not be reused by the caller.
      */
-    loadMapAsync(buf: ArrayBuffer): Promise<boolean>;
+    loadMapAsync(buf: ArrayBuffer, source?: string): Promise<boolean>;
     /**
      * Mudlet `saveMap([location])`. Serialises the in-memory MapStore to the
      * Mudlet binary `.dat` format and persists it to this connection's
@@ -544,19 +785,41 @@ export declare class WindowManager {
      * completes because the worker and IDB outlive the session instance.
      */
     flushMapSave(): void;
+    /**
+     * Page-unload counterpart to {@link flushMapSave}: a worker round trip may
+     * not finish before the page is gone, so serialise on this thread and
+     * start the IndexedDB write now. Mudlet saves an unsaved map on close
+     * (TMainConsole::closeEvent → saveMapFile); without this, rooms a script
+     * added since the last autosave are lost when the tab closes.
+     */
+    flushMapSaveSync(): void;
     /**
      * Mudlet `saveJsonMap(path)` backbone — serialise the current MapStore
      * to a JSON string. Used by the Lua binding, which writes the result to
      * the VFS path the script provided.
      */
-    saveJsonMap(): string;
+    /** Mudlet's own interchange schema, not the binary model — a file written
+     *  here has to open in Mudlet, and be readable by anything that parses it
+     *  directly. */
+    /** Every distinct room symbol the map uses; see symbolsThisFontCannotDraw. */
+    mapRoomSymbols(): string[];
+    /** Mudlet's "Show symbol usage…" data: each symbol with the rooms using it,
+     *  commonest first. */
+    mapRoomSymbolUsage(): {
+        symbol: string;
+        rooms: number[];
+    }[];
+    saveJsonMap(extras?: Record<string, unknown>): string;
     /**
      * Mudlet `loadJsonMap(path)` backbone — parse a JSON payload previously
      * produced by `saveJsonMap` and replace MapStore's contents, then ask any
      * open map panel to re-render. Returns false on parse failure or when the
      * JSON doesn't carry the expected MudletMap shape.
      */
-    loadJsonMap(json: string): boolean;
+    loadJsonMap(json: string, source?: string): boolean;
+    private lastMapReport;
+    /** The report the last loadJsonMap wrote for log/errors.txt, once. */
+    takeMapReport(): string;
     /**
      * Import an IRE-style XML map (Mudlet TConsole::importMap →
      * XMLimport::readMap) — the format `loadMap("...xml")` and MMP map
@@ -568,11 +831,17 @@ export declare class WindowManager {
     loadMapXml(xmlText: string): boolean;
     markAsMiniConsole(id: string): void;
     isMiniConsole(id: string): boolean;
+    /** Whether `id` is a text console (a user window or miniconsole) rather
+     *  than a map or HTML panel. */
+    isTextWindow(id: string): boolean;
     /** Flag a console as an MXP frame so it renders with a frame border. Also
      *  hides its scrollbar: Mudlet's frames are `TConsole::SubConsole`s, which
      *  start with theirs hidden, and no MXP server ever calls enableScrollBar.
      *  Idempotent — the layout re-places a frame on every reflow. */
     markAsMxpFrame(id: string): void;
+    /** Whether `id` is an MXP frame's own console — false once a script has
+     *  deleted it, even if it then made a window of its own under the name. */
+    isMxpFrame(id: string): boolean;
     /** Install (or replace) an MXP frame's tab strip. An empty `pages` list
      *  removes it. Pages other than the active one are hidden, which keeps their
      *  panel mounted — the content pool renders every open window regardless of
@@ -600,6 +869,19 @@ export declare class WindowManager {
         bottom: number;
         left: number;
     }): void;
+    /** Write the console insets straight onto the main viewport, on top of
+     *  notifying React to render the same values.
+     *
+     *  A server's frames and the script that reads what they cost are in the
+     *  same turn: `<FRAME ALIGN=left WIDTH=25%>` and the getColumnCount() that
+     *  measures what is left of the main window both happen before React can
+     *  render anything, so a caller waiting on the React path measures the
+     *  window as it was and lays its own output out over the frame. The browser
+     *  reflows on the next geometry read either way, so writing the padding
+     *  here makes that measurement the true one. React then renders the
+     *  identical value, and the two never disagree — the sum is computed the
+     *  same way in both places (OutputArea's contentStyle). */
+    private applyMainViewportInsets;
     getRoomIDbyHash(hash: string): number | undefined;
     setPosition(id: string, x: number, y: number): void;
     /** Mudlet setWindow for miniconsole / mapper panels — re-portal the panel
@@ -659,13 +941,20 @@ export declare class WindowManager {
      */
     scrollBarVisible(id: string): boolean;
     /** Mudlet enable/disableHorizontalScrollBar — toggle a horizontal scrollbar
-     *  on a console wrapper. mudix wraps long lines by default so this is rarely
+     *  on a console wrapper. Mudlet Web wraps long lines by default so this is rarely
      *  needed; included for parity. */
     setHorizontalScrollBarVisible(id: string, visible: boolean): void;
     /** Mudlet enable/disableScrolling — when disabled, the wrapper sticks to the
      *  bottom (wheel/touch/keys cannot scroll back). Mudlet forbids this on the
-     *  main window; we follow that policy. Returns false on 'main', true otherwise. */
+     *  main window; we follow that policy. Returns false on 'main', true otherwise.
+     *  Disabling also closes the split view (TConsole::setScrolling calls
+     *  clearSplit), so a console a script had scrolled up does not stay parked
+     *  there with no way left to scroll it down. */
     setScrollingEnabled(id: string, enabled: boolean): boolean;
+    /** Mudlet `TConsole::clearSplit` for a script: forget any scrolled-to line
+     *  and put the console back on its tail. The renderer's own scroll handler
+     *  sees the wrapper reach the bottom and drops the split pane. */
+    clearSplit(id: string): void;
     /**
      * Mudlet `timeStampsEnabled(window)` — whether the console is showing its
      * timestamp column. Null when the window has no renderer registered, which
@@ -686,14 +975,6 @@ export declare class WindowManager {
      *  allowed. Always true for `'main'`, which setScrollingEnabled refuses to
      *  change, and true for any console nobody has called disableScrolling on. */
     isScrollingEnabled(id: string): boolean;
-    /** Buffer-line index of the topmost visible line in `id`'s wrapper. In tail
-     *  mode returns the last line number (matching Mudlet's mCursorY behaviour at
-     *  the end of the buffer). Returns 0 if the element is unmounted or empty.
-     *
-     *  Uses getBoundingClientRect rather than offsetTop because `.output-container`
-     *  is `position: relative` — child offsetTop is relative to *that*, not to the
-     *  scroll-container `.output-wrapper`, so the rectangles are the unambiguous
-     *  way to relate child position to the scroll viewport. */
     /** Whether `id`'s wrapper is mounted with laid-out lines, i.e. whether
      *  {@link getScrollLine}'s measurement means anything. A console whose panel
      *  isn't on screen yet measures as 0, which is indistinguishable from being
@@ -703,7 +984,7 @@ export declare class WindowManager {
      * Where `scrollTo` last parked each console, as a buffer line index; absent
      * means tail mode (or that only the user has scrolled it).
      *
-     * Mudlet's getScroll/scrollTo are buffer-index operations. mudix measured
+     * Mudlet's getScroll/scrollTo are buffer-index operations. Mudlet Web measured
      * the DOM instead, which is fine for a console the player is looking at but
      * answers nothing useful for one whose panel has not been laid out yet — and
      * a script that scrolls and reads back in the same breath never gives React
@@ -711,18 +992,77 @@ export declare class WindowManager {
      * and the measurement is the fallback, not the source of truth.
      */
     private readonly scriptScrollLine;
+    /** The buffer dropped `removed` lines off its top (TBuffer::shrinkBuffer).
+     *  A console scrolled back keeps showing the lines it showed, which are now
+     *  that many lines nearer the start, so the line a script parked it on
+     *  moves up with them, as desktop's upper pane cursor does. */
+    noteLinesRemoved(id: string, removed: number): void;
+    /** Whether `id` follows its output (desktop's TTextEdit::mIsTailMode):
+     *  neither a script nor the reader has scrolled it back. */
+    followsNewLines(id: string): boolean;
     /** Called when the *user* scrolls a console, so a script's remembered
      *  position stops overriding what they can see. */
     noteUserScroll(id: string): void;
-    getScrollLine(id: string): number;
-    /** Scroll `id`'s wrapper so `line` (0-indexed) sits at the top. `undefined`
-     *  resumes tail mode (scroll-to-bottom); negative values count from the end
-     *  (Mudlet semantics). Returns false if the wrapper is not mounted. */
+    /** The wrapper's scrollTop as scrollToLine left it. A scroll event that
+     *  lands anywhere else was the reader's (wheel, scroll bar, PageUp, the
+     *  split view closing), so the scripted position stops being the answer. */
+    private readonly scriptScrollTop;
+    /**
+     * Wrappers the reader has scrolled back from the end of — the inverse of
+     * desktop's `TTextEdit::mIsTailMode`. Kept from scroll events rather than
+     * measured when asked: new output is appended before the renderer scrolls
+     * down to it, so in between a console that is following its output measures
+     * as some way up — right after a burst of echoes, at the very top. Desktop
+     * stays in tail mode through that, and so does this; only a scroll that
+     * actually leaves the end takes a console out of it.
+     */
+    private readonly scrolledBack;
+    private watchTail;
+    /** Height of the split view's lower pane laid over the bottom of `el` —
+     *  the sticky area StickyOutputPanel renders as the wrapper's sibling. It
+     *  keeps its height while hidden, which is the height it will cover once a
+     *  scroll back raises it. */
+    private splitPaneHeight;
+    /** The height the split view's lower pane takes off `id`'s upper pane
+     *  while it is open — the console scrolled back, by hand or by script —
+     *  and 0 while the console follows its output. A console with no panel to
+     *  measure yet, scrolled back by a script, has the pane at the height it
+     *  opens at. */
+    openSplitPaneHeight(id: string): number;
+    /** Mudlet's scroll position for `id`'s wrapper, or null while it follows
+     *  its output (tail mode), where Mudlet's getScroll answers the last line —
+     *  which the caller takes from the buffer, since the DOM's line count is not
+     *  the buffer's. Returns 0 if the element is unmounted or empty.
+     *
+     *  Desktop's position is the upper pane's `mCursorY`, and that pane draws
+     *  the rows *above* it (TTextEdit::imageTopLine is `mCursorY -
+     *  mScreenHeight`): the number is the first line below the scrolled view,
+     *  one past its bottom row — not the top row. The scrolled view ends where
+     *  the split view's lower pane begins, so that pane's height comes off the
+     *  bottom.
+     *
+     *  Uses getBoundingClientRect rather than offsetTop because `.output-container`
+     *  is `position: relative` — child offsetTop is relative to *that*, not to the
+     *  scroll-container `.output-wrapper`, so the rectangles are the unambiguous
+     *  way to relate child position to the scroll viewport. */
+    getScrollLine(id: string): number | null;
+    /** Mudlet `scrollTo(window, line)`: scroll `id`'s wrapper so `line` is the
+     *  first line below the scrolled view — its bottom row is `line - 1`, the
+     *  same edge {@link getScrollLine} reads. `undefined`, or a line at or past
+     *  the last one, resumes tail mode (TMainConsole::scrollWindowTo); negative
+     *  values count back from the last line. Returns false if the console has
+     *  neither a buffer nor a mounted wrapper. */
     scrollToLine(id: string, line: number | undefined): boolean;
+    /** Mudlet's PageUp / PageDown in the command line (TCommandLine::event):
+     *  scroll `id`'s console a page — the scrolled view's height, the split
+     *  pane excluded — up or down. Paging down into what the split pane already
+     *  shows closes it and resumes tail mode, as TConsole::scrollDown does. */
+    scrollPage(id: string, direction: 'up' | 'down'): void;
     private getScrollStateMut;
     private applyScrollClasses;
-    /** Direct line-element children of the wrapper (skips the sticky-output
-     *  sentinel, which sits at the end with height: 0). */
+    /** The wrapper's line elements, in order, through its scrollback blocks
+     *  (skips the sticky-output sentinel, which sits at the end with
+     *  height: 0). */
     private lineElements;
     /** Mudlet setBackgroundColor for a userwindow / miniconsole. */
     setBackgroundColor(id: string, r: number, g: number, b: number, a?: number): boolean;
@@ -760,11 +1100,58 @@ export declare class WindowManager {
      *  window's command line. Pass null to clear. Returns false when the
      *  window doesn't exist. */
     setCmdLineAction(id: string, cb: ((text: string) => void) | null): boolean;
+    /**
+     * How much taller (positive) or shorter (negative) window `id`'s text pane
+     * is about to be than it measures now: enable/disableCommandLine change
+     * whether it has a command line under it at once, but the panel only takes
+     * the input in or out on its next render, which a script still running
+     * does not let happen. getRowCount adds this so it counts the rows the pane
+     * has, not the ones it had.
+     */
+    pendingCmdLineHeightDelta(id: string): number;
+    /** The height a window's one-row command line takes, measured once off a
+     *  hidden probe styled as the real one; 0 where nothing can be measured. */
+    private cmdLineHeight;
+    private measuredCmdLineHeight;
+    /** Whether window `id` has a command line of its own: one enableCommandLine
+     *  made, which disableCommandLine only hides. A console that never had one
+     *  enabled has none (#342). */
+    hasCommandLine(id: string): boolean;
+    /** Window `id`'s command-line keyboard state, or null when it has none. */
+    cmdLineModel(id: string): SubCommandLine | null;
+    /** The profile settings and Tab pool every command line reads. Set by the
+     *  ScriptingEngine. */
+    cmdLineHost: CmdLineHost;
+    /**
+     * Mudlet deleteCommandLine(name) on a miniconsole's or user window's own
+     * line (TMainConsole::deleteCommandLine finds it in mSubCommandLineMap,
+     * under the console's name): the line goes, action and history with it,
+     * and the console has none until enableCommandLine makes a new one.
+     * False when it has none.
+     */
+    deleteCommandLine(id: string): boolean;
+    /** What a script last put on window `id`'s command line, and the count
+     *  that changes with every such write. */
+    cmdLineSeed(id: string): {
+        value: string;
+        seq: number;
+    } | null;
     /** Whether a script has bound a per-window Enter handler. */
     hasCmdLineAction(id: string): boolean;
     /** Read the bound callback (or null). The TextPanel input invokes this
      *  directly on Enter so the React tree never sees the function. */
     getCmdLineAction(id: string): ((text: string) => void) | null;
+    /** Where Enter goes on a window command line with no action bound: the
+     *  game, as typed input, then echoed into window `id` itself. Set by the
+     *  ScriptingEngine. */
+    onCmdLineDefaultSend?: (text: string, id: string) => void;
+    /**
+     * The user pressed Enter in window `id`'s command line. Runs the bound
+     * action, or else sends the text, as Mudlet's TCommandLine::enterCommand
+     * falls back to `Host::send`. Returns whether anything took the text, i.e.
+     * whether the line should clear.
+     */
+    submitCmdLine(id: string, text: string): boolean;
     /** Mudlet clearCmdLine([name]) when name is a userwindow — wipes the
      *  input contents. The seq bump forces React to apply the seed even
      *  when the value didn't change. Returns false when the window doesn't
@@ -808,6 +1195,8 @@ export declare class WindowManager {
     hide(id: string): void;
     show(id: string): boolean;
     isVisible(id: string): boolean;
+    /** Whether the window sits in a dock (rather than floating). */
+    isDocked(id: string): boolean;
     /** Stored geometry for a user window / miniconsole — deliberately the saved
      *  x/y/width/height rather than {@link getSize}'s live DOM rect, so it is an
      *  exact inverse of moveWindow/resizeWindow (Mudlet's getWindowGeometry
@@ -818,6 +1207,28 @@ export declare class WindowManager {
         width: number;
         height: number;
     } | null;
+    /** The dock frame (title bar and content) a docked window is shown in. */
+    private dockFrame;
+    /**
+     * Lay the windows out NOW rather than on React's next render, so the script
+     * line after a dock change already sees the sizes it produced.
+     *
+     * Desktop docks synchronously: by the time openUserWindow() returns, the
+     * dock has its size, the main console has shrunk to make room and
+     * sysWindowResizeEvent has fired, so getUserWindowSize, getMainWindowSize
+     * and getWindowGeometry all answer with the final layout. Here the layout is
+     * React state, which commits on a later turn — scripts that positioned
+     * things right after creating a docked window read the pre-dock numbers.
+     * flushSync commits that render (and the panels' mount effects) before it
+     * returns, so the DOM — which every geometry getter measures — is already
+     * the docked layout, and the main viewport's resize is raised on the spot
+     * like setMainWindowSize does; the observer's own tick dedupes to nothing.
+     *
+     * A no-op beyond the measure when no layout is mounted. When called from
+     * inside a React render or effect, React refuses to flush and the layout
+     * catches up on its own turn, as it always did.
+     */
+    settleLayout(): void;
     /** The window this one nests inside, or null for a root floating window.
      *  Used by the ancestor-aware windowVisible walk. */
     parentOf(id: string): string | null;
@@ -837,9 +1248,10 @@ export declare class WindowManager {
     getTitle(id: string): string | null;
     /**
      * The title a window carries when nobody has set one. Mudlet builds it from
-     * the profile and the window's own name ("<profile> - <window>"), which is
-     * what a player sees on a freshly opened user window; mudix used to fall
-     * back to the bare id, so resetting a title lost the profile half of it.
+     * the profile and the window's own name ("User window - <profile> -
+     * <window>", TMainConsole's tr() string), which is what
+     * setUserWindowTitle(name) with no title goes back to; Mudlet Web used to
+     * fall back to the bare id, then to "<profile> - <window>" (mudlet-web#380).
      * The profile name is injected by ScriptingAPI — the manager has no other
      * reason to know it.
      */
@@ -847,6 +1259,9 @@ export declare class WindowManager {
     defaultTitle(id: string): string;
     focus(id: string): void;
     has(id: string): boolean;
+    /** The record behind `id`, compared by identity to tell a window from one
+     *  put in its place under the same name. */
+    record(id: string): object | undefined;
     getElement(id: string): HTMLElement | null;
     /** Mudlet getUserWindowSize. Reports the live rendered size of a userwindow
      *  / miniconsole when mounted (so docked panels return their actual on-screen