@mudlet/mudlet-web 0.5.0 → 1.0.1

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

@@ -7,26 +7,33 @@
  */
 /**
  * Map a wire-format charset name (case-insensitive, with various dash/underscore
- * spellings) onto an IANA label that `TextDecoder` accepts. Returns null for
- * encodings we don't support — most legacy MUD codepages aren't reachable from
- * the browser TextDecoder API and would need a polyfill not worth shipping.
+ * spellings) onto the label Mudlet Web decodes it with, or null when it is not an
+ * encoding this client speaks.
  *
- * Coverage is deliberately narrow: UTF-8 (the universal modern answer), the
- * Latin-N family, the Cyrillic KOI8 variants, and the Windows-125x codepages.
- * That covers every Polish, Russian, and Western European MUD seen in practice.
+ * The label is not always an IANA one, because not every encoding here is the
+ * browser's to decode. Three kinds come out:
+ *
+ *  - a lowercase TextDecoder label (`utf-8`, `iso-8859-2`, `windows-1250`,
+ *    `gbk`) for the encodings the browser knows;
+ *  - an uppercase code-page name (`CP437`, `MEDIEVIA`) for the ones it does not,
+ *    which are decoded from the tables in codePages.ts;
+ *  - `ascii`, which is neither — it is a decoder of its own, since the browser
+ *    reads that label as windows-1252.
+ *
+ * Downstream tells them apart by the label, so the casing carries meaning.
  */
 export declare function normalizeCharsetName(raw: string): string | null;
-/** Wire-format names of every charset mudix can decode, surfaced to Lua scripts
- *  via `getServerEncodingsList()`. Every entry round-trips through
- *  {@link normalizeCharsetName}, so any name here is a valid `setServerEncoding`
- *  argument. ("ASCII" maps to the UTF-8 decoder, which handles it byte-for-byte.) */
 /** What `getServerEncoding()` reports before anything has changed it. UTF-8
- *  rather than Mudlet's ASCII: the decoder handles ASCII byte-for-byte anyway,
- *  and a browser stream is far more likely to be UTF-8 than not. */
+ *  rather than Mudlet's ASCII: a browser stream is far more likely to be UTF-8
+ *  than not, and ASCII text reads identically either way. */
 export declare const DEFAULT_SERVER_ENCODING = "UTF-8";
 export declare const SUPPORTED_SERVER_ENCODINGS: readonly string[];
+/** A profile's saved `serverEncoding`, with any name only an older Mudlet Web
+ *  wrote brought up to the one it meant. */
+export declare function savedServerEncoding(saved: string): string;
+export declare function savedServerEncoding(saved: string | undefined): string | undefined;
 /** The {@link SUPPORTED_SERVER_ENCODINGS} entry a caller's spelling means, or
- *  null when mudix cannot decode it. Dash/space/case differences are all the
+ *  null when Mudlet Web cannot decode it. Dash/space/case differences are all the
  *  same encoding — the profile XML, the wire, and Mudlet's own list disagree
  *  about which to use — so the answer is always the list's own spelling and
  *  `getServerEncoding()` reports one canonical name whatever was set. */
@@ -36,65 +43,129 @@ export declare function canonicalServerEncoding(raw: string): string | null;
  * `serverEncoding` — Mudlet's TEncodingHelper::canEncode, which is what decides
  * whether a send gets the "unlikely to understand it" warning.
  *
- * Anything mudix cannot judge (an unknown label) is called encodable: the point
+ * Anything Mudlet Web cannot judge (an unknown label) is called encodable: the point
  * is to warn about a loss that will certainly happen, not to guess.
  */
 export declare function canEncodeForServer(text: string, serverEncoding: string): boolean;
