rustial-engine 1.0.0

#![warn(missing_docs)]
#![cfg_attr(not(test), deny(clippy::unwrap_used))]
// ---------------------------------------------------------------------------
//! # rustial-engine
//!
//! Framework-agnostic 2.5D map engine for the [rustial](https://crates.io/crates/rustial)
//! geospatial library.
//!
//! This crate owns the **core logic** of the map: camera control, layer
//! management, tile fetching, terrain elevation, vector tessellation,
//! 3D model placement, and the per-frame update loop that produces a
//! [`FrameOutput`] consumed by renderers.
//!
//! ## Design principles
//!
//! | Principle | How it is enforced |
//! |-----------|--------------------|
//! | **No GPU code** | Zero dependency on `wgpu`, `bevy`, or any graphics API. Renderers live in separate crates. |
//! | **No windowing** | No `winit`, no event loop. Input arrives via [`InputEvent`] values pushed by the host. |
//! | **No async runtime** | Tile I/O uses a synchronous send/poll pattern ([`HttpClient`], [`TileSource`]) so the engine can be embedded anywhere. |
//! | **Thread-safe** | All public types are `Send + Sync`. [`MapState`] is designed to sit behind an `RwLock`. |
//! | **Precision** | Coordinates are `f64` (meters, WGS-84). Camera-relative rendering avoids f32 jitter at large Mercator values. |
//!
//! ## Module map
//!
//! | Module / File | Visibility | Purpose |
//! |---------------|------------|---------|
//! | [`camera`] | private | [`Camera`], [`CameraConstraints`], [`CameraController`], [`CameraMode`] |
//! | [`camera_animator`] | private | [`CameraAnimator`] -- smooth zoom, rotation, and pan momentum |
//! | [`geometry`] | private | OGC-style geometry model ([`Feature`], [`Geometry`], [`Polygon`], ...) |
//! | [`input`] | private | [`InputEvent`] enum (Pan, Zoom, Rotate, Resize) |
//! | [`interaction`] | **public** | Canonical interaction event and target types layered on top of picking |
//! | [`io`] | **public** | [`HttpClient`], [`HttpRequest`], [`HttpResponse`], [`SharedHttpClient`], [`FetchPool`], [`DiskCache`]* |
//! | [`layer`] | private | [`Layer`] trait + [`LayerId`] |
//! | [`layers`] | **public** | [`LayerStack`], [`TileLayer`], [`VectorLayer`], [`ModelLayer`] |
//! | [`map_state`] | private | [`MapState`], [`FrameOutput`] |
//! | [`models`] | **public** | [`ModelMesh`], [`ModelInstance`], [`AltitudeMode`] |
//! | [`simplify`] | private | Douglas-Peucker line simplification |
//! | [`terrain`] | **public** | [`TerrainManager`], [`TerrainConfig`], elevation sources, mesh building |
//! | [`tessellator`] | private | Polygon triangulation + thick-line stroking |
//! | [`tile_cache`] | private | LRU tile cache |
//! | [`tile_manager`] | private | Tile request scheduling with parent-tile fallback |
//! | [`tile_request_coordinator`] | private | Cross-source tile request coordination and global budget allocation |
//! | [`tile_source`] | private | [`TileSource`] trait, [`TileData`], [`TileDecoder`] |
//! | [`tile_source_http`] | private | [`HttpTileSource`] (URL-template HTTP fetcher) |
//! | [`geojson`] | **public*** | GeoJSON parser (behind the `geojson` feature flag) |
//! | [`style`] | **public** | Map style system -- layer configuration, paint, and update logic |
//! | [`symbols`] | **public** | Symbol and cartography foundation -- sprite atlases, placement, and collision |
//!
//! *Items marked with `*` require a Cargo feature flag.
//!
//! ## Feature flags
//!
//! | Flag | Default | Description |
//! |------|---------|-------------|
//! | `geojson` | off | Enables the GeoJSON parser ([`parse_geojson`]) and its `serde`/`serde_json` dependencies. |
//! | `shapefile` | off | Enables the Shapefile parser ([`parse_shapefile`]) and its `shapefile` dependency. |
//! | `gltf` | off | Enables [`ModelMesh::from_gltf`] for GLTF/GLB 3D model loading. |
//! | `obj` | off | Enables [`ModelMesh::from_obj`] for Wavefront OBJ 3D model loading. |
//! | `disk-cache` | off | Enables [`DiskCache`] for flat-file on-disk tile persistence. |
//!
//! ## Re-exported dependency
//!
//! This crate depends on [`glam`](https://docs.rs/glam) (workspace version)
//! for matrix and vector math. The `glam` types appear in public signatures
//! (e.g. [`FrameOutput::view_projection`] is a `glam::DMat4`). Downstream
//! crates that interact with these values should use the same `glam` version
//! declared in the workspace `Cargo.toml`.
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// Modules
// ---------------------------------------------------------------------------

