mudlet-map-renderer 0.43.0-konva → 1.1.0

package/dist/AreaMapRenderer.d.ts

@@ -1,4 +1,4 @@
-import { default as MapReader } from './reader/MapReader';
+import { IMapReader } from './reader/MapReader';
 import { PlanarDirection } from './directions';
 type AreaConnection = {
     fromAreaId: number;
@@ -71,7 +71,7 @@ export declare class AreaMapRenderer {
     private backgroundImage?;
     private backgroundConfig?;
     private dotsMode;
-    constructor(container: HTMLDivElement, mapReader: MapReader, settings?: AreaMapSettings);
+    constructor(container: HTMLDivElement, mapReader: IMapReader, settings?: AreaMapSettings);
     private initResize;
     private initScaling;
     setZoom(zoom: number): boolean;

package/dist/ExitRenderer.d.ts

@@ -1,5 +1,5 @@
-import { default as Exit } from './reader/Exit';
-import { default as MapReader } from './reader/MapReader';
+import { default as IExit } from './reader/Exit';
+import { IMapReader } from './reader/MapReader';
 import { Settings } from './types/Settings';
 export type ExitDrawLine = {
     points: number[];
@@ -52,14 +52,14 @@ export type ExitDrawData = {
 export default class ExitRenderer {
     private mapReader;
     private readonly settings;
-    constructor(mapReader: MapReader, settings: Settings);
+    constructor(mapReader: IMapReader, settings: Settings);
     /**
      * Get the edge point of a room based on its shape.
      * The inset accounts for the inner border so exit lines reach the visible room edge.
      */
     private getRoomEdgePoint;
-    renderData(exit: Exit, zIndex: number): ExitDrawData | undefined;
-    renderDataWithColor(exit: Exit, color: string, zIndex: number): ExitDrawData | undefined;
+    renderData(exit: IExit, zIndex: number): ExitDrawData | undefined;
+    renderDataWithColor(exit: IExit, color: string, zIndex: number): ExitDrawData | undefined;
     private renderTwoWayExitData;
     private renderOneWayExitData;
     /**

package/dist/MapGraph.d.ts

@@ -1,4 +1,4 @@
-import { default as MapReader } from './reader/MapReader';
+import { IMapReader } from './reader/MapReader';
 export interface Edge {
     id: number;
     weight: number;
@@ -17,7 +17,7 @@ export interface GraphData {
 export declare class MapGraph {
     private readonly mapReader;
     private readonly data;
-    constructor(mapReader: MapReader);
+    constructor(mapReader: IMapReader);
     getAdj(): Map<number, Edge[]>;
     getGraphDefinition(): Record<string, Record<string, number>>;
     getMaxEdgeDistance(): number;

package/dist/MapReader-mU_4JWv_.js

@@ -0,0 +1,224 @@
+//#region src/reader/Plane.ts
+var e = class {
+	constructor(e, t) {
+		this.rooms = [], this.labels = [], this.rooms = e, this.labels = t, this.bounds = this.createBounds();
+	}
+	getRooms() {
+		return this.rooms;
+	}
+	getLabels() {
+		return this.labels;
+	}
+	getBounds() {
+		return this.bounds;
+	}
+	createBounds() {
+		let e = this.rooms.reduce((e, t) => ({
+			minX: Math.min(e.minX, t.x),
+			maxX: Math.max(e.maxX, t.x),
+			minY: Math.min(e.minY, t.y),
+			maxY: Math.max(e.maxY, t.y)
+		}), {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		});
+		for (let t of this.labels) {
+			let n = t.X, r = -t.Y;
+			e.minX = Math.min(e.minX, n), e.maxX = Math.max(e.maxX, n + t.Width), e.minY = Math.min(e.minY, r), e.maxY = Math.max(e.maxY, r + t.Height);
+		}
+		return e;
+	}
+}, t = class t {
+	constructor(e) {
+		this.planes = {}, this.exits = /* @__PURE__ */ new Map(), this.version = 0, this.area = e, this.planes = this.createPlanes(), this.createExits();
+	}
+	getAreaName() {
+		return this.area.areaName;
+	}
+	getAreaId() {
+		return parseInt(this.area.areaId);
+	}
+	getVersion() {
+		return this.version;
+	}
+	markDirty() {
+		this.version++;
+	}
+	getPlane(e) {
+		return this.planes[e];
+	}
+	getPlanes() {
+		return Object.values(this.planes);
+	}
+	getZLevels() {
+		return Object.keys(this.planes).map(Number).sort((e, t) => e - t);
+	}
+	getRooms() {
+		return this.area.rooms;
+	}
+	getFullBounds() {
+		return this.getPlanes().reduce((e, t) => {
+			let n = t.getBounds();
+			return {
+				minX: Math.min(e.minX, n.minX),
+				maxX: Math.max(e.maxX, n.maxX),
+				minY: Math.min(e.minY, n.minY),
+				maxY: Math.max(e.maxY, n.maxY)
+			};
+		}, {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		});
+	}
+	getLinkExits(e) {
+		return Array.from(this.exits.values()).filter((t) => t.zIndex.includes(e));
+	}
+	createPlanes() {
+		let t = this.area.rooms.reduce((e, t) => (e[t.z] || (e[t.z] = []), e[t.z].push(t), e), {});
+		return Object.entries(t).reduce((t, [n, r]) => (t[+n] = new e(r, this.area.labels.filter((e) => e.Z === +n)), t), {});
+	}
+	static {
+		this.oppositeDir = {
+			north: "south",
+			south: "north",
+			east: "west",
+			west: "east",
+			northeast: "southwest",
+			southwest: "northeast",
+			northwest: "southeast",
+			southeast: "northwest",
+			up: "down",
+			down: "up",
+			in: "out",
+			out: "in"
+		};
+	}
+	createExits() {
+		let e = /* @__PURE__ */ new Map();
+		this.area.rooms.forEach((t) => {
+			Object.entries(t.exits).forEach(([n, r]) => {
+				if (t.id === r) return;
+				let i = `${Math.min(t.id, r)}-${Math.max(t.id, r)}`;
+				e.has(i) || e.set(i, []), e.get(i).push({
+					origin: t.id,
+					target: r,
+					z: t.z,
+					dir: n
+				});
+			});
+		});
+		for (let [n, r] of e) {
+			let [e, i] = n.split("-"), a = parseInt(e), o = parseInt(i), s = r.filter((e) => e.origin === a), c = r.filter((e) => e.origin === o), l = /* @__PURE__ */ new Set();
+			for (let e of s) {
+				let r = -1;
+				for (let n = 0; n < c.length; n++) if (!l.has(n) && c[n].dir === t.oppositeDir[e.dir]) {
+					r = n;
+					break;
+				}
+				if (r !== -1) {
+					l.add(r);
+					let t = c[r];
+					this.exits.set(`${n}-${e.dir}`, {
+						a,
+						b: o,
+						aDir: e.dir,
+						bDir: t.dir,
+						zIndex: [e.z, t.z]
+					});
+				} else this.exits.set(`${n}-a:${e.dir}`, {
+					a,
+					b: o,
+					aDir: e.dir,
+					zIndex: [e.z]
+				});
+			}
+			for (let e = 0; e < c.length; e++) if (!l.has(e)) {
+				let t = c[e];
+				this.exits.set(`${n}-b:${t.dir}`, {
+					a,
+					b: o,
+					bDir: t.dir,
+					zIndex: [t.z]
+				});
+			}
+		}
+	}
+}, n = {
+	rgb: [
+		114,
+		1,
+		0
+	],
+	rgbValue: "rgb(114, 1, 0)",
+	symbolColor: [
+		225,
+		225,
+		225
+	],
+	symbolColorValue: "rgb(225,225,225)"
+};
+function r(e) {
+	let t = e[0] / 255, n = e[1] / 255, r = e[2] / 255;
+	return (Math.max(t, n, r) + Math.min(t, n, r)) / 2;
+}
+var i = class {
+	constructor(e, n) {
+		this.rooms = {}, this.areas = {}, this.colors = {}, e.forEach((e) => {
+			let n = {
+				...e,
+				rooms: e.rooms.map((e) => ({
+					...e,
+					y: -e.y
+				}))
+			};
+			n.rooms.forEach((e) => {
+				this.rooms[e.id] = e;
+			});
+			let r = parseInt(e.areaId);
+			this.areas[r] = new t(n);
+		}), this.colors = n.reduce((e, t) => ({
+			...e,
+			[t.envId]: {
+				rgb: t.colors,
+				rgbValue: `rgb(${t.colors.join(",")})`,
+				symbolColor: r(t.colors) > .41 ? [
+					25,
+					25,
+					25
+				] : [
+					225,
+					255,
+					255
+				],
+				symbolColorValue: r(t.colors) > .41 ? "rgb(25,25,25)" : "rgb(225,255,255)"
+			}
+		}), {});
+	}
+	getArea(e) {
+		return this.areas[e];
+	}
+	getAreas() {
+		return Object.values(this.areas);
+	}
+	getRooms() {
+		return Object.values(this.rooms);
+	}
+	getRoom(e) {
+		return this.rooms[e];
+	}
+	getColorValue(e) {
+		return this.colors[e]?.rgbValue ?? n.rgbValue;
+	}
+	getSymbolColor(e, t) {
+		let r = this.colors[e]?.symbolColor ?? n.symbolColor, i = Math.min(Math.max(t ?? 1, 0), 1), a = r.join(",");
+		return i == 1 ? `rgba(${a})` : `rgba(${a}, ${i})`;
+	}
+};
+//#endregion
+export { t as n, e as r, i as t };
+
+//# sourceMappingURL=MapReader-mU_4JWv_.js.map

package/dist/MapReader-mU_4JWv_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapReader-mU_4JWv_.js","names":[],"sources":["../src/reader/Plane.ts","../src/reader/Area.ts","../src/reader/MapReader.ts"],"sourcesContent":["/**\n * Public, renderer-facing surface of a z-level slice of an area.\n *\n * The renderer (and other library consumers) only depend on this interface;\n * the concrete {@link Plane} class is one implementation of it. Downstream\n * apps that want to drive the renderer from their own data model can hand it\n * any `IPlane`-shaped object (typically returned from an {@link IArea}).\n */\nexport interface IPlane {\n    getRooms(): MapData.Room[];\n    getLabels(): MapData.Label[];\n    getBounds(): { minX: number; maxX: number; minY: number; maxY: number };\n}\n\nexport default class Plane implements IPlane {\n\n    private readonly bounds: { minX: number, maxX: number, minY: number, maxY: number }\n    private readonly rooms: MapData.Room[] = [];\n    private readonly labels: MapData.Label[] = [];\n\n    constructor(rooms: MapData.Room[], labels: MapData.Label[]) {\n        this.rooms = rooms;\n        this.labels = labels;\n        this.bounds = this.createBounds();\n    }\n\n    getRooms() {\n        return this.rooms;\n    }\n\n    getLabels() {\n        return this.labels;\n    }\n\n    getBounds() {\n        return this.bounds;\n    }\n\n    private createBounds() {\n        const b = this.rooms.reduce(\n            (acc, r) => ({\n                minX: Math.min(acc.minX, r.x),\n                maxX: Math.max(acc.maxX, r.x),\n                minY: Math.min(acc.minY, r.y),\n                maxY: Math.max(acc.maxY, r.y),\n            }),\n            {\n                minX: Number.POSITIVE_INFINITY,\n                maxX: Number.NEGATIVE_INFINITY,\n                minY: Number.POSITIVE_INFINITY,\n                maxY: Number.NEGATIVE_INFINITY,\n            }\n        );\n        for (const label of this.labels) {\n            const lx = label.X;\n            const ly = -label.Y;\n            b.minX = Math.min(b.minX, lx);\n            b.maxX = Math.max(b.maxX, lx + label.Width);\n            b.minY = Math.min(b.minY, ly);\n            b.maxY = Math.max(b.maxY, ly + label.Height);\n        }\n        return b;\n    }\n\n}\n","import Plane, {IPlane} from \"./Plane\";\n\nimport IExit from \"./Exit\";\n\n/**\n * Public, renderer-facing surface of an area. The renderer never inspects\n * private state of {@link Area}; it talks to this interface only. Custom data\n * models (e.g. an app that owns its own room store) can satisfy `IArea` and\n * hand the result to {@link MapRenderer} without subclassing.\n *\n * Mutability lives on the concrete implementation: {@link Area.markDirty} is\n * `protected`, kept off the public interface. Consumers signal \"redraw me\" by\n * bumping {@link getVersion}; the renderer reads the version to decide\n * whether to rebuild.\n */\nexport interface IArea {\n    getAreaName(): string;\n    getAreaId(): number;\n    /**\n     * Monotonically increasing version. The renderer compares the value it\n     * cached on the last build against the current value to decide whether\n     * the area needs a rebuild.\n     */\n    getVersion(): number;\n    getPlane(zIndex: number): IPlane;\n    getPlanes(): IPlane[];\n    getZLevels(): number[];\n    getRooms(): MapData.Room[];\n    getFullBounds(): { minX: number; maxX: number; minY: number; maxY: number };\n    /**\n     * Inter-room exits drawn on the given z-level. Each exit is bidirectional\n     * with optional one-way fallback; see {@link IExit}.\n     */\n    getLinkExits(zIndex: number): IExit[];\n}\n\nexport default class Area implements IArea {\n\n    private readonly planes: Record<number, Plane> = {};\n    private readonly area: MapData.Area;\n    private readonly exits: Map<string, IExit> = new Map();\n    private version = 0;\n\n    constructor(area: MapData.Area) {\n        this.area = area;\n        this.planes = this.createPlanes();\n        this.createExits();\n    }\n\n    getAreaName() {\n        return this.area.areaName\n    }\n\n    getAreaId() {\n        return parseInt(this.area.areaId)\n    }\n\n    getVersion() {\n        return this.version;\n    }\n\n    protected markDirty() {\n        this.version++;\n    }\n\n    getPlane(zIndex: number) {\n        return this.planes[zIndex];\n    }\n\n    getPlanes() {\n        return Object.values(this.planes);\n    }\n\n    getZLevels(): number[] {\n        return Object.keys(this.planes).map(Number).sort((a, b) => a - b);\n    }\n\n    getRooms() {\n        return this.area.rooms\n    }\n\n    getFullBounds(): { minX: number; maxX: number; minY: number; maxY: number } {\n        return this.getPlanes().reduce(\n            (acc, plane) => {\n                const b = plane.getBounds();\n                return {\n                    minX: Math.min(acc.minX, b.minX),\n                    maxX: Math.max(acc.maxX, b.maxX),\n                    minY: Math.min(acc.minY, b.minY),\n                    maxY: Math.max(acc.maxY, b.maxY),\n                };\n            },\n            { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }\n        );\n    }\n\n    getLinkExits(zIndex: number) {\n        return Array.from(this.exits.values()).filter(e => e.zIndex.includes(zIndex));\n    }\n\n    private createPlanes() {\n        const grouped = this.area.rooms.reduce<Record<number, MapData.Room[]>>((acc, room) => {\n            if (!acc[room.z]) {\n                acc[room.z] = [];\n            }\n            // @ts-ignore\n            acc[room.z].push(room);\n            return acc;\n        }, {});\n        return Object.entries(grouped).reduce(\n            (acc, [z, rooms]) => {\n                acc[+z] = new Plane(rooms, this.area.labels.filter(label => label.Z === +z));\n                return acc;\n            },\n            {} as Record<number, Plane>\n        );\n    }\n\n    private static readonly oppositeDir: Partial<Record<MapData.direction, MapData.direction>> = {\n        \"north\": \"south\", \"south\": \"north\",\n        \"east\": \"west\", \"west\": \"east\",\n        \"northeast\": \"southwest\", \"southwest\": \"northeast\",\n        \"northwest\": \"southeast\", \"southeast\": \"northwest\",\n        \"up\": \"down\", \"down\": \"up\",\n        \"in\": \"out\", \"out\": \"in\",\n    };\n\n    private createExits() {\n        type HalfExit = { origin: number, target: number, z: number, dir: MapData.direction };\n        const halfExitsByPair = new Map<string, HalfExit[]>();\n\n        this.area.rooms.forEach(room => {\n            Object.entries(room.exits).forEach(([direction, targetRoomId]) => {\n                if (room.id === targetRoomId) return;\n                const a = Math.min(room.id, targetRoomId);\n                const b = Math.max(room.id, targetRoomId);\n                const key = `${a}-${b}`;\n                if (!halfExitsByPair.has(key)) halfExitsByPair.set(key, []);\n                halfExitsByPair.get(key)!.push({\n                    origin: room.id, target: targetRoomId, z: room.z, dir: direction as MapData.direction\n                });\n            });\n        });\n\n        for (const [pairKey, halves] of halfExitsByPair) {\n            const [aStr, bStr] = pairKey.split('-');\n            const a = parseInt(aStr), b = parseInt(bStr);\n\n            const aSide = halves.filter(h => h.origin === a);\n            const bSide = halves.filter(h => h.origin === b);\n\n            const usedB = new Set<number>();\n\n            for (const aHalf of aSide) {\n                let bestIdx = -1;\n                for (let i = 0; i < bSide.length; i++) {\n                    if (usedB.has(i)) continue;\n                    if (bSide[i].dir === Area.oppositeDir[aHalf.dir]) {\n                        bestIdx = i;\n                        break;\n                    }\n                }\n\n                if (bestIdx !== -1) {\n                    usedB.add(bestIdx);\n                    const bHalf = bSide[bestIdx];\n                    this.exits.set(`${pairKey}-${aHalf.dir}`, {\n                        a, b, aDir: aHalf.dir, bDir: bHalf.dir, zIndex: [aHalf.z, bHalf.z]\n                    });\n                } else {\n                    this.exits.set(`${pairKey}-a:${aHalf.dir}`, {\n                        a, b, aDir: aHalf.dir, zIndex: [aHalf.z]\n                    });\n                }\n            }\n\n            for (let i = 0; i < bSide.length; i++) {\n                if (!usedB.has(i)) {\n                    const bHalf = bSide[i];\n                    this.exits.set(`${pairKey}-b:${bHalf.dir}`, {\n                        a, b, bDir: bHalf.dir, zIndex: [bHalf.z]\n                    });\n                }\n            }\n        }\n    }\n\n}","import Area, {IArea} from \"./Area\";\n\n/**\n * Public, renderer-facing surface for map data. Everything the renderer\n * (and other library consumers) call on `MapReader` is on this interface —\n * private state and internal helpers are not.\n *\n * Downstream apps with their own room/area store can implement `IMapReader`\n * directly (no need to subclass {@link MapReader}) and hand the result to\n * {@link MapRenderer}. Visibility filtering (exploration, scope overlays,\n * etc.) lives on the renderer's lens — it is intentionally not on this\n * interface.\n */\nexport interface IMapReader {\n    getArea(areaId: number): IArea;\n    getAreas(): IArea[];\n    getRooms(): MapData.Room[];\n    getRoom(roomId: number): MapData.Room;\n    /** Returns the env's `rgb(r,g,b)` string, or a default colour if the env id is unknown. */\n    getColorValue(envId: number): string;\n    /** Returns a contrasting symbol colour for the env, optionally with the given alpha. */\n    getSymbolColor(envId: number, opacity?: number): string;\n}\n\ninterface Color {\n    rgb: number[];\n    rgbValue: string;\n    symbolColor: number[];\n    symbolColorValue: string,\n}\n\nconst defaultColor: Color = {\n    rgb: [114, 1, 0],\n    rgbValue: 'rgb(114, 1, 0)',\n    symbolColor: [225, 225, 225],\n    symbolColorValue: 'rgb(225,225,225)'\n}\n\nfunction calculateLuminance(rgb: number[]) {\n    const rn = rgb[0] / 255;\n    const gn = rgb[1] / 255;\n    const bn = rgb[2] / 255;\n\n    const max = Math.max(rn, gn, bn);\n    const min = Math.min(rn, gn, bn);\n\n    return (max + min) / 2;\n}\n\nexport default class MapReader implements IMapReader {\n\n    private rooms: Record<number, MapData.Room> = {};\n    private areas: Record<number, Area> = {};\n    private colors: Record<number, Color> = {};\n\n    constructor(map: MapData.Map, envs: MapData.Env[]) {\n        map.forEach(area => {\n            const clonedArea: MapData.Area = {\n                ...area,\n                rooms: area.rooms.map(room => ({ ...room, y: -room.y })),\n            };\n            clonedArea.rooms.forEach(room => {\n                this.rooms[room.id] = room;\n            });\n            const areaId = parseInt(area.areaId);\n            this.areas[areaId] = new Area(clonedArea);\n        })\n        this.colors = envs.reduce((acc, c) => ({\n            ...acc,\n            [c.envId]: {\n                rgb: c.colors,\n                rgbValue: `rgb(${c.colors.join(',')})`,\n                symbolColor: calculateLuminance(c.colors) > 0.41 ? [25, 25, 25] : [225, 255, 255],\n                symbolColorValue: calculateLuminance(c.colors) > 0.41 ? 'rgb(25,25,25)' : 'rgb(225,255,255)'\n            }\n        }), {});\n    }\n\n    getArea(areaId: number) {\n        return this.areas[areaId];\n    }\n\n    getAreas() {\n        return Object.values(this.areas);\n    }\n\n    getRooms() {\n        return Object.values(this.rooms);\n    }\n\n    getRoom(roomId: number) {\n        return this.rooms[roomId];\n    }\n\n    getColorValue(envId: number): string {\n        return this.colors[envId]?.rgbValue ?? defaultColor.rgbValue;\n    }\n\n    getSymbolColor(envId: number, opacity?: number): string {\n        const color = this.colors[envId]?.symbolColor ?? defaultColor.symbolColor;\n        const normalizedOpacity = Math.min(Math.max(opacity ?? 1, 0), 1);\n        const value = color.join(',');\n        if (normalizedOpacity != 1) {\n            return `rgba(${value}, ${normalizedOpacity})`;\n        }\n        return `rgba(${value})`;\n    }\n\n}\n"],"mappings":"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"}

package/dist/MapState.d.ts

@@ -1,9 +1,10 @@
-import { default as MapReader } from './reader/MapReader';
-import { default as Area } from './reader/Area';
-import { default as Plane } from './reader/Plane';
+import { IMapReader } from './reader/MapReader';
+import { IArea } from './reader/Area';
+import { IPlane } from './reader/Plane';
 import { Settings } from './types/Settings';
 import { SvgOverlays } from './SvgTypes';
 import { TypedEventEmitter } from './TypedEventEmitter';
+import { RoomLens } from './lens/RoomLens';
 export type HighlightEntry = {
     color: string;
     area: number;
@@ -15,7 +16,7 @@ export type PathEntry = {
 };
 export type MapStateEventMap = {
     area: {
-        area: Area;
+        area: IArea;
         zIndex: number;
     };
     position: {
@@ -33,6 +34,9 @@ export type MapStateEventMap = {
     };
     path: undefined;
     clear: undefined;
+    lens: {
+        lens: RoomLens;
+    };
 };
 /**
  * Pure data + events layer for map state.
@@ -42,18 +46,20 @@ export type MapStateEventMap = {
  * Rendering backends subscribe to events and sync their visual state.
  */
 export declare class MapState {
-    readonly mapReader: MapReader;
+    readonly mapReader: IMapReader;
     readonly settings: Settings;
     readonly events: TypedEventEmitter<MapStateEventMap>;
     currentArea?: number;
-    currentAreaInstance?: Area;
+    currentAreaInstance?: IArea;
     currentZIndex?: number;
     currentAreaVersion?: number;
     positionRoomId?: number;
     centerRoomId?: number;
     highlights: Map<number, HighlightEntry>;
     paths: PathEntry[];
-    constructor(mapReader: MapReader, settings: Settings);
+    lens: RoomLens;
+    constructor(mapReader: IMapReader, settings: Settings);
+    setLens(lens: RoomLens): void;
     /**
      * Set the displayed area and z-level.
      * Returns true if the area/z actually changed (or area version bumped).
@@ -86,7 +92,7 @@ export declare class MapState {
     /**
      * Get the effective plane bounds (respects uniformLevelSize setting).
      */
-    getEffectiveBounds(area: Area, plane: Plane): {
+    getEffectiveBounds(area: IArea, plane: IPlane): {
         minX: number;
         maxX: number;
         minY: number;
@@ -95,7 +101,7 @@ export declare class MapState {
     /**
      * Compute export bounds for a given area/plane, optionally centered on a room.
      */
-    computeExportBounds(area: Area, plane: Plane, roomId: number | undefined, padding: number): {
+    computeExportBounds(area: IArea, plane: IPlane, roomId: number | undefined, padding: number): {
         x: number;
         y: number;
         w: number;

package/dist/PathData.d.ts

@@ -1,4 +1,4 @@
-import { default as MapReader } from './reader/MapReader';
+import { IMapReader } from './reader/MapReader';
 import { Settings } from './types/Settings';
 export interface PathSegment {
     points: number[];
@@ -15,4 +15,4 @@ export interface PathResult {
     innerMarkers: PathInnerMarker[];
     customLines: PathCustomLine[];
 }
-export declare function computePathData(mapReader: MapReader, settings: Settings, locations: number[], currentArea: number, currentZIndex: number): PathResult;
+export declare function computePathData(mapReader: IMapReader, settings: Settings, locations: number[], currentArea: number, currentZIndex: number): PathResult;

package/dist/PathFinder.d.ts

@@ -1,11 +1,11 @@
-import { default as MapReader } from './reader/MapReader';
+import { IMapReader } from './reader/MapReader';
 export type PathFindingAlgorithm = 'dijkstra' | 'astar';
 export default class PathFinder {
     private readonly mapGraph;
     private readonly dijkstraGraph;
     private _algorithm;
     private readonly cache;
-    constructor(mapReader: MapReader, algorithm?: PathFindingAlgorithm);
+    constructor(mapReader: IMapReader, algorithm?: PathFindingAlgorithm);
     get algorithm(): PathFindingAlgorithm;
     setAlgorithm(algorithm: PathFindingAlgorithm): void;
     findPath(from: number, to: number): number[] | null;

package/dist/ScenePipeline.d.ts

@@ -1,9 +1,10 @@
-import { default as MapReader } from './reader/MapReader';
-import { default as Area } from './reader/Area';
-import { default as Plane } from './reader/Plane';
+import { IMapReader } from './reader/MapReader';
+import { IArea } from './reader/Area';
+import { IPlane } from './reader/Plane';
 import { Settings } from './types/Settings';
 import { default as ExitRenderer, ExitDrawData } from './ExitRenderer';
 import { GroupShape, Shape } from './scene/Shape';
+import { RoomLens } from './lens/RoomLens';
 type Bounds = {
     x: number;
     y: number;
@@ -185,14 +186,17 @@ export declare class ScenePipeline {
     private specialExitShapeRefs;
     private stubShapeRefs;
     private areaExitLabelShapeRefs;
-    constructor(mapReader: MapReader, settings: Settings);
+    constructor(mapReader: IMapReader, settings: Settings);
     /**
      * Build the full scene for an area/plane.
      * Clears layers, renders grid → labels → exits → rooms → area name.
      * Returns data for culling and interaction (room nodes, exit data, hit zones).
+     *
+     * The `lens` filters which rooms paint and how partially-visible exits are
+     * treated. Pass {@link ALL_VISIBLE} (or omit) for an unfiltered build.
      */
-    buildScene(area: Area, plane: Plane, zIndex: number): SceneBuildResult;
-    getEffectiveBounds(area: Area, plane: Plane): {
+    buildScene(area: IArea, plane: IPlane, zIndex: number, lens?: RoomLens): SceneBuildResult;
+    getEffectiveBounds(area: IArea, plane: IPlane): {
         minX: number;
         maxX: number;
         minY: number;
@@ -200,6 +204,15 @@ export declare class ScenePipeline {
     };
     private renderRooms;
     private renderLinkExits;
+    /**
+     * Build a stub anchored at the visible endpoint of an exit, pointing
+     * toward the hidden one. Returns undefined when the exit can't be drawn
+     * as a stub (no planar direction on the visible side, both sides hidden,
+     * or both sides visible — the last is a caller bug).
+     */
+    private buildLensStub;
+    private emitLensStub;
+    private getRoomEdgePoint;
     /**
      * Build the world-space shape tree for one inter-room exit. Used by the
      * live renderer's current-room overlay path to recolour a single exit

package/dist/binary/BinaryMapReader.d.ts

@@ -0,0 +1,36 @@
+import { MudletMap, readMapFromBuffer } from 'mudlet-map-binary-reader';
+import { IMapReader } from '../reader/MapReader';
+import { IArea } from '../reader/Area';
+/**
+ * {@link IMapReader} implementation backed by a parsed Mudlet binary map.
+ *
+ * Convenience wrapper around the existing {@link MapReader} that converts a
+ * {@link MudletMap} (the in-memory binary model from
+ * `mudlet-map-binary-reader`) into the renderer's `{mapData, colors}` shape
+ * via `readerExport()`, then forwards every `IMapReader` call to the wrapped
+ * reader.
+ *
+ * Useful for downstream apps (the upstream Mudix client is one) that already
+ * own binary `.dat` bytes and want a single object they can hand to
+ * {@link MapRenderer} without staging a separate JSON export step.
+ *
+ * `mudlet-map-binary-reader` is a `peerDependency`; consumers who do not use
+ * binary maps never pay the bundle cost.
+ */
+export default class BinaryMapReader implements IMapReader {
+    private readonly reader;
+    /** Build directly from a parsed {@link MudletMap}. */
+    constructor(model: MudletMap);
+    /**
+     * Parse the given binary map buffer and construct a reader from it.
+     * In Node, pass `fs.readFileSync(path)`; in the browser, construct a
+     * `Buffer` from an `ArrayBuffer` (e.g. via the `buffer` polyfill).
+     */
+    static fromBuffer(buf: Parameters<typeof readMapFromBuffer>[0]): BinaryMapReader;
+    getArea(areaId: number): IArea;
+    getAreas(): IArea[];
+    getRooms(): MapData.Room[];
+    getRoom(roomId: number): MapData.Room;
+    getColorValue(envId: number): string;
+    getSymbolColor(envId: number, opacity?: number): string;
+}

package/dist/binary/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BinaryMapReader } from './BinaryMapReader';
+export type { MudletMap, MudletArea, MudletRoom, MudletColor, MudletLabel } from 'mudlet-map-binary-reader';

package/dist/binary.mjs

@@ -0,0 +1,34 @@
+import { t as e } from "./MapReader-mU_4JWv_.js";
+import { readMapFromBuffer as t, readerExport as n } from "mudlet-map-binary-reader";
+//#region src/binary/BinaryMapReader.ts
+var r = class r {
+	constructor(t) {
+		let { mapData: r, colors: i } = n(t);
+		this.reader = new e(r, i);
+	}
+	static fromBuffer(e) {
+		return new r(t(e));
+	}
+	getArea(e) {
+		return this.reader.getArea(e);
+	}
+	getAreas() {
+		return this.reader.getAreas();
+	}
+	getRooms() {
+		return this.reader.getRooms();
+	}
+	getRoom(e) {
+		return this.reader.getRoom(e);
+	}
+	getColorValue(e) {
+		return this.reader.getColorValue(e);
+	}
+	getSymbolColor(e, t) {
+		return this.reader.getSymbolColor(e, t);
+	}
+};
+//#endregion
+export { r as BinaryMapReader };
+
+//# sourceMappingURL=binary.mjs.map

package/dist/binary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.mjs","names":[],"sources":["../src/binary/BinaryMapReader.ts"],"sourcesContent":["import {\n    type MudletMap,\n    readerExport,\n    readMapFromBuffer,\n} from \"mudlet-map-binary-reader\";\nimport MapReader, {type IMapReader} from \"../reader/MapReader\";\nimport type {IArea} from \"../reader/Area\";\n\n/**\n * {@link IMapReader} implementation backed by a parsed Mudlet binary map.\n *\n * Convenience wrapper around the existing {@link MapReader} that converts a\n * {@link MudletMap} (the in-memory binary model from\n * `mudlet-map-binary-reader`) into the renderer's `{mapData, colors}` shape\n * via `readerExport()`, then forwards every `IMapReader` call to the wrapped\n * reader.\n *\n * Useful for downstream apps (the upstream Mudix client is one) that already\n * own binary `.dat` bytes and want a single object they can hand to\n * {@link MapRenderer} without staging a separate JSON export step.\n *\n * `mudlet-map-binary-reader` is a `peerDependency`; consumers who do not use\n * binary maps never pay the bundle cost.\n */\nexport default class BinaryMapReader implements IMapReader {\n    private readonly reader: MapReader;\n\n    /** Build directly from a parsed {@link MudletMap}. */\n    constructor(model: MudletMap) {\n        const {mapData, colors} = readerExport(model);\n        // RendererRoom (binary-reader output) and MapData.Room (renderer\n        // input) overlap structurally — RendererRoom is missing only\n        // `areaId`, which the renderer never reads from rooms (only from\n        // the area). Cast through `unknown` to bridge the nominal gap.\n        this.reader = new MapReader(mapData as unknown as MapData.Map, colors);\n    }\n\n    /**\n     * Parse the given binary map buffer and construct a reader from it.\n     * In Node, pass `fs.readFileSync(path)`; in the browser, construct a\n     * `Buffer` from an `ArrayBuffer` (e.g. via the `buffer` polyfill).\n     */\n    static fromBuffer(buf: Parameters<typeof readMapFromBuffer>[0]): BinaryMapReader {\n        return new BinaryMapReader(readMapFromBuffer(buf));\n    }\n\n    // --- IMapReader forwarding ---\n\n    getArea(areaId: number): IArea {\n        return this.reader.getArea(areaId);\n    }\n\n    getAreas(): IArea[] {\n        return this.reader.getAreas();\n    }\n\n    getRooms(): MapData.Room[] {\n        return this.reader.getRooms();\n    }\n\n    getRoom(roomId: number): MapData.Room {\n        return this.reader.getRoom(roomId);\n    }\n\n    getColorValue(envId: number): string {\n        return this.reader.getColorValue(envId);\n    }\n\n    getSymbolColor(envId: number, opacity?: number): string {\n        return this.reader.getSymbolColor(envId, opacity);\n    }\n}\n"],"mappings":";;;AAwBA,IAAqB,IAArB,MAAqB,EAAsC;CAIvD,YAAY,GAAkB;EAC1B,IAAM,EAAC,YAAS,cAAU,EAAa,EAAM;AAK7C,OAAK,SAAS,IAAI,EAAU,GAAmC,EAAO;;CAQ1E,OAAO,WAAW,GAA+D;AAC7E,SAAO,IAAI,EAAgB,EAAkB,EAAI,CAAC;;CAKtD,QAAQ,GAAuB;AAC3B,SAAO,KAAK,OAAO,QAAQ,EAAO;;CAGtC,WAAoB;AAChB,SAAO,KAAK,OAAO,UAAU;;CAGjC,WAA2B;AACvB,SAAO,KAAK,OAAO,UAAU;;CAGjC,QAAQ,GAA8B;AAClC,SAAO,KAAK,OAAO,QAAQ,EAAO;;CAGtC,cAAc,GAAuB;AACjC,SAAO,KAAK,OAAO,cAAc,EAAM;;CAG3C,eAAe,GAAe,GAA0B;AACpD,SAAO,KAAK,OAAO,eAAe,GAAO,EAAQ"}

package/dist/index.d.ts

@@ -7,7 +7,6 @@ export type { DrawnExitEntry, DrawnSpecialExitEntry, DrawnStubEntry } from './Sc
 export type { ExitDrawData, ExitDrawLine, ExitDrawArrow, ExitDrawDoor } from './ExitRenderer';
 export { MapState } from './MapState';
 export type { MapStateEventMap, HighlightEntry, PathEntry } from './MapState';
-export { KonvaRenderBackend } from './rendering/KonvaRenderBackend';
 export { Camera } from './camera/Camera';
 export type { CameraEventMap } from './camera/Camera';
 export { HitTester } from './hit/HitTester';
@@ -34,15 +33,26 @@ export type { PngExportOptions } from './export/PngExporter';
 export { CanvasExporter, PngBytesExporter } from './export/CanvasExporter';
 export type { CanvasExportOptions, PngBytesExportOptions } from './export/CanvasExporter';
 export { canvasToBytes } from './export/canvasToBytes';
-export type { SceneOverlay, SceneOverlayContext, CanvasDrawState } from './overlay/SceneOverlay';
+export type { SceneOverlay, SceneOverlayContext } from './overlay/SceneOverlay';
+export type { LiveEffect, CoordinateTransform } from './overlay/LiveEffect';
 export { AmbientLightOverlay } from './overlay/AmbientLightOverlay';
 export type { AmbientLightOptions } from './overlay/AmbientLightOverlay';
 export { default as MapReader } from './reader/MapReader';
+export type { IMapReader } from './reader/MapReader';
 export { default as PathFinder } from './PathFinder';
 export type { PathFindingAlgorithm } from './PathFinder';
 export { MapGraph } from './MapGraph';
 export type { Edge, GraphData } from './MapGraph';
-export { default as ExplorationArea } from './reader/ExplorationArea';
+export { default as Area } from './reader/Area';
+export type { IArea } from './reader/Area';
+export { default as Plane } from './reader/Plane';
+export type { IPlane } from './reader/Plane';
+export type { IExit, Kind as ExitKind } from './reader/Exit';
+export type { RoomLens, ExitTreatment } from './lens/RoomLens';
+export { ALL_VISIBLE, defaultExitTreatment } from './lens/RoomLens';
+export { composeLenses } from './lens/composeLenses';
+export type { ComposeOptions, ExitConflictStrategy } from './lens/composeLenses';
+export { ExplorationLens } from './lens/ExplorationLens';
 export { AreaMapRenderer, createAreaMapSettings } from './AreaMapRenderer';
 export type { AreaMapSettings } from './AreaMapRenderer';
 export type { AreaDomainInfo, DomainFilter } from './AreaMapRenderer';