+/**
+ * Decode a byte-string that is already in the game's encoding into text, the
+ * way the inbound stream would have decoded it. This is the one-shot form of
+ * {@link SessionCodec.decode} for callers holding a complete payload rather
+ * than a socket frame — `feedTriggers(data, false)`, where the caller says the
+ * bytes are pre-encoded and Mudlet must pass them through untouched rather than
+ * reading them as UTF-8.
+ *
+ * An encoding Mudlet Web cannot name falls back to UTF-8, which is what the session
+ * starts on; a label the browser refuses hands the bytes back unchanged rather
+ * than losing them.
+ */
+export declare function decodeForServer(byteString: string, serverEncoding: string): string;
 /**
  * Parse an `IAC SB CHARSET REQUEST ...` subnegotiation body (leading byte is
- * the option code 42, then subcommand byte 1, then optional `[TTABLE]<ver>`
- * prefix, then a separator byte, then separator-delimited IANA names). Returns
- * the best match against {@link CHARSET_PRIORITY} with both the original wire
- * spelling (echoed back in the ACCEPTED reply per RFC 2066) and the normalized
- * IANA label suitable for `new TextDecoder(...)`. Returns null if no offered
- * name is supported.
+ * the option code 42, then subcommand byte 1, then a separator byte, then
+ * separator-delimited IANA names). Returns
+ * the one to switch to with both the original wire spelling (echoed back in
+ * the ACCEPTED reply per RFC 2066) and this client's canonical name for it,
+ * which is what `getServerEncoding()` then reports. Returns null if no offered
+ * name is one we can decode.
  */
