@mudlet/mudlet-web 0.3.0

package/dist-lib/scripting/StopwatchManager.d.ts

@@ -0,0 +1,94 @@
+/** Backing store for persistent stopwatches (localStorage in the browser). */
+export interface StopwatchStore {
+    load(): string | null;
+    save(data: string): void;
+}
+/** Build a localStorage-backed store scoped to a connection, or undefined when
+ *  localStorage is unavailable (tests / SSR) — in which case persistence is a
+ *  no-op and watches behave as memory-only. */
+export declare function localStorageStopwatchStore(connectionId: string): StopwatchStore | undefined;
+/** Broken-down elapsed time, mirroring Mudlet's generateElapsedTimeTable. */
+export interface BrokenDownTime {
+    negative: boolean;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliSeconds: number;
+    /** Signed total seconds (matches Mudlet's elapsedMilliSeconds / 1000). */
+    decimalSeconds: number;
+}
+/** Per-watch record returned by getStopWatches (keyed by stringified id). */
+export interface StopwatchSummary {
+    name: string;
+    isRunning: boolean;
+    isPersistent: boolean;
+    elapsedTime: BrokenDownTime;
+}
+export declare class StopwatchManager {
+    private readonly storage?;
+    private readonly watches;
+    private nextId;
+    constructor(storage?: StopwatchStore | undefined);
+    private now;
+    private elapsedMs;
+    /**
+     * Resolve a watchID-or-name argument. Numbers (and numeric strings, which
+     * Mudlet's lua_isnumber treats as ids) look up by id; other strings look up
+     * by name. An empty string returns the first unnamed watch — Mudlet's
+     * findStopWatchId("") behaviour.
+     */
+    private resolve;
+    /** Rehydrate persistent watches from the backing store (called once on construction). */
+    private restore;
+    /** Write the current set of persistent watches to the backing store. */
+    private persist;
+    /**
+     * Mudlet createStopWatch([name], [autostart]). Returns the new id, or null
+     * when `name` is given and already in use (Mudlet rejects duplicate names).
+     */
+    create(name: string, autoStart: boolean): number | null;
+    /**
+     * Mudlet startStopWatch. `resetAndRestart` replicates the legacy behaviour
+     * for a numeric id called bare: reset to zero and run from there. Otherwise
+     * a stopped watch resumes and a running one is left untouched. Returns false
+     * for an unknown watch.
+     */
+    start(arg: number | string, resetAndRestart: boolean): boolean;
+    /**
+     * Mudlet stopStopWatch. Pauses the watch and returns the elapsed seconds
+     * once (legacy behaviour preserved by Mudlet). null for an unknown watch.
+     */
+    stop(arg: number | string): number | null;
+    /** Mudlet getStopWatchTime — elapsed seconds without stopping. */
+    getTime(arg: number | string): number | null;
+    /** Mudlet getStopWatchBrokenDownTime — elapsed time as a day/hour/minute/
+     *  second/millisecond table. null for an unknown watch. */
+    getBrokenDownTime(arg: number | string): BrokenDownTime | null;
+    /**
+     * Mudlet setStopWatchName(watchID|currentName, newName). Assigns or renames
+     * a watch. Returns false for an unknown watch, an empty new name, or when
+     * another watch already uses the new name (Mudlet rejects duplicate names).
+     */
+    /**
+     * Mudlet `setStopWatchName(id|name, newName)`. Refuses a name another
+     * stopwatch already carries, naming that one — the reason has to reach the
+     * caller, so this returns the message (null on success) rather than a bare
+     * boolean the binding would have to guess a reason for.
+     */
+    setName(arg: number | string, newName: string): boolean | string;
+    /** Mudlet resetStopWatch — zero the elapsed time; a running watch keeps running. */
+    reset(arg: number | string): boolean;
+    /** Mudlet adjustStopWatch — add `seconds` (may be negative) to the elapsed time. */
+    adjust(arg: number | string, seconds: number): boolean;
+    /** Mudlet deleteStopWatch. */
+    delete(arg: number | string): boolean;
+    /**
+     * Mudlet setStopWatchPersistence(id|name, state). Marks whether the watch is
+     * saved to (and restored from) the backing store across reloads. Returns
+     * false for an unknown watch.
+     */
+    setPersistence(arg: number | string, state: boolean): boolean;
+    /** Mudlet getStopWatches — record keyed by stringified id (Bridge.lua re-keys to ints). */
+    getAll(): Record<string, StopwatchSummary>;
+}

