feat(rust): per-layer byte stats in mlt-ffi

The parsers record each column's byte span, exposed as `Layer::bytes()`.
mlt-ffi adds `MltTileStats`, and the Java wrapper adds `MltLayerStats.of`
and `MltEncoder.lastLayerSizes()`, so Planetiler can drop `org.maplibre:mlt`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: CommanderStorm

rust/mlt-core/Cargo.toml

@@ -106,6 +106,10 @@ required-features = ["__private"]
 name = "geojson02"
 required-features = ["__private-v2"]
 
+[[test]]
+name = "layer_bytes"
+required-features = ["unstable-v2"]
+
 [[test]]
 name = "mvt_round_trip"
 required-features = ["__private"]

rust/mlt-core/src/decoder/layer.rs

@@ -1,7 +1,7 @@
 use crate::codecs::varint::parse_varint;
 #[cfg(feature = "unstable-v2")]
 use crate::decoder::root02::parse_layer02;
-use crate::decoder::{ColumnDecl, ColumnStorage, Layer01, ParsedLayer01, Unknown};
+use crate::decoder::{ColumnDecl, ColumnStorage, Layer01, LayerBytes, ParsedLayer01, Unknown};
 #[cfg(feature = "unstable-v2")]
 use crate::decoder::{Layer02, ParsedLayer02};
 use crate::utils::{parse_u8, take};
@@ -22,6 +22,17 @@ impl<'a, S: DecodeState> Layer<'a, S> {
             Self::Unknown(_) => None,
         }
     }
+
+    /// The bytes the layer spent on the wire, or `None` for a tag this build does not know.
+    #[must_use]
+    pub fn bytes(&self) -> Option<LayerBytes> {
+        match self {
+            Self::Tag01(l) => Some(l.bytes()),
+            #[cfg(feature = "unstable-v2")]
+            Self::Tag02(l) => Some(l.layer().bytes()),
+            Self::Unknown(_) => None,
+        }
+    }
 }
 
 impl<'a> Layer<'a> {
@@ -107,6 +118,7 @@ impl<'a> Layer01<'a, Lazy> {
                 .into_iter()
                 .map(|p| p.into_parsed(dec))
                 .collect::<MltResult<Vec<_>>>()?,
+            bytes: self.bytes,
             #[cfg(fuzzing)]
             layer_order: self.layer_order,
         })

rust/mlt-core/src/decoder/mod.rs

@@ -39,7 +39,7 @@ pub use iterators::{
     PropValueRef,
 };
 pub use limits::{Decoder, Parser};
-pub use model::{Layer, ParsedLayer, Unknown};
+pub use model::{Layer, LayerBytes, ParsedLayer, Unknown};
 pub(crate) use model01::{BASE_TYPE_MASK, Column, OPTIONAL_FLAG};
 pub use model01::{ColumnType, Layer01, ParsedLayer01};
 #[cfg(feature = "unstable-v2")]

rust/mlt-core/src/decoder/model.rs

@@ -30,6 +30,58 @@ pub enum Layer<'a, S: DecodeState = Lazy> {
 }
 pub type ParsedLayer<'a> = Layer<'a, Parsed>;
 
+/// The bytes a layer spends on the wire, by what they hold.
+///
+/// Every byte the columns leave over is layer metadata: the tag, name, header and column schema.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct LayerBytes {
+    pub(crate) size: u32,
+    pub(crate) geometry: u32,
+    pub(crate) properties: u32,
+    pub(crate) ids: u32,
+}
+
+impl LayerBytes {
+    /// Start counting a layer whose body is `body_len` bytes.
+    pub(crate) fn of_body(body_len: usize) -> Self {
+        Self {
+            // The body never exceeds the u32 size varint that framed it.
+            size: u32::try_from(body_len).map_or(u32::MAX, |len| len.saturating_add(1)),
+            ..Self::default()
+        }
+    }
+
+    /// The value of the layer's size varint: the tag and the body, without the varint itself.
+    #[must_use]
+    pub fn size(&self) -> u32 {
+        self.size
+    }
+
+    /// The geometry column, or the v2 geometry section.
+    #[must_use]
+    pub fn geometry(&self) -> u32 {
+        self.geometry
+    }
+
+    /// Every column that is neither geometry nor the id, nested and m-value columns included.
+    #[must_use]
+    pub fn properties(&self) -> u32 {
+        self.properties
+    }
+
+    /// The id column.
+    #[must_use]
+    pub fn ids(&self) -> u32 {
+        self.ids
+    }
+
+    /// What is left of [`Self::size`] once every column is taken out.
+    #[must_use]
+    pub fn metadata(&self) -> u32 {
+        self.size - self.geometry - self.properties - self.ids
+    }
+}
+
 /// Unknown layer data, stored as encoded bytes.
 ///
 /// Returned inside [`Layer::Unknown`] for any layer tag that is not recognized

