mudlet-map-renderer 2.5.1 → 2.6.1

package/dist/reader/Area.d.ts

@@ -1,5 +1,12 @@
 import { default as Plane, IPlane } from './Plane';
 import { default as IExit } from './Exit';
+/**
+ * Pair each room's half-exits into bidirectional {@link IExit}s (or one-way
+ * fallbacks when a room's neighbour doesn't exit back). Exposed standalone so
+ * callers with an already-filtered room list (e.g. a viewport-narrowed set)
+ * can pair exits directly, without constructing a full {@link Area}.
+ */
+export declare function pairLinkExits(rooms: MapData.Room[]): Map<string, IExit>;
 /**
  * Public, renderer-facing surface of an area. The renderer never inspects
  * private state of {@link Area}; it talks to this interface only. Custom data
@@ -39,7 +46,7 @@ export interface IArea {
 export default class Area implements IArea {
     private readonly planes;
     private readonly area;
-    private readonly exits;
+    private exits;
     private version;
     constructor(area: MapData.Area);
     getAreaName(): string;
@@ -58,6 +65,5 @@ export default class Area implements IArea {
     };
     getLinkExits(zIndex: number): IExit[];
     private createPlanes;
-    private static readonly oppositeDir;
     private createExits;
 }

package/dist/reader/HashLookup.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Optional capability interface for readers that can resolve a Mudlet room
+ * content hash (`MapData.Room.hash`) directly to a room id.
+ *
+ * `SkeletonMapReader.getRooms()` deliberately always returns `[]` (see
+ * {@link ViewportDataSource} — never materialise the full room list), so a
+ * linear `getRooms().find(r => r.hash === hash)` scan — the only option
+ * `IMapReader` supports on its own — can never find anything on a big/
+ * streamed map. This interface gives such readers a way to opt into an O(1)
+ * (or otherwise scan-free) hash lookup instead.
+ */
+export interface HashLookupCapable {
+    readonly hashLookupCapable: true;
+    /** Resolve a room's content hash to its id, or `undefined` if unknown. */
+    getRoomIdByHash(hash: string): number | undefined;
+}
+export declare function isHashLookupCapable(reader: unknown): reader is HashLookupCapable;

package/dist/reader/ViewportDataSource.d.ts

@@ -0,0 +1,33 @@
+import { ViewportBounds } from '../types/Settings';
+/**
+ * Optional capability interface for readers that materialise rooms
+ * per-viewport instead of holding a full object graph (see
+ * `SkeletonMapReader` in `src/bigmap/`).
+ *
+ * The interactive backend detects this capability (via
+ * {@link isViewportDataSource}) and, when present:
+ *  - pushes padded viewport bounds into the reader before every scene build,
+ *    rebuilding the scene when the camera leaves the previously applied
+ *    window (rebuild-on-pan), and
+ *  - drives the raster LOD overview through {@link forEachInBounds}, which
+ *    visits raw room positions without materialising `MapData.Room` objects.
+ *
+ * All bounds are renderer space (the space `getViewportBounds()` reports).
+ */
+export interface ViewportDataSource {
+    readonly viewportAware: true;
+    /**
+     * Set the window that subsequent `getPlane().getRooms()` /
+     * `getLinkExits()` calls materialise. Implementations must bump their
+     * areas' `getVersion()` when the bounds actually change.
+     */
+    setViewport(bounds: ViewportBounds): void;
+    getViewport(): ViewportBounds;
+    /** Total rooms on the (area, z) plane — input to the LOD mode decision. */
+    getPlaneRoomCount(areaId: number, z: number): number;
+    /** Cheap upper bound of the rooms inside `bounds` on that plane. */
+    estimateVisibleCount(areaId: number, z: number, bounds: ViewportBounds): number;
+    /** Visit every room inside `bounds` (renderer-space x/y + env id). */
+    forEachInBounds(areaId: number, z: number, bounds: ViewportBounds, fn: (x: number, y: number, envId: number) => void): void;
+}
+export declare function isViewportDataSource(reader: unknown): reader is ViewportDataSource;

package/dist/render/CullIndex.d.ts