package/dist-lib/scripting/heldModifiers.d.ts

@@ -0,0 +1,3 @@
+/** Current held-modifier bitmask in Qt::KeyboardModifier units (matches
+ *  `mudlet.keymodifier`). Installs the global listeners on first call. */
+export declare function getHeldModifiers(): number;

package/dist-lib/scripting/http/HttpService.d.ts

@@ -0,0 +1,23 @@
+import type { ProfileVFS } from '../vfs/ProfileVFS';
+type EmitFn = (event: string, args: unknown[]) => void;
+type VFSGetter = () => ProfileVFS | null;
+type ProxyUrlGetter = () => string | undefined;
+export declare class HttpService {
+    private readonly emit;
+    private readonly vfsGetter;
+    private readonly proxyUrlGetter;
+    private readonly proxiedOrigins;
+    constructor(emit: EmitFn, vfsGetter: VFSGetter, proxyUrlGetter?: ProxyUrlGetter);
+    downloadFile(saveTo: string, url: string): void;
+    getHTTP(url: string, headers?: Record<string, string>): void;
+    postHTTP(data: string | null, url: string, headers?: Record<string, string>, file?: string): void;
+    putHTTP(data: string | null, url: string, headers?: Record<string, string>, file?: string): void;
+    deleteHTTP(url: string, headers?: Record<string, string>): void;
+    customHTTP(method: string, data: string | null, url: string, headers?: Record<string, string>, file?: string): void;
+    private runDownload;
+    private readWithProgress;
+    private bodyForUpload;
+    private runRequest;
+    private fetchWithFallback;
+}
+export {};

package/dist-lib/scripting/lua/LuaRuntime.d.ts