#[path = "math/bounds.rs"]
mod bounds;
#[path = "math/coord.rs"]
mod coord;
#[path = "math/elevation.rs"]
mod elevation;
#[path = "math/ellipsoid.rs"]
mod ellipsoid;
#[path = "math/equirectangular.rs"]
mod equirectangular;
#[path = "math/frustum.rs"]
mod frustum;
#[path = "math/geodesic.rs"]
mod geodesic;
#[path = "math/globe.rs"]
mod globe;
#[path = "math/mercator.rs"]
mod mercator;
#[path = "math/projection.rs"]
mod projection;
#[path = "math/tile.rs"]
mod tile;
#[path = "math/vertical_perspective.rs"]
mod vertical_perspective;

mod camera;
mod camera_animator;
mod camera_projection;
pub(crate) mod geo_wrap;
pub mod async_data;
pub mod cluster;
pub mod expression;
#[cfg(feature = "geojson")]
pub mod geojson;
#[cfg(feature = "shapefile")]
pub mod shapefile_parser;
mod geometry;
pub mod event_emitter;
pub mod gesture;
pub mod geometry_ops;
pub mod image_compare;
mod input;
pub mod interaction;
pub mod interaction_manager;
pub mod io;
mod layer;
pub mod layers;
mod map_state;
pub mod models;
pub mod picking;
pub mod query;
pub mod regression;
pub mod shapes;
mod simplify;
mod streamed_payload;
pub mod terrain;
mod tessellator;
mod tile_cache;
mod tile_lifecycle;
mod tile_manager;
mod tile_source;
mod tile_source_http;
mod tile_source_vector_http;
mod pooled_tile_source;
mod tile_request_coordinator;
pub mod tilejson;
pub mod mvt;
pub mod style;
#[cfg(feature = "style-json")]
pub mod style_json;
pub mod symbols;
pub mod visualization;
pub mod loading_placeholder;

pub mod precision_invariants;

#[cfg(test)]
mod support_contract;
#[cfg(test)]
mod visualization_contract;

pub extern crate self as rustial_math;

// ---------------------------------------------------------------------------
// Re-exports -- Math primitives
// ---------------------------------------------------------------------------

pub use bounds::{GeoBounds, WorldBounds};
pub use coord::{GeoCoord, WorldCoord};
pub use elevation::ElevationGrid;
pub use ellipsoid::Ellipsoid;
pub use equirectangular::Equirectangular;
pub use frustum::{
    Frustum, Plane, PLANE_BOTTOM, PLANE_FAR, PLANE_LEFT, PLANE_NEAR, PLANE_RIGHT, PLANE_TOP,
};
pub use geodesic::{
    GeodesicResult, VincentyConvergenceError, geodesic_destination, geodesic_destination_on,
    geodesic_distance, geodesic_distance_on,
};
pub use globe::Globe;
pub use mercator::WebMercator;
pub use projection::Projection;
pub use tile::{
    CoveringCamera, CoveringTilesOptions, FlatTileSelectionConfig, FlatTileView, MAX_ZOOM,
    TileCoord, TileId, geo_to_tile, geo_to_tile_checked, tile_bounds_world, tile_to_geo,
    tile_xy_to_geo, visible_tiles, visible_tiles_checked, visible_tiles_covering,
    visible_tiles_flat_view, visible_tiles_flat_view_capped,
    visible_tiles_flat_view_capped_with_config, visible_tiles_flat_view_refined_capped,
    visible_tiles_flat_view_refined_capped_with_config, visible_tiles_flat_view_with_config,
    visible_tiles_frustum, visible_tiles_lod,
};
pub use vertical_perspective::VerticalPerspective;

// ---------------------------------------------------------------------------
// Re-exports -- Camera & Input
// ---------------------------------------------------------------------------

