@mudlet/mudlet-web 0.4.5 → 1.0.0

package/dist-lib/mud/keybindings/qtKeys.d.ts

@@ -12,24 +12,103 @@ export declare const QT_KEY_UNKNOWN = 33554431;
  * numpad keys from the main keyboard while Qt::Key alone does not.
  */
 export declare function qtKeyToDomCode(key: string | number, modifier?: number): string;
+/** Qt::KeyboardModifier bits. */
+export declare const QT_SHIFT_MODIFIER = 33554432;
+export declare const QT_CONTROL_MODIFIER = 67108864;
+export declare const QT_ALT_MODIFIER = 134217728;
+export declare const QT_META_MODIFIER = 268435456;
 /**
  * Translate a Qt::KeyboardModifier bitmask into an array of modifier names
- * that match the {ctrl,shift,alt,meta} strings KeyEngine compares against.
+ * that match the {ctrl,shift,alt,meta,keypad} strings KeyEngine compares
+ * against.
  *
- * Qt::ShiftModifier   = 0x02000000
- * Qt::ControlModifier = 0x04000000
- * Qt::AltModifier     = 0x08000000
- * Qt::MetaModifier    = 0x10000000
- * Qt::KeypadModifier  = 0x20000000  (ignored — DOM `code` already encodes "Numpad*")
- * Qt::GroupSwitchMod. = 0x40000000  (ignored — X11-only)
+ * Qt::KeypadModifier is kept as `keypad`: desktop's key matcher compares the
+ * whole mask, so a binding on Keypad+Up (numpad 8 with NumLock off) is a
+ * different key from the arrow, and `ArrowUp` alone cannot say which one it
+ * is. A Numpad* DOM code says it by itself, so `keypad` is redundant there but
+ * harmless. Qt::GroupSwitchModifier (0x40000000, X11-only) is ignored.
  */
 export declare function qtModifiersToList(modifier: number): string[];
-/** Inverse of qtModifiersToList — {ctrl,shift,alt,meta} names → Qt bitmask. */
+/** Inverse of qtModifiersToList — {ctrl,shift,alt,meta,keypad} names → Qt bitmask. */
 export declare function listToQtModifiers(modifiers: string[]): number;