@@ -0,0 +1,54 @@
+import { Shape } from '../scene/Shape';
+import { ViewportBounds } from '../types/Settings';
+import { CoordFn } from '../coord/CoordFn';
+/** One indexed shape with its scene-space axis-aligned bounding box. */
+export interface CullIndexEntry {
+    shape: Shape;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export declare class CullIndex {
+    private entries;
+    private allShapes;
+    private linear;
+    private originX;
+    private originY;
+    private cellSize;
+    private cols;
+    private rows;
+    /** Per-cell lists of entry indices (row-major, length cols*rows). */
+    private cells;
+    /** Indices of entries too large to grid — always tested. */
+    private oversized;
+    /** Per-query dedup stamps so a multi-cell entry is tested at most once. */
+    private stamp;
+    private queryGen;
+    /**
+     * (Re)build the index from scene-space entries. `entries` is retained by
+     * reference; callers should not mutate it afterwards.
+     */
+    build(entries: CullIndexEntry[]): void;
+    /** Shapes known to this index (i.e. cullable). Order is build order. */
+    getAllShapes(): ReadonlySet<Shape>;
+    /**
+     * Return the set of shapes whose AABB intersects `viewport`. Inclusive on
+     * every edge, matching `buildCullingVisibilityMap`.
+     */
+    queryVisible(viewport: ViewportBounds): Set<Shape>;
+    private clampCol;
+    private clampRow;
+}
+/**
+ * Project a world-space AABB through `transform` into a scene-space AABB by
+ * transforming its four corners and taking the min/max. For the identity
+ * transform the box is returned unchanged. Mirrors the `transformedBbox`
+ * helper in `clipSceneToViewport` so index bounds match the cull predicate.
+ */
+export declare function projectBounds(minX: number, minY: number, maxX: number, maxY: number, transform: CoordFn): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};

package/dist/rendering/KonvaRenderBackend.d.ts