pub use camera::{Camera, CameraConstraints, CameraController, CameraMode};
pub use camera_animator::{CameraAnimator, EaseToOptions, FlyToOptions};
pub use camera_projection::CameraProjection;
pub use input::{InputEvent, TouchContact, TouchPhase};
pub use interaction::{
    InteractionButton, InteractionEvent, InteractionEventKind, InteractionModifiers,
    InteractionTarget, InteractionTargetKind, PointerKind, ScreenPoint,
};
pub use interaction_manager::{InteractionConfig, InteractionManager};

// ---------------------------------------------------------------------------
// Re-exports -- Layer system
// ---------------------------------------------------------------------------

pub use layer::{Layer, LayerId, LayerKind};
pub use layers::{BackgroundLayer, CallbackFrameProvider, CircleInstanceData, DynamicImageOverlayLayer, FrameData, FrameProvider, FrameProviderFactory, HillshadeLayer, HillshadeParams, ImageOverlayData, ImageOverlayLayer, LayerStack, ModelLayer, PatternImage, TileLayer, VectorLayer, VectorMeshData, VectorRenderMode, VectorStyle};
pub use style::{
    BackgroundStyleLayer, CircleStyleLayer, FillExtrusionStyleLayer, FillStyleLayer,
    FromFeatureStateProperty, GeoJsonSource, HeatmapStyleLayer, HillshadeStyleLayer,
    LineStyleLayer, MapStyle, ModelSource, ModelStyleLayer, RasterSource, RasterStyleLayer,
    StyleDocument, StyleError, StyleEvalContext, StyleEvalContextFull, StyleLayer, StyleLayerId,
    StyleLayerMeta, StyleProjection, StyleSource, StyleSourceId, StyleSourceKind, StyleValue,
    SymbolStyleLayer, TerrainSource, VectorStyleLayer, VectorTileSource, ImageSource,
    VideoSource, CanvasSource,
    // Fog / atmosphere configuration.
    FogConfig, ComputedFog, atmospheric_clear_color, compute_fog,
    // Feature-state-driven style resolution helpers.
    circle_style_with_state, fill_extrusion_style_with_state, fill_style_with_state,
    heatmap_style_with_state, line_style_with_state, symbol_style_with_state,
    vector_style_with_state,
};
pub use expression::{
    Expression, ExprEvalContext, NumericExpression, StringExpression, BoolExpression,
};
#[cfg(feature = "style-json")]
pub use style_json::{
    parse_style_json, StyleSourceRegistry, StyleSpecDocument, StyleSpecError,
    StyleSpecLayer, StyleSpecLayerType, StyleSpecSource, StyleSpecSourceType,
    StyleSpecProjection, StyleSpecProjectionType, StyleSpecTerrain,
};

// ---------------------------------------------------------------------------
// Re-exports -- Map state & frame output
// ---------------------------------------------------------------------------

pub use map_state::{
    FitBoundsOptions, FitBoundsPadding, FrameOutput, MapState, TilePipelineDiagnostics,
};
pub use event_emitter::{EventEmitter, ListenerId};
pub use loading_placeholder::{LoadingPlaceholder, PlaceholderGenerator, PlaceholderStyle};
pub use regression::{
    TilePipelineRegressionEvaluation, TilePipelineRegressionParseError,
    TilePipelineRegressionSample, TilePipelineRegressionSummary,
    TilePipelineRegressionThresholds, TilePipelineRegressionViolation,
    TILE_PIPELINE_REGRESSION_CSV_HEADER,
};

// ---------------------------------------------------------------------------
// Re-exports -- Geometry & vector data
// ---------------------------------------------------------------------------

pub use geometry::{
    Feature, FeatureCollection, Geometry, LineString, MultiLineString, MultiPoint, MultiPolygon,
    Point, Polygon, PropertyValue,
};

pub use cluster::{ClusterOptions, PointCluster};
pub use gesture::GestureRecognizer;

#[cfg(feature = "geojson")]
pub use geojson::{parse_geojson, GeoJsonError};

#[cfg(feature = "shapefile")]
pub use shapefile_parser::{parse_shapefile, ShapefileError};

pub use simplify::{simplify_douglas_peucker, simplify_polygon_ring};
pub use tessellator::{stroke_line, stroke_line_styled, StrokeLineResult, triangulate_polygon, triangulate_polygon_with_holes};
pub use geometry_ops::{
    bearing, geometry_bbox, geometry_centroid, initial_bearing,
    interpolate_great_circle, linestring_length, polygon_area, ring_area,
};

