@mudlet/mudlet-web 0.5.0 → 1.0.1

package/dist-lib/mud/aliases/AliasEngine.d.ts

@@ -1,15 +1,61 @@
 import type { AliasNode } from '../../storage/schema';
 import { PatternEngine } from '../PatternEngine';
 export type { AliasNode };
+/** One permanent alias a command matched — see AliasEngine.forEachPermMatch. */
+export interface PermAliasMatch {
+    alias: AliasNode;
+    matchedText: string;
+    captures: string[];
+    named: Record<string, string>;
+}
 export declare class AliasEngine extends PatternEngine<AliasNode> {
-    /** Returns true and fires the first matching temp alias. Stops at first match. */
+    /**
+     * Fire EVERY matching temp alias, and report whether any did.
+     *
+     * Not "the first one": `AliasUnit::processDataStream` walks the whole unit
+     * and calls `match()` on each active alias, so two aliases on one command
+     * both run — which is how a package can add its own handling of a command
+     * the player already has an alias for, and what the corpus pins by putting
+     * two aliases on one pattern and expecting both to see it.
+     *
+     * The walk is over a snapshot, as Mudlet's is (issue #4297): an alias's
+     * script may create or kill one, and mutating the map underneath the
+     * iterator is precisely what the deferred reap exists to avoid. One killed
+     * by an earlier fire is skipped rather than run, which is what `isActive()`
+     * decides on the desktop side.
+     */
     processTemp(input: string): boolean;
-    /** Returns the first matching perm alias, or null. `matchedText` is the
-     *  portion of `input` the regex actually matched (Mudlet's `matches[1]`),
-     *  which differs from the whole input for an unanchored pattern. */
-    matchPerm(input: string): {
-        alias: AliasNode;
-        matchedText: string;
-        captures: string[];
-    } | null;
+    /** Match one temp alias against `input` and run it if it hits. */
+    private fireTemp;
+    /**
+     * A command's whole alias pass: every matching alias, temporary and
+     * permanent alike, in the one order desktop's `mAliasRootNodeList` holds
+     * them — creation order, with a permanent subtree walked where its root
+     * sits (see PatternEngine's unified ordering). Running all the temps first
+     * put a tempAlias made after a permAlias ahead of it (mudlet-web#327).
+     * Temps fire themselves; each permanent hit goes to `firePerm` as it is
+     * reached, for the reason {@link forEachPermMatch} gives. Both lists are
+     * the ones that stood when the pass began. True when anything fired.
+     */
+    process(input: string, firePerm: (hit: PermAliasMatch) => void): boolean;
+    /**
+     * Walk the perm aliases in tree order and hand each one the input matches
+     * to `fire` as it is reached — all of them fire, for the reason
+     * {@link processTemp} gives. `matchedText` is the portion of `input` the
+     * regex actually matched (Mudlet's `matches[1]`), which differs from the
+     * whole input for an unanchored pattern.
+     *
+     * Match-then-fire, one alias at a time, rather than collecting every match
+     * first: `AliasUnit::processDataStream` asks each alias `isActive()` as it
+     * reaches it, so an earlier alias's `disableAlias`/`enableAlias` decides
+     * whether a later one runs in the same pass (issue #284). The walk is over
+     * the list as it stood when the pass began — a new alias waits for the
+     * next command — but each step reads the live state, which the toggle has
+     * already reloaded through the store subscription.
+     */
+    forEachPermMatch(input: string, fire: (hit: PermAliasMatch) => void): void;
+    private firePermIfMatched;
+    /** Every perm alias the input matches, in tree order, without firing any.
+     *  A command goes through {@link forEachPermMatch} instead. */
+    matchAllPerm(input: string): PermAliasMatch[];
 }