rust/mlt-core/src/decoder/model01.rs

@@ -9,7 +9,7 @@ use std::io::Write;
 use num_enum::TryFromPrimitive;
 
 use crate::MltError::ParsingColumnType;
-use crate::decoder::{Geometry, GeometryValues, Id, ParsedProperty, Property};
+use crate::decoder::{Geometry, GeometryValues, Id, LayerBytes, ParsedProperty, Property};
 use crate::tile::Extent;
 use crate::utils::{BinarySerializer as _, parse_string, parse_u8};
 use crate::{DecodeState, Lazy, MltRefResult, Parsed, Parser};
@@ -41,6 +41,7 @@ pub struct Layer01<'a, S: DecodeState = Lazy> {
     pub(crate) id: Option<Id<'a, S>>,
     pub(crate) geometry: Geometry<'a, S>,
     pub(crate) properties: Vec<Property<'a, S>>,
+    pub(crate) bytes: LayerBytes,
     #[cfg(fuzzing)]
     pub(crate) layer_order: Vec<crate::decoder::fuzzing::LayerOrdering>,
 }
@@ -57,6 +58,12 @@ impl<'a, S: DecodeState> Layer01<'a, S> {
     pub fn extent(&self) -> Extent {
         self.extent
     }
+
+    /// The bytes the layer spent on the wire, by what they hold.
+    #[must_use]
+    pub fn bytes(&self) -> LayerBytes {
+        self.bytes
+    }
 }
 
 impl ParsedLayer01<'_> {
@@ -168,6 +175,15 @@ impl ColumnType {
         )
     }
 