-export declare function pickCharsetFromRequest(subneg: string): {
+export declare function pickCharsetFromRequest(subneg: string, current?: string): {
     original: string;
-    normalized: string;
+    canonical: string;
 } | null;
 /**
- * The session's byte→char codec. Owns the streaming inbound `TextDecoder`
- * (holding trailing partial multi-byte chars across WebSocket frames) and the
+ * The session's byte→char codec. Owns the streaming inbound decoder (holding
+ * trailing partial multi-byte chars across WebSocket frames) and the
  * matching outgoing encoding. Starts at UTF-8 — correct for ASCII and modern
  * MUDs — and switches when a CHARSET exchange (or an explicit
  * `setServerEncoding`) agrees on something else.
  */
 export declare class SessionCodec {
+    /** The browser's decoder, for a label none of the paths below covers.
+     *  Null for UTF-8, which is decoded by TBuffer's rule (decodeUtf8Stream). */
     private decoder;
+    /** Set instead of {@link decoder} while a single-byte encoding is in use. */
+    private table;
+    /** Set instead of both while an encoding Mudlet Web frames itself is in use. */
+    private framed;
+    /** Bytes of a UTF-8 or framed sequence cut short by the end of a frame,
+     *  waiting for the rest of it. */
+    private pendingBytes;
     private currentEncoding;
+    /** The encoder for outgoing text while a multi-byte encoding is in use. */
+    private outgoingMultiByte;
+    /** What the next decode starts with: the replacement mark for a sequence
+     *  an encoding change cut short (see {@link trySetEncoding}). */
+    private owed;
+    /** Called just before the encoding actually changes, while the old one is
+     *  still in place — cTelnet's postHeldDataBeforeEncodingChange, which
+     *  posts the text ahead of the change in the same read under the encoding
+     *  it was sent in. */
+    onBeforeEncodingChange: (() => void) | null;
     /** The IANA name of the decoder currently applied to the inbound stream. */
     get encoding(): string;
     /** Back to the UTF-8 baseline with a fresh decoder (call on connect). */
     reset(): void;
+    /** About to decode with `encoding`. When that is a change, the text ahead
+     *  of it is posted first, and the bytes of a sequence still waiting for
+     *  the rest of it are dropped for one replacement mark at the head of the
+     *  next text: they were sent in the old encoding and cannot be paired with
+     *  a byte read in the new one (TBuffer::translateToPlainText, on seeing
+     *  the encoding differ). A colour change held behind a lead byte is not
+     *  part of the character and is kept. */
+    private beforeSwitch;
     /** Swap the streaming decoder to a new encoding label (an IANA name the
-     *  TextDecoder constructor accepts: 'utf-8', 'iso-8859-2', ...). Any partial
-     *  multi-byte sequence buffered in the previous decoder is discarded —
-     *  fine because CHARSET typically negotiates before any real content
-     *  arrives. Returns false (leaving the current decoder untouched) when the
-     *  browser refuses the label. */
-    trySetEncoding(encoding: string): boolean;
+     *  TextDecoder constructor accepts: 'utf-8', 'iso-8859-2', ...). A partial
+     *  multi-byte sequence buffered under the previous encoding becomes one
+     *  replacement mark (see {@link beforeSwitch}). Returns false (leaving the
+     *  current decoder untouched) when the browser refuses the label. `name` is the encoding's own name where it
+     *  says more than the label does — BIG5-HKSCS, which decodes as big5 but
+     *  encodes differently. */
+    trySetEncoding(encoding: string, name?: string): boolean;
     /** Converts a Latin-1 byte-string into decoded text under the current
      *  encoding, buffering any trailing partial multi-byte sequence for the
-     *  next frame. */
-    decode(byteString: string): string;
+     *  next frame — unless `final`, for text that ends a prompt: Mudlet's
+     *  cTelnet::gotPrompt ends a prompt with a byte of its own, which cannot
+     *  continue a sequence either, so a sequence the prompt cut short earns its
+     *  replacement mark there and the next line starts afresh. */
+    decode(byteString: string, final?: boolean): string;
+    private decodeStream;
+    /** Decode an out-of-band body (an MSSP or MSDP subnegotiation payload)
+     *  under the current encoding. Separate from {@link decode} because that
+     *  one streams: it holds a trailing partial sequence back for the next
+     *  frame, and a subnegotiation is a whole message that must neither leave
+     *  bytes behind in the display path nor take any from it. Mudlet decodes
+     *  these through the same encoding tables (`decodeBytes`), which is what
+     *  makes an MSSP value readable on a game running CP437. Under ASCII, which
+     *  Mudlet holds as no encoding at all, it reads them as UTF-8 instead
+     *  (cTelnet::setMSSPVariables' "though this can handle Utf-8" branch), so a
+     *  game that sends UTF-8 there anyway still gets its text through. */
+    decodeOutOfBand(byteString: string): string;
+    /** Encode an out-of-band value (`sendMSDP`'s names and values) under the
+     *  current encoding — the outgoing half of {@link decodeOutOfBand}, and like
+     *  it UTF-8 under ASCII. Desktop encodes these through the game's encoding
+     *  as it does a `send`, so a GBK game gets GBK bytes rather than UTF-8. */
+    encodeOutOfBand(text: string): string;
     /** Convert a user-typed JS string (UTF-16) into the Latin-1 byte-string the
      *  socket layer expects, using the currently negotiated outgoing encoding.
-     *  UTF-8 goes through TextEncoder so multi-byte chars survive; every other
-     *  encoding here is single-byte and goes through the inverted decode table,
-     *  which puts the codepage's own byte on the wire. (A plain `& 0xff`
+     *  UTF-8 goes through TextEncoder so multi-byte chars survive; the East
+     *  Asian multi-byte encodings go through the tables in multiByteEncode.ts;
+     *  every other encoding here is single-byte and goes through the inverted
+     *  decode table, which puts the codepage's own byte on the wire. (A plain `& 0xff`
      *  truncation used to stand in for that, and was right only for the
      *  Latin-1 range — every Polish, Cyrillic, or Greek character above it went
      *  out as a byte meaning something else entirely.) A character the codepage
-     *  has no byte for becomes '?', as Qt's encoder does it — and the send path
-     *  warns before it comes to that. */
+     *  has no byte for becomes what desktop writes for one ({@link substitute})
+     *  — and the send path warns before it comes to that. */
     encodeOutgoing(text: string): string;
 }
 export interface CharsetHandlerHooks {
     sendRaw(data: string): void;
     /** Fired when an encoding switch takes effect. The argument is the
-     *  wire-spelling name (e.g. "UTF-8") so listeners can surface it. */
-    onNegotiated(displayName: string): void;
+     *  wire-spelling name (e.g. "UTF-8") so listeners can surface it;
+     *  `acceptedRequest` says the switch is this client ACCEPTing a server's
+     *  REQUEST rather than anything else. */
+    onNegotiated(displayName: string, acceptedRequest: boolean): void;
 }
 /**
  * Drives the CHARSET REQUEST/ACCEPTED/REJECTED exchange against a
@@ -107,17 +178,11 @@ export declare class CharsetHandler {
     private readonly enabled;
     private readonly hooks;
     constructor(codec: SessionCodec, enabled: boolean, hooks: CharsetHandlerHooks);
-    /** Send `IAC SB CHARSET REQUEST ;UTF-8;ISO-8859-2;ISO-8859-1 IAC SE` —
-     *  advertising the encodings we can decode, in preference order. Each name
-     *  is prefixed by the separator (`;`) per RFC 2066 (the separator comes
-     *  before each charset, not between them). The server replies ACCEPTED
-     *  <name> or REJECTED; handleSubneg() processes either. */
-    sendRequest(): void;
     /** Route an `IAC SB CHARSET ... IAC SE` subnegotiation body (leading byte
      *  is the option code, 42). Handles REQUEST (server lists charsets, we
      *  ACCEPT one or REJECT), ACCEPTED (server picked one of ours — switch
      *  codec), and REJECTED (server didn't like any of ours — stay put).
-     *  TTABLE-* subcommands are silently ignored; almost no MUD uses them. */
+     *  TTABLE-IS (a translation table) gets TTABLE-REJECTED, as in Mudlet. */
     handleSubneg(subneg: string): void;
     /** Mudlet `setServerEncoding(name)`. Switch the inbound decoder to `name`
      *  (any value from getServerEncodingsList()). Returns false — leaving the

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

@@ -0,0 +1,10 @@
+/**
+ * The 0x80-0xFF half of `name` as characters, or null when it is not one of the
+ * pages carried here. Names are matched exactly as {@link CODE_PAGES} spells
+ * them (upper case), or as the decoder labels {@link QT_CODE_PAGES} is keyed by
+ * (lower case) for the pages desktop reads through Qt rather than its own
+ * tables — every other single-byte encoding Mudlet Web speaks.
+ */
+export declare function codePageUpperHalf(name: string): readonly string[] | null;
+/** Every code page this module carries, in the spelling Mudlet uses. */
+export declare const VENDORED_CODE_PAGES: readonly string[];

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