// ---------------------------------------------------------------------------
// Re-exports -- Tile engine
// ---------------------------------------------------------------------------

pub use tile_cache::{TileCache, TileCacheEntry, TileCacheStats};
pub use tile_lifecycle::{
    TileLifecycleDiagnostics, TileLifecycleEvent, TileLifecycleEventKind,
    TileLifecycleRecord,
};
pub use tile_manager::{
    TileManager, TileManagerCounters, TilePixelRect, TileSelectionConfig, TileSelectionStats,
    TileTextureRegion, VisibleTile, VisibleTileSet,
};
pub use tile_request_coordinator::{
    CoordinatorConfig, CoordinatorStats, SourcePriority, TileRequestCoordinator,
};
pub use tile_source::{
    DecodedImage, RasterMipChain, RasterMipLevel, RawVectorPayload, RevalidationHint, TileData,
    TileDecoder, TileError, TileFreshness, TileResponse, TileSource, TileSourceDiagnostics,
    TileSourceFailureDiagnostics, VectorTileData,
};
pub use tile_source_http::HttpTileSource;
pub use tile_source_vector_http::HttpVectorTileSource;
pub use pooled_tile_source::{
    PooledRasterTileSourceConfig, PooledTileSource, DEFAULT_RASTER_TILE_URL,
    DEFAULT_RASTER_TILE_USER_AGENT,
};

// ---------------------------------------------------------------------------
// Re-exports -- I/O
// ---------------------------------------------------------------------------

pub use io::{FetchPool, HttpClient, HttpRequest, HttpResponse, SharedHttpClient};

#[cfg(all(feature = "disk-cache", not(target_arch = "wasm32")))]
pub use io::{DiskCache, DiskCacheError};

// ---------------------------------------------------------------------------
// Re-exports -- Terrain & elevation
// ---------------------------------------------------------------------------

pub use terrain::{
    expand_with_clamped_border, interior_dims, patch_border_edge, patch_changed_tiles,
    BackfillState, NEIGHBOR_OFFSETS,
    build_terrain_descriptor, build_terrain_descriptor_with_source, build_terrain_mesh,
    build_terrain_mesh_with_source, elevation_region_in_texture_space, materialize_terrain_mesh,
    prepare_hillshade_raster, skirt_height, ElevationSource, ElevationSourceDiagnostics,
    ElevationSourceFailureDiagnostics, FlatElevationSource, HttpElevationSource,
    PreparedHillshadeRaster, QuantizedMeshSource, TerrainConfig,
    TerrainDiagnostics, TerrainElevationTexture, TerrainError, TerrainManager, TerrainMeshData,
    TerrainRgbEncoding,
};

// ---------------------------------------------------------------------------
// Re-exports -- 3D models
// ---------------------------------------------------------------------------

pub use models::{AltitudeMode, ModelInstance, ModelLoadError, ModelMesh};

// ---------------------------------------------------------------------------
// Re-exports -- Symbols and cartography foundation
// ---------------------------------------------------------------------------

pub use symbols::{
    GlyphAtlas, GlyphAtlasEntry, GlyphKey, GlyphProvider, GlyphQuad, GlyphRaster, ImageManager,
    PlacedSymbol, ProceduralGlyphProvider, SpriteImage, SpriteSheet,
    SymbolAnchor, SymbolAssetDependencies, SymbolAssetRegistry, SymbolCandidate,
    SymbolCollisionBox, SymbolPlacementConfig, SymbolPlacementEngine,
    SymbolIconTextFit, SymbolPlacement, SymbolTextJustify, SymbolTextTransform,
    SymbolWritingMode,
    layout_symbol_glyphs,
    cross_tile_index::{CrossTileSymbolIndex, SymbolCandidateEntry},
};

// ---------------------------------------------------------------------------
// Re-exports -- Query API
// ---------------------------------------------------------------------------

pub use query::{
    FeatureState, FeatureStateId, GeoBBox, QueriedFeature, QueryOptions,
    geometry_intersects_bbox,
};

// ---------------------------------------------------------------------------
// Re-exports -- Picking API
// ---------------------------------------------------------------------------

pub use picking::{
    HitCategory, HitProvenance, NonPickableLayerKind, PickHit, PickOptions, PickQuery,
    PickResult, PickableLayerKind,
};

