@atlas-viewer/atlas 3.1.0 → 3.2.0

package/dist/index.d.cts

@@ -2,11 +2,11 @@ import { Projection as Projection$1, Strand } from "@atlas-viewer/dna";
 import { ImageService as ImageService$1, ViewingDirection as ViewingDirection$1 } from "@iiif/presentation-3";
 import LRUCache from "lru-cache";
 import { HookOptions as HookOptions$1 } from "src/standalone";
+import { CanvasNormalized, ManifestNormalized } from "@iiif/presentation-3-normalized";
 import * as react0 from "react";
-import React, { ReactNode } from "react";
+import React, { CSSProperties, ReactNode } from "react";
 import { RectReadOnly } from "react-use-measure";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { CanvasNormalized, ManifestNormalized } from "@iiif/presentation-3-normalized";
 
 //#region src/events.d.ts
 declare const supportedEventAttributes: readonly ["onMouseDown", "onMouseEnter", "onMouseLeave", "onMouseMove", "onMouseOut", "onMouseOver", "onMouseUp", "onTouchCancel", "onTouchEnd", "onTouchMove", "onTouchStart", "onPointerDown", "onPointerMove", "onPointerUp", "onPointerCancel", "onPointerEnter", "onPointerLeave", "onPointerOver", "onPointerOut", "onScroll", "onWheel", "onClick", "onDragStart", "onDragEnd", "onDragEnter", "onDragExit", "onDrag", "onDragOver", "onContextMenu"];
