mudlet-map-renderer 2.3.1 → 2.5.0

package/dist/lens/hiddenAwareLens.d.ts

@@ -0,0 +1,12 @@
+import { RoomLens } from './RoomLens';
+/**
+ * Wrap a lens so Mudlet-hidden rooms (`settings.hiddenRooms === "hide"`) count
+ * as not-visible: the room filter drops them via `isVisible`, and any exit
+ * touching one is treated as `"hidden"` via `getExitTreatment`. This reuses the
+ * existing lens machinery so every consumer (scene build, current-room overlay)
+ * hides hidden rooms and their exits identically.
+ *
+ * Returns `lens` unchanged when `hideHidden` is false (the "show"/"faded" modes
+ * keep hidden rooms visible — "faded" fades them in the room pass instead).
+ */
+export declare function hiddenAwareLens(lens: RoomLens, hideHidden: boolean): RoomLens;

package/dist/offscreen.mjs

@@ -1,4 +1,4 @@
-import { E as e, T as t, _ as n, a as r, b as i, g as a, h as o, k as s, m as c, o as l, r as u, t as d, v as f, w as p, x as m, y as h } from "./flushSceneShapes-Duhi0OQv.js";
+import { A as e, C as t, E as n, P as r, S as i, T as a, a as o, h as s, j as c, k as l, m as u, o as d, r as f, t as p, w as m, x as h } from "./flushSceneShapes-c7ttw7D-.js";
 import g from "konva";
 //#region src/rendering/offscreen/serializeTransform.ts
 function _(e) {
@@ -26,33 +26,33 @@ function b() {
 	return typeof document < "u" && typeof HTMLCanvasElement < "u" && typeof HTMLCanvasElement.prototype.transferControlToOffscreen == "function";
 }
 var x = class {
-	constructor(n, i, a = {}) {
-		this.hitTester = new l(), this.currentStyle = r, this._coordinateTransform = t, this.coordinateInverse = t, this.lastHitShapes = [], this.boundsByShape = /* @__PURE__ */ new Map(), this.sceneOverlays = /* @__PURE__ */ new Map(), this.viewportSubscribers = /* @__PURE__ */ new Set(), this.liveEffects = /* @__PURE__ */ new Map(), this.pendingExports = /* @__PURE__ */ new Map(), this.exportSeq = 0, this.destroyed = !1, this.state = n, this.container = i, this.pipeline = new o(n.mapReader, n.settings), this.dpr = a.devicePixelRatio ?? (typeof devicePixelRatio < "u" ? devicePixelRatio : 1), this.transport = a.transport ?? a.createTransport?.();
-		let u = i?.clientWidth ?? 1, d = i?.clientHeight ?? 1;
-		if (this.camera = new e(u, d), this.events = new s(i), this.culling = new p(n.settings, () => {
+	constructor(t, n, i = {}) {
+		this.hitTester = new d(), this.currentStyle = o, this._coordinateTransform = e, this.coordinateInverse = e, this.lastHitShapes = [], this.boundsByShape = /* @__PURE__ */ new Map(), this.sceneOverlays = /* @__PURE__ */ new Map(), this.viewportSubscribers = /* @__PURE__ */ new Set(), this.liveEffects = /* @__PURE__ */ new Map(), this.pendingExports = /* @__PURE__ */ new Map(), this.exportSeq = 0, this.destroyed = !1, this.state = t, this.container = n, this.pipeline = new s(t.mapReader, t.settings), this.dpr = i.devicePixelRatio ?? (typeof devicePixelRatio < "u" ? devicePixelRatio : 1), this.transport = i.transport ?? i.createTransport?.();
+		let a = n?.clientWidth ?? 1, f = n?.clientHeight ?? 1;
+		if (this.camera = new c(a, f), this.events = new r(n), this.culling = new l(t.settings, () => {
 			this.postSettings(), this.postCamera();
 		}), this.transport) {
 			let e = (e) => this.handleWorkerMessage(e.data);
 			this.transport.addEventListener ? this.transport.addEventListener("message", e) : this.transport.onmessage = e;
 		}
-		if (i && this.transport && b()) {
-			getComputedStyle(i).position === "static" && (i.style.position = "relative");
+		if (n && this.transport && b()) {
+			getComputedStyle(n).position === "static" && (n.style.position = "relative");
 			let e = document.createElement("canvas");
-			e.style.position = "absolute", e.style.inset = "0", e.style.width = "100%", e.style.height = "100%", e.style.display = "block", i.appendChild(e), i.style.backgroundColor = n.settings.backgroundColor;
-			let t = e.transferControlToOffscreen();
+			e.style.position = "absolute", e.style.inset = "0", e.style.width = "100%", e.style.height = "100%", e.style.display = "block", n.appendChild(e), n.style.backgroundColor = t.settings.backgroundColor;
+			let r = e.transferControlToOffscreen();
 			this.transport.postMessage({
 				type: "init",
-				canvas: t,
-				width: u,
-				height: d,
+				canvas: r,
+				width: a,
+				height: f,
 				dpr: this.dpr,
-				settings: n.settings
-			}, [t]), this.interactionHandler = new c(i, this.camera, n, {
-				clientToMapPoint: (e, t) => this.camera.clientToMapPoint(e, t, i.getBoundingClientRect()),
+				settings: t.settings
+			}, [r]), this.interactionHandler = new u(n, this.camera, t, {
+				clientToMapPoint: (e, t) => this.camera.clientToMapPoint(e, t, n.getBoundingClientRect()),
 				pickAtPoint: (e, t) => this.hitTester.pick(e, t)
 			}, this.events);
 		}
-		this.cameraChangeHandler = () => this.onCameraChange(), this.camera.on("change", this.cameraChangeHandler), this.applyStyleTransforms(), this.subscribeToState(n), this.postCamera();
+		this.cameraChangeHandler = () => this.onCameraChange(), this.camera.on("change", this.cameraChangeHandler), this.applyStyleTransforms(), this.subscribeToState(t), this.postCamera();
 	}
 	get coordinateTransform() {
 		return this._coordinateTransform;
@@ -109,7 +109,7 @@ var x = class {
 	postOverlays() {
 		let e = this.styleContext(), t = [];
 		for (let n of this.buildCurrentRoomOverlayShapes()) t.push(...this.styleOne(n, e, !1));
-		for (let n of d(this.state)) t.push(...this.styleOne(n, e, !1));
+		for (let n of p(this.state)) t.push(...this.styleOne(n, e, !1));
 		for (let n of this.sceneOverlays.values()) {
 			let r = n.render(this.state, this.camera.getViewportBounds());
 			if (!r) continue;
@@ -128,20 +128,20 @@ var x = class {
 		};
 	}
 	styleOne(e, t, n) {
-		return n || this.currentStyle === r ? [e] : u([e], this.currentStyle, t);
+		return n || this.currentStyle === o ? [e] : f([e], this.currentStyle, t);
 	}
 	styleShapes(e, t) {
-		return this.currentStyle === r ? e : u(e, this.currentStyle, t);
+		return this.currentStyle === o ? e : f(e, this.currentStyle, t);
 	}
 	styleLayer(e, t) {
-		let n = [], i = [];
-		for (let a of e) {
-			let e = this.boundsByShape.get(a) ?? null, o = this.currentStyle === r ? [a] : u([a], this.currentStyle, t);
-			for (let t of o) n.push(t), i.push(e);
+		let n = [], r = [];
+		for (let i of e) {
+			let e = this.boundsByShape.get(i) ?? null, a = this.currentStyle === o ? [i] : f([i], this.currentStyle, t);
+			for (let t of a) n.push(t), r.push(e);
 		}
 		return {
 			shapes: n,
-			bounds: i
+			bounds: r
 		};
 	}
 	refresh() {
@@ -171,38 +171,38 @@ var x = class {
 		return t;
 	}
 	buildCurrentRoomOverlayShapes() {
-		let e = this.state, t = e.positionRoomId;
-		if (t === void 0) return [];
-		let r = e.mapReader.getRoom(t);
-		if (!r || r.area !== e.currentArea || r.z !== e.currentZIndex) return [];
-		let o = e.settings;
-		if (!o.highlightCurrentRoom) return [];
-		let s = [], c = this.pipeline.exitRenderer, l = e.lens, u = /* @__PURE__ */ new Map();
-		if (u.set(r.id, r), e.currentAreaInstance && e.currentZIndex !== void 0) {
-			let t = e.currentAreaInstance.getLinkExits(e.currentZIndex).filter((e) => e.a === r.id || e.b === r.id);
+		let e = this.state, r = e.positionRoomId;
+		if (r === void 0) return [];
+		let o = e.mapReader.getRoom(r);
+		if (!o || o.area !== e.currentArea || o.z !== e.currentZIndex) return [];
+		let s = e.settings;
+		if (!s.highlightCurrentRoom) return [];
+		let c = [], l = this.pipeline.exitRenderer, u = e.lens, d = /* @__PURE__ */ new Map();
+		if (d.set(o.id, o), e.currentAreaInstance && e.currentZIndex !== void 0) {
+			let t = e.currentAreaInstance.getLinkExits(e.currentZIndex).filter((e) => e.a === o.id || e.b === o.id);
 			for (let n of t) {
-				let t = c.renderDataWithColor(n, y, e.currentZIndex);
-				t && s.push(this.pipeline.buildExitShape(t));
+				let t = l.renderDataWithColor(n, y, e.currentZIndex);
+				t && c.push(this.pipeline.buildExitShape(t));
 			}
 		}
-		for (let e of i(r, o, y)) s.push(n(e, r.id));
-		for (let e of m(r, o, y)) s.push(a(e));
-		return [...Object.values(r.exits), ...Object.values(r.specialExits)].forEach((t) => {
+		for (let e of a(o, s, y)) c.push(i(e, o.id));
+		for (let e of n(o, s, y)) c.push(h(e));
+		return [...Object.values(o.exits), ...Object.values(o.specialExits)].forEach((t) => {
 			let n = e.mapReader.getRoom(t);
-			n && n.area === e.currentArea && n.z === e.currentZIndex && l.isVisible(n) && u.set(n.id, n);
-		}), u.forEach((t, n) => {
-			let i = n === r.id, a = h(t, e.mapReader, o, {
-				strokeOverride: i ? y : o.lineColor,
+			n && n.area === e.currentArea && n.z === e.currentZIndex && u.isVisible(n) && d.set(n.id, n);
+		}), d.forEach((n, r) => {
+			let i = r === o.id, a = m(n, e.mapReader, s, {
+				strokeOverride: i ? y : s.lineColor,
 				flatPipeline: !0
 			});
-			a.children.push(...f(t, e.mapReader, o)), s.push(a);
-		}), s;
+			a.children.push(...t(n, e.mapReader, s)), c.push(a);
+		}), c;
 	}
 	setStyle(e) {
 		this.currentStyle = e, this.lastHitShapes = [], this.hitTester.clear(), this.applyStyleTransforms(), this.refresh();
 	}
 	applyStyleTransforms() {
-		let e = this.currentStyle, n = e.worldToScene ? (t, n) => e.worldToScene(t, n) : t, r = e.sceneToWorld ? (t, n) => e.sceneToWorld(t, n) : t, i = this.coordinateInverse, a = e.sceneLayerOffset ? (t) => e.sceneLayerOffset(t) : void 0;
+		let t = this.currentStyle, n = t.worldToScene ? (e, n) => t.worldToScene(e, n) : e, r = t.sceneToWorld ? (e, n) => t.sceneToWorld(e, n) : e, i = this.coordinateInverse, a = t.sceneLayerOffset ? (e) => t.sceneLayerOffset(e) : void 0;
 		this._coordinateTransform = n, this.coordinateInverse = r, this.coordinateLayerOffset = a, this.culling.setCoordinateTransform(n), this.lastHitShapes.length > 0 && this.hitTester.build(this.lastHitShapes, this.state.settings.roomSize, n, a);
 		let o = this.camera.getScale(), s = this.camera.width / 2, c = this.camera.height / 2, l = i((s - this.camera.position.x) / o, (c - this.camera.position.y) / o), u = n(l.x, l.y);
 		this.camera.position = {

package/dist/render/RecordingLayer.d.ts

@@ -1,5 +1,5 @@
 import { default as Konva } from 'konva';
-import { FillStyle } from '../scene/Shape';
+import { FillStyle, LayerId } from '../scene/Shape';
 type RectCommand = {
     type: 'rect';
     x: number;
@@ -78,6 +78,8 @@ export declare class RecordingGroupNode {
     y: number;
     _visible: boolean;
     noScaling: boolean;
+    /** Scene layer this group belongs to; drives coalesced draw ordering. */
+    layer?: LayerId;
     readonly commands: RecordingDrawCommand[];
     /** Lazily created when this group is materialized for a Konva.Layer. */
     _konvaGroup?: Konva.Group;
@@ -107,20 +109,33 @@ export type DrawEntry = {
     x: number;
     y: number;
     noScaling: boolean;
+    layer?: LayerId;
     readonly commands: RecordingDrawCommand[];
     visible: boolean;
 };
-/**
- * LayerNode backed by a single Konva.Shape whose sceneFunc replays
- * {@link DrawEntry} objects. Used for the main scene layer where individual
- * shapes need cull toggling.
- */
 export declare class DrawCommandLayerNode {
+    private readonly coalesce;
     private readonly entries;
     private readonly nodeToEntry;
     private readonly konvaLayer;
     private konvaShape;
-    constructor(konvaLayer: Konva.Layer);
+    /** Reusable bucket map for coalesced draws — cleared per frame, never reallocated. */
+    private readonly buckets;
+    constructor(konvaLayer: Konva.Layer, coalesce?: () => boolean);
+    /** Original path: one setTransform + replay per visible entry, in order. */
+    private drawPerEntry;
+    /**
+     * Fast path: same-style primitives are accumulated into one path per style
+     * and drawn with a single `fill()`/`stroke()`. Done in two sweeps — link
+     * entries (exit lines) first, then room entries — so rooms stay painted on
+     * top of exits, matching the per-entry insertion order. Within a sweep,
+     * non-batchable entries (one-way arrows, doors, symbols, emboss, inner-exit
+     * triangles…) replay per-entry; batched primitives flush afterwards. Exit
+     * lines and room bodies don't meaningfully overlap same-layer siblings, so
+     * reordering them within a sweep is visually immaterial.
+     */
+    private drawCoalesced;
+    private sweep;
     addNode(node: RecordingGroupNode): void;
     /** Return the DrawEntry created when `node` was added, or undefined if not found. */
     getEntry(node: RecordingGroupNode): DrawEntry | undefined;

package/dist/rendering/KonvaRenderBackend.d.ts

@@ -53,6 +53,13 @@ export declare class KonvaRenderBackend implements InteractiveBackend {
     private positionMarker?;
     private highlightShapes;
     private pathShapes;
+    /**
+     * Projected positions of the current build's spilled neighbouring-area
+     * rooms (roomId → current-area-frame x/y). Empty when neighbour spill is
+     * off or yields nothing. Drives {@link overlayReader} so highlights/paths
+     * on spilled rooms land at their projected spots.
+     */
+    private spilledRoomPositions;
     private currentRoomOverlay;
     private interactionHandler?;
     private origSetSize?;
@@ -94,6 +101,19 @@ export declare class KonvaRenderBackend implements InteractiveBackend {
     private clearSceneOverlayNodes;
     private subscribeToState;
     private buildScene;
+    /**
+     * Compute neighbouring-area spill for the current build, or `undefined` when
+     * the feature is off / the player isn't on this area+plane. Driven by the
+     * live player position so it updates as the player nears a boundary.
+     */
+    private computeNeighborSpill;
+    /**
+     * The map reader the overlay code (highlights, paths) should use. When
+     * neighbour spill produced rooms, this is a {@link ProjectedMapReader} that
+     * makes those spilled rooms look like current-area rooms at their projected
+     * positions; otherwise it's the plain reader.
+     */
+    private overlayReader;
     /**
      * Run the active {@link Style} over `shape`, walk the (possibly multi-shape)
      * result into a single {@link RecordingGroupNode}, and add it to `layerNode`.

package/dist/rendering/SceneManager.d.ts

@@ -8,6 +8,7 @@ import { GroupShape, Shape } from '../scene/Shape';
 import { IMapReader } from '../reader/MapReader';
 import { RoomLens } from '../lens/RoomLens';
 import { ExitDrawData } from '../ExitRenderer';
+import { NeighborSpill } from '../scene/NeighborProjector';
 export interface CullStats {
     visibleRooms: number;
     totalRooms: number;
@@ -39,7 +40,7 @@ export declare class SceneManager {
     get drawnStubs(): readonly DrawnStubEntry[];
     get areaExitHitZones(): readonly AreaExitHitZone[];
     get hitShapes(): readonly Shape[];
-    rebuild(area: IArea, plane: IPlane, zIndex: number, lens?: RoomLens): SceneBuildResult;
+    rebuild(area: IArea, plane: IPlane, zIndex: number, lens?: RoomLens, spill?: NeighborSpill): SceneBuildResult;
     buildExitShape(data: ExitDrawData): GroupShape;
     reset(): void;
     resetPipeline(mapReader: IMapReader): void;

package/dist/scene/NeighborProjector.d.ts

@@ -0,0 +1,82 @@
+import { IMapReader } from '../reader/MapReader';
+import { IArea } from '../reader/Area';
+/**
+ * Clone a room placed at projected `(x, y)` in the current area+plane, shifting
+ * its custom-line points by the same delta so they follow the room. Custom-line
+ * points are stored with world-y negated (`world = -point.y`), so a world shift
+ * of `dy` maps to `point.y -= dy`.
+ */
+export declare function projectRoom(room: MapData.Room, x: number, y: number, area: number, z: number): MapData.Room;
+/** One neighbouring-area room, with its position projected into the current area's frame. */
+export interface ProjectedRoom {
+    /** The real room (its `id` is preserved so the rendered shape stays clickable). */
+    room: MapData.Room;
+    /** Projected X in the current area's coordinate space. */
+    x: number;
+    /** Projected Y in the current area's coordinate space. */
+    y: number;
+}
+/** A connector line between two projected room centres (current-area frame). */
+export interface ProjectedEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+}
+/** Result of {@link computeNeighborSpill}: faded preview geometry for neighbouring areas. */
+export interface NeighborSpill {
+    rooms: ProjectedRoom[];
+    edges: ProjectedEdge[];
+}
+/**
+ * Walk the exit graph outward from the player's room (BFS, depth ≤ `maxSteps`)
+ * and project the positions of rooms that live in a *different* area onto the
+ * current area's coordinate plane, so they can be drawn across the boundary.
+ *
+ * Areas use independent (area-local) coordinates, so we can't trust a
+ * neighbour room's raw x/y to align with the current area. Instead we carry a
+ * projected position through the BFS:
+ *   - within one area, we advance by the real coordinate delta between rooms;
+ *   - crossing a boundary, we place the target one grid step away in the exit's
+ *     planar direction (the only geometric anchor we have).
+ *
+ * Only planar exits (n/s/e/w + diagonals) are followed — non-planar links
+ * (up/down/in/out, special exits) can't be placed on the plane. Only rooms on
+ * the current z-level (`currentZ`) are collected.
+ *
+ * Returns `undefined` when there's nothing to draw.
+ */
+export declare function computeNeighborSpill(mapReader: IMapReader, currentAreaId: number, currentZ: number, playerRoomId: number, maxSteps: number, isVisible?: (room: MapData.Room) => boolean): NeighborSpill | undefined;
+/**
+ * Wraps an {@link IMapReader} so that spilled neighbouring-area rooms appear to
+ * live in the current area at their projected positions. {@link getRoom}
+ * returns a clone of a spilled room with `x`/`y` swapped for the projected
+ * coordinates, `area`/`z` rewritten to the current area+plane, and custom-line
+ * points shifted by the same delta so they follow the room; every other room and
+ * method passes straight through to the base reader.
+ *
+ * This lets the overlay code (highlights, paths) treat spilled rooms exactly
+ * like current-area rooms: existing area/visibility checks pass for them and
+ * all coordinate maths lands on the projected positions, with no special cases.
+ */
+export declare class ProjectedMapReader implements IMapReader {
+    private readonly base;
+    private readonly currentArea;
+    private readonly currentZ;
+    private readonly projected;
+    constructor(base: IMapReader, currentArea: number, currentZ: number, projected: Map<number, {
+        x: number;
+        y: number;
+    }>);
+    getRoom(roomId: number): MapData.Room;
+    getArea(areaId: number): IArea;
+    getAreas(): IArea[];
+    getRooms(): MapData.Room[];
+    getColorValue(envId: number): string;
+    getSymbolColor(envId: number, opacity?: number): string;
+}
+/** Build a roomId → projected-position map from a {@link NeighborSpill}. */
+export declare function spillPositionMap(spill: NeighborSpill): Map<number, {
+    x: number;
+    y: number;
+}>;

package/dist/scene/RoomFlags.d.ts

@@ -0,0 +1,36 @@
+import { HiddenRoomMode } from '../types/Settings';
+/**
+ * userData key Mudlet uses for a room's hidden state on pre-v21 map formats
+ * (case-insensitive `"true"`). On v21+ formats Mudlet stores this as a binary
+ * `hidden` field instead — which the JSON pipeline does not currently surface,
+ * so only maps carrying this fallback key are detected as hidden here.
+ */
+export declare const ROOM_UI_HIDDEN = "system.fallback_hidden";
+/** userData key for a room's custom border colour. */
+export declare const ROOM_UI_BORDER_COLOR = "room.ui_borderColor";
+/** userData key for a room's custom border thickness (Mudlet clamps it to 1..10). */
+export declare const ROOM_UI_BORDER_THICKNESS = "room.ui_borderThickness";
+/** Whether Mudlet has marked this room hidden on the 2D map. */
+export declare function isRoomHidden(room: MapData.Room): boolean;
+/**
+ * The room's custom border colour as a CSS colour, or `undefined` when none is
+ * set. Mudlet stores it as a Qt `#AARRGGBB` string (see {@link qtColorToCss}).
+ */
+export declare function getRoomBorderColor(room: MapData.Room): string | undefined;
+/** Opacity applied to hidden rooms in {@link HiddenRoomMode} `"faded"`. */
+export declare const HIDDEN_ROOM_FADE = 0.35;
+/**
+ * The {@link layoutRoom} options that render a room's hidden state for the given
+ * mode (`{}` when the room isn't hidden / the mode draws it normally). Shared by
+ * the scene build and the current-room overlay so a redrawn hidden room keeps
+ * its fade / dashed border.
+ */
+export declare function hiddenRoomLayoutOptions(room: MapData.Room, mode: HiddenRoomMode): {
+    fade?: number;
+    dashedBorder?: boolean;
+};
+/**
+ * The room's custom border thickness clamped to Mudlet's 1..10 range, or
+ * `undefined` when unset or unparseable.
+ */
+export declare function getRoomBorderThickness(room: MapData.Room): number | undefined;

package/dist/scene/RoomStyle.d.ts

@@ -6,6 +6,8 @@ export type RoomColors = {
     borderWidth: number;
     symbolColor: string;
     envColor: string;
+    /** True when the room carries an explicit per-room border colour (userData). */
+    customBorder: boolean;
 };
 export type EmbossEdge = {
     points: number[];

package/dist/scene/elements/RoomLayout.d.ts

@@ -10,6 +10,18 @@ export interface RoomLayoutOptions {
      * as flat diamonds outside the cube footprint).
      */
     flatPipeline: boolean;
+    /**
+     * When set (0..1), the room's fill, border, and symbol colours are drawn at
+     * this opacity — used to render hidden rooms faded. Baked into the colour
+     * strings so every renderer (Konva, canvas, SVG) honours it identically.
+     */
+    fade?: number;
+    /**
+     * Draw the room with a dashed border at full opacity — a more distinct
+     * "hidden" marker than {@link fade}. Suppresses emboss (the dashed outline
+     * is the signal) and forces a visible border even when borders are off.
+     */
+    dashedBorder?: boolean;
 }
 /**
  * Pure layout for a single room. Returns a {@link GroupShape} positioned at

package/dist/types/Settings.d.ts

@@ -1,6 +1,15 @@
 export type LabelRenderMode = "image" | "data" | "none";
 export type CullingMode = "none" | "basic" | "indexed";
 export type RoomShape = "rectangle" | "circle" | "roundedRectangle";
+/**
+ * How to render rooms Mudlet has marked hidden (see {@link isRoomHidden}):
+ * - `"hide"` — omit them from the scene entirely (Mudlet's default).
+ * - `"show"` — draw them exactly like any other room.
+ * - `"faded"` — draw them at reduced opacity so they read as de-emphasised.
+ * - `"dashed"` — draw them at full opacity but with a dashed border, a more
+ *   distinct "hidden" marker than a fade (which can read as just another shade).
+ */
+export type HiddenRoomMode = "hide" | "show" | "faded" | "dashed";
 export type RoomContextMenuEventDetail = {
     roomId: number;
     position: {
@@ -171,12 +180,25 @@ export type Settings = {
         width: number;
         height: number;
     } | null;
+    /**
+     * When true, room bodies that share the same fill/stroke/shape are drawn in
+     * a single batched path (one `fill()` + one `stroke()` per style) instead of
+     * one draw per room. Big win on large areas with few environment colours;
+     * see {@link DrawCommandLayerNode}. Rooms with symbols, emboss, gradient
+     * fills, or coloured multi-rings fall back to per-room replay automatically.
+     *
+     * Off by default: coalescing reorders same-style rooms, which can shift
+     * sub-pixel border overlaps where rooms touch. Default: false
+     */
+    coalesceRooms: boolean;
     /** How to render room labels: "image" | "data". Default: "image" */
     labelRenderMode: LabelRenderMode;
     /** When true, room labels have transparent backgrounds. Default: false */
     transparentLabels: boolean;
     /** Shape used to render rooms: "rectangle" | "circle" | "roundedRectangle". Default: "rectangle" */
     roomShape: RoomShape;
+    /** How to render rooms Mudlet has marked hidden: "hide" | "show" | "faded". Default: "hide" */
+    hiddenRooms: HiddenRoomMode;
     /** Style configuration for the player position marker. */
     playerMarker: PlayerMarkerStyle;
     /** Style configuration for room highlights (added via {@link MapRenderer.renderHighlight}). */
@@ -209,6 +231,13 @@ export type Settings = {
     /** Font size (in map units) for area-exit labels. Padding, corner radius, and stroke
      *  scale proportionally. Default: 0.3 */
     areaExitLabelFontSize: number;
+    /** When true, rooms from neighbouring areas reachable within {@link neighborSpillDistance}
+     *  steps of the player are drawn (faded) across the boundary, projected into the current
+     *  area's coordinate space. Requires a known player position. Default: false */
+    neighborSpill: boolean;
+    /** Max number of steps from the player's room to spill neighbouring-area rooms across a
+     *  boundary (BFS depth over planar exits). Default: 20 */
+    neighborSpillDistance: number;
 };
 /** Creates a new Settings object with default values. */
 export declare function createSettings(): Settings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mudlet-map-renderer",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "license": "MIT",
   "repository": {
     "url": "https://github.com/Delwing/mudlet-map-renderer"
@@ -46,7 +46,7 @@
     "node-dijkstra": "^2.5.1"
   },
   "peerDependencies": {
-    "mudlet-map-binary-reader": ">=0.9.0"
+    "mudlet-map-binary-reader": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "mudlet-map-binary-reader": {
@@ -57,8 +57,10 @@
     "@playwright/test": "^1.59.1",
     "@types/node": "^25.6.0",
     "@types/node-dijkstra": "^2.5.6",
+    "@types/three": "^0.184.1",
     "canvas": "^3.2.3",
-    "mudlet-map-binary-reader": "^0.9.0",
+    "mudlet-map-binary-reader": "^1.0.1",
+    "three": "^0.184.0",
     "tslib": "^2.8.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",