+/** Whether a stored binding is on the numpad: flagged `keypad`, or on a
+ *  Numpad* DOM code (which only the numpad reports). */
+export declare function isKeypadBinding(key: string, modifiers: readonly string[]): boolean;
+/** A stored binding's Qt modifier mask, as desktop's getKeyCode and XML would
+ *  carry it — the Keypad bit included for a Numpad* code (Key_Enter too: Qt
+ *  reports the numpad Enter as Key_Enter with KeypadModifier). */
+export declare function bindingQtModifiers(key: string, modifiers: string[]): number;
 /**
- * Inverse of qtKeyToDomCode for the common case — a DOM `KeyboardEvent.code`
- * back to a Qt::Key integer. Used by getKeyCode() to report a permanent key
- * binding (stored as a DOM code) in Mudlet's Qt terms. Returns undefined for a
- * code with no Qt mapping.
+ * Whether a Qt::Key is a printable character — the ASCII and Latin-1 ranges,
+ * where Qt::Key IS the (upper-cased) character the press produced. Qt reports
+ * the character, not the key's position: Shift+1 is Key_Exclam on a US layout,
+ * while on French AZERTY the same key gives Key_Ampersand plain and Key_1 with
+ * Shift, and its A key (US Q) is Key_A. So a binding on one of these is matched
+ * by the character the browser says was typed, never by the US position its
+ * DOM code names.
+ */
+export declare function isPrintableQtKey(key: number | undefined): key is number;
+/**
+ * The printable Qt::Key a press produced, from `KeyboardEvent.key` — upper-cased
+ * as Qt does (Key_A for `a`, Key_Eacute 0xC9 for `é`). Undefined when the press
+ * named no single printable character (`Dead`, `Unidentified`, a named key, or a
+ * script beyond Latin-1), in which case its position is all there is to go on.
+ */
+export declare function printableEventQtKey(e: Pick<KeyboardEvent, 'key' | 'altKey'>): number | undefined;
+/** Whether this browser runs on macOS, where Qt sets KeypadModifier on the
+ *  arrow keys (they count as part of the keypad there, per Qt's docs), and
+ *  takes the key from the character typed *without* Option. */
+export declare function isMacPlatform(): boolean;
+/**
+ * Whether Qt would report this press with KeypadModifier: every numpad key,
+ * and on macOS the arrow keys too. A binding desktop recorded on a Mac for
+ * Alt+Up carries the Keypad bit, and matching it against the arrows (as desktop
+ * on a Mac does) needs this; elsewhere the arrows are not the keypad.
+ */
+export declare function isQtKeypadEvent(e: Pick<KeyboardEvent, 'code' | 'location'>): boolean;
+/** Whether a press is a numpad key, whatever NumLock makes of it. */
+export declare function isKeypadEvent(e: Pick<KeyboardEvent, 'code' | 'location'>): boolean;
+/**
+ * The Qt::Key desktop would get for a numpad press. Unlike `code`, which is
+ * `Numpad8` whatever NumLock says, Qt reports what the key produced: Key_8 with
+ * NumLock on, Key_Up with it off — which is how a NumLock-off walking binding
+ * and a NumLock-on digit binding stay apart. Falls back to the code when the
+ * browser gives no usable `key`.
+ */
+export declare function keypadEventQtKey(e: Pick<KeyboardEvent, 'code' | 'key'>): number | undefined;
+/**
+ * The Qt::Key desktop would record for a press, for the key recorder: the
+ * character it produced in the printable range (`!` for Shift+1 on a US
+ * layout, `&` for the same key on AZERTY, upper case for letters, as Qt::Key_A
+ * is), the numpad's NumLock-dependent key, and
+ * otherwise the code's own key.
+ */
+export declare function eventQtKey(e: Pick<KeyboardEvent, 'code' | 'key' | 'location' | 'altKey'>): number | undefined;
+/**
+ * A press as the key + modifiers a binding stores. A numpad key with NumLock
+ * off is stored under the key it produced (`ArrowUp`) and flagged `keypad`, so
+ * it records the same Key_Up|Keypad desktop's recorder would.
+ */
+export declare function bindingFromEvent(e: KeyboardEvent): {
+    key: string;
+    modifiers: string[];
+    qtKey?: number;
+};
+/**
+ * Inverse of qtKeyToDomCode — a DOM `KeyboardEvent.code` back to a Qt::Key
+ * integer. Used by getKeyCode() to report a permanent key binding (stored as a
+ * DOM code) in Mudlet's Qt terms, and by the Mudlet XML export to write a key
+ * item's `<keyCode>`. Numpad codes return the shared main-keyboard Qt::Key; the
+ * keypad flag lives in the modifier. Returns undefined for a code with no Qt
+ * mapping.
  */
 export declare function domCodeToQtKey(code: string): number | undefined;
+/** Every key name a Qt key sequence can spell out — what a shortcut parser has
+ *  to recognise as the key half of a step. */
+export declare const QT_KEY_NAMES: ReadonlySet<string>;
+/**
+ * One key of a Qt key sequence ("F9", "Left", ",", "k") as the DOM
+ * `KeyboardEvent.code` a key binding stores it under. Null when the name is not
+ * a key Qt would read, or names one the browser cannot report.
+ */
+export declare function keyNameToDomCode(name: string): string | null;

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

@@ -0,0 +1,19 @@
+/** One inbound ATCP (telnet option 200) message as desktop files it: `name`
+ *  keys the Lua `atcp` table and names the event, `value` is what both carry. */
+export interface AtcpMessage {
+    name: string;
+    value: string;
+}
+/** Split a decoded ATCP subnegotiation body the way Mudlet's
+ *  `cTelnet::setATCPVariables` does. A body with a line feed is split at the
+ *  first one, anything else at the first space; the dots come out of the name
+ *  (`Char.Vitals` → `CharVitals`) and the line feeds out of the value; and when
+ *  the first line held more than the name, the rest of it leads the value,
+ *  space-separated — so `Char.Vitals H:1 M:2\nNL:3` files `"H:1 M:2 NL:3"`
+ *  under `CharVitals`. Desktop removes every dot from that whole first line
+ *  before splitting it, value half included, and so does this.
+ *
+ *  Null for `Client.Compose`, which desktop hands to its composer window and
+ *  never puts in the table or raises. There is no composer here (the hello
+ *  doesn't offer `composer 1`), so it is dropped. */
+export declare function parseAtcpMessage(text: string): AtcpMessage | null;

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