@@ -0,0 +1,190 @@
+import type { IScriptingRuntime, CaptureSpan, LuaGlobalEntry } from '../IScriptingRuntime';
+import type { ScriptingAPI } from '../ScriptingAPI';
+import type { ProfileVFS } from '../vfs/ProfileVFS';
+import { type MudletVariable } from '../../import/mudletVariables';
+export declare class LuaRuntime implements IScriptingRuntime {
+    private readonly lua;
+    private readonly api;
+    private vfs;
+    private readonly proxyUrlGetter;
+    private readonly tempIds;
+    private nextTempId;
+    private readonly labelCbIds;
+    private cmdLineActionCbId;
+    private windowCmdLineActionCbIds;
+    private overlayCmdLineActionCbIds;
+    private currentMatches;
+    private currentCaptureSpans;
+    private currentNamedSpans;
+    private currentFullMatchSpan;
+    private _denyCurrentSend;
+    private destroyed;
+    private readonly watchedPaths;
+    private readonly rawFnPtrs;
+    private http;
+    private tts;
+    private globalEvents;
+    private flushPendingSqlSnapshots;
+    private toLuaValue;
+    private constructor();
+    static create(api: ScriptingAPI, vfs?: ProfileVFS | null, proxyUrlGetter?: () => string | undefined): Promise<LuaRuntime>;
+    private setup;
+    private installFastColorEcho;
+    private setupAnsiColorTable;
+    /**
+     * True when a script-created (temp) alias/trigger with this id is live and of
+     * the given type. Backs exists(id, "alias"/"trigger") for temp items, which
+     * don't live in the persisted store the way permanent items do.
+     */
+    tempItemExists(id: number, type: string): boolean;
+    /** enableTrigger/disableTrigger/enableAlias/disableAlias with a numeric id.
+     *  False when no temp item of that id is live. */
+    setTempItemEnabled(id: number, enabled: boolean): boolean;
+    /** Whether a live temp item is enabled — backs isActive(id, type). */
+    tempItemEnabled(id: number): boolean;
+    private setupBustedBridge;
+    private setupSqlBridge;
+    /**
+     * Fire sysPathChanged for any addFileWatch subscription whose path equals
+     * `changedPath` or is an ancestor directory of it. Mudlet's QFileSystemWatcher
+     * reports the *watched* path (not the inner file) for directory watches, so
+     * we do the same — handlers comparing `path == watchedPath` round-trip.
+     */
+    private notifyVfsPathChange;
+    private setupVFS;
+    load(code: string, name: string): void;
+    run(code: string, name: string): void;
+    /**
+     * Restore saved Lua globals (a parsed Mudlet `<VariablePackage>` tree) into
+     * `_G`. Call on profile load, after the bundle is up but before user scripts
+     * run, so handlers see their persisted state. No-op for an empty list.
+     */
+    restoreVariables(vars: MudletVariable[]): void;
+    /**
+     * Snapshot the current values of the save-listed globals out of `_G` into a
+     * `MudletVariable[]` tree (for serialization to `<VariablePackage>` / the
+     * profile JSON). `saveList` is the set of top-level global names flagged to
+     * persist (Mudlet's VarUnit::mSaveList). Names that are unset or hold a
+     * non-serializable value (function/userdata/thread) are skipped.
+     */
+    captureVariables(saveList: string[]): MudletVariable[];
+    /** Enumerate `_G` (user globals as a nested tree, built-ins flagged) for the
+     *  Variables view. See {@link LuaGlobalEntry}. */
+    listGlobals(): LuaGlobalEntry[];
+    runWithMatches(code: string, name: string, matches: (string | undefined)[], multimatches?: (string | undefined)[][], namedGroups?: Record<string, string>, captureSpans?: CaptureSpan[], namedSpans?: Record<string, CaptureSpan>, fullMatchSpan?: CaptureSpan): void;
+    private setMatches;
+    /** Push a 1-indexed Lua table of capture strings (`matches[1]` = whole match),
+     *  optionally merging named captures as string keys (`matches.hp`). Same shape
+     *  the old `oneIndexed()` + `global.set` produced, via raw stack ops. An
+     *  unmatched optional group (`undefined`) is left unset → nil, as before. */
+    private pushMatchesTable;
+    private exec;
+    private execInner;
+    private runChunk;
+    private static readonly FILE_DIALOG_SENTINEL;
+    /** Threads suspended in invokeFileDialog, tracked so destroy() forgets
+     *  them (their registry refs die with the closed Lua state). */
+    private readonly parkedDialogs;
+    /**
+     * A thread resume returned LUA_YIELD. If it is invokeFileDialog's yield
+     * (sentinel first), read the request off the thread stack, anchor the
+     * thread, and open the picker — returns true. Any other yield reaching
+     * the handler boundary is a script bug (stock Lua 5.1 errors with
+     * "attempt to yield from outside a coroutine" there): report and abandon
+     * the thread — returns false.
+     *
+     * First park: the thread still sits at `threadIndex` on the global stack
+     * (the caller's finally pops it), so take a registry ref now. Re-park
+     * (`existingRef` set): the previous ref already anchors this thread.
+     */
+    private parkDialogThread;
+    /** Continue a parked handler with the picked VFS path ('' = cancelled). */
+    private resumeDialogThread;
+    private dispatchCb;
+    private dispatchCbWithArg;
+    private unregisterCb;
+    private execModule;
+    private dispatchingEvent;
+    private readonly pendingEvents;
+    emitEvent(event: string, args: unknown[]): void;
+    private dispatchEventNow;
+    setGmcpValue(path: string, value: unknown): void;
+    setMsdpValue(path: string, value: unknown): void;
+    setMsspValue(name: string, value: string): void;
+    /**
+     * Bridges one use of a server-defined MXP element into the Lua `mxp` global
+     * as `mxp.<element>` — a fresh table each time, with every attribute key
+     * lowercased and a `text` field, exactly as Mudlet's signalMXPEvent builds
+     * it. Values keep their case.
+     */
+    setMxpElement(name: string, attrs: Record<string, string>): void;
+    /**
+     * Mudlet-style async unzip. Reads the zip from the profile VFS, decodes
+     * it on a worker (fflate falls back to a chunked main-thread decode where
+     * workers aren't available), writes every entry under destDir, then
+     * raises sysUnzipDone / sysUnzipError. Always fire-and-forget.
+     */
+    private runUnzipAsync;
+    setCurrentLine(line: string, _isPrompt: boolean): void;
+    setCommand(command: string): void;
+    dispatchSendRequest(text: string): boolean;
+    killScriptHandlers(scriptId: string): void;
+    /**
+     * Mudlet REGEX_LUA_CODE: the pattern body runs as a Lua function on every
+     * incoming line. Side effects (raiseEvent, etc.) always run; the trigger
+     * "matches" only when the body returns a truthy value.
+     */
+    evalTriggerPattern(code: string): boolean;
+    /**
+     * Invoke a `registerMapInfo` contributor. The Lua dispatcher pcalls the
+     * stashed callback and writes its multi-return into scalar globals
+     * (`__mudix_mapinfo_text` / _bold / _italic / _r / _g / _b). Returning
+     * `null` covers three cases: runtime is being torn down, callback id is
+     * stale, or the callback returned a nil/empty text — the panel treats
+     * all three the same (skip the entry).
+     */
+    private evaluateMapInfo;
+    /**
+     * Invoke a `setExitWeightFilter` callback for a single candidate exit.
+     * The Lua dispatcher pcalls the stashed callback and normalises its return
+     * into two scalar globals, mirroring Mudlet's applyExitWeightFilter
+     * (TLuaInterpreterMapper.cpp): boolean `false` or the string "block"
+     * (case-insensitive) blocks the exit; a number becomes a weight override
+     * clamped to [1, INT_MAX]; nil, `true` and anything else are ignored.
+     *
+     * Runs re-entrantly — findPath calls this while Lua is already suspended
+     * inside the `__getPath` JS call — so it must not touch the output queue or
+     * any other state a live Lua frame could also be mutating.
+     */
+    private evaluateExitWeightFilter;
+    /**
+     * Push a JS value onto `L`'s stack via the raw lua_* C API, mirroring
+     * wasmoon's pushValue conventions EXACTLY so behaviour is byte-identical to
+     * the generic path — only the O(n²) ref/unref bookkeeping wasmoon's
+     * pushTable does (see issue #2) is gone:
+     *   - integer-valued numbers → lua_pushinteger, others → lua_pushnumber
+     *   - arrays keyed by Object.keys + lua_rawseti, so dense 0-based arrays
+     *     (map getters) stay 0-indexed and the sparse 1-based arrays toLuaValue
+     *     builds stay 1-indexed — identical to wasmoon's arrIndexs handling
+     *   - plain objects → string keys via lua_setfield
+     * Anything that isn't a primitive / plain array / plain object (wasmoon
+     * LuaTable proxies such as the yajl.null sentinel, functions, Maps, class
+     * instances) is delegated to wasmoon's own pushValue, which is O(1) for
+     * these leaves and preserves their reference identity. Such values only
+     * appear as leaves of GMCP/MSDP payloads (toLuaValue rebuilds every
+     * container as a fresh plain array/object) and always push on the main
+     * thread; on a coroutine stack we can't safely delegate, so degrade to nil.
+     */
+    private pushJsValue;
+    /**
+     * Register `name` as a raw lua_CFunction (bypassing wasmoon's generic
+     * pushValue marshalling for the return value). `fn` receives the lua_State
+     * pointer, reads its args via the raw lua_* API, pushes its results with
+     * pushJsValue(), and returns the result count. A throw across the WASM
+     * trampoline would corrupt the C stack, so it is contained and the getter
+     * degrades to a single nil (these are read-only queries — a nil miss is a
+     * safe fallback).
+     */
+    private registerRawGlobal;
+    destroy(): void;
+}