@@ -1,5 +1,4 @@
 export declare const TELNET_OPTION_REGEX: RegExp;
-export declare const TELNET_OPTION_REGEX_NO_SB: RegExp;
 export declare const TELNET_GA = "\u00FF\u00F9";
 export declare const TELNET_EOR = "\u00FF\u00EF";
 export declare const TELOPT_EOR = "\u0019";
@@ -84,23 +83,29 @@ export declare const MTTS_MNES = 512;
 export declare const MTTS_MSLP = 1024;
 export declare const MTTS_SSL = 2048;
 /** Live capabilities that toggle the dynamic MTTS bits. The static bits (ANSI,
- *  256 colours, OSC colour palette, truecolour) are always on. */
+ *  256 colours, OSC colour palette, truecolour, SSL) are always on. */
 export interface MttsCapabilities {
     /** UTF-8 is the active encoding (sets the UTF-8 bit). */
     utf8?: boolean;
-    /** The game-facing transport is TLS-encrypted (sets the SSL bit). */
-    tls?: boolean;
-    /** MNES is negotiated (sets the MNES bit). */
+    /** MNES is on — Mudlet sets the bit when the profile has both MNES and
+     *  NEW-ENVIRON enabled, negotiated or not (sets the MNES bit). */
     mnes?: boolean;
     /** A screen reader is being advertised (sets the SCREEN READER bit). */
     screenReader?: boolean;
 }
 /**
- * Compose the MTTS bitvector mudix advertises. Mirrors Mudlet's
- * `getNewEnvironMTTS`: ANSI + 256 COLORS + OSC COLOR PALETTE + TRUECOLOR are
- * always present (mudix's static terminal capabilities); UTF-8, SSL/TLS, MNES
- * and SCREEN READER are added from live state. With UTF-8 + TLS this yields
- * 2349, matching a default Mudlet connection.
+ * Compose the MTTS bitvector Mudlet Web advertises. Mirrors Mudlet's
+ * `getNewEnvironMTTS`: ANSI + 256 COLORS + OSC COLOR PALETTE + TRUECOLOR + SSL
+ * are always present; UTF-8, MNES and SCREEN READER are added from live state.
+ * With UTF-8 this yields 2349, matching a default Mudlet connection.
+ *
+ * SSL is a capability ("client supports SSL for data transmission"), not a
+ * report on the current link: Mudlet sets it whenever it was built with SSL,
+ * encrypted connection or not, and a server reads it as "this client could use
+ * the TLS port". Mudlet Web can — over `wss://` in websocket mode, and through
+ * the proxy's TLS leg to the game (`&tls=1`) in proxy mode — so it is always
+ * set. Whether the browser↔proxy hop happens to be `wss://` says nothing about
+ * the game link either way, and is deliberately not consulted.
  */
 export declare function computeMtts(caps?: MttsCapabilities): number;
 export declare const NAWS_COMMAND_CODE = 31;
