@mappedin/mappedin-js 6.5.0 → 6.7.0

package/lib/esm/index.d.ts

@@ -1,5 +1,5 @@
 import { Color as Color$1, CompositeExpression, DiffCommand, DiffOperations, Feature as Feature$2, FeatureFilter, FeatureState, FilterSpecification, Formatted, FormattedSection, GlobalProperties, ICanonicalTileID, IMercatorCoordinate, InterpolationType, LayerSpecification, LightSpecification, Padding, ProjectionSpecification, PromoteIdSpecification, PropertyValueSpecification, ResolvedImage, SkySpecification, SourceExpression, SourceSpecification, SpriteSpecification, StylePropertyExpression, StylePropertySpecification, StyleSpecification, TerrainSpecification, TransitionSpecification, VariableAnchorOffsetCollection } from '@maplibre/maplibre-gl-style-spec';
-import { AnnotationCollection, AnnotationSymbol, AreaCollection, AreaId, BaseTextAreaProperties, Category as MVFCategory, CategoryId, Connection as MVFConnection, Details, EnterpriseCategory as MVFEnterpriseCategory, EnterpriseCategory as MvfEnterpriseCategory, EnterpriseCategoryId as MVFEnterpriseCategoryId, EnterpriseLocation as MVFEnterpriseLocation, EnterpriseLocation as MvfEnterpriseLocation, EnterpriseLocationId as MVFEnterpriseLocationId, EnterpriseLocationInstance, EnterpriseTexture, EnterpriseVenue as MVFEnterpriseVenue, EntranceCollection, EntranceFeature, Facade as MVFFacade, Feature, Feature as MVFFeature, FeatureCollection, FloatingFloorTextProperties, FloorCollection, FloorId, FloorProperties as MVFFloor, FloorProperties as MvfFloor, FloorStack as MVFFloorStack, FloorStack as MvfFloorStack, FloorTextCommonProperties, Geometry, Hyperlink as MVFHyperlink, Image as MVFImage, Language, LineStringStyle, LineStringStyle as TMVFLineStringStyle, Location as MVFLocation, LocationId, LocationLink, LocationSocial, LocationState, MultiPolygon, NavigationFlagDeclarations, NodeCollection, NodeCollection as MVFNodeCollection, NodeId, ObstructionCollection, ObstructionFeature, ObstructionId, ObstructionProperties, OpeningHoursSpecification, OperationHours, ParsedMVF, ParsedMVF as TMVF, ParsedMVFLocalePack, Point, PointStyle, PointStyle as TMVFPointStyle, Polygon, PolygonStyle, PolygonStyle as TMVFPolygonStyle, SiblingGroup, SpaceCollection, SpaceFeature, SpaceId, SpaceProperties, Style as TMVFStyle, StyleCollection, StyleCollection as TMVFStyleCollection, TilesetStyle } from '@mappedin/mvf-v2';
+import { AnnotationCollection, AnnotationSymbol, AreaCollection, AreaId, BaseTextAreaProperties, Category as MVFCategory, CategoryId, Connection as MVFConnection, Details, EnterpriseCategory as MVFEnterpriseCategory, EnterpriseCategory as MvfEnterpriseCategory, EnterpriseCategoryId as MVFEnterpriseCategoryId, EnterpriseLocation as MVFEnterpriseLocation, EnterpriseLocation as MvfEnterpriseLocation, EnterpriseLocationId as MVFEnterpriseLocationId, EnterpriseLocationInstance, EnterpriseTexture, EnterpriseVenue as MVFEnterpriseVenue, EnterpriseVenueType, EntranceCollection, EntranceFeature, Facade as MVFFacade, Feature, Feature as MVFFeature, FeatureCollection, FloatingFloorTextProperties, FloorCollection, FloorId, FloorProperties as MVFFloor, FloorProperties as MvfFloor, FloorStack as MVFFloorStack, FloorStack as MvfFloorStack, FloorTextCommonProperties, Geometry, Hyperlink as MVFHyperlink, Image as MVFImage, Language, LineStringStyle, LineStringStyle as TMVFLineStringStyle, Location as MVFLocation, LocationId, LocationLink, LocationSocial, LocationState, MultiPolygon, NavigationFlagDeclarations, NodeCollection, NodeCollection as MVFNodeCollection, NodeId, ObstructionCollection, ObstructionFeature, ObstructionId, ObstructionProperties, OpeningHoursSpecification, OperationHours, ParsedMVF, ParsedMVF as TMVF, ParsedMVFLocalePack, Point, PointStyle, PointStyle as TMVFPointStyle, Polygon, PolygonStyle, PolygonStyle as TMVFPolygonStyle, SiblingGroup, SpaceCollection, SpaceFeature, SpaceId, SpaceProperties, Style as TMVFStyle, StyleCollection, StyleCollection as TMVFStyleCollection, TilesetStyle } from '@mappedin/mvf-v2';
 import { ParsedMVF, RawMVF } from '@mappedin/mvf-v2/no-validator';
 import { Group as TweenGroup, Tween } from '@tweenjs/tween.js';
 import { AmbientLight, BatchedMesh, BatchedMeshGeometryRange, BufferAttribute, BufferGeometry, Camera, Camera as ThreeCamera, Color, DirectionalLight, Group, Intersection, LineSegments, Mesh, MeshLambertMaterial, MeshLambertMaterialParameters, Object3D, Object3DEventMap, PerspectiveCamera, Plane, PlaneGeometry, Raycaster, Scene, ShaderMaterial, Texture, TubeGeometry, Vector2, Vector3, WebGLRenderer } from 'three';