@@ -31,3 +31,27 @@ export declare const toByteString: (s: string) => string;
  *  post-decode text — where every malformed sequence has already collapsed to
  *  an indistinguishable U+FFFD. Truncated: the head is where the fault is. */
 export declare const toHex: (s: string) => string;
+/** Decode a byte-string as UTF-8 the way Mudlet's `TBuffer::processUtf8Sequence`
+ *  does, for text that reaches the buffer without cTelnet in front of it
+ *  (`feedTriggers` under UTF-8 hands its bytes straight to the buffer). It
+ *  differs from the WHATWG decoder in how much a bad sequence eats: the lead
+ *  byte declares a length, and a malformed sequence — bad continuation,
+ *  overlong, surrogate, past U+10FFFF, 5/6-byte — becomes ONE replacement mark
+ *  spanning all of it, where WHATWG re-reads the offending byte as the start of
+ *  something new. That is what makes a carriage return after a truncated lead
+ *  byte part of the rejected sequence instead of a line ending. A UTF-8 BOM
+ *  arrives as U+FEFF rather than vanishing. A sequence cut short by the end of
+ *  the input keeps the lenient decoder's answer, as before. */
+export declare const decodeUtf8AsTBuffer: (s: string) => string;
+/** TBuffer's rule for a socket's bytes, as desktop has had it since Mudlet PR
+ *  #11068: a malformed sequence is still ONE replacement mark — the browser's
+ *  decoder gives one per byte of an overlong form or a surrogate — but a byte
+ *  that cannot continue a sequence is not swallowed by it: the bytes before
+ *  it earn the mark and it is read in its own right, so a line ending, an
+ *  escape or a letter after a truncated sequence survives. A sequence the
+ *  end of `s` cuts short is handed back as `pending` to be prefixed to the
+ *  next frame — unless `final` (a prompt ends there), where it earns its mark. */
+export declare const decodeUtf8Stream: (s: string, final: boolean) => {
+    text: string;
+    pending: string;
+};

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

@@ -3,18 +3,154 @@
  *
  * The server sends `Char.Login.Default` to ask for credentials and then waits,
  * withholding its text login prompt until the client answers. Answering is
- * therefore mandatory — every path here ends in either a credentials reply or a
- * popup that will produce one. `Char.Login.Result` reports the outcome, and a
- * server that rejects an attempt commonly re-sends `Char.Login.Default` to ask
- * again, so these rules run repeatedly within one connection.
+ * therefore mandatory — every path here ends in a reply (the hand-off when
+ * there is nothing to send), or a popup, vault unlock or browser sign-in that
+ * will produce one. `Char.Login.Result` reports the outcome, and a server that
+ * rejects an attempt commonly re-sends `Char.Login.Default` to ask again, so
+ * these rules run repeatedly within one connection.
  *
