npm - @mudlet/mudlet-web - Versions diffs - 0.3.1 → 0.4.0 - Mend

@mudlet/mudlet-web 0.3.1 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (97) hide show

package/README.md +8 -0
package/dist-lib/assets/qt-resources/index.d.ts +16 -0
package/dist-lib/branding.d.ts +1 -1
package/dist-lib/hooks/useMudSession.d.ts +1 -1
package/dist-lib/hooks/useOutput.d.ts +3 -1
package/dist-lib/import/defaultPackages.d.ts +35 -2
package/dist-lib/import/defaults/generic_mapper/generic_mapper.mpackage +0 -0
package/dist-lib/import/defaults/gui-drop/gui-drop.mpackage +0 -0
package/dist-lib/import/defaults/{run-lua-code.mpackage → mudlet-base-ui/mudlet-base-ui.mpackage} +0 -0
package/dist-lib/import/defaults/run-lua-code/run-lua-code.mpackage +0 -0
package/dist-lib/import/packageExport.d.ts +71 -0
package/dist-lib/import/packageInstaller.d.ts +4 -1
package/dist-lib/index.js +45935 -40688
package/dist-lib/logging/SessionLogger.d.ts +66 -1
package/dist-lib/map/MapStore.d.ts +32 -4
package/dist-lib/map/mapImageExport.d.ts +1 -1
package/dist-lib/map/mapZoom.d.ts +71 -0
package/dist-lib/mud/ItemIdSequence.d.ts +23 -0
package/dist-lib/mud/MudSession.d.ts +113 -11
package/dist-lib/mud/PatternEngine.d.ts +6 -1
package/dist-lib/mud/commandSplit.d.ts +16 -0
package/dist-lib/mud/connection/LineAssembler.d.ts +56 -0
package/dist-lib/mud/connection/MudClient.d.ts +120 -16
package/dist-lib/mud/connection/TelnetNegotiator.d.ts +39 -0
package/dist-lib/mud/connection/telnetByteTags.d.ts +35 -0
package/dist-lib/mud/events.d.ts +19 -4
package/dist-lib/mud/games/bundledGames.d.ts +29 -0
package/dist-lib/mud/games/gameIcons.d.ts +5 -0
package/dist-lib/mud/keybindings/KeyEngine.d.ts +9 -2
package/dist-lib/mud/keybindings/browserReservedKeys.d.ts +5 -1
package/dist-lib/mud/keybindings/keyEventTarget.d.ts +17 -0
package/dist-lib/mud/keybindings/qtKeys.d.ts +2 -0
package/dist-lib/mud/protocol/charLoginFlow.d.ts +68 -0
package/dist-lib/mud/protocol/charset.d.ts +27 -5
package/dist-lib/mud/protocol/constants.d.ts +1 -0
package/dist-lib/mud/protocol/gmcp.d.ts +19 -3
package/dist-lib/mud/protocol/index.d.ts +1 -1
package/dist-lib/mud/protocol/mxp.d.ts +28 -5
package/dist-lib/mud/replay/ReplayPlayer.d.ts +17 -0
package/dist-lib/mud/text/Console.d.ts +64 -0
package/dist-lib/mud/text/FormatState.d.ts +66 -3
package/dist-lib/mud/text/hyperlinkVisibility.d.ts +35 -0
package/dist-lib/mud/text/osc8Docs.d.ts +23 -0
package/dist-lib/mud/text/serverWrap.d.ts +191 -0
package/dist-lib/mud/timers/TimerEngine.d.ts +43 -12
package/dist-lib/mud/triggers/TriggerEngine.d.ts +112 -3
package/dist-lib/scripting/EngineHost.d.ts +56 -3
package/dist-lib/scripting/IScriptingRuntime.d.ts +16 -0
package/dist-lib/scripting/MxpFrameManager.d.ts +118 -0
package/dist-lib/scripting/ScriptingAPI.d.ts +323 -54
package/dist-lib/scripting/ScriptingEngine.d.ts +180 -23
package/dist-lib/scripting/http/HttpService.d.ts +51 -1
package/dist-lib/scripting/lua/LuaRuntime.d.ts +151 -2
package/dist-lib/scripting/lua/bindings/map.d.ts +0 -12
package/dist-lib/scripting/lua/utf8Patterns.d.ts +59 -0
package/dist-lib/storage/index.d.ts +1 -1
package/dist-lib/storage/persistentStorage.d.ts +10 -0
package/dist-lib/storage/schema.d.ts +116 -0
package/dist-lib/styles.css +1 -1
package/dist-lib/ui/BundledGameGrid.d.ts +21 -0
package/dist-lib/ui/CommandBar.d.ts +7 -1
package/dist-lib/ui/ConnectionGrid.d.ts +4 -1
package/dist-lib/ui/FilePickerModal.d.ts +3 -3
package/dist-lib/ui/HelpModal.d.ts +11 -0
package/dist-lib/ui/LogBrowserModal.d.ts +4 -1
package/dist-lib/ui/PlayerMarkerPreview.d.ts +20 -0
package/dist-lib/ui/Toolbar.d.ts +2 -1
package/dist-lib/ui/VfsPickerModal.d.ts +26 -0
package/dist-lib/ui/components/FileSourceButton.d.ts +47 -0
package/dist-lib/ui/components/index.d.ts +1 -0
package/dist-lib/ui/helpTopics.d.ts +19 -0
package/dist-lib/ui/labels/LabelManager.d.ts +7 -0
package/dist-lib/ui/layout/ScriptWindow.d.ts +11 -2
package/dist-lib/ui/markdown.d.ts +10 -1
package/dist-lib/ui/output/OutputArea.d.ts +11 -1
package/dist-lib/ui/output/OutputContextMenu.d.ts +3 -1
package/dist-lib/ui/output/OutputRenderer.d.ts +7 -1
package/dist-lib/ui/output/OutputSearchBar.d.ts +25 -0
package/dist-lib/ui/output/StickyOutputPanel.d.ts +5 -1
package/dist-lib/ui/output/outputSearch.d.ts +130 -0
package/dist-lib/ui/search/matcher.d.ts +15 -0
package/dist-lib/ui/search/useDebounced.d.ts +3 -0
package/dist-lib/ui/tts/TtsManager.d.ts +3 -0
package/dist-lib/ui/useCommandHistory.d.ts +4 -2
package/dist-lib/ui/useOpenProfiles.d.ts +26 -0
package/dist-lib/ui/video/VideoManager.d.ts +17 -0
package/dist-lib/ui/windows/WindowManager.d.ts +132 -2
package/dist-lib/ui/windows/panels/MapPanel.d.ts +4 -1
package/dist-lib/ui/windows/panels/PackageExportModal.d.ts +18 -0
package/dist-lib/ui/windows/panels/TextPanel.d.ts +3 -1
package/dist-lib/ui/windows/types.d.ts +35 -0
package/dist-lib/utils/describeThrown.d.ts +22 -0
package/dist-lib/utils/fontLoader.d.ts +5 -0
package/dist-lib/vite.js +22 -0
package/package.json +10 -6
package/dist-lib/scripting/lua/mudlet-lua/generic-mapper/generic_mapper.mpackage +0 -0
package/dist-lib/ui/windows/panels/VfsModulePickerModal.d.ts +0 -8