@@ -76,18 +76,6 @@ type SupportedEvents = {
 type SupportedEventNames = 'mousedown' | 'mouseenter' | 'mouseleave' | 'mousemove' | 'mouseout' | 'mouseover' | 'mouseup' | 'touchcancel' | 'touchend' | 'touchmove' | 'touchstart' | 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel' | 'pointerenter' | 'pointerleave' | 'pointerover' | 'pointerout' | 'scroll' | 'wheel' | 'click' | 'dragstart' | 'dragend' | 'dragenter' | 'dragexit' | 'drag' | 'dragover' | 'contextmenu';
 type SupportedEventMap = { [Name in keyof SupportedEvents]: Array<SupportedEvents[Name]> };
 //#endregion
-//#region src/world-objects/paint.d.ts
-type Paintable = SpacialContent;
-type Paint = [Paintable, Strand, Strand | undefined];
-//#endregion
-//#region src/world-objects/abstract-object.d.ts
-interface AbstractObject {
-  id: string;
-  height: number;
-  width: number;
-  layers: Paintable[];
-}
-//#endregion
 //#region src/aom.d.ts
 interface AtlasObjectModel<Props, SupportedChildElements> {
   applyProps(props: Props): void;
@@ -97,59 +85,180 @@ interface AtlasObjectModel<Props, SupportedChildElements> {
   hideInstance(): void;
 }
 //#endregion
-//#region src/world-objects/render-pipeline.d.ts
-interface RenderPipeline {
-  getAllPointsAt(target: Strand, aggregate: Strand, scale: number): Paint[];
-  transform(op: Strand): void;
-}
-//#endregion
-//#region src/world-objects/abstract-world-object.d.ts
-/**
- * @deprecated
- */
-interface AbstractWorldObject extends AbstractObject, RenderPipeline {
+//#region src/modules/react-reconciler/devtools/types.d.ts
+type RuntimeDebugEvent = RuntimeFrameStartEvent | RuntimePaintEvent | RuntimeFrameEndEvent;
+type RuntimeFrameStartEvent = {
+  type: 'frame-start';
+  at: number;
+  runtimeId: string;
+  frame: number;
+  delta: number;
+  mode: string;
+  pendingUpdate: boolean;
+  rendererPendingUpdate: boolean;
+  target: [number, number, number, number];
+};
+type RuntimePaintEvent = {
+  type: 'paint';
+  at: number;
+  runtimeId: string;
+  frame: number;
+  layerIndex: number;
+  tileIndex: number;
   x: number;
   y: number;
-  scale: number;
-  time: WorldTime[];
-  points: Strand;
-  worldPoints: Strand;
-  atScale(factor: number): void;
-  translate(x: number, y: number): void;
-  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => Promise<void>>;
-}
-//#endregion
-//#region src/world-objects/image.d.ts
-declare function fromImage(image: {
-  src: string;
-  height: number;
   width: number;
-  target?: {
-    width: number;
-    height: number;
-  };
-}): WorldObject;
+  height: number;
+  paintId: string;
+  paintType: string;
+  ownerId?: string;
+  compositeId?: string;
+  imageUrl?: string;
+};
+type RuntimeFrameEndEvent = {
+  type: 'frame-end';
+  at: number;
+  runtimeId: string;
+  frame: number;
+  delta: number;
+  scaleFactor: number;
+  paintCount: number;
+  ready: boolean;
+  pendingUpdate: boolean;
+  worldWidth: number;
+  worldHeight: number;
+  target: [number, number, number, number];
+};
+type WorldDebugEvent = WorldTriggerDebugEvent | WorldPointerDebugEvent | WorldTouchDebugEvent;
+type WorldTriggerDebugEvent = {
+  type: 'trigger';
+  at: number;
+  event: string;
+  data?: unknown;
+};
+type WorldPointerDebugEvent = {
+  type: 'pointer';
+  at: number;
+  event: string;
+  x: number;
+  y: number;
+  targets: number;
+};
+type WorldTouchDebugEvent = {
+  type: 'touch';
+  at: number;
+  event: string;
+  touches: number;
+};
+type DevToolsTab = 'Overview' | 'World' | 'Inspector' | 'Events' | 'Images' | 'Actions';
+//#endregion
+//#region src/modules/shared/ready-events.d.ts
+type AtlasReadyResetReason = 'initial' | 'manual' | 'ready-reset-key-change' | 'runtime-reset';
+type AtlasReadyRenderer = 'canvas' | 'webgl' | 'static' | 'composite' | 'unknown';
+type AtlasReadyEvent = {
+  runtimeId: string;
+  cycle: number;
+  reason: AtlasReadyResetReason;
+  renderer: AtlasReadyRenderer;
+  timestamp: number;
+};
 //#endregion
-//#region src/world-objects/zone.d.ts
-interface ZoneInterface {
-  id: string;
-  config: Required<ZoneConfig>;
-  objects: WorldObject[];
-  points: Strand;
-  recalculateBounds(): void;
-  getPointsAt(target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
-}
-type ZoneConfig = {
-  margin?: number;
+//#region src/utility/easing-functions.d.ts
+type EasingFunction = (progress: number) => number;
+declare const bounceOut: EasingFunction;
+type EasingFunctionNames = 'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce';
+declare const easingFunctions: { [key in EasingFunctionNames]: EasingFunction };
+//#endregion
+//#region src/modules/transition-manager/transition-manager.d.ts
+type PendingTransition = {
+  from: Strand;
+  to: Strand;
+  elapsed_time: number;
+  total_time: number;
+  timingFunction: EasingFunction;
+  done: boolean;
+  constrain: boolean;
+  callback?: () => void;
 };
-declare class Zone implements ZoneInterface {
-  id: string;
-  config: Required<ZoneConfig>;
-  points: Strand;
-  objects: WorldObject[];
-  constructor(objects: [WorldObject, ...WorldObject[]], config?: ZoneConfig);
-  recalculateBounds(): void;
-  getPointsAt(target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
+declare class TransitionManager {
+  runtime: Runtime;
+  readonly pendingTransition: PendingTransition;
+  constructor(runtime: Runtime);
+  hasPending(): boolean;
+  getPendingTransition(): PendingTransition;
+  getPendingFrom(): Strand;
+  customTransition(func: (transition: PendingTransition) => void): void;
+  stopTransition(): void;
+  runTransition(target: Strand, delta: number): void;
+  lastZoomTo: {
+    factor: number;
+    options: any;
+  } | null;
+  resumeTransition(): void;
+  zoomTo(factor: number, options?: {
+    origin?: Position;
+    stream?: boolean;
+    minZoomFactor?: number;
+    transition?: {
+      duration?: number;
+      easing?: EasingFunction;
+    };
+  }): void;
+  isConstraining: boolean;
+  constrainBounds({
+    transition,
+    panPadding
+  }?: {
+    panPadding?: number;
+    transition?: {
+      duration?: number;
+      easing?: EasingFunction;
+    };
+  }): void;
+  constrainTarget(target: Strand, {
+    origin,
+    transition,
+    panPadding
+  }?: {
+    origin?: Position;
+    panPadding?: number;
+    transition?: {
+      duration?: number;
+      easing?: EasingFunction;
+    };
+  }): void;
+  applyTransition(target: Strand, transition?: {
+    duration?: number;
+    easing?: EasingFunction;
+    constrain?: boolean;
+  }, defaults?: {
+    duration: number;
+    easing: EasingFunction;
+    constrain?: boolean;
+    callback?: () => void;
+  }, {
+    stream
+  }?: {
+    stream?: boolean;
+  }): void;
+  lastGoToRegion: null | {
+    target: any;
+    options: any;
+  };
+  goToRegion(target: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    padding?: number;
+  }, {
+    transition
+  }?: {
+    transition?: {
+      duration?: number;
+      easing?: EasingFunction;
+    };
+  }): void;
 }
 //#endregion
 //#region src/spacial-content/abstract-content.d.ts
@@ -171,8 +280,16 @@ type RenderOptions = {
   minSize: number;
   maxImageSize: number;
   quality: number;
+  useDevicePixelRatio: boolean;
+  layerPolicy: 'fallback-only' | 'always-blend' | 'active-only';
+  loadingBias: 'balanced' | 'speed' | 'data';
+  prefetchRadius?: number;
+  fadeInMs: number;
+  fadeFallbackTiles: boolean;
+  fadeOnLayerChange: boolean;
+  clipToBounds: boolean;
 };
-type CompositeResourceProps = RenderOptions;
+type CompositeResourceProps = Partial<RenderOptions>;
 declare class CompositeResource extends AbstractContent implements SpacialContent, AtlasObjectModel<CompositeResourceProps, SpacialContent> {
   readonly id: string;
   readonly display: DisplayData;
@@ -183,7 +300,10 @@ declare class CompositeResource extends AbstractContent implements SpacialConten
   aggregateBuffer: Strand;
   lazyLoader?: () => Promise<SpacialContent[]>;
   isFullyLoaded: boolean;
+  isLoadingFullResource: boolean;
   maxScaleFactor: number;
+  private layerSelection;
+  private layerSelectionFrame;
   renderOptions: RenderOptions;
   constructor(data: {
     id: string;
@@ -191,7 +311,7 @@ declare class CompositeResource extends AbstractContent implements SpacialConten
     height: number;
     images: SpacialContent[];
     loadFullImages?: () => Promise<SpacialContent[]>;
-    renderOptions?: RenderOptions;
+    renderOptions?: CompositeResourceProps;
   });
   applyProps(props: CompositeResourceProps): void;
   appendChild(item: SpacialContent): void;
@@ -199,6 +319,7 @@ declare class CompositeResource extends AbstractContent implements SpacialConten
   insertBefore(item: SpacialContent, before: SpacialContent): void;
   hideInstance(): void;
   addImages(images: SpacialContent[]): void;
+  private getImageDedupeKey;
   sortByScales(): void;
   _scheduleSortByScales: boolean;
   _sortByScales: () => void;
@@ -206,56 +327,339 @@ declare class CompositeResource extends AbstractContent implements SpacialConten
   fallback: (() => Promise<void>)[];
   getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => Promise<void>>;
   getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
+  isImageActive(image: SpacialContent): boolean;
+  getImageActivatedAt(image: SpacialContent): number | undefined;
+  private getNow;
 }
 //#endregion
-//#region src/objects/base-object.d.ts
-declare abstract class BaseObject<Props = any, SupportedChildElements = never> implements AtlasObjectModel<Props, SupportedChildElements> {
-  __id: string;
-  __revision: number;
-  __host: any;
-  __onCreate?: () => void;
-  __parent?: CompositeResource;
-  __owner: {
-    value: WorldObject | undefined;
+//#region src/spacial-content/image-texture.d.ts
+type UpdateTextureFunction = () => {
+  source: TexImageSource | undefined;
+  hash: any;
+};
+type ImageTextureProps = {
+  id: string;
+  display?: {
+    width: number;
+    height: number;
   };
-  __state: any;
-  eventHandlers: SupportedEventMap;
-  scale: number;
-  layers: SupportedChildElements[];
-  time: WorldTime[];
-  _crop?: Strand;
-  cropData?: {
+  target: {
+    width: number;
+    height: number;
+  };
+  scale?: number;
+  getTexture: UpdateTextureFunction;
+};
+declare class ImageTexture extends BaseObject implements SpacialContent {
+  readonly type = "spacial-content";
+  id: string;
+  uri: string;
+  display: DisplayData;
+  points: Strand;
+  getTexture: UpdateTextureFunction;
+  constructor(data?: {
+    id?: string;
+    uri: string;
+    width: number;
+    height: number;
+    scale?: number;
+  });
+  applyProps(props: ImageTextureProps): void;
+  getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
+}
+//#endregion
+//#region src/modules/maps/types.d.ts
+type MapBounds = {
+  west: number;
+  south: number;
+  east: number;
+  north: number;
+};
+type LngLatPoint = {
+  lng: number;
+  lat: number;
+};
+type WorldPoint = {
+  x: number;
+  y: number;
+};
+type WorldRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type MapProjection = {
+  lngLatToWorld: (lng: number, lat: number) => WorldPoint;
+  worldToLngLat: (x: number, y: number) => LngLatPoint;
+  lngLatBoundsToWorldRect: (bounds: MapBounds) => WorldRect;
+  worldRectToLngLatBounds: (rect: WorldRect) => MapBounds;
+  projectRing: (ring: Array<[number, number]>) => Array<[number, number]>;
+};
+type MapTileUrlContext = {
+  z: number;
+  x: number;
+  y: number;
+  s?: string;
+  subdomains?: string[];
+  tileSize?: number;
+};
+type MapTileSource = string | ((ctx: MapTileUrlContext) => string);
+type GeoJSONPoint = {
+  type: 'Point';
+  coordinates: [number, number];
+};
+type GeoJSONMultiPoint = {
+  type: 'MultiPoint';
+  coordinates: Array<[number, number]>;
+};
+type GeoJSONLineString = {
+  type: 'LineString';
+  coordinates: Array<[number, number]>;
+};
+type GeoJSONMultiLineString = {
+  type: 'MultiLineString';
+  coordinates: Array<Array<[number, number]>>;
+};
+type GeoJSONPolygon = {
+  type: 'Polygon';
+  coordinates: Array<Array<[number, number]>>;
+};
+type GeoJSONMultiPolygon = {
+  type: 'MultiPolygon';
+  coordinates: Array<Array<Array<[number, number]>>>;
+};
+type MapGeoJSONGeometry = GeoJSONPoint | GeoJSONMultiPoint | GeoJSONLineString | GeoJSONMultiLineString | GeoJSONPolygon | GeoJSONMultiPolygon;
+type MapGeoJSONFeature<TGeometry extends MapGeoJSONGeometry | null = MapGeoJSONGeometry, TProperties = Record<string, unknown> | null> = {
+  type: 'Feature';
+  id?: string | number;
+  geometry: TGeometry;
+  properties?: TProperties;
+};
+type MapGeoJSONFeatureCollection<TGeometry extends MapGeoJSONGeometry | null = MapGeoJSONGeometry, TProperties = Record<string, unknown> | null> = {
+  type: 'FeatureCollection';
+  features: Array<MapGeoJSONFeature<TGeometry, TProperties>>;
+};
+type MapGeoJSONInput = MapGeoJSONGeometry | MapGeoJSONFeature | MapGeoJSONFeatureCollection;
+//#endregion
+//#region src/spacial-content/tiled-image.d.ts
+declare class TiledImage extends BaseObject implements SpacialContent {
+  readonly id: string;
+  readonly type = "spacial-content";
+  readonly display: DisplayData;
+  tileWidth: number;
+  tileHeight: number;
+  columns: number;
+  rows: number;
+  style: {
+    opacity: number;
+  };
+  points: Strand;
+  service?: ImageService$1;
+  format: string;
+  crop2?: Strand;
+  version3?: boolean;
+  tileUrl: string;
+  constructor(data: {
+    url: string;
+    scaleFactor: number;
+    points: Strand;
+    displayPoints?: Strand;
+    tileWidth: number;
+    tileHeight: number;
+    width: number;
+    height: number;
+    columns: number;
+    rows: number;
+    format?: string;
+    id?: string;
+    version3?: boolean;
+  });
+  applyProps(props: any): void;
+  static fromTile(url: string, canvas: {
+    width: number;
+    height: number;
+  }, tile: {
+    width: number;
+    height?: number;
+  }, scaleFactor: number, service?: ImageService$1, format?: string, useFloorCalc?: boolean, version3?: boolean): TiledImage;
+  getImageUrl(index: number): string;
+  getAllPointsAt(target: Strand, aggregate?: Strand, scaleFactor?: number): Paint[];
+  transform(op: Strand): void;
+  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => Promise<void>>;
+}
+//#endregion
+//#region src/spacial-content/map-tiled-image.d.ts
+type MapTileCoordinate = {
+  x: number;
+  y: number;
+  z: number;
+};
+type MapTileGrid = {
+  points: Strand;
+  tiles: MapTileCoordinate[];
+  columns: number;
+  rows: number;
+  count: number;
+  minTileX: number;
+  maxTileX: number;
+  minTileY: number;
+  maxTileY: number;
+};
+type MapTileGridCoverage = Omit<MapTileGrid, 'points' | 'tiles'> & {
+  westTile: number;
+  eastTile: number;
+  northTile: number;
+  southTile: number;
+  tileSpanX: number;
+  tileSpanY: number;
+};
+type MapTiledImageProps = {
+  id?: string;
+  bounds: MapBounds;
+  worldWidth: number;
+  worldHeight: number;
+  zoom: number;
+  tileSize?: number;
+  scaleFactor?: number;
+  tileSource?: MapTileSource;
+  tileUrlTemplate?: string;
+  subdomains?: string[];
+};
+declare function estimateFiniteTileGridCoverage(config: {
+  bounds: MapBounds;
+  zoom: number;
+}): MapTileGridCoverage;
+declare function createFiniteTileGrid(config: {
+  bounds: MapBounds;
+  zoom: number;
+  worldWidth: number;
+  worldHeight: number;
+  maxTiles?: number;
+}): MapTileGrid;
+declare class MapTiledImage extends TiledImage {
+  readonly zoom: number;
+  readonly bounds: MapBounds;
+  readonly worldWidth: number;
+  readonly worldHeight: number;
+  readonly tileSize: number;
+  readonly tileSource: MapTileSource;
+  readonly subdomains: string[];
+  readonly tileCoordinates: MapTileCoordinate[];
+  readonly minTileX: number;
+  readonly maxTileX: number;
+  readonly minTileY: number;
+  readonly maxTileY: number;
+  constructor(props: MapTiledImageProps);
+  getImageUrl(index: number): string;
+}
+//#endregion
+//#region src/spacial-content/single-image.d.ts
+type SingleImageProps = {
+  uri: string;
+  id?: string;
+  display?: {
+    width: number;
+    height: number;
+    rotation?: number;
+  };
+  target: {
+    width: number;
+    height: number;
+    x?: number;
+    y?: number;
+  };
+  crop?: {
     x: number;
     y: number;
     width: number;
     height: number;
-  };
-  get crop(): Strand | undefined;
-  set crop(crop: Strand | undefined);
+  };
+  scale?: number;
+  priority?: boolean;
+  style?: any;
+};
+declare class SingleImage extends BaseObject implements SpacialContent {
+  readonly type = "spacial-content";
+  /**
+   * An identifier for this image. Will default to the image URI.
+   */
+  id: string;
+  /**
+   * The URI of the image being painted.
+   */
+  uri: string;
+  /**
+   * The real height and width of the image. For example a 1000x1000 painted at 100x100 would contain
+   * the display data for 1000x1000 and `this.points` would scale that down to 100x100. This is used to
+   * calculate the scale.
+   */
+  display: DisplayData;
+  /**
+   * Points are relative to the world object.
+   * Does not change when viewport moves
+   * Does not change if world object position changes.
+   * */
+  points: Strand;
+  /**
+   * Displayed as priority
+   */
+  priority?: boolean;
+  /**
+   * Some simple styling options
+   */
+  style: {
+    opacity: number;
+  };
+  constructor(data?: {
+    id?: string;
+    uri: string;
+    width: number;
+    height: number;
+    scale?: number;
+    x?: number;
+    y?: number;
+    rotation?: number;
+  });
+  applyProps(props: SingleImageProps): void;
+  getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
+  static fromSvg(svg: string, target: SpacialSize, display?: SpacialSize, id?: string): SingleImage;
+  static fromImage(uri: string, target: SpacialSize, display?: SpacialSize, id?: string): SingleImage;
+  getImageUrl(): string;
+}
+//#endregion
+//#region src/world-objects/paint.d.ts
+type Paintable = SpacialContent;
+type Paint = [Paintable, Strand, Strand | undefined];
+//#endregion
+//#region src/world-objects/abstract-object.d.ts
+interface AbstractObject {
   id: string;
-  abstract points: Strand;
-  getObjectsAt(target: Strand): SupportedChildElements[] | Array<[SupportedChildElements, any[]]>;
+  height: number;
+  width: number;
+  layers: Paintable[];
+}
+//#endregion
+//#region src/world-objects/render-pipeline.d.ts
+interface RenderPipeline {
   getAllPointsAt(target: Strand, aggregate: Strand, scale: number): Paint[];
-  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => void | Promise<void>>;
-  protected constructor();
-  addEventListener: <Name$1 extends SupportedEventNames>(name: Name$1, cb: (e: any) => void, options?: {
-    capture: boolean;
-    passive: boolean;
-  }) => void;
-  removeEventListener: <Name$1 extends SupportedEventNames>(name: Name$1, cb: (e: any) => void) => void;
-  dispatchEvent<Name$1 extends keyof SupportedEvents>(name: Name$1, e: any): boolean;
-  get x(): number;
-  get y(): number;
-  get width(): number;
-  get height(): number;
-  translate(x: number, y: number): void;
-  atScale(factor: number): void;
   transform(op: Strand): void;
-  applyProps(props: Props): void;
-  appendChild(item: SupportedChildElements): void;
-  removeChild(item: SupportedChildElements): void;
-  insertBefore(item: SupportedChildElements, before: SupportedChildElements): void;
-  hideInstance(): void;
+}
+//#endregion
+//#region src/world-objects/abstract-world-object.d.ts
+/**
+ * @deprecated
+ */
+interface AbstractWorldObject extends AbstractObject, RenderPipeline {
+  x: number;
+  y: number;
+  scale: number;
+  time: WorldTime[];
+  points: Strand;
+  worldPoints: Strand;
+  atScale(factor: number): void;
+  translate(x: number, y: number): void;
+  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => Promise<void>>;
 }
 //#endregion
 //#region src/world-objects/world-object.d.ts
@@ -309,6 +713,91 @@ declare class WorldObject extends BaseObject<WorldObjectProps, Paintable> {
   getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => void | Promise<void>>;
 }
 //#endregion
+//#region src/world-objects/image.d.ts
+declare function fromImage(image: {
+  src: string;
+  height: number;
+  width: number;
+  target?: {
+    width: number;
+    height: number;
+  };
+}): WorldObject;
+//#endregion
+//#region src/world-objects/zone.d.ts
+interface ZoneInterface {
+  id: string;
+  config: ZoneResolvedConfig;
+  objects: WorldObject[];
+  points: Strand;
+  recalculateBounds(): void;
+  getPointsAt(target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
+}
+type ZoneConfig = {
+  margin?: number;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+};
+type ZoneResolvedConfig = {
+  margin: number;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+};
+declare class Zone implements ZoneInterface {
+  id: string;
+  config: ZoneResolvedConfig;
+  points: Strand;
+  objects: WorldObject[];
+  constructor(objects: [WorldObject, ...WorldObject[]], config?: ZoneConfig);
+  constructor(config: ZoneConfig & {
+    id: string;
+    objects?: WorldObject[];
+  });
+  applyProps(config: ZoneConfig & {
+    id?: string;
+  }): void;
+  addObject(object: WorldObject): void;
+  removeObject(object: WorldObject): void;
+  recalculateBounds(): void;
+  getPointsAt(target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
+}
+//#endregion
+//#region src/spacial-content/spacial-content.d.ts
+interface SpacialContent {
+  readonly id: string;
+  readonly type: 'spacial-content';
+  readonly display: DisplayData;
+  __id?: string;
+  __parent?: CompositeResource;
+  __owner: {
+    value: WorldObject | undefined;
+  };
+  __host?: any;
+  priority?: boolean;
+  points: Strand;
+  crop?: Strand;
+  cropData?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  style?: {
+    opacity: number;
+  };
+  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => void | Promise<void>>;
+  getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
+  transform(op: Strand): void;
+  loadFullResource?(): Promise<void>;
+  dispatchEvent(event: string, e: any): void;
+  getImageUrl?: (index: number) => string;
+  getTexture?: UpdateTextureFunction;
+}
+//#endregion
 //#region src/world.d.ts
 type WorldTarget = {
   x: number;
@@ -339,6 +828,13 @@ declare class World extends BaseObject<WorldProps, WorldObject> {
   needsRecalculate: boolean;
   emptyPaintables: never[];
   renderOrder: number[];
+  debugSubscribers: Set<(event: WorldDebugEvent) => void>;
+  zoneVisibilityFadeDurationMs: number;
+  zoneOutsideOpacity: number;
+  zoneVisibilityFade?: {
+    zoneId: string;
+    startedAt: number;
+  };
   get x(): number;
   get y(): number;
   get width(): number;
@@ -371,6 +867,9 @@ declare class World extends BaseObject<WorldProps, WorldObject> {
   hideInstance(): void;
   asWorldObject(): WorldObject | null;
   addZone(zone: ZoneInterface): void;
+  removeZone(zone: ZoneInterface): void;
+  getZoneById(id: string): ZoneInterface | undefined;
+  hasZone(id: string): boolean;
   selectZone(id: string | number): void;
   deselectZone(): void;
   getActiveZone(): ZoneInterface | undefined;
@@ -390,7 +889,9 @@ declare class World extends BaseObject<WorldProps, WorldObject> {
   getPointsFromViewer(target: Viewer, aggregate?: Strand): Paint[];
   addLayoutSubscriber(subscription: (type: string, data: unknown) => void): () => void;
   getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => void | Promise<void>>;
-  getObjectsAt(target: Strand, all?: boolean): Array<[WorldObject, Paintable[]]>;
+  private isZoneOutsideVisibilityFading;
+  private getZoneOutsideVisibility;
+  getObjectsAt(target: Strand, all?: boolean, includeZoneFade?: boolean): Array<[WorldObject, Paintable[]]>;
   getPointsAt(target: Strand, aggregate?: Strand, scaleFactor?: number): Paint[];
   _alreadyFlushed: any;
   flushSubscriptions(): void;
@@ -428,122 +929,41 @@ declare class World extends BaseObject<WorldProps, WorldObject> {
   }): void;
   zoomOut(point?: {
     x: number;
-    y: number;
-  }): void;
-  constraintBounds(immediate?: boolean): void;
-}
-//#endregion
-//#region src/renderer/renderer.d.ts
-interface Renderer {
-  beforeFrame(world: World, delta: number, target: Strand, options: HookOptions): void;
-  paint(paint: SpacialContent, index: number, x: number, y: number, width: number, height: number): void;
-  afterFrame(world: World, delta: number, target: Strand, options: HookOptions): void;
-  getScale(width: number, height: number, dpi?: boolean): number;
-  prepareLayer(paint: SpacialContent, point: Strand): void;
-  finishLayer(paint: SpacialContent, point: Strand): void;
-  afterPaintLayer(paint: SpacialContent, transform?: Strand): void;
-  pendingUpdate(): boolean;
-  getPointsAt(world: World, target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
-  getViewportBounds(world: World, target: Strand, padding: number): PositionPair | null;
-  isReady(): boolean;
-  resize(): void;
-  resize(width?: number, height?: number): void;
-  triggerResize?: () => void;
-  reset(): void;
-  getRendererScreenPosition(): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-  } | undefined;
-}
-//#endregion
-//#region src/utility/easing-functions.d.ts
-type EasingFunction = (progress: number) => number;
-declare const bounceOut: EasingFunction;
-type EasingFunctionNames = 'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce';
-declare const easingFunctions: { [key in EasingFunctionNames]: EasingFunction };
-//#endregion
-//#region src/modules/transition-manager/transition-manager.d.ts
-type PendingTransition = {
-  from: Strand;
-  to: Strand;
-  elapsed_time: number;
-  total_time: number;
-  timingFunction: EasingFunction;
-  done: boolean;
-  constrain: boolean;
-  callback?: () => void;
-};
-declare class TransitionManager {
-  runtime: Runtime;
-  readonly pendingTransition: PendingTransition;
-  constructor(runtime: Runtime);
-  hasPending(): boolean;
-  getPendingTransition(): PendingTransition;
-  getPendingFrom(): Strand;
-  customTransition(func: (transition: PendingTransition) => void): void;
-  stopTransition(): void;
-  runTransition(target: Strand, delta: number): void;
-  lastZoomTo: {
-    factor: number;
-    options: any;
-  } | null;
-  resumeTransition(): void;
-  zoomTo(factor: number, options?: {
-    origin?: Position;
-    stream?: boolean;
-    minZoomFactor?: number;
-    transition?: {
-      duration?: number;
-      easing?: EasingFunction;
-    };
-  }): void;
-  isConstraining: boolean;
-  constrainBounds({
-    transition,
-    panPadding
-  }?: {
-    panPadding?: number;
-    transition?: {
-      duration?: number;
-      easing?: EasingFunction;
-    };
-  }): void;
-  applyTransition(target: Strand, transition?: {
-    duration?: number;
-    easing?: EasingFunction;
-    constrain?: boolean;
-  }, defaults?: {
-    duration: number;
-    easing: EasingFunction;
-    constrain?: boolean;
-    callback?: () => void;
-  }, {
-    stream
-  }?: {
-    stream?: boolean;
-  }): void;
-  lastGoToRegion: null | {
-    target: any;
-    options: any;
-  };
-  goToRegion(target: {
+    y: number;
+  }): void;
+  constraintBounds(immediate?: boolean): void;
+  hasPendingAnimation(): boolean;
+  addDebugSubscriber(callback: (event: WorldDebugEvent) => void): () => void;
+  removeDebugSubscriber(callback: (event: WorldDebugEvent) => void): void;
+  private emitDebug;
+}
+//#endregion
+//#region src/renderer/renderer.d.ts
+interface Renderer {
+  beforeFrame(world: World, delta: number, target: Strand, options: HookOptions): void;
+  paint(paint: SpacialContent, index: number, x: number, y: number, width: number, height: number): void;
+  afterFrame(world: World, delta: number, target: Strand, options: HookOptions): void;
+  getScale(width: number, height: number, dpi?: boolean): number;
+  prepareLayer(paint: SpacialContent, point: Strand): void;
+  finishLayer(paint: SpacialContent, point: Strand): void;
+  afterPaintLayer(paint: SpacialContent, transform?: Strand): void;
+  pendingUpdate(): boolean;
+  getPointsAt(world: World, target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
+  getViewportBounds(world: World, target: Strand, padding: number): PositionPair | null;
+  isReady(): boolean;
+  resize(): void;
+  resize(width?: number, height?: number): void;
+  triggerResize?: () => void;
+  resetReadyState?: () => void;
+  reset(): void;
+  getRendererScreenPosition(): {
     x: number;
     y: number;
     width: number;
     height: number;
-    padding?: number;
-  }, {
-    transition
-  }?: {
-    transition?: {
-      duration?: number;
-      easing?: EasingFunction;
-    };
-  }): void;
+    top: number;
+    left: number;
+  } | undefined;
 }
 //#endregion
 //#region src/renderer/runtime.d.ts
@@ -575,9 +995,18 @@ type RuntimeOptions = {
   maxOverZoom: number;
   maxUnderZoom: number;
 };
+type RuntimeZoneState = {
+  zoneId: string;
+  exists: boolean;
+  active: boolean;
+  visibleInViewport: boolean;
+};
 declare class Runtime {
   id: string;
   ready: boolean;
+  readyCycle: number;
+  readyReason: AtlasReadyResetReason;
+  readyTimestamp: number | undefined;
   get x(): number;
   set x(x: number);
   get y(): number;
@@ -624,27 +1053,20 @@ declare class Runtime {
     y: number;
   };
   _lastGoodScale: number;
-  _canvasWidth: number;
-  _canvasHeight: number;
+  debugFrame: number;
+  debugSubscribers: Set<(event: RuntimeDebugEvent) => void>;
   hooks: RuntimeHooks;
   fpsLimit: number | undefined;
   options: RuntimeOptions;
   hookOptions: HookOptions;
   constructor(renderer: Renderer, world: World, target: Viewer, controllers?: RuntimeController[], options?: Partial<RuntimeOptions>);
   setHomePosition(position?: Projection): void;
-  /**
-   * Set the default home padding in CSS pixels. When `goHome()` is invoked without a paddingPx
-   * this value will be used and converted to world units internally.
-   */
   setHomePaddingPx(px?: number | {
     left?: number;
     right?: number;
     top?: number;
     bottom?: number;
   }): void;
-  /**
-   * Get the current default home padding in CSS pixels (as set via `setHomePaddingPx`).
-   */
   getHomePaddingPx(): number | {
     left?: number;
     right?: number;
@@ -667,6 +1089,14 @@ declare class Runtime {
   } | undefined;
   updateRendererScreenPosition(): void;
   setOptions(options: Partial<RuntimeOptions>): void;
+  /**
+   * Normalize padding input to a consistent per-side format.
+   */
+  private normalizePadding;
+  /**
+   * Calculate the viewport region that fits the target content within the available
+   * canvas area (accounting for CSS pixel padding).
+   */
   getHomeTarget(options?: {
     cover?: boolean;
     position?: Strand;
@@ -682,16 +1112,16 @@ declare class Runtime {
     width: number;
     height: number;
   };
-  getHomeTargetStrand(options?: {
+  isViewportAtHome(options?: {
     cover?: boolean;
-    position?: Strand;
-    paddingPx?: number | {
-      left?: number;
-      right?: number;
-      top?: number;
-      bottom?: number;
-    };
-  }): Strand;
+    tolerance?: number;
+    target?: Projection;
+  }): boolean;
+  isViewportAtHomeZoomLevel(options?: {
+    cover?: boolean;
+    tolerance?: number;
+    target?: Projection;
+  }): boolean;
   goHome(options?: {
     cover?: boolean;
     position?: Strand;
@@ -746,17 +1176,10 @@ declare class Runtime {
   }) => void;
   constrainBounds(target: Strand, {
     panPadding,
-    ref,
-    homePaddingPx
+    ref
   }?: {
     ref?: boolean;
     panPadding?: number;
-    homePaddingPx?: number | {
-      left?: number;
-      right?: number;
-      top?: number;
-      bottom?: number;
-    };
   }): readonly [boolean, Strand];
   /**
    * Get bounds
@@ -768,12 +1191,6 @@ declare class Runtime {
   getBounds(options: {
     padding: number;
     target?: Strand;
-    homePaddingPx?: number | {
-      left?: number;
-      right?: number;
-      top?: number;
-      bottom?: number;
-    };
   }): {
     readonly minX: number;
     readonly maxX: number;
@@ -781,6 +1198,20 @@ declare class Runtime {
     readonly maxY: number;
   };
   getScaleFactor(dpi?: boolean): number;
+  private copyStrandValues;
+  private getZoomConstraintState;
+  constrainTarget(target: Strand, {
+    origin,
+    panPadding,
+    ref
+  }?: {
+    origin?: {
+      x: number;
+      y: number;
+    };
+    panPadding?: number;
+    ref?: boolean;
+  }): readonly [boolean, Strand];
   /**
    * Zoom
    */
@@ -869,8 +1300,25 @@ declare class Runtime {
    */
   stop(): () => void;
   reset(): void;
+  resetReadyState(reason?: AtlasReadyResetReason): void;
+  getReadyState(): {
+    ready: boolean;
+    cycle: number;
+    reason: AtlasReadyResetReason;
+    timestamp?: number;
+  };
   selectZone(zone: number | string): void;
+  goToZone(id: string, options?: {
+    paddingPx?: number | {
+      left?: number;
+      right?: number;
+      top?: number;
+      bottom?: number;
+    };
+    immediate?: boolean;
+  }): boolean;
   deselectZone(): void;
+  getZoneRuntimeState(zoneId: string, viewport?: Projection): RuntimeZoneState;
   hook<Name$1 extends keyof RuntimeHooks, Arg = UnwrapHookArg<Name$1>>(name: keyof RuntimeHooks, arg: Arg): void;
   registerHook<Name$1 extends keyof RuntimeHooks, Hook = UnwrapHook<Name$1>>(name: Name$1, hook: Hook): () => void;
   /**
@@ -882,6 +1330,10 @@ declare class Runtime {
    */
   render: (t: number) => void;
   updateNextFrame(): void;
+  addDebugSubscriber(callback: (event: RuntimeDebugEvent) => void): () => void;
+  removeDebugSubscriber(callback: (event: RuntimeDebugEvent) => void): void;
+  private hasDebugSubscribers;
+  private emitDebug;
 }
 //#endregion
 //#region src/types.d.ts
@@ -994,187 +1446,108 @@ interface TextWrapperOptions {
   textDecoration?: 'none' | 'underline';
 }
 //#endregion
-//#region src/spacial-content/image-texture.d.ts
-type UpdateTextureFunction = () => {
-  source: TexImageSource | undefined;
-  hash: any;
-};
-type ImageTextureProps = {
-  id: string;
-  display?: {
-    width: number;
-    height: number;
-  };
-  target: {
-    width: number;
-    height: number;
-  };
-  scale?: number;
-  getTexture: UpdateTextureFunction;
-};
-declare class ImageTexture extends BaseObject implements SpacialContent {
-  readonly type = "spacial-content";
-  id: string;
-  uri: string;
-  display: DisplayData;
-  points: Strand;
-  getTexture: UpdateTextureFunction;
-  constructor(data?: {
-    id?: string;
-    uri: string;
-    width: number;
-    height: number;
-    scale?: number;
-  });
-  applyProps(props: ImageTextureProps): void;
-  getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
-}
-//#endregion
-//#region src/spacial-content/spacial-content.d.ts
-interface SpacialContent {
-  readonly id: string;
-  readonly type: 'spacial-content';
-  readonly display: DisplayData;
-  __id?: string;
+//#region src/objects/base-object.d.ts
+declare abstract class BaseObject<Props = any, SupportedChildElements = never> implements AtlasObjectModel<Props, SupportedChildElements> {
+  __id: string;
+  __revision: number;
+  __host: any;
+  __onCreate?: () => void;
   __parent?: CompositeResource;
   __owner: {
     value: WorldObject | undefined;
   };
-  __host?: any;
-  priority?: boolean;
-  points: Strand;
-  crop?: Strand;
-  cropData?: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  style?: {
-    opacity: number;
-  };
-  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => void | Promise<void>>;
-  getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
-  transform(op: Strand): void;
-  loadFullResource?(): Promise<void>;
-  dispatchEvent(event: string, e: any): void;
-  getImageUrl?: (index: number) => string;
-  getTexture?: UpdateTextureFunction;
-}
-//#endregion
-//#region src/spacial-content/single-image.d.ts
-type SingleImageProps = {
-  uri: string;
-  id?: string;
-  display?: {
-    width: number;
-    height: number;
-    rotation?: number;
-  };
-  target: {
-    width: number;
-    height: number;
-    x?: number;
-    y?: number;
-  };
-  crop?: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  scale?: number;
-  priority?: boolean;
-  style?: any;
-};
-declare class SingleImage extends BaseObject implements SpacialContent {
-  readonly type = "spacial-content";
-  /**
-   * An identifier for this image. Will default to the image URI.
-   */
-  id: string;
-  /**
-   * The URI of the image being painted.
-   */
-  uri: string;
-  /**
-   * The real height and width of the image. For example a 1000x1000 painted at 100x100 would contain
-   * the display data for 1000x1000 and `this.points` would scale that down to 100x100. This is used to
-   * calculate the scale.
-   */
-  display: DisplayData;
-  /**
-   * Points are relative to the world object.
-   * Does not change when viewport moves
-   * Does not change if world object position changes.
-   * */
-  points: Strand;
-  /**
-   * Displayed as priority
-   */
-  priority?: boolean;
-  /**
-   * Some simple styling options
-   */
-  style: {
-    opacity: number;
-  };
-  constructor(data?: {
-    id?: string;
-    uri: string;
-    width: number;
-    height: number;
-    scale?: number;
-    x?: number;
-    y?: number;
-    rotation?: number;
-  });
-  applyProps(props: SingleImageProps): void;
-  getAllPointsAt(target: Strand, aggregate?: Strand, scale?: number): Paint[];
-  static fromSvg(svg: string, target: SpacialSize, display?: SpacialSize, id?: string): SingleImage;
-  static fromImage(uri: string, target: SpacialSize, display?: SpacialSize, id?: string): SingleImage;
-  getImageUrl(): string;
-}
-//#endregion
-//#region src/spacial-content/tiled-image.d.ts
-declare class TiledImage extends BaseObject implements SpacialContent {
-  readonly id: string;
-  readonly type = "spacial-content";
-  readonly display: DisplayData;
-  tileWidth: number;
-  style: {
-    opacity: number;
-  };
-  points: Strand;
-  service?: ImageService$1;
-  format: string;
-  crop2?: Strand;
-  version3?: boolean;
-  tileUrl: string;
-  constructor(data: {
-    url: string;
-    scaleFactor: number;
-    points: Strand;
-    displayPoints?: Strand;
-    tileWidth: number;
-    width: number;
-    height: number;
-    format?: string;
-    id?: string;
-    version3?: boolean;
-  });
-  applyProps(props: any): void;
-  static fromTile(url: string, canvas: {
+  __state: any;
+  eventHandlers: SupportedEventMap;
+  scale: number;
+  layers: SupportedChildElements[];
+  time: WorldTime[];
+  _crop?: Strand;
+  cropData?: {
+    x: number;
+    y: number;
     width: number;
     height: number;
-  }, tile: {
-    width: number;
-    height?: number;
-  }, scaleFactor: number, service?: ImageService$1, format?: string, useFloorCalc?: boolean, version3?: boolean): TiledImage;
-  getImageUrl(index: number): string;
-  getAllPointsAt(target: Strand, aggregate?: Strand, scaleFactor?: number): Paint[];
+  };
+  get crop(): Strand | undefined;
+  set crop(crop: Strand | undefined);
+  id: string;
+  abstract points: Strand;
+  getObjectsAt(target: Strand): SupportedChildElements[] | Array<[SupportedChildElements, any[]]>;
+  getAllPointsAt(target: Strand, aggregate: Strand, scale: number): Paint[];
+  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => void | Promise<void>>;
+  protected constructor();
+  addEventListener: <Name$1 extends SupportedEventNames>(name: Name$1, cb: (e: any) => void, options?: {
+    capture: boolean;
+    passive: boolean;
+  }) => void;
+  removeEventListener: <Name$1 extends SupportedEventNames>(name: Name$1, cb: (e: any) => void) => void;
+  dispatchEvent<Name$1 extends keyof SupportedEvents>(name: Name$1, e: any): boolean;
+  get x(): number;
+  get y(): number;
+  get width(): number;
+  get height(): number;
+  translate(x: number, y: number): void;
+  atScale(factor: number): void;
   transform(op: Strand): void;
-  getScheduledUpdates(target: Strand, scaleFactor: number): Array<() => Promise<void>>;
+  applyProps(props: Props): void;
+  appendChild(item: SupportedChildElements): void;
+  removeChild(item: SupportedChildElements): void;
+  insertBefore(item: SupportedChildElements, before: SupportedChildElements): void;
+  hideInstance(): void;
+}
+//#endregion
+//#region src/modules/browser-event-manager/browser-event-manager.d.ts
+type BrowserEventManagerOptions = {
+  /** Default 50ms **/
+  simulationRate: number;
+};
+declare class BrowserEventManager {
+  element: HTMLElement;
+  runtime: Runtime;
+  unsubscribe: () => any;
+  activatedEvents: string[];
+  eventHandlers: [string, any][];
+  bounds: DOMRect;
+  listening: boolean;
+  static eventPool: {
+    atlas: {
+      x: number;
+      y: number;
+    };
+  };
+  pointerMoveEvent: PointerEvent | undefined;
+  pointerEventState: {
+    isClicking: boolean;
+    isPressed: boolean;
+    isDragging: boolean;
+    mousedOver: BaseObject[];
+    itemsBeingDragged: BaseObject[];
+    mouseDownStart: {
+      x: number;
+      y: number;
+    };
+    lastTouches: Array<{
+      id: number;
+      x: number;
+      y: number;
+    }>;
+  };
+  options: BrowserEventManagerOptions;
+  constructor(element: HTMLElement, runtime: Runtime, options?: Partial<BrowserEventManagerOptions>);
+  updateBounds(): void;
+  layoutSubscriber(type: string): void;
+  assignToEvent(e: any, x: number, y: number): void;
+  activateEvents(): void;
+  _realPointerMove: (e: PointerEvent) => void;
+  onWheelEvent: (e: WheelEvent) => void;
+  onContextMenu: (e: MouseEvent) => void;
+  onTouchEvent: (e: TouchEvent) => void;
+  onPointerEvent: (e: PointerEvent | MouseEvent) => void;
+  onPointerDown: (e: PointerEvent | MouseEvent) => void;
+  onPointerUp: (e: PointerEvent | MouseEvent) => void;
+  onPointerMove: (e: PointerEvent | MouseEvent) => void;
+  normalizeEventName(event: string): string;
+  stop(): void;
 }
 //#endregion
 //#region src/objects/box.d.ts
@@ -1328,115 +1701,6 @@ declare class Text extends BaseObject<TextProps> implements SpacialContent {
   }: Partial<TextProps>): void;
 }
 //#endregion
-//#region src/objects/geometry.d.ts
-type GeometryProps = {
-  id: string;
-  target: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  open?: boolean;
-  points: [number, number][];
-  className?: string;
-  href?: string;
-  title?: string;
-  hrefTarget?: string;
-  interactive?: boolean;
-  relativeSize?: boolean;
-  relativeStyle?: boolean;
-  html?: boolean;
-  style?: GeometryStyle;
-  backgroundColor?: string;
-  border?: string;
-};
-type GeometryStyle = _GeometryStyle & {
-  ':hover'?: _GeometryStyle;
-  ':active'?: _GeometryStyle;
-};
-type _GeometryStyle = Partial<{
-  backgroundColor: string;
-  opacity: number;
-  boxShadow: string;
-  borderColor: string;
-  borderWidth: string;
-  borderStyle: string;
-  outlineColor: string;
-  outlineWidth: string;
-  outlineOffset: string;
-  outlineStyle: string;
-  border: string;
-  outline: string;
-  background: string;
-}>;
-declare class Geometry extends BaseObject<GeometryProps> implements SpacialContent {
-  id: string;
-  type: 'spacial-content';
-  isShape: boolean;
-  points: Strand;
-  hoverEvents: boolean;
-  activeEvents: boolean;
-  display: {
-    x: number;
-    y: number;
-    scale: number;
-    width: number;
-    height: number;
-    points: Strand;
-  };
-  boundingBox: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  } | null;
-  _parsed: {
-    border: {
-      id: string | null;
-      match: string[];
-    };
-    outline: {
-      id: string | null;
-      match: string[];
-    };
-  };
-  hovering?: boolean;
-  pressing?: boolean;
-  props: {
-    href?: string;
-    hrefTarget?: string;
-    title?: string;
-    backgroundColor?: string;
-    border?: string;
-    interactive?: boolean;
-    open?: boolean;
-    className?: string;
-    relativeSize?: boolean;
-    relativeStyle?: boolean;
-    html?: boolean;
-    style?: GeometryStyle;
-    hoverStyles?: GeometryStyle;
-    pressStyles?: GeometryStyle;
-  };
-  shape: {
-    type: 'none';
-  } | {
-    type: 'polygon';
-    points: [number, number][];
-    open?: boolean;
-  };
-  constructor();
-  updateBoundingBox(): void;
-  intersects(pointer?: [number, number] | null): boolean;
-  getAllPointsAt(target: Strand, aggregate: Strand): Paint[];
-  addHover: () => void;
-  removeHover: () => void;
-  addPress: () => void;
-  removePress: () => void;
-  applyProps(props?: Partial<GeometryProps>): void;
-}
-//#endregion
 //#region src/modules/composite-renderer/composite-renderer.d.ts
 declare class CompositeRenderer implements Renderer {
   renderers: Renderer[];
@@ -1464,6 +1728,7 @@ declare class CompositeRenderer implements Renderer {
   finishLayer(paint: SpacialContent, point: Strand): void;
   resize(width?: number, height?: number): void;
   reset(): void;
+  resetReadyState(): void;
 }
 //#endregion
 //#region src/modules/grid-builder/grid-builder.d.ts
@@ -1493,6 +1758,85 @@ declare class GridBuilder {
   getWorld(): World;
 }
 //#endregion
+//#region src/modules/iiif/shared.d.ts
+type GetTile = {
+  id: string;
+  width: number;
+  height: number;
+  thumbnail?: {
+    id: string;
+    width: number;
+    height: number;
+  };
+  imageService: ImageService$1;
+};
+declare function getId(entity: any): string;
+//#endregion
+//#region src/modules/maps/projection.d.ts
+declare const MAX_MERCATOR_LATITUDE = 85.05112878;
+declare function clampMercatorLatitude(lat: number): number;
+declare function validateMapBounds(bounds: MapBounds): MapBounds;
+declare function longitudeToMercatorX(lng: number): number;
+declare function latitudeToMercatorY(lat: number): number;
+declare function mercatorXToLongitude(x: number): number;
+declare function mercatorYToLatitude(y: number): number;
+declare function lngToTileX(lng: number, zoom: number): number;
+declare function latToTileY(lat: number, zoom: number): number;
+declare function tileXToLng(tileX: number, zoom: number): number;
+declare function tileYToLat(tileY: number, zoom: number): number;
+declare function createMapProjection(config: {
+  bounds: MapBounds;
+  width: number;
+  height: number;
+}): MapProjection;
+//#endregion
+//#region src/modules/maps/tile-source.d.ts
+declare const DEFAULT_OSM_TILE_TEMPLATE = "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+declare function getSubdomainForTile(ctx: MapTileUrlContext): string | undefined;
+declare function resolveTileTemplate(template: string, ctx: MapTileUrlContext): string;
+declare function resolveTileUrl(source: MapTileSource | undefined, ctx: MapTileUrlContext): string;
+//#endregion
+//#region src/modules/maps/warped/types.d.ts
+type WarpControlPoint = {
+  image: {
+    x: number;
+    y: number;
+  };
+  map: {
+    lng: number;
+    lat: number;
+  };
+};
+type WarpTransformationType = 'affine' | 'projective' | 'thinPlateSpline';
+type WarpUpdateReason = 'gcps' | 'transformation' | 'manual';
+type WarpAdapterHooks = {
+  onControlPointsChange?: (controlPoints: WarpControlPoint[]) => void;
+  onTransformationTypeChange?: (type: WarpTransformationType) => void;
+  onUpdate?: (reason: WarpUpdateReason) => void;
+};
+type WarpAdapter = {
+  setMapGcps(controlPoints: WarpControlPoint[]): void;
+  setMapTransformationType(type: WarpTransformationType): void;
+  update(reason?: WarpUpdateReason): void;
+};
+//#endregion
+//#region src/modules/maps/warped/adapter.d.ts
+declare class WarpAdapterController {
+  private readonly adapter;
+  private readonly hooks;
+  private controlPoints;
+  private transformationType;
+  constructor(adapter: WarpAdapter, hooks?: WarpAdapterHooks);
+  getState(): {
+    controlPoints: WarpControlPoint[];
+    transformationType: WarpTransformationType;
+  };
+  setControlPoints(controlPoints: WarpControlPoint[]): void;
+  setTransformationType(type: WarpTransformationType): void;
+  update(reason?: WarpUpdateReason): void;
+}
+declare function createWarpAdapterController(adapter: WarpAdapter, hooks?: WarpAdapterHooks): WarpAdapterController;
+//#endregion
 //#region src/modules/popmotion-controller/popmotion-controller.d.ts
 type PopmotionControllerConfig = {
   zoomOutFactor?: number;
@@ -1506,14 +1850,24 @@ type PopmotionControllerConfig = {
   panBounceDamping?: number;
   panTimeConstant?: number;
   panPower?: number;
+  /**
+   * Enable inertial momentum when releasing from pan.
+   */
+  enablePanMomentum?: boolean;
+  /**
+   * Pan momentum intensity multiplier. 1 is the default "Apple-like" feel.
+   */
+  panMomentumStrength?: number;
   nudgeDistance?: number;
   panPadding?: number;
   devicePixelRatio?: number;
   enableWheel?: boolean;
   enableClickToZoom?: boolean;
+  enableDoubleTapZoom?: boolean;
   ignoreSingleFingerTouch?: boolean;
   enablePanOnWait?: boolean;
   requireMetaKeyForWheelZoom?: boolean;
+  wheelInExploreModeOnly?: boolean;
   panOnWaitDelay?: number;
   parentElement?: HTMLElement | null;
   onPanInSketchMode?: () => void;
@@ -1521,72 +1875,83 @@ type PopmotionControllerConfig = {
 declare const defaultConfig: Required<PopmotionControllerConfig>;
 declare const popmotionController: (config?: PopmotionControllerConfig) => RuntimeController;
 //#endregion
-//#region src/modules/iiif/shared.d.ts
-type GetTile = {
-  id: string;
-  width: number;
-  height: number;
-  thumbnail?: {
-    id: string;
-    width: number;
-    height: number;
-  };
-  imageService: ImageService$1;
+//#region src/modules/pdf-scroll-zone-controller/pdf-scroll-zone-controller.d.ts
+type PdfScrollZoneControllerConfig = PopmotionControllerConfig & {
+  scrollWheelFactor?: number;
+  scrollLoadAheadFactor?: number;
+  clickDragThresholdPx?: number;
+  touchScrollMomentumStrength?: number;
+  touchScrollMomentumMinStartPxPerMs?: number;
+};
+declare const pdfScrollZoneController: (config?: PdfScrollZoneControllerConfig) => RuntimeController;
+//#endregion
+//#region src/modules/shared/image-load-events.d.ts
+type AtlasImageLoadErrorSeverity = 'recoverable' | 'fatal';
+type AtlasImageLoadRenderer = 'canvas' | 'webgl';
+type AtlasImageLoadErrorEvent = {
+  severity: AtlasImageLoadErrorSeverity;
+  renderer: AtlasImageLoadRenderer;
+  imageUrl?: string;
+  contentId?: string;
+  tileIndex?: number;
+  attempt?: number;
+  maxAttempts?: number;
+  willRetry?: boolean;
+  nextRetryAt?: number;
+  error?: unknown;
 };
-declare function getId(entity: any): string;
 //#endregion
-//#region src/modules/browser-event-manager/browser-event-manager.d.ts
-type BrowserEventManagerOptions = {
-  /** Default 50ms **/
-  simulationRate: number;
+//#region src/modules/shared/image-loading-config.d.ts
+type ImageLoadingConfig = {
+  maxConcurrentRequests: number;
+  maxPrefetchPerFrame: number;
+  timeoutMs: number;
+  maxAttempts: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+  jitterRatio: number;
+  errorRetryIntervalMs: number;
+  revealDelayFrames: number;
+  revealBatchWindowFrames: number;
+  skipFadeIfLoadedWithinMs: number;
+};
+type ImageLoadingConfigOverrides = Partial<ImageLoadingConfig>;
+declare function resolveImageLoadingConfig(overrides?: ImageLoadingConfigOverrides): ImageLoadingConfig;
+declare function getRetryDelayMs(config: ImageLoadingConfig, attempt: number, random?: () => number): number;
+//#endregion
+//#region src/modules/shared/image-request-pool.d.ts
+type AcquireResult = {
+  requestKey: string;
+  promise: Promise<HTMLImageElement>;
+  release: (opts?: {
+    silent?: boolean;
+  }) => void;
+};
+type ImageRequestPoolOptions = {
+  timeoutMs: number;
+  crossOrigin?: 'anonymous' | 'use-credentials';
+  useFetch?: boolean;
+  cache?: Map<string, HTMLImageElement>;
 };
-declare class BrowserEventManager {
-  element: HTMLElement;
-  runtime: Runtime;
-  unsubscribe: () => any;
-  activatedEvents: string[];
-  eventHandlers: [string, any][];
-  bounds: DOMRect;
-  listening: boolean;
-  static eventPool: {
-    atlas: {
-      x: number;
-      y: number;
-    };
-  };
-  pointerMoveEvent: PointerEvent | undefined;
-  pointerEventState: {
-    isClicking: boolean;
-    isPressed: boolean;
-    isDragging: boolean;
-    mousedOver: BaseObject[];
-    itemsBeingDragged: BaseObject[];
-    mouseDownStart: {
-      x: number;
-      y: number;
-    };
-    lastTouches: Array<{
-      id: number;
-      x: number;
-      y: number;
-    }>;
-  };
-  options: BrowserEventManagerOptions;
-  constructor(element: HTMLElement, runtime: Runtime, options?: Partial<BrowserEventManagerOptions>);
-  updateBounds(): void;
-  layoutSubscriber(type: string): void;
-  assignToEvent(e: any, x: number, y: number): void;
-  activateEvents(): void;
-  _realPointerMove: (e: PointerEvent) => void;
-  onWheelEvent: (e: WheelEvent) => void;
-  onContextMenu: (e: MouseEvent) => void;
-  onTouchEvent: (e: TouchEvent) => void;
-  onPointerEvent: (e: PointerEvent | MouseEvent) => void;
-  onPointerDown: (e: PointerEvent | MouseEvent) => void;
-  onPointerUp: (e: PointerEvent | MouseEvent) => void;
-  onPointerMove: (e: PointerEvent | MouseEvent) => void;
-  normalizeEventName(event: string): string;
-  stop(): void;
+declare class ImageRequestPool {
+  private readonly timeoutMs;
+  private readonly crossOrigin?;
+  private readonly useFetch;
+  private readonly cache;
+  private readonly inFlight;
+  private readonly knownConsumers;
+  constructor(options: ImageRequestPoolOptions);
+  acquire(url: string, consumerId: string): AcquireResult;
+  release(url: string, consumerId: string, opts?: {
+    silent?: boolean;
+  }): void;
+  releaseConsumer(consumerId: string, opts?: {
+    silent?: boolean;
+  }): void;
+  cancelAll(opts?: {
+    silent?: boolean;
+  }): void;
+  private createRequest;
 }
 //#endregion
 //#region src/modules/canvas-renderer/canvas-renderer.d.ts
@@ -1599,15 +1964,60 @@ type CanvasRendererOptions = {
   box?: boolean;
   polygon?: boolean;
   lruCache?: boolean;
+  paintImages?: boolean;
+  shouldPaintImage?: (paint: SingleImage | TiledImage, index: number) => boolean;
+  readiness?: 'first-meaningful-paint' | 'immediate';
+  imageLoading?: Partial<ImageLoadingConfig>;
+  onImageError?: (event: AtlasImageLoadErrorEvent) => void;
 };
 type ImageBuffer = {
-  canvas: HTMLCanvasElement;
+  canvas?: HTMLCanvasElement;
   canvases: string[];
+  tiles?: Record<number, TileLoadingState>;
   indices: number[];
   loaded: number[];
   fallback?: ImageBuffer;
   loading: boolean;
 };
+type TileLoadingState = {
+  state: 'idle' | 'queued' | 'loading' | 'decoded' | 'error';
+  requestedAt?: number;
+  loadedAt?: number;
+  lastUsedAt?: number;
+  url?: string;
+  error?: unknown;
+  attempts?: number;
+  nextRetryAt?: number;
+  lastRequestKey?: string;
+  cancelledAt?: number;
+  skipFade?: boolean;
+};
+type QueueTask = {
+  id: string;
+  scale: number;
+  kind: 'network' | 'decode';
+  tileKey?: string;
+  requestKey?: string;
+  network?: boolean;
+  distance: number;
+  shifted?: boolean;
+  paint?: SingleImage | TiledImage;
+  index?: number;
+  prefetch?: boolean;
+  task: () => Promise<any>;
+};
+type InFlightTileLoad$1 = {
+  tileKey: string;
+  requestKey: string;
+  url: string;
+  consumerId: string;
+  paint: SingleImage | TiledImage;
+  imageBuffer: ImageBuffer;
+  index: number;
+  release: (opts?: {
+    silent?: boolean;
+  }) => void;
+};
 declare class CanvasRenderer implements Renderer {
   /**
    * The primary viewing space for the viewer.
@@ -1640,18 +2050,24 @@ declare class CanvasRenderer implements Renderer {
   pendingDrawCall: boolean;
   firstMeaningfulPaint: boolean;
   parallelTasks: number;
+  maxPrefetchPerFrame: number;
+  imageLoadingConfig: ImageLoadingConfig;
+  imageRequestPool: ImageRequestPool;
   frameTasks: number;
   loadingQueueOrdered: boolean;
-  loadingQueue: Array<{
-    id: string;
-    scale: number;
-    network?: boolean;
-    distance: number;
-    shifted?: boolean;
-    task: () => Promise<any>;
-  }>;
+  loadingQueue: QueueTask[];
   currentTask: Promise<any>;
   tasksRunning: number;
+  inFlightImageLoads: Map<string, InFlightTileLoad$1>;
+  requiredTileKeys: Set<string>;
+  requiredPrefetchTileKeys: Set<string>;
+  requestGeneration: number;
+  frameCounter: number;
+  pendingTileReveals: Map<string, {
+    imageBuffer: ImageBuffer;
+    index: number;
+    queuedFrame: number;
+  }>;
   stats?: any;
   averageJobTime: number;
   lastKnownScale: number;
@@ -1663,12 +2079,18 @@ declare class CanvasRenderer implements Renderer {
   lastPaintedObject?: WorldObject;
   hostCache: LRUCache<string, HTMLCanvasElement>;
   invalidated: string[];
+  fallbackRevealTimeout: ReturnType<typeof setTimeout> | null;
+  framePrefetchCount: number;
+  hasTilesFading: boolean;
+  hasActiveLayerClip: boolean;
   constructor(canvas: HTMLCanvasElement, options?: CanvasRendererOptions);
   getCanvasDims(): {
     width: number;
     height: number;
   };
   resize(): void;
+  private getCompositeOwner;
+  private compareCompositeLoadPriority;
   isReady(): boolean;
   afterFrame(world: World): void;
   doOffscreenWork(): void;
@@ -1679,9 +2101,31 @@ declare class CanvasRenderer implements Renderer {
   beforeFrame(world: World, delta: number, target: Strand, options: HookOptions): void;
   applyTransform(paint: Paintable, x: number, y: number, width: number, height: number): void;
   clearTransform(): void;
+  private getTileKey;
+  private nextRequestKey;
+  private markTileRequired;
+  private isTileRequired;
+  private shouldSkipFade;
+  private enqueueTileReveal;
+  private flushTileRevealBatch;
+  private emitImageError;
+  private releaseInFlightTileLoad;
+  private pruneStaleTileWork;
+  private ensureImageBuffer;
+  private getTileState;
+  private setTileState;
+  private syncBufferState;
+  private getCompositeRenderOptions;
+  private shouldClipLayerToBounds;
+  private getBoundsFromPoints;
+  private getLayerPolicy;
+  private isLayerActive;
+  private getPrefetchRadius;
+  private getFadeAlpha;
+  private schedulePrefetchNeighbours;
+  private scheduleSingleImageLookahead;
   paint(paint: SpacialContent | Text | Box, index: number, x: number, y: number, width: number, height: number): void;
-  loadImage(url: string, callback: (image: HTMLImageElement) => void, err: (e: any) => void, retry?: boolean): void;
-  schedulePaintToCanvas(imageBuffer: ImageBuffer, paint: SingleImage | TiledImage, index: number, priority: number): void;
+  schedulePaintToCanvas(imageBuffer: ImageBuffer, paint: SingleImage | TiledImage, index: number, priority: number, prefetch?: boolean): boolean;
   afterPaintLayer(paint: SpacialContent, transform: Strand): void;
   prepareLayer(paint: SpacialContent, points: Strand): void;
   finishLayer(): void;
@@ -1690,6 +2134,7 @@ declare class CanvasRenderer implements Renderer {
   getViewportBounds(world: World, target: Strand, padding: number): PositionPair | null;
   pendingUpdate(): boolean;
   getRendererScreenPosition(): DOMRect;
+  resetReadyState(): void;
   reset(): void;
 }
 //#endregion
@@ -1726,6 +2171,254 @@ declare class DebugRenderer implements Renderer {
   reset(): void;
 }
 //#endregion
+//#region src/modules/iiif/get-tiles.d.ts
+declare function getTileFromImageService(infoJsonId: string, width: number, height: number): Promise<GetTile>;
+declare function getTileFromCanvas(canvas: CanvasNormalized, thumbnailSize?: number): Promise<GetTile[]>;
+declare function getTilesFromManifest(manifest: ManifestNormalized): Promise<any[]>;
+declare function getTiles(manifestId: string): Promise<Array<GetTile>>;
+//#endregion
+//#region src/modules/navigator-renderer/navigator-renderer.d.ts
+type NavigatorTransform = {
+  scale: number;
+  offsetX: number;
+  offsetY: number;
+  worldX: number;
+  worldY: number;
+  worldWidth: number;
+  worldHeight: number;
+};
+type NavigatorWorldRegion = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type NavigatorRendererStyle = {
+  background: string;
+  objectFill: string;
+  objectStroke: string;
+  viewportFill: string;
+  viewportStroke: string;
+  viewportLineWidth: number;
+};
+type SharedCanvasTileState = {
+  state?: 'idle' | 'queued' | 'loading' | 'decoded' | 'error';
+};
+type SharedCanvasImageBuffer = {
+  canvases?: string[];
+  tiles?: Record<number, SharedCanvasTileState>;
+};
+type SharedCanvasRenderer = {
+  hostCache?: {
+    get(id: string): HTMLCanvasElement | undefined;
+  };
+  invalidated?: string[];
+  schedulePaintToCanvas?: (imageBuffer: SharedCanvasImageBuffer, paint: SingleImage | TiledImage, index: number, priority: number, prefetch?: boolean) => boolean;
+  createImageHost?: (paint: SingleImage | TiledImage) => void;
+};
+type NavigatorRendererOptions = {
+  style?: Partial<NavigatorRendererStyle>;
+  maxRects?: number;
+  minVisibleRectSize?: number;
+  drawFallbackBoxes?: boolean;
+  zoneWindow?: NavigatorZoneWindowOptions;
+  sharedCanvasRenderer?: SharedCanvasRenderer;
+  onRequestRender?: () => void;
+  onDebugEvent?: (event: NavigatorDebugEvent) => void;
+};
+type NavigatorDebugEvent = {
+  type: 'preview-image-requested';
+  imageUrl: string;
+} | {
+  type: 'preview-image-loaded';
+  imageUrl: string;
+  cached: boolean;
+} | {
+  type: 'preview-image-error';
+  imageUrl: string;
+} | {
+  type: 'world-layer-invalidated';
+  reason: string;
+} | {
+  type: 'frame-skipped-zero-size-canvas';
+  canvasWidth: number;
+  canvasHeight: number;
+  baseCanvasWidth: number;
+  baseCanvasHeight: number;
+} | {
+  type: 'world-layer-render-start';
+  region: NavigatorWorldRegion;
+} | {
+  type: 'world-layer-render-end';
+  region: NavigatorWorldRegion;
+} | {
+  type: 'render-request-forwarded';
+  reason: string;
+};
+type NavigatorZoneWindowOptions = {
+  total?: number;
+  before?: number;
+  after?: number;
+};
+type NavigatorWorldRegionOptions = {
+  target?: Strand | {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  zoneWindow?: NavigatorZoneWindowOptions;
+};
+declare function getNavigatorWorldTransform(worldWidth: number, worldHeight: number, navigatorWidth: number, navigatorHeight: number, worldX?: number, worldY?: number): NavigatorTransform;
+declare function getNavigatorWorldRegion(world: World, options?: NavigatorWorldRegionOptions): NavigatorWorldRegion;
+declare function getNavigatorVisibleZoneIdSet(world: World, options?: NavigatorWorldRegionOptions): Set<string> | null;
+declare function navigatorToWorldPoint(transform: NavigatorTransform, x: number, y: number): {
+  x: number;
+  y: number;
+};
+declare class NavigatorRenderer extends DebugRenderer {
+  private readonly style;
+  private readonly maxRects;
+  private readonly minVisibleRectSize;
+  private readonly drawFallbackBoxes;
+  private readonly zoneWindow?;
+  private readonly sharedCanvasRenderer?;
+  private readonly onRequestRender?;
+  private readonly onDebugEvent?;
+  private readonly baseCanvas;
+  private readonly baseContext;
+  private readonly worldTarget;
+  private readonly previewImageCache;
+  private worldLayerDirty;
+  private lastWorldWidth;
+  private lastWorldHeight;
+  private lastTargetX;
+  private lastTargetY;
+  private lastTargetX2;
+  private lastTargetY2;
+  private lastRegionX;
+  private lastRegionY;
+  private lastRegionWidth;
+  private lastRegionHeight;
+  private worldLayerInvalidationVersion;
+  private sharedCanvasResourcesPending;
+  constructor(canvas: HTMLCanvasElement, options?: NavigatorRendererOptions);
+  private emitDebugEvent;
+  private requestRender;
+  invalidateWorldLayer(reason?: string): void;
+  resize(): void;
+  beforeFrame(world: World): void;
+  paint(): void;
+  pendingUpdate(): boolean;
+  afterFrame(world: World, _delta: number, target: Strand): void;
+  private hasViewportChanged;
+  private hasRegionChanged;
+  private syncBaseLayerCanvas;
+  private shouldClipImagePaintToBounds;
+  private getBoundsFromPoints;
+  private getLayerClipBounds;
+  private renderWorldLayer;
+  private renderFallbackBox;
+  private renderImagePaint;
+  private ensureSharedCanvasImageBuffer;
+  private drawSharedCanvasTile;
+  private renderSharedCanvasImage;
+  private getLoadedPreviewImage;
+  private renderBox;
+  private renderGeometry;
+  private renderViewportBox;
+}
+//#endregion
+//#region src/utility/stylesheet.d.ts
+declare class Stylesheet {
+  $element: HTMLStyleElement;
+  stylesheetClasses: string[];
+  activeStylesheetClasses: string[];
+  sheetsDidUpdate: boolean;
+  sheetPrefix: string;
+  stylesheetEntries: Record<string, string>;
+  constructor(options?: {
+    sheetPrefix?: string;
+  });
+  getElement(): HTMLStyleElement;
+  addStylesheet(_sheet: string): string;
+  removeStylesheet(obj: any): void;
+  clearClasses(): void;
+  didUpdateActive(): boolean;
+  updateSheet(): void;
+}
+//#endregion
+//#region src/modules/overlay-renderer/overlay-renderer.d.ts
+type OverlayRendererOptions = {
+  sheetPrefix: string;
+  box: boolean;
+  text: boolean;
+  inlineStyles: boolean;
+  triggerResize: () => void;
+  background: string;
+};
+declare class OverlayRenderer implements Renderer {
+  htmlContainer: HTMLDivElement;
+  visible: Array<Text | Box | SpacialContent>;
+  previousVisible: Array<Text | Box | SpacialContent>;
+  htmlIds: string[];
+  firstMeaningfulPaint: boolean;
+  rendererPosition: DOMRect;
+  stylesheet: Stylesheet;
+  options: OverlayRendererOptions;
+  paintTx: number;
+  zIndex: number;
+  classes: {
+    hostClassName: string;
+    interactive: string;
+    nonInteractive: string;
+  };
+  constructor(htmlContainer: HTMLDivElement, options?: Partial<OverlayRendererOptions>);
+  createHtmlHost(paint: Text | Box): void;
+  triggerResize(): void;
+  updateHtmlHost(paint: Text | Box, width?: number, height?: number): void;
+  afterFrame(world: World, delta: number, target: Strand): void;
+  afterPaintLayer(paint: SpacialContent, transform?: Strand): void;
+  beforeFrame(world: World, delta: number, target: Strand): void;
+  getPointsAt(world: World, target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
+  getScale(width: number, height: number): number;
+  getViewportBounds(world: World, target: Strand, padding: number): PositionPair | null;
+  isReady(): boolean;
+  paint(paint: SpacialContent, index: number, x: number, y: number, width: number, height: number): void;
+  pendingUpdate(): boolean;
+  prepareLayer(paint: SpacialContent): void;
+  resize(width?: number, height?: number): void;
+  getRendererScreenPosition(): DOMRect;
+  finishLayer(): void;
+  reset(): void;
+}
+//#endregion
+//#region src/modules/webgl-renderer/types.d.ts
+type AtlasWebGLFallbackReason = 'image-cors-or-load' | 'teximage-security' | 'webgl-context-unavailable' | 'webgl-context-lost';
+type AtlasWebGLFallbackEvent = {
+  from: 'webgl';
+  to: 'canvas';
+  reason: AtlasWebGLFallbackReason;
+  imageUrl?: string;
+  contentId?: string;
+  tileIndex?: number;
+  error?: unknown;
+};
+//#endregion
+//#region src/modules/react-reconciler/components/DevTools.d.ts
+declare const DevTools: React.FC<DevToolsProps>;
+type DevToolsProps = {
+  initialOpen?: boolean;
+  bottom?: number;
+  right?: number;
+  zIndex?: number;
+  maxEvents?: number;
+  maxRuntimeEvents?: number;
+  runtimeId?: string;
+  className?: string;
+  style?: CSSProperties;
+};
+//#endregion
 //#region src/modules/react-reconciler/presets/_types.d.ts
 type Preset = {
   name: string;
@@ -1736,6 +2429,7 @@ type Preset = {
   ready?: boolean;
   unmount(): void;
   canvas?: HTMLCanvasElement;
+  parityCanvas?: HTMLCanvasElement;
   overlay?: HTMLDivElement;
   container?: HTMLDivElement;
   navigator?: HTMLCanvasElement;
@@ -1743,44 +2437,63 @@ type Preset = {
 type PresetArgs = {
   viewport: Viewer;
   forceRefresh: () => void;
+  controllerConfig?: any;
+  interactionMode?: 'popmotion' | 'pdf-scroll-zone';
   runtimeOptions?: RuntimeOptions;
   containerElement?: HTMLDivElement;
   canvasElement?: HTMLCanvasElement;
+  parityCanvasElement?: HTMLCanvasElement;
   overlayElement?: HTMLDivElement;
   navigatorElement?: HTMLCanvasElement;
+  onWebGLFallback?: (event: AtlasWebGLFallbackEvent) => void;
+  onImageError?: (event: AtlasImageLoadErrorEvent) => void;
+  imageLoading?: Partial<ImageLoadingConfig>;
+  webglFallbackOnImageLoadError?: boolean;
+  webglReadiness?: 'first-meaningful-paint' | 'immediate';
 };
 //#endregion
 //#region src/modules/react-reconciler/presets/default-preset.d.ts
 type DefaultPresetName = 'default-preset';
 type DefaultPresetOptions = {
   controllerConfig?: any;
+  interactionMode?: 'popmotion' | 'pdf-scroll-zone';
   unstable_webglRenderer?: boolean;
   interactive?: boolean;
   dpi?: number;
   debug?: boolean;
   canvasBox?: boolean;
   polygon?: boolean;
+  navigatorRendererOptions?: NavigatorRendererOptions;
 };
 declare function defaultPreset({
   interactive,
   viewport,
   forceRefresh,
   canvasElement,
+  parityCanvasElement,
   overlayElement,
   controllerConfig,
+  interactionMode,
   unstable_webglRenderer,
   dpi,
   debug,
   canvasBox,
   polygon,
   navigatorElement,
-  runtimeOptions
+  runtimeOptions,
+  onWebGLFallback,
+  onImageError,
+  imageLoading,
+  webglFallbackOnImageLoadError,
+  webglReadiness,
+  navigatorRendererOptions
 }: PresetArgs & DefaultPresetOptions): Preset;
 //#endregion
 //#region src/modules/react-reconciler/presets/static-preset.d.ts
 type StaticPresetName = 'static-preset';
 type StaticPresetOptions = {
   controllerConfig?: any;
+  interactionMode?: 'popmotion' | 'pdf-scroll-zone';
   interactive?: boolean;
 };
 declare function staticPreset({
@@ -1789,7 +2502,8 @@ declare function staticPreset({
   forceRefresh,
   containerElement,
   overlayElement,
-  controllerConfig
+  controllerConfig,
+  interactionMode
 }: PresetArgs & StaticPresetOptions): Preset;
 //#endregion
 //#region src/modules/react-reconciler/presets/index.d.ts
@@ -1804,11 +2518,19 @@ type AtlasProps = {
   onCreated?: (ctx: Preset) => void | Promise<void>;
   resetWorldOnChange?: boolean;
   unstable_webglRenderer?: boolean;
+  onWebGLFallback?: (event: AtlasWebGLFallbackEvent) => void;
+  onReady?: (event: AtlasReadyEvent) => void;
+  onImageError?: (event: AtlasImageLoadErrorEvent) => void;
+  readyResetKey?: string | number;
+  webglFallbackOnImageLoadError?: boolean;
+  webglReadiness?: 'first-meaningful-paint' | 'immediate';
+  imageLoading?: Partial<ImageLoadingConfig>;
   unstable_noReconciler?: boolean;
   overlayStyle?: any;
   containerStyle?: any;
   containerProps?: any;
-  controllerConfig?: PopmotionControllerConfig;
+  controllerConfig?: PopmotionControllerConfig | PdfScrollZoneControllerConfig;
+  interactionMode?: 'popmotion' | 'pdf-scroll-zone';
   renderPreset?: PresetNames | Presets;
   hideInlineStyle?: boolean;
   homeCover?: true | false | 'start' | 'end';
@@ -1827,8 +2549,19 @@ type AtlasProps = {
   className?: string;
   background?: string;
   enableNavigator?: boolean;
+  navigatorOptions?: {
+    width?: number;
+    idleFade?: boolean;
+    idleMs?: number;
+    fadeDurationMs?: number;
+    opacityActive?: number;
+    opacityIdle?: number;
+    style?: Partial<NavigatorRendererStyle>;
+    pdfScrollZoneZoneWindow?: NavigatorZoneWindowOptions;
+  };
   htmlChildren?: ReactNode;
   children: ReactNode;
+  devTools?: boolean | DevToolsProps;
   runtimeOptions?: Partial<RuntimeOptions>;
   filters?: Partial<ViewerFilters>;
 };
@@ -1837,52 +2570,211 @@ declare const Atlas: React.FC<AtlasProps & {
   height: number;
 }>;
 //#endregion
-//#region src/modules/react-reconciler/reconciler.d.ts
-declare function applyProps(instance: any, oldProps: any, newProps: any): void;
-declare function activateEvents(world: World, props: any): void;
-declare function unmountComponentAtNode(runtime: Runtime, callback?: (runtime: any) => void): void;
-declare const ReactAtlas: {
-  render(whatToRender: any, runtime: any): void;
-  unmountComponentAtNode(runtime: Runtime, callback?: (runtime: any) => void): void;
+//#region src/modules/react-reconciler/components/AtlasAuto.d.ts
+declare const AtlasAuto: React.FC<AtlasProps & {
+  height?: number | string;
+  width?: number | string;
+  resizeHash?: number;
+  containerProps?: any;
+  aspectRatio?: number;
+}>;
+//#endregion
+//#region src/modules/react-reconciler/components/AtlasContext.d.ts
+declare const AtlasContext: React.Context<Preset | null>;
+declare const BoundsContext: React.Context<RectReadOnly | null>;
+//#endregion
+//#region src/modules/react-reconciler/components/BoxDraw.d.ts
+declare const DrawBox: React.FC<{
+  children?: ReactNode;
+  onCreate: (bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }) => void;
+}>;
+//#endregion
+//#region src/modules/react-reconciler/components/HTMLPortal.d.ts
+declare const HTMLPortal: React.FC<{
+  children?: ReactNode;
+  backgroundColor?: string;
+  interactive?: boolean;
+  relative?: boolean;
+  target?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+} & React.RefAttributes<Box>>;
+//#endregion
+//#region src/modules/react-reconciler/components/ImageService.d.ts
+declare const ImageService: React.FC<{
+  id: string;
+  width: number;
+  height: number;
+  x?: number;
+  y?: number;
+  rotation?: number;
+  scale?: number;
+  children?: ReactNode;
+  crop?: any;
+  enableSizes?: boolean;
+  enableThumbnail?: boolean;
+  renderOptions?: CompositeResourceProps;
+}>;
+//#endregion
+//#region src/objects/geometry.d.ts
+type GeometryProps = {
+  id: string;
+  target: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  open?: boolean;
+  points: [number, number][];
+  className?: string;
+  href?: string;
+  title?: string;
+  hrefTarget?: string;
+  interactive?: boolean;
+  relativeSize?: boolean;
+  relativeStyle?: boolean;
+  html?: boolean;
+  style?: GeometryStyle;
+  backgroundColor?: string;
+  border?: string;
+};
+type GeometryStyle = _GeometryStyle & {
+  ':hover'?: _GeometryStyle;
+  ':active'?: _GeometryStyle;
 };
-//#endregion
-//#region src/modules/react-reconciler/components/AtlasAuto.d.ts
-declare const AtlasAuto: React.FC<AtlasProps & {
-  height?: number | string;
-  width?: number | string;
-  resizeHash?: number;
-  containerProps?: any;
-  aspectRatio?: number;
+type _GeometryStyle = Partial<{
+  backgroundColor: string;
+  opacity: number;
+  boxShadow: string;
+  borderColor: string;
+  borderWidth: string;
+  borderStyle: string;
+  outlineColor: string;
+  outlineWidth: string;
+  outlineOffset: string;
+  outlineStyle: string;
+  border: string;
+  outline: string;
+  background: string;
 }>;
-//#endregion
-//#region src/modules/react-reconciler/components/AtlasContext.d.ts
-declare const AtlasContext: React.Context<Preset | null>;
-declare const BoundsContext: React.Context<RectReadOnly | null>;
-//#endregion
-//#region src/modules/react-reconciler/components/BoxDraw.d.ts
-declare const DrawBox: React.FC<{
-  children?: ReactNode;
-  onCreate: (bounds: {
+declare class Geometry extends BaseObject<GeometryProps> implements SpacialContent {
+  id: string;
+  type: 'spacial-content';
+  isShape: boolean;
+  points: Strand;
+  hoverEvents: boolean;
+  activeEvents: boolean;
+  display: {
     x: number;
     y: number;
+    scale: number;
     width: number;
     height: number;
-  }) => void;
-}>;
-//#endregion
-//#region src/modules/react-reconciler/components/HTMLPortal.d.ts
-declare const HTMLPortal: React.FC<{
-  children?: ReactNode;
-  backgroundColor?: string;
-  interactive?: boolean;
-  relative?: boolean;
-  target?: {
+    points: Strand;
+  };
+  boundingBox: {
     x: number;
     y: number;
     width: number;
     height: number;
+  } | null;
+  _parsed: {
+    border: {
+      id: string | null;
+      match: string[];
+    };
+    outline: {
+      id: string | null;
+      match: string[];
+    };
   };
-} & React.RefAttributes<Box>>;
+  hovering?: boolean;
+  pressing?: boolean;
+  props: {
+    href?: string;
+    hrefTarget?: string;
+    title?: string;
+    backgroundColor?: string;
+    border?: string;
+    interactive?: boolean;
+    open?: boolean;
+    className?: string;
+    relativeSize?: boolean;
+    relativeStyle?: boolean;
+    html?: boolean;
+    style?: GeometryStyle;
+    hoverStyles?: GeometryStyle;
+    pressStyles?: GeometryStyle;
+  };
+  shape: {
+    type: 'none';
+  } | {
+    type: 'polygon';
+    points: [number, number][];
+    open?: boolean;
+  };
+  constructor();
+  updateBoundingBox(): void;
+  intersects(pointer?: [number, number] | null): boolean;
+  getAllPointsAt(target: Strand, aggregate: Strand): Paint[];
+  addHover: () => void;
+  removeHover: () => void;
+  addPress: () => void;
+  removePress: () => void;
+  applyProps(props?: Partial<GeometryProps>): void;
+}
+//#endregion
+//#region src/modules/react-reconciler/components/MapGeoJSON.d.ts
+type MapGeoJSONProps = {
+  data: MapGeoJSONInput;
+  markerSize?: number;
+  markerStyle?: BoxStyle;
+  lineStyle?: GeometryStyle;
+  polygonStyle?: GeometryStyle;
+  interactive?: boolean;
+};
+declare const MapGeoJSON: React.FC<MapGeoJSONProps>;
+//#endregion
+//#region src/modules/react-reconciler/components/MapObject.d.ts
+type MapObjectProps = {
+  id?: string;
+  bounds: MapBounds;
+  x?: number;
+  y?: number;
+  width: number;
+  height: number;
+  preserveAspectRatio?: boolean;
+  scale?: number;
+  rotation?: number;
+  children?: React.ReactNode;
+};
+declare const MapObject: React.FC<MapObjectProps>;
+//#endregion
+//#region src/modules/react-reconciler/components/MapTileLayer.d.ts
+type MapTileLayerProps = {
+  id?: string;
+  tileUrlTemplate?: string;
+  tileSource?: MapTileSource;
+  subdomains?: string[];
+  tileSize?: number;
+  minZoom?: number;
+  maxZoom?: number;
+  maxQualityLevels?: number;
+  maxTilesPerLayer?: number;
+  maxTotalTiles?: number;
+  useDevicePixelRatio?: boolean;
+  renderOptions?: CompositeResourceProps;
+};
+declare const MapTileLayer: React.FC<MapTileLayerProps>;
 //#endregion
 //#region src/modules/react-reconciler/components/RegionHighlight.d.ts
 type RegionHighlightType = {
@@ -1958,22 +2850,6 @@ declare const TileSet: React.FC<{
   renderOptions?: CompositeResourceProps;
 }>;
 //#endregion
-//#region src/modules/react-reconciler/components/ImageService.d.ts
-declare const ImageService: React.FC<{
-  id: string;
-  width: number;
-  height: number;
-  x?: number;
-  y?: number;
-  rotation?: number;
-  scale?: number;
-  children?: ReactNode;
-  crop?: any;
-  enableSizes?: boolean;
-  enableThumbnail?: boolean;
-  renderOptions?: CompositeResourceProps;
-}>;
-//#endregion
 //#region src/modules/react-reconciler/hooks/use-after-frame.d.ts
 declare const useAfterFrame: (callback: (time: number) => void, deps?: any[]) => void;
 //#endregion
@@ -2041,6 +2917,51 @@ declare const useControlledAnnotationList: (initialList?: Array<{
 //#region src/modules/react-reconciler/hooks/use-frame.d.ts
 declare const useFrame: (callback: (time: number) => void, deps?: any[]) => void;
 //#endregion
+//#region src/modules/react-reconciler/hooks/use-map-geojson.d.ts
+type ProjectedMapGeoJSONShape = {
+  kind: 'shape';
+  open: boolean;
+  points: Array<[number, number]>;
+  key: string;
+  feature?: MapGeoJSONFeature;
+};
+type ProjectedMapGeoJSONPoint = {
+  kind: 'point';
+  x: number;
+  y: number;
+  key: string;
+  feature?: MapGeoJSONFeature;
+};
+type ProjectedMapGeoJSONItem = ProjectedMapGeoJSONShape | ProjectedMapGeoJSONPoint;
+declare function projectMapGeoJSON(input: MapGeoJSONInput | null | undefined, projection: {
+  projectRing: (ring: Array<[number, number]>) => Array<[number, number]>;
+  lngLatToWorld: (lng: number, lat: number) => {
+    x: number;
+    y: number;
+  };
+}): ProjectedMapGeoJSONItem[];
+type MapGeoJSONProjector = {
+  project: (input: MapGeoJSONInput | null | undefined) => ProjectedMapGeoJSONItem[];
+};
+declare function useMapGeoJSON(): MapGeoJSONProjector;
+//#endregion
+//#region src/modules/react-reconciler/hooks/use-map-projection.d.ts
+type MapProjectionContextValue = {
+  bounds: MapBounds;
+  width: number;
+  height: number;
+  mapRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  projection: MapProjection;
+};
+declare const MapProjectionContext: react0.Context<MapProjectionContextValue | null>;
+declare function useMapProjectionContext(): MapProjectionContextValue;
+declare function useMapProjection(): MapProjection;
+//#endregion
 //#region src/modules/react-reconciler/hooks/use-mode.d.ts
 declare const ModeContext: React.Context<ViewerMode>;
 declare const useMode: () => ViewerMode;
@@ -2076,10 +2997,17 @@ declare const useRuntime: () => Runtime | undefined;
 //#region src/modules/react-reconciler/hooks/use-world-event.d.ts
 declare const useWorldEvent: <Name$1 extends SupportedEventNames>(name: Name$1, cb: (e: any) => void, deps?: any[]) => void;
 //#endregion
-//#region src/modules/react-reconciler/utility/can-drag.d.ts
-declare function canDrag(ref: {
-  current: ViewerMode;
-}): boolean;
+//#region src/modules/react-reconciler/hooks/use-zone-runtime-state.d.ts
+declare const useZoneRuntimeState: (zoneId: string) => RuntimeZoneState;
+//#endregion
+//#region src/modules/react-reconciler/reconciler.d.ts
+declare function applyProps(instance: any, oldProps: any, newProps: any): void;
+declare function activateEvents(world: World, props: any): void;
+declare function unmountComponentAtNode(runtime: Runtime, callback?: (runtime: any) => void): void;
+declare const ReactAtlas: {
+  render(whatToRender: any, runtime: any): void;
+  unmountComponentAtNode(runtime: Runtime, callback?: (runtime: any) => void): void;
+};
 //#endregion
 //#region src/clean-objects/traits/evented.d.ts
 type AtlasEvent<BaseEvent extends Event> = BaseEvent & {
@@ -2133,6 +3061,11 @@ type BaseElement = {
   priority?: boolean;
 };
 type AllEvents = EventListenerProps;
+type ZoneVisibilityProps = {
+  onZoneVisible?: () => void;
+  onZoneHidden?: () => void;
+  onZoneVisibilityChange?: (visible: boolean) => void;
+};
 declare global {
   namespace JSX {
     interface IntrinsicElements {
@@ -2158,6 +3091,15 @@ declare global {
         y?: number;
         rotation?: number;
       } & AllEvents;
+      zone: BaseElement & {
+        id: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        margin?: number;
+        children?: React.ReactNode;
+      } & ZoneVisibilityProps;
       worldImage: BaseElement & {
         uri: string;
         target: any;
@@ -2215,6 +3157,28 @@ declare global {
         crop: any;
         version3?: boolean;
       } & AllEvents;
+      mapTiledImage: BaseElement & {
+        bounds: MapBounds;
+        worldWidth: number;
+        worldHeight: number;
+        zoom: number;
+        tileSize?: number;
+        scaleFactor?: number;
+        tileSource?: MapTileSource;
+        tileUrlTemplate?: string;
+        subdomains?: string[];
+      } & AllEvents;
+      ['map-tiled-image']: BaseElement & {
+        bounds: MapBounds;
+        worldWidth: number;
+        worldHeight: number;
+        zoom: number;
+        tileSize?: number;
+        scaleFactor?: number;
+        tileSource?: MapTileSource;
+        tileUrlTemplate?: string;
+        subdomains?: string[];
+      } & AllEvents;
       box: BaseElement & {
         interactive?: boolean;
         backgroundColor?: string;
@@ -2254,75 +3218,10 @@ declare global {
   }
 }
 //#endregion
-//#region src/modules/iiif/get-tiles.d.ts
-declare function getTileFromImageService(infoJsonId: string, width: number, height: number): Promise<GetTile>;
-declare function getTileFromCanvas(canvas: CanvasNormalized, thumbnailSize?: number): Promise<GetTile[]>;
-declare function getTilesFromManifest(manifest: ManifestNormalized): Promise<any[]>;
-declare function getTiles(manifestId: string): Promise<Array<GetTile>>;
-//#endregion
-//#region src/utility/stylesheet.d.ts
-declare class Stylesheet {
-  $element: HTMLStyleElement;
-  stylesheetClasses: string[];
-  activeStylesheetClasses: string[];
-  sheetsDidUpdate: boolean;
-  sheetPrefix: string;
-  stylesheetEntries: Record<string, string>;
-  constructor(options?: {
-    sheetPrefix?: string;
-  });
-  getElement(): HTMLStyleElement;
-  addStylesheet(_sheet: string): string;
-  removeStylesheet(obj: any): void;
-  clearClasses(): void;
-  didUpdateActive(): boolean;
-  updateSheet(): void;
-}
-//#endregion
-//#region src/modules/overlay-renderer/overlay-renderer.d.ts
-type OverlayRendererOptions = {
-  sheetPrefix: string;
-  box: boolean;
-  text: boolean;
-  inlineStyles: boolean;
-  triggerResize: () => void;
-  background: string;
-};
-declare class OverlayRenderer implements Renderer {
-  htmlContainer: HTMLDivElement;
-  visible: Array<Text | Box | SpacialContent>;
-  previousVisible: Array<Text | Box | SpacialContent>;
-  htmlIds: string[];
-  firstMeaningfulPaint: boolean;
-  rendererPosition: DOMRect;
-  stylesheet: Stylesheet;
-  options: OverlayRendererOptions;
-  paintTx: number;
-  zIndex: number;
-  classes: {
-    hostClassName: string;
-    interactive: string;
-    nonInteractive: string;
-  };
-  constructor(htmlContainer: HTMLDivElement, options?: Partial<OverlayRendererOptions>);
-  createHtmlHost(paint: Text | Box): void;
-  triggerResize(): void;
-  updateHtmlHost(paint: Text | Box, width?: number, height?: number): void;
-  afterFrame(world: World, delta: number, target: Strand): void;
-  afterPaintLayer(paint: SpacialContent, transform?: Strand): void;
-  beforeFrame(world: World, delta: number, target: Strand): void;
-  getPointsAt(world: World, target: Strand, aggregate: Strand, scaleFactor: number): Paint[];
-  getScale(width: number, height: number): number;
-  getViewportBounds(world: World, target: Strand, padding: number): PositionPair | null;
-  isReady(): boolean;
-  paint(paint: SpacialContent, index: number, x: number, y: number, width: number, height: number): void;
-  pendingUpdate(): boolean;
-  prepareLayer(paint: SpacialContent): void;
-  resize(width?: number, height?: number): void;
-  getRendererScreenPosition(): DOMRect;
-  finishLayer(): void;
-  reset(): void;
-}
+//#region src/modules/react-reconciler/utility/can-drag.d.ts
+declare function canDrag(ref: {
+  current: ViewerMode;
+}): boolean;
 //#endregion
 //#region src/modules/static-renderer/static-renderer.d.ts
 type StaticRendererOptions = {
@@ -2366,10 +3265,44 @@ declare class StaticRenderer implements Renderer {
 //#region src/modules/webgl-renderer/webgl-renderer.d.ts
 type WebGLRendererOptions = {
   dpi?: number;
+  onFatalImageError?: (event: AtlasWebGLFallbackEvent) => void;
+  onImageError?: (event: AtlasImageLoadErrorEvent) => void;
+  imageLoading?: Partial<ImageLoadingConfig>;
+  fallbackOnImageLoadError?: boolean;
+  readiness?: 'first-meaningful-paint' | 'immediate';
+};
+type WebGLTileRequest = {
+  key: string;
+  tileKey: string;
+  requestKey: string;
+  paint: SingleImage | TiledImage;
+  index: number;
+  url: string;
+  priority: number;
+  scale: number;
+  prefetch: boolean;
+};
+type InFlightTileLoad = {
+  tileKey: string;
+  requestKey: string;
+  consumerId: string;
+  paint: SingleImage | TiledImage;
+  index: number;
+  release: (opts?: {
+    silent?: boolean;
+  }) => void;
+};
+type ScissorRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
 };
 declare class WebGLRenderer implements Renderer {
   canvas: HTMLCanvasElement;
   gl: WebGL2RenderingContext;
+  options: WebGLRendererOptions;
+  fatalImageError?: AtlasWebGLFallbackEvent;
   program: WebGLProgram;
   fragmentShader: WebGLShader;
   vertexShader: WebGLShader;
@@ -2383,6 +3316,7 @@ declare class WebGLRenderer implements Renderer {
   uniforms: {
     resolution: WebGLUniformLocation | null;
     texture: WebGLUniformLocation | null;
+    alpha: WebGLUniformLocation | null;
   };
   buffers: {
     position: WebGLBuffer;
@@ -2390,14 +3324,67 @@ declare class WebGLRenderer implements Renderer {
   };
   rendererPosition: DOMRect;
   dpi: number;
+  maxConcurrentTasks: number;
+  maxPrefetchPerFrame: number;
+  imageLoadingConfig: ImageLoadingConfig;
+  imageRequestPool: ImageRequestPool;
+  framePrefetchCount: number;
+  loadingCount: number;
+  hasTilesFading: boolean;
+  firstMeaningfulPaint: boolean;
+  frameSawFastPathCandidate: boolean;
+  requiresRepaint: boolean;
+  tileRequestQueue: WebGLTileRequest[];
+  queuedTileRequestKeys: Set<string>;
+  inFlightImageLoads: Map<string, InFlightTileLoad>;
+  requiredTileKeys: Set<string>;
+  requiredPrefetchTileKeys: Set<string>;
+  requestGeneration: number;
+  frameCounter: number;
+  pendingTileReveals: Map<string, {
+    paint: SingleImage | TiledImage;
+    index: number;
+    queuedFrame: number;
+  }>;
+  activeLayerScissorRect: ScissorRect | undefined;
+  onContextLost: (event: Event) => void;
   constructor(canvas: HTMLCanvasElement, options?: WebGLRendererOptions);
+  private isImmediateReadiness;
+  emitFatalImageError(event: Omit<AtlasWebGLFallbackEvent, 'from' | 'to'>): void;
   resize(): void;
   isReady(): boolean;
-  beforeFrame(world: World, delta: number, target: Strand): void;
+  beforeFrame(world: World, delta: number, target: Strand, options: HookOptions): void;
   lastResize: number;
-  prepareLayer(paint: SpacialContent): void;
+  private getCompositeRenderOptions;
+  private shouldClipLayerToBounds;
+  private getBoundsFromPoints;
+  private toScissorRect;
+  prepareLayer(paint: SpacialContent, points?: Strand): void;
   createTextureHost(paint: ImageTexture | Box): void;
   createImageHost(paint: SingleImage | TiledImage): void;
+  removeLoadingIndex(paint: SpacialContent, index: number): void;
+  private getTileKey;
+  private nextRequestKey;
+  private getTileState;
+  private setTileState;
+  private markTileRequired;
+  private isTileRequired;
+  private shouldSkipFade;
+  private enqueueTileReveal;
+  private flushTileRevealBatch;
+  private emitImageError;
+  private releaseInFlightTileLoad;
+  private pruneStaleTileWork;
+  private getPrefetchRadius;
+  private isLayerActive;
+  private shouldDrawLayer;
+  private getFadeAlpha;
+  private getTileRequestKey;
+  private getCompositeOwner;
+  private compareCompositeLoadPriority;
+  private enqueueTileRequest;
+  private schedulePrefetchNeighbours;
+  private processTileQueue;
   paint(paint: SpacialContent, index: number, x: number, y: number, width: number, height: number): void;
   afterPaintLayer(paint: SpacialContent, transform?: Strand): void;
   pendingUpdate(): boolean;
@@ -2418,11 +3405,12 @@ declare class WebGLRenderer implements Renderer {
   getRectangle(x: number, y: number, width: number, height: number): Float32Array<ArrayBufferLike>;
   getRendererScreenPosition(): DOMRect;
   finishLayer(): void;
+  resetReadyState(): void;
   reset(): void;
 }
 //#endregion
 //#region src/utility/merge-styles.d.ts
 declare function mergeStyles(defaultStyle?: BoxStyle, style?: BoxStyle): BoxStyle | undefined;
 //#endregion
-export { AbstractObject, AbstractWorldObject, AllEvents, Atlas, AtlasAuto, AtlasContext, AtlasProps, BoundsContext, Box, BoxProps, BoxStyle, BrowserEventManager, BrowserEventManagerOptions, CanvasRenderer, CanvasRendererOptions, CompositeRenderer, CompositeResource, CompositeResourceProps, DebugRenderer, DefaultPresetName, DefaultPresetOptions, DisplayData, DrawBox, EasingFunction, EasingFunctionNames, Geometry, GeometryProps, GeometryStyle, GetTile, GridBuilder, HTMLPortal, HookOptions, ImageBuffer, ImageService, ImageTexture, ImageTextureProps, ModeContext, ModeProvider, OverlayRenderer, OverlayRendererOptions, Paint, Paintable, PointerEvents, PopmotionControllerConfig, Position, PositionPair, Preset, PresetArgs, PresetNames, Presets, Projection, ReactAtlas, RegionHighlight, RegionHighlightProps, Renderer, ResizeWorldItem, Runtime, RuntimeController, RuntimeHooks, RuntimeOptions, Scaled, SingleImage, SpacialContent, SpacialSize, StaticPresetName, StaticPresetOptions, StaticRenderer, SupportedEventMap, SupportedEventNames, SupportedEvents, Text, TextProps, TextWrapperOptions, TileSet, TiledImage, UpdateTextureFunction, Viewer, ViewerFilters, ViewerMode, ViewingDirection, WebGLRenderer, WebGLRendererOptions, World, WorldObject, WorldTime, Zone, ZoneConfig, ZoneInterface, activateEvents, applyProps, bounceOut, canDrag, createDefaultEventMap, defaultConfig, defaultPreset, easingFunctions, fromImage, getId, getTileFromCanvas, getTileFromImageService, getTiles, getTilesFromManifest, mergeStyles, popmotionController, presets, staticPreset, supportedEventAttributes, supportedEventMap, unmountComponentAtNode, useAfterFrame, useAfterPaint, useAtlas, useAtlasImage, useBeforeFrame, useCanvas, useControlledAnnotationList, useFrame, useMode, useResizeWorldItem, useRuntime, useWorldEvent };
+export { AbstractObject, AbstractWorldObject, AllEvents, Atlas, AtlasAuto, AtlasContext, type AtlasImageLoadErrorEvent, AtlasImageLoadErrorSeverity, AtlasImageLoadRenderer, AtlasProps, AtlasReadyEvent, AtlasReadyRenderer, AtlasReadyResetReason, type AtlasWebGLFallbackEvent, type AtlasWebGLFallbackReason, BoundsContext, Box, BoxProps, BoxStyle, BrowserEventManager, BrowserEventManagerOptions, CanvasRenderer, CanvasRendererOptions, CompositeRenderer, CompositeResource, CompositeResourceProps, DEFAULT_OSM_TILE_TEMPLATE, DebugRenderer, DefaultPresetName, DefaultPresetOptions, DevTools, DevToolsProps, DevToolsTab, DisplayData, DrawBox, EasingFunction, EasingFunctionNames, GeoJSONLineString, GeoJSONMultiLineString, GeoJSONMultiPoint, GeoJSONMultiPolygon, GeoJSONPoint, GeoJSONPolygon, Geometry, GeometryProps, GeometryStyle, GetTile, GridBuilder, HTMLPortal, HookOptions, ImageBuffer, ImageLoadingConfig, ImageLoadingConfigOverrides, ImageService, ImageTexture, ImageTextureProps, LngLatPoint, MAX_MERCATOR_LATITUDE, MapBounds, MapGeoJSON, MapGeoJSONFeature, MapGeoJSONFeatureCollection, MapGeoJSONGeometry, MapGeoJSONInput, MapGeoJSONProjector, MapGeoJSONProps, MapObject, MapObjectProps, MapProjection, MapProjectionContext, MapProjectionContextValue, MapTileCoordinate, MapTileGrid, MapTileGridCoverage, MapTileLayer, MapTileLayerProps, MapTileSource, MapTileUrlContext, MapTiledImage, MapTiledImageProps, ModeContext, ModeProvider, NavigatorDebugEvent, NavigatorRenderer, NavigatorRendererOptions, NavigatorRendererStyle, NavigatorTransform, NavigatorWorldRegion, NavigatorWorldRegionOptions, NavigatorZoneWindowOptions, OverlayRenderer, OverlayRendererOptions, Paint, Paintable, PdfScrollZoneControllerConfig, PointerEvents, PopmotionControllerConfig, Position, PositionPair, Preset, PresetArgs, PresetNames, Presets, ProjectedMapGeoJSONItem, ProjectedMapGeoJSONPoint, ProjectedMapGeoJSONShape, Projection, ReactAtlas, RegionHighlight, RegionHighlightProps, Renderer, ResizeWorldItem, Runtime, RuntimeController, RuntimeDebugEvent, RuntimeFrameEndEvent, RuntimeFrameStartEvent, RuntimeHooks, RuntimeOptions, RuntimePaintEvent, RuntimeZoneState, Scaled, SingleImage, SpacialContent, SpacialSize, StaticPresetName, StaticPresetOptions, StaticRenderer, SupportedEventMap, SupportedEventNames, SupportedEvents, Text, TextProps, TextWrapperOptions, TileLoadingState, TileSet, TiledImage, UpdateTextureFunction, Viewer, ViewerFilters, ViewerMode, ViewingDirection, WarpAdapter, WarpAdapterController, WarpAdapterHooks, WarpControlPoint, WarpTransformationType, WarpUpdateReason, WebGLRenderer, WebGLRendererOptions, World, WorldDebugEvent, WorldObject, WorldPoint, WorldPointerDebugEvent, WorldRect, WorldTime, WorldTouchDebugEvent, WorldTriggerDebugEvent, Zone, ZoneConfig, ZoneInterface, ZoneResolvedConfig, activateEvents, applyProps, bounceOut, canDrag, clampMercatorLatitude, createDefaultEventMap, createFiniteTileGrid, createMapProjection, createWarpAdapterController, defaultConfig, defaultPreset, easingFunctions, estimateFiniteTileGridCoverage, fromImage, getId, getNavigatorVisibleZoneIdSet, getNavigatorWorldRegion, getNavigatorWorldTransform, getRetryDelayMs, getSubdomainForTile, getTileFromCanvas, getTileFromImageService, getTiles, getTilesFromManifest, latToTileY, latitudeToMercatorY, lngToTileX, longitudeToMercatorX, mercatorXToLongitude, mercatorYToLatitude, mergeStyles, navigatorToWorldPoint, pdfScrollZoneController, popmotionController, presets, projectMapGeoJSON, resolveImageLoadingConfig, resolveTileTemplate, resolveTileUrl, staticPreset, supportedEventAttributes, supportedEventMap, tileXToLng, tileYToLat, unmountComponentAtNode, useAfterFrame, useAfterPaint, useAtlas, useAtlasImage, useBeforeFrame, useCanvas, useControlledAnnotationList, useFrame, useMapGeoJSON, useMapProjection, useMapProjectionContext, useMode, useResizeWorldItem, useRuntime, useWorldEvent, useZoneRuntimeState, validateMapBounds };
 //# sourceMappingURL=index.d.cts.map