+    /// Check if the column holds the feature ids.
+    #[must_use]
+    pub(crate) fn is_id(self) -> bool {
+        matches!(
+            self,
+            Self::Id | Self::OptId | Self::LongId | Self::OptLongId
+        )
+    }
+
     /// Check if the column type has a presence stream
     #[must_use]
     pub(crate) fn is_optional(self) -> bool {

rust/mlt-core/src/decoder/root01.rs

@@ -12,8 +12,8 @@ use crate::codecs::varint::parse_varint;
 use crate::decoder::stream::header01;
 use crate::decoder::{
     Column, ColumnType, DictLayout, DictionaryType, GeoTypes, Geometry, Id, IndexBase, Layer01,
-    RawFloats, RawFsstData, RawGeometry, RawId, RawIdValue, RawPlainData, RawPresence, RawProperty,
-    RawScalar, RawSharedDict, RawSharedDictEncoding, RawSharedDictItem, RawStrings,
+    LayerBytes, RawFloats, RawFsstData, RawGeometry, RawId, RawIdValue, RawPlainData, RawPresence,
+    RawProperty, RawScalar, RawSharedDict, RawSharedDictEncoding, RawSharedDictItem, RawStrings,
     RawStringsEncoding, StreamType, ValueKind,
 };
 use crate::errors::AsMltError as _;
@@ -24,6 +24,7 @@ use crate::{Lazy, MltRefResult, MltResult, Parser};
 impl<'a> Layer01<'a, Lazy> {
     /// Parse `v01::Layer` metadata, reserving decoded memory against the parser's budget.
     pub(crate) fn from_bytes(input: &'a [u8], parser: &mut Parser) -> MltResult<Self> {
+        let mut bytes = LayerBytes::of_body(input.len());
         let (input, layer_name) = parse_string(input)?;
         if layer_name.is_empty() {
             return Err(MissingLayerName);
@@ -57,6 +58,7 @@ impl<'a> Layer01<'a, Lazy> {
             let presence;
             let value;
             let name = column.name.unwrap_or("");
+            let before = input.len();
 
             match column.typ {
                 ColumnType::Id | ColumnType::OptId => {
@@ -124,6 +126,14 @@ impl<'a> Layer01<'a, Lazy> {
                     properties.push(Raw(prop));
                 }
             }
+            let spent = u32::try_from(before - input.len())?;
+            if column.typ == ColumnType::Geometry {
+                bytes.geometry += spent;
+            } else if column.typ.is_id() {
+                bytes.ids += spent;
+            } else {
+                bytes.properties += spent;
+            }
         }
         if input.is_empty() {
             Ok(Layer01 {
@@ -132,6 +142,7 @@ impl<'a> Layer01<'a, Lazy> {
                 id: id_column,
                 geometry: geometry.ok_or(MissingGeometry)?,
                 properties,
+                bytes,
                 #[cfg(fuzzing)]
                 layer_order,
             })

rust/mlt-core/src/decoder/root02.rs

@@ -59,11 +59,11 @@ use crate::decoder::stream::header02::{
 use crate::decoder::{
     Column02, ColumnCounts, ColumnKind02, ColumnType02, DataType02, Decoder, DictLayout,
     DictionaryType, FloatLogical, GeoLayout, GeoTypes, Id, IdWidth02, IndexBase, Layer01, Layer02,
-    LayerHeader02, LayerLayout, LengthType, LogicalEncoding, MValues, Nested, Presence02,
-    RawFloats, RawFloatsEncoding, RawFsstData, RawGeometry, RawId, RawIdValue, RawMValue,
-    RawPlainData, RawPresence, RawProperty, RawScalar, RawSharedDict, RawSharedDictEncoding,
-    RawSharedDictItem, RawStream, RawStrings, RawStringsEncoding, SharedDictKind, ValueType02,
-    ValuesColumn02,
+    LayerBytes, LayerHeader02, LayerLayout, LengthType, LogicalEncoding, MValues, Nested,
+    Presence02, RawFloats, RawFloatsEncoding, RawFsstData, RawGeometry, RawId, RawIdValue,
+    RawMValue, RawPlainData, RawPresence, RawProperty, RawScalar, RawSharedDict,
+    RawSharedDictEncoding, RawSharedDictItem, RawStream, RawStrings, RawStringsEncoding,
+    SharedDictKind, ValueType02, ValuesColumn02,
 };
 use crate::tile::{ColumnRole, Extent, reject_taken_name};
 use crate::utils::{SetOptionOnce as _, parse_string, parse_u8};
@@ -74,6 +74,7 @@ pub(crate) fn parse_layer02<'a>(
     input: &'a [u8],
     parser: &mut Parser,
 ) -> MltResult<Layer02<'a, Lazy>> {
+    let mut bytes = LayerBytes::of_body(input.len());
     let (input, layer_name) = parse_string(input)?;
     if layer_name.is_empty() {
         return Err(MissingLayerName);
@@ -93,7 +94,9 @@ pub(crate) fn parse_layer02<'a>(
     let (input, cols) = parse_shared_presence(input, layout, feature_count, parser)?;
 
     // ── Geometry section ──────────────────────────────────────────────────
-    let (input, geometry) = parse_geometry(input, header, layout.geometry, feature_count, parser)?;
+    let (rest, geometry) = parse_geometry(input, header, layout.geometry, feature_count, parser)?;
+    bytes.geometry = u32::try_from(input.len() - rest.len())?;
+    let input = rest;
 
     // ── Counted columns ───────────────────────────────────────────────────
     let (mut input, counts) = ColumnCounts::parse(input, header.m_values)?;
@@ -112,6 +115,7 @@ pub(crate) fn parse_layer02<'a>(
     let mut layer_order = vec![crate::decoder::fuzzing::LayerOrdering::Geometry];
 
     for _ in 0..column_count {
+        let before = input.len();
         let typ_byte;
         (input, typ_byte) = parse_u8(input)?;
         let typ = match cols.column(typ_byte)? {
@@ -124,6 +128,7 @@ pub(crate) fn parse_layer02<'a>(
                     column_names.push((Cow::Owned(name), ColumnRole::Property));
                 }
                 properties.push(Raw(RawProperty::SharedDict(shared_dict)));
+                bytes.properties += u32::try_from(before - input.len())?;
                 #[cfg(fuzzing)]
                 layer_order.push(crate::decoder::fuzzing::LayerOrdering::Property);
                 continue;
@@ -148,6 +153,7 @@ pub(crate) fn parse_layer02<'a>(
                     IdWidth02::Id64 => RawIdValue::Id64(data),
                 };
                 id_column.set_once(Raw(RawId { presence, value }))?;
+                bytes.ids += u32::try_from(before - input.len())?;
             }
             ColumnKind02::Values(column) => {
                 #[cfg(fuzzing)]
@@ -164,6 +170,7 @@ pub(crate) fn parse_layer02<'a>(
                     parser,
                 )?;
                 properties.push(Raw(values.into()));
+                bytes.properties += u32::try_from(before - input.len())?;
             }
             ColumnKind02::Nested(column) => {
                 #[cfg(fuzzing)]
@@ -174,17 +181,20 @@ pub(crate) fn parse_layer02<'a>(
                 (input, tree) =
                     parse_nested(input, name, presence, column.root, data_count, parser)?;
                 nested.push(Raw(tree));
+                bytes.properties += u32::try_from(before - input.len())?;
             }
         }
     }
 
     // ── M-value section ───────────────────────────────────────────────────
+    let before = input.len();
     let m_values;
     (input, m_values) = if header.m_values {
         parse_m_values(input, counts.m_values, &cols, &mut column_names, parser)?
     } else {
         (input, Vec::new())
     };
+    bytes.properties += u32::try_from(before - input.len())?;
 
     if !input.is_empty() {
         return Err(TrailingLayerData(input.len()));
@@ -196,6 +206,7 @@ pub(crate) fn parse_layer02<'a>(
             id: id_column,
             geometry: Raw(geometry),
             properties,
+            bytes,
             #[cfg(fuzzing)]
             layer_order,
         },

rust/mlt-core/src/lib.rs

@@ -84,7 +84,9 @@ pub mod wire {
         LengthType, LogicalEncoding, LogicalTechnique, Morton, OffsetType, PhysicalEncoding,
         RleLayout, RleMeta, StreamMeta, StreamType, ValueKind, VertexLogical,
     };
-    pub use crate::decoder::{ColumnDecl, ColumnStorage, ColumnType, DictLayout, StringLayout};
+    pub use crate::decoder::{
+        ColumnDecl, ColumnStorage, ColumnType, DictLayout, LayerBytes, StringLayout,
+    };
     #[cfg(feature = "unstable-v2")]
     pub use crate::decoder::{GeoLayout, LayerLayout};
     pub use crate::utils::analyze::{Analyze, StatType};

rust/mlt-core/tests/layer_bytes.rs

@@ -0,0 +1,63 @@
+use std::fs;
+use std::path::Path;
+
+use mlt_core::Parser;
+use mlt_core::dump::{Region, annotate_tile};
+use test_each_file::test_each_path;
+
+test_each_path! { for ["mlt"] in "../test/synthetic/0x01" as bytes_0x01 => matches_the_inspector }
+test_each_path! { for ["mlt"] in "../test/synthetic/0x01-rust" as bytes_0x01_rust => matches_the_inspector }
+test_each_path! { for ["mlt"] in "../test/synthetic/0x02" as bytes_0x02 => matches_the_inspector }
+
+fn matches_the_inspector([path]: [&Path; 1]) {
+    let buffer = fs::read(path).unwrap();
+    let Ok(layers) = Parser::default().parse_layers(&buffer) else {
+        return;
+    };
+    let parsed: Vec<_> = layers
+        .iter()
+        .filter_map(mlt_core::Layer::bytes)
+        .map(|b| [b.size(), b.geometry(), b.properties(), b.ids()].map(|n| n as usize))
+        .collect();
+    let (tree, err) = annotate_tile(&buffer);
+    assert!(err.is_none(), "{}: {err:?}", path.display());
+
+    assert_eq!(parsed, inspector_bytes(&tree.regions), "{}", path.display());
+}
+
+/// The classification `inspector/src/tileStats.ts` applies to the annotated regions.
+fn inspector_bytes(regions: &[Region]) -> Vec<[usize; 4]> {
+    let mut layers = Vec::new();
+    for (at, layer) in regions.iter().enumerate() {
+        if layer.depth != 0 || !layer.label.starts_with("layer[") {
+            continue;
+        }
+        let kids = regions[at + 1..]
+            .iter()
+            .take_while(|r| r.depth > 0)
+            .filter(|r| r.depth == 1);
+        let mut size = layer.len;
+        let (mut geometry, mut properties, mut ids) = (0, 0, 0);
+        for kid in kids {
+            if kid.label == "size" {
+                size -= kid.len;
+            }
+            if !kid.container {
+                continue;
+            }
+            let typ = kid
+                .label
+                .strip_prefix("column[")
+                .or_else(|| kid.label.strip_prefix("m_value["))
+                .and_then(|rest| rest.split(' ').nth(1));
+            match (kid.label.as_str(), typ) {
+                ("geometry", _) | (_, Some("Geometry")) => geometry += kid.len,
+                (_, Some("Id" | "OptId" | "LongId" | "OptLongId")) => ids += kid.len,
+                (_, Some(_)) => properties += kid.len,
+                _ => {}
+            }
+        }
+        layers.push([size, geometry, properties, ids]);
+    }
+    layers
+}

rust/mlt-ffi/README.md

@@ -10,6 +10,8 @@
 | `MltLayerBuilder`    | Writes a layer one feature at a time from MVT geometry commands and encodes it into an `MltBuffer` |
 | `MltEncoderOptions`  | Builder wrapping `EncoderConfig` - construct with `new()`, toggle flags with setters               |
 | `MltBuffer`          | Owned byte buffer with `.bytes` / `.len` accessors, `clear()`, and appending encodes               |
+| `MltTileStats`       | `from_bytes(bytes)` parses a tile without decoding it, then reports each layer's name and bytes    |
+| `MltLayerBytes`      | One layer's size, split into geometry, property, id and metadata bytes                             |
 | `ConvertError`       | Opaque error with `.kind` (`ConvertErrorKind`) and `.message` accessors                            |
 | `MltWireVersion`     | `V01` (default) or the experimental `V02`                                                          |
 | `MltMvtGeometryType` | The MVT geometry type of one `MltLayerBuilder` feature                                             |