- * Mirrors Mudlet's `GMCPAuthenticator` (GMCPAuthenticator.cpp). Kept free of
- * React and session plumbing so the rules can be tested directly; the caller
- * supplies the per-connection state.
+ * Two protocol versions are in play, and they want different things from us:
+ *
+ * - **Version 1** is a password exchange. We autofill a saved login once, and
+ *   raise `CharLoginModal` when the game rejects it, so the player can correct
+ *   it. That is what every version 1 profile in the wild is talking to.
+ * - **Version 2** adds browser sign-in (Google, Discord, or the game's own
+ *   account system) and password-less reconnect tokens. There the game owns the
+ *   interactive sign-in screen and we automate *around* it — Mudlet's design is
+ *   explicit that the client does not render a pop-up of its own — so on
+ *   version 2 the modal never opens: we replay a token, resume a provider,
+ *   autofill a stored pair, run the client-driven OAuth flow, or hand off.
+ *
+ * Mirrors Mudlet's `GMCPAuthenticator` (development branch,
+ * GMCPAuthenticator.{h,cpp}). Kept free of React and session plumbing so the
+ * rules can be tested directly; `CharLoginController` supplies the state.
+ */
+/** The highest `Char.Login` version this client implements — what
+ *  `Core.Supports.Set` advertises and the ceiling every negotiation is clamped
+ *  to. */
+export declare const CHAR_LOGIN_CLIENT_VERSION = 2;
+/**
+ * Decode a field the standard declares boolean, in every form it permits: a
+ * JSON boolean, the strings `"true"`/`"false"`/`"1"`/`"0"` (case-insensitive,
+ * whitespace ignored), or the numbers 1/0. Several MUD drivers have no JSON
+ * boolean at all — LDMud's `json_serialize()` among them, and StickMUD sends
+ * `"true"` — which is why the string and number forms exist.
+ *
+ * Anything else is `undefined`, *not* false, so the caller applies that field's
+ * own default: the defaults here are true or "the transport the token arrived
+ * on", never a flat false, so collapsing the two would answer a
+ * security-bearing question wrong. Mudlet's `decodeWireBool`.
+ */
+export declare function decodeWireBool(value: unknown): boolean | undefined;
+/**
+ * Clamp the version a server reported in `Char.Login.Default` to what we
+ * implement: the negotiated version is `min(client, server)`.
+ *
+ * Absent, unreadable, fractional or non-positive all mean 1 — a version 1
+ * server sends no field at all. The string form is read too: a driver with no
+ * JSON number sends `"2"`, and read as a number that answered a version 2
+ * server as version 1 for the whole session. A value *above* what we implement
+ * is clamped down, not read as 1. Mirrors `saveSupportsSet`.
+ */
+export declare function negotiateCharLoginVersion(reported: unknown): number;
+/** The client-driven OAuth capability a version 2 server advertises when it is
+ *  itself an OpenID Provider. */
+export interface CharLoginOAuthCapability {
+    /** The OpenID Connect discovery document's URL (the `location` field). */
+    location: string;
+    clientId: string;
+    /** Requested scopes; the flow defaults an empty list to `["openid"]`. */
+    scopes: string[];
+    /** The authorization request must carry a `nonce` the server can check the
+     *  ID token against. */
+    nonceRequired: boolean;
+}
+/** Everything `Char.Login.Default` told us, normalised. */
+export interface CharLoginCapabilities {
+    /** Negotiated version — see {@link negotiateCharLoginVersion}. */
+    version: number;
+    /** The `type` list, malformed entries dropped. Empty when the server sent none. */
+    methods: string[];
+    /** Present only on an encrypted game-facing transport, and only when the
+     *  server sent both `location` and `client_id`. */
+    oauth?: CharLoginOAuthCapability;
+}
+/**
+ * Read a `Char.Login.Default` payload into capabilities.
+ *
+ * `secureTransport` is whether the link to the *game* is encrypted, not "is the
+ * WebSocket wss:" — in proxy mode a `wss://` proxy URL only secures the
+ * browser↔proxy hop. The client-driven OAuth fields are read only when it is:
+ * the `Char.Login.AuthCode` that completes that flow carries the authorization
+ * code and the PKCE verifier together and must never travel in the clear, so on
+ * cleartext they are dropped and the sign-in silently uses the server-driven
+ * flow instead — Mudlet's `saveSupportsSet`.
+ *
+ * The standard's field is `nonce_required`. Mudlet read a plain `nonce` until
+ * Mudlet/Mudlet#10623; the old key is still honoured when the standard's is
+ * absent, so a server written against that keeps working.
+ */
+export declare function parseCharLoginDefault(value: unknown, secureTransport: boolean): CharLoginCapabilities;
+/** A validated `Char.Login.URL`. */
+export interface CharLoginUrl {
+    url: string;
+    /** Lowercase provider id (`discord`, `google`, …) when the server named one. */
+    provider?: string;
+}
+/**
+ * Validate a `Char.Login.URL` payload.
+ *
+ * The address arrives unauthenticated over the wire, so only `http`/`https`
+ * survive — never `javascript:`, `file:`, `data:` or any other scheme handler,
+ * whether we would open it or merely render it as a link. Control characters
+ * are refused outright: the address is rendered into the console inside an
+ * OSC 8 sequence, where an ESC would close it early and let the game paint
+ * arbitrary ANSI through what is supposed to be one link. Returns null for
+ * anything unusable, including a missing or unparseable `url`.
+ */
+export declare function parseCharLoginUrl(value: unknown): CharLoginUrl | null;
+/** A parsed `Char.Login.Token`. */
+export interface CharLoginToken {
+    account: string;
+    token: string;
+    /** Whether the token may only ever be replayed over an encrypted transport. */
+    secureOnly: boolean;
+}
+/**
+ * Read a `Char.Login.Token` payload. Null when the account or token is missing.
+ *
+ * `secure_only` absent — or in a form that is not a boolean at all — means the
+ * token inherits the transport it arrived on: one minted over TLS is
+ * encrypted-only, one minted in the clear may be replayed either way. A server
+ * that mints over TLS but accepts replays in the clear has to say so with an
+ * explicit false, so where a token has protection to lose, silence keeps it.
+ * Mudlet's `handleAuthToken`.
+ *
+ * Never logs the payload: it is a bearer secret.
+ */
+export declare function parseCharLoginToken(value: unknown, secureTransport: boolean): CharLoginToken | null;
+/** A parsed `Char.Login.Result`. */
+export interface CharLoginResult {
+    success: boolean;
+    message?: string;
+}
+/**
+ * Read a `Char.Login.Result`. `success` decodes like every other declared
+ * boolean — reading only `true`/`"true"` made an integer 1 a failure, and a
+ * failed reconnect deletes a token the server had just accepted
+ * (Mudlet/Mudlet#10622). Absent or undecodable reads as failure.
  */