// ---------------------------------------------------------------------------
// Re-exports -- Visualization primitives
// ---------------------------------------------------------------------------

pub use visualization::{
    ColorRamp, ColorStop, ColumnInstance, ColumnInstanceSet, ExtrusionParams,
    GeoGrid, GridExtrusionLayer, GridScalarLayer, InstancedColumnLayer,
    LabeledStop, LegendSpec, NormalizationMode, PointCloudLayer, PointInstance,
    PointInstanceSet, ScalarField2D, VisualizationOverlay,
};

// ---------------------------------------------------------------------------
// Re-exports -- Image comparison (cross-renderer parity)
// ---------------------------------------------------------------------------

pub use image_compare::{compute_rmse, count_differing_pixels, differing_pixel_fraction};

// ---------------------------------------------------------------------------
// Re-exports -- TileJSON metadata
// ---------------------------------------------------------------------------

pub use tilejson::{TileJson, TileJsonError, TileScheme, VectorLayerMeta};
#[cfg(feature = "style-json")]
pub use tilejson::{parse_tilejson, parse_tilejson_value};

// ---------------------------------------------------------------------------
// Re-exports -- MVT decoder
// ---------------------------------------------------------------------------

pub use mvt::{decode_mvt, DecodedVectorTile, MvtDecodeOptions, MvtError};

// ---------------------------------------------------------------------------
// Re-exports -- Async data pipeline
// ---------------------------------------------------------------------------

pub use async_data::{
    DataTaskPool, DataTaskResultReceiver, ThreadDataTaskPool,
    TerrainTaskInput, TerrainTaskOutput, TerrainCacheKey,
    VectorTaskInput, VectorTaskOutput, VectorCacheKey,
    VectorBucketKey, partition_features_by_tile,
    MvtDecodeOutput,
    AsyncVisualizationPipeline, VisualizationTaskOutput,
};

// ---------------------------------------------------------------------------
// Compile-time Send + Sync assertions
//
// Every public data type that downstream code may share across threads
// must be Send + Sync.  These zero-cost assertions catch regressions at
// compile time rather than in production.
// ---------------------------------------------------------------------------