@@ -1009,6 +1009,7 @@ declare class BatchedStandardMaterial extends MeshLambertMaterial {
 	removeSideTexture(batchId: number): void;
 	removeTopTexture(batchId: number): void;
 	dispose(): void;
+	clone(params?: MeshLambertMaterialParameters): this;
 }
 interface StandardSchemaV1<Input = unknown, Output = Input> {
 	/** The Standard Schema properties. */
@@ -4837,6 +4838,44 @@ type PathState = {
 	 * Only applies when smoothingTension > 0.
 	 */
 	smoothingCornerRadius: number;
+	/**
+	 * Whether the path should be rendered as a dashed line.
+	 */
+	dashed: boolean;
+	/**
+	 * Length of each dash segment as fraction of path (0-1).
+	 */
+	dashLength: number;
+	/**
+	 * Length of each gap between dashes as fraction of path (0-1).
+	 */
+	dashGap: number;
+	/**
+	 * When true, dashSize and gapSize are interpreted as multiples of path width.
+	 * When false, dashLength and dashGap are used as fractions of path length.
+	 */
+	dashRelativeToWidth: boolean;
+	/**
+	 * Length of each dash as a multiple of path width. Only used when dashRelativeToWidth is true.
+	 */
+	dashSize: number;
+	/**
+	 * Length of each gap as a multiple of path width. Only used when dashRelativeToWidth is true.
+	 */
+	gapSize: number;
+	/**
+	 * When true, dashMeters and gapMeters are used as absolute sizes in meters.
+	 * Takes precedence over dashRelativeToWidth.
+	 */
+	dashAbsolute: boolean;
+	/**
+	 * Length of each dash in meters. Only used when dashAbsolute is true.
+	 */
+	dashMeters: number;
+	/**
+	 * Length of each gap in meters. Only used when dashAbsolute is true.
+	 */
+	gapMeters: number;
 };
 type AddPathOptions = {
 	/**
@@ -4908,6 +4947,48 @@ type AddPathOptions = {
 	 * @default 0.0
 	 */
 	smoothingCornerRadius?: number;
+	/**
+	 * Length of each dash segment as fraction of path (0-1).
+	 * @default 0.1
+	 */
+	dashLength?: number;
+	/**
+	 * Length of each gap between dashes as fraction of path (0-1).
+	 * @default 0.1
+	 */
+	dashGap?: number;
+	/**
+	 * When true, dashSize and gapSize are interpreted as multiples of path width (deck.gl style).
+	 * When false (default), dashLength and dashGap are used as fractions of path length.
+	 * @default false
+	 */
+	dashRelativeToWidth?: boolean;
+	/**
+	 * Length of each dash as a multiple of path width. Only used when dashRelativeToWidth is true.
+	 * @default 3.0
+	 */
+	dashSize?: number;
+	/**
+	 * Length of each gap as a multiple of path width. Only used when dashRelativeToWidth is true.
+	 * @default 2.0
+	 */
+	gapSize?: number;
+	/**
+	 * When true, dashMeters and gapMeters are used as absolute sizes in meters.
+	 * Takes precedence over dashRelativeToWidth.
+	 * @default false
+	 */
+	dashAbsolute?: boolean;
+	/**
+	 * Length of each dash in meters. Only used when dashAbsolute is true.
+	 * @default 1.0
+	 */
+	dashMeters?: number;
+	/**
+	 * Length of each gap in meters. Only used when dashAbsolute is true.
+	 * @default 0.5
+	 */
+	gapMeters?: number;
 };
 declare class PathComponent {
 	#private;
@@ -4936,6 +5017,14 @@ declare class PathComponent {
 	dashed: boolean;
 	smoothingTension: number;
 	smoothingCornerRadius: number;
+	dashLength: number;
+	dashGap: number;
+	dashRelativeToWidth: boolean;
+	dashSize: number;
+	gapSize: number;
+	dashAbsolute: boolean;
+	dashMeters: number;
+	gapMeters: number;
 	/**
 	 * If the path is vertical it will be rebuilt whenever altitudeDirty = true. This will be set during the first render of the path.
 	 */
@@ -5129,8 +5218,11 @@ declare class OutlineComponent implements Outline {
 }
 declare class FocusableComponent {
 	readonly type: "focusable";
-	focusMesh?: Mesh;
 	dirty: boolean;
+	/**
+	 * Vertices of the geometry in world space
+	 */
+	vertices?: Vector3[];
 }
 type TextureStyle = {
 	texture?: SingleTexture;
@@ -5387,6 +5479,38 @@ interface PathUniforms {
 		type: "f";
 		value: number;
 	};
+	dashLength: {
+		type: "f";
+		value: number;
+	};
+	dashGap: {
+		type: "f";
+		value: number;
+	};
+	dashRelativeToWidth: {
+		type: "b";
+		value: boolean;
+	};
+	dashSize: {
+		type: "f";
+		value: number;
+	};
+	gapSize: {
+		type: "f";
+		value: number;
+	};
+	dashAbsolute: {
+		type: "b";
+		value: boolean;
+	};
+	dashMeters: {
+		type: "f";
+		value: number;
+	};
+	gapMeters: {
+		type: "f";
+		value: number;
+	};
 }
 declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EVENT_PAYLOAD> {
 	/**
@@ -5397,13 +5521,37 @@ declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EV
 	/**
 	 * @private
 	 * @internal
+	 * AbortController for managing lifecycle and cleanup
+	 */
+	private _abortController;
+	/**
+	 * @protected
+	 * @internal
+	 * Tracks all cleanup functions for subscriptions made via on()
 	 */
-	private _destroyed;
+	protected _cleanupFunctions: Array<() => void>;
+	/**
+	 * Returns the AbortSignal for this PubSub instance.
+	 * Use this signal with APIs that support cancellation (fetch, addEventListener, etc.)
+	 * When the PubSub is destroyed, the signal will be aborted and all listeners using it will be automatically removed.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Automatically cleaned up when PubSub is destroyed
+	 * pubsub.addEventListener(window, 'resize', handler, { signal: pubsub.signal });
+	 * ```
+	 */
+	get signal(): AbortSignal;
 	/**
 	 * @private
 	 * @internal
 	 */
 	publish<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, data?: EVENT_PAYLOAD[EVENT_NAME]): void;
+	/**
+	 * Subscribe a function to be called when the signal is aborted.
+	 * @param fn The function to call when the signal is aborted.
+	 */
+	onAbort<T extends (...args: any[]) => void>(fn: T): void;
 	/**
 	 * Subscribe a function to an event.
 	 *
@@ -5411,6 +5559,9 @@ declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EV
 	 * function.
 	 * @param fn A callback that gets called when the corresponding event is fired. The
 	 * callback will get passed an argument with a type that's one of event payloads.
+	 * @param options Optional options object. If a signal is provided, the subscription will be
+	 * automatically cleaned up when that signal is aborted.
+	 * @returns A cleanup function that unsubscribes the event listener when called.
 	 * @example
 	 * // Subscribe to the 'click' event
 	 * const handler = (event) => {
@@ -5422,7 +5573,9 @@ declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EV
 	 */
 	on<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
 		data: null;
-	} ? EVENT_PAYLOAD[EVENT_NAME]["data"] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
+	} ? EVENT_PAYLOAD[EVENT_NAME]["data"] : EVENT_PAYLOAD[EVENT_NAME]) => void, options?: {
+		signal?: AbortSignal;
+	}): () => void;
 	/**
 	 * Unsubscribe a function previously subscribed with {@link on}
 	 *
@@ -5443,6 +5596,7 @@ declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EV
 	/**
 	 * @private
 	 * @internal
+	 * Destroys the PubSub instance and automatically unsubscribes all listeners registered via on().
 	 */
 	destroy(): void;
 }
@@ -5702,13 +5856,37 @@ declare class PubSub$1<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof
 	/**
 	 * @private
 	 * @internal
+	 * AbortController for managing lifecycle and cleanup
 	 */
-	private _destroyed;
+	private _abortController;
+	/**
+	 * @protected
+	 * @internal
+	 * Tracks all cleanup functions for subscriptions made via on()
+	 */
+	protected _cleanupFunctions: Array<() => void>;
+	/**
+	 * Returns the AbortSignal for this PubSub instance.
+	 * Use this signal with APIs that support cancellation (fetch, addEventListener, etc.)
+	 * When the PubSub is destroyed, the signal will be aborted and all listeners using it will be automatically removed.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Automatically cleaned up when PubSub is destroyed
+	 * pubsub.addEventListener(window, 'resize', handler, { signal: pubsub.signal });
+	 * ```
+	 */
+	get signal(): AbortSignal;
 	/**
 	 * @private
 	 * @internal
 	 */
 	publish<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, data?: EVENT_PAYLOAD[EVENT_NAME]): void;