@@ -25,6 +25,8 @@ import { Style } from '../style/Style';
  */
 export declare class KonvaRenderBackend implements InteractiveBackend {
     readonly stage: Konva.Stage;
+    /** Bottom-most layer: raster LOD overview underlay (see Settings.lodEnabled). */
+    readonly lodLayer: Konva.Layer;
     readonly gridLayer: Konva.Layer;
     readonly linkLayer: Konva.Layer;
     readonly roomLayer: Konva.Layer;
@@ -47,6 +49,14 @@ export declare class KonvaRenderBackend implements InteractiveBackend {
     readonly hitTester: HitTester;
     private lastHitShapes;
     private shapeToDrawEntry;
+    /**
+     * Managed shapes visible after the last cull pass. applyClipping diffs the
+     * fresh visible set against this and flips only the entries that changed,
+     * so a pan touches O(shapes entering/leaving the viewport), not O(all).
+     * Seeded with every managed shape on rebuild (all entries start visible) so
+     * the first pass hides the off-screen ones.
+     */
+    private lastVisibleShapes;
     private sceneNode;
     /** Lookup from a pipeline-emitted shape to its recording node; rebuilt per buildScene. */
     private shapeToGroup;
@@ -73,6 +83,14 @@ export declare class KonvaRenderBackend implements InteractiveBackend {
     private sceneOverlays;
     private sceneOverlayNodes;
     private viewportSubscribers;
+    private readonly lodController;
+    /** Current LOD tier for the displayed plane — see {@link computeLodMode}. */
+    private lodMode;
+    /** Padded bounds last pushed into a ViewportDataSource reader (rebuild-on-pan hysteresis). */
+    private lastAppliedViewport;
+    /** Camera scale at the last applied viewport — see {@link onCameraViewportChanged}. */
+    private lastAppliedScale;
+    private refreshScheduled;
     constructor(state: MapState, container?: HTMLDivElement);
     setStyle(style: Style): void;
     /** Pull forward/inverse coord transforms from the active shape Style. */
@@ -89,7 +107,57 @@ export declare class KonvaRenderBackend implements InteractiveBackend {
         pixelRatio?: number;
     }): ExportCanvas | undefined;
     private applyViewportToStage;
+    /**
+     * Camera-move follow-up for LOD and viewport-aware readers. A scene
+     * rebuild (RAF-coalesced) is scheduled when:
+     *  - the LOD mode decision flipped (zoom crossed the raster threshold), or
+     *  - a {@link ViewportDataSource} reader's camera left the padded viewport
+     *    applied on the last build (rebuild-on-pan with hysteresis — panning
+     *    inside the padding is covered by the existing culling), or
+     *  - the zoom has drifted materially (±20%) from the scale the padded
+     *    viewport was computed at. The generous (50%-per-side) padding means a
+     *    pure zoom-IN can leave the camera viewport spatially inside the old
+     *    padded region indefinitely — without this check the reader would
+     *    keep reporting the stale, much-too-wide room count (visibleEstimate,
+     *    the vector/hit-test budget decisions) forever while zooming in,
+     *    instead of narrowing to reflect what's actually worth materialising
+     *    at the new zoom.
+     * In raster mode the underlay repaints itself independently (also
+     * coalesced, and only when the painted region no longer covers the view).
+     */
+    private onCameraViewportChanged;
+    private scheduleRefresh;
     refresh(): void;
+    /**
+     * Viewport clamping and LOD only engage once the camera has a real size.
+     * Container-backed stages always do; a headless backend starts at 1×1
+     * (a meaningless viewport that must not clamp exports) until the caller
+     * opts in via `camera.setSize(w, h)`.
+     */
+    private hasRealViewport;
+    /**
+     * Pad viewport bounds by 6% + 1 map unit per side: rooms are selected by
+     * centre, so a room just off-screen can still have half its body in view —
+     * the margin keeps edge rooms from popping and lets the regular culling
+     * reveal margin rooms between rebuilds (rebuild-on-pan hysteresis).
+     */
+    private padViewport;
+    private planeRoomCount;
+    private computeLodMode;
+    /** Room source for the raster painter (never materialises rooms for viewport-aware readers). */
+    private rasterVisit;
+    /** Tear down the vector scene (raster mode replaces it entirely). */
+    private clearVectorScene;
+    /**
+     * Above `settings.lodHitTestBudget` rooms in the current plane build, skip
+     * rebuilding the hit index instead of paying for it on every rebuild — the
+     * vector scene still renders at full detail, but clicks/hover stop
+     * resolving to a room until the density drops back under the budget.
+     * Counted in rooms (same unit as `lodRoomBudget`), not raw hittable-shape
+     * count, so the two settings are directly comparable.
+     */
+    private hitTestBudgetExceeded;
+    private emitLodEvent;
     addLiveEffect(id: string, effect: LiveEffect): void;
     removeLiveEffect(id: string): void;
     addSceneOverlay(id: string, overlay: SceneOverlay): void;

package/dist/rendering/SceneManager.d.ts

@@ -32,6 +32,9 @@ export declare class SceneManager {
     private pipeline;
     private lastBuildResult?;
     private standaloneExitShapeSet;
+    /** Spatial index over the current scene, built lazily and memoised per transform. */
+    private cullIndex?;
+    private cullIndexTransform?;
     constructor(camera: Camera, settings: Settings, mapReader: IMapReader);
     get exitRenderer(): import('../ExitRenderer').default;
     get lastResult(): SceneBuildResult | undefined;
@@ -45,11 +48,31 @@ export declare class SceneManager {
     reset(): void;
     resetPipeline(mapReader: IMapReader): void;
     /**
-     * Lightweight cull for the interactive render path.  Returns a
-     * `Map<Shape, boolean>` where absent shapes are unmanaged pass-throughs
-     * (always visible).  Avoids the 12 Sets + 2 filtered arrays produced by
-     * the full {@link cull} path.
+     * Lightweight cull for the interactive render path. Returns the set of
+     * currently-visible managed shapes (rooms, exits, labels, stubs…) by
+     * querying the spatial {@link CullIndex} — O(visible cells), not O(all
+     * shapes). Shapes outside this set that are *known to the index* should be
+     * hidden; shapes the index has never heard of are unmanaged pass-throughs
+     * (always visible) and the caller must leave them alone.
+     *
+     * When culling is disabled the full managed-shape set is returned, so the
+     * caller's delta logic naturally reveals everything.
      */
-    cullInteractive(coordinateTransform?: CoordFn): Map<Shape, boolean>;
+    cullInteractive(coordinateTransform?: CoordFn): Set<Shape>;
+    /**
+     * Every shape the cull index can hide. Callers seed their "previously
+     * visible" set with this after a rebuild (all entries start visible) so the
+     * first cull pass hides the off-screen ones.
+     */
+    managedShapes(coordinateTransform?: CoordFn): Set<Shape>;
+    /** Build (or reuse) the spatial index for the current scene + transform. */
+    private ensureCullIndex;
+    /**
+     * Project every cullable shape's world-space bounds into scene space and
+     * collect them as index entries. Mirrors the bounds used by
+     * `buildCullingVisibilityMap` exactly so the index and the export-path
+     * predicate agree on which shapes a viewport contains.
+     */
+    private buildCullEntries;
     cull(coordinateTransform?: CoordFn): CullOutput;
 }

package/dist/rendering/lod/LodController.d.ts

@@ -0,0 +1,45 @@
+import { default as Konva } from 'konva';
+import { Camera } from '../../camera/Camera';
+import { ViewportBounds } from '../../types/Settings';
+/** Visit every room (renderer-space x/y + env id) inside `bounds`. */
+export type RasterVisit = (bounds: ViewportBounds, fn: (x: number, y: number, envId: number) => void) => void;
+/**
+ * Owns the raster LOD underlay: an offscreen canvas painted with the room
+ * overview, shown through a single map-space `Konva.Image` on the (bottom)
+ * LOD layer. Because the image is positioned in map coordinates, the stage
+ * transform pans and zooms it like any other node — panning inside the
+ * painted region costs nothing, and a repaint is only needed when the camera
+ * escapes the region or the zoom changes (RAF-coalesced; the stretched image
+ * covers the frames in between).
+ *
+ * Note: the raster paints raw renderer-space coordinates — decorator styles
+ * with a `worldToScene` transform (e.g. isometric) are not applied to it.
+ */
+export declare class LodController {
+    private readonly layer;
+    private readonly camera;
+    private readonly colorCss;
+    private readonly roomSizeOf;
+    private readonly canvas;
+    private image?;
+    private visit;
+    private paintedRegion;
+    private paintedScale;
+    private repaintScheduled;
+    private destroyed;
+    private readonly packedCache;
+    constructor(layer: Konva.Layer, camera: Camera, colorCss: (envId: number) => string, roomSizeOf: () => number);
+    /** Activate the raster overview over `visit` and paint immediately. */
+    setSource(visit: RasterVisit): void;
+    /** Deactivate and hide the overview (vector mode). */
+    clear(): void;
+    /**
+     * Camera moved: repaint (coalesced) if the viewport left the painted
+     * region or the zoom changed; otherwise the stage transform already
+     * moved the image correctly and there is nothing to do.
+     */
+    onViewportChange(): void;
+    destroy(): void;
+    private colorOf;
+    private paint;
+}

package/dist/rendering/lod/RasterOverview.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure pixel painter for the raster LOD overview: each room becomes a small
+ * filled box in an `ImageData`, written directly as packed 32-bit pixels.
+ * Fast enough to repaint a million-room viewport in a few milliseconds —
+ * which is exactly the regime where Konva nodes are not an option.
+ */
+export interface RasterPaintParams {
+    /** Camera scale — screen = map * scale + offset. */
+    scale: number;
+    offsetX: number;
+    offsetY: number;
+    /** Packed little-endian RGBA (see {@link cssToPackedRGBA}) for an env id. */
+    colorOf: (envId: number) => number;
+    /**
+     * `settings.roomSize` at the time of painting — how large a room's own
+     * footprint is relative to the ~1-map-unit spacing between room centres.
+     * Only ever GROWS the box beyond the gap-free minimum (when > 1, rooms
+     * overlap their neighbours in vector mode too); values ≤ 1 leave the box
+     * at the gap-free minimum, since shrinking to match a smaller footprint
+     * would reintroduce visible gaps/erosion in the overview raster is meant
+     * to avoid. Omit (or 1) for the previous gap-free-only behaviour.
+     */
+    roomSize?: number;
+}
+/**
+ * Room box side in pixels for a given camera scale. Must always cover the
+ * inter-room spacing (= `scale` px, fractional): `round(scale)` under-covers
+ * at some zooms and the sub-pixel gaps read as a flickering grid, so
+ * `ceil(scale)+1` guarantees overlap → consistently solid regions. This is
+ * the FLOOR — `roomSize` above 1 (rooms configured larger than the spacing
+ * between them) grows the box further so the raster overview's density
+ * roughly matches how much vector mode's rooms overlap their neighbours;
+ * `roomSize` at or below 1 never shrinks the box below that floor.
+ */
+export declare function rasterBoxSize(scale: number, roomSize?: number): number;
+/**
+ * Paint every room `visit` yields into `img`. Pixels not covered by a room
+ * are left untouched (alpha 0 on a fresh ImageData), so the layer composites
+ * over the stage background — no background fill here.
+ *
+ * `visit` is typically `ViewportDataSource.forEachInBounds` curried with the
+ * painted region's map-space bounds.
+ */
+export declare function paintRasterOverview(img: ImageData, visit: (fn: (x: number, y: number, envId: number) => void) => void, p: RasterPaintParams): void;
+/** `#rgb` / `#rrggbb` / `rgb(a)(r,g,b[,a])` → packed little-endian RGBA uint32 (alpha 255). */
+export declare function cssToPackedRGBA(css: string): number;

package/dist/rendering/lod/lodDecision.d.ts

@@ -0,0 +1,45 @@
+export interface LodDecisionInput {
+    /** Total rooms on the whole (area, z) plane — NOT the viewport count. */
+    planeRoomCount: number;
+    /** Camera scale (screen pixels per map unit), `camera.getScale()`. */
+    scale: number;
+    stageWidth: number;
+    stageHeight: number;
+    /** Max rooms the vector (Konva) scene may hold, `settings.lodRoomBudget`. */
+    roomBudget: number;
+}
+/**
+ * Decide raster overview vs full vector detail.
+ *
+ * If the WHOLE plane fits the budget, always draw vectors — a small area
+ * never needs the raster overview. Genuinely large planes switch by ZOOM,
+ * not by in-view room count: count varies with local density and would flip
+ * modes mid-pan, while scale is constant during a pan. Bound: a fully-packed
+ * viewport holds ~stageW*stageH/scale² rooms (one per map unit), so vectors
+ * are safe once that worst case is within budget.
+ */
+export declare function shouldUseRaster(i: LodDecisionInput): boolean;
+export type LodMode = "vector" | "roomsOnly" | "raster";
+export interface LodModeInput extends Omit<LodDecisionInput, "roomBudget"> {
+    /** Max rooms the vector scene may hold before switching to raster. */
+    roomBudget: number;
+    /**
+     * Above this many rooms (and below `roomBudget`), exit lines are dropped
+     * but rooms still render as full vector shapes — a bridge tier between
+     * full vector and raster. Exit pairing + exit-shape building is typically
+     * the single largest share of a dense rebuild's cost (exit count often
+     * runs ~2x room count), so this tier buys back most of that cost while
+     * keeping real vector rooms, not raster pixels. Must be ≤ `roomBudget`;
+     * treated as unlimited (never hides exits) if omitted.
+     */
+    exitBudget?: number;
+}
+/**
+ * Decide the LOD tier: full vector (rooms + exits + hit-test-eligible),
+ * rooms-only vector (exits dropped, rooms still real vector shapes), or
+ * raster overview. Same pan-invariant zoom-based math as {@link shouldUseRaster}
+ * applied at two budgets — `exitBudget` always yields "roomsOnly" no later
+ * (i.e. at an equal or lower zoom-out) than `roomBudget` yields "raster",
+ * since exitBudget ≤ roomBudget.
+ */
+export declare function computeLodMode(i: LodModeInput): LodMode;

package/dist/rendering/lod/roomsOnlyArea.d.ts

@@ -0,0 +1,16 @@
+import { IArea } from '../../reader/Area';
+/**
+ * Wrap an {@link IArea} so `getLinkExits` reports none, while every other
+ * method delegates unchanged. Used for the "rooms only" LOD tier: a bridge
+ * between full vector (rooms + exit lines) and the raster overview — rooms
+ * still render as real vector shapes (env colour, border, shape), but exit
+ * pairing and exit-line shape building are skipped entirely, which is a large
+ * share of a dense rebuild's cost (pairing scales with exit count, typically
+ * ~2x room count in a well-connected area).
+ *
+ * A plain object literal rather than a class: `IArea` implementations are
+ * often plain objects or class instances whose methods live on the
+ * prototype, so `{...area}` would silently drop them — explicit delegation
+ * avoids that trap.
+ */
+export declare function withoutLinkExits(area: IArea): IArea;

package/dist/types/Settings.d.ts

@@ -41,6 +41,25 @@ export type ViewportBounds = {
     maxY: number;
 };
 export type PanEventDetail = ViewportBounds;
+/** Emitted after every LOD mode decision (see {@link Settings.lodEnabled}). */
+export type LodEventDetail = {
+    /**
+     * "vector": rooms + exit lines, full detail. "roomsOnly": exit lines
+     * dropped, rooms still real vector shapes (bridge tier — see
+     * {@link Settings.lodExitBudget}). "raster": pixel overview.
+     */
+    mode: "vector" | "roomsOnly" | "raster";
+    /** Total rooms on the displayed (area, z) plane. */
+    planeRoomCount: number;
+    /** Cheap upper bound of the rooms inside the applied viewport. */
+    visibleEstimate: number;
+    /**
+     * Whether clicks/hover currently resolve to a room. Always false in
+     * raster mode; false in vector/roomsOnly mode once the room count exceeds
+     * {@link Settings.lodHitTestBudget}.
+     */
+    hitTestActive: boolean;
+};
 export type RendererEventMap = {
     roomclick: RoomClickEventDetail;
     roomcontextmenu: RoomContextMenuEventDetail;
@@ -48,6 +67,7 @@ export type RendererEventMap = {
     mapclick: undefined;
     pan: PanEventDetail;
     zoom: ZoomChangeEventDetail;
+    lod: LodEventDetail;
 };
 /**
  * Style configuration for the player position marker.
@@ -238,6 +258,49 @@ export type Settings = {
     /** 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;
+    /**
+     * Level-of-detail for very dense planes: when the current plane holds more
+     * rooms than {@link lodRoomBudget} and the zoom is far enough out that a
+     * viewport could exceed that budget, the vector scene is replaced by a
+     * raster pixel overview (one filled box per room) painted on an underlay.
+     * Zooming in switches back to full vector detail. The mode is reported via
+     * the renderer's `lod` event. Interactive Konva backend only. Default: false
+     */
+    lodEnabled: boolean;
+    /**
+     * Max rooms the vector scene may hold before zoomed-out views switch to the
+     * raster overview; also the per-viewport budget the zoom threshold is
+     * derived from. Each rebuild at this density touches shape building, hit
+     * testing, and draw for the whole visible set, so lower this if rebuilds
+     * near the flip feel slow. Default: 16000
+     */
+    lodRoomBudget: number;
+    /**
+     * Above this many rooms in the current plane build (same unit as
+     * {@link lodRoomBudget}), the hit-test index is skipped instead of
+     * rebuilt — the scene still renders at full vector detail, but
+     * clicks/hover won't resolve to a room until you zoom in below this
+     * density. Rebuilding the hit index is a meaningful fraction of a large
+     * rebuild, and precise pointer interaction is rarely needed at very high
+     * densities anyway. Only takes effect while `lodEnabled` is true, and only
+     * below `lodRoomBudget` (above it the plane is raster and has no hit
+     * shapes at all). Default: 10000
+     */
+    lodHitTestBudget: number;
+    /**
+     * Above this many rooms in the current plane build (same unit as
+     * {@link lodRoomBudget}) and below `lodRoomBudget`, exit lines are
+     * dropped but rooms still render as full vector shapes — a bridge tier
+     * between full vector detail and the raster overview. Exit pairing and
+     * exit-line shape building are typically the single largest share of a
+     * dense rebuild's cost (exit count often runs ~2x room count in a
+     * well-connected area), so this buys back most of that cost while still
+     * showing real room shapes instead of raster pixels. Only takes effect
+     * while `lodEnabled` is true. Set above `lodRoomBudget` (or to `Infinity`)
+     * to disable this tier and jump straight from full vector to raster.
+     * Default: 12000
+     */
+    lodExitBudget: 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.5.1",
+  "version": "2.6.1",
   "license": "MIT",
   "repository": {
     "url": "https://github.com/Delwing/mudlet-map-renderer"
@@ -18,6 +18,10 @@
       "types": "./dist/binary/index.d.ts",
       "import": "./dist/binary.mjs"
     },
+    "./bigmap": {
+      "types": "./dist/bigmap/index.d.ts",
+      "import": "./dist/bigmap.mjs"
+    },
     "./offscreen": {
       "types": "./dist/rendering/offscreen/index.d.ts",
       "import": "./dist/offscreen.mjs"
@@ -39,14 +43,15 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:visual": "playwright test",
-    "test:visual:update": "playwright test --update-snapshots"
+    "test:visual:update": "playwright test --update-snapshots",
+    "demo:streaming": "vite --config vite.streaming.config.ts"
   },
   "dependencies": {
     "konva": "^10.2.4",
     "node-dijkstra": "^2.5.1"
   },
   "peerDependencies": {
-    "mudlet-map-binary-reader": ">=1.0.0"
+    "mudlet-map-binary-reader": ">=1.2.0"
   },
   "peerDependenciesMeta": {
     "mudlet-map-binary-reader": {
@@ -59,7 +64,7 @@
     "@types/node-dijkstra": "^2.5.6",
     "@types/three": "^0.184.1",
     "canvas": "^3.2.3",
-    "mudlet-map-binary-reader": "^1.0.1",
+    "mudlet-map-binary-reader": "^1.2.0",
     "three": "^0.184.0",
     "tslib": "^2.8.1",
     "tsx": "^4.21.0",