@mudlet/mudlet-web 0.3.0 → 0.4.0

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

@@ -20,7 +20,26 @@ export declare function normalizeCharsetName(raw: string): string | null;
  *  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. */
+export declare const DEFAULT_SERVER_ENCODING = "UTF-8";
 export declare const SUPPORTED_SERVER_ENCODINGS: readonly string[];
+/** 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
+ *  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. */
+export declare function canonicalServerEncoding(raw: string): string | null;
+/**
+ * Whether every character of `text` survives a trip to the game under
+ * `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
+ * is to warn about a loss that will certainly happen, not to guess.
+ */
+export declare function canEncodeForServer(text: string, serverEncoding: string): boolean;
 /**
  * Parse an `IAC SB CHARSET REQUEST ...` subnegotiation body (leading byte is
  * the option code 42, then subcommand byte 1, then optional `[TTABLE]<ver>`
@@ -61,11 +80,14 @@ export declare class SessionCodec {
     decode(byteString: 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.
-     *  For UTF-8 we run it through TextEncoder so multi-byte chars survive;
-     *  for other encodings we fall back to a per-char `& 0xff` truncation,
-     *  which is lossless for ASCII and acceptable for Latin-1-family inputs.
-     *  TextEncoder has no API for non-UTF-8 outputs, so a full per-encoding
-     *  outbound table isn't worth the bytes given how rare non-UTF-8 MUDs are. */
+     *  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`
+     *  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. */
     encodeOutgoing(text: string): string;
 }
 export interface CharsetHandlerHooks {

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

@@ -1,4 +1,5 @@
 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";

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

@@ -3,12 +3,28 @@ export interface GmcpEnvelope {
     value: unknown;
 }
 export type TelnetOptionHandler = (data: string) => string;
-export declare const createTelnetOptionParser: (onSubnegotiation: (data: string) => void) => TelnetOptionHandler;
+/** UTF-8-encode into a Latin-1 byte-string, for MudClient.sendBytes (which
+ *  writes `charCodeAt(i) & 0xff` per char). The inverse of fromByteString. */
+export declare const toByteString: (s: string) => string;
+export declare const createTelnetOptionParser: (onSubnegotiation: (data: string) => void, opts?: {
+    /** When true, an inbound IAC GA / IAC EOR is replaced by a newline
+     *  rather than stripped — Mudlet's `mFORCE_GA_OFF` behaviour
+     *  (`cTelnet::processSocketData` pushes `'\n'` in place of the marker
+     *  instead of treating it as a prompt). Doing the substitution here,
+     *  inside the sequence parser, keeps it positional: the newline lands
+     *  exactly where the marker was, and a `\xFF\xF9` byte pair inside a
+     *  subnegotiation payload is never mistaken for one. */
+    promptMarkerAsNewline?: boolean;
+}) => TelnetOptionHandler;
 export declare const stripTelnetSequences: (data: string, handler: TelnetOptionHandler) => 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"`).
