@mudlet/mudlet-web 0.5.0 → 1.0.1

package/dist-lib/mud/connection/TelnetNegotiator.d.ts

@@ -1,5 +1,9 @@
 import type { EventBus } from "../../core/EventBus";
 import type { MudClientEvents } from "../events";
+/** Columns the timestamp gutter takes off the main console when it is shown —
+ *  the length of Mudlet's `TBuffer::smTimeStampFormat` ("hh:mm:ss.zzz "). Desktop
+ *  takes it off the NAWS width, so a game wraps to what is left beside it. */
+export declare const TIMESTAMP_GUTTER_COLUMNS = 13;
 export interface TelnetNegotiatorFlags {
     gmcpEnabled: boolean;
     mttsEnabled: boolean;
@@ -11,8 +15,6 @@ export interface TelnetNegotiatorFlags {
     mnesEnabled: boolean;
     newEnvironEnabled: boolean;
     nawsEnabled: boolean;
-    /** Whether the game-facing transport is TLS (MTTS SSL bit, NEW-ENVIRON TLS var). */
-    secureTransport: boolean;
     /** Whether to advertise screen-reader use (MTTS SCREEN READER bit,
      *  NEW-ENVIRON SCREEN_READER var) — Mudlet's `advertiseScreenReader` config
      *  key. Default false; some MUDs adjust their output (e.g. suppress ASCII
@@ -46,15 +48,20 @@ export interface TelnetNegotiatorFlags {
 }
 export interface TelnetNegotiatorHooks {
     sendRaw(data: string): void;
-    /** GMCP came up — send the Core.Hello / Core.Supports.Set handshake
-     *  (latched by the owner so a re-offer doesn't re-announce). */
+    /** The server offered GMCP (IAC WILL GMCP) — send the Core.Hello /
+     *  Core.Supports.Set handshake. Mudlet answers every offer with it,
+     *  re-offers included — a server that switched GMCP off and on again has
+     *  forgotten our modules. Not called for a server's IAC DO GMCP: Mudlet
+     *  answers that with WILL alone and announces nothing until the server's
+     *  own WILL (mudlet-web#362). */
     onGmcpNegotiated(): void;
-    /** CHARSET came up — kick off the client-driven REQUEST listing our
-     *  preferred encodings. */
-    onCharsetNegotiated(): void;
     /** Current inbound encoding (IANA label) — drives the MTTS UTF-8 bit and
      *  the MNES/NEW-ENVIRON CHARSET variable. */
     getEncoding(): string;
+    /** Whether MCCP may be taken up — false under `specialForceCompressionOff`.
+     *  The server's offer is otherwise MccpHandler's to accept; this only lets
+     *  the negotiator turn it down while that handler stands aside. */
+    isMccpEnabled(): boolean;
     /** The server's option-negotiation order matched KaVir's protocol snippet —
      *  it wants a version in our TTYPE reply. Fired at most once per connection;
      *  the owner turns `versionInTTYPE` on and redials. */
@@ -64,7 +71,7 @@ export interface TelnetNegotiatorHooks {
  * Telnet option negotiation for a MUD session. Owns the WILL/WONT/DO/DONT
  * response policy, the per-session negotiation latches (TTYPE cycle position,
  * MXP started, NAWS accepted), the Mudlet `addSupportedTelnetOption` registry,
- * and the `telnet.event` (sysTelnetEvent) surface for everything unrecognized.
+ * and the `telnet.event` (sysTelnetEvent) surface raised for every command.
  *
  * `processFrame` makes a single position-aware walk over each incoming frame's
  * IAC sequences — skipping subnegotiation payloads and escaped `IAC IAC` bytes
@@ -83,20 +90,14 @@ export declare class TelnetNegotiator {
      *  own response logic. Survives reconnects (matches the old client-field
      *  lifetime: the registry lives as long as the client instance). */
     private readonly supportedTelnetOptions;
-    /** Per-incoming-frame dedupe. Keys below 0x100 mark a natively-handled
-     *  option as already answered this frame (mirroring the old one-response-
-     *  per-frame `includes()` behavior); keys `(cmd << 8) | opt` mark a
-     *  `telnet.event` as already raised. Telnet sequences can repeat across
-     *  frames, so we only suppress duplicates within a single frame to avoid
-     *  event storms. */
-    private readonly frameSeen;
     /** Trailing bytes of a frame that might be the start of a split IAC
      *  sequence (a bare IAC, IAC WILL with no option byte yet, or an IAC SB
      *  whose IAC SE hasn't arrived) — prepended to the next frame so
      *  negotiation commands split across WebSocket frames aren't missed. */
     private carry;
-    /** MTTS cycle position. The server issues SB TTYPE SEND repeatedly; we walk
-     *  through client name (0), terminal type (1), then the MTTS bitvector (2+).
+    /** MTTS cycle position — Mudlet's `mCycleCountMTTS`. The server issues SB
+     *  TTYPE SEND repeatedly; we walk through client name (0), terminal type
+     *  (1), the MTTS bitvector (2) and the bitvector again (3), then start over.
      *  Reset on each connect(). */
     private ttypeStep;
     /** Latches true once MXP has started for this session — via telnet option 91
@@ -105,6 +106,10 @@ export declare class TelnetNegotiator {
      *  telnet handshake, so the in-band signal is the reliable trigger. Reset on
      *  each connect(). */
     private mxpStarted;
+    /** cTelnet's `mMxpDetectionTail`: the last three bytes of the last read
+     *  scanned for a mode switch, so a switch the game's packets split is still
+     *  found once the rest arrives. A read that is not scanned clears it. */
+    private mxpDetectionTail;
     /** Rolling window of the last {@link KAVIR_NEGOTIATION_ORDER}`.length`
      *  options the server sent us a WILL/DO for, oldest first — Mudlet's
      *  `mNegotiationOrder`. Compared against the KaVir fingerprint after each
@@ -114,9 +119,6 @@ export declare class TelnetNegotiator {
      *  detector fires the hook at most once even though a server may keep
      *  re-offering options. */
     private kaVirDetected;
-    /** True once we've sent IAC WILL NAWS this session (proactively on connect,
-     *  or in response to a server-initiated IAC DO NAWS), so we don't re-offer. */
-    private nawsWillSent;
     /** True once the server has accepted NAWS (IAC DO NAWS). Gates whether a
      *  window-size change is pushed to the server. */
     private nawsNegotiated;
@@ -126,15 +128,43 @@ export declare class TelnetNegotiator {
      *  did. See {@link isMspNegotiated}. */
     private mspNegotiated;
     /** Latest known main output window size in character columns × rows, fed in
-     *  by the session's resize observer via setWindowSize(). Null until the UI
-     *  has measured the grid at least once. Deliberately NOT cleared by reset()
-     *  so a reconnect keeps reporting the current grid. */
+     *  by the session's resize observer via setWindowSize() — Mudlet's
+     *  `mScreenWidth` × `mScreenHeight`. Null until the UI has measured the grid
+     *  at least once. Deliberately NOT cleared by reset() so a reconnect keeps
+     *  reporting the current grid. */
     private windowSize;
+    /** The main console's wrap column — Mudlet's `Host::mWrapAt`; 0 means
+     *  wrapping is off. Caps the NAWS width and is reported as WORD_WRAP.
+     *  Survives reset() like the window size. */
+    private wrapAt;
+    /** Whether the main console draws its timestamp gutter, which desktop takes
+     *  off the NAWS width. */
+    private timestampsShown;
+    /** The NAWS width × height last sent this connection — Mudlet's `mNaws_x` /
+     *  `mNaws_y` — so a change that leaves the reported size alone sends nothing.
+     *  Null until the first report; cleared by reset() and by each DO NAWS. */
+    private lastNaws;
     /** Latches true once the server has asked us to suppress go-ahead (IAC WILL
-     *  SGA). mudix refuses SGA (line mode only), but records the request:
+     *  SGA). Mudlet Web refuses SGA (line mode only), but records the request:
      *  combined with active server echo it's the character-at-a-time signature
      *  the owner uses to raise `sysCharacterModeDetected`. Reset on connect(). */
     private serverRequestedSGA;
+    /** Option bytes currently negotiated on, for the protocols that carry a
+     *  sysProtocolEnabled / sysProtocolDisabled pair. Mudlet keeps one bool per
+     *  protocol (enableGMCP, enableMSSP, …) and reads it to decide whether
+     *  turning an offer down is news; this is that set. Cleared by reset() with
+     *  the rest of the per-connection latches.
+     *  @see PROTOCOL_NAMES */
+    private readonly enabledProtocols;
+    /** Mudlet's four per-option bitsets (`cTelnet::sendTelnetOption` keeps
+     *  them), which decide whether a WONT/DONT or a repeated offer is answered:
+     *  `hisOn` — we sent DO; `heAnnounced` — the server has sent WILL or WONT;
+     *  `myOn` — we sent WILL; `announced` — we have sent WILL or WONT. Cleared by
+     *  reset(). */
+    private readonly hisOn;
+    private readonly heAnnounced;
+    private readonly myOn;
+    private readonly announced;
     constructor(flags: TelnetNegotiatorFlags, eventBus: EventBus<MudClientEvents>, hooks: TelnetNegotiatorHooks);
     /** Clear the per-connection latches (call on connect). */
     reset(): void;
@@ -143,6 +173,29 @@ export declare class TelnetNegotiator {
      *  config (which only decides whether we agree to negotiate at all). Gates
      *  `receiveMSP`, which Mudlet refuses unless the option is live. */
     isMspNegotiated(): boolean;
+    /** Whether GMCP (option 201) is live — Mudlet's `isGMCPEnabled()`, which
+     *  `sendGMCP` refuses without: nothing goes to a server that has not taken
+     *  the option up. */
+    isGmcpEnabled(): boolean;
+    /** Whether ATCP (option 200) is live — Mudlet's `isATCPEnabled()`, the
+     *  gate `sendATCP` refuses without, as `sendGMCP` does for GMCP. */
+    isAtcpEnabled(): boolean;
+    /** Whether CHARSET (option 42) is live — Mudlet's `enableCHARSET`. A
+     *  REQUEST subnegotiation is read only while it is, so a server that has
+     *  withdrawn the option cannot go on changing the encoding. */
+    isCharsetNegotiated(): boolean;
+    /** Whether the server has taken zMUD channel 102 up this connection —
+     *  Mudlet's `isChannel102Enabled()`. It is the only gate on
+     *  `sendTelnetChannel102`: Mudlet frames and writes the subnegotiation
+     *  whether or not a socket is still there and answers true either way, so
+     *  a caller is told about the option rather than about the connection. */
+    isChannel102Enabled(): boolean;
+    /** Whether we have agreed to the server's side of `opt` (sent it DO) and
+     *  not since turned it off — Mudlet's `hisOptionState`. */
+    isServerOptionOn(opt: number): boolean;
+    /** Clear `opt` from `hisOn` without answering anything — for an option
+     *  that lapses on its own, as compression does when its stream ends. */
+    forgetServerOption(opt: number): void;
     /** Drop the negotiated-MSP latch without resetting the rest of the
      *  negotiation state — used on disconnect, where the option dies with the
      *  connection but reset() isn't otherwise run. */
@@ -151,11 +204,6 @@ export declare class TelnetNegotiator {
      *  (IAC WILL SGA). We refuse SGA, but the owner combines this with the
      *  echo state to detect character-at-a-time mode. */
     get sgaRequested(): boolean;
-    /** The WebSocket handshake completed — proactively offer NAWS (RFC 1073
-     *  has the window-owning side send WILL). The server replies IAC DO NAWS —
-     *  handled in processFrame — at which point we send the actual dimensions.
-     *  Harmless if the server doesn't support it (it answers DONT or ignores us). */
-    onSocketOpen(): void;
     /** Mudlet `addSupportedTelnetOption(option)`. Marks the telnet option byte
      *  (0..255) as one the client will accept: on the next IAC WILL <opt> we
      *  reply IAC DO <opt>; on IAC DO <opt> we reply IAC WILL <opt>. Natively
@@ -166,19 +214,66 @@ export declare class TelnetNegotiator {
     /** Record the main output window's character grid (columns × rows) for NAWS.
      *  The value is stored regardless of negotiation state (so a client created
      *  on a later connect can be seeded with the current size); it's only sent
-     *  to the server once NAWS has been negotiated, and only when it changed. */
+     *  to the server once NAWS has been negotiated, and only when the size it
+     *  reports changed. */
     setWindowSize(cols: number, rows: number): void;
+    /** Record the main console's wrap column (Mudlet's `Host::mWrapAt`; 0 for
+     *  off). It caps the NAWS width, so a change re-reports the size the way
+     *  desktop's `setWindowWrap("main", n)` does. */
+    setWrapAt(wrapAt: number): void;
+    /** Record whether the main console draws its timestamp gutter, which
+     *  desktop takes off the NAWS width. */
+    setTimestampsShown(shown: boolean): void;
+    /** Note option commands a sibling handler (EchoHandler, MccpHandler) put on
+     *  the wire itself, so the option bitsets — and with them the STATUS reply
+     *  and the repeat-offer checks — know about them, as Mudlet's single
+     *  `sendTelnetOption` does. `data` is what was sent. */
+    noteOptionsSent(data: string): void;
     /** Walk one incoming frame (post-MCCP Latin-1 byte-string) for telnet IAC
-     *  sequences: answer WILL/WONT/DO/DONT per the option policy, auto-respond
-     *  to registered supported options, raise `telnet.event` for everything
-     *  else (including SB of unrecognized options), and watch for in-band MXP
-     *  line-mode sequences on servers that skip the option-91 handshake. */
+     *  sequences: answer WILL/WONT/DO/DONT per the option policy, raise
+     *  `telnet.event` for every command but GA/EOR and consumed SBs (as Mudlet's
+     *  `processTelnetCommand` does), and watch for in-band MXP line-mode
+     *  sequences on servers that skip the option-91 handshake. */
     processFrame(data: string): void;
-    /** One WILL/WONT/DO/DONT for `opt`. Natively-handled options are answered
-     *  at most once per frame (matching the old `includes()`-based scan); the
-     *  supported-options registry answers every occurrence; anything left is
-     *  surfaced as a `telnet.event`. */
+    /**
+     * Run `post` — the showing of a read this negotiator has just scanned —
+     * without letting what it feeds in meanwhile disturb the read's detection
+     * tail. An escape this read leaves unfinished is joined to the NEXT read,
+     * not to what a trigger `feedTelnet()`s while this one is shown, so that
+     * must neither be joined to this read's tail nor replace it (cTelnet's
+     * postKeepingDetectionTail).
+     */
+    keepingMxpDetectionTail(post: () => void): void;
+    /** One WILL/WONT/DO/DONT for `opt`. Natively-handled options follow their
+     *  own rules; everything else gets Mudlet's generic answer. Every
+     *  occurrence is answered on its merits — no per-frame dedupe — so a
+     *  server that turns an option off and on again within one packet is
+     *  answered for each step, as Mudlet does. */
     private handleNegotiationCommand;
+    /** Send `IAC <cmd> <opt>` and keep the four option bitsets in step, as
+     *  Mudlet's `cTelnet::sendTelnetOption` does. */
+    private sendOption;
+    private trackOption;
+    /** Mudlet's reply to STATUS SEND: `IAC SB STATUS IS`, then `WILL <opt>`
+     *  for every option we have on and `DO <opt>` for every one we asked the
+     *  server to have on, in option order, then `IAC SE`. Sent whether or not
+     *  STATUS itself was negotiated, as desktop does. RFC 859 exempts the list
+     *  from IAC escaping except for an option byte equal to SE (240), which is
+     *  doubled. */
+    private sendStatusIs;
+    /** The answer every option gets once nothing specific to it applies —
+     *  Mudlet's fall-through branches in `processTelnetCommand`:
+     *   - WILL: DO for STATUS, TERMINAL-TYPE and anything registered with
+     *     `addSupportedTelnetOption`, DONT for the rest — unless we already
+     *     sent DO, in which case the offer is only a repeat.
+     *   - DO: WONT to TIMING-MARK always; otherwise, unless we already said
+     *     WILL, WILL for STATUS, TERMINAL-TYPE and registered options, WONT
+     *     for the rest.
+     *   - WONT: DONT when we had it on or the server had announced it before
+     *     (RFC 854's acknowledgement), silence for a first unprompted WONT.
+     *   - DONT: WONT when we had it on or have never said anything about it.
+     *  Silence to an offer is what leaves a strict server waiting. */
+    private respondToOtherOption;
     /** Mudlet `cTelnet::trackKaVirNegotiation`. Records the option of each
      *  inbound WILL/DO in a rolling window and fires the hook the first time the
      *  window equals the KaVir fingerprint. Recording happens before the
@@ -187,47 +282,92 @@ export declare class TelnetNegotiator {
      *  `processTelnetCommand`. */
     private trackKaVirNegotiation;
     private respondToKnownOption;
-    /** Raise `telnet.event` for an SB of an option we neither handle natively
-     *  nor auto-negotiate (type 5 in Mudlet's sysTelnetEvent mapping). */
-    private noticeSubnegotiation;
-    /** `type` mirrors Mudlet's TLuaInterpreter mapping: 1=WILL, 2=WONT, 3=DO,
-     *  4=DONT, 5=SB. Deduped per (command, option) within the frame so a server
-     *  that spams the same option doesn't flood handlers. */
+    /** Take the option up: answer the server, latch it on and announce it as
+     *  Mudlet's `sysProtocolEnabled`. Raised on every acceptance rather than
+     *  only the first, matching `raiseProtocolEvent` — a server that re-offers
+     *  mid-session re-announces. `beforeAnnounce` runs after the agreement is
+     *  on the wire but before the event, for handshakes that must precede
+     *  anything a script sends in response. */
+    private enableProtocol;
+    /** Turn an offer down because the profile has that protocol switched off.
+     *  The refusal is announced only if we had the option on: declining one
+     *  that was never taken up is not news, and Mudlet guards it the same way. */
+    private refuseProtocol;
+    /** The server withdrew the option (IAC WONT / IAC DONT). */
+    private withdrawProtocol;
+    /** Mudlet's ATCP hello, sent after `IAC DO ATCP` and again in answer to
+     *  the server's `Auth.Request`: the client's name and version, then the
+     *  modules it asks for. Mudlet's list less `composer`, since there is no
+     *  ATCP composer here to answer `Client.Compose`. */
+    sendAtcpHello(): void;
+    /** Mudlet's MSDP start sequence, sent after `IAC DO MSDP`:
+     *  `LIST COMMANDS`, then `CLIENT_NAME` / `CLIENT_VERSION` in one frame. */
+    private sendMsdpHello;
+    /** Raise `telnet.event` (Mudlet's `sysTelnetEvent`) for one complete
+     *  command, `raw` being its bytes from the IAC on. Mirrors the tail of
+     *  `cTelnet::processTelnetCommand`: raised for every command — handled
+     *  options included — except GA and EOR, which end nearly every prompt,
+     *  and the subnegotiations of the options in `SB_CONSUMED`.
+     *  `type` is the command byte itself (251 WILL, 250 SB, …), `option` the
+     *  byte after it (0 for a two-byte command). `message` is a byte-string:
+     *  desktop hands it to Lua as ARGUMENT_TYPE_BYTES, byte for byte and not
+     *  decoded, since an option it has no handler for can carry any binary
+     *  data. A subnegotiation's is its payload alone — without the
+     *  `IAC SB <option>` and `IAC SE` framing, a doubled IAC unescaped, and
+     *  empty for an empty one — and any other command's is the whole command. */
     private emitTelnetEvent;
     /** Reply to a TERMINAL-TYPE / MTTS subnegotiation. `subneg` is the SB body
      *  with the option byte (24) at [0]; [1] is the request kind (1 = SEND). We
-     *  answer `IAC SB TTYPE IS <value> IAC SE`, cycling client name → terminal
-     *  type → MTTS capability bitvector on successive SENDs, then repeating the
-     *  last value to signal the list is exhausted (RFC 1091 + the MTTS standard). */
+     *  answer `IAC SB TTYPE IS <value> IAC SE`, walking Mudlet's
+     *  `mCycleCountMTTS` cycle on successive SENDs: client name, terminal type,
+     *  the MTTS bitvector, the bitvector again — the repeat is what tells the
+     *  server the list is done (RFC 1091 + the MTTS standard) — and then back to
+     *  the client name, so a server that re-detects the client later (after a
+     *  copyover, say) is told who it is again. With MTTS off the cycle is just
+     *  the client name, repeated — desktop Mudlet still identifies itself, it
+     *  only skips the MTTS steps. */
     handleTtypeSubneg(subneg: string): void;
+    /** The MTTS bitvector from live state — Mudlet's `getNewEnvironMTTS`: UTF-8
+     *  when that is the encoding, SCREEN READER when advertised, MNES when the
+     *  profile has MNES and NEW-ENVIRON both on; the rest are static (see
+     *  computeMtts, including why SSL always is). */
+    private currentMtts;
     /** Handle an `IAC SB MXP IAC SE` subnegotiation. Per spec it carries no
      *  payload — it merely confirms MXP is active — so we just start MXP. The
      *  actual MXP markup arrives in-band and is parsed downstream by the
      *  scripting engine. */
     handleMxpSubneg(): void;
-    /** Answer an `IAC SB NEW-ENVIRON SEND … IAC SE` request, framed as
-     *  `IAC SB NEW-ENVIRON IS <marker> … VALUE … IAC SE`. Telnet option 39 is
-     *  shared by two modes: MNES reports the five core variables framed as VAR;
-     *  plain NEW-ENVIRON reports the core set plus an extended capability set,
-     *  framed as USERVAR. MNES takes precedence when both toggles are on
-     *  (matching Mudlet). The server may request specific variables or send a
-     *  bare SEND for all; selectMnesVars handles both. No-op when the option is
-     *  off for this profile or on a malformed/non-SEND body. */
+    /** Answer an `IAC SB NEW-ENVIRON SEND … IAC SE` request. Telnet option 39
+     *  is shared by two modes, each answered as Mudlet answers it: MNES
+     *  (`sendIsMNESValues`) reports the five core variables framed as VAR, one
+     *  reply per named variable; plain NEW-ENVIRON (`sendIsNewEnvironValues`)
+     *  reports the core set plus an extended capability set, framed as USERVAR,
+     *  in a single reply that lists unknown names as undefined and may come
+     *  back empty. MNES takes precedence when both toggles are on. No-op when
+     *  the option is off for this profile or on a non-SEND body. */
     handleNewEnvironSubneg(subneg: string): void;
     /** Build the option-39 variable set from live client state. CHARSET tracks
-     *  the negotiated encoding; the extended NEW-ENVIRON capabilities derive from
-     *  the game-facing transport (TLS — false in proxy mode) and the measured
-     *  output grid (WORD_WRAP). The static identity (CLIENT_NAME/VERSION, MTTS,
-     *  TERMINAL_TYPE) and the capability defaults live in buildNewEnvironVars. */
+     *  the negotiated encoding and WORD_WRAP the main console's wrap column
+     *  (Mudlet's `Host::mWrapAt`, not the window's width). The static identity
+     *  (CLIENT_NAME/VERSION, TERMINAL_TYPE) and the capability defaults live in
+     *  buildNewEnvironVars. */
     private collectNewEnvironVars;
-    /** Latch MXP on for this session and notify listeners. Idempotent — only the
-     *  first call emits `mxp.negotiated`; later calls (repeat WILL/DO, in-band
-     *  detection on subsequent frames) are no-ops. `viaTelnet` distinguishes a
-     *  real option-91 handshake from in-band-only detection (see the event doc). */
+    /** Latch MXP on for this session and notify listeners: on every switch-on
+     *  from the game, and on the first in-band detection. `viaTelnet`
+     *  distinguishes a real option-91 switch-on from in-band-only detection (see
+     *  the event doc), and `viaSubnegotiation` a bare `IAC SB MXP IAC SE`. */
     private startMxp;
-    /** Send the current window size as an `IAC SB NAWS … IAC SE` subnegotiation.
-     *  Falls back to a conventional 80×24 terminal default when the UI hasn't
-     *  reported a real size yet — better than the NAWS 0×0 "no preference"
-     *  sentinel, which some servers treat as "disable wrapping". */
-    private sendNawsSize;
+    /** Mudlet's `cTelnet::sendCurrentNAWS`: report the size the game should
+     *  format for as an `IAC SB NAWS … IAC SE` subnegotiation — once NAWS is
+     *  on, and only when it differs from what was last sent. The width is the
+     *  smaller of the window's columns and the wrap column, less the timestamp
+     *  gutter when one is drawn; a game told the full window width would wrap
+     *  wider than the client does, and every long line would break twice.
+     *  Wrapping switched off (wrap 0, which only the Settings field can set and
+     *  desktop has no equivalent of) leaves the window width alone.
+     *
+     *  Falls back to a conventional 80×24 terminal when the UI hasn't reported a
+     *  real size yet — better than the NAWS 0×0 "no preference" sentinel, which
+     *  some servers treat as "disable wrapping". */
+    private sendCurrentNaws;
 }

package/dist-lib/mud/connection/telnetDebug.d.ts

@@ -1,37 +1,37 @@
 /**
  * localStorage-gated diagnostic logging for the MUD connection. Each gate is
- * toggled from the browser console (e.g. `localStorage.setItem('mudix.debugTelnet',
+ * toggled from the browser console (e.g. `localStorage.setItem('mudlet.debugTelnet',
  * '1')`) and read live on every use, so logging can be flipped mid-session
  * without a reconnect.
  */
 /**
- * `mudix.debugTelnet` — log every telnet command/subnegotiation byte seen on
+ * `mudlet.debugTelnet` — log every telnet command/subnegotiation byte seen on
  * each incoming frame, and every byte-string we send. Used to investigate
  * protocol-negotiation issues (GMCP/MSDP/MCCP not enabling) by revealing
  * exactly what crosses the wire in both directions.
  */
 export declare function debugTelnetEnabled(): boolean;
 /**
- * `mudix.debugFrames` — log WebSocket frame boundaries for the MUD stream.
+ * `mudlet.debugFrames` — log WebSocket frame boundaries for the MUD stream.
  * Used to investigate "extra line break" issues that surface when long MUD
  * lines arrive split across multiple WebSocket frames.
  */
 export declare function debugFramesEnabled(): boolean;
 /**
- * `mudix.debugMsp` — log MSP negotiation, parsed `!!SOUND`/`!!MUSIC` tags
+ * `mudlet.debugMsp` — log MSP negotiation, parsed `!!SOUND`/`!!MUSIC` tags
  * (inline and subneg), and their dispatch into the SoundManager. Use this to
  * confirm whether a MUD is actually emitting MSP and whether the client is
  * routing it through.
  */
 export declare function debugMspEnabled(): boolean;
 /**
- * `mudix.debugGmcp` — log every parsed GMCP message's path and (truncated) body
+ * `mudlet.debugGmcp` — log every parsed GMCP message's path and (truncated) body
  * as it arrives. Used to see exactly which modules a server drives — e.g.
  * whether login audio comes over `Client.Media.*` GMCP vs. MSP tags.
  */
 export declare function debugGmcpEnabled(): boolean;
 /**
- * `mudix.debugGa` — log every IAC GA / IAC EOR prompt marker the server sends,
+ * `mudlet.debugGa` — log every IAC GA / IAC EOR prompt marker the server sends,
  * plus the one-time moment the client latches into GA-driven prompt mode. Use
  * this to confirm whether a MUD actually signals its prompts (GA-less MUDs rely
  * on the `promptTimeoutMs` idle-flush fallback instead).
@@ -48,7 +48,7 @@ export declare function logTelnetNegotiation(label: string, s: string): void;
  * a malformed body from a well-formed one.
  *
  * Bodies only: plain command text is reported as a byte count, never content,
- * because `send()` also carries typed passwords. `Char.Login.Credentials` is
- * redacted for the same reason.
+ * because `send()` also carries typed passwords. The `Char.Login` messages in
+ * {@link SECRET_GMCP_MODULES} are redacted for the same reason.
  */
 export declare function logOutboundBytes(s: string): void;