@mudlet/mudlet-web 0.5.0 → 1.0.1

package/dist-lib/mud/protocol/mnes.d.ts

@@ -6,56 +6,35 @@ import { CLIENT_NAME, CLIENT_VERSION, TERMINAL_TYPE } from "../../version";
  *  distinction structurally: a name followed by VALUE is defined (and, with
  *  nothing after the VALUE, defined-but-empty), while a name followed by the
  *  next marker or IAC with no VALUE at all is undefined. That is how a variable
- *  the client deliberately does not supply is answered — see
- *  {@link MNES_UNMAINTAINED}. */
+ *  the client does not supply is answered. */
 export interface MnesVar {
     name: string;
     value: string | null;
 }
-/** Result of parsing an `IAC SB NEW-ENVIRON SEND … IAC SE` request body. */
-export interface MnesRequest {
-    /** True when the body is a well-formed SEND command (the only request kind
-     *  a client answers). */
-    isSend: boolean;
-    /** Variable names the server explicitly asked for, in request order. Empty
-     *  means a bare SEND — the server wants every variable we report. */
-    requested: string[];
-}
-/**
- * Parse an `IAC SB NEW-ENVIRON SEND …` request. `subneg` is the subnegotiation
- * body with the leading option code (39) still attached (matching how the
- * telnet option parser hands bodies to the other protocol streams). The byte
- * after the option code is the command; for a server→client request it's SEND.
- * After SEND comes an optional list of `VAR <name>` / `USERVAR <name>` entries,
- * each name running until the next marker (ESC-escaped bytes pass through).
- * A bare SEND with no entries — or only empty names — means "send everything".
- */
-export declare function parseMnesRequest(subneg: string): MnesRequest;
 /**
  * Frame an `IAC SB NEW-ENVIRON IS <marker> <name> VALUE <value> … IAC SE` reply
  * for the given variables. The returned string is a Latin-1 byte-string ready
- * for sendBytes (names/values are ASCII; control bytes are escaped per RFC
- * 1572). `marker` selects how each variable name is tagged: `NEW_ENVIRON_VAR`
- * (the default — MNES frames every variable as a standard VAR) or
- * `NEW_ENVIRON_USERVAR` (plain NEW-ENVIRON frames its client-defined variables
- * as USERVAR, matching Mudlet). The two never mix within one reply because the
- * client reports a single coherent set per negotiated mode.
+ * for sendRaw. `marker` selects how each variable name is tagged:
+ * `NEW_ENVIRON_VAR` (the default — MNES frames every variable as a standard
+ * VAR) or `NEW_ENVIRON_USERVAR`. An empty list frames an empty IS.
  */
 export declare function encodeMnesIs(vars: ReadonlyArray<MnesVar>, marker?: string): string;
 /** Live client state the NEW-ENVIRON variable set is derived from. Everything
  *  here is something the server can't know on its own — the negotiated encoding,
- *  the transport's TLS status, the output window's wrap column. */
+ *  the profile's wrap column, the advertising preferences. */
 export interface NewEnvironState {
     /** The active byte→char codec label as reported for the CHARSET variable,
      *  e.g. "UTF-8" or "LATIN-1". */
     charset: string;
     /** Whether the live encoding is UTF-8 (drives the UTF-8 capability flag). */
     utf8: boolean;
-    /** Whether the link to the game server is TLS-encrypted. True for a direct
-     *  `wss://` connection; false in proxy mode (plaintext upstream telnet). */
-    tls: boolean;
-    /** Output window wrap column, or 0 when the grid hasn't been measured yet. */
-    wrapColumns: number;
+    /** Whether the MTTS bitvector carries the MNES bit — Mudlet sets it when the
+     *  profile has both MNES and NEW-ENVIRON enabled. Defaults to false. */
+    mnes?: boolean;
+    /** The main console's wrap column — Mudlet's `Host::mWrapAt`, reported as
+     *  WORD_WRAP. Not the window's column count: a server wrapping to this
+     *  value produces lines the client then shows unbroken. */
+    wordWrap: number;
     /** Whether the client is advertising screen-reader use (MTTS SCREEN READER
      *  bit, NEW-ENVIRON SCREEN_READER var) — `setConfig("advertiseScreenReader", …)`.
      *  Defaults to false (matching Mudlet's opt-in behaviour). */
@@ -79,34 +58,38 @@ export { CLIENT_NAME, CLIENT_VERSION, TERMINAL_TYPE };
  * always present; when `extended` is true the broader NEW-ENVIRON capability
  * set is appended (mirroring Mudlet's `getNewEnvironDataMap`): terminal
  * capabilities (ANSI, 256_COLORS, TRUECOLOR, UTF-8), transport/security (TLS),
- * and layout/accessibility hints (WORD_WRAP, SCREEN_READER). Capabilities mudix
+ * and layout/accessibility hints (WORD_WRAP, SCREEN_READER). Capabilities Mudlet Web
  * doesn't implement are reported honestly as "0" rather than omitted, so a
- * server gets a definite answer instead of inferring absence. The caller frames
- * the result with VAR (MNES) or USERVAR (NEW-ENVIRON) via encodeMnesIs.
+ * server gets a definite answer instead of inferring absence.
+ *
+ * TLS is "1" always: like the MTTS SSL bit (see computeMtts) it is Mudlet's
+ * compiled-in capability, not the state of this link.
  */
 export declare function buildNewEnvironVars(state: NewEnvironState, extended: boolean): MnesVar[];
-/** MNES names the standard defines that mudix deliberately does not supply.
- *  They are still *known*, so a server that asks for one is told it is
- *  undefined rather than left with silence — Mudlet's `isMNESVariable` lists
- *  IPADDRESS alongside the five it reports, and answers it with a name and no
- *  VALUE. (A browser tab has no way to learn its own address, and the client is
- *  not the right party to guess: the server already sees the peer address.) */
-export declare const MNES_UNMAINTAINED: ReadonlyArray<string>;
+/** The names MNES defines — Mudlet's `isMNESVariable`. IPADDRESS is among
+ *  them though no client supplies it (a browser tab cannot learn its own
+ *  address, and the server already sees the peer), so a request for it is
+ *  answered "undefined" rather than ignored. */
+export declare const MNES_VARIABLES: ReadonlyArray<string>;
 /**
- * Pick which of the client's `available` variables to report in response to a
- * parsed request, mirroring Mudlet's `sendIsMNESValues` /
- * `sendIsNewEnvironValues`:
+ * Answer a plain NEW-ENVIRON `SEND` the way Mudlet's
+ * `cTelnet::sendIsNewEnvironValues` does — one IS reply, possibly empty, or
+ * null when the body is not a SEND. Every variable in `available` is a USERVAR
+ * (Mudlet defines no VAR of its own while SYSTEMTYPE and USER are opt-in), so:
  *
- *   - A bare SEND (no names) asks for everything, and gets it.
- *   - Named variables come back in request order, each either with its value or
- *     — for a name in `undefinedNames` — as undefined (no VALUE).
- *   - A name that is neither is left out entirely.
- *
- * A request naming only names we do not report therefore selects **nothing**.
- * It used to fall back to sending everything on the reasoning that the server
- * still learns who we are, but that answers a question nobody asked: a server
- * probing for one specific variable gets an unsolicited dump of the whole set,
- * which is not what Mudlet does and not what the request meant. The caller
- * decides what an empty selection is framed as.
+ *  - a bare SEND lists them all, in key order;
+ *  - `USERVAR` with no name lists them all, `VAR` with no name lists none;
+ *  - `USERVAR <name>` gets its value; `VAR <name>` for one of ours, or either
+ *    marker with a name we do not define, is echoed back with no VALUE —
+ *    RFC 1572's "undefined" — rather than dropped.
+ */
+export declare function newEnvironIsReply(subneg: string, available: ReadonlyArray<MnesVar>): string | null;
+/**
+ * Answer an MNES `SEND` the way Mudlet's `cTelnet::sendIsMNESValues` does, or
+ * null when the body is not a SEND. Only VAR separates names here. Each named
+ * MNES variable gets an IS reply of its own (IPADDRESS as undefined), a name
+ * MNES does not define gets nothing, and a request that ends without a name — a
+ * bare SEND, or a trailing empty VAR — is answered with every variable in one
+ * reply, after any per-name replies.
  */
-export declare function selectMnesVars(request: MnesRequest, available: ReadonlyArray<MnesVar>, undefinedNames?: ReadonlyArray<string>): MnesVar[];
+export declare function mnesIsReplies(subneg: string, available: ReadonlyArray<MnesVar>): string[] | null;

package/dist-lib/mud/protocol/msdp.d.ts

@@ -1,9 +1,11 @@
 /**
  * Frame a Mudlet-style `sendMSDP(variable, ...values)` call as an MSDP
  * subnegotiation: `IAC SB MSDP MSDP_VAR <variable> [MSDP_VAL <value>]... IAC SE`.
- * The returned string is a Latin-1 byte-string ready for sendBytes.
+ * The returned string is a Latin-1 byte-string ready for sendBytes. `encode`
+ * turns text into the game's bytes — the session's encoding, as desktop
+ * writes them; UTF-8 for a caller with no session.
  */
-export declare function encodeMsdp(variable: string, values: string[]): string;
+export declare function encodeMsdp(variable: string, values: string[], encode?: (text: string) => string): string;
 export interface MsdpEnvelope {
     /** Top-level MSDP variable name (e.g. "HEALTH", "ROOM"). */
     path: string;
@@ -12,8 +14,13 @@ export interface MsdpEnvelope {
 }
 export interface MsdpStreamOptions {
     onEnvelope: (payload: MsdpEnvelope) => void;
+    /** Byte-string to text under the session's game encoding. Defaults to
+     *  UTF-8. */
+    decode?: (bytes: string) => string;
 }
 /** Mirror of createGmcpStream for MSDP subnegotiations. The handler receives a
  *  subnegotiation body whose first byte is the MSDP option code (69); each
- *  top-level variable is emitted as its own envelope. */
-export declare const createMsdpStream: ({ onEnvelope }: MsdpStreamOptions) => (data: string) => void;
+ *  top-level variable is emitted as its own envelope. A variable the parser
+ *  dropped as malformed yields no envelope at all, so no arrival event fires
+ *  for data the game never finished sending. */
+export declare const createMsdpStream: ({ onEnvelope, decode }: MsdpStreamOptions) => (data: string) => void;

package/dist-lib/mud/protocol/msp.d.ts

@@ -20,8 +20,9 @@ export interface MspCommand {
     type?: string;
 }
 /**
- * Stateful MSP parser. Feed each post-telnet-strip chunk through `feed()` and
- * render the returned `text` instead of the raw input. Parsed commands are
+ * Stateful MSP parser. `feed()` parses `!!SOUND(...)` / `!!MUSIC(...)` tags out
+ * of text a script hands to `receiveMSP()` — game text itself is never parsed,
+ * as in Mudlet — returning the remaining `text`. Parsed commands are
  * delivered as `commands`. The parser holds back a partial tag (`!!SOUND(...`
  * with no closing `)` yet) until the next chunk supplies the rest, so tags
  * split across WebSocket frames still parse correctly.

package/dist-lib/mud/protocol/mssp.d.ts

@@ -12,14 +12,19 @@ export interface MsspEnvelope {
  * `MSSP_VAR <name> MSSP_VAL <value>` pairs; names/values are scalar byte runs
  * terminated by the next control byte. Tolerant of truncation and stray bytes.
  *
- * Mirrors Mudlet's TLuaInterpreter::parseMSSP: scalar string values, and a
- * variable with extra `MSSP_VAL` runs keeps only its first value.
+ * Mirrors Mudlet's TLuaInterpreter::parseMSSP: scalar string values, a
+ * variable with no `MSSP_VAL` is skipped, and a variable with extra `MSSP_VAL`
+ * runs keeps only its first value.
  */
-export declare function parseMssp(body: string): MsspEnvelope[];
+export declare function parseMssp(body: string, decode?: (bytes: string) => string): MsspEnvelope[];
 export interface MsspStreamOptions {
     onEnvelope: (payload: MsspEnvelope) => void;
+    /** Byte-string to text under the session's game encoding. Defaults to
+     *  UTF-8, which is what a session that negotiated nothing else is reading
+     *  anyway. */
+    decode?: (bytes: string) => string;
 }
 /** Mirror of createMsdpStream for MSSP subnegotiations. The handler receives a
  *  subnegotiation body whose first byte is the MSSP option code (70); each
  *  variable is emitted as its own envelope. */
-export declare const createMsspStream: ({ onEnvelope }: MsspStreamOptions) => (data: string) => void;
+export declare const createMsspStream: ({ onEnvelope, decode }: MsspStreamOptions) => (data: string) => void;

package/dist-lib/mud/protocol/multiByte.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Sequence framing for the East Asian multi-byte encodings.
+ *
+ * The browser can decode GBK, GB18030, Big5, EUC-KR, Shift_JIS and EUC-JP, and this module leans on
+ * it to do so — the character tables are enormous and there is no reason to
+ * carry a second copy. What it does NOT borrow is the browser's error recovery,
+ * because that differs from Mudlet's in ways a MUD player would see:
+ *
+ *  - **How much a bad sequence eats.** Both now put a trail byte that cannot
+ *    belong to the sequence back onto the stream (`C4 20 5A` under GBK renders
+ *    as `<?> Z`), but Mudlet consumes a trail that is merely out of range with
+ *    its lead, and frames GB18030's four-byte form its own way.
+ *  - **Which bytes count as valid at all.** The two disagree on GBK 0x80, which
+ *    WHATWG maps to a euro sign and Mudlet rejects, and on EUC-KR 0x7F, which
+ *    WHATWG passes through as DEL and Mudlet rejects.
+ *
+ * So the framing here decides where each sequence starts and ends and whether
+ * it is valid, using the ranges from `TBuffer::processGBSequence`,
+ * `processBig5Sequence` and `processEUC_KRSequence`; a valid sequence is then
+ * handed to the browser to map, and an invalid one becomes exactly one
+ * replacement character however many bytes it consumed.
+ *
+ * Input and output are byte-strings (one char per byte), as everywhere else on
+ * the inbound path.
+ */
+/** The encodings this module frames. UTF-8 is multi-byte too but the browser's
+ *  handling of it already matches, and it is far too hot a path to re-frame. */
+export type MultiByteLabel = 'gbk' | 'gb18030' | 'big5' | 'euc-kr' | 'shift_jis' | 'euc-jp';
+export declare const MULTI_BYTE_FRAMED: ReadonlySet<string>;
+export declare function isMultiByteFramed(label: string): label is MultiByteLabel;
+export interface FramedDecode {
+    /** What the complete sequences in the input decoded to. */
+    text: string;
+    /** Bytes of a sequence that ran off the end of the input, for the caller to
+     *  put back in front of the next chunk. Empty unless the input was cut
+     *  mid-sequence. */
+    pending: string;
+}
+/**
+ * Decode `byteString` under `label`, framing each sequence the way Mudlet does.
+ * Any trailing incomplete sequence comes back as `pending` rather than being
+ * decoded or dropped.
+ *
+ * Some games restyle the right half of a full-width character between its two
+ * bytes. Mudlet holds the lead byte over the SGR and decodes the pair whole
+ * once its trail arrives, the character keeping the colour it started in; so
+ * here the character comes out first and the SGR after it, which the line
+ * parser then reads the same way. Any other sequence, or a byte that cannot be
+ * the trail, ends the character as a replacement mark in front of it.
+ */
+export declare function decodeMultiByte(byteString: string, label: MultiByteLabel): FramedDecode;

package/dist-lib/mud/protocol/multiByteEncode.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Char → bytes for the East Asian multi-byte encodings, the outgoing half of
+ * multiByte.ts.
+ *
+ * The browser decodes GBK, GB18030, Big5 and EUC-KR but will not encode them —
+ * TextEncoder writes UTF-8 and nothing else. So the encode tables are built by
+ * running every sequence the encoding defines through the browser's own
+ * decoder and inverting the result, exactly as the single-byte tables in
+ * charset.ts are. That keeps the two directions in agreement by construction
+ * and spares carrying a second copy of tables the browser already has.
+ *
+ * Which sequences get enumerated follows the inbound framing in multiByte.ts
+ * (Mudlet's TBuffer ranges), so nothing is written that this client would not
+ * itself read back:
+ *
+ *  - **GBK / GB18030**: every lead 0x81–0xFE with every trail 0x40–0xFE bar
+ *    0x7F. GB18030 adds its four-byte form — the BMP part enumerated like the
+ *    pairs, the supplementary planes computed, since they are a straight line.
+ *    The single byte 0x80, which WHATWG's GBK reads as a euro sign and Mudlet
+ *    rejects, is never written; € goes out as its pair, A2 E3.
+ *  - **Big5**: leads 0xA1–0xFE with trails 0x40–0x7E and 0xA1–0xFE. The HKSCS
+ *    leads below 0xA1 are only written for BIG5-HKSCS; a plain Big5 game has
+ *    no reading for them, so there a character found only there is unencodable
+ *    and the send path warns about it. Where one character has two codes, the
+ *    first wins (as in the WHATWG Big5 encoder, with the same six exceptions
+ *    that take the last) — but see buildTable for HKSCS's order.
+ *  - **EUC-KR**: leads and trails 0xA1–0xFE — KS X 1001, which is all Mudlet's
+ *    framing accepts. The browser's decoder also reads the wider UHC (CP949)
+ *    range, but a game that declared EUC-KR is not promised to.
+ *
+ * Output is a byte-string (one char per byte), as the socket layer expects.
+ */
+export type MultiByteEncoding = 'gbk' | 'gb18030' | 'big5' | 'big5-hkscs' | 'euc-kr' | 'shift_jis' | 'euc-jp';
+/**
+ * The bytes (as a byte-string) that write the single code point `ch` in
+ * `encoding`, or null when it has none. ASCII is written as itself. Null also
+ * when the browser cannot decode the encoding at all, since then there is no
+ * table to build.
+ */
+export declare function encodeMultiByteChar(ch: string, encoding: MultiByteEncoding): string | null;
+/** Whether the browser can supply the tables for `encoding` at all. */
+export declare function canBuildMultiByteEncoder(encoding: MultiByteEncoding): boolean;

package/dist-lib/mud/protocol/mxp.d.ts

@@ -8,8 +8,10 @@ export interface MxpLink {
     start: number;
     /** End offset into the line's plain text (exclusive). */
     end: number;
-    /** `url` → open in a browser tab; `command` → send to the MUD. */
-    kind: "command" | "url";
+    /** `url` → open in a browser tab; `command` → send to the MUD;
+     *  `prompt` → write it to the command line and leave it there for the
+     *  player to edit and submit (a SEND carrying the PROMPT flag). */
+    kind: "command" | "url" | "prompt";
     /** The single command or URL fired on left-click. */
     payload: string;
     /** Tooltip / title text. */
@@ -20,6 +22,9 @@ export interface MxpLink {
         cmds: string[];
         hints: string[];
     };
+    /** The link's id in the parser's link store; a click asks
+     *  {@link MxpParser.isLinkLive} with it whether an `<EXPIRE>` retired it. */
+    id: number;
 }
 /** A `<FRAME>` window-lifecycle command the parser surfaces to the session.
  *  The parser is session-free, so it only reports the request; the consumer
@@ -77,13 +82,36 @@ export interface MxpLineResult {
      *  SoundManager path as MSP. Omitted when none. */
     sounds?: MspCommand[];
 }
+/** Cap on a held partial escape sequence. Beyond this it was never a real one,
+ *  so it is dropped rather than swallowing the rest of the stream. */
+/** Whether an `<A>` may open `href`. The game chooses the address, so only
+ *  web and mail schemes reach the opener, as other schemes (`file:`, a
+ *  program's own like `steam:`, `javascript:`) can launch local programs or run
+ *  in this page; a scheme-less address opens nothing
+ *  (TMxpLinkTagHandler::actionFor). */
+export declare function mxpLinkOpens(href: string): boolean;
+/** The address an `<A>` to `href` opens, or `""` when it opens nothing (see
+ *  {@link mxpLinkOpens}). A mail address keeps only its recipients and its
+ *  `subject` and `body` fields: mail clients attach the local files an
+ *  `attach`/`attachment` field names, and the game chose them. The fragment
+ *  goes with the rest, so `#?attachment=` cannot smuggle one past the check
+ *  (TMxpLinkTagHandler::openableAddress). */
+export declare function mxpOpenableAddress(href: string): string;
 export declare class MxpParser {
     private readonly opts;
     private elements;
+    /** The custom elements whose definitions are running right now, innermost
+     *  last — TMxpCustomElementTagHandler's `mElementsBeingExpanded`. See
+     *  {@link mayExpand}. */
+    private readonly expanding;
     private entities;
     private lineMode;
+    /** Mudlet's mMXP_DEFAULT — the mode a newline returns to. Null is OPEN,
+     *  the initial default. */
     private lockedMode;
-    private tempSecure;
+    /** TMxpProcessor's mModeBeforeTempSecure: what an `ESC[4z` line goes back
+     *  to once its one tag is read. */
+    private modeBeforeTempSecure;
     private stack;
     /** Active MXP `<COLOR>`/`<FONT>` fg/bg overrides, innermost last. While
      *  non-empty, the top entry's colours are painted over whatever the ANSI
@@ -105,6 +133,20 @@ export declare class MxpParser {
     /** OSC 8 preset definitions seen this session (shared with the ANSI path
      *  when the engine supplies a registry). */
     private presets;
+    /** Set while Force MXP is on: a secure default then holds against a lock
+     *  to OPEN or LOCKED, the game's `ESC[5z`/`ESC[7z` and the open start a
+     *  switch-on asks for included — Mudlet's shouldLockModeToSecure. */
+    private forcedSecure;
+    /** Id of the newest link; ids are never reused, so a click on a link long
+     *  gone from the store still finds nothing rather than someone else's. */
+    private linkSeq;
+    /** The newest link and the Lua its click runs — what a custom element's
+     *  `mxp.<element>.actions` reports (TLinkStore::getCurrentLinks). Emptied
+     *  when an `<EXPIRE>` retires it. */
+    private currentLink;
+    /** Every link made with an `EXPIRE` name, oldest first: the name while it
+     *  is live, null once an `<EXPIRE>` has retired it. */
+    private expiringLinks;
     private fmt;
     private out;
     private run;
@@ -124,20 +166,45 @@ export declare class MxpParser {
         presets?: HyperlinkPresetRegistry;
         /** Fired whenever a server-defined custom element is used, with the
          *  tag's attributes resolved the way Mudlet resolves them (see
-         *  {@link elementEventAttrs}). Backs the Lua `mxp` table. */
-        onElementEvent?: (name: string, attrs: Record<string, string>) => void;
+         *  {@link elementEventAttrs}). Backs the Lua `mxp` table. `body` is
+         *  carried by the tags that wrap text and act on it — a `<SEND>` reports
+         *  the text it wrapped and the commands its click would run. */
+        onElementEvent?: (name: string, attrs: Record<string, string>, body?: {
+            text: string;
+            actions: string[];
+        }) => void;
+        /** Carry out a `<FRAME>` as it is read, answering whether it could be:
+         *  false leaves the tag in the line as text, which is what a game sees
+         *  when it names a frame that is not open or a name that is not a plain
+         *  word. Without this the commands are collected into the result for a
+         *  caller to run afterwards, which cannot report a refusal in time. */
+        onFrame?: (frame: MxpFrameCommand) => boolean;
+        /** Whether a frame of this name is open for a `<DEST>` to write into.
+         *  Text sent to one that is not stays where it was, in the main line
+         *  (Mudlet leaves it in the line it was building when the frame has no
+         *  sink). Without this every `<DEST>` is redirected and the caller
+         *  decides afterwards. */
+        hasFrame?: (name: string) => boolean;
         /** Columns the main window wraps at — how wide `<HR>` draws its rule.
          *  Mudlet's `TMxpClient::getWrapWidth`, whose own fallback is 80. */
         wrapWidth?: () => number;
     });
     /**
-     * Lock the parser to secure line mode (or release the lock). Mudlet does
-     * this whenever the MXP processor is forced on without an option-91
-     * handshake (ctelnet.cpp: MXP_MODE_CODE_LOCK_SECURE): such servers are
-     * IRE-style and never send mode switches, they just use secure tags — and
-     * without the lock every definition tag would be ignored as unsafe.
+     * Whether Force MXP is on — TMxpMudlet::shouldLockModeToSecure, read live.
+     * While it is, a secure default holds against any lock to OPEN or LOCKED,
+     * the game's `ESC[5z`/`7z` included. It changes no mode by itself: forcing
+     * the processor on is what locks it secure ({@link applyMode} with 6), and
+     * that secure default outlives the box being unticked.
      */
-    lockSecureMode(locked: boolean): void;
+    setForceLock(on: boolean): void;
+    /** Apply mode code `n` (TMxpProcessor::setMode) from the client's side:
+     *  6 when the processor is forced on or auto-enabled, 5 each time the game
+     *  switches MXP on, which starts it in open mode. */
+    applyMode(n: number): void;
+    /** Whether a link is still there to click: false once an `<EXPIRE>` has
+     *  retired the name it was made with (TLinkStore::expireLinks), when a
+     *  click on it runs nothing. */
+    isLinkLive(id: number): boolean;
     /** Clear all cross-line state. Called on (re)connect so a new session starts
      *  with no leftover definitions, open tags, or modes. */
     reset(): void;
@@ -152,16 +219,88 @@ export declare class MxpParser {
      *  mode that capture ended on, and the next real tag would be discarded as
      *  unsafe. */
     parseLine(rawLine: string, baseSnapshot?: FormatStateSnapshot, fromServer?: boolean): MxpLineResult;
+    /**
+     * The styling MXP tags still hold open: the colour of the innermost open
+     * `<COLOR>`/`<FONT>`, and bold, italic, underline and strikeout while a tag
+     * of that kind is open. Desktop keeps these in TMxpMudlet, apart from the
+     * ANSI pen, and TBuffer paints them on every character it writes — whether
+     * or not MXP is still on, so a game that turns MXP off with a tag left open
+     * goes on showing it until MXP is reset. Undefined when nothing is open.
+     */
+    openStyle(): FormatStateSnapshot | undefined;
     private effectiveMode;
     private resetTransientMode;
+    /** Take off the styling open tags put on — bold, italic, underline,
+     *  strikeout and colour — when the mode moves away from OPEN, the way
+     *  Mudlet's resetTextProperties drops its counters and colour stacks.
+     *  Links and variables are left running: that call does not touch them. */
+    private closeOpenModeTags;
+    /** Add text to the line. `markup` marks text that is markup put back —
+     *  a tag that could not be acted on, shown as what it was — which the
+     *  links open around it do not count as the text they wrap (Mudlet inserts
+     *  such a tag straight into the line, past the handlers' handleContent). */
     private appendText;
+    /** `CSI n C` (cursor forward): n spaces painted in the background colour,
+     *  as TBuffer writes them (see cursorForwardCount). They go straight into
+     *  the line, past any open link's content, the way Mudlet appends them to
+     *  mMudLine without the MXP handlers seeing them. */
+    private appendCursorForward;
     private flushRun;
     private parseFragment;
     private applyLineMode;
+    /** The style id a game named with `<VERSION styleId>`, stamped onto every
+     *  later VERSION answer. Nothing takes it back off — an empty attribute is
+     *  dropped by the parser before it gets here, so `<VERSION "">` is just a
+     *  bare VERSION — and it lasts as long as the session that set it. */
+    private mxpStyle;
     private closeAllTags;
+    /** `mapValue`, when given, is applied to every attribute once the tag has
+     *  been read — how a custom element's values reach the tags of its
+     *  definition. Filling them in before the read would let a value with a
+     *  quote in it end the attribute it was put in and write attributes of its
+     *  own. */
     private handleTag;
+    /** A tag the current line mode does not allow is shown to the player as
+     *  the text it literally is, brackets and all — Mudlet re-inserts the raw
+     *  tag content the same way (HANDLER_INSERT_ENTITY_SYS). Swallowing it
+     *  instead would hide half a game's output on an OPEN line and leave the
+     *  other half — the text the tag wrapped — with no explanation. */
+    private showAsText;
+    private isKnownTag;
+    /** Whether Mudlet would recognise a tag (its trimmed raw text) as MXP —
+     *  the definitions it lists in allMxpTags, or a known element, open or
+     *  closing. What it does not recognise it rejects as text before the
+     *  temp-secure mode is spent. */
+    private isRecognisedTag;
     private openAllowed;
     private handleOpenTag;
+    /** Hand a finished `<SEND>` to Lua the way Mudlet does: the `mxp.send`
+     *  table and an `mxp.send` event, carrying the tag's attributes, the text it
+     *  wrapped, and the Lua each of its commands would run — `send(…)`, or
+     *  `printCmdLine(…)` for a PROMPT, the command quoted by
+     *  {@link quoteLuaLiteral}. Queued on the closing tag because
+     *  until then the caption is not known, and the caption is what `&text;`
+     *  resolves to in every one of those (TMxpMudlet::setCaptionForSendEvent).
+     *
+     *  A script reads this to act on a link the game drew — to relabel it, to
+     *  run something of its own alongside it, or to count what a shop offered.
+     *  The command list is reported whole even where the click can only fire
+     *  the first of them. */
+    private reportSend;
+    /** `<SUPPORT>` asks what this client can do. Bare, it lists everything;
+     *  named, it answers about exactly what was asked, in the order it was asked
+     *  — `element` for the whole element and its attributes, `element.attribute`
+     *  for one of them, `element.*` for the whole element again, and a leading
+     *  minus for anything not here. A game reads this to decide which of its
+     *  markup to send, so answering about something we do not do would cost it
+     *  the fallback it has for clients that lack it. */
+    private answerSupport;
+    /** `<VERSION>` asks who this client is; `<VERSION styleId>` instead names a
+     *  style the game wants its answers stamped with from then on, and is not
+     *  answered at all. MXP=1.0 is the protocol version we speak; CLIENT and
+     *  VERSION are our own identity (see src/version.ts). Unquoted, as Mudlet
+     *  sends it — a game's parser may be no more than a split on spaces. */
+    private answerVersion;
     /** `<FRAME name [action] [internal|external|floating] [left|top|width|height]
      *  [scrolling] [title]>` — record a window create/close request for the
      *  consumer. NAME is the first positional or the NAME attribute; valueless
@@ -169,8 +308,10 @@ export declare class MxpParser {
     private handleFrameTag;
     /** `<DEST name [eol] [eof]>` — start redirecting enclosed text into `name`.
      *  NAME is the NAME attribute or the first non-flag positional. Persists
-     *  until `</DEST>` (or end of line). A nameless DEST is ignored so its text
-     *  renders inline, matching Mudlet (setMxpDestination fails → not handled). */
+     *  until `</DEST>` (or end of line). A nameless DEST is a tag Mudlet cannot
+     *  act on, and is shown as text; one naming a frame that is not open is
+     *  taken out, but its text stays in the line it was part of — Mudlet keeps
+     *  building the main line when the destination has no sink to flush to. */
     private handleDestTag;
     /** `<SOUND fname [V=vol] [L=loops] [P=priority] [T=type] [U=url]>` and
      *  `<MUSIC fname [V=vol] [L=loops] [C=continue] [T=type] [U=url]>` — MXP's
@@ -185,14 +326,52 @@ export declare class MxpParser {
     private openFormat;
     private openColor;
     private openLink;
+    /** The Lua each of a link's commands runs, `&text;` filled with `text`
+     *  before the command is quoted, so nothing the game wrote in either can
+     *  end the string it is put in (TMxpSendTagHandler::actionFor). */
+    private linkActions;
+    /** Record a new link as the newest — TLinkStore::addLinks. */
+    private storeLink;
+    /** `<EXPIRE name>`: the links made with that name stop working, and if the
+     *  newest is one of them there is no newest link left to report
+     *  (TLinkStore::expireLinks removes them from the store outright). */
+    private expireLinks;
+    /** Replace `&name;` with the game's entity of that name, or a built-in
+     *  one; anything that names neither is left as it was (TEntityResolver's
+     *  interpolate) — which is what keeps `&text;` for the close to fill. */
+    private interpolateEntities;
     private openVar;
     private handleCloseTag;
+    /** TMxpCustomElementTagHandler::mayExpand: a game can define an element
+     *  that expands to itself, directly or through other elements, or a chain
+     *  of elements long enough to exhaust the stack. An element already being
+     *  expanded, or one past {@link MAX_ELEMENT_EXPANSION_DEPTH} of them, is
+     *  handled without running its definition. */
+    private mayExpand;
     private finalizeTag;
+    /** A `<!…>` definition. False when it is not one Mudlet can act on — an
+     *  element with nothing after its name, an entity with no name — which is
+     *  then shown as the text it is. */
     private handleDefinition;
     private defineElement;
     private defineEntity;
     private expandElement;
-    private substituteTemplate;
+    /** `&att;` → the value the tag gave that attribute, by name or by the
+     *  position the definition declared it at, else its default; anything else
+     *  is left alone for the entity pass (TMxpCustomElementTagHandler's
+     *  mapAttributes). */
+    private elementValues;
+    /** Run a definition's markup. Its tags are read first and filled in after,
+     *  attribute by attribute, so a value cannot rewrite the tag it lands in:
+     *  a quote in it stays in the value. The text between them is filled in
+     *  and read as the game's own. Per the MXP spec a definition holds only
+     *  opening tags, so a closing tag in one is skipped, as
+     *  TMxpCustomElementTagHandler::handleStartTag skips it — `'<B>x</B>'`
+     *  leaves its element bold until the element itself is closed. */
+    private runTemplate;
+    /** What `&ent;` stands for, or null when it names nothing. A game's
+     *  entities are kept under their lowercased names, as Mudlet's
+     *  registerEntity keeps them. */
     private decodeEntity;
 }
 /** Split a parsed MXP line into one entry per *visual* line. MXP `<BR>` tags