- *  Matches Mudlet's `sendGMCP` semantics — the caller controls the exact bytes
- *  between IAC SB GMCP and IAC SE. */
+ *  Mudlet's `sendGMCP` semantics — the caller controls the body between IAC SB
+ *  GMCP and IAC SE — except that the body is transcoded to UTF-8 rather than to
+ *  the session's outgoing encoding, so it can't be used to place arbitrary raw
+ *  bytes on the wire. UTF-8 is what the GMCP spec asks for, and it's also what
+ *  keeps a 0xFF byte (which would need IAC-escaping inside a subnegotiation)
+ *  out of the body in the first place. */
 export declare const encodeGmcpRaw: (message: string) => string;
 export interface GmcpStreamOptions {
     onEnvelope: (payload: GmcpEnvelope) => void;

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

@@ -8,4 +8,4 @@ export { MspParser, type MspCommand, type MspKind } from "./msp";
 export { MxpParser, splitMxpResultLines, type MxpLink, type MxpLineResult } from "./mxp";
 export { parseMnesRequest, encodeMnesIs, selectMnesVars, buildNewEnvironVars, CLIENT_NAME, CLIENT_VERSION, TERMINAL_TYPE, type MnesVar, type MnesRequest, type NewEnvironState } from "./mnes";
 export { encodeNaws } from "./naws";
-export { SessionCodec, CharsetHandler, normalizeCharsetName, pickCharsetFromRequest, SUPPORTED_SERVER_ENCODINGS, type CharsetHandlerHooks } from "./charset";
+export { SessionCodec, CharsetHandler, normalizeCharsetName, pickCharsetFromRequest, SUPPORTED_SERVER_ENCODINGS, DEFAULT_SERVER_ENCODING, canonicalServerEncoding, canEncodeForServer, type CharsetHandlerHooks } from "./charset";

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

@@ -0,0 +1,54 @@
+/**
+ * MSSP-advertised TLS port tracking.
+ *
+ * Mirrors Mudlet's `cTelnet::promptTlsConnectionAvailable` (ctelnet.cpp) —
+ * a server may advertise a secure port through the MSSP `TLS` / `SSL` variable,
+ * and the client offers, once, to switch to it.
+ *
+ * Kept free of React and session plumbing so the decision rules can be tested
+ * directly; the caller supplies the current connection state.
+ */
+/** Per-connection MSSP facts that bear on the TLS offer. */
+export interface MsspTlsFacts {
+    /** The advertised secure port, or 0 when none/unusable. */
+    tlsPort: number;
+    /** MSSP `HOSTNAME`, used to catch an advertisement meant for a different host. */
+    hostName: string;
+}
+export declare function emptyMsspTlsFacts(): MsspTlsFacts;
+/**
+ * Fold one MSSP variable into the accumulated facts.
+ *
+ * `TLS`/`SSL` normally carries a port number, but the values `-1` and `1` are
+ * used by some servers as plain "unsupported"/"supported" booleans. Mudlet
+ * discards both rather than dialling port 1, and so do we.
+ */
+export declare function applyMsspVariable(facts: MsspTlsFacts, name: string, value: string): MsspTlsFacts;
+/** True for a literal IPv4/IPv6 address. A certificate is very unlikely to be
+ *  issued for a bare IP, so Mudlet suppresses the offer in that case rather
+ *  than steering the user into a guaranteed validation failure. */
+export declare function isIpAddress(host: string): boolean;
+export interface TlsOfferState {
+    /** MSSP facts gathered on this connection. */
+    facts: MsspTlsFacts;
+    /** The host this profile actually dialled. */
+    host: string;
+    /** The port currently in use. */
+    port: number;
+    /** Whether this profile is already connecting over TLS. */
+    tlsEnabled: boolean;
+    /** The profile's "remind me about secure connections" preference. */
+    askTlsAvailable: boolean;
+    /** True while an offer is already on screen, so repeats can't stack. */
+    promptInFlight: boolean;
+    /** Only proxy-mode connections can be upgraded: an MSSP TLS port is a raw
+     *  telnet-over-TLS port, which a browser cannot dial directly. */
+    proxyMode: boolean;
+}
+/**
+ * Decide whether to offer the secure-port switch. Mirrors Mudlet's guard set:
+ * a usable advertised port, not already encrypted, the reminder still enabled,
+ * the host not a bare IP, MSSP `HOSTNAME` (when given) matching the host we
+ * dialled, and no offer already pending.
+ */
+export declare function shouldOfferTlsUpgrade(s: TlsOfferState): boolean;

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

@@ -29,9 +29,16 @@ export interface MxpFrameCommand {
     name: string;
     /** Upper-cased attribute keys → raw string values. Flag attributes
      *  (`INTERNAL`/`EXTERNAL`/`FLOATING`) are present with value `"true"`.
-     *  `ACTION` is `open` (default) / `close` / `redirect`; geometry lives in
-     *  `LEFT`/`TOP`/`WIDTH`/`HEIGHT`. */
+     *  `ACTION` is `open` (default) / `close` / `focus`; geometry lives in
+     *  `ALIGN`/`LEFT`/`TOP`/`WIDTH`/`HEIGHT`. */
     attrs: Record<string, string>;
+    /** Name of the `<DEST>` frame that was open when this tag was seen, if any.
+     *  A `<FRAME>` nested inside a `<DEST>` is laid out *inside* that frame
+     *  rather than against the main window — Mudlet's `mCurrentDestination`
+     *  check in TMxpFrameManager::layoutInternalFrame. The parser batches frames
+     *  and redirects into separate arrays, so the association has to travel with
+     *  the command. */
+    dest?: string;
 }
 /** Text the parser redirected into a named frame via `<DEST>…</DEST>`. */
 export interface MxpRedirect {
@@ -41,6 +48,9 @@ export interface MxpRedirect {
     segments: BufferSegment[];
     /** Plain text of the redirected run. */
     plain: string;
+    /** Clickable regions inside this run, offset into `plain`. Separate from
+     *  `MxpLineResult.links` because the two index different strings. */
+    links: MxpLink[];
     /** `EOL` attr (or the network line ended mid-DEST): the write is a complete
      *  line. */
     eol: boolean;
@@ -84,6 +94,8 @@ export declare class MxpParser {
     private mxpColorStack;
     /** Partial tag/entity held from the end of the previous line. */
     private pendingTag;
+    /** Whether the line being parsed came off the socket — see {@link parseLine}. */
+    private fromServer;
     /** Active `<DEST>` target frame (persists across lines until `</DEST>`), or
      *  null when output flows to the main window. While set, appended text and
      *  flushed runs route to `destOut`/`destPlain` instead of `out`/`plain`. */
@@ -103,9 +115,10 @@ export declare class MxpParser {
     private redirects;
     /** `<SOUND>`/`<MUSIC>` commands accumulated this line. */
     private sounds;
-    /** Redirected-text scratch — the current `<DEST>` run's segments/plain. */
+    /** Redirected-text scratch — the current `<DEST>` run's segments/plain/links. */
     private destOut;
     private destPlain;
+    private destLinks;
     constructor(opts: {
         send: (raw: string) => void;
         presets?: HyperlinkPresetRegistry;
@@ -113,6 +126,9 @@ export declare class MxpParser {
          *  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;
+        /** 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
@@ -127,8 +143,15 @@ export declare class MxpParser {
     reset(): void;
     /** Parse one raw line (post telnet-strip, post UTF-8 decode), which may carry
      *  ANSI SGR, MXP tags, `ESC[#z` modes, and entities. `baseSnapshot` is the
-     *  carried pen from the previous line. */
-    parseLine(rawLine: string, baseSnapshot?: FormatStateSnapshot): MxpLineResult;
+     *  carried pen from the previous line.
+     *
+     *  `fromServer` false means the line was synthesised locally (feedTriggers).
+     *  Such a line's `ESC[#z` is consumed but does not switch mode, matching
+     *  Mudlet's `isFromServer` gate on `mMxpProcessor.setMode` — otherwise a
+     *  script feeding a captured game line would leave the parser in whatever
+     *  mode that capture ended on, and the next real tag would be discarded as
+     *  unsafe. */
+    parseLine(rawLine: string, baseSnapshot?: FormatStateSnapshot, fromServer?: boolean): MxpLineResult;
     private effectiveMode;
     private resetTransientMode;
     private appendText;

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

@@ -0,0 +1,4 @@
+export declare function describeCertCode(code: string): string;
+/** Which of Mudlet's three tolerance checkboxes would clear a given fault.
+ *  `all` means only "accept all certificate errors" covers it. */
+export declare function toleranceForCode(code: string): 'expired' | 'selfSigned' | 'all';

package/dist-lib/mud/replay/ReplayPlayer.d.ts

@@ -27,5 +27,22 @@ export declare class ReplayPlayer {
     /** Stop playback and drop any pending chunk. Idempotent; onDone is not
      *  fired for an aborted replay. */
     abort(): void;
+    /**
+     * Deliver every chunk that has come due, without waiting for its setTimeout.
+     *
+     * The counterpart of TimerEngine.pumpDue, and there for the same caller: a
+     * script blocked in waitForEvent/pumpEvents is not running the event loop,
+     * so the pending timeout below can never land and a replay started from such
+     * a script would sit at chunk zero forever. Mudlet has no equivalent problem
+     * — its nested QEventLoop keeps driving the replay timer along with
+     * everything else — so this is what standing in for that loop costs.
+     *
+     * Returns the number of chunks delivered.
+     */
+    pumpDue(now?: number): number;
+    /** When the pending chunk is due, in epoch ms; null when none is scheduled. */
+    private dueAt;
+    /** Feed the chunk at `index` and schedule the one after it. */
+    private deliverPending;
     private scheduleNext;
 }

package/dist-lib/mud/text/Console.d.ts

@@ -1,6 +1,9 @@
 import { FormatState } from './FormatState';
 import { AnsiAwareBuffer } from './FormatState';
 import type { FormatStateSnapshot } from './FormatState';
+/** Longest run of characters one echo or insert may add to a line. Mudlet's
+ *  `TBuffer::MAX_CHARACTERS_PER_ECHO`. */
+export declare const MAX_CHARACTERS_PER_ECHO = 1000000;
 /**
  * Self-contained text output entity — equivalent of Mudlet's TConsole.
  * Owns format state, line history, and cursor position.
@@ -36,6 +39,13 @@ export declare class Console {
     get batchDeleteSize(): number;
     setBatchDeleteSize(n: number): void;
     echo(text: string): void;
+    /**
+     * Move every newline-terminated line out of the in-flight `partial` and
+     * into history, leaving whatever follows the last newline as the new
+     * partial. Shared by `echo` and by `insertText`, which can put a newline
+     * into the line being built just as an echo can.
+     */
+    private promotePartialLines;
     /**
      * Append a pre-built complete line buffer to history. Used by the network
      * trigger pipeline: the line has already been parsed and is being added as
@@ -55,6 +65,14 @@ export declare class Console {
      * `selectCurrentLine` sees the pasted line.
      */
     appendBuffer(buffer: AnsiAwareBuffer): void;
+    /**
+     * The one way a completed line enters history. An OSC 8 link set to reveal
+     * itself after a delay is written into the buffer as spaces here and gets
+     * its text back when the delay is up — Mudlet does the same, so that a
+     * script reading the line back sees what the player can see rather than the
+     * secret behind it.
+     */
+    private store;
     private evict;
     /** Drain newly completed lines to hand to the renderer. */
     takeLines(): AnsiAwareBuffer[];
@@ -82,12 +100,32 @@ export declare class Console {
     clearPartial(): void;
     private get cursor();
     private get followingEnd();
+    /**
+     * Whether the line under the cursor is the in-flight `partial` — an echo
+     * that hasn't seen its newline yet — rather than a finished history line.
+     *
+     * The distinction matters to every cursor-line operation, not just the
+     * readers: Mudlet's cursor sits on the line being built, so `insertText`,
+     * `replace` and friends have to reach it there. Reading it but not writing
+     * it made `prefix()`/`suffix()` on an unfinished line silent no-ops.
+     */
+    private get onPartialLine();
     getLine(): string;
     getBuffer(): AnsiAwareBuffer | null;
+    /** The buffer the cursor is on: the partial when it is following the end,
+     *  otherwise the history line it was parked on. */
+    private currentBuffer;
     /** Per-line prompt flag on the current cursor line. Mirrors Mudlet's TBuffer
      *  behaviour: `isPrompt()` follows the cursor, so moveCursor + isPrompt can
      *  inspect any historical line's prompt status, not just the most recent. */
     cursorOnPrompt(): boolean;
+    /** Whether the cursor was left one slot beyond the last line — the state
+     *  deleteLine() leaves behind when it removes the line the cursor was on and
+     *  there is nothing after it to shift up. Distinct from the ordinary
+     *  "following the end" cursor (index -1), which every read treats as the last
+     *  line. Reads cursorIdx rather than `cursor`, which clamps and so can never
+     *  report either state. */
+    cursorPastEnd(): boolean;
     deleteLine(): void;
     /**
      * Insert `text` at the cursor (Mudlet `insertText`). Embedded `\n` split the
@@ -124,6 +162,13 @@ export declare class Console {
      * `keepHorizontal` move never reports past the end of a shorter line.
      */
     getCursorColumn(): number;
+    /**
+     * The column as it was set, unclamped. Mudlet keeps `mUserCursor.x()` raw
+     * and only the operations that write through it decide what a column past
+     * the end of the line means — `paste` pads out to it, which the clamped
+     * reading above cannot express.
+     */
+    getCursorColumnRaw(): number;
     setCursorColumn(col: number): boolean;
     /** Mark cursor as positioned at the end of existing rendered content, so the
      *  next leading `\n` is treated as cursor advance rather than a blank line.
@@ -179,5 +224,24 @@ export declare class Console {
      * every continuation, matching setWindowWrapIndent /
      * setWindowWrapHangingIndent.
      */
+    /**
+     * The wrap this console applies to a line as it is stored — the console's
+     * own `setWindowWrap` width, so a line longer than it becomes several
+     * buffer lines rather than one long one that only *looks* wrapped.
+     *
+     * Off (width 0) unless a script sets one, which is the state nearly every
+     * console is in: the renderer wraps to the panel's real pixel width, and
+     * splitting on a column nobody chose would only fight it. Mudlet always
+     * splits because its buffer IS its layout.
+     */
+    setWrapWidth(width: number, indent?: number, hangingIndent?: number): void;
+    private wrapWidth;
+    private wrapIndent;
+    private wrapHangingIndent;
+    /**
+     * Split one completed line to the console's wrap width, newest-last. With no
+     * width set — the usual case — this is the line itself, untouched.
+     */
+    private toStoredLines;
     wrapLine(lineNumber: number, wrapAt?: number, indent?: number, hangingIndent?: number): boolean;
 }

package/dist-lib/mud/text/FormatState.d.ts

@@ -1,5 +1,5 @@
 import { type OscPaletteOp } from "./ansiEscapes";
-import { HyperlinkPresetRegistry, type HyperlinkConfig } from "./hyperlinkConfig";
+import { HyperlinkPresetRegistry, type HyperlinkConfig, type UnderlineStyle } from "./hyperlinkConfig";
 /** Apply OSC 4/104 palette operations to the global colour tables. Palette
  *  changes affect text parsed *after* this point — which is exactly document
  *  order, since lines are fed to the parser in the order the server sent them. */
@@ -53,6 +53,9 @@ export interface HexColor {
     color: string;
 }
 export type FormatColor = IndexedColor | RgbColor | HexColor;
+/** One SGR parameter: a number, or its sub-parameters when it carried any
+ *  (`4:3` → `[4, 3]`). See {@link parseSgrCodes}. */
+export type SgrParam = number | number[];
 export type DimEasing = 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out';
 export interface DimEffect {
     startOpacity: number;
@@ -66,6 +69,9 @@ export interface FormatStateSnapshot {
     bold?: boolean;
     italic?: boolean;
     underline?: boolean;
+    /** Which underline SGR asked for (`4:1`..`4:5`). Only meaningful while
+     *  `underline` is set; absent means the plain solid one. */
+    underlineStyle?: UnderlineStyle;
     inverse?: boolean;
     strikethrough?: boolean;
     overline?: boolean;
@@ -84,11 +90,11 @@ declare function cloneState(state?: FormatStateSnapshot): FormatStateSnapshot |
 declare function statesEqual(a?: FormatStateSnapshot, b?: FormatStateSnapshot): boolean;
 export declare class FormatState {
     static DEFAULT: {};
-    foreground?: FormatColor;
     background?: FormatColor;
     bold?: boolean;
     italic?: boolean;
     underline?: boolean;
+    underlineStyle?: UnderlineStyle;
     inverse?: boolean;
     strikethrough?: boolean;
     overline?: boolean;
@@ -96,13 +102,66 @@ export declare class FormatState {
     rapidBlink?: boolean;
     dim?: DimEffect;
     hyperlink?: FormatHyperlink;
+    private fgNormal?;
+    private fgLight?;
+    /** True while the foreground is the profile's own — as it starts, and as
+     *  SGR 0 and SGR 39 leave it. Bold never brightens a default foreground. */
+    private fgIsDefault;
+    private _foreground?;
+    /** The foreground in force, both variants already resolved. */
+    get foreground(): FormatColor | undefined;
+    /** Writing the foreground from outside the SGR decoder — `setFgColor`, MXP
+     *  colour attributes, link styling — names one colour and knows nothing of
+     *  the bold pair, so it becomes both variants. Without that a later bold
+     *  would re-resolve to whatever the escape stream had left behind and undo
+     *  the write. */
+    set foreground(color: FormatColor | undefined);
     constructor(initial?: FormatStateSnapshot);
     private applySnapshot;
     reset(): void;
     toSnapshot(): FormatStateSnapshot;
-    applySgr(params: number[]): void;
+    applySgr(params: SgrParam[]): void;
+    /**
+     * Apply one SGR parameter that carried sub-parameters (`4:3`, `38:5:196`).
+     *
+     * Only the underline styles need reading apart from the flat form: an
+     * extended colour means the same written either way, so it is handed back to
+     * the ordinary path with its sub-parameters flattened.
+     */
+    private applySgrGroup;
+    /**
+     * `38:…` / `48:…` — an extended colour written with sub-parameters.
+     *
+     * The colon form carries one element the semicolon form does not: a colour
+     * space identifier sits between the `2` and the red component, almost always
+     * empty (`38:2::255:0:0`). So the components are the 4th, 5th and 6th
+     * sub-parameters here where they are the 3rd, 4th and 5th parameters there.
+     * Missing components are zero, as in Mudlet's decodeSGR38.
+     */
+    private applyExtendedColorGroup;
+    /** Record a foreground and the colour bold should show instead of it, then
+     *  resolve which of the two is in force. Pass the same colour twice when it
+     *  has no brighter twin. */
+    private setForeground;
+    /** Pick the variant the current bold state calls for. Mudlet writes each
+     *  cell as `(!mIsDefaultColor && mBold) ? light : normal` — a default
+     *  foreground stays default however bold the text is. */
+    private resolveForeground;
     setHyperlink(link?: FormatHyperlink): void;
 }
+/**
+ * Split an SGR sequence into its parameters. `;` separates parameters and `:`
+ * their sub-parameters (ECMA-48 / ITU T.416), so a parameter that carries
+ * sub-parameters comes back as an array and a plain one as a number.
+ *
+ * The distinction matters for exactly one reason, but it matters a lot: `4:3` is
+ * a *curly underline*, one parameter with a sub-parameter, while `4;3` is an
+ * underline followed by italics. Flattening both — which mudix did, to make
+ * `38:5:1` work alongside `38;5;1` — turned every styled underline into an
+ * accidental italic. Extended colours still read either form, since applySgr
+ * looks ahead across parameters for the `38;5;n` spelling.
+ */
+export declare function parseSgrCodes(sequence: string): SgrParam[];
 /**
  * A run of text with its visual attributes resolved to concrete CSS colour
  * strings — the shape a canvas/image renderer wants. `color`/`background` are
@@ -165,6 +224,10 @@ export declare class AnsiAwareBuffer {
     remove(range: [number, number]): this;
     /** @internal */
     getSegments(): BufferSegment[];
+    /** Whether any segment carries an OSC 8 link with `visibility` settings.
+     *  A cheap pre-check (no cloning, no grouping) for the concealment pass,
+     *  which every stored line goes through. */
+    hasVisibilityLink(): boolean;
     toHyperlinkSegments(): {
         text: string;
         hyperlink?: FormatHyperlink;

package/dist-lib/mud/text/hyperlinkVisibility.d.ts

@@ -15,8 +15,15 @@
  * (owned by the session) conceals them when the matching session event fires.
  * The first occurrence of each trigger is skipped: it's the response to the very
  * command the click sent, not a fresh event.
+ *
+ * **The buffer half.** Hiding an element is not enough for a *delayed reveal*:
+ * Mudlet writes such a link into its buffer as spaces and puts the text back
+ * when the delay is up, so a script reading the line back (`getLines`) sees what
+ * the player sees rather than the secret. {@link concealDelayedReveals} does the
+ * same to a stored line here — see the section at the foot of this file.
  */
 import type { VisibilitySettings } from "./hyperlinkConfig";
+import type { AnsiAwareBuffer } from "./FormatState";
 /** Wire one link element's visibility behaviour. Call *after* the element's base
  *  style has been applied (it may set `visibility: hidden`, which a later
  *  `cssText` assignment would wipe). */
@@ -35,3 +42,31 @@ export declare class HyperlinkVisibilityController {
     onOutput(): void;
     private fire;
 }
+/**
+ * Whether a link with these settings is written concealed and revealed later.
+ *
+ * Only the timed reveals are, unlike Mudlet, which also conceals a reveal armed
+ * on an expire trigger. mudix drives expire triggers off the rendered element
+ * (see {@link HyperlinkVisibilityController}), and that path only ever conceals
+ * — a link the buffer blanked with nothing to un-blank it would lose its text
+ * for good, which is worse than showing it early.
+ */
+export declare function startsConcealed(vis: VisibilitySettings): boolean;
+/**
+ * Blank out every delayed-reveal link on a freshly stored line and schedule the
+ * text to come back. Called once per line as it enters a console's history.
+ */
+export declare function concealDelayedReveals(line: AnsiAwareBuffer): void;
+/**
+ * Put back the text of every concealed link whose delay has elapsed, and arm a
+ * timer for the earliest one still waiting. Returns true when a line changed.
+ *
+ * Also the hook the busted harness drives: a spec runs as one synchronous call
+ * on top of the event loop, so no `setTimeout` of ours can fire until it
+ * returns, and `pumpEvents` calls in here instead.
+ */
+export declare function pumpDelayedReveals(now?: number): boolean;
+/** Drop everything still waiting — a profile teardown, or a test resetting
+ *  between cases. The lines themselves are left as they are; they are going
+ *  away with the console. */
+export declare function resetDelayedReveals(): void;

package/dist-lib/mud/text/osc8Docs.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Mudlet's `!osc8-docs` easter egg — the worked OSC 8 examples banner
+ * (`TBuffer::injectOSC8DocumentationExamples`).
+ *
+ * A line printed through the echo family that holds the phrase is swallowed and
+ * this banner goes into the MAIN console instead, whichever window the echo was
+ * addressed to. It is the one page of OSC 8 documentation that can be read
+ * without leaving the client, so every escape in it is load-bearing: the text is
+ * a verbatim port of Mudlet's, kept one source line per array entry so the two
+ * can be diffed after a re-sync.
+ *
+ * Not every printing path reaches it — what the game sends and what a trigger
+ * echoes onto the matched line print the phrase as ordinary text, exactly as in
+ * Mudlet, where those go through `commitLine()` rather than `appendLine()`.
+ */
+/** The phrase itself, split so that this file does not set off its own check
+ *  when something echoes a line of it. */
+export declare const OSC8_DOCS_PHRASE: string;
+/** Once a second at most — an echo and the server response that repeats it must
+ *  not print the banner twice. Mudlet's `mLastOSC8DocsInjectionTime` window. */
+export declare const OSC8_DOCS_DEBOUNCE_MS = 1000;
+/** The banner as one blob, ready to hand to `Console.echo`. */
+export declare function osc8DocumentationExamples(): string;