@mudlet/mudlet-web 0.5.0 → 1.0.0

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

@@ -14,7 +14,33 @@ export interface LogFormat {
         g: number;
         b: number;
     };
+    /** Console foreground — the body's text colour, and what an HTML log line
+     *  names for text with no colour of its own (Host::mFgColor). */
+    foreground?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+/** The slice of the profile filesystem the logger writes into. */
+export interface LogVfs {
+    profilePath: string;
+    mkdir(p: string): void;
+    writeFile(p: string, c: string): void;
+    exists(p: string): boolean;
+    readFile(p: string): string;
+    deleteFile(p: string): void;
 }
+/**
+ * Whether a profile was closed while it was logging, so opening it resumes
+ * logging — Host::startSavedLogging, which tests for the `autolog` sentinel
+ * {@link SessionLogger.startFileLog} leaves in the profile directory.
+ */
+export declare function hasSavedLogging(vfs: Pick<LogVfs, 'profilePath' | 'exists'> | null | undefined): boolean;
+/** The line TConsoleModel::toggleLogging opens and closes every log session
+ *  with — `'Log session starting at 'hh:mm:ss' on 'dddd', 'd' 'MMMM' 'yyyy'.'`,
+ *  e.g. "Log session starting at 06:16:55 on Thursday, 1 October 2026." */
+export declare function logSessionLine(kind: 'starting' | 'ending', d: Date): string;
 /**
  * Records one gameplay session to IndexedDB. Subscribes to the session's
  * `message` event — the single choke point every line of output passes
@@ -53,13 +79,7 @@ export declare class SessionLogger {
     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);
+    vfs?: (LogVfs | 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. */
@@ -67,13 +87,15 @@ export declare class SessionLogger {
     /**
      * 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
+     * a Mudlet Web 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:
+     * hand its path straight to something else. Named as Mudlet names its own,
+     * after the moment logging starts (TConsoleModel::toggleLogging's
+     * `logDateTime`), so every start opens a file of 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
@@ -81,26 +103,64 @@ export declare class SessionLogger {
      * {@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. */
+    private autologPath;
+    /** Stop mirroring to the file, writing out whatever is buffered, then the
+     *  "Log session ending at …" line — 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;
+    /** The console colours an HTML log line names for text with none of its own
+     *  (and paints transparent backgrounds with). */
+    private logBackground;
+    private logForeground;
     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;
+    /**
+     * The line most recently given to the file log, not yet written to it —
+     * TBuffer's `lastTextToLog`. Desktop holds every line back by one: the
+     * command the player types at a prompt is written onto the prompt line
+     * after that line was logged, and the line's log text is re-assembled
+     * rather than the command going in on a line of its own; and a trigger on
+     * the next line that deletes this one ("gag the previous line") keeps it
+     * out of the log altogether. Each entry pairs a buffer line with its log
+     * text as it read when it was logged.
+     */
+    private pendingLog;
+    /** `appendLog()` text that arrived while a line was held back, so it is
+     *  written after that line, in arrival order — TBuffer's
+     *  `mTextAppendedToLog`. */
+    private appendedToLog;
+    /** Whether `appendLog()` text went into {@link fileBuffer} since it was
+     *  last written out. */
+    private appendedSinceFlush;
+    private logText;
+    /** Write the held-back line out, unless a script has deleted it from the
+     *  buffer since (TBuffer::deleteLines drops it from the deferred state). */
+    private commitPendingLine;
+    /** A gagged line never reaches {@link capture}, so without this a run of
+     *  them would hold their `appendLog()` text until a line that is not gagged
+     *  arrives. A held prompt stays held, as the command echo still lands on it
+     *  (TBuffer::logTextAppendedBehindPendingLine). */
+    private logTextAppendedBehindPendingLine;
     private capture;
     /**
-     * Mudlet `appendLog(text)` — append an arbitrary line to the current log,
-     * outside the normal output stream. Recorded with type 'appendLog'; any
-     * embedded ANSI is parsed for the HTML snapshot.
+     * Mudlet `appendLog(text)` — TBuffer::appendLog writes the text straight
+     * into the log file: no newline added, nothing escaped or wrapped in HTML,
+     * ANSI codes left as the raw bytes they are. A line still held back for a
+     * possible command echo arrived first, so the text waits behind it and goes
+     * out with it. The log browser still records it as an entry of its own,
+     * with type 'appendLog'.
      */
     appendLine(text: string): void;
     /** Persist any buffered lines and bump the session's end time/count. */
     flush(): Promise<void>;
     private doFlush;
-    /** Detach the listener and write out whatever is buffered. */
+    /** Detach the listener and write out whatever is buffered. The file log is
+     *  left without its closing line, and the autolog sentinel stays, as
+     *  closing a profile that is still logging leaves them on desktop. */
     stop(): Promise<void>;
 }

package/dist-lib/map/MapSelectionOverlay.d.ts

@@ -1,13 +1,13 @@
 import type { MapState, SceneOverlay, SceneOverlayContext, Shape, ViewportBounds } from 'mudlet-map-renderer';
 import type { MapStore } from './MapStore';
-import type { MudixMapReader } from './MudixMapReader';
+import type { MudletMapReader } from './MudletMapReader';
 export declare class MapSelectionOverlay implements SceneOverlay {
     private readonly mapStore;
     private readonly reader;
     private ctx?;
     private mapStoreUnsub?;
     private areaHandler?;
-    constructor(mapStore: MapStore, reader: MudixMapReader);
+    constructor(mapStore: MapStore, reader: MudletMapReader);
     attach(ctx: SceneOverlayContext): void;
     detach(): void;
     render(state: MapState, _bounds: ViewportBounds): Shape[] | void;