package/dist-lib/scripting/lua/bindings/automation.d.ts

@@ -0,0 +1,10 @@
+import type { BindingContext } from './context';
+/**
+ * Enable/disable/exists/kill for the six automation node types (scripts,
+ * triggers, aliases, timers, keys, buttons), plus the perm* constructors that
+ * create them from Lua and the toolbar/button state accessors.
+ *
+ * Every one of these is a thin forward into ScriptingAPI, which in turn routes
+ * through the engine callbacks so mutations land in the appStore tree.
+ */
+export declare function installAutomationBindings({ lua, api }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/commandLine.d.ts

@@ -0,0 +1,11 @@
+import type { BindingContext } from './context';
+/**
+ * The main command bar and Mudlet's createCommandLine overlays: reading and
+ * writing the input text, styling, autocomplete suggestions, and the
+ * right-click context menu Lua can populate.
+ *
+ * 'Command line' here covers three distinct targets - the main command bar, a
+ * user window's embedded input, and a free-floating createCommandLine widget -
+ * which cmdLineKind below resolves from the name Lua passed.
+ */
+export declare function installCommandLineBindings({ lua, api, channel, emitEvent }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/context.d.ts

@@ -0,0 +1,87 @@
+import type { Lua } from 'wasmoon-lua5.1';
+import type { ScriptingAPI } from '../../ScriptingAPI';
+import type { ExitWeightFilterResult } from '../../../map/pathfinding';
+import type { ProfileVFS } from '../../vfs/ProfileVFS';
+/** wasmoon doesn't re-export its opaque lua_State pointer type; derive it from
+ *  the public API so raw lua_* bindings can be typed without reaching into the
+ *  package internals. Mirrors the alias in LuaRuntime. */
+export type LuaState = Lua['global']['address'];
+/** What a `registerMapInfo` callback yields once evaluated on the Lua side. */
+export interface MapInfoEvaluation {
+    text: string;
+    isBold: boolean;
+    isItalic: boolean;
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+/**
+ * The slice of {@link LuaRuntime} internals that the extracted binding modules
+ * are allowed to touch.
+ *
+ * Historically every Mudlet global was registered inside a single 3,700-line
+ * `LuaRuntime.setup()`, so each binding closed over `this` and could reach any
+ * private field. Splitting those registrations into per-domain modules needs a
+ * deliberate seam: this interface *is* that seam. Anything a binding module
+ * needs from the runtime is declared here, which keeps the dependency surface
+ * visible (and reviewable) instead of implicit.
+ *
+ * Mutable runtime state is exposed as accessor methods rather than fields —
+ * a plain field copy would snapshot the value at context-construction time and
+ * miss every later mutation (`nextTempId`, the match arrays, and the callback
+ * id counters are all reassigned during normal operation).
+ */
+export interface BindingContext {
+    /** The live Lua VM. Bindings register globals via `lua.global.set(...)`. */
+    readonly lua: Lua;
+    /** The bridge into MUD sends, windows, timers, sound, the map, and so on. */
+    readonly api: ScriptingAPI;
+    /**
+     * Coerce a Lua-passed value to an integer colour channel in 0..255,
+     * returning null when it is non-finite or out of range. Mudlet validates
+     * each channel this way and silently no-ops on a bad one, so callers treat
+     * null as "leave the pen alone".
+     *
+     * Shared rather than per-module: nine different binding domains (labels,
+     * borders, env colours, room highlights, sounds, …) validate channels.
+     */
+    channel(v: unknown): number | null;
+    /**
+     * Invoke a Lua callback previously registered through `__mudix_register_cb`.
+     * `what` names the call site and is used only to attribute errors.
+     */
+    dispatchCb(id: number, what: string): void;
+    /** Release a registered Lua callback slot so its chunk can be collected. */
+    releaseCb(id: number): void;
+    /** Raise a Mudlet event on the Lua side (deferred if a dispatch is live). */
+    emitEvent(name: string, args: unknown[]): void;
+    /** This profile's virtual filesystem, or null before one is mounted.
+     *  Never reassigned after the runtime is constructed, so a plain reference
+     *  is safe here. */
+    readonly vfs: ProfileVFS | null;
+    /** Drop a Lua-side callback registration by id (the registry slot behind
+     *  `__mudix_register_cb`). Distinct from {@link releaseCb}, which goes
+     *  through Lua; this is the direct JS-side removal. */
+    unregisterCb(cbId: number): void;
+    /** Marshal a JS value onto the Lua stack. Used by the raw lua_CFunction
+     *  getters that return tables too large to round-trip through wasmoon's
+     *  automatic conversion. */
+    pushJsValue(L: LuaState, value: unknown, depth?: number): void;
+    /** Register a global implemented as a raw lua_CFunction rather than a
+     *  wasmoon-wrapped JS function. */
+    registerRawGlobal(name: string, fn: (L: LuaState) => number): void;
+    /** Callback-registry ids for `setCmdLineAction` handlers bound to overlay
+     *  command lines (createCommandLine widgets), keyed by widget name. Held so
+     *  a re-bind or a delete can free the previous Lua registry slot instead of
+     *  leaking it. Mutated in place and never reassigned, so a reference is
+     *  enough. */
+    readonly overlayCmdLineActionCbIds: Map<string, number>;
+    /** Run a registerMapInfo callback and read back what it produced. */
+    evaluateMapInfo(cbId: number, roomId: number | null, selectionSize: number, areaId: number, displayedAreaId: number): MapInfoEvaluation | null;
+    /** Run a `setExitWeightFilter` callback for one candidate exit and read
+     *  back its verdict. Called from inside findPath — i.e. re-entrantly,
+     *  while Lua is already suspended in the `__getPath` JS call. */
+    evaluateExitWeightFilter(cbId: number, roomId: number, exitCommand: string): ExitWeightFilterResult;
+}

package/dist-lib/scripting/lua/bindings/cursor.d.ts

@@ -0,0 +1,10 @@
+import type { BindingContext } from './context';
+/**
+ * Line, cursor, and scrollback inspection: reading the buffer, moving the
+ * output cursor, scrolling, wrap settings, column/row geometry, and the
+ * selection primitives triggers use to recolour matched text.
+ *
+ * Mudlet models a console as a cursor over a line buffer, so most of these are
+ * stateful with respect to the currently selected window.
+ */
+export declare function installCursorBindings({ lua, api }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { BindingContext } from './context';
+/**
+ * Error reporting and the send/alias expansion primitives.
+ *
+ * Grouped because both are about what user code does *around* a command rather
+ * than with the console: raising a script error the editor can attribute, and
+ * expanding an alias without executing it.
+ */
+export declare function installDiagnosticsBindings({ lua, api }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/map.d.ts

@@ -0,0 +1,14 @@
+import type { BindingContext } from './context';
+/**
+ * Mudlet's map API: the 2D view, room and area CRUD, exits, doors, custom
+ * lines, labels, highlights, selection, per-room styling, user data, and the
+ * mapInfo / context-menu extension points.
+ *
+ * This is by far the widest binding surface in the runtime — it mirrors
+ * Mudlet's map Lua API essentially one-for-one — so it lives in its own
+ * module. The heavy lifting is all in MapStore behind `api.map`; the code
+ * here is argument coercion and Mudlet's return-shape conventions (notably
+ * alse where Mudlet returns nil, which Bridge.lua unpacks into the
+ * documented (nil, errMsg) multi-returns).
+ */
+export declare function installMapBindings({ lua, api, vfs, channel, emitEvent, unregisterCb, pushJsValue, registerRawGlobal, evaluateMapInfo, evaluateExitWeightFilter, }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/media.d.ts

@@ -0,0 +1,24 @@
+import type { TtsManager } from '../../../ui/tts/TtsManager';
+import type { BindingContext } from './context';
+/**
+ * Mudlet playSoundFile / playMusicFile / stopSounds / stopMusic and friends.
+ * Web Audio backend lives on session.sounds.
+ */
+export declare function installSoundBindings({ lua, api }: BindingContext): void;
+/**
+ * Mudlet playVideoFile / pauseVideos / stopVideos.
+ * Same VFS-or-URL loader as sounds; videos mount on the main viewport.
+ * playVideoFile(path [, volume, loops]) | playVideoFile{name=..., ...}.
+ */
+export declare function installVideoBindings({ lua, api }: BindingContext): void;
+/**
+ * Mudlet ttsSpeak / ttsQueue / ttsSetRate / … — Web Speech API backend.
+ *
+ * The manager is constructed by the runtime (it needs the runtime's own event
+ * emitter) and passed in, so this module stays free of runtime internals.
+ *
+ * These globals are bound BEFORE LuaGlobal.lua loads Other.lua, so its
+ * `if not ttsSpeak` guard sees real implementations and skips installing the
+ * no-op dummy stubs.
+ */
+export declare function installTtsBindings({ lua }: BindingContext, tts: TtsManager): void;

package/dist-lib/scripting/lua/bindings/output.d.ts

@@ -0,0 +1,10 @@
+import type { BindingContext } from './context';
+/**
+ * Console output and text formatting: the echo family's targets, foreground/
+ * background pens, bold/italic/underline/strikethrough attributes, hyperlink
+ * and popup insertion, and the format-state reset primitives.
+ *
+ * Colour channels are validated through the shared 0..255 coercion; Mudlet
+ * silently no-ops on an out-of-range channel rather than raising.
+ */
+export declare function installOutputBindings({ lua, api, channel }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/packages.d.ts

@@ -0,0 +1,10 @@
+import type { BindingContext } from './context';
+/**
+ * Mudlet package and module management: install/uninstall, the module sync and
+ * priority accessors, and the manifest info getters/setters.
+ *
+ * Modules differ from packages by being backed by a file on disk that can be
+ * synced back; the requireModule helper below centralises the 'does this module
+ * exist' guard the Mudlet API applies before every module operation.
+ */
+export declare function installPackageBindings({ lua, api }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/session.d.ts

@@ -0,0 +1,16 @@
+import type { GlobalEventChannel } from '../../GlobalEventChannel';
+import type { BindingContext } from './context';
+/**
+ * Session-level introspection and event raising: stopwatches, the console
+ * width, connection info, desktop notifications, screen-reader announcements,
+ * the clock, and raiseEvent / raiseGlobalEvent.
+ *
+ * These share no subsystem - what groups them is that each answers a question
+ * about (or acts on) the session as a whole rather than a specific window,
+ * which is why they were interleaved in the original setup().
+ *
+ * The cross-tab channel behind raiseGlobalEvent is constructed by the runtime
+ * and passed in: it needs the runtime's event emitter and the live profile
+ * name, neither of which belongs in this module.
+ */
+export declare function installSessionBindings({ lua, api, emitEvent }: BindingContext, globalEvents: GlobalEventChannel): void;

package/dist-lib/scripting/lua/bindings/textEdit.d.ts

@@ -0,0 +1,9 @@
+import type { BindingContext } from './context';
+/**
+ * Mudlet createTextEdit widgets - a plain multi-line text box addressed by
+ * name, with get/set/append/clear and the usual geometry and styling setters.
+ *
+ * Backed by TextEditManager, which is a pure data-model registry; the React
+ * overlay renders whatever the model holds.
+ */
+export declare function installTextEditBindings({ lua, api, channel }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/userWindows.d.ts

@@ -0,0 +1,11 @@
+import type { BindingContext } from './context';
+/**
+ * Creating and destroying the addressable UI surfaces Lua can open:
+ * user windows, the map widget, mini-consoles, command lines, and scroll
+ * boxes - plus windowType(), which reports what a given name resolves to.
+ *
+ * Deletion is the interesting half. Each destroy path has to free whatever
+ * Lua-side callback slots the widget had bound before dropping it, or the
+ * registry entry leaks for the lifetime of the runtime.
+ */
+export declare function installUserWindowBindings({ lua, api, emitEvent, unregisterCb, overlayCmdLineActionCbIds, }: BindingContext): void;

package/dist-lib/scripting/lua/bindings/window.d.ts

@@ -0,0 +1,10 @@
+import type { BindingContext } from './context';
+/**
+ * Main-window and user-window geometry, border sizes/colours, and the Mudlet
+ * 4.21 memory-introspection helpers.
+ *
+ * Borders here are the *main console's* insets (Mudlet's setBorderTop and
+ * friends), not per-window padding - they shrink the area the MUD output wraps
+ * into, which is how Geyser reserves room for docked labels and gauges.
+ */
+export declare function installWindowBindings({ lua, api, channel }: BindingContext): void;

package/dist-lib/scripting/lua/imageSize.d.ts

@@ -0,0 +1,4 @@
+export declare function parseImageSize(b: Uint8Array): {
+    width: number;
+    height: number;
+} | null;

package/dist-lib/scripting/lua/luaCompletions.d.ts

@@ -0,0 +1,9 @@
+import type { Completion, CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+export interface ReferenceGroup {
+    title: string;
+    prefix: string;
+    entries: Completion[];
+}
+export declare const REFERENCE_GROUPS: ReferenceGroup[];
+export declare const HOVER_MAP: Map<string, Completion>;
+export declare function luaCompletionSource(context: CompletionContext): CompletionResult | null;

package/dist-lib/scripting/lua/rex.d.ts

@@ -0,0 +1,3 @@
+import type { Lua } from 'wasmoon-lua5.1';
+/** Register __rex_* JS helpers and put rex_pcre2 into package.loaded. */
+export declare function setupRex(lua: Lua): Promise<void>;

package/dist-lib/scripting/lua/sqlRowEncoder.d.ts

@@ -0,0 +1 @@
+export declare function encodeRowsToLuaSource(rows: unknown[][]): string;

package/dist-lib/scripting/lua/yajl.d.ts

@@ -0,0 +1,11 @@
+import type { Lua } from 'wasmoon-lua5.1';
+export type LuaValueTransform = (v: unknown) => unknown;
+/**
+ * Serialise a JSON-decoded value as a Lua chunk returning it. The chunk takes
+ * the null sentinel as its vararg so nulls survive without a global lookup.
+ * Returns null when the value nests too deeply to express as source.
+ */
+export declare function luaChunkForValue(v: unknown): string | null;
+export declare function setupYajl(lua: Lua): {
+    transform: LuaValueTransform;
+};