Merge release/0.1.21 into main

Brings the PVA tracker-state memory ceiling and the 0.1.22 version bump onto
the mainline. The released line was cut from origin/main and never merged
back, so main carried neither the feature nor the published version.

Workspace version resolved to 0.1.22 (the published one) over main's stale
0.1.20.

# Conflicts:
#	Cargo.toml
#	spvirit-py/pyproject.toml

Author: MatSTFCInGit

Cargo.lock

@@ -7,13 +7,13 @@ resolver = "2"
 # in step: `spvirit-py/pyproject.toml` pins `spvirit-tools` by exact version,
 # and `spvirit-tools/tests/version_pin.rs` fails the build if it drifts.
 [workspace.package]
-version = "0.1.20"
+version = "0.1.22"
 
 # Internal crates are declared once so their version is not repeated across
 # five manifests. Members refer to them with `workspace = true`.
 [workspace.dependencies]
-spvirit-types = { version = "0.1.20", path = "spvirit-types" }
-spvirit-codec = { version = "0.1.20", path = "spvirit-codec" }
-spvirit-client = { version = "0.1.20", path = "spvirit-client" }
-spvirit-server = { version = "0.1.20", path = "spvirit-server" }
-spvirit-ioc = { version = "0.1.20", path = "spvirit-ioc" }
+spvirit-types = { version = "0.1.22", path = "spvirit-types" }
+spvirit-codec = { version = "0.1.22", path = "spvirit-codec" }
+spvirit-client = { version = "0.1.22", path = "spvirit-client" }
+spvirit-server = { version = "0.1.22", path = "spvirit-server" }
+spvirit-ioc = { version = "0.1.22", path = "spvirit-ioc" }

Cargo.toml

@@ -143,6 +143,20 @@ impl FieldType {
             FieldType::BoundedString(_) => "string",
         }
     }
+
+    /// Bytes this type owns on the heap, walked recursively.
+    ///
+    /// Only the nesting variants own anything; scalars are pure discriminant.
+    pub fn heap_size(&self) -> usize {
+        match self {
+            FieldType::Structure(s) | FieldType::StructureArray(s) => s.heap_size(),
+            FieldType::Union(f) | FieldType::UnionArray(f) => {
+                f.capacity() * std::mem::size_of::<FieldDesc>()
+                    + f.iter().map(FieldDesc::heap_size).sum::<usize>()
+            }
+            _ => 0,
+        }
+    }
 }
 
 /// Field description (name + type)
@@ -152,6 +166,13 @@ pub struct FieldDesc {
     pub field_type: FieldType,
 }
 
+impl FieldDesc {
+    /// Bytes this field owns on the heap, including any nested structure.
+    pub fn heap_size(&self) -> usize {
+        self.name.capacity() + self.field_type.heap_size()
+    }
+}
+
 /// Structure description with optional ID
 #[derive(Debug, Clone, PartialEq)]
 pub struct StructureDesc {
@@ -171,6 +192,20 @@ impl StructureDesc {
     pub fn field(&self, name: &str) -> Option<&FieldDesc> {
         self.fields.iter().find(|f| f.name == name)
     }
+
+    /// Bytes this description owns on the heap, walked recursively.
+    ///
+    /// Introspection is the one term in the state tracker's memory estimate
+    /// that is both large and expensive to measure: an NTScalar carries
+    /// thirty-odd nested `FieldDesc` nodes, each with its own name. Callers
+    /// are expected to cache this at assignment rather than re-walk the tree
+    /// on every accounting pass.
+    pub fn heap_size(&self) -> usize {
+        let id = self.struct_id.as_ref().map_or(0, |s| s.capacity());
+        let fields = self.fields.capacity() * std::mem::size_of::<FieldDesc>()
+            + self.fields.iter().map(FieldDesc::heap_size).sum::<usize>();
+        id + fields
+    }
 }
 
 impl Default for StructureDesc {