package/dist-lib/logging/SessionLogger.d.ts CHANGED Viewed

@@ -1,4 +1,20 @@
 import type { MudSession } from '../mud/MudSession';
+/**
+ * How the file log is written. Mudlet's `logInHTML` picks between two genuinely
+ * different documents, and the HTML one has to name the console's own font and
+ * background — neither of which the logger can see for itself.
+ */
+export interface LogFormat {
+    html: boolean;
+    /** Resolved console font family, the one `getFont()` reports. */
+    font?: string;
+    /** Console background, painted behind the whole document as Mudlet does. */
+    background?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
 /**
  * Records one gameplay session to IndexedDB. Subscribes to the session's
  * `message` event — the single choke point every line of output passes
@@ -14,9 +30,19 @@ export declare class SessionLogger {
     private readonly session;
     private readonly connectionId;
     private readonly connectionName;
+    /** Profile filesystem the plain-text log is written into. Optional: the
+     *  IndexedDB record is the primary log and works without one. */
+    private readonly vfs?;
     private readonly sessionId;
     private readonly startedAt;
     private buffer;
+    /** Absolute VFS path of the plain-text log, or null when there is no VFS to
+     *  write one into. See {@link openLogFile}. */
+    private logFilePath;
+    /** Lines written to the text log but not yet flushed to the VFS. Kept
+     *  separate from `buffer` (the IndexedDB batch) because the two flush on
+     *  different triggers and the text log has to survive an IDB failure. */
+    private fileBuffer;
     private seq;
     private totalCount;
     private flushTimer;
@@ -24,8 +50,47 @@ export declare class SessionLogger {
     private sessionCreated;
     /** Serializes flushes so a size-triggered flush can't race the timer. */
     private flushing;
-    constructor(session: MudSession, connectionId: string, connectionName: string);
+    constructor(session: MudSession, connectionId: string, connectionName: string,
+    /** Profile filesystem the plain-text log is written into. Optional: the
+     *  IndexedDB record is the primary log and works without one. */
+    vfs?: {
+        profilePath: string;
+        mkdir(p: string): void;
+        writeFile(p: string, c: string): void;
+        exists(p: string): boolean;
+        readFile(p: string): string;
+    } | null | undefined);
     start(): void;
+    /** Where this session's plain-text log is being written, or null when the
+     *  file log is off. Backs Mudlet's `startLogging` path return. */
+    get filePath(): string | null;
+    /**
+     * Mudlet's `startLogging(true)` — begin mirroring output to a file as well.
+     * Deliberately separate from {@link start}: recording to the log browser is
+     * a mudix profile setting that is on by default, whereas Mudlet's file log
+     * is something a player or script asks for. Sharing one switch would have
+     * every profile quietly writing a file nobody asked for, and would make
+     * `startLogging(true)` report "already on" for ever.
+     *
+     * The file is created up front, before any line has arrived, so a script can
+     * hand its path straight to something else. Named as Mudlet names its own:
+     * `<profile>/log/<yyyy-MM-dd#hh-mm-ss>.txt` — or `.html` when `format.html`
+     * is set (Mudlet's `logInHTML`), which is a whole second document format
+     * rather than the same lines with markup: a `<html>` wrapper, a stylesheet
+     * naming the console's own font and background, and a closing tag pair only
+     * {@link stopFileLog} writes.
+     */
+    startFileLog(format?: LogFormat): string | null;
+    /** Stop mirroring to the file, writing out whatever is buffered — and, for
+     *  an HTML log, the closing tags that make it a document. */
+    stopFileLog(): void;
+    /** Whether the open file log is HTML rather than plain text. */
+    private logHtml;
+    private openLogFile;
+    /** Append the buffered lines to the log file. ZenFS has no
+     *  append mode we can rely on across both backends, so this re-writes the
+     *  file with the new tail — hence the buffering. */
+    private flushLogFile;
     private capture;
     /**
      * Mudlet `appendLog(text)` — append an arbitrary line to the current log,

package/dist-lib/map/MapStore.d.ts CHANGED Viewed

@@ -168,6 +168,7 @@ export declare class MapStore {
     profileName: string;
     private mapEventDispatcher;
     private mapInfoContributors;
+    private pendingMapInfoEnabled;
     private builtinMapInfo;
     private mapInfoEvaluator;
     constructor();
@@ -232,6 +233,14 @@ export declare class MapStore {
      * adding rooms). Returns true.
      */
     deleteMap(): boolean;
+    /**
+     * Mudlet `T2DMap::slot_newMap` — the mapper's "Create new map" action,
+     * offered when the profile has no map at all. Wipes to a fresh empty map
+     * and seeds it with a single room at the origin of the default area (-1),
+     * marked as the player's position so the marker and the opening view both
+     * land on it. Returns the new room's id.
+     */
+    createNewMap(): number;
     toRendererData(): MapRendererData | null;
     /**
      * Mudlet `saveJsonMap(path)` backbone — serialise the entire MapStore as a
@@ -707,9 +716,15 @@ export declare class MapStore {
     searchAreaUserData(key?: string, value?: string): string[] | number[];
     /**
      * Per-area 2D-map zoom stored in the map file (area userData under
-     * {@link AREA_ZOOM_KEY}). Returns `undefined` when the area is missing or has
-     * no saved zoom (caller falls back to fitArea). Mirrors Mudlet's treatment of
-     * zoom as map data rather than client config.
+     * {@link AREA_ZOOM_KEY}), in Mudlet units. Returns `undefined` when the area
+     * is missing or has no usable saved zoom, in which case the caller opens at
+     * {@link DEFAULT_MAP_ZOOM}. Mirrors Mudlet's treatment of zoom as map data
+     * rather than client config.
+     *
+     * A value below {@link MIN_MAP_ZOOM} is treated as absent, exactly as
+     * TMap::restore does with the same key — it can only come from a corrupt or
+     * foreign write, and honouring it would open the area zoomed in past the
+     * limit the wheel itself enforces.
      */
     getAreaZoom(id: number): number | undefined;
     /**
@@ -719,7 +734,10 @@ export declare class MapStore {
      * handler calls this on every wheel tick; notifying would rebuild the whole
      * scene on each one. The value persists to IndexedDB the next time the map is
      * serialised (saveMap → toMudletMapForSave). Returns false when the area is
-     * missing or the zoom isn't a positive finite number.
+     * missing or the zoom is below {@link MIN_MAP_ZOOM} — TArea::set2DMapZoom
+     * silently ignores those too, and the floor is what stops a bad reading (a
+     * fit computed against a not-yet-laid-out 0×0 panel, say) from being written
+     * out and then restored on every subsequent open.
      */
     setAreaZoom(id: number, zoom: number): boolean;
     /**
@@ -892,6 +910,16 @@ export declare class MapStore {
     };
     enableMapInfo(label: string): boolean;
     disableMapInfo(label: string): boolean;
+    /** Mudlet `setConfig("showMapInfo", label)` — switch a map-info overlay on.
+     *  Unlike `enableMapInfo`, an unknown label is *not* an error: Mudlet inserts
+     *  the name straight into `mMapInfoContributors` without consulting the
+     *  registry, so the overlay lights up if and when something registers under
+     *  that label. Always succeeds, matching setConfig's unconditional success. */
+    showMapInfo(label: string): void;
+    /** Mudlet `setConfig("hideMapInfo", label)` — switch a map-info overlay off.
+     *  Clears a pending enable as well, so hiding a label that was turned on
+     *  before its contributor existed actually cancels it. */
+    hideMapInfo(label: string): void;
     /** Snapshot for tests / debug. The panel goes through evaluateMapInfos. */
     getMapInfoContributors(): MapInfoContributor[];
     /** Run every enabled contributor and collect their (text, style, color)

package/dist-lib/map/mapImageExport.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import type { Settings as MapRendererSettings } from 'mudlet-map-renderer';
 import type { MapStore } from './MapStore';
-import type { MapperSettings } from '../storage';
+import { type MapperSettings } from '../storage/schema';
 /**
  * Copy user-set fields from MapperSettings onto a live renderer settings
  * object. Anything left undefined in `mapper` is intentionally not touched

package/dist-lib/map/mapZoom.d.ts ADDED Viewed

@@ -0,0 +1,71 @@
+import type { MapRenderer } from 'mudlet-map-renderer';
+/**
+ * Map-view zoom: the two units it comes in, and the policy for opening an area.
+ *
+ * Two different numbers are both called "zoom", and mixing them is what made
+ * maps open absurdly far in or out:
+ *
+ *  - **renderer zoom** — a scale multiplier; `camera.getScale() === BASE_SCALE *
+ *    zoom` is the pixels drawn per map unit. Bigger = zoomed in. A pure renderer
+ *    concept that only means anything paired with the current viewport size.
+ *  - **Mudlet zoom** — how many map units the *shorter* viewport edge spans
+ *    (T2DMap's `xyzoom`: 3 → 3 rooms across, 100 → ~100). Bigger = zoomed *out*.
+ *    This is what `getMapZoom`/`setMapZoom` speak and what gets persisted into
+ *    the map file, because it survives the panel being a different size in a
+ *    later session.
+ *
+ * Everything outside the renderer is in Mudlet units; {@link toMudletZoom} and
+ * {@link toRendererZoom} convert at that boundary.
+ */
+/** Mudlet's hard floor for the 2D map zoom (T2DMap `csmMinXYZoom`): the shorter
+ *  viewport edge may never span fewer than this many map units, i.e. you can't
+ *  zoom in any closer. Mirrored so wheel/pinch zoom obeys the same limit. */
+export declare const MUDLET_MIN_MAP_ZOOM = 3;
+/** Mudlet's `T2DMap::csmDefaultXYZoom` — what an area opens at when it has no
+ *  remembered zoom of its own. */
+export declare const MUDLET_DEFAULT_MAP_ZOOM = 20;
+/** How far past "the whole area exactly fills the panel" the user may keep
+ *  zooming out. The renderer's `fitToMapBounds` ends with `minZoom = zoom`, so
+ *  every `fitArea()` pins the zoom-out floor to that exact fit — the wheel then
+ *  stops dead with the area flush against the panel edges, and there's no way
+ *  to pull back for context or to see where an area sits relative to its
+ *  surroundings. Relaxing the floor afterwards restores that headroom. */
+export declare const ZOOM_OUT_HEADROOM = 4;
+/**
+ * The renderer's current view expressed in Mudlet units, or null when the camera
+ * has no usable size yet.
+ *
+ * A panel that hasn't been laid out reports 0×0, and a "zoom" derived from that
+ * is meaningless — persisting one is exactly how an area got stuck at a few
+ * pixels per room on every subsequent open.
+ */
+export declare function toMudletZoom(renderer: MapRenderer): number | null;
+/**
+ * The renderer zoom that makes `mudletZoom` map units span the shorter viewport
+ * edge, or null when the camera isn't sized (see {@link toMudletZoom}) or the
+ * request isn't a positive number.
+ */
+export declare function toRendererZoom(renderer: MapRenderer, mudletZoom: number): number | null;
+/** Fit the area, then relax the floor the fit just pinned (see
+ *  {@link ZOOM_OUT_HEADROOM}). Use everywhere instead of `renderer.fitArea()`. */
+export declare function fitAreaWithHeadroom(renderer: MapRenderer): void;
+/**
+ * Open an area at its remembered zoom, or at Mudlet's default when it has none,
+ * with a zoom-out floor derived from the area's actual extent.
+ *
+ * The fit runs first, but only for the floor it leaves behind — it is the only
+ * thing that derives one from how big the area actually is. The camera's own
+ * default floor is a fixed 0.05 with no relation to map size: on any map larger
+ * than the viewport that sits far *above* the zoom needed to see the whole thing,
+ * so opening without fitting first leaves the wheel pinned at a floor from which
+ * the map can never be framed.
+ *
+ * The fit deliberately does NOT survive as the opening view. Mudlet never fits an
+ * area to the widget — T2DMap opens at `TArea::mLast2DMapZoom`, defaulting to
+ * `csmDefaultXYZoom`. Fitting produced both halves of a reported bug: a four-room
+ * area fitted to roughly one room per screen (the fit of a 1×1-unit extent is
+ * already past Mudlet's zoom-in limit), while a city-sized area fitted to rooms a
+ * few pixels wide. A fixed unit count is scale-free and gives both the same
+ * legible room size.
+ */
+export declare function applyAreaZoom(renderer: MapRenderer, savedZoom: number | null | undefined): void;

package/dist-lib/mud/ItemIdSequence.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+/**
+ * The one source of item ids in a profile.
+ *
+ * Mudlet hands every trigger, alias, timer, key, button and script its id from
+ * a single running number — temporary and permanent alike — so `tempAlias()`
+ * followed by `permAlias()` followed by `tempAlias()` yields n, n+1, n+2. mudix
+ * grew a counter per engine plus one for the permanent tree, which meant a
+ * temporary item and a permanent one could be handed the *same* id: two
+ * different things answering to one number, which `killAlias(id)` and
+ * `exists(name)` then could not tell apart.
+ *
+ * Injected rather than constructed in place (see {@link ScriptingEngine}, which
+ * hands its own sequence to each engine) so every engine in a profile draws
+ * from the same one, while a bare engine built for a unit test still works with
+ * a private sequence of its own.
+ */
+export declare class ItemIdSequence {
+    private n;
+    next(): number;
+    /** Ensure future ids exceed `id` — used when an id arrives from outside the
+     *  sequence (a restored profile, say) so it can never be handed out twice. */
+    reserve(id: number): void;
+}

package/dist-lib/mud/MudSession.d.ts CHANGED Viewed

@@ -54,6 +54,10 @@ export declare class MudSession {
     private lastUrl;
     private pingTracker;
     private stateUnsubs;
+    /** The profile's server encoding, as `getServerEncodingsList()` spells it.
+     *  Lives here rather than on the client so it survives having none — see
+     *  {@link getServerEncoding}. */
+    private serverEncoding;
     private _status;
     private _ping;
     private _outputReady;
@@ -114,11 +118,53 @@ export declare class MudSession {
      *  local echo, under the current showSentText mode. `script` defers to the
      *  flag; `always`/`never` ignore it. */
     private shouldEchoSentText;
+    /** Set by ScriptingAPI while trigger-mode echo deferral owns the main
+     *  console's in-flight partial line (beginLine → flushDeferredEcho). Read
+     *  by {@link echoCommand}, which must not close a partial the deferral is
+     *  about to emit itself. */
+    scriptEchoDeferred: boolean;
+    /** Host::send's echo stage: print a command the player (or an item acting
+     *  for them) sent, under the showSentText mode. `wantPrint` is the per-call
+     *  flag `script` mode defers to — `always` and `never` overrule it. */
+    echoSentCommand(text: string, wantPrint: boolean): void;
     echoCommand(text: string): void;
     /** Wrap the echoed command in ANSI truecolor escapes from commandEchoColor
      *  so it renders in the configured foreground (and optional background). */
     private styleEchoCommand;
-    send(text: string, echo?: boolean): void;
+    /** `isGameCommand` mirrors `cTelnet::sendData`'s flag — see
+     *  {@link MudClient.send}. Everything the player or a script submits is one;
+     *  auto-login credentials are not, so they can't arm character-at-a-time
+     *  detection. */
+    send(text: string, echo?: boolean, isGameCommand?: boolean): void;
+    /**
+     * `cTelnet::sendData` — put one command on the wire with **no** local echo
+     * under any showSentText mode.
+     *
+     * Mudlet echoes player input exactly once, at the top of `Host::send`,
+     * before the command separator split and before aliases see it (see
+     * {@link ScriptingEngine.hostSend}); the parts that come out the far side
+     * must not echo again. `send(text, false)` cannot express that — `always`
+     * overrides the per-call flag — which is the same reason
+     * {@link sendSecret} exists. Unlike sendSecret this is an ordinary command:
+     * it still warns about text the server encoding can't carry.
+     */
+    sendData(text: string, isGameCommand?: boolean): void;
+    /** Mudlet's `mEncodingWarningIssued`: once per encoding, not once per
+     *  command, so a script sending in a loop doesn't paper the screen. Reset by
+     *  {@link setServerEncoding} / {@link noteNegotiatedEncoding}, because the
+     *  new encoding may have no trouble with what the old one couldn't say. */
+    private encodingWarningIssued;
+    /**
+     * Warn when a command cannot survive the trip to the game — cTelnet::sendData
+     * posts this before sending anyway, and so do we: the server may still make
+     * something of what arrives, and silently dropping the command would be
+     * worse than sending it mangled.
+     *
+     * Warning here rather than in MudClient is deliberate: the encoding belongs
+     * to the profile, not the socket, and a player typing at a client that isn't
+     * connected yet has just as much use for the notice.
+     */
+    private warnIfUnencodable;
     /** Send credentials/secrets that must NEVER be echoed locally — regardless of
      *  the showSentText mode (including `always`) or the server-echo state. Used
      *  for auto-login passwords. The normal `send(text, false)` only suppresses
@@ -135,6 +181,15 @@ export declare class MudSession {
     sendSocket(data: string): boolean;
     /** True when there is no live socket — see MudClient.isSocketUnconnected. */
     isSocketUnconnected(): boolean;
+    /** Mudlet `feedTelnet(data)`. Injects raw bytes into the inbound pipeline as
+     *  if the server had sent them.
+     *
+     *  Works with no connection, which is the state the API is *for*: Mudlet
+     *  refuses to inject into a live socket (it would interleave with the real
+     *  stream), so every caller — its own test suite included — is offline by
+     *  definition. With no client there is no pipeline to inject into, so this
+     *  borrows the detached one replay playback already builds for the same
+     *  reason: the telnet/ANSI/trigger path needs no socket to run. */
     feedTelnet(data: string): void;
     sendATCP(message: string): boolean;
     sendTelnetChannel102(msg: string): boolean;
@@ -144,6 +199,10 @@ export declare class MudSession {
     get replaySpeed(): number;
     get isReplayRecording(): boolean;
     get isReplaying(): boolean;
+    /** Deliver any replay chunk that has come due. See ReplayPlayer.pumpDue —
+     *  a script standing in for the event loop has to drive this queue too, or a
+     *  replay it started never advances past its first chunk. */
+    pumpReplay(): number;
     /** Set the playback speed divisor, clamped to Mudlet's 1..1024 range.
      *  Takes effect from the next chunk of an active replay. */
     setReplaySpeed(speed: number): void;
@@ -162,23 +221,35 @@ export declare class MudSession {
     /** Stop the active replay without delivering its remaining chunks.
      *  Returns false when no replay is running. */
     abortReplay(): boolean;
-    /** The client whose parsing pipeline replay chunks feed into. Reuses the
-     *  live client when one exists; otherwise creates a detached MudClient
-     *  that is never connect()ed — the inbound pipeline works without a
-     *  socket, and any replies the replayed IAC traffic provokes are dropped
-     *  by the readyState guards, which is exactly right for playback. */
-    private ensureReplayClient;
+    /** The client whose parsing pipeline injected bytes feed into — replay
+     *  chunks and feedTelnet alike. Reuses the live client when one exists;
+     *  otherwise creates a detached MudClient that is never connect()ed — the
+     *  inbound pipeline works without a socket, and any replies the injected IAC
+     *  traffic provokes are dropped by the readyState guards, which is exactly
+     *  right when nothing is listening for them. */
+    private ensureParsingClient;
     private postReplayInfo;
     /** Mudlet `reconnect()`. Disconnect and redial the most recently connected
      *  URL (set by connect(), so it covers both the app and Lua connect paths).
      *  Returns false when nothing has been dialed yet. */
     reconnect(): boolean;
-    /** Mudlet `getServerEncoding()`. The live client's inbound decoder name;
-     *  'utf-8' when no client is attached. */
+    /**
+     * Mudlet `getServerEncoding()` / `setServerEncoding(name)`.
+     *
+     * The encoding is the profile's, not the socket's: it can be read and
+     * changed with nothing dialed, and the setting carries across a connect.
+     * A live client is told about the change so its decoder follows, and a
+     * CHARSET negotiation writes the agreed name back here — but the client is
+     * not where the answer comes from. It used to be, which made both functions
+     * inert until a connection existed, and the name they reported was the
+     * decoder's IANA spelling ("utf-8") rather than the one the caller chose
+     * ("UTF-8" as `getServerEncodingsList()` spells it).
+     */
     getServerEncoding(): string;
-    /** Mudlet `setServerEncoding(name)`. Returns false when no client is
-     *  attached or the name isn't supported. */
     setServerEncoding(name: string): boolean;
+    /** Called when CHARSET negotiation settles on a name, so the profile-level
+     *  setting reflects what the connection actually agreed. */
+    noteNegotiatedEncoding(name: string): void;
     /** Mudlet `getServerEncodingsList()`. The fixed set of encodings mudix can
      *  decode — available even before a connection is dialed. */
     getServerEncodingsList(): string[];
@@ -194,6 +265,37 @@ export declare class MudSession {
     /** Mudlet `setConfig("fixUnnecessaryLinebreaks", …)`. Updates the live client
      *  and the stored options so the setting survives a reconnect. */
     setFixUnnecessaryLinebreaks(enabled: boolean): void;
+    /** Mudlet `Host::mUndoServerWrap` / `mUndoServerWrapWidth`, as getConfig
+     *  reads them back. */
+    get undoServerWrap(): boolean;
+    get undoServerWrapWidth(): number;
+    /** Mudlet `setConfig("undoServerWrap", …)`. Updates the live client and the
+     *  stored options so the setting survives a reconnect. */
+    setUndoServerWrap(enabled: boolean): void;
+    /** Mudlet `setConfig("undoServerWrapWidth", …)`. */
+    setUndoServerWrapWidth(width: number): void;
+    /** Commit a line held for a wrap continuation whose flush delay has passed —
+     *  the busted `pumpEvents` path, which cannot wait for a real timer. */
+    pumpServerWrap(): boolean;
+    /** Mudlet `setConfig("inputLineStrictUnixEndings", …)`. Live — the next
+     *  command submitted uses the new line terminator. */
+    setInputLineStrictUnixEndings(enabled: boolean): void;
+    /** Mudlet `setConfig("specialForceGAOff", …)`. Stored for the next dial, and
+     *  applied at once to a client that is not connected — which is the state a
+     *  profile driving `feedTelnet` is in, and the only one where Mudlet lets
+     *  the change land early. See MudClient.setForceGaOff. */
+    setSpecialForceGAOff(enabled: boolean): void;
+    /** Mudlet `setConfig("versionInTTYPE", …)` / `("promptForVersionInTTYPE", …)`.
+     *  Stored only: TTYPE is negotiated at connect, so both take effect on the
+     *  next dial — the same reconnect requirement Mudlet's own auto-detect works
+     *  around by redialing for you. */
+    setVersionInTTYPE(enabled: boolean, prompted?: boolean): void;
+    /** Mudlet `setConfig("promptForMXPProcessorOn", …)` / `("specialForceMXPProcessorOn", …)`.
+     *  Stored only — together they gate whether an in-band `ESC[<n>z` may still
+     *  auto-start MXP, which the negotiator decides at connect. The *parser*
+     *  side of `specialForceMXPProcessorOn` is applied live by ScriptingEngine;
+     *  this is just the detection gate. */
+    setMxpProcessorFlags(prompted: boolean, forced: boolean): void;
     /** Mudlet `setConfig("controlCharacterHandling", …)`. Applies immediately —
      *  every console/text window re-renders control characters (and tab-stops)
      *  under the new mode on their next paint. */

package/dist-lib/mud/PatternEngine.d.ts CHANGED Viewed

@@ -14,7 +14,12 @@ export declare class PatternEngine<T extends PatternItem> {
         pattern: RegExp;
         fn: TempFn;
     }>;
-    protected nextId: number;
+    /** Key for this engine's own temp map. NOT an item id: addTemp hands the
+     *  caller an unsubscribe function, and the id Lua sees is allocated by the
+     *  runtime from the profile's shared sequence. Drawing from that sequence
+     *  here would burn a number per temp item and put permAlias/tempAlias out
+     *  of step (Alias_spec pins the run of ids). */
+    protected nextInternalId: number;
     protected permCompiled: Array<{
         item: T;
         re: RegExp;

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

@@ -0,0 +1,16 @@
+/**
+ * The command-separator split from Mudlet's `Host::send`.
+ *
+ * One line typed (or one `command` field on an alias/key/trigger/timer/button)
+ * can carry several commands, joined by the profile's separator — `;;` by
+ * default. Mudlet splits with `Qt::SkipEmptyParts`, so `n;;;;s` is two commands
+ * rather than three, and a line that is nothing but separators collapses to
+ * nothing at all.
+ *
+ * An empty result is meaningful: Mudlet answers it by putting a bare line feed
+ * on the wire, so pressing Enter on an empty command line still reaches the
+ * game (menus, "more" prompts). Callers handle that case themselves — see
+ * {@link ScriptingEngine.hostSend} — which is why this returns `[]` rather than
+ * quietly inventing an empty command.
+ */
+export declare function splitCommands(text: string, separator: string): string[];

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

@@ -19,6 +19,11 @@ export interface LineAssemblerCallbacks {
 }
 export interface LineAssemblerOptions {
     promptTimeoutMs?: number;
+    /** Mudlet `Host::mUndoServerWrap` — rejoin lines the game hard-wrapped
+     *  itself. Off by default; toggled live via setConfig. */
+    undoServerWrap?: boolean;
+    /** Mudlet `Host::mUndoServerWrapWidth` — the column the game wraps at. */
+    undoServerWrapWidth?: number;
     /** Mudlet `mUSE_IRE_DRIVER_BUGFIX` — strip a spurious leading newline from
      *  GA-driven prompt blocks. Off by default; toggled live via
      *  setFixUnnecessaryLinebreaks (setConfig). */
@@ -58,6 +63,19 @@ export declare class LineAssembler {
      *  the block's leading-newline question has been settled. */
     private atPromptBlockStart;
     private fixUnnecessaryLinebreaks;
+    private undoServerWrap;
+    private undoServerWrapWidth;
+    private serverWrapPending;
+    /** Visible length of the last *game line* joined into the held text — what
+     *  the next word is measured against, not the whole joined paragraph. */
+    private serverWrapPendingSegmentLength;
+    /** Opening of that same game line, kept so a continuation repeating it can
+     *  be told from one that carries on where it left off. */
+    private serverWrapPendingSegmentStart;
+    private serverWrapTimer;
+    /** When the held line falls due, so a blocked event loop can still commit it
+     *  on demand — see {@link pumpServerWrapDue}. */
+    private serverWrapDeadline;
     constructor(callbacks: LineAssemblerCallbacks, options?: LineAssemblerOptions);
     /** True once the session has latched into GA-driven prompt mode. */
     get gaDriver(): boolean;
@@ -66,6 +84,12 @@ export declare class LineAssembler {
     /** Mudlet `setConfig("fixUnnecessaryLinebreaks", …)`. Takes effect on the
      *  next GA-driven block; never retroactive. */
     setFixUnnecessaryLinebreaks(enabled: boolean): void;
+    /** 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;
     /** 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
@@ -79,6 +103,38 @@ export declare class LineAssembler {
      *  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;
+    /**
+     * 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
+     * nothing else.
+     *
+     * Mudlet decides this per '\n' inside `TBuffer::append`, gated on the line
+     * having come from the server: everything else (prompts, timer-flushed
+     * fragments, MXP `<br>`, blank lines) is a real boundary. Here the gate is
+     * structural — this is the only path whole server lines take, and
+     * feedTriggers/echoes never reach it.
+     */
+    private emitServerLines;
+    /**
+     * Offer one whole server line to the join. Returns the text to commit —
+     * newline-terminated lines, or the empty string when the line was held back
+     * for a continuation.
+     */
+    private consumeServerLine;
+    /** Take the held line, if any, and stop its timer. */
+    private takeServerWrapPending;
+    /** Commit the held line on its own, as its own chunk. */
+    private commitServerWrapPending;
+    /**
+     * Commit a held line whose flush delay has elapsed. The timer below cannot
+     * be relied on alone: a busted run is one synchronous call sitting on top of
+     * the event loop, so no `setTimeout` of ours can fire until it returns. The
+     * spec's `pumpEvents` reaches this instead, exactly as it reaches the Lua
+     * timer queue and the replay player. Returns true when a line was committed.
+     */
+    pumpServerWrapDue(now?: number): boolean;
+    private startServerWrapTimer;
+    private clearServerWrapTimer;
     private scheduleTailFlush;
     private clearTailTimer;
 }