#[allow(dead_code)]
const _: () = {
    fn assert_send_sync<T: Send + Sync>() {}
    fn assertions() {
        // Math primitives
        assert_send_sync::<GeoCoord>();
        assert_send_sync::<WorldCoord>();
        assert_send_sync::<GeoBounds>();
        assert_send_sync::<WorldBounds>();
        assert_send_sync::<Ellipsoid>();
        assert_send_sync::<Frustum>();
        assert_send_sync::<Plane>();
        assert_send_sync::<TileId>();
        assert_send_sync::<TileCoord>();
        assert_send_sync::<FlatTileSelectionConfig>();
        assert_send_sync::<FlatTileView>();
        assert_send_sync::<CoveringCamera>();
        assert_send_sync::<CoveringTilesOptions>();
        assert_send_sync::<GeodesicResult>();
        assert_send_sync::<ElevationGrid>();
        assert_send_sync::<VincentyConvergenceError>();
        assert_send_sync::<WebMercator>();
        assert_send_sync::<Equirectangular>();
        assert_send_sync::<Globe>();
        assert_send_sync::<VerticalPerspective>();

        // Camera & input
        assert_send_sync::<Camera>();
        assert_send_sync::<CameraConstraints>();
        assert_send_sync::<CameraMode>();
        assert_send_sync::<CameraProjection>();
        assert_send_sync::<CameraAnimator>();
        assert_send_sync::<InputEvent>();

        // Layer system
        assert_send_sync::<BackgroundLayer>();
        assert_send_sync::<HillshadeLayer>();
        assert_send_sync::<LayerId>();
        assert_send_sync::<LayerStack>();
        assert_send_sync::<TileLayer>();
        assert_send_sync::<VectorLayer>();
        assert_send_sync::<ModelLayer>();
        assert_send_sync::<VectorStyle>();
        assert_send_sync::<VectorMeshData>();
        assert_send_sync::<StyleDocument>();
        assert_send_sync::<MapStyle>();

        // Map state
        assert_send_sync::<MapState>();
        assert_send_sync::<FrameOutput>();
        assert_send_sync::<FeatureState>();
        assert_send_sync::<FeatureStateId>();
        assert_send_sync::<QueriedFeature>();
        assert_send_sync::<QueryOptions>();

        // Picking
        assert_send_sync::<PickQuery>();
        assert_send_sync::<PickOptions>();
        assert_send_sync::<PickHit>();
        assert_send_sync::<PickResult>();

        // Geometry
        assert_send_sync::<Feature>();
        assert_send_sync::<FeatureCollection>();
        assert_send_sync::<Geometry>();
        assert_send_sync::<PropertyValue>();

        // Tile engine
        assert_send_sync::<TileCache>();
        assert_send_sync::<TileCacheEntry>();
        assert_send_sync::<TileCacheStats>();
        assert_send_sync::<TileManager>();
        assert_send_sync::<TileManagerCounters>();
        assert_send_sync::<TilePixelRect>();
        assert_send_sync::<TileSelectionConfig>();
        assert_send_sync::<TileSelectionStats>();
        assert_send_sync::<TilePipelineDiagnostics>();
        assert_send_sync::<TileTextureRegion>();
        assert_send_sync::<VisibleTile>();
        assert_send_sync::<VisibleTileSet>();
        assert_send_sync::<DecodedImage>();
        assert_send_sync::<RasterMipChain>();
        assert_send_sync::<RasterMipLevel>();
        assert_send_sync::<TileData>();
        assert_send_sync::<TileError>();
        assert_send_sync::<TileSourceDiagnostics>();
        assert_send_sync::<PooledTileSource>();
        assert_send_sync::<VectorTileData>();

        // TileJSON
        assert_send_sync::<TileJson>();
        assert_send_sync::<TileJsonError>();
        assert_send_sync::<TileScheme>();
        assert_send_sync::<VectorLayerMeta>();

        // MVT
        assert_send_sync::<MvtDecodeOptions>();
        assert_send_sync::<MvtError>();

        // I/O
        assert_send_sync::<FetchPool>();
        assert_send_sync::<HttpRequest>();
        assert_send_sync::<HttpResponse>();

        // Terrain
        assert_send_sync::<TerrainConfig>();
        assert_send_sync::<TerrainError>();
        assert_send_sync::<TerrainManager>();
        assert_send_sync::<TerrainMeshData>();
        assert_send_sync::<PreparedHillshadeRaster>();
        assert_send_sync::<TerrainRgbEncoding>();
        assert_send_sync::<TerrainSource>();
        assert_send_sync::<VectorTileSource>();
        assert_send_sync::<ImageSource>();
        assert_send_sync::<VideoSource>();
        assert_send_sync::<CanvasSource>();
        assert_send_sync::<GlyphAtlas>();
        assert_send_sync::<GlyphAtlasEntry>();
        assert_send_sync::<GlyphKey>();
        assert_send_sync::<GlyphRaster>();
        assert_send_sync::<ImageManager>();
        assert_send_sync::<PlacedSymbol>();
        assert_send_sync::<ProceduralGlyphProvider>();
        assert_send_sync::<SpriteImage>();
        assert_send_sync::<SpriteSheet>();
        assert_send_sync::<SymbolAnchor>();
        assert_send_sync::<SymbolAssetDependencies>();
        assert_send_sync::<SymbolAssetRegistry>();
        assert_send_sync::<SymbolCandidate>();
        assert_send_sync::<SymbolCollisionBox>();
        assert_send_sync::<SymbolPlacementConfig>();
        assert_send_sync::<SymbolPlacementEngine>();
        assert_send_sync::<SymbolWritingMode>();

        // Models
        assert_send_sync::<ModelInstance>();
        assert_send_sync::<ModelMesh>();
        assert_send_sync::<AltitudeMode>();
        assert_send_sync::<GeoJsonSource>();
        assert_send_sync::<ModelSource>();

        // Visualization
        assert_send_sync::<GeoGrid>();
        assert_send_sync::<ScalarField2D>();
        assert_send_sync::<ColorRamp>();
        assert_send_sync::<ColorStop>();
        assert_send_sync::<LegendSpec>();
        assert_send_sync::<ColumnInstance>();
        assert_send_sync::<ColumnInstanceSet>();
        assert_send_sync::<PointInstance>();
        assert_send_sync::<PointInstanceSet>();
        assert_send_sync::<GridScalarLayer>();
        assert_send_sync::<GridExtrusionLayer>();
        assert_send_sync::<InstancedColumnLayer>();
        assert_send_sync::<PointCloudLayer>();
        assert_send_sync::<VisualizationOverlay>();
    }
};