+export declare function parseCharLoginResult(value: unknown): CharLoginResult;
 /** What to do about a `Char.Login.Default` request. */
 export type CharLoginAction = 
-/** Reply with the empty `{}` form — "no credentials, use your next method". */
+/**
+ * Hand the sign-in to the game: version 1's empty `{}` ("no credentials,
+ * use your next method" — the player's *Use text login*), or version 2's
+ * deliberate "run your own sign-in screen", which carries the common fields
+ * but no account. Mudlet sends it even when the profile has a stored
+ * password the game will not take, so a saved password never blocks the
+ * player from reaching a provider choice.
+ */
 {
     kind: 'decline';
 }
@@ -24,11 +160,49 @@ export type CharLoginAction =
     account: string;
     password: string;
 }
-/** Raise the credentials popup. */
+/** Replay the saved password-less token — `Char.Login.Reconnect`. */
+ | {
+    kind: 'reconnect';
+    account: string;
+    token: string;
+}
+/**
+ * Ask the game to restart this provider's browser sign-in — the *resume*
+ * form of `Char.Login.Credentials`, `{account, provider}`. The absence of a
+ * password, not the presence of `provider`, makes it a resume.
+ */
+ | {
+    kind: 'resume';
+    account: string;
+    provider: string;
+}
+/** Run the client-driven OAuth flow (discovery, PKCE, redirect capture). */
+ | {
+    kind: 'oauth';
+}
+/** Raise the credentials popup. Version 1 only. */
  | {
     kind: 'prompt';
+}
+/**
+ * Ask to unlock the vault. `read`: it holds this profile's saved login or
+ * sign-in. `store`: it holds nothing for this profile yet, but only an open
+ * vault lets the game hand over a token to keep (`token_storage`).
+ */
+ | {
+    kind: 'unlock';
+    reason: 'read' | 'store';
 };