package/dist-lib/mud/autoLogin.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Text auto-login — Mudlet's `mTimerLogin` / `mTimerPass` pair in cTelnet.
+ *
+ * Desktop answers a text login on fixed timers and nothing else:
+ * `slot_socketConnected` starts the login timer, `slot_send_login` sends the
+ * saved character name when there is one and, when a password is saved too
+ * (`Host::hasAutoLoginCredentials`), starts the password timer, and
+ * `slot_send_pass` sends the password — "timer-based, independent of ECHO
+ * mode". No prompt marker, no ECHO negotiation, moves either step earlier.
+ *
+ * Mudlet Web used to answer the first IAC GA/EOR with the name and the first
+ * ECHO-off with the password. A game that greets with a GA-marked splash
+ * ("Press ENTER to continue") took the name at 42 ms, answering a question the
+ * game had not asked yet (issue #237). And the name was sent only when a
+ * password was saved as well, where desktop sends it whenever it is set.
+ *
+ * Neither step echoes: both are `cTelnet::sendData`, below `Host::send` where
+ * the command echo lives, and neither is a game command (so neither arms
+ * character-at-a-time detection — the password prompt the name walks into is
+ * exactly the ECHO+SGA state that detection is trying to tell apart).
+ */
+/** cTelnet's `AUTO_LOGIN_USERNAME_DELAY_MS`: connect → character name. */
+export declare const AUTO_LOGIN_USERNAME_DELAY_MS = 2000;
+/** cTelnet's `AUTO_LOGIN_PASSWORD_DELAY_MS`: character name → password. */
+export declare const AUTO_LOGIN_PASSWORD_DELAY_MS = 1000;
+export interface AutoLoginCredentials {
+    account: string;
+    password: string;
+}
+export interface TextAutoLoginDeps {
+    /** Read at each step rather than at connect, as Mudlet reads the Host's
+     *  login and password when its timers fire. */
+    readCredentials: () => AutoLoginCredentials;
+    /** `cTelnet::sendData(login)` — no echo, not a game command. */
+    sendLogin: (account: string) => void;
+    /** `cTelnet::sendData(pass, false)` — never shown, never echoed. */
+    sendPassword: (password: string) => void;
+    setTimeout?: (fn: () => void, ms: number) => unknown;
+    clearTimeout?: (handle: unknown) => void;
+}
+export declare class TextAutoLogin {
+    private readonly deps;
+    private loginTimer;
+    private passTimer;
+    private readonly setTimer;
+    private readonly clearTimer;
+    constructor(deps: TextAutoLoginDeps);
+    /** The game link is up — `slot_socketConnected` starting `mTimerLogin`.
+     *  Started on every connection, credentials or not: they are looked at
+     *  only when the timer fires. */
+    start(): void;
+    /** `cancelLoginTimers` — the connection ended, or GMCP `Char.Login` has
+     *  taken the login over. */
+    cancel(): void;
+    /** Whether either step is still to come. */
+    get pending(): boolean;
+    private sendLogin;
+    private sendPassword;
+}

package/dist-lib/mud/commandSplit.d.ts

@@ -14,3 +14,12 @@
  * quietly inventing an empty command.
  */
 export declare function splitCommands(text: string, separator: string): string[];
+/**
+ * The rest of Host::send's loop on top of the split: each part has its line
+ * feeds removed, but only after the empty parts were skipped. So a part that
+ * was nothing but a line feed survives as an EMPTY command — which is what an
+ * echoed command's trailing line feed (see MudSession.echoSentCommand) leaves
+ * after a final separator, or as the whole of an empty one, and what a `^$`
+ * alias then fires on.
+ */
+export declare function splitSentCommands(text: string, separator: string): string[];

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

@@ -10,8 +10,10 @@ export interface LineAssemblerCallbacks {
     /** Deliver assembled whole lines (or a flushed prompt tail) downstream —
      *  the trigger pipeline and rendering treat each chunk as complete lines. */
     onChunk(text: string, ts: number): void;
-    /** Fired after a prompt marker (IAC GA/EOR) flushed the held tail — the
-     *  owner emits its `prompt` event here. */
+    /** Fired for every prompt marker (IAC GA/EOR), after it flushed the line
+     *  it ends — the owner emits its `prompt` event here, and the line just
+     *  handed to `onChunk` is the prompt. A bare marker ends an empty line, so
+     *  there always is one. */
     onPrompt(): void;
     /** Fired after an idle-timer flush so the owner can render any messages
      *  the flushed chunk produced (MudClient.flushMessageBuffer). */
@@ -56,12 +58,6 @@ export declare class LineAssembler {
      *  partial lines here, because our render path finalizes every emitted
      *  chunk and has no downstream open-line carry. */
     private _gaDriver;
-    /** True at the start of a GA-driven data block — i.e. before any content of
-     *  the current post-GA transmission has been seen. Drives the
-     *  `fixUnnecessaryLinebreaks` leading-newline strip, which fires at most once
-     *  per block. Set true on connect and after each prompt flush, cleared once
-     *  the block's leading-newline question has been settled. */
-    private atPromptBlockStart;
     private fixUnnecessaryLinebreaks;
     private undoServerWrap;
     private undoServerWrapWidth;
@@ -82,14 +78,44 @@ export declare class LineAssembler {
     setPromptTimeoutMs(ms: number): void;
     getPromptTimeoutMs(): number;
     /** Mudlet `setConfig("fixUnnecessaryLinebreaks", …)`. Takes effect on the
-     *  next GA-driven block; never retroactive. */
+     *  next block that ends in a prompt marker; never retroactive. */
     setFixUnnecessaryLinebreaks(enabled: boolean): void;
+    /**
+     * Mudlet's "Fix unnecessary linebreaks on GA servers" (cTelnet::gotPrompt
+     * under `mUSE_IRE_DRIVER_BUGFIX`): from a block of one read that ENDS in
+     * IAC GA/EOR, drop a single leading newline — after any leading SGR
+     * escapes, none of which it removes. `block` is that run's raw text, up to
+     * the marker; it is returned unchanged when the option is off.
+     *
+     * Only such a block is touched. Text that arrives on its own, with no
+     * prompt marker after it — the reply that follows a prompt a moment later,
+     * say — keeps its newline, as desktop's gotRest posts it untouched.
+     *
+     * Desktop strips from `mMudData`, which once GA-driven holds only this
+     * block (every read's leftovers are posted straight away). Before the first
+     * marker it also still holds whatever partial line the previous reads left
+     * waiting for the posting timer, so a block continuing one does not start
+     * at its own first byte — which is what the held tail stands in for here.
+     */
+    stripPromptBlockNewline(block: string): string;
+    /**
+     * The fix-up above for text posted ahead of an encoding change in a read
+     * (cTelnet::postHeldDataBeforeEncodingChange): it may open a prompt whose
+     * GA the posting hides it from, so once GA-driven its leading newline is
+     * dropped there instead. Null when the fix does not apply — then the GA
+     * still judges the rest of the block.
+     */
+    stripPostedPromptStart(text: string): string | null;
     /** Mudlet `setConfig("undoServerWrap", …)`. Turning it off commits anything
      *  held on the spot rather than stranding it until the next line. */
     setUndoServerWrap(enabled: boolean): void;
     /** Mudlet `setConfig("undoServerWrapWidth", …)`. Applies from the next line;
      *  the held one was already judged against the previous column. */
     setUndoServerWrapWidth(width: number): void;
+    /** Nothing held back: no partial tail and no line waiting on a wrap
+     *  continuation, so no timer of ours has anything to fire on. MudClient
+     *  only pauses between slices of a large read at such a point. */
+    get idle(): boolean;
     /** Drop all held state (call on connect and after close). */
     reset(): void;
     /** Feed one frame's decoded text plus whether the frame carried a prompt
@@ -101,8 +127,9 @@ export declare class LineAssembler {
     /** Flush a held-back partial line (text after the final `\n` of a frame).
      *  Triggered by prompt markers (IAC GA/EOR), the idle-flush timer, or
      *  socket close. Pushes the tail through the normal chunk path so triggers
-     *  and rendering treat it as a complete line. */
-    flush(ts: number, final?: boolean): void;
+     *  and rendering treat it as a complete line. Returns whether any text was
+     *  emitted. */
+    flush(ts: number, final?: boolean): boolean;
     /**
      * Run the whole lines of one ready chunk through the server-wrap join and
      * emit what comes out. With the option off this is `onChunk(ready)` and