@mudlet/mudlet-web 0.3.1 → 0.4.0

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/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;

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

@@ -0,0 +1,191 @@
+/**
+ * Undoing the game's own line wrapping — Mudlet's `undoServerWrap` /
+ * `undoServerWrapWidth` (`TBuffer.cpp`).
+ *
+ * Many MUDs word-wrap their output server-side at a fixed column. That makes
+ * triggers awkward to write (a phrase can be split across two "lines" that were
+ * never separate) and pins the display to the game's width instead of the
+ * window's. Turning the option on holds back any line that ends where the game's
+ * wrapper would have broken it and glues the continuation on, so triggers and
+ * rendering see one whole logical line.
+ *
+ * The heuristics live here as pure functions over *visible* text so they can be
+ * tested directly, and so the pipeline glue in `ScriptingEngine` stays readable.
+ *
+ * **Visible text, not raw.** Mudlet judges `mMudLine`, which is plain characters
+ * with the styling held alongside in a `TChar` buffer. mudix keeps styling
+ * inline as ANSI escapes, so every predicate here takes text that has been put
+ * through {@link visibleText} first — otherwise a colour-heavy line would be
+ * measured as far longer than the player sees, and its escape punctuation would
+ * drag the letter ratio below the prose threshold.
+ */
+/** How far below the configured column a line may end and still count as
+ *  ending *at* it. The game breaks at the last space that fits, so a wrapped
+ *  segment falls up to a word short. Mudlet's `csmServerWrapSlack`. */
+export declare const SERVER_WRAP_SLACK = 15;
+/** Refuse to keep joining past this visible length — a runaway join would
+ *  otherwise swallow a whole screen. Mudlet's `csmServerWrapMaxJoinedLength`. */
+export declare const SERVER_WRAP_MAX_JOINED_LENGTH = 10000;
+/** How much clear room the continuation's first word must have had on the line
+ *  above before that line counts as one the game ended itself. Mudlet's
+ *  `csmServerWrapFitTolerance` — only *clear* room disproves a wrap, because a
+ *  segment inside the join band already sits up to {@link SERVER_WRAP_SLACK}
+ *  short of the column. */
+export declare const SERVER_WRAP_FIT_TOLERANCE = 8;
+/** Longest run of digits a bare list label may carry (`1.`, `12)`, `999.`).
+ *  Mudlet's `csmMaxListNumberDigits`. Bracketed labels are exempt — `[1366]` is
+ *  a label however long it runs, where a bare `1364.` is as likely a price. */
+export declare const MAX_LIST_NUMBER_DIGITS = 3;
+/** How much of a held game line's opening is kept for comparing a continuation
+ *  against. Mudlet's `csmServerWrapSegmentStartChars` — only the first
+ *  {@link SERVER_WRAP_REPEATED_WORDS} shared words and the spaces after them
+ *  have to fall inside it, and that leaves room for it even where a long name
+ *  is one of them. */
+export declare const SERVER_WRAP_SEGMENT_START_CHARS = 48;
+/** How many opening words a continuation has to share with the held segment
+ *  before it is a message the game re-prefixed rather than a wrap. Mudlet's
+ *  `csmServerWrapRepeatedWords` — one is far too common in prose to prove
+ *  anything. */
+export declare const SERVER_WRAP_REPEATED_WORDS = 2;
+/** How long a held-back line waits for its continuation before being committed
+ *  on its own. Mudlet's `csmServerWrapFlushDelayMs`. */
+export declare const SERVER_WRAP_FLUSH_DELAY_MS = 300;
+/** Bounds on `undoServerWrapWidth`, matching Mudlet's `setConfig` validation
+ *  (and the `qBound` its profile-XML import applies). */
+export declare const SERVER_WRAP_WIDTH_MIN = 20;
+export declare const SERVER_WRAP_WIDTH_MAX = 500;
+/** Mudlet's `Host::mUndoServerWrapWidth` default. */
+export declare const SERVER_WRAP_WIDTH_DEFAULT = 80;
+/** Strip ANSI/OSC escapes so a line can be measured and classified the way the
+ *  player sees it. Uses the shared scanner, so it skips CSI, OSC, DCS-family and
+ *  short escapes alike rather than guessing at a regex. */
+export declare function visibleText(line: string): string;
+/**
+ * Mudlet `TBuffer::endsAtServerWrapColumn`. True when a segment's visible length
+ * lands in the `[width - slack, width]` band — i.e. where the game's own word
+ * wrap would have broken it.
+ */
+export declare function endsAtServerWrapColumn(visibleLength: number, width: number): boolean;
+/**
+ * Mudlet `TBuffer::looksLikeWrappedProse`. Word-wrapped prose breaks *between
+ * words*, so a wrapped segment ends in a word (or a sentence mark that happened
+ * to land on the wrap column) and is mostly letters. ASCII art, dividers and
+ * table borders also run right up to the screen width but end in — and are full
+ * of — symbols; gluing those back together would mangle them.
+ *
+ * `visible` must already be ANSI-stripped.
+ */
+export declare function looksLikeWrappedProse(visible: string): boolean;
+/**
+ * Mudlet `TBuffer::segmentEndsSettledSentence`. Where a game swallows the space
+ * it breaks at, a segment that finishes a sentence right on the wrap column
+ * looks exactly like one the game ended there itself — and games end lines on
+ * sentences all the time: a room description, the exits line below it, the
+ * object line below that. Joining those runs separate lines into one and breaks
+ * triggers anchored to their starts.
+ *
+ * A kept break space is the one piece of evidence that settles it, so only a
+ * sentence with nothing at all after it is refused — the check reads the very
+ * last character rather than the last non-space one. What that costs is a
+ * genuine wrap landing exactly after a sentence staying split, which reads as a
+ * break at a sentence boundary; far cheaper than the joins it prevents.
+ *
+ * This belongs at the *hold* decision only: continuations legitimately end
+ * sentences, so {@link looksLikeWrappedProse} must keep accepting them.
+ *
+ * `visible` must already be ANSI-stripped.
+ */
+export declare function segmentEndsSettledSentence(visible: string): boolean;
+/**
+ * Mudlet `TBuffer::continuationRepeatsSegmentOpening`. Games that wrap a tell,
+ * say or channel message themselves put the whole prefix back on every physical
+ * line of it (`Anne teilt Dir mit: …`). Those lines break mid-sentence at the
+ * wrap column and leave no room for the next word, so every other check reads
+ * them as one wrapped paragraph and the join buries the prefix in the middle of
+ * it. The repeated opening is what gives them away — two words of it, because
+ * prose starts line after line with the same article or pronoun and one proves
+ * nothing.
+ *
+ * `segmentStart` is the held *game line's* opening (see
+ * {@link SERVER_WRAP_SEGMENT_START_CHARS}), not the joined paragraph's: a
+ * continuation is compared against the line it actually follows.
+ *
+ * Both strings must already be ANSI-stripped.
+ */
+export declare function continuationRepeatsSegmentOpening(segmentStart: string, visibleNext: string): boolean;
+/**
+ * Mudlet `TBuffer::startsWithListMarker`. A list entry reads exactly like
+ * wrapped prose — a sentence that can end right at the wrap column — so only its
+ * marker tells a list apart from a paragraph.
+ *
+ * Every form accepted here has to be one the game's own word wrap could not
+ * produce at the start of a continuation. The ambiguous ones are deliberately
+ * left out: a spaced dash opens a continuation whenever the wrap lands on it,
+ * and a parenthesised number is as often an aside as a label, so it is capped at
+ * {@link MAX_LIST_NUMBER_DIGITS} like a bare one. Only `[...]` is exempt from
+ * the cap — nothing writes `[2500]` mid-sentence.
+ *
+ * `visible` must already be ANSI-stripped.
+ */
+export declare function startsWithListMarker(visible: string): boolean;
+/**
+ * Mudlet `TBuffer::pendingLineHadRoomForNextWord`. Word wrap breaks a line for
+ * one reason only: the next word did not fit. So a continuation whose first word
+ * would have gone on the game line above it is not a continuation at all — the
+ * game ended that line itself. Without this, two sentences that each stop short
+ * of the wrap column read exactly like one wrapped paragraph.
+ *
+ * `heldSegmentLength` is the length of the last *game line* joined into the held
+ * text, not of the held text itself: once a paragraph has been joined the held
+ * text is longer than the wrap column, and the line the next word would have
+ * landed on is the one the game last sent.
+ *
+ * Both strings must already be ANSI-stripped.
+ */
+export declare function pendingLineHadRoomForNextWord(visiblePending: string, heldSegmentLength: number, visibleNext: string, width: number): boolean;
+/**
+ * Mudlet's guard before joining: a genuine continuation of wrapped prose starts
+ * with a word — or with the single space some games move the break to instead of
+ * swallowing it. *Deeper* indentation, a segment that isn't prose at all, a list
+ * entry, or a first word that would have fitted on the line above all mean the
+ * held line was complete after all and must be committed on its own first.
+ *
+ * `visibleNext` must already be ANSI-stripped.
+ */
+export declare function shouldCommitPendingBeforeJoin(visibleNext: string, nextIsProse: boolean, fit?: {
+    visiblePending: string;
+    heldSegmentLength: number;
+    segmentStart: string;
+    width: number;
+}): boolean;
+/**
+ * Mudlet `TBuffer::joinPendingServerWrapOntoCurrent`. Concatenates the held line
+ * and its continuation, restoring the space the game's wrapper swallowed when
+ * neither side already carries one.
+ *
+ * Operates on the **raw** lines (escapes and all): mudix's styling is inline, so
+ * a plain concatenation carries each half's colour across untouched — the
+ * `TChar`-buffer splice Mudlet needs has no equivalent here. The space-insertion
+ * test looks at the visible text so a trailing colour reset can't hide the space
+ * that is already there.
+ */
+export declare function joinWrappedLines(pending: string, next: string): string;
+/** Lines shorter than this carry no signal about a wrap column. */
+export declare const WRAP_DETECT_MIN_LENGTH = 40;
+/** Evaluate the collected sample only once every this many recorded lines. */
+export declare const WRAP_DETECT_SAMPLE_INTERVAL = 100;
+/** How many lines must sit at the ceiling before it's believable. */
+export declare const WRAP_DETECT_THRESHOLD = 40;
+/** A plausible wrap column has to fall in this range. */
+export declare const WRAP_DETECT_CEILING_MIN = 60;
+export declare const WRAP_DETECT_CEILING_MAX = 160;
+/**
+ * Given the tally of observed line lengths, report the game's apparent wrap
+ * column, or null when the evidence doesn't support one.
+ *
+ * The ceiling is the longest length seen more than incidentally (≥3 times); it
+ * has to be a plausible screen width, carry enough lines just below it, and have
+ * almost nothing beyond it — a game that regularly emits longer lines is not
+ * wrapping at that column.
+ */
+export declare function detectWrapCeiling(counts: ReadonlyMap<number, number>): number | null;