@@ -113,5 +118,7 @@ export declare const OPT_CHARSET = "*";
 export declare const CHARSET_REQUEST = "\u0001";
 export declare const CHARSET_ACCEPTED = "\u0002";
 export declare const CHARSET_REJECTED = "\u0003";
+export declare const CHARSET_TTABLE_IS = "\u0004";
+export declare const CHARSET_TTABLE_REJECTED = "\u0005";
 export declare const CHARSET_WILL = "\u00FF\u00FB*";
 export declare const CHARSET_DO = "\u00FF\u00FD*";

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

@@ -1,27 +1,10 @@
 export declare class EchoHandler {
-    /** Committed (debounced) state exposed to UI / send-echo logic. True
-     *  whenever the server is echoing for us, which means we must suppress our
-     *  own local command echo to avoid showing every line twice. This is *not*
-     *  the same as password masking — see `_passwordStyle` / `passwordMode`. */
+    /** State exposed to UI / send-echo logic, committed on the negotiation
+     *  itself as cTelnet does. True whenever the server is echoing for us, which
+     *  means we must suppress our own local command echo to avoid showing every
+     *  line twice — and, since a server that echoes for us is a server we must
+     *  not echo a password for, it is also when the input is masked. */
     private _serverEchoing;
-    /** Latest raw on-the-wire state. Used to gate ack dedup and decide whether
-     *  to schedule a commit. */
-    private _rawEchoing;
-    /** Whether the *current* ECHO engagement should mask the input line. A
-     *  server that enables ECHO during the opening negotiation burst — before
-     *  it has printed any output — is doing session-wide remote echo (it will
-     *  echo your name, commands, everything), not requesting a password. The
-     *  classic Diku/ROM password pattern instead toggles `IAC WILL ECHO` on
-     *  *after* the name prompt, right before "Password:". So we only treat an
-     *  ECHO that engages after the server has already sent output as a password
-     *  prompt. Captured at each OFF→ON transition. Mudlet masks on every ECHO;
-     *  doing so here would hide the name on full-server-echo MUDs, which is the
-     *  bug this distinction fixes. */
-    private _passwordStyle;
-    /** Set once the server has emitted any non-telnet output. Distinguishes a
-     *  connect-time (server-wide) ECHO from a later (password) ECHO. */
-    private sawAppData;
-    private stabilityTimer;
     private passwordSafetyTimer;
     private connectionStartAt;
     private toggleCount;
@@ -32,10 +15,23 @@ export declare class EchoHandler {
     private readonly onAnomalyDetected;
     constructor(sendRaw: (data: string) => void, onEchoChange: (maskInput: boolean) => void, onAnomalyDetected?: () => void);
     get serverEchoing(): boolean;
-    /** Whether the command input should be masked (password mode). Only true
-     *  for an ECHO engagement that began after the server started sending
-     *  output — a genuine password prompt — never for connect-time server-wide
-     *  echo. */
+    /**
+     * Whether the command input should be masked. Any ECHO the server takes,
+     * which is what cTelnet does — setRemoteEchoingActive(true) on WILL ECHO,
+     * with nothing else consulted.
+     *
+     * Mudlet Web used to mask only for an ECHO that engaged AFTER the server had
+     * printed something, on the reading that a connect-time one is session-wide
+     * remote echo rather than a password prompt, and that masking it would hide
+     * the player's name as they typed it. Nothing was ever recorded as running
+     * into that: the commit carrying the distinction does not mention echo at
+     * all, and the one MUD named anywhere near this file is cited for two other
+     * problems. Meanwhile the reading has a worse failure of its own — a server
+     * that negotiates ECHO in its opening burst and then asks for a password
+     * gets no masking at all, which is the error that matters. So: Mudlet's
+     * rule, and if a MUD does turn up that needs the distinction it comes back
+     * with a name attached.
+     */
     get passwordMode(): boolean;
     get anomalyDetected(): boolean;
     /** Scan the post-MCCP byte stream for true `IAC WILL/WONT ECHO`. Substring
@@ -56,7 +52,7 @@ export declare class EchoHandler {
      *  this call (the caller should bail out). */
     private trackToggleAndDetectAnomaly;
     /** Refuse ECHO for the rest of the session: send `IAC DONT ECHO`, drop any
-     *  pending commit / safety timers, force the UI back to normal, and notify
+     *  the safety timer, force the UI back to normal, and notify
      *  the engine so a `sysEchoAnomalyDetected` Lua event can fire. */
     private tripAnomaly;
     reset(): void;

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

@@ -13,7 +13,38 @@ export declare const createTelnetOptionParser: (onSubnegotiation: (data: string)
      *  subnegotiation payload is never mistaken for one. */
     promptMarkerAsNewline?: boolean;
 }) => TelnetOptionHandler;
-export declare const stripTelnetSequences: (data: string, handler: TelnetOptionHandler) => string;
+/**
+ * Consume every complete telnet sequence in `data`, replacing each with what
+ * `handler` returns, and return the text that is left.
+ *
+ * A single forward scan with the same semantics as TELNET_OPTION_REGEX
+ * (`IAC SB … IAC SE` up to the first IAC SE, else `IAC WILL/WONT/DO/DONT x`,
+ * else `IAC x`), so `handler` sees exactly the sequences the regex matched.
+ * It replaced the regex because the lazy SB branch rescans to end-of-buffer
+ * from every IAC SB whose terminator never comes — quadratic on a run of
+ * IAC SB from a hostile server. Here the terminator search runs once: when it
+ * fails, no later IAC SB can find one either, so it is not repeated; when it
+ * succeeds, the scan resumes past it.
+ *
+ * Unfinished sequences, as the regex left them: a lone trailing IAC is
+ * dropped, `IAC WILL` at the very end is consumed as a two-byte command, and
+ * so is an `IAC SB` with no IAC SE after it. (MudClient holds a sequence split
+ * across frames back for the next one before calling this — `scanTelnetFrame`.)
+ *
+ * A NUL goes too. cTelnet::processSocketData drops `\0` from the text stream
+ * outside a subnegotiation (it is the padding half of telnet's `CR NUL`), so
+ * it never reaches the buffer; kept, it cut `line`, getCurrentLine() and
+ * getLines() short at the NUL and shifted every position after it
+ * (mudlet-web#272). Subnegotiation payloads go to `handler` intact, so a NUL
+ * inside one is untouched.
+ */
+export interface TextAheadSlot {
+    /** While `handler` runs, hands over the text stripped so far — the text
+     *  ahead of the sequence being handled — and drops it from what the strip
+     *  returns; null otherwise. */
+    take: (() => string) | null;
+}
+export declare const stripTelnetSequences: (data: string, handler: TelnetOptionHandler, textAhead?: TextAheadSlot) => string;
 export declare const encodeGmcp: (path: string, payload: unknown) => string;
 /** Encode a GMCP frame from a single pre-formatted body (e.g. `"Module.Sub args"`).
  *  Mudlet's `sendGMCP` semantics — the caller controls the body between IAC SB
@@ -32,9 +63,10 @@ export declare const encodeGmcp: (path: string, payload: unknown) => string;
  *  `%XX` armoring the VFS io path uses. */
 export declare const encodeGmcpRaw: (message: string) => string;
 export interface GmcpStreamOptions {
+    /** Every message that reaches the `gmcp` table — `gmcp_msgs` included,
+     *  which Mudlet treats as an ordinary package rather than decoding and
+     *  printing its base64 `text` (mudlet-web#362). */
     onEnvelope: (payload: GmcpEnvelope) => void;
-    /** Called for gmcp_msgs subnegotiations (base64-encoded text with a type field). */
-    onMessage?: (text: string, type: string) => void;
     /** Called for every `Client.GUI` request, in whichever wire format it
      *  arrived: the parsed `{url, version}` object, or the legacy raw
      *  `<version>\n<url>` string. Split out from `onEnvelope` so the install has
@@ -43,7 +75,5 @@ export interface GmcpStreamOptions {
      *  table-populating path. The JSON form still emits its envelope as well,
      *  and does so first, so scripts observe it before the install runs. */
     onClientGui?: (payload: unknown) => void;
-    /** Text decoder used for gmcp_msgs payloads. Defaults to UTF-8. */
-    textEncoding?: string;
 }
-export declare const createGmcpStream: ({ onEnvelope, onMessage, onClientGui, textEncoding, }: GmcpStreamOptions) => (data: string) => void;
+export declare const createGmcpStream: ({ onEnvelope, onClientGui, }: GmcpStreamOptions) => (data: string) => void;

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

@@ -4,9 +4,10 @@ export * from "./msdp";
 export * from "./mssp";
 export { toByteString } from "./byteString";
 export { MccpHandler } from "./mccp";
+export { parseAtcpMessage, type AtcpMessage } from "./atcp";
 export { EchoHandler } from "./echo";
 export { MspParser, type MspCommand, type MspKind } from "./msp";
 export { MxpParser, splitMxpResultLines, type MxpLink, type MxpLineResult } from "./mxp";
-export { parseMnesRequest, encodeMnesIs, selectMnesVars, MNES_UNMAINTAINED, buildNewEnvironVars, CLIENT_NAME, CLIENT_VERSION, TERMINAL_TYPE, type MnesVar, type MnesRequest, type NewEnvironState } from "./mnes";
+export { encodeMnesIs, newEnvironIsReply, mnesIsReplies, MNES_VARIABLES, buildNewEnvironVars, CLIENT_NAME, CLIENT_VERSION, TERMINAL_TYPE, type MnesVar, type NewEnvironState } from "./mnes";
 export { encodeNaws } from "./naws";
-export { SessionCodec, CharsetHandler, normalizeCharsetName, pickCharsetFromRequest, SUPPORTED_SERVER_ENCODINGS, DEFAULT_SERVER_ENCODING, canonicalServerEncoding, canEncodeForServer, type CharsetHandlerHooks } from "./charset";
+export { SessionCodec, CharsetHandler, normalizeCharsetName, pickCharsetFromRequest, SUPPORTED_SERVER_ENCODINGS, DEFAULT_SERVER_ENCODING, canonicalServerEncoding, savedServerEncoding, canEncodeForServer, type CharsetHandlerHooks } from "./charset";

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

@@ -0,0 +1,12 @@
+/**
+ * Escalate the bracket level until the text can do none of three things:
+ * close the literal outright; reopen it, which Lua 5.1 rejects under its
+ * deprecated-nesting rule; or merge with the closing bracket appended after it
+ * (text ending in `]` plus this level's `=` run is completed into a closer by
+ * the first character of the real one). Terminates because none of the three
+ * fits in text shorter than the `=` run it needs.
+ *
+ * Lua drops a newline straight after the opening bracket, so the one added
+ * costs nothing and lets text that starts with a newline survive.
+ */
+export declare function quoteLuaLiteral(text: string): string;

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

@@ -1,9 +1,44 @@
+/** A desktop `postMessage()` the handler asks its owner to show, in desktop's
+ *  words. `text` may hold a `\n`: the lines after it are the notice's
+ *  indented continuation. */
+export interface MccpNotice {
+    notice: string;
+}
+/** One piece of a read, in stream order: text for the telnet pipeline, or a
+ *  notice to post where it falls between the texts. */
+export type MccpPiece = string | MccpNotice;
 export declare class MccpHandler {
     private compressing;
+    /** We answered the server's `WILL COMPRESS` with DO — Mudlet's
+     *  `mMCCP_version_1`. Only then is a v1 start sequence honoured. */
+    private v1Accepted;
+    /** We answered `WILL COMPRESS2` with DO — Mudlet's `mMCCP_version_2`. Only
+     *  then is a v2 start sequence honoured, and after it Mudlet turns a v1
+     *  offer down, as the MCCP spec asks. */
+    private v2Accepted;
+    /** The option of the stream in progress — Mudlet's `mCompressionOption`. */
+    private streamOption;
     private inflator;
+    private phase;
+    /** The zlib header (CMF, FLG and an optional DICTID) read so far. */
+    private header;
+    /** The Adler-32 trailer read so far. */
+    private trailer;
+    /** Running Adler-32 of the inflated output, checked against the trailer. */
+    private adlerA;
+    private adlerB;
+    /** Bytes the stream has inflated to — zlib's `total_out`. */
+    private totalOut;
+    /** cTelnet's `mUninflatedInput` / `mUninflatedInputComplete`: every byte
+     *  the stream took while it had produced nothing, from earlier reads. */
+    private uninflated;
+    private uninflatedComplete;
     private readonly sendRaw;
+    private readonly onStreamEnd;
     private _enabled;
-    constructor(sendRaw: (data: string) => void);
+    /** `onStreamEnd` runs when a stream finishes (Z_STREAM_END), where desktop
+     *  resets `hisOptionState` for both compression options. */
+    constructor(sendRaw: (data: string) => void, onStreamEnd?: () => void);
     isActive(): boolean;
     get enabled(): boolean;
     set enabled(value: boolean);
@@ -12,7 +47,54 @@ export declare class MccpHandler {
      * Must be called BEFORE stripTelnetSequences.
      */
     processData(data: string): string;
+    /**
+     * {@link processData}, but cut where compression starts and where it ends:
+     * the plain text before an MCCP start, the inflated text, and the plain
+     * text after the end of the stream come back as separate pieces, in order.
+     * Desktop processes each of them as a unit of its own (cTelnet calls
+     * gotRest on the plain part before it inflates the rest), so a caller that
+     * runs the pieces through the pipeline one at a time keeps a trigger on the
+     * last line of one part from seeing out-of-band data from the next. Never
+     * empty: a frame that yields no bytes still comes back as one empty piece.
+     * Notices are left out; {@link processPieces} keeps them.
+     */
+    processChunks(data: string): string[];
+    /** {@link processChunks} with desktop's MCCP warnings in their place
+     *  among the texts. Empty pieces are dropped, so this can be empty. */
+    processPieces(data: string): MccpPiece[];
+    private pieces;
+    /** Forget the connection: the stream and what was agreed for it. */
     reset(): void;
+    /** Act on the compression offers in `data`, in stream order, up to the
+     *  first start sequence of a version that is agreed to; return where that
+     *  starts, or -1.
+     *
+     *  Mudlet's answer to `WILL COMPRESS2` is DO; to `WILL COMPRESS` it is DO
+     *  too, unless v2 was taken up first (then DONT), and nothing for a repeat
+     *  of a v1 offer already accepted. `WONT` withdraws either. The negotiator
+     *  answers both for a profile with compression forced off; this never runs
+     *  then. */
+    private negotiate;
+    private endStream;
     private startCompression;
+    /** cTelnet::refuseCompressedStream: tell the game DONT for the version the
+     *  stream was using and stop taking its start sequence as one until it
+     *  offers that version again. */
+    private refuseStream;
+    /** cTelnet::decompressBuffer over one read, followed through to the plain
+     *  text after the end of the stream (or after a broken one). */
     private decompress;
+    /** cTelnet::processSocketData scans the output of a stream that ended in
+     *  this read (out_buffer, with mNeedDecompression already cleared) and
+     *  skips any start sequence it finds there whole rather than inflating
+     *  out_buffer back into itself (#10662): a server has no reason to nest a
+     *  stream in its own output. It has to go here, not to the telnet parser
+     *  downstream — MCCP1's start has no IAC before its SE, and would leave
+     *  that parser inside a subnegotiation swallowing the text after it. Only
+     *  the versions agreed to are recognised, as desktop's look-ahead is. */
+    private skipNestedStarts;
+    /** Feed deflate data to the inflater; report how much of it was used, and
+     *  whether the deflate stream ended or broke. Output goes to `output`. */
+    private inflateBody;
+    private updateAdler;
 }