+/** A saved sign-in as the decision sees it — the vault's `VaultSignIn`. */
+export interface StoredSignInView {
+    account: string;
+    provider?: string;
+    token?: string;
+    secureOnly?: boolean;
+}
 export interface CharLoginRequestState {
+    /** Negotiated `Char.Login` version. Absent reads as 1. */
+    version?: number;
     /** The `type` list from `Char.Login.Default`; empty when the server sent none. */
     methods: string[];
     /** The player chose "Use text login" earlier this connection. */
@@ -38,21 +212,69 @@ export interface CharLoginRequestState {
     /** Stored/in-memory credentials, if any. */
     account?: string;
     password?: string;
+    /** A saved password or sign-in exists but sits in a locked vault, so it
+     *  can't be read yet. Mudlet Web only — desktop has no vault to unlock. */
+    credentialsLocked?: boolean;
+    /** A vault exists but is locked, and holds nothing for this profile — so
+     *  the game would be told `token_storage: false`. False once the player
+     *  said "Not now". Mudlet Web only. */
+    storageLocked?: boolean;
+    /** The saved version 2 sign-in, if the vault holds one and is open. */
+    signIn?: StoredSignInView;
+    /** Whether the link to the *game* is encrypted. */
+    secureTransport?: boolean;
+    /** A token was rejected earlier: read the store, but do not replay a token
+     *  this once. Mudlet's `mReconnectRejected` latch. */
+    tokenRejected?: boolean;
+    /** A token has already been replayed this connection. */
+    reconnectAttempted?: boolean;
+    /** A provider resume has already been sent this connection. */
+    resumeAttempted?: boolean;
+    /** The client-driven OAuth flow can run: the server advertised it over an
+     *  encrypted link, and it has not already been tried this connection. */
+    clientOAuthAvailable?: boolean;
 }
 /**
  * Decide how to answer a `Char.Login.Default`.
  *
- * The one automatic attempt per connection is the load-bearing rule: it makes a
- * saved login silent when it works, and guarantees that a *wrong* saved login
- * turns into a visible popup instead of a silent send-reject-send loop against
- * the server's repeated asks.
+ * Version 1's one automatic attempt per connection is the load-bearing rule: it
+ * makes a saved login silent when it works, and guarantees that a *wrong* saved
+ * login turns into a visible popup instead of a silent send-reject-send loop
+ * against the server's repeated asks.
  */
 export declare function decideCharLoginRequest(state: CharLoginRequestState): CharLoginAction;
 /**
- * The console line for a rejected login, in Mudlet's wording
- * (`GMCPAuthenticator::handleAuthResult`). Servers doing GMCP login usually send
- * no text of their own, so this is often the only trace of the failure.
+ * Whether a token would have been replayed but for the game-facing transport
+ * being in the clear — the one case worth telling the player about, since their
+ * saved sign-in silently stopped working and the reason is fixable. Answered by
+ * re-running the ladder with the gate lifted, so the two cannot drift apart.
  */
+export declare function charLoginTokenRefusedForCleartext(state: CharLoginRequestState): boolean;
+/** A provider id as a human-readable name. Unknown ids are capitalised rather
+ *  than dropped. Empty for no provider. */
+export declare function charLoginProviderName(provider?: string): string;
+/** Offered with a `Char.Login.URL` or the client-driven flow's sign-in page. A
+ *  browser blocks a tab opened outside a user gesture, so where Mudlet
+ *  launches the system browser we always offer the link. */
+/** Mudlet's `GMCPAuthenticator::announceBrowserHandoff` wording. No link: the
+ *  sign-in dialog carries it, and a game-linked page is printed by the game. */
+export declare function charLoginSignInLinkMessage(provider?: string): string;
+export declare const CHAR_LOGIN_INVALID_URL_MESSAGE = "The game sent an invalid sign-in link; cannot continue.";
+export declare const CHAR_LOGIN_INSECURE_RECONNECT_MESSAGE = "Not using your saved sign-in because this connection is not encrypted; please sign in again.";
+export declare function charLoginResumeMessage(provider: string): string;
+/** Shown once per sign-in attempt, on the first token that attempt saves. */
+export declare const CHAR_LOGIN_TOKEN_SAVED_MESSAGE: string;
+/** Mudlet Web only: the game can hand over a sign-in to keep, but there is no
+ *  vault to keep it in, so it was told `token_storage: false`. The line ends
+ *  in {@link CHAR_LOGIN_NO_VAULT_LINK}, a link that opens vault setup. */
+export declare const CHAR_LOGIN_NO_VAULT_MESSAGE = "Want to stay signed in next time?";
+export declare const CHAR_LOGIN_NO_VAULT_LINK = "Set up saved logins";
+/** Vault setup, opened from that link, finished. */
+export declare const CHAR_LOGIN_VAULT_READY_MESSAGE = "Saved logins are set up. The next time you sign in, it will be kept.";
+export declare const CHAR_LOGIN_TOKEN_SAVE_FAILED_MESSAGE = "Could not save your sign-in for next time; you may need to sign in again.";
+export declare const CHAR_LOGIN_TOKEN_EXPIRED_MESSAGE = "Your saved sign-in has expired; reconnecting so you can sign in again.";
+export declare const CHAR_LOGIN_OAUTH_FAILED_MESSAGE = "The browser sign-in could not be completed; reconnect to try again.";
+export declare const CHAR_LOGIN_AUTHCODE_INSECURE_MESSAGE = "Cannot complete the sign-in because the connection is not encrypted.";
 /**
  * The console line for credentials the game never answered at all: it closed the
  * connection instead of sending `Char.Login.Result`.
@@ -65,4 +287,9 @@ export declare function decideCharLoginRequest(state: CharLoginRequestState): Ch
  * line a mistyped password is indistinguishable from a network failure.
  */
 export declare const CHAR_LOGIN_SILENT_DROP_MESSAGE: string;
+/**
+ * The console line for a rejected login, in Mudlet's wording
+ * (`GMCPAuthenticator::handleAuthResult`). Servers doing GMCP login usually send
+ * no text of their own, so this is often the only trace of the failure.
+ */
 export declare function charLoginFailureMessage(message?: string): string;