Struct Metadata 

pub struct Metadata {

    pub name: String,
    pub description: String,
    pub attribution: String,
    pub bounds: BoundingBox,
    pub time_range: TimeRange,
    pub min_zoom: u8,
    pub max_zoom: u8,
    pub tile_count: u64,
    pub feature_count: u64,
    pub layers: Vec<String>,
    pub properties: BTreeMap<String, String>,
    pub temporal_bucket_ms: u64,
    pub summary_tier: Option<SummaryTier>,
    pub temporal_lod: Option<Vec<TemporalLodLevel>>,
    pub heatmap_domain: Option<HeatmapDomain>,
    pub style_hints: Option<StyleHints>,
}

Archive metadata.

Stored in the archive as UTF-8 JSON — small, human-inspectable, and versionless thanks to serde’s field defaults.

Fields

name: String

Archive name

description: String

Description

attribution: String

Attribution text

bounds: BoundingBox

Bounding box

time_range: TimeRange

Time range

min_zoom: u8

Minimum zoom level

max_zoom: u8

Maximum zoom level

tile_count: u64

Total number of tiles. For packed manifests this is derived from the directory at write time (PackWriter::finalize); caller-set values are ignored there.

feature_count: u64

Total feature records summed across tiles — a feature that lands in N tiles (zoom pyramid, clipping, temporal LOD) counts N times. Matches stt-validate’s feature_count_index; derived from the directory at write time for packed manifests.

layers: Vec<String>

Layer names

properties: BTreeMap<String, String>

Custom properties. A BTreeMap so the serialized JSON key order is deterministic across processes — the packed manifest embeds this map, and byte-reproducible builds must not depend on hash-map iteration order.

temporal_bucket_ms: u64

Temporal bucket size in milliseconds for tile chunking Tiles are organized into fixed temporal intervals (e.g., 3600000 = 1 hour)

summary_tier: Option<SummaryTier>

Optional server-side aggregated summary tier. v2/v3 archives without a summary tier round-trip cleanly via the field default.

temporal_lod: Option<Vec<TemporalLodLevel>>

Optional temporal LOD pyramid (orthogonal to summary tier). When present, the archive carries aggregate tiles at coarser temporal granularities so a reader animating decades of data at “year scale” can fetch coarser tiles instead of streaming per-hour base tiles.

heatmap_domain: Option<HeatmapDomain>

Optional bake-time HeatmapLayer intensity domains. When set, the renderer’s HeatmapLayer skips its runtime colorDomain default of [0, 1] and uses these per-class entries instead — vital when the configured weightProperty carries values far outside that range (earthquake magnitudes, AIS speed, etc.).

style_hints: Option<StyleHints>

Optional build-time style hints (per-property statistics + suggested rendering defaults). Baked by stt-build --style-hints; always overridable by the renderer/user, ignored by older readers.

Implementations

impl Metadata

pub fn new(name: impl Into<String>) -> Self

Create a new metadata object

pub fn with_description(self, description: impl Into<String>) -> Self

Set description

pub fn with_attribution(self, attribution: impl Into<String>) -> Self

Set attribution

pub fn with_bounds(self, bounds: BoundingBox) -> Self

Set bounds

pub fn with_time_range(self, time_range: TimeRange) -> Self

Set time range

pub fn with_zoom_levels(self, min_zoom: u8, max_zoom: u8) -> Self

Set zoom levels

pub fn with_temporal_bucket_ms(self, temporal_bucket_ms: u64) -> Self

Set temporal bucket size in milliseconds

pub fn with_temporal_lod(self, levels: Vec<TemporalLodLevel>) -> Result<Self>

Attach a temporal LOD pyramid.

Each level’s bucket_ms MUST be a strict multiple of the archive’s base temporal_bucket_ms and MUST be strictly greater than it; levels MUST be sorted by ascending bucket_ms. Returns Err if the input breaks any of those invariants — the build pipeline relies on them when re-bucketing features into LOD aggregates.

pub fn temporal_lod_for_zoom(&self, zoom: u8) -> Option<&TemporalLodLevel>

Return the LOD level that applies at zoom, if any. The largest matching bucket_ms (coarsest level) wins — at a global zoom, you want the coarsest available aggregate, not the finest.

pub fn with_property( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add a custom property

pub fn with_summary_tier(self, tier: SummaryTier) -> Self

Attach an aggregated summary-tier descriptor.

pub fn with_heatmap_domain(self, domain: HeatmapDomain) -> Self

Attach a bake-time HeatmapLayer intensity-domain block.

pub fn with_style_hints(self, hints: StyleHints) -> Self

Attach a build-time style-hints block.

pub fn to_json_bytes(&self) -> Result<Vec<u8>>

Serialise to the JSON byte form stored in an archive.

pub fn from_json_bytes(bytes: &[u8]) -> Result<Self>

Parse from the JSON byte form stored in an archive.

pub fn to_tilejson(&self, tile_url_template: Option<&str>) -> Value

Render a TileJSON 3.0 descriptor (with a STAC-style temporal extension) for this archive.

This is the self-describing, ecosystem-recognisable face of the archive: MapLibre / Leaflet / OpenLayers understand the core TileJSON fields, and the additive temporal block — an ISO-8601 interval à la STAC, plus the bucket size/step and any LOD pyramid — carries the time dimension the spatial-only standard lacks (unknown keys are ignored by existing clients). tile_url_template is the {z}/{x}/{y}/{t} URL the host serves tiles at; when None, a relative template is emitted.

Trait Implementations

impl Clone for Metadata

fn clone(&self) -> Metadata

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Metadata

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Metadata

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Metadata

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.