+	/**
+	 * Subscribe a function to be called when the signal is aborted.
+	 * @param fn The function to call when the signal is aborted.
+	 */
+	onAbort<T extends (...args: any[]) => void>(fn: T): void;
 	/**
 	 * Subscribe a function to an event.
 	 *
@@ -5716,6 +5894,9 @@ declare class PubSub$1<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof
 	 * function.
 	 * @param fn A callback that gets called when the corresponding event is fired. The
 	 * callback will get passed an argument with a type that's one of event payloads.
+	 * @param options Optional options object. If a signal is provided, the subscription will be
+	 * automatically cleaned up when that signal is aborted.
+	 * @returns A cleanup function that unsubscribes the event listener when called.
 	 * @example
 	 * // Subscribe to the 'click' event
 	 * const handler = (event) => {
@@ -5727,7 +5908,9 @@ declare class PubSub$1<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof
 	 */
 	on<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
 		data: null;
-	} ? EVENT_PAYLOAD[EVENT_NAME]["data"] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
+	} ? EVENT_PAYLOAD[EVENT_NAME]["data"] : EVENT_PAYLOAD[EVENT_NAME]) => void, options?: {
+		signal?: AbortSignal;
+	}): () => void;
 	/**
 	 * Unsubscribe a function previously subscribed with {@link on}
 	 *
@@ -5748,6 +5931,7 @@ declare class PubSub$1<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof
 	/**
 	 * @private
 	 * @internal
+	 * Destroys the PubSub instance and automatically unsubscribes all listeners registered via on().
 	 */
 	destroy(): void;
 }
@@ -15989,12 +16173,6 @@ declare class DOMVisibilitySystem {
 	constructor(state: RendererState, domTree: Entity2DHTMLDivElementContainer);
 	update(): void;
 }
-declare class TwoDProjectionSystem {
-	state: RendererState;
-	project: (projection: Vector2, position: Vector3) => void;
-	constructor(state: RendererState, project: (projection: Vector2, position: Vector3) => void);
-	update(): void;
-}
 declare enum PINVISIBILITY {
 	/** The pin is visible. */
 	ACTIVE = 1,
@@ -16697,7 +16875,6 @@ declare class CameraSystem extends PubSub<CameraEvents> {
 	private addMouseEventListeners;
 	private addMouseMoveEventListeners;
 	private removeMouseMoveEventListeners;
-	private removeEventListeners;
 	private removeMouseUpEventListeners;
 	private onContextMenu;
 	private onMouseUp;
@@ -16818,7 +16995,11 @@ export declare const ANIMATION_TWEENS: {
 	"ease-out": (amount: number) => number;
 	"ease-in-out": (amount: number) => number;
 };
-declare class Camera$2 {
+declare class Camera$2 extends PubSub$1<{
+	"padding-change": {
+		padding: InsetPadding;
+	};
+}> {
 	#private;
 	/**
 	 * @internal
@@ -17111,7 +17292,7 @@ declare class ImageSystem extends PubSub$1<{
 	private naturalBearing;
 	private imagePlacementOptions;
 	private cameraFrustum;
-	constructor(rendererState: RendererState, convertTo3DMapPosition: Core["convertTo3DMapPosition"], projectToScreen: (projectVector: Vector2, position: Vector3) => void, initialBearing?: number, naturalBearing?: number, imagePlacementOptions?: ImagePlacementOptions);
+	constructor(rendererState: RendererState, convertTo3DMapPosition: Core["convertTo3DMapPosition"], projectToScreen: Core["project"], initialBearing?: number, naturalBearing?: number, imagePlacementOptions?: ImagePlacementOptions);
 	private createImageMesh;
 	private getOrDownloadImage;
 	/**
@@ -17140,28 +17321,59 @@ declare class GeometryInFocusSystem extends PubSub$1<{
 	focusablesDirty: boolean;
 	private state;
 	private camera;
+	private projectToScreen;
+	private cameraFrustum;
+	private viewProjectionMatrix;
+	private tempScreenPos;
 	private debugEl;
-	private raycasters;
 	private collisions;
 	private focusableEntities;
-	private debugRaycasters;
-	constructor(state: RendererState, camera: PerspectiveCamera);
+	private debug;
+	private debugBBoxElements;
+	private debugVertexDots;
+	private viewfinder;
+	private screenBoundsMap;
+	private screenDiagonal;
+	constructor(state: RendererState, camera: PerspectiveCamera, projectToScreen: Core["project"]);
 	resize(): void;
 	/**
-	 * Build 5 raycasters, one for the center of the screen, and one for each corner of the screen.
-	 * the center one has the highest weight, and the corners have the lowest weight.
-	 * this allows us to detect focus closer to the center of the screen more easily.
+	 * Everything within this square is considered "in focus" and ranked based on proximity to center.
+	 */
+	private createViewfinder;
+	/**
+	 * Filters vertices to keep only those on the perimeter (convex hull)
+	 * @param vertices - Array of all vertices in world space
+	 * @returns Array of perimeter vertices in world space
 	 */
-	private buildRaycasters;
+	private simplifyVertices;
+	/**
+	 * Projects a 3D vertex from world space to screen coordinates
+	 * @param worldPosition - Position in world space
+	 */
+	private projectVertexToScreen;
+	/**
+	 * Computes screen-space bounding box and depth info from world-space vertices
+	 * Projects all vertices to screen space and finds the bounding box
+	 * Only culls if ALL vertices are outside the camera frustum
+	 */
+	private computeScreenSpaceBounds;
 	private updateFocusableEntities;
 	update: (cameraIsMoving?: boolean, cameraStoppedMovingTime?: number) => void;
 	updateRaf(): void;
-	raycast(): void;
-	showRaycasters(): void;
-	hideRaycasters(): void;
+	/**
+	 * Updates debug visualization for screen-space bounding boxes
+	 */
+	private updateDebugBBoxes;
+	/**
+	 * Updates debug visualization for vertex dots on screen
+	 */
+	private updateDebugVertexDots;
+	compute(): void;
+	showDebug(): void;
+	hideDebug(): void;
 	destroy(): void;
 }
-declare class OutdoorLayers {
+declare class OutdoorLayers extends PubSub<{}> {
 	#private;
 	idleQueue: IdleQueue;
 	hideLayersIntersectingPolygons(polygons: Feature$1<Polygon$1 | MultiPolygon$1, any>[], layers: string[]): void;
@@ -17371,6 +17583,12 @@ declare class Core extends PubSub<MapEvent> {
 	 * @internal
 	 */
 	constructor(container: HTMLElement, options?: RendererCoreOptions);
+	/**
+	 * Projects a position into screen space. If a Vector3 is provided, the z-coordinate will include the depth from the camera.
+	 * @param projectVector - The vector to project the position into
+	 * @param position - The position to project
+	 */
+	private project;
 	/**
 	 * Add a container that can hold other containers, geometry groups, markers, labels and paths. Use this to group entities together.
 	 */
@@ -17489,6 +17707,12 @@ declare class Core extends PubSub<MapEvent> {
 	getState<T extends EntityId<EntityState>>(geometryOrGeometryId: T): T extends EntityId<LabelState> ? LabelState : T extends EntityId<GeometryState> ? GeometryState : T extends EntityId<MarkerState> ? MarkerState : T extends EntityId<GeometryGroupState> ? GeometryGroupState : T extends EntityId<GroupContainerState> ? GroupContainerState : T extends EntityId<ModelState> ? ModelState : T extends EntityId<PathState> ? PathState : T extends EntityId<ShapeState> ? ShapeState : T extends EntityId<ImageState> ? ImageState : T extends EntityId<Text3DState> ? Text3DState : EntityState;
 	getState(geometryOrGeometryId?: Record<string | number, any> | string | number): EntityState;
 	getState<T extends EntityState>(geometryOrGeometryId: T["id"]): T extends LabelState ? LabelState : T extends GeometryState ? GeometryState : T extends MarkerState ? MarkerState : T extends GeometryGroupState ? GeometryGroupState : T extends GroupContainerState ? GroupContainerState : T extends ModelState ? ModelState : T extends PathState ? PathState : T extends ShapeState ? ShapeState : T extends ImageState ? ImageState : EntityState;
+	/**
+	 * Get rendered state for an entity (e.g., runtime rendering state that changes frequently)
+	 * @param entity The entity to get rendered state for
+	 * @returns Object with all available rendered state properties, or undefined if not found
+	 */
+	getRenderedState(entity: EntityId<LabelState> | string | number): LabelRenderedState | undefined;
 	/**
 	 * Set the state of the map view or any entity that was added, regardless of whether it is visible in the scene.
 	 */
@@ -17618,16 +17842,7 @@ declare class Core extends PubSub<MapEvent> {
 	/**
 	 * Remove a MapLibre event listener
 	 */
-	offMapLibreEvent(event: keyof MapEventType, handler: (...args: any[]) => void): void;
-	/**
-	 * Returns true if the renderer has been aborted.
-	 */
-	get aborted(): boolean;
-	/**
-	 * Register a handler once to be called when the renderer is aborted.
-	 * The handler will be removed after it is called.
-	 */
-	onAbort(handler: () => void): void;
+	offMapLibreEvent(event: LiteralUnion<keyof MapEventType, string>, handler: (...args: any[]) => void): void;
 	/**
 	 * @internal for testing
 	 */
@@ -17656,7 +17871,7 @@ declare class Core extends PubSub<MapEvent> {
 	 * };
 	 * map.on('click', handler);
 	 */
-	on: <EventName extends keyof MapEvent>(eventName: EventName, fn: (payload: MapEventPayload<EventName>) => void) => void;
+	on: PubSub<MapEvent>["on"];
 	/**
 	 * Unsubscribe a function previously subscribed with {@link on}
 	 *
@@ -17671,7 +17886,7 @@ declare class Core extends PubSub<MapEvent> {
 	 * };
 	 * map.off('click', handler);
 	 */
-	off: <EventName extends keyof MapEvent>(eventName: EventName, fn: (payload: MapEventPayload<EventName>) => void) => void;
+	off: PubSub<MapEvent>["off"];
 	/**
 	 * @hidden
 	 * Returns the current cursor decided by Mappedin. This is useful when integrating with other overlays to show the correct user interaction.
@@ -17841,6 +18056,7 @@ declare class LabelComponent {
 	get scaledPinSize(): number;
 	iconPadding: number;
 	get scaledIconPadding(): number;
+	get textVisible(): boolean;
 	dirty: boolean;
 	textDirty: boolean;
 	pinDirty: boolean;
@@ -18212,6 +18428,12 @@ type MapEvent = {
 	 * If outdoor view is enabled, this is fired when the style first loads or changes.
 	 */
 	"outdoor-style-loaded": undefined;
+	/**
+	 * Fired when outdoor style loading fails. The map will fall back to indoor-only rendering.
+	 */
+	"outdoor-style-error": {
+		error: unknown;
+	};
 	/**
 	 * Fired when the user starts interacting with the map.
 	 */
@@ -18242,9 +18464,6 @@ type MapEvent = {
 	resize: undefined;
 	"pan-bounds-change": PanBounds;
 };
-type MapEventPayload<EventName extends keyof MapEvent> = MapEvent[EventName] extends {
-	data: null;
-} ? MapEvent[EventName]["data"] : MapEvent[EventName];
 type All3DTypes = Geometry3DTypes | GeometryGroupObject3D | GroupContainerObject3D;
 type RendererState = {
 	/**
@@ -18342,6 +18561,12 @@ type ImagePlacementOptions = {
 	 */
 	minimumSizeRatio?: number;
 };
+type LabelRenderedState = {
+	/**
+	 * whether the text is visible
+	 */
+	textVisible: boolean;
+};
 declare const collisionRankingTierSchema: z.ZodUnion<readonly [
 	z.ZodEnum<{
 		low: "low";
@@ -19069,7 +19294,10 @@ declare class FloorObject implements MVFFloor {
 	facadesByStyleId: Map<string, string[]>;
 	get geoJSONBoundingBox(): BBox | undefined;
 	constructor(parentId: string, floor: MVFFloor, mapObject: GeojsonApiMapObject, multiFloorView: Required<TShow3DMapOptions["multiFloorView"]>, options: TShow3DMapOptions, mvf?: ParsedMVF, styleMap?: AggregatedStyleMap, mapDataInternal?: MapDataInternal);
-	load: () => this;
+	/**
+	 * @param focusable - Whether the floor is part of a building and should be focusable. This will be set on the geometry layer.
+	 */
+	load: (focusable?: boolean) => this;
 	/**
 	 * Add an occluder to the floor if it has a footprint.
 	 */
@@ -19080,6 +19308,7 @@ declare class FloorObject implements MVFFloor {
 	get hasFacadeGeometry(): boolean;
 	get visible(): boolean;
 	setVisible(visible: boolean): void;
+	setBatchedTextVisible(visible: boolean): void;
 }
 declare class FloorStackObject implements Omit<MVFFloorStack, "maps" | "floors" | "defaultFloor" | "footprint"> {
 	#private;
@@ -19095,7 +19324,6 @@ declare class FloorStackObject implements Omit<MVFFloorStack, "maps" | "floors"
 	metadata?: MVFFloorStack["metadata"];
 	containerId: string;
 	facade?: MVFFacade;
-	private renderer;
 	constructor(floorStack: MVFFloorStack, parentId: string, renderer: Core, facade?: MVFFacade);
 	get defaultFloor(): FloorObject;
 	/**
@@ -19967,6 +20195,22 @@ export declare class MapView {
 	 * ```
 	 */
 	getState<T extends MapElementsWithState>(target: T): TGetState<T>;
+	/**
+	 * Gets the rendered state of a map element.
+	 *
+	 * Retrieves runtime rendering state that changes frequently, such as text visibility for labels.
+	 *
+	 * @param target The map element to get the rendered state for.
+	 * @returns An object containing the requested rendered state keys, or undefined if not found.
+	 *
+	 * @example Get label text visibility
+	 * ```ts
+	 * const label = mapView.Labels.add(space, 'Hello');
+	 * const renderedState = mapView.__EXPERIMENTAL__getRenderedState(label);
+	 * console.log('Text visible:', renderedState?.textVisible);
+	 * ```
+	 */
+	__EXPERIMENTAL__getRenderedState<T extends MapElementWithRenderedState>(target: T): TGetRenderedState<T> | undefined;
 	/**
 	 * Sets the hover color for map elements.
 	 *
@@ -21592,6 +21836,9 @@ declare const floorStateSchemaPartial: z.ZodObject<{
 		type: z.ZodOptional<z.ZodDefault<z.ZodLiteral<"floor.areas">>>;
 		visible: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
 	}, z.core.$strip>>;
+	text3d: z.ZodOptional<z.ZodObject<{
+		visible: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+	}, z.core.$strip>>;
 	type: z.ZodOptional<z.ZodDefault<z.ZodLiteral<"floor">>>;
 	visible: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
 	altitude: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
@@ -21639,6 +21886,9 @@ declare const floorStateSchemaStrict: z.ZodObject<{
 		type: z.ZodDefault<z.ZodLiteral<"floor.areas">>;
 		visible: z.ZodDefault<z.ZodBoolean>;
 	}, z.core.$strict>;
+	text3d: z.ZodObject<{
+		visible: z.ZodDefault<z.ZodBoolean>;
+	}, z.core.$strict>;
 	type: z.ZodDefault<z.ZodLiteral<"floor">>;
 	visible: z.ZodDefault<z.ZodBoolean>;
 	altitude: z.ZodDefault<z.ZodNumber>;
@@ -21870,6 +22120,24 @@ declare const pathStateSchemaPartial: z.ZodObject<{
 	xrayOpacity: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 	__EXPERIMENTAL_SMOOTHING_TENSION: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 	__EXPERIMENTAL_SMOOTHING_CORNER_RADIUS: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+	dashed: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+	__EXPERIMENTAL_DASH_OPTIONS: z.ZodOptional<z.ZodOptional<z.ZodDiscriminatedUnion<[
+		z.ZodObject<{
+			__EXPERIMENTAL_DASH_MODE: z.ZodLiteral<"length-scaling">;
+			__EXPERIMENTAL_DASH_LENGTH: z.ZodDefault<z.ZodNumber>;
+			__EXPERIMENTAL_DASH_GAP: z.ZodDefault<z.ZodNumber>;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			__EXPERIMENTAL_DASH_MODE: z.ZodLiteral<"width-scaling">;
+			__EXPERIMENTAL_DASH_SIZE: z.ZodDefault<z.ZodNumber>;
+			__EXPERIMENTAL_GAP_SIZE: z.ZodDefault<z.ZodNumber>;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			__EXPERIMENTAL_DASH_MODE: z.ZodLiteral<"absolute">;
+			__EXPERIMENTAL_DASH_METERS: z.ZodDefault<z.ZodNumber>;
+			__EXPERIMENTAL_GAP_METERS: z.ZodDefault<z.ZodNumber>;
+		}, z.core.$strip>
+	], "__EXPERIMENTAL_DASH_MODE">>>;
 }, z.core.$strip>;
 declare const pathStateSchemaStrict: z.ZodObject<{
 	type: z.ZodDefault<z.ZodLiteral<"path">>;
@@ -21886,9 +22154,27 @@ declare const pathStateSchemaStrict: z.ZodObject<{
 	xrayOpacity: z.ZodDefault<z.ZodNumber>;
 	__EXPERIMENTAL_SMOOTHING_TENSION: z.ZodDefault<z.ZodNumber>;
 	__EXPERIMENTAL_SMOOTHING_CORNER_RADIUS: z.ZodDefault<z.ZodNumber>;
+	dashed: z.ZodDefault<z.ZodBoolean>;
+	__EXPERIMENTAL_DASH_OPTIONS: z.ZodOptional<z.ZodDiscriminatedUnion<[
+		z.ZodObject<{
+			__EXPERIMENTAL_DASH_MODE: z.ZodLiteral<"length-scaling">;
+			__EXPERIMENTAL_DASH_LENGTH: z.ZodDefault<z.ZodNumber>;
+			__EXPERIMENTAL_DASH_GAP: z.ZodDefault<z.ZodNumber>;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			__EXPERIMENTAL_DASH_MODE: z.ZodLiteral<"width-scaling">;
+			__EXPERIMENTAL_DASH_SIZE: z.ZodDefault<z.ZodNumber>;
+			__EXPERIMENTAL_GAP_SIZE: z.ZodDefault<z.ZodNumber>;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			__EXPERIMENTAL_DASH_MODE: z.ZodLiteral<"absolute">;
+			__EXPERIMENTAL_DASH_METERS: z.ZodDefault<z.ZodNumber>;
+			__EXPERIMENTAL_GAP_METERS: z.ZodDefault<z.ZodNumber>;
+		}, z.core.$strip>
+	], "__EXPERIMENTAL_DASH_MODE">>;
 }, z.core.$strict>;
 export type TPathState = z.infer<typeof pathStateSchemaStrict>;
-export type TPathUpdateState = z.infer<typeof pathStateSchemaPartial>;
+export type TPathUpdateState = z.input<typeof pathStateSchemaPartial>;
 declare const shapeStateSchemaPartial: z.ZodObject<{
 	type: z.ZodOptional<z.ZodDefault<z.ZodLiteral<"shape">>>;
 	visible: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -22229,6 +22515,7 @@ declare class GeoJsonApi extends PubSub$1<TNavigationEvents> {
 	get currentFloorStack(): FloorStack;
 	get currentFloor(): Floor;
 	getState<T extends MapElementsWithState | string>(target: T): TGetState<T>;
+	__EXPERIMENTAL__getRenderedState<T extends MapElementWithRenderedState>(target: T): TGetRenderedState<T> | undefined;
 	setHoverColor(c: string): void;
 	getHoverColor(): string | undefined;
 	/**
@@ -22447,17 +22734,55 @@ type DirectionProperties = {
 };
 type DirectionFeature = Feature$1<Point$1, DirectionProperties>;
 type DirectionsCollection = FeatureCollection$1<Point$1, DirectionProperties>;
-type SimplifyDirectionsOptions = {
+interface DoorGeometry {
+	geoJSON: {
+		geometry: {
+			coordinates: [
+				[
+					number,
+					number
+				],
+				[
+					number,
+					number
+				]
+			];
+		};
+	};
+}
+type BaseSimplifyOptions = {
 	/**
 	 * Enable or disable simplifying.
 	 */
 	enabled: boolean;
 	/**
 	 * The radius of the buffer around the path to consider when simplifying, in meters.
-	 * @default 0.7
+	 * @default 0.4
+	 */
+	radius?: number;
+};
+type GreedyLosOptions = BaseSimplifyOptions & {
+	__EXPERIMENTAL_METHOD?: "greedy-los";
+};
+type RdpOptions = BaseSimplifyOptions & {
+	__EXPERIMENTAL_METHOD: "rdp";
+	/**
+	 * Whether to include door-adjacent nodes (predecessor/successor of doors) in the must-include set.
+	 * When true, nodes immediately before and after doors are preserved during simplification.
+	 * @default true
 	 */
-	bufferRadius?: number;
+	mustIncludeDoorBufferNodes?: boolean;
 };
+type DpOptimalOptions = BaseSimplifyOptions & {
+	__EXPERIMENTAL_METHOD: "dp-optimal";
+	/**
+	 * Whether to include door buffer nodes in DP simplification.
+	 * When true, predecessor and successor nodes of doors are marked with preventSmoothing.
+	 * @default false
+	 */
+	includeDoorBufferNodes?: boolean;
+};
+type SimplifyDirectionsOptions = GreedyLosOptions | RdpOptions | DpOptimalOptions;
 type DirectionsZone = {
 	geometry: Feature$1<MultiPolygon$1 | Polygon$1>;
 	/**
@@ -22475,6 +22800,7 @@ declare class Navigator$1 {
 	graph: NavigationGraph;
 	private geometryEdgesByMapId;
 	private flagDeclarations;
+	private getDoorByNodeId;
 	private disabledNodeIds;
 	/**
 	 * Constructs a Navigator instance to manage pathfinding with optional obstructions and grouping features.
@@ -22483,13 +22809,15 @@ declare class Navigator$1 {
 	 * @param {ObstructionCollection} [obstructions] - Optional collection of obstructions that could block paths.
 	 * @param {SpaceCollection} [spaces] - Optional collection of spaces that could block paths.
 	 * @param {string} [groupBy] - Optional property name to group nodes and paths for differentiated processing.
+	 * @param {Function} getDoorByNodeId - Function to get door object by node ID.
 	 */
-	constructor({ nodes, geojsonCollection, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, }: {
+	constructor({ nodes, geojsonCollection, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, getDoorByNodeId, }: {
 		nodes: NodeCollection$1;
 		geojsonCollection?: ObstructionCollection | SpaceCollection;
 		groupBy?: string;
 		multiplicativeDistanceWeightScaling?: boolean;
 		flagDeclarations?: NavigationFlagDeclarations;
+		getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
 	});
 	private getDisabledNodeIds;
 	/**
@@ -22502,9 +22830,11 @@ declare class Navigator$1 {
 	 * @param {SimplifyDirectionsOptions} [simplify] - Options to simplify the pathfinding result.
 	 * @returns {DirectionsCollection} A collection of directional features representing the path.
 	 */
-	getDirections({ zones: directionsZones, originIds, destinationNodeIds, disabledConnectionNodeIds, simplify, multiplicativeDistanceWeightScaling, overrideEdgeWeights, }: {
+	getDirections({ zones: directionsZones, originIds, from, to, destinationNodeIds, disabledConnectionNodeIds, simplify, multiplicativeDistanceWeightScaling, overrideEdgeWeights, }: {
 		originIds: string[];
 		destinationNodeIds: string[];
+		from: NodeFeature[];
+		to: NodeFeature[];
 		zones?: DirectionsZone[];
 		disabledConnectionNodeIds?: string[];
 		simplify?: SimplifyDirectionsOptions;
@@ -22519,11 +22849,21 @@ declare class Navigator$1 {
 	 */
 	private generatePath;
 	/**
-	 * Simplifies a sequence of steps by reducing unnecessary nodes using a buffer radius to check for obstructions.
+	 * Simplifies a sequence of steps by reducing unnecessary nodes using line-of-sight checks.
+	 *
+	 * Method Selection:
+	 * - 'greedy-los': Greedy forward scan with line-of-sight validation. Fastest, O(n) time complexity. Good default choice.
+	 * - 'rdp': Uses Ramer-Douglas-Peucker preprocessing + line-of-sight validation + door buffer nodes.
+	 *   Better for paths with doors and complex geometry. Medium speed.
+	 * - 'dp-optimal': Dynamic Programming for globally optimal simplification. Slowest but highest quality, O(n²) complexity.
+	 *   Best when path quality is critical (e.g., indoor navigation with many turns).
+	 *
+	 * Performance: greedy-los < rdp < dp-optimal
+	 * Quality: greedy-los < rdp < dp-optimal
 	 *
 	 * @param {Edge[]} steps - The steps to simplify.
-	 * @param {number} bufferRadius - The buffer radius to use
-	 * for simplification.
+	 * @param {SimplifyDirectionsOptions} options - Simplification options.
+	 * @param {boolean} multiplicativeDistanceWeightScaling - Distance weight scaling option.
 	 * @returns {Edge[]} An array of simplified edges representing a more direct path.
 	 */
 	private simplifyAllSteps;
@@ -22566,6 +22906,8 @@ declare class Navigator$1 {
 	 * @returns {Edge[]} An array of simplified edges.
 	 */
 	private simplifySteps;
+	private simplifyStepsImprovedWithSimplifyBeforeLoSChecks;
+	private simplifyStepsWithDPMethod;
 	/**
 	 * Calculates the approximate distance between two geographic coordinates on Earth's surface.
 	 *
@@ -22653,13 +22995,14 @@ declare class DirectionsInternal {
 	/**
 	 * @hidden
 	 */
-	constructor({ nodes, geojsonCollection, connections, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, }: {
+	constructor({ nodes, geojsonCollection, connections, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, getDoorByNodeId, }: {
 		nodes: ParsedMVF["node.geojson"];
 		geojsonCollection: ParsedMVF["obstruction"] | ParsedMVF["space"];
 		connections: ParsedMVF["connection.json"];
 		groupBy?: string;
 		multiplicativeDistanceWeightScaling?: boolean;
 		flagDeclarations?: ParsedMVF["navigationFlags.json"];
+		getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
 	});
 	processTargets(fromNodesByTarget: Map<TNavigationTarget, string[]>, toNodesByTarget: Map<TNavigationTarget, string[]>, mapData: MapDataInternal): {
 		originIds: string[];
@@ -22668,10 +23011,7 @@ declare class DirectionsInternal {
 	};
 	getDirections: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
 		accessible: boolean;
-		smoothing: {
-			enabled: boolean;
-			radius: number;
-		};
+		smoothing: SimplifyDirectionsOptions;
 		zones: TDirectionZone[];
 		excludedConnections: Connection[];
 		connectionIdWeightMap: Record<string, number>;
@@ -22679,10 +23019,7 @@ declare class DirectionsInternal {
 	/** @deprecated use getDirections instead */
 	getDirectionsSync: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
 		accessible: boolean;
-		smoothing: {
-			enabled: boolean;
-			radius: number;
-		};
+		smoothing: SimplifyDirectionsOptions;
 		zones: TDirectionZone[];
 		excludedConnections: Connection[];
 		connectionIdWeightMap: Record<string, number>;
@@ -23337,6 +23674,52 @@ export type TDirectionZone = {
 	 */
 	floor?: Floor;
 };
+type TExperimentalDashOptions = {
+	/**
+	 * Length-scaling mode: dash/gap as fractions of path length (0-1)
+	 */
+	__EXPERIMENTAL_DASH_MODE: "length-scaling";
+	/**
+	 * Dash length as fraction of path (0-1).
+	 * @default 0.1
+	 */
+	__EXPERIMENTAL_DASH_LENGTH?: number;
+	/**
+	 * Gap length as fraction of path (0-1).
+	 * @default 0.1
+	 */
+	__EXPERIMENTAL_DASH_GAP?: number;
+} | {
+	/**
+	 * Width-scaling mode: dash/gap as multiples of path width (deck.gl style)
+	 */
+	__EXPERIMENTAL_DASH_MODE: "width-scaling";
+	/**
+	 * Dash size as multiple of path width.
+	 * @default 3.0
+	 */
+	__EXPERIMENTAL_DASH_SIZE?: number;
+	/**
+	 * Gap size as multiple of path width.
+	 * @default 2.0
+	 */
+	__EXPERIMENTAL_GAP_SIZE?: number;
+} | {
+	/**
+	 * Absolute mode: dash/gap in meters (deterministic regardless of path length)
+	 */
+	__EXPERIMENTAL_DASH_MODE: "absolute";
+	/**
+	 * Dash length in meters.
+	 * @default 1.0
+	 */
+	__EXPERIMENTAL_DASH_METERS?: number;
+	/**
+	 * Gap length in meters.
+	 * @default 0.5
+	 */
+	__EXPERIMENTAL_GAP_METERS?: number;
+};
 /**
  * Options for controlling the behavior of a {@link Path}.
  */
@@ -23459,6 +23842,13 @@ export type TAddPathOptions = {
 	 * @defaultValue 0.5
 	 */
 	__EXPERIMENTAL_SMOOTHING_CORNER_RADIUS?: number;
+	/**
+	 * @experimental
+	 * Dash configuration. When dashed=true, controls dash/gap sizing.
+	 * Uses discriminated union - mode determines which properties are valid.
+	 * @see TExperimentalDashOptions
+	 */
+	__EXPERIMENTAL_DASH_OPTIONS?: TExperimentalDashOptions;
 };
 /**
  * Defines the priority levels for collider collision handling, allowing customization of collider visibility in congested areas.
@@ -23500,31 +23890,128 @@ export type TGetDirectionsOptions = {
 	 */
 	accessible?: boolean;
 	/**
-	 * Enable or disable line-of-sight directions smoothing.
-	 * With this option enabled, the directions will be simplified to provide a more visually appealing path and shorter instructions.
+	 * Enable or disable path smoothing for directions.
+	 * When enabled, the path is simplified using line-of-sight checks to provide a more visually appealing route and shorter instructions.
 	 *
-	 * Can be a boolean to enable or disable smoothing, or an object with a radius property to specify the line of sight radius in metres.
+	 * Can be a boolean to enable or disable smoothing, or an object with configuration options.
+	 *
+	 * **Available methods:**
+	 * - `'greedy-los'` (default): Greedy forward scan with line-of-sight validation. Fastest, O(n) time complexity. Good default choice.
+	 * - `'rdp'`: Uses Ramer-Douglas-Peucker preprocessing + line-of-sight validation + door buffer nodes. Better for paths with doors and complex geometry. Medium speed.
+	 * - `'dp-optimal'`: Dynamic Programming for globally optimal simplification. Slowest but highest quality, O(n²) complexity. Best when path quality is critical.
 	 *
 	 * @default true for non-enterprise mode, false for enterprise mode
 	 *
 	 * @example
 	 * ```ts
-	 * // Enable smoothing with a radius of 3 metres
+	 * // Enable smoothing with default settings
 	 * mapView.getDirections(firstSpace, secondSpace, {
-	 * 	 smoothing: {
-	 *     radius: 3,
+	 *   smoothing: true
+	 * })
+	 *
+	 * // Enable smoothing with custom radius (in meters)
+	 * mapView.getDirections(firstSpace, secondSpace, {
+	 *   smoothing: {
+	 *     radius: 1.5,
 	 *   }
 	 * })
 	 *
-	 * // Explicitly enable smoothing in enterprise mode
+	 * // Use greedy line-of-sight method (default, explicit)
 	 * mapView.getDirections(firstSpace, secondSpace, {
-	 *   smoothing: true
+	 *   smoothing: {
+	 *     enabled: true,
+	 *     __EXPERIMENTAL_METHOD: 'greedy-los',
+	 *     radius: 0.4,
+	 *   }
+	 * })
+	 *
+	 * // Use RDP method (always uses line-of-sight)
+	 * mapView.getDirections(firstSpace, secondSpace, {
+	 *   smoothing: {
+	 *     enabled: true,
+	 *     __EXPERIMENTAL_METHOD: 'rdp',
+	 *     radius: 0.4,
+	 *   }
+	 * })
+	 *
+	 * // Use DP-optimal method with door buffer nodes
+	 * mapView.getDirections(firstSpace, secondSpace, {
+	 *   smoothing: {
+	 *     enabled: true,
+	 *     __EXPERIMENTAL_METHOD: 'dp-optimal',
+	 *     __EXPERIMENTAL_INCLUDE_DOOR_BUFFER_NODES: true,
+	 *     radius: 0.4,
+	 *   }
 	 * })
 	 * ```
 	 */
 	smoothing?: boolean | {
+		/**
+		 * Enable or disable path smoothing.
+		 * @default true for non-enterprise mode, false for enterprise mode
+		 */
 		enabled?: boolean;
-		radius: number;
+		/**
+		 * The radius of the buffer around the path to consider when simplifying, in meters.
+		 * @default 0.75
+		 */
+		radius?: number;
+		/**
+		 * @experimental
+		 * Path smoothing method using greedy line-of-sight algorithm.
+		 * Fastest method with O(n) time complexity. Good default choice.
+		 * @default 'greedy-los'
+		 */
+		__EXPERIMENTAL_METHOD?: "greedy-los";
+	} | {
+		/**
+		 * Enable or disable path smoothing.
+		 * @default true for non-enterprise mode, false for enterprise mode
+		 */
+		enabled?: boolean;
+		/**
+		 * The radius of the buffer around the path to consider when simplifying, in meters.
+		 * @default 0.75
+		 */
+		radius?: number;
+		/**
+		 * @experimental
+		 * Path smoothing method using Ramer-Douglas-Peucker preprocessing with line-of-sight validation.
+		 * Better for paths with doors and complex geometry. Medium speed.
+		 * Always uses line-of-sight validation (cannot be disabled).
+		 */
+		__EXPERIMENTAL_METHOD: "rdp";
+		/**
+		 * @experimental
+		 * Whether to include door-adjacent nodes (predecessor/successor of doors) in the must-include set.
+		 * When true (default), nodes immediately before and after doors are preserved during simplification.
+		 * @default true
+		 */
+		__EXPERIMENTAL_MUST_INCLUDE_DOOR_BUFFER_NODES?: boolean;
+	} | {
+		/**
+		 * Enable or disable path smoothing.
+		 * @default true for non-enterprise mode, false for enterprise mode
+		 */
+		enabled?: boolean;
+		/**
+		 * The radius of the buffer around the path to consider when simplifying, in meters.
+		 * @default 0.75
+		 */
+		radius?: number;
+		/**
+		 * @experimental
+		 * Path smoothing method using Dynamic Programming for globally optimal simplification.
+		 * Slowest but highest quality, O(n²) complexity. Best when path quality is critical.
+		 */
+		__EXPERIMENTAL_METHOD: "dp-optimal";
+		/**
+		 * @experimental
+		 * Whether to include 0.5m buffer nodes perpendicular to doors in DP simplification.
+		 * When true, predecessor and successor nodes of doors are marked with preventSmoothing.
+		 * @default false
+		 */
+		__EXPERIMENTAL_INCLUDE_DOOR_BUFFER_NODES?: boolean;
 	};
 	/**
 	 * Defines the special zones for navigation operations.
@@ -23780,6 +24267,9 @@ export type WithState<T> = T extends {
 export type TUpdateState<T extends MapElementsWithState | string> = T extends {
 	__type: infer U;
 } ? U extends keyof MapElementToUpdateState ? MapElementToUpdateState[U] : never : T extends string ? T extends keyof MapElementToUpdateState ? MapElementToUpdateState[T] : Record<string, any> : never;
+export type MapElementToGetRenderedState = {
+	[Label.__type]: ReadonlyDeep<LabelRenderedState>;
+};
 /**
  * The type for getting the state of map elements.
  * Returns the full state type for all element types.
@@ -23787,6 +24277,10 @@ export type TUpdateState<T extends MapElementsWithState | string> = T extends {
 export type TGetState<T extends MapElementsWithState | string> = T extends {
 	__type: infer U;
 } ? U extends keyof MapElementToGetState ? MapElementToGetState[U] : never : T extends string ? T extends keyof MapElementToGetState ? MapElementToGetState[T] : Record<string, any> : never;
+type MapElementWithRenderedState = WithState<Label>;
+type TGetRenderedState<T extends MapElementWithRenderedState | string> = T extends {
+	__type: infer U;
+} ? U extends keyof MapElementToGetRenderedState ? MapElementToGetRenderedState[U] : never : T extends string ? T extends keyof MapElementToGetRenderedState ? MapElementToGetRenderedState[T] : Record<string, any> : never;
 export type GlobalState = {
 	/**
 	 * The color of the background, in hex format(#000000).
@@ -24911,8 +25405,7 @@ export declare class Connection extends DetailedMapData<Feature<Point, SpaceProp
 	 * @internal
 	 */
 	constructor(data: MapDataInternal, options: {
-		mvfDataByFloorId: Record<string, FeatureCollection<Point, SpaceProperties>["features"][number]> | Record<string, Feature<Point, MVFConnection>>;
-		accessible?: boolean;
+		mvfData: MVFConnection;
 	});
 	/**
 	 * Whether the connection is accessible. For example elevators are accessible while stairs are not.
@@ -24948,10 +25441,6 @@ export declare class Connection extends DetailedMapData<Feature<Point, SpaceProp
 	 * @returns {Floor[]} An array of floors for the connection.
 	 */
 	get floors(): Floor[];
-	/**
-	 * Gets the location profiles ({@link LocationProfile}) associated with the connection.
-	 */
-	get locationProfiles(): LocationProfile[];
 	/** @internal */
 	get focusTarget(): Coordinate[];
 	/**
@@ -25611,8 +26100,6 @@ type MapDataRecords = {
 	locationProfilesByExternalId: Record<string, LocationProfile[]>;
 	objectEntranceNodeIdsByObstructionId: Record<string, string[]>;
 	obstructionIdByEntranceId: Record<string, string>;
-	connectionIdsByLatLon: Record<string, string[]>;
-	mvfConnectionIdsByLatLon: Record<string, string[]>;
 	locationProfilesByAttachedFeatureId: Record<string, LocationProfile[]>;
 	mvfSpacesById: Record<string, SpaceCollection["features"][number]>;
 	mvfNodesById: Record<string, NodeCollection["features"][number]>;
@@ -26048,6 +26535,10 @@ export declare class EnterpriseVenue extends BaseMetaData implements MVFEnterpri
 	 * The default map of the venue.
 	 */
 	get defaultMap(): string;
+	/**
+	 * The enterprise venue type.
+	 */
+	get enterpriseType(): EnterpriseVenueType | undefined;
 	/**
 	 * Serializes the EnterpriseVenue data to JSON.
 	 *
@@ -26245,7 +26736,6 @@ declare class MapDataInternal extends PubSub$1<{
 	mvfAnnotationsById: MapDataRecords["mvfAnnotationsById"];
 	mvfConnectionsById: MapDataRecords["mvfConnectionsById"];
 	mvfConnectionsByNodeId: MapDataRecords["mvfConnectionsByNodeId"];
-	mvfConnectionIdsByLatLon: MapDataRecords["mvfConnectionIdsByLatLon"];
 	mvfEntrancesById: MapDataRecords["mvfEntrancesById"];
 	mvfNodesById: MapDataRecords["mvfNodesById"];
 	mvfObstructionById: MapDataRecords["mvfObstructionById"];
@@ -26261,7 +26751,6 @@ declare class MapDataInternal extends PubSub$1<{
 	floorStacksByExternalId: MapDataRecords["floorStacksByExternalId"];
 	doorsByExternalId: MapDataRecords["doorsByExternalId"];
 	areasByExternalId: MapDataRecords["areasByExternalId"];
-	connectionSpaceIdsByLatLon: MapDataRecords["connectionIdsByLatLon"];
 	locationProfilesByAttachedFeatureId: MapDataRecords["locationProfilesByAttachedFeatureId"];
 	entranceNodeIdsBySpaceId?: MapDataRecords["entranceNodeIdsBySpaceId"];
 	locationsById: EnterpriseMapDataRecords["locationsById"];
@@ -26460,6 +26949,13 @@ declare class MapDataInternal extends PubSub$1<{
 	getDirections: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], opt?: TGetDirectionsOptions) => Promise<Directions | undefined>;
 	getDirectionsMultiDestination: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | (TNavigationTarget | TNavigationTarget[])[], opt?: TGetDirectionsOptions) => Promise<Directions[] | undefined>;
 	getDistance(from: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node$1 | EnterpriseLocation | Area, to: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node$1 | EnterpriseLocation | Area): number;
+	/**
+	 * Gets the door associated with a node.
+	 *
+	 * @param nodeId The ID of the node to check
+	 * @returns The door object if the node is associated with a door, undefined otherwise
+	 */
+	getDoorByNodeId: (nodeId: string) => Door | undefined;
 	transformImageRequest: (url: string) => Promise<{
 		url: string;
 	}>;