diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000..60ebea5
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,15 @@
+# Revisions listed here are ignored by `git blame` so that purely
+# mechanical commits (reformatting, mass renames) don't overwrite
+# the blame history of every line they touch.
+#
+# GitHub honours this file automatically on the web UI.  Locally, run:
+#
+#     git config blame.ignoreRevsFile .git-blame-ignore-revs
+#
+# to make the local `git blame` respect it as well.
+#
+# Only add a SHA here when the commit is guaranteed to change no
+# semantics -- formatters, whitespace-only edits, renames.
+
+# Repo-wide clang-format-15 sweep (2026-04-23)
+101feb407ac0fdfa1b96de37f625b40b716573b0
diff --git a/benchmarks/bench_accessor.cpp b/benchmarks/bench_accessor.cpp
index a219515..a82e9cc 100644
--- a/benchmarks/bench_accessor.cpp
+++ b/benchmarks/bench_accessor.cpp
@@ -39,50 +39,50 @@
 
 namespace {
 
-// The arena replay lives under samples/content/reader/arena/.  Benchmarks
-// run from various working dirs, so we resolve the path relative to the
-// fixtures dir that CMake exposes via VTX_BENCH_FIXTURES_DIR.
-std::string ArenaReplayPath() {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "reader" / "arena" / "arena_from_fbs_ds.vtx")
-        .string();
-}
+    // The arena replay lives under samples/content/reader/arena/.  Benchmarks
+    // run from various working dirs, so we resolve the path relative to the
+    // fixtures dir that CMake exposes via VTX_BENCH_FIXTURES_DIR.
+    std::string ArenaReplayPath() {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "reader" / "arena" / "arena_from_fbs_ds.vtx")
+            .string();
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_accessor_debug_logs_once{};
-
-// Small bundle that holds the reader + accessor + resolved keys.  Moving
-// this construction out of the measured loop is intentional -- a real
-// integration resolves keys once at setup, not per frame.
-struct AccessorFixture {
-    VTX::ReaderContext reader_result;
-    VTX::FrameAccessor accessor;
-    VTX::PropertyKey<VTX::Vector> key_position;
-    VTX::PropertyKey<float>       key_health;
-    VTX::PropertyKey<std::string> key_unique_id;
-
-    static AccessorFixture Load(benchmark::State& state) {
-        AccessorFixture f;
-        f.reader_result = VTX::OpenReplayFile(ArenaReplayPath());
-        if (!f.reader_result) {
-            state.SkipWithError("OpenReplayFile failed (run vtx_sample_generate + vtx_sample_advance_write first)");
-            return f;
-        }
-        f.accessor      = f.reader_result.reader->CreateAccessor();
-        f.key_position  = f.accessor.Get<VTX::Vector>("Player", "Position");
-        f.key_health    = f.accessor.Get<float>("Player", "Health");
-        f.key_unique_id = f.accessor.Get<std::string>("Player", "UniqueID");
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_accessor_debug_logs_once {};
+
+    // Small bundle that holds the reader + accessor + resolved keys.  Moving
+    // this construction out of the measured loop is intentional -- a real
+    // integration resolves keys once at setup, not per frame.
+    struct AccessorFixture {
+        VTX::ReaderContext reader_result;
+        VTX::FrameAccessor accessor;
+        VTX::PropertyKey<VTX::Vector> key_position;
+        VTX::PropertyKey<float> key_health;
+        VTX::PropertyKey<std::string> key_unique_id;
+
+        static AccessorFixture Load(benchmark::State& state) {
+            AccessorFixture f;
+            f.reader_result = VTX::OpenReplayFile(ArenaReplayPath());
+            if (!f.reader_result) {
+                state.SkipWithError("OpenReplayFile failed (run vtx_sample_generate + vtx_sample_advance_write first)");
+                return f;
+            }
+            f.accessor = f.reader_result.reader->CreateAccessor();
+            f.key_position = f.accessor.Get<VTX::Vector>("Player", "Position");
+            f.key_health = f.accessor.Get<float>("Player", "Health");
+            f.key_unique_id = f.accessor.Get<std::string>("Player", "UniqueID");
 
-        if (!f.key_position.IsValid() || !f.key_health.IsValid() || !f.key_unique_id.IsValid()) {
-            state.SkipWithError("one or more Player keys did not resolve");
+            if (!f.key_position.IsValid() || !f.key_health.IsValid() || !f.key_unique_id.IsValid()) {
+                state.SkipWithError("one or more Player keys did not resolve");
+            }
+            return f;
         }
-        return f;
-    }
-};
+    };
 
-}  // namespace
+} // namespace
 
 // Open the replay, create the accessor, resolve three keys, then linearly
 // enumerate every frame, iterate every entity in the "entity" bucket, and
@@ -92,24 +92,27 @@ static void BM_AccessorSequentialScan(benchmark::State& state) {
     int32_t total_frames = 0;
     for (auto _ : state) {
         auto fixture = AccessorFixture::Load(state);
-        if (!fixture.reader_result) break;
+        if (!fixture.reader_result)
+            break;
         auto& reader = fixture.reader_result.reader;
 
         total_frames = reader->GetTotalFrames();
         double pos_accum = 0.0;
-        float  hp_accum  = 0.0f;
-        size_t id_count  = 0;
+        float hp_accum = 0.0f;
+        size_t id_count = 0;
 
         for (int32_t i = 0; i < total_frames; ++i) {
             const auto* frame = reader->GetFrameSync(i);
-            if (!frame) continue;
+            if (!frame)
+                continue;
             for (const auto& bucket : frame->GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
-                    if (entity.entity_type_id != 0) continue;  // 0 = Player
+                    if (entity.entity_type_id != 0)
+                        continue; // 0 = Player
                     VTX::EntityView view(entity);
                     pos_accum += view.Get(fixture.key_position).x;
-                    hp_accum  += view.Get(fixture.key_health);
-                    id_count  += view.Get(fixture.key_unique_id).size();
+                    hp_accum += view.Get(fixture.key_health);
+                    id_count += view.Get(fixture.key_unique_id).size();
                 }
             }
         }
@@ -128,12 +131,15 @@ BENCHMARK(BM_AccessorSequentialScan)->Unit(benchmark::kMillisecond);
 // the replay in memory would observe when scrubbing over the properties.
 static void BM_AccessorHotLoopPreloaded(benchmark::State& state) {
     auto result = VTX::OpenReplayFile(ArenaReplayPath());
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
-    auto accessor     = reader->CreateAccessor();
+    auto accessor = reader->CreateAccessor();
     auto key_position = accessor.Get<VTX::Vector>("Player", "Position");
-    auto key_health   = accessor.Get<float>("Player", "Health");
+    auto key_health = accessor.Get<float>("Player", "Health");
     if (!key_position.IsValid() || !key_health.IsValid()) {
         state.SkipWithError("keys did not resolve");
         return;
@@ -161,7 +167,8 @@ static void BM_AccessorHotLoopPreloaded(benchmark::State& state) {
     for (const auto& frame : ram_cache) {
         for (const auto& bucket : frame.GetBuckets()) {
             for (const auto& entity : bucket.entities) {
-                if (entity.entity_type_id == 0) ++entities_per_sweep;
+                if (entity.entity_type_id == 0)
+                    ++entities_per_sweep;
             }
         }
     }
@@ -171,7 +178,8 @@ static void BM_AccessorHotLoopPreloaded(benchmark::State& state) {
         for (const auto& frame : ram_cache) {
             for (const auto& bucket : frame.GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
-                    if (entity.entity_type_id != 0) continue;
+                    if (entity.entity_type_id != 0)
+                        continue;
                     VTX::EntityView view(entity);
                     sink += view.Get(key_position).x + view.Get(key_health);
                 }
@@ -189,10 +197,13 @@ BENCHMARK(BM_AccessorHotLoopPreloaded)->Unit(benchmark::kMillisecond);
 // behaviour under non-sequential access.
 static void BM_AccessorRandomWithinBucket(benchmark::State& state) {
     auto result = VTX::OpenReplayFile(ArenaReplayPath());
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
-    auto accessor     = reader->CreateAccessor();
+    auto accessor = reader->CreateAccessor();
     auto key_position = accessor.Get<VTX::Vector>("Player", "Position");
     if (!key_position.IsValid()) {
         state.SkipWithError("Player::Position did not resolve");
@@ -227,16 +238,20 @@ static void BM_AccessorRandomWithinBucket(benchmark::State& state) {
             std::vector<size_t> idxs;
             idxs.reserve(bucket.entities.size());
             for (size_t i = 0; i < bucket.entities.size(); ++i) {
-                if (bucket.entities[i].entity_type_id == 0) idxs.push_back(i);
-                if (bucket.entities[i].entity_type_id == 0) idxs.push_back(i);
+                if (bucket.entities[i].entity_type_id == 0)
+                    idxs.push_back(i);
+                if (bucket.entities[i].entity_type_id == 0)
+                    idxs.push_back(i);
             }
-            if (idxs.size() < 2) continue;
+            if (idxs.size() < 2)
+                continue;
             std::shuffle(idxs.begin(), idxs.end(), rng);
             prepared.push_back({&bucket.entities, std::move(idxs)});
         }
     }
     int64_t ops_per_sweep = 0;
-    for (const auto& pb : prepared) ops_per_sweep += static_cast<int64_t>(pb.shuffled.size());
+    for (const auto& pb : prepared)
+        ops_per_sweep += static_cast<int64_t>(pb.shuffled.size());
 
     double sink = 0.0;
     for (auto _ : state) {
diff --git a/benchmarks/bench_accessor_key_resolution.cpp b/benchmarks/bench_accessor_key_resolution.cpp
index c7651ae..fa56987 100644
--- a/benchmarks/bench_accessor_key_resolution.cpp
+++ b/benchmarks/bench_accessor_key_resolution.cpp
@@ -20,39 +20,45 @@
 
 namespace {
 
-std::string ArenaReplayPath() {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "reader" / "arena" / "arena_from_fbs_ds.vtx")
-        .string();
-}
+    std::string ArenaReplayPath() {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "reader" / "arena" / "arena_from_fbs_ds.vtx")
+            .string();
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_keyres_debug_logs_once{};
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_keyres_debug_logs_once {};
 
-// A representative spread of property lookups a real integration performs.
-struct PropSpec { const char* struct_name; const char* prop_name; };
-constexpr std::array<PropSpec, 9> kProps = {{
-    {"Player",     "Position"},
-    {"Player",     "Health"},
-    {"Player",     "UniqueID"},
-    {"Player",     "Velocity"},
-    {"Player",     "Score"},
-    {"Projectile", "Position"},
-    {"Projectile", "Damage"},
-    {"MatchState", "ScoreTeam1"},
-    {"MatchState", "ScoreTeam2"},
-}};
+    // A representative spread of property lookups a real integration performs.
+    struct PropSpec {
+        const char* struct_name;
+        const char* prop_name;
+    };
+    constexpr std::array<PropSpec, 9> kProps = {{
+        {"Player", "Position"},
+        {"Player", "Health"},
+        {"Player", "UniqueID"},
+        {"Player", "Velocity"},
+        {"Player", "Score"},
+        {"Projectile", "Position"},
+        {"Projectile", "Damage"},
+        {"MatchState", "ScoreTeam1"},
+        {"MatchState", "ScoreTeam2"},
+    }};
 
-}  // namespace
+} // namespace
 
 // Resolve a full set of PropertyKey<T> via the public accessor API.  If
 // the underlying cache is O(1) then time-per-resolution should stay
 // constant regardless of how many properties the schema defines.
 static void BM_AccessorKeyResolution(benchmark::State& state) {
     auto result = VTX::OpenReplayFile(ArenaReplayPath());
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
 
     const auto accessor = result.reader->CreateAccessor();
 
diff --git a/benchmarks/bench_cs.cpp b/benchmarks/bench_cs.cpp
index 2ed734d..46a8644 100644
--- a/benchmarks/bench_cs.cpp
+++ b/benchmarks/bench_cs.cpp
@@ -37,60 +37,59 @@
 
 namespace {
 
-std::string CsReplayPath(const char* backend_filename) {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "reader" / "cs" / backend_filename)
-        .string();
-}
-
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_cs_debug_logs_once{};
-
-// Opens + iterates every frame + touches the bucket list.  Mirrors the
-// BM_ReaderSequentialScan shape but against a realistic fixture.
-void SequentialScanImpl(benchmark::State& state, const char* filename) {
-    const std::string path = CsReplayPath(filename);
-    if (!std::filesystem::exists(path)) {
-        state.SkipWithError("CS fixture missing (expected under samples/content/reader/cs/)");
-        return;
+    std::string CsReplayPath(const char* backend_filename) {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "reader" / "cs" / backend_filename)
+            .string();
     }
-    VtxBench::WarmFileCache(path);
 
-    int64_t total_frames = 0;
-    for (auto _ : state) {
-        auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
-        total_frames = result.reader->GetTotalFrames();
-        int64_t bucket_count = 0;
-        for (int32_t i = 0; i < total_frames; ++i) {
-            if (const auto* frame = result.reader->GetFrameSync(i)) {
-                bucket_count += static_cast<int64_t>(frame->GetBuckets().size());
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_cs_debug_logs_once {};
+
+    // Opens + iterates every frame + touches the bucket list.  Mirrors the
+    // BM_ReaderSequentialScan shape but against a realistic fixture.
+    void SequentialScanImpl(benchmark::State& state, const char* filename) {
+        const std::string path = CsReplayPath(filename);
+        if (!std::filesystem::exists(path)) {
+            state.SkipWithError("CS fixture missing (expected under samples/content/reader/cs/)");
+            return;
+        }
+        VtxBench::WarmFileCache(path);
+
+        int64_t total_frames = 0;
+        for (auto _ : state) {
+            auto result = VTX::OpenReplayFile(path);
+            if (!result) {
+                state.SkipWithError("OpenReplayFile failed");
+                break;
             }
+            total_frames = result.reader->GetTotalFrames();
+            int64_t bucket_count = 0;
+            for (int32_t i = 0; i < total_frames; ++i) {
+                if (const auto* frame = result.reader->GetFrameSync(i)) {
+                    bucket_count += static_cast<int64_t>(frame->GetBuckets().size());
+                }
+            }
+            benchmark::DoNotOptimize(bucket_count);
         }
-        benchmark::DoNotOptimize(bucket_count);
-    }
 
-    state.SetItemsProcessed(state.iterations() * total_frames);
-    VtxBench::SetNsPerFrame(state, total_frames);
-}
+        state.SetItemsProcessed(state.iterations() * total_frames);
+        VtxBench::SetNsPerFrame(state, total_frames);
+    }
 
-}  // namespace
+} // namespace
 
 static void BM_CS_ReaderSequentialScan_FBS(benchmark::State& state) {
     SequentialScanImpl(state, "cs_fbs.vtx");
 }
-BENCHMARK(BM_CS_ReaderSequentialScan_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_CS_ReaderSequentialScan_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 static void BM_CS_ReaderSequentialScan_Proto(benchmark::State& state) {
     SequentialScanImpl(state, "cs_proto.vtx");
 }
-BENCHMARK(BM_CS_ReaderSequentialScan_Proto)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_CS_ReaderSequentialScan_Proto)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // Full user-facing path: accessor + read Player::Transform + Player::Health
 // + Player::UniqueID per Player entity across every frame.
@@ -105,37 +104,40 @@ static void BM_CS_AccessorSequentialScan_FBS(benchmark::State& state) {
     int64_t total_frames = 0;
     for (auto _ : state) {
         auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
+        if (!result) {
+            state.SkipWithError("OpenReplayFile failed");
+            break;
+        }
         auto& reader = result.reader;
 
-        auto accessor      = reader->CreateAccessor();
+        auto accessor = reader->CreateAccessor();
         auto key_transform = accessor.Get<VTX::Transform>("Player", "Transform");
-        auto key_health    = accessor.Get<int32_t>("Player", "Health");
+        auto key_health = accessor.Get<int32_t>("Player", "Health");
         auto key_unique_id = accessor.Get<std::string>("Player", "UniqueID");
-        auto key_steam_id  = accessor.Get<int64_t>("Player", "SteamId");
+        auto key_steam_id = accessor.Get<int64_t>("Player", "SteamId");
 
-        if (!key_transform.IsValid() || !key_health.IsValid() ||
-            !key_unique_id.IsValid() || !key_steam_id.IsValid()) {
+        if (!key_transform.IsValid() || !key_health.IsValid() || !key_unique_id.IsValid() || !key_steam_id.IsValid()) {
             state.SkipWithError("Player keys did not resolve");
             break;
         }
 
         total_frames = reader->GetTotalFrames();
-        double  tx_accum = 0.0;
+        double tx_accum = 0.0;
         int64_t hp_accum = 0;
-        size_t  id_count = 0;
-        int64_t sid_sum  = 0;
+        size_t id_count = 0;
+        int64_t sid_sum = 0;
 
         for (int32_t i = 0; i < total_frames; ++i) {
             const auto* frame = reader->GetFrameSync(i);
-            if (!frame) continue;
+            if (!frame)
+                continue;
             for (const auto& bucket : frame->GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
                     VTX::EntityView view(entity);
                     tx_accum += view.Get(key_transform).translation.x;
                     hp_accum += view.Get(key_health);
                     id_count += view.Get(key_unique_id).size();
-                    sid_sum  += view.Get(key_steam_id);
+                    sid_sum += view.Get(key_steam_id);
                 }
             }
         }
@@ -148,9 +150,7 @@ static void BM_CS_AccessorSequentialScan_FBS(benchmark::State& state) {
     state.SetItemsProcessed(state.iterations() * total_frames);
     VtxBench::SetNsPerFrame(state, total_frames);
 }
-BENCHMARK(BM_CS_AccessorSequentialScan_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_CS_AccessorSequentialScan_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // Random access through the accessor: open + keep the reader alive, then
 // pick uniformly random frames and read Player::Transform + Health per
@@ -164,12 +164,15 @@ static void BM_CS_AccessorRandomAccess_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
-    auto accessor      = reader->CreateAccessor();
+    auto accessor = reader->CreateAccessor();
     auto key_transform = accessor.Get<VTX::Transform>("Player", "Transform");
-    auto key_health    = accessor.Get<int32_t>("Player", "Health");
+    auto key_health = accessor.Get<int32_t>("Player", "Health");
     if (!key_transform.IsValid() || !key_health.IsValid()) {
         state.SkipWithError("Player keys did not resolve");
         return;
@@ -180,14 +183,15 @@ static void BM_CS_AccessorRandomAccess_FBS(benchmark::State& state) {
     std::uniform_int_distribution<int32_t> dist(0, total - 1);
 
     constexpr int kAccessesPerIter = 50;
-    double  tx_accum = 0.0;
+    double tx_accum = 0.0;
     int64_t hp_accum = 0;
 
     for (auto _ : state) {
         for (int i = 0; i < kAccessesPerIter; ++i) {
             const int32_t idx = dist(rng);
             const auto* frame = reader->GetFrameSync(idx);
-            if (!frame) continue;
+            if (!frame)
+                continue;
             for (const auto& bucket : frame->GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
                     VTX::EntityView view(entity);
@@ -215,14 +219,23 @@ static void BM_CS_DifferConsecutiveFrames_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
     auto differ = VtxDiff::CreateDifferFacade(VTX::VtxFormat::FlatBuffers);
-    if (!differ) { state.SkipWithError("CreateDifferFacade failed"); return; }
+    if (!differ) {
+        state.SkipWithError("CreateDifferFacade failed");
+        return;
+    }
 
     const int32_t total = reader->GetTotalFrames();
-    if (total < 2) { state.SkipWithError("fixture has fewer than 2 frames"); return; }
+    if (total < 2) {
+        state.SkipWithError("fixture has fewer than 2 frames");
+        return;
+    }
 
     int32_t pair_index = 0;
     const int32_t max_pair = total - 1;
diff --git a/benchmarks/bench_differ.cpp b/benchmarks/bench_differ.cpp
index 95ebf07..bf79070 100644
--- a/benchmarks/bench_differ.cpp
+++ b/benchmarks/bench_differ.cpp
@@ -19,16 +19,16 @@
 
 namespace {
 
-std::string FixturePath(const char* name) {
-    return std::string(VTX_BENCH_FIXTURES_DIR) + "/" + name;
-}
+    std::string FixturePath(const char* name) {
+        return std::string(VTX_BENCH_FIXTURES_DIR) + "/" + name;
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_differ_debug_logs_once{};
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_differ_debug_logs_once {};
 
-}  // namespace
+} // namespace
 
 // Diff cost between two consecutive frames.  Opens the fixture once and the
 // differ once; the measured loop only does DiffRawFrames over sliding pairs.
diff --git a/benchmarks/bench_property_cache.cpp b/benchmarks/bench_property_cache.cpp
index f6d6b40..60699cf 100644
--- a/benchmarks/bench_property_cache.cpp
+++ b/benchmarks/bench_property_cache.cpp
@@ -20,35 +20,36 @@
 
 namespace {
 
-std::string FixturePath(const char* name) {
-    return std::string(VTX_BENCH_FIXTURES_DIR) + "/" + name;
-}
+    std::string FixturePath(const char* name) {
+        return std::string(VTX_BENCH_FIXTURES_DIR) + "/" + name;
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_pcache_debug_logs_once{};
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_pcache_debug_logs_once {};
 
-// Collect every (struct_name, property_name) pair present in the cache so
-// the benchmark can iterate them in a round-robin.
-struct ResolutionKey {
-    std::string struct_name;
-    std::string property_name;
-};
+    // Collect every (struct_name, property_name) pair present in the cache so
+    // the benchmark can iterate them in a round-robin.
+    struct ResolutionKey {
+        std::string struct_name;
+        std::string property_name;
+    };
 
-std::vector<ResolutionKey> CollectResolutionKeys(const VTX::PropertyAddressCache& cache) {
-    std::vector<ResolutionKey> keys;
-    for (const auto& [struct_name, struct_id] : cache.name_to_id) {
-        auto it = cache.structs.find(struct_id);
-        if (it == cache.structs.end()) continue;
-        for (const auto& [property_name, _addr] : it->second.properties) {
-            keys.push_back({struct_name, property_name});
+    std::vector<ResolutionKey> CollectResolutionKeys(const VTX::PropertyAddressCache& cache) {
+        std::vector<ResolutionKey> keys;
+        for (const auto& [struct_name, struct_id] : cache.name_to_id) {
+            auto it = cache.structs.find(struct_id);
+            if (it == cache.structs.end())
+                continue;
+            for (const auto& [property_name, _addr] : it->second.properties) {
+                keys.push_back({struct_name, property_name});
+            }
         }
+        return keys;
     }
-    return keys;
-}
 
-}  // namespace
+} // namespace
 
 // Three hash lookups per resolution: name -> struct_id -> schema cache ->
 // property address.  Per-iteration loops through every known (struct,
@@ -63,7 +64,7 @@ static void BM_PropertyAddressCacheLookup(benchmark::State& state) {
     }
 
     const auto cache = result.reader->GetPropertyAddressCache();
-    const auto keys  = CollectResolutionKeys(cache);
+    const auto keys = CollectResolutionKeys(cache);
     if (keys.empty()) {
         state.SkipWithError("empty PropertyAddressCache");
         return;
@@ -74,9 +75,11 @@ static void BM_PropertyAddressCacheLookup(benchmark::State& state) {
     for (auto _ : state) {
         for (const auto& key : keys) {
             const auto id_it = cache.name_to_id.find(key.struct_name);
-            if (id_it == cache.name_to_id.end()) continue;
+            if (id_it == cache.name_to_id.end())
+                continue;
             const auto struct_it = cache.structs.find(id_it->second);
-            if (struct_it == cache.structs.end()) continue;
+            if (struct_it == cache.structs.end())
+                continue;
             const auto prop_it = struct_it->second.properties.find(key.property_name);
             if (prop_it != struct_it->second.properties.end()) {
                 benchmark::DoNotOptimize(prop_it->second);
@@ -85,8 +88,7 @@ static void BM_PropertyAddressCacheLookup(benchmark::State& state) {
         }
     }
 
-    state.SetItemsProcessed(static_cast<int64_t>(state.iterations()) *
-                            static_cast<int64_t>(keys.size()));
+    state.SetItemsProcessed(static_cast<int64_t>(state.iterations()) * static_cast<int64_t>(keys.size()));
     state.counters["keys_per_iter"] = static_cast<double>(keys.size());
     benchmark::DoNotOptimize(hit_count);
 }
diff --git a/benchmarks/bench_reader.cpp b/benchmarks/bench_reader.cpp
index 5b4c48d..dd2e178 100644
--- a/benchmarks/bench_reader.cpp
+++ b/benchmarks/bench_reader.cpp
@@ -24,23 +24,21 @@
 
 namespace {
 
-constexpr int32_t kFixtureFrameCount = 10'000;
+    constexpr int32_t kFixtureFrameCount = 10'000;
 
-std::string FixturePath(const char* name) {
-    return std::string(VTX_BENCH_FIXTURES_DIR) + "/" + name;
-}
-
-// Silence VTX::Logger Debug messages once (e.g. "Chunk N loaded into RAM").
-// Info/Warning/Error still print so real problems remain visible.  This runs
-// once at static init, before google/benchmark starts its measured loops.
-struct SilenceDebugLogsAtInit {
-    SilenceDebugLogsAtInit() {
-        VTX::Logger::Instance().SetDebugEnabled(false);
+    std::string FixturePath(const char* name) {
+        return std::string(VTX_BENCH_FIXTURES_DIR) + "/" + name;
     }
-};
-const SilenceDebugLogsAtInit silence_debug_logs_at_init{};
 
-}  // namespace
+    // Silence VTX::Logger Debug messages once (e.g. "Chunk N loaded into RAM").
+    // Info/Warning/Error still print so real problems remain visible.  This runs
+    // once at static init, before google/benchmark starts its measured loops.
+    struct SilenceDebugLogsAtInit {
+        SilenceDebugLogsAtInit() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsAtInit silence_debug_logs_at_init {};
+
+} // namespace
 
 // Open the .vtx and linearly iterate every frame, touching the bucket list
 // so the reader is forced to deserialize every chunk along the way.  This
diff --git a/benchmarks/bench_rl.cpp b/benchmarks/bench_rl.cpp
index c430515..466a011 100644
--- a/benchmarks/bench_rl.cpp
+++ b/benchmarks/bench_rl.cpp
@@ -30,59 +30,58 @@
 
 namespace {
 
-std::string RlReplayPath(const char* backend_filename) {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "reader" / "rl" / backend_filename)
-        .string();
-}
-
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_rl_debug_logs_once{};
-
-// Raw reader scan: open + iterate every frame + touch bucket list.
-void SequentialScanImpl(benchmark::State& state, const char* filename) {
-    const std::string path = RlReplayPath(filename);
-    if (!std::filesystem::exists(path)) {
-        state.SkipWithError("RL fixture missing (expected under samples/content/reader/rl/)");
-        return;
+    std::string RlReplayPath(const char* backend_filename) {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "reader" / "rl" / backend_filename)
+            .string();
     }
-    VtxBench::WarmFileCache(path);
 
-    int64_t total_frames = 0;
-    for (auto _ : state) {
-        auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
-        total_frames = result.reader->GetTotalFrames();
-        int64_t bucket_count = 0;
-        for (int32_t i = 0; i < total_frames; ++i) {
-            if (const auto* frame = result.reader->GetFrameSync(i)) {
-                bucket_count += static_cast<int64_t>(frame->GetBuckets().size());
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_rl_debug_logs_once {};
+
+    // Raw reader scan: open + iterate every frame + touch bucket list.
+    void SequentialScanImpl(benchmark::State& state, const char* filename) {
+        const std::string path = RlReplayPath(filename);
+        if (!std::filesystem::exists(path)) {
+            state.SkipWithError("RL fixture missing (expected under samples/content/reader/rl/)");
+            return;
+        }
+        VtxBench::WarmFileCache(path);
+
+        int64_t total_frames = 0;
+        for (auto _ : state) {
+            auto result = VTX::OpenReplayFile(path);
+            if (!result) {
+                state.SkipWithError("OpenReplayFile failed");
+                break;
             }
+            total_frames = result.reader->GetTotalFrames();
+            int64_t bucket_count = 0;
+            for (int32_t i = 0; i < total_frames; ++i) {
+                if (const auto* frame = result.reader->GetFrameSync(i)) {
+                    bucket_count += static_cast<int64_t>(frame->GetBuckets().size());
+                }
+            }
+            benchmark::DoNotOptimize(bucket_count);
         }
-        benchmark::DoNotOptimize(bucket_count);
-    }
 
-    state.SetItemsProcessed(state.iterations() * total_frames);
-    VtxBench::SetNsPerFrame(state, total_frames);
-}
+        state.SetItemsProcessed(state.iterations() * total_frames);
+        VtxBench::SetNsPerFrame(state, total_frames);
+    }
 
-}  // namespace
+} // namespace
 
 static void BM_RL_ReaderSequentialScan_FBS(benchmark::State& state) {
     SequentialScanImpl(state, "rl_fbs.vtx");
 }
-BENCHMARK(BM_RL_ReaderSequentialScan_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_RL_ReaderSequentialScan_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 static void BM_RL_ReaderSequentialScan_Proto(benchmark::State& state) {
     SequentialScanImpl(state, "rl_proto.vtx");
 }
-BENCHMARK(BM_RL_ReaderSequentialScan_Proto)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_RL_ReaderSequentialScan_Proto)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // Full user-facing path: accessor + read 4 keys per entity (Transform,
 // ActorId, UniqueId, BoostAmount).  Entity struct properties are inlined
@@ -99,14 +98,17 @@ static void BM_RL_AccessorSequentialScan_FBS(benchmark::State& state) {
     int64_t total_frames = 0;
     for (auto _ : state) {
         auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
+        if (!result) {
+            state.SkipWithError("OpenReplayFile failed");
+            break;
+        }
         auto& reader = result.reader;
 
-        auto accessor     = reader->CreateAccessor();
+        auto accessor = reader->CreateAccessor();
         auto key_transform = accessor.Get<VTX::Transform>("Entity", "Transform");
-        auto key_actor_id  = accessor.Get<int64_t>("Entity", "ActorId");
+        auto key_actor_id = accessor.Get<int64_t>("Entity", "ActorId");
         auto key_unique_id = accessor.Get<std::string>("Entity", "UniqueId");
-        auto key_boost     = accessor.Get<float>("VehiclePickup_Boost", "BoostAmount");
+        auto key_boost = accessor.Get<float>("VehiclePickup_Boost", "BoostAmount");
 
         if (!key_transform.IsValid() || !key_actor_id.IsValid() || !key_unique_id.IsValid()) {
             state.SkipWithError("Entity keys did not resolve");
@@ -114,20 +116,21 @@ static void BM_RL_AccessorSequentialScan_FBS(benchmark::State& state) {
         }
 
         total_frames = reader->GetTotalFrames();
-        double  tx_accum    = 0.0;
-        int64_t aid_accum   = 0;
-        size_t  id_count    = 0;
-        float   boost_accum = 0.0f;
+        double tx_accum = 0.0;
+        int64_t aid_accum = 0;
+        size_t id_count = 0;
+        float boost_accum = 0.0f;
 
         for (int32_t i = 0; i < total_frames; ++i) {
             const auto* frame = reader->GetFrameSync(i);
-            if (!frame) continue;
+            if (!frame)
+                continue;
             for (const auto& bucket : frame->GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
                     VTX::EntityView view(entity);
-                    tx_accum    += view.Get(key_transform).translation.x;
-                    aid_accum   += view.Get(key_actor_id);
-                    id_count    += view.Get(key_unique_id).size();
+                    tx_accum += view.Get(key_transform).translation.x;
+                    aid_accum += view.Get(key_actor_id);
+                    id_count += view.Get(key_unique_id).size();
                     boost_accum += view.Get(key_boost);
                 }
             }
@@ -141,9 +144,7 @@ static void BM_RL_AccessorSequentialScan_FBS(benchmark::State& state) {
     state.SetItemsProcessed(state.iterations() * total_frames);
     VtxBench::SetNsPerFrame(state, total_frames);
 }
-BENCHMARK(BM_RL_AccessorSequentialScan_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_RL_AccessorSequentialScan_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // Random access via accessor: simulates a replay-viewer scrub jumping
 // around arbitrary frames and reading Transform + ActorId per entity.
@@ -156,12 +157,15 @@ static void BM_RL_AccessorRandomAccess_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
-    auto accessor      = reader->CreateAccessor();
+    auto accessor = reader->CreateAccessor();
     auto key_transform = accessor.Get<VTX::Transform>("Entity", "Transform");
-    auto key_actor_id  = accessor.Get<int64_t>("Entity", "ActorId");
+    auto key_actor_id = accessor.Get<int64_t>("Entity", "ActorId");
     if (!key_transform.IsValid() || !key_actor_id.IsValid()) {
         state.SkipWithError("Entity keys did not resolve");
         return;
@@ -172,18 +176,19 @@ static void BM_RL_AccessorRandomAccess_FBS(benchmark::State& state) {
     std::uniform_int_distribution<int32_t> dist(0, total - 1);
 
     constexpr int kAccessesPerIter = 50;
-    double  tx_accum  = 0.0;
+    double tx_accum = 0.0;
     int64_t aid_accum = 0;
 
     for (auto _ : state) {
         for (int i = 0; i < kAccessesPerIter; ++i) {
             const int32_t idx = dist(rng);
             const auto* frame = reader->GetFrameSync(idx);
-            if (!frame) continue;
+            if (!frame)
+                continue;
             for (const auto& bucket : frame->GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
                     VTX::EntityView view(entity);
-                    tx_accum  += view.Get(key_transform).translation.x;
+                    tx_accum += view.Get(key_transform).translation.x;
                     aid_accum += view.Get(key_actor_id);
                 }
             }
@@ -206,14 +211,23 @@ static void BM_RL_DifferConsecutiveFrames_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
     auto differ = VtxDiff::CreateDifferFacade(VTX::VtxFormat::FlatBuffers);
-    if (!differ) { state.SkipWithError("CreateDifferFacade failed"); return; }
+    if (!differ) {
+        state.SkipWithError("CreateDifferFacade failed");
+        return;
+    }
 
     const int32_t total = reader->GetTotalFrames();
-    if (total < 2) { state.SkipWithError("fixture has fewer than 2 frames"); return; }
+    if (total < 2) {
+        state.SkipWithError("fixture has fewer than 2 frames");
+        return;
+    }
 
     int32_t pair_index = 0;
     const int32_t max_pair = total - 1;
diff --git a/benchmarks/bench_scenarios.cpp b/benchmarks/bench_scenarios.cpp
index ed5a453..648a0f4 100644
--- a/benchmarks/bench_scenarios.cpp
+++ b/benchmarks/bench_scenarios.cpp
@@ -39,24 +39,24 @@
 
 namespace {
 
-std::string CsReplayPath(const char* backend_filename) {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "reader" / "cs" / backend_filename)
-        .string();
-}
+    std::string CsReplayPath(const char* backend_filename) {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "reader" / "cs" / backend_filename)
+            .string();
+    }
 
-std::string ArenaReplayPath() {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "reader" / "arena" / "arena_from_fbs_ds.vtx")
-        .string();
-}
+    std::string ArenaReplayPath() {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "reader" / "arena" / "arena_from_fbs_ds.vtx")
+            .string();
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_scenarios_debug_logs_once{};
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_scenarios_debug_logs_once {};
 
-}  // namespace
+} // namespace
 
 // ============================================================================
 // Partial / windowed scans (CS fixture)
@@ -79,7 +79,10 @@ static void BM_CS_PreviewFirst1000Frames_FBS(benchmark::State& state) {
     constexpr int32_t kPreviewFrames = 1000;
     for (auto _ : state) {
         auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
+        if (!result) {
+            state.SkipWithError("OpenReplayFile failed");
+            break;
+        }
         const int32_t limit = std::min(kPreviewFrames, result.reader->GetTotalFrames());
         int64_t bucket_count = 0;
         for (int32_t i = 0; i < limit; ++i) {
@@ -92,9 +95,7 @@ static void BM_CS_PreviewFirst1000Frames_FBS(benchmark::State& state) {
     state.SetItemsProcessed(state.iterations() * kPreviewFrames);
     VtxBench::SetNsPerFrame(state, kPreviewFrames);
 }
-BENCHMARK(BM_CS_PreviewFirst1000Frames_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_CS_PreviewFirst1000Frames_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // "User seeks to 50% and plays 300 frames" -- typical scrubbing-UI shape.
 // The middle-of-file seek forces a cold chunk load even on a warm OS cache,
@@ -111,10 +112,13 @@ static void BM_CS_SeekMiddlePlay300Frames_FBS(benchmark::State& state) {
     constexpr int32_t kPlayFrames = 300;
     for (auto _ : state) {
         auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
+        if (!result) {
+            state.SkipWithError("OpenReplayFile failed");
+            break;
+        }
         const int32_t total = result.reader->GetTotalFrames();
         const int32_t start = total / 2;
-        const int32_t end   = std::min(total, start + kPlayFrames);
+        const int32_t end = std::min(total, start + kPlayFrames);
         int64_t bucket_count = 0;
         for (int32_t i = start; i < end; ++i) {
             if (const auto* frame = result.reader->GetFrameSync(i)) {
@@ -126,9 +130,7 @@ static void BM_CS_SeekMiddlePlay300Frames_FBS(benchmark::State& state) {
     state.SetItemsProcessed(state.iterations() * kPlayFrames);
     VtxBench::SetNsPerFrame(state, kPlayFrames);
 }
-BENCHMARK(BM_CS_SeekMiddlePlay300Frames_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_CS_SeekMiddlePlay300Frames_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // "Timeline thumbnails" -- one frame every 100, covering the whole replay.
 // Each sample is in a different chunk, so this is effectively a chunk-miss
@@ -146,7 +148,10 @@ static void BM_CS_StridedScan_Every100th_FBS(benchmark::State& state) {
     int64_t samples_total = 0;
     for (auto _ : state) {
         auto result = VTX::OpenReplayFile(path);
-        if (!result) { state.SkipWithError("OpenReplayFile failed"); break; }
+        if (!result) {
+            state.SkipWithError("OpenReplayFile failed");
+            break;
+        }
         const int32_t total = result.reader->GetTotalFrames();
         int64_t bucket_count = 0;
         int64_t samples = 0;
@@ -162,9 +167,7 @@ static void BM_CS_StridedScan_Every100th_FBS(benchmark::State& state) {
     state.SetItemsProcessed(state.iterations() * samples_total);
     VtxBench::SetNsPerFrame(state, samples_total);
 }
-BENCHMARK(BM_CS_StridedScan_Every100th_FBS)
-    ->Unit(benchmark::kMillisecond)
-    BENCH_HEAVY_FIXTURE_SUFFIX;
+BENCHMARK(BM_CS_StridedScan_Every100th_FBS)->Unit(benchmark::kMillisecond) BENCH_HEAVY_FIXTURE_SUFFIX;
 
 // ============================================================================
 // Cache-window sweep (CS fixture)
@@ -195,14 +198,16 @@ static void BM_CS_AccessorRandomAccess_CacheSweep_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
-    reader->SetCacheWindow(static_cast<uint32_t>(cache_window),
-                           static_cast<uint32_t>(cache_window));
+    reader->SetCacheWindow(static_cast<uint32_t>(cache_window), static_cast<uint32_t>(cache_window));
 
-    auto accessor      = reader->CreateAccessor();
+    auto accessor = reader->CreateAccessor();
     auto key_transform = accessor.Get<VTX::Transform>("Player", "Transform");
-    auto key_health    = accessor.Get<int32_t>("Player", "Health");
+    auto key_health = accessor.Get<int32_t>("Player", "Health");
     if (!key_transform.IsValid() || !key_health.IsValid()) {
         state.SkipWithError("Player keys did not resolve");
         return;
@@ -213,14 +218,15 @@ static void BM_CS_AccessorRandomAccess_CacheSweep_FBS(benchmark::State& state) {
     std::uniform_int_distribution<int32_t> dist(0, total - 1);
 
     constexpr int kAccessesPerIter = 50;
-    double  tx_accum = 0.0;
+    double tx_accum = 0.0;
     int64_t hp_accum = 0;
 
     for (auto _ : state) {
         for (int i = 0; i < kAccessesPerIter; ++i) {
             const int32_t idx = dist(rng);
             const auto* frame = reader->GetFrameSync(idx);
-            if (!frame) continue;
+            if (!frame)
+                continue;
             for (const auto& bucket : frame->GetBuckets()) {
                 for (const auto& entity : bucket.entities) {
                     VTX::EntityView view(entity);
@@ -245,7 +251,11 @@ static void BM_CS_AccessorRandomAccess_CacheSweep_FBS(benchmark::State& state) {
 // Reps aren't useful here: the RNG is seeded (seed=42) so the access
 // sequence is identical across runs.  Single iteration is deterministic.
 BENCHMARK(BM_CS_AccessorRandomAccess_CacheSweep_FBS)
-    ->Arg(0)->Arg(2)->Arg(5)->Arg(10)->Arg(20)
+    ->Arg(0)
+    ->Arg(2)
+    ->Arg(5)
+    ->Arg(10)
+    ->Arg(20)
     ->Unit(benchmark::kMicrosecond);
 
 // ============================================================================
@@ -263,8 +273,7 @@ BENCHMARK(BM_CS_AccessorRandomAccess_CacheSweep_FBS)
 // dangling.  Copying the bytes once, pre-measured loop, keeps the diff
 // path free of that footgun.  (It also makes the measured number "pure
 // diff cost" instead of "diff + cache lookup + potential chunk reload".)
-static std::vector<std::byte> SnapshotFrame(VTX::IVtxReaderFacade* reader,
-                                            int32_t frame_index) {
+static std::vector<std::byte> SnapshotFrame(VTX::IVtxReaderFacade* reader, int32_t frame_index) {
     auto span = reader->GetRawFrameBytes(frame_index);
     return std::vector<std::byte>(span.begin(), span.end());
 }
@@ -281,14 +290,23 @@ static void BM_Arena_DifferIdenticalFrames_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
     auto differ = VtxDiff::CreateDifferFacade(VTX::VtxFormat::FlatBuffers);
-    if (!differ) { state.SkipWithError("CreateDifferFacade failed"); return; }
+    if (!differ) {
+        state.SkipWithError("CreateDifferFacade failed");
+        return;
+    }
 
     auto frame_a = SnapshotFrame(reader.get(), 0);
-    if (frame_a.empty()) { state.SkipWithError("GetRawFrameBytes returned empty"); return; }
+    if (frame_a.empty()) {
+        state.SkipWithError("GetRawFrameBytes returned empty");
+        return;
+    }
 
     for (auto _ : state) {
         auto patch = differ->DiffRawFrames(frame_a, frame_a);
@@ -310,14 +328,23 @@ static void BM_Arena_DifferFirstVsLast_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
     auto differ = VtxDiff::CreateDifferFacade(VTX::VtxFormat::FlatBuffers);
-    if (!differ) { state.SkipWithError("CreateDifferFacade failed"); return; }
+    if (!differ) {
+        state.SkipWithError("CreateDifferFacade failed");
+        return;
+    }
 
     const int32_t total = reader->GetTotalFrames();
-    if (total < 2) { state.SkipWithError("fixture has fewer than 2 frames"); return; }
+    if (total < 2) {
+        state.SkipWithError("fixture has fewer than 2 frames");
+        return;
+    }
 
     // Copy *both* frames out before the measured loop.  The first span
     // becomes invalid the moment the second call evicts its chunk.
@@ -348,14 +375,23 @@ static void BM_CS_DifferIdenticalFrames_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
     auto differ = VtxDiff::CreateDifferFacade(VTX::VtxFormat::FlatBuffers);
-    if (!differ) { state.SkipWithError("CreateDifferFacade failed"); return; }
+    if (!differ) {
+        state.SkipWithError("CreateDifferFacade failed");
+        return;
+    }
 
     auto frame_a = SnapshotFrame(reader.get(), 0);
-    if (frame_a.empty()) { state.SkipWithError("GetRawFrameBytes returned empty"); return; }
+    if (frame_a.empty()) {
+        state.SkipWithError("GetRawFrameBytes returned empty");
+        return;
+    }
 
     for (auto _ : state) {
         auto patch = differ->DiffRawFrames(frame_a, frame_a);
@@ -377,14 +413,23 @@ static void BM_CS_DifferFirstVsLast_FBS(benchmark::State& state) {
     VtxBench::WarmFileCache(path);
 
     auto result = VTX::OpenReplayFile(path);
-    if (!result) { state.SkipWithError("OpenReplayFile failed"); return; }
+    if (!result) {
+        state.SkipWithError("OpenReplayFile failed");
+        return;
+    }
     auto& reader = result.reader;
 
     auto differ = VtxDiff::CreateDifferFacade(VTX::VtxFormat::FlatBuffers);
-    if (!differ) { state.SkipWithError("CreateDifferFacade failed"); return; }
+    if (!differ) {
+        state.SkipWithError("CreateDifferFacade failed");
+        return;
+    }
 
     const int32_t total = reader->GetTotalFrames();
-    if (total < 2) { state.SkipWithError("fixture has fewer than 2 frames"); return; }
+    if (total < 2) {
+        state.SkipWithError("fixture has fewer than 2 frames");
+        return;
+    }
 
     auto frame_a = SnapshotFrame(reader.get(), 0);
     auto frame_b = SnapshotFrame(reader.get(), total - 1);
diff --git a/benchmarks/bench_schema.cpp b/benchmarks/bench_schema.cpp
index 0c65e24..7760ffb 100644
--- a/benchmarks/bench_schema.cpp
+++ b/benchmarks/bench_schema.cpp
@@ -30,18 +30,18 @@
 
 namespace {
 
-std::string ArenaSchemaPath() {
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "writer" / "arena" / "arena_schema.json")
-        .string();
-}
+    std::string ArenaSchemaPath() {
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "writer" / "arena" / "arena_schema.json")
+            .string();
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_schema_debug_logs_once{};
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_schema_debug_logs_once {};
 
-}  // namespace
+} // namespace
 
 // Full load: JSON parse + SchemaStruct population + PropertyAddressCache
 // construction.  This is what OpenReplayFile triggers internally.
@@ -56,7 +56,10 @@ static void BM_Schema_LoadArena_Both(benchmark::State& state) {
     for (auto _ : state) {
         VTX::SchemaRegistry registry;
         const bool ok = registry.LoadFromJson(path, VTX::SchemaRegistry::ELoadMethod::Both);
-        if (!ok) { state.SkipWithError("LoadFromJson failed"); break; }
+        if (!ok) {
+            state.SkipWithError("LoadFromJson failed");
+            break;
+        }
         benchmark::DoNotOptimize(registry);
     }
     state.SetItemsProcessed(state.iterations());
@@ -76,7 +79,10 @@ static void BM_Schema_LoadArena_BufferOnly(benchmark::State& state) {
     for (auto _ : state) {
         VTX::SchemaRegistry registry;
         const bool ok = registry.LoadFromJson(path, VTX::SchemaRegistry::ELoadMethod::LoadToBuffer);
-        if (!ok) { state.SkipWithError("LoadFromJson failed"); break; }
+        if (!ok) {
+            state.SkipWithError("LoadFromJson failed");
+            break;
+        }
         benchmark::DoNotOptimize(registry);
     }
     state.SetItemsProcessed(state.iterations());
diff --git a/benchmarks/bench_utils.h b/benchmarks/bench_utils.h
index 4dbcdab..429b8a8 100644
--- a/benchmarks/bench_utils.h
+++ b/benchmarks/bench_utils.h
@@ -24,40 +24,39 @@
 
 namespace VtxBench {
 
-// Read the whole file into a throwaway buffer so the OS file cache is
-// warm.  Cheap on repeats (~tens of ms even for 91 MB once cached).
-// Call once in the benchmark body before the measured loop.
-//
-// The scratch buffer is heap-allocated on purpose: a 1 MB char array on
-// the stack blows Windows' default 1 MB thread stack and the process
-// terminates silently with no stderr output.  64 KB is plenty -- the OS
-// read-ahead keeps I/O saturated even with a small working buffer.
-inline void WarmFileCache(const std::string& path) {
-    std::ifstream in(path, std::ios::binary);
-    if (!in) return;
-    constexpr std::streamsize kChunk = 64 * 1024;  // 64 KB, safely on stack
-    char buf[kChunk];
-    while (in.read(buf, kChunk) || in.gcount() > 0) {
-        benchmark::DoNotOptimize(buf);
+    // Read the whole file into a throwaway buffer so the OS file cache is
+    // warm.  Cheap on repeats (~tens of ms even for 91 MB once cached).
+    // Call once in the benchmark body before the measured loop.
+    //
+    // The scratch buffer is heap-allocated on purpose: a 1 MB char array on
+    // the stack blows Windows' default 1 MB thread stack and the process
+    // terminates silently with no stderr output.  64 KB is plenty -- the OS
+    // read-ahead keeps I/O saturated even with a small working buffer.
+    inline void WarmFileCache(const std::string& path) {
+        std::ifstream in(path, std::ios::binary);
+        if (!in)
+            return;
+        constexpr std::streamsize kChunk = 64 * 1024; // 64 KB, safely on stack
+        char buf[kChunk];
+        while (in.read(buf, kChunk) || in.gcount() > 0) {
+            benchmark::DoNotOptimize(buf);
+        }
     }
-}
 
-// Expose "nanoseconds of CPU time per frame" as a first-class counter.
-// google/benchmark's items_per_second divides by CPU time; this flips the
-// ratio and scales it to ns so the output reads directly as "X ns/frame".
-inline void SetNsPerFrame(benchmark::State& state, int64_t total_frames) {
-    state.counters["ns_per_frame"] = benchmark::Counter(
-        static_cast<double>(total_frames),
-        benchmark::Counter::kIsIterationInvariantRate | benchmark::Counter::kInvert,
-        benchmark::Counter::kIs1000);
-}
+    // Expose "nanoseconds of CPU time per frame" as a first-class counter.
+    // google/benchmark's items_per_second divides by CPU time; this flips the
+    // ratio and scales it to ns so the output reads directly as "X ns/frame".
+    inline void SetNsPerFrame(benchmark::State& state, int64_t total_frames) {
+        state.counters["ns_per_frame"] = benchmark::Counter(
+            static_cast<double>(total_frames),
+            benchmark::Counter::kIsIterationInvariantRate | benchmark::Counter::kInvert, benchmark::Counter::kIs1000);
+    }
 
-}  // namespace VtxBench
+} // namespace VtxBench
 
 // Apply to heavy fixture scans so mean/median/stddev/CV always appear.
 //
 //   BENCHMARK(BM_CS_ReaderSequentialScan_FBS)
 //       ->Unit(benchmark::kMillisecond)
 //       BENCH_HEAVY_FIXTURE_SUFFIX;
-#define BENCH_HEAVY_FIXTURE_SUFFIX \
-    ->Repetitions(5)->ReportAggregatesOnly(true)
+#define BENCH_HEAVY_FIXTURE_SUFFIX ->Repetitions(5)->ReportAggregatesOnly(true)
diff --git a/benchmarks/bench_writer.cpp b/benchmarks/bench_writer.cpp
index f1a90f2..9eac4d4 100644
--- a/benchmarks/bench_writer.cpp
+++ b/benchmarks/bench_writer.cpp
@@ -18,41 +18,41 @@
 
 namespace {
 
-constexpr int kFramesPerIteration = 1'000;
+    constexpr int kFramesPerIteration = 1'000;
 
-std::string TempOutputPath() {
-    return (std::filesystem::temp_directory_path() / "vtx_bench_writer_out.vtx").string();
-}
+    std::string TempOutputPath() {
+        return (std::filesystem::temp_directory_path() / "vtx_bench_writer_out.vtx").string();
+    }
 
-std::string ArenaSchemaPath() {
-    // benchmarks/ is two levels above the schema in samples/content/writer/arena/.
-    // VTX_BENCH_FIXTURES_DIR = <repo>/benchmarks/fixtures so we walk up twice.
-    return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path()
-            / "samples" / "content" / "writer" / "arena" / "arena_schema.json")
-        .string();
-}
+    std::string ArenaSchemaPath() {
+        // benchmarks/ is two levels above the schema in samples/content/writer/arena/.
+        // VTX_BENCH_FIXTURES_DIR = <repo>/benchmarks/fixtures so we walk up twice.
+        return (std::filesystem::path(VTX_BENCH_FIXTURES_DIR).parent_path().parent_path() / "samples" / "content" /
+                "writer" / "arena" / "arena_schema.json")
+            .string();
+    }
 
-struct SilenceDebugLogsOnce {
-    SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
-};
-const SilenceDebugLogsOnce silence_writer_debug_logs_once{};
+    struct SilenceDebugLogsOnce {
+        SilenceDebugLogsOnce() { VTX::Logger::Instance().SetDebugEnabled(false); }
+    };
+    const SilenceDebugLogsOnce silence_writer_debug_logs_once {};
 
-}  // namespace
+} // namespace
 
 // End-to-end throughput: create writer, record N frames, finalize.
 static void BM_WriterThroughput(benchmark::State& state) {
     const std::string schema_path = ArenaSchemaPath();
-    const std::string out_path    = TempOutputPath();
+    const std::string out_path = TempOutputPath();
 
     for (auto _ : state) {
         VTX::WriterFacadeConfig config;
-        config.output_filepath  = out_path;
+        config.output_filepath = out_path;
         config.schema_json_path = schema_path;
-        config.replay_name      = "BenchmarkWriter";
-        config.replay_uuid      = "bench-0001";
-        config.default_fps      = 60.0f;
+        config.replay_name = "BenchmarkWriter";
+        config.replay_uuid = "bench-0001";
+        config.default_fps = 60.0f;
         config.chunk_max_frames = 500;
-        config.use_compression  = true;
+        config.use_compression = true;
 
         auto writer = VTX::CreateFlatBuffersWriterFacade(config);
         if (!writer) {
@@ -69,9 +69,9 @@ static void BM_WriterThroughput(benchmark::State& state) {
             entity.float_properties.push_back(static_cast<float>(i) * 1.5f);
 
             VTX::Transform t;
-            t.translation = { static_cast<double>(i), 0.0, 50.0 };
-            t.rotation    = { 0.0f, 0.0f, 0.0f, 1.0f };
-            t.scale       = { 1.0, 1.0, 1.0 };
+            t.translation = {static_cast<double>(i), 0.0, 50.0};
+            t.rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+            t.scale = {1.0, 1.0, 1.0};
             entity.transform_properties.push_back(t);
 
             bucket.unique_ids.push_back("player_" + std::to_string(i % 10));
diff --git a/samples/advance_write.cpp b/samples/advance_write.cpp
index 355d28d..8d47519 100644
--- a/samples/advance_write.cpp
+++ b/samples/advance_write.cpp
@@ -61,263 +61,209 @@
 
 namespace {
 
-VTX::Vector ToVtxVector(const ::arena_pb::Vec3& value)
-{
-    return {value.x(), value.y(), value.z()};
-}
+    VTX::Vector ToVtxVector(const ::arena_pb::Vec3& value) {
+        return {value.x(), value.y(), value.z()};
+    }
 
-VTX::Quat ToVtxQuat(const ::arena_pb::Rotation& value)
-{
-    return {value.x(), value.y(), value.z(), value.w()};
-}
+    VTX::Quat ToVtxQuat(const ::arena_pb::Rotation& value) {
+        return {value.x(), value.y(), value.z(), value.w()};
+    }
 
-VTX::Vector ToVtxVector(const ::arena_fb::Vec3& value)
-{
-    return {value.x(), value.y(), value.z()};
-}
+    VTX::Vector ToVtxVector(const ::arena_fb::Vec3& value) {
+        return {value.x(), value.y(), value.z()};
+    }
 
-VTX::Quat ToVtxQuat(const ::arena_fb::Rotation& value)
-{
-    return {value.x(), value.y(), value.z(), value.w()};
-}
+    VTX::Quat ToVtxQuat(const ::arena_fb::Rotation& value) {
+        return {value.x(), value.y(), value.z(), value.w()};
+    }
 
 } // namespace
 
 namespace VTX {
 
-// ===================================================================
-//  Protobuf bindings -- driven by VTX::GenericProtobufLoader
-// ===================================================================
-//  Each Transfer() method maps one protobuf message into a
-//  VTX::PropertyContainer by delegating scalar/struct/array copies to the
-//  loader, which resolves field slots via SchemaRegistry.
-
-template <>
-struct ProtoBinding<::arena_pb::Player> {
-    static void Transfer(
-        const ::arena_pb::Player& src,
-        VTX::PropertyContainer& dest,
-        VTX::GenericProtobufLoader& loader,
-        const std::string& schema_name)
-    {
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::UniqueID, src.unique_id());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Name, src.name());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Team, src.team());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Health, src.health());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Armor, src.armor());
-        if (src.has_position()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Position, ToVtxVector(src.position()));
+    // ===================================================================
+    //  Protobuf bindings -- driven by VTX::GenericProtobufLoader
+    // ===================================================================
+    //  Each Transfer() method maps one protobuf message into a
+    //  VTX::PropertyContainer by delegating scalar/struct/array copies to the
+    //  loader, which resolves field slots via SchemaRegistry.
+
+    template <>
+    struct ProtoBinding<::arena_pb::Player> {
+        static void Transfer(const ::arena_pb::Player& src, VTX::PropertyContainer& dest,
+                             VTX::GenericProtobufLoader& loader, const std::string& schema_name) {
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::UniqueID, src.unique_id());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Name, src.name());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Team, src.team());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Health, src.health());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Armor, src.armor());
+            if (src.has_position()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Position, ToVtxVector(src.position()));
+            }
+            if (src.has_rotation()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Rotation, ToVtxQuat(src.rotation()));
+            }
+            if (src.has_velocity()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Velocity, ToVtxVector(src.velocity()));
+            }
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::IsAlive, src.is_alive());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Score, src.score());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Deaths, src.deaths());
         }
-        if (src.has_rotation()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Rotation, ToVtxQuat(src.rotation()));
+    };
+
+    template <>
+    struct ProtoBinding<::arena_pb::Projectile> {
+        static void Transfer(const ::arena_pb::Projectile& src, VTX::PropertyContainer& dest,
+                             VTX::GenericProtobufLoader& loader, const std::string& schema_name) {
+            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::UniqueID, src.unique_id());
+            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::OwnerID, src.owner_id());
+            if (src.has_position()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Position, ToVtxVector(src.position()));
+            }
+            if (src.has_velocity()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Velocity, ToVtxVector(src.velocity()));
+            }
+            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Damage, src.damage());
+            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Type, src.type());
         }
-        if (src.has_velocity()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Velocity, ToVtxVector(src.velocity()));
+    };
+
+    template <>
+    struct ProtoBinding<::arena_pb::MatchState> {
+        static void Transfer(const ::arena_pb::MatchState& src, VTX::PropertyContainer& dest,
+                             VTX::GenericProtobufLoader& loader, const std::string& schema_name) {
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::UniqueID, std::string("match_001"));
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam1, src.score_team1());
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam2, src.score_team2());
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Round, src.round());
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Phase, src.phase());
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::TimeRemaining, src.time_remaining());
         }
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::IsAlive, src.is_alive());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Score, src.score());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Deaths, src.deaths());
-    }
-};
+    };
 
-template <>
-struct ProtoBinding<::arena_pb::Projectile> {
-    static void Transfer(
-        const ::arena_pb::Projectile& src,
-        VTX::PropertyContainer& dest,
-        VTX::GenericProtobufLoader& loader,
-        const std::string& schema_name)
-    {
-        loader.LoadField(dest, schema_name, ArenaSchema::Projectile::UniqueID, src.unique_id());
-        loader.LoadField(dest, schema_name, ArenaSchema::Projectile::OwnerID, src.owner_id());
-        if (src.has_position()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Position, ToVtxVector(src.position()));
-        }
-        if (src.has_velocity()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Velocity, ToVtxVector(src.velocity()));
-        }
-        loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Damage, src.damage());
-        loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Type, src.type());
-    }
-};
+    template <>
+    struct ProtoBinding<::arena_pb::FrameData> {
+        static void TransferToFrame(const ::arena_pb::FrameData& src, VTX::Frame& dest,
+                                    VTX::GenericProtobufLoader& loader, const std::string& schema_name) {
+            (void)schema_name;
 
-template <>
-struct ProtoBinding<::arena_pb::MatchState> {
-    static void Transfer(
-        const ::arena_pb::MatchState& src,
-        VTX::PropertyContainer& dest,
-        VTX::GenericProtobufLoader& loader,
-        const std::string& schema_name)
-    {
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::UniqueID, std::string("match_001"));
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam1, src.score_team1());
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam2, src.score_team2());
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Round, src.round());
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Phase, src.phase());
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::TimeRemaining, src.time_remaining());
-    }
-};
+            dest = VTX::Frame {};
+            VTX::Bucket& entity_bucket = dest.GetBucket("entity");
+            entity_bucket.entities.clear();
+            entity_bucket.unique_ids.clear();
 
-template <>
-struct ProtoBinding<::arena_pb::FrameData> {
-    static void TransferToFrame(
-        const ::arena_pb::FrameData& src,
-        VTX::Frame& dest,
-        VTX::GenericProtobufLoader& loader,
-        const std::string& schema_name)
-    {
-        (void)schema_name;
-
-        dest = VTX::Frame{};
-        VTX::Bucket& entity_bucket = dest.GetBucket("entity");
-        entity_bucket.entities.clear();
-        entity_bucket.unique_ids.clear();
-
-        loader.AppendActorList(
-            entity_bucket,
-            ArenaSchema::Player::StructName,
-            src.players(),
-            [](const ::arena_pb::Player& player) { return player.unique_id(); });
-
-        loader.AppendActorList(
-            entity_bucket,
-            ArenaSchema::Projectile::StructName,
-            src.projectiles(),
-            [](const ::arena_pb::Projectile& projectile) { return projectile.unique_id(); });
-
-        if (src.has_match_state()) {
-            loader.AppendSingleActor(
-                entity_bucket,
-                ArenaSchema::MatchState::StructName,
-                src.match_state(),
-                [](const ::arena_pb::MatchState&) { return std::string("match_001"); });
-        }
-    }
-};
+            loader.AppendActorList(entity_bucket, ArenaSchema::Player::StructName, src.players(),
+                                   [](const ::arena_pb::Player& player) { return player.unique_id(); });
 
-// ===================================================================
-//  FlatBuffers bindings -- driven by VTX::GenericFlatBufferLoader
-// ===================================================================
-//  Transfer() receives a pointer to the generated FBS table (zero-copy
-//  access into the mapped buffer).  Field slots are resolved once via
-//  PropertyAddressCache -- subsequent frames hit the cached addresses.
-
-template <>
-struct FlatBufferBinding<::arena_fb::Player> {
-    static void Transfer(
-        const ::arena_fb::Player* src,
-        VTX::PropertyContainer& dest,
-        VTX::GenericFlatBufferLoader& loader,
-        const std::string& schema_name)
-    {
-        if (src->unique_id()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::UniqueID, src->unique_id()->str());
-        }
-        if (src->name()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Name, src->name()->str());
-        }
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Team, src->team());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Health, src->health());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Armor, src->armor());
-        if (src->position()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Position, ToVtxVector(*src->position()));
-        }
-        if (src->rotation()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Rotation, ToVtxQuat(*src->rotation()));
-        }
-        if (src->velocity()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Player::Velocity, ToVtxVector(*src->velocity()));
-        }
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::IsAlive, src->is_alive());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Score, src->score());
-        loader.LoadField(dest, schema_name, ArenaSchema::Player::Deaths, src->deaths());
-    }
-};
+            loader.AppendActorList(entity_bucket, ArenaSchema::Projectile::StructName, src.projectiles(),
+                                   [](const ::arena_pb::Projectile& projectile) { return projectile.unique_id(); });
 
-template <>
-struct FlatBufferBinding<::arena_fb::Projectile> {
-    static void Transfer(
-        const ::arena_fb::Projectile* src,
-        VTX::PropertyContainer& dest,
-        VTX::GenericFlatBufferLoader& loader,
-        const std::string& schema_name)
-    {
-        if (src->unique_id()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::UniqueID, src->unique_id()->str());
+            if (src.has_match_state()) {
+                loader.AppendSingleActor(entity_bucket, ArenaSchema::MatchState::StructName, src.match_state(),
+                                         [](const ::arena_pb::MatchState&) { return std::string("match_001"); });
+            }
         }
-        if (src->owner_id()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::OwnerID, src->owner_id()->str());
+    };
+
+    // ===================================================================
+    //  FlatBuffers bindings -- driven by VTX::GenericFlatBufferLoader
+    // ===================================================================
+    //  Transfer() receives a pointer to the generated FBS table (zero-copy
+    //  access into the mapped buffer).  Field slots are resolved once via
+    //  PropertyAddressCache -- subsequent frames hit the cached addresses.
+
+    template <>
+    struct FlatBufferBinding<::arena_fb::Player> {
+        static void Transfer(const ::arena_fb::Player* src, VTX::PropertyContainer& dest,
+                             VTX::GenericFlatBufferLoader& loader, const std::string& schema_name) {
+            if (src->unique_id()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::UniqueID, src->unique_id()->str());
+            }
+            if (src->name()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Name, src->name()->str());
+            }
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Team, src->team());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Health, src->health());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Armor, src->armor());
+            if (src->position()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Position, ToVtxVector(*src->position()));
+            }
+            if (src->rotation()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Rotation, ToVtxQuat(*src->rotation()));
+            }
+            if (src->velocity()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Player::Velocity, ToVtxVector(*src->velocity()));
+            }
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::IsAlive, src->is_alive());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Score, src->score());
+            loader.LoadField(dest, schema_name, ArenaSchema::Player::Deaths, src->deaths());
         }
-        if (src->position()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Position, ToVtxVector(*src->position()));
+    };
+
+    template <>
+    struct FlatBufferBinding<::arena_fb::Projectile> {
+        static void Transfer(const ::arena_fb::Projectile* src, VTX::PropertyContainer& dest,
+                             VTX::GenericFlatBufferLoader& loader, const std::string& schema_name) {
+            if (src->unique_id()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::UniqueID, src->unique_id()->str());
+            }
+            if (src->owner_id()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::OwnerID, src->owner_id()->str());
+            }
+            if (src->position()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Position, ToVtxVector(*src->position()));
+            }
+            if (src->velocity()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Velocity, ToVtxVector(*src->velocity()));
+            }
+            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Damage, src->damage());
+            if (src->type()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Type, src->type()->str());
+            }
         }
-        if (src->velocity()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Velocity, ToVtxVector(*src->velocity()));
+    };
+
+    template <>
+    struct FlatBufferBinding<::arena_fb::MatchState> {
+        static void Transfer(const ::arena_fb::MatchState* src, VTX::PropertyContainer& dest,
+                             VTX::GenericFlatBufferLoader& loader, const std::string& schema_name) {
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::UniqueID, std::string("match_001"));
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam1, src->score_team1());
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam2, src->score_team2());
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Round, src->round());
+            if (src->phase()) {
+                loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Phase, src->phase()->str());
+            }
+            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::TimeRemaining, src->time_remaining());
         }
-        loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Damage, src->damage());
-        if (src->type()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::Projectile::Type, src->type()->str());
+    };
+
+    template <>
+    struct FlatBufferBinding<::arena_fb::FrameData> {
+        static void TransferToFrame(const ::arena_fb::FrameData* src, VTX::Frame& dest,
+                                    VTX::GenericFlatBufferLoader& loader, const std::string& schema_name) {
+            (void)schema_name;
+
+            dest = VTX::Frame {};
+            VTX::Bucket& entity_bucket = dest.GetBucket("entity");
+            entity_bucket.entities.clear();
+            entity_bucket.unique_ids.clear();
+
+            loader.AppendActorList(entity_bucket, ArenaSchema::Player::StructName, src->players(),
+                                   [](const ::arena_fb::Player* player) {
+                                       return player->unique_id() ? player->unique_id()->str() : std::string {};
+                                   });
+
+            loader.AppendActorList(entity_bucket, ArenaSchema::Projectile::StructName, src->projectiles(),
+                                   [](const ::arena_fb::Projectile* projectile) {
+                                       return projectile->unique_id() ? projectile->unique_id()->str() : std::string {};
+                                   });
+
+            loader.AppendSingleEntity(entity_bucket, ArenaSchema::MatchState::StructName, src->match_state(),
+                                      [](const ::arena_fb::MatchState*) { return std::string("match_001"); });
         }
-    }
-};
-
-template <>
-struct FlatBufferBinding<::arena_fb::MatchState> {
-    static void Transfer(
-        const ::arena_fb::MatchState* src,
-        VTX::PropertyContainer& dest,
-        VTX::GenericFlatBufferLoader& loader,
-        const std::string& schema_name)
-    {
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::UniqueID, std::string("match_001"));
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam1, src->score_team1());
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::ScoreTeam2, src->score_team2());
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Round, src->round());
-        if (src->phase()) {
-            loader.LoadField(dest, schema_name, ArenaSchema::MatchState::Phase, src->phase()->str());
-        }
-        loader.LoadField(dest, schema_name, ArenaSchema::MatchState::TimeRemaining, src->time_remaining());
-    }
-};
-
-template <>
-struct FlatBufferBinding<::arena_fb::FrameData> {
-    static void TransferToFrame(
-        const ::arena_fb::FrameData* src,
-        VTX::Frame& dest,
-        VTX::GenericFlatBufferLoader& loader,
-        const std::string& schema_name)
-    {
-        (void)schema_name;
-
-        dest = VTX::Frame{};
-        VTX::Bucket& entity_bucket = dest.GetBucket("entity");
-        entity_bucket.entities.clear();
-        entity_bucket.unique_ids.clear();
-
-        loader.AppendActorList(
-            entity_bucket,
-            ArenaSchema::Player::StructName,
-            src->players(),
-            [](const ::arena_fb::Player* player) {
-                return player->unique_id() ? player->unique_id()->str() : std::string{};
-            });
-
-        loader.AppendActorList(
-            entity_bucket,
-            ArenaSchema::Projectile::StructName,
-            src->projectiles(),
-            [](const ::arena_fb::Projectile* projectile) {
-                return projectile->unique_id() ? projectile->unique_id()->str() : std::string{};
-            });
-
-        loader.AppendSingleEntity(
-            entity_bucket,
-            ArenaSchema::MatchState::StructName,
-            src->match_state(),
-            [](const ::arena_fb::MatchState*) { return std::string("match_001"); });
-    }
-};
+    };
 
 } // namespace VTX
 
@@ -334,8 +280,7 @@ class ArenaJsonDataSource : public VTX::IFrameDataSource {
     explicit ArenaJsonDataSource(std::string filepath)
         : filepath_(std::move(filepath)) {}
 
-    bool Initialize() override
-    {
+    bool Initialize() override {
         std::ifstream ifs(filepath_);
         if (!ifs.is_open()) {
             VTX_ERROR("[JSON ] Could not open: {}", filepath_);
@@ -355,10 +300,7 @@ class ArenaJsonDataSource : public VTX::IFrameDataSource {
         return true;
     }
 
-    bool GetNextFrame(
-        VTX::Frame& out_frame,
-        VTX::GameTime::GameTimeRegister& out_time) override
-    {
+    bool GetNextFrame(VTX::Frame& out_frame, VTX::GameTime::GameTimeRegister& out_time) override {
         if (cursor_ >= total_) {
             return false;
         }
@@ -366,7 +308,7 @@ class ArenaJsonDataSource : public VTX::IFrameDataSource {
         const ArenaFrame& af = replay_.frames[cursor_++];
         out_frame = ArenaToVtx::MapFrame(af);
 
-        out_time = {af.game_time,std::nullopt, VTX::GameTime::EFilterType::OnlyIncreasing};
+        out_time = {af.game_time, std::nullopt, VTX::GameTime::EFilterType::OnlyIncreasing};
 
         return true;
     }
@@ -392,10 +334,10 @@ class ArenaJsonDataSource : public VTX::IFrameDataSource {
 class ArenaProtoDataSource : public VTX::IFrameDataSource {
 public:
     ArenaProtoDataSource(std::string filepath, VTX::SchemaRegistry& schema)
-        : filepath_(std::move(filepath)), loader_(schema, false) {}
+        : filepath_(std::move(filepath))
+        , loader_(schema, false) {}
 
-    bool Initialize() override
-    {
+    bool Initialize() override {
         std::ifstream ifs(filepath_, std::ios::binary);
         if (!ifs.is_open()) {
             VTX_ERROR("[Proto] Could not open: {}", filepath_);
@@ -411,19 +353,16 @@ class ArenaProtoDataSource : public VTX::IFrameDataSource {
         return true;
     }
 
-    bool GetNextFrame(
-        VTX::Frame& out_frame,
-        VTX::GameTime::GameTimeRegister& out_time) override
-    {
+    bool GetNextFrame(VTX::Frame& out_frame, VTX::GameTime::GameTimeRegister& out_time) override {
         if (cursor_ >= total_) {
             return false;
         }
 
         const auto& frame = replay_.frames(static_cast<int>(cursor_++));
-        out_frame = VTX::Frame{};
+        out_frame = VTX::Frame {};
         loader_.LoadFrame(frame, out_frame, "ArenaFrame");
 
-        out_time = {frame.game_time(),std::nullopt, VTX::GameTime::EFilterType::OnlyIncreasing};
+        out_time = {frame.game_time(), std::nullopt, VTX::GameTime::EFilterType::OnlyIncreasing};
 
         return true;
     }
@@ -449,10 +388,10 @@ class ArenaProtoDataSource : public VTX::IFrameDataSource {
 class ArenaFbsDataSource : public VTX::IFrameDataSource {
 public:
     ArenaFbsDataSource(std::string filepath, const VTX::PropertyAddressCache& cache)
-        : filepath_(std::move(filepath)), loader_(cache, false) {}
+        : filepath_(std::move(filepath))
+        , loader_(cache, false) {}
 
-    bool Initialize() override
-    {
+    bool Initialize() override {
         std::ifstream ifs(filepath_, std::ios::binary | std::ios::ate);
         if (!ifs.is_open()) {
             VTX_ERROR("[FBS  ] Could not open: {}", filepath_);
@@ -475,19 +414,16 @@ class ArenaFbsDataSource : public VTX::IFrameDataSource {
         return true;
     }
 
-    bool GetNextFrame(
-        VTX::Frame& out_frame,
-        VTX::GameTime::GameTimeRegister& out_time) override
-    {
+    bool GetNextFrame(VTX::Frame& out_frame, VTX::GameTime::GameTimeRegister& out_time) override {
         if (cursor_ >= total_) {
             return false;
         }
 
         const auto* frame = replay_->frames()->Get(static_cast<flatbuffers::uoffset_t>(cursor_++));
-        out_frame = VTX::Frame{};
+        out_frame = VTX::Frame {};
         loader_.LoadFrame(frame, out_frame, "ArenaFrame");
 
-        out_time = {frame->game_time(),std::nullopt, VTX::GameTime::EFilterType::OnlyIncreasing};
+        out_time = {frame->game_time(), std::nullopt, VTX::GameTime::EFilterType::OnlyIncreasing};
 
         return true;
     }
@@ -507,16 +443,10 @@ class ArenaFbsDataSource : public VTX::IFrameDataSource {
 //  Pipeline driver -- initialise source, stream frames into the writer
 // ===================================================================
 
-using WriterFactoryFn =
-    std::unique_ptr<VTX::IVtxWriterFacade>(*)(const VTX::WriterFacadeConfig&);
+using WriterFactoryFn = std::unique_ptr<VTX::IVtxWriterFacade> (*)(const VTX::WriterFacadeConfig&);
 
-static bool RunPipeline(
-    VTX::IFrameDataSource& source,
-    const std::string& output_path,
-    const std::string& schema_path,
-    const std::string& uuid,
-    WriterFactoryFn factory)
-{
+static bool RunPipeline(VTX::IFrameDataSource& source, const std::string& output_path, const std::string& schema_path,
+                        const std::string& uuid, WriterFactoryFn factory) {
     if (!source.Initialize()) {
         VTX_ERROR("Data source Initialize() failed.");
         return false;
@@ -551,8 +481,7 @@ static bool RunPipeline(
     return true;
 }
 
-int main()
-{
+int main() {
     const std::string schema = "content/writer/arena/arena_schema.json";
     const std::string writer_dir = "content/writer/arena";
     const std::string reader_dir = "content/reader/arena";
@@ -568,30 +497,18 @@ int main()
 
     VTX_INFO("--- 1. JSON data source ---");
     ArenaJsonDataSource json_ds(writer_dir + "/arena_replay_data.json");
-    RunPipeline(
-        json_ds,
-        reader_dir + "/arena_from_json_ds.vtx",
-        schema,
-        "arena-adv-json-0001",
-        VTX::CreateFlatBuffersWriterFacade);
+    RunPipeline(json_ds, reader_dir + "/arena_from_json_ds.vtx", schema, "arena-adv-json-0001",
+                VTX::CreateFlatBuffersWriterFacade);
 
     VTX_INFO("--- 2. Protobuf data source ---");
     ArenaProtoDataSource proto_ds(writer_dir + "/arena_replay_data.proto.bin", arena_schema);
-    RunPipeline(
-        proto_ds,
-        reader_dir + "/arena_from_proto_ds.vtx",
-        schema,
-        "arena-adv-proto-0001",
-        VTX::CreateProtobuffWriterFacade);
+    RunPipeline(proto_ds, reader_dir + "/arena_from_proto_ds.vtx", schema, "arena-adv-proto-0001",
+                VTX::CreateProtobuffWriterFacade);
 
     VTX_INFO("--- 3. FlatBuffers data source ---");
     ArenaFbsDataSource fbs_ds(writer_dir + "/arena_replay_data.fbs.bin", arena_schema.GetPropertyCache());
-    RunPipeline(
-        fbs_ds,
-        reader_dir + "/arena_from_fbs_ds.vtx",
-        schema,
-        "arena-adv-fbs-0001",
-        VTX::CreateFlatBuffersWriterFacade);
+    RunPipeline(fbs_ds, reader_dir + "/arena_from_fbs_ds.vtx", schema, "arena-adv-fbs-0001",
+                VTX::CreateFlatBuffersWriterFacade);
 
     VTX_INFO("=== Complete ===");
     VTX_INFO("Outputs (content/reader/arena/):");
diff --git a/samples/arena_mappings.h b/samples/arena_mappings.h
index 27ad23e..8258255 100644
--- a/samples/arena_mappings.h
+++ b/samples/arena_mappings.h
@@ -34,55 +34,59 @@
 //  Arena game data model (matches the JSON data source structure)
 // ===================================================================
 
-struct ArenaVec3  { double x = 0, y = 0, z = 0; };
-struct ArenaQuat  { float  x = 0, y = 0, z = 0, w = 1; };
+struct ArenaVec3 {
+    double x = 0, y = 0, z = 0;
+};
+struct ArenaQuat {
+    float x = 0, y = 0, z = 0, w = 1;
+};
 
 struct ArenaPlayer {
     std::string unique_id;
     std::string name;
-    int         team     = 0;
-    float       health   = 100.0f;
-    float       armor    = 50.0f;
-    ArenaVec3   position;
-    ArenaQuat   rotation;
-    ArenaVec3   velocity;
-    bool        is_alive = true;
-    int         score    = 0;
-    int         deaths   = 0;
+    int team = 0;
+    float health = 100.0f;
+    float armor = 50.0f;
+    ArenaVec3 position;
+    ArenaQuat rotation;
+    ArenaVec3 velocity;
+    bool is_alive = true;
+    int score = 0;
+    int deaths = 0;
 };
 
 struct ArenaProjectile {
     std::string unique_id;
     std::string owner_id;
-    ArenaVec3   position;
-    ArenaVec3   velocity;
-    float       damage = 25.0f;
-    std::string type   = "bullet";
+    ArenaVec3 position;
+    ArenaVec3 velocity;
+    float damage = 25.0f;
+    std::string type = "bullet";
 };
 
 struct ArenaMatchState {
-    int         score_team1    = 0;
-    int         score_team2    = 0;
-    int         round          = 1;
+    int score_team1 = 0;
+    int score_team2 = 0;
+    int round = 1;
     std::string phase;
-    float       time_remaining = 0.0f;
+    float time_remaining = 0.0f;
 };
 
 struct ArenaFrame {
-    int                          frame_index = 0;
-    float                        game_time   = 0.0f;
-    int64_t                      utc_ticks   = 0;
-    std::vector<ArenaPlayer>     players;
+    int frame_index = 0;
+    float game_time = 0.0f;
+    int64_t utc_ticks = 0;
+    std::vector<ArenaPlayer> players;
     std::vector<ArenaProjectile> projectiles;
-    ArenaMatchState              match_state;
+    ArenaMatchState match_state;
 };
 
 struct ArenaReplayJson {
-    std::string                replay_name;
-    int                        total_frames     = 0;
-    int                        fps              = 60;
-    double                     duration_seconds = 0.0;
-    std::vector<ArenaFrame>    frames;
+    std::string replay_name;
+    int total_frames = 0;
+    int fps = 60;
+    double duration_seconds = 0.0;
+    std::vector<ArenaFrame> frames;
 };
 
 // ===================================================================
@@ -95,42 +99,29 @@ struct ArenaReplayJson {
 template <>
 struct VTX::JsonMapping<ArenaVec3> {
     static constexpr auto GetFields() {
-        return std::make_tuple(
-            MakeField("x", &ArenaVec3::x),
-            MakeField("y", &ArenaVec3::y),
-            MakeField("z", &ArenaVec3::z)
-        );
+        return std::make_tuple(MakeField("x", &ArenaVec3::x), MakeField("y", &ArenaVec3::y),
+                               MakeField("z", &ArenaVec3::z));
     }
 };
 
 template <>
 struct VTX::JsonMapping<ArenaQuat> {
     static constexpr auto GetFields() {
-        return std::make_tuple(
-            MakeField("x", &ArenaQuat::x),
-            MakeField("y", &ArenaQuat::y),
-            MakeField("z", &ArenaQuat::z),
-            MakeField("w", &ArenaQuat::w)
-        );
+        return std::make_tuple(MakeField("x", &ArenaQuat::x), MakeField("y", &ArenaQuat::y),
+                               MakeField("z", &ArenaQuat::z), MakeField("w", &ArenaQuat::w));
     }
 };
 
 template <>
 struct VTX::JsonMapping<ArenaPlayer> {
     static constexpr auto GetFields() {
-        return std::make_tuple(
-            MakeField("unique_id", &ArenaPlayer::unique_id),
-            MakeField("name",      &ArenaPlayer::name),
-            MakeField("team",      &ArenaPlayer::team),
-            MakeField("health",    &ArenaPlayer::health),
-            MakeField("armor",     &ArenaPlayer::armor),
-            MakeField("position",  &ArenaPlayer::position),
-            MakeField("rotation",  &ArenaPlayer::rotation),
-            MakeField("velocity",  &ArenaPlayer::velocity),
-            MakeField("is_alive",  &ArenaPlayer::is_alive),
-            MakeField("score",     &ArenaPlayer::score),
-            MakeField("deaths",    &ArenaPlayer::deaths)
-        );
+        return std::make_tuple(MakeField("unique_id", &ArenaPlayer::unique_id), MakeField("name", &ArenaPlayer::name),
+                               MakeField("team", &ArenaPlayer::team), MakeField("health", &ArenaPlayer::health),
+                               MakeField("armor", &ArenaPlayer::armor), MakeField("position", &ArenaPlayer::position),
+                               MakeField("rotation", &ArenaPlayer::rotation),
+                               MakeField("velocity", &ArenaPlayer::velocity),
+                               MakeField("is_alive", &ArenaPlayer::is_alive), MakeField("score", &ArenaPlayer::score),
+                               MakeField("deaths", &ArenaPlayer::deaths));
     }
 };
 
@@ -138,26 +129,19 @@ template <>
 struct VTX::JsonMapping<ArenaProjectile> {
     static constexpr auto GetFields() {
         return std::make_tuple(
-            MakeField("unique_id", &ArenaProjectile::unique_id),
-            MakeField("owner_id",  &ArenaProjectile::owner_id),
-            MakeField("position",  &ArenaProjectile::position),
-            MakeField("velocity",  &ArenaProjectile::velocity),
-            MakeField("damage",    &ArenaProjectile::damage),
-            MakeField("type",      &ArenaProjectile::type)
-        );
+            MakeField("unique_id", &ArenaProjectile::unique_id), MakeField("owner_id", &ArenaProjectile::owner_id),
+            MakeField("position", &ArenaProjectile::position), MakeField("velocity", &ArenaProjectile::velocity),
+            MakeField("damage", &ArenaProjectile::damage), MakeField("type", &ArenaProjectile::type));
     }
 };
 
 template <>
 struct VTX::JsonMapping<ArenaMatchState> {
     static constexpr auto GetFields() {
-        return std::make_tuple(
-            MakeField("score_team1",    &ArenaMatchState::score_team1),
-            MakeField("score_team2",    &ArenaMatchState::score_team2),
-            MakeField("round",          &ArenaMatchState::round),
-            MakeField("phase",          &ArenaMatchState::phase),
-            MakeField("time_remaining", &ArenaMatchState::time_remaining)
-        );
+        return std::make_tuple(MakeField("score_team1", &ArenaMatchState::score_team1),
+                               MakeField("score_team2", &ArenaMatchState::score_team2),
+                               MakeField("round", &ArenaMatchState::round), MakeField("phase", &ArenaMatchState::phase),
+                               MakeField("time_remaining", &ArenaMatchState::time_remaining));
     }
 };
 
@@ -165,26 +149,20 @@ template <>
 struct VTX::JsonMapping<ArenaFrame> {
     static constexpr auto GetFields() {
         return std::make_tuple(
-            MakeField("frame_index",  &ArenaFrame::frame_index),
-            MakeField("game_time",    &ArenaFrame::game_time),
-            MakeField("utc_ticks",    &ArenaFrame::utc_ticks),
-            MakeField("players",      &ArenaFrame::players),
-            MakeField("projectiles",  &ArenaFrame::projectiles),
-            MakeField("match_state",  &ArenaFrame::match_state)
-        );
+            MakeField("frame_index", &ArenaFrame::frame_index), MakeField("game_time", &ArenaFrame::game_time),
+            MakeField("utc_ticks", &ArenaFrame::utc_ticks), MakeField("players", &ArenaFrame::players),
+            MakeField("projectiles", &ArenaFrame::projectiles), MakeField("match_state", &ArenaFrame::match_state));
     }
 };
 
 template <>
 struct VTX::JsonMapping<ArenaReplayJson> {
     static constexpr auto GetFields() {
-        return std::make_tuple(
-            MakeField("replay_name",      &ArenaReplayJson::replay_name),
-            MakeField("total_frames",     &ArenaReplayJson::total_frames),
-            MakeField("fps",              &ArenaReplayJson::fps),
-            MakeField("duration_seconds", &ArenaReplayJson::duration_seconds),
-            MakeField("frames",           &ArenaReplayJson::frames)
-        );
+        return std::make_tuple(MakeField("replay_name", &ArenaReplayJson::replay_name),
+                               MakeField("total_frames", &ArenaReplayJson::total_frames),
+                               MakeField("fps", &ArenaReplayJson::fps),
+                               MakeField("duration_seconds", &ArenaReplayJson::duration_seconds),
+                               MakeField("frames", &ArenaReplayJson::frames));
     }
 };
 
@@ -196,63 +174,73 @@ struct VTX::JsonMapping<ArenaReplayJson> {
 
 namespace ArenaToVtx {
 
-inline VTX::Vector ToVtxVector(const ArenaVec3& v) { return {v.x, v.y, v.z}; }
-inline VTX::Quat   ToVtxQuat(const ArenaQuat& q)   { return {q.x, q.y, q.z, q.w}; }
+    inline VTX::Vector ToVtxVector(const ArenaVec3& v) {
+        return {v.x, v.y, v.z};
+    }
+    inline VTX::Quat ToVtxQuat(const ArenaQuat& q) {
+        return {q.x, q.y, q.z, q.w};
+    }
 
-/// Player → entity_type_id 0
-///   string[0]=UniqueID  string[1]=Name
-///   int32[0]=Team       int32[1]=Score   int32[2]=Deaths
-///   float[0]=Health     float[1]=Armor
-///   vector[0]=Position  vector[1]=Velocity
-///   quat[0]=Rotation
-///   bool[0]=IsAlive
-inline VTX::PropertyContainer MapPlayer(const ArenaPlayer& p) {
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 0;
-    pc.string_properties = { p.unique_id, p.name };
-    pc.int32_properties  = { p.team, p.score, p.deaths };
-    pc.float_properties  = { p.health, p.armor };
-    pc.vector_properties = { ToVtxVector(p.position), ToVtxVector(p.velocity) };
-    pc.quat_properties   = { ToVtxQuat(p.rotation) };
-    pc.bool_properties   = { p.is_alive };
-    return pc;
-}
+    /// Player → entity_type_id 0
+    ///   string[0]=UniqueID  string[1]=Name
+    ///   int32[0]=Team       int32[1]=Score   int32[2]=Deaths
+    ///   float[0]=Health     float[1]=Armor
+    ///   vector[0]=Position  vector[1]=Velocity
+    ///   quat[0]=Rotation
+    ///   bool[0]=IsAlive
+    inline VTX::PropertyContainer MapPlayer(const ArenaPlayer& p) {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {p.unique_id, p.name};
+        pc.int32_properties = {p.team, p.score, p.deaths};
+        pc.float_properties = {p.health, p.armor};
+        pc.vector_properties = {ToVtxVector(p.position), ToVtxVector(p.velocity)};
+        pc.quat_properties = {ToVtxQuat(p.rotation)};
+        pc.bool_properties = {p.is_alive};
+        return pc;
+    }
 
-/// Projectile → entity_type_id 1
-///   string[0]=UniqueID  string[1]=OwnerID  string[2]=Type
-///   vector[0]=Position  vector[1]=Velocity
-///   float[0]=Damage
-inline VTX::PropertyContainer MapProjectile(const ArenaProjectile& pr) {
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 1;
-    pc.string_properties = { pr.unique_id, pr.owner_id, pr.type };
-    pc.vector_properties = { ToVtxVector(pr.position), ToVtxVector(pr.velocity) };
-    pc.float_properties  = { pr.damage };
-    return pc;
-}
+    /// Projectile → entity_type_id 1
+    ///   string[0]=UniqueID  string[1]=OwnerID  string[2]=Type
+    ///   vector[0]=Position  vector[1]=Velocity
+    ///   float[0]=Damage
+    inline VTX::PropertyContainer MapProjectile(const ArenaProjectile& pr) {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 1;
+        pc.string_properties = {pr.unique_id, pr.owner_id, pr.type};
+        pc.vector_properties = {ToVtxVector(pr.position), ToVtxVector(pr.velocity)};
+        pc.float_properties = {pr.damage};
+        return pc;
+    }
 
-/// MatchState → entity_type_id 2
-///   string[0]=UniqueID  string[1]=Phase
-///   int32[0]=ScoreTeam1  int32[1]=ScoreTeam2  int32[2]=Round
-///   float[0]=TimeRemaining
-inline VTX::PropertyContainer MapMatchState(const ArenaMatchState& m) {
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 2;
-    pc.string_properties = { "match_001", m.phase };
-    pc.int32_properties  = { m.score_team1, m.score_team2, m.round };
-    pc.float_properties  = { m.time_remaining };
-    return pc;
-}
+    /// MatchState → entity_type_id 2
+    ///   string[0]=UniqueID  string[1]=Phase
+    ///   int32[0]=ScoreTeam1  int32[1]=ScoreTeam2  int32[2]=Round
+    ///   float[0]=TimeRemaining
+    inline VTX::PropertyContainer MapMatchState(const ArenaMatchState& m) {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 2;
+        pc.string_properties = {"match_001", m.phase};
+        pc.int32_properties = {m.score_team1, m.score_team2, m.round};
+        pc.float_properties = {m.time_remaining};
+        return pc;
+    }
 
-/// Full frame → single "entity" bucket.
-inline VTX::Frame MapFrame(const ArenaFrame& af) {
-    VTX::Frame frame;
-    VTX::Bucket& bucket = frame.CreateBucket("entity");
-    for (const auto& p  : af.players)     { bucket.unique_ids.push_back(p.unique_id);  bucket.entities.push_back(MapPlayer(p)); }
-    for (const auto& pr : af.projectiles) { bucket.unique_ids.push_back(pr.unique_id); bucket.entities.push_back(MapProjectile(pr)); }
-    bucket.unique_ids.push_back("match_001");
-    bucket.entities.push_back(MapMatchState(af.match_state));
-    return frame;
-}
+    /// Full frame → single "entity" bucket.
+    inline VTX::Frame MapFrame(const ArenaFrame& af) {
+        VTX::Frame frame;
+        VTX::Bucket& bucket = frame.CreateBucket("entity");
+        for (const auto& p : af.players) {
+            bucket.unique_ids.push_back(p.unique_id);
+            bucket.entities.push_back(MapPlayer(p));
+        }
+        for (const auto& pr : af.projectiles) {
+            bucket.unique_ids.push_back(pr.unique_id);
+            bucket.entities.push_back(MapProjectile(pr));
+        }
+        bucket.unique_ids.push_back("match_001");
+        bucket.entities.push_back(MapMatchState(af.match_state));
+        return frame;
+    }
 
 } // namespace ArenaToVtx
diff --git a/samples/basic_diff.cpp b/samples/basic_diff.cpp
index cf283ce..fa6b3f5 100644
--- a/samples/basic_diff.cpp
+++ b/samples/basic_diff.cpp
@@ -25,30 +25,34 @@
 
 namespace {
 
-const char* OpName(VtxDiff::DiffOperation op) {
-    switch (op) {
-        case VtxDiff::DiffOperation::Add:          return "Add";
-        case VtxDiff::DiffOperation::Remove:       return "Remove";
-        case VtxDiff::DiffOperation::Replace:      return "Replace";
-        case VtxDiff::DiffOperation::ReplaceRange: return "ReplaceRange";
+    const char* OpName(VtxDiff::DiffOperation op) {
+        switch (op) {
+        case VtxDiff::DiffOperation::Add:
+            return "Add";
+        case VtxDiff::DiffOperation::Remove:
+            return "Remove";
+        case VtxDiff::DiffOperation::Replace:
+            return "Replace";
+        case VtxDiff::DiffOperation::ReplaceRange:
+            return "ReplaceRange";
+        }
+        return "?";
     }
-    return "?";
-}
 
-std::string PathToString(const VtxDiff::DiffIndexPath& p) {
-    std::string s = "[";
-    for (size_t i = 0; i < p.count; ++i) {
-        if (i > 0) s += ",";
-        s += std::to_string(p.indices[i]);
+    std::string PathToString(const VtxDiff::DiffIndexPath& p) {
+        std::string s = "[";
+        for (size_t i = 0; i < p.count; ++i) {
+            if (i > 0)
+                s += ",";
+            s += std::to_string(p.indices[i]);
+        }
+        s += "]";
+        return s;
     }
-    s += "]";
-    return s;
-}
 
 } // namespace
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
     std::string filepath = "content/reader/arena/arena_from_fbs_ds.vtx";
     bool fail_on_empty = false;
 
@@ -99,7 +103,7 @@ int main(int argc, char* argv[])
     // ---- Run the diff ----------------------------------------------------
     VtxDiff::DiffOptions opts;
     opts.compare_floats_with_epsilon = true;
-    opts.float_epsilon               = 1e-5f;
+    opts.float_epsilon = 1e-5f;
 
     VtxDiff::PatchIndex patch = differ->DiffRawFrames(bytes_a, raw_b, opts);
 
@@ -110,15 +114,11 @@ int main(int argc, char* argv[])
     constexpr size_t kDetailLimit = 20;
     for (size_t i = 0; i < patch.operations.size() && i < kDetailLimit; ++i) {
         const auto& op = patch.operations[i];
-        VTX_INFO("  {:>12} container={} path={} actor='{}'",
-                 OpName(op.Operation),
-                 VtxDiff::TypeToFieldName(op.ContainerType),
-                 PathToString(op.Path),
-                 op.ActorId);
+        VTX_INFO("  {:>12} container={} path={} actor='{}'", OpName(op.Operation),
+                 VtxDiff::TypeToFieldName(op.ContainerType), PathToString(op.Path), op.ActorId);
     }
     if (patch.operations.size() > kDetailLimit) {
-        VTX_INFO("  ... {} more operation(s) suppressed",
-                 patch.operations.size() - kDetailLimit);
+        VTX_INFO("  ... {} more operation(s) suppressed", patch.operations.size() - kDetailLimit);
     }
 
     if (fail_on_empty && patch.operations.empty()) {
diff --git a/samples/basic_read.cpp b/samples/basic_read.cpp
index 5711d63..f36ac9a 100644
--- a/samples/basic_read.cpp
+++ b/samples/basic_read.cpp
@@ -22,11 +22,8 @@
 
 #include <string>
 
-int main(int argc, char* argv[])
-{
-    const std::string filepath = (argc > 1)
-        ? argv[1]
-        : "content/reader/arena/arena_from_fbs_ds.vtx";
+int main(int argc, char* argv[]) {
+    const std::string filepath = (argc > 1) ? argv[1] : "content/reader/arena/arena_from_fbs_ds.vtx";
 
 
     auto result = VTX::OpenReplayFile(filepath);
diff --git a/samples/basic_write.cpp b/samples/basic_write.cpp
index a2241b7..e0c2a1b 100644
--- a/samples/basic_write.cpp
+++ b/samples/basic_write.cpp
@@ -18,26 +18,21 @@
 
 #include <string>
 
-int main(int argc, char* argv[])
-{
-    const std::string schema_path = (argc > 1)
-        ? argv[1]
-        : "content/writer/arena/arena_schema.json";
-    const std::string output_path = (argc > 2)
-        ? argv[2]
-        : "sample_output.vtx";
+int main(int argc, char* argv[]) {
+    const std::string schema_path = (argc > 1) ? argv[1] : "content/writer/arena/arena_schema.json";
+    const std::string output_path = (argc > 2) ? argv[2] : "sample_output.vtx";
 
     const int frame_count = (argc > 3) ? std::max(1, std::atoi(argv[3])) : 100;
 
     // Configure the writer.
     VTX::WriterFacadeConfig config;
-    config.output_filepath  = output_path;
+    config.output_filepath = output_path;
     config.schema_json_path = schema_path;
-    config.replay_name      = "BasicWriteSample";
-    config.replay_uuid      = "sample-0001";
-    config.default_fps      = 60.0f;
+    config.replay_name = "BasicWriteSample";
+    config.replay_uuid = "sample-0001";
+    config.default_fps = 60.0f;
     config.chunk_max_frames = 500;
-    config.use_compression  = true;
+    config.use_compression = true;
 
     // Create a FlatBuffers writer (use CreateProtobuffWriterFacade for Protobuf).
     auto writer = VTX::CreateFlatBuffersWriterFacade(config);
@@ -61,9 +56,9 @@ int main(int argc, char* argv[])
 
         // Add a transform property (index 0).
         VTX::Transform t;
-        t.translation = { static_cast<double>(i), 0.0, 50.0 };
-        t.rotation    = { 0.0f, 0.0f, 0.0f, 1.0f };
-        t.scale       = { 1.0, 1.0, 1.0 };
+        t.translation = {static_cast<double>(i), 0.0, 50.0};
+        t.rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+        t.scale = {1.0, 1.0, 1.0};
         entity.transform_properties.push_back(t);
 
         bucket.unique_ids.push_back("player_" + std::to_string(i % 10));
@@ -79,6 +74,6 @@ int main(int argc, char* argv[])
     writer->Flush();
     writer->Stop();
 
-    VTX_INFO("Wrote {} frames to {}",frame_count, output_path);
+    VTX_INFO("Wrote {} frames to {}", frame_count, output_path);
     return 0;
 }
diff --git a/samples/generate_replay.cpp b/samples/generate_replay.cpp
index bf8826c..f8b6490 100644
--- a/samples/generate_replay.cpp
+++ b/samples/generate_replay.cpp
@@ -59,27 +59,27 @@
 //  SECTION 1 — Constants
 // ===================================================================
 
-static constexpr int     TOTAL_FRAMES       = 3600;
-static constexpr float   FPS                = 60.0f;
-static constexpr float   DT                 = 1.0f / 60.0f;
-static constexpr int     NUM_PLAYERS        = 10;          // 5v5
-static constexpr double  ARENA_MIN          = -50.0;
-static constexpr double  ARENA_MAX          =  50.0;
-static constexpr int     RESPAWN_FRAMES     = 180;         // 3 s
+static constexpr int TOTAL_FRAMES = 3600;
+static constexpr float FPS = 60.0f;
+static constexpr float DT = 1.0f / 60.0f;
+static constexpr int NUM_PLAYERS = 10; // 5v5
+static constexpr double ARENA_MIN = -50.0;
+static constexpr double ARENA_MAX = 50.0;
+static constexpr int RESPAWN_FRAMES = 180; // 3 s
 
-static constexpr int64_t UTC_TICKS_PER_FRAME = 166'666LL;  // 10^7 / 60
+static constexpr int64_t UTC_TICKS_PER_FRAME = 166'666LL; // 10^7 / 60
 
 // Phase boundaries.
-static constexpr int WARMUP_END  = 300;
+static constexpr int WARMUP_END = 300;
 static constexpr int PLAYING_END = 3300;
 
 // Combat cadence (active during "playing" only).
-static constexpr int PROJ_INTERVAL  = 300;
-static constexpr int PROJ_OFFSET    = 150;
-static constexpr int KILL_INTERVAL  = 600;
-static constexpr int KILL_OFFSET    = 300;
+static constexpr int PROJ_INTERVAL = 300;
+static constexpr int PROJ_OFFSET = 150;
+static constexpr int KILL_INTERVAL = 600;
+static constexpr int KILL_OFFSET = 300;
 static constexpr int KILL_MIN_FRAME = 600;
-static constexpr int PROJ_LIFETIME  = 90;
+static constexpr int PROJ_LIFETIME = 90;
 
 
 // ===================================================================
@@ -89,13 +89,13 @@ static constexpr int PROJ_LIFETIME  = 90;
 struct PlayerSim {
     std::string unique_id;
     std::string name;
-    int   team = 1;
+    int team = 1;
     float health = 100.0f, armor = 50.0f;
     double pos_x = 0, pos_y = 0, pos_z = 0;
     double vel_x = 0, vel_y = 0, vel_z = 0;
-    float  rot_x = 0, rot_y = 0, rot_z = 0, rot_w = 1;
-    bool  is_alive = true;
-    int   score = 0, deaths = 0, respawn_timer = 0;
+    float rot_x = 0, rot_y = 0, rot_z = 0, rot_w = 1;
+    bool is_alive = true;
+    int score = 0, deaths = 0, respawn_timer = 0;
     // Movement params (set once at init).
     double base_x = 0, base_z = 0;
     double freq_x = 0, freq_z = 0;
@@ -106,7 +106,7 @@ struct ProjectileSim {
     std::string unique_id, owner_id;
     double pos_x = 0, pos_y = 0, pos_z = 0;
     double vel_x = 0, vel_y = 0, vel_z = 0;
-    float  damage = 25.0f;
+    float damage = 25.0f;
     std::string type = "bullet";
     int lifetime = PROJ_LIFETIME;
 };
@@ -118,10 +118,10 @@ struct MatchSim {
 };
 
 struct FrameSnapshot {
-    std::vector<PlayerSim>     players;
+    std::vector<PlayerSim> players;
     std::vector<ProjectileSim> projectiles;
-    MatchSim                   match;
-    float   game_time = 0.0f;
+    MatchSim match;
+    float game_time = 0.0f;
     int64_t utc_ticks = 0;
 };
 
@@ -131,17 +131,14 @@ struct FrameSnapshot {
 // ===================================================================
 
 static int64_t GetUtcNowTicks() {
-    auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
-                  std::chrono::system_clock::now().time_since_epoch()).count();
+    auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch())
+                  .count();
     return ns / 100;
 }
 
-static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc)
-{
-    static const char* const kNames[NUM_PLAYERS] = {
-        "Alpha","Bravo","Charlie","Delta","Echo",
-        "Foxtrot","Golf","Hotel","India","Juliet"
-    };
+static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc) {
+    static const char* const kNames[NUM_PLAYERS] = {"Alpha",   "Bravo", "Charlie", "Delta", "Echo",
+                                                    "Foxtrot", "Golf",  "Hotel",   "India", "Juliet"};
 
     uint64_t rng = 42;
     auto rand_d = [&](double lo, double hi) {
@@ -154,14 +151,16 @@ static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc)
     for (int i = 0; i < NUM_PLAYERS; ++i) {
         auto& p = players[i];
         p.unique_id = "player_" + std::to_string(i);
-        p.name  = kNames[i];
-        p.team  = (i < 5) ? 1 : 2;
+        p.name = kNames[i];
+        p.team = (i < 5) ? 1 : 2;
         p.base_x = ARENA_MIN + (ARENA_MAX - ARENA_MIN) * (i + 0.5) / NUM_PLAYERS;
         p.base_z = (p.team == 1) ? -20.0 : 20.0;
-        p.pos_x  = p.base_x;
-        p.pos_z  = p.base_z;
-        p.freq_x = rand_d(0.3, 1.2);  p.freq_z = rand_d(0.3, 1.2);
-        p.phase_x = rand_d(0.0, 6.28); p.phase_z = rand_d(0.0, 6.28);
+        p.pos_x = p.base_x;
+        p.pos_z = p.base_z;
+        p.freq_x = rand_d(0.3, 1.2);
+        p.freq_z = rand_d(0.3, 1.2);
+        p.phase_x = rand_d(0.0, 6.28);
+        p.phase_z = rand_d(0.0, 6.28);
     }
 
     MatchSim match;
@@ -175,23 +174,41 @@ static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc)
         const float t = static_cast<float>(f) * DT;
 
         // Phase.
-        if      (f < WARMUP_END)  { match.phase = "warmup";   match.time_remaining = (WARMUP_END  - f) * DT; }
-        else if (f < PLAYING_END) { match.phase = "playing";  match.time_remaining = (PLAYING_END - f) * DT; }
-        else                      { match.phase = "roundend"; match.time_remaining = (TOTAL_FRAMES- f) * DT; }
+        if (f < WARMUP_END) {
+            match.phase = "warmup";
+            match.time_remaining = (WARMUP_END - f) * DT;
+        } else if (f < PLAYING_END) {
+            match.phase = "playing";
+            match.time_remaining = (PLAYING_END - f) * DT;
+        } else {
+            match.phase = "roundend";
+            match.time_remaining = (TOTAL_FRAMES - f) * DT;
+        }
 
         // Movement.
         for (auto& p : players) {
             if (!p.is_alive) {
-                if (--p.respawn_timer <= 0) { p.is_alive = true; p.health = 100; p.armor = 50; p.pos_x = p.base_x; p.pos_z = p.base_z; }
-                p.vel_x = p.vel_y = p.vel_z = 0; continue;
+                if (--p.respawn_timer <= 0) {
+                    p.is_alive = true;
+                    p.health = 100;
+                    p.armor = 50;
+                    p.pos_x = p.base_x;
+                    p.pos_z = p.base_z;
+                }
+                p.vel_x = p.vel_y = p.vel_z = 0;
+                continue;
             }
             double px = p.pos_x, pz = p.pos_z;
             p.pos_x = std::clamp(p.base_x + 15.0 * std::sin(p.freq_x * t + p.phase_x), ARENA_MIN, ARENA_MAX);
             p.pos_z = std::clamp(p.base_z + 10.0 * std::sin(p.freq_z * t + p.phase_z), ARENA_MIN, ARENA_MAX);
-            p.vel_x = (p.pos_x - px) / DT;  p.vel_z = (p.pos_z - pz) / DT;  p.vel_y = 0;
+            p.vel_x = (p.pos_x - px) / DT;
+            p.vel_z = (p.pos_z - pz) / DT;
+            p.vel_y = 0;
             if (std::abs(p.vel_x) > 0.001 || std::abs(p.vel_z) > 0.001) {
                 float yaw = std::atan2(float(p.vel_x), float(p.vel_z));
-                p.rot_y = std::sin(yaw * 0.5f); p.rot_w = std::cos(yaw * 0.5f); p.rot_x = p.rot_z = 0;
+                p.rot_y = std::sin(yaw * 0.5f);
+                p.rot_w = std::cos(yaw * 0.5f);
+                p.rot_x = p.rot_z = 0;
             }
         }
 
@@ -203,7 +220,9 @@ static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc)
                     ProjectileSim proj;
                     proj.unique_id = "proj_" + std::to_string(next_proj_id++);
                     proj.owner_id = players[si].unique_id;
-                    proj.pos_x = players[si].pos_x; proj.pos_y = 1.0; proj.pos_z = players[si].pos_z;
+                    proj.pos_x = players[si].pos_x;
+                    proj.pos_y = 1.0;
+                    proj.pos_z = players[si].pos_z;
                     proj.vel_z = (players[si].team == 1) ? 30.0 : -30.0;
                     projectiles.push_back(std::move(proj));
                 }
@@ -212,20 +231,33 @@ static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc)
                 int ki = ((f / KILL_INTERVAL) * 3) % NUM_PLAYERS;
                 int vi = (ki + 5) % NUM_PLAYERS;
                 if (players[ki].is_alive && players[vi].is_alive) {
-                    players[vi].health = 0; players[vi].armor = 0; players[vi].is_alive = false;
-                    players[vi].respawn_timer = RESPAWN_FRAMES; players[vi].deaths++;
+                    players[vi].health = 0;
+                    players[vi].armor = 0;
+                    players[vi].is_alive = false;
+                    players[vi].respawn_timer = RESPAWN_FRAMES;
+                    players[vi].deaths++;
                     players[ki].score++;
-                    if (players[ki].team == 1) match.score_team1++; else match.score_team2++;
+                    if (players[ki].team == 1)
+                        match.score_team1++;
+                    else
+                        match.score_team2++;
                 }
             }
         }
 
         // Advance projectiles.
-        for (auto& pr : projectiles) { pr.pos_x += pr.vel_x*DT; pr.pos_y += pr.vel_y*DT; pr.pos_z += pr.vel_z*DT; pr.lifetime--; }
-        std::erase_if(projectiles, [](auto& p){ return p.lifetime <= 0; });
+        for (auto& pr : projectiles) {
+            pr.pos_x += pr.vel_x * DT;
+            pr.pos_y += pr.vel_y * DT;
+            pr.pos_z += pr.vel_z * DT;
+            pr.lifetime--;
+        }
+        std::erase_if(projectiles, [](auto& p) { return p.lifetime <= 0; });
 
         FrameSnapshot snap;
-        snap.players = players; snap.projectiles = projectiles; snap.match = match;
+        snap.players = players;
+        snap.projectiles = projectiles;
+        snap.match = match;
         snap.game_time = t;
         snap.utc_ticks = base_utc + int64_t(f) * UTC_TICKS_PER_FRAME;
         frames.push_back(std::move(snap));
@@ -239,46 +271,57 @@ static std::vector<FrameSnapshot> RunSimulation(int64_t base_utc)
 // ===================================================================
 
 // ---- 4a: JSON ----
-static void ExportJsonSource(const std::vector<FrameSnapshot>& frames, const std::string& path)
-{
+static void ExportJsonSource(const std::vector<FrameSnapshot>& frames, const std::string& path) {
     nlohmann::json root;
-    root["replay_name"]      = "Arena Sample Replay";
-    root["total_frames"]     = TOTAL_FRAMES;
-    root["fps"]              = int(FPS);
+    root["replay_name"] = "Arena Sample Replay";
+    root["total_frames"] = TOTAL_FRAMES;
+    root["fps"] = int(FPS);
     root["duration_seconds"] = double(TOTAL_FRAMES) / FPS;
 
-    auto& jf = root["frames"];  jf = nlohmann::json::array();
+    auto& jf = root["frames"];
+    jf = nlohmann::json::array();
     for (size_t i = 0; i < frames.size(); ++i) {
         const auto& s = frames[i];
         nlohmann::json f;
-        f["frame_index"] = i;  f["game_time"] = s.game_time;  f["utc_ticks"] = s.utc_ticks;
+        f["frame_index"] = i;
+        f["game_time"] = s.game_time;
+        f["utc_ticks"] = s.utc_ticks;
 
         f["players"] = nlohmann::json::array();
         for (const auto& p : s.players)
-            f["players"].push_back({{"unique_id",p.unique_id},{"name",p.name},{"team",p.team},
-                {"health",p.health},{"armor",p.armor},
-                {"position",{{"x",p.pos_x},{"y",p.pos_y},{"z",p.pos_z}}},
-                {"rotation",{{"x",p.rot_x},{"y",p.rot_y},{"z",p.rot_z},{"w",p.rot_w}}},
-                {"velocity",{{"x",p.vel_x},{"y",p.vel_y},{"z",p.vel_z}}},
-                {"is_alive",p.is_alive},{"score",p.score},{"deaths",p.deaths}});
+            f["players"].push_back({{"unique_id", p.unique_id},
+                                    {"name", p.name},
+                                    {"team", p.team},
+                                    {"health", p.health},
+                                    {"armor", p.armor},
+                                    {"position", {{"x", p.pos_x}, {"y", p.pos_y}, {"z", p.pos_z}}},
+                                    {"rotation", {{"x", p.rot_x}, {"y", p.rot_y}, {"z", p.rot_z}, {"w", p.rot_w}}},
+                                    {"velocity", {{"x", p.vel_x}, {"y", p.vel_y}, {"z", p.vel_z}}},
+                                    {"is_alive", p.is_alive},
+                                    {"score", p.score},
+                                    {"deaths", p.deaths}});
 
         f["projectiles"] = nlohmann::json::array();
         for (const auto& pr : s.projectiles)
-            f["projectiles"].push_back({{"unique_id",pr.unique_id},{"owner_id",pr.owner_id},
-                {"position",{{"x",pr.pos_x},{"y",pr.pos_y},{"z",pr.pos_z}}},
-                {"velocity",{{"x",pr.vel_x},{"y",pr.vel_y},{"z",pr.vel_z}}},
-                {"damage",pr.damage},{"type",pr.type}});
-
-        f["match_state"] = {{"score_team1",s.match.score_team1},{"score_team2",s.match.score_team2},
-            {"round",s.match.round},{"phase",s.match.phase},{"time_remaining",s.match.time_remaining}};
+            f["projectiles"].push_back({{"unique_id", pr.unique_id},
+                                        {"owner_id", pr.owner_id},
+                                        {"position", {{"x", pr.pos_x}, {"y", pr.pos_y}, {"z", pr.pos_z}}},
+                                        {"velocity", {{"x", pr.vel_x}, {"y", pr.vel_y}, {"z", pr.vel_z}}},
+                                        {"damage", pr.damage},
+                                        {"type", pr.type}});
+
+        f["match_state"] = {{"score_team1", s.match.score_team1},
+                            {"score_team2", s.match.score_team2},
+                            {"round", s.match.round},
+                            {"phase", s.match.phase},
+                            {"time_remaining", s.match.time_remaining}};
         jf.push_back(std::move(f));
     }
     std::ofstream(path) << root.dump(2);
 }
 
 // ---- 4b: Protobuf binary ----
-static void ExportProtoSource(const std::vector<FrameSnapshot>& frames, const std::string& path)
-{
+static void ExportProtoSource(const std::vector<FrameSnapshot>& frames, const std::string& path) {
     ::arena_pb::ArenaReplay replay;
     replay.set_replay_name("Arena Sample Replay");
     replay.set_total_frames(TOTAL_FRAMES);
@@ -294,23 +337,49 @@ static void ExportProtoSource(const std::vector<FrameSnapshot>& frames, const st
 
         for (const auto& p : s.players) {
             auto* pp = fd->add_players();
-            pp->set_unique_id(p.unique_id);  pp->set_name(p.name);  pp->set_team(p.team);
-            pp->set_health(p.health);        pp->set_armor(p.armor);
-            auto* pos = pp->mutable_position(); pos->set_x(p.pos_x); pos->set_y(p.pos_y); pos->set_z(p.pos_z);
-            auto* rot = pp->mutable_rotation(); rot->set_x(p.rot_x); rot->set_y(p.rot_y); rot->set_z(p.rot_z); rot->set_w(p.rot_w);
-            auto* vel = pp->mutable_velocity(); vel->set_x(p.vel_x); vel->set_y(p.vel_y); vel->set_z(p.vel_z);
-            pp->set_is_alive(p.is_alive);    pp->set_score(p.score);  pp->set_deaths(p.deaths);
+            pp->set_unique_id(p.unique_id);
+            pp->set_name(p.name);
+            pp->set_team(p.team);
+            pp->set_health(p.health);
+            pp->set_armor(p.armor);
+            auto* pos = pp->mutable_position();
+            pos->set_x(p.pos_x);
+            pos->set_y(p.pos_y);
+            pos->set_z(p.pos_z);
+            auto* rot = pp->mutable_rotation();
+            rot->set_x(p.rot_x);
+            rot->set_y(p.rot_y);
+            rot->set_z(p.rot_z);
+            rot->set_w(p.rot_w);
+            auto* vel = pp->mutable_velocity();
+            vel->set_x(p.vel_x);
+            vel->set_y(p.vel_y);
+            vel->set_z(p.vel_z);
+            pp->set_is_alive(p.is_alive);
+            pp->set_score(p.score);
+            pp->set_deaths(p.deaths);
         }
         for (const auto& pr : s.projectiles) {
             auto* pp = fd->add_projectiles();
-            pp->set_unique_id(pr.unique_id);  pp->set_owner_id(pr.owner_id);
-            auto* pos = pp->mutable_position(); pos->set_x(pr.pos_x); pos->set_y(pr.pos_y); pos->set_z(pr.pos_z);
-            auto* vel = pp->mutable_velocity(); vel->set_x(pr.vel_x); vel->set_y(pr.vel_y); vel->set_z(pr.vel_z);
-            pp->set_damage(pr.damage);  pp->set_type(pr.type);
+            pp->set_unique_id(pr.unique_id);
+            pp->set_owner_id(pr.owner_id);
+            auto* pos = pp->mutable_position();
+            pos->set_x(pr.pos_x);
+            pos->set_y(pr.pos_y);
+            pos->set_z(pr.pos_z);
+            auto* vel = pp->mutable_velocity();
+            vel->set_x(pr.vel_x);
+            vel->set_y(pr.vel_y);
+            vel->set_z(pr.vel_z);
+            pp->set_damage(pr.damage);
+            pp->set_type(pr.type);
         }
         auto* ms = fd->mutable_match_state();
-        ms->set_score_team1(s.match.score_team1);  ms->set_score_team2(s.match.score_team2);
-        ms->set_round(s.match.round);  ms->set_phase(s.match.phase);  ms->set_time_remaining(s.match.time_remaining);
+        ms->set_score_team1(s.match.score_team1);
+        ms->set_score_team2(s.match.score_team2);
+        ms->set_round(s.match.round);
+        ms->set_phase(s.match.phase);
+        ms->set_time_remaining(s.match.time_remaining);
     }
 
     std::ofstream ofs(path, std::ios::binary);
@@ -318,43 +387,52 @@ static void ExportProtoSource(const std::vector<FrameSnapshot>& frames, const st
 }
 
 // ---- 4c: FlatBuffers binary ----
-static void ExportFbsSource(const std::vector<FrameSnapshot>& frames, const std::string& path)
-{
+static void ExportFbsSource(const std::vector<FrameSnapshot>& frames, const std::string& path) {
     // Build using the Object API (ArenaReplayT, FrameDataT, PlayerT, ...).
     ::arena_fb::ArenaReplayT replay;
-    replay.replay_name      = "Arena Sample Replay";
-    replay.total_frames     = TOTAL_FRAMES;
-    replay.fps              = int(FPS);
+    replay.replay_name = "Arena Sample Replay";
+    replay.total_frames = TOTAL_FRAMES;
+    replay.fps = int(FPS);
     replay.duration_seconds = double(TOTAL_FRAMES) / FPS;
 
     for (size_t i = 0; i < frames.size(); ++i) {
         const auto& s = frames[i];
         auto fd = std::make_unique<::arena_fb::FrameDataT>();
         fd->frame_index = int(i);
-        fd->game_time   = s.game_time;
-        fd->utc_ticks   = s.utc_ticks;
+        fd->game_time = s.game_time;
+        fd->utc_ticks = s.utc_ticks;
 
         for (const auto& p : s.players) {
             auto pp = std::make_unique<::arena_fb::PlayerT>();
-            pp->unique_id = p.unique_id;  pp->name = p.name;  pp->team = p.team;
-            pp->health = p.health;        pp->armor = p.armor;
+            pp->unique_id = p.unique_id;
+            pp->name = p.name;
+            pp->team = p.team;
+            pp->health = p.health;
+            pp->armor = p.armor;
             pp->position = std::make_unique<::arena_fb::Vec3>(p.pos_x, p.pos_y, p.pos_z);
             pp->rotation = std::make_unique<::arena_fb::Rotation>(p.rot_x, p.rot_y, p.rot_z, p.rot_w);
             pp->velocity = std::make_unique<::arena_fb::Vec3>(p.vel_x, p.vel_y, p.vel_z);
-            pp->is_alive = p.is_alive;    pp->score = p.score;  pp->deaths = p.deaths;
+            pp->is_alive = p.is_alive;
+            pp->score = p.score;
+            pp->deaths = p.deaths;
             fd->players.push_back(std::move(pp));
         }
         for (const auto& pr : s.projectiles) {
             auto pp = std::make_unique<::arena_fb::ProjectileT>();
-            pp->unique_id = pr.unique_id;  pp->owner_id = pr.owner_id;
+            pp->unique_id = pr.unique_id;
+            pp->owner_id = pr.owner_id;
             pp->position = std::make_unique<::arena_fb::Vec3>(pr.pos_x, pr.pos_y, pr.pos_z);
             pp->velocity = std::make_unique<::arena_fb::Vec3>(pr.vel_x, pr.vel_y, pr.vel_z);
-            pp->damage = pr.damage;  pp->type = pr.type;
+            pp->damage = pr.damage;
+            pp->type = pr.type;
             fd->projectiles.push_back(std::move(pp));
         }
         auto ms = std::make_unique<::arena_fb::MatchStateT>();
-        ms->score_team1 = s.match.score_team1;  ms->score_team2 = s.match.score_team2;
-        ms->round = s.match.round;  ms->phase = s.match.phase;  ms->time_remaining = s.match.time_remaining;
+        ms->score_team1 = s.match.score_team1;
+        ms->score_team2 = s.match.score_team2;
+        ms->round = s.match.round;
+        ms->phase = s.match.phase;
+        ms->time_remaining = s.match.time_remaining;
         fd->match_state = std::move(ms);
 
         replay.frames.push_back(std::move(fd));
@@ -369,17 +447,16 @@ static void ExportFbsSource(const std::vector<FrameSnapshot>& frames, const std:
 
 
 // ===================================================================
-int main()
-{
-    const std::string schema_path   = "content/writer/arena/arena_schema.json";
-    const std::string writer_dir    = "content/writer/arena";
-    const std::string reader_dir    = "content/reader/arena";
+int main() {
+    const std::string schema_path = "content/writer/arena/arena_schema.json";
+    const std::string writer_dir = "content/writer/arena";
+    const std::string reader_dir = "content/reader/arena";
 
     std::filesystem::create_directories(writer_dir);
     std::filesystem::create_directories(reader_dir);
 
     VTX_INFO("=== Arena Replay Generator ===");
-    VTX_INFO("Simulating {} frames ({:.1f}s @ {:.0f} FPS)...", TOTAL_FRAMES, double(TOTAL_FRAMES)/FPS, FPS);
+    VTX_INFO("Simulating {} frames ({:.1f}s @ {:.0f} FPS)...", TOTAL_FRAMES, double(TOTAL_FRAMES) / FPS, FPS);
 
     // ---- Phase 1: Simulate ----
     // Use a fixed historical timestamp so the data is reproducible across
@@ -389,9 +466,9 @@ int main()
     VTX_INFO("Simulation complete: {} frames, {} players.", int(sim_frames.size()), NUM_PLAYERS);
 
     // ---- Phase 2: Export 3 data-source files ----
-    const std::string json_src  = writer_dir + "/arena_replay_data.json";
+    const std::string json_src = writer_dir + "/arena_replay_data.json";
     const std::string proto_src = writer_dir + "/arena_replay_data.proto.bin";
-    const std::string fbs_src   = writer_dir + "/arena_replay_data.fbs.bin";
+    const std::string fbs_src = writer_dir + "/arena_replay_data.fbs.bin";
 
     ExportJsonSource(sim_frames, json_src);
     VTX_INFO("Exported data source: {}", json_src);
diff --git a/sdk/include/vtx/common/adapters/flatbuffer/flatbuffer_adapter.h b/sdk/include/vtx/common/adapters/flatbuffer/flatbuffer_adapter.h
index 3b41975..1c23a92 100644
--- a/sdk/include/vtx/common/adapters/flatbuffer/flatbuffer_adapter.h
+++ b/sdk/include/vtx/common/adapters/flatbuffer/flatbuffer_adapter.h
@@ -36,8 +36,8 @@ namespace VTX {
      */
     template <typename CppType, typename CppMemberType, typename FbTable, typename FbReturnType>
     struct FastField {
-        CppMemberType CppType::* cpp_member;        //  &BBChampion::Kills
-        FbReturnType(FbTable::* fb_accessor)() const; // &FB::Champion::kills()
+        CppMemberType CppType::*cpp_member;           //  &BBChampion::Kills
+        FbReturnType (FbTable::*fb_accessor)() const; // &FB::Champion::kills()
     };
 
     /**
@@ -47,8 +47,8 @@ namespace VTX {
      * @return FastField instance.
      */
     template <typename CppType, typename CppMemberType, typename FbTable, typename FbReturnType>
-    constexpr auto MapFB(CppMemberType CppType::* cpp_ptr, FbReturnType(FbTable::* fb_ptr)() const) {
-        return FastField<CppType, CppMemberType, FbTable, FbReturnType>{cpp_ptr, fb_ptr};
+    constexpr auto MapFB(CppMemberType CppType::*cpp_ptr, FbReturnType (FbTable::*fb_ptr)() const) {
+        return FastField<CppType, CppMemberType, FbTable, FbReturnType> {cpp_ptr, fb_ptr};
     }
 
     /**
@@ -61,23 +61,21 @@ namespace VTX {
     public:
         template <typename T>
         static T Load(const typename FlatBufferMapping<T>::FbType* fb_table) {
-            T instance{};
+            T instance {};
 
-            if (!fb_table) return instance;
+            if (!fb_table)
+                return instance;
 
             // Retrieve the compile-time mapping tuple
             constexpr auto mapping = FlatBufferMapping<T>::GetFields();
 
             // Iterate over all mapped fields and process them
-            std::apply([&](auto&&... fields) {
-                (ProcessField(instance, fb_table, fields), ...);
-                }, mapping);
+            std::apply([&](auto&&... fields) { (ProcessField(instance, fb_table, fields), ...); }, mapping);
 
             return instance;
         }
 
     private:
-
         /**
          * @brief Processes a single field mapping.
          * @details Calls the FB accessor, converts the type if necessary, and assigns to the C++ member.
@@ -99,29 +97,26 @@ namespace VTX {
 
         /** @brief Conversion for arithmetic types (int, float, etc.). */
         template <typename Target, typename Source>
-        static std::enable_if_t<std::is_arithmetic_v<Target>, Target>
-            Convert(Source fb_val) {
+        static std::enable_if_t<std::is_arithmetic_v<Target>, Target> Convert(Source fb_val) {
             return static_cast<Target>(fb_val);
         }
 
         /** @brief Conversion for Enum types. */
         template <typename Target, typename Source>
-        static std::enable_if_t<std::is_enum_v<Target>, Target>
-            Convert(Source fb_val) {
+        static std::enable_if_t<std::is_enum_v<Target>, Target> Convert(Source fb_val) {
             return static_cast<Target>(fb_val);
         }
 
         /** @brief Conversion for Strings (FlatBuffer String* -> std::string). */
         template <typename Target>
         static std::enable_if_t<std::is_same_v<Target, std::string>, std::string>
-            Convert(const flatbuffers::String* fb_str) {
+        Convert(const flatbuffers::String* fb_str) {
             return fb_str ? fb_str->str() : "";
         }
 
         /** @brief Recursive conversion for nested structures (Sub-tables). */
         template <typename Target, typename FbSubTable>
-        static std::enable_if_t<has_fb_mapping_v<Target>, Target>
-            Convert(const FbSubTable* fb_sub_table) {
+        static std::enable_if_t<has_fb_mapping_v<Target>, Target> Convert(const FbSubTable* fb_sub_table) {
             Target result;
             if (fb_sub_table) {
                 result = Load<Target>(fb_sub_table);
@@ -135,9 +130,10 @@ namespace VTX {
         */
         template <typename Target, typename FbSubTable>
         static std::enable_if_t<VTX::is_vector_v<Target>, Target>
-            Convert(const flatbuffers::Vector<flatbuffers::Offset<FbSubTable>>* fb_vector) {
+        Convert(const flatbuffers::Vector<flatbuffers::Offset<FbSubTable>>* fb_vector) {
             Target result;
-            if (!fb_vector) return result;
+            if (!fb_vector)
+                return result;
 
             using ElementType = typename Target::value_type;
 
@@ -148,8 +144,7 @@ namespace VTX {
 
                 if constexpr (has_fb_mapping_v<ElementType>) {
                     result.push_back(Load<ElementType>(fb_element));
-                }
-                else {
+                } else {
                     result.push_back(static_cast<ElementType>(*fb_element));
                 }
             }
@@ -161,10 +156,10 @@ namespace VTX {
         * @brief Conversion for Vectors of Pointers (Structs in FB are often pointers).
         */
         template <typename Target, typename U>
-        static std::enable_if_t<VTX::is_vector_v<Target>, Target>
-            Convert(const flatbuffers::Vector<const U*>* fb_vec) {
+        static std::enable_if_t<VTX::is_vector_v<Target>, Target> Convert(const flatbuffers::Vector<const U*>* fb_vec) {
             Target result;
-            if (!fb_vec) return result;
+            if (!fb_vec)
+                return result;
 
             result.reserve(fb_vec->size());
             for (const U* element : *fb_vec) {
@@ -174,4 +169,4 @@ namespace VTX {
             return result;
         }
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/common/adapters/json/json_adapter.h b/sdk/include/vtx/common/adapters/json/json_adapter.h
index 908a4b4..c0a1059 100644
--- a/sdk/include/vtx/common/adapters/json/json_adapter.h
+++ b/sdk/include/vtx/common/adapters/json/json_adapter.h
@@ -14,7 +14,7 @@
 #pragma once
 #include <nlohmann/json.hpp>
 
-namespace VTX{
+namespace VTX {
 
     /**
      * @class JsonAdapter
@@ -24,100 +24,99 @@ namespace VTX{
      */
     class JsonAdapter {
         const nlohmann::json* node = nullptr;
-        public:
 
-            JsonAdapter() {}
-            /**
+    public:
+        JsonAdapter() {}
+        /**
              * @brief Explicit constructor.
              * @param j Constant reference to the JSON node to wrap.
              */
-            JsonAdapter(const nlohmann::json& j) : node(&j) {}
+        JsonAdapter(const nlohmann::json& j)
+            : node(&j) {}
 
-            /**
+        /**
              * @brief Checks if a specific key exists in the current object.
              * @param key The key string to search for.
              * @return true If the node is an object and contains the key.
              * @return false If the node is not an object or the key is missing.
              */
-            bool HasKey(const std::string& key) const {
-                if (!node->is_object()) {
-                    return false;
-                }
-                return node->contains(key);
+        bool HasKey(const std::string& key) const {
+            if (!node->is_object()) {
+                return false;
             }
+            return node->contains(key);
+        }
 
 
-            /**
+        /**
              * @brief Extracts a value of the specified type.
              * @tparam T The target type (int, float, std::string, bool, etc.).
              * @return T The converted value from the JSON node.
              * @throws nlohmann::json::type_error If the conversion is invalid.
              */
-            template <typename T>
-            T GetValue() const {
-                return node->get<T>();
-            }
+        template <typename T>
+        T GetValue() const {
+            return node->get<T>();
+        }
 
-            /**
+        /**
              * @brief Retrieves a child adapter for a specific key.
              * @param key The key of the child node.
              * @return JsonAdapter A new adapter instance pointing to the child node.
              * @throws nlohmann::json::out_of_range If the key does not exist.
              */
-            JsonAdapter GetChild(const std::string& key) const {
-                if (!IsMap()) return JsonAdapter(); 
-                if (!node->contains(key)) return JsonAdapter();
-                return JsonAdapter(node->at(key));
-            }
+        JsonAdapter GetChild(const std::string& key) const {
+            if (!IsMap())
+                return JsonAdapter();
+            if (!node->contains(key))
+                return JsonAdapter();
+            return JsonAdapter(node->at(key));
+        }
 
-            /**
+        /**
              * @brief Checks if the current node represents an array.
              * @return true If it is an array, false otherwise.
              */
-            bool IsArray() const { 
-                return node->is_array();
-            }
+        bool IsArray() const { return node->is_array(); }
 
-            /**
+        /**
              * @brief Gets the number of elements in the array.
              * @return size_t Number of elements.
              */
-            size_t Size() const {
-                return node->size(); 
-            }
+        size_t Size() const { return node->size(); }
 
-            /**
+        /**
              * @brief Retrieves an adapter for a specific element in an array.
              * @param index The zero-based index of the element.
              * @return JsonAdapter Adapter for the element at the given index.
              */
-            JsonAdapter GetElement(size_t index) const {
-                if (!node || !node->is_array()) {
-                    throw std::runtime_error("JsonAdapter: GetElement attempted to access a none array object");
-                }
-                // Usamos .at() que es más seguro (lanza excepción si el índice no existe)
-                return JsonAdapter(node->at(index));
+        JsonAdapter GetElement(size_t index) const {
+            if (!node || !node->is_array()) {
+                throw std::runtime_error("JsonAdapter: GetElement attempted to access a none array object");
             }
+            // Usamos .at() que es más seguro (lanza excepción si el índice no existe)
+            return JsonAdapter(node->at(index));
+        }
 
-            /**
+        /**
              * @brief Checks if the current node represents a map/object.
              * @return true If it is an object, false otherwise.
              */
-            bool IsMap() const { return node->is_object(); }
+        bool IsMap() const { return node->is_object(); }
 
-            /**
+        /**
              * @brief Retrieves all keys from the current JSON object.
              * @return std::vector<std::string> A list of all keys.
              */
-            std::vector<std::string> GetKeys() const {
-                std::vector<std::string> keys;
-                for (auto& [key, val] : node->items()) {
-                    keys.push_back(key);
-                }
-                return keys;
+        std::vector<std::string> GetKeys() const {
+            std::vector<std::string> keys;
+            for (auto& [key, val] : node->items()) {
+                keys.push_back(key);
             }
+            return keys;
+        }
 
-            /**
+        /**
              * @brief Converts a string key from the JSON map to a specific target type.
              * @details Useful for deserializing `std::map<int, T>` or `std::map<Enum, T>` where
              * JSON only supports string keys.
@@ -125,22 +124,19 @@ namespace VTX{
              * @param key_str The key as a string.
              * @return KeyType The parsed key value.
              */
-            template <typename KeyType>
-            KeyType ParseKey(const std::string& key_str) const {
-                if constexpr (std::is_same_v<KeyType, std::string>) {
-                    return key_str;
-                }
-                else if constexpr (std::is_integral_v<KeyType>) {
-                    return static_cast<KeyType>(std::stoll(key_str));
-                }
-                else if constexpr (std::is_enum_v<KeyType>) {
-                    // Attempt to deserialize the enum directly from the string using nlohmann
-                    return nlohmann::json(key_str).get<KeyType>();
-                }
-                else {
-                    static_assert(std::is_void_v<KeyType>, "Key type_max_indices not supported by JsonReader.");
-                    return KeyType{};
-                }
+        template <typename KeyType>
+        KeyType ParseKey(const std::string& key_str) const {
+            if constexpr (std::is_same_v<KeyType, std::string>) {
+                return key_str;
+            } else if constexpr (std::is_integral_v<KeyType>) {
+                return static_cast<KeyType>(std::stoll(key_str));
+            } else if constexpr (std::is_enum_v<KeyType>) {
+                // Attempt to deserialize the enum directly from the string using nlohmann
+                return nlohmann::json(key_str).get<KeyType>();
+            } else {
+                static_assert(std::is_void_v<KeyType>, "Key type_max_indices not supported by JsonReader.");
+                return KeyType {};
             }
+        }
     };
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/adapters/json/json_policy.h b/sdk/include/vtx/common/adapters/json/json_policy.h
index 7c22a38..8120e6b 100644
--- a/sdk/include/vtx/common/adapters/json/json_policy.h
+++ b/sdk/include/vtx/common/adapters/json/json_policy.h
@@ -22,10 +22,10 @@ namespace VTX {
     template <typename Class, typename Type>
     struct Field {
         const char* json_key;
-        Type Class::* member_ptr;
+        Type Class::*member_ptr;
     };
 
-    
+
     /**
      * @brief Helper function to create a Field object with automatic type deduction.
      * @details Simplifies the syntax for defining mappings.
@@ -37,7 +37,7 @@ namespace VTX {
      * @return Field<Class, Type> A initialized Field structure.
      */
     template <typename Class, typename Type>
-    constexpr auto MakeField(const char* name, Type Class::* ptr) {
-        return Field<Class, Type>{name, ptr};
+    constexpr auto MakeField(const char* name, Type Class::*ptr) {
+        return Field<Class, Type> {name, ptr};
     }
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/adapters/protobuff/protobuff_adapter.h b/sdk/include/vtx/common/adapters/protobuff/protobuff_adapter.h
index 461172c..4c42696 100644
--- a/sdk/include/vtx/common/adapters/protobuff/protobuff_adapter.h
+++ b/sdk/include/vtx/common/adapters/protobuff/protobuff_adapter.h
@@ -23,15 +23,14 @@ namespace VTX {
         const google::protobuf::FieldDescriptor* field_desc_; // Null if root or full obj
 
     public:
-        
         explicit ProtobufAdapter(const google::protobuf::Message& msg)
-            : message_(msg), field_desc_(nullptr) {
-        }
+            : message_(msg)
+            , field_desc_(nullptr) {}
 
         //submessage constructor, used internally
         ProtobufAdapter(const google::protobuf::Message& msg, const google::protobuf::FieldDescriptor* fd)
-            : message_(msg), field_desc_(fd) {
-        }
+            : message_(msg)
+            , field_desc_(fd) {}
 
         bool HasKey(const std::string& key) const {
             const auto* descriptor = message_.GetDescriptor();
@@ -40,8 +39,7 @@ namespace VTX {
 
         template <typename T>
         T GetValue() const {
-
-            return T{};
+            return T {};
         }
 
 
@@ -49,17 +47,15 @@ namespace VTX {
             const auto* descriptor = message_.GetDescriptor();
             const auto* field = descriptor->FindFieldByName(key);
 
-            if (!field) throw std::runtime_error("Field not found: " + key);
+            if (!field)
+                throw std::runtime_error("Field not found: " + key);
 
             const auto* reflection = message_.GetReflection();
 
             if (field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
                 if (field->is_repeated()) {
-   
                     return ProtobufAdapter(message_, field);
-                }
-                else
-                {
+                } else {
                     const auto& sub_message = reflection->GetMessage(message_, field);
                     return ProtobufAdapter(sub_message);
                 }
@@ -71,29 +67,25 @@ namespace VTX {
 
         template <typename T>
         T GetValueFromField() const {
-            if (!field_desc) return T{}; // Error
+            if (!field_desc)
+                return T {}; // Error
 
             const auto* ref = message.GetReflection();
 
             if constexpr (std::is_same_v<T, int> || std::is_same_v<T, int32_t>) {
                 return ref->GetInt32(message_, field_desc);
-            }
-            else if constexpr (std::is_same_v<T, int64_t>) {
+            } else if constexpr (std::is_same_v<T, int64_t>) {
                 return ref->GetInt64(message_, field_desc);
-            }
-            else if constexpr (std::is_same_v<T, bool>) {
+            } else if constexpr (std::is_same_v<T, bool>) {
                 return ref->GetBool(message_, field_desc);
-            }
-            else if constexpr (std::is_same_v<T, float>) {
+            } else if constexpr (std::is_same_v<T, float>) {
                 return ref->GetFloat(message_, field_desc);
-            }
-            else if constexpr (std::is_same_v<T, double>) {
+            } else if constexpr (std::is_same_v<T, double>) {
                 return ref->GetDouble(message_, field_desc);
-            }
-            else if constexpr (std::is_same_v<T, std::string>) {
+            } else if constexpr (std::is_same_v<T, std::string>) {
                 return ref->GetString(message_, field_desc);
             }
-            return T{};
+            return T {};
         }
 
         template <typename T>
@@ -101,9 +93,7 @@ namespace VTX {
             return GetValueFromField<T>();
         }
 
-        bool IsArray() const {
-            return field_desc_ && field_desc_->is_repeated();
-        }
+        bool IsArray() const { return field_desc_ && field_desc_->is_repeated(); }
 
         size_t Size() const {
             if (IsArray()) {
@@ -113,7 +103,8 @@ namespace VTX {
         }
 
         ProtobufAdapter GetElement(size_t index) const {
-            if (!IsArray()) throw std::runtime_error("Not an array");
+            if (!IsArray())
+                throw std::runtime_error("Not an array");
 
             const auto* ref = message_.GetReflection();
 
diff --git a/sdk/include/vtx/common/readers/frame_reader/flatbuffer_loader.h b/sdk/include/vtx/common/readers/frame_reader/flatbuffer_loader.h
index 31e585e..d74187c 100644
--- a/sdk/include/vtx/common/readers/frame_reader/flatbuffer_loader.h
+++ b/sdk/include/vtx/common/readers/frame_reader/flatbuffer_loader.h
@@ -12,23 +12,25 @@
 
 namespace VTX {
 
-    template<typename T>
+    template <typename T>
     struct FlatBufferBinding {
-         static_assert(sizeof(T) == 0, "ERROR: Missing Bindings for this FlatBuffer type.");
+        static_assert(sizeof(T) == 0, "ERROR: Missing Bindings for this FlatBuffer type.");
     };
 
     class GenericFlatBufferLoader {
     private:
-        const PropertyAddressCache* cache_; 
+        const PropertyAddressCache* cache_;
         bool debug_mode_;
 
     public:
-        explicit GenericFlatBufferLoader(const PropertyAddressCache& cache, bool debug = false) 
-            : cache_(&cache), debug_mode_(debug) {}
-        
+        explicit GenericFlatBufferLoader(const PropertyAddressCache& cache, bool debug = false)
+            : cache_(&cache)
+            , debug_mode_(debug) {}
+
         template <typename FBType>
         void Load(const FBType* src, PropertyContainer& dest, const std::string& struct_name) {
-            if (!src) return;
+            if (!src)
+                return;
 
             if (dest.entity_type_id == -1) {
                 auto it = cache_->name_to_id.find(struct_name);
@@ -43,13 +45,16 @@ namespace VTX {
 
         template <typename FrameFBType>
         void LoadFrame(const FrameFBType* src, VTX::Frame& dest, const std::string& schemaName) {
-            if (!src) return;
+            if (!src)
+                return;
             FlatBufferBinding<FrameFBType>::TransferToFrame(src, dest, *this, schemaName);
         }
 
         template <typename FBVectorType, typename IdExtractorFunc>
-        void AppendActorList(VTX::Bucket& targetBlock, const std::string& schemaType, const FBVectorType* src_vector, IdExtractorFunc idExtractor) {
-            if (!src_vector || src_vector->size() == 0) return;
+        void AppendActorList(VTX::Bucket& targetBlock, const std::string& schemaType, const FBVectorType* src_vector,
+                             IdExtractorFunc idExtractor) {
+            if (!src_vector || src_vector->size() == 0)
+                return;
             targetBlock.entities.reserve(targetBlock.entities.size() + src_vector->size());
 
             for (auto it = src_vector->begin(); it != src_vector->end(); ++it) {
@@ -58,48 +63,79 @@ namespace VTX {
         }
 
         template <typename FBType, typename IdExtractorFunc>
-        void AppendSingleEntity(VTX::Bucket& targetBlock, const std::string& schemaType, const FBType* src_item, IdExtractorFunc idExtractor) {
-            if (!src_item) return;
+        void AppendSingleEntity(VTX::Bucket& targetBlock, const std::string& schemaType, const FBType* src_item,
+                                IdExtractorFunc idExtractor) {
+            if (!src_item)
+                return;
             ExtractActorWithIdFunc(src_item, targetBlock, schemaType, idExtractor);
         }
-                
+
         template <typename T>
-        void LoadField(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name, const T& value) {
-            
+        void LoadField(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name,
+                       const T& value) {
             auto struct_it = cache_->structs.find(dest.entity_type_id);
-            if (struct_it == cache_->structs.end()) return;
+            if (struct_it == cache_->structs.end())
+                return;
 
             auto prop_it = struct_it->second.properties.find(field_name);
-            if (prop_it == struct_it->second.properties.end()) return;
+            if (prop_it == struct_it->second.properties.end())
+                return;
 
             const PropertyAddress& addr = prop_it->second;
 
             switch (addr.type_id) {
-                case FieldType::String:     StoreValue(dest.string_properties, addr.index, value); break;
-                case FieldType::Int8:
-                case FieldType::Int32:
-                case FieldType::Enum:       StoreValue(dest.int32_properties, addr.index, value);  break;
-                case FieldType::Int64:      StoreValue(dest.int64_properties, addr.index, value);  break;
-                case FieldType::Float:      StoreValue(dest.float_properties, addr.index, value);  break;
-                case FieldType::Double:     StoreValue(dest.double_properties, addr.index, value); break;
-                case FieldType::Bool:       StoreValue(dest.bool_properties, addr.index, value);   break;
-                case FieldType::Vector:     StoreValue(dest.vector_properties, addr.index, value); break;
-                case FieldType::Quat:       StoreValue(dest.quat_properties, addr.index, value);   break;
-                case FieldType::Transform:  StoreValue(dest.transform_properties, addr.index, value); break;
-                case FieldType::FloatRange: StoreValue(dest.range_properties, addr.index, value);  break;
-                case FieldType::Struct: StoreValue(dest.any_struct_properties, addr.index, value); break;
-                default: break;
+            case FieldType::String:
+                StoreValue(dest.string_properties, addr.index, value);
+                break;
+            case FieldType::Int8:
+            case FieldType::Int32:
+            case FieldType::Enum:
+                StoreValue(dest.int32_properties, addr.index, value);
+                break;
+            case FieldType::Int64:
+                StoreValue(dest.int64_properties, addr.index, value);
+                break;
+            case FieldType::Float:
+                StoreValue(dest.float_properties, addr.index, value);
+                break;
+            case FieldType::Double:
+                StoreValue(dest.double_properties, addr.index, value);
+                break;
+            case FieldType::Bool:
+                StoreValue(dest.bool_properties, addr.index, value);
+                break;
+            case FieldType::Vector:
+                StoreValue(dest.vector_properties, addr.index, value);
+                break;
+            case FieldType::Quat:
+                StoreValue(dest.quat_properties, addr.index, value);
+                break;
+            case FieldType::Transform:
+                StoreValue(dest.transform_properties, addr.index, value);
+                break;
+            case FieldType::FloatRange:
+                StoreValue(dest.range_properties, addr.index, value);
+                break;
+            case FieldType::Struct:
+                StoreValue(dest.any_struct_properties, addr.index, value);
+                break;
+            default:
+                break;
             }
         }
 
-        void LoadBlob(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name, const void* data, size_t byte_size) {
-            if (!data || byte_size == 0) return;
+        void LoadBlob(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name,
+                      const void* data, size_t byte_size) {
+            if (!data || byte_size == 0)
+                return;
 
             auto struct_it = cache_->structs.find(dest.entity_type_id);
-            if (struct_it == cache_->structs.end()) return;
+            if (struct_it == cache_->structs.end())
+                return;
 
             auto prop_it = struct_it->second.properties.find(field_name);
-            if (prop_it == struct_it->second.properties.end()) return;
+            if (prop_it == struct_it->second.properties.end())
+                return;
 
             int32_t idx = prop_it->second.index;
             const uint8_t* byte_data = static_cast<const uint8_t*>(data);
@@ -110,14 +146,18 @@ namespace VTX {
         }
 
         template <typename NestedFBType>
-        void LoadStruct(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name, const NestedFBType* src_nested) {
-            if (!src_nested) return;
+        void LoadStruct(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name,
+                        const NestedFBType* src_nested) {
+            if (!src_nested)
+                return;
 
             auto struct_it = cache_->structs.find(dest.entity_type_id);
-            if (struct_it == cache_->structs.end()) return;
+            if (struct_it == cache_->structs.end())
+                return;
 
             auto prop_it = struct_it->second.properties.find(field_name);
-            if (prop_it == struct_it->second.properties.end()) return;
+            if (prop_it == struct_it->second.properties.end())
+                return;
 
             int32_t index = prop_it->second.index;
             const std::string& child_schema = prop_it->second.child_type_name;
@@ -127,40 +167,45 @@ namespace VTX {
         }
 
         template <typename FBVectorType>
-        void LoadArray(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name, const FBVectorType* src_array) {
-            if (!src_array || src_array->size() == 0) return;
+        void LoadArray(PropertyContainer& dest, const std::string& /*struct_name*/, const std::string& field_name,
+                       const FBVectorType* src_array) {
+            if (!src_array || src_array->size() == 0)
+                return;
 
             auto struct_it = cache_->structs.find(dest.entity_type_id);
-            if (struct_it == cache_->structs.end()) return;
+            if (struct_it == cache_->structs.end())
+                return;
 
             auto prop_it = struct_it->second.properties.find(field_name);
-            if (prop_it == struct_it->second.properties.end()) return;
+            if (prop_it == struct_it->second.properties.end())
+                return;
 
             const int32_t idx = prop_it->second.index;
             const FieldType type_id = prop_it->second.type_id;
-        
-            const std::string& child_schema = prop_it->second.child_type_name; 
+
+            const std::string& child_schema = prop_it->second.child_type_name;
             const VTX::FieldContainerType container = prop_it->second.container_type;
-            
+
             using IteratorT = typename FBVectorType::const_iterator;
             using ElementT = typename std::iterator_traits<IteratorT>::value_type;
-        
+
             if constexpr (std::is_pointer_v<ElementT>) {
                 for (auto it = src_array->begin(); it != src_array->end(); ++it) {
-                    const auto* item = *it; 
-                    if (!item) continue;
+                    const auto* item = *it;
+                    if (!item)
+                        continue;
 
                     if (type_id == FieldType::Struct) {
                         PropertyContainer nested_container;
-                        Load(item, nested_container, child_schema); 
-                        
+                        Load(item, nested_container, child_schema);
+
                         if (nested_container.entity_type_id != -1) {
                             if (container == VTX::FieldContainerType::Map) {
-                            
                                 EnsureSize(dest.map_properties, idx);
-                                
+
                                 std::string map_key;
-                                if (!nested_container.string_properties.empty() && !nested_container.string_properties[0].empty()) {
+                                if (!nested_container.string_properties.empty() &&
+                                    !nested_container.string_properties[0].empty()) {
                                     map_key = nested_container.string_properties[0];
                                 } else if (!nested_container.int32_properties.empty()) {
                                     map_key = std::to_string(nested_container.int32_properties[0]);
@@ -170,14 +215,14 @@ namespace VTX {
 
                                 dest.map_properties[idx].keys.push_back(map_key);
                                 dest.map_properties[idx].values.push_back(nested_container);
-                            
+
                             } else {
                                 dest.any_struct_arrays.PushBack(idx, nested_container);
                             }
                         }
                     } else {
                         PropertyContainer temp;
-                        Load(item, temp, child_schema); 
+                        Load(item, temp, child_schema);
                         PushToFlatArray(dest, type_id, idx, temp);
                     }
                 }
@@ -185,51 +230,78 @@ namespace VTX {
                 FillFlatArray(dest, type_id, idx, src_array);
             }
         }
-    
+
     private:
         template <typename FBVectorT>
         void FillFlatArray(PropertyContainer& dest, FieldType type, int32_t idx, const FBVectorT* src) {
-            if (!src) return;
+            if (!src)
+                return;
             for (auto it = src->begin(); it != src->end(); ++it) {
-                const auto& val = *it; 
+                const auto& val = *it;
                 switch (type) {
-                    case FieldType::Int8:
-                    case FieldType::Int32:
-                    case FieldType::Enum:   dest.int32_arrays.PushBack(idx, static_cast<int32_t>(val)); break;
-                    case FieldType::Int64:  dest.int64_arrays.PushBack(idx, static_cast<int64_t>(val)); break;
-                    case FieldType::Float:  dest.float_arrays.PushBack(idx, static_cast<float>(val)); break;
-                    case FieldType::Double: dest.double_arrays.PushBack(idx, static_cast<double>(val)); break;
-                    case FieldType::Bool:   dest.bool_arrays.PushBack(idx, static_cast<bool>(val)); break;
-                    case FieldType::String:
-                        if constexpr (std::is_assignable_v<std::string&, decltype(val)>) {
-                            dest.string_arrays.PushBack(idx, val);
-                        } else {
-                            dest.string_arrays.PushBack(idx, std::to_string(val));
-                        }
-                        break;
-                    default: break;
+                case FieldType::Int8:
+                case FieldType::Int32:
+                case FieldType::Enum:
+                    dest.int32_arrays.PushBack(idx, static_cast<int32_t>(val));
+                    break;
+                case FieldType::Int64:
+                    dest.int64_arrays.PushBack(idx, static_cast<int64_t>(val));
+                    break;
+                case FieldType::Float:
+                    dest.float_arrays.PushBack(idx, static_cast<float>(val));
+                    break;
+                case FieldType::Double:
+                    dest.double_arrays.PushBack(idx, static_cast<double>(val));
+                    break;
+                case FieldType::Bool:
+                    dest.bool_arrays.PushBack(idx, static_cast<bool>(val));
+                    break;
+                case FieldType::String:
+                    if constexpr (std::is_assignable_v<std::string&, decltype(val)>) {
+                        dest.string_arrays.PushBack(idx, val);
+                    } else {
+                        dest.string_arrays.PushBack(idx, std::to_string(val));
+                    }
+                    break;
+                default:
+                    break;
                 }
             }
         }
-        
-        void PushToFlatArray(PropertyContainer& dest, FieldType type, int32_t idx, const PropertyContainer& temp) const {
+
+        void PushToFlatArray(PropertyContainer& dest, FieldType type, int32_t idx,
+                             const PropertyContainer& temp) const {
             switch (type) {
-                case FieldType::Vector: if (!temp.vector_properties.empty()) dest.vector_arrays.PushBack(idx, temp.vector_properties[0]); break;
-                case FieldType::Quat: if (!temp.quat_properties.empty()) dest.quat_arrays.PushBack(idx, temp.quat_properties[0]); break;
-                case FieldType::Transform: if (!temp.transform_properties.empty()) dest.transform_arrays.PushBack(idx, temp.transform_properties[0]); break;
-                case FieldType::FloatRange: if (!temp.range_properties.empty()) dest.range_arrays.PushBack(idx, temp.range_properties[0]); break;
-                default: break;
+            case FieldType::Vector:
+                if (!temp.vector_properties.empty())
+                    dest.vector_arrays.PushBack(idx, temp.vector_properties[0]);
+                break;
+            case FieldType::Quat:
+                if (!temp.quat_properties.empty())
+                    dest.quat_arrays.PushBack(idx, temp.quat_properties[0]);
+                break;
+            case FieldType::Transform:
+                if (!temp.transform_properties.empty())
+                    dest.transform_arrays.PushBack(idx, temp.transform_properties[0]);
+                break;
+            case FieldType::FloatRange:
+                if (!temp.range_properties.empty())
+                    dest.range_arrays.PushBack(idx, temp.range_properties[0]);
+                break;
+            default:
+                break;
             }
         }
 
         template <typename ActorPtrT, typename IdExtractorFunc>
-        void ExtractActorWithIdFunc(const ActorPtrT src, VTX::Bucket& block, const std::string& schemaType, IdExtractorFunc idExtractor) {
+        void ExtractActorWithIdFunc(const ActorPtrT src, VTX::Bucket& block, const std::string& schemaType,
+                                    IdExtractorFunc idExtractor) {
             PropertyContainer& entity = block.entities.emplace_back();
             Load(src, entity, schemaType);
             std::string uid = idExtractor(src);
             block.unique_ids.push_back(uid);
         }
-        
+
         template <typename Vec>
         inline void EnsureSize(Vec& v, size_t index) {
             if (v.size() <= index) {
@@ -240,15 +312,14 @@ namespace VTX {
         template <typename Vec, typename V>
         inline void StoreValue(Vec& vector, size_t index, const V& val) {
             EnsureSize(vector, index);
-            
+
             if constexpr (std::is_same_v<typename Vec::value_type, std::string>) {
                 if constexpr (std::is_convertible_v<V, std::string>) {
                     vector[index] = val;
                 } else if constexpr (std::is_arithmetic_v<V>) {
                     vector[index] = std::to_string(val);
                 }
-            } 
-            else if constexpr (std::is_assignable_v<typename Vec::value_type&, V>) {
+            } else if constexpr (std::is_assignable_v<typename Vec::value_type&, V>) {
                 vector[index] = static_cast<typename Vec::value_type>(val);
             }
         }
diff --git a/sdk/include/vtx/common/readers/frame_reader/protobuff_loader.h b/sdk/include/vtx/common/readers/frame_reader/protobuff_loader.h
index d4b1b4a..f7c0d23 100644
--- a/sdk/include/vtx/common/readers/frame_reader/protobuff_loader.h
+++ b/sdk/include/vtx/common/readers/frame_reader/protobuff_loader.h
@@ -13,7 +13,8 @@
 namespace VTX {
 
     // Forward declaration for the binding logic used by the loader
-    template <typename ProtoType> struct ProtoBinding;
+    template <typename ProtoType>
+    struct ProtoBinding;
 
     /**
      * @class GenericProtobufLoader
@@ -32,9 +33,10 @@ namespace VTX {
          * @param schema The registry containing field and type metadata.
          * @param debug Enable or disable debug logging.
          */
-        explicit GenericProtobufLoader(const SchemaRegistry& schema, bool debug = false) 
-            : schema_(&schema), debug_mode_(debug) {}
-        
+        explicit GenericProtobufLoader(const SchemaRegistry& schema, bool debug = false)
+            : schema_(&schema)
+            , debug_mode_(debug) {}
+
         /**
          * @brief Loads data from a Protobuf message into a native PropertyContainer.
          * @tparam ProtoType The Protobuf message type generated by protoc.
@@ -49,7 +51,7 @@ namespace VTX {
             }
             dest.entity_type_id = schema_->GetStructTypeId(struct_name);
             ProtoBinding<ProtoType>::Transfer(src, dest, *this, struct_name);
-            dest.content_hash  = Helpers::CalculateContainerHash(dest);
+            dest.content_hash = Helpers::CalculateContainerHash(dest);
         }
 
         /**
@@ -74,8 +76,10 @@ namespace VTX {
          * @param idExtractor Instance of the ID extractor function.
          */
         template <typename RepeatedProtoType, typename IdExtractorFunc>
-        void AppendActorList(VTX::Bucket& targetBlock, const std::string& schemaType, const RepeatedProtoType& src_array, IdExtractorFunc idExtractor) {
-            if (src_array.empty()) return;
+        void AppendActorList(VTX::Bucket& targetBlock, const std::string& schemaType,
+                             const RepeatedProtoType& src_array, IdExtractorFunc idExtractor) {
+            if (src_array.empty())
+                return;
 
             targetBlock.entities.reserve(targetBlock.entities.size() + src_array.size());
 
@@ -94,10 +98,11 @@ namespace VTX {
          * @param idExtractor The ID extractor function.
          */
         template <typename ProtoType, typename IdExtractorFunc>
-        void AppendSingleActor(VTX::Bucket& targetBlock, const std::string& schemaType, const ProtoType& src_item, IdExtractorFunc idExtractor) {
+        void AppendSingleActor(VTX::Bucket& targetBlock, const std::string& schemaType, const ProtoType& src_item,
+                               IdExtractorFunc idExtractor) {
             ExtractActorWithIdFunc(src_item, targetBlock, schemaType, idExtractor);
         }
-                
+
         /**
          * @brief Sets a single field value in a PropertyContainer based on schema metadata.
          * @tparam T The native C++ type of the value.
@@ -108,11 +113,13 @@ namespace VTX {
          * @note Performs type conversion and bounds checking via EnsureSize.
          */
         template <typename T>
-        void LoadField(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name, const T& value) {
+        void LoadField(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name,
+                       const T& value) {
             const auto* field_info = schema_->GetField(struct_name, field_name);
-            
+
             if (!field_info) {
-                if (debug_mode_) std::cout << "  [WARNING] Field not found: " << struct_name << "::" << field_name << "\n";
+                if (debug_mode_)
+                    std::cout << "  [WARNING] Field not found: " << struct_name << "::" << field_name << "\n";
                 return;
             }
 
@@ -120,27 +127,50 @@ namespace VTX {
             VTX::FieldType target_type = field_info->type_id;
 
             if (debug_mode_) {
-                std::cout << "  [SET] " << struct_name << "::" << field_name 
+                std::cout << "  [SET] " << struct_name << "::" << field_name
                           << " (EnumID: " << static_cast<int>(target_type) << ")"
                           << " -> Index: " << idx << "\n";
             }
 
             switch (target_type) {
-                case FieldType::String:     StoreValue(dest.string_properties, idx, value); break;
-                case FieldType::Int8:
-                case FieldType::Int32:
-                case FieldType::Enum:       StoreValue(dest.int32_properties, idx, value);  break;
-                case FieldType::Int64:      StoreValue(dest.int64_properties, idx, value);  break;
-                case FieldType::Float:      StoreValue(dest.float_properties, idx, value);  break;
-                case FieldType::Double:     StoreValue(dest.double_properties, idx, value); break;
-                case FieldType::Bool:       StoreValue(dest.bool_properties, idx, value);   break;
-                case FieldType::Vector:     StoreValue(dest.vector_properties, idx, value); break;
-                case FieldType::Quat:       StoreValue(dest.quat_properties, idx, value);   break;
-                case FieldType::Transform:  StoreValue(dest.transform_properties, idx, value); break;
-                case FieldType::FloatRange: StoreValue(dest.range_properties, idx, value);  break;
-                case FieldType::Struct: StoreValue(dest.any_struct_properties, idx, value); break;
-                case FieldType::None:
-                default: break;
+            case FieldType::String:
+                StoreValue(dest.string_properties, idx, value);
+                break;
+            case FieldType::Int8:
+            case FieldType::Int32:
+            case FieldType::Enum:
+                StoreValue(dest.int32_properties, idx, value);
+                break;
+            case FieldType::Int64:
+                StoreValue(dest.int64_properties, idx, value);
+                break;
+            case FieldType::Float:
+                StoreValue(dest.float_properties, idx, value);
+                break;
+            case FieldType::Double:
+                StoreValue(dest.double_properties, idx, value);
+                break;
+            case FieldType::Bool:
+                StoreValue(dest.bool_properties, idx, value);
+                break;
+            case FieldType::Vector:
+                StoreValue(dest.vector_properties, idx, value);
+                break;
+            case FieldType::Quat:
+                StoreValue(dest.quat_properties, idx, value);
+                break;
+            case FieldType::Transform:
+                StoreValue(dest.transform_properties, idx, value);
+                break;
+            case FieldType::FloatRange:
+                StoreValue(dest.range_properties, idx, value);
+                break;
+            case FieldType::Struct:
+                StoreValue(dest.any_struct_properties, idx, value);
+                break;
+            case FieldType::None:
+            default:
+                break;
             }
         }
 
@@ -153,23 +183,26 @@ namespace VTX {
          * @param src_nested The source nested Protobuf message.
          */
         template <typename NestedProtoType>
-        void LoadStruct(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name, const NestedProtoType& src_nested) {
+        void LoadStruct(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name,
+                        const NestedProtoType& src_nested) {
             const auto* field_info = schema_->GetField(struct_name, field_name);
-            if (!field_info) return;
+            if (!field_info)
+                return;
 
             int32_t index = field_info->index;
-            std::string child_type_name = field_info->struct_type; 
+            std::string child_type_name = field_info->struct_type;
 
             if (debug_mode_) {
-                std::cout << "  [STRUCT] " << struct_name << "::" << field_name 
-                          << " -> Index: " << index << " (SchemaType: " << child_type_name << ")" << "\n";
+                std::cout << "  [STRUCT] " << struct_name << "::" << field_name << " -> Index: " << index
+                          << " (SchemaType: " << child_type_name << ")"
+                          << "\n";
             }
 
             EnsureSize(dest.any_struct_properties, index);
             Load(src_nested, dest.any_struct_properties[index], child_type_name);
         }
 
-       /**
+        /**
          * @brief Fills a flattened SoA (Structure of Arrays) from a repeated Protobuf primitive field.
          * @details Iterates through the source collection and uses the PushBack method of FlatArray
          * to maintain the data and offset integrity within the PropertyContainer.
@@ -183,119 +216,124 @@ namespace VTX {
         void FillFlatArray(PropertyContainer& dest, FieldType type, int32_t idx, const RepeatedT& src) {
             for (const auto& val : src) {
                 // Compile-time check: is the value a string-like type?
-                constexpr bool is_string_type = std::is_convertible_v<decltype(val), std::string_view> || 
+                constexpr bool is_string_type = std::is_convertible_v<decltype(val), std::string_view> ||
                                                 std::is_same_v<std::decay_t<decltype(val)>, std::string>;
 
                 switch (type) {
-                    case FieldType::Int8:
-                    case FieldType::Int32:
-                    case FieldType::Enum:
-                        if constexpr (!is_string_type) {
-                            dest.int32_arrays.PushBack(idx, static_cast<int32_t>(val));
-                        } else {
-                            if (debug_mode_) std::cerr << "[LOADER] Error: Trying to cast a string to Int32 array.\n";
-                        }
-                        break;
-
-                    case FieldType::Int64:
-                        if constexpr (!is_string_type) {
-                            dest.int64_arrays.PushBack(idx, static_cast<int64_t>(val));
-                        } else {
-                            if (debug_mode_) std::cerr << "[LOADER] Error: Trying to cast a string to Int64 array.\n";
-                        }
-                        break;
-
-                    case FieldType::Float:
-                        if constexpr (!is_string_type) {
-                            dest.float_arrays.PushBack(idx, static_cast<float>(val));
-                        } else {
-                            if (debug_mode_) std::cerr << "[LOADER] Error: Trying to cast a string to Float array.\n";
-                        }
-                        break;
-
-                    case FieldType::Double:
-                        if constexpr (!is_string_type) {
-                            dest.double_arrays.PushBack(idx, static_cast<double>(val));
-                        } else {
-                            if (debug_mode_) std::cerr << "[LOADER] Error: Trying to cast a string to Double array.\n";
-                        }
-                        break;
-
-                    case FieldType::Bool:
-                        if constexpr (!is_string_type) {
-                            dest.bool_arrays.PushBack(idx, static_cast<bool>(val));
-                        } else {
-                            if (debug_mode_) std::cerr << "[LOADER] Error: Trying to cast a string to Bool array.\n";
-                        }
-                        break;
-
-                    case FieldType::String:
-                        if constexpr (is_string_type) {
-                            dest.string_arrays.PushBack(idx, std::string(val));
-                        } else if constexpr (std::is_arithmetic_v<std::decay_t<decltype(val)>>) {
-                            dest.string_arrays.PushBack(idx, std::to_string(val));
-                        }
-                        break;
-
-                    default:
-                        if (debug_mode_) {
-                            std::cerr << "[LOADER] FillFlatArray: FieldType " << static_cast<int>(type) 
-                                      << " is not a supported primitive for flat arrays.\n";
-                        }
-                        break;
-                }
-            }
-        }
-        
-        /**
-         * @brief Helper to push a complex math object that was temporarily loaded into its SoA FlatArray.
-         * @details This is used when an array contains complex types (Vector, Quat, etc.) that the 
-         * loader first processes into a single PropertyContainer before flattening them into the 
-         * main SoA structure.
-         * * @param dest The target PropertyContainer holding the SoA arrays.
-         * @param type The VTX FieldType identifying which array to target.
-         * @param idx The specific sub-array index within the FlatArray.
-         * @param temp The temporary container where the single object was initially loaded.
-         */
-        void PushToFlatArray(PropertyContainer& dest, FieldType type, int32_t idx, const PropertyContainer& temp) const
-        {
-            switch (type) {
-                case FieldType::Vector:
-                    if (!temp.vector_properties.empty()) {
-                        dest.vector_arrays.PushBack(idx, temp.vector_properties[0]);
+                case FieldType::Int8:
+                case FieldType::Int32:
+                case FieldType::Enum:
+                    if constexpr (!is_string_type) {
+                        dest.int32_arrays.PushBack(idx, static_cast<int32_t>(val));
+                    } else {
+                        if (debug_mode_)
+                            std::cerr << "[LOADER] Error: Trying to cast a string to Int32 array.\n";
                     }
                     break;
 
-                case FieldType::Quat:
-                    if (!temp.quat_properties.empty()) {
-                        dest.quat_arrays.PushBack(idx, temp.quat_properties[0]);
+                case FieldType::Int64:
+                    if constexpr (!is_string_type) {
+                        dest.int64_arrays.PushBack(idx, static_cast<int64_t>(val));
+                    } else {
+                        if (debug_mode_)
+                            std::cerr << "[LOADER] Error: Trying to cast a string to Int64 array.\n";
+                    }
+                    break;
+
+                case FieldType::Float:
+                    if constexpr (!is_string_type) {
+                        dest.float_arrays.PushBack(idx, static_cast<float>(val));
+                    } else {
+                        if (debug_mode_)
+                            std::cerr << "[LOADER] Error: Trying to cast a string to Float array.\n";
                     }
                     break;
 
-                case FieldType::Transform:
-                    if (!temp.transform_properties.empty()) {
-                        dest.transform_arrays.PushBack(idx, temp.transform_properties[0]);
+                case FieldType::Double:
+                    if constexpr (!is_string_type) {
+                        dest.double_arrays.PushBack(idx, static_cast<double>(val));
+                    } else {
+                        if (debug_mode_)
+                            std::cerr << "[LOADER] Error: Trying to cast a string to Double array.\n";
                     }
                     break;
 
-                case FieldType::FloatRange:
-                    if (!temp.range_properties.empty()) {
-                        dest.range_arrays.PushBack(idx, temp.range_properties[0]);
+                case FieldType::Bool:
+                    if constexpr (!is_string_type) {
+                        dest.bool_arrays.PushBack(idx, static_cast<bool>(val));
+                    } else {
+                        if (debug_mode_)
+                            std::cerr << "[LOADER] Error: Trying to cast a string to Bool array.\n";
                     }
                     break;
 
-                case FieldType::Struct:
-                    if (temp.entity_type_id != -1) {
-                        dest.any_struct_arrays.PushBack(idx, temp);
+                case FieldType::String:
+                    if constexpr (is_string_type) {
+                        dest.string_arrays.PushBack(idx, std::string(val));
+                    } else if constexpr (std::is_arithmetic_v<std::decay_t<decltype(val)>>) {
+                        dest.string_arrays.PushBack(idx, std::to_string(val));
                     }
                     break;
 
                 default:
                     if (debug_mode_) {
-                        std::cerr << "[LOADER] PushToFlatArray: Type " << static_cast<int>(type) 
-                                  << " is not a complex math type_max_indices supported by SoA flattening.\n";
+                        std::cerr << "[LOADER] FillFlatArray: FieldType " << static_cast<int>(type)
+                                  << " is not a supported primitive for flat arrays.\n";
                     }
                     break;
+                }
+            }
+        }
+
+        /**
+         * @brief Helper to push a complex math object that was temporarily loaded into its SoA FlatArray.
+         * @details This is used when an array contains complex types (Vector, Quat, etc.) that the 
+         * loader first processes into a single PropertyContainer before flattening them into the 
+         * main SoA structure.
+         * * @param dest The target PropertyContainer holding the SoA arrays.
+         * @param type The VTX FieldType identifying which array to target.
+         * @param idx The specific sub-array index within the FlatArray.
+         * @param temp The temporary container where the single object was initially loaded.
+         */
+        void PushToFlatArray(PropertyContainer& dest, FieldType type, int32_t idx,
+                             const PropertyContainer& temp) const {
+            switch (type) {
+            case FieldType::Vector:
+                if (!temp.vector_properties.empty()) {
+                    dest.vector_arrays.PushBack(idx, temp.vector_properties[0]);
+                }
+                break;
+
+            case FieldType::Quat:
+                if (!temp.quat_properties.empty()) {
+                    dest.quat_arrays.PushBack(idx, temp.quat_properties[0]);
+                }
+                break;
+
+            case FieldType::Transform:
+                if (!temp.transform_properties.empty()) {
+                    dest.transform_arrays.PushBack(idx, temp.transform_properties[0]);
+                }
+                break;
+
+            case FieldType::FloatRange:
+                if (!temp.range_properties.empty()) {
+                    dest.range_arrays.PushBack(idx, temp.range_properties[0]);
+                }
+                break;
+
+            case FieldType::Struct:
+                if (temp.entity_type_id != -1) {
+                    dest.any_struct_arrays.PushBack(idx, temp);
+                }
+                break;
+
+            default:
+                if (debug_mode_) {
+                    std::cerr << "[LOADER] PushToFlatArray: Type " << static_cast<int>(type)
+                              << " is not a complex math type_max_indices supported by SoA flattening.\n";
+                }
+                break;
             }
         }
 
@@ -308,10 +346,11 @@ namespace VTX {
          * @param src_array The source collection of values/messages.
          */
         template <typename RepeatedProtoType>
-        void LoadArray(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name, const RepeatedProtoType& src_array) {
-
+        void LoadArray(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name,
+                       const RepeatedProtoType& src_array) {
             const auto* field_info = schema_->GetField(struct_name, field_name);
-            if (!field_info || src_array.empty()) return;
+            if (!field_info || src_array.empty())
+                return;
 
             using ElementT = typename RepeatedProtoType::value_type;
             const int32_t idx = field_info->index;
@@ -330,26 +369,27 @@ namespace VTX {
                         PushToFlatArray(dest, field_info->type_id, idx, temp);
                     }
                 }
-            } 
-            else {
+            } else {
                 FillFlatArray(dest, field_info->type_id, idx, src_array);
             }
         }
-    
+
         /**
          * @brief Injects a memory block (Blob) directly into byte_array_properties
          */
-        void LoadBlob(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name, const void* data, size_t byte_size) {
+        void LoadBlob(PropertyContainer& dest, const std::string& struct_name, const std::string& field_name,
+                      const void* data, size_t byte_size) {
             const auto* field_info = schema_->GetField(struct_name, field_name);
-            if (!field_info || byte_size == 0) return;
+            if (!field_info || byte_size == 0)
+                return;
 
             const uint8_t* byte_data = static_cast<const uint8_t*>(data);
-            
+
             for (size_t i = 0; i < byte_size; ++i) {
                 dest.byte_array_properties.PushBack(field_info->index, byte_data[i]);
             }
         }
-        
+
     private:
         /**
          * @brief Internal helper to load an actor and extract its ID.
@@ -361,15 +401,15 @@ namespace VTX {
          * @param idExtractor Function instance.
          */
         template <typename ActorT, typename IdExtractorFunc>
-        void ExtractActorWithIdFunc(const ActorT& src, VTX::Bucket& block, const std::string& schemaType, IdExtractorFunc idExtractor) {
-            
+        void ExtractActorWithIdFunc(const ActorT& src, VTX::Bucket& block, const std::string& schemaType,
+                                    IdExtractorFunc idExtractor) {
             PropertyContainer& entity = block.entities.emplace_back();
             Load(src, entity, schemaType);
             Helpers::CalculateContainerHash(entity);
             std::string uid = idExtractor(src);
             block.unique_ids.push_back(uid);
         }
-        
+
         /**
          * @brief Internal utility to resize a vector to accommodate a specific index.
          * @tparam Vec Vector type.
@@ -391,7 +431,5 @@ namespace VTX {
             else if constexpr (std::is_assignable_v<typename Vec::value_type&, V>)
                 vector[index] = static_cast<typename Vec::value_type>(val);
         }
-
-        
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/common/readers/frame_reader/type_traits.h b/sdk/include/vtx/common/readers/frame_reader/type_traits.h
index 33553ea..03e1f12 100644
--- a/sdk/include/vtx/common/readers/frame_reader/type_traits.h
+++ b/sdk/include/vtx/common/readers/frame_reader/type_traits.h
@@ -19,34 +19,36 @@ namespace VTX {
     /** * @brief Base struct for std::vector detection (false case).
      * @tparam T The type to check.
      */
-    template<typename T>
+    template <typename T>
     struct is_vector : std::false_type {};
 
     /** * @brief Specialization for std::vector detection (true case).
      * @tparam T The element type.
      * @tparam A The allocator type.
      */
-    template<typename T, typename A>
+    template <typename T, typename A>
     struct is_vector<std::vector<T, A>> : std::true_type {};
 
     /** * @brief Helper variable template. True if T is a std::vector.
      * @tparam T The type to check.
      */
-    template<typename T>
+    template <typename T>
     inline constexpr bool is_vector_v = is_vector<T>::value;
 
     /** * @brief Base struct for std::map detection (false case).
      */
-    template<typename T> struct is_map : std::false_type {};
+    template <typename T>
+    struct is_map : std::false_type {};
 
     /** * @brief Specialization for std::map detection (true case).
      */
-    template<typename K, typename V, typename C, typename A>
+    template <typename K, typename V, typename C, typename A>
     struct is_map<std::map<K, V, C, A>> : std::true_type {};
 
     /** * @brief Helper variable template. True if T is a std::map.
      */
-    template<typename T> inline constexpr bool is_map_v = is_map<T>::value;
+    template <typename T>
+    inline constexpr bool is_map_v = is_map<T>::value;
 
 
     /**
@@ -64,37 +66,40 @@ namespace VTX {
      * @tparam T The type to inspect.
      * @tparam void Placeholder for SFINAE.
      */
-    template<typename T, typename = void>
+    template <typename T, typename = void>
     struct HasJsonMapping : std::false_type {};
 
     /**
      * @brief Specialization for types that HAVE a valid JsonMapping.
      */
-    template<typename T>
+    template <typename T>
     struct HasJsonMapping<T, std::void_t<decltype(VTX::JsonMapping<T>::GetFields())>> : std::true_type {};
 
     /** * @brief Helper variable. True if T has a registered JSON mapping.
      */
-    template<typename T> inline constexpr bool has_mapping_v = HasJsonMapping<T>::value;
+    template <typename T>
+    inline constexpr bool has_mapping_v = HasJsonMapping<T>::value;
 
     /**
      * @brief Base template for FlatBuffer mappings.
      * @details Users must specialize this struct to link C++ types with FlatBuffer tables.
      */
-    template <typename T> struct FlatBufferMapping;
+    template <typename T>
+    struct FlatBufferMapping;
 
     /**
      * @brief SFINAE Meta-function to detect if a type has a defined FlatBufferMapping.
      * @details Checks if `VTX::FlatBufferMapping<T>::GetFields()` is a valid expression.
      */
-    template<typename T, typename = void>
+    template <typename T, typename = void>
     struct HasFbMapping : std::false_type {};
 
-    template<typename T>
+    template <typename T>
     struct HasFbMapping<T, std::void_t<decltype(FlatBufferMapping<T>::GetFields())>> : std::true_type {};
 
     /** 
     * @brief Helper variable. True if T has a registered FlatBuffer mapping.
     */
-    template<typename T> inline constexpr bool has_fb_mapping_v = HasFbMapping<T>::value;
-}
\ No newline at end of file
+    template <typename T>
+    inline constexpr bool has_fb_mapping_v = HasFbMapping<T>::value;
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/readers/frame_reader/universal_deserializer.h b/sdk/include/vtx/common/readers/frame_reader/universal_deserializer.h
index 30ef8eb..cfe9390 100644
--- a/sdk/include/vtx/common/readers/frame_reader/universal_deserializer.h
+++ b/sdk/include/vtx/common/readers/frame_reader/universal_deserializer.h
@@ -57,10 +57,9 @@ namespace VTX {
     * @tparam ErrorPolicy Policy class determining how to handle missing keys or type mismatches (e.g., Strict, Lenient).
     * @tparam NamingPolicy Policy class determining how to transform key names before lookup (e.g., Exact, Lowercase).
     */
-    template <typename ErrorPolicy = VTX::StrictErrorPolicy, typename NamingPolicy = VTX::ExactNamingPolicy >
+    template <typename ErrorPolicy = VTX::StrictErrorPolicy, typename NamingPolicy = VTX::ExactNamingPolicy>
     class UniversalDeserializer {
     public:
-
         /**
          * @brief Main entry point to load data into a struct.
          * @details This function orchestrates the process:
@@ -72,9 +71,8 @@ namespace VTX {
          * @param adapter The adapter instance pointing to the current data node.
          * @return T A fully populated instance of the struct.
          */
-        template <typename T,typename FormatAdapter>
+        template <typename T, typename FormatAdapter>
         static T Load(const FormatAdapter& adapter) {
-
             // Compile-time check to ensure T has been registered with the reflection system.
             using RawAdapter = std::decay_t<FormatAdapter>;
             using Selector = MappingSelector<RawAdapter, T>;
@@ -82,22 +80,19 @@ namespace VTX {
 
             // Compile-time validation
             static_assert(Selector::HasMapping,
-                "ERROR: The target struct T does not have a registered Mapping for this format.");
+                          "ERROR: The target struct T does not have a registered Mapping for this format.");
 
-            T instance{};
+            T instance {};
 
             // Retrieve fields from the selected mapping (JsonMapping or FlatBufferMapping)
             constexpr auto mapping = Mapping::GetFields();
 
-            std::apply([&](auto&&... fields) {
-                (ProcessField(instance, adapter, fields), ...);
-                }, mapping);
+            std::apply([&](auto&&... fields) { (ProcessField(instance, adapter, fields), ...); }, mapping);
 
             return instance;
         }
 
     private:
-       
         /**
          * @brief Recursive function to deserialize a specific value based on its type.
          * @details Uses `if constexpr` to select the correct loading strategy (Vector, Map, Struct, or Primitive).
@@ -107,11 +102,11 @@ namespace VTX {
          * @param out[out] Reference to the variable where the value will be stored.
          */
         template <typename T, typename FormatAdapter>
-        static void DeserializeValue(const FormatAdapter& adapter, T& out)
-        {
+        static void DeserializeValue(const FormatAdapter& adapter, T& out) {
             //std::vector<T>
             if constexpr (is_vector_v<T>) {
-                if (!adapter.IsArray()) return;
+                if (!adapter.IsArray())
+                    return;
                 using ElementType = typename T::value_type;
                 for (size_t i = 0; i < adapter.Size(); ++i) {
                     ElementType element;
@@ -121,7 +116,8 @@ namespace VTX {
             }
             //std::map<K, V>
             else if constexpr (is_map_v<T>) {
-                if (!adapter.IsMap()) return;
+                if (!adapter.IsMap())
+                    return;
 
                 using KeyType = typename T::key_type;
                 using MappedType = typename T::mapped_type;
@@ -141,10 +137,9 @@ namespace VTX {
                 out = Load<T>(adapter);
             }
             //basic types (int, float, bool, std::string)
-            else 
-            {
-                static_assert(std::is_default_constructible_v<T>,
-                    "ERROR: T is not a basic type_max_indices or vector or map, or is not registered as StructMapping.");
+            else {
+                static_assert(std::is_default_constructible_v<T>, "ERROR: T is not a basic type_max_indices or vector "
+                                                                  "or map, or is not registered as StructMapping.");
 
                 out = adapter.template GetValue<T>();
             }
@@ -162,7 +157,6 @@ namespace VTX {
          */
         template <typename T, typename FormatAdapter, typename FieldType>
         static void ProcessField(T& instance, const FormatAdapter& adapter, const FieldType& field) {
-
             // Transform the code name to the data name (e.g. "MyVar" -> "my_var")
             std::string target_key = NamingPolicy::Transform(field.json_key);
 
@@ -174,6 +168,5 @@ namespace VTX {
 
             DeserializeValue(adapter.GetChild(target_key), instance.*(field.member_ptr));
         }
-
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/common/readers/frame_reader/vtx_loader.h b/sdk/include/vtx/common/readers/frame_reader/vtx_loader.h
index a3f70f4..601afc1 100644
--- a/sdk/include/vtx/common/readers/frame_reader/vtx_loader.h
+++ b/sdk/include/vtx/common/readers/frame_reader/vtx_loader.h
@@ -25,4 +25,4 @@ namespace VTX {
     T Load(const FbPointer* fb_data) {
         return FlatBufferAdapter::Load<T>(fb_data);
     }
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/common/readers/json_file_reader.h b/sdk/include/vtx/common/readers/json_file_reader.h
index bfdaa1b..4e4087b 100644
--- a/sdk/include/vtx/common/readers/json_file_reader.h
+++ b/sdk/include/vtx/common/readers/json_file_reader.h
@@ -24,10 +24,8 @@ namespace VTX {
             json j;
             try {
                 file >> j;
-            }
-            catch (const json::parse_error& e) {
-                std::cerr << "[Error Parser] JSON malformed " << filepath
-                    << "\nDetalles: " << e.what() << std::endl;
+            } catch (const json::parse_error& e) {
+                std::cerr << "[Error Parser] JSON malformed " << filepath << "\nDetalles: " << e.what() << std::endl;
                 return std::nullopt;
             }
 
@@ -46,5 +44,5 @@ namespace VTX {
 
             return buffer.str();
         }
-    };
-}
\ No newline at end of file
+    }; // namespace JsonFileReader
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/readers/schema_reader/game_schema_types.h b/sdk/include/vtx/common/readers/schema_reader/game_schema_types.h
index fd4d74c..4c36337 100644
--- a/sdk/include/vtx/common/readers/schema_reader/game_schema_types.h
+++ b/sdk/include/vtx/common/readers/schema_reader/game_schema_types.h
@@ -30,51 +30,48 @@ namespace VTX {
         Transform,
         FloatRange,
         Struct,
-        Enum 
+        Enum
     };
 
-    enum class FieldContainerType : uint8_t {
-        None = 0,
-        Array,
-        Map
-    };
-    
+    enum class FieldContainerType : uint8_t { None = 0, Array, Map };
+
     /**
     * @brief Metadata of a field.
     */
     struct SchemaMeta {
-        std::string type;      ///< Bucket type_max_indices string (e.g., "int32", "float", "vector","struct"). For debugging
-        std::string key_type;   ///< If this is a Map, the type_max_indices of the key (e.g., "string", "enum").
-        std::string category;  ///< Organizational category (e.g., "Stats", "Transform").
-        std::string display_name;   ///< Human-readable name for UI.
+        std::string type; ///< Bucket type_max_indices string (e.g., "int32", "float", "vector","struct"). For debugging
+        std::string key_type;      ///< If this is a Map, the type_max_indices of the key (e.g., "string", "enum").
+        std::string category;      ///< Organizational category (e.g., "Stats", "Transform").
+        std::string display_name;  ///< Human-readable name for UI.
         std::string tooltip;       ///< Description or help text.
-        std::string default_value;  ///< Default value as a string.
+        std::string default_value; ///< Default value as a string.
         int32_t version;           ///< Version of this specific field definition.
-        
+
         //internal only, schema resolver will generate this
-        int32_t fixed_array_dim;     ///< If > 0, indicates this field is a fixed-size array.
+        int32_t fixed_array_dim; ///< If > 0, indicates this field is a fixed-size array.
     };
 
     /**
      * @brief Definition of a single property/field within a struct.
      */
-    struct SchemaField { 
-        std::string name;      ///< Internal variable name (e.g., "health_current").
-        std::string struct_type;      ///< If type_max_indices is a struct, the struct name
-        FieldType type_id;      ///< Bucket type_max_indices string (e.g., "int32", "float", "vector"). For quick swithc-case
-        FieldType key_id;     
-        FieldContainerType container_type;      ///< Bucket type_max_indices `container(e.g., "struct", "array", ",a"). For quick swithc-case
-        SchemaMeta meta;       ///< Additional UI metadata.
-        
+    struct SchemaField {
+        std::string name;        ///< Internal variable name (e.g., "health_current").
+        std::string struct_type; ///< If type_max_indices is a struct, the struct name
+        FieldType type_id; ///< Bucket type_max_indices string (e.g., "int32", "float", "vector"). For quick swithc-case
+        FieldType key_id;
+        FieldContainerType
+            container_type; ///< Bucket type_max_indices `container(e.g., "struct", "array", ",a"). For quick swithc-case
+        SchemaMeta meta;    ///< Additional UI metadata.
+
         //internal only, schema resolver will generate this
-        int32_t index;         ///< The index in the generic PropertyContainer arrays.
+        int32_t index; ///< The index in the generic PropertyContainer arrays.
     };
 
     /**
     * @brief Definition of a complex structure (like a Class or Struct in C++).
     */
     struct SchemaStruct {
-        std::string struct_name; ///< Name of the structure.
+        std::string struct_name;         ///< Name of the structure.
         std::vector<SchemaField> fields; ///< List of fields contained in this structure.
 
         /** * @brief Max indices required for each type in this struct.
@@ -95,6 +92,6 @@ namespace VTX {
             return result;
         }
     };
-    
+
 
 } // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/readers/schema_reader/schema_registry.h b/sdk/include/vtx/common/readers/schema_reader/schema_registry.h
index 68812b2..11eda19 100644
--- a/sdk/include/vtx/common/readers/schema_reader/schema_registry.h
+++ b/sdk/include/vtx/common/readers/schema_reader/schema_registry.h
@@ -19,20 +19,15 @@
 #include "vtx/common/vtx_types.h"
 
 namespace VTX {
-    
-    
+
+
     /**
      * @class SchemaRegistry
      * @brief Singleton-like registry that holds all loaded structure definitions.
      */
     class SchemaRegistry {
     public:
-        enum class ELoadMethod: uint32_t
-        {
-            LoadToBuffer = 0,
-            LoadToSchema,
-            Both
-        };
+        enum class ELoadMethod : uint32_t { LoadToBuffer = 0, LoadToSchema, Both };
         /**
          * @brief Default constructor. Initializes the registry as valid.
          */
@@ -44,7 +39,7 @@ namespace VTX {
          * @return true If loading and parsing were successful.
          * @return false If the file could not be opened or parsed.
          */
-        bool LoadFromJson(const std::string& json_path,ELoadMethod = ELoadMethod::Both);
+        bool LoadFromJson(const std::string& json_path, ELoadMethod = ELoadMethod::Both);
 
         /**
          * @brief
@@ -53,7 +48,7 @@ namespace VTX {
          * @return
          */
         bool LoadFromRawString(const std::string& raw_json);
-        
+
         /**
          * @brief Retrieves the numeric index for a specific field within a struct.
          * @param structName The name of the structure (e.g., "PlayerState").
@@ -81,28 +76,26 @@ namespace VTX {
          * @return 
          */
         const VTX::SchemaField* GetField(const std::string& struct_name, const std::string& field_name) const;
-        
+
         /**
          * @brief Retrieves the unique integer ID for a structure (matches the generated Enum).
          * @param name The name of the structure.
          * @return int32_t The TypeId, or -1 if the struct is not registered.
          */
         int32_t GetStructTypeId(const std::string& name) const;
-        
+
         /**/
-        std::string GetContentAsString() const{return json_content_;}
-        
-        const VTX::PropertyAddressCache& GetPropertyCache() const
-        {
-            return property_cache_;
-        }
+        std::string GetContentAsString() const { return json_content_; }
+
+        const VTX::PropertyAddressCache& GetPropertyCache() const { return property_cache_; }
+
     private:
         std::string json_content_;
         std::unordered_map<std::string, SchemaStruct> structs_; ///< Storage map: Struct Name -> Definition.
         std::unordered_map<std::string, int32_t> struct_type_ids_;
         VTX::PropertyAddressCache property_cache_;
-        int32_t current_type_id_=0;
-        bool b_is_valid_;///< Internal validity flag.
+        int32_t current_type_id_ = 0;
+        bool b_is_valid_; ///< Internal validity flag.
     };
-            
+
 } // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/vtx_concepts.h b/sdk/include/vtx/common/vtx_concepts.h
index 77fc239..b489950 100644
--- a/sdk/include/vtx/common/vtx_concepts.h
+++ b/sdk/include/vtx/common/vtx_concepts.h
@@ -5,96 +5,84 @@
 #include "vtx_types.h"
 
 
-namespace VTX
-{
+namespace VTX {
     struct PropertyAddressCache;
     struct ChunkIndexData;
     struct SessionFooter;
-    
+
 
     template <typename SchemaT>
-    struct SchemaAdapter
-    {
+    struct SchemaAdapter {
         static void BuildCache(const SchemaT&, PropertyAddressCache&) = delete;
     };
 
 
-    //List of supported types in vtx 
-    template<typename T>
-        concept VtxScalarType = 
-            std::same_as<T, bool> || std::same_as<T, int32_t> || std::same_as<T, int64_t> || std::same_as<T, uint8_t> ||
-            std::same_as<T, float> || std::same_as<T, double> || std::same_as<T, std::string> ||
-            std::same_as<T, VTX::Vector> || std::same_as<T, VTX::Quat> || 
-            std::same_as<T, VTX::Transform> || std::same_as<T, VTX::FloatRange> || 
-            std::same_as<T, VTX::PropertyContainer> || std::same_as<T, class EntityView>;
+    //List of supported types in vtx
+    template <typename T>
+    concept VtxScalarType =
+        std::same_as<T, bool> || std::same_as<T, int32_t> || std::same_as<T, int64_t> || std::same_as<T, uint8_t> ||
+        std::same_as<T, float> || std::same_as<T, double> || std::same_as<T, std::string> ||
+        std::same_as<T, VTX::Vector> || std::same_as<T, VTX::Quat> || std::same_as<T, VTX::Transform> ||
+        std::same_as<T, VTX::FloatRange> || std::same_as<T, VTX::PropertyContainer> ||
+        std::same_as<T, class EntityView>;
 
     //Concepts for arrays, uint8 is used for bools
-    template<typename T>
+    template <typename T>
     concept VtxArrayType = VtxScalarType<T> || std::same_as<T, uint8_t>;
 
 
-
     /*Concept that defines how a vtx writer policy must look*/
-    template<typename T>
-    concept IVtxWriterPolicy = requires(
-        const typename T::HeaderType& header_config,
-        const typename T::SchemaType& schema,
-        std::vector<std::unique_ptr<typename T::FrameType>>& frames,
-        int32_t chunk_index,
-        bool is_compressed,
-        const std::vector<ChunkIndexData>& seek_table,
-        const SessionFooter& footer_data
-    )
-    {
-        typename T::FrameType;
-        typename T::SchemaType;
-        typename T::HeaderType; 
-
-         requires std::semiregular<typename T::HeaderType>;
-
-        { T::GetMagicBytes() } -> std::convertible_to<std::string>;
-        { T::SerializeHeader(header_config, schema) } -> std::convertible_to<std::string>;
-        { T::SerializeChunk(frames, chunk_index,is_compressed) } -> std::convertible_to<std::string>;
-        { T::SerializeFooter(seek_table, footer_data) } -> std::convertible_to<std::string>;
-    };
-    
+    template <typename T>
+    concept IVtxWriterPolicy =
+        requires(const typename T::HeaderType& header_config, const typename T::SchemaType& schema,
+                 std::vector<std::unique_ptr<typename T::FrameType>>& frames, int32_t chunk_index, bool is_compressed,
+                 const std::vector<ChunkIndexData>& seek_table, const SessionFooter& footer_data) {
+            typename T::FrameType;
+            typename T::SchemaType;
+            typename T::HeaderType;
+
+            requires std::semiregular<typename T::HeaderType>;
+
+            { T::GetMagicBytes() } -> std::convertible_to<std::string>;
+            { T::SerializeHeader(header_config, schema) } -> std::convertible_to<std::string>;
+            { T::SerializeChunk(frames, chunk_index, is_compressed) } -> std::convertible_to<std::string>;
+            { T::SerializeFooter(seek_table, footer_data) } -> std::convertible_to<std::string>;
+        };
+
     /*Concept that defines how a vtx reader_ policy must look*/
-    template<typename T>
-    concept IVtxReaderPolicy = requires(
-        std::string buffer,
-        const typename T::HeaderType& header,
-        const typename T::FooterType& footer,
-        std::vector<VTX::ChunkIndexEntry> index_table,
-        VTX::GameTime::VTXGameTimes& game_times,
-        int32_t chunk_idx,
-        std::stop_token stop_token,
-        std::vector<VTX::Frame>& out_native_frames,
-        std::vector<uint8_t>& out_decompressed_blob,
-        std::vector<std::span<const std::byte>>& out_raw_frames_spans)
-    {
-        typename T::HeaderType;
-        typename T::FooterType;
-        typename T::SchemaType;
-
-        requires std::semiregular<typename T::HeaderType>;
-        requires std::semiregular<typename T::FooterType>;
-        requires std::semiregular<typename T::SchemaType>;
-
-        { T::ParseHeader(buffer) } -> std::same_as<typename T::HeaderType>;
-        { T::ParseFooter(buffer) } -> std::same_as<typename T::FooterType>;
-
-        { T::GetTotalFrames(footer) } -> std::convertible_to<int32_t>;
-        { T::GetSchema(header) } -> std::convertible_to<const typename T::SchemaType&>;
-        { T::GetVTXHeader(header) } -> std::convertible_to<VTX::FileHeader>;
-        { T::GetVTXFooter(footer) } -> std::convertible_to< VTX::FileFooter>;
-        { T::ProcessChunkData(chunk_idx, buffer, stop_token,out_native_frames,out_decompressed_blob,out_raw_frames_spans) } -> std::same_as<void>;
-    };
+    template <typename T>
+    concept IVtxReaderPolicy =
+        requires(std::string buffer, const typename T::HeaderType& header, const typename T::FooterType& footer,
+                 std::vector<VTX::ChunkIndexEntry> index_table, VTX::GameTime::VTXGameTimes& game_times,
+                 int32_t chunk_idx, std::stop_token stop_token, std::vector<VTX::Frame>& out_native_frames,
+                 std::vector<uint8_t>& out_decompressed_blob,
+                 std::vector<std::span<const std::byte>>& out_raw_frames_spans) {
+            typename T::HeaderType;
+            typename T::FooterType;
+            typename T::SchemaType;
+
+            requires std::semiregular<typename T::HeaderType>;
+            requires std::semiregular<typename T::FooterType>;
+            requires std::semiregular<typename T::SchemaType>;
+
+            { T::ParseHeader(buffer) } -> std::same_as<typename T::HeaderType>;
+            { T::ParseFooter(buffer) } -> std::same_as<typename T::FooterType>;
+
+            { T::GetTotalFrames(footer) } -> std::convertible_to<int32_t>;
+            { T::GetSchema(header) } -> std::convertible_to<const typename T::SchemaType&>;
+            { T::GetVTXHeader(header) } -> std::convertible_to<VTX::FileHeader>;
+            { T::GetVTXFooter(footer) } -> std::convertible_to<VTX::FileFooter>;
+            {
+                T::ProcessChunkData(chunk_idx, buffer, stop_token, out_native_frames, out_decompressed_blob,
+                                    out_raw_frames_spans)
+                } -> std::same_as<void>;
+        };
 
 
     //Schema adapter concept
     //Is mandatory to implement a BuildCache method , receives schema and cache and return void
     template <typename T>
     concept SchemaAdaptable = requires(const T& schema, PropertyAddressCache& cache) {
-        { SchemaAdapter<T>::BuildCache(schema, cache) } -> std::same_as<void>;
-    };
-}
+                                  { SchemaAdapter<T>::BuildCache(schema, cache) } -> std::same_as<void>;
+                              };
+} // namespace VTX
diff --git a/sdk/include/vtx/common/vtx_entity_registry.h b/sdk/include/vtx/common/vtx_entity_registry.h
index 002d5e6..5972cca 100644
--- a/sdk/include/vtx/common/vtx_entity_registry.h
+++ b/sdk/include/vtx/common/vtx_entity_registry.h
@@ -7,9 +7,7 @@ namespace VTX {
 
     class EntityTypeRegistry {
     public:
-        static void RegisterName(int32_t type_id, const std::string& name) {
-            GetInternalMap()[type_id] = name;
-        }
+        static void RegisterName(int32_t type_id, const std::string& name) { GetInternalMap()[type_id] = name; }
 
         static std::string GetName(int32_t type_id) {
             auto& map = GetInternalMap();
@@ -20,9 +18,7 @@ namespace VTX {
             return "Type_" + std::to_string(type_id);
         }
 
-        static void Clear() {
-            GetInternalMap().clear();
-        }
+        static void Clear() { GetInternalMap().clear(); }
 
     private:
         static std::unordered_map<int32_t, std::string>& GetInternalMap() {
diff --git a/sdk/include/vtx/common/vtx_error_policy.h b/sdk/include/vtx/common/vtx_error_policy.h
index 12a95af..05983cd 100644
--- a/sdk/include/vtx/common/vtx_error_policy.h
+++ b/sdk/include/vtx/common/vtx_error_policy.h
@@ -6,7 +6,7 @@
  * @brief Generic error policies for reading operations
  * @author Zenos Interactive
  */
-namespace VTX{
+namespace VTX {
 
     /**
      * @struct StrictErrorPolicy
@@ -20,9 +20,7 @@ namespace VTX{
          * @param key The name of the missing key.
          * @throw std::runtime_error Always throws.
          */
-        static void OnMissingKey(const std::string& key) {
-            throw std::runtime_error("Missing mandatory key : " + key);
-        }
+        static void OnMissingKey(const std::string& key) { throw std::runtime_error("Missing mandatory key : " + key); }
 
         /**
          * @brief Called when the data type in JSON does not match the C++ target type.
@@ -66,11 +64,9 @@ namespace VTX{
      */
     struct SilentErrorPolicy {
         /** @brief No-op implementation. */
-        static void OnMissingKey(const std::string& key) {
-        }
+        static void OnMissingKey(const std::string& key) {}
         /** @brief No-op implementation. */
-        static void OnTypeMismatch(const std::string& key) {
-        }
+        static void OnTypeMismatch(const std::string& key) {}
     };
 
     // ==========================================================
@@ -109,4 +105,4 @@ namespace VTX{
             return key;
         }
     };
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/vtx_logger.h b/sdk/include/vtx/common/vtx_logger.h
index 207b2ea..8d1f65d 100644
--- a/sdk/include/vtx/common/vtx_logger.h
+++ b/sdk/include/vtx/common/vtx_logger.h
@@ -21,20 +21,15 @@ namespace VTX {
     // Replicates UE_LOG macros
     // ==========================================================
 
-    constexpr const char* ANSI_COLOR_RESET   = "\033[0m";
-    constexpr const char* ANSI_COLOR_INFO    = "\033[32m"; // Green
-    constexpr const char* ANSI_COLOR_WARN    = "\033[33m"; // Yellow
-    constexpr const char* ANSI_COLOR_ERROR   = "\033[31m"; // Red
-    constexpr const char* ANSI_COLOR_DEBUG   = "\033[36m"; // Cian
+    constexpr const char* ANSI_COLOR_RESET = "\033[0m";
+    constexpr const char* ANSI_COLOR_INFO = "\033[32m";  // Green
+    constexpr const char* ANSI_COLOR_WARN = "\033[33m";  // Yellow
+    constexpr const char* ANSI_COLOR_ERROR = "\033[31m"; // Red
+    constexpr const char* ANSI_COLOR_DEBUG = "\033[36m"; // Cian
 
     class Logger {
     public:
-        enum class Level {
-            Info,
-            Warning,
-            Error,
-            Debug
-        };
+        enum class Level { Info, Warning, Error, Debug };
 
         struct Entry {
             Level level = Level::Info;
@@ -66,13 +61,9 @@ namespace VTX {
         // print).  Useful for benchmarks, production deployments, or noisy
         // workloads where per-chunk trace output would dominate timings.
         // Thread-safe; can be toggled any time.
-        void SetDebugEnabled(bool enabled) {
-            debug_enabled_.store(enabled, std::memory_order_relaxed);
-        }
+        void SetDebugEnabled(bool enabled) { debug_enabled_.store(enabled, std::memory_order_relaxed); }
 
-        bool IsDebugEnabled() const {
-            return debug_enabled_.load(std::memory_order_relaxed);
-        }
+        bool IsDebugEnabled() const { return debug_enabled_.load(std::memory_order_relaxed); }
 
         void Log(Level LogLvl, const std::string& Message) {
             if (LogLvl == Level::Debug && !IsDebugEnabled()) {
@@ -95,11 +86,8 @@ namespace VTX {
                 entry.timestamp = timestamp_stream.str();
                 entry.message = Message;
 
-                std::cout << GetColorCode(LogLvl)
-                          << "[" << entry.timestamp << "] "
-                          << "[" << ToString(LogLvl) << "] "
-                          << Message
-                          << ANSI_COLOR_RESET << std::endl;
+                std::cout << GetColorCode(LogLvl) << "[" << entry.timestamp << "] "
+                          << "[" << ToString(LogLvl) << "] " << Message << ANSI_COLOR_RESET << std::endl;
 
                 sinks_copy.reserve(sinks_.size());
                 for (const auto& [_, sink] : sinks_) {
@@ -112,32 +100,33 @@ namespace VTX {
             }
         }
 
-        template<typename... Args>
+        template <typename... Args>
         void Info(std::string_view format_str, Args&&... args) {
             Log(Level::Info, std::vformat(format_str, std::make_format_args(args...)));
         }
 
-        template<typename... Args>
+        template <typename... Args>
         void Warn(std::string_view format_str, Args&&... args) {
             Log(Level::Warning, std::vformat(format_str, std::make_format_args(args...)));
         }
 
-        template<typename... Args>
+        template <typename... Args>
         void Error(std::string_view format_str, Args&&... args) {
             Log(Level::Error, std::vformat(format_str, std::make_format_args(args...)));
         }
 
-        template<typename... Args>
+        template <typename... Args>
         void Debug(std::string_view format_str, Args&&... args) {
             Log(Level::Debug, std::vformat(format_str, std::make_format_args(args...)));
         }
+
     private:
         std::mutex mute_;
         std::unordered_map<SinkId, SinkCallback> sinks_;
         SinkId next_sink_id_ = 1;
-        std::atomic<bool> debug_enabled_{true};
+        std::atomic<bool> debug_enabled_ {true};
 
-        template<typename ...Args>
+        template <typename... Args>
         void LogFormatted(Level log_level, const char* message, Args... args) {
             if constexpr (sizeof...(args) == 0) {
                 Log(log_level, message);
@@ -159,27 +148,36 @@ namespace VTX {
 
         const char* ToString(Level LogLvl) const {
             switch (LogLvl) {
-            case Level::Info:    return "INFO";
-            case Level::Warning: return "WARN";
-            case Level::Error:   return "ERROR";
-            case Level::Debug:   return "DEBUG";
-            default:             return "LOG";
+            case Level::Info:
+                return "INFO";
+            case Level::Warning:
+                return "WARN";
+            case Level::Error:
+                return "ERROR";
+            case Level::Debug:
+                return "DEBUG";
+            default:
+                return "LOG";
             }
         }
 
         const char* GetColorCode(Level LogLvl) const {
             switch (LogLvl) {
-            case Level::Info:    return ANSI_COLOR_INFO;
-            case Level::Warning: return ANSI_COLOR_WARN;
-            case Level::Error:   return ANSI_COLOR_ERROR;
-            case Level::Debug:   return ANSI_COLOR_DEBUG;
-            default:             return ANSI_COLOR_RESET;
+            case Level::Info:
+                return ANSI_COLOR_INFO;
+            case Level::Warning:
+                return ANSI_COLOR_WARN;
+            case Level::Error:
+                return ANSI_COLOR_ERROR;
+            case Level::Debug:
+                return ANSI_COLOR_DEBUG;
+            default:
+                return ANSI_COLOR_RESET;
             }
         }
-
     };
-    #define VTX_INFO(...)  VTX::Logger::Instance().Info(__VA_ARGS__)
-    #define VTX_WARN(...)  VTX::Logger::Instance().Warn(__VA_ARGS__)
-    #define VTX_ERROR(...) VTX::Logger::Instance().Error(__VA_ARGS__)
-    #define VTX_DEBUG(...) VTX::Logger::Instance().Debug(__VA_ARGS__)
+#define VTX_INFO(...) VTX::Logger::Instance().Info(__VA_ARGS__)
+#define VTX_WARN(...) VTX::Logger::Instance().Warn(__VA_ARGS__)
+#define VTX_ERROR(...) VTX::Logger::Instance().Error(__VA_ARGS__)
+#define VTX_DEBUG(...) VTX::Logger::Instance().Debug(__VA_ARGS__)
 } // namespace VTX
diff --git a/sdk/include/vtx/common/vtx_optimized_bone.h b/sdk/include/vtx/common/vtx_optimized_bone.h
index f47a116..4a8a62a 100644
--- a/sdk/include/vtx/common/vtx_optimized_bone.h
+++ b/sdk/include/vtx/common/vtx_optimized_bone.h
@@ -6,23 +6,21 @@
 #include <array>
 #include <iostream>
 
-#include "vtx_types.h" 
+#include "vtx_types.h"
 
-namespace VTX 
-{
+namespace VTX {
     /**
      * @brief Equivalent to UE's FBoneCompressionSettings.
      * Defines the ranges and precision modes for packing the Transform.
      */
     struct BoneCompressionSettings {
-        
         float position_minimum = -10000.0f;
         float position_range = 20000.0f; // Max - Min
-        
+
         float scale_minimum = 0.0f;
         float scale_range = 10.0f;
-        
-        Vector default_scale = { 1.0, 1.0, 1.0 };
+
+        Vector default_scale = {1.0, 1.0, 1.0};
         bool use_high_precision_position_no_scale = false;
 
         inline float GetPositionRange() const { return position_range; }
@@ -34,51 +32,43 @@ namespace VTX
      * A 16-byte (128-bit) container for a full Transform (Quat, Pos, Scale).
      * Layout: [41 Bits Rotation] [87 Bits Payload]
      */
-    struct alignas(16) OptimizedBoneData
-    {
+    struct alignas(16) OptimizedBoneData {
         /** Raw bit-storage. Exactly 16 bytes. 
          * alignas(16) ensures this can be loaded into SIMD registers efficiently. */
         uint32_t packed_transform[4];
 
         /** Packs a standard VTX::Transform into the 16-byte bitstream. */
-        void Pack(const Transform& SourceTransform, const BoneCompressionSettings& Settings)
-        {
+        void Pack(const Transform& SourceTransform, const BoneCompressionSettings& Settings) {
             // Reset all bits to zero
             packed_transform[0] = packed_transform[1] = packed_transform[2] = packed_transform[3] = 0;
 
             // --- SECTION 1: ROTATION (Fixed 41 Bits) ---
             Quat NormalizedQuat = SourceTransform.rotation;
-            
+
             // Normalize Quat
-            float invLen = 1.0f / std::sqrt(NormalizedQuat.x * NormalizedQuat.x + 
-                                            NormalizedQuat.y * NormalizedQuat.y + 
-                                            NormalizedQuat.z * NormalizedQuat.z + 
-                                            NormalizedQuat.w * NormalizedQuat.w);
+            float invLen = 1.0f / std::sqrt(NormalizedQuat.x * NormalizedQuat.x + NormalizedQuat.y * NormalizedQuat.y +
+                                            NormalizedQuat.z * NormalizedQuat.z + NormalizedQuat.w * NormalizedQuat.w);
             NormalizedQuat.x *= invLen;
             NormalizedQuat.y *= invLen;
             NormalizedQuat.z *= invLen;
             NormalizedQuat.w *= invLen;
 
             // Ensure W is always positive (Quaternions are double-cover, -Q == Q)
-            if (NormalizedQuat.w < 0.0f) 
-            {
+            if (NormalizedQuat.w < 0.0f) {
                 NormalizedQuat.x *= -1.0f;
                 NormalizedQuat.y *= -1.0f;
                 NormalizedQuat.z *= -1.0f;
                 NormalizedQuat.w *= -1.0f;
             }
 
-            const std::array<float, 4> Components = { 
-                NormalizedQuat.x, NormalizedQuat.y, NormalizedQuat.z, NormalizedQuat.w 
-            };
+            const std::array<float, 4> Components = {NormalizedQuat.x, NormalizedQuat.y, NormalizedQuat.z,
+                                                     NormalizedQuat.w};
 
             // Find the index of the largest absolute component
             int32_t LargestIndex = 0;
             float LargestValue = std::abs(Components[0]);
-            for (int32_t i = 1; i < 4; i++) 
-            {
-                if (std::abs(Components[i]) > LargestValue) 
-                {
+            for (int32_t i = 1; i < 4; i++) {
+                if (std::abs(Components[i]) > LargestValue) {
                     LargestValue = std::abs(Components[i]);
                     LargestIndex = i;
                 }
@@ -88,12 +78,13 @@ namespace VTX
             const float SignMultiplier = (Components[LargestIndex] < 0.0f) ? -1.0f : 1.0f;
 
             // Pack the index (2 bits) and the other 3 components (13 bits each)
-            constexpr float RotationPackFactor = 5791.9103f; 
+            constexpr float RotationPackFactor = 5791.9103f;
             const uint32_t PackedRotationIndex = static_cast<uint32_t>(LargestIndex);
-            
+
             auto PackComponent = [&](int offset) -> uint32_t {
                 float comp = Components[(LargestIndex + offset) % 4] * SignMultiplier;
-                return std::clamp(static_cast<uint32_t>(std::round((comp + 0.707107f) * RotationPackFactor)), 0u, 8191u);
+                return std::clamp(static_cast<uint32_t>(std::round((comp + 0.707107f) * RotationPackFactor)), 0u,
+                                  8191u);
             };
 
             const uint32_t Quat1 = PackComponent(1);
@@ -110,13 +101,14 @@ namespace VTX
             const float PosRange = std::max(0.0001f, Settings.GetPositionRange());
             const float InvPosRange = 1.0f / PosRange;
 
-            if (Settings.use_high_precision_position_no_scale)
-            {
+            if (Settings.use_high_precision_position_no_scale) {
                 // Mode: 21 bits per Position axis (0 to 2,097,151)
-                const float PosScaleFactor = 2097151.0f * InvPosRange; 
+                const float PosScaleFactor = 2097151.0f * InvPosRange;
 
                 auto PackPos = [&](double locAxis) -> uint32_t {
-                    return std::clamp(static_cast<uint32_t>(std::round((static_cast<float>(locAxis) - Settings.position_minimum) * PosScaleFactor)), 0u, 2097151u);
+                    return std::clamp(static_cast<uint32_t>(std::round(
+                                          (static_cast<float>(locAxis) - Settings.position_minimum) * PosScaleFactor)),
+                                      0u, 2097151u);
                 };
 
                 const uint32_t PackedPosX = PackPos(Location.x);
@@ -126,14 +118,14 @@ namespace VTX
                 packed_transform[1] |= (PackedPosX << 9);
                 packed_transform[2] = PackedPosY | ((PackedPosZ & 0x7FF) << 21);
                 packed_transform[3] = (PackedPosZ >> 11);
-            }
-            else
-            {
+            } else {
                 // Mode: 16 bits Position (0 to 65535) + 8 bits Scale (0 to 255)
-                const float PosScaleFactor = 65535.0f * InvPosRange; 
+                const float PosScaleFactor = 65535.0f * InvPosRange;
 
                 auto PackPos = [&](double locAxis) -> uint32_t {
-                    return std::clamp(static_cast<uint32_t>(std::round((static_cast<float>(locAxis) - Settings.position_minimum) * PosScaleFactor)), 0u, 65535u);
+                    return std::clamp(static_cast<uint32_t>(std::round(
+                                          (static_cast<float>(locAxis) - Settings.position_minimum) * PosScaleFactor)),
+                                      0u, 65535u);
                 };
 
                 const uint32_t PackedPosX = PackPos(Location.x);
@@ -145,7 +137,9 @@ namespace VTX
                 const float ScalePackFactor = 255.0f * (1.0f / ScaleRange);
 
                 auto PackScale = [&](double scaleAxis) -> uint32_t {
-                    return std::clamp(static_cast<uint32_t>(std::round((static_cast<float>(scaleAxis) - Settings.scale_minimum) * ScalePackFactor)), 0u, 255u);
+                    return std::clamp(static_cast<uint32_t>(std::round(
+                                          (static_cast<float>(scaleAxis) - Settings.scale_minimum) * ScalePackFactor)),
+                                      0u, 255u);
                 };
 
                 const uint32_t PackedScaleX = PackScale(Scale.x);
@@ -159,8 +153,7 @@ namespace VTX
         }
 
         /** Unpacks the 16-byte buffer into a usable VTX::Transform. */
-        void Unpack(const BoneCompressionSettings& Settings, Transform& OutTransform) const
-        {
+        void Unpack(const BoneCompressionSettings& Settings, Transform& OutTransform) const {
             // --- STEP 1: EXTRACT ROTATION ---
             const uint32_t QuatIndex = packed_transform[0] & 0x3;
             const uint32_t RawQuat1 = (packed_transform[0] >> 2) & 0x1FFF;
@@ -170,8 +163,8 @@ namespace VTX
             std::array<float, 4> QuatComponents = {0.0f, 0.0f, 0.0f, 0.0f};
 
             constexpr float QuatUnpackFactor = 0.000172654f;
-            auto DequantizeQuat = [](const uint32_t Value) { 
-                return (static_cast<float>(Value) * QuatUnpackFactor) - 0.707107f; 
+            auto DequantizeQuat = [](const uint32_t Value) {
+                return (static_cast<float>(Value) * QuatUnpackFactor) - 0.707107f;
             };
 
             QuatComponents[(QuatIndex + 1) % 4] = DequantizeQuat(RawQuat1);
@@ -179,23 +172,20 @@ namespace VTX
             QuatComponents[(QuatIndex + 3) % 4] = DequantizeQuat(RawQuat3);
 
             // Reconstruct the largest component using the property X^2 + Y^2 + Z^2 + W^2 = 1
-            const float SquaredSum = QuatComponents[(QuatIndex + 1) % 4] * QuatComponents[(QuatIndex + 1) % 4] + 
-                                     QuatComponents[(QuatIndex + 2) % 4] * QuatComponents[(QuatIndex + 2) % 4] + 
+            const float SquaredSum = QuatComponents[(QuatIndex + 1) % 4] * QuatComponents[(QuatIndex + 1) % 4] +
+                                     QuatComponents[(QuatIndex + 2) % 4] * QuatComponents[(QuatIndex + 2) % 4] +
                                      QuatComponents[(QuatIndex + 3) % 4] * QuatComponents[(QuatIndex + 3) % 4];
 
             QuatComponents[QuatIndex] = std::sqrt(std::max(0.0f, 1.0f - SquaredSum));
-            
-            OutTransform.rotation = { 
-                QuatComponents[0], QuatComponents[1], QuatComponents[2], QuatComponents[3] 
-            };
-            
+
+            OutTransform.rotation = {QuatComponents[0], QuatComponents[1], QuatComponents[2], QuatComponents[3]};
+
             // --- STEP 2: EXTRACT POSITION & SCALE ---
             Vector OutPosition;
             Vector OutScale = Settings.default_scale;
             const float PosRange = Settings.GetPositionRange();
 
-            if (Settings.use_high_precision_position_no_scale)
-            {
+            if (Settings.use_high_precision_position_no_scale) {
                 // 21-bit Extraction
                 const uint32_t RawPosX = (packed_transform[1] >> 9) & 0x1FFFFF;
                 const uint32_t RawPosY = (packed_transform[2] & 0x1FFFFF);
@@ -203,12 +193,13 @@ namespace VTX
 
                 const float PosUnpackFactor = PosRange * 0.000000476837f;
 
-                OutPosition.x = static_cast<double>(static_cast<float>(RawPosX) * PosUnpackFactor + Settings.position_minimum);
-                OutPosition.y = static_cast<double>(static_cast<float>(RawPosY) * PosUnpackFactor + Settings.position_minimum);
-                OutPosition.z = static_cast<double>(static_cast<float>(RawPosZ) * PosUnpackFactor + Settings.position_minimum);
-            }
-            else
-            {
+                OutPosition.x =
+                    static_cast<double>(static_cast<float>(RawPosX) * PosUnpackFactor + Settings.position_minimum);
+                OutPosition.y =
+                    static_cast<double>(static_cast<float>(RawPosY) * PosUnpackFactor + Settings.position_minimum);
+                OutPosition.z =
+                    static_cast<double>(static_cast<float>(RawPosZ) * PosUnpackFactor + Settings.position_minimum);
+            } else {
                 // 16-bit Position + 8-bit Scale Extraction
                 const uint32_t RawPosX = (packed_transform[1] >> 9) & 0xFFFF;
                 const uint32_t RawPosY = ((packed_transform[1] >> 25) & 0x7F) | ((packed_transform[2] & 0x1FF) << 7);
@@ -220,15 +211,21 @@ namespace VTX
                 const uint32_t RawScaleY = (packed_transform[3] >> 1) & 0xFF;
                 const uint32_t RawScaleZ = (packed_transform[3] >> 9) & 0xFF;
 
-                OutPosition.x = static_cast<double>(static_cast<float>(RawPosX) * PosUnpackFactor + Settings.position_minimum);
-                OutPosition.y = static_cast<double>(static_cast<float>(RawPosY) * PosUnpackFactor + Settings.position_minimum);
-                OutPosition.z = static_cast<double>(static_cast<float>(RawPosZ) * PosUnpackFactor + Settings.position_minimum);
+                OutPosition.x =
+                    static_cast<double>(static_cast<float>(RawPosX) * PosUnpackFactor + Settings.position_minimum);
+                OutPosition.y =
+                    static_cast<double>(static_cast<float>(RawPosY) * PosUnpackFactor + Settings.position_minimum);
+                OutPosition.z =
+                    static_cast<double>(static_cast<float>(RawPosZ) * PosUnpackFactor + Settings.position_minimum);
 
                 const float ScaleUnpackFactor = Settings.GetScaleRange() * 0.00392157f;
 
-                OutScale.x = static_cast<double>(static_cast<float>(RawScaleX) * ScaleUnpackFactor + Settings.scale_minimum);
-                OutScale.y = static_cast<double>(static_cast<float>(RawScaleY) * ScaleUnpackFactor + Settings.scale_minimum);
-                OutScale.z = static_cast<double>(static_cast<float>(RawScaleZ) * ScaleUnpackFactor + Settings.scale_minimum);
+                OutScale.x =
+                    static_cast<double>(static_cast<float>(RawScaleX) * ScaleUnpackFactor + Settings.scale_minimum);
+                OutScale.y =
+                    static_cast<double>(static_cast<float>(RawScaleY) * ScaleUnpackFactor + Settings.scale_minimum);
+                OutScale.z =
+                    static_cast<double>(static_cast<float>(RawScaleZ) * ScaleUnpackFactor + Settings.scale_minimum);
             }
 
             OutTransform.translation = OutPosition;
@@ -236,14 +233,12 @@ namespace VTX
         }
 
         // C++ Standard I/O replacement for Unreal's FArchive
-        friend std::ostream& operator<<(std::ostream& os, const OptimizedBoneData& data)
-        {
+        friend std::ostream& operator<<(std::ostream& os, const OptimizedBoneData& data) {
             os.write(reinterpret_cast<const char*>(data.packed_transform), sizeof(data.packed_transform));
             return os;
         }
 
-        friend std::istream& operator>>(std::istream& is, OptimizedBoneData& data)
-        {
+        friend std::istream& operator>>(std::istream& is, OptimizedBoneData& data) {
             is.read(reinterpret_cast<char*>(data.packed_transform), sizeof(data.packed_transform));
             return is;
         }
@@ -251,4 +246,4 @@ namespace VTX
 
     // Ensure it remains exactly 16 bytes for hardware alignment guarantees
     static_assert(sizeof(OptimizedBoneData) == 16, "OptimizedBoneData must be exactly 16 bytes");
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/common/vtx_property_cache.h b/sdk/include/vtx/common/vtx_property_cache.h
index 932fa78..5a400b0 100644
--- a/sdk/include/vtx/common/vtx_property_cache.h
+++ b/sdk/include/vtx/common/vtx_property_cache.h
@@ -5,14 +5,14 @@
 #include <string_view>
 #include <vector>
 #include "vtx/common/vtx_types.h"
-#include  "vtx/common/readers/schema_reader/game_schema_types.h"
-namespace VTX
-{
+#include "vtx/common/readers/schema_reader/game_schema_types.h"
+namespace VTX {
 
-    constexpr uint64_t MakePropertyLookupKey(int32_t index, VTX::FieldType type_id, VTX::FieldContainerType container_type) {
+    constexpr uint64_t MakePropertyLookupKey(int32_t index, VTX::FieldType type_id,
+                                             VTX::FieldContainerType container_type) {
         return (static_cast<uint64_t>(static_cast<uint32_t>(index)) << 32) |
-            (static_cast<uint64_t>(static_cast<uint8_t>(type_id)) << 16) |
-            static_cast<uint64_t>(static_cast<uint8_t>(container_type));
+               (static_cast<uint64_t>(static_cast<uint8_t>(type_id)) << 16) |
+               static_cast<uint64_t>(static_cast<uint8_t>(container_type));
     }
 
     /**
@@ -21,18 +21,29 @@ namespace VTX
      */
     template <typename T>
     constexpr VTX::FieldType GetExpectedFieldType() {
-        if constexpr (std::same_as<T, bool>) return VTX::FieldType::Bool;
-        else if constexpr (std::same_as<T, int32_t>) return VTX::FieldType::Int32;
-        else if constexpr (std::same_as<T, int64_t>) return VTX::FieldType::Int64;
-        else if constexpr (std::same_as<T, float>) return VTX::FieldType::Float;
-        else if constexpr (std::same_as<T, double>) return VTX::FieldType::Double;
-        else if constexpr (std::same_as<T, std::string>) return VTX::FieldType::String;
-        else if constexpr (std::same_as<T, VTX::Vector>) return VTX::FieldType::Vector;
-        else if constexpr (std::same_as<T, VTX::Quat>) return VTX::FieldType::Quat;
-        else if constexpr (std::same_as<T, VTX::Transform>) return VTX::FieldType::Transform;
-        else if constexpr (std::same_as<T, VTX::FloatRange>) return VTX::FieldType::FloatRange;
+        if constexpr (std::same_as<T, bool>)
+            return VTX::FieldType::Bool;
+        else if constexpr (std::same_as<T, int32_t>)
+            return VTX::FieldType::Int32;
+        else if constexpr (std::same_as<T, int64_t>)
+            return VTX::FieldType::Int64;
+        else if constexpr (std::same_as<T, float>)
+            return VTX::FieldType::Float;
+        else if constexpr (std::same_as<T, double>)
+            return VTX::FieldType::Double;
+        else if constexpr (std::same_as<T, std::string>)
+            return VTX::FieldType::String;
+        else if constexpr (std::same_as<T, VTX::Vector>)
+            return VTX::FieldType::Vector;
+        else if constexpr (std::same_as<T, VTX::Quat>)
+            return VTX::FieldType::Quat;
+        else if constexpr (std::same_as<T, VTX::Transform>)
+            return VTX::FieldType::Transform;
+        else if constexpr (std::same_as<T, VTX::FloatRange>)
+            return VTX::FieldType::FloatRange;
         // else if constexpr (std::same_as<T, VTX::PropertyContainer>) return VTX::FieldType::Struct;
-        else return VTX::FieldType::None; 
+        else
+            return VTX::FieldType::None;
     }
 
     /**
@@ -43,11 +54,9 @@ namespace VTX
     struct PropertyKey {
         int32_t index = -1;
         bool IsValid() const { return index > -1; }
-        bool operator==(const PropertyKey& other) const {
-            return index == other.index;
-        }
+        bool operator==(const PropertyKey& other) const { return index == other.index; }
     };
-    
+
     /**
      * @brief Represents the metadata of a property in the schema.
      * Now includes the type (and optionally array flag) for safety validation.
@@ -55,7 +64,8 @@ namespace VTX
     struct PropertyAddress {
         int32_t index = -1;                            ///< Index in the SoA vector or FlatArray offset list.
         VTX::FieldType type_id = VTX::FieldType::None; ///< Stored to validate the type at runtime.
-        VTX::FieldContainerType container_type = VTX::FieldContainerType::None; ///< Full container metadata from schema.
+        VTX::FieldContainerType container_type =
+            VTX::FieldContainerType::None; ///< Full container metadata from schema.
         std::string child_type_name;
         bool IsValid() const { return index > -1; }
     };
@@ -82,7 +92,7 @@ namespace VTX
                 for (const auto& property_name : property_order) {
                     const auto it = properties.find(property_name);
                     if (it != properties.end()) {
-                        ordered_properties.push_back(OrderedPropertyView{
+                        ordered_properties.push_back(OrderedPropertyView {
                             .name = it->first,
                             .address = &it->second,
                         });
@@ -93,7 +103,7 @@ namespace VTX
 
             ordered_properties.reserve(properties.size());
             for (const auto& [property_name, property_address] : properties) {
-                ordered_properties.push_back(OrderedPropertyView{
+                ordered_properties.push_back(OrderedPropertyView {
                     .name = property_name,
                     .address = &property_address,
                 });
@@ -111,20 +121,16 @@ namespace VTX
         // Value: The schema cache containing its specific properties
         std::unordered_map<int32_t, StructSchemaCache> structs;
         std::unordered_map<std::string, int32_t> name_to_id;
-        void Clear()
-        {
+        void Clear() {
             structs.clear();
             name_to_id.clear();
         }
     };
-}
+} // namespace VTX
 
-namespace std
-{
+namespace std {
     template <typename T>
     struct hash<VTX::PropertyKey<T>> {
-        size_t operator()(const VTX::PropertyKey<T>& key) const noexcept {
-            return std::hash<int32_t>()(key.index);
-        }
+        size_t operator()(const VTX::PropertyKey<T>& key) const noexcept { return std::hash<int32_t>()(key.index); }
     };
-}
+} // namespace std
diff --git a/sdk/include/vtx/common/vtx_reflection.h b/sdk/include/vtx/common/vtx_reflection.h
index 070250f..9e615c0 100644
--- a/sdk/include/vtx/common/vtx_reflection.h
+++ b/sdk/include/vtx/common/vtx_reflection.h
@@ -12,26 +12,26 @@
 #include "readers/schema_reader/game_schema_types.h"
 
 namespace VTX {
-    
+
     struct FieldMapping {
         std::string name;
         std::string json_name;
         FieldType type;
-        int32_t index;       // index in PropertyContainer (SoA)
+        int32_t index;        // index in PropertyContainer (SoA)
         std::string sub_type; // for complexObject / struct (struct name)
     };
 
-    #define VTX_BEGIN_STRUCT(struct_name) \
-    inline void Register_##struct_name(SchemaRegistry& reg) { \
-    SchemaStruct s; s.name = #struct_name;
+#define VTX_BEGIN_STRUCT(struct_name)                                                                                  \
+    inline void Register_##struct_name(SchemaRegistry& reg) {                                                          \
+        SchemaStruct s;                                                                                                \
+        s.name = #struct_name;
 
-    #define VTX_FIELD(field_name, json_key, type_id, idx) \
-    s.fields.push_back({#field_name, json_key, type_id, idx, ""});
+#define VTX_FIELD(field_name, json_key, type_id, idx) s.fields.push_back({#field_name, json_key, type_id, idx, ""});
 
-    #define VTX_COMPLEX_FIELD(field_name, json_key, idx, sub_struct) \
+#define VTX_COMPLEX_FIELD(field_name, json_key, idx, sub_struct)                                                       \
     s.fields.push_back({#field_name, json_key, FieldType::Struct, idx, #sub_struct});
 
-    #define VTX_END_STRUCT() \
-    reg.AddStruct(std::move(s)); \
+#define VTX_END_STRUCT()                                                                                               \
+    reg.AddStruct(std::move(s));                                                                                       \
     }
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/common/vtx_types.h b/sdk/include/vtx/common/vtx_types.h
index d5fb4ad..c705be7 100644
--- a/sdk/include/vtx/common/vtx_types.h
+++ b/sdk/include/vtx/common/vtx_types.h
@@ -23,16 +23,11 @@
 #include <unordered_map>
 #include <vector>
 
-namespace VTX
-{
+namespace VTX {
     /**
      * @brief Identifies the binary serialization format of a VTX file.
      */
-    enum class VtxFormat : uint8_t {
-        Unknown = 0,
-        FlatBuffers,
-        Protobuf
-    };
+    enum class VtxFormat : uint8_t { Unknown = 0, FlatBuffers, Protobuf };
 
     /**
      * @brief Represents a double-precision 3D vector.
@@ -63,7 +58,7 @@ namespace VTX
     struct Transform {
         Vector translation;
         Quat rotation;
-        Vector scale = { 1.0, 1.0, 1.0 };
+        Vector scale = {1.0, 1.0, 1.0};
         bool operator==(const Transform&) const = default;
     };
 
@@ -88,7 +83,7 @@ namespace VTX
      */
     template <typename T>
     struct FlatArray {
-        std::vector<T> data;          ///< Contiguous block of data values.
+        std::vector<T> data;           ///< Contiguous block of data values.
         std::vector<uint32_t> offsets; ///< Indices or offsets defining boundaries/mapping.
 
         /**
@@ -106,40 +101,35 @@ namespace VTX
         size_t TotalElementCount() const { return data.size(); }
 
         /** Returns a read-only span for subarray at Index (empty on out-of-bounds). */
-        std::span<const T> GetSubArray(size_t Index) const
-        {
-            if (Index >= offsets.size()) return {};
+        std::span<const T> GetSubArray(size_t Index) const {
+            if (Index >= offsets.size())
+                return {};
             const size_t Start = offsets[Index];
-            const size_t End   = (Index + 1 < offsets.size()) ? offsets[Index + 1] : data.size();
+            const size_t End = (Index + 1 < offsets.size()) ? offsets[Index + 1] : data.size();
             return std::span<const T>(&data[Start], End - Start);
         }
 
         /** Returns a mutable span for subarray at Index (empty on out-of-bounds). */
-        std::span<T> GetMutableSubArray(size_t Index)
-        {
-            if (Index >= offsets.size()) return {};
+        std::span<T> GetMutableSubArray(size_t Index) {
+            if (Index >= offsets.size())
+                return {};
             const size_t Start = offsets[Index];
-            const size_t End   = (Index + 1 < offsets.size()) ? offsets[Index + 1] : data.size();
+            const size_t End = (Index + 1 < offsets.size()) ? offsets[Index + 1] : data.size();
             return std::span<T>(&data[Start], End - Start);
         }
 
 
         /** Creates an empty subarray at the end (i.e., a new marker pointing to current Bucket.size()). */
-        void CreateEmptySubArray()
-        {
-            offsets.push_back(data.size());
-        }
+        void CreateEmptySubArray() { offsets.push_back(data.size()); }
 
         /** Appends a subarray with given elements at the end. */
-        void AppendSubArray(std::span<const T> Items)
-        {
+        void AppendSubArray(std::span<const T> Items) {
             offsets.push_back(data.size());
             data.insert(data.end(), Items.begin(), Items.end());
         }
 
         /** Appends a subarray with an initializer_list. */
-        void AppendSubArray(std::initializer_list<T> Items)
-        {
+        void AppendSubArray(std::initializer_list<T> Items) {
             AppendSubArray(std::span<const T>(Items.begin(), Items.size()));
         }
 
@@ -147,9 +137,9 @@ namespace VTX
          * Inserts a subarray BEFORE SubIndex. Returns false if SubIndex is out of range (SubIndex > offsets.size()).
          * SubIndex == offsets.size() is equivalent to AppendSubArray.
          */
-        bool InsertSubArray(size_t SubIndex, std::span<const T> Items)
-        {
-            if (SubIndex > offsets.size()) return false;
+        bool InsertSubArray(size_t SubIndex, std::span<const T> Items) {
+            if (SubIndex > offsets.size())
+                return false;
 
             // Compute insertion position in Bucket
             const size_t InsertPos = (SubIndex < offsets.size()) ? offsets[SubIndex] : data.size();
@@ -168,8 +158,7 @@ namespace VTX
         }
 
         /** Inserts a subarray from initializer_list BEFORE SubIndex. */
-        bool InsertSubArray(size_t SubIndex, std::initializer_list<T> Items)
-        {
+        bool InsertSubArray(size_t SubIndex, std::initializer_list<T> Items) {
             return InsertSubArray(SubIndex, std::span<const T>(Items.begin(), Items.size()));
         }
 
@@ -177,12 +166,12 @@ namespace VTX
          * Erases the entire subarray at SubIndex. Returns false on out-of-bounds.
          * Elements are removed from Bucket and offsets are rebased.
          */
-        bool EraseSubArray(size_t SubIndex)
-        {
-            if (SubIndex >= offsets.size()) return false;
+        bool EraseSubArray(size_t SubIndex) {
+            if (SubIndex >= offsets.size())
+                return false;
 
             const size_t Start = offsets[SubIndex];
-            const size_t End   = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
+            const size_t End = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
             const size_t Count = End - Start;
 
             // Remove range from Bucket
@@ -204,8 +193,7 @@ namespace VTX
          * Pushes Value at the end of subarray SubIndex.
          * Returns false on out-of-bounds.
          */
-        bool PushBack(size_t SubIndex, const T& Value)
-        {
+        bool PushBack(size_t SubIndex, const T& Value) {
             if (SubIndex >= offsets.size()) {
                 size_t old_size = offsets.size();
                 offsets.resize(SubIndex + 1);
@@ -230,14 +218,15 @@ namespace VTX
          * Inserts Value at position ItemIndex INSIDE subarray SubIndex.
          * ItemIndex is 0..SubArraySize; ItemIndex==SubArraySize inserts at the end.
          */
-        bool Insert(size_t SubIndex, size_t ItemIndex, const T& Value)
-        {
-            if (SubIndex >= offsets.size()) return false;
+        bool Insert(size_t SubIndex, size_t ItemIndex, const T& Value) {
+            if (SubIndex >= offsets.size())
+                return false;
 
             const size_t Start = offsets[SubIndex];
-            const size_t End   = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
-            const size_t Sz    = End - Start;
-            if (ItemIndex > Sz) return false;
+            const size_t End = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
+            const size_t Sz = End - Start;
+            if (ItemIndex > Sz)
+                return false;
 
             const size_t InsertPos = Start + ItemIndex;
             data.insert(data.begin() + InsertPos, Value);
@@ -252,14 +241,15 @@ namespace VTX
         /**
          * Replaces the element at ItemIndex INSIDE subarray SubIndex with Value.
          */
-        bool Replace(size_t SubIndex, size_t ItemIndex, const T& Value)
-        {
-            if (SubIndex >= offsets.size()) return false;
+        bool Replace(size_t SubIndex, size_t ItemIndex, const T& Value) {
+            if (SubIndex >= offsets.size())
+                return false;
 
             const size_t Start = offsets[SubIndex];
-            const size_t End   = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
-            const size_t Sz    = End - Start;
-            if (ItemIndex >= Sz) return false;
+            const size_t End = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
+            const size_t Sz = End - Start;
+            if (ItemIndex >= Sz)
+                return false;
 
             data[Start + ItemIndex] = Value;
             return true;
@@ -269,14 +259,15 @@ namespace VTX
          * Erases the element at ItemIndex INSIDE subarray SubIndex.
          * Returns false on out-of-bounds.
          */
-        bool Erase(size_t SubIndex, size_t ItemIndex)
-        {
-            if (SubIndex >= offsets.size()) return false;
+        bool Erase(size_t SubIndex, size_t ItemIndex) {
+            if (SubIndex >= offsets.size())
+                return false;
 
             const size_t Start = offsets[SubIndex];
-            const size_t End   = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
-            const size_t Sz    = End - Start;
-            if (ItemIndex >= Sz) return false;
+            const size_t End = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
+            const size_t Sz = End - Start;
+            if (ItemIndex >= Sz)
+                return false;
 
             data.erase(data.begin() + (Start + ItemIndex));
 
@@ -291,20 +282,22 @@ namespace VTX
          * Removes a range [First, Last) INSIDE subarray SubIndex.
          * Returns false if the range is invalid.
          */
-        bool EraseRange(size_t SubIndex, size_t First, size_t Last)
-        {
-            if (SubIndex >= offsets.size()) return false;
+        bool EraseRange(size_t SubIndex, size_t First, size_t Last) {
+            if (SubIndex >= offsets.size())
+                return false;
 
             const size_t Start = offsets[SubIndex];
-            const size_t End   = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
-            const size_t Sz    = End - Start;
+            const size_t End = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
+            const size_t Sz = End - Start;
 
-            if (First > Last || Last > Sz) return false;
+            if (First > Last || Last > Sz)
+                return false;
             const size_t GlobalFirst = Start + First;
-            const size_t GlobalLast  = Start + Last;
+            const size_t GlobalLast = Start + Last;
 
             const size_t Count = GlobalLast - GlobalFirst;
-            if (Count == 0) return true;
+            if (Count == 0)
+                return true;
 
             data.erase(data.begin() + GlobalFirst, data.begin() + GlobalLast);
 
@@ -318,12 +311,12 @@ namespace VTX
          * Replaces the entire subarray SubIndex with Items.
          * Equivalent to EraseSubArray + InsertSubArray at the same position.
          */
-        bool ReplaceSubArray(size_t SubIndex, std::span<const T> Items)
-        {
-            if (SubIndex >= offsets.size()) return false;
+        bool ReplaceSubArray(size_t SubIndex, std::span<const T> Items) {
+            if (SubIndex >= offsets.size())
+                return false;
 
             const size_t Start = offsets[SubIndex];
-            const size_t End   = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
+            const size_t End = (SubIndex + 1 < offsets.size()) ? offsets[SubIndex + 1] : data.size();
             const size_t OldCount = End - Start;
             const size_t NewCount = Items.size();
 
@@ -333,8 +326,7 @@ namespace VTX
 
             // Rebase subsequent offsets by (NewCount - OldCount)
             const ptrdiff_t Delta = static_cast<ptrdiff_t>(NewCount) - static_cast<ptrdiff_t>(OldCount);
-            if (Delta != 0)
-            {
+            if (Delta != 0) {
                 for (size_t i = SubIndex + 1; i < offsets.size(); ++i)
                     offsets[i] = static_cast<size_t>(static_cast<ptrdiff_t>(offsets[i]) + Delta);
             }
@@ -342,8 +334,7 @@ namespace VTX
             return true;
         }
 
-        bool ReplaceSubArray(size_t SubIndex, std::initializer_list<T> Items)
-        {
+        bool ReplaceSubArray(size_t SubIndex, std::initializer_list<T> Items) {
             return ReplaceSubArray(SubIndex, std::span<const T>(Items.begin(), Items.size()));
         }
     };
@@ -385,7 +376,6 @@ namespace VTX
     using FlatMapArray = FlatArray<MapContainer>;
 
 
-
     /**
      * @brief The core dynamic container for all entity properties.
      * @details This "Mega-Struct" acts as a variant-like container capable of holding
@@ -393,7 +383,6 @@ namespace VTX
      * vectors for every supported type.
      */
     struct PropertyContainer {
-
         /**
          * @brief Type identifier for this container (maps to the autogenerated EntityType enum).
          * If -1, the type is unknown or anonymous.
@@ -408,56 +397,56 @@ namespace VTX
 
         // These vectors hold the values for properties mapped by index in the Schema.
 
-        std::vector<bool>        bool_properties;   ///< List of boolean property values.
-        std::vector<int32_t>     int32_properties;  ///< List of int32_t property values.
-        std::vector<int64_t>     int64_properties;  ///< List of int64_t property values.
-        std::vector<float>       float_properties;  ///< List of float property values.
-        std::vector<double>      double_properties; ///< List of double property values.
+        std::vector<bool> bool_properties;          ///< List of boolean property values.
+        std::vector<int32_t> int32_properties;      ///< List of int32_t property values.
+        std::vector<int64_t> int64_properties;      ///< List of int64_t property values.
+        std::vector<float> float_properties;        ///< List of float property values.
+        std::vector<double> double_properties;      ///< List of double property values.
         std::vector<std::string> string_properties; ///< List of string property values.
 
-        std::vector<Transform>  transform_properties; ///< List of Transform values.
-        std::vector<Vector>     vector_properties;    ///< List of Vector values.
-        std::vector<Quat>       quat_properties;      ///< List of Quaternion values.
-        std::vector<FloatRange> range_properties;     ///< List of FloatRange values.
+        std::vector<Transform> transform_properties; ///< List of Transform values.
+        std::vector<Vector> vector_properties;       ///< List of Vector values.
+        std::vector<Quat> quat_properties;           ///< List of Quaternion values.
+        std::vector<FloatRange> range_properties;    ///< List of FloatRange values.
 
         // --- Optimized Flat Arrays (SoA) ---
         // These store arrays of arrays (e.g., an inventory list per entity).
 
-        FlatBytesArray     byte_array_properties; ///< Arrays of bytes.
-        FlatIntArray       int32_arrays;         ///< Arrays of int32_ts.
-        Flatint64_tArray   int64_arrays;         ///< Arrays of int64_ts.
-        FlatFloatArray     float_arrays;         ///< Arrays of floats.
-        FlatDoubleArray    double_arrays;        ///< Arrays of doubles.
+        FlatBytesArray byte_array_properties; ///< Arrays of bytes.
+        FlatIntArray int32_arrays;            ///< Arrays of int32_ts.
+        Flatint64_tArray int64_arrays;        ///< Arrays of int64_ts.
+        FlatFloatArray float_arrays;          ///< Arrays of floats.
+        FlatDoubleArray double_arrays;        ///< Arrays of doubles.
 
-        FlatVectorArray    vector_arrays;        ///< Arrays of Vectors.
-        FlatQuatArray      quat_arrays;          ///< Arrays of Quaternions.
-        FlatTransformArray transform_arrays;     ///< Arrays of Transforms.
-        FlatRangeArray     range_arrays;         ///< Arrays of FloatRanges.
+        FlatVectorArray vector_arrays;       ///< Arrays of Vectors.
+        FlatQuatArray quat_arrays;           ///< Arrays of Quaternions.
+        FlatTransformArray transform_arrays; ///< Arrays of Transforms.
+        FlatRangeArray range_arrays;         ///< Arrays of FloatRanges.
 
-        FlatBoolArray      bool_arrays;          ///< Arrays of booleans.
-        FlatStringArray    string_arrays;        ///< Arrays of strings.
+        FlatBoolArray bool_arrays;     ///< Arrays of booleans.
+        FlatStringArray string_arrays; ///< Arrays of strings.
 
 
         /**
          * @brief Nested structures.
          * @details Recursively holds other PropertyContainers.
          */
-        std::vector<PropertyContainer>      any_struct_properties;
+        std::vector<PropertyContainer> any_struct_properties;
 
         /**
          * @brief Arrays of nested structures.
          */
-        FlatAnyStructArray                  any_struct_arrays;
+        FlatAnyStructArray any_struct_arrays;
 
         /**
          * @brief Map properties (Key-Value pairs).
          */
-        std::vector<MapContainer>           map_properties;
+        std::vector<MapContainer> map_properties;
 
         /**
          * @brief Arrays of Maps.
          */
-        FlatMapArray                        map_arrays;
+        FlatMapArray map_arrays;
     };
 
     /**
@@ -465,8 +454,8 @@ namespace VTX
      * @details Maps string keys to PropertyContainer values.
      */
     struct MapContainer {
-        std::vector<std::string> keys;          ///< List of keys.
-        std::vector<PropertyContainer> values;  ///< Corresponding list of values.
+        std::vector<std::string> keys;         ///< List of keys.
+        std::vector<PropertyContainer> values; ///< Corresponding list of values.
     };
 
 
@@ -479,9 +468,10 @@ namespace VTX
      * @brief Represents the data payload for a specific grouping (e.g., a Team or Actor list).
      */
     struct Bucket {
-        std::vector<std::string> unique_ids;      ///< Unique identifiers for the entities in this data block.
+        std::vector<std::string> unique_ids;     ///< Unique identifiers for the entities in this data block.
         std::vector<PropertyContainer> entities; ///< The actual properties for each entity/ID.
-        std::vector<EntityRange> type_ranges; //< Ranges to know were a type starts and ends, assumes entites are ordered by type
+        std::vector<EntityRange>
+            type_ranges; //< Ranges to know were a type starts and ends, assumes entites are ordered by type
 
         std::span<const PropertyContainer> GetEntitiesOfType(int32_t typeId) const {
             if (typeId >= 0 && typeId < type_ranges.size()) {
@@ -503,15 +493,11 @@ namespace VTX
      * @brief Represents a single simulation frame or tick.
      */
     struct Frame {
-        Frame()
-        {
-        }
+        Frame() {}
 
-        Bucket& CreateBucket(const std::string& name)
-        {
+        Bucket& CreateBucket(const std::string& name) {
             auto it = bucket_map.find(name);
-            if (it != bucket_map.end())
-            {
+            if (it != bucket_map.end()) {
                 return buckets[it->second];
             }
 
@@ -520,23 +506,15 @@ namespace VTX
             return buckets.back();
         }
 
-        Bucket& GetBucket(const std::string& name)
-        {
-            return CreateBucket(name);
-        }
+        Bucket& GetBucket(const std::string& name) { return CreateBucket(name); }
 
-        Bucket& GetBucket(int32_t bucket_index)
-        {
-            return buckets.at(bucket_index);
-        }
+        Bucket& GetBucket(int32_t bucket_index) { return buckets.at(bucket_index); }
 
-        const Bucket& GetBucket(const std::string& name) const
-        {
-            static const Bucket Dummy{};
+        const Bucket& GetBucket(const std::string& name) const {
+            static const Bucket Dummy {};
 
             auto it = bucket_map.find(name);
-            if (it != bucket_map.end())
-            {
+            if (it != bucket_map.end()) {
                 return buckets[it->second];
             }
             return Dummy;
@@ -554,9 +532,9 @@ namespace VTX
      * @brief Versioning information for the replay file.
      */
     struct VersionInfo {
-        uint32_t format_major = 1;       ///< Major binary format version.
-        uint32_t format_minor = 2;       ///< Minor binary format version.
-        uint32_t schema_version = 3;     ///< Logic schema version (gameplay data structure).
+        uint32_t format_major = 1;   ///< Major binary format version.
+        uint32_t format_minor = 2;   ///< Minor binary format version.
+        uint32_t schema_version = 3; ///< Logic schema version (gameplay data structure).
     };
 
     /**
@@ -565,12 +543,12 @@ namespace VTX
      * `PropertyContainer` vectors (e.g., int32_tProperties[5]).
      */
     struct PropertySchema {
-        std::unordered_map<std::string, uint32_t> bool_mapping;      ///< Name -> Index for Bool.
-        std::unordered_map<std::string, uint32_t> int_mapping;       ///< Name -> Index for int32_t.
-        std::unordered_map<std::string, uint32_t> int64_mapping;     ///< Name -> Index for int64_t.
-        std::unordered_map<std::string, uint32_t> float_mapping;     ///< Name -> Index for Float.
-        std::unordered_map<std::string, uint32_t> double_mapping;    ///< Name -> Index for Double.
-        std::unordered_map<std::string, uint32_t> string_mapping;    ///< Name -> Index for String.
+        std::unordered_map<std::string, uint32_t> bool_mapping;   ///< Name -> Index for Bool.
+        std::unordered_map<std::string, uint32_t> int_mapping;    ///< Name -> Index for int32_t.
+        std::unordered_map<std::string, uint32_t> int64_mapping;  ///< Name -> Index for int64_t.
+        std::unordered_map<std::string, uint32_t> float_mapping;  ///< Name -> Index for Float.
+        std::unordered_map<std::string, uint32_t> double_mapping; ///< Name -> Index for Double.
+        std::unordered_map<std::string, uint32_t> string_mapping; ///< Name -> Index for String.
 
         std::unordered_map<std::string, uint32_t> vector_mapping;    ///< Name -> Index for Vector.
         std::unordered_map<std::string, uint32_t> quat_mapping;      ///< Name -> Index for Quat.
@@ -578,12 +556,11 @@ namespace VTX
         std::unordered_map<std::string, uint32_t> range_mapping;     ///< Name -> Index for FloatRange.
     };
 
-    struct ContextualSchema
-    {
+    struct ContextualSchema {
         std::string data_identifier;
-        int32_t data_version; // 0
+        int32_t data_version;            // 0
         std::string data_version_string; //data_version 0 = 15.23 prod
-        std::string property_mapping; //This is the full schema in json format
+        std::string property_mapping;    //This is the full schema in json format
     };
 
     /**
@@ -591,11 +568,11 @@ namespace VTX
      * @details Used for UI navigation and scrubbing.
      */
     struct TimelineEvent {
-        float game_time = 0.0f;         ///< Time in seconds when the event occurred.
-        std::string event_type;         ///< type_ category (e.g., "Kill").
-        std::string label;              ///< Display label (e.g., "Player A killed Player B").
-        Vector location;                ///< 3D location of the event.
-        std::string entity_unique_id;   ///< ID of the primary entity involved.
+        float game_time = 0.0f;       ///< Time in seconds when the event occurred.
+        std::string event_type;       ///< type_ category (e.g., "Kill").
+        std::string label;            ///< Display label (e.g., "Player A killed Player B").
+        Vector location;              ///< 3D location of the event.
+        std::string entity_unique_id; ///< ID of the primary entity involved.
     };
 
 
@@ -603,11 +580,11 @@ namespace VTX
      * @brief Header structure located at the beginning of a VTX file.
      */
     struct FileHeader {
-        VersionInfo version;              ///< Versioning info.
-        PropertySchema prop_schema;       ///< Schema for property lookup.
+        VersionInfo version;        ///< Versioning info.
+        PropertySchema prop_schema; ///< Schema for property lookup.
         ContextualSchema contextual_schema;
-        std::string replay_uuid;          ///< Unique ID for the replay session.
-        std::string replay_name;          ///< Display name of the replay.
+        std::string replay_uuid;            ///< Unique ID for the replay session.
+        std::string replay_name;            ///< Display name of the replay.
         int64_t recorded_utc_timestamp = 0; ///< UTC Timestamp of recording start.
 
         std::string custom_json_metadata; ///< Arbitrary JSON string for extra metadata.
@@ -618,10 +595,10 @@ namespace VTX
      * @details Frames are grouped into chunks to allow for compression and partial loading.
      */
     struct Chunk {
-        int32_t chunk_index = 0;          ///< Sequential index of the chunk.
-        bool is_compressed = false;       ///< Flag indicating if `compressed_frames` contains valid data.
+        int32_t chunk_index = 0;    ///< Sequential index of the chunk.
+        bool is_compressed = false; ///< Flag indicating if `compressed_frames` contains valid data.
 
-        std::vector<Frame> frames;        ///< Raw frames (if not compressed / after decompression).
+        std::vector<Frame> frames;              ///< Raw frames (if not compressed / after decompression).
         std::vector<uint8_t> compressed_frames; ///< Compressed binary blob of frames.
     };
 
@@ -629,12 +606,12 @@ namespace VTX
      * @brief Entry in the seek table for random access.
      */
     struct ChunkIndexEntry {
-        int32_t chunk_index = 0;      ///< Index of the chunk.
-        int32_t start_frame = 0;      ///< First frame number in this chunk.
-        int32_t end_frame = 0;        ///< Last frame number in this chunk.
+        int32_t chunk_index = 0; ///< Index of the chunk.
+        int32_t start_frame = 0; ///< First frame number in this chunk.
+        int32_t end_frame = 0;   ///< Last frame number in this chunk.
 
-        uint64_t file_offset = 0;     ///< Byte offset in the file where the chunk begins.
-        uint32_t chunk_size_bytes = 0;///< Size of the chunk in bytes.
+        uint64_t file_offset = 0;      ///< Byte offset in the file where the chunk begins.
+        uint32_t chunk_size_bytes = 0; ///< Size of the chunk in bytes.
     };
 
     /**
@@ -652,24 +629,18 @@ namespace VTX
      * @details Contains the index and summary data needed to navigate the file efficiently.
      */
     struct FileFooter {
-        int32_t total_frames = 0;         ///< Total number of frames in the replay.
-        float duration_seconds = 0.0f;    ///< Total duration in seconds.
+        int32_t total_frames = 0;      ///< Total number of frames in the replay.
+        float duration_seconds = 0.0f; ///< Total duration in seconds.
 
-        ReplayTimeData times;             ///< Detailed time data.
+        ReplayTimeData times;                     ///< Detailed time data.
         std::vector<ChunkIndexEntry> chunk_index; ///< Seek table.
         std::vector<TimelineEvent> events;        ///< List of significant events.
 
-        uint64_t payload_checksum = 0;    ///< Integrity checksum of the payload.
+        uint64_t payload_checksum = 0; ///< Integrity checksum of the payload.
     };
 
-    namespace GameTime
-    {
-        enum class EGameTimeType : uint8_t {
-            None,
-            OnlyGameTime,
-            OnlyCreatedUtc,
-            Both
-        };
+    namespace GameTime {
+        enum class EGameTimeType : uint8_t { None, OnlyGameTime, OnlyCreatedUtc, Both };
 
         enum class EFilterType : uint8_t {
             None,
@@ -677,8 +648,7 @@ namespace VTX
             OnlyDecreasing,
         };
 
-        struct GameTimeRegister
-        {
+        struct GameTimeRegister {
             std::optional<float> game_time = std::nullopt;
             std::optional<int64_t> created_utc_time = std::nullopt;
             EFilterType FrameFilterType = EFilterType::None;
@@ -688,16 +658,9 @@ namespace VTX
         using int32 = std::int32_t;
         constexpr int64 TICKS_PER_SECOND = 10'000'000;
 
-        enum class GameTimeType
-        {
-            None,
-            OnlyGameTime,
-            OnlyCreatedUtc,
-            Both
-        };
+        enum class GameTimeType { None, OnlyGameTime, OnlyCreatedUtc, Both };
 
-        struct VTXGameTimes
-        {
+        struct VTXGameTimes {
             struct StateSnapshot {
                 size_t game_time_size = 0;
                 size_t created_utc_size = 0;
@@ -712,16 +675,14 @@ namespace VTX
             StateSnapshot current_snapshot;
 
             void CreateSnapshot() {
-                current_snapshot = {
-                    game_time_.size(),
-                    created_utc_.size(),
-                    timeline_gaps_.size(),
-                    game_segments_.size(),
-                    offset_,
-                    type_,
-                    add_used_,
-                    resolve_success_
-                };
+                current_snapshot = {game_time_.size(),
+                                    created_utc_.size(),
+                                    timeline_gaps_.size(),
+                                    game_segments_.size(),
+                                    offset_,
+                                    type_,
+                                    add_used_,
+                                    resolve_success_};
             }
 
             void Rollback() {
@@ -744,37 +705,38 @@ namespace VTX
             // Initialising it to system_clock::now() here used to reject any
             // replay whose timestamps predate the writer process.
             VTXGameTimes()
-                : fps_(0), fps_inverse_(0), is_increasing_(true), start_utc_(0), offset_(0),
-                  type_(EGameTimeType::None), add_used_(false), resolve_success_(false), chunk_start_index_(0)
-            {
+                : fps_(0)
+                , fps_inverse_(0)
+                , is_increasing_(true)
+                , start_utc_(0)
+                , offset_(0)
+                , type_(EGameTimeType::None)
+                , add_used_(false)
+                , resolve_success_(false)
+                , chunk_start_index_(0) {
                 SetFPS(30);
             }
 
 
-            static int64 GetUtcNowTicks()
-            {
-
+            static int64 GetUtcNowTicks() {
                 auto now = std::chrono::system_clock::now();
                 auto duration = now.time_since_epoch();
                 return std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() / 100;
             }
 
-            static int64 SecondsToTicks(float Seconds)
-            {
+            static int64 SecondsToTicks(float Seconds) {
                 // Simulates FTimespan::FromSeconds(Seconds).GetTicks()
                 return static_cast<int64>(Seconds * TICKS_PER_SECOND);
             }
 
-            static std::string TicksToString(int64 Ticks)
-            {
+            static std::string TicksToString(int64 Ticks) {
                 // Simulates FTimespan(...).ToString()
                 double seconds = static_cast<double>(Ticks) / TICKS_PER_SECOND;
                 return std::to_string(seconds) + "s";
             }
 
 
-            void CopyFrom(const VTXGameTimes& GameTimes)
-            {
+            void CopyFrom(const VTXGameTimes& GameTimes) {
                 game_time_ = GameTimes.GetLastChunkGameTime();
                 created_utc_ = GameTimes.GetLastChunkCreatedUtc();
                 receive_utc_ = GameTimes.GetLastChunkReceiveUtc();
@@ -784,8 +746,7 @@ namespace VTX
                 game_segments_ = GameTimes.GetLastChunkGameSegments();
             }
 
-            void Clear()
-            {
+            void Clear() {
                 game_time_.clear();
                 created_utc_.clear();
                 receive_utc_.clear();
@@ -793,7 +754,7 @@ namespace VTX
                 sorted_game_time_indexes_.clear();
                 timeline_gaps_.clear();
                 game_segments_.clear();
-                start_utc_ = 0;  // set when the first real frame arrives
+                start_utc_ = 0; // set when the first real frame arrives
                 offset_ = 0;
                 type_ = EGameTimeType::None;
                 SetFPS(30);
@@ -803,35 +764,38 @@ namespace VTX
                 resolve_success_ = false;
             }
 
-            void Setup(const float InFPS, const bool InIsIncreasing, const int64 InStartUtc = 0)
-            {
+            void Setup(const float InFPS, const bool InIsIncreasing, const int64 InStartUtc = 0) {
                 SetFPS(InFPS);
 
                 is_increasing_ = InIsIncreasing;
 
-                if (InStartUtc == 0)
-                {
+                if (InStartUtc == 0) {
                     start_utc_ = GetUtcNowTicks();
-                }
-                else
-                {
+                } else {
                     start_utc_ = InStartUtc;
                 }
             }
 
-            void InsertLiveChunkTimes(const VTXGameTimes& NewChunkGameTime)
-            {
-                game_time_.insert(game_time_.end(), NewChunkGameTime.game_time_.begin(), NewChunkGameTime.game_time_.end());
-                created_utc_.insert(created_utc_.end(), NewChunkGameTime.created_utc_.begin(), NewChunkGameTime.created_utc_.end());
-                receive_utc_.insert(receive_utc_.end(), NewChunkGameTime.receive_utc_.begin(), NewChunkGameTime.receive_utc_.end());
-                game_times_sorted_as_ticks_.insert(game_times_sorted_as_ticks_.end(), NewChunkGameTime.game_times_sorted_as_ticks_.begin(), NewChunkGameTime.game_times_sorted_as_ticks_.end());
-                sorted_game_time_indexes_.insert(sorted_game_time_indexes_.end(), NewChunkGameTime.sorted_game_time_indexes_.begin(), NewChunkGameTime.sorted_game_time_indexes_.end());
-                timeline_gaps_.insert(timeline_gaps_.end(), NewChunkGameTime.timeline_gaps_.begin(), NewChunkGameTime.timeline_gaps_.end());
-                game_segments_.insert(game_segments_.end(), NewChunkGameTime.game_segments_.begin(), NewChunkGameTime.game_segments_.end());
+            void InsertLiveChunkTimes(const VTXGameTimes& NewChunkGameTime) {
+                game_time_.insert(game_time_.end(), NewChunkGameTime.game_time_.begin(),
+                                  NewChunkGameTime.game_time_.end());
+                created_utc_.insert(created_utc_.end(), NewChunkGameTime.created_utc_.begin(),
+                                    NewChunkGameTime.created_utc_.end());
+                receive_utc_.insert(receive_utc_.end(), NewChunkGameTime.receive_utc_.begin(),
+                                    NewChunkGameTime.receive_utc_.end());
+                game_times_sorted_as_ticks_.insert(game_times_sorted_as_ticks_.end(),
+                                                   NewChunkGameTime.game_times_sorted_as_ticks_.begin(),
+                                                   NewChunkGameTime.game_times_sorted_as_ticks_.end());
+                sorted_game_time_indexes_.insert(sorted_game_time_indexes_.end(),
+                                                 NewChunkGameTime.sorted_game_time_indexes_.begin(),
+                                                 NewChunkGameTime.sorted_game_time_indexes_.end());
+                timeline_gaps_.insert(timeline_gaps_.end(), NewChunkGameTime.timeline_gaps_.begin(),
+                                      NewChunkGameTime.timeline_gaps_.end());
+                game_segments_.insert(game_segments_.end(), NewChunkGameTime.game_segments_.begin(),
+                                      NewChunkGameTime.game_segments_.end());
             }
 
-            bool AddTimeRegistry(const GameTimeRegister& time_registry)
-            {
+            bool AddTimeRegistry(const GameTimeRegister& time_registry) {
                 // UTC regression check only makes sense once we already have a
                 // prior frame.  Comparing against start_utc_ (system_clock::now
                 // at construction time) was wrong -- it rejected valid
@@ -840,13 +804,12 @@ namespace VTX
                 // fixes.
                 if (time_registry.created_utc_time.has_value() && !created_utc_.empty() &&
                     *time_registry.created_utc_time <= created_utc_.back()) {
-                    VTX_WARN("CreatedUTC {} (new) is <= {} (last)",
-                             *time_registry.created_utc_time, created_utc_.back());
+                    VTX_WARN("CreatedUTC {} (new) is <= {} (last)", *time_registry.created_utc_time,
+                             created_utc_.back());
                     return false;
                 }
 
-                if (time_registry.game_time.has_value()){
-
+                if (time_registry.game_time.has_value()) {
                     // Monotonicity filters only apply once we already have a
                     // prior frame -- the first frame is always accepted,
                     // otherwise a replay that legitimately starts at t=0 would
@@ -856,13 +819,15 @@ namespace VTX
                     switch (time_registry.FrameFilterType) {
                     case EFilterType::OnlyIncreasing:
                         if (has_prior_game_time && time_registry.game_time <= GetLastGameTimeSeconds()) {
-                            VTX_WARN("OnlyIncreasing filter rejected game_time {} (new) <= {} (last)", *time_registry.game_time, GetLastGameTimeSeconds());
+                            VTX_WARN("OnlyIncreasing filter rejected game_time {} (new) <= {} (last)",
+                                     *time_registry.game_time, GetLastGameTimeSeconds());
                             return false;
                         }
                         break;
                     case EFilterType::OnlyDecreasing:
                         if (has_prior_game_time && time_registry.game_time >= GetLastGameTimeSeconds()) {
-                            VTX_WARN("OnlyDecreasing filter rejected game_time {} (new) >= {} (last)", *time_registry.game_time, GetLastGameTimeSeconds());
+                            VTX_WARN("OnlyDecreasing filter rejected game_time {} (new) >= {} (last)",
+                                     *time_registry.game_time, GetLastGameTimeSeconds());
                             return false;
                         }
                         break;
@@ -874,20 +839,16 @@ namespace VTX
 
                 if (time_registry.game_time.has_value() && time_registry.created_utc_time.has_value()) {
                     return AddBoth(*time_registry.game_time, *time_registry.created_utc_time);
-                }
-                else if (time_registry.created_utc_time.has_value()) {
+                } else if (time_registry.created_utc_time.has_value()) {
                     return AddCreatedUtc(*time_registry.created_utc_time);
-                }
-                else if (time_registry.game_time.has_value()) {
+                } else if (time_registry.game_time.has_value()) {
                     return AddGameTime(*time_registry.game_time);
                 }
                 return true;
             }
 
-            bool AddAll(const float InGameTime, const int64 InCreatedUtc, const int64 InReceiveUtc)
-            {
-                if (add_used_)
-                {
+            bool AddAll(const float InGameTime, const int64 InCreatedUtc, const int64 InReceiveUtc) {
+                if (add_used_) {
                     VTX_ERROR("Another Add method has already been used for this frame!");
                     return false;
                 }
@@ -901,10 +862,8 @@ namespace VTX
                 return true;
             }
 
-            bool AddBoth(const float InGameTime, const int64 InCreatedUtc)
-            {
-                if (add_used_)
-                {
+            bool AddBoth(const float InGameTime, const int64 InCreatedUtc) {
+                if (add_used_) {
                     VTX_ERROR("Another Add method has already been used for this frame!");
                     return false;
                 }
@@ -917,10 +876,8 @@ namespace VTX
                 return true;
             }
 
-            bool AddGameTime(const float InGameTime)
-            {
-                if (add_used_)
-                {
+            bool AddGameTime(const float InGameTime) {
+                if (add_used_) {
                     VTX_ERROR("Another Add method has already been used for this frame!");
                     return false;
                 }
@@ -932,10 +889,8 @@ namespace VTX
                 return true;
             }
 
-            bool AddCreatedUtc(const int64 InCreatedUtc)
-            {
-                if (add_used_)
-                {
+            bool AddCreatedUtc(const int64 InCreatedUtc) {
+                if (add_used_) {
                     VTX_ERROR("Another Add method has already been used for this frame!");
                     return false;
                 }
@@ -947,126 +902,106 @@ namespace VTX
                 return true;
             }
 
-            bool ResolveGameTimes(const int32 FrameAmountSoFar)
-            {
+            bool ResolveGameTimes(const int32 FrameAmountSoFar) {
                 add_used_ = false;
                 resolve_success_ = Resolve(FrameAmountSoFar);
                 return resolve_success_;
             }
 
-            void ManuallyMarkGameSegmentStart(const int32 FrameNumber)
-            {
-                game_segments_.push_back(FrameNumber);
-            }
+            void ManuallyMarkGameSegmentStart(const int32 FrameNumber) { game_segments_.push_back(FrameNumber); }
 
-            void ManuallyMarkGameSegmentStart()
-            {
-                game_segments_.push_back(GetFrameNumber());
-            }
+            void ManuallyMarkGameSegmentStart() { game_segments_.push_back(GetFrameNumber()); }
 
-            bool IsEmpty() const
-            {
-                return game_time_.empty() && created_utc_.empty() && receive_utc_.empty();
-            }
+            bool IsEmpty() const { return game_time_.empty() && created_utc_.empty() && receive_utc_.empty(); }
 
-            int64 LastGameTime() const
-            {
-                if (!game_time_.empty())
-                {
+            int64 LastGameTime() const {
+                if (!game_time_.empty()) {
                     return game_time_.back();
                 }
                 return 0;
             }
 
-            double GetLastGameTimeSeconds() const
-            {
+            double GetLastGameTimeSeconds() const {
                 const int64 Time = LastGameTime();
                 return static_cast<double>(Time) / static_cast<double>(TICKS_PER_SECOND);
             }
 
-            int64 FirstGameTime() const
-            {
-                if (!game_time_.empty())
-                {
+            int64 FirstGameTime() const {
+                if (!game_time_.empty()) {
                     return game_time_.front();
                 }
                 return 0;
             }
 
-            double FirstGameTimeSeconds() const
-            {
+            double FirstGameTimeSeconds() const {
                 const int64 Time = FirstGameTime();
                 return static_cast<double>(Time) / static_cast<double>(TICKS_PER_SECOND);
             }
 
-            int64 LastCreatedUtc() const
-            {
-                if (!created_utc_.empty())
-                {
+            int64 LastCreatedUtc() const {
+                if (!created_utc_.empty()) {
                     return created_utc_.back();
                 }
                 return start_utc_;
             }
 
-            int64 StartUtc() const
-            {
-                return start_utc_;
-            }
+            int64 StartUtc() const { return start_utc_; }
 
-            int64 FirstCreatedUtc() const
-            {
-                if (!created_utc_.empty())
-                {
+            int64 FirstCreatedUtc() const {
+                if (!created_utc_.empty()) {
                     return created_utc_.front();
                 }
                 return start_utc_;
             }
 
-            float GetDuration() const
-            {
+            float GetDuration() const {
                 return static_cast<float>(LastCreatedUtc() - FirstCreatedUtc()) / static_cast<double>(TICKS_PER_SECOND);
             }
 
-            void DebugPrintGameTimes()
-            {
-                for (size_t i = 0; i < game_time_.size(); ++i)
-                {
-                    VTX_DEBUG("Frame {}: game_time_ = {}, CreatedUTC = {}", i, TicksToString(game_time_[i]), TicksToString(created_utc_[i]));
+            void DebugPrintGameTimes() {
+                for (size_t i = 0; i < game_time_.size(); ++i) {
+                    VTX_DEBUG("Frame {}: game_time_ = {}, CreatedUTC = {}", i, TicksToString(game_time_[i]),
+                              TicksToString(created_utc_[i]));
                 }
             }
 
-            void UpdateChunkStartIndex()
-            {
-                chunk_start_index_ = GetFrameNumber();
-            }
+            void UpdateChunkStartIndex() { chunk_start_index_ = GetFrameNumber(); }
 
             // Getters
-            const std::vector<int64>& GetGameTime() const { return game_time_;}
-            const std::vector<int64>& GetCreatedUtc() const { return created_utc_;}
-            const std::vector<int64>& GetReceiveUtc() const { return receive_utc_;}
-            const std::vector<int32>& GetSortedGameTimeIndexes() const { return sorted_game_time_indexes_;}
-            const std::vector<int64>& GetGameTimesSortedAsTicks() const { return game_times_sorted_as_ticks_;}
-            const std::vector<int32>& GetTimelineGaps() const { return timeline_gaps_;}
-            const std::vector<int32>& GetGameSegments() const { return game_segments_;}
+            const std::vector<int64>& GetGameTime() const { return game_time_; }
+            const std::vector<int64>& GetCreatedUtc() const { return created_utc_; }
+            const std::vector<int64>& GetReceiveUtc() const { return receive_utc_; }
+            const std::vector<int32>& GetSortedGameTimeIndexes() const { return sorted_game_time_indexes_; }
+            const std::vector<int64>& GetGameTimesSortedAsTicks() const { return game_times_sorted_as_ticks_; }
+            const std::vector<int32>& GetTimelineGaps() const { return timeline_gaps_; }
+            const std::vector<int32>& GetGameSegments() const { return game_segments_; }
 
             // Chunk Getters
             std::vector<int64> GetLastChunkGameTime() const { return GetLastChunk(game_time_); }
             std::vector<int64> GetLastChunkCreatedUtc() const { return GetLastChunk(created_utc_); }
             std::vector<int64> GetLastChunkReceiveUtc() const { return GetLastChunk(receive_utc_); }
-            std::vector<int32> GetLastChunkSortedGameTimeIndexes() const { return GetLastChunk(sorted_game_time_indexes_); }
-            std::vector<int64> GetLastChunkGameTimesSortedAsTicks() const { return GetLastChunk(game_times_sorted_as_ticks_); }
+            std::vector<int32> GetLastChunkSortedGameTimeIndexes() const {
+                return GetLastChunk(sorted_game_time_indexes_);
+            }
+            std::vector<int64> GetLastChunkGameTimesSortedAsTicks() const {
+                return GetLastChunk(game_times_sorted_as_ticks_);
+            }
             std::vector<int32> GetLastChunkTimelineGaps() const { return GetLastChunkPartial(timeline_gaps_); }
             std::vector<int32> GetLastChunkGameSegments() const { return GetLastChunkPartial(game_segments_); }
 
             void SetGameTime(std::vector<int64_t> times) { game_time_ = std::move(times); }
             void SetCreatedUtc(std::vector<int64_t> utc) { created_utc_ = std::move(utc); }
             void SetReceiveUtc(std::vector<int64_t> utc) { receive_utc_ = std::move(utc); }
-            void SetGameTimesSortedAsTicks(std::vector<int64_t> ticks) { game_times_sorted_as_ticks_ = std::move(ticks); }
-            void SetSortedGameTimeIndexes(std::vector<int32_t> indexes) { sorted_game_time_indexes_ = std::move(indexes); }
+            void SetGameTimesSortedAsTicks(std::vector<int64_t> ticks) {
+                game_times_sorted_as_ticks_ = std::move(ticks);
+            }
+            void SetSortedGameTimeIndexes(std::vector<int32_t> indexes) {
+                sorted_game_time_indexes_ = std::move(indexes);
+            }
             void SetTimelineGaps(std::vector<int32_t> gaps) { timeline_gaps_ = std::move(gaps); }
             void SetGameSegments(std::vector<int32_t> segments) { game_segments_ = std::move(segments); }
-        private:
 
+        private:
             std::vector<int64> game_time_;
             std::vector<int64> created_utc_;
             std::vector<int64> receive_utc_;
@@ -1085,21 +1020,17 @@ namespace VTX
             bool resolve_success_;
             int32 chunk_start_index_;
 
-            void SetFPS(const float InFPS)
-            {
+            void SetFPS(const float InFPS) {
                 fps_ = InFPS;
                 fps_inverse_ = static_cast<int64>((1.0f / fps_) * TICKS_PER_SECOND);
             }
 
-            int32 GetFrameNumber() const
-            {
+            int32 GetFrameNumber() const {
                 return static_cast<int32>(std::max({game_time_.size(), created_utc_.size(), receive_utc_.size()}));
             }
 
-            bool Resolve(const int32 FrameAmountSoFar)
-            {
-                if(FrameAmountSoFar <= 0)
-                {
+            bool Resolve(const int32 FrameAmountSoFar) {
+                if (FrameAmountSoFar <= 0) {
                     VTX_ERROR("Quitting because there are 0 frames while trying to resolve GameTimes!");
                     return false;
                 }
@@ -1116,13 +1047,12 @@ namespace VTX
                     break;
                 case EGameTimeType::Both:
                     // Dont do anything.
-                        break;
+                    break;
                 }
 
-                if (game_time_.size() == created_utc_.size() && game_time_.size() == static_cast<size_t>(FrameAmountSoFar))
-                {
-                    if (!game_time_.empty())
-                    {
+                if (game_time_.size() == created_utc_.size() &&
+                    game_time_.size() == static_cast<size_t>(FrameAmountSoFar)) {
+                    if (!game_time_.empty()) {
                         SortGameTime();
                         DetectGap();
                         DetectGameSegment();
@@ -1133,52 +1063,36 @@ namespace VTX
                 return false;
             }
 
-            void FakeBothTimesFromFPS()
-            {
-                if (created_utc_.empty())
-                {
+            void FakeBothTimesFromFPS() {
+                if (created_utc_.empty()) {
                     created_utc_.push_back(start_utc_);
                     game_time_.push_back(0);
-                }
-                else
-                {
+                } else {
                     game_time_.push_back(game_time_.back() + fps_inverse_);
                     created_utc_.push_back(created_utc_.back() + fps_inverse_);
                 }
             }
 
-            void FakeGameTimeFromUtc()
-            {
-                game_time_.push_back(created_utc_.back() - created_utc_[0]);
-            }
+            void FakeGameTimeFromUtc() { game_time_.push_back(created_utc_.back() - created_utc_[0]); }
 
-            void FakeUtcFromGameTime()
-            {
+            void FakeUtcFromGameTime() {
                 int64 FakedUtc;
                 const int64 RawTicks = start_utc_ + game_time_.back();
 
-                if (created_utc_.empty())
-                {
+                if (created_utc_.empty()) {
                     FakedUtc = RawTicks;
-                }
-                else
-                {
+                } else {
                     const int64 LastFakeUtc = created_utc_.back();
                     FakedUtc = RawTicks + offset_;
 
-                    if (is_increasing_)
-                    {
-                        if (FakedUtc <= LastFakeUtc)
-                        {
+                    if (is_increasing_) {
+                        if (FakedUtc <= LastFakeUtc) {
                             const int64 Bump = LastFakeUtc + fps_inverse_ - FakedUtc;
                             offset_ += Bump;
                             FakedUtc = RawTicks + offset_;
                         }
-                    }
-                    else
-                    {
-                        if (FakedUtc >= LastFakeUtc)
-                        {
+                    } else {
+                        if (FakedUtc >= LastFakeUtc) {
                             const int64 Bump = LastFakeUtc - fps_inverse_ - FakedUtc;
                             offset_ += Bump;
                             FakedUtc = RawTicks + offset_;
@@ -1189,82 +1103,75 @@ namespace VTX
                 created_utc_.push_back(FakedUtc);
             }
 
-            void SortGameTime()
-            {
+            void SortGameTime() {
                 const int32 NewIdx = static_cast<int32>(game_time_.size()) - 1;
                 const int64 NewTime = game_time_.back();
 
-                auto it = std::lower_bound(game_times_sorted_as_ticks_.begin(), game_times_sorted_as_ticks_.end(), NewTime);
+                auto it =
+                    std::lower_bound(game_times_sorted_as_ticks_.begin(), game_times_sorted_as_ticks_.end(), NewTime);
                 auto insertPos = std::distance(game_times_sorted_as_ticks_.begin(), it);
 
                 sorted_game_time_indexes_.insert(sorted_game_time_indexes_.begin() + insertPos, NewIdx);
                 game_times_sorted_as_ticks_.insert(it, NewTime);
             }
 
-            void DetectGap()
-            {
-                if (fps_ > 0 && created_utc_.size() > 1)
-                {
+            void DetectGap() {
+                if (fps_ > 0 && created_utc_.size() > 1) {
                     const int64 Threshold = 3 * fps_inverse_;
 
                     int64 last = created_utc_.back();
                     int64 prev = created_utc_[created_utc_.size() - 2];
 
-                    if ((last - prev) > Threshold)
-                    {
+                    if ((last - prev) > Threshold) {
                         timeline_gaps_.push_back(GetFrameNumber());
                     }
                 }
             }
 
-            void DetectGameSegment()
-            {
+            void DetectGameSegment() {
                 int32 currentFrame = GetFrameNumber();
                 bool bContains = false;
-                for(int32 val : game_segments_) { if(val == currentFrame) { bContains = true; break; } }
+                for (int32 val : game_segments_) {
+                    if (val == currentFrame) {
+                        bContains = true;
+                        break;
+                    }
+                }
 
-                if (bContains)
-                {
+                if (bContains) {
                     return;
                 }
 
-                if(game_time_.size() > 1)
-                {
+                if (game_time_.size() > 1) {
                     const int64 Delta = game_time_.back() - game_time_[game_time_.size() - 2];
-                    if ((is_increasing_ && Delta < 0) || (!is_increasing_ && Delta > 0))
-                    {
+                    if ((is_increasing_ && Delta < 0) || (!is_increasing_ && Delta > 0)) {
                         game_segments_.push_back(GetFrameNumber());
                     }
                 }
             }
 
-            std::vector<int32> GetLastChunkPartial(const std::vector<int32>& InArray) const
-            {
+            std::vector<int32> GetLastChunkPartial(const std::vector<int32>& InArray) const {
                 std::vector<int32> Result;
-                for (const int32 Elem : InArray)
-                {
-                    if (Elem > chunk_start_index_)
-                    {
+                for (const int32 Elem : InArray) {
+                    if (Elem > chunk_start_index_) {
                         Result.push_back(Elem);
                     }
                 }
                 return Result;
             }
 
-            template<typename T>
-            std::vector<T> GetLastChunk(const std::vector<T>& InArray) const
-            {
+            template <typename T>
+            std::vector<T> GetLastChunk(const std::vector<T>& InArray) const {
                 const int32 Count = static_cast<int32>(InArray.size()) - chunk_start_index_;
                 std::vector<T> Result;
-                if (Count > 0)
-                {
+                if (Count > 0) {
                     Result.reserve(Count);
                     Result.insert(Result.end(), InArray.begin() + chunk_start_index_, InArray.end());
                 }
                 return Result;
             }
         };
-    }
+    } // namespace GameTime
 
     struct SessionConfig {
         std::string replay_name;
@@ -1274,9 +1181,9 @@ namespace VTX
     };
 
     struct SessionFooter {
-        SessionFooter() : total_frames(0), duration_seconds(0)
-        {
-        }
+        SessionFooter()
+            : total_frames(0)
+            , duration_seconds(0) {}
 
         int32_t total_frames;
         double duration_seconds;
@@ -1288,9 +1195,12 @@ namespace VTX
     };
 
     struct ChunkIndexData {
-        ChunkIndexData() : chunk_index(0), file_offset(0), chunk_size_bytes(0), start_frame(0), end_frame(0)
-        {
-        }
+        ChunkIndexData()
+            : chunk_index(0)
+            , file_offset(0)
+            , chunk_size_bytes(0)
+            , start_frame(0)
+            , end_frame(0) {}
 
         int32_t chunk_index;
         int64_t file_offset;
@@ -1298,4 +1208,4 @@ namespace VTX
         int32_t start_frame;
         int32_t end_frame;
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/common/vtx_types_helpers.h b/sdk/include/vtx/common/vtx_types_helpers.h
index c3cc0e8..ee90450 100644
--- a/sdk/include/vtx/common/vtx_types_helpers.h
+++ b/sdk/include/vtx/common/vtx_types_helpers.h
@@ -26,91 +26,104 @@ namespace VTX {
           * @param schema The schema definition for the structure to be held.
          */
         inline void PreparePropertyContainer(PropertyContainer& container, const SchemaStruct& schema) {
-            
             auto GetNeeded = [&](FieldType type) -> int32_t {
                 size_t typeIdx = static_cast<size_t>(type);
                 return (typeIdx < schema.type_max_indices.size()) ? schema.type_max_indices[typeIdx] : 0;
             };
-            
-            if (int32_t n = GetNeeded(FieldType::Bool))          container.bool_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::Int32))         container.int32_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::Int64))         container.int64_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::Float))         container.float_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::Double))        container.double_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::String))        container.string_properties.resize(n);
-            
-            if (int32_t n = GetNeeded(FieldType::Vector))        container.vector_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::Quat))          container.quat_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::Transform))     container.transform_properties.resize(n);
-            if (int32_t n = GetNeeded(FieldType::FloatRange))    container.range_properties.resize(n);
-
-            if (int32_t n = GetNeeded(FieldType::Struct)) container.any_struct_properties.resize(n);
+
+            if (int32_t n = GetNeeded(FieldType::Bool))
+                container.bool_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::Int32))
+                container.int32_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::Int64))
+                container.int64_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::Float))
+                container.float_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::Double))
+                container.double_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::String))
+                container.string_properties.resize(n);
+
+            if (int32_t n = GetNeeded(FieldType::Vector))
+                container.vector_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::Quat))
+                container.quat_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::Transform))
+                container.transform_properties.resize(n);
+            if (int32_t n = GetNeeded(FieldType::FloatRange))
+                container.range_properties.resize(n);
+
+            if (int32_t n = GetNeeded(FieldType::Struct))
+                container.any_struct_properties.resize(n);
         }
-        
-        inline uint64_t CalculateContainerHash(const PropertyContainer& container)
-        {
+
+        inline uint64_t CalculateContainerHash(const PropertyContainer& container) {
             thread_local XXH_INLINE_XXH3_state_t* state = XXH3_createState();
             XXH3_64bits_reset(state);
-            
-            auto hash_update = [&](const void*data, size_t size)
-            {
-                if (size > 0 && data != nullptr )
-                {
+
+            auto hash_update = [&](const void* data, size_t size) {
+                if (size > 0 && data != nullptr) {
                     XXH3_64bits_update(state, data, size);
                 }
-                
             };
-            
-            hash_update(&container.entity_type_id,sizeof(container.entity_type_id));
-            
+
+            hash_update(&container.entity_type_id, sizeof(container.entity_type_id));
+
             //special case, std::vector<bool> does not have .data(), fast loop instead
             for (const bool& b : container.bool_properties) {
                 uint8_t val = b ? 1 : 0;
                 hash_update(&val, sizeof(val));
             }
-                        
+
             hash_update(container.int32_properties.data(), container.int32_properties.size() * sizeof(int32_t));
             hash_update(container.int64_properties.data(), container.int64_properties.size() * sizeof(int64_t));
             hash_update(container.float_properties.data(), container.float_properties.size() * sizeof(float));
             hash_update(container.double_properties.data(), container.double_properties.size() * sizeof(double));
-            
+
             for (const auto& str : container.string_properties) {
                 hash_update(str.data(), str.size());
             }
-            
-            hash_update(container.transform_properties.data(), container.transform_properties.size() * sizeof(Transform));
+
+            hash_update(container.transform_properties.data(),
+                        container.transform_properties.size() * sizeof(Transform));
             hash_update(container.vector_properties.data(), container.vector_properties.size() * sizeof(Vector));
             hash_update(container.quat_properties.data(), container.quat_properties.size() * sizeof(Quat));
             hash_update(container.range_properties.data(), container.range_properties.size() * sizeof(FloatRange));
-            
-            
+
+
             //arrays
-            
+
             if (!container.byte_array_properties.data.empty()) {
-                hash_update(container.byte_array_properties.data.data(), container.byte_array_properties.data.size() * sizeof(uint8_t));
-                hash_update(container.byte_array_properties.offsets.data(), container.byte_array_properties.offsets.size() * sizeof(uint32_t));
+                hash_update(container.byte_array_properties.data.data(),
+                            container.byte_array_properties.data.size() * sizeof(uint8_t));
+                hash_update(container.byte_array_properties.offsets.data(),
+                            container.byte_array_properties.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.int32_arrays.data.empty()) {
                 hash_update(container.int32_arrays.data.data(), container.int32_arrays.data.size() * sizeof(int32_t));
-                hash_update(container.int32_arrays.offsets.data(), container.int32_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.int32_arrays.offsets.data(),
+                            container.int32_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.int64_arrays.data.empty()) {
                 hash_update(container.int64_arrays.data.data(), container.int64_arrays.data.size() * sizeof(int64_t));
-                hash_update(container.int64_arrays.offsets.data(), container.int64_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.int64_arrays.offsets.data(),
+                            container.int64_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.float_arrays.data.empty()) {
                 hash_update(container.float_arrays.data.data(), container.float_arrays.data.size() * sizeof(float));
-                hash_update(container.float_arrays.offsets.data(), container.float_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.float_arrays.offsets.data(),
+                            container.float_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.double_arrays.data.empty()) {
                 hash_update(container.double_arrays.data.data(), container.double_arrays.data.size() * sizeof(double));
-                hash_update(container.double_arrays.offsets.data(), container.double_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.double_arrays.offsets.data(),
+                            container.double_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             // Nested structs (scalar)
             for (const auto& sc : container.any_struct_properties) {
                 uint64_t sub = CalculateContainerHash(sc);
@@ -123,7 +136,8 @@ namespace VTX {
                     uint64_t sub = CalculateContainerHash(sc);
                     hash_update(&sub, sizeof(sub));
                 }
-                hash_update(container.any_struct_arrays.offsets.data(), container.any_struct_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.any_struct_arrays.offsets.data(),
+                            container.any_struct_arrays.offsets.size() * sizeof(uint32_t));
             }
 
             // Maps (scalar)
@@ -148,45 +162,55 @@ namespace VTX {
                         hash_update(&sub, sizeof(sub));
                     }
                 }
-                hash_update(container.map_arrays.offsets.data(), container.map_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.map_arrays.offsets.data(),
+                            container.map_arrays.offsets.size() * sizeof(uint32_t));
             }
 
             if (!container.vector_arrays.data.empty()) {
-                hash_update(container.vector_arrays.data.data(), container.vector_arrays.data.size() * sizeof(VTX::Vector));
-                hash_update(container.vector_arrays.offsets.data(), container.vector_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.vector_arrays.data.data(),
+                            container.vector_arrays.data.size() * sizeof(VTX::Vector));
+                hash_update(container.vector_arrays.offsets.data(),
+                            container.vector_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.quat_arrays.data.empty()) {
                 hash_update(container.quat_arrays.data.data(), container.quat_arrays.data.size() * sizeof(VTX::Quat));
-                hash_update(container.quat_arrays.offsets.data(), container.quat_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.quat_arrays.offsets.data(),
+                            container.quat_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.transform_arrays.data.empty()) {
-                hash_update(container.transform_arrays.data.data(), container.transform_arrays.data.size() * sizeof(VTX::Transform));
-                hash_update(container.transform_arrays.offsets.data(), container.transform_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.transform_arrays.data.data(),
+                            container.transform_arrays.data.size() * sizeof(VTX::Transform));
+                hash_update(container.transform_arrays.offsets.data(),
+                            container.transform_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.range_arrays.data.empty()) {
-                hash_update(container.range_arrays.data.data(), container.range_arrays.data.size() * sizeof(VTX::FloatRange));
-                hash_update(container.range_arrays.offsets.data(), container.range_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.range_arrays.data.data(),
+                            container.range_arrays.data.size() * sizeof(VTX::FloatRange));
+                hash_update(container.range_arrays.offsets.data(),
+                            container.range_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.bool_arrays.data.empty()) {
                 hash_update(container.bool_arrays.data.data(), container.bool_arrays.data.size() * sizeof(uint8_t));
-                hash_update(container.bool_arrays.offsets.data(), container.bool_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.bool_arrays.offsets.data(),
+                            container.bool_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
+
             if (!container.string_arrays.data.empty()) {
                 for (const auto& str : container.string_arrays.data) {
                     hash_update(str.data(), str.size());
                 }
-                hash_update(container.string_arrays.offsets.data(), container.string_arrays.offsets.size() * sizeof(uint32_t));
+                hash_update(container.string_arrays.offsets.data(),
+                            container.string_arrays.offsets.size() * sizeof(uint32_t));
             }
-            
-            
+
+
             return XXH3_64bits_digest(state);
         }
-    }
+    } // namespace Helpers
 
     namespace TimeUtils {
         constexpr int64 TICKS_PER_SECOND = 10'000'000;
@@ -195,17 +219,15 @@ namespace VTX {
         // (Days between 0001 and 1970) * SecondsPerDay * TicksPerSecond
         constexpr int64 TICKS_AT_UNIX_EPOCH = 621'355'968'000'000'000;
 
-        enum class TimeFormat
-        {
-            UeUTC,      // Ticks  (since 0001)
-            UnixUTC,    // Secs since 1970
-            UnixMsUTC,  // Ms since 1970
-            ISO8601,    // String date
+        enum class TimeFormat {
+            UeUTC,     // Ticks  (since 0001)
+            UnixUTC,   // Secs since 1970
+            UnixMsUTC, // Ms since 1970
+            ISO8601,   // String date
             Seconds
         };
-        
-        inline int64 ConvertToUeTicks(TimeFormat in_time_format, int64 value)
-        {
+
+        inline int64 ConvertToUeTicks(TimeFormat in_time_format, int64 value) {
             switch (in_time_format) {
             case TimeFormat::UeUTC:
                 return value;
@@ -216,36 +238,36 @@ namespace VTX {
             case TimeFormat::ISO8601:
             case TimeFormat::Seconds:
                 return 0;
-            default: ;
+            default:;
             }
             return 0;
         }
 
-        inline int64 ConvertToUeTicks(TimeFormat in_time_format,float seconds)
-        {
-            if (in_time_format != TimeFormat::Seconds)
-            {
+        inline int64 ConvertToUeTicks(TimeFormat in_time_format, float seconds) {
+            if (in_time_format != TimeFormat::Seconds) {
                 return 0;
             }
-            
+
             return seconds * TICKS_PER_SECOND;
         }
-        
-        inline int64 ConvertToUeTicks(TimeFormat in_time_format, const std::string& ISO8601UTC)
-        {
-            if (in_time_format != TimeFormat::ISO8601) return 0;
-            if (ISO8601UTC.empty()) return 0;
+
+        inline int64 ConvertToUeTicks(TimeFormat in_time_format, const std::string& ISO8601UTC) {
+            if (in_time_format != TimeFormat::ISO8601)
+                return 0;
+            if (ISO8601UTC.empty())
+                return 0;
 
             std::tm tm = {};
             std::istringstream ss(ISO8601UTC);
             ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
-            if (ss.fail()) return 0;
-            
-            
-            auto time_point = std::chrono::sys_days{std::chrono::year(tm.tm_year + 1900) / (tm.tm_mon + 1) / tm.tm_mday};
-            auto tp_seconds = std::chrono::time_point_cast<std::chrono::seconds>(time_point) + 
-                              std::chrono::hours(tm.tm_hour) + 
-                              std::chrono::minutes(tm.tm_min) + 
+            if (ss.fail())
+                return 0;
+
+
+            auto time_point =
+                std::chrono::sys_days {std::chrono::year(tm.tm_year + 1900) / (tm.tm_mon + 1) / tm.tm_mday};
+            auto tp_seconds = std::chrono::time_point_cast<std::chrono::seconds>(time_point) +
+                              std::chrono::hours(tm.tm_hour) + std::chrono::minutes(tm.tm_min) +
                               std::chrono::seconds(tm.tm_sec);
 
             int64 unix_seconds = tp_seconds.time_since_epoch().count();
@@ -262,53 +284,50 @@ namespace VTX {
             int32_t milliseconds = 0;
         };
 
-        inline Duration TicksToDuration(int64 ticks)
-        {
+        inline Duration TicksToDuration(int64 ticks) {
             const int64 total_ms = (ticks + (TICKS_PER_MILLISECOND / 2)) / TICKS_PER_MILLISECOND;
             Duration d;
-            d.hours        = static_cast<int32_t>(total_ms / 3'600'000);
-            d.minutes      = static_cast<int32_t>((total_ms % 3'600'000) / 60'000);
-            d.seconds      = static_cast<int32_t>((total_ms % 60'000) / 1'000);
+            d.hours = static_cast<int32_t>(total_ms / 3'600'000);
+            d.minutes = static_cast<int32_t>((total_ms % 3'600'000) / 60'000);
+            d.seconds = static_cast<int32_t>((total_ms % 60'000) / 1'000);
             d.milliseconds = static_cast<int32_t>(total_ms % 1'000);
             return d;
         }
 
-        inline std::string FormatDuration(int64 ticks)
-        {
+        inline std::string FormatDuration(int64 ticks) {
             auto d = TicksToDuration(ticks);
             std::ostringstream s;
-            if (d.hours > 0)                   s << d.hours << "h ";
-            if (d.minutes > 0 || d.hours > 0)  s << d.minutes << "m ";
+            if (d.hours > 0)
+                s << d.hours << "h ";
+            if (d.minutes > 0 || d.hours > 0)
+                s << d.minutes << "m ";
             s << d.seconds << "s " << d.milliseconds << "ms";
             return s.str();
         }
 
-        inline double TicksToSeconds(int64 ticks)
-        {
+        inline double TicksToSeconds(int64 ticks) {
             return static_cast<double>(ticks) / static_cast<double>(TICKS_PER_SECOND);
         }
 
-        inline std::string FormatUtcTicks(int64 ticks)
-        {
+        inline std::string FormatUtcTicks(int64 ticks) {
             // Normalize: if ticks are in UE epoch (since 0001), convert to unix-relative
-            const int64 unix_ticks = (ticks >= TICKS_AT_UNIX_EPOCH)
-                ? ticks - TICKS_AT_UNIX_EPOCH
-                : ticks;
+            const int64 unix_ticks = (ticks >= TICKS_AT_UNIX_EPOCH) ? ticks - TICKS_AT_UNIX_EPOCH : ticks;
             const int64 unix_seconds = unix_ticks / TICKS_PER_SECOND;
             const int32_t ms = static_cast<int32_t>((unix_ticks % TICKS_PER_SECOND) / TICKS_PER_MILLISECOND);
 
             const std::time_t time_val = static_cast<std::time_t>(unix_seconds);
-            std::tm utc_time{};
+            std::tm utc_time {};
 #if defined(_WIN32)
-            if (gmtime_s(&utc_time, &time_val) != 0) return "Invalid UTC";
+            if (gmtime_s(&utc_time, &time_val) != 0)
+                return "Invalid UTC";
 #else
-            if (gmtime_r(&time_val, &utc_time) == nullptr) return "Invalid UTC";
+            if (gmtime_r(&time_val, &utc_time) == nullptr)
+                return "Invalid UTC";
 #endif
             std::ostringstream s;
-            s << std::put_time(&utc_time, "%d %b %Y %H:%M:%S")
-              << "." << std::setw(3) << std::setfill('0') << (ms >= 0 ? ms : ms + 1000)
-              << " UTC";
+            s << std::put_time(&utc_time, "%d %b %Y %H:%M:%S") << "." << std::setw(3) << std::setfill('0')
+              << (ms >= 0 ? ms : ms + 1000) << " UTC";
             return s.str();
         }
-    }
-}
\ No newline at end of file
+    } // namespace TimeUtils
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.h b/sdk/include/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.h
index ed32117..d7099cf 100644
--- a/sdk/include/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.h
+++ b/sdk/include/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.h
@@ -18,11 +18,11 @@ namespace VtxDiff::Flatbuffers {
     struct CachedField {
         const reflection::Field* FbField = nullptr;
         EVTXContainerType VtxType = EVTXContainerType::Unknown;
-        
+
         reflection::BaseType BaseType = reflection::None;
         reflection::BaseType ElementType = reflection::None;
         size_t ByteSize = 0;
-        size_t ElementByteSize = 0; 
+        size_t ElementByteSize = 0;
 
         const reflection::Object* NestedObj = nullptr;
         const reflection::Field* SoaDataField = nullptr;
@@ -37,7 +37,7 @@ namespace VtxDiff::Flatbuffers {
         std::vector<FieldDesc> EnumerableFields;
         std::unordered_map<std::string_view, CachedField> FieldsByName;
     };
-        
+
     class FbSchemaCache {
     public:
         void Build(const reflection::Schema* Schema);
@@ -45,26 +45,28 @@ namespace VtxDiff::Flatbuffers {
         const std::vector<FieldDesc>& GetEnumerableFields(const reflection::Object* Obj) const;
 
         const reflection::Schema* RawSchema = nullptr;
+
     private:
         std::unordered_map<const reflection::Object*, CachedObject> ObjectCache;
     };
-        
+
     class FlatbufferViewAdapter {
     public:
         FlatbufferViewAdapter() = default;
-        FlatbufferViewAdapter(const FbSchemaCache* Cache, const reflection::Object* Object, const flatbuffers::Table* TablePtr);
-        
+        FlatbufferViewAdapter(const FbSchemaCache* Cache, const reflection::Object* Object,
+                              const flatbuffers::Table* TablePtr);
+
         void Clear() {}
         void Reset();
         bool IsValid() const;
-        
+
         std::span<const FieldDesc> EnumerateFields() const;
         std::span<const std::byte> GetFieldBytes(const FieldDesc& Fd) const;
-     
+
         size_t GetArraySize(const FieldDesc& Fd) const;
         std::span<const std::byte> GetArrayElementBytes(const FieldDesc& Fd, size_t Index) const;
         std::span<const std::byte> GetSubArrayBytes(const FieldDesc& Fd, size_t SubIndex) const;
-     
+
         size_t GetMapSize(const FieldDesc& Fd) const;
         std::string GetMapKey(const FieldDesc& Fd, size_t I) const;
         std::string GetScalarFieldString(const std::string& FieldName) const;
@@ -75,24 +77,25 @@ namespace VtxDiff::Flatbuffers {
         FlatbufferViewAdapter GetMapValueAsStruct(const FieldDesc& Fd, size_t I) const;
         FlatbufferViewAdapter GetFieldByName(const std::string& FieldName) const;
 
-        static std::optional<FlatbufferViewAdapter> CreateRoot(
-            const FbSchemaCache* Cache,
-            const char* RootObjectName, const uint8_t* Buffer, size_t BufferSize);
+        static std::optional<FlatbufferViewAdapter> CreateRoot(const FbSchemaCache* Cache, const char* RootObjectName,
+                                                               const uint8_t* Buffer, size_t BufferSize);
 
     private:
         const reflection::Field* FindField(std::string_view FieldName) const;
-        const uint8_t* GetVectorData(const flatbuffers::Table* Tbl, const reflection::Field* F, size_t& Count, size_t& ElemSize) const;
+        const uint8_t* GetVectorData(const flatbuffers::Table* Tbl, const reflection::Field* F, size_t& Count,
+                                     size_t& ElemSize) const;
         bool IsFlatArrayType(EVTXContainerType Type) const;
 
     private:
-        const FbSchemaCache* Cache{nullptr};
-        const reflection::Object* Object{nullptr};
-        const flatbuffers::Table* TablePtr{nullptr};
+        const FbSchemaCache* Cache {nullptr};
+        const reflection::Object* Object {nullptr};
+        const flatbuffers::Table* TablePtr {nullptr};
     };
 
-    static_assert(CBinaryNodeView<FlatbufferViewAdapter>, "FlatbufferViewAdapter does not follow CBinaryNodeView concept!");
-    
-    class FbViewFactory{
+    static_assert(CBinaryNodeView<FlatbufferViewAdapter>,
+                  "FlatbufferViewAdapter does not follow CBinaryNodeView concept!");
+
+    class FbViewFactory {
     public:
         FbViewFactory() = default;
 
@@ -100,13 +103,14 @@ namespace VtxDiff::Flatbuffers {
 
         bool InitFromFile(const std::string& Path, const std::string& RootType);
         bool InitFromMemory(const uint8_t* Data, size_t Size, const std::string& RootType);
+
     private:
-        const reflection::Schema* Schema{};
+        const reflection::Schema* Schema {};
         std::string RootName;
         std::unordered_map<std::string, SubArrayNames> SubNames;
         std::vector<uint8_t> SchemaBytes;
         FbSchemaCache GlobalCache;
     };
 
-    
-}
+
+} // namespace VtxDiff::Flatbuffers
diff --git a/sdk/include/vtx/differ/adapters/protobuff/vtx_proto_verify.h b/sdk/include/vtx/differ/adapters/protobuff/vtx_proto_verify.h
index 85051ff..ebcf1a6 100644
--- a/sdk/include/vtx/differ/adapters/protobuff/vtx_proto_verify.h
+++ b/sdk/include/vtx/differ/adapters/protobuff/vtx_proto_verify.h
@@ -12,19 +12,20 @@
 #include "google/protobuf/util/message_differencer.h"
 
 
-namespace VtxDiff::Protobuf
-{
-	static bool ProtoEquals(const google::protobuf::Message& A,const google::protobuf::Message& B,std::string* OutDiff)
-	{
-		using google::protobuf::util::MessageDifferencer;
-		MessageDifferencer Diff;
-		Diff.set_message_field_comparison(MessageDifferencer::EQUIVALENT);
-
-		std::string report;
-		if (OutDiff) Diff.ReportDifferencesToString(&report);
-
-		const bool Ok = Diff.Compare(A, B);
-		if (!Ok && OutDiff) *OutDiff = report;
-		return Ok;
-	}
-}
\ No newline at end of file
+namespace VtxDiff::Protobuf {
+    static bool ProtoEquals(const google::protobuf::Message& A, const google::protobuf::Message& B,
+                            std::string* OutDiff) {
+        using google::protobuf::util::MessageDifferencer;
+        MessageDifferencer Diff;
+        Diff.set_message_field_comparison(MessageDifferencer::EQUIVALENT);
+
+        std::string report;
+        if (OutDiff)
+            Diff.ReportDifferencesToString(&report);
+
+        const bool Ok = Diff.Compare(A, B);
+        if (!Ok && OutDiff)
+            *OutDiff = report;
+        return Ok;
+    }
+} // namespace VtxDiff::Protobuf
\ No newline at end of file
diff --git a/sdk/include/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h b/sdk/include/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h
index 1190e11..27459fa 100644
--- a/sdk/include/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h
+++ b/sdk/include/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h
@@ -21,14 +21,13 @@ namespace VtxDiff::Protobuf {
         std::string FlatDataField;
         std::string OffsetsField;
     };
-    
-    class FProtobufViewAdapter
-    {
+
+    class FProtobufViewAdapter {
     public:
         FProtobufViewAdapter() = default;
 
         FProtobufViewAdapter(const google::protobuf::Message* InMsg, bool bOwnsMessage);
-        
+
         ~FProtobufViewAdapter();
 
         FProtobufViewAdapter(FProtobufViewAdapter&&) noexcept;
@@ -37,17 +36,14 @@ namespace VtxDiff::Protobuf {
         FProtobufViewAdapter(const FProtobufViewAdapter&) = delete;
         FProtobufViewAdapter& operator=(const FProtobufViewAdapter&) = delete;
 
-        static std::optional<FProtobufViewAdapter> CreateRoot(
-            const google::protobuf::DescriptorPool* Pool,
-            const std::string& RootType,
-            const uint8_t* Buffer,
-            size_t Size);
+        static std::optional<FProtobufViewAdapter> CreateRoot(const google::protobuf::DescriptorPool* Pool,
+                                                              const std::string& RootType, const uint8_t* Buffer,
+                                                              size_t Size);
 
-        static std::optional<FProtobufViewAdapter> FromMessage(
-            const google::protobuf::Message& Message);
+        static std::optional<FProtobufViewAdapter> FromMessage(const google::protobuf::Message& Message);
 
         void SetSubArrayNames(std::unordered_map<std::string, SubArrayNames> Map);
-        
+
         void Reset();
         bool IsValid() const;
 
@@ -59,7 +55,7 @@ namespace VtxDiff::Protobuf {
         size_t GetArraySize(const VtxDiff::FieldDesc& Field) const;
         std::span<const std::byte> GetArrayElementBytes(const VtxDiff::FieldDesc& Field, size_t Index) const;
         std::span<const std::byte> GetSubArrayBytes(const VtxDiff::FieldDesc& Field, size_t SubIndex) const;
-        
+
         size_t GetMapSize(const VtxDiff::FieldDesc& Field) const;
         std::string GetMapKey(const VtxDiff::FieldDesc& Field, size_t Index) const;
 
@@ -84,7 +80,7 @@ namespace VtxDiff::Protobuf {
         const google::protobuf::FieldDescriptor* FindField(std::string_view Name) const;
         bool IsScalar(const google::protobuf::FieldDescriptor* Field) const;
         EVTXContainerType InferContainerType(const google::protobuf::FieldDescriptor* Field) const;
-        
+
         std::span<const std::byte> Publish(const void* Data, size_t Size) const;
         std::span<const std::byte> Publish(const std::vector<std::byte>& Buffer) const;
         std::span<const std::byte> Publish(std::vector<std::byte>&& Buffer) const;
@@ -93,9 +89,7 @@ namespace VtxDiff::Protobuf {
         static std::unique_ptr<google::protobuf::Message> CloneMessage(const google::protobuf::Message& Src);
 
     public:
-        inline const google::protobuf::Message* GetMsg() const noexcept {
-            return Owned ? Owned.get() : External;
-        }
+        inline const google::protobuf::Message* GetMsg() const noexcept { return Owned ? Owned.get() : External; }
         inline const google::protobuf::Descriptor* GetDesc() const noexcept {
             auto* m = GetMsg();
             return m ? m->GetDescriptor() : nullptr;
@@ -106,8 +100,9 @@ namespace VtxDiff::Protobuf {
         }
     };
 
-    static_assert(CBinaryNodeView<FProtobufViewAdapter>, "FProtobufViewAdapter does not follow CBinaryNodeView concept!");
-    
+    static_assert(CBinaryNodeView<FProtobufViewAdapter>,
+                  "FProtobufViewAdapter does not follow CBinaryNodeView concept!");
+
     class PbViewFactory {
     public:
         PbViewFactory() = default;
diff --git a/sdk/include/vtx/differ/core/interfaces/vtx_binary_view_node.h b/sdk/include/vtx/differ/core/interfaces/vtx_binary_view_node.h
index 7cfdbb9..fb65faa 100644
--- a/sdk/include/vtx/differ/core/interfaces/vtx_binary_view_node.h
+++ b/sdk/include/vtx/differ/core/interfaces/vtx_binary_view_node.h
@@ -2,26 +2,25 @@
 
 namespace VtxDiff {
 
-    template<typename T>
-    concept CBinaryNodeView = requires(const T& View, const FieldDesc& Fd, size_t Index, const std::string& Str)
-    {
-        { View.IsValid() } -> std::same_as<bool>;
-        //{ View.Reset() } -> std::same_as<void>;
-        
-        { View.EnumerateFields() } -> std::same_as<std::span<const FieldDesc>>;
-        { View.GetFieldBytes(Fd) } -> std::same_as<std::span<const std::byte>>;
-        { View.GetScalarFieldString(Str) } -> std::same_as<std::string>;
-        
-        { View.GetArraySize(Fd) } -> std::same_as<size_t>;
-        { View.GetArrayElementBytes(Fd, Index) } -> std::same_as<std::span<const std::byte>>;
-        { View.GetSubArrayBytes(Fd, Index) } -> std::same_as<std::span<const std::byte>>;
-        
-        { View.GetMapSize(Fd) } -> std::same_as<size_t>;
-        { View.GetMapKey(Fd, Index) } -> std::same_as<std::string>;
-        
-        { View.GetNestedStruct(Fd) } -> std::same_as<T>;
-        { View.GetArrayElementAsStruct(Fd, Index) } -> std::same_as<T>;
-        { View.GetMapValueAsStruct(Fd, Index) } -> std::same_as<T>;
-        { View.GetFieldByName(Str) } -> std::same_as<T>;
-    };
+    template <typename T>
+    concept CBinaryNodeView = requires(const T& View, const FieldDesc& Fd, size_t Index, const std::string& Str) {
+                                  { View.IsValid() } -> std::same_as<bool>;
+                                  //{ View.Reset() } -> std::same_as<void>;
+
+                                  { View.EnumerateFields() } -> std::same_as<std::span<const FieldDesc>>;
+                                  { View.GetFieldBytes(Fd) } -> std::same_as<std::span<const std::byte>>;
+                                  { View.GetScalarFieldString(Str) } -> std::same_as<std::string>;
+
+                                  { View.GetArraySize(Fd) } -> std::same_as<size_t>;
+                                  { View.GetArrayElementBytes(Fd, Index) } -> std::same_as<std::span<const std::byte>>;
+                                  { View.GetSubArrayBytes(Fd, Index) } -> std::same_as<std::span<const std::byte>>;
+
+                                  { View.GetMapSize(Fd) } -> std::same_as<size_t>;
+                                  { View.GetMapKey(Fd, Index) } -> std::same_as<std::string>;
+
+                                  { View.GetNestedStruct(Fd) } -> std::same_as<T>;
+                                  { View.GetArrayElementAsStruct(Fd, Index) } -> std::same_as<T>;
+                                  { View.GetMapValueAsStruct(Fd, Index) } -> std::same_as<T>;
+                                  { View.GetFieldByName(Str) } -> std::same_as<T>;
+                              };
 } // namespace VtxDiff
diff --git a/sdk/include/vtx/differ/core/vtx_default_tree_diff.h b/sdk/include/vtx/differ/core/vtx_default_tree_diff.h
index b5f2aa9..579a10f 100644
--- a/sdk/include/vtx/differ/core/vtx_default_tree_diff.h
+++ b/sdk/include/vtx/differ/core/vtx_default_tree_diff.h
@@ -17,708 +17,865 @@
 
 namespace VtxDiff {
 
-inline std::span<const std::byte> SafeSubspan(std::span<const std::byte> Data, size_t Start, size_t End) {
-    const size_t Max = Data.size();
-    Start = std::min(Start, Max); End = std::min(End, Max); End = std::max(End, Start);
-    return Data.subspan(Start, End - Start);
-}
-
-inline bool SpanEqual(std::span<const std::byte> A, std::span<const std::byte> B) {
-    if (A.size() != B.size()) return false;
-    if (A.empty()) return true;
-    return std::memcmp(A.data(), B.data(), A.size()) == 0;
-}
-
-inline bool ReadOffsetU32(std::span<const std::byte> Raw, size_t& Out) {
-    if (Raw.size() != sizeof(uint32_t)) return false;
-    uint32_t v = 0; std::memcpy(&v, Raw.data(), sizeof(uint32_t)); Out = (size_t)v; return true;
-}
-
-inline bool ReadOffsetAny(std::span<const std::byte> Raw, size_t& Out) {
-    if (Raw.size() == sizeof(uint32_t)) { uint32_t v; std::memcpy(&v, Raw.data(), sizeof(v)); Out = v; return true; }
-    if (Raw.size() == sizeof(uint64_t)) { uint64_t v; std::memcpy(&v, Raw.data(), sizeof(v)); Out = static_cast<size_t>(v); return true; }
-    return false;
-}
-
-inline uint64_t StableHash64(std::string_view s) {
-    uint64_t idHash64 = XXH3_64bits(s.data(), s.size());
-    return idHash64;
-}
-
-inline bool IsAncestorPath(const VtxDiff::DiffIndexPath& A, const VtxDiff::DiffIndexPath& B) {
-    if (A.size() >= B.size()) return false;
-    for (size_t i = 0; i < A.size(); ++i) if (A[i] != B[i]) return false;
-    return true;
-}
-
-template <CBinaryNodeView TNodeView>
-class DefaultTreeDiff
-{
-private:
-    struct ActorEntry { uint64_t Hash; size_t Index; };
-    mutable std::vector<ActorEntry> ScratchActorsB;
-    mutable std::vector<uint8_t> ScratchMatchedB;
-
-    struct MapEntry { uint64_t Hash; std::string Key; size_t Index; };
-    mutable std::vector<MapEntry> ScratchMapA;
-    mutable std::vector<MapEntry> ScratchMapB;
-
-    static int32_t HashToPathKey(uint64_t Hash) {
-        return static_cast<int32_t>(Hash & 0x7FFFFFFF);
+    inline std::span<const std::byte> SafeSubspan(std::span<const std::byte> Data, size_t Start, size_t End) {
+        const size_t Max = Data.size();
+        Start = std::min(Start, Max);
+        End = std::min(End, Max);
+        End = std::max(End, Start);
+        return Data.subspan(Start, End - Start);
     }
 
-    std::optional<uint64_t> TryGetContentHash(const TNodeView& Node) const
-    {
-        const std::string hash_string = Node.GetScalarFieldString("content_hash");
-        if (hash_string.empty()) {
-            return std::nullopt;
-        }
-        return Node.GetUint64Field("content_hash");
+    inline bool SpanEqual(std::span<const std::byte> A, std::span<const std::byte> B) {
+        if (A.size() != B.size())
+            return false;
+        if (A.empty())
+            return true;
+        return std::memcmp(A.data(), B.data(), A.size()) == 0;
     }
 
-    bool HaveMatchingContentHash(const TNodeView& NodeA, const TNodeView& NodeB) const
-    {
-        const auto hash_a = TryGetContentHash(NodeA);
-        const auto hash_b = TryGetContentHash(NodeB);
-        return hash_a.has_value() && hash_b.has_value() && (*hash_a == *hash_b);
+    inline bool ReadOffsetU32(std::span<const std::byte> Raw, size_t& Out) {
+        if (Raw.size() != sizeof(uint32_t))
+            return false;
+        uint32_t v = 0;
+        std::memcpy(&v, Raw.data(), sizeof(uint32_t));
+        Out = (size_t)v;
+        return true;
     }
 
-public:
-    DefaultTreeDiff() = default;
-    ~DefaultTreeDiff() = default;
-
-    PatchIndex ComputeDiff(const TNodeView& NodeA, const TNodeView& NodeB, const DiffOptions& Opt) const
-    {
-        PatchIndex Out;
-        Out.operations.reserve(512);
-        DiffIndexPath root;
+    inline bool ReadOffsetAny(std::span<const std::byte> Raw, size_t& Out) {
+        if (Raw.size() == sizeof(uint32_t)) {
+            uint32_t v;
+            std::memcpy(&v, Raw.data(), sizeof(v));
+            Out = v;
+            return true;
+        }
+        if (Raw.size() == sizeof(uint64_t)) {
+            uint64_t v;
+            std::memcpy(&v, Raw.data(), sizeof(v));
+            Out = static_cast<size_t>(v);
+            return true;
+        }
+        return false;
+    }
 
-        if (!NodeA.IsValid() && !NodeB.IsValid()) return Out;
-        if (!NodeA.IsValid() && NodeB.IsValid()) { Out.operations.push_back({ DiffOperation::Add, EVTXContainerType::Unknown, root }); return Out; }
-        if (NodeA.IsValid() && !NodeB.IsValid()) { Out.operations.push_back({ DiffOperation::Remove, EVTXContainerType::Unknown, root }); return Out; }
+    inline uint64_t StableHash64(std::string_view s) {
+        uint64_t idHash64 = XXH3_64bits(s.data(), s.size());
+        return idHash64;
+    }
 
-        std::span<const FieldDesc> fields_a = NodeA.EnumerateFields();
-        std::span<const FieldDesc> fields_b = NodeB.EnumerateFields();
+    inline bool IsAncestorPath(const VtxDiff::DiffIndexPath& A, const VtxDiff::DiffIndexPath& B) {
+        if (A.size() >= B.size())
+            return false;
+        for (size_t i = 0; i < A.size(); ++i)
+            if (A[i] != B[i])
+                return false;
+        return true;
+    }
 
-        const FieldDesc* entities_a = nullptr;
-        const FieldDesc* entities_b = nullptr;
+    template <CBinaryNodeView TNodeView>
+    class DefaultTreeDiff {
+    private:
+        struct ActorEntry {
+            uint64_t Hash;
+            size_t Index;
+        };
+        mutable std::vector<ActorEntry> ScratchActorsB;
+        mutable std::vector<uint8_t> ScratchMatchedB;
 
-        for (const auto& f : fields_a) { if (f.name == "entities") { entities_a = &f; break; } }
-        for (const auto& f : fields_b) { if (f.name == "entities") { entities_b = &f; break; } }
+        struct MapEntry {
+            uint64_t Hash;
+            std::string Key;
+            size_t Index;
+        };
+        mutable std::vector<MapEntry> ScratchMapA;
+        mutable std::vector<MapEntry> ScratchMapB;
 
-        if (entities_a && entities_b)
-        {
-            root.push_back(static_cast<int32_t>(entities_a->type));
-            DiffActorsArray(NodeA, NodeB, *entities_a, *entities_b, Opt, Out, root);
-            return Out;
-        }
+        static int32_t HashToPathKey(uint64_t Hash) { return static_cast<int32_t>(Hash & 0x7FFFFFFF); }
 
-        Diff(NodeA, NodeB, Opt, root, Out);
-        return Out;
-    }
-    
-    PatchIndex ComputeEntityDiff(const TNodeView& EntityA, const TNodeView& EntityB,const DiffOptions& Opt, DiffIndexPath BasePath = {}) const
-    {
-        PatchIndex Out;
-        Out.operations.reserve(512);
-        if (!EntityA.IsValid() && !EntityB.IsValid()) return Out;
-        if (!EntityA.IsValid() && EntityB.IsValid()) { Out.operations.push_back({ DiffOperation::Add, EVTXContainerType::Unknown, BasePath }); return Out; }
-        if (EntityA.IsValid() && !EntityB.IsValid()) { Out.operations.push_back({ DiffOperation::Remove, EVTXContainerType::Unknown, BasePath }); return Out; }
-
-        if (HaveMatchingContentHash(EntityA, EntityB)) {
-            return Out; 
-        }
-        
-        Diff(EntityA, EntityB, Opt, BasePath, Out);
-        return Out;
-    }
-    
-
-private:
-    void Diff(const TNodeView& NodeA, const TNodeView& NodeB, const DiffOptions& Opt, DiffIndexPath& Path, PatchIndex& Out) const
-    {
-        const bool validA = NodeA.IsValid();
-        const bool validB = NodeB.IsValid();
-
-        if (!validA && !validB) return;
-        if (!validA && validB) { Out.operations.push_back({ DiffOperation::Add, EVTXContainerType::Unknown, Path }); return; }
-        if (validA && !validB) { Out.operations.push_back({ DiffOperation::Remove, EVTXContainerType::Unknown, Path }); return; }
-
-        auto FieldsA = NodeA.EnumerateFields();
-        auto FieldsB = NodeB.EnumerateFields();
-        
-        constexpr uint32_t MAX_ENUM_TYPES = 64; 
-        const FieldDesc* ArrA[MAX_ENUM_TYPES] = { nullptr };
-        const FieldDesc* ArrB[MAX_ENUM_TYPES] = { nullptr };
-        uint32_t maxTypeSeen = 0;
-
-        for (const auto& f : FieldsA) {
-            if (f.is_actors_field || f.type == EVTXContainerType::Unknown) continue;
-            uint32_t t = static_cast<uint32_t>(f.type);
-            if (t < MAX_ENUM_TYPES) { ArrA[t] = &f; if (t > maxTypeSeen) maxTypeSeen = t; }
-        }
-        for (const auto& f : FieldsB) {
-            if (f.is_actors_field || f.type == EVTXContainerType::Unknown) continue;
-            uint32_t t = static_cast<uint32_t>(f.type);
-            if (t < MAX_ENUM_TYPES) { ArrB[t] = &f; if (t > maxTypeSeen) maxTypeSeen = t; }
+        std::optional<uint64_t> TryGetContentHash(const TNodeView& Node) const {
+            const std::string hash_string = Node.GetScalarFieldString("content_hash");
+            if (hash_string.empty()) {
+                return std::nullopt;
+            }
+            return Node.GetUint64Field("content_hash");
         }
 
-        for (uint32_t t = 0; t <= maxTypeSeen; ++t)
-        {
-            const FieldDesc* Fda = ArrA[t];
-            const FieldDesc* Fdb = ArrB[t];
-            if (!Fda && !Fdb) continue;
-
-            EVTXContainerType T = static_cast<EVTXContainerType>(t);
-            Path.push_back(t);
-            
-            if (!Fda && Fdb) {
-                Out.operations.push_back({ DiffOperation::Add, T, Path });
-            } else if (Fda && !Fdb) {
-                Out.operations.push_back({ DiffOperation::Remove, T, Path });
-            } else if (IsArraysType(T)) {
-                DiffEncapsulatedArray(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path);
-            } else {
-                switch (T) {
-                case EVTXContainerType::BoolProperties:
-                case EVTXContainerType::Int32Properties:
-                case EVTXContainerType::Int64Properties:
-                case EVTXContainerType::FloatProperties:
-                case EVTXContainerType::DoubleProperties:
-                case EVTXContainerType::StringProperties:
-                case EVTXContainerType::TransformProperties:
-                case EVTXContainerType::VectorProperties:
-                case EVTXContainerType::QuatProperties:
-                case EVTXContainerType::RangeProperties:
-                    DiffScalarArray(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path); break;
-                case EVTXContainerType::AnyStructProperties:
-                    DiffStructArray(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path); break;
-                case EVTXContainerType::MapProperties:
-                    DiffMapContainers(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path); break;
-                default: break;
-                }
-            }
-            Path.pop_back();
+        bool HaveMatchingContentHash(const TNodeView& NodeA, const TNodeView& NodeB) const {
+            const auto hash_a = TryGetContentHash(NodeA);
+            const auto hash_b = TryGetContentHash(NodeB);
+            return hash_a.has_value() && hash_b.has_value() && (*hash_a == *hash_b);
         }
-    }
-        
-    void DiffActorsArray(const TNodeView& NodeA, const TNodeView& NodeB, const FieldDesc& Fda, const FieldDesc& Fdb, const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const
-    {
-        const size_t CountA = NodeA.GetArraySize(Fda);
-        const size_t CountB = NodeB.GetArraySize(Fdb); 
-        if (CountA == 0 && CountB == 0) return;
 
-        FieldDesc IdFieldDesc; IdFieldDesc.name = "unique_ids";
+    public:
+        DefaultTreeDiff() = default;
+        ~DefaultTreeDiff() = default;
 
-        ScratchActorsB.clear();
-        ScratchMatchedB.assign(CountB, 0); 
+        PatchIndex ComputeDiff(const TNodeView& NodeA, const TNodeView& NodeB, const DiffOptions& Opt) const {
+            PatchIndex Out;
+            Out.operations.reserve(512);
+            DiffIndexPath root;
 
-        //check if  actors order has changed, actor order is different in frames a and b
-        for (size_t i = 0; i < CountB; ++i) {
-            auto spanId = NodeB.GetArrayElementBytes(IdFieldDesc, i);
-            if (!spanId.empty()) {
-                std::string_view IdView(reinterpret_cast<const char*>(spanId.data()), spanId.size());
-                ScratchActorsB.push_back({StableHash64(IdView), i});
+            if (!NodeA.IsValid() && !NodeB.IsValid())
+                return Out;
+            if (!NodeA.IsValid() && NodeB.IsValid()) {
+                Out.operations.push_back({DiffOperation::Add, EVTXContainerType::Unknown, root});
+                return Out;
+            }
+            if (NodeA.IsValid() && !NodeB.IsValid()) {
+                Out.operations.push_back({DiffOperation::Remove, EVTXContainerType::Unknown, root});
+                return Out;
             }
-        }
 
-        std::sort(ScratchActorsB.begin(), ScratchActorsB.end(), [](const ActorEntry& a, const ActorEntry& b) {
-            return a.Hash < b.Hash;
-        });
-
-        for (size_t i = 0; i < CountA; ++i) {
-            auto spanIdA = NodeA.GetArrayElementBytes(IdFieldDesc, i);
-            if (spanIdA.empty()) continue;
-
-            std::string_view IdViewA(reinterpret_cast<const char*>(spanIdA.data()), spanIdA.size());
-            uint64_t TargetHash = StableHash64(IdViewA);
-
-            size_t foundIndexB = static_cast<size_t>(-1);
-            
-            //fast-path, direct position, 99% of the cases  entity 'i' is in the same postion 'i'
-            if (i < CountB) {
-                auto spanIdB_Direct = NodeB.GetArrayElementBytes(IdFieldDesc, i);
-                std::string_view IdViewB_Direct(reinterpret_cast<const char*>(spanIdB_Direct.data()), spanIdB_Direct.size());
-                if (IdViewA == IdViewB_Direct) {
-                    foundIndexB = i; //found we dont search
+            std::span<const FieldDesc> fields_a = NodeA.EnumerateFields();
+            std::span<const FieldDesc> fields_b = NodeB.EnumerateFields();
+
+            const FieldDesc* entities_a = nullptr;
+            const FieldDesc* entities_b = nullptr;
+
+            for (const auto& f : fields_a) {
+                if (f.name == "entities") {
+                    entities_a = &f;
+                    break;
                 }
             }
-            
-            //entities are out of order, do a binary search
-            if (foundIndexB == static_cast<size_t>(-1)) {
-                auto It = std::lower_bound(ScratchActorsB.begin(), ScratchActorsB.end(), TargetHash, 
-                    [](const ActorEntry& elem, uint64_t val) { return elem.Hash < val; });
-                
-                if (It != ScratchActorsB.end() && It->Hash == TargetHash) {
-                    auto spanIdB = NodeB.GetArrayElementBytes(IdFieldDesc, It->Index);
-                    std::string_view IdB(reinterpret_cast<const char*>(spanIdB.data()), spanIdB.size());
-                    if (IdViewA == IdB) {
-                        foundIndexB = It->Index;
-                    }
+            for (const auto& f : fields_b) {
+                if (f.name == "entities") {
+                    entities_b = &f;
+                    break;
                 }
             }
-            
-            //not found in binary search, removed or destroyed
-            if (foundIndexB == static_cast<size_t>(-1))
-            {
-                std::string IdStr(IdViewA);
-                Path.push_back(HashToPathKey(TargetHash));
-                Out.operations.push_back({ DiffOperation::Remove, EVTXContainerType::AnyStructProperties, Path, IdStr });
-                Path.pop_back();
-                continue;
+
+            if (entities_a && entities_b) {
+                root.push_back(static_cast<int32_t>(entities_a->type));
+                DiffActorsArray(NodeA, NodeB, *entities_a, *entities_b, Opt, Out, root);
+                return Out;
             }
 
-            //mark entity B as processed
-            ScratchMatchedB[foundIndexB] = 1;
+            Diff(NodeA, NodeB, Opt, root, Out);
+            return Out;
+        }
 
-            auto ActorA = NodeA.GetArrayElementAsStruct(Fda, i);   
-            auto ActorB = NodeB.GetArrayElementAsStruct(Fdb, foundIndexB);
-            if (!ActorA.IsValid() || !ActorB.IsValid()) continue;
-            
-            //check now content hash
+        PatchIndex ComputeEntityDiff(const TNodeView& EntityA, const TNodeView& EntityB, const DiffOptions& Opt,
+                                     DiffIndexPath BasePath = {}) const {
+            PatchIndex Out;
+            Out.operations.reserve(512);
+            if (!EntityA.IsValid() && !EntityB.IsValid())
+                return Out;
+            if (!EntityA.IsValid() && EntityB.IsValid()) {
+                Out.operations.push_back({DiffOperation::Add, EVTXContainerType::Unknown, BasePath});
+                return Out;
+            }
+            if (EntityA.IsValid() && !EntityB.IsValid()) {
+                Out.operations.push_back({DiffOperation::Remove, EVTXContainerType::Unknown, BasePath});
+                return Out;
+            }
 
-            if (HaveMatchingContentHash(ActorA, ActorB)) {
-                continue; //entity is edentical, no need to process all vectors.
+            if (HaveMatchingContentHash(EntityA, EntityB)) {
+                return Out;
             }
-            
-            const int32_t Key = HashToPathKey(TargetHash);
-            Path.push_back(Key);
 
-            size_t OpCountBefore = Out.operations.size();
-            Diff(ActorA, ActorB, Opt, Path, Out); 
+            Diff(EntityA, EntityB, Opt, BasePath, Out);
+            return Out;
+        }
+
+
+    private:
+        void Diff(const TNodeView& NodeA, const TNodeView& NodeB, const DiffOptions& Opt, DiffIndexPath& Path,
+                  PatchIndex& Out) const {
+            const bool validA = NodeA.IsValid();
+            const bool validB = NodeB.IsValid();
+
+            if (!validA && !validB)
+                return;
+            if (!validA && validB) {
+                Out.operations.push_back({DiffOperation::Add, EVTXContainerType::Unknown, Path});
+                return;
+            }
+            if (validA && !validB) {
+                Out.operations.push_back({DiffOperation::Remove, EVTXContainerType::Unknown, Path});
+                return;
+            }
 
-            if (Out.operations.size() > OpCountBefore) {
-                std::string IdStr(IdViewA); 
-                Out.actor_id_by_key.try_emplace(Key, IdStr);
-                for (size_t opIdx = OpCountBefore; opIdx < Out.operations.size(); ++opIdx) {
-                    Out.operations[opIdx].ActorId = IdStr;
+            auto FieldsA = NodeA.EnumerateFields();
+            auto FieldsB = NodeB.EnumerateFields();
+
+            constexpr uint32_t MAX_ENUM_TYPES = 64;
+            const FieldDesc* ArrA[MAX_ENUM_TYPES] = {nullptr};
+            const FieldDesc* ArrB[MAX_ENUM_TYPES] = {nullptr};
+            uint32_t maxTypeSeen = 0;
+
+            for (const auto& f : FieldsA) {
+                if (f.is_actors_field || f.type == EVTXContainerType::Unknown)
+                    continue;
+                uint32_t t = static_cast<uint32_t>(f.type);
+                if (t < MAX_ENUM_TYPES) {
+                    ArrA[t] = &f;
+                    if (t > maxTypeSeen)
+                        maxTypeSeen = t;
+                }
+            }
+            for (const auto& f : FieldsB) {
+                if (f.is_actors_field || f.type == EVTXContainerType::Unknown)
+                    continue;
+                uint32_t t = static_cast<uint32_t>(f.type);
+                if (t < MAX_ENUM_TYPES) {
+                    ArrB[t] = &f;
+                    if (t > maxTypeSeen)
+                        maxTypeSeen = t;
                 }
             }
-            Path.pop_back();
-        }
 
-        //process entities added in frame B
-        for (size_t i = 0; i < CountB; ++i) {
-            if (ScratchMatchedB[i] == 0) {
-                auto spanIdB = NodeB.GetArrayElementBytes(IdFieldDesc, i);
-                if (spanIdB.empty()) continue;
-                std::string_view IdView(reinterpret_cast<const char*>(spanIdB.data()), spanIdB.size());
-                std::string IdStr(IdView);
-                
-                Path.push_back(HashToPathKey(StableHash64(IdView)));
-                Out.operations.push_back({ DiffOperation::Add, EVTXContainerType::AnyStructProperties, Path, IdStr });
+            for (uint32_t t = 0; t <= maxTypeSeen; ++t) {
+                const FieldDesc* Fda = ArrA[t];
+                const FieldDesc* Fdb = ArrB[t];
+                if (!Fda && !Fdb)
+                    continue;
+
+                EVTXContainerType T = static_cast<EVTXContainerType>(t);
+                Path.push_back(t);
+
+                if (!Fda && Fdb) {
+                    Out.operations.push_back({DiffOperation::Add, T, Path});
+                } else if (Fda && !Fdb) {
+                    Out.operations.push_back({DiffOperation::Remove, T, Path});
+                } else if (IsArraysType(T)) {
+                    DiffEncapsulatedArray(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path);
+                } else {
+                    switch (T) {
+                    case EVTXContainerType::BoolProperties:
+                    case EVTXContainerType::Int32Properties:
+                    case EVTXContainerType::Int64Properties:
+                    case EVTXContainerType::FloatProperties:
+                    case EVTXContainerType::DoubleProperties:
+                    case EVTXContainerType::StringProperties:
+                    case EVTXContainerType::TransformProperties:
+                    case EVTXContainerType::VectorProperties:
+                    case EVTXContainerType::QuatProperties:
+                    case EVTXContainerType::RangeProperties:
+                        DiffScalarArray(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path);
+                        break;
+                    case EVTXContainerType::AnyStructProperties:
+                        DiffStructArray(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path);
+                        break;
+                    case EVTXContainerType::MapProperties:
+                        DiffMapContainers(NodeA, NodeB, *Fda, *Fdb, Opt, Out, Path);
+                        break;
+                    default:
+                        break;
+                    }
+                }
                 Path.pop_back();
             }
         }
-    }
 
-    inline bool FastSpanEqual(std::span<const std::byte> A, std::span<const std::byte> B) const {
-        if (A.size() != B.size()) return false;
-        const size_t sz = A.size();
-        if (sz == 0) return true;
+        void DiffActorsArray(const TNodeView& NodeA, const TNodeView& NodeB, const FieldDesc& Fda, const FieldDesc& Fdb,
+                             const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const {
+            const size_t CountA = NodeA.GetArraySize(Fda);
+            const size_t CountB = NodeB.GetArraySize(Fdb);
+            if (CountA == 0 && CountB == 0)
+                return;
+
+            FieldDesc IdFieldDesc;
+            IdFieldDesc.name = "unique_ids";
+
+            ScratchActorsB.clear();
+            ScratchMatchedB.assign(CountB, 0);
+
+            //check if  actors order has changed, actor order is different in frames a and b
+            for (size_t i = 0; i < CountB; ++i) {
+                auto spanId = NodeB.GetArrayElementBytes(IdFieldDesc, i);
+                if (!spanId.empty()) {
+                    std::string_view IdView(reinterpret_cast<const char*>(spanId.data()), spanId.size());
+                    ScratchActorsB.push_back({StableHash64(IdView), i});
+                }
+            }
 
-        const void* pa = A.data();
-        const void* pb = B.data();
+            std::sort(ScratchActorsB.begin(), ScratchActorsB.end(),
+                      [](const ActorEntry& a, const ActorEntry& b) { return a.Hash < b.Hash; });
 
-        // 4 bytes (Int32, Float)
-        if (sz == 4) {
-            uint32_t va, vb; 
-            std::memcpy(&va, pa, 4); std::memcpy(&vb, pb, 4);
-            return va == vb;
-        }
-        // 8 bytes (Int64, Double, 2x Float)
-        if (sz == 8) {
-            uint64_t va, vb; 
-            std::memcpy(&va, pa, 8); std::memcpy(&vb, pb, 8);
-            return va == vb;
-        }
-        // 12 bytes (Vector: 3x Float) - 64 bits + 32 bits
-        if (sz == 12) {
-            uint64_t va8, vb8; uint32_t va4, vb4;
-            std::memcpy(&va8, pa, 8); std::memcpy(&vb8, pb, 8);
-            std::memcpy(&va4, static_cast<const uint8_t*>(pa) + 8, 4); 
-            std::memcpy(&vb4, static_cast<const uint8_t*>(pb) + 8, 4);
-            return (va8 == vb8) && (va4 == vb4);
-        }
-        // 16 bytes (Quat, Range, 4x Float) - 128 bits (2x 64 bits)
-        if (sz == 16) {
-            uint64_t va1, vb1, va2, vb2;
-            std::memcpy(&va1, pa, 8); std::memcpy(&vb1, pb, 8);
-            std::memcpy(&va2, static_cast<const uint8_t*>(pa) + 8, 8); 
-            std::memcpy(&vb2, static_cast<const uint8_t*>(pb) + 8, 8);
-            return (va1 == vb1) && (va2 == vb2);
-        }
+            for (size_t i = 0; i < CountA; ++i) {
+                auto spanIdA = NodeA.GetArrayElementBytes(IdFieldDesc, i);
+                if (spanIdA.empty())
+                    continue;
 
-        // Fallback para strings o arrays gigantes
-        return std::memcmp(pa, pb, sz) == 0;
-    }
-    
-    void DiffScalarArray(const TNodeView& A, const TNodeView& B, const FieldDesc& Fda, const FieldDesc& Fdb, const DiffOptions& Opt, PatchIndex& Out, const DiffIndexPath& Path) const
-    {
-        auto full_bytes_a = A.GetFieldBytes(Fda);
-        auto full_bytes_b = B.GetFieldBytes(Fdb);
-        
-        // Fast-path global (Idénticos al 100%)
-        if (!full_bytes_a.empty() && full_bytes_a.size() == full_bytes_b.size()) {
-            if (std::memcmp(full_bytes_a.data(), full_bytes_b.data(), full_bytes_a.size()) == 0) return; 
-        }
+                std::string_view IdViewA(reinterpret_cast<const char*>(spanIdA.data()), spanIdA.size());
+                uint64_t TargetHash = StableHash64(IdViewA);
 
-        const size_t size_a = A.GetArraySize(Fda);
-        const size_t size_b = B.GetArraySize(Fdb);
-        const size_t size = std::min(size_a, size_b);
-
-        int32_t current_range_start = -1;
-        int32_t current_range_count = 0;
-        
-        auto FlushRange = [&]() {
-            if (current_range_count > 0) {
-                if (current_range_count == 1) {
-                    Out.operations.push_back({DiffOperation::Replace, Fda.type, Path.Append(current_range_start)});
-                } else {
-                    DiffIndexOp op = {DiffOperation::ReplaceRange, Fda.type, Path.Append(current_range_start)};
-                    op.ReplaceRangeCount = current_range_count;
-                    Out.operations.push_back(op);
-                }
-                current_range_start = -1;
-                current_range_count = 0;
-            }
-        };
-        
-        bool is_contiguous = !full_bytes_a.empty() && !full_bytes_b.empty() && size_a > 0 && size_b > 0;
-        
-        if (is_contiguous) {
-            const size_t stride_a = full_bytes_a.size() / size_a;
-            const size_t stride_b = full_bytes_b.size() / size_b;
-            
-            if (stride_a == stride_b && stride_a > 0) {
-                const uint8_t* ptr_a = reinterpret_cast<const uint8_t*>(full_bytes_a.data());
-                const uint8_t* ptr_b = reinterpret_cast<const uint8_t*>(full_bytes_b.data());
-
-                for (size_t i = 0; i < size; ++i) {
-                    bool bDifferent = false;
-
-                    if (Opt.compare_floats_with_epsilon) {
-                        if (stride_a == sizeof(float)) {
-                            float fa, fb;
-                            std::memcpy(&fa, ptr_a + (i * stride_a), sizeof(float));
-                            std::memcpy(&fb, ptr_b + (i * stride_b), sizeof(float));
-                            bDifferent = std::abs(fa - fb) > Opt.float_epsilon;
-                        } else if (stride_a == sizeof(double)) {
-                            double da, db;
-                            std::memcpy(&da, ptr_a + (i * stride_a), sizeof(double));
-                            std::memcpy(&db, ptr_b + (i * stride_b), sizeof(double));
-                            bDifferent = std::abs(da - db) > static_cast<double>(Opt.float_epsilon);
-                        } else {
-                            bDifferent = (std::memcmp(ptr_a + (i * stride_a), ptr_b + (i * stride_b), stride_a) != 0);
-                        }
-                    } else {
-                        auto span_a = std::span<const std::byte>(reinterpret_cast<const std::byte*>(ptr_a + (i * stride_a)), stride_a);
-                        auto span_b = std::span<const std::byte>(reinterpret_cast<const std::byte*>(ptr_b + (i * stride_b)), stride_a);
-                        bDifferent = !FastSpanEqual(span_a, span_b);
+                size_t foundIndexB = static_cast<size_t>(-1);
+
+                //fast-path, direct position, 99% of the cases  entity 'i' is in the same postion 'i'
+                if (i < CountB) {
+                    auto spanIdB_Direct = NodeB.GetArrayElementBytes(IdFieldDesc, i);
+                    std::string_view IdViewB_Direct(reinterpret_cast<const char*>(spanIdB_Direct.data()),
+                                                    spanIdB_Direct.size());
+                    if (IdViewA == IdViewB_Direct) {
+                        foundIndexB = i; //found we dont search
                     }
+                }
 
-                    if (bDifferent) {
-                        if (current_range_start == -1) current_range_start = static_cast<int32_t>(i);
-                        ++current_range_count;
-                    } else {
-                        FlushRange();
+                //entities are out of order, do a binary search
+                if (foundIndexB == static_cast<size_t>(-1)) {
+                    auto It = std::lower_bound(ScratchActorsB.begin(), ScratchActorsB.end(), TargetHash,
+                                               [](const ActorEntry& elem, uint64_t val) { return elem.Hash < val; });
+
+                    if (It != ScratchActorsB.end() && It->Hash == TargetHash) {
+                        auto spanIdB = NodeB.GetArrayElementBytes(IdFieldDesc, It->Index);
+                        std::string_view IdB(reinterpret_cast<const char*>(spanIdB.data()), spanIdB.size());
+                        if (IdViewA == IdB) {
+                            foundIndexB = It->Index;
+                        }
                     }
                 }
-                FlushRange();
-                goto EMIT_RESIZES; // Saltamos el bucle lento
-            }
-        }
-        
-        for (size_t i = 0; i < size; ++i) {
-           auto bytes_a = A.GetArrayElementBytes(Fda, i);
-           auto bytes_b = B.GetArrayElementBytes(Fdb, i);
-
-           if (bytes_a.empty() && bytes_b.empty()) { FlushRange(); continue; }
-
-           bool bDifferent = false;
-           if (Opt.compare_floats_with_epsilon && bytes_a.size() == bytes_b.size()) {
-              if (bytes_a.size() == sizeof(float)) {
-                 float fa, fb; std::memcpy(&fa, bytes_a.data(), sizeof(float)); std::memcpy(&fb, bytes_b.data(), sizeof(float));
-                 bDifferent = std::abs(fa - fb) > Opt.float_epsilon;
-              } else if (bytes_a.size() == sizeof(double)) {
-                 double da, db; std::memcpy(&da, bytes_a.data(), sizeof(double)); std::memcpy(&db, bytes_b.data(), sizeof(double));
-                 bDifferent = std::abs(da - db) > static_cast<double>(Opt.float_epsilon);
-              } else {
-                 bDifferent = !FastSpanEqual(bytes_a, bytes_b);
-              }
-           } else {
-              bDifferent = !FastSpanEqual(bytes_a, bytes_b);
-           }
-
-           if (bDifferent) {
-               if (current_range_start == -1) current_range_start = static_cast<int32_t>(i);
-               ++current_range_count;
-           } else {
-              FlushRange();
-           }
-        }
-        FlushRange();
 
-EMIT_RESIZES:
-        for (size_t i = size; i < size_b; ++i) {
-            Out.operations.push_back({ DiffOperation::Add, Fda.type, Path.Append(static_cast<int32_t>(i)) });
-        }
-        
-        for (size_t i = size; i < size_a; ++i) {
-            Out.operations.push_back({ DiffOperation::Remove, Fda.type, Path.Append(static_cast<int32_t>(i)) });
-        }
-    }
+                //not found in binary search, removed or destroyed
+                if (foundIndexB == static_cast<size_t>(-1)) {
+                    std::string IdStr(IdViewA);
+                    Path.push_back(HashToPathKey(TargetHash));
+                    Out.operations.push_back(
+                        {DiffOperation::Remove, EVTXContainerType::AnyStructProperties, Path, IdStr});
+                    Path.pop_back();
+                    continue;
+                }
 
-    void DiffStructArray(const TNodeView& A, const TNodeView& B, const FieldDesc& Fda, const FieldDesc& Fdb, const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const
-    {
-        auto full_bytes_a = A.GetFieldBytes(Fda);
-        auto full_bytes_b = B.GetFieldBytes(Fdb);
-        
-        if (!full_bytes_a.empty() && full_bytes_a.size() == full_bytes_b.size()) {
-            if (std::memcmp(full_bytes_a.data(), full_bytes_b.data(), full_bytes_a.size()) == 0) return; 
-        }
+                //mark entity B as processed
+                ScratchMatchedB[foundIndexB] = 1;
 
-        const size_t size_a = A.GetArraySize(Fda);
-        const size_t size_b = B.GetArraySize(Fdb);
+                auto ActorA = NodeA.GetArrayElementAsStruct(Fda, i);
+                auto ActorB = NodeB.GetArrayElementAsStruct(Fdb, foundIndexB);
+                if (!ActorA.IsValid() || !ActorB.IsValid())
+                    continue;
 
-        if (size_a != size_b) {
-            Out.operations.push_back({ DiffOperation::Replace, Fda.type, Path });
-            return;
-        }
+                //check now content hash
 
-        for (size_t i = 0; i < size_a; ++i) {
-            auto node_a = A.GetArrayElementAsStruct(Fda, i);
-            auto node_b = B.GetArrayElementAsStruct(Fdb, i);
-            Path.push_back(static_cast<int32_t>(i));
-            
-            if (!node_a.IsValid() || !node_b.IsValid()) {
-                Out.operations.push_back({ DiffOperation::Replace, Fda.type, Path });
-            } else
-            {
-                //use fast-path with content hash to omit identical structs
-                if (HaveMatchingContentHash(node_a, node_b)) {
-                    //structs are identical, omit
-                } else {
-                    Diff(node_a, node_b, Opt, Path, Out);
+                if (HaveMatchingContentHash(ActorA, ActorB)) {
+                    continue; //entity is edentical, no need to process all vectors.
                 }
-            }
-            Path.pop_back();
-        }
-    }
 
-    void DiffFlatRepeatedByOffsets(const TNodeView& A, const TNodeView& B, const FieldDesc& FlatFda, const FieldDesc& FlatFdb, const FieldDesc& OffFda, const FieldDesc& OffFdb, const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const
-    {
-        const size_t OffCountA = A.GetArraySize(OffFda);
-        const size_t OffCountB = B.GetArraySize(OffFdb);
-        const size_t N = std::min(OffCountA, OffCountB);
-
-        for (size_t i = 0; i < N; ++i) {
-            size_t StartA = 0, StartB = 0;
-            bool bValidOffsets = true;
-            bValidOffsets &= ReadOffsetU32(A.GetArrayElementBytes(OffFda, i), StartA);
-            bValidOffsets &= ReadOffsetU32(B.GetArrayElementBytes(OffFdb, i), StartB);
-
-            if (!bValidOffsets) {
-                Out.operations.push_back({ DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i)) });
-                continue;
-            }
-
-            size_t EndA = A.GetArraySize(FlatFda);
-            size_t EndB = B.GetArraySize(FlatFdb);
-            if (i + 1 < OffCountA) { size_t Next = 0; if (ReadOffsetU32(A.GetArrayElementBytes(OffFda, i + 1), Next)) EndA = Next; }
-            if (i + 1 < OffCountB) { size_t Next = 0; if (ReadOffsetU32(B.GetArrayElementBytes(OffFdb, i + 1), Next)) EndB = Next; }
-
-            if (EndA < StartA) EndA = StartA;
-            if (EndB < StartB) EndB = StartB;
-
-            const size_t LenA = EndA - StartA;
-            const size_t LenB = EndB - StartB;
-
-            if (LenA != LenB) {
-                Out.operations.push_back({ DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i)) });
-                continue;
-            }
-
-            bool bSubArrayChanged = false;
-            if (FlatFda.type == EVTXContainerType::AnyStructArrays) {
-                for (size_t j = 0; j < LenA; ++j) {
-                    auto NodeElemA = A.GetArrayElementAsStruct(FlatFda, StartA + j);
-                    auto NodeElemB = B.GetArrayElementAsStruct(FlatFdb, StartB + j);
-                    if (!NodeElemA.IsValid() || !NodeElemB.IsValid()) { bSubArrayChanged = true; break; }
-                    
-                    size_t before = Out.operations.size();
-                    Diff(NodeElemA, NodeElemB, Opt, Path, Out);
-                    if (Out.operations.size() > before) {
-                        Out.operations.resize(before);
-                        bSubArrayChanged = true; break;
+                const int32_t Key = HashToPathKey(TargetHash);
+                Path.push_back(Key);
+
+                size_t OpCountBefore = Out.operations.size();
+                Diff(ActorA, ActorB, Opt, Path, Out);
+
+                if (Out.operations.size() > OpCountBefore) {
+                    std::string IdStr(IdViewA);
+                    Out.actor_id_by_key.try_emplace(Key, IdStr);
+                    for (size_t opIdx = OpCountBefore; opIdx < Out.operations.size(); ++opIdx) {
+                        Out.operations[opIdx].ActorId = IdStr;
                     }
                 }
-            } else {
-                for (size_t j = 0; j < LenA; ++j) {
-                    auto EA = A.GetArrayElementBytes(FlatFda, StartA + j);
-                    auto EB = B.GetArrayElementBytes(FlatFdb, StartB + j);
-                    if (!AreScalarsEqual(FlatFda.type, EA, EB, Opt)) { bSubArrayChanged = true; break; }
+                Path.pop_back();
+            }
+
+            //process entities added in frame B
+            for (size_t i = 0; i < CountB; ++i) {
+                if (ScratchMatchedB[i] == 0) {
+                    auto spanIdB = NodeB.GetArrayElementBytes(IdFieldDesc, i);
+                    if (spanIdB.empty())
+                        continue;
+                    std::string_view IdView(reinterpret_cast<const char*>(spanIdB.data()), spanIdB.size());
+                    std::string IdStr(IdView);
+
+                    Path.push_back(HashToPathKey(StableHash64(IdView)));
+                    Out.operations.push_back({DiffOperation::Add, EVTXContainerType::AnyStructProperties, Path, IdStr});
+                    Path.pop_back();
                 }
             }
+        }
 
-            if (bSubArrayChanged) {
-                Out.operations.push_back({ DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i)) });
+        inline bool FastSpanEqual(std::span<const std::byte> A, std::span<const std::byte> B) const {
+            if (A.size() != B.size())
+                return false;
+            const size_t sz = A.size();
+            if (sz == 0)
+                return true;
+
+            const void* pa = A.data();
+            const void* pb = B.data();
+
+            // 4 bytes (Int32, Float)
+            if (sz == 4) {
+                uint32_t va, vb;
+                std::memcpy(&va, pa, 4);
+                std::memcpy(&vb, pb, 4);
+                return va == vb;
+            }
+            // 8 bytes (Int64, Double, 2x Float)
+            if (sz == 8) {
+                uint64_t va, vb;
+                std::memcpy(&va, pa, 8);
+                std::memcpy(&vb, pb, 8);
+                return va == vb;
             }
+            // 12 bytes (Vector: 3x Float) - 64 bits + 32 bits
+            if (sz == 12) {
+                uint64_t va8, vb8;
+                uint32_t va4, vb4;
+                std::memcpy(&va8, pa, 8);
+                std::memcpy(&vb8, pb, 8);
+                std::memcpy(&va4, static_cast<const uint8_t*>(pa) + 8, 4);
+                std::memcpy(&vb4, static_cast<const uint8_t*>(pb) + 8, 4);
+                return (va8 == vb8) && (va4 == vb4);
+            }
+            // 16 bytes (Quat, Range, 4x Float) - 128 bits (2x 64 bits)
+            if (sz == 16) {
+                uint64_t va1, vb1, va2, vb2;
+                std::memcpy(&va1, pa, 8);
+                std::memcpy(&vb1, pb, 8);
+                std::memcpy(&va2, static_cast<const uint8_t*>(pa) + 8, 8);
+                std::memcpy(&vb2, static_cast<const uint8_t*>(pb) + 8, 8);
+                return (va1 == vb1) && (va2 == vb2);
+            }
+
+            // Fallback para strings o arrays gigantes
+            return std::memcmp(pa, pb, sz) == 0;
         }
 
-        for (size_t i = N; i < OffCountA; ++i) { Out.operations.push_back({ DiffOperation::Remove, FlatFda.type, Path.Append(static_cast<int32_t>(i)) }); }
-        for (size_t i = N; i < OffCountB; ++i) { Out.operations.push_back({ DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i)) }); }
-    }
+        void DiffScalarArray(const TNodeView& A, const TNodeView& B, const FieldDesc& Fda, const FieldDesc& Fdb,
+                             const DiffOptions& Opt, PatchIndex& Out, const DiffIndexPath& Path) const {
+            auto full_bytes_a = A.GetFieldBytes(Fda);
+            auto full_bytes_b = B.GetFieldBytes(Fdb);
 
-    void DiffEncapsulatedArray(const TNodeView& ParentA, const TNodeView& ParentB, const FieldDesc& WrapperFda, const FieldDesc& WrapperFdb, const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const
-    {
-        auto wrap_a = ParentA.GetNestedStruct(WrapperFda);
-        auto wrap_b = ParentB.GetNestedStruct(WrapperFdb);
+            // Fast-path global (Idénticos al 100%)
+            if (!full_bytes_a.empty() && full_bytes_a.size() == full_bytes_b.size()) {
+                if (std::memcmp(full_bytes_a.data(), full_bytes_b.data(), full_bytes_a.size()) == 0)
+                    return;
+            }
 
-        if (!wrap_a.IsValid() && !wrap_b.IsValid()) return;
-        if (!wrap_a.IsValid() && wrap_b.IsValid()) { Out.operations.push_back({ DiffOperation::Add, WrapperFda.type, Path }); return; }
-        if (wrap_a.IsValid() && !wrap_b.IsValid()) { Out.operations.push_back({ DiffOperation::Remove, WrapperFda.type, Path }); return; }
+            const size_t size_a = A.GetArraySize(Fda);
+            const size_t size_b = B.GetArraySize(Fdb);
+            const size_t size = std::min(size_a, size_b);
 
-        FieldDesc field_desc; field_desc.name = "offsets";
-        FieldDesc data_desc; data_desc.name = "data"; 
+            int32_t current_range_start = -1;
+            int32_t current_range_count = 0;
 
-        bool b_is_recursive = (WrapperFda.type == EVTXContainerType::AnyStructArrays);
+            auto FlushRange = [&]() {
+                if (current_range_count > 0) {
+                    if (current_range_count == 1) {
+                        Out.operations.push_back({DiffOperation::Replace, Fda.type, Path.Append(current_range_start)});
+                    } else {
+                        DiffIndexOp op = {DiffOperation::ReplaceRange, Fda.type, Path.Append(current_range_start)};
+                        op.ReplaceRangeCount = current_range_count;
+                        Out.operations.push_back(op);
+                    }
+                    current_range_start = -1;
+                    current_range_count = 0;
+                }
+            };
+
+            bool is_contiguous = !full_bytes_a.empty() && !full_bytes_b.empty() && size_a > 0 && size_b > 0;
+
+            if (is_contiguous) {
+                const size_t stride_a = full_bytes_a.size() / size_a;
+                const size_t stride_b = full_bytes_b.size() / size_b;
+
+                if (stride_a == stride_b && stride_a > 0) {
+                    const uint8_t* ptr_a = reinterpret_cast<const uint8_t*>(full_bytes_a.data());
+                    const uint8_t* ptr_b = reinterpret_cast<const uint8_t*>(full_bytes_b.data());
+
+                    for (size_t i = 0; i < size; ++i) {
+                        bool bDifferent = false;
+
+                        if (Opt.compare_floats_with_epsilon) {
+                            if (stride_a == sizeof(float)) {
+                                float fa, fb;
+                                std::memcpy(&fa, ptr_a + (i * stride_a), sizeof(float));
+                                std::memcpy(&fb, ptr_b + (i * stride_b), sizeof(float));
+                                bDifferent = std::abs(fa - fb) > Opt.float_epsilon;
+                            } else if (stride_a == sizeof(double)) {
+                                double da, db;
+                                std::memcpy(&da, ptr_a + (i * stride_a), sizeof(double));
+                                std::memcpy(&db, ptr_b + (i * stride_b), sizeof(double));
+                                bDifferent = std::abs(da - db) > static_cast<double>(Opt.float_epsilon);
+                            } else {
+                                bDifferent =
+                                    (std::memcmp(ptr_a + (i * stride_a), ptr_b + (i * stride_b), stride_a) != 0);
+                            }
+                        } else {
+                            auto span_a = std::span<const std::byte>(
+                                reinterpret_cast<const std::byte*>(ptr_a + (i * stride_a)), stride_a);
+                            auto span_b = std::span<const std::byte>(
+                                reinterpret_cast<const std::byte*>(ptr_b + (i * stride_b)), stride_a);
+                            bDifferent = !FastSpanEqual(span_a, span_b);
+                        }
+
+                        if (bDifferent) {
+                            if (current_range_start == -1)
+                                current_range_start = static_cast<int32_t>(i);
+                            ++current_range_count;
+                        } else {
+                            FlushRange();
+                        }
+                    }
+                    FlushRange();
+                    goto EMIT_RESIZES; // Saltamos el bucle lento
+                }
+            }
+
+            for (size_t i = 0; i < size; ++i) {
+                auto bytes_a = A.GetArrayElementBytes(Fda, i);
+                auto bytes_b = B.GetArrayElementBytes(Fdb, i);
 
-        const size_t off_count_a = wrap_a.GetArraySize(field_desc);
-        const size_t off_count_b = wrap_b.GetArraySize(field_desc);
-        const size_t size = std::min(off_count_a, off_count_b);
+                if (bytes_a.empty() && bytes_b.empty()) {
+                    FlushRange();
+                    continue;
+                }
+
+                bool bDifferent = false;
+                if (Opt.compare_floats_with_epsilon && bytes_a.size() == bytes_b.size()) {
+                    if (bytes_a.size() == sizeof(float)) {
+                        float fa, fb;
+                        std::memcpy(&fa, bytes_a.data(), sizeof(float));
+                        std::memcpy(&fb, bytes_b.data(), sizeof(float));
+                        bDifferent = std::abs(fa - fb) > Opt.float_epsilon;
+                    } else if (bytes_a.size() == sizeof(double)) {
+                        double da, db;
+                        std::memcpy(&da, bytes_a.data(), sizeof(double));
+                        std::memcpy(&db, bytes_b.data(), sizeof(double));
+                        bDifferent = std::abs(da - db) > static_cast<double>(Opt.float_epsilon);
+                    } else {
+                        bDifferent = !FastSpanEqual(bytes_a, bytes_b);
+                    }
+                } else {
+                    bDifferent = !FastSpanEqual(bytes_a, bytes_b);
+                }
 
-        for (size_t i = 0; i < size; ++i) {
-            size_t start_a = 0, start_b = 0;
-            bool b_valid = true;
-            b_valid &= ReadOffsetAny(wrap_a.GetArrayElementBytes(field_desc, i), start_a);
-            b_valid &= ReadOffsetAny(wrap_b.GetArrayElementBytes(field_desc, i), start_b);
+                if (bDifferent) {
+                    if (current_range_start == -1)
+                        current_range_start = static_cast<int32_t>(i);
+                    ++current_range_count;
+                } else {
+                    FlushRange();
+                }
+            }
+            FlushRange();
 
-            if (!b_valid) {
-                Out.operations.push_back({ DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i)) });
-                continue;
+        EMIT_RESIZES:
+            for (size_t i = size; i < size_b; ++i) {
+                Out.operations.push_back({DiffOperation::Add, Fda.type, Path.Append(static_cast<int32_t>(i))});
             }
 
-            size_t end_a = wrap_a.GetArraySize(data_desc);
-            size_t end_b = wrap_b.GetArraySize(data_desc);
+            for (size_t i = size; i < size_a; ++i) {
+                Out.operations.push_back({DiffOperation::Remove, Fda.type, Path.Append(static_cast<int32_t>(i))});
+            }
+        }
 
-            if (i + 1 < off_count_a) { size_t Next = 0; if (ReadOffsetAny(wrap_a.GetArrayElementBytes(field_desc, i + 1), Next)) end_a = Next; }
-            if (i + 1 < off_count_b) { size_t Next = 0; if (ReadOffsetAny(wrap_b.GetArrayElementBytes(field_desc, i + 1), Next)) end_b = Next; }
+        void DiffStructArray(const TNodeView& A, const TNodeView& B, const FieldDesc& Fda, const FieldDesc& Fdb,
+                             const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const {
+            auto full_bytes_a = A.GetFieldBytes(Fda);
+            auto full_bytes_b = B.GetFieldBytes(Fdb);
 
-            if (end_a < start_a) end_a = start_a;
-            if (end_b < start_b) end_b = start_b;
+            if (!full_bytes_a.empty() && full_bytes_a.size() == full_bytes_b.size()) {
+                if (std::memcmp(full_bytes_a.data(), full_bytes_b.data(), full_bytes_a.size()) == 0)
+                    return;
+            }
 
-            const size_t len_a = end_a - start_a;
-            const size_t len_b = end_b - start_b;
+            const size_t size_a = A.GetArraySize(Fda);
+            const size_t size_b = B.GetArraySize(Fdb);
 
-            if (len_a != len_b) {
-                Out.operations.push_back({ DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i)) });
-                continue;
+            if (size_a != size_b) {
+                Out.operations.push_back({DiffOperation::Replace, Fda.type, Path});
+                return;
             }
 
-            bool b_changed = false;
-            if (b_is_recursive) {
-                for (size_t j = 0; j < len_a; ++j) {
-                    auto node_a = wrap_a.GetArrayElementAsStruct(data_desc, start_a + j);
-                    auto node_b = wrap_b.GetArrayElementAsStruct(data_desc, start_b + j);
-                    if (!node_a.IsValid() || !node_b.IsValid()) { b_changed = true; break; }
+            for (size_t i = 0; i < size_a; ++i) {
+                auto node_a = A.GetArrayElementAsStruct(Fda, i);
+                auto node_b = B.GetArrayElementAsStruct(Fdb, i);
+                Path.push_back(static_cast<int32_t>(i));
 
+                if (!node_a.IsValid() || !node_b.IsValid()) {
+                    Out.operations.push_back({DiffOperation::Replace, Fda.type, Path});
+                } else {
                     //use fast-path with content hash to omit identical structs
                     if (HaveMatchingContentHash(node_a, node_b)) {
                         //structs are identical, omit
                     } else {
-                        //we surely know something has changed, we can omit the full diff
-                        b_changed = true; 
-                        break;
+                        Diff(node_a, node_b, Opt, Path, Out);
                     }
                 }
-            } else {
-                auto block_a = wrap_a.GetSubArrayBytes(WrapperFda, i);
-                auto block_b = wrap_b.GetSubArrayBytes(WrapperFdb, i);
+                Path.pop_back();
+            }
+        }
+
+        void DiffFlatRepeatedByOffsets(const TNodeView& A, const TNodeView& B, const FieldDesc& FlatFda,
+                                       const FieldDesc& FlatFdb, const FieldDesc& OffFda, const FieldDesc& OffFdb,
+                                       const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const {
+            const size_t OffCountA = A.GetArraySize(OffFda);
+            const size_t OffCountB = B.GetArraySize(OffFdb);
+            const size_t N = std::min(OffCountA, OffCountB);
+
+            for (size_t i = 0; i < N; ++i) {
+                size_t StartA = 0, StartB = 0;
+                bool bValidOffsets = true;
+                bValidOffsets &= ReadOffsetU32(A.GetArrayElementBytes(OffFda, i), StartA);
+                bValidOffsets &= ReadOffsetU32(B.GetArrayElementBytes(OffFdb, i), StartB);
+
+                if (!bValidOffsets) {
+                    Out.operations.push_back(
+                        {DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i))});
+                    continue;
+                }
+
+                size_t EndA = A.GetArraySize(FlatFda);
+                size_t EndB = B.GetArraySize(FlatFdb);
+                if (i + 1 < OffCountA) {
+                    size_t Next = 0;
+                    if (ReadOffsetU32(A.GetArrayElementBytes(OffFda, i + 1), Next))
+                        EndA = Next;
+                }
+                if (i + 1 < OffCountB) {
+                    size_t Next = 0;
+                    if (ReadOffsetU32(B.GetArrayElementBytes(OffFdb, i + 1), Next))
+                        EndB = Next;
+                }
+
+                if (EndA < StartA)
+                    EndA = StartA;
+                if (EndB < StartB)
+                    EndB = StartB;
+
+                const size_t LenA = EndA - StartA;
+                const size_t LenB = EndB - StartB;
+
+                if (LenA != LenB) {
+                    Out.operations.push_back(
+                        {DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i))});
+                    continue;
+                }
+
+                bool bSubArrayChanged = false;
+                if (FlatFda.type == EVTXContainerType::AnyStructArrays) {
+                    for (size_t j = 0; j < LenA; ++j) {
+                        auto NodeElemA = A.GetArrayElementAsStruct(FlatFda, StartA + j);
+                        auto NodeElemB = B.GetArrayElementAsStruct(FlatFdb, StartB + j);
+                        if (!NodeElemA.IsValid() || !NodeElemB.IsValid()) {
+                            bSubArrayChanged = true;
+                            break;
+                        }
 
-                if (!block_a.empty() && block_a.size() == block_b.size()) {
-                    if (std::memcmp(block_a.data(), block_b.data(), block_a.size()) == 0) continue;
+                        size_t before = Out.operations.size();
+                        Diff(NodeElemA, NodeElemB, Opt, Path, Out);
+                        if (Out.operations.size() > before) {
+                            Out.operations.resize(before);
+                            bSubArrayChanged = true;
+                            break;
+                        }
+                    }
+                } else {
+                    for (size_t j = 0; j < LenA; ++j) {
+                        auto EA = A.GetArrayElementBytes(FlatFda, StartA + j);
+                        auto EB = B.GetArrayElementBytes(FlatFdb, StartB + j);
+                        if (!AreScalarsEqual(FlatFda.type, EA, EB, Opt)) {
+                            bSubArrayChanged = true;
+                            break;
+                        }
+                    }
                 }
 
-                for (size_t j = 0; j < len_a; ++j) {
-                    auto bytes_a = wrap_a.GetArrayElementBytes(data_desc, start_a + j);
-                    auto bytes_b = wrap_b.GetArrayElementBytes(data_desc, start_b + j);
-                    if (!AreScalarsEqual(WrapperFda.type, bytes_a, bytes_b, Opt)) { b_changed = true; break; }
+                if (bSubArrayChanged) {
+                    Out.operations.push_back(
+                        {DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i))});
                 }
             }
 
-            if (b_changed) {
-                Out.operations.push_back({ DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i)) });
+            for (size_t i = N; i < OffCountA; ++i) {
+                Out.operations.push_back({DiffOperation::Remove, FlatFda.type, Path.Append(static_cast<int32_t>(i))});
+            }
+            for (size_t i = N; i < OffCountB; ++i) {
+                Out.operations.push_back({DiffOperation::Replace, FlatFda.type, Path.Append(static_cast<int32_t>(i))});
             }
         }
 
-        for (size_t i = size; i < off_count_a; ++i) { Out.operations.push_back({ DiffOperation::Remove, WrapperFda.type, Path.Append(static_cast<int32_t>(i)) }); }
-        for (size_t i = size; i < off_count_b; ++i) { Out.operations.push_back({ DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i)) }); }
-    }
+        void DiffEncapsulatedArray(const TNodeView& ParentA, const TNodeView& ParentB, const FieldDesc& WrapperFda,
+                                   const FieldDesc& WrapperFdb, const DiffOptions& Opt, PatchIndex& Out,
+                                   DiffIndexPath& Path) const {
+            auto wrap_a = ParentA.GetNestedStruct(WrapperFda);
+            auto wrap_b = ParentB.GetNestedStruct(WrapperFdb);
+
+            if (!wrap_a.IsValid() && !wrap_b.IsValid())
+                return;
+            if (!wrap_a.IsValid() && wrap_b.IsValid()) {
+                Out.operations.push_back({DiffOperation::Add, WrapperFda.type, Path});
+                return;
+            }
+            if (wrap_a.IsValid() && !wrap_b.IsValid()) {
+                Out.operations.push_back({DiffOperation::Remove, WrapperFda.type, Path});
+                return;
+            }
 
-    void DiffMapContainers(const TNodeView& A, const TNodeView& B, const FieldDesc& Fda, const FieldDesc& Fdb, const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const
-    {
-        const size_t size_a = A.GetMapSize(Fda);
-        const size_t size_b = B.GetMapSize(Fdb);
-        if (size_a == 0 && size_b == 0) return;
-        
-        ScratchMapA.clear(); ScratchMapB.clear();
-        for (size_t i = 0; i < size_a; ++i) {
-            std::string k = A.GetMapKey(Fda, i);
-            ScratchMapA.push_back({StableHash64(k), std::move(k), i});
-        }
-        for (size_t i = 0; i < size_b; ++i) {
-            std::string k = B.GetMapKey(Fdb, i);
-            ScratchMapB.push_back({StableHash64(k), std::move(k), i});
-        }
+            FieldDesc field_desc;
+            field_desc.name = "offsets";
+            FieldDesc data_desc;
+            data_desc.name = "data";
 
-        std::sort(ScratchMapA.begin(), ScratchMapA.end(), [](const auto& a, const auto& b){ return a.Hash < b.Hash; });
-        std::sort(ScratchMapB.begin(), ScratchMapB.end(), [](const auto& a, const auto& b){ return a.Hash < b.Hash; });
+            bool b_is_recursive = (WrapperFda.type == EVTXContainerType::AnyStructArrays);
 
-        size_t idx_a = 0, idx_b = 0;
-        while(idx_a < ScratchMapA.size() || idx_b < ScratchMapB.size()) {
-            if (idx_a < ScratchMapA.size() && (idx_b == ScratchMapB.size() || ScratchMapA[idx_a].Hash < ScratchMapB[idx_b].Hash)) {
-                Path.push_back(HashToPathKey(ScratchMapA[idx_a].Hash));
-                Out.operations.push_back({ DiffOperation::Remove, Fda.type, Path, {}, ScratchMapA[idx_a].Key });
-                Path.pop_back();
-                idx_a++;
-            }
-            else if (idx_b < ScratchMapB.size() && (idx_a == ScratchMapA.size() || ScratchMapB[idx_b].Hash < ScratchMapA[idx_a].Hash)) {
-                Path.push_back(HashToPathKey(ScratchMapB[idx_b].Hash));
-                Out.operations.push_back({ DiffOperation::Add, Fda.type, Path, {}, ScratchMapB[idx_b].Key });
-                Path.pop_back();
-                idx_b++;
-            }
-            else {
-                if (ScratchMapA[idx_a].Key == ScratchMapB[idx_b].Key) {
-                    auto node_a = A.GetMapValueAsStruct(Fda, ScratchMapA[idx_a].Index);
-                    auto node_b = B.GetMapValueAsStruct(Fdb, ScratchMapB[idx_b].Index);
-                    if (node_a.IsValid() && node_b.IsValid()) {
+            const size_t off_count_a = wrap_a.GetArraySize(field_desc);
+            const size_t off_count_b = wrap_b.GetArraySize(field_desc);
+            const size_t size = std::min(off_count_a, off_count_b);
+
+            for (size_t i = 0; i < size; ++i) {
+                size_t start_a = 0, start_b = 0;
+                bool b_valid = true;
+                b_valid &= ReadOffsetAny(wrap_a.GetArrayElementBytes(field_desc, i), start_a);
+                b_valid &= ReadOffsetAny(wrap_b.GetArrayElementBytes(field_desc, i), start_b);
+
+                if (!b_valid) {
+                    Out.operations.push_back(
+                        {DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i))});
+                    continue;
+                }
+
+                size_t end_a = wrap_a.GetArraySize(data_desc);
+                size_t end_b = wrap_b.GetArraySize(data_desc);
+
+                if (i + 1 < off_count_a) {
+                    size_t Next = 0;
+                    if (ReadOffsetAny(wrap_a.GetArrayElementBytes(field_desc, i + 1), Next))
+                        end_a = Next;
+                }
+                if (i + 1 < off_count_b) {
+                    size_t Next = 0;
+                    if (ReadOffsetAny(wrap_b.GetArrayElementBytes(field_desc, i + 1), Next))
+                        end_b = Next;
+                }
+
+                if (end_a < start_a)
+                    end_a = start_a;
+                if (end_b < start_b)
+                    end_b = start_b;
+
+                const size_t len_a = end_a - start_a;
+                const size_t len_b = end_b - start_b;
+
+                if (len_a != len_b) {
+                    Out.operations.push_back(
+                        {DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i))});
+                    continue;
+                }
+
+                bool b_changed = false;
+                if (b_is_recursive) {
+                    for (size_t j = 0; j < len_a; ++j) {
+                        auto node_a = wrap_a.GetArrayElementAsStruct(data_desc, start_a + j);
+                        auto node_b = wrap_b.GetArrayElementAsStruct(data_desc, start_b + j);
+                        if (!node_a.IsValid() || !node_b.IsValid()) {
+                            b_changed = true;
+                            break;
+                        }
+
+                        //use fast-path with content hash to omit identical structs
                         if (HaveMatchingContentHash(node_a, node_b)) {
                             //structs are identical, omit
                         } else {
-                            Path.push_back(HashToPathKey(ScratchMapA[idx_a].Hash));
-                            const size_t OpCountBefore = Out.operations.size();
-                            Diff(node_a, node_b, Opt, Path, Out);
-                            for (size_t OpIdx = OpCountBefore; OpIdx < Out.operations.size(); ++OpIdx) {
-                                Out.operations[OpIdx].MapKey = ScratchMapA[idx_a].Key;
-                            }
-                            Path.pop_back();
+                            //we surely know something has changed, we can omit the full diff
+                            b_changed = true;
+                            break;
                         }
                     }
                 } else {
+                    auto block_a = wrap_a.GetSubArrayBytes(WrapperFda, i);
+                    auto block_b = wrap_b.GetSubArrayBytes(WrapperFdb, i);
+
+                    if (!block_a.empty() && block_a.size() == block_b.size()) {
+                        if (std::memcmp(block_a.data(), block_b.data(), block_a.size()) == 0)
+                            continue;
+                    }
+
+                    for (size_t j = 0; j < len_a; ++j) {
+                        auto bytes_a = wrap_a.GetArrayElementBytes(data_desc, start_a + j);
+                        auto bytes_b = wrap_b.GetArrayElementBytes(data_desc, start_b + j);
+                        if (!AreScalarsEqual(WrapperFda.type, bytes_a, bytes_b, Opt)) {
+                            b_changed = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (b_changed) {
+                    Out.operations.push_back(
+                        {DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i))});
+                }
+            }
+
+            for (size_t i = size; i < off_count_a; ++i) {
+                Out.operations.push_back(
+                    {DiffOperation::Remove, WrapperFda.type, Path.Append(static_cast<int32_t>(i))});
+            }
+            for (size_t i = size; i < off_count_b; ++i) {
+                Out.operations.push_back(
+                    {DiffOperation::Replace, WrapperFda.type, Path.Append(static_cast<int32_t>(i))});
+            }
+        }
+
+        void DiffMapContainers(const TNodeView& A, const TNodeView& B, const FieldDesc& Fda, const FieldDesc& Fdb,
+                               const DiffOptions& Opt, PatchIndex& Out, DiffIndexPath& Path) const {
+            const size_t size_a = A.GetMapSize(Fda);
+            const size_t size_b = B.GetMapSize(Fdb);
+            if (size_a == 0 && size_b == 0)
+                return;
+
+            ScratchMapA.clear();
+            ScratchMapB.clear();
+            for (size_t i = 0; i < size_a; ++i) {
+                std::string k = A.GetMapKey(Fda, i);
+                ScratchMapA.push_back({StableHash64(k), std::move(k), i});
+            }
+            for (size_t i = 0; i < size_b; ++i) {
+                std::string k = B.GetMapKey(Fdb, i);
+                ScratchMapB.push_back({StableHash64(k), std::move(k), i});
+            }
+
+            std::sort(ScratchMapA.begin(), ScratchMapA.end(),
+                      [](const auto& a, const auto& b) { return a.Hash < b.Hash; });
+            std::sort(ScratchMapB.begin(), ScratchMapB.end(),
+                      [](const auto& a, const auto& b) { return a.Hash < b.Hash; });
+
+            size_t idx_a = 0, idx_b = 0;
+            while (idx_a < ScratchMapA.size() || idx_b < ScratchMapB.size()) {
+                if (idx_a < ScratchMapA.size() &&
+                    (idx_b == ScratchMapB.size() || ScratchMapA[idx_a].Hash < ScratchMapB[idx_b].Hash)) {
                     Path.push_back(HashToPathKey(ScratchMapA[idx_a].Hash));
-                    Out.operations.push_back({ DiffOperation::Remove, Fda.type, Path, {}, ScratchMapA[idx_a].Key });
+                    Out.operations.push_back({DiffOperation::Remove, Fda.type, Path, {}, ScratchMapA[idx_a].Key});
                     Path.pop_back();
-                    
+                    idx_a++;
+                } else if (idx_b < ScratchMapB.size() &&
+                           (idx_a == ScratchMapA.size() || ScratchMapB[idx_b].Hash < ScratchMapA[idx_a].Hash)) {
                     Path.push_back(HashToPathKey(ScratchMapB[idx_b].Hash));
-                    Out.operations.push_back({ DiffOperation::Add, Fda.type, Path, {}, ScratchMapB[idx_b].Key });
+                    Out.operations.push_back({DiffOperation::Add, Fda.type, Path, {}, ScratchMapB[idx_b].Key});
                     Path.pop_back();
+                    idx_b++;
+                } else {
+                    if (ScratchMapA[idx_a].Key == ScratchMapB[idx_b].Key) {
+                        auto node_a = A.GetMapValueAsStruct(Fda, ScratchMapA[idx_a].Index);
+                        auto node_b = B.GetMapValueAsStruct(Fdb, ScratchMapB[idx_b].Index);
+                        if (node_a.IsValid() && node_b.IsValid()) {
+                            if (HaveMatchingContentHash(node_a, node_b)) {
+                                //structs are identical, omit
+                            } else {
+                                Path.push_back(HashToPathKey(ScratchMapA[idx_a].Hash));
+                                const size_t OpCountBefore = Out.operations.size();
+                                Diff(node_a, node_b, Opt, Path, Out);
+                                for (size_t OpIdx = OpCountBefore; OpIdx < Out.operations.size(); ++OpIdx) {
+                                    Out.operations[OpIdx].MapKey = ScratchMapA[idx_a].Key;
+                                }
+                                Path.pop_back();
+                            }
+                        }
+                    } else {
+                        Path.push_back(HashToPathKey(ScratchMapA[idx_a].Hash));
+                        Out.operations.push_back({DiffOperation::Remove, Fda.type, Path, {}, ScratchMapA[idx_a].Key});
+                        Path.pop_back();
+
+                        Path.push_back(HashToPathKey(ScratchMapB[idx_b].Hash));
+                        Out.operations.push_back({DiffOperation::Add, Fda.type, Path, {}, ScratchMapB[idx_b].Key});
+                        Path.pop_back();
+                    }
+                    idx_a++;
+                    idx_b++;
                 }
-                idx_a++; idx_b++;
             }
         }
-    }
-};
+    };
 
 } // namespace VtxDiff
diff --git a/sdk/include/vtx/differ/core/vtx_diff_types.h b/sdk/include/vtx/differ/core/vtx_diff_types.h
index c9b8f88..6bd48eb 100644
--- a/sdk/include/vtx/differ/core/vtx_diff_types.h
+++ b/sdk/include/vtx/differ/core/vtx_diff_types.h
@@ -19,14 +19,7 @@ namespace VtxDiff {
     // Represents the binary serialization technology used for
     // reading/writing structured binary data (Protobuf, FlatBuffers, etc.).
     // ==========================================================
-    enum class WireFormat : uint8_t
-    {
-        None = 0,
-        Archive,
-        Flatbuffers,
-        Protobuf,
-        MAX
-    };
+    enum class WireFormat : uint8_t { None = 0, Archive, Flatbuffers, Protobuf, MAX };
 
     // ==========================================================
     // Enum: DiffAlgorithmType
@@ -34,8 +27,8 @@ namespace VtxDiff {
     // Identifies which diff algorithm implementation to use.
     // ==========================================================
     enum class DiffAlgorithmType : uint8_t {
-        Default = 0,     // Tree-based recursive diff
-        Experimental,    // Placeholder for testing new ones
+        Default = 0,  // Tree-based recursive diff
+        Experimental, // Placeholder for testing new ones
         MAX
     };
 
@@ -46,104 +39,130 @@ namespace VtxDiff {
     enum class EVTXContainerType : uint8_t {
         Unknown = 0,
 
-        BoolProperties,       // 1
-        Int32Properties,      // 2
-        Int64Properties,      // 3
-        FloatProperties,      // 4
-        DoubleProperties,     // 5
-        StringProperties,     // 6
-        TransformProperties,  // 7
-        VectorProperties,     // 8
-        QuatProperties,       // 9
-        RangeProperties,      // 10
-
-        ByteArrayProperties,  // 11 (reaplce  UInt8Arrays/Int8Arrays)
-        Int32Arrays,          // 12
-        Int64Arrays,          // 13
-        FloatArrays,          // 14
-        DoubleArrays,         // 15
-        StringArrays,         // 16
-        TransformArrays,      // 17
-        VectorArrays,         // 18
-        QuatArrays,           // 19
-        RangeArrays,          // 20
-        BoolArrays,           // 21
-
-        AnyStructProperties,  // 22
-        AnyStructArrays,      // 23
-        MapProperties,        // 24
-        MapArrays             // 25
+        BoolProperties,      // 1
+        Int32Properties,     // 2
+        Int64Properties,     // 3
+        FloatProperties,     // 4
+        DoubleProperties,    // 5
+        StringProperties,    // 6
+        TransformProperties, // 7
+        VectorProperties,    // 8
+        QuatProperties,      // 9
+        RangeProperties,     // 10
+
+        ByteArrayProperties, // 11 (reaplce  UInt8Arrays/Int8Arrays)
+        Int32Arrays,         // 12
+        Int64Arrays,         // 13
+        FloatArrays,         // 14
+        DoubleArrays,        // 15
+        StringArrays,        // 16
+        TransformArrays,     // 17
+        VectorArrays,        // 18
+        QuatArrays,          // 19
+        RangeArrays,         // 20
+        BoolArrays,          // 21
+
+        AnyStructProperties, // 22
+        AnyStructArrays,     // 23
+        MapProperties,       // 24
+        MapArrays            // 25
     };
-    
+
     static std::string TypeToFieldName(VtxDiff::EVTXContainerType Type) {
-    switch (Type) {
-        case VtxDiff::EVTXContainerType::Unknown:              return "Unknown";
-
-        case VtxDiff::EVTXContainerType::BoolProperties:       return "bool_properties";
-        case VtxDiff::EVTXContainerType::Int32Properties:      return "int32_properties";
-        case VtxDiff::EVTXContainerType::Int64Properties:      return "int64_properties";
-        case VtxDiff::EVTXContainerType::FloatProperties:      return "float_properties";
-        case VtxDiff::EVTXContainerType::DoubleProperties:     return "double_properties";
-        case VtxDiff::EVTXContainerType::StringProperties:     return "string_properties";
-        case VtxDiff::EVTXContainerType::TransformProperties:  return "transform_properties";
-        case VtxDiff::EVTXContainerType::VectorProperties:     return "vector_properties";
-        case VtxDiff::EVTXContainerType::QuatProperties:       return "quat_properties";
-        case VtxDiff::EVTXContainerType::RangeProperties:      return "range_properties";
-
-        case VtxDiff::EVTXContainerType::ByteArrayProperties:  return "byte_array_properties";
-        case VtxDiff::EVTXContainerType::Int32Arrays:          return "int32_arrays";
-        case VtxDiff::EVTXContainerType::Int64Arrays:          return "int64_arrays";
-        case VtxDiff::EVTXContainerType::FloatArrays:          return "float_arrays";
-        case VtxDiff::EVTXContainerType::DoubleArrays:         return "double_arrays";
-        case VtxDiff::EVTXContainerType::StringArrays:         return "string_arrays";
-        case VtxDiff::EVTXContainerType::TransformArrays:      return "transform_arrays";
-        case VtxDiff::EVTXContainerType::VectorArrays:         return "vector_arrays";
-        case VtxDiff::EVTXContainerType::QuatArrays:           return "quat_arrays";
-        case VtxDiff::EVTXContainerType::RangeArrays:          return "range_arrays";
-        case VtxDiff::EVTXContainerType::BoolArrays:           return "bool_arrays";
-
-        case VtxDiff::EVTXContainerType::AnyStructProperties:  return "any_struct_properties";
-        case VtxDiff::EVTXContainerType::AnyStructArrays:      return "any_struct_arrays";
-        case VtxDiff::EVTXContainerType::MapProperties:        return "map_properties";
-        case VtxDiff::EVTXContainerType::MapArrays:            return "map_arrays";
-
-        default: return "";
+        switch (Type) {
+        case VtxDiff::EVTXContainerType::Unknown:
+            return "Unknown";
+
+        case VtxDiff::EVTXContainerType::BoolProperties:
+            return "bool_properties";
+        case VtxDiff::EVTXContainerType::Int32Properties:
+            return "int32_properties";
+        case VtxDiff::EVTXContainerType::Int64Properties:
+            return "int64_properties";
+        case VtxDiff::EVTXContainerType::FloatProperties:
+            return "float_properties";
+        case VtxDiff::EVTXContainerType::DoubleProperties:
+            return "double_properties";
+        case VtxDiff::EVTXContainerType::StringProperties:
+            return "string_properties";
+        case VtxDiff::EVTXContainerType::TransformProperties:
+            return "transform_properties";
+        case VtxDiff::EVTXContainerType::VectorProperties:
+            return "vector_properties";
+        case VtxDiff::EVTXContainerType::QuatProperties:
+            return "quat_properties";
+        case VtxDiff::EVTXContainerType::RangeProperties:
+            return "range_properties";
+
+        case VtxDiff::EVTXContainerType::ByteArrayProperties:
+            return "byte_array_properties";
+        case VtxDiff::EVTXContainerType::Int32Arrays:
+            return "int32_arrays";
+        case VtxDiff::EVTXContainerType::Int64Arrays:
+            return "int64_arrays";
+        case VtxDiff::EVTXContainerType::FloatArrays:
+            return "float_arrays";
+        case VtxDiff::EVTXContainerType::DoubleArrays:
+            return "double_arrays";
+        case VtxDiff::EVTXContainerType::StringArrays:
+            return "string_arrays";
+        case VtxDiff::EVTXContainerType::TransformArrays:
+            return "transform_arrays";
+        case VtxDiff::EVTXContainerType::VectorArrays:
+            return "vector_arrays";
+        case VtxDiff::EVTXContainerType::QuatArrays:
+            return "quat_arrays";
+        case VtxDiff::EVTXContainerType::RangeArrays:
+            return "range_arrays";
+        case VtxDiff::EVTXContainerType::BoolArrays:
+            return "bool_arrays";
+
+        case VtxDiff::EVTXContainerType::AnyStructProperties:
+            return "any_struct_properties";
+        case VtxDiff::EVTXContainerType::AnyStructArrays:
+            return "any_struct_arrays";
+        case VtxDiff::EVTXContainerType::MapProperties:
+            return "map_properties";
+        case VtxDiff::EVTXContainerType::MapArrays:
+            return "map_arrays";
+
+        default:
+            return "";
+        }
     }
-}
 
     // ==========================================================
     // Enum: DiffOperation
     // ----------------------------------------------------------
     // Represents one kind of change in a diff result.
     // ==========================================================
-    enum class DiffOperation : uint8_t {
-        Add,
-        Remove,
-        Replace,
-        ReplaceRange
-    };
+    enum class DiffOperation : uint8_t { Add, Remove, Replace, ReplaceRange };
 
-    
-    struct EnumHash
-    {
+
+    struct EnumHash {
         template <class T>
-        size_t operator()(T v) const noexcept { return static_cast<size_t>(v); }
+        size_t operator()(T v) const noexcept {
+            return static_cast<size_t>(v);
+        }
     };
 
 
     // ===========================================================
     // Binary path (no strings)
     // ===========================================================
-    struct DiffIndexPath
-    {
+    struct DiffIndexPath {
         int32_t indices[16];
         uint8_t count = 0;
 
         void push_back(int32_t v) {
-            if (count < 16) { indices[count++] = v; }
+            if (count < 16) {
+                indices[count++] = v;
+            }
         }
         void pop_back() {
-            if (count > 0) { count--; }
+            if (count > 0) {
+                count--;
+            }
         }
         DiffIndexPath Append(int32_t Index) const {
             DiffIndexPath p = *this;
@@ -151,17 +170,17 @@ namespace VtxDiff {
             return p;
         }
         bool IsEmpty() const { return count == 0; }
-        
+
         size_t size() const { return count; }
         int32_t operator[](size_t i) const { return indices[i]; }
         bool operator==(const DiffIndexPath& o) const {
-            if (count != o.count) return false;
+            if (count != o.count)
+                return false;
             return std::memcmp(indices, o.indices, count * sizeof(int32_t)) == 0;
         }
     };
 
-    struct DiffIndexOp
-    {
+    struct DiffIndexOp {
         DiffOperation Operation;
         EVTXContainerType ContainerType;
         DiffIndexPath Path;
@@ -173,8 +192,7 @@ namespace VtxDiff {
     // ===========================================================
     // Patch container
     // ===========================================================
-    struct PatchIndex
-    {
+    struct PatchIndex {
         std::vector<DiffIndexOp> operations;
         std::unordered_map<int32_t, std::string> actor_id_by_key;
 
@@ -188,11 +206,11 @@ namespace VtxDiff {
     // ==========================================================
     struct FieldDesc {
         std::string name;
-        EVTXContainerType type{ EVTXContainerType::Int32Properties };
-        bool is_array_like{ false };
+        EVTXContainerType type {EVTXContainerType::Int32Properties};
+        bool is_array_like {false};
         bool is_actors_field = false;
-        bool is_map_like{ false };
-        uint32_t array_size{0};
+        bool is_map_like {false};
+        uint32_t array_size {0};
         auto operator<=>(const FieldDesc&) const = default;
     };
 
@@ -202,12 +220,12 @@ namespace VtxDiff {
     // Represents a single patch operation (add/remove/replace).
     // ==========================================================
     struct PatchOp {
-        DiffOperation Operation{ DiffOperation::Replace };
+        DiffOperation Operation {DiffOperation::Replace};
         std::string Path;
-        EVTXContainerType FieldType{ EVTXContainerType::Int32Properties };
+        EVTXContainerType FieldType {EVTXContainerType::Int32Properties};
         std::vector<std::byte> Data;
     };
-        
+
     // ==========================================================
     // Struct: DiffOptions
     // ----------------------------------------------------------
@@ -215,14 +233,12 @@ namespace VtxDiff {
     // and comparison behavior.
     // ==========================================================
     struct DiffOptions {
-        bool compare_floats_with_epsilon{ true };
-        float float_epsilon{ 1e-5f };
-        bool verbose{ false };
+        bool compare_floats_with_epsilon {true};
+        float float_epsilon {1e-5f};
+        bool verbose {false};
     };
 
 
-
-        
     // ==========================================================
     // Struct: PathS
     // ----------------------------------------------------------
@@ -268,16 +284,17 @@ namespace VtxDiff {
             return OSS.str();
         }
     };
-        
+
     // ==========================================================
     // Utility helpers for path building and byte copying.
     // ==========================================================
     inline std::vector<std::byte> CopyBytes(std::span<const std::byte> data) {
-        return { data.begin(), data.end() };
+        return {data.begin(), data.end()};
     }
 
     inline std::string MakeFieldPath(const std::string& base, const std::string& field_name) {
-        if (base.empty()) return field_name;
+        if (base.empty())
+            return field_name;
         return base + "." + field_name;
     }
 
@@ -289,10 +306,8 @@ namespace VtxDiff {
         return base + "{" + key + "}";
     }
 
-    inline constexpr bool IsArraysType(EVTXContainerType type)
-    {
-        switch (type)
-        {
+    inline constexpr bool IsArraysType(EVTXContainerType type) {
+        switch (type) {
         case EVTXContainerType::ByteArrayProperties:
         case EVTXContainerType::Int32Arrays:
         case EVTXContainerType::Int64Arrays:
@@ -313,66 +328,68 @@ namespace VtxDiff {
     }
 
 
-    static bool EndsWith(const std::string& s, const char* suffix)
-    {
+    static bool EndsWith(const std::string& s, const char* suffix) {
         const size_t n = s.size();
         const size_t m = std::strlen(suffix);
-        if (n < m) return false;
+        if (n < m)
+            return false;
         return std::memcmp(s.data() + (n - m), suffix, m) == 0;
     }
 
 
-
-    static bool AreScalarsEqual(VtxDiff::EVTXContainerType type, std::span<const std::byte> A, std::span<const std::byte> B, const VtxDiff::DiffOptions& Opt)
-    {
+    static bool AreScalarsEqual(VtxDiff::EVTXContainerType type, std::span<const std::byte> A,
+                                std::span<const std::byte> B, const VtxDiff::DiffOptions& Opt) {
         if (!Opt.compare_floats_with_epsilon)
             return std::memcmp(A.data(), B.data(), A.size()) == 0;
 
-        auto IsNear = [&](float a, float b) { return std::abs(a - b) <= Opt.float_epsilon; };
+        auto IsNear = [&](float a, float b) {
+            return std::abs(a - b) <= Opt.float_epsilon;
+        };
 
         switch (type) {
-            case VtxDiff::EVTXContainerType::FloatArrays:
-            case VtxDiff::EVTXContainerType::FloatProperties:
-            {
-                float fa, fb;
-                std::memcpy(&fa, A.data(), sizeof(float));
-                std::memcpy(&fb, B.data(), sizeof(float));
-                return IsNear(fa, fb);
-            }
+        case VtxDiff::EVTXContainerType::FloatArrays:
+        case VtxDiff::EVTXContainerType::FloatProperties: {
+            float fa, fb;
+            std::memcpy(&fa, A.data(), sizeof(float));
+            std::memcpy(&fb, B.data(), sizeof(float));
+            return IsNear(fa, fb);
+        }
 
 
-            case VtxDiff::EVTXContainerType::VectorArrays:
-            case VtxDiff::EVTXContainerType::VectorProperties:
-            {
-                if (A.size() < sizeof(float) * 3) return false;
-                const float* va = reinterpret_cast<const float*>(A.data());
-                const float* vb = reinterpret_cast<const float*>(B.data());
-                return IsNear(va[0], vb[0]) && IsNear(va[1], vb[1]) && IsNear(va[2], vb[2]);
-            }
+        case VtxDiff::EVTXContainerType::VectorArrays:
+        case VtxDiff::EVTXContainerType::VectorProperties: {
+            if (A.size() < sizeof(float) * 3)
+                return false;
+            const float* va = reinterpret_cast<const float*>(A.data());
+            const float* vb = reinterpret_cast<const float*>(B.data());
+            return IsNear(va[0], vb[0]) && IsNear(va[1], vb[1]) && IsNear(va[2], vb[2]);
+        }
 
 
-            case VtxDiff::EVTXContainerType::QuatArrays:
-            case VtxDiff::EVTXContainerType::QuatProperties:
-            {
-                if (A.size() < sizeof(float) * 4) return false;
-                const float* qa = reinterpret_cast<const float*>(A.data());
-                const float* qb = reinterpret_cast<const float*>(B.data());
-                return IsNear(qa[0], qb[0]) && IsNear(qa[1], qb[1]) && IsNear(qa[2], qb[2]) && IsNear(qa[3], qb[3]);
-            }
+        case VtxDiff::EVTXContainerType::QuatArrays:
+        case VtxDiff::EVTXContainerType::QuatProperties: {
+            if (A.size() < sizeof(float) * 4)
+                return false;
+            const float* qa = reinterpret_cast<const float*>(A.data());
+            const float* qb = reinterpret_cast<const float*>(B.data());
+            return IsNear(qa[0], qb[0]) && IsNear(qa[1], qb[1]) && IsNear(qa[2], qb[2]) && IsNear(qa[3], qb[3]);
+        }
 
-            case VtxDiff::EVTXContainerType::TransformArrays:
-            case VtxDiff::EVTXContainerType::TransformProperties:
-            {
-                if (A.size() < sizeof(float) * 10) return false;
-                const float* ta = reinterpret_cast<const float*>(A.data());
-                const float* tb = reinterpret_cast<const float*>(B.data());
-                for (int k = 0; k < 10; ++k) if (!IsNear(ta[k], tb[k])) return false;
-                return true;
-            }
-        default: ;
+        case VtxDiff::EVTXContainerType::TransformArrays:
+        case VtxDiff::EVTXContainerType::TransformProperties: {
+            if (A.size() < sizeof(float) * 10)
+                return false;
+            const float* ta = reinterpret_cast<const float*>(A.data());
+            const float* tb = reinterpret_cast<const float*>(B.data());
+            for (int k = 0; k < 10; ++k)
+                if (!IsNear(ta[k], tb[k]))
+                    return false;
+            return true;
+        }
+        default:;
         }
         return std::memcmp(A.data(), B.data(), A.size()) == 0;
     }
 
-    
+
 } // namespace VtxDiff
diff --git a/sdk/include/vtx/differ/core/vtx_diff_validator.h b/sdk/include/vtx/differ/core/vtx_diff_validator.h
index 36202fd..35be602 100644
--- a/sdk/include/vtx/differ/core/vtx_diff_validator.h
+++ b/sdk/include/vtx/differ/core/vtx_diff_validator.h
@@ -15,207 +15,216 @@
 
 namespace VtxDiff {
 
-inline uint64_t StableHash64(std::string_view s);
-
-template <typename TNodeView>
-requires CBinaryNodeView<TNodeView>
-class DiffValidator {
-public:
-    static bool ValidatePatch(const TNodeView& NodeA,
-                              const TNodeView& NodeB,
-                              const PatchIndex& Patch,
-                              const DiffOptions& Opt)
-    {
-        std::cout << "\n[VALIDATOR] Starting Patch Validator...\n";
-        bool allValid = true;
-        int checkedOps = 0;
-
-        for (const auto& Op : Patch.operations) {
-            const bool existsA = PatchAccessor<TNodeView>::Exists(NodeA, Op);
-            const bool existsB = PatchAccessor<TNodeView>::Exists(NodeB, Op);
-            const auto bytesA = PatchAccessor<TNodeView>::GetRawBytes(NodeA, Op);
-            const auto bytesB = PatchAccessor<TNodeView>::GetRawBytes(NodeB, Op);
-
-            switch (Op.Operation) {
-            case DiffOperation::Replace:
-                if (!existsA || !existsB) {
-                    std::cerr << "[FAIL] Replace on missing data. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                } else if (bytesA.empty() || bytesB.empty()) {
-                    std::cerr << "[FAIL] Replace without readable bytes. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                } else if (AreBytesEqual(bytesA, bytesB, Opt)) {
-                    std::cerr << "[FAIL] False positive replace. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
+    inline uint64_t StableHash64(std::string_view s);
+
+    template <typename TNodeView>
+        requires CBinaryNodeView<TNodeView>
+    class DiffValidator {
+    public:
+        static bool ValidatePatch(const TNodeView& NodeA, const TNodeView& NodeB, const PatchIndex& Patch,
+                                  const DiffOptions& Opt) {
+            std::cout << "\n[VALIDATOR] Starting Patch Validator...\n";
+            bool allValid = true;
+            int checkedOps = 0;
+
+            for (const auto& Op : Patch.operations) {
+                const bool existsA = PatchAccessor<TNodeView>::Exists(NodeA, Op);
+                const bool existsB = PatchAccessor<TNodeView>::Exists(NodeB, Op);
+                const auto bytesA = PatchAccessor<TNodeView>::GetRawBytes(NodeA, Op);
+                const auto bytesB = PatchAccessor<TNodeView>::GetRawBytes(NodeB, Op);
+
+                switch (Op.Operation) {
+                case DiffOperation::Replace:
+                    if (!existsA || !existsB) {
+                        std::cerr << "[FAIL] Replace on missing data. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    } else if (bytesA.empty() || bytesB.empty()) {
+                        std::cerr << "[FAIL] Replace without readable bytes. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    } else if (AreBytesEqual(bytesA, bytesB, Opt)) {
+                        std::cerr << "[FAIL] False positive replace. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    }
+                    break;
+
+                case DiffOperation::ReplaceRange:
+                    if (!existsA || !existsB) {
+                        std::cerr << "[FAIL] ReplaceRange on missing data. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    } else if (bytesA.empty() || bytesB.empty()) {
+                        std::cerr << "[FAIL] ReplaceRange without readable bytes. Path: " << DecodePath(Patch, Op)
+                                  << "\n";
+                        allValid = false;
+                    } else if (AreBytesEqual(bytesA, bytesB, Opt)) {
+                        std::cerr << "[FAIL] False positive replace range. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    }
+                    break;
+
+                case DiffOperation::Add:
+                    if (existsA) {
+                        std::cerr << "[FAIL] Add op but node already exists in A. Path: " << DecodePath(Patch, Op)
+                                  << "\n";
+                        allValid = false;
+                    }
+                    if (!existsB) {
+                        std::cerr << "[FAIL] Add op but node missing in B. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    }
+                    break;
+
+                case DiffOperation::Remove:
+                    if (!existsA) {
+                        std::cerr << "[FAIL] Remove op but node missing in A. Path: " << DecodePath(Patch, Op) << "\n";
+                        allValid = false;
+                    }
+                    if (existsB) {
+                        std::cerr << "[FAIL] Remove op but node still exists in B. Path: " << DecodePath(Patch, Op)
+                                  << "\n";
+                        allValid = false;
+                    }
+                    break;
                 }
-                break;
-
-            case DiffOperation::ReplaceRange:
-                if (!existsA || !existsB) {
-                    std::cerr << "[FAIL] ReplaceRange on missing data. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                } else if (bytesA.empty() || bytesB.empty()) {
-                    std::cerr << "[FAIL] ReplaceRange without readable bytes. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                } else if (AreBytesEqual(bytesA, bytesB, Opt)) {
-                    std::cerr << "[FAIL] False positive replace range. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                }
-                break;
 
-            case DiffOperation::Add:
-                if (existsA) {
-                    std::cerr << "[FAIL] Add op but node already exists in A. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                }
-                if (!existsB) {
-                    std::cerr << "[FAIL] Add op but node missing in B. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                }
-                break;
+                checkedOps++;
+            }
 
-            case DiffOperation::Remove:
-                if (!existsA) {
-                    std::cerr << "[FAIL] Remove op but node missing in A. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                }
-                if (existsB) {
-                    std::cerr << "[FAIL] Remove op but node still exists in B. Path: " << DecodePath(Patch, Op) << "\n";
-                    allValid = false;
-                }
-                break;
+            if (allValid) {
+                std::cout << "[PASS] " << checkedOps << " operations verified successfully.\n";
+            } else {
+                std::cout << "[WARN] Validation found inconsistencies.\n";
             }
 
-            checkedOps++;
+            return allValid;
         }
 
-        if (allValid) {
-            std::cout << "[PASS] " << checkedOps << " operations verified successfully.\n";
-        } else {
-            std::cout << "[WARN] Validation found inconsistencies.\n";
-        }
+        static void PrintPatch(const PatchIndex& Patch, size_t max_ops_to_print = 50) {
+            std::cout << "\n================================================================================\n";
+            std::cout << "                              PATCH DEBUG PRINTER                               \n";
+            std::cout << "================================================================================\n";
+            std::cout << "Total Ops: " << Patch.operations.size() << "\n";
+            std::cout << "--------------------------------------------------------------------------------\n";
+
+            const size_t limit = std::min(Patch.operations.size(), max_ops_to_print);
+            for (size_t i = 0; i < limit; ++i) {
+                const auto& op = Patch.operations[i];
+
+                std::string op_name;
+                switch (op.Operation) {
+                case DiffOperation::Add:
+                    op_name = "[ADD]";
+                    break;
+                case DiffOperation::Remove:
+                    op_name = "[REMOVE]";
+                    break;
+                case DiffOperation::Replace:
+                    op_name = "[REPLACE]";
+                    break;
+                case DiffOperation::ReplaceRange:
+                    op_name = "[REPLACE RANGE]";
+                    break;
+                }
 
-        return allValid;
-    }
-
-    static void PrintPatch(const PatchIndex& Patch, size_t max_ops_to_print = 50) {
-        std::cout << "\n================================================================================\n";
-        std::cout << "                              PATCH DEBUG PRINTER                               \n";
-        std::cout << "================================================================================\n";
-        std::cout << "Total Ops: " << Patch.operations.size() << "\n";
-        std::cout << "--------------------------------------------------------------------------------\n";
-
-        const size_t limit = std::min(Patch.operations.size(), max_ops_to_print);
-        for (size_t i = 0; i < limit; ++i) {
-            const auto& op = Patch.operations[i];
-
-            std::string op_name;
-            switch (op.Operation) {
-            case DiffOperation::Add:          op_name = "[ADD]"; break;
-            case DiffOperation::Remove:       op_name = "[REMOVE]"; break;
-            case DiffOperation::Replace:      op_name = "[REPLACE]"; break;
-            case DiffOperation::ReplaceRange: op_name = "[REPLACE RANGE]"; break;
+                std::cout << std::left << std::setw(17) << op_name << " | Field: " << std::setw(22)
+                          << TypeToFieldName(op.ContainerType);
+                if (op.Operation == DiffOperation::ReplaceRange) {
+                    std::cout << " | Count: " << op.ReplaceRangeCount;
+                }
+                std::cout << " -> " << DecodePath(Patch, op) << "\n";
             }
 
-            std::cout << std::left << std::setw(17) << op_name
-                      << " | Field: " << std::setw(22) << TypeToFieldName(op.ContainerType);
-            if (op.Operation == DiffOperation::ReplaceRange) {
-                std::cout << " | Count: " << op.ReplaceRangeCount;
+            if (Patch.operations.size() > limit) {
+                std::cout << "\n  " << (Patch.operations.size() - limit) << " hidden ops.\n";
             }
-            std::cout << " -> " << DecodePath(Patch, op) << "\n";
-        }
-
-        if (Patch.operations.size() > limit) {
-            std::cout << "\n  " << (Patch.operations.size() - limit) << " hidden ops.\n";
+            std::cout << "================================================================================\n\n";
         }
-        std::cout << "================================================================================\n\n";
-    }
 
-private:
-    static bool AreBytesEqual(std::span<const std::byte> BytesA, std::span<const std::byte> BytesB, const DiffOptions& Opt) {
-        if (BytesA.size() != BytesB.size()) {
-            return false;
-        }
+    private:
+        static bool AreBytesEqual(std::span<const std::byte> BytesA, std::span<const std::byte> BytesB,
+                                  const DiffOptions& Opt) {
+            if (BytesA.size() != BytesB.size()) {
+                return false;
+            }
 
-        bool different = false;
-        if (Opt.compare_floats_with_epsilon && BytesA.size() == BytesB.size()) {
-            if (BytesA.size() == sizeof(float)) {
-                float fa = 0.0f;
-                float fb = 0.0f;
-                std::memcpy(&fa, BytesA.data(), sizeof(float));
-                std::memcpy(&fb, BytesB.data(), sizeof(float));
-                different = std::abs(fa - fb) > Opt.float_epsilon;
-            } else if (BytesA.size() == sizeof(double)) {
-                double da = 0.0;
-                double db = 0.0;
-                std::memcpy(&da, BytesA.data(), sizeof(double));
-                std::memcpy(&db, BytesB.data(), sizeof(double));
-                different = std::abs(da - db) > static_cast<double>(Opt.float_epsilon);
+            bool different = false;
+            if (Opt.compare_floats_with_epsilon && BytesA.size() == BytesB.size()) {
+                if (BytesA.size() == sizeof(float)) {
+                    float fa = 0.0f;
+                    float fb = 0.0f;
+                    std::memcpy(&fa, BytesA.data(), sizeof(float));
+                    std::memcpy(&fb, BytesB.data(), sizeof(float));
+                    different = std::abs(fa - fb) > Opt.float_epsilon;
+                } else if (BytesA.size() == sizeof(double)) {
+                    double da = 0.0;
+                    double db = 0.0;
+                    std::memcpy(&da, BytesA.data(), sizeof(double));
+                    std::memcpy(&db, BytesB.data(), sizeof(double));
+                    different = std::abs(da - db) > static_cast<double>(Opt.float_epsilon);
+                } else {
+                    different = std::memcmp(BytesA.data(), BytesB.data(), BytesA.size()) != 0;
+                }
             } else {
                 different = std::memcmp(BytesA.data(), BytesB.data(), BytesA.size()) != 0;
             }
-        } else {
-            different = std::memcmp(BytesA.data(), BytesB.data(), BytesA.size()) != 0;
+
+            return !different;
         }
 
-        return !different;
-    }
+        static std::string DecodePath(const PatchIndex& Patch, const DiffIndexOp& Op) {
+            if (Op.Path.size() == 0) {
+                return "root";
+            }
 
-    static std::string DecodePath(const PatchIndex& Patch, const DiffIndexOp& Op) {
-        if (Op.Path.size() == 0) {
-            return "root";
-        }
+            std::string result = "root";
+            for (size_t i = 0; i < Op.Path.size(); ++i) {
+                const int32_t value = Op.Path.indices[i];
 
-        std::string result = "root";
-        for (size_t i = 0; i < Op.Path.size(); ++i) {
-            const int32_t value = Op.Path.indices[i];
+                if (i == 0) {
+                    const auto type = static_cast<EVTXContainerType>(value);
+                    result += (type == EVTXContainerType::AnyStructArrays) ? ".entities" : "." + TypeToFieldName(type);
+                    continue;
+                }
 
-            if (i == 0) {
-                const auto type = static_cast<EVTXContainerType>(value);
-                result += (type == EVTXContainerType::AnyStructArrays) ? ".entities" : "." + TypeToFieldName(type);
-                continue;
-            }
+                if (i == 1 && Op.Path.indices[0] == static_cast<int32_t>(EVTXContainerType::AnyStructArrays)) {
+                    auto it = Patch.actor_id_by_key.find(value);
+                    if (it != Patch.actor_id_by_key.end()) {
+                        result += "[\"" + it->second + "\"]";
+                    } else if (!Op.ActorId.empty()) {
+                        result += "[\"" + Op.ActorId + "\"]";
+                    } else {
+                        result += "[Hash:" + std::to_string(value) + "]";
+                    }
+                    continue;
+                }
 
-            if (i == 1 && Op.Path.indices[0] == static_cast<int32_t>(EVTXContainerType::AnyStructArrays)) {
-                auto it = Patch.actor_id_by_key.find(value);
-                if (it != Patch.actor_id_by_key.end()) {
-                    result += "[\"" + it->second + "\"]";
-                } else if (!Op.ActorId.empty()) {
-                    result += "[\"" + Op.ActorId + "\"]";
-                } else {
-                    result += "[Hash:" + std::to_string(value) + "]";
+                const int32_t previous = Op.Path.indices[i - 1];
+                if (previous == static_cast<int32_t>(EVTXContainerType::MapProperties) ||
+                    previous == static_cast<int32_t>(EVTXContainerType::MapArrays)) {
+                    if (!Op.MapKey.empty()) {
+                        result += "{\"" + Op.MapKey + "\"}";
+                    } else {
+                        result += "{Hash:" + std::to_string(value) + "}";
+                    }
+                    continue;
                 }
-                continue;
-            }
 
-            const int32_t previous = Op.Path.indices[i - 1];
-            if (previous == static_cast<int32_t>(EVTXContainerType::MapProperties) ||
-                previous == static_cast<int32_t>(EVTXContainerType::MapArrays)) {
-                if (!Op.MapKey.empty()) {
-                    result += "{\"" + Op.MapKey + "\"}";
-                } else {
-                    result += "{Hash:" + std::to_string(value) + "}";
+                if (previous >= static_cast<int32_t>(EVTXContainerType::BoolProperties) &&
+                    previous <= static_cast<int32_t>(EVTXContainerType::MapArrays)) {
+                    result += "[" + std::to_string(value) + "]";
+                    continue;
                 }
-                continue;
-            }
 
-            if (previous >= static_cast<int32_t>(EVTXContainerType::BoolProperties) &&
-                previous <= static_cast<int32_t>(EVTXContainerType::MapArrays)) {
-                result += "[" + std::to_string(value) + "]";
-                continue;
+                const auto type = static_cast<EVTXContainerType>(value);
+                const std::string field_name = TypeToFieldName(type);
+                if (!field_name.empty()) {
+                    result += "." + field_name;
+                } else {
+                    result += "[" + std::to_string(value) + "]";
+                }
             }
 
-            const auto type = static_cast<EVTXContainerType>(value);
-            const std::string field_name = TypeToFieldName(type);
-            if (!field_name.empty()) {
-                result += "." + field_name;
-            } else {
-                result += "[" + std::to_string(value) + "]";
-            }
+            return result;
         }
-
-        return result;
-    }
-};
+    };
 
 } // namespace VtxDiff
diff --git a/sdk/include/vtx/differ/core/vtx_differ_facade.h b/sdk/include/vtx/differ/core/vtx_differ_facade.h
index db1a974..899ee21 100644
--- a/sdk/include/vtx/differ/core/vtx_differ_facade.h
+++ b/sdk/include/vtx/differ/core/vtx_differ_facade.h
@@ -12,7 +12,8 @@ namespace VtxDiff {
     public:
         virtual ~IVtxDifferFacade() = default;
 
-        virtual PatchIndex DiffRawFrames(std::span<const std::byte> frame_a,std::span<const std::byte> frame_b,const DiffOptions& options = {}) = 0;
+        virtual PatchIndex DiffRawFrames(std::span<const std::byte> frame_a, std::span<const std::byte> frame_b,
+                                         const DiffOptions& options = {}) = 0;
     };
 
     // Returns nullptr only if format is Unknown.
diff --git a/sdk/include/vtx/differ/core/vtx_patch.h b/sdk/include/vtx/differ/core/vtx_patch.h
index ff899d2..fe5b431 100644
--- a/sdk/include/vtx/differ/core/vtx_patch.h
+++ b/sdk/include/vtx/differ/core/vtx_patch.h
@@ -8,11 +8,10 @@
 #include "vtx/differ/core/vtx_default_tree_diff.h"
 #include "vtx/differ/core/vtx_diff_types.h"
 
-namespace DiffUtils
-{
-    template<typename TNodeView>
-    VtxDiff::PatchIndex DiffSingleActorByIndex(const TNodeView& FrameA, const TNodeView& FrameB, uint32_t ActorIndexA, uint32_t ActorIndexB, const VtxDiff::DiffOptions& Opt)
-    {
+namespace DiffUtils {
+    template <typename TNodeView>
+    VtxDiff::PatchIndex DiffSingleActorByIndex(const TNodeView& FrameA, const TNodeView& FrameB, uint32_t ActorIndexA,
+                                               uint32_t ActorIndexB, const VtxDiff::DiffOptions& Opt) {
         VtxDiff::FieldDesc entities_field;
         entities_field.name = "entities";
         entities_field.type = VtxDiff::EVTXContainerType::AnyStructArrays;
@@ -23,12 +22,12 @@ namespace DiffUtils
         VtxDiff::DefaultTreeDiff<TNodeView> differ;
         return differ.ComputeEntityDiff(entity_a, entity_b, Opt);
     }
-}
+} // namespace DiffUtils
 
 namespace VtxDiff {
 
     template <typename TNodeView>
-    requires CBinaryNodeView<TNodeView>
+        requires CBinaryNodeView<TNodeView>
     class PatchAccessor {
     public:
         static TNodeView GetTargetNode(const TNodeView& Root, const DiffIndexPath& Path) {
@@ -44,14 +43,12 @@ namespace VtxDiff {
         }
 
     private:
-        static constexpr size_t InvalidIndex() {
-            return std::numeric_limits<size_t>::max();
-        }
+        static constexpr size_t InvalidIndex() { return std::numeric_limits<size_t>::max(); }
 
         struct ResolvedPath {
             bool Exists = false;
-            std::span<const std::byte> Bytes{};
-            TNodeView Node{};
+            std::span<const std::byte> Bytes {};
+            TNodeView Node {};
         };
 
         static FieldDesc MakeField(EVTXContainerType Type) {
@@ -83,14 +80,16 @@ namespace VtxDiff {
             const size_t count = Node.GetArraySize(entities_field);
             for (size_t i = 0; i < count; ++i) {
                 auto actor = Node.GetArrayElementAsStruct(entities_field, i);
-                if (!actor.IsValid()) continue;
+                if (!actor.IsValid())
+                    continue;
 
                 auto span_id = actor.GetFieldBytes(id_field);
-                if (span_id.empty()) continue;
+                if (span_id.empty())
+                    continue;
 
-                const int32_t current_hash = static_cast<int32_t>(VtxDiff::StableHash64(
-                    { reinterpret_cast<const char*>(span_id.data()), span_id.size() }
-                ) & 0x7FFFFFFF);
+                const int32_t current_hash = static_cast<int32_t>(
+                    VtxDiff::StableHash64({reinterpret_cast<const char*>(span_id.data()), span_id.size()}) &
+                    0x7FFFFFFF);
 
                 if (current_hash == TargetHash) {
                     return i;
@@ -99,15 +98,19 @@ namespace VtxDiff {
             return InvalidIndex();
         }
 
-        static size_t FindMapIndexByHash(const TNodeView& Node, const FieldDesc& Field, int32_t TargetHash, const std::string& ExpectedKey) {
+        static size_t FindMapIndexByHash(const TNodeView& Node, const FieldDesc& Field, int32_t TargetHash,
+                                         const std::string& ExpectedKey) {
             const size_t count = Node.GetMapSize(Field);
             for (size_t i = 0; i < count; ++i) {
                 const std::string key = Node.GetMapKey(Field, i);
-                if (key.empty()) continue;
+                if (key.empty())
+                    continue;
 
                 const int32_t key_hash = static_cast<int32_t>(VtxDiff::StableHash64(key) & 0x7FFFFFFF);
-                if (key_hash != TargetHash) continue;
-                if (!ExpectedKey.empty() && key != ExpectedKey) continue;
+                if (key_hash != TargetHash)
+                    continue;
+                if (!ExpectedKey.empty() && key != ExpectedKey)
+                    continue;
                 return i;
             }
             return InvalidIndex();
@@ -119,7 +122,7 @@ namespace VtxDiff {
             }
 
             if (Path.size() == 0) {
-                return { true, {}, Root };
+                return {true, {}, Root};
             }
 
             if (Path[0] == static_cast<int32_t>(EVTXContainerType::AnyStructArrays) && Path.size() >= 2) {
@@ -138,7 +141,7 @@ namespace VtxDiff {
                 }
 
                 if (Path.size() == 2) {
-                    return { true, Root.GetArrayElementBytes(entities_field, actor_index), actor_node };
+                    return {true, Root.GetArrayElementBytes(entities_field, actor_index), actor_node};
                 }
 
                 return ResolveNode(actor_node, Path, 2, MapKey);
@@ -147,7 +150,8 @@ namespace VtxDiff {
             return ResolveNode(Root, Path, 0, MapKey);
         }
 
-        static ResolvedPath ResolveNode(const TNodeView& Node, const DiffIndexPath& Path, size_t PathIndex, const std::string& MapKey) {
+        static ResolvedPath ResolveNode(const TNodeView& Node, const DiffIndexPath& Path, size_t PathIndex,
+                                        const std::string& MapKey) {
             if (!Node.IsValid() || PathIndex >= Path.size()) {
                 return {};
             }
@@ -157,7 +161,7 @@ namespace VtxDiff {
             const bool field_exists = HasField(Node, field);
 
             if (PathIndex + 1 >= Path.size()) {
-                return { field_exists, Node.GetFieldBytes(field), Node.GetNestedStruct(field) };
+                return {field_exists, Node.GetFieldBytes(field), Node.GetNestedStruct(field)};
             }
 
             const int32_t RawIndex = Path[PathIndex + 1];
@@ -177,7 +181,7 @@ namespace VtxDiff {
                 }
 
                 if (PathIndex + 2 >= Path.size()) {
-                    return { true, Node.GetArrayElementBytes(field, struct_index), child };
+                    return {true, Node.GetArrayElementBytes(field, struct_index), child};
                 }
 
                 return ResolveNode(child, Path, PathIndex + 2, MapKey);
@@ -191,11 +195,11 @@ namespace VtxDiff {
 
                 auto child = Node.GetMapValueAsStruct(field, map_index);
                 if (!child.IsValid()) {
-                    return { true, {}, {} };
+                    return {true, {}, {}};
                 }
 
                 if (PathIndex + 2 >= Path.size()) {
-                    return { true, {}, child };
+                    return {true, {}, child};
                 }
 
                 return ResolveNode(child, Path, PathIndex + 2, MapKey);
@@ -207,7 +211,7 @@ namespace VtxDiff {
                     return {};
                 }
 
-                return { true, Node.GetSubArrayBytes(field, array_index), {} };
+                return {true, Node.GetSubArrayBytes(field, array_index), {}};
             }
 
             const size_t element_index = static_cast<size_t>(RawIndex);
@@ -215,7 +219,7 @@ namespace VtxDiff {
                 return {};
             }
 
-            return { true, Node.GetArrayElementBytes(field, element_index), {} };
+            return {true, Node.GetArrayElementBytes(field, element_index), {}};
         }
     };
-}
+} // namespace VtxDiff
diff --git a/sdk/include/vtx/reader/core/vtx_deserializer_service.h b/sdk/include/vtx/reader/core/vtx_deserializer_service.h
index 541f43b..31c2bd6 100644
--- a/sdk/include/vtx/reader/core/vtx_deserializer_service.h
+++ b/sdk/include/vtx/reader/core/vtx_deserializer_service.h
@@ -3,15 +3,14 @@
 #include <string>
 #include <memory>
 
-namespace cppvtx
-{
+namespace cppvtx {
     class FrameChunk;
     class Frame;
-}
+} // namespace cppvtx
 
 namespace VTX {
     namespace ReplayUnpacker {
         std::string Decompress(const std::string& compressed_data);
         std::vector<std::unique_ptr<cppvtx::Frame>> Unpack(const cppvtx::FrameChunk& chunk);
-    };
-}
+    }; // namespace ReplayUnpacker
+} // namespace VTX
diff --git a/sdk/include/vtx/reader/core/vtx_frame_accessor.h b/sdk/include/vtx/reader/core/vtx_frame_accessor.h
index 184309f..755142c 100644
--- a/sdk/include/vtx/reader/core/vtx_frame_accessor.h
+++ b/sdk/include/vtx/reader/core/vtx_frame_accessor.h
@@ -2,10 +2,9 @@
 #include "vtx/common/vtx_concepts.h"
 #include "vtx/common/vtx_logger.h"
 #include "vtx/common/vtx_property_cache.h"
-#include <type_traits> 
+#include <type_traits>
 
-namespace VTX
-{
+namespace VTX {
     struct PropertyMetadata {
         std::string name;
         VTX::FieldType type;
@@ -16,31 +15,46 @@ namespace VTX
         const PropertyContainer* data_ = nullptr;
 
     public:
-        EntityView() : data_(nullptr) {}
-        explicit EntityView(const PropertyContainer& data) : data_(&data) {}
+        EntityView()
+            : data_(nullptr) {}
+        explicit EntityView(const PropertyContainer& data)
+            : data_(&data) {}
 
         template <typename T>
         static constexpr auto GetContainerMember() {
-            if constexpr (std::same_as<T, bool>) return &PropertyContainer::bool_properties;
-            else if constexpr (std::same_as<T, int32_t>) return &PropertyContainer::int32_properties;
-            else if constexpr (std::same_as<T, int64_t>) return &PropertyContainer::int64_properties;
-            else if constexpr (std::same_as<T, float>) return &PropertyContainer::float_properties;
-            else if constexpr (std::same_as<T, double>) return &PropertyContainer::double_properties;
-            else if constexpr (std::same_as<T, std::string>) return &PropertyContainer::string_properties;
-            else if constexpr (std::same_as<T, VTX::Vector>) return &PropertyContainer::vector_properties;
-            else if constexpr (std::same_as<T, VTX::Quat>) return &PropertyContainer::quat_properties;
-            else if constexpr (std::same_as<T, VTX::Transform>) return &PropertyContainer::transform_properties;
-            else if constexpr (std::same_as<T, VTX::FloatRange>) return &PropertyContainer::range_properties;
-            else if constexpr (std::same_as<T, EntityView>) return &PropertyContainer::any_struct_properties;
-            else static_assert(std::same_as<T, void>, "type not supported in EntityView");
+            if constexpr (std::same_as<T, bool>)
+                return &PropertyContainer::bool_properties;
+            else if constexpr (std::same_as<T, int32_t>)
+                return &PropertyContainer::int32_properties;
+            else if constexpr (std::same_as<T, int64_t>)
+                return &PropertyContainer::int64_properties;
+            else if constexpr (std::same_as<T, float>)
+                return &PropertyContainer::float_properties;
+            else if constexpr (std::same_as<T, double>)
+                return &PropertyContainer::double_properties;
+            else if constexpr (std::same_as<T, std::string>)
+                return &PropertyContainer::string_properties;
+            else if constexpr (std::same_as<T, VTX::Vector>)
+                return &PropertyContainer::vector_properties;
+            else if constexpr (std::same_as<T, VTX::Quat>)
+                return &PropertyContainer::quat_properties;
+            else if constexpr (std::same_as<T, VTX::Transform>)
+                return &PropertyContainer::transform_properties;
+            else if constexpr (std::same_as<T, VTX::FloatRange>)
+                return &PropertyContainer::range_properties;
+            else if constexpr (std::same_as<T, EntityView>)
+                return &PropertyContainer::any_struct_properties;
+            else
+                static_assert(std::same_as<T, void>, "type not supported in EntityView");
         }
-        
-        template <typename U> using ScalarRetType = std::conditional_t<std::is_same_v<U, bool>, bool, const U&>;
+
+        template <typename U>
+        using ScalarRetType = std::conditional_t<std::is_same_v<U, bool>, bool, const U&>;
 
         template <VtxScalarType T>
         ScalarRetType<T> Get(PropertyKey<T> key) const {
             if (!data_ || !key.IsValid()) {
-                static const T default_val = {}; 
+                static const T default_val = {};
                 return default_val;
             }
             constexpr auto MemberPtr = GetContainerMember<T>();
@@ -55,43 +69,57 @@ namespace VTX
         template <VtxArrayType T>
         auto GetArray(PropertyKey<T> key) const {
             constexpr auto MemberPtr = GetArrayContainerMember<T>();
-            
+
             using ExactSpanType = decltype((data_->*MemberPtr).GetSubArray(0));
-            
+
             if (!data_ || !key.IsValid()) {
-                return ExactSpanType{}; 
+                return ExactSpanType {};
             }
-            
-            return (data_->*MemberPtr).GetSubArray(key.index); 
+
+            return (data_->*MemberPtr).GetSubArray(key.index);
         }
-        
+
         EntityView GetView(PropertyKey<EntityView> key) const {
-            if (!data_ || !key.IsValid() || static_cast<size_t>(key.index) >= data_->any_struct_properties.size()) return EntityView{}; 
+            if (!data_ || !key.IsValid() || static_cast<size_t>(key.index) >= data_->any_struct_properties.size())
+                return EntityView {};
             return EntityView(data_->any_struct_properties[key.index]);
         }
 
         std::span<const PropertyContainer> GetViewArray(PropertyKey<std::span<const PropertyContainer>> key) const {
-            if (!data_ || !key.IsValid()) return {};
+            if (!data_ || !key.IsValid())
+                return {};
             return data_->any_struct_arrays.GetSubArray(key.index);
         }
 
         template <typename T>
         static constexpr auto GetArrayContainerMember() {
-            if constexpr (std::is_same_v<T, int32_t>) return &PropertyContainer::int32_arrays;
-            else if constexpr (std::is_same_v<T, int64_t>) return &PropertyContainer::int64_arrays;
-            else if constexpr (std::is_same_v<T, float>) return &PropertyContainer::float_arrays;
-            else if constexpr (std::is_same_v<T, double>) return &PropertyContainer::double_arrays;
-            else if constexpr (std::is_same_v<T, std::string>) return &PropertyContainer::string_arrays;
-            else if constexpr (std::is_same_v<T, VTX::Vector>) return &PropertyContainer::vector_arrays;
-            else if constexpr (std::is_same_v<T, VTX::Quat>) return &PropertyContainer::quat_arrays;
-            else if constexpr (std::is_same_v<T, VTX::Transform>) return &PropertyContainer::transform_arrays;
-            else if constexpr (std::is_same_v<T, VTX::FloatRange>) return &PropertyContainer::range_arrays;
-            else if constexpr (std::is_same_v<T, bool>) return &PropertyContainer::bool_arrays;
-            else if constexpr (std::is_same_v<T, uint8_t>) return &PropertyContainer::byte_array_properties;
-            else if constexpr (std::is_same_v<T, VTX::PropertyContainer>) return &PropertyContainer::any_struct_arrays;
-            else static_assert(std::same_as<T, void>, "type not supported in EntityView");
+            if constexpr (std::is_same_v<T, int32_t>)
+                return &PropertyContainer::int32_arrays;
+            else if constexpr (std::is_same_v<T, int64_t>)
+                return &PropertyContainer::int64_arrays;
+            else if constexpr (std::is_same_v<T, float>)
+                return &PropertyContainer::float_arrays;
+            else if constexpr (std::is_same_v<T, double>)
+                return &PropertyContainer::double_arrays;
+            else if constexpr (std::is_same_v<T, std::string>)
+                return &PropertyContainer::string_arrays;
+            else if constexpr (std::is_same_v<T, VTX::Vector>)
+                return &PropertyContainer::vector_arrays;
+            else if constexpr (std::is_same_v<T, VTX::Quat>)
+                return &PropertyContainer::quat_arrays;
+            else if constexpr (std::is_same_v<T, VTX::Transform>)
+                return &PropertyContainer::transform_arrays;
+            else if constexpr (std::is_same_v<T, VTX::FloatRange>)
+                return &PropertyContainer::range_arrays;
+            else if constexpr (std::is_same_v<T, bool>)
+                return &PropertyContainer::bool_arrays;
+            else if constexpr (std::is_same_v<T, uint8_t>)
+                return &PropertyContainer::byte_array_properties;
+            else if constexpr (std::is_same_v<T, VTX::PropertyContainer>)
+                return &PropertyContainer::any_struct_arrays;
+            else
+                static_assert(std::same_as<T, void>, "type not supported in EntityView");
         }
-        
     };
 
     class FrameAccessor {
@@ -106,21 +134,20 @@ namespace VTX
             }
             return -1;
         }
-        
+
     public:
         void Initialize(const SchemaAdaptable auto& schema) {
             SchemaAdapter<std::remove_cvref_t<decltype(schema)>>::BuildCache(schema, cache_);
         }
 
-        template <typename T> requires SchemaAdaptable<T>
+        template <typename T>
+            requires SchemaAdaptable<T>
         void Initialize(const std::unique_ptr<T>& schema) {
             //if (schema) SchemaAdapter<T>::BuildCache(*schema, cache_);
         }
-    
-        void InitializeFromCache(const PropertyAddressCache& prebuilt_cache) {
-            cache_ = prebuilt_cache; 
-        }
-        
+
+        void InitializeFromCache(const PropertyAddressCache& prebuilt_cache) { cache_ = prebuilt_cache; }
+
         template <VtxScalarType T>
         PropertyKey<T> Get(int32_t structId, const std::string& propName) const {
             auto structIt = cache_.structs.find(structId);
@@ -128,14 +155,15 @@ namespace VTX
                 auto propIt = structIt->second.properties.find(propName);
                 if (propIt != structIt->second.properties.end()) {
                     const PropertyAddress& addr = propIt->second;
-                    if (addr.type_id == GetExpectedFieldType<T>() && addr.container_type == VTX::FieldContainerType::None) {
-                        return PropertyKey<T>{ static_cast<int32_t>(addr.index) };
+                    if (addr.type_id == GetExpectedFieldType<T>() &&
+                        addr.container_type == VTX::FieldContainerType::None) {
+                        return PropertyKey<T> {static_cast<int32_t>(addr.index)};
                     } else {
                         VTX_ERROR("Type mismatch for struct ID {}. Property: {}", structId, propName);
                     }
                 }
             }
-            return PropertyKey<T>{ -1 };
+            return PropertyKey<T> {-1};
         }
 
         template <VtxScalarType T, typename EnumType, typename std::enable_if_t<std::is_enum_v<EnumType>, int> = 0>
@@ -149,9 +177,9 @@ namespace VTX
             if (structId != -1) {
                 return Get<T>(structId, propName);
             }
-            return PropertyKey<T>{ -1 };
+            return PropertyKey<T> {-1};
         }
-        
+
         template <VtxArrayType T>
         PropertyKey<T> GetArray(int32_t structId, const std::string& propName) const {
             auto structIt = cache_.structs.find(structId);
@@ -159,12 +187,13 @@ namespace VTX
                 auto propIt = structIt->second.properties.find(propName);
                 if (propIt != structIt->second.properties.end()) {
                     const PropertyAddress& addr = propIt->second;
-                    if (addr.type_id == GetExpectedFieldType<T>() && addr.container_type == VTX::FieldContainerType::Array) {
-                        return PropertyKey<T>{ static_cast<int32_t>(addr.index) };
+                    if (addr.type_id == GetExpectedFieldType<T>() &&
+                        addr.container_type == VTX::FieldContainerType::Array) {
+                        return PropertyKey<T> {static_cast<int32_t>(addr.index)};
                     }
                 }
             }
-            return PropertyKey<T>{ -1 };
+            return PropertyKey<T> {-1};
         }
 
         template <VtxArrayType T, typename EnumType, typename std::enable_if_t<std::is_enum_v<EnumType>, int> = 0>
@@ -178,23 +207,24 @@ namespace VTX
             if (structId != -1) {
                 return GetArray<T>(structId, propName);
             }
-            return PropertyKey<T>{ -1 };
+            return PropertyKey<T> {-1};
         }
-                
+
         PropertyKey<VTX::EntityView> GetViewKey(int32_t structId, const std::string& propName) const {
             auto structIt = cache_.structs.find(structId);
             if (structIt != cache_.structs.end()) {
                 auto propIt = structIt->second.properties.find(propName);
                 if (propIt != structIt->second.properties.end()) {
                     const PropertyAddress& addr = propIt->second;
-                    if (addr.type_id == VTX::FieldType::Struct && addr.container_type == VTX::FieldContainerType::None) {
-                        return PropertyKey<VTX::EntityView>{ static_cast<int32_t>(addr.index) };
+                    if (addr.type_id == VTX::FieldType::Struct &&
+                        addr.container_type == VTX::FieldContainerType::None) {
+                        return PropertyKey<VTX::EntityView> {static_cast<int32_t>(addr.index)};
                     } else {
                         VTX_ERROR("Type mismatch for struct ID {}. Property: {}", structId, propName);
                     }
                 }
             }
-            return PropertyKey<VTX::EntityView>{ -1 };
+            return PropertyKey<VTX::EntityView> {-1};
         }
 
         template <typename EnumType, typename std::enable_if_t<std::is_enum_v<EnumType>, int> = 0>
@@ -207,43 +237,47 @@ namespace VTX
             if (structId != -1) {
                 return GetViewKey(structId, propName);
             }
-            return PropertyKey<VTX::EntityView>{ -1 };
+            return PropertyKey<VTX::EntityView> {-1};
         }
-        
-        
-        PropertyKey<std::span<const VTX::PropertyContainer>> GetViewArrayKey(int32_t structId, const std::string& propName) const {
+
+
+        PropertyKey<std::span<const VTX::PropertyContainer>> GetViewArrayKey(int32_t structId,
+                                                                             const std::string& propName) const {
             auto structIt = cache_.structs.find(structId);
             if (structIt != cache_.structs.end()) {
                 auto propIt = structIt->second.properties.find(propName);
                 if (propIt != structIt->second.properties.end()) {
                     const PropertyAddress& addr = propIt->second;
-                    if (addr.type_id == VTX::FieldType::Struct && addr.container_type == VTX::FieldContainerType::Array) {
-                        return PropertyKey<std::span<const VTX::PropertyContainer>>{ static_cast<int32_t>(addr.index) };
+                    if (addr.type_id == VTX::FieldType::Struct &&
+                        addr.container_type == VTX::FieldContainerType::Array) {
+                        return PropertyKey<std::span<const VTX::PropertyContainer>> {static_cast<int32_t>(addr.index)};
                     } else {
                         VTX_ERROR("Type mismatch for struct ID {}. Property: {}", structId, propName);
                     }
                 }
             }
-            return PropertyKey<std::span<const VTX::PropertyContainer>>{ -1 };
+            return PropertyKey<std::span<const VTX::PropertyContainer>> {-1};
         }
 
         template <typename EnumType, typename std::enable_if_t<std::is_enum_v<EnumType>, int> = 0>
-        PropertyKey<std::span<const VTX::PropertyContainer>> GetViewArrayKey(EnumType structEnum, const std::string& propName) const {
+        PropertyKey<std::span<const VTX::PropertyContainer>> GetViewArrayKey(EnumType structEnum,
+                                                                             const std::string& propName) const {
             return GetViewArrayKey(static_cast<int32_t>(structEnum), propName);
         }
 
-        PropertyKey<std::span<const VTX::PropertyContainer>> GetViewArrayKey(const std::string& structName, const std::string& propName) const {
+        PropertyKey<std::span<const VTX::PropertyContainer>> GetViewArrayKey(const std::string& structName,
+                                                                             const std::string& propName) const {
             const int32_t structId = FindStructId(structName);
             if (structId != -1) {
                 return GetViewArrayKey(structId, propName);
             }
-            return PropertyKey<std::span<const VTX::PropertyContainer>>{ -1 };
+            return PropertyKey<std::span<const VTX::PropertyContainer>> {-1};
         }
-        
+
 
         std::vector<std::string> GetAvailableStructNames() const {
             std::vector<std::string> names;
-            names.reserve(cache_.name_to_id.size()); 
+            names.reserve(cache_.name_to_id.size());
             for (const auto& [name, id] : cache_.name_to_id) {
                 names.push_back(name);
             }
@@ -272,7 +306,8 @@ namespace VTX
 
         bool HasProperty(int32_t structId, const std::string& propName) const {
             auto it = cache_.structs.find(structId);
-            if (it != cache_.structs.end()) return it->second.properties.contains(propName);
+            if (it != cache_.structs.end())
+                return it->second.properties.contains(propName);
             return false;
         }
 
@@ -284,4 +319,4 @@ namespace VTX
             return false;
         }
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/reader/core/vtx_reader.h b/sdk/include/vtx/reader/core/vtx_reader.h
index 2d72ebd..6598696 100644
--- a/sdk/include/vtx/reader/core/vtx_reader.h
+++ b/sdk/include/vtx/reader/core/vtx_reader.h
@@ -47,7 +47,8 @@ namespace VTX {
         using FooterType = typename SerializerPolicy::FooterType;
         using SchemaType = typename SerializerPolicy::SchemaType;
 
-        explicit ReplayReader(const std::string& filepath) : filepath_(filepath) {
+        explicit ReplayReader(const std::string& filepath)
+            : filepath_(filepath) {
             std::ifstream init_stream(filepath_, std::ios::binary | std::ios::in);
             if (!init_stream.is_open()) {
                 throw std::runtime_error("VTX Reader: Can not open the file " + filepath);
@@ -74,11 +75,14 @@ namespace VTX {
                 std::lock_guard<std::mutex> lock(cache_mutex_);
                 for (auto& kv : pending_loads_) {
                     kv.second.stop.request_stop();
-                    if (kv.second.future.valid()) tasks.push_back(kv.second.future);
+                    if (kv.second.future.valid())
+                        tasks.push_back(kv.second.future);
                 }
             }
 
-            for (auto& task : tasks) { task.wait(); }
+            for (auto& task : tasks) {
+                task.wait();
+            }
         }
 
         // Fix A4: protect events_ with a mutex.  std::function is not
@@ -96,6 +100,7 @@ namespace VTX {
             std::lock_guard<std::mutex> lock(events_mutex_);
             return events_;
         }
+
     public:
         int32_t GetTotalFrames() const { return SerializerPolicy::GetTotalFrames(footer_); }
         const std::vector<ChunkIndexEntry>& GetSeekTable() const { return chunk_index_table_; }
@@ -130,9 +135,8 @@ namespace VTX {
         // it contributes to the EWMA reflects the real jump the caller
         // just committed to.
         void WarmAt(int32_t frame_index) {
-            auto it = std::lower_bound(
-                chunk_index_table_.begin(), chunk_index_table_.end(), frame_index,
-                [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
+            auto it = std::lower_bound(chunk_index_table_.begin(), chunk_index_table_.end(), frame_index,
+                                       [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
             if (it == chunk_index_table_.end() || frame_index < it->start_frame) {
                 return;
             }
@@ -141,7 +145,7 @@ namespace VTX {
 
         std::span<const std::byte> GetRawFrameBytes(int32_t frame_index) {
             auto it = std::lower_bound(chunk_index_table_.begin(), chunk_index_table_.end(), frame_index,
-                [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
+                                       [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
 
             if (it == chunk_index_table_.end() || frame_index < it->start_frame) {
                 return {};
@@ -185,9 +189,10 @@ namespace VTX {
 
         bool GetFrame(int32_t frame_index, VTX::Frame& out_frame) {
             auto it = std::lower_bound(chunk_index_table_.begin(), chunk_index_table_.end(), frame_index,
-                [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
+                                       [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
 
-            if (it == chunk_index_table_.end() || frame_index < it->start_frame) return false;
+            if (it == chunk_index_table_.end() || frame_index < it->start_frame)
+                return false;
 
             int32_t target_chunk = it->chunk_index;
             int32_t relative_idx = frame_index - it->start_frame;
@@ -234,9 +239,10 @@ namespace VTX {
 
         const VTX::Frame* GetFramePtr(int32_t frame_index) {
             auto it = std::lower_bound(chunk_index_table_.begin(), chunk_index_table_.end(), frame_index,
-                [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
+                                       [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
 
-            if (it == chunk_index_table_.end() || frame_index < it->start_frame) return nullptr;
+            if (it == chunk_index_table_.end() || frame_index < it->start_frame)
+                return nullptr;
 
             int32_t target_chunk = it->chunk_index;
             int32_t relative_idx = frame_index - it->start_frame;
@@ -256,7 +262,7 @@ namespace VTX {
 
         const VTX::Frame* GetFramePtrSync(int32_t frame_index) {
             auto it = std::lower_bound(chunk_index_table_.begin(), chunk_index_table_.end(), frame_index,
-                [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
+                                       [](const ChunkIndexEntry& e, int32_t val) { return e.end_frame < val; });
 
             if (it == chunk_index_table_.end() || frame_index < it->start_frame) {
                 return nullptr;
@@ -300,9 +306,10 @@ namespace VTX {
         }
 
         int32_t GetChunkFrameCountSafe(int32_t chunk_index) {
-             std::lock_guard<std::mutex> lock(cache_mutex_);
-             if (chunk_cache_.contains(chunk_index)) return chunk_cache_[chunk_index].native_frames.size();
-             return 0;
+            std::lock_guard<std::mutex> lock(cache_mutex_);
+            if (chunk_cache_.contains(chunk_index))
+                return chunk_cache_[chunk_index].native_frames.size();
+            return 0;
         }
 
         FrameAccessor CreateAccessor() const {
@@ -312,32 +319,21 @@ namespace VTX {
         }
 
         void InspectChunkHeader(int32_t index) const {
-            if (index < 0 || index >= chunk_index_table_.size()) return;
+            if (index < 0 || index >= chunk_index_table_.size())
+                return;
             const auto& entry = chunk_index_table_[index];
-            VTX_INFO("--- Chunk Inspection --- Index: {} Offset: {} Size: {}", entry.chunk_index, entry.file_offset, entry.chunk_size_bytes);
-        }
-
-        VTX::FileHeader GetFileHeader()
-        {
-            return SerializerPolicy::GetVTXHeader(header_);
+            VTX_INFO("--- Chunk Inspection --- Index: {} Offset: {} Size: {}", entry.chunk_index, entry.file_offset,
+                     entry.chunk_size_bytes);
         }
 
-        VTX::FileFooter GetFileFooter()
-        {
-            return SerializerPolicy::GetVTXFooter(footer_);
-        }
+        VTX::FileHeader GetFileHeader() { return SerializerPolicy::GetVTXHeader(header_); }
 
-        VTX::ContextualSchema GetContextualSchema()
-        {
-            return SerializerPolicy::GetVTXContextualSchema(header_);
-        }
+        VTX::FileFooter GetFileFooter() { return SerializerPolicy::GetVTXFooter(footer_); }
 
+        VTX::ContextualSchema GetContextualSchema() { return SerializerPolicy::GetVTXContextualSchema(header_); }
 
 
-        VTX::PropertyAddressCache GetPropertyAddressCache()
-        {
-            return property_address_cache_;
-        }
+        VTX::PropertyAddressCache GetPropertyAddressCache() { return property_address_cache_; }
 
     private:
         struct CachedChunk {
@@ -357,7 +353,7 @@ namespace VTX {
             stream.seekg(0, std::ios::end);
             const auto end = stream.tellg();
             stream.seekg(prev);
-            return (end < 0) ? int64_t{0} : static_cast<int64_t>(end);
+            return (end < 0) ? int64_t {0} : static_cast<int64_t>(end);
         }
 
         void ReadHeader(std::ifstream& stream) {
@@ -422,8 +418,7 @@ namespace VTX {
             // Fix A3: guard against an implausible footer_size (either
             // malicious UINT32_MAX or garbage from a corrupt trailer) that
             // would seek before the beginning of the file.
-            if (footer_size == 0 ||
-                static_cast<int64_t>(footer_size) + 8 > file_size) {
+            if (footer_size == 0 || static_cast<int64_t>(footer_size) + 8 > file_size) {
                 throw std::runtime_error("VTX file has implausible footer size");
             }
 
@@ -494,18 +489,15 @@ namespace VTX {
             if (last_requested_chunk_ >= 0) {
                 const int32_t dist = std::abs(current_idx - last_requested_chunk_);
                 constexpr float alpha = 0.3f;
-                ewma_chunk_distance_ =
-                    alpha * static_cast<float>(dist) +
-                    (1.0f - alpha) * ewma_chunk_distance_;
-                if (window_size > 0 &&
-                    ewma_chunk_distance_ > static_cast<float>(window_size)) {
+                ewma_chunk_distance_ = alpha * static_cast<float>(dist) + (1.0f - alpha) * ewma_chunk_distance_;
+                if (window_size > 0 && ewma_chunk_distance_ > static_cast<float>(window_size)) {
                     do_lateral_prefetch = false;
                 }
             }
             last_requested_chunk_ = current_idx;
 
             // Reap prefetches that finished naturally since the last call.
-            for (auto it = pending_loads_.begin(); it != pending_loads_.end(); ) {
+            for (auto it = pending_loads_.begin(); it != pending_loads_.end();) {
                 if (it->second.future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
                     it = pending_loads_.erase(it);
                 } else {
@@ -514,10 +506,13 @@ namespace VTX {
             }
 
             int32_t start = std::max(0, current_idx - static_cast<int32_t>(cache_backward_));
-            int32_t end = std::min(static_cast<int32_t>(chunk_index_table_.size()) - 1, current_idx + (int32_t)cache_forward_);
+            int32_t end =
+                std::min(static_cast<int32_t>(chunk_index_table_.size()) - 1, current_idx + (int32_t)cache_forward_);
 
-            if (start == current_range_start_ && end == current_range_end_) return;
-            current_range_start_ = start; current_range_end_ = end;
+            if (start == current_range_start_ && end == current_range_end_)
+                return;
+            current_range_start_ = start;
+            current_range_end_ = end;
 
             // Cancel in-flight prefetches whose target chunk fell outside
             // the new window.  AsyncLoadTask checks `stop_requested()` at
@@ -546,9 +541,10 @@ namespace VTX {
             // while firing user callbacks.
             const auto evts = GetEventsSnapshot();
 
-            for (auto it = chunk_cache_.begin(); it != chunk_cache_.end(); ) {
+            for (auto it = chunk_cache_.begin(); it != chunk_cache_.end();) {
                 if (it->first < start || it->first > end) {
-                    if (evts.OnChunkEvicted) evts.OnChunkEvicted(it->first);
+                    if (evts.OnChunkEvicted)
+                        evts.OnChunkEvicted(it->first);
                     it = chunk_cache_.erase(it);
                 } else {
                     ++it;
@@ -619,7 +615,8 @@ namespace VTX {
             trigger(current_idx);
             if (do_lateral_prefetch) {
                 for (int32_t i = start; i <= end; ++i) {
-                    if (i != current_idx) trigger(i);
+                    if (i != current_idx)
+                        trigger(i);
                 }
             }
         }
@@ -637,7 +634,8 @@ namespace VTX {
                     chunk_cache_[idx] = std::move(data);
                     pending_loads_.erase(idx);
                 }
-                if (evts.OnChunkLoadFinished) evts.OnChunkLoadFinished(idx);
+                if (evts.OnChunkLoadFinished)
+                    evts.OnChunkLoadFinished(idx);
             }
         }
 
@@ -662,20 +660,24 @@ namespace VTX {
             if (thread_survived) {
                 // A4: snapshot before invoking.
                 const auto evts = GetEventsSnapshot();
-                if (evts.OnChunkLoadFinished) evts.OnChunkLoadFinished(idx);
+                if (evts.OnChunkLoadFinished)
+                    evts.OnChunkLoadFinished(idx);
             }
         }
 
         CachedChunk PerformHeavyLoading(int32_t idx, const std::stop_token& stop_token) {
-            if (idx < 0 || idx >= chunk_index_table_.size()) return {};
+            if (idx < 0 || idx >= chunk_index_table_.size())
+                return {};
             const auto& entry = chunk_index_table_[idx];
 
-            if (stop_token.stop_requested()) return {};
+            if (stop_token.stop_requested())
+                return {};
 
             std::string compressed_blob;
             {
                 std::ifstream local_stream(filepath_, std::ios::binary | std::ios::in);
-                if (!local_stream.is_open()) return {};
+                if (!local_stream.is_open())
+                    return {};
 
                 // Fix A3: validate that the chunk is fully contained in the
                 // file before seeking.  A corrupt seek table can list offsets
@@ -683,15 +685,11 @@ namespace VTX {
                 // produce garbage that then crashes the deserialiser.
                 const int64_t file_size = GetStreamSize(local_stream);
                 const int64_t chunk_end =
-                    static_cast<int64_t>(entry.file_offset) +
-                    static_cast<int64_t>(entry.chunk_size_bytes);
-                if (entry.chunk_size_bytes == 0 ||
-                    static_cast<int64_t>(entry.file_offset) < 0 ||
+                    static_cast<int64_t>(entry.file_offset) + static_cast<int64_t>(entry.chunk_size_bytes);
+                if (entry.chunk_size_bytes == 0 || static_cast<int64_t>(entry.file_offset) < 0 ||
                     chunk_end > file_size) {
-                    VTX_ERROR("[READER] Chunk {} offset/size out of bounds (offset={}, size={}, file_size={})",
-                              idx,
-                              static_cast<int64_t>(entry.file_offset),
-                              static_cast<int64_t>(entry.chunk_size_bytes),
+                    VTX_ERROR("[READER] Chunk {} offset/size out of bounds (offset={}, size={}, file_size={})", idx,
+                              static_cast<int64_t>(entry.file_offset), static_cast<int64_t>(entry.chunk_size_bytes),
                               file_size);
                     return {};
                 }
@@ -706,22 +704,24 @@ namespace VTX {
                 // would otherwise leave `raw_buffer` half-filled with zeros
                 // and feed that to the deserialiser.
                 if (local_stream.gcount() != static_cast<std::streamsize>(entry.chunk_size_bytes)) {
-                    VTX_ERROR("[READER] Chunk {} short read: expected {} bytes, got {}",
-                              idx, entry.chunk_size_bytes,
+                    VTX_ERROR("[READER] Chunk {} short read: expected {} bytes, got {}", idx, entry.chunk_size_bytes,
                               static_cast<int64_t>(local_stream.gcount()));
                     return {};
                 }
 
-                if (raw_buffer.size() <= 4) return {};
+                if (raw_buffer.size() <= 4)
+                    return {};
                 compressed_blob = raw_buffer.substr(4);
             }
 
-            if (stop_token.stop_requested()) return {};
+            if (stop_token.stop_requested())
+                return {};
 
             try {
                 CachedChunk cc;
                 cc.index = idx;
-                SerializerPolicy::ProcessChunkData(idx, compressed_blob, stop_token, cc.native_frames, cc.decompressed_blob, cc.raw_frames_spans);
+                SerializerPolicy::ProcessChunkData(idx, compressed_blob, stop_token, cc.native_frames,
+                                                   cc.decompressed_blob, cc.raw_frames_spans);
                 return cc;
             } catch (const std::exception& e) {
                 VTX_ERROR("[READER] Chunk {} deserialization failed: {}", idx, e.what());
@@ -758,7 +758,7 @@ namespace VTX {
 
         mutable std::mutex cache_mutex_;
         ReplayReaderEvents events_;
-        mutable std::mutex events_mutex_;  // protects events_ (A4)
+        mutable std::mutex events_mutex_; // protects events_ (A4)
 
         uint32_t cache_backward_ = 2;
         uint32_t cache_forward_ = 2;
@@ -776,7 +776,6 @@ namespace VTX {
         int32_t last_requested_chunk_ = -1;
         float ewma_chunk_distance_ = 0.0f;
 
-        PropertyAddressCache property_address_cache_={};
+        PropertyAddressCache property_address_cache_ = {};
     };
-}
-
+} // namespace VTX
diff --git a/sdk/include/vtx/reader/core/vtx_reader_facade.h b/sdk/include/vtx/reader/core/vtx_reader_facade.h
index 35fc6e9..ce8e1ba 100644
--- a/sdk/include/vtx/reader/core/vtx_reader_facade.h
+++ b/sdk/include/vtx/reader/core/vtx_reader_facade.h
@@ -42,7 +42,8 @@ namespace VTX {
         virtual const VTX::Frame* GetFrame(int32_t frame_index) = 0;
         virtual const VTX::Frame* GetFrameSync(int frame_index) = 0;
         virtual void GetFrameRange(int32_t start_frame, int32_t range, std::vector<VTX::Frame>& out_frames) = 0;
-        virtual std::vector<VTX::Frame> GetFrameContext(int32_t center_frame, int32_t back_range, int32_t forward_range) = 0;
+        virtual std::vector<VTX::Frame> GetFrameContext(int32_t center_frame, int32_t back_range,
+                                                        int32_t forward_range) = 0;
         virtual const std::vector<ChunkIndexEntry>& GetSeekTable() const = 0;
         virtual VTX::FileHeader GetHeader() = 0;
         virtual VTX::FileFooter GetFooter() = 0;
@@ -59,7 +60,8 @@ namespace VTX {
     /// Bundles a reader, its detected format, chunk state, and file metadata.
     /// Returned by OpenReplayFile(). Chunk events are pre-wired automatically.
     struct ReaderContext {
-        ReaderContext() : chunk_state(std::make_unique<ReaderChunkState>()) {}
+        ReaderContext()
+            : chunk_state(std::make_unique<ReaderChunkState>()) {}
 
         explicit operator bool() const { return reader != nullptr; }
         IVtxReaderFacade* operator->() const { return reader.get(); }
@@ -73,7 +75,8 @@ namespace VTX {
             // async chunk-load callbacks capture a raw pointer into
             // chunk_state, so chunk_state must outlive the reader.
             reader.reset();
-            if (chunk_state) chunk_state->Reset();
+            if (chunk_state)
+                chunk_state->Reset();
             error.clear();
             format = VtxFormat::Unknown;
             size_in_mb = 0.0f;
@@ -95,4 +98,4 @@ namespace VTX {
     std::unique_ptr<IVtxReaderFacade> CreateProtobuffFacade(const std::string& filepath);
     ReaderContext OpenReplayFile(const std::string& filepath);
 
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/reader/core/vtx_schema_adapter.h b/sdk/include/vtx/reader/core/vtx_schema_adapter.h
index 14802f7..8934567 100644
--- a/sdk/include/vtx/reader/core/vtx_schema_adapter.h
+++ b/sdk/include/vtx/reader/core/vtx_schema_adapter.h
@@ -11,12 +11,12 @@ namespace fbsvtx {
 }
 
 namespace VTX {
-        
+
     // =========================================================================================
     // PROTOBUF (cppvtx::PropertySchema)
     // =========================================================================================
     template <>
-        struct SchemaAdapter<cppvtx::ContextualSchema> {
+    struct SchemaAdapter<cppvtx::ContextualSchema> {
         static void BuildCache(const cppvtx::ContextualSchema& src, PropertyAddressCache& cache);
     };
 
@@ -24,7 +24,7 @@ namespace VTX {
     // FLATBUFFERS (fbsvtx::PropertySchemaT)
     // =========================================================================================
     template <>
-        struct SchemaAdapter<fbsvtx::ContextualSchemaT> {
+    struct SchemaAdapter<fbsvtx::ContextualSchemaT> {
         static void BuildCache(const fbsvtx::ContextualSchemaT& src, PropertyAddressCache& cache);
     };
 
@@ -42,5 +42,5 @@ namespace VTX {
         }
     };
     */
-    
-}
\ No newline at end of file
+
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/reader/policies/formatters/flatbuffer_reader_policy.h b/sdk/include/vtx/reader/policies/formatters/flatbuffer_reader_policy.h
index 90d257f..9813a56 100644
--- a/sdk/include/vtx/reader/policies/formatters/flatbuffer_reader_policy.h
+++ b/sdk/include/vtx/reader/policies/formatters/flatbuffer_reader_policy.h
@@ -4,14 +4,13 @@
 #include <stop_token>
 #include "vtx/common/vtx_types.h"
 
-namespace fbsvtx
-{
+namespace fbsvtx {
     struct FileHeaderT;
     struct FileFooterT;
     struct ContextualSchemaT;
     struct FileHeaderT;
     struct FileFooterT;
-}
+} // namespace fbsvtx
 
 namespace VTX {
 
@@ -23,8 +22,11 @@ namespace VTX {
         static HeaderType ParseHeader(const std::string& buffer);
         static std::string GetMagicBytes();
         static FooterType ParseFooter(const std::string& buffer);
-        static void ProcessChunkData(int chunk_index,const std::string& compressed, std::stop_token st,std::vector<VTX::Frame>& out_native_frames,std::vector<uint8_t>& out_decompressed_blob,std::vector<std::span<const std::byte>>& out_raw_frames_spans);
-        static void PopulateIndexTable(const FooterType& footer,std::vector<ChunkIndexEntry>& chunk_index_table);
+        static void ProcessChunkData(int chunk_index, const std::string& compressed, std::stop_token st,
+                                     std::vector<VTX::Frame>& out_native_frames,
+                                     std::vector<uint8_t>& out_decompressed_blob,
+                                     std::vector<std::span<const std::byte>>& out_raw_frames_spans);
+        static void PopulateIndexTable(const FooterType& footer, std::vector<ChunkIndexEntry>& chunk_index_table);
         static void PopulateGameTimes(const FooterType& footer, VTX::GameTime::VTXGameTimes& game_times);
         static int32_t GetTotalFrames(const FooterType& footer);
         static const SchemaType& GetSchema(const HeaderType& header);
@@ -32,4 +34,4 @@ namespace VTX {
         static VTX::FileHeader GetVTXHeader(const HeaderType& fbs_header);
         static VTX::FileFooter GetVTXFooter(const FooterType& fbs_footer);
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/reader/policies/formatters/protobuff_reader_policy.h b/sdk/include/vtx/reader/policies/formatters/protobuff_reader_policy.h
index eb01976..0c7511b 100644
--- a/sdk/include/vtx/reader/policies/formatters/protobuff_reader_policy.h
+++ b/sdk/include/vtx/reader/policies/formatters/protobuff_reader_policy.h
@@ -9,7 +9,7 @@ namespace cppvtx {
     class FileHeader;
     class FileFooter;
     class ContextualSchema;
-}
+} // namespace cppvtx
 namespace VTX {
 
     struct ProtobufReaderPolicy {
@@ -20,13 +20,16 @@ namespace VTX {
         static std::string GetMagicBytes();
         static HeaderType ParseHeader(const std::string& buffer);
         static FooterType ParseFooter(const std::string& buffer);
-        static void ProcessChunkData(int chunk_index,const std::string& compressed, std::stop_token st,std::vector<VTX::Frame>& out_native_frames,std::vector<uint8_t>& out_decompressed_blob,std::vector<std::span<const std::byte>>& out_raw_frames_spans);
-        static void PopulateIndexTable(const FooterType& footer,std::vector<ChunkIndexEntry>& chunk_index_table);
-        static void PopulateGameTimes(const FooterType& footer, VTX::GameTime::VTXGameTimes& game_times);        
+        static void ProcessChunkData(int chunk_index, const std::string& compressed, std::stop_token st,
+                                     std::vector<VTX::Frame>& out_native_frames,
+                                     std::vector<uint8_t>& out_decompressed_blob,
+                                     std::vector<std::span<const std::byte>>& out_raw_frames_spans);
+        static void PopulateIndexTable(const FooterType& footer, std::vector<ChunkIndexEntry>& chunk_index_table);
+        static void PopulateGameTimes(const FooterType& footer, VTX::GameTime::VTXGameTimes& game_times);
         static int32_t GetTotalFrames(const FooterType& footer);
         static const SchemaType& GetSchema(const HeaderType& header);
         static VTX::ContextualSchema GetVTXContextualSchema(const HeaderType& header);
         static VTX::FileHeader GetVTXHeader(const HeaderType& fbs_header);
         static VTX::FileFooter GetVTXFooter(const FooterType& fbs_footer);
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/reader/serialization/flatbuffers_to_vtx.h b/sdk/include/vtx/reader/serialization/flatbuffers_to_vtx.h
index bb94c1a..e9a2d4b 100644
--- a/sdk/include/vtx/reader/serialization/flatbuffers_to_vtx.h
+++ b/sdk/include/vtx/reader/serialization/flatbuffers_to_vtx.h
@@ -15,7 +15,7 @@ namespace fbsvtx {
     struct ChunkIndexEntry;
     struct ReplayTimeData;
     struct TimelineEvent;
-}
+} // namespace fbsvtx
 
 namespace VTX {
     namespace Serialization {
@@ -24,7 +24,7 @@ namespace VTX {
         void FromFlat(const fbsvtx::Quat* src, VTX::Quat& dst);
         void FromFlat(const fbsvtx::Transform* src, VTX::Transform& dst);
         void FromFlat(const fbsvtx::FloatRange* src, VTX::FloatRange& dst);
-        
+
         void FromFlat(const fbsvtx::MapContainer* src, VTX::MapContainer& dst);
         void FromFlat(const fbsvtx::PropertyContainer* src, VTX::PropertyContainer& dst);
         void FromFlat(const fbsvtx::Bucket* src, VTX::Bucket& dst);
diff --git a/sdk/include/vtx/reader/serialization/proto_to_vtx.h b/sdk/include/vtx/reader/serialization/proto_to_vtx.h
index ec9dc65..8579f12 100644
--- a/sdk/include/vtx/reader/serialization/proto_to_vtx.h
+++ b/sdk/include/vtx/reader/serialization/proto_to_vtx.h
@@ -8,7 +8,7 @@ namespace cppvtx {
     class PropertyContainer;
     class Bucket;
     class Frame;
-}
+} // namespace cppvtx
 
 namespace VTX {
     namespace Serialization {
@@ -19,5 +19,5 @@ namespace VTX {
         void FromProto(const cppvtx::PropertyContainer& proto, VTX::PropertyContainer& out);
         void FromProto(const cppvtx::Bucket& proto, VTX::Bucket& out);
         void FromProto(const cppvtx::Frame& proto, VTX::Frame& out);
-    }
-}
\ No newline at end of file
+    } // namespace Serialization
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/writer/core/schema_dynamic_loader.h b/sdk/include/vtx/writer/core/schema_dynamic_loader.h
index 4291151..5671dd8 100644
--- a/sdk/include/vtx/writer/core/schema_dynamic_loader.h
+++ b/sdk/include/vtx/writer/core/schema_dynamic_loader.h
@@ -18,7 +18,7 @@
 #include "vtx/common/vtx_types_helpers.h"
 
 namespace VTX {
-    
+
     class SchemaDynamicLoader {
     private:
         const SchemaRegistry* registry_;
@@ -26,25 +26,28 @@ namespace VTX {
         bool debug_mode_;
 
     public:
-        explicit SchemaDynamicLoader(const SchemaRegistry& registry, 
-                                    const SchemaSanitizerRegistry* sanitizer = nullptr, 
-                                    bool debug_mode = false) 
-            : registry_(&registry), sanitizer_(sanitizer), debug_mode_(debug_mode) {}
+        explicit SchemaDynamicLoader(const SchemaRegistry& registry, const SchemaSanitizerRegistry* sanitizer = nullptr,
+                                     bool debug_mode = false)
+            : registry_(&registry)
+            , sanitizer_(sanitizer)
+            , debug_mode_(debug_mode) {}
 
 
         template <typename AdapterType>
         void Load(const AdapterType& adapter, const std::string& structName, PropertyContainer& outContainer) {
-            if (debug_mode_) std::cout << "[Loader] Loading struct: '" << structName << "'" << std::endl;
-            
-            if(!registry_)
-            {
-                if (debug_mode_) std::cerr << "[Loader][Error] Schema is null: " << std::endl;
+            if (debug_mode_)
+                std::cout << "[Loader] Loading struct: '" << structName << "'" << std::endl;
+
+            if (!registry_) {
+                if (debug_mode_)
+                    std::cerr << "[Loader][Error] Schema is null: " << std::endl;
                 return;
             }
-            
+
             const SchemaStruct* schema = registry_->GetStruct(structName);
             if (!schema) {
-                if (debug_mode_) std::cerr << "[Loader][Error] Schema not found: " << structName << std::endl;
+                if (debug_mode_)
+                    std::cerr << "[Loader][Error] Schema not found: " << structName << std::endl;
                 return;
             }
 
@@ -61,122 +64,134 @@ namespace VTX {
 
                 if (field.container_type == FieldContainerType::Array) {
                     LoadArray(child_adapter, field, outContainer);
-                } 
-                else if (field.type_id == FieldType::Struct) {
+                } else if (field.type_id == FieldType::Struct) {
                     Load(child_adapter, field.struct_type, outContainer.any_struct_properties[field.index]);
-                } 
-                else {
+                } else {
                     LoadSingleField(child_adapter, field, outContainer);
                 }
             }
 
             if (sanitizer_) {
-                SanitizeContext ctx{structName,schema,true};// is_loading = true, we are in loading phase
+                SanitizeContext ctx {structName, schema, true}; // is_loading = true, we are in loading phase
                 sanitizer_->TrySanitize(outContainer, ctx);
             }
-            
+
             outContainer.content_hash = Helpers::CalculateContainerHash(outContainer);
         }
 
     private:
-
         template <typename AdapterType>
         void LoadSingleField(const AdapterType& node, const SchemaField& field, PropertyContainer& out) {
             const int32_t idx = field.index;
             try {
                 switch (field.type_id) {
-                    case FieldType::Int32:  out.int32_properties[idx] = node.template GetValue<int32_t>(); break;
-                    case FieldType::Int64:  out.int64_properties[idx] = node.template GetValue<int64_t>(); break;
-                    case FieldType::Float:  out.float_properties[idx] = node.template GetValue<float>(); break;
-                    case FieldType::Double: out.double_properties[idx] = node.template GetValue<double>(); break;
-                    case FieldType::Bool:   out.bool_properties[idx] = node.template GetValue<bool>(); break;
-                    case FieldType::String: out.string_properties[idx] = node.template GetValue<std::string>(); break;
-
-                    case FieldType::Vector: {
-                        out.vector_properties[idx] = {
-                            node.GetChild("x").template GetValue<double>(),
-                            node.GetChild("y").template GetValue<double>(),
-                            node.GetChild("z").template GetValue<double>()
-                        };
-                        break;
-                    }
-                    case FieldType::Quat: {
-                        out.quat_properties[idx] = {
-                            node.GetChild("x").template GetValue<float>(),
-                            node.GetChild("y").template GetValue<float>(),
-                            node.GetChild("z").template GetValue<float>(),
-                            node.GetChild("w").template GetValue<float>()
-                        };
-                        break;
-                    }
-                    case FieldType::FloatRange: {
-                        out.range_properties[idx] = {
-                            node.GetChild("min").template GetValue<float>(),
-                            node.GetChild("max").template GetValue<float>(),
-                            node.GetChild("value").template GetValue<float>()
-                        };
-                        break;
-                    }
-                    case FieldType::Transform: {
-                        Transform t;
-                        auto loc = node.GetChild("translation");
-                        t.translation = { loc.GetChild("x").template GetValue<double>(), loc.GetChild("y").template GetValue<double>(), loc.GetChild("z").template GetValue<double>() };
-                        
-                        auto rot = node.GetChild("rotation");
-                        t.rotation = { rot.GetChild("x").template GetValue<float>(), rot.GetChild("y").template GetValue<float>(), rot.GetChild("z").template GetValue<float>(), rot.GetChild("w").template GetValue<float>() };
-                        
-                        auto scl = node.GetChild("scale");
-                        t.scale = { scl.GetChild("x").template GetValue<double>(), scl.GetChild("y").template GetValue<double>(), scl.GetChild("z").template GetValue<double>() };
-                        
-                        out.transform_properties[idx] = t;
-                        break;
-                    }
-                    default: break;
+                case FieldType::Int32:
+                    out.int32_properties[idx] = node.template GetValue<int32_t>();
+                    break;
+                case FieldType::Int64:
+                    out.int64_properties[idx] = node.template GetValue<int64_t>();
+                    break;
+                case FieldType::Float:
+                    out.float_properties[idx] = node.template GetValue<float>();
+                    break;
+                case FieldType::Double:
+                    out.double_properties[idx] = node.template GetValue<double>();
+                    break;
+                case FieldType::Bool:
+                    out.bool_properties[idx] = node.template GetValue<bool>();
+                    break;
+                case FieldType::String:
+                    out.string_properties[idx] = node.template GetValue<std::string>();
+                    break;
+
+                case FieldType::Vector: {
+                    out.vector_properties[idx] = {node.GetChild("x").template GetValue<double>(),
+                                                  node.GetChild("y").template GetValue<double>(),
+                                                  node.GetChild("z").template GetValue<double>()};
+                    break;
+                }
+                case FieldType::Quat: {
+                    out.quat_properties[idx] = {
+                        node.GetChild("x").template GetValue<float>(), node.GetChild("y").template GetValue<float>(),
+                        node.GetChild("z").template GetValue<float>(), node.GetChild("w").template GetValue<float>()};
+                    break;
+                }
+                case FieldType::FloatRange: {
+                    out.range_properties[idx] = {node.GetChild("min").template GetValue<float>(),
+                                                 node.GetChild("max").template GetValue<float>(),
+                                                 node.GetChild("value").template GetValue<float>()};
+                    break;
+                }
+                case FieldType::Transform: {
+                    Transform t;
+                    auto loc = node.GetChild("translation");
+                    t.translation = {loc.GetChild("x").template GetValue<double>(),
+                                     loc.GetChild("y").template GetValue<double>(),
+                                     loc.GetChild("z").template GetValue<double>()};
+
+                    auto rot = node.GetChild("rotation");
+                    t.rotation = {
+                        rot.GetChild("x").template GetValue<float>(), rot.GetChild("y").template GetValue<float>(),
+                        rot.GetChild("z").template GetValue<float>(), rot.GetChild("w").template GetValue<float>()};
+
+                    auto scl = node.GetChild("scale");
+                    t.scale = {scl.GetChild("x").template GetValue<double>(),
+                               scl.GetChild("y").template GetValue<double>(),
+                               scl.GetChild("z").template GetValue<double>()};
+
+                    out.transform_properties[idx] = t;
+                    break;
+                }
+                default:
+                    break;
                 }
             } catch (const std::exception& e) {
-                if (debug_mode_) std::cerr << "[Loader] Error loading field '" << field.name << "': " << e.what() << std::endl;
+                if (debug_mode_)
+                    std::cerr << "[Loader] Error loading field '" << field.name << "': " << e.what() << std::endl;
             }
         }
 
 
         template <typename AdapterType>
         void LoadArray(const AdapterType& arrayNode, const SchemaField& field, PropertyContainer& out) {
-            if (!arrayNode.IsArray()) return;
-            
+            if (!arrayNode.IsArray())
+                return;
+
             const size_t count = arrayNode.Size();
             const int32_t idx = field.index;
 
             switch (field.type_id) {
-                case FieldType::Int32:
-                    for (size_t i = 0; i < count; ++i) 
-                        out.int32_arrays.PushBack(idx, arrayNode.GetElement(i).template GetValue<int32_t>());
-                    break;
-                case FieldType::Float:
-                    for (size_t i = 0; i < count; ++i) 
-                        out.float_arrays.PushBack(idx, arrayNode.GetElement(i).template GetValue<float>());
-                    break;
-                case FieldType::String:
-                    for (size_t i = 0; i < count; ++i) 
-                        out.string_arrays.PushBack(idx, arrayNode.GetElement(i).template GetValue<std::string>());
-                    break;
-                case FieldType::Vector:
-                    for (size_t i = 0; i < count; ++i) {
-                        auto elem = arrayNode.GetElement(i);
-                        Vector v{ elem.GetChild("x").template GetValue<double>(), 
-                                  elem.GetChild("y").template GetValue<double>(), 
-                                  elem.GetChild("z").template GetValue<double>() };
-                        out.vector_arrays.PushBack(idx, v);
-                    }
-                    break;
-                case FieldType::Struct:
-                    for (size_t i = 0; i < count; ++i) {
-                        PropertyContainer childContainer;
-                        Load(arrayNode.GetElement(i), field.struct_type, childContainer);
-                        out.any_struct_arrays.PushBack(idx, childContainer);
-                    }
-                    break;
-                default: break;
+            case FieldType::Int32:
+                for (size_t i = 0; i < count; ++i)
+                    out.int32_arrays.PushBack(idx, arrayNode.GetElement(i).template GetValue<int32_t>());
+                break;
+            case FieldType::Float:
+                for (size_t i = 0; i < count; ++i)
+                    out.float_arrays.PushBack(idx, arrayNode.GetElement(i).template GetValue<float>());
+                break;
+            case FieldType::String:
+                for (size_t i = 0; i < count; ++i)
+                    out.string_arrays.PushBack(idx, arrayNode.GetElement(i).template GetValue<std::string>());
+                break;
+            case FieldType::Vector:
+                for (size_t i = 0; i < count; ++i) {
+                    auto elem = arrayNode.GetElement(i);
+                    Vector v {elem.GetChild("x").template GetValue<double>(),
+                              elem.GetChild("y").template GetValue<double>(),
+                              elem.GetChild("z").template GetValue<double>()};
+                    out.vector_arrays.PushBack(idx, v);
+                }
+                break;
+            case FieldType::Struct:
+                for (size_t i = 0; i < count; ++i) {
+                    PropertyContainer childContainer;
+                    Load(arrayNode.GetElement(i), field.struct_type, childContainer);
+                    out.any_struct_arrays.PushBack(idx, childContainer);
+                }
+                break;
+            default:
+                break;
             }
         }
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/writer/core/schema_sanitizer.h b/sdk/include/vtx/writer/core/schema_sanitizer.h
index fcefe36..c8b6382 100644
--- a/sdk/include/vtx/writer/core/schema_sanitizer.h
+++ b/sdk/include/vtx/writer/core/schema_sanitizer.h
@@ -16,10 +16,9 @@ namespace VTX {
 
     class SchemaSanitizerRegistry {
         std::unordered_map<std::string, SanitizeFunc> _processors;
+
     public:
-        void Register(const std::string& structName, const SanitizeFunc& func) {
-            _processors[structName] = func;
-        }
+        void Register(const std::string& structName, const SanitizeFunc& func) { _processors[structName] = func; }
 
         void TrySanitize(PropertyContainer& container, const SanitizeContext& ctx) const {
             auto it = _processors.find(ctx.struct_name);
@@ -28,4 +27,4 @@ namespace VTX {
             }
         }
     };
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/writer/core/vtx_data_source.h b/sdk/include/vtx/writer/core/vtx_data_source.h
index ea51044..07a4120 100644
--- a/sdk/include/vtx/writer/core/vtx_data_source.h
+++ b/sdk/include/vtx/writer/core/vtx_data_source.h
@@ -11,4 +11,4 @@ namespace VTX {
         virtual size_t GetExpectedTotalFrames() const = 0;
     };
 
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/writer/core/vtx_record_pipeline.h b/sdk/include/vtx/writer/core/vtx_record_pipeline.h
index 75936df..e118cca 100644
--- a/sdk/include/vtx/writer/core/vtx_record_pipeline.h
+++ b/sdk/include/vtx/writer/core/vtx_record_pipeline.h
@@ -8,10 +8,11 @@ namespace VTX {
     class RecordPipeline {
     public:
         RecordPipeline(std::unique_ptr<IFrameDataSource> source, std::unique_ptr<IVtxWriterFacade> writer);
-        bool Run(std::function<void(float,std::string)> on_progress = nullptr);
+        bool Run(std::function<void(float, std::string)> on_progress = nullptr);
+
     private:
         std::unique_ptr<IFrameDataSource> source_;
         std::unique_ptr<IVtxWriterFacade> writer_;
     };
 
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/writer/core/vtx_writer_facade.h b/sdk/include/vtx/writer/core/vtx_writer_facade.h
index 131e533..f10501a 100644
--- a/sdk/include/vtx/writer/core/vtx_writer_facade.h
+++ b/sdk/include/vtx/writer/core/vtx_writer_facade.h
@@ -15,12 +15,13 @@ namespace VTX {
     public:
         virtual ~IVtxWriterFacade() = default;
 
-        virtual void RecordFrame(VTX::Frame& native_frame, const VTX::GameTime::GameTimeRegister& game_time_register) = 0;
+        virtual void RecordFrame(VTX::Frame& native_frame,
+                                 const VTX::GameTime::GameTimeRegister& game_time_register) = 0;
         virtual void Flush() = 0;
         virtual void Stop() = 0;
-        virtual  VTX::SchemaRegistry& GetSchema() = 0 ;
+        virtual VTX::SchemaRegistry& GetSchema() = 0;
     };
-    
+
     struct WriterFacadeConfig {
         std::string replay_name = "";
         std::string replay_uuid = "";
@@ -31,19 +32,13 @@ namespace VTX {
         size_t chunk_max_bytes = 10 * 1024 * 1024; // 10 MB
         bool use_compression = true;
         std::string schema_json_path = "";
-        
     };
-    enum class SerializationFormat : uint8_t
-    {
+    enum class SerializationFormat : uint8_t {
         Flatbuffers,
         Protobuffs,
     };
 
-    std::unique_ptr<IVtxWriterFacade> CreateFlatBuffersWriterFacade(
-        const WriterFacadeConfig& config
-    );
+    std::unique_ptr<IVtxWriterFacade> CreateFlatBuffersWriterFacade(const WriterFacadeConfig& config);
 
-    std::unique_ptr<IVtxWriterFacade> CreateProtobuffWriterFacade(
-        const WriterFacadeConfig& config
-    );
-}
+    std::unique_ptr<IVtxWriterFacade> CreateProtobuffWriterFacade(const WriterFacadeConfig& config);
+} // namespace VTX
diff --git a/sdk/include/vtx/writer/core/writer.h b/sdk/include/vtx/writer/core/writer.h
index 96ce3f1..b465198 100644
--- a/sdk/include/vtx/writer/core/writer.h
+++ b/sdk/include/vtx/writer/core/writer.h
@@ -6,8 +6,7 @@
 
 
 namespace VTX {
-    namespace ChunkingPolicy
-    {
+    namespace ChunkingPolicy {
         struct ThresholdChunkPolicy {
             int32_t max_frames = 1000;
             size_t max_bytes = 10 * 1024 * 1024;
@@ -19,18 +18,18 @@ namespace VTX {
         struct InstantFlushPolicy {
             bool ShouldFlush(size_t, size_t, size_t) const { return true; }
         };
-    }
+    } // namespace ChunkingPolicy
 
 
     template <typename SinkPolicy, typename ChunkingPolicy = ChunkingPolicy::ThresholdChunkPolicy>
     class ReplayWriter {
     public:
         using Serializer = typename SinkPolicy::SerializerPolicy;
-        using FrameType  = typename SinkPolicy::FrameType;
+        using FrameType = typename SinkPolicy::FrameType;
         using SchemaType = typename SinkPolicy::SchemaType;
 
         struct Config {
-            typename SinkPolicy::Config sink_config; 
+            typename SinkPolicy::Config sink_config;
             float default_fps = 60.0f;
             bool is_increasing = true;
             ChunkingPolicy chunker_config;
@@ -38,19 +37,19 @@ namespace VTX {
         };
 
         ReplayWriter(Config config)
-            : sink_(config.sink_config),
-              chunker_(config.chunker_config), registry_({}), sanitizer_(nullptr)
-        {
+            : sink_(config.sink_config)
+            , chunker_(config.chunker_config)
+            , registry_({})
+            , sanitizer_(nullptr) {
             timer_.Setup(config.default_fps, config.is_increasing);
             registry_.LoadFromJson(config.schema_json_path);
             auto schema = Serializer::CreateSchema(registry_);
             sink_.OnSessionStart(schema);
         }
 
-        void RecordFrame(VTX::Frame& native_frame, const VTX::GameTime::GameTimeRegister& game_time_register) 
-        {
+        void RecordFrame(VTX::Frame& native_frame, const VTX::GameTime::GameTimeRegister& game_time_register) {
             timer_.CreateSnapshot();
-            
+
             if (!timer_.AddTimeRegistry(game_time_register)) {
                 timer_.Rollback();
                 return;
@@ -61,13 +60,12 @@ namespace VTX {
                 timer_.Rollback();
                 return;
             }
-            
+
             std::unique_ptr<FrameType> sink_frame = Serializer::FromNative(std::move(native_frame));
             size_t frameSize = Serializer::GetFrameSize(*sink_frame);
-    
-            if (!pending_frames_.empty() && 
-                chunker_.ShouldFlush(pending_frames_.size(), current_chunk_bytes_, frameSize)) 
-            {
+
+            if (!pending_frames_.empty() &&
+                chunker_.ShouldFlush(pending_frames_.size(), current_chunk_bytes_, frameSize)) {
                 Flush();
             }
 
@@ -77,13 +75,14 @@ namespace VTX {
         }
 
         void Flush() {
-            if (pending_frames_.empty()) return;
+            if (pending_frames_.empty())
+                return;
 
             int32_t start_frame = total_frames_ - static_cast<int32_t>(pending_frames_.size());
-            auto time_chunk = timer_.GetLastChunkCreatedUtc(); 
+            auto time_chunk = timer_.GetLastChunkCreatedUtc();
             sink_.SaveChunk(pending_frames_, time_chunk, start_frame, total_frames_);
-            
-            pending_frames_.clear(); 
+
+            pending_frames_.clear();
             current_chunk_bytes_ = 0;
             timer_.UpdateChunkStartIndex();
         }
@@ -93,33 +92,31 @@ namespace VTX {
             VTX::SessionFooter footer_data;
             footer_data.total_frames = total_frames_;
             footer_data.duration_seconds = timer_.GetDuration();
-            
+
             const auto& v_gametime = timer_.GetGameTime();
-            const auto& v_utc      = timer_.GetCreatedUtc();
-            const auto& v_gaps     = timer_.GetTimelineGaps();
-            const auto& v_seg      = timer_.GetGameSegments();
+            const auto& v_utc = timer_.GetCreatedUtc();
+            const auto& v_gaps = timer_.GetTimelineGaps();
+            const auto& v_seg = timer_.GetGameSegments();
 
-            footer_data.game_times  = &v_gametime;
+            footer_data.game_times = &v_gametime;
             footer_data.created_utc = &v_utc;
-            footer_data.gaps        = &v_gaps;
-            footer_data.segments    = &v_seg;
-            
+            footer_data.gaps = &v_gaps;
+            footer_data.segments = &v_seg;
+
             sink_.Close(footer_data);
         }
 
-        VTX::SchemaRegistry& GetRegistry()
-        {
-            return registry_;
-        }
+        VTX::SchemaRegistry& GetRegistry() { return registry_; }
+
     private:
         SinkPolicy sink_;
         ChunkingPolicy chunker_;
-        
+
         VTX::SchemaRegistry registry_;
         const SchemaSanitizerRegistry* sanitizer_;
         std::vector<std::unique_ptr<FrameType>> pending_frames_;
-        VTX::GameTime::VTXGameTimes timer_; 
+        VTX::GameTime::VTXGameTimes timer_;
         size_t current_chunk_bytes_ = 0;
         int32_t total_frames_ = 0;
     };
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/writer/policies/formatters/flatbuffers_vtx_policy.h b/sdk/include/vtx/writer/policies/formatters/flatbuffers_vtx_policy.h
index 3bea488..f86ad2d 100644
--- a/sdk/include/vtx/writer/policies/formatters/flatbuffers_vtx_policy.h
+++ b/sdk/include/vtx/writer/policies/formatters/flatbuffers_vtx_policy.h
@@ -3,16 +3,15 @@
 #include "vtx/common/readers/schema_reader/schema_registry.h"
 #include "vtx/writer/serialization/vtx_to_flatbuffer.h"
 
-namespace fbsvtx
-{
+namespace fbsvtx {
     struct ContextualSchemaT;
 }
 
 namespace VTX {
 
-    struct  FlatBuffersVtxPolicy {
-        using HeaderType      = VTX::SessionConfig;
-        using FrameType       = VTX::Frame; 
+    struct FlatBuffersVtxPolicy {
+        using HeaderType = VTX::SessionConfig;
+        using FrameType = VTX::Frame;
         using SchemaType = std::unique_ptr<fbsvtx::ContextualSchemaT>;
 
         static std::string GetMagicBytes();
@@ -20,7 +19,9 @@ namespace VTX {
         static size_t GetFrameSize(const FrameType& /*frame*/);
         static SchemaType CreateSchema(const SchemaRegistry& registry);
         static std::string SerializeHeader(const VTX::SessionConfig& config, const SchemaType& schema);
-        static std::string SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames, int32_t chunk_idx, bool is_compressed);
-        static std::string SerializeFooter(const std::vector<ChunkIndexData>& seek_table, const SessionFooter& footer_data);
+        static std::string SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames, int32_t chunk_idx,
+                                          bool is_compressed);
+        static std::string SerializeFooter(const std::vector<ChunkIndexData>& seek_table,
+                                           const SessionFooter& footer_data);
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/writer/policies/formatters/protobuff_vtx_policy.h b/sdk/include/vtx/writer/policies/formatters/protobuff_vtx_policy.h
index 8bff563..edea78b 100644
--- a/sdk/include/vtx/writer/policies/formatters/protobuff_vtx_policy.h
+++ b/sdk/include/vtx/writer/policies/formatters/protobuff_vtx_policy.h
@@ -6,29 +6,29 @@
 #include "vtx/common/vtx_types.h"
 #include "vtx/common/readers/schema_reader/schema_registry.h"
 
-namespace cppvtx
-{
+namespace cppvtx {
     class Frame;
     class ContextualSchema;
-}
+} // namespace cppvtx
 
 namespace VTX {
     struct ProtobufVtxPolicy {
-        using FrameType  = cppvtx::Frame;
+        using FrameType = cppvtx::Frame;
         using SchemaType = cppvtx::ContextualSchema;
         using HeaderType = VTX::SessionConfig;
 
         static std::string GetMagicBytes();
-        
+
         static std::unique_ptr<FrameType> FromNative(VTX::Frame&& native);
-        
+
         static size_t GetFrameSize(const FrameType& frame);
 
         static SchemaType CreateSchema(const SchemaRegistry& registry);
-        
+
         static std::string SerializeHeader(const VTX::SessionConfig& config, const SchemaType& schema);
-        static std::string SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames, int32_t chunkIdx, bool is_compressed);
-        static std::string SerializeFooter(const std::vector<ChunkIndexData>& seekTable, 
+        static std::string SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames, int32_t chunkIdx,
+                                          bool is_compressed);
+        static std::string SerializeFooter(const std::vector<ChunkIndexData>& seekTable,
                                            const SessionFooter& footerData);
     };
-}
+} // namespace VTX
diff --git a/sdk/include/vtx/writer/policies/sinks/file_sink.h b/sdk/include/vtx/writer/policies/sinks/file_sink.h
index 64d2d4d..106c597 100644
--- a/sdk/include/vtx/writer/policies/sinks/file_sink.h
+++ b/sdk/include/vtx/writer/policies/sinks/file_sink.h
@@ -7,90 +7,86 @@
 #include <zstd.h>
 #include "vtx/common/vtx_types.h"
 #include "vtx/common/vtx_concepts.h"
-namespace VTX
-{
-    
+namespace VTX {
+
     template <IVtxWriterPolicy Policy>
-    class ChunkedFileSink
-    {
-        public:
+    class ChunkedFileSink {
+    public:
         using SerializerPolicy = Policy;
-            using FrameType  = typename SerializerPolicy::FrameType;
-            using SchemaType = typename SerializerPolicy::SchemaType;
-            using HeaderType = typename SerializerPolicy::HeaderType;
-
-            struct Config {
-                std::string filename;
-                HeaderType header_config;
-                bool b_use_compression = true;
-                int8_t compression_level = 10;
-            };
-            
-            explicit ChunkedFileSink(Config config) : config_(std::move(config)) {
-                file_.open(config_.filename, std::ios::binary | std::ios::out | std::ios::trunc);
-                if (!file_.is_open()) throw std::runtime_error("VTX: Could not open " + config_.filename);
-            }
+        using FrameType = typename SerializerPolicy::FrameType;
+        using SchemaType = typename SerializerPolicy::SchemaType;
+        using HeaderType = typename SerializerPolicy::HeaderType;
 
-            void OnSessionStart(const SchemaType& schema) {
-
-                //this writes the vrx format, ie  "VTXP"(protobuff) VTXF(flatbuffer)
-                std::string magic_bytes = SerializerPolicy::GetMagicBytes();
-                WriteBlob(magic_bytes);
-                
-                std::string header_payload = SerializerPolicy::SerializeHeader(config_.header_config, schema);
-                header_payload = CompressIfBeneficial(std::move(header_payload));
-                uint32_t final_size = static_cast<uint32_t>(header_payload.size());
-                file_.write(reinterpret_cast<const char*>(&final_size), sizeof(final_size));
-                file_.write(header_payload.data(), final_size);
-            }
-        
-            void SaveChunk(std::vector<std::unique_ptr<FrameType>>& frames, 
-                           const std::vector<int64_t>& created_utc,
-                           int32_t start_frame, 
-                           int32_t total_frames) 
-            {
-                if (frames.empty()) return;
-                
-                float chunk_start_time = 0.0f;
-                float chunk_end_time = 0.0f;
-                if (!created_utc.empty()) {
-                    chunk_start_time = static_cast<float>(created_utc.front());
-                    chunk_end_time = static_cast<float>(created_utc.back());
-                }
-                
-                std::string payload = SerializerPolicy::SerializeChunk(frames, chunkIndex_,config_.b_use_compression);
-                payload = CompressIfBeneficial(std::move(payload));
-                
-                uint64_t current_offset = file_.tellp();
-                uint32_t final_size = static_cast<uint32_t>(payload.size());
-
-                file_.write(reinterpret_cast<const char*>(&final_size), sizeof(final_size));
-                file_.write(payload.data(), final_size);
-
-                ChunkIndexData indexEntry;
-                indexEntry.chunk_index = chunkIndex_++;
-                indexEntry.file_offset = current_offset;
-                indexEntry.start_frame = start_frame;
-                indexEntry.end_frame = total_frames - 1;
-                indexEntry.chunk_size_bytes = final_size + sizeof(uint32_t);
-                seek_table_.push_back(indexEntry);
+        struct Config {
+            std::string filename;
+            HeaderType header_config;
+            bool b_use_compression = true;
+            int8_t compression_level = 10;
+        };
+
+        explicit ChunkedFileSink(Config config)
+            : config_(std::move(config)) {
+            file_.open(config_.filename, std::ios::binary | std::ios::out | std::ios::trunc);
+            if (!file_.is_open())
+                throw std::runtime_error("VTX: Could not open " + config_.filename);
+        }
+
+        void OnSessionStart(const SchemaType& schema) {
+            //this writes the vrx format, ie  "VTXP"(protobuff) VTXF(flatbuffer)
+            std::string magic_bytes = SerializerPolicy::GetMagicBytes();
+            WriteBlob(magic_bytes);
+
+            std::string header_payload = SerializerPolicy::SerializeHeader(config_.header_config, schema);
+            header_payload = CompressIfBeneficial(std::move(header_payload));
+            uint32_t final_size = static_cast<uint32_t>(header_payload.size());
+            file_.write(reinterpret_cast<const char*>(&final_size), sizeof(final_size));
+            file_.write(header_payload.data(), final_size);
+        }
+
+        void SaveChunk(std::vector<std::unique_ptr<FrameType>>& frames, const std::vector<int64_t>& created_utc,
+                       int32_t start_frame, int32_t total_frames) {
+            if (frames.empty())
+                return;
+
+            float chunk_start_time = 0.0f;
+            float chunk_end_time = 0.0f;
+            if (!created_utc.empty()) {
+                chunk_start_time = static_cast<float>(created_utc.front());
+                chunk_end_time = static_cast<float>(created_utc.back());
             }
-        
+
+            std::string payload = SerializerPolicy::SerializeChunk(frames, chunkIndex_, config_.b_use_compression);
+            payload = CompressIfBeneficial(std::move(payload));
+
+            uint64_t current_offset = file_.tellp();
+            uint32_t final_size = static_cast<uint32_t>(payload.size());
+
+            file_.write(reinterpret_cast<const char*>(&final_size), sizeof(final_size));
+            file_.write(payload.data(), final_size);
+
+            ChunkIndexData indexEntry;
+            indexEntry.chunk_index = chunkIndex_++;
+            indexEntry.file_offset = current_offset;
+            indexEntry.start_frame = start_frame;
+            indexEntry.end_frame = total_frames - 1;
+            indexEntry.chunk_size_bytes = final_size + sizeof(uint32_t);
+            seek_table_.push_back(indexEntry);
+        }
+
         void Close(const SessionFooter& footerData) {
-            if (!file_.is_open()) return;
+            if (!file_.is_open())
+                return;
             std::string footer_payload = SerializerPolicy::SerializeFooter(seek_table_, footerData);
             footer_payload = CompressIfBeneficial(std::move(footer_payload));
-                
+
             file_.write(footer_payload.data(), footer_payload.size());
             uint32_t final_size = static_cast<uint32_t>(footer_payload.size());
             file_.write(reinterpret_cast<const char*>(&final_size), sizeof(final_size));
             WriteBlob(SerializerPolicy::GetMagicBytes());
         }
 
-        private:
-            void WriteBlob(const std::string& data) {
-                file_.write(data.data(), data.size());
-            }
+    private:
+        void WriteBlob(const std::string& data) { file_.write(data.data(), data.size()); }
 
         std::string CompressIfBeneficial(std::string payload) {
             if (!config_.b_use_compression || payload.size() < 512) {
@@ -100,14 +96,11 @@ namespace VTX
             size_t const max_size = ZSTD_compressBound(payload.size());
             std::string compressed_blob(max_size, '\0');
 
-            size_t const compressed_size = ZSTD_compress(
-                compressed_blob.data(), max_size, 
-                payload.data(), payload.size(), 
-                config_.compression_level
-            );
+            size_t const compressed_size = ZSTD_compress(compressed_blob.data(), max_size, payload.data(),
+                                                         payload.size(), config_.compression_level);
 
             if (ZSTD_isError(compressed_size)) {
-                return payload; 
+                return payload;
             }
 
             if (compressed_size >= payload.size()) {
@@ -117,12 +110,10 @@ namespace VTX
             compressed_blob.resize(compressed_size);
             return compressed_blob;
         }
-        
+
         Config config_;
         std::ofstream file_;
         int32_t chunkIndex_ = 0;
-        std::vector<ChunkIndexData> seek_table_;//Generic tables, format agnostic
+        std::vector<ChunkIndexData> seek_table_; //Generic tables, format agnostic
     };
-};
-
-    
+}; // namespace VTX
diff --git a/sdk/include/vtx/writer/serialization/vtx_to_flatbuffer.h b/sdk/include/vtx/writer/serialization/vtx_to_flatbuffer.h
index 05a331d..24dd7ee 100644
--- a/sdk/include/vtx/writer/serialization/vtx_to_flatbuffer.h
+++ b/sdk/include/vtx/writer/serialization/vtx_to_flatbuffer.h
@@ -4,7 +4,8 @@
 #include <flatbuffers/flatbuffer_builder.h>
 
 namespace flatbuffers {
-    template<typename T> struct Offset;
+    template <typename T>
+    struct Offset;
 }
 
 namespace fbsvtx {
@@ -16,20 +17,22 @@ namespace fbsvtx {
     struct MapContainer;
     struct Bucket;
     struct Frame;
-}
+} // namespace fbsvtx
 
 namespace VTX {
     namespace Serialization {
 
-        fbsvtx::Vector     ToFlat(VTX::Vector& v);
-        fbsvtx::Quat       ToFlat(VTX::Quat& q);
-        fbsvtx::Transform  ToFlat(VTX::Transform& t);
+        fbsvtx::Vector ToFlat(VTX::Vector& v);
+        fbsvtx::Quat ToFlat(VTX::Quat& q);
+        fbsvtx::Transform ToFlat(VTX::Transform& t);
         fbsvtx::FloatRange ToFlat(VTX::FloatRange& r);
 
-        flatbuffers::Offset<fbsvtx::MapContainer>      ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::MapContainer& src);
-        flatbuffers::Offset<fbsvtx::PropertyContainer> ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::PropertyContainer& src);
-        flatbuffers::Offset<fbsvtx::Bucket>              ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::Bucket& src);
-        flatbuffers::Offset<fbsvtx::Frame>             ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::Frame& src);
+        flatbuffers::Offset<fbsvtx::MapContainer> ToFlat(flatbuffers::FlatBufferBuilder& builder,
+                                                         VTX::MapContainer& src);
+        flatbuffers::Offset<fbsvtx::PropertyContainer> ToFlat(flatbuffers::FlatBufferBuilder& builder,
+                                                              VTX::PropertyContainer& src);
+        flatbuffers::Offset<fbsvtx::Bucket> ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::Bucket& src);
+        flatbuffers::Offset<fbsvtx::Frame> ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::Frame& src);
 
     } // namespace Serialization
 } // namespace VTX
\ No newline at end of file
diff --git a/sdk/include/vtx/writer/serialization/vtx_to_proto.h b/sdk/include/vtx/writer/serialization/vtx_to_proto.h
index 68bc3c7..62e5b70 100644
--- a/sdk/include/vtx/writer/serialization/vtx_to_proto.h
+++ b/sdk/include/vtx/writer/serialization/vtx_to_proto.h
@@ -30,7 +30,7 @@ namespace VTX {
          * @param src The source native Quat (x, y, z, w).
          * @param dst The destination Protobuf message pointer.
          */
-        inline void ToProto( VTX::Quat& src, cppvtx::Quat* dst) {
+        inline void ToProto(VTX::Quat& src, cppvtx::Quat* dst) {
             dst->set_x(src.x);
             dst->set_y(src.y);
             dst->set_z(src.z);
@@ -58,7 +58,7 @@ namespace VTX {
             dst->set_max(src.max);
             dst->set_value_normalized(src.value_normalized);
         }
-        
+
         /**
          * @brief Serializes a PropertyContainer containing various data types.
          * * This function handles:
@@ -70,96 +70,125 @@ namespace VTX {
          * @param dst The destination Protobuf message pointer.
          */
         inline void ToProto(VTX::PropertyContainer& src, cppvtx::PropertyContainer* dst) {
-            
             src.content_hash = VTX::Helpers::CalculateContainerHash(src);
-            
+
             dst->set_type_id(src.entity_type_id);
             dst->set_content_hash(src.content_hash);
             // --- Scalar Properties ---
-            for (auto val : src.int32_properties)  dst->add_int32_properties(val);
-            for (auto val : src.int64_properties)  dst->add_int64_properties(val);
-            for (auto val : src.float_properties)  dst->add_float_properties(val);
-            for (auto val : src.double_properties) dst->add_double_properties(val);
-            for (auto val : src.bool_properties)   dst->add_bool_properties(val);
-            for (auto& val : src.string_properties) dst->add_string_properties(val);
+            for (auto val : src.int32_properties)
+                dst->add_int32_properties(val);
+            for (auto val : src.int64_properties)
+                dst->add_int64_properties(val);
+            for (auto val : src.float_properties)
+                dst->add_float_properties(val);
+            for (auto val : src.double_properties)
+                dst->add_double_properties(val);
+            for (auto val : src.bool_properties)
+                dst->add_bool_properties(val);
+            for (auto& val : src.string_properties)
+                dst->add_string_properties(val);
 
             // --- Object Properties ---
-            for (auto& val : src.vector_properties)    ToProto(val, dst->add_vector_properties());
-            for (auto& val : src.quat_properties)      ToProto(val, dst->add_quat_properties());
-            for (auto& val : src.transform_properties) ToProto(val, dst->add_transform_properties());
-            for (auto& val : src.range_properties)     ToProto(val, dst->add_range_properties());
+            for (auto& val : src.vector_properties)
+                ToProto(val, dst->add_vector_properties());
+            for (auto& val : src.quat_properties)
+                ToProto(val, dst->add_quat_properties());
+            for (auto& val : src.transform_properties)
+                ToProto(val, dst->add_transform_properties());
+            for (auto& val : src.range_properties)
+                ToProto(val, dst->add_range_properties());
 
             // --- Array Properties (Flattened Bucket + offsets) ---
             // Each block checks if the source data is non-empty before mutating the destination.
             if (!src.byte_array_properties.data.empty()) {
                 auto* dest_arr = dst->mutable_byte_array_properties();
-                
-                dest_arr->add_data(src.byte_array_properties.data.data(),src.byte_array_properties.data.size());
+
+                dest_arr->add_data(src.byte_array_properties.data.data(), src.byte_array_properties.data.size());
                 for (auto o : src.byte_array_properties.offsets) {
                     dest_arr->add_offsets(o);
                 }
             }
-            
+
             if (!src.int32_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_int32_arrays();
-                for (auto v : src.int32_arrays.data) dest_arr->add_data(v);
-                for (auto o : src.int32_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto v : src.int32_arrays.data)
+                    dest_arr->add_data(v);
+                for (auto o : src.int32_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.int64_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_int64_arrays();
-                for (auto v : src.int64_arrays.data) dest_arr->add_data(v);
-                for (auto o : src.int64_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto v : src.int64_arrays.data)
+                    dest_arr->add_data(v);
+                for (auto o : src.int64_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.float_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_float_arrays();
-                for (auto v : src.float_arrays.data) dest_arr->add_data(v);
-                for (auto o : src.float_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto v : src.float_arrays.data)
+                    dest_arr->add_data(v);
+                for (auto o : src.float_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.double_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_double_arrays();
-                for (auto v : src.double_arrays.data) dest_arr->add_data(v);
-                for (auto o : src.double_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto v : src.double_arrays.data)
+                    dest_arr->add_data(v);
+                for (auto o : src.double_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.bool_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_bool_arrays();
-                for (auto v : src.bool_arrays.data) dest_arr->add_data(v);
-                for (auto o : src.bool_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto v : src.bool_arrays.data)
+                    dest_arr->add_data(v);
+                for (auto o : src.bool_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.string_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_string_arrays();
-                for (auto& v : src.string_arrays.data) dest_arr->add_data(v);
-                for (auto o : src.string_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto& v : src.string_arrays.data)
+                    dest_arr->add_data(v);
+                for (auto o : src.string_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
-            
+
             if (!src.vector_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_vector_arrays();
-                for (auto& v : src.vector_arrays.data) ToProto(v, dest_arr->add_data());
-                for (auto o : src.vector_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto& v : src.vector_arrays.data)
+                    ToProto(v, dest_arr->add_data());
+                for (auto o : src.vector_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.quat_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_quat_arrays();
-                for (auto& v : src.quat_arrays.data) ToProto(v, dest_arr->add_data());
-                for (auto o : src.quat_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto& v : src.quat_arrays.data)
+                    ToProto(v, dest_arr->add_data());
+                for (auto o : src.quat_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.transform_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_transform_arrays();
-                for (auto& v : src.transform_arrays.data) ToProto(v, dest_arr->add_data());
-                for (auto o : src.transform_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto& v : src.transform_arrays.data)
+                    ToProto(v, dest_arr->add_data());
+                for (auto o : src.transform_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
 
             if (!src.range_arrays.data.empty()) {
                 auto* dest_arr = dst->mutable_range_arrays();
-                for (auto& v : src.range_arrays.data) ToProto(v, dest_arr->add_data());
-                for (auto o : src.range_arrays.offsets) dest_arr->add_offsets(o);
+                for (auto& v : src.range_arrays.data)
+                    ToProto(v, dest_arr->add_data());
+                for (auto o : src.range_arrays.offsets)
+                    dest_arr->add_offsets(o);
             }
-            
+
             // --- AnyStruct Properties & Arrays ---
             for (auto& child : src.any_struct_properties) {
                 ToProto(child, dst->add_any_struct_properties());
@@ -177,18 +206,23 @@ namespace VTX {
 
             for (auto& map_item : src.map_properties) {
                 auto* dstMap = dst->add_map_properties();
-                for(auto& key : map_item.keys) dstMap->add_keys(key);
-                for(auto& val : map_item.values) ToProto(val, dstMap->add_values());
+                for (auto& key : map_item.keys)
+                    dstMap->add_keys(key);
+                for (auto& val : map_item.values)
+                    ToProto(val, dstMap->add_values());
             }
 
             if (!src.map_arrays.data.empty()) {
                 auto* dst_arr = dst->mutable_map_arrays();
                 for (auto& map_item : src.map_arrays.data) {
                     auto* dst_map = dst_arr->add_data();
-                    for(auto& key : map_item.keys) dst_map->add_keys(key);
-                    for(auto& val : map_item.values) ToProto(val, dst_map->add_values());
+                    for (auto& key : map_item.keys)
+                        dst_map->add_keys(key);
+                    for (auto& val : map_item.values)
+                        ToProto(val, dst_map->add_values());
                 }
-                for (auto o : src.map_arrays.offsets) dst_arr->add_offsets(o);
+                for (auto o : src.map_arrays.offsets)
+                    dst_arr->add_offsets(o);
             }
         }
 
@@ -198,15 +232,15 @@ namespace VTX {
          * @param dst The destination Protobuf message pointer.
          */
         inline void ToProto(VTX::Bucket& src, cppvtx::Bucket* dst) {
-            
             dst->mutable_unique_ids()->Reserve(static_cast<int>(src.unique_ids.size()));
-            for (auto& id : src.unique_ids) dst->add_unique_ids(id);
-            
+            for (auto& id : src.unique_ids)
+                dst->add_unique_ids(id);
+
             dst->mutable_entities()->Reserve(static_cast<int>(src.entities.size()));
             for (auto& entity : src.entities) {
                 ToProto(entity, dst->add_entities());
             }
-            
+
             for (auto& native_range : src.type_ranges) {
                 cppvtx::EntityRange* proto_range = dst->add_type_ranges();
                 proto_range->set_start_index(native_range.start_index);
@@ -224,5 +258,5 @@ namespace VTX {
                 ToProto(dataBlock, dst->add_data());
             }
         }
-    }
-}
\ No newline at end of file
+    } // namespace Serialization
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/src/vtx_common/src/vtx/common/readers/schema_reader/schema_registry.cpp b/sdk/src/vtx_common/src/vtx/common/readers/schema_reader/schema_registry.cpp
index 3b4ca36..a23444d 100644
--- a/sdk/src/vtx_common/src/vtx/common/readers/schema_reader/schema_registry.cpp
+++ b/sdk/src/vtx_common/src/vtx/common/readers/schema_reader/schema_registry.cpp
@@ -13,48 +13,31 @@ using json = nlohmann::json;
 
 static VTX::FieldType StringToTypeEnum(const std::string& type) {
     static const std::unordered_map<std::string, VTX::FieldType> map_type = {
-        {"int8", VTX::FieldType::Int8},
-        {"Int8", VTX::FieldType::Int8},
-        {"uint8", VTX::FieldType::Int8},
-        {"UInt8", VTX::FieldType::Int8},
-        {"int32", VTX::FieldType::Int32},
-        {"Int32", VTX::FieldType::Int32},
-        {"uint32", VTX::FieldType::Int32},
-        {"UInt32", VTX::FieldType::Int32},
-        {"int", VTX::FieldType::Int32},
-        {"Int", VTX::FieldType::Int32},
-        {"int64", VTX::FieldType::Int64},
-        {"Int64", VTX::FieldType::Int64},
-        {"uint64", VTX::FieldType::Int64},
-        {"UInt64", VTX::FieldType::Int64},
-        {"long", VTX::FieldType::Int64},
-        {"Long", VTX::FieldType::Int64},
-        {"float", VTX::FieldType::Float},
-        {"Float", VTX::FieldType::Float},
-        {"double", VTX::FieldType::Double},
-        {"Double", VTX::FieldType::Double},
-        {"bool", VTX::FieldType::Bool},
-        {"Bool", VTX::FieldType::Bool},
-        {"string", VTX::FieldType::String},
-        {"String", VTX::FieldType::String},
-        {"vector", VTX::FieldType::Vector},
-        {"Vector", VTX::FieldType::Vector},
-        {"quat", VTX::FieldType::Quat},
-        {"Quat", VTX::FieldType::Quat},
-        {"transform", VTX::FieldType::Transform},
-        {"Transform", VTX::FieldType::Transform},
-        {"struct", VTX::FieldType::Struct},
-        {"Struct", VTX::FieldType::Struct}
-    };
+        {"int8", VTX::FieldType::Int8},           {"Int8", VTX::FieldType::Int8},
+        {"uint8", VTX::FieldType::Int8},          {"UInt8", VTX::FieldType::Int8},
+        {"int32", VTX::FieldType::Int32},         {"Int32", VTX::FieldType::Int32},
+        {"uint32", VTX::FieldType::Int32},        {"UInt32", VTX::FieldType::Int32},
+        {"int", VTX::FieldType::Int32},           {"Int", VTX::FieldType::Int32},
+        {"int64", VTX::FieldType::Int64},         {"Int64", VTX::FieldType::Int64},
+        {"uint64", VTX::FieldType::Int64},        {"UInt64", VTX::FieldType::Int64},
+        {"long", VTX::FieldType::Int64},          {"Long", VTX::FieldType::Int64},
+        {"float", VTX::FieldType::Float},         {"Float", VTX::FieldType::Float},
+        {"double", VTX::FieldType::Double},       {"Double", VTX::FieldType::Double},
+        {"bool", VTX::FieldType::Bool},           {"Bool", VTX::FieldType::Bool},
+        {"string", VTX::FieldType::String},       {"String", VTX::FieldType::String},
+        {"vector", VTX::FieldType::Vector},       {"Vector", VTX::FieldType::Vector},
+        {"quat", VTX::FieldType::Quat},           {"Quat", VTX::FieldType::Quat},
+        {"transform", VTX::FieldType::Transform}, {"Transform", VTX::FieldType::Transform},
+        {"struct", VTX::FieldType::Struct},       {"Struct", VTX::FieldType::Struct}};
 
     auto it = map_type.find(type);
-    if (it != map_type.end()) return it->second;
+    if (it != map_type.end())
+        return it->second;
 
     return VTX::FieldType::None;
 };
 
 
-
 static VTX::FieldContainerType StringToContainerEnum(const std::string& container) {
     static const std::unordered_map<std::string, VTX::FieldContainerType> map_container = {
         {"array", VTX::FieldContainerType::Array},
@@ -62,17 +45,17 @@ static VTX::FieldContainerType StringToContainerEnum(const std::string& containe
     };
 
     auto it = map_container.find(container);
-    if (it != map_container.end()) return it->second;
+    if (it != map_container.end())
+        return it->second;
 
     return VTX::FieldContainerType::None;
 }
 
-VTX::SchemaRegistry::SchemaRegistry()
-{
+VTX::SchemaRegistry::SchemaRegistry() {
     b_is_valid_ = true;
 }
 
-bool VTX::SchemaRegistry::LoadFromJson(const std::string& json_path,ELoadMethod load_method) {
+bool VTX::SchemaRegistry::LoadFromJson(const std::string& json_path, ELoadMethod load_method) {
     std::ifstream file(json_path);
     if (!file.is_open()) {
         VTX_ERROR("Cannot open JSON: {}", json_path);
@@ -87,14 +70,12 @@ bool VTX::SchemaRegistry::LoadFromJson(const std::string& json_path,ELoadMethod
     return LoadFromRawString(buffer.str());
 }
 
-bool VTX::SchemaRegistry::LoadFromRawString(const std::string& raw_json)
-{
+bool VTX::SchemaRegistry::LoadFromRawString(const std::string& raw_json) {
     json_content_ = raw_json;
     json j;
     try {
         j = json::parse(json_content_);
-    }
-    catch (const json::parse_error& e) {
+    } catch (const json::parse_error& e) {
         VTX_ERROR("Error parsing JSON: {}", e.what());
         b_is_valid_ = false;
         return b_is_valid_;
@@ -112,7 +93,8 @@ bool VTX::SchemaRegistry::LoadFromRawString(const std::string& raw_json)
 
     for (const auto& struct_json : j["property_mapping"]) {
         std::string struct_name = struct_json.value("struct", "");
-        if (struct_name.empty()) continue;
+        if (struct_name.empty())
+            continue;
 
         struct_type_ids_[struct_name] = current_type_id_;
         current_type_id_++;
@@ -168,19 +150,18 @@ bool VTX::SchemaRegistry::LoadFromRawString(const std::string& raw_json)
             }
         }
 
-        for (const auto& field : current_struct.fields)
-        {
+        for (const auto& field : current_struct.fields) {
             current_struct.field_map[field.name] = &field;
 
-            if (field.container_type == VTX::FieldContainerType::None)
-            {
+            if (field.container_type == VTX::FieldContainerType::None) {
                 size_t typeIdx = static_cast<size_t>(field.type_id);
 
                 if (typeIdx >= current_struct.type_max_indices.size()) {
                     current_struct.type_max_indices.resize(typeIdx + 1, 0);
                 }
 
-                current_struct.type_max_indices[typeIdx] = std::max(current_struct.type_max_indices[typeIdx], field.index + 1);
+                current_struct.type_max_indices[typeIdx] =
+                    std::max(current_struct.type_max_indices[typeIdx], field.index + 1);
             }
         }
     }
@@ -206,7 +187,9 @@ bool VTX::SchemaRegistry::LoadFromRawString(const std::string& raw_json)
                 addr.container_type = field.container_type;
                 addr.child_type_name = field.struct_type;
                 struct_cache.properties[field.name] = addr;
-                struct_cache.names_by_lookup_key[VTX::MakePropertyLookupKey(field.index, field.type_id, field.container_type)] = field.name;
+                struct_cache
+                    .names_by_lookup_key[VTX::MakePropertyLookupKey(field.index, field.type_id, field.container_type)] =
+                    field.name;
                 struct_cache.property_order.push_back(field.name);
             }
         }
@@ -240,7 +223,7 @@ const VTX::SchemaStruct* VTX::SchemaRegistry::GetStruct(const std::string& name)
     return nullptr;
 }
 
-bool VTX::SchemaRegistry::GetIsValid() const{
+bool VTX::SchemaRegistry::GetIsValid() const {
     return b_is_valid_;
 }
 
@@ -248,9 +231,11 @@ const std::unordered_map<std::string, VTX::SchemaStruct>& VTX::SchemaRegistry::G
     return structs_;
 }
 
-const VTX::SchemaField* VTX::SchemaRegistry::GetField(const std::string& struct_name, const std::string& field_name) const {
+const VTX::SchemaField* VTX::SchemaRegistry::GetField(const std::string& struct_name,
+                                                      const std::string& field_name) const {
     const auto* s = GetStruct(struct_name);
-    if (!s) return nullptr;
+    if (!s)
+        return nullptr;
 
     auto it = s->field_map.find(field_name);
     if (it != s->field_map.end()) {
@@ -259,8 +244,7 @@ const VTX::SchemaField* VTX::SchemaRegistry::GetField(const std::string& struct_
     return nullptr;
 }
 
-int32_t VTX::SchemaRegistry::GetStructTypeId(const std::string& name) const
-{
+int32_t VTX::SchemaRegistry::GetStructTypeId(const std::string& name) const {
     auto it = struct_type_ids_.find(name);
     if (it != struct_type_ids_.end()) {
         return it->second;
diff --git a/sdk/src/vtx_differ/src/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.cpp b/sdk/src/vtx_differ/src/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.cpp
index e087bd3..a2163bf 100644
--- a/sdk/src/vtx_differ/src/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.cpp
+++ b/sdk/src/vtx_differ/src/vtx/differ/adapters/flatbuffers/vtx_flatbuffer_view_adapter.cpp
@@ -9,449 +9,549 @@
 namespace VtxDiff::Flatbuffers {
 
 
-namespace {
-    const reflection::Field* FindFieldByName(const reflection::Object* Obj, std::string_view Name) {
-        if (!Obj || !Obj->fields()) return nullptr;
-        for (auto* F : *Obj->fields()) {
-            if (F && F->name() && F->name()->string_view() == Name) return F;
+    namespace {
+        const reflection::Field* FindFieldByName(const reflection::Object* Obj, std::string_view Name) {
+            if (!Obj || !Obj->fields())
+                return nullptr;
+            for (auto* F : *Obj->fields()) {
+                if (F && F->name() && F->name()->string_view() == Name)
+                    return F;
+            }
+            return nullptr;
         }
-        return nullptr;
-    }
 
-    EVTXContainerType InferTypeFromName(std::string_view Name) {
-        
-        if (Name == "bool_properties") return EVTXContainerType::BoolProperties;
-        if (Name == "int32_properties") return EVTXContainerType::Int32Properties;
-        if (Name == "int64_properties") return EVTXContainerType::Int64Properties;
-        if (Name == "float_properties") return EVTXContainerType::FloatProperties;
-        if (Name == "double_properties") return EVTXContainerType::DoubleProperties;
-        if (Name == "string_properties") return EVTXContainerType::StringProperties;
-        if (Name == "transform_properties") return EVTXContainerType::TransformProperties;
-        if (Name == "vector_properties") return EVTXContainerType::VectorProperties;
-        if (Name == "quat_properties") return EVTXContainerType::QuatProperties;
-        if (Name == "range_properties") return EVTXContainerType::RangeProperties;
-        if (Name == "byte_array_properties") return EVTXContainerType::ByteArrayProperties;
-        
-        if (Name == "int32_arrays") return EVTXContainerType::Int32Arrays;
-        if (Name == "int64_arrays") return EVTXContainerType::Int64Arrays;
-        if (Name == "float_arrays") return EVTXContainerType::FloatArrays;
-        if (Name == "double_arrays") return EVTXContainerType::DoubleArrays;
-        if (Name == "string_arrays") return EVTXContainerType::StringArrays;
-        if (Name == "transform_arrays") return EVTXContainerType::TransformArrays;
-        if (Name == "vector_arrays") return EVTXContainerType::VectorArrays;
-        if (Name == "quat_arrays") return EVTXContainerType::QuatArrays;
-        if (Name == "range_arrays") return EVTXContainerType::RangeArrays;
-        if (Name == "bool_arrays") return EVTXContainerType::BoolArrays;
-
-        if (Name == "any_struct_properties") return EVTXContainerType::AnyStructProperties;
-        if (Name == "any_struct_arrays" || Name == "entities") return EVTXContainerType::AnyStructArrays;
-        if (Name == "map_properties") return EVTXContainerType::MapProperties;
-        if (Name == "map_arrays") return EVTXContainerType::MapArrays;
-
-        return EVTXContainerType::Unknown;
-
-        return EVTXContainerType::Unknown;
-    }
-    
-    bool IsFlatArrayType(EVTXContainerType Type) {
-        switch (Type) {
-        case EVTXContainerType::Int32Arrays:
-        case EVTXContainerType::Int64Arrays:
-        case EVTXContainerType::FloatArrays:
-        case EVTXContainerType::DoubleArrays:
-        case EVTXContainerType::StringArrays:
-        case EVTXContainerType::TransformArrays:
-        case EVTXContainerType::VectorArrays:
-        case EVTXContainerType::QuatArrays:
-        case EVTXContainerType::RangeArrays:
-        case EVTXContainerType::BoolArrays:
-        case EVTXContainerType::AnyStructArrays:
-        case EVTXContainerType::MapArrays:
-            return true;
-        default:
-            return false;
+        EVTXContainerType InferTypeFromName(std::string_view Name) {
+            if (Name == "bool_properties")
+                return EVTXContainerType::BoolProperties;
+            if (Name == "int32_properties")
+                return EVTXContainerType::Int32Properties;
+            if (Name == "int64_properties")
+                return EVTXContainerType::Int64Properties;
+            if (Name == "float_properties")
+                return EVTXContainerType::FloatProperties;
+            if (Name == "double_properties")
+                return EVTXContainerType::DoubleProperties;
+            if (Name == "string_properties")
+                return EVTXContainerType::StringProperties;
+            if (Name == "transform_properties")
+                return EVTXContainerType::TransformProperties;
+            if (Name == "vector_properties")
+                return EVTXContainerType::VectorProperties;
+            if (Name == "quat_properties")
+                return EVTXContainerType::QuatProperties;
+            if (Name == "range_properties")
+                return EVTXContainerType::RangeProperties;
+            if (Name == "byte_array_properties")
+                return EVTXContainerType::ByteArrayProperties;
+
+            if (Name == "int32_arrays")
+                return EVTXContainerType::Int32Arrays;
+            if (Name == "int64_arrays")
+                return EVTXContainerType::Int64Arrays;
+            if (Name == "float_arrays")
+                return EVTXContainerType::FloatArrays;
+            if (Name == "double_arrays")
+                return EVTXContainerType::DoubleArrays;
+            if (Name == "string_arrays")
+                return EVTXContainerType::StringArrays;
+            if (Name == "transform_arrays")
+                return EVTXContainerType::TransformArrays;
+            if (Name == "vector_arrays")
+                return EVTXContainerType::VectorArrays;
+            if (Name == "quat_arrays")
+                return EVTXContainerType::QuatArrays;
+            if (Name == "range_arrays")
+                return EVTXContainerType::RangeArrays;
+            if (Name == "bool_arrays")
+                return EVTXContainerType::BoolArrays;
+
+            if (Name == "any_struct_properties")
+                return EVTXContainerType::AnyStructProperties;
+            if (Name == "any_struct_arrays" || Name == "entities")
+                return EVTXContainerType::AnyStructArrays;
+            if (Name == "map_properties")
+                return EVTXContainerType::MapProperties;
+            if (Name == "map_arrays")
+                return EVTXContainerType::MapArrays;
+
+            return EVTXContainerType::Unknown;
+
+            return EVTXContainerType::Unknown;
         }
-    }
-}
 
+        bool IsFlatArrayType(EVTXContainerType Type) {
+            switch (Type) {
+            case EVTXContainerType::Int32Arrays:
+            case EVTXContainerType::Int64Arrays:
+            case EVTXContainerType::FloatArrays:
+            case EVTXContainerType::DoubleArrays:
+            case EVTXContainerType::StringArrays:
+            case EVTXContainerType::TransformArrays:
+            case EVTXContainerType::VectorArrays:
+            case EVTXContainerType::QuatArrays:
+            case EVTXContainerType::RangeArrays:
+            case EVTXContainerType::BoolArrays:
+            case EVTXContainerType::AnyStructArrays:
+            case EVTXContainerType::MapArrays:
+                return true;
+            default:
+                return false;
+            }
+        }
+    } // namespace
 
-void FbSchemaCache::Build(const reflection::Schema* Schema) {
-    RawSchema = Schema;
-    ObjectCache.clear();
-    if (!Schema || !Schema->objects()) return;
 
-    for (auto* Obj : *Schema->objects()) {
-        if (!Obj || !Obj->fields()) continue;
+    void FbSchemaCache::Build(const reflection::Schema* Schema) {
+        RawSchema = Schema;
+        ObjectCache.clear();
+        if (!Schema || !Schema->objects())
+            return;
 
-        CachedObject CObj;
-        CObj.EnumerableFields.reserve(Obj->fields()->size());
+        for (auto* Obj : *Schema->objects()) {
+            if (!Obj || !Obj->fields())
+                continue;
 
-        for (auto* F : *Obj->fields()) {
-            if (!F || !F->name()) continue;
+            CachedObject CObj;
+            CObj.EnumerableFields.reserve(Obj->fields()->size());
 
-            CachedField CF;
-            CF.FbField = F;
-            std::string_view Name = F->name()->string_view();
-            CF.VtxType = InferTypeFromName(Name);
-            CF.BaseType = F->type()->base_type();
-            CF.ElementType = F->type()->element();
+            for (auto* F : *Obj->fields()) {
+                if (!F || !F->name())
+                    continue;
 
-            if (CF.BaseType != reflection::Vector && CF.BaseType != reflection::Obj) {
-                CF.ByteSize = flatbuffers::GetTypeSize(static_cast<reflection::BaseType>(static_cast<flatbuffers::ElementaryType>(CF.BaseType)));
-            } else if (CF.BaseType == reflection::Obj) {
-                const auto* ObjSchema = Schema->objects()->Get(F->type()->index());
-                if (ObjSchema && ObjSchema->is_struct()) CF.ByteSize = static_cast<size_t>(ObjSchema->bytesize());
-            }
+                CachedField CF;
+                CF.FbField = F;
+                std::string_view Name = F->name()->string_view();
+                CF.VtxType = InferTypeFromName(Name);
+                CF.BaseType = F->type()->base_type();
+                CF.ElementType = F->type()->element();
 
-            if (CF.BaseType == reflection::Vector) {
-                if (CF.ElementType == reflection::Obj) {
+                if (CF.BaseType != reflection::Vector && CF.BaseType != reflection::Obj) {
+                    CF.ByteSize = flatbuffers::GetTypeSize(
+                        static_cast<reflection::BaseType>(static_cast<flatbuffers::ElementaryType>(CF.BaseType)));
+                } else if (CF.BaseType == reflection::Obj) {
                     const auto* ObjSchema = Schema->objects()->Get(F->type()->index());
-                    if (ObjSchema && ObjSchema->is_struct()) CF.ElementByteSize = static_cast<size_t>(ObjSchema->bytesize());
-                } else {
-                    CF.ElementByteSize = flatbuffers::GetTypeSize(static_cast<reflection::BaseType>(static_cast<flatbuffers::ElementaryType>(CF.ElementType)));
+                    if (ObjSchema && ObjSchema->is_struct())
+                        CF.ByteSize = static_cast<size_t>(ObjSchema->bytesize());
                 }
-            }
 
-            FieldDesc D;
-            D.name = std::string(Name);
-            D.type = CF.VtxType;
-            D.is_array_like = IsFlatArrayType(CF.VtxType);
-            D.is_map_like   = (D.type == EVTXContainerType::MapProperties || D.type == EVTXContainerType::MapArrays);
-            CObj.EnumerableFields.push_back(D);
-
-            if (D.is_array_like && CF.BaseType == reflection::Obj) {
-                CF.NestedObj = Schema->objects()->Get(F->type()->index());
-                if (CF.NestedObj) {
-                    CF.SoaDataField = FindFieldByName(CF.NestedObj, "data");
-                    CF.SoaOffsetsField = FindFieldByName(CF.NestedObj, "offsets");
+                if (CF.BaseType == reflection::Vector) {
+                    if (CF.ElementType == reflection::Obj) {
+                        const auto* ObjSchema = Schema->objects()->Get(F->type()->index());
+                        if (ObjSchema && ObjSchema->is_struct())
+                            CF.ElementByteSize = static_cast<size_t>(ObjSchema->bytesize());
+                    } else {
+                        CF.ElementByteSize = flatbuffers::GetTypeSize(static_cast<reflection::BaseType>(
+                            static_cast<flatbuffers::ElementaryType>(CF.ElementType)));
+                    }
                 }
-            }
 
-            if (D.is_map_like && CF.BaseType == reflection::Vector) {
-                CF.NestedObj = Schema->objects()->Get(F->type()->index());
-                if (CF.NestedObj) {
-                    CF.MapKeysField = FindFieldByName(CF.NestedObj, "keys");
-                    CF.MapValuesField = FindFieldByName(CF.NestedObj, "values");
-                    if (CF.MapValuesField) {
-                        CF.MapValuesObj = Schema->objects()->Get(CF.MapValuesField->type()->index());
+                FieldDesc D;
+                D.name = std::string(Name);
+                D.type = CF.VtxType;
+                D.is_array_like = IsFlatArrayType(CF.VtxType);
+                D.is_map_like = (D.type == EVTXContainerType::MapProperties || D.type == EVTXContainerType::MapArrays);
+                CObj.EnumerableFields.push_back(D);
+
+                if (D.is_array_like && CF.BaseType == reflection::Obj) {
+                    CF.NestedObj = Schema->objects()->Get(F->type()->index());
+                    if (CF.NestedObj) {
+                        CF.SoaDataField = FindFieldByName(CF.NestedObj, "data");
+                        CF.SoaOffsetsField = FindFieldByName(CF.NestedObj, "offsets");
+                    }
+                }
+
+                if (D.is_map_like && CF.BaseType == reflection::Vector) {
+                    CF.NestedObj = Schema->objects()->Get(F->type()->index());
+                    if (CF.NestedObj) {
+                        CF.MapKeysField = FindFieldByName(CF.NestedObj, "keys");
+                        CF.MapValuesField = FindFieldByName(CF.NestedObj, "values");
+                        if (CF.MapValuesField) {
+                            CF.MapValuesObj = Schema->objects()->Get(CF.MapValuesField->type()->index());
+                        }
                     }
                 }
-            }
 
-            CObj.FieldsByName[Name] = CF;
+                CObj.FieldsByName[Name] = CF;
+            }
+            ObjectCache[Obj] = std::move(CObj);
         }
-        ObjectCache[Obj] = std::move(CObj);
     }
-}
-
-const CachedField* FbSchemaCache::GetCachedField(const reflection::Object* Obj, std::string_view FieldName) const {
-    auto It = ObjectCache.find(Obj);
-    if (It != ObjectCache.end()) {
-        auto FieldIt = It->second.FieldsByName.find(FieldName);
-        if (FieldIt != It->second.FieldsByName.end()) {
-            return &FieldIt->second;
+
+    const CachedField* FbSchemaCache::GetCachedField(const reflection::Object* Obj, std::string_view FieldName) const {
+        auto It = ObjectCache.find(Obj);
+        if (It != ObjectCache.end()) {
+            auto FieldIt = It->second.FieldsByName.find(FieldName);
+            if (FieldIt != It->second.FieldsByName.end()) {
+                return &FieldIt->second;
+            }
         }
+        return nullptr;
     }
-    return nullptr;
-}
-
-const std::vector<FieldDesc>& FbSchemaCache::GetEnumerableFields(const reflection::Object* Obj) const {
-    auto It = ObjectCache.find(Obj);
-    if (It != ObjectCache.end()) return It->second.EnumerableFields;
-    static std::vector<FieldDesc> Empty;
-    return Empty;
-}
-
-
-FlatbufferViewAdapter::FlatbufferViewAdapter(const FbSchemaCache* Cache,
-                                             const reflection::Object* Object,
-                                             const flatbuffers::Table* TablePtr)
-    : Cache(Cache), Object(Object), TablePtr(TablePtr) {}
-
-void FlatbufferViewAdapter::Reset()
-{
-    
-}
-    
-bool FlatbufferViewAdapter::IsValid() const
-{
-    return TablePtr && Cache && Object;
-}
-
-std::optional<FlatbufferViewAdapter> FlatbufferViewAdapter::CreateRoot(const FbSchemaCache* Cache, const char* RootObjectName, const uint8_t* Buffer, size_t BufferSize) {    
-    if (!Cache || !Cache->RawSchema || !RootObjectName || !Buffer) return std::nullopt;
-                
-    const reflection::Object* RootObj = nullptr;
-    for (auto* O : *Cache->RawSchema->objects()) {
-        if (O && O->name() && std::strcmp(O->name()->c_str(), RootObjectName) == 0) {
-            RootObj = O;
-            break;
-        }
+
+    const std::vector<FieldDesc>& FbSchemaCache::GetEnumerableFields(const reflection::Object* Obj) const {
+        auto It = ObjectCache.find(Obj);
+        if (It != ObjectCache.end())
+            return It->second.EnumerableFields;
+        static std::vector<FieldDesc> Empty;
+        return Empty;
     }
-    if (!RootObj) return std::nullopt;
 
-    auto* Tbl = flatbuffers::GetRoot<flatbuffers::Table>(Buffer);
-    return FlatbufferViewAdapter(Cache, RootObj, Tbl);
-}
 
-std::span<const FieldDesc> FlatbufferViewAdapter::EnumerateFields() const {
-    return Cache->GetEnumerableFields(Object);
-}
+    FlatbufferViewAdapter::FlatbufferViewAdapter(const FbSchemaCache* Cache, const reflection::Object* Object,
+                                                 const flatbuffers::Table* TablePtr)
+        : Cache(Cache)
+        , Object(Object)
+        , TablePtr(TablePtr) {}
 
-const reflection::Field* FlatbufferViewAdapter::FindField(std::string_view FieldName) const {
-    return FindFieldByName(Object, FieldName);
-}
+    void FlatbufferViewAdapter::Reset() {}
 
-const uint8_t* FlatbufferViewAdapter::GetVectorData(const flatbuffers::Table* Tbl, const reflection::Field* F, size_t& Count, size_t& ElemSize) const {
-    Count = 0; ElemSize = 0;
-    if (!Tbl || !F || F->type()->base_type() != reflection::Vector) return nullptr;
+    bool FlatbufferViewAdapter::IsValid() const {
+        return TablePtr && Cache && Object;
+    }
 
-    auto VecU8 = Tbl->GetPointer<const flatbuffers::Vector<uint8_t>*>(F->offset());
-    if (!VecU8) return nullptr;
-    Count = VecU8->size();
+    std::optional<FlatbufferViewAdapter> FlatbufferViewAdapter::CreateRoot(const FbSchemaCache* Cache,
+                                                                           const char* RootObjectName,
+                                                                           const uint8_t* Buffer, size_t BufferSize) {
+        if (!Cache || !Cache->RawSchema || !RootObjectName || !Buffer)
+            return std::nullopt;
+
+        const reflection::Object* RootObj = nullptr;
+        for (auto* O : *Cache->RawSchema->objects()) {
+            if (O && O->name() && std::strcmp(O->name()->c_str(), RootObjectName) == 0) {
+                RootObj = O;
+                break;
+            }
+        }
+        if (!RootObj)
+            return std::nullopt;
 
-    if (F->type()->element() == reflection::Obj) {
-        const auto* ObjSchema = Cache->RawSchema->objects()->Get(F->type()->index());
-        ElemSize = (ObjSchema && ObjSchema->is_struct()) ? static_cast<size_t>(ObjSchema->bytesize()) : 0;
-    } else {
-        ElemSize = flatbuffers::GetTypeSize(static_cast<reflection::BaseType>(static_cast<flatbuffers::ElementaryType>(F->type()->element())));
+        auto* Tbl = flatbuffers::GetRoot<flatbuffers::Table>(Buffer);
+        return FlatbufferViewAdapter(Cache, RootObj, Tbl);
     }
-    return VecU8->Data();
-}
-
-bool FlatbufferViewAdapter::IsFlatArrayType(EVTXContainerType Type) const {
-    return (Type >= EVTXContainerType::ByteArrayProperties && Type <= EVTXContainerType::BoolArrays) ||
-            Type == EVTXContainerType::AnyStructArrays || 
-            Type == EVTXContainerType::MapArrays;
-}
-    
-size_t FlatbufferViewAdapter::GetArraySize(const FieldDesc& Fd) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->FbField) return 0;
-
-    if (CF->SoaOffsetsField) {
-        const flatbuffers::Table* NestedTable = TablePtr->GetPointer<const flatbuffers::Table*>(CF->FbField->offset());
-        if (!NestedTable) return 0;
+
+    std::span<const FieldDesc> FlatbufferViewAdapter::EnumerateFields() const {
+        return Cache->GetEnumerableFields(Object);
+    }
+
+    const reflection::Field* FlatbufferViewAdapter::FindField(std::string_view FieldName) const {
+        return FindFieldByName(Object, FieldName);
+    }
+
+    const uint8_t* FlatbufferViewAdapter::GetVectorData(const flatbuffers::Table* Tbl, const reflection::Field* F,
+                                                        size_t& Count, size_t& ElemSize) const {
+        Count = 0;
+        ElemSize = 0;
+        if (!Tbl || !F || F->type()->base_type() != reflection::Vector)
+            return nullptr;
+
+        auto VecU8 = Tbl->GetPointer<const flatbuffers::Vector<uint8_t>*>(F->offset());
+        if (!VecU8)
+            return nullptr;
+        Count = VecU8->size();
+
+        if (F->type()->element() == reflection::Obj) {
+            const auto* ObjSchema = Cache->RawSchema->objects()->Get(F->type()->index());
+            ElemSize = (ObjSchema && ObjSchema->is_struct()) ? static_cast<size_t>(ObjSchema->bytesize()) : 0;
+        } else {
+            ElemSize = flatbuffers::GetTypeSize(
+                static_cast<reflection::BaseType>(static_cast<flatbuffers::ElementaryType>(F->type()->element())));
+        }
+        return VecU8->Data();
+    }
+
+    bool FlatbufferViewAdapter::IsFlatArrayType(EVTXContainerType Type) const {
+        return (Type >= EVTXContainerType::ByteArrayProperties && Type <= EVTXContainerType::BoolArrays) ||
+               Type == EVTXContainerType::AnyStructArrays || Type == EVTXContainerType::MapArrays;
+    }
+
+    size_t FlatbufferViewAdapter::GetArraySize(const FieldDesc& Fd) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->FbField)
+            return 0;
+
+        if (CF->SoaOffsetsField) {
+            const flatbuffers::Table* NestedTable =
+                TablePtr->GetPointer<const flatbuffers::Table*>(CF->FbField->offset());
+            if (!NestedTable)
+                return 0;
+            size_t count = 0, elemSize = 0;
+            GetVectorData(NestedTable, CF->SoaOffsetsField, count, elemSize);
+            return count;
+        }
+
         size_t count = 0, elemSize = 0;
-        GetVectorData(NestedTable, CF->SoaOffsetsField, count, elemSize);
+        GetVectorData(TablePtr, CF->FbField, count, elemSize);
         return count;
     }
 
-    size_t count = 0, elemSize = 0;
-    GetVectorData(TablePtr, CF->FbField, count, elemSize);
-    return count;
-}
+    std::span<const std::byte> FlatbufferViewAdapter::GetFieldBytes(const FieldDesc& Fd) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->FbField)
+            return {};
 
-std::span<const std::byte> FlatbufferViewAdapter::GetFieldBytes(const FieldDesc& Fd) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->FbField) return {};
+        auto Voff = static_cast<flatbuffers::voffset_t>(CF->FbField->offset());
 
-    auto Voff = static_cast<flatbuffers::voffset_t>(CF->FbField->offset());
+        if (CF->BaseType == reflection::String) {
+            const flatbuffers::String* S = TablePtr->GetPointer<const flatbuffers::String*>(Voff);
+            if (!S)
+                return {};
+            return {reinterpret_cast<const std::byte*>(S->c_str()), S->size()};
+        }
 
-    if (CF->BaseType == reflection::String) {
-        const flatbuffers::String* S = TablePtr->GetPointer<const flatbuffers::String*>(Voff);
-        if (!S) return {};
-        return { reinterpret_cast<const std::byte*>(S->c_str()), S->size() };
+        if (CF->BaseType != reflection::Vector && CF->BaseType != reflection::Obj) {
+            const uint8_t* Ptr = TablePtr->GetAddressOf(Voff);
+            if (!Ptr)
+                return {};
+            return {reinterpret_cast<const std::byte*>(Ptr), CF->ByteSize};
+        }
+
+        if (CF->BaseType == reflection::Obj && CF->ByteSize > 0) {
+            const uint8_t* Ptr = TablePtr->GetStruct<const uint8_t*>(Voff);
+            if (!Ptr)
+                return {};
+            return {reinterpret_cast<const std::byte*>(Ptr), CF->ByteSize};
+        }
+        return {};
     }
 
-    if (CF->BaseType != reflection::Vector && CF->BaseType != reflection::Obj) {
-        const uint8_t* Ptr = TablePtr->GetAddressOf(Voff);
-        if (!Ptr) return {};
-        return { reinterpret_cast<const std::byte*>(Ptr), CF->ByteSize };
+    std::span<const std::byte> FlatbufferViewAdapter::GetArrayElementBytes(const FieldDesc& Fd, size_t Index) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF)
+            return {};
+
+        if (CF->SoaDataField)
+            return GetSubArrayBytes(Fd, Index);
+
+        if (!CF->FbField || CF->BaseType != reflection::Vector)
+            return {};
+
+        if (CF->ElementType == reflection::String) {
+            auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(
+                CF->FbField->offset());
+            if (!Vec || Index >= Vec->size())
+                return {};
+            const flatbuffers::String* S = Vec->Get(Index);
+            return S ? std::span<const std::byte> {reinterpret_cast<const std::byte*>(S->c_str()), S->size()}
+                     : std::span<const std::byte> {};
+        }
+
+        auto VecU8 = TablePtr->GetPointer<const flatbuffers::Vector<uint8_t>*>(CF->FbField->offset());
+        if (!VecU8 || Index >= VecU8->size() || CF->ElementByteSize == 0)
+            return {};
+
+        return {reinterpret_cast<const std::byte*>(VecU8->Data() + Index * CF->ElementByteSize), CF->ElementByteSize};
     }
 
-    if (CF->BaseType == reflection::Obj && CF->ByteSize > 0) {
-        const uint8_t* Ptr = TablePtr->GetStruct<const uint8_t*>(Voff);
-        if (!Ptr) return {};
-        return { reinterpret_cast<const std::byte*>(Ptr), CF->ByteSize };
+    std::span<const std::byte> FlatbufferViewAdapter::GetSubArrayBytes(const FieldDesc& Fd, size_t SubIndex) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->SoaDataField || !CF->SoaOffsetsField)
+            return {};
+
+        const flatbuffers::Table* NestedTable = TablePtr->GetPointer<const flatbuffers::Table*>(CF->FbField->offset());
+        if (!NestedTable)
+            return {};
+
+        auto VecOffsets = NestedTable->GetPointer<const flatbuffers::Vector<uint32_t>*>(CF->SoaOffsetsField->offset());
+        if (!VecOffsets || SubIndex >= VecOffsets->size())
+            return {};
+
+        uint32_t StartElem = VecOffsets->Get(static_cast<flatbuffers::uoffset_t>(SubIndex));
+
+        if (CF->SoaDataField->type()->element() == reflection::String) {
+            auto Vec = NestedTable->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(
+                CF->SoaDataField->offset());
+            if (!Vec)
+                return {};
+
+            uint32_t EndElem = (SubIndex + 1 < VecOffsets->size())
+                                   ? VecOffsets->Get(static_cast<flatbuffers::uoffset_t>(SubIndex + 1))
+                                   : static_cast<uint32_t>(Vec->size());
+            if (EndElem < StartElem || EndElem > Vec->size())
+                return {};
+
+            size_t totalBytes = 0;
+            for (uint32_t i = StartElem; i < EndElem; ++i) {
+                const flatbuffers::String* S = Vec->Get(i);
+                totalBytes += 4 + (S ? S->size() : 0);
+            }
+
+            static thread_local std::vector<std::byte> Scratch;
+            Scratch.resize(totalBytes);
+
+            std::byte* Dest = Scratch.data();
+            for (uint32_t i = StartElem; i < EndElem; ++i) {
+                const flatbuffers::String* S = Vec->Get(i);
+                uint32_t Len = S ? static_cast<uint32_t>(S->size()) : 0u;
+                std::memcpy(Dest, &Len, 4);
+                Dest += 4;
+                if (Len) {
+                    std::memcpy(Dest, S->c_str(), Len);
+                    Dest += Len;
+                }
+            }
+            return {Scratch.data(), Scratch.size()};
+        }
+
+        auto VecData = NestedTable->GetPointer<const flatbuffers::Vector<uint8_t>*>(CF->SoaDataField->offset());
+        if (!VecData)
+            return {};
+
+        size_t DataElemSize = flatbuffers::GetTypeSize(static_cast<reflection::BaseType>(
+            static_cast<flatbuffers::ElementaryType>(CF->SoaDataField->type()->element())));
+
+        uint32_t EndElem = (SubIndex + 1 < VecOffsets->size())
+                               ? VecOffsets->Get(static_cast<flatbuffers::uoffset_t>(SubIndex + 1))
+                               : static_cast<uint32_t>(VecData->size() / DataElemSize);
+        if (EndElem < StartElem)
+            return {};
+
+        size_t ByteStart = StartElem * DataElemSize;
+        size_t ByteLen = (EndElem - StartElem) * DataElemSize;
+
+        return {reinterpret_cast<const std::byte*>(VecData->Data() + ByteStart), ByteLen};
     }
-    return {};
-}
 
-std::span<const std::byte> FlatbufferViewAdapter::GetArrayElementBytes(const FieldDesc& Fd, size_t Index) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF) return {};
+    FlatbufferViewAdapter FlatbufferViewAdapter::GetArrayElementAsStruct(const FieldDesc& Fd, size_t Index) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->FbField || CF->FbField->type()->base_type() != reflection::Vector ||
+            CF->FbField->type()->element() != reflection::Obj)
+            return {}; // Devuelve vacío
 
-    if (CF->SoaDataField) return GetSubArrayBytes(Fd, Index);
+        const auto* NestedObj = Cache->RawSchema->objects()->Get(CF->FbField->type()->index());
+        if (!NestedObj || NestedObj->is_struct())
+            return {};
+
+        auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(
+            CF->FbField->offset());
+        if (!Vec || Index >= Vec->size())
+            return {};
+        return FlatbufferViewAdapter(Cache, NestedObj, Vec->Get(Index));
+    }
 
-    if (!CF->FbField || CF->BaseType != reflection::Vector) return {};
+    FlatbufferViewAdapter FlatbufferViewAdapter::GetNestedStruct(const FieldDesc& Fd) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->FbField || CF->FbField->type()->base_type() != reflection::Obj)
+            return {};
+
+        const auto* NestedObj = Cache->RawSchema->objects()->Get(CF->FbField->type()->index());
+        if (!NestedObj || NestedObj->is_struct())
+            return {};
 
-    if (CF->ElementType == reflection::String) {
-        auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(CF->FbField->offset());
-        if (!Vec || Index >= Vec->size()) return {};
-        const flatbuffers::String* S = Vec->Get(Index);
-        return S ? std::span<const std::byte>{reinterpret_cast<const std::byte*>(S->c_str()), S->size()} : std::span<const std::byte>{};
+        const flatbuffers::Table* NestedTbl = TablePtr->GetPointer<const flatbuffers::Table*>(CF->FbField->offset());
+        if (!NestedTbl)
+            return {};
+
+        return FlatbufferViewAdapter(Cache, NestedObj, NestedTbl);
     }
 
-    auto VecU8 = TablePtr->GetPointer<const flatbuffers::Vector<uint8_t>*>(CF->FbField->offset());
-    if (!VecU8 || Index >= VecU8->size() || CF->ElementByteSize == 0) return {};
-    
-    return { reinterpret_cast<const std::byte*>(VecU8->Data() + Index * CF->ElementByteSize), CF->ElementByteSize };
-}
+    FlatbufferViewAdapter FlatbufferViewAdapter::GetMapValueAsStruct(const FieldDesc& Fd, size_t I) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->MapValuesField || !CF->MapValuesObj)
+            return {};
 
-std::span<const std::byte> FlatbufferViewAdapter::GetSubArrayBytes(const FieldDesc& Fd, size_t SubIndex) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->SoaDataField || !CF->SoaOffsetsField) return {};
+        auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(
+            CF->FbField->offset());
+        if (!Vec || I >= Vec->size())
+            return {};
 
-    const flatbuffers::Table* NestedTable = TablePtr->GetPointer<const flatbuffers::Table*>(CF->FbField->offset());
-    if (!NestedTable) return {};
+        const flatbuffers::Table* MC = Vec->Get(I);
+        if (!MC)
+            return {};
 
-    auto VecOffsets = NestedTable->GetPointer<const flatbuffers::Vector<uint32_t>*>(CF->SoaOffsetsField->offset());
-    if (!VecOffsets || SubIndex >= VecOffsets->size()) return {};
+        auto Values = MC->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(
+            CF->MapValuesField->offset());
+        if (!Values || Values->size() == 0)
+            return {};
 
-    uint32_t StartElem = VecOffsets->Get(static_cast<flatbuffers::uoffset_t>(SubIndex));
+        size_t ValIndex = std::min<size_t>(I, Values->size() - 1);
+        return FlatbufferViewAdapter(Cache, CF->MapValuesObj,
+                                     Values->Get(static_cast<flatbuffers::uoffset_t>(ValIndex)));
+    }
 
-    if (CF->SoaDataField->type()->element() == reflection::String) {
-        auto Vec = NestedTable->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(CF->SoaDataField->offset());
-        if (!Vec) return {};
+    FlatbufferViewAdapter FlatbufferViewAdapter::GetFieldByName(const std::string& FieldName) const {
+        FieldDesc fd;
+        fd.name = FieldName;
+        return GetNestedStruct(fd);
+    }
 
-        uint32_t EndElem = (SubIndex + 1 < VecOffsets->size()) ? VecOffsets->Get(static_cast<flatbuffers::uoffset_t>(SubIndex + 1)) : static_cast<uint32_t>(Vec->size());
-        if (EndElem < StartElem || EndElem > Vec->size()) return {};
+    size_t FlatbufferViewAdapter::GetMapSize(const FieldDesc& Fd) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->FbField)
+            return 0;
+        auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(
+            CF->FbField->offset());
+        return Vec ? Vec->size() : 0;
+    }
 
-        size_t totalBytes = 0;
-        for (uint32_t i = StartElem; i < EndElem; ++i) {
-            const flatbuffers::String* S = Vec->Get(i);
-            totalBytes += 4 + (S ? S->size() : 0);
-        }
+    std::string FlatbufferViewAdapter::GetMapKey(const FieldDesc& Fd, size_t I) const {
+        const auto* CF = Cache->GetCachedField(Object, Fd.name);
+        if (!CF || !CF->MapKeysField)
+            return "";
 
-        static thread_local std::vector<std::byte> Scratch;
-        Scratch.resize(totalBytes);
-        
-        std::byte* Dest = Scratch.data();
-        for (uint32_t i = StartElem; i < EndElem; ++i) {
-            const flatbuffers::String* S = Vec->Get(i);
-            uint32_t Len = S ? static_cast<uint32_t>(S->size()) : 0u;
-            std::memcpy(Dest, &Len, 4);
-            Dest += 4;
-            if (Len) {
-                std::memcpy(Dest, S->c_str(), Len);
-                Dest += Len;
-            }
-        }
-        return { Scratch.data(), Scratch.size() };
+        auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(
+            CF->FbField->offset());
+        if (!Vec || I >= Vec->size())
+            return "";
+
+        const flatbuffers::Table* MC = Vec->Get(I);
+        if (!MC)
+            return "";
+
+        auto Keys = MC->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(
+            CF->MapKeysField->offset());
+        if (!Keys || Keys->size() == 0)
+            return "";
+
+        size_t KeyIndex = std::min<size_t>(I, Keys->size() - 1);
+        return Keys->Get(static_cast<flatbuffers::uoffset_t>(KeyIndex))->str();
     }
 
-    auto VecData = NestedTable->GetPointer<const flatbuffers::Vector<uint8_t>*>(CF->SoaDataField->offset());
-    if (!VecData) return {};
-    
-    size_t DataElemSize = flatbuffers::GetTypeSize(static_cast<reflection::BaseType>(static_cast<flatbuffers::ElementaryType>(CF->SoaDataField->type()->element())));
-    
-    uint32_t EndElem = (SubIndex + 1 < VecOffsets->size()) ? VecOffsets->Get(static_cast<flatbuffers::uoffset_t>(SubIndex + 1)) : static_cast<uint32_t>(VecData->size() / DataElemSize);
-    if (EndElem < StartElem) return {};
-
-    size_t ByteStart = StartElem * DataElemSize;
-    size_t ByteLen = (EndElem - StartElem) * DataElemSize;
-
-    return { reinterpret_cast<const std::byte*>(VecData->Data() + ByteStart), ByteLen };
-}
-    
-FlatbufferViewAdapter FlatbufferViewAdapter::GetArrayElementAsStruct(const FieldDesc& Fd, size_t Index) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->FbField || CF->FbField->type()->base_type() != reflection::Vector || CF->FbField->type()->element() != reflection::Obj) return {}; // Devuelve vacío
-
-    const auto* NestedObj = Cache->RawSchema->objects()->Get(CF->FbField->type()->index());
-    if (!NestedObj || NestedObj->is_struct()) return {};
-
-    auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(CF->FbField->offset());
-    if (!Vec || Index >= Vec->size()) return {};
-    return FlatbufferViewAdapter(Cache, NestedObj, Vec->Get(Index));
-}
-
-FlatbufferViewAdapter FlatbufferViewAdapter::GetNestedStruct(const FieldDesc& Fd) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->FbField || CF->FbField->type()->base_type() != reflection::Obj) return {};
-    
-    const auto* NestedObj = Cache->RawSchema->objects()->Get(CF->FbField->type()->index());
-    if (!NestedObj || NestedObj->is_struct()) return {};
-    
-    const flatbuffers::Table* NestedTbl = TablePtr->GetPointer<const flatbuffers::Table*>(CF->FbField->offset());
-    if (!NestedTbl) return {};
-    
-    return FlatbufferViewAdapter(Cache, NestedObj, NestedTbl);
-}
-
-FlatbufferViewAdapter FlatbufferViewAdapter::GetMapValueAsStruct(const FieldDesc& Fd, size_t I) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->MapValuesField || !CF->MapValuesObj) return {};
-    
-    auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(CF->FbField->offset());
-    if (!Vec || I >= Vec->size()) return {};
-    
-    const flatbuffers::Table* MC = Vec->Get(I);
-    if (!MC) return {};
-
-    auto Values = MC->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(CF->MapValuesField->offset());
-    if (!Values || Values->size() == 0) return {};
-
-    size_t ValIndex = std::min<size_t>(I, Values->size() - 1);
-    return FlatbufferViewAdapter(Cache, CF->MapValuesObj, Values->Get(static_cast<flatbuffers::uoffset_t>(ValIndex)));
-}
-
-FlatbufferViewAdapter FlatbufferViewAdapter::GetFieldByName(const std::string& FieldName) const {
-    FieldDesc fd; fd.name = FieldName; return GetNestedStruct(fd);
-}
-
-size_t FlatbufferViewAdapter::GetMapSize(const FieldDesc& Fd) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->FbField) return 0;
-    auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(CF->FbField->offset());
-    return Vec ? Vec->size() : 0;
-}
-
-std::string FlatbufferViewAdapter::GetMapKey(const FieldDesc& Fd, size_t I) const {
-    const auto* CF = Cache->GetCachedField(Object, Fd.name);
-    if (!CF || !CF->MapKeysField) return "";
-    
-    auto Vec = TablePtr->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(CF->FbField->offset());
-    if (!Vec || I >= Vec->size()) return "";
-    
-    const flatbuffers::Table* MC = Vec->Get(I);
-    if (!MC) return "";
-
-    auto Keys = MC->GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(CF->MapKeysField->offset());
-    if (!Keys || Keys->size() == 0) return "";
-    
-    size_t KeyIndex = std::min<size_t>(I, Keys->size() - 1);
-    return Keys->Get(static_cast<flatbuffers::uoffset_t>(KeyIndex))->str();
-}
-
-std::string FlatbufferViewAdapter::GetScalarFieldString(const std::string& FieldName) const {
-    if (!TablePtr || !Object) return {};
-
-    const reflection::Field* FbField = FindField(FieldName);
-    if (!FbField) return {};
-
-    auto voffset = static_cast<flatbuffers::voffset_t>(FbField->offset());
-    auto base_type = FbField->type()->base_type();
-
-    switch (base_type) {
-        case reflection::String:
-            {
-                const auto* s = TablePtr->GetPointer<const flatbuffers::String*>(voffset);
-                return s ? s->str() : std::string{};
-            }
+    std::string FlatbufferViewAdapter::GetScalarFieldString(const std::string& FieldName) const {
+        if (!TablePtr || !Object)
+            return {};
+
+        const reflection::Field* FbField = FindField(FieldName);
+        if (!FbField)
+            return {};
+
+        auto voffset = static_cast<flatbuffers::voffset_t>(FbField->offset());
+        auto base_type = FbField->type()->base_type();
+
+        switch (base_type) {
+        case reflection::String: {
+            const auto* s = TablePtr->GetPointer<const flatbuffers::String*>(voffset);
+            return s ? s->str() : std::string {};
+        }
         case reflection::ULong:
-            return std::to_string(TablePtr->GetField<uint64_t>(voffset, static_cast<uint64_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<uint64_t>(voffset, static_cast<uint64_t>(FbField->default_integer())));
         case reflection::Long:
-            return std::to_string(TablePtr->GetField<int64_t>(voffset, static_cast<int64_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<int64_t>(voffset, static_cast<int64_t>(FbField->default_integer())));
         case reflection::UInt:
-            return std::to_string(TablePtr->GetField<uint32_t>(voffset, static_cast<uint32_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<uint32_t>(voffset, static_cast<uint32_t>(FbField->default_integer())));
         case reflection::Int:
-            return std::to_string(TablePtr->GetField<int32_t>(voffset, static_cast<int32_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<int32_t>(voffset, static_cast<int32_t>(FbField->default_integer())));
         case reflection::Float:
             return std::to_string(TablePtr->GetField<float>(voffset, static_cast<float>(FbField->default_real())));
         case reflection::Double:
             return std::to_string(TablePtr->GetField<double>(voffset, static_cast<double>(FbField->default_real())));
         case reflection::Bool:
-            return TablePtr->GetField<uint8_t>(voffset, static_cast<uint8_t>(FbField->default_integer())) ? "true" : "false";
+            return TablePtr->GetField<uint8_t>(voffset, static_cast<uint8_t>(FbField->default_integer())) ? "true"
+                                                                                                          : "false";
         case reflection::UByte:
-            return std::to_string(TablePtr->GetField<uint8_t>(voffset, static_cast<uint8_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<uint8_t>(voffset, static_cast<uint8_t>(FbField->default_integer())));
         case reflection::Byte:
             return std::to_string(TablePtr->GetField<int8_t>(voffset, static_cast<int8_t>(FbField->default_integer())));
         case reflection::UShort:
-            return std::to_string(TablePtr->GetField<uint16_t>(voffset, static_cast<uint16_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<uint16_t>(voffset, static_cast<uint16_t>(FbField->default_integer())));
         case reflection::Short:
-            return std::to_string(TablePtr->GetField<int16_t>(voffset, static_cast<int16_t>(FbField->default_integer())));
+            return std::to_string(
+                TablePtr->GetField<int16_t>(voffset, static_cast<int16_t>(FbField->default_integer())));
         case reflection::None:
         case reflection::UType:
         case reflection::Vector:
@@ -462,43 +562,47 @@ std::string FlatbufferViewAdapter::GetScalarFieldString(const std::string& Field
         case reflection::MaxBaseType:
         default:
             return {};
+        }
     }
-}
-
-uint64_t FlatbufferViewAdapter::GetUint64Field(const std::string& FieldName) const
-{
-    const reflection::Field* FbField = FindField(FieldName);
-    if (!FbField) return 0;
-
-    auto voffset = static_cast<flatbuffers::voffset_t>(FbField->offset());
-    auto base_type = FbField->type()->base_type();
-    if ( base_type == reflection::ULong)
-    {
-        return TablePtr->GetField<uint64_t>(voffset, static_cast<uint64_t>(FbField->default_integer()));
+
+    uint64_t FlatbufferViewAdapter::GetUint64Field(const std::string& FieldName) const {
+        const reflection::Field* FbField = FindField(FieldName);
+        if (!FbField)
+            return 0;
+
+        auto voffset = static_cast<flatbuffers::voffset_t>(FbField->offset());
+        auto base_type = FbField->type()->base_type();
+        if (base_type == reflection::ULong) {
+            return TablePtr->GetField<uint64_t>(voffset, static_cast<uint64_t>(FbField->default_integer()));
+        }
+        return 0;
+    }
+
+
+    std::optional<FlatbufferViewAdapter> FbViewFactory::CreateRoot(std::span<const std::byte> Buffer) {
+        if (RootName.empty() || Buffer.empty() || !GlobalCache.RawSchema)
+            return std::nullopt;
+        return FlatbufferViewAdapter::CreateRoot(&GlobalCache, RootName.c_str(),
+                                                 reinterpret_cast<const uint8_t*>(Buffer.data()), Buffer.size());
+    }
+
+    bool FbViewFactory::InitFromFile(const std::string& Path, const std::string& RootType) {
+        return false;
+    }
+
+    bool FbViewFactory::InitFromMemory(const uint8_t* Data, size_t Size, const std::string& RootType) {
+        const uint8_t* schemaData = fbsvtx::FileHeaderBinarySchema::data();
+        size_t schemaSize = fbsvtx::FileHeaderBinarySchema::size();
+
+        if (!schemaData || schemaSize == 0)
+            return false;
+        const reflection::Schema* loadedSchema = reflection::GetSchema(schemaData);
+        if (!loadedSchema)
+            return false;
+
+        GlobalCache.Build(loadedSchema);
+        RootName = RootType;
+        return true;
     }
-    return 0;
-}
-
-
-std::optional<FlatbufferViewAdapter> FbViewFactory::CreateRoot(std::span<const std::byte> Buffer){
-    if (RootName.empty() || Buffer.empty() || !GlobalCache.RawSchema) return std::nullopt;
-    return FlatbufferViewAdapter::CreateRoot(&GlobalCache, RootName.c_str(), reinterpret_cast<const uint8_t*>(Buffer.data()), Buffer.size());
-}
-
-bool FbViewFactory::InitFromFile(const std::string& Path, const std::string& RootType) { return false; }
-
-bool FbViewFactory::InitFromMemory(const uint8_t* Data, size_t Size, const std::string& RootType) {
-    
-    const uint8_t* schemaData = fbsvtx::FileHeaderBinarySchema::data();
-    size_t schemaSize = fbsvtx::FileHeaderBinarySchema::size();
-    
-    if (!schemaData || schemaSize == 0) return false;
-    const reflection::Schema* loadedSchema = reflection::GetSchema(schemaData);
-    if (!loadedSchema) return false;
-    
-    GlobalCache.Build(loadedSchema);
-    RootName = RootType;
-    return true;
-}
 
 } // namespace VtxDiff::Flatbuffers
\ No newline at end of file
diff --git a/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_proto_verify.h b/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_proto_verify.h
index 85051ff..ebcf1a6 100644
--- a/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_proto_verify.h
+++ b/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_proto_verify.h
@@ -12,19 +12,20 @@
 #include "google/protobuf/util/message_differencer.h"
 
 
-namespace VtxDiff::Protobuf
-{
-	static bool ProtoEquals(const google::protobuf::Message& A,const google::protobuf::Message& B,std::string* OutDiff)
-	{
-		using google::protobuf::util::MessageDifferencer;
-		MessageDifferencer Diff;
-		Diff.set_message_field_comparison(MessageDifferencer::EQUIVALENT);
-
-		std::string report;
-		if (OutDiff) Diff.ReportDifferencesToString(&report);
-
-		const bool Ok = Diff.Compare(A, B);
-		if (!Ok && OutDiff) *OutDiff = report;
-		return Ok;
-	}
-}
\ No newline at end of file
+namespace VtxDiff::Protobuf {
+    static bool ProtoEquals(const google::protobuf::Message& A, const google::protobuf::Message& B,
+                            std::string* OutDiff) {
+        using google::protobuf::util::MessageDifferencer;
+        MessageDifferencer Diff;
+        Diff.set_message_field_comparison(MessageDifferencer::EQUIVALENT);
+
+        std::string report;
+        if (OutDiff)
+            Diff.ReportDifferencesToString(&report);
+
+        const bool Ok = Diff.Compare(A, B);
+        if (!Ok && OutDiff)
+            *OutDiff = report;
+        return Ok;
+    }
+} // namespace VtxDiff::Protobuf
\ No newline at end of file
diff --git a/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.cpp b/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.cpp
index e35bd7f..3ad328d 100644
--- a/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.cpp
+++ b/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.cpp
@@ -24,21 +24,16 @@
 using namespace google::protobuf;
 
 
-
-
-namespace VtxDiff::Protobuf
-{
+namespace VtxDiff::Protobuf {
     // ============================================================================
     // Persistent factory per descriptor pool
     // ============================================================================
-    namespace
-    {
+    namespace {
         using FactoryPtr = std::unique_ptr<DynamicMessageFactory>;
         std::mutex GlobalFactoryMutex;
         std::unordered_map<const DescriptorPool*, FactoryPtr> GlobalFactories;
 
-        DynamicMessageFactory* GetFactoryForPool(const DescriptorPool* Pool)
-        {
+        DynamicMessageFactory* GetFactoryForPool(const DescriptorPool* Pool) {
             std::lock_guard<std::mutex> Lock(GlobalFactoryMutex);
             auto& Entry = GlobalFactories[Pool];
             if (!Entry)
@@ -46,8 +41,7 @@ namespace VtxDiff::Protobuf
             return Entry.get();
         }
 
-        std::unique_ptr<Message> NewOwnedMessage(const DescriptorPool* Pool, const Descriptor* Desc)
-        {
+        std::unique_ptr<Message> NewOwnedMessage(const DescriptorPool* Pool, const Descriptor* Desc) {
             DynamicMessageFactory* Factory = GetFactoryForPool(Pool);
             const Message* Proto = Factory->GetPrototype(Desc);
             if (!Proto)
@@ -55,8 +49,7 @@ namespace VtxDiff::Protobuf
             return std::unique_ptr<Message>(Proto->New());
         }
 
-        std::unique_ptr<Message> CloneMessage(const Message& Src)
-        {
+        std::unique_ptr<Message> CloneMessage(const Message& Src) {
             const Descriptor* Desc = Src.GetDescriptor();
             const DescriptorPool* Pool = Desc->file()->pool();
             auto Copy = NewOwnedMessage(Pool, Desc);
@@ -64,132 +57,154 @@ namespace VtxDiff::Protobuf
                 Copy->CopyFrom(Src);
             return Copy;
         }
-    }
-    
-// ============================================================================
-// Byte utilities
-// ============================================================================
+    } // namespace
+
+    // ============================================================================
+    // Byte utilities
+    // ============================================================================
 
-template <typename T>
-static void PutLE(std::vector<std::byte>& Dst, T Value)
-{
-    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-    std::array<unsigned char, sizeof(T)> buf{};
-    std::memcpy(buf.data(), &Value, sizeof(T));
-    #if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    template <typename T>
+    static void PutLE(std::vector<std::byte>& Dst, T Value) {
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        std::array<unsigned char, sizeof(T)> buf {};
+        std::memcpy(buf.data(), &Value, sizeof(T));
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
         std::reverse(buf.begin(), buf.end());
-    #elif defined(_BIG_ENDIAN) && _BIG_ENDIAN
+#elif defined(_BIG_ENDIAN) && _BIG_ENDIAN
         std::reverse(buf.begin(), buf.end());
-    #endif
-        for (unsigned char b : buf) Dst.push_back(static_cast<std::byte>(b));
-}
+#endif
+        for (unsigned char b : buf)
+            Dst.push_back(static_cast<std::byte>(b));
+    }
 
-static inline void PutF(std::vector<std::byte>& dst, float v) { PutLE(dst, v); }
+    static inline void PutF(std::vector<std::byte>& dst, float v) {
+        PutLE(dst, v);
+    }
 
-// ============================================================================
-// Vector/Quat/Transform packing helpers
-// ============================================================================
+    // ============================================================================
+    // Vector/Quat/Transform packing helpers
+    // ============================================================================
 
-static float SafeGetFloat(const Message& m, const Reflection* r, const FieldDescriptor* f) {
-    if (!f) return 0.0f;
+    static float SafeGetFloat(const Message& m, const Reflection* r, const FieldDescriptor* f) {
+        if (!f)
+            return 0.0f;
 
-    if (f->cpp_type() == FieldDescriptor::CPPTYPE_DOUBLE) {
-        return static_cast<float>(r->GetDouble(m, f));
-    } else if (f->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT) {
-        return r->GetFloat(m, f);
+        if (f->cpp_type() == FieldDescriptor::CPPTYPE_DOUBLE) {
+            return static_cast<float>(r->GetDouble(m, f));
+        } else if (f->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT) {
+            return r->GetFloat(m, f);
+        }
+        return 0.0f;
     }
-    return 0.0f; 
-}
 
     static bool PackVector(const Message& m, std::vector<std::byte>& out) {
-    auto* r = m.GetReflection();
-    const Descriptor* d = m.GetDescriptor();
-    const FieldDescriptor* fx = d->FindFieldByName("x"); if (!fx) fx = d->FindFieldByName("r");
-    const FieldDescriptor* fy = d->FindFieldByName("y"); if (!fy) fy = d->FindFieldByName("g");
-    const FieldDescriptor* fz = d->FindFieldByName("z"); if (!fz) fz = d->FindFieldByName("b");
-    const FieldDescriptor* fw = d->FindFieldByName("w");
-    
-    if (!fx || !fy || !fz) return false;
-
-    PutF(out, SafeGetFloat(m, r, fx));
-    PutF(out, SafeGetFloat(m, r, fy));
-    PutF(out, SafeGetFloat(m, r, fz));
-    if (fw) PutF(out, SafeGetFloat(m, r, fw));
-    
-    return true;
-}
-
-static bool PackQuat(const Message& m, std::vector<std::byte>& out) {
-    auto* d = m.GetDescriptor(); auto* r = m.GetReflection();
-    const char* names[4] = { "x","y","z","w" };
-    for (int i = 0; i < 4; ++i) {
-        auto* f = d->FindFieldByName(names[i]);
-        if (!f) return false;
-        PutF(out, SafeGetFloat(m, r, f));
+        auto* r = m.GetReflection();
+        const Descriptor* d = m.GetDescriptor();
+        const FieldDescriptor* fx = d->FindFieldByName("x");
+        if (!fx)
+            fx = d->FindFieldByName("r");
+        const FieldDescriptor* fy = d->FindFieldByName("y");
+        if (!fy)
+            fy = d->FindFieldByName("g");
+        const FieldDescriptor* fz = d->FindFieldByName("z");
+        if (!fz)
+            fz = d->FindFieldByName("b");
+        const FieldDescriptor* fw = d->FindFieldByName("w");
+
+        if (!fx || !fy || !fz)
+            return false;
+
+        PutF(out, SafeGetFloat(m, r, fx));
+        PutF(out, SafeGetFloat(m, r, fy));
+        PutF(out, SafeGetFloat(m, r, fz));
+        if (fw)
+            PutF(out, SafeGetFloat(m, r, fw));
+
+        return true;
     }
-    return true;
-}
-
-static bool PackFloatRange(const Message& m, std::vector<std::byte>& out) {
-    auto* r = m.GetReflection();
-    const Descriptor* d = m.GetDescriptor();
-    auto fmin = d->FindFieldByName("min");
-    auto fmax = d->FindFieldByName("max");
-    
-    PutF(out, SafeGetFloat(m, r, fmin));
-    PutF(out, SafeGetFloat(m, r, fmax));
-    return true;
-}
-
-static bool PackTransform(const Message& m, std::vector<std::byte>& out) {
-    auto* d = m.GetDescriptor();
-    auto* r = m.GetReflection();
-
-    auto packVec = [&](const FieldDescriptor* f)->bool {
-        if (!f || f->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) return false;
-        const Message& sub = r->GetMessage(m, f);
-        return PackVector(sub, out); // x,y,z
-    };
-
-    auto* fT = d->FindFieldByName("translation");
-    auto* fR = d->FindFieldByName("rotation");
-    auto* fS = d->FindFieldByName("scale");
-    if (!fT || !fR || !fS) return false;
-
-    if (!packVec(fT)) return false;
-
-    // quat (x,y,z,w)
-    {
-        const Message& q = r->GetMessage(m, fR);
-        if (!PackQuat(q, out)) return false;
+
+    static bool PackQuat(const Message& m, std::vector<std::byte>& out) {
+        auto* d = m.GetDescriptor();
+        auto* r = m.GetReflection();
+        const char* names[4] = {"x", "y", "z", "w"};
+        for (int i = 0; i < 4; ++i) {
+            auto* f = d->FindFieldByName(names[i]);
+            if (!f)
+                return false;
+            PutF(out, SafeGetFloat(m, r, f));
+        }
+        return true;
     }
 
-    if (!packVec(fS)) return false;
-    return true;
-}
-    
-static inline bool IsKnownStructMsg(const Descriptor* md) {
-    if (!md) return false;
-    const std::string& n = md->name();
-    return n == "Vector" || n == "Quat" || n == "Transform" || n == "FloatRange";
-}
-
-static bool PackKnownStruct(const Message& m, std::vector<std::byte>& out) {
-    const std::string& n = m.GetDescriptor()->name();
-    if (n == "Vector")     return PackVector(m, out);
-    if (n == "Quat")       return PackQuat(m, out);
-    if (n == "Transform")  return PackTransform(m, out);
-    if (n == "FloatRange") return PackFloatRange(m, out);
-    return false;
-}
-    
-// ============================================================
-// Constructor / Destructor
-// ============================================================
-    
+    static bool PackFloatRange(const Message& m, std::vector<std::byte>& out) {
+        auto* r = m.GetReflection();
+        const Descriptor* d = m.GetDescriptor();
+        auto fmin = d->FindFieldByName("min");
+        auto fmax = d->FindFieldByName("max");
+
+        PutF(out, SafeGetFloat(m, r, fmin));
+        PutF(out, SafeGetFloat(m, r, fmax));
+        return true;
+    }
+
+    static bool PackTransform(const Message& m, std::vector<std::byte>& out) {
+        auto* d = m.GetDescriptor();
+        auto* r = m.GetReflection();
+
+        auto packVec = [&](const FieldDescriptor* f) -> bool {
+            if (!f || f->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE)
+                return false;
+            const Message& sub = r->GetMessage(m, f);
+            return PackVector(sub, out); // x,y,z
+        };
+
+        auto* fT = d->FindFieldByName("translation");
+        auto* fR = d->FindFieldByName("rotation");
+        auto* fS = d->FindFieldByName("scale");
+        if (!fT || !fR || !fS)
+            return false;
+
+        if (!packVec(fT))
+            return false;
+
+        // quat (x,y,z,w)
+        {
+            const Message& q = r->GetMessage(m, fR);
+            if (!PackQuat(q, out))
+                return false;
+        }
+
+        if (!packVec(fS))
+            return false;
+        return true;
+    }
+
+    static inline bool IsKnownStructMsg(const Descriptor* md) {
+        if (!md)
+            return false;
+        const std::string& n = md->name();
+        return n == "Vector" || n == "Quat" || n == "Transform" || n == "FloatRange";
+    }
+
+    static bool PackKnownStruct(const Message& m, std::vector<std::byte>& out) {
+        const std::string& n = m.GetDescriptor()->name();
+        if (n == "Vector")
+            return PackVector(m, out);
+        if (n == "Quat")
+            return PackQuat(m, out);
+        if (n == "Transform")
+            return PackTransform(m, out);
+        if (n == "FloatRange")
+            return PackFloatRange(m, out);
+        return false;
+    }
+
+    // ============================================================
+    // Constructor / Destructor
+    // ============================================================
+
     FProtobufViewAdapter::FProtobufViewAdapter(const google::protobuf::Message* InMsg, bool bOwnsMessage)
-        : External(InMsg) 
-    {
+        : External(InMsg) {
         if (!bOwnsMessage) {}
     }
 
@@ -199,205 +214,206 @@ static bool PackKnownStruct(const Message& m, std::vector<std::byte>& out) {
     FProtobufViewAdapter& FProtobufViewAdapter::operator=(FProtobufViewAdapter&&) noexcept = default;
 
 
-// ============================================================
-// CloneMessage
-// ------------------------------------------------------------
-// Creates a deep copy of a protobuf message using the same
-// DescriptorPool and DynamicMessageFactory.
-// This is used to produce isolated views for diffing without
-// modifying the original protobuf instance.
-// ============================================================
-
-std::unique_ptr<Message> FProtobufViewAdapter::CloneMessage(const Message& Src)
-{
-    const google::protobuf::Descriptor* Desc = Src.GetDescriptor();
-    const google::protobuf::DescriptorPool* Pool = Desc ? Desc->file()->pool() : google::protobuf::DescriptorPool::generated_pool();
-
-    // Always use the same pool as the source
-    auto* Factory = GetFactoryForPool(Pool);
-    const google::protobuf::Message* Proto = Factory->GetPrototype(Desc);
-    if (!Proto) return nullptr;
-
-    auto Copy = std::unique_ptr<google::protobuf::Message>(Proto->New());
-    Copy->CopyFrom(Src);
-    return Copy;
-}
-
-void FProtobufViewAdapter::Reset()
-{
-    ResetArena();
-}
-    
-// ============================================================
-// CreateRoot
-// ------------------------------------------------------------
-// Creates a ProtobufViewAdapter from a serialized buffer and
-// the provided root message type name.
-// Used when reading frames directly from binary memory.
-// ============================================================
-std::optional<FProtobufViewAdapter> FProtobufViewAdapter::CreateRoot(const DescriptorPool* Pool, const std::string& RootType, const uint8_t* Buffer, size_t Size)
-{
-    if (!Pool || !Buffer || Size == 0) return std::nullopt;
-    const google::protobuf::Descriptor* Desc = Pool->FindMessageTypeByName(RootType);
-    if (!Desc) return std::nullopt;
-    auto OwnedMsg = NewOwnedMessage(Pool, Desc);
-    if (!OwnedMsg) return std::nullopt;
-    if (!OwnedMsg->ParseFromArray(Buffer, static_cast<int>(Size))) return std::nullopt;
-
-    FProtobufViewAdapter Adapter(OwnedMsg.get(), true);
-    Adapter.Owned = std::move(OwnedMsg);
-    return Adapter;
-}
-
-// ============================================================
-// FromMessage
-// ------------------------------------------------------------
-// Creates a ProtobufViewAdapter from an existing in-memory
-// protobuf message by cloning it internally.
-// This avoids modifying the original instance during diffing.
-// ============================================================
-
-std::optional<FProtobufViewAdapter> FProtobufViewAdapter::FromMessage(const Message& M)
-{
-    auto OwnedMsg = CloneMessage(M);
-    if (!OwnedMsg) return std::nullopt;
-
-    FProtobufViewAdapter Adapter(OwnedMsg.get(), true);
-    Adapter.Owned = std::move(OwnedMsg);
-    return Adapter;
-}
-
-void FProtobufViewAdapter::SetSubArrayNames(std::unordered_map<std::string, SubArrayNames> Map)
-{
-    SubNames = std::move(Map);
-}
-// ============================================================
-// FindField
-// ------------------------------------------------------------
-// Locates a field descriptor by its name within the current
-// message descriptor. Returns nullptr if not found.
-// ============================================================
-const google::protobuf::FieldDescriptor* FProtobufViewAdapter::FindField(std::string_view Name) const
-{
-    const auto* D = GetDesc();
-    if (!D)
-        return nullptr;
-
-    return D->FindFieldByName(std::string(Name));
-}
-
-
-// ============================================================
-// GetScalarFieldString
-// ------------------------------------------------------------
-// Retrieves the string value of a scalar (non-repeated) field
-// from the current protobuf message. Returns an empty string
-// if the field does not exist or is not a string type.
-// ============================================================
- 
-std::string FProtobufViewAdapter::GetScalarFieldString(const std::string& FieldName) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
-
-    if (!M || !D || !R)
-        return {};
+    // ============================================================
+    // CloneMessage
+    // ------------------------------------------------------------
+    // Creates a deep copy of a protobuf message using the same
+    // DescriptorPool and DynamicMessageFactory.
+    // This is used to produce isolated views for diffing without
+    // modifying the original protobuf instance.
+    // ============================================================
 
-    const auto* Field = D->FindFieldByName(FieldName);
-    
-    if (!Field || Field->is_repeated())
-        return {};
+    std::unique_ptr<Message> FProtobufViewAdapter::CloneMessage(const Message& Src) {
+        const google::protobuf::Descriptor* Desc = Src.GetDescriptor();
+        const google::protobuf::DescriptorPool* Pool =
+            Desc ? Desc->file()->pool() : google::protobuf::DescriptorPool::generated_pool();
 
-    switch (Field->cpp_type())
-    {
-    case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
-        return R->GetString(*M, Field);
+        // Always use the same pool as the source
+        auto* Factory = GetFactoryForPool(Pool);
+        const google::protobuf::Message* Proto = Factory->GetPrototype(Desc);
+        if (!Proto)
+            return nullptr;
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
-        return std::to_string(R->GetUInt64(*M, Field));
+        auto Copy = std::unique_ptr<google::protobuf::Message>(Proto->New());
+        Copy->CopyFrom(Src);
+        return Copy;
+    }
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
-        return std::to_string(R->GetInt64(*M, Field));
+    void FProtobufViewAdapter::Reset() {
+        ResetArena();
+    }
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
-        return std::to_string(R->GetUInt32(*M, Field));
+    // ============================================================
+    // CreateRoot
+    // ------------------------------------------------------------
+    // Creates a ProtobufViewAdapter from a serialized buffer and
+    // the provided root message type name.
+    // Used when reading frames directly from binary memory.
+    // ============================================================
+    std::optional<FProtobufViewAdapter> FProtobufViewAdapter::CreateRoot(const DescriptorPool* Pool,
+                                                                         const std::string& RootType,
+                                                                         const uint8_t* Buffer, size_t Size) {
+        if (!Pool || !Buffer || Size == 0)
+            return std::nullopt;
+        const google::protobuf::Descriptor* Desc = Pool->FindMessageTypeByName(RootType);
+        if (!Desc)
+            return std::nullopt;
+        auto OwnedMsg = NewOwnedMessage(Pool, Desc);
+        if (!OwnedMsg)
+            return std::nullopt;
+        if (!OwnedMsg->ParseFromArray(Buffer, static_cast<int>(Size)))
+            return std::nullopt;
+
+        FProtobufViewAdapter Adapter(OwnedMsg.get(), true);
+        Adapter.Owned = std::move(OwnedMsg);
+        return Adapter;
+    }
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
-        return std::to_string(R->GetInt32(*M, Field));
+    // ============================================================
+    // FromMessage
+    // ------------------------------------------------------------
+    // Creates a ProtobufViewAdapter from an existing in-memory
+    // protobuf message by cloning it internally.
+    // This avoids modifying the original instance during diffing.
+    // ============================================================
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
-        return std::to_string(R->GetFloat(*M, Field));
+    std::optional<FProtobufViewAdapter> FProtobufViewAdapter::FromMessage(const Message& M) {
+        auto OwnedMsg = CloneMessage(M);
+        if (!OwnedMsg)
+            return std::nullopt;
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
-        return std::to_string(R->GetDouble(*M, Field));
+        FProtobufViewAdapter Adapter(OwnedMsg.get(), true);
+        Adapter.Owned = std::move(OwnedMsg);
+        return Adapter;
+    }
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
-        return R->GetBool(*M, Field) ? "true" : "false";
+    void FProtobufViewAdapter::SetSubArrayNames(std::unordered_map<std::string, SubArrayNames> Map) {
+        SubNames = std::move(Map);
+    }
+    // ============================================================
+    // FindField
+    // ------------------------------------------------------------
+    // Locates a field descriptor by its name within the current
+    // message descriptor. Returns nullptr if not found.
+    // ============================================================
+    const google::protobuf::FieldDescriptor* FProtobufViewAdapter::FindField(std::string_view Name) const {
+        const auto* D = GetDesc();
+        if (!D)
+            return nullptr;
 
-    case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
-        return std::to_string(R->GetEnumValue(*M, Field));
+        return D->FindFieldByName(std::string(Name));
+    }
 
-    default:
-        return {};
+
+    // ============================================================
+    // GetScalarFieldString
+    // ------------------------------------------------------------
+    // Retrieves the string value of a scalar (non-repeated) field
+    // from the current protobuf message. Returns an empty string
+    // if the field does not exist or is not a string type.
+    // ============================================================
+
+    std::string FProtobufViewAdapter::GetScalarFieldString(const std::string& FieldName) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+
+        if (!M || !D || !R)
+            return {};
+
+        const auto* Field = D->FindFieldByName(FieldName);
+
+        if (!Field || Field->is_repeated())
+            return {};
+
+        switch (Field->cpp_type()) {
+        case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
+            return R->GetString(*M, Field);
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
+            return std::to_string(R->GetUInt64(*M, Field));
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
+            return std::to_string(R->GetInt64(*M, Field));
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
+            return std::to_string(R->GetUInt32(*M, Field));
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
+            return std::to_string(R->GetInt32(*M, Field));
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
+            return std::to_string(R->GetFloat(*M, Field));
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
+            return std::to_string(R->GetDouble(*M, Field));
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
+            return R->GetBool(*M, Field) ? "true" : "false";
+
+        case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
+            return std::to_string(R->GetEnumValue(*M, Field));
+
+        default:
+            return {};
+        }
     }
-}
 
-uint64_t FProtobufViewAdapter::GetUint64Field(const std::string& FieldName) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
+    uint64_t FProtobufViewAdapter::GetUint64Field(const std::string& FieldName) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+
+        if (!M || !D || !R)
+            return 0;
+
+        const auto* Field = D->FindFieldByName(FieldName);
 
-    if (!M || !D || !R)
+        if (!Field || Field->is_repeated())
+            return {};
+
+        if (Field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_UINT64) {
+            return R->GetUInt64(*M, Field);
+        }
         return 0;
+    }
 
-    const auto* Field = D->FindFieldByName(FieldName);
-    
-    if (!Field || Field->is_repeated())
-        return {};
-    
-    if ( Field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_UINT64)
-    {
-        return R->GetUInt64(*M, Field);
+    // ============================================================
+    // GetFieldByName
+    // ------------------------------------------------------------
+    // Returns a nested node view (sub-structure) for the given field
+    // name, if that field represents a singular message type.
+    // ============================================================
+    FProtobufViewAdapter FProtobufViewAdapter::GetFieldByName(const std::string& FieldName) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+        if (!M || !D || !R)
+            return {};
+        const auto* Field = FindField(FieldName);
+        if (!Field || Field->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE || Field->is_repeated())
+            return {};
+        if (!R->HasField(*M, Field))
+            return {};
+
+        const google::protobuf::Message& Nested = R->GetMessage(*M, Field);
+        return FProtobufViewAdapter(&Nested, false);
     }
-    return 0;
-}
-
-// ============================================================
-// GetFieldByName
-// ------------------------------------------------------------
-// Returns a nested node view (sub-structure) for the given field
-// name, if that field represents a singular message type.
-// ============================================================
-FProtobufViewAdapter FProtobufViewAdapter::GetFieldByName(const std::string& FieldName) const
-{
-    const auto* M = GetMsg(); const auto* D = GetDesc(); const auto* R = GetRefl();
-    if (!M || !D || !R) return {};
-    const auto* Field = FindField(FieldName);
-    if (!Field || Field->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE || Field->is_repeated()) return {};
-    if (!R->HasField(*M, Field)) return {};
-
-    const google::protobuf::Message& Nested = R->GetMessage(*M, Field);
-    return FProtobufViewAdapter(&Nested, false);
-}
-
-
-// ============================================================
-// IsScalar
-// ------------------------------------------------------------
-// Returns true if a protobuf field is a scalar POD type
-// (int, float, double, bool, enum, etc).
-// ============================================================
-    
-bool FProtobufViewAdapter::IsScalar(const FieldDescriptor* Field) const
-{
-    if (!Field) 
-        return false;
 
-    using FD = google::protobuf::FieldDescriptor;
-    switch (Field->cpp_type())
-    {
+
+    // ============================================================
+    // IsScalar
+    // ------------------------------------------------------------
+    // Returns true if a protobuf field is a scalar POD type
+    // (int, float, double, bool, enum, etc).
+    // ============================================================
+
+    bool FProtobufViewAdapter::IsScalar(const FieldDescriptor* Field) const {
+        if (!Field)
+            return false;
+
+        using FD = google::protobuf::FieldDescriptor;
+        switch (Field->cpp_type()) {
         case FD::CPPTYPE_INT32:
         case FD::CPPTYPE_UINT32:
         case FD::CPPTYPE_INT64:
@@ -409,572 +425,565 @@ bool FProtobufViewAdapter::IsScalar(const FieldDescriptor* Field) const
             return true;
         default:
             return false;
+        }
     }
-}
-
-// ============================================================
-// InferContainerType
-// ------------------------------------------------------------
-// Determines the EVTXContainerType that corresponds to a given
-// protobuf field. This mapping follows the naming and layout
-// rules used in FVTXPropertyContainerArrays.
-// ============================================================
-
-EVTXContainerType FProtobufViewAdapter::InferContainerType(const FieldDescriptor* Field) const
-{
-    if (!Field) return EVTXContainerType::Unknown;
-
-    const std::string_view N = Field->name();
-
-    using Pair = std::pair<std::string_view, EVTXContainerType>;
-    static constexpr std::array<Pair, 25> kByName = { {
-        {"transform_properties", EVTXContainerType::TransformProperties},
-        {"int32_properties",     EVTXContainerType::Int32Properties},
-        {"int64_properties",     EVTXContainerType::Int64Properties},
-        {"float_properties",     EVTXContainerType::FloatProperties},
-        {"double_properties",    EVTXContainerType::DoubleProperties},
-        {"vector_properties",    EVTXContainerType::VectorProperties},
-        {"quat_properties",      EVTXContainerType::QuatProperties},
-        {"range_properties",     EVTXContainerType::RangeProperties},
-        {"bool_properties",      EVTXContainerType::BoolProperties},
-        {"string_properties",    EVTXContainerType::StringProperties},
-
-        {"byte_array_properties",EVTXContainerType::ByteArrayProperties},
-        {"int32_arrays",         EVTXContainerType::Int32Arrays},
-        {"int64_arrays",         EVTXContainerType::Int64Arrays},
-        {"float_arrays",         EVTXContainerType::FloatArrays},
-        {"double_arrays",        EVTXContainerType::DoubleArrays},
-        {"vector_arrays",        EVTXContainerType::VectorArrays},
-        {"quat_arrays",          EVTXContainerType::QuatArrays},
-        {"transform_arrays",     EVTXContainerType::TransformArrays},
-        {"range_arrays",         EVTXContainerType::RangeArrays},
-        {"bool_arrays",          EVTXContainerType::BoolArrays},
-        {"string_arrays",        EVTXContainerType::StringArrays},
-
-        {"any_struct_properties", EVTXContainerType::AnyStructProperties},
-        {"any_struct_arrays",     EVTXContainerType::AnyStructArrays},
-        {"map_properties",       EVTXContainerType::MapProperties},
-        {"map_arrays",           EVTXContainerType::MapArrays}
-    } };
-
-    for (const auto& [K, V] : kByName)
-        if (K == N) return V;
-
-    return EVTXContainerType::Unknown;
-}
-
-std::span<const std::byte> FProtobufViewAdapter::Publish(const void* Data, size_t Size) const
-{
-    if (!Data || Size == 0)
-        return {};
 
-    const auto* Bytes = static_cast<const std::byte*>(Data);
-    Arena.emplace_back(Bytes, Bytes + Size);
+    // ============================================================
+    // InferContainerType
+    // ------------------------------------------------------------
+    // Determines the EVTXContainerType that corresponds to a given
+    // protobuf field. This mapping follows the naming and layout
+    // rules used in FVTXPropertyContainerArrays.
+    // ============================================================
+
+    EVTXContainerType FProtobufViewAdapter::InferContainerType(const FieldDescriptor* Field) const {
+        if (!Field)
+            return EVTXContainerType::Unknown;
+
+        const std::string_view N = Field->name();
+
+        using Pair = std::pair<std::string_view, EVTXContainerType>;
+        static constexpr std::array<Pair, 25> kByName = {
+            {{"transform_properties", EVTXContainerType::TransformProperties},
+             {"int32_properties", EVTXContainerType::Int32Properties},
+             {"int64_properties", EVTXContainerType::Int64Properties},
+             {"float_properties", EVTXContainerType::FloatProperties},
+             {"double_properties", EVTXContainerType::DoubleProperties},
+             {"vector_properties", EVTXContainerType::VectorProperties},
+             {"quat_properties", EVTXContainerType::QuatProperties},
+             {"range_properties", EVTXContainerType::RangeProperties},
+             {"bool_properties", EVTXContainerType::BoolProperties},
+             {"string_properties", EVTXContainerType::StringProperties},
+
+             {"byte_array_properties", EVTXContainerType::ByteArrayProperties},
+             {"int32_arrays", EVTXContainerType::Int32Arrays},
+             {"int64_arrays", EVTXContainerType::Int64Arrays},
+             {"float_arrays", EVTXContainerType::FloatArrays},
+             {"double_arrays", EVTXContainerType::DoubleArrays},
+             {"vector_arrays", EVTXContainerType::VectorArrays},
+             {"quat_arrays", EVTXContainerType::QuatArrays},
+             {"transform_arrays", EVTXContainerType::TransformArrays},
+             {"range_arrays", EVTXContainerType::RangeArrays},
+             {"bool_arrays", EVTXContainerType::BoolArrays},
+             {"string_arrays", EVTXContainerType::StringArrays},
+
+             {"any_struct_properties", EVTXContainerType::AnyStructProperties},
+             {"any_struct_arrays", EVTXContainerType::AnyStructArrays},
+             {"map_properties", EVTXContainerType::MapProperties},
+             {"map_arrays", EVTXContainerType::MapArrays}}};
+
+        for (const auto& [K, V] : kByName)
+            if (K == N)
+                return V;
+
+        return EVTXContainerType::Unknown;
+    }
 
-    const auto& Last = Arena.back();
-    return { Last.data(), Last.size() };
-}
+    std::span<const std::byte> FProtobufViewAdapter::Publish(const void* Data, size_t Size) const {
+        if (!Data || Size == 0)
+            return {};
 
-std::span<const std::byte> FProtobufViewAdapter::Publish(const std::vector<std::byte>& Buffer) const
-{
-    if (Buffer.empty())
-        return {};
+        const auto* Bytes = static_cast<const std::byte*>(Data);
+        Arena.emplace_back(Bytes, Bytes + Size);
 
-    Arena.emplace_back(Buffer.begin(), Buffer.end());
-    const auto& Last = Arena.back();
-    return { Last.data(), Last.size() };
-}
-
-std::span<const std::byte> FProtobufViewAdapter::Publish(std::vector<std::byte>&& Buffer) const
-{
-    Arena.push_back(std::move(Buffer));
-    const auto& Last = Arena.back();
-    return { Last.data(), Last.size() };
-}
-    
-void FProtobufViewAdapter::ResetArena() const
-{
-    Arena.clear();
-    Scratch.clear();
-    TempString.clear();
-}
-
-const google::protobuf::Descriptor* FProtobufViewAdapter::ActiveDesc() const
-{
-    return GetDesc();
-}
+        const auto& Last = Arena.back();
+        return {Last.data(), Last.size()};
+    }
 
-    // ============================================================
-// EnumerateFields
-// ------------------------------------------------------------
-// Returns a list of all protobuf fields in the current message
-// that contain meaningful data. This function dynamically queries
-// the descriptor and reflection interface, without relying on any
-// cached pointers.
-// ============================================================
-std::span<const VtxDiff::FieldDesc> FProtobufViewAdapter::EnumerateFields() const
-{
-    if (bFieldsCached) return CachedFields;
-
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
-
-    if (!M || !D || !R) return {};
-
-    CachedFields.reserve(D->field_count());
-
-    auto hasData = [&](const google::protobuf::FieldDescriptor* f) -> bool {
-        if (!f) return false;
-        if (f->is_repeated()) return R->FieldSize(*M, f) > 0;
-        
-        using FD = google::protobuf::FieldDescriptor;
-        switch (f->cpp_type()) {
-        case FD::CPPTYPE_MESSAGE: return R->HasField(*M, f);
-        case FD::CPPTYPE_STRING:  return !R->GetString(*M, f).empty();
-        case FD::CPPTYPE_BOOL:    return R->GetBool(*M, f);
-        case FD::CPPTYPE_INT32:   return R->GetInt32(*M, f) != 0;
-        case FD::CPPTYPE_UINT32:  return R->GetUInt32(*M, f) != 0;
-        case FD::CPPTYPE_INT64:   return R->GetInt64(*M, f) != 0;
-        case FD::CPPTYPE_UINT64:  return R->GetUInt64(*M, f) != 0;
-        case FD::CPPTYPE_FLOAT:   return R->GetFloat(*M, f) != 0.0f;
-        case FD::CPPTYPE_DOUBLE:  return R->GetDouble(*M, f) != 0.0;
-        case FD::CPPTYPE_ENUM:    return R->GetEnumValue(*M, f) != 0;
-        default: return false;
-        }
-    };
+    std::span<const std::byte> FProtobufViewAdapter::Publish(const std::vector<std::byte>& Buffer) const {
+        if (Buffer.empty())
+            return {};
 
-    for (int i = 0; i < D->field_count(); ++i) {
-        const auto* f = D->field(i);
-        if (!f || !hasData(f)) continue;
+        Arena.emplace_back(Buffer.begin(), Buffer.end());
+        const auto& Last = Arena.back();
+        return {Last.data(), Last.size()};
+    }
 
-        VtxDiff::FieldDesc d;
-        d.name = f->name();
-        d.is_actors_field = (d.name == "entities");
-        d.type = InferContainerType(f);
-        d.is_array_like = f->is_repeated();
-        d.is_map_like = f->is_map();
+    std::span<const std::byte> FProtobufViewAdapter::Publish(std::vector<std::byte>&& Buffer) const {
+        Arena.push_back(std::move(Buffer));
+        const auto& Last = Arena.back();
+        return {Last.data(), Last.size()};
+    }
 
-        CachedFields.push_back(std::move(d));
+    void FProtobufViewAdapter::ResetArena() const {
+        Arena.clear();
+        Scratch.clear();
+        TempString.clear();
     }
 
-    bFieldsCached = true;
-    return CachedFields;
-}
-
-// ============================================================
-// GetFieldBytes
-// ------------------------------------------------------------
-// Retrieves the binary data for a specific field in the message.
-// Handles scalar, repeated, and nested message types.
-// ============================================================
-std::span<const std::byte> FProtobufViewAdapter::GetFieldBytes(const VtxDiff::FieldDesc& Field) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
-
-    if (!M || !D || !R)
-        return {};
+    const google::protobuf::Descriptor* FProtobufViewAdapter::ActiveDesc() const {
+        return GetDesc();
+    }
 
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F)
-        return {};
+    // ============================================================
+    // EnumerateFields
+    // ------------------------------------------------------------
+    // Returns a list of all protobuf fields in the current message
+    // that contain meaningful data. This function dynamically queries
+    // the descriptor and reflection interface, without relying on any
+    // cached pointers.
+    // ============================================================
+    std::span<const VtxDiff::FieldDesc> FProtobufViewAdapter::EnumerateFields() const {
+        if (bFieldsCached)
+            return CachedFields;
+
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
 
-    Scratch.clear();
+        if (!M || !D || !R)
+            return {};
+
+        CachedFields.reserve(D->field_count());
+
+        auto hasData = [&](const google::protobuf::FieldDescriptor* f) -> bool {
+            if (!f)
+                return false;
+            if (f->is_repeated())
+                return R->FieldSize(*M, f) > 0;
+
+            using FD = google::protobuf::FieldDescriptor;
+            switch (f->cpp_type()) {
+            case FD::CPPTYPE_MESSAGE:
+                return R->HasField(*M, f);
+            case FD::CPPTYPE_STRING:
+                return !R->GetString(*M, f).empty();
+            case FD::CPPTYPE_BOOL:
+                return R->GetBool(*M, f);
+            case FD::CPPTYPE_INT32:
+                return R->GetInt32(*M, f) != 0;
+            case FD::CPPTYPE_UINT32:
+                return R->GetUInt32(*M, f) != 0;
+            case FD::CPPTYPE_INT64:
+                return R->GetInt64(*M, f) != 0;
+            case FD::CPPTYPE_UINT64:
+                return R->GetUInt64(*M, f) != 0;
+            case FD::CPPTYPE_FLOAT:
+                return R->GetFloat(*M, f) != 0.0f;
+            case FD::CPPTYPE_DOUBLE:
+                return R->GetDouble(*M, f) != 0.0;
+            case FD::CPPTYPE_ENUM:
+                return R->GetEnumValue(*M, f) != 0;
+            default:
+                return false;
+            }
+        };
+
+        for (int i = 0; i < D->field_count(); ++i) {
+            const auto* f = D->field(i);
+            if (!f || !hasData(f))
+                continue;
+
+            VtxDiff::FieldDesc d;
+            d.name = f->name();
+            d.is_actors_field = (d.name == "entities");
+            d.type = InferContainerType(f);
+            d.is_array_like = f->is_repeated();
+            d.is_map_like = f->is_map();
+
+            CachedFields.push_back(std::move(d));
+        }
+
+        bFieldsCached = true;
+        return CachedFields;
+    }
 
     // ============================================================
-    // Handle scalar (non-repeated, non-message) types
+    // GetFieldBytes
+    // ------------------------------------------------------------
+    // Retrieves the binary data for a specific field in the message.
+    // Handles scalar, repeated, and nested message types.
     // ============================================================
-    if (!F->is_repeated() && F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
-    {
-        switch (F->cpp_type())
-        {
+    std::span<const std::byte> FProtobufViewAdapter::GetFieldBytes(const VtxDiff::FieldDesc& Field) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+
+        if (!M || !D || !R)
+            return {};
+
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F)
+            return {};
+
+        Scratch.clear();
+
+        // ============================================================
+        // Handle scalar (non-repeated, non-message) types
+        // ============================================================
+        if (!F->is_repeated() && F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
+            switch (F->cpp_type()) {
             case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
-                PutLE(Scratch, R->GetInt32(*M, F)); break;
+                PutLE(Scratch, R->GetInt32(*M, F));
+                break;
             case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
-                PutLE(Scratch, R->GetUInt32(*M, F)); break;
+                PutLE(Scratch, R->GetUInt32(*M, F));
+                break;
             case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
-                PutLE(Scratch, R->GetInt64(*M, F)); break;
+                PutLE(Scratch, R->GetInt64(*M, F));
+                break;
             case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
-                PutLE(Scratch, R->GetUInt64(*M, F)); break;
+                PutLE(Scratch, R->GetUInt64(*M, F));
+                break;
             case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
-                PutLE(Scratch, R->GetFloat(*M, F)); break;
+                PutLE(Scratch, R->GetFloat(*M, F));
+                break;
             case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
-                PutLE(Scratch, R->GetDouble(*M, F)); break;
-            case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
-            {
+                PutLE(Scratch, R->GetDouble(*M, F));
+                break;
+            case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
                 uint8_t val = R->GetBool(*M, F) ? 1 : 0;
                 Scratch.push_back(static_cast<std::byte>(val));
                 break;
             }
-            case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
-            {
+            case google::protobuf::FieldDescriptor::CPPTYPE_STRING: {
                 std::string s = R->GetString(*M, F);
                 return Publish(s.data(), s.size());
             }
             default:
                 break;
-        }
+            }
 
-        return Publish(Scratch);
-    }
+            return Publish(Scratch);
+        }
 
-    // ============================================================
-    // Handle singular nested messages (e.g., Vector, Quat, Transform)
-    // ============================================================
-    if (!F->is_repeated() && F->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
-    {
-        const google::protobuf::Message& Nested = R->GetMessage(*M, F);
+        // ============================================================
+        // Handle singular nested messages (e.g., Vector, Quat, Transform)
+        // ============================================================
+        if (!F->is_repeated() && F->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
+            const google::protobuf::Message& Nested = R->GetMessage(*M, F);
 
-        // Try to pack known math-style structs efficiently
-        if (PackKnownStruct(Nested, Scratch))
-            return Publish(Scratch);
+            // Try to pack known math-style structs efficiently
+            if (PackKnownStruct(Nested, Scratch))
+                return Publish(Scratch);
 
-        // Fallback: serialize full message
-        std::vector<std::byte> Data(static_cast<size_t>(Nested.ByteSizeLong()));
-        Nested.SerializePartialToArray(Data.data(), static_cast<int>(Data.size()));
-        return Publish(std::move(Data));
-    }
+            // Fallback: serialize full message
+            std::vector<std::byte> Data(static_cast<size_t>(Nested.ByteSizeLong()));
+            Nested.SerializePartialToArray(Data.data(), static_cast<int>(Data.size()));
+            return Publish(std::move(Data));
+        }
 
-    // ============================================================
-    // Handle repeated scalar fields
-    // ============================================================
-    if (F->is_repeated() && F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
-    {
-        const int Count = R->FieldSize(*M, F);
-        Scratch.reserve(Count * 8); // estimated element size
+        // ============================================================
+        // Handle repeated scalar fields
+        // ============================================================
+        if (F->is_repeated() && F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
+            const int Count = R->FieldSize(*M, F);
+            Scratch.reserve(Count * 8); // estimated element size
 
-        for (int i = 0; i < Count; ++i)
-        {
-            switch (F->cpp_type())
-            {
+            for (int i = 0; i < Count; ++i) {
+                switch (F->cpp_type()) {
                 case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
-                    PutLE(Scratch, R->GetRepeatedInt32(*M, F, i)); break;
+                    PutLE(Scratch, R->GetRepeatedInt32(*M, F, i));
+                    break;
                 case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
-                    PutLE(Scratch, R->GetRepeatedUInt32(*M, F, i)); break;
+                    PutLE(Scratch, R->GetRepeatedUInt32(*M, F, i));
+                    break;
                 case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
-                    PutLE(Scratch, R->GetRepeatedInt64(*M, F, i)); break;
+                    PutLE(Scratch, R->GetRepeatedInt64(*M, F, i));
+                    break;
                 case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
-                    PutLE(Scratch, R->GetRepeatedUInt64(*M, F, i)); break;
+                    PutLE(Scratch, R->GetRepeatedUInt64(*M, F, i));
+                    break;
                 case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
-                    PutLE(Scratch, R->GetRepeatedFloat(*M, F, i)); break;
+                    PutLE(Scratch, R->GetRepeatedFloat(*M, F, i));
+                    break;
                 case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
-                    PutLE(Scratch, R->GetRepeatedDouble(*M, F, i)); break;
-                case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
-                {
+                    PutLE(Scratch, R->GetRepeatedDouble(*M, F, i));
+                    break;
+                case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
                     uint8_t val = R->GetRepeatedBool(*M, F, i) ? 1 : 0;
                     Scratch.push_back(static_cast<std::byte>(val));
                     break;
                 }
                 default:
                     break;
+                }
             }
+
+            return Publish(Scratch);
         }
 
-        return Publish(Scratch);
+        return {};
     }
 
-    return {};
-}
-
 
-// ============================================================
-// GetArraySize
-// ------------------------------------------------------------
-// Returns the number of elements in a repeated field or 1 for
-// scalar fields. Returns 0 if the field is invalid or unset.
-// ============================================================
-size_t FProtobufViewAdapter::GetArraySize(const VtxDiff::FieldDesc& Fd) const
-{
-    const auto* M = GetMsg();
-    const auto* R = GetRefl();
+    // ============================================================
+    // GetArraySize
+    // ------------------------------------------------------------
+    // Returns the number of elements in a repeated field or 1 for
+    // scalar fields. Returns 0 if the field is invalid or unset.
+    // ============================================================
+    size_t FProtobufViewAdapter::GetArraySize(const VtxDiff::FieldDesc& Fd) const {
+        const auto* M = GetMsg();
+        const auto* R = GetRefl();
 
-    if (!M || !R)
-    {
-        VTX_WARN("[GetArraySize] Invalid message or reflection for field {}", Fd.name);
-        return 0;
-    }
+        if (!M || !R) {
+            VTX_WARN("[GetArraySize] Invalid message or reflection for field {}", Fd.name);
+            return 0;
+        }
 
-    const auto* F = FindField(Fd.name);
-    if (!F)
-    {
-       VTX_ERROR("[GetArraySize] Field not found in message: {}", Fd.name);
+        const auto* F = FindField(Fd.name);
+        if (!F) {
+            VTX_ERROR("[GetArraySize] Field not found in message: {}", Fd.name);
 
-        return 0;
-    }
+            return 0;
+        }
 
-    const int Size = F->is_repeated() ? R->FieldSize(*M, F) : 1;
+        const int Size = F->is_repeated() ? R->FieldSize(*M, F) : 1;
 
 #if defined(UE_LOG)
-    UE_LOG(LogTemp, Verbose, TEXT("[GetArraySize] Field %s size = %d (is_repeated=%d)"),
-        *FString(Fd.Name.c_str()), Size, static_cast<int>(F->is_repeated()));
+        UE_LOG(LogTemp, Verbose, TEXT("[GetArraySize] Field %s size = %d (is_repeated=%d)"), *FString(Fd.Name.c_str()),
+               Size, static_cast<int>(F->is_repeated()));
 #endif
 
-    return static_cast<size_t>(Size);
-}
-
-// ============================================================
-// GetArrayElementBytes
-// ------------------------------------------------------------
-// Returns a binary span for a specific element of a repeated field.
-// Handles scalar and message element types.
-// ============================================================
-std::span<const std::byte> FProtobufViewAdapter::GetArrayElementBytes(
-    const VtxDiff::FieldDesc& Field, size_t Index) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
-
-    if (!M || !D || !R)
-        return {};
+        return static_cast<size_t>(Size);
+    }
 
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F || !F->is_repeated())
-        return {};
+    // ============================================================
+    // GetArrayElementBytes
+    // ------------------------------------------------------------
+    // Returns a binary span for a specific element of a repeated field.
+    // Handles scalar and message element types.
+    // ============================================================
+    std::span<const std::byte> FProtobufViewAdapter::GetArrayElementBytes(const VtxDiff::FieldDesc& Field,
+                                                                          size_t Index) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
 
-    const int Count = R->FieldSize(*M, F);
-    if (Index >= static_cast<size_t>(Count))
-        return {};
+        if (!M || !D || !R)
+            return {};
 
-    Scratch.clear();
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F || !F->is_repeated())
+            return {};
 
-    // Handle repeated message elements (Vector, Quat, Transform, etc.)
-    if (F->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
-    {
-        const google::protobuf::Message& Nested =
-            R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
+        const int Count = R->FieldSize(*M, F);
+        if (Index >= static_cast<size_t>(Count))
+            return {};
 
-        // Attempt to pack known math/struct types directly
-        if (PackKnownStruct(Nested, Scratch))
-            return Publish(Scratch);
+        Scratch.clear();
 
-        // Fallback: serialize the entire sub-message
-        std::vector<std::byte> Data(static_cast<size_t>(Nested.ByteSizeLong()));
-        Nested.SerializePartialToArray(Data.data(), static_cast<int>(Data.size()));
-        return Publish(std::move(Data));
-    }
+        // Handle repeated message elements (Vector, Quat, Transform, etc.)
+        if (F->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
+            const google::protobuf::Message& Nested = R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
+
+            // Attempt to pack known math/struct types directly
+            if (PackKnownStruct(Nested, Scratch))
+                return Publish(Scratch);
 
-    // Handle repeated scalar types
-    switch (F->cpp_type())
-    {
+            // Fallback: serialize the entire sub-message
+            std::vector<std::byte> Data(static_cast<size_t>(Nested.ByteSizeLong()));
+            Nested.SerializePartialToArray(Data.data(), static_cast<int>(Data.size()));
+            return Publish(std::move(Data));
+        }
+
+        // Handle repeated scalar types
+        switch (F->cpp_type()) {
         case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
-            PutLE(Scratch, R->GetRepeatedInt32(*M, F, static_cast<int>(Index))); break;
+            PutLE(Scratch, R->GetRepeatedInt32(*M, F, static_cast<int>(Index)));
+            break;
         case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
-            PutLE(Scratch, R->GetRepeatedUInt32(*M, F, static_cast<int>(Index))); break;
+            PutLE(Scratch, R->GetRepeatedUInt32(*M, F, static_cast<int>(Index)));
+            break;
         case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
-            PutLE(Scratch, R->GetRepeatedInt64(*M, F, static_cast<int>(Index))); break;
+            PutLE(Scratch, R->GetRepeatedInt64(*M, F, static_cast<int>(Index)));
+            break;
         case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
-            PutLE(Scratch, R->GetRepeatedUInt64(*M, F, static_cast<int>(Index))); break;
+            PutLE(Scratch, R->GetRepeatedUInt64(*M, F, static_cast<int>(Index)));
+            break;
         case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
-            PutLE(Scratch, R->GetRepeatedFloat(*M, F, static_cast<int>(Index))); break;
+            PutLE(Scratch, R->GetRepeatedFloat(*M, F, static_cast<int>(Index)));
+            break;
         case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
-            PutLE(Scratch, R->GetRepeatedDouble(*M, F, static_cast<int>(Index))); break;
-        case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
-        {
+            PutLE(Scratch, R->GetRepeatedDouble(*M, F, static_cast<int>(Index)));
+            break;
+        case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
             uint8_t val = R->GetRepeatedBool(*M, F, static_cast<int>(Index)) ? 1 : 0;
             Scratch.push_back(static_cast<std::byte>(val));
             break;
         }
-        case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
-        {
+        case google::protobuf::FieldDescriptor::CPPTYPE_STRING: {
             std::string Str = R->GetRepeatedString(*M, F, static_cast<int>(Index));
             return Publish(Str.data(), Str.size());
         }
         default:
             break;
-    }
+        }
 
-    return Publish(Scratch);
-}
+        return Publish(Scratch);
+    }
 
 
-// ============================================================
-// GetSubArrayBytes
-// ------------------------------------------------------------
-// Returns a binary span representing the serialized data of a
-// sub-array (nested repeated message fields, e.g. TArray<TArray<T>>).
-// ============================================================
-std::span<const std::byte> FProtobufViewAdapter::GetSubArrayBytes(
-    const VtxDiff::FieldDesc& Field, size_t SubIndex) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
+    // ============================================================
+    // GetSubArrayBytes
+    // ------------------------------------------------------------
+    // Returns a binary span representing the serialized data of a
+    // sub-array (nested repeated message fields, e.g. TArray<TArray<T>>).
+    // ============================================================
+    std::span<const std::byte> FProtobufViewAdapter::GetSubArrayBytes(const VtxDiff::FieldDesc& Field,
+                                                                      size_t SubIndex) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
 
-    if (!M || !D || !R)
-        return {};
+        if (!M || !D || !R)
+            return {};
 
 #if defined(UE_LOG)
-    UE_LOG(LogTemp, Verbose, TEXT("[GetSubArrayBytes] Msg type = %hs | Field = %hs"),
-        UTF8_TO_TCHAR(M->GetDescriptor()->full_name().c_str()),
-        UTF8_TO_TCHAR(Field.Name.c_str()));
+        UE_LOG(LogTemp, Verbose, TEXT("[GetSubArrayBytes] Msg type = %hs | Field = %hs"),
+               UTF8_TO_TCHAR(M->GetDescriptor()->full_name().c_str()), UTF8_TO_TCHAR(Field.Name.c_str()));
 #endif
 
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F || !F->is_repeated() ||
-        F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
-        return {};
-
-    const int OuterCount = R->FieldSize(*M, F);
-    if (SubIndex >= static_cast<size_t>(OuterCount))
-        return {};
-
-    Scratch.clear();
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F || !F->is_repeated() || F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+            return {};
 
-    // Retrieve the message representing one "subarray"
-    const google::protobuf::Message& SubArrayMsg =
-        R->GetRepeatedMessage(*M, F, static_cast<int>(SubIndex));
+        const int OuterCount = R->FieldSize(*M, F);
+        if (SubIndex >= static_cast<size_t>(OuterCount))
+            return {};
 
-    const auto* SubDesc = SubArrayMsg.GetDescriptor();
-    const auto* SubRefl = SubArrayMsg.GetReflection();
-    if (!SubDesc || !SubRefl)
-        return {};
+        Scratch.clear();
 
-    // Iterate over nested repeated fields (usually one)
-    for (int i = 0; i < SubDesc->field_count(); ++i)
-    {
-        const auto* InnerField = SubDesc->field(i);
-        if (!InnerField || !InnerField->is_repeated())
-            continue;
+        // Retrieve the message representing one "subarray"
+        const google::protobuf::Message& SubArrayMsg = R->GetRepeatedMessage(*M, F, static_cast<int>(SubIndex));
 
-        const int InnerCount = SubRefl->FieldSize(SubArrayMsg, InnerField);
-        if (InnerCount == 0)
-            continue;
+        const auto* SubDesc = SubArrayMsg.GetDescriptor();
+        const auto* SubRefl = SubArrayMsg.GetReflection();
+        if (!SubDesc || !SubRefl)
+            return {};
 
-        // Serialize all elements inside the subarray
-        for (int j = 0; j < InnerCount; ++j)
-        {
-            if (InnerField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
-            {
-                const google::protobuf::Message& ElemMsg =
-                    SubRefl->GetRepeatedMessage(SubArrayMsg, InnerField, j);
-
-                // Attempt to pack known math structs directly
-                if (!PackKnownStruct(ElemMsg, Scratch))
-                {
-                    std::vector<std::byte> Data(static_cast<size_t>(ElemMsg.ByteSizeLong()));
-                    ElemMsg.SerializePartialToArray(Data.data(), static_cast<int>(Data.size()));
-                    Scratch.insert(Scratch.end(), Data.begin(), Data.end());
-                }
-            }
-            else if (InnerField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_STRING)
-            {
-                std::string s = SubRefl->GetRepeatedString(SubArrayMsg, InnerField, j);
-                Scratch.insert(Scratch.end(),
-                               reinterpret_cast<const std::byte*>(s.data()),
-                               reinterpret_cast<const std::byte*>(s.data()) + s.size());
-            }
-            else
-            {
-                // Handle scalar types
-                switch (InnerField->cpp_type())
-                {
+        // Iterate over nested repeated fields (usually one)
+        for (int i = 0; i < SubDesc->field_count(); ++i) {
+            const auto* InnerField = SubDesc->field(i);
+            if (!InnerField || !InnerField->is_repeated())
+                continue;
+
+            const int InnerCount = SubRefl->FieldSize(SubArrayMsg, InnerField);
+            if (InnerCount == 0)
+                continue;
+
+            // Serialize all elements inside the subarray
+            for (int j = 0; j < InnerCount; ++j) {
+                if (InnerField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
+                    const google::protobuf::Message& ElemMsg = SubRefl->GetRepeatedMessage(SubArrayMsg, InnerField, j);
+
+                    // Attempt to pack known math structs directly
+                    if (!PackKnownStruct(ElemMsg, Scratch)) {
+                        std::vector<std::byte> Data(static_cast<size_t>(ElemMsg.ByteSizeLong()));
+                        ElemMsg.SerializePartialToArray(Data.data(), static_cast<int>(Data.size()));
+                        Scratch.insert(Scratch.end(), Data.begin(), Data.end());
+                    }
+                } else if (InnerField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_STRING) {
+                    std::string s = SubRefl->GetRepeatedString(SubArrayMsg, InnerField, j);
+                    Scratch.insert(Scratch.end(), reinterpret_cast<const std::byte*>(s.data()),
+                                   reinterpret_cast<const std::byte*>(s.data()) + s.size());
+                } else {
+                    // Handle scalar types
+                    switch (InnerField->cpp_type()) {
                     case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
-                        PutLE(Scratch, SubRefl->GetRepeatedInt32(SubArrayMsg, InnerField, j)); break;
+                        PutLE(Scratch, SubRefl->GetRepeatedInt32(SubArrayMsg, InnerField, j));
+                        break;
                     case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
-                        PutLE(Scratch, SubRefl->GetRepeatedUInt32(SubArrayMsg, InnerField, j)); break;
+                        PutLE(Scratch, SubRefl->GetRepeatedUInt32(SubArrayMsg, InnerField, j));
+                        break;
                     case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
-                        PutLE(Scratch, SubRefl->GetRepeatedInt64(SubArrayMsg, InnerField, j)); break;
+                        PutLE(Scratch, SubRefl->GetRepeatedInt64(SubArrayMsg, InnerField, j));
+                        break;
                     case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
-                        PutLE(Scratch, SubRefl->GetRepeatedUInt64(SubArrayMsg, InnerField, j)); break;
+                        PutLE(Scratch, SubRefl->GetRepeatedUInt64(SubArrayMsg, InnerField, j));
+                        break;
                     case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
-                        PutLE(Scratch, SubRefl->GetRepeatedFloat(SubArrayMsg, InnerField, j)); break;
+                        PutLE(Scratch, SubRefl->GetRepeatedFloat(SubArrayMsg, InnerField, j));
+                        break;
                     case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
-                        PutLE(Scratch, SubRefl->GetRepeatedDouble(SubArrayMsg, InnerField, j)); break;
-                    case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
-                    {
+                        PutLE(Scratch, SubRefl->GetRepeatedDouble(SubArrayMsg, InnerField, j));
+                        break;
+                    case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
                         uint8_t val = SubRefl->GetRepeatedBool(SubArrayMsg, InnerField, j) ? 1 : 0;
                         Scratch.push_back(static_cast<std::byte>(val));
                         break;
                     }
                     default:
                         break;
+                    }
                 }
             }
+
+            // Only process the first repeated field per subarray
+            break;
         }
 
-        // Only process the first repeated field per subarray
-        break;
+        return Publish(Scratch);
     }
 
-    return Publish(Scratch);
-}
-
-// ============================================================
-// GetMapSize
-// ------------------------------------------------------------
-// Returns the number of key-value pairs in a map field.
-// Supports both native protobuf map<K,V> and Unreal-style
-// FVTXMapContainer (Keys + Values arrays).
-// ============================================================
-size_t FProtobufViewAdapter::GetMapSize(const VtxDiff::FieldDesc& Field) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
-
-    if (!M || !D || !R)
-        return 0;
-
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F)
-        return 0;
+    // ============================================================
+    // GetMapSize
+    // ------------------------------------------------------------
+    // Returns the number of key-value pairs in a map field.
+    // Supports both native protobuf map<K,V> and Unreal-style
+    // FVTXMapContainer (Keys + Values arrays).
+    // ============================================================
+    size_t FProtobufViewAdapter::GetMapSize(const VtxDiff::FieldDesc& Field) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
 
-    // Case 1: native protobuf map<K, V>
-    if (F->is_map())
-        return static_cast<size_t>(R->FieldSize(*M, F));
+        if (!M || !D || !R)
+            return 0;
 
-    // Case 2: Unreal-style "FVTXMapContainer" (Keys + Values arrays)
-    if (Field.type == EVTXContainerType::MapProperties)
-    {
-        const auto* KeysField = D->FindFieldByName("Keys");
-        const auto* ValuesField = D->FindFieldByName("Values");
-        if (!KeysField || !ValuesField)
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F)
             return 0;
 
-        const int KeyCount = R->FieldSize(*M, KeysField);
-        const int ValueCount = R->FieldSize(*M, ValuesField);
-        return static_cast<size_t>(std::min(KeyCount, ValueCount));
-    }
+        // Case 1: native protobuf map<K, V>
+        if (F->is_map())
+            return static_cast<size_t>(R->FieldSize(*M, F));
 
-    return 0;
-}
+        // Case 2: Unreal-style "FVTXMapContainer" (Keys + Values arrays)
+        if (Field.type == EVTXContainerType::MapProperties) {
+            const auto* KeysField = D->FindFieldByName("Keys");
+            const auto* ValuesField = D->FindFieldByName("Values");
+            if (!KeysField || !ValuesField)
+                return 0;
 
+            const int KeyCount = R->FieldSize(*M, KeysField);
+            const int ValueCount = R->FieldSize(*M, ValuesField);
+            return static_cast<size_t>(std::min(KeyCount, ValueCount));
+        }
 
-// ============================================================
-// GetMapKey
-// ------------------------------------------------------------
-// Retrieves the string representation of a map key at the given
-// index. Supports both native protobuf maps and FVTXMapContainer.
-// ============================================================
-std::string FProtobufViewAdapter::GetMapKey(const VtxDiff::FieldDesc& Field, size_t Index) const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
+        return 0;
+    }
 
-    if (!M || !D || !R)
-        return {};
 
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F)
-        return {};
+    // ============================================================
+    // GetMapKey
+    // ------------------------------------------------------------
+    // Retrieves the string representation of a map key at the given
+    // index. Supports both native protobuf maps and FVTXMapContainer.
+    // ============================================================
+    std::string FProtobufViewAdapter::GetMapKey(const VtxDiff::FieldDesc& Field, size_t Index) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
 
-    // --- Case 1: Native protobuf map<K,V> ---
-    if (F->is_map())
-    {
-        const google::protobuf::Message& Entry =
-            R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
+        if (!M || !D || !R)
+            return {};
 
-        const auto* EntryRefl = Entry.GetReflection();
-        const auto* KeyField = F->message_type()->map_key();
-        if (!KeyField || !EntryRefl)
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F)
             return {};
 
-        switch (KeyField->cpp_type())
-        {
+        // --- Case 1: Native protobuf map<K,V> ---
+        if (F->is_map()) {
+            const google::protobuf::Message& Entry = R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
+
+            const auto* EntryRefl = Entry.GetReflection();
+            const auto* KeyField = F->message_type()->map_key();
+            if (!KeyField || !EntryRefl)
+                return {};
+
+            switch (KeyField->cpp_type()) {
             case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
                 return EntryRefl->GetString(Entry, KeyField);
             case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
@@ -987,171 +996,184 @@ std::string FProtobufViewAdapter::GetMapKey(const VtxDiff::FieldDesc& Field, siz
                 return std::to_string(EntryRefl->GetUInt64(Entry, KeyField));
             default:
                 return {};
+            }
         }
-    }
 
-    // --- Case 2: FVTXMapContainer (Keys + Values arrays) ---
-    if (Field.type == EVTXContainerType::MapProperties)
-    {
-        const auto* KeysField = D->FindFieldByName("Keys");
-        if (!KeysField || !KeysField->is_repeated())
+        // --- Case 2: FVTXMapContainer (Keys + Values arrays) ---
+        if (Field.type == EVTXContainerType::MapProperties) {
+            const auto* KeysField = D->FindFieldByName("Keys");
+            if (!KeysField || !KeysField->is_repeated())
+                return {};
+
+            if (Index >= static_cast<size_t>(R->FieldSize(*M, KeysField)))
+                return {};
+
+            if (KeysField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_STRING)
+                return R->GetRepeatedString(*M, KeysField, static_cast<int>(Index));
+
+            if (KeysField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_INT32)
+                return std::to_string(R->GetRepeatedInt32(*M, KeysField, static_cast<int>(Index)));
+
             return {};
+        }
 
-        if (Index >= static_cast<size_t>(R->FieldSize(*M, KeysField)))
+        return {};
+    }
+
+
+    // ============================================================
+    // GetMapValueAsStruct
+    // ------------------------------------------------------------
+    // Returns a node view for the map value at the specified index.
+    // Supports both native protobuf maps and FVTXMapContainer.
+    // ============================================================
+    FProtobufViewAdapter FProtobufViewAdapter::GetMapValueAsStruct(const VtxDiff::FieldDesc& Field,
+                                                                   size_t Index) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+        if (!M || !D || !R)
+            return {};
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F)
             return {};
 
-        if (KeysField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_STRING)
-            return R->GetRepeatedString(*M, KeysField, static_cast<int>(Index));
+        if (F->is_map()) {
+            const google::protobuf::Message& Entry = R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
+            const auto* EntryRefl = Entry.GetReflection();
+            const auto* ValueField = F->message_type()->map_value();
+            if (!EntryRefl || !ValueField ||
+                ValueField->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+                return {};
 
-        if (KeysField->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_INT32)
-            return std::to_string(R->GetRepeatedInt32(*M, KeysField, static_cast<int>(Index)));
+            const google::protobuf::Message& ValueMsg = EntryRefl->GetMessage(Entry, ValueField);
+            return FProtobufViewAdapter(&ValueMsg, false);
+        }
+
+        if (Field.type == EVTXContainerType::MapProperties) {
+            const auto* ValuesField = D->FindFieldByName("Values");
+            if (!ValuesField || !ValuesField->is_repeated() ||
+                Index >= static_cast<size_t>(R->FieldSize(*M, ValuesField)))
+                return {};
 
+            const google::protobuf::Message& SubMsg = R->GetRepeatedMessage(*M, ValuesField, static_cast<int>(Index));
+            return FProtobufViewAdapter(&SubMsg, false);
+        }
         return {};
     }
 
-    return {};
-}
-
-
-// ============================================================
-// GetMapValueAsStruct
-// ------------------------------------------------------------
-// Returns a node view for the map value at the specified index.
-// Supports both native protobuf maps and FVTXMapContainer.
-// ============================================================
-FProtobufViewAdapter FProtobufViewAdapter::GetMapValueAsStruct(const VtxDiff::FieldDesc& Field, size_t Index) const
-{
-    const auto* M = GetMsg(); const auto* D = GetDesc(); const auto* R = GetRefl();
-    if (!M || !D || !R) return {};
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F) return {};
-
-    if (F->is_map()) {
-        const google::protobuf::Message& Entry = R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
-        const auto* EntryRefl = Entry.GetReflection();
-        const auto* ValueField = F->message_type()->map_value();
-        if (!EntryRefl || !ValueField || ValueField->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) return {};
-
-        const google::protobuf::Message& ValueMsg = EntryRefl->GetMessage(Entry, ValueField);
-        return FProtobufViewAdapter(&ValueMsg, false);
+    // ============================================================
+    // GetArrayElementAsStruct
+    // ------------------------------------------------------------
+    // Returns a nested IBinaryNodeView for an element inside a
+    // repeated message field (e.g., array of structs).
+    // ============================================================
+    FProtobufViewAdapter FProtobufViewAdapter::GetArrayElementAsStruct(const VtxDiff::FieldDesc& Field,
+                                                                       size_t Index) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+        if (!M || !D || !R)
+            return {};
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F || !F->is_repeated() || F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+            return {};
+
+        const int Count = R->FieldSize(*M, F);
+        if (Index >= static_cast<size_t>(Count))
+            return {};
+
+        const google::protobuf::Message& NestedMsg = R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
+        return FProtobufViewAdapter(&NestedMsg, false);
     }
 
-    if (Field.type == EVTXContainerType::MapProperties) {
-        const auto* ValuesField = D->FindFieldByName("Values");
-        if (!ValuesField || !ValuesField->is_repeated() || Index >= static_cast<size_t>(R->FieldSize(*M, ValuesField))) return {};
 
-        const google::protobuf::Message& SubMsg = R->GetRepeatedMessage(*M, ValuesField, static_cast<int>(Index));
-        return FProtobufViewAdapter(&SubMsg, false);
+    // ============================================================
+    // IsValid
+    // ------------------------------------------------------------
+    // Returns true if the current adapter contains a valid message,
+    // descriptor, and reflection instance.
+    // ============================================================
+    bool FProtobufViewAdapter::IsValid() const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+
+        return (M != nullptr && D != nullptr && R != nullptr);
+    }
+
+
+    // ============================================================
+    // GetNestedStruct
+    // ------------------------------------------------------------
+    // Returns a nested IBinaryNodeView for a singular message field
+    // (non-repeated). Used for nested structures or sub-messages.
+    // ============================================================
+    FProtobufViewAdapter FProtobufViewAdapter::GetNestedStruct(const VtxDiff::FieldDesc& Field) const {
+        const auto* M = GetMsg();
+        const auto* D = GetDesc();
+        const auto* R = GetRefl();
+        if (!M || !D || !R)
+            return {};
+        const auto* F = D->FindFieldByName(Field.name);
+        if (!F || F->is_repeated() || F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+            return {};
+        if (!R->HasField(*M, F))
+            return {};
+
+        const google::protobuf::Message& Nested = R->GetMessage(*M, F);
+        return FProtobufViewAdapter(&Nested, false);
     }
-    return {};
-}
-
-// ============================================================
-// GetArrayElementAsStruct
-// ------------------------------------------------------------
-// Returns a nested IBinaryNodeView for an element inside a
-// repeated message field (e.g., array of structs).
-// ============================================================
-FProtobufViewAdapter FProtobufViewAdapter::GetArrayElementAsStruct(const VtxDiff::FieldDesc& Field, size_t Index) const
-{
-    const auto* M = GetMsg(); const auto* D = GetDesc(); const auto* R = GetRefl();
-    if (!M || !D || !R) return {};
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F || !F->is_repeated() || F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) return {};
-
-    const int Count = R->FieldSize(*M, F);
-    if (Index >= static_cast<size_t>(Count)) return {};
-
-    const google::protobuf::Message& NestedMsg = R->GetRepeatedMessage(*M, F, static_cast<int>(Index));
-    return FProtobufViewAdapter(&NestedMsg, false);
-}
-
-
-// ============================================================
-// IsValid
-// ------------------------------------------------------------
-// Returns true if the current adapter contains a valid message,
-// descriptor, and reflection instance.
-// ============================================================
-bool FProtobufViewAdapter::IsValid() const
-{
-    const auto* M = GetMsg();
-    const auto* D = GetDesc();
-    const auto* R = GetRefl();
-
-    return (M != nullptr && D != nullptr && R != nullptr);
-}
-
-
-// ============================================================
-// GetNestedStruct
-// ------------------------------------------------------------
-// Returns a nested IBinaryNodeView for a singular message field
-// (non-repeated). Used for nested structures or sub-messages.
-// ============================================================
-FProtobufViewAdapter FProtobufViewAdapter::GetNestedStruct(const VtxDiff::FieldDesc& Field) const
-{
-    const auto* M = GetMsg(); const auto* D = GetDesc(); const auto* R = GetRefl();
-    if (!M || !D || !R) return {};
-    const auto* F = D->FindFieldByName(Field.name);
-    if (!F || F->is_repeated() || F->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) return {};
-    if (!R->HasField(*M, F)) return {};
-
-    const google::protobuf::Message& Nested = R->GetMessage(*M, F);
-    return FProtobufViewAdapter(&Nested, false); 
-}
-
-
-  // ============================================================================
+
+
+    // ============================================================================
     // PbViewFactory implementation
     // ============================================================================
 
-    void PbViewFactory::SetSubArrayNames(const std::unordered_map<std::string, SubArrayNames>& Map)
-    {
+    void PbViewFactory::SetSubArrayNames(const std::unordered_map<std::string, SubArrayNames>& Map) {
         SubNames = std::move(Map);
     }
 
-    std::optional<FProtobufViewAdapter> PbViewFactory::CreateRoot(std::span<const std::byte> Buffer) const
-    {
-        if (RootType.empty() || Buffer.empty()) return std::nullopt;
+    std::optional<FProtobufViewAdapter> PbViewFactory::CreateRoot(std::span<const std::byte> Buffer) const {
+        if (RootType.empty() || Buffer.empty())
+            return std::nullopt;
         const DescriptorPool* Pool = UsePool ? UsePool : DescriptorPool::generated_pool();
         const Descriptor* RootDesc = Pool->FindMessageTypeByName(RootType);
-        if (!RootDesc) return std::nullopt;
+        if (!RootDesc)
+            return std::nullopt;
 
         const uint8_t* DataPtr = reinterpret_cast<const uint8_t*>(Buffer.data());
         const size_t DataSize = Buffer.size();
 
         auto View = FProtobufViewAdapter::CreateRoot(Pool, RootType, DataPtr, DataSize);
-        if (!View) return std::nullopt;
+        if (!View)
+            return std::nullopt;
 
-        if (!SubNames.empty()) View->SetSubArrayNames(SubNames);
+        if (!SubNames.empty())
+            View->SetSubArrayNames(SubNames);
         return View;
     }
 
 
-    bool PbViewFactory::InitFromFile(const std::string& Path, const std::string& InRootType)
-    {
+    bool PbViewFactory::InitFromFile(const std::string& Path, const std::string& InRootType) {
         RootType = InRootType;
 
         // File-based descriptor loading not supported; use InitFromMemory instead
         return false;
     }
 
-    bool PbViewFactory::InitFromMemory(const uint8_t* Data, size_t Size, const std::string& InRootType)
-    {
+    bool PbViewFactory::InitFromMemory(const uint8_t* Data, size_t Size, const std::string& InRootType) {
         RootType = InRootType;
 
         // If no data provided, use the default generated pool
-        if (!Data || Size == 0)
-        {
+        if (!Data || Size == 0) {
             UsePool = DescriptorPool::generated_pool();
             return true;
         }
 
         // Attempt to parse a serialized FileDescriptorSet from memory
         FileDescriptorSet DescriptorSet;
-        if (!DescriptorSet.ParseFromArray(Data, static_cast<int>(Size)))
-        {
+        if (!DescriptorSet.ParseFromArray(Data, static_cast<int>(Size))) {
             VTX_ERROR("PbViewFactory: Failed to parse FileDescriptorSet; falling back to generated_pool().");
             UsePool = DescriptorPool::generated_pool();
             return true;
@@ -1159,11 +1181,9 @@ FProtobufViewAdapter FProtobufViewAdapter::GetNestedStruct(const VtxDiff::FieldD
 
         // Build a custom DescriptorPool dynamically from the FileDescriptorSet
         auto NewPool = std::make_unique<DescriptorPool>();
-        for (int I = 0; I < DescriptorSet.file_size(); ++I)
-        {
+        for (int I = 0; I < DescriptorSet.file_size(); ++I) {
             const FileDescriptor* FileDesc = NewPool->BuildFile(DescriptorSet.file(I));
-            if (!FileDesc)
-            {
+            if (!FileDesc) {
                 VTX_ERROR("PbViewFactory: Failed to build FileDescriptor (index {}); using generated_pool().", I);
                 UsePool = DescriptorPool::generated_pool();
                 return true;
@@ -1177,4 +1197,3 @@ FProtobufViewAdapter FProtobufViewAdapter::GetNestedStruct(const VtxDiff::FieldD
     }
 
 } // namespace VtxDiff::Protobuf
-
diff --git a/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h b/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h
index 2be4f54..0dc184f 100644
--- a/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h
+++ b/sdk/src/vtx_differ/src/vtx/differ/adapters/protobuff/vtx_protobuff_view_adapter.h
@@ -16,123 +16,120 @@
 
 namespace VtxDiff::Protobuf {
 
-// ================================================================
-// Struct: SubArrayNames
-// ---------------------------------------------------------------
-// Describes paired fields for subarray handling, e.g.:
-//    "vertices_arrays" + "vertices_offsets"
-// ================================================================
-    struct SubArrayNames
-    {
+    // ================================================================
+    // Struct: SubArrayNames
+    // ---------------------------------------------------------------
+    // Describes paired fields for subarray handling, e.g.:
+    //    "vertices_arrays" + "vertices_offsets"
+    // ================================================================
+    struct SubArrayNames {
         std::string FlatDataField;
         std::string OffsetsField;
     };
 
-// ================================================================
-// Class: ProtobufViewAdapter
-// ---------------------------------------------------------------
-// A reflection-based adapter that exposes a protobuf message as a
-// hierarchical binary tree for diff computation.
-// ================================================================
-class FProtobufViewAdapter final : public IBinaryNodeView
-{
-public:
-	FProtobufViewAdapter(const google::protobuf::Message* Msg);
-	virtual ~FProtobufViewAdapter() override;
-
-	static std::unique_ptr<FProtobufViewAdapter> CreateRoot(
-	    const google::protobuf::DescriptorPool* Pool,
-	    const std::string& RootType,
-	    const uint8_t* Buffer,
-	    size_t Size);
-
-	static std::unique_ptr<FProtobufViewAdapter> FromMessage(
-	    const google::protobuf::Message& Message);
-
-	void SetSubArrayNames(std::unordered_map<std::string, SubArrayNames> Map);
-
-	// ============================================================
-	// IBinaryNodeView interface
-	// ============================================================
-	virtual std::vector<VtxDiff::FieldDesc> EnumerateFields() const override;
-	virtual std::span<const std::byte> GetFieldBytes(const VtxDiff::FieldDesc& Field) const override;
-	virtual size_t GetArraySize(const VtxDiff::FieldDesc& Field) const override;
-	virtual std::span<const std::byte> GetArrayElementBytes(const VtxDiff::FieldDesc& Field, size_t Index) const override;
-	virtual std::span<const std::byte> GetSubArrayBytes(const VtxDiff::FieldDesc& Field, size_t SubIndex) const override;
-	virtual std::unique_ptr<IBinaryNodeView> GetNestedStruct(const VtxDiff::FieldDesc& Field) const override;
-	virtual std::unique_ptr<IBinaryNodeView> GetArrayElementAsStruct(const VtxDiff::FieldDesc& Field, size_t Index) const override;
-	virtual bool IsValid() const  override;
-	virtual size_t GetMapSize(const VtxDiff::FieldDesc& Field) const override;
-	virtual std::string GetMapKey(const VtxDiff::FieldDesc& Field, size_t Index) const override;
-	virtual std::unique_ptr<IBinaryNodeView> GetMapValueAsStruct(const VtxDiff::FieldDesc& Field, size_t Index) const override;
-	virtual std::string GetScalarFieldString(const std::string& FieldName) const override;
-	virtual std::unique_ptr<IBinaryNodeView> GetFieldByName(const std::string& FieldName) const override;
-private:
-	std::unique_ptr<google::protobuf::Message> Owned;
-	const google::protobuf::Message* External = nullptr;
-
-	mutable std::vector<std::vector<std::byte>> Arena;
-	mutable std::vector<std::byte> Scratch;
-	mutable std::string TempString;
-	std::unordered_map<std::string, SubArrayNames> SubNames;
-
-private:
-	// Helpers internos
-	const google::protobuf::FieldDescriptor* FindField(std::string_view Name) const;
-
-	bool IsScalar(const google::protobuf::FieldDescriptor* Field) const;
-
-	EVTXContainerType InferContainerType(const google::protobuf::FieldDescriptor* Field) const;
-	std::span<const std::byte> Publish(const void* Data, size_t Size) const;
-	std::span<const std::byte> Publish(const std::vector<std::byte>& Buffer) const;
-	std::span<const std::byte> Publish(std::vector<std::byte>&& Buffer) const;
-	void ResetArena() const;
-	const google::protobuf::Descriptor* ActiveDesc() const;
-	static std::unique_ptr<google::protobuf::Message> CloneMessage(const google::protobuf::Message& Src);
-
-public:
-	virtual void Reset() override;
-
-	inline const google::protobuf::Message* GetMsg() const noexcept {
-		return Owned ? Owned.get() : External;
-	}
-
-	inline const google::protobuf::Descriptor* GetDesc() const noexcept {
-		auto* m = GetMsg();
-		return m ? m->GetDescriptor() : nullptr;
-	}
-
-	inline const google::protobuf::Reflection* GetRefl() const noexcept {
-		auto* m = GetMsg();
-		return m ? m->GetReflection() : nullptr;
-	}
-
-};
-
-// ================================================================
-// Class: PbViewFactory
-// ---------------------------------------------------------------
-// Factory responsible for loading descriptor pools and creating
-// root-level ProtobufViewAdapters.
-// ================================================================
-class PbViewFactory final : public IBinaryViewFactory {
-public:
-    PbViewFactory() = default;
-    ~PbViewFactory() override = default;
-
-    bool InitFromMemory(const uint8_t* Data, size_t Size, const std::string& RootType);
-    bool InitFromFile(const std::string& Path, const std::string& RootType);
-
-    void SetSubArrayNames(const std::unordered_map<std::string, SubArrayNames>& Map);
-    std::unique_ptr<IBinaryNodeView> CreateRoot(std::span<const std::byte> Buffer) const override;
-
-    const std::string& GetRootType() const { return RootType; }
-
-private:
-    std::string RootType;
-    std::unordered_map<std::string, SubArrayNames> SubNames;
-    const google::protobuf::DescriptorPool* UsePool = nullptr;
-    std::unique_ptr<google::protobuf::DescriptorPool> OwnedPool;
-};
+    // ================================================================
+    // Class: ProtobufViewAdapter
+    // ---------------------------------------------------------------
+    // A reflection-based adapter that exposes a protobuf message as a
+    // hierarchical binary tree for diff computation.
+    // ================================================================
+    class FProtobufViewAdapter final : public IBinaryNodeView {
+    public:
+        FProtobufViewAdapter(const google::protobuf::Message* Msg);
+        virtual ~FProtobufViewAdapter() override;
+
+        static std::unique_ptr<FProtobufViewAdapter> CreateRoot(const google::protobuf::DescriptorPool* Pool,
+                                                                const std::string& RootType, const uint8_t* Buffer,
+                                                                size_t Size);
+
+        static std::unique_ptr<FProtobufViewAdapter> FromMessage(const google::protobuf::Message& Message);
+
+        void SetSubArrayNames(std::unordered_map<std::string, SubArrayNames> Map);
+
+        // ============================================================
+        // IBinaryNodeView interface
+        // ============================================================
+        virtual std::vector<VtxDiff::FieldDesc> EnumerateFields() const override;
+        virtual std::span<const std::byte> GetFieldBytes(const VtxDiff::FieldDesc& Field) const override;
+        virtual size_t GetArraySize(const VtxDiff::FieldDesc& Field) const override;
+        virtual std::span<const std::byte> GetArrayElementBytes(const VtxDiff::FieldDesc& Field,
+                                                                size_t Index) const override;
+        virtual std::span<const std::byte> GetSubArrayBytes(const VtxDiff::FieldDesc& Field,
+                                                            size_t SubIndex) const override;
+        virtual std::unique_ptr<IBinaryNodeView> GetNestedStruct(const VtxDiff::FieldDesc& Field) const override;
+        virtual std::unique_ptr<IBinaryNodeView> GetArrayElementAsStruct(const VtxDiff::FieldDesc& Field,
+                                                                         size_t Index) const override;
+        virtual bool IsValid() const override;
+        virtual size_t GetMapSize(const VtxDiff::FieldDesc& Field) const override;
+        virtual std::string GetMapKey(const VtxDiff::FieldDesc& Field, size_t Index) const override;
+        virtual std::unique_ptr<IBinaryNodeView> GetMapValueAsStruct(const VtxDiff::FieldDesc& Field,
+                                                                     size_t Index) const override;
+        virtual std::string GetScalarFieldString(const std::string& FieldName) const override;
+        virtual std::unique_ptr<IBinaryNodeView> GetFieldByName(const std::string& FieldName) const override;
+
+    private:
+        std::unique_ptr<google::protobuf::Message> Owned;
+        const google::protobuf::Message* External = nullptr;
+
+        mutable std::vector<std::vector<std::byte>> Arena;
+        mutable std::vector<std::byte> Scratch;
+        mutable std::string TempString;
+        std::unordered_map<std::string, SubArrayNames> SubNames;
+
+    private:
+        // Helpers internos
+        const google::protobuf::FieldDescriptor* FindField(std::string_view Name) const;
+
+        bool IsScalar(const google::protobuf::FieldDescriptor* Field) const;
+
+        EVTXContainerType InferContainerType(const google::protobuf::FieldDescriptor* Field) const;
+        std::span<const std::byte> Publish(const void* Data, size_t Size) const;
+        std::span<const std::byte> Publish(const std::vector<std::byte>& Buffer) const;
+        std::span<const std::byte> Publish(std::vector<std::byte>&& Buffer) const;
+        void ResetArena() const;
+        const google::protobuf::Descriptor* ActiveDesc() const;
+        static std::unique_ptr<google::protobuf::Message> CloneMessage(const google::protobuf::Message& Src);
+
+    public:
+        virtual void Reset() override;
+
+        inline const google::protobuf::Message* GetMsg() const noexcept { return Owned ? Owned.get() : External; }
+
+        inline const google::protobuf::Descriptor* GetDesc() const noexcept {
+            auto* m = GetMsg();
+            return m ? m->GetDescriptor() : nullptr;
+        }
+
+        inline const google::protobuf::Reflection* GetRefl() const noexcept {
+            auto* m = GetMsg();
+            return m ? m->GetReflection() : nullptr;
+        }
+    };
+
+    // ================================================================
+    // Class: PbViewFactory
+    // ---------------------------------------------------------------
+    // Factory responsible for loading descriptor pools and creating
+    // root-level ProtobufViewAdapters.
+    // ================================================================
+    class PbViewFactory final : public IBinaryViewFactory {
+    public:
+        PbViewFactory() = default;
+        ~PbViewFactory() override = default;
+
+        bool InitFromMemory(const uint8_t* Data, size_t Size, const std::string& RootType);
+        bool InitFromFile(const std::string& Path, const std::string& RootType);
+
+        void SetSubArrayNames(const std::unordered_map<std::string, SubArrayNames>& Map);
+        std::unique_ptr<IBinaryNodeView> CreateRoot(std::span<const std::byte> Buffer) const override;
+
+        const std::string& GetRootType() const { return RootType; }
+
+    private:
+        std::string RootType;
+        std::unordered_map<std::string, SubArrayNames> SubNames;
+        const google::protobuf::DescriptorPool* UsePool = nullptr;
+        std::unique_ptr<google::protobuf::DescriptorPool> OwnedPool;
+    };
 
 } // namespace VtxDiff::Protobuf
diff --git a/sdk/src/vtx_differ/src/vtx/differ/core/vtx_differ_facade.cpp b/sdk/src/vtx_differ/src/vtx/differ/core/vtx_differ_facade.cpp
index b4b4863..0209c02 100644
--- a/sdk/src/vtx_differ/src/vtx/differ/core/vtx_differ_facade.cpp
+++ b/sdk/src/vtx_differ/src/vtx/differ/core/vtx_differ_facade.cpp
@@ -7,63 +7,55 @@
 namespace VtxDiff {
 
 
-class FlatBuffersDifferFacade final : public IVtxDifferFacade {
-public:
-    FlatBuffersDifferFacade() {
-        factory_.InitFromMemory(nullptr, 0, "fbsvtx.Bucket");
-    }
+    class FlatBuffersDifferFacade final : public IVtxDifferFacade {
+    public:
+        FlatBuffersDifferFacade() { factory_.InitFromMemory(nullptr, 0, "fbsvtx.Bucket"); }
 
-    PatchIndex DiffRawFrames(
-        std::span<const std::byte> frame_a,
-        std::span<const std::byte> frame_b,
-        const DiffOptions& options) override
-    {
-        auto node_a = factory_.CreateRoot(frame_a);
-        auto node_b = factory_.CreateRoot(frame_b);
-        if (!node_a || !node_b) return {};
+        PatchIndex DiffRawFrames(std::span<const std::byte> frame_a, std::span<const std::byte> frame_b,
+                                 const DiffOptions& options) override {
+            auto node_a = factory_.CreateRoot(frame_a);
+            auto node_b = factory_.CreateRoot(frame_b);
+            if (!node_a || !node_b)
+                return {};
 
-        DefaultTreeDiff<Flatbuffers::FlatbufferViewAdapter> engine;
-        return engine.ComputeDiff(*node_a, *node_b, options);
-    }
+            DefaultTreeDiff<Flatbuffers::FlatbufferViewAdapter> engine;
+            return engine.ComputeDiff(*node_a, *node_b, options);
+        }
 
-private:
-    Flatbuffers::FbViewFactory factory_;
-};
+    private:
+        Flatbuffers::FbViewFactory factory_;
+    };
 
 
-class ProtobufDifferFacade final : public IVtxDifferFacade {
-public:
-    ProtobufDifferFacade() {
-        factory_.InitFromMemory(nullptr, 0, "cppvtx.Bucket");
-    }
+    class ProtobufDifferFacade final : public IVtxDifferFacade {
+    public:
+        ProtobufDifferFacade() { factory_.InitFromMemory(nullptr, 0, "cppvtx.Bucket"); }
 
-    PatchIndex DiffRawFrames(
-        std::span<const std::byte> frame_a,
-        std::span<const std::byte> frame_b,
-        const DiffOptions& options) override
-    {
-        auto node_a = factory_.CreateRoot(frame_a);
-        auto node_b = factory_.CreateRoot(frame_b);
-        if (!node_a || !node_b) return {};
+        PatchIndex DiffRawFrames(std::span<const std::byte> frame_a, std::span<const std::byte> frame_b,
+                                 const DiffOptions& options) override {
+            auto node_a = factory_.CreateRoot(frame_a);
+            auto node_b = factory_.CreateRoot(frame_b);
+            if (!node_a || !node_b)
+                return {};
 
-        DefaultTreeDiff<Protobuf::FProtobufViewAdapter> engine;
-        return engine.ComputeDiff(*node_a, *node_b, options);
-    }
+            DefaultTreeDiff<Protobuf::FProtobufViewAdapter> engine;
+            return engine.ComputeDiff(*node_a, *node_b, options);
+        }
 
-private:
-    Protobuf::PbViewFactory factory_;
-};
+    private:
+        Protobuf::PbViewFactory factory_;
+    };
 
 
-std::unique_ptr<IVtxDifferFacade> CreateDifferFacade(VTX::VtxFormat format) {
-    switch (format) {
+    std::unique_ptr<IVtxDifferFacade> CreateDifferFacade(VTX::VtxFormat format) {
+        switch (format) {
         case VTX::VtxFormat::FlatBuffers:
             return std::make_unique<FlatBuffersDifferFacade>();
         case VTX::VtxFormat::Protobuf:
             return std::make_unique<ProtobufDifferFacade>();
         default:
             return nullptr;
+        }
     }
-}
 
 } // namespace VtxDiff
diff --git a/sdk/src/vtx_reader/src/vtx/reader/core/vtx_deserializer_service.cpp b/sdk/src/vtx_reader/src/vtx/reader/core/vtx_deserializer_service.cpp
index 43c4782..fe952e1 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/core/vtx_deserializer_service.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/core/vtx_deserializer_service.cpp
@@ -6,8 +6,7 @@
 #include "vtx_schema.pb.h"
 using namespace VTX;
 
-std::string VTX::ReplayUnpacker::Decompress(const std::string& compressed_data)
-{
+std::string VTX::ReplayUnpacker::Decompress(const std::string& compressed_data) {
     //zstd includes a magic number of 4 bytes, if is smaller than that is not a valid zstd buffer
     if (compressed_data.size() < 4) {
         return compressed_data;
@@ -16,13 +15,13 @@ std::string VTX::ReplayUnpacker::Decompress(const std::string& compressed_data)
     //get magic number
     const uint8_t* bytes = reinterpret_cast<const uint8_t*>(compressed_data.data());
     bool is_zstd = (bytes[0] == 0x28 && bytes[1] == 0xB5 && bytes[2] == 0x2F && bytes[3] == 0xFD);
-    
+
     if (!is_zstd) {
         return compressed_data;
     }
-    
+
     unsigned long long const rSize = ZSTD_getFrameContentSize(compressed_data.data(), compressed_data.size());
-    
+
     if (rSize == ZSTD_CONTENTSIZE_ERROR) {
         throw std::runtime_error("ZSTD: It's not a standard ZSTD compressed block");
     }
@@ -33,10 +32,8 @@ std::string VTX::ReplayUnpacker::Decompress(const std::string& compressed_data)
     std::string decompressedBuffer;
     decompressedBuffer.resize(rSize);
 
-    size_t const dSize = ZSTD_decompress(
-        decompressedBuffer.data(), rSize, 
-        compressed_data.data(), compressed_data.size()
-    );
+    size_t const dSize =
+        ZSTD_decompress(decompressedBuffer.data(), rSize, compressed_data.data(), compressed_data.size());
 
     if (ZSTD_isError(dSize)) {
         throw std::runtime_error("ZSTD Decompress Error: " + std::string(ZSTD_getErrorName(dSize)));
@@ -50,21 +47,20 @@ std::vector<std::unique_ptr<cppvtx::Frame>> VTX::ReplayUnpacker::Unpack(const cp
 
     if (chunk.is_compressed() && !chunk.compressed_data().empty()) {
         const std::string& compressed = chunk.compressed_data();
-    
+
         unsigned long long const c_size = ZSTD_getFrameContentSize(compressed.data(), compressed.size());
         if (c_size == ZSTD_CONTENTSIZE_ERROR || c_size == ZSTD_CONTENTSIZE_UNKNOWN) {
             throw std::runtime_error("VTX Reader: Unknown ZSTD original size");
         }
 
         uncompressed_data.resize(c_size);
-        size_t const dSize = ZSTD_decompress(uncompressed_data.data(), c_size, 
-                                             compressed.data(), compressed.size());
+        size_t const dSize = ZSTD_decompress(uncompressed_data.data(), c_size, compressed.data(), compressed.size());
 
         if (ZSTD_isError(dSize)) {
             throw std::runtime_error("VTX Reader: Error decompressing ZSTD");
         }
     } else {
-        uncompressed_data = chunk.compressed_data(); 
+        uncompressed_data = chunk.compressed_data();
     }
 
     cppvtx::FrameChunk innerContainer;
diff --git a/sdk/src/vtx_reader/src/vtx/reader/core/vtx_reader_facade.cpp b/sdk/src/vtx_reader/src/vtx/reader/core/vtx_reader_facade.cpp
index 546b8ac..b00f6d3 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/core/vtx_reader_facade.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/core/vtx_reader_facade.cpp
@@ -12,280 +12,238 @@
 namespace VTX {
 
 
-void ReaderChunkState::OnChunkLoadStarted(int32_t chunk_idx) {
-    std::lock_guard<std::mutex> lock(state_mutex_);
-    loading_chunks_.push_back(chunk_idx);
-    VTX_DEBUG("Chunk {} load started.", chunk_idx);
-}
-
-void ReaderChunkState::OnChunkLoadFinished(int32_t chunk_idx) {
-    std::lock_guard<std::mutex> lock(state_mutex_);
-    auto it = std::remove(loading_chunks_.begin(), loading_chunks_.end(), chunk_idx);
-    if (it != loading_chunks_.end()) {
-        loading_chunks_.erase(it, loading_chunks_.end());
+    void ReaderChunkState::OnChunkLoadStarted(int32_t chunk_idx) {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        loading_chunks_.push_back(chunk_idx);
+        VTX_DEBUG("Chunk {} load started.", chunk_idx);
     }
-    loaded_chunks_.push_back(chunk_idx);
-    std::sort(loaded_chunks_.begin(), loaded_chunks_.end());
-    VTX_DEBUG("Chunk {} loaded into RAM.", chunk_idx);
-}
-
-void ReaderChunkState::OnChunkEvicted(int32_t chunk_idx) {
-    std::lock_guard<std::mutex> lock(state_mutex_);
-    auto it = std::remove(loaded_chunks_.begin(), loaded_chunks_.end(), chunk_idx);
-    if (it != loaded_chunks_.end()) {
-        loaded_chunks_.erase(it, loaded_chunks_.end());
-    }
-    VTX_DEBUG("Chunk {} evicted from RAM.", chunk_idx);
-}
-
-ReaderChunkSnapshot ReaderChunkState::GetSnapshot() const {
-    std::lock_guard<std::mutex> lock(state_mutex_);
-    return ReaderChunkSnapshot{
-        .loaded_chunks = loaded_chunks_,
-        .loading_chunks = loading_chunks_,
-    };
-}
-
-void ReaderChunkState::Reset() {
-    std::lock_guard<std::mutex> lock(state_mutex_);
-    loaded_chunks_.clear();
-    loading_chunks_.clear();
-}
-
 
-class FlatBuffersFacadeImpl : public IVtxReaderFacade {
-public:
-    FlatBuffersFacadeImpl(const std::string& filepath)
-        : InternalReader(filepath) {}
-
-    void SetEvents(const ReplayReaderEvents& events) override {
-        InternalReader.SetEvents(events);
-    }
-
-    VTX::FileHeader GetHeader() override {
-        return InternalReader.GetFileHeader();
+    void ReaderChunkState::OnChunkLoadFinished(int32_t chunk_idx) {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        auto it = std::remove(loading_chunks_.begin(), loading_chunks_.end(), chunk_idx);
+        if (it != loading_chunks_.end()) {
+            loading_chunks_.erase(it, loading_chunks_.end());
+        }
+        loaded_chunks_.push_back(chunk_idx);
+        std::sort(loaded_chunks_.begin(), loaded_chunks_.end());
+        VTX_DEBUG("Chunk {} loaded into RAM.", chunk_idx);
     }
 
-    VTX::FileFooter GetFooter() override {
-        return InternalReader.GetFileFooter();
+    void ReaderChunkState::OnChunkEvicted(int32_t chunk_idx) {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        auto it = std::remove(loaded_chunks_.begin(), loaded_chunks_.end(), chunk_idx);
+        if (it != loaded_chunks_.end()) {
+            loaded_chunks_.erase(it, loaded_chunks_.end());
+        }
+        VTX_DEBUG("Chunk {} evicted from RAM.", chunk_idx);
     }
 
-    VTX::ContextualSchema GetContextualSchema() override {
-        return InternalReader.GetContextualSchema();
+    ReaderChunkSnapshot ReaderChunkState::GetSnapshot() const {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        return ReaderChunkSnapshot {
+            .loaded_chunks = loaded_chunks_,
+            .loading_chunks = loading_chunks_,
+        };
     }
 
-    VTX::PropertyAddressCache GetPropertyAddressCache() override {
-        return InternalReader.GetPropertyAddressCache();
+    void ReaderChunkState::Reset() {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        loaded_chunks_.clear();
+        loading_chunks_.clear();
     }
 
-    int32_t GetTotalFrames() const override {
-        return InternalReader.GetTotalFrames();
-    }
 
-    const std::vector<ChunkIndexEntry>& GetSeekTable() const override {
-        return InternalReader.GetSeekTable();
-    }
+    class FlatBuffersFacadeImpl : public IVtxReaderFacade {
+    public:
+        FlatBuffersFacadeImpl(const std::string& filepath)
+            : InternalReader(filepath) {}
 
-    void SetCacheWindow(uint32_t backward, uint32_t forward) override {
-        InternalReader.SetCacheWindow(backward, forward);
-    }
+        void SetEvents(const ReplayReaderEvents& events) override { InternalReader.SetEvents(events); }
 
-    void WarmAt(int32_t frame_index) override {
-        InternalReader.WarmAt(frame_index);
-    }
+        VTX::FileHeader GetHeader() override { return InternalReader.GetFileHeader(); }
 
-    bool GetFrame(int32_t frame_index, VTX::Frame& out_frame) override {
-        return InternalReader.GetFrame(frame_index, out_frame);
-    }
+        VTX::FileFooter GetFooter() override { return InternalReader.GetFileFooter(); }
 
-    const VTX::Frame* GetFrame(int32_t frame_index) override {
-        return InternalReader.GetFramePtr(frame_index);
-    }
+        VTX::ContextualSchema GetContextualSchema() override { return InternalReader.GetContextualSchema(); }
 
-    const VTX::Frame* GetFrameSync(int frame_index) override {
-        return InternalReader.GetFramePtrSync(frame_index);
-    }
+        VTX::PropertyAddressCache GetPropertyAddressCache() override {
+            return InternalReader.GetPropertyAddressCache();
+        }
 
-    void GetFrameRange(int32_t start_frame, int32_t range, std::vector<VTX::Frame>& out_frames) override {
-        InternalReader.GetFrameRange(start_frame, range, out_frames);
-    }
+        int32_t GetTotalFrames() const override { return InternalReader.GetTotalFrames(); }
 
-    std::vector<VTX::Frame> GetFrameContext(int32_t center_frame, int32_t back_range, int32_t forward_range) override {
-        return InternalReader.GetFrameContext(center_frame, back_range, forward_range);
-    }
+        const std::vector<ChunkIndexEntry>& GetSeekTable() const override { return InternalReader.GetSeekTable(); }
 
-    int32_t GetChunkFrameCountSafe(int32_t chunk_index) override {
-        return InternalReader.GetChunkFrameCountSafe(chunk_index);
-    }
+        void SetCacheWindow(uint32_t backward, uint32_t forward) override {
+            InternalReader.SetCacheWindow(backward, forward);
+        }
 
-    void InspectChunkHeader(int32_t index) const override {
-        InternalReader.InspectChunkHeader(index);
-    }
+        void WarmAt(int32_t frame_index) override { InternalReader.WarmAt(frame_index); }
 
-    FrameAccessor CreateAccessor() const override {
-        return InternalReader.CreateAccessor();
-    }
+        bool GetFrame(int32_t frame_index, VTX::Frame& out_frame) override {
+            return InternalReader.GetFrame(frame_index, out_frame);
+        }
 
-    std::span<const std::byte> GetRawFrameBytes(int32_t frame_index) override {
-        return InternalReader.GetRawFrameBytes(frame_index);
-    }
+        const VTX::Frame* GetFrame(int32_t frame_index) override { return InternalReader.GetFramePtr(frame_index); }
 
-private:
-    VTX::ReplayReader<VTX::FlatBuffersReaderPolicy> InternalReader;
-};
+        const VTX::Frame* GetFrameSync(int frame_index) override { return InternalReader.GetFramePtrSync(frame_index); }
 
+        void GetFrameRange(int32_t start_frame, int32_t range, std::vector<VTX::Frame>& out_frames) override {
+            InternalReader.GetFrameRange(start_frame, range, out_frames);
+        }
 
-class ProtobuffFacadeImpl : public IVtxReaderFacade {
-public:
-    ProtobuffFacadeImpl(const std::string& filepath)
-        : InternalReader(filepath) {}
+        std::vector<VTX::Frame> GetFrameContext(int32_t center_frame, int32_t back_range,
+                                                int32_t forward_range) override {
+            return InternalReader.GetFrameContext(center_frame, back_range, forward_range);
+        }
 
-    void SetEvents(const ReplayReaderEvents& events) override {
-        InternalReader.SetEvents(events);
-    }
+        int32_t GetChunkFrameCountSafe(int32_t chunk_index) override {
+            return InternalReader.GetChunkFrameCountSafe(chunk_index);
+        }
 
-    VTX::FileHeader GetHeader() override {
-        return InternalReader.GetFileHeader();
-    }
+        void InspectChunkHeader(int32_t index) const override { InternalReader.InspectChunkHeader(index); }
 
-    VTX::FileFooter GetFooter() override {
-        return InternalReader.GetFileFooter();
-    }
+        FrameAccessor CreateAccessor() const override { return InternalReader.CreateAccessor(); }
 
-    VTX::ContextualSchema GetContextualSchema() override {
-        return InternalReader.GetContextualSchema();
-    }
+        std::span<const std::byte> GetRawFrameBytes(int32_t frame_index) override {
+            return InternalReader.GetRawFrameBytes(frame_index);
+        }
 
-    VTX::PropertyAddressCache GetPropertyAddressCache() override {
-        return InternalReader.GetPropertyAddressCache();
-    }
+    private:
+        VTX::ReplayReader<VTX::FlatBuffersReaderPolicy> InternalReader;
+    };
 
-    int32_t GetTotalFrames() const override {
-        return InternalReader.GetTotalFrames();
-    }
 
-    const std::vector<ChunkIndexEntry>& GetSeekTable() const override {
-        return InternalReader.GetSeekTable();
-    }
+    class ProtobuffFacadeImpl : public IVtxReaderFacade {
+    public:
+        ProtobuffFacadeImpl(const std::string& filepath)
+            : InternalReader(filepath) {}
 
-    void SetCacheWindow(uint32_t backward, uint32_t forward) override {
-        InternalReader.SetCacheWindow(backward, forward);
-    }
+        void SetEvents(const ReplayReaderEvents& events) override { InternalReader.SetEvents(events); }
 
-    void WarmAt(int32_t frame_index) override {
-        InternalReader.WarmAt(frame_index);
-    }
+        VTX::FileHeader GetHeader() override { return InternalReader.GetFileHeader(); }
 
-    bool GetFrame(int32_t frame_index, VTX::Frame& out_frame) override {
-        return InternalReader.GetFrame(frame_index, out_frame);
-    }
+        VTX::FileFooter GetFooter() override { return InternalReader.GetFileFooter(); }
 
-    const VTX::Frame* GetFrame(int32_t frame_index) override {
-        return InternalReader.GetFramePtr(frame_index);
-    }
+        VTX::ContextualSchema GetContextualSchema() override { return InternalReader.GetContextualSchema(); }
 
-    const VTX::Frame* GetFrameSync(int frame_index) override {
-        return InternalReader.GetFramePtrSync(frame_index);
-    }
+        VTX::PropertyAddressCache GetPropertyAddressCache() override {
+            return InternalReader.GetPropertyAddressCache();
+        }
 
-    void GetFrameRange(int32_t start_frame, int32_t range, std::vector<VTX::Frame>& out_frames) override {
-        InternalReader.GetFrameRange(start_frame, range, out_frames);
-    }
+        int32_t GetTotalFrames() const override { return InternalReader.GetTotalFrames(); }
 
-    std::vector<VTX::Frame> GetFrameContext(int32_t center_frame, int32_t back_range, int32_t forward_range) override {
-        return InternalReader.GetFrameContext(center_frame, back_range, forward_range);
-    }
+        const std::vector<ChunkIndexEntry>& GetSeekTable() const override { return InternalReader.GetSeekTable(); }
 
-    int32_t GetChunkFrameCountSafe(int32_t chunk_index) override {
-        return InternalReader.GetChunkFrameCountSafe(chunk_index);
-    }
+        void SetCacheWindow(uint32_t backward, uint32_t forward) override {
+            InternalReader.SetCacheWindow(backward, forward);
+        }
 
-    void InspectChunkHeader(int32_t index) const override {
-        InternalReader.InspectChunkHeader(index);
-    }
+        void WarmAt(int32_t frame_index) override { InternalReader.WarmAt(frame_index); }
 
-    FrameAccessor CreateAccessor() const override {
-        return InternalReader.CreateAccessor();
-    }
+        bool GetFrame(int32_t frame_index, VTX::Frame& out_frame) override {
+            return InternalReader.GetFrame(frame_index, out_frame);
+        }
 
-    std::span<const std::byte> GetRawFrameBytes(int32_t frame_index) override {
-        return InternalReader.GetRawFrameBytes(frame_index);
-    }
+        const VTX::Frame* GetFrame(int32_t frame_index) override { return InternalReader.GetFramePtr(frame_index); }
 
-private:
-    VTX::ReplayReader<VTX::ProtobufReaderPolicy> InternalReader;
-};
+        const VTX::Frame* GetFrameSync(int frame_index) override { return InternalReader.GetFramePtrSync(frame_index); }
 
+        void GetFrameRange(int32_t start_frame, int32_t range, std::vector<VTX::Frame>& out_frames) override {
+            InternalReader.GetFrameRange(start_frame, range, out_frames);
+        }
 
-std::unique_ptr<IVtxReaderFacade> CreateFlatBuffersFacade(const std::string& filepath) {
-    return std::make_unique<FlatBuffersFacadeImpl>(filepath);
-}
+        std::vector<VTX::Frame> GetFrameContext(int32_t center_frame, int32_t back_range,
+                                                int32_t forward_range) override {
+            return InternalReader.GetFrameContext(center_frame, back_range, forward_range);
+        }
 
-std::unique_ptr<IVtxReaderFacade> CreateProtobuffFacade(const std::string& filepath) {
-    return std::make_unique<ProtobuffFacadeImpl>(filepath);
-}
+        int32_t GetChunkFrameCountSafe(int32_t chunk_index) override {
+            return InternalReader.GetChunkFrameCountSafe(chunk_index);
+        }
 
+        void InspectChunkHeader(int32_t index) const override { InternalReader.InspectChunkHeader(index); }
 
-ReaderContext OpenReplayFile(const std::string& filepath) {
-    ReaderContext result;
-    try {
-        std::ifstream file(filepath, std::ios::binary | std::ios::in);
-        if (!file.is_open()) {
-            result.SetError("Failed to open file: " + filepath);
-            return result;
-        }
+        FrameAccessor CreateAccessor() const override { return InternalReader.CreateAccessor(); }
 
-        // Calculate file size
-        file.seekg(0, std::ios::end);
-        const auto file_size = file.tellg();
-        result.size_in_mb = static_cast<float>(file_size) / (1024.0f * 1024.0f);
-        file.seekg(0);
-
-        // Read magic bytes
-        std::string magic(4, '\0');
-        file.read(magic.data(), 4);
-        file.close();
-
-        if (magic == "VTXF") {
-            result.format = VtxFormat::FlatBuffers;
-            result.reader = std::make_unique<FlatBuffersFacadeImpl>(filepath);
-        } else if (magic == "VTXP") {
-            result.format = VtxFormat::Protobuf;
-            result.reader = std::make_unique<ProtobuffFacadeImpl>(filepath);
-        } else {
-            result.SetError("Unknown file format. Magic: " + magic);
-            return result;
+        std::span<const std::byte> GetRawFrameBytes(int32_t frame_index) override {
+            return InternalReader.GetRawFrameBytes(frame_index);
         }
 
-        if (!result.reader) {
-            result.SetError("Reader creation failed.");
-            return result;
-        }
+    private:
+        VTX::ReplayReader<VTX::ProtobufReaderPolicy> InternalReader;
+    };
 
-        // Wire chunk events to the built-in state tracker
-        auto* cs = result.chunk_state.get();
-        cs->Reset();
 
-        ReplayReaderEvents events;
-        events.OnChunkLoadStarted = [cs](int32_t chunk_idx) {
-            cs->OnChunkLoadStarted(chunk_idx);
-        };
-        events.OnChunkLoadFinished = [cs](int32_t chunk_idx) {
-            cs->OnChunkLoadFinished(chunk_idx);
-        };
-        events.OnChunkEvicted = [cs](int32_t chunk_idx) {
-            cs->OnChunkEvicted(chunk_idx);
-        };
-        result.reader->SetEvents(events);
-
-    } catch (const std::exception& e) {
-        result.SetError(std::string("Error opening replay: ") + e.what());
-        result.reader.reset();
-    } catch (...) {
-        result.SetError("Unknown error while opening replay.");
-        result.reader.reset();
+    std::unique_ptr<IVtxReaderFacade> CreateFlatBuffersFacade(const std::string& filepath) {
+        return std::make_unique<FlatBuffersFacadeImpl>(filepath);
+    }
+
+    std::unique_ptr<IVtxReaderFacade> CreateProtobuffFacade(const std::string& filepath) {
+        return std::make_unique<ProtobuffFacadeImpl>(filepath);
+    }
+
+
+    ReaderContext OpenReplayFile(const std::string& filepath) {
+        ReaderContext result;
+        try {
+            std::ifstream file(filepath, std::ios::binary | std::ios::in);
+            if (!file.is_open()) {
+                result.SetError("Failed to open file: " + filepath);
+                return result;
+            }
+
+            // Calculate file size
+            file.seekg(0, std::ios::end);
+            const auto file_size = file.tellg();
+            result.size_in_mb = static_cast<float>(file_size) / (1024.0f * 1024.0f);
+            file.seekg(0);
+
+            // Read magic bytes
+            std::string magic(4, '\0');
+            file.read(magic.data(), 4);
+            file.close();
+
+            if (magic == "VTXF") {
+                result.format = VtxFormat::FlatBuffers;
+                result.reader = std::make_unique<FlatBuffersFacadeImpl>(filepath);
+            } else if (magic == "VTXP") {
+                result.format = VtxFormat::Protobuf;
+                result.reader = std::make_unique<ProtobuffFacadeImpl>(filepath);
+            } else {
+                result.SetError("Unknown file format. Magic: " + magic);
+                return result;
+            }
+
+            if (!result.reader) {
+                result.SetError("Reader creation failed.");
+                return result;
+            }
+
+            // Wire chunk events to the built-in state tracker
+            auto* cs = result.chunk_state.get();
+            cs->Reset();
+
+            ReplayReaderEvents events;
+            events.OnChunkLoadStarted = [cs](int32_t chunk_idx) {
+                cs->OnChunkLoadStarted(chunk_idx);
+            };
+            events.OnChunkLoadFinished = [cs](int32_t chunk_idx) {
+                cs->OnChunkLoadFinished(chunk_idx);
+            };
+            events.OnChunkEvicted = [cs](int32_t chunk_idx) {
+                cs->OnChunkEvicted(chunk_idx);
+            };
+            result.reader->SetEvents(events);
+
+        } catch (const std::exception& e) {
+            result.SetError(std::string("Error opening replay: ") + e.what());
+            result.reader.reset();
+        } catch (...) {
+            result.SetError("Unknown error while opening replay.");
+            result.reader.reset();
+        }
+        return result;
     }
-    return result;
-}
 
 } // namespace VTX
diff --git a/sdk/src/vtx_reader/src/vtx/reader/core/vtx_schema_adapter.cpp b/sdk/src/vtx_reader/src/vtx/reader/core/vtx_schema_adapter.cpp
index 84fef40..9d54644 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/core/vtx_schema_adapter.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/core/vtx_schema_adapter.cpp
@@ -6,8 +6,7 @@
 
 namespace VTX {
 
-    void PopulateCacheFromJsonString(const std::string& json_str, PropertyAddressCache& cache)
-    {
+    void PopulateCacheFromJsonString(const std::string& json_str, PropertyAddressCache& cache) {
         cache.Clear();
         if (json_str.empty()) {
             VTX_WARN("JSON string is empty in the .vtx file");
@@ -23,12 +22,12 @@ namespace VTX {
         for (const auto& [struct_name, struct_def] : temp_registry.GetDefinitions()) {
             int32_t type_id = temp_registry.GetStructTypeId(struct_name);
             if (type_id == -1) {
-                 VTX_WARN("Struct '{}' does not have a TypeID registered in the enum.", struct_name);
-                continue; 
+                VTX_WARN("Struct '{}' does not have a TypeID registered in the enum.", struct_name);
+                continue;
             }
             cache.name_to_id[struct_name] = type_id;
-            
-            auto& struct_cache = cache.structs[type_id];   
+
+            auto& struct_cache = cache.structs[type_id];
             struct_cache.name = struct_name;
             for (const auto& field : struct_def.fields) {
                 if (field.type_id != VTX::FieldType::None) {
@@ -38,7 +37,8 @@ namespace VTX {
                     addr.container_type = field.container_type;
                     addr.child_type_name = field.struct_type;
                     struct_cache.properties[field.name] = addr;
-                    struct_cache.names_by_lookup_key[VTX::MakePropertyLookupKey(field.index, field.type_id, field.container_type)] = field.name;
+                    struct_cache.names_by_lookup_key[VTX::MakePropertyLookupKey(field.index, field.type_id,
+                                                                                field.container_type)] = field.name;
                     struct_cache.property_order.push_back(field.name);
                 }
             }
@@ -47,17 +47,16 @@ namespace VTX {
     // =========================================================================================
     // PROTOBUF (cppvtx::PropertySchema)
     // =========================================================================================
-    void SchemaAdapter<cppvtx::ContextualSchema>::BuildCache(const cppvtx::ContextualSchema& src, PropertyAddressCache& cache)
-    {
+    void SchemaAdapter<cppvtx::ContextualSchema>::BuildCache(const cppvtx::ContextualSchema& src,
+                                                             PropertyAddressCache& cache) {
         PopulateCacheFromJsonString(src.schema(), cache);
     }
 
     // =========================================================================================
     // FLATBUFFERS (fbsvtx::PropertySchemaT)
     // =========================================================================================
-    void SchemaAdapter<fbsvtx::ContextualSchemaT>::BuildCache(const fbsvtx::ContextualSchemaT& src, PropertyAddressCache& cache) 
-    {
+    void SchemaAdapter<fbsvtx::ContextualSchemaT>::BuildCache(const fbsvtx::ContextualSchemaT& src,
+                                                              PropertyAddressCache& cache) {
         PopulateCacheFromJsonString(src.schema, cache);
-
     }
-}
+} // namespace VTX
diff --git a/sdk/src/vtx_reader/src/vtx/reader/formatters/flatbuffer_reader_policy.cpp b/sdk/src/vtx_reader/src/vtx/reader/formatters/flatbuffer_reader_policy.cpp
index ffb7697..c0879d3 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/formatters/flatbuffer_reader_policy.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/formatters/flatbuffer_reader_policy.cpp
@@ -19,7 +19,7 @@ VTX::FlatBuffersReaderPolicy::HeaderType VTX::FlatBuffersReaderPolicy::ParseHead
 }
 
 std::string VTX::FlatBuffersReaderPolicy::GetMagicBytes() {
-    return "VTXF"; 
+    return "VTXF";
 }
 
 VTX::FlatBuffersReaderPolicy::FooterType VTX::FlatBuffersReaderPolicy::ParseFooter(const std::string& buffer) {
@@ -31,35 +31,38 @@ VTX::FlatBuffersReaderPolicy::FooterType VTX::FlatBuffersReaderPolicy::ParseFoot
     return footer;
 }
 
-void VTX::FlatBuffersReaderPolicy::ProcessChunkData(int chunk_index,const std::string& compressed, std::stop_token st,std::vector<VTX::Frame>& out_native_frames,std::vector<uint8_t>& out_decompressed_blob,std::vector<std::span<const std::byte>>& out_raw_frames_spans)
- {
+void VTX::FlatBuffersReaderPolicy::ProcessChunkData(int chunk_index, const std::string& compressed, std::stop_token st,
+                                                    std::vector<VTX::Frame>& out_native_frames,
+                                                    std::vector<uint8_t>& out_decompressed_blob,
+                                                    std::vector<std::span<const std::byte>>& out_raw_frames_spans) {
     std::string decompressed = VTX::ReplayUnpacker::Decompress(compressed);
     auto* chunk = flatbuffers::GetRoot<fbsvtx::Chunk>(decompressed.data());
-        
-    if (!chunk || !chunk->frames()) return;
+
+    if (!chunk || !chunk->frames())
+        return;
 
     size_t num_frames = chunk->frames()->size();
     out_native_frames.resize(num_frames);
     out_raw_frames_spans.reserve(num_frames);
-        
+
     flatbuffers::FlatBufferBuilder fbb;
     std::vector<size_t> frame_sizes;
     frame_sizes.reserve(num_frames);
 
     //serialize and concatenate frmaes in a single block
     for (size_t i = 0; i < num_frames; ++i) {
-        if (st.stop_requested()) return;
+        if (st.stop_requested())
+            return;
         VTX::Serialization::FromFlat(chunk->frames()->Get(i), out_native_frames[i]);
-            
+
         //pack for differ
         auto* data_obj = chunk->frames()->Get(i)->data()->Get(0);
         std::unique_ptr<fbsvtx::BucketT> dataT(data_obj->UnPack());
-            
+
         fbb.Clear();
         fbb.Finish(fbsvtx::Bucket::Pack(fbb, dataT.get()));
-            
-        out_decompressed_blob.insert(out_decompressed_blob.end(), 
-                                     fbb.GetBufferPointer(), 
+
+        out_decompressed_blob.insert(out_decompressed_blob.end(), fbb.GetBufferPointer(),
                                      fbb.GetBufferPointer() + fbb.GetSize());
         frame_sizes.push_back(fbb.GetSize());
     }
@@ -67,34 +70,33 @@ void VTX::FlatBuffersReaderPolicy::ProcessChunkData(int chunk_index,const std::s
     //genrate spans for each frame, zero copy
     size_t offset = 0;
     for (size_t size : frame_sizes) {
-        out_raw_frames_spans.emplace_back(
-            reinterpret_cast<const std::byte*>(out_decompressed_blob.data() + offset), 
-            size
-        );
+        out_raw_frames_spans.emplace_back(reinterpret_cast<const std::byte*>(out_decompressed_blob.data() + offset),
+                                          size);
         offset += size;
     }
 }
 
-void VTX::FlatBuffersReaderPolicy::PopulateIndexTable(const FooterType& footer,std::vector<ChunkIndexEntry>& chunk_index_table)
-{
+void VTX::FlatBuffersReaderPolicy::PopulateIndexTable(const FooterType& footer,
+                                                      std::vector<ChunkIndexEntry>& chunk_index_table) {
     chunk_index_table.reserve(footer.chunk_index.size());
-    
+
     for (const auto& e : footer.chunk_index) {
-        if(!e) continue;
+        if (!e)
+            continue;
 
         ChunkIndexEntry ce;
-        ce.chunk_index      = e->chunk_index;
-        ce.start_frame      = e->start_frame;
-        ce.end_frame        = e->end_frame;
-        ce.file_offset      = e->file_offset;
+        ce.chunk_index = e->chunk_index;
+        ce.start_frame = e->start_frame;
+        ce.end_frame = e->end_frame;
+        ce.file_offset = e->file_offset;
         ce.chunk_size_bytes = e->chunk_size_bytes;
-        
+
         chunk_index_table.push_back(ce);
     }
 }
 
-void VTX::FlatBuffersReaderPolicy::PopulateGameTimes(const FooterType& footer, VTX::GameTime::VTXGameTimes& game_times)
-{
+void VTX::FlatBuffersReaderPolicy::PopulateGameTimes(const FooterType& footer,
+                                                     VTX::GameTime::VTXGameTimes& game_times) {
     if (footer.times) {
         const auto& t = *footer.times;
         game_times.SetGameTime(t.game_time);
@@ -112,12 +114,11 @@ const VTX::FlatBuffersReaderPolicy::SchemaType& VTX::FlatBuffersReaderPolicy::Ge
     if (header.contextual_schema) {
         return *header.contextual_schema;
     }
-    static SchemaType dummy; 
-    return dummy; 
+    static SchemaType dummy;
+    return dummy;
 }
 
- VTX::ContextualSchema VTX::FlatBuffersReaderPolicy::GetVTXContextualSchema(const HeaderType& header)
-{
+VTX::ContextualSchema VTX::FlatBuffersReaderPolicy::GetVTXContextualSchema(const HeaderType& header) {
     VTX::ContextualSchema contextual_schema;
     contextual_schema.data_identifier = header.contextual_schema->data_identifier;
     contextual_schema.data_version = header.contextual_schema->data_version;
@@ -126,14 +127,13 @@ const VTX::FlatBuffersReaderPolicy::SchemaType& VTX::FlatBuffersReaderPolicy::Ge
     return contextual_schema;
 }
 
-VTX::FileHeader VTX::FlatBuffersReaderPolicy::GetVTXHeader(const HeaderType& fbs_header)
-{
+VTX::FileHeader VTX::FlatBuffersReaderPolicy::GetVTXHeader(const HeaderType& fbs_header) {
     VTX::FileHeader out;
     out.replay_name = fbs_header.replay_name;
     out.replay_uuid = fbs_header.replay_uuid;
     out.recorded_utc_timestamp = fbs_header.recorded_utc_timestamp;
     out.custom_json_metadata = fbs_header.custom_json_metadata;
-            
+
     if (fbs_header.version) {
         out.version.format_major = fbs_header.version->format_major;
         out.version.format_minor = fbs_header.version->format_minor;
@@ -142,13 +142,12 @@ VTX::FileHeader VTX::FlatBuffersReaderPolicy::GetVTXHeader(const HeaderType& fbs
     return out;
 }
 
-VTX::FileFooter VTX::FlatBuffersReaderPolicy::GetVTXFooter(const FooterType& fbs_footer)
-{
+VTX::FileFooter VTX::FlatBuffersReaderPolicy::GetVTXFooter(const FooterType& fbs_footer) {
     VTX::FileFooter out;
     out.total_frames = fbs_footer.total_frames;
     out.duration_seconds = fbs_footer.duration_seconds;
     out.payload_checksum = fbs_footer.payload_checksum;
-            
+
     out.chunk_index.reserve(fbs_footer.chunk_index.size());
     for (const auto& chunk : fbs_footer.chunk_index) {
         if (chunk) {
@@ -157,12 +156,12 @@ VTX::FileFooter VTX::FlatBuffersReaderPolicy::GetVTXFooter(const FooterType& fbs
             entry.chunk_size_bytes = chunk->chunk_size_bytes;
             entry.start_frame = chunk->start_frame;
             entry.end_frame = chunk->end_frame;
-            
+
             entry.file_offset = chunk->file_offset;
             out.chunk_index.push_back(entry);
         }
     }
-            
+
     out.events.reserve(fbs_footer.events.size());
     for (const auto& ev : fbs_footer.events) {
         if (ev) {
@@ -173,13 +172,13 @@ VTX::FileFooter VTX::FlatBuffersReaderPolicy::GetVTXFooter(const FooterType& fbs
             out.events.push_back(out_ev);
         }
     }
-     
+
     if (fbs_footer.times) {
         const auto& fbs_times = fbs_footer.times;
         out.times.game_time.assign(fbs_times->game_time.begin(), fbs_times->game_time.end());
         out.times.created_utc.assign(fbs_times->created_utc.begin(), fbs_times->created_utc.end());
         out.times.gaps.assign(fbs_times->gaps.begin(), fbs_times->gaps.end());
         out.times.segments.assign(fbs_times->segments.begin(), fbs_times->segments.end());
-    }    
+    }
     return out;
 }
diff --git a/sdk/src/vtx_reader/src/vtx/reader/formatters/protobuff_reader_policy.cpp b/sdk/src/vtx_reader/src/vtx/reader/formatters/protobuff_reader_policy.cpp
index 780b45f..2af17ee 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/formatters/protobuff_reader_policy.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/formatters/protobuff_reader_policy.cpp
@@ -18,7 +18,7 @@ VTX::ProtobufReaderPolicy::HeaderType VTX::ProtobufReaderPolicy::ParseHeader(con
     return header;
 }
 
- VTX::ProtobufReaderPolicy::FooterType VTX::ProtobufReaderPolicy::ParseFooter(const std::string& buffer) {
+VTX::ProtobufReaderPolicy::FooterType VTX::ProtobufReaderPolicy::ParseFooter(const std::string& buffer) {
     FooterType footer;
     if (!footer.ParseFromString(buffer)) {
         throw std::runtime_error("VTX Reader [Proto]: Failed to parse FileFooter.");
@@ -26,8 +26,10 @@ VTX::ProtobufReaderPolicy::HeaderType VTX::ProtobufReaderPolicy::ParseHeader(con
     return footer;
 }
 
-void VTX::ProtobufReaderPolicy::ProcessChunkData(int chunk_index,const std::string& compressed, std::stop_token st,std::vector<VTX::Frame>& out_native_frames,std::vector<uint8_t>& out_decompressed_blob,std::vector<std::span<const std::byte>>& out_raw_frames_spans)
- {
+void VTX::ProtobufReaderPolicy::ProcessChunkData(int chunk_index, const std::string& compressed, std::stop_token st,
+                                                 std::vector<VTX::Frame>& out_native_frames,
+                                                 std::vector<uint8_t>& out_decompressed_blob,
+                                                 std::vector<std::span<const std::byte>>& out_raw_frames_spans) {
     std::string decompressed = VTX::ReplayUnpacker::Decompress(compressed);
 
     cppvtx::FrameChunk proto;
@@ -39,7 +41,7 @@ void VTX::ProtobufReaderPolicy::ProcessChunkData(int chunk_index,const std::stri
 
     //precalculate data size
     size_t total_raw_size = 0;
-    for(int i = 0; i < num_frames; ++i) {
+    for (int i = 0; i < num_frames; ++i) {
         total_raw_size += proto.frames(i).data(0).ByteSizeLong();
     }
     out_decompressed_blob.reserve(total_raw_size);
@@ -48,8 +50,9 @@ void VTX::ProtobufReaderPolicy::ProcessChunkData(int chunk_index,const std::stri
     frame_sizes.reserve(num_frames);
 
     //serialize and concatenate frmaes in a single block
-    for(int i = 0; i < num_frames; ++i) {
-        if (st.stop_requested()) return;
+    for (int i = 0; i < num_frames; ++i) {
+        if (st.stop_requested())
+            return;
         Serialization::FromProto(proto.frames(i), out_native_frames[i]);
 
         // Eextract root for the differ
@@ -62,32 +65,30 @@ void VTX::ProtobufReaderPolicy::ProcessChunkData(int chunk_index,const std::stri
     // done here because if we do it before , if vector grows pointers are invalid
     size_t offset = 0;
     for (size_t size : frame_sizes) {
-        out_raw_frames_spans.emplace_back(
-            reinterpret_cast<const std::byte*>(out_decompressed_blob.data() + offset),
-            size
-        );
+        out_raw_frames_spans.emplace_back(reinterpret_cast<const std::byte*>(out_decompressed_blob.data() + offset),
+                                          size);
         offset += size;
     }
 }
 
-void VTX::ProtobufReaderPolicy::PopulateIndexTable(const FooterType& footer,std::vector<ChunkIndexEntry>& chunk_index_table)
-{
+void VTX::ProtobufReaderPolicy::PopulateIndexTable(const FooterType& footer,
+                                                   std::vector<ChunkIndexEntry>& chunk_index_table) {
     chunk_index_table.reserve(footer.chunk_index_size());
 
     for (const auto& protoEntry : footer.chunk_index()) {
         ChunkIndexEntry nativeEntry;
-        nativeEntry.chunk_index     = protoEntry.chunk_index();
-        nativeEntry.start_frame     = protoEntry.start_frame();
-        nativeEntry.end_frame       = protoEntry.end_frame();
-        nativeEntry.file_offset     = protoEntry.file_offset();
+        nativeEntry.chunk_index = protoEntry.chunk_index();
+        nativeEntry.start_frame = protoEntry.start_frame();
+        nativeEntry.end_frame = protoEntry.end_frame();
+        nativeEntry.file_offset = protoEntry.file_offset();
         nativeEntry.chunk_size_bytes = protoEntry.chunk_size_bytes();
 
         chunk_index_table.push_back(nativeEntry);
     }
 }
 
-void VTX::ProtobufReaderPolicy::PopulateGameTimes(const VTX::ProtobufReaderPolicy::FooterType& footer, VTX::GameTime::VTXGameTimes& game_times)
-{
+void VTX::ProtobufReaderPolicy::PopulateGameTimes(const VTX::ProtobufReaderPolicy::FooterType& footer,
+                                                  VTX::GameTime::VTXGameTimes& game_times) {
     const auto& times_proto = footer.times();
     game_times.SetGameTime({times_proto.game_time().begin(), times_proto.game_time().end()});
     game_times.SetCreatedUtc({times_proto.created_utc().begin(), times_proto.created_utc().end()});
@@ -103,8 +104,7 @@ const VTX::ProtobufReaderPolicy::SchemaType& VTX::ProtobufReaderPolicy::GetSchem
     return header.prop_schema();
 }
 
-VTX::ContextualSchema VTX::ProtobufReaderPolicy::GetVTXContextualSchema(const HeaderType& header)
-{
+VTX::ContextualSchema VTX::ProtobufReaderPolicy::GetVTXContextualSchema(const HeaderType& header) {
     VTX::ContextualSchema contextual_schema;
     contextual_schema.data_identifier = header.prop_schema().data_indentifier();
     contextual_schema.data_version = header.prop_schema().data_version();
@@ -113,8 +113,7 @@ VTX::ContextualSchema VTX::ProtobufReaderPolicy::GetVTXContextualSchema(const He
     return contextual_schema;
 }
 
-VTX::FileHeader VTX::ProtobufReaderPolicy::GetVTXHeader(const HeaderType& pb_header)
-{
+VTX::FileHeader VTX::ProtobufReaderPolicy::GetVTXHeader(const HeaderType& pb_header) {
     VTX::FileHeader out;
     out.replay_name = pb_header.replay_name();
     out.replay_uuid = pb_header.replay_uuid();
@@ -130,8 +129,7 @@ VTX::FileHeader VTX::ProtobufReaderPolicy::GetVTXHeader(const HeaderType& pb_hea
     return out;
 }
 
-VTX::FileFooter VTX::ProtobufReaderPolicy::GetVTXFooter(const FooterType& pb_footer)
-{
+VTX::FileFooter VTX::ProtobufReaderPolicy::GetVTXFooter(const FooterType& pb_footer) {
     VTX::FileFooter out;
     out.total_frames = pb_footer.total_frames();
     out.duration_seconds = pb_footer.duration_seconds();
diff --git a/sdk/src/vtx_reader/src/vtx/reader/serialization/flatbuffers_to_vtx.cpp b/sdk/src/vtx_reader/src/vtx/reader/serialization/flatbuffers_to_vtx.cpp
index a018765..42b6b53 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/serialization/flatbuffers_to_vtx.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/serialization/flatbuffers_to_vtx.cpp
@@ -5,41 +5,47 @@
 
 // --- MATH TYPES ---
 void VTX::Serialization::FromFlat(const fbsvtx::Vector* src, VTX::Vector& dst) {
-    if (!src) return;
-    dst.x = src->x(); 
-    dst.y = src->y(); 
+    if (!src)
+        return;
+    dst.x = src->x();
+    dst.y = src->y();
     dst.z = src->z();
 }
 
 void VTX::Serialization::FromFlat(const fbsvtx::Quat* src, VTX::Quat& dst) {
-    if (!src) return;
-    dst.x = src->x(); 
-    dst.y = src->y(); 
-    dst.z = src->z(); 
+    if (!src)
+        return;
+    dst.x = src->x();
+    dst.y = src->y();
+    dst.z = src->z();
     dst.w = src->w();
 }
 
 void VTX::Serialization::FromFlat(const fbsvtx::Transform* src, VTX::Transform& dst) {
-    if (!src) return;
-    FromFlat(&src->translation(), dst.translation); 
+    if (!src)
+        return;
+    FromFlat(&src->translation(), dst.translation);
     FromFlat(&src->rotation(), dst.rotation);
     FromFlat(&src->scale(), dst.scale);
 }
 
 void VTX::Serialization::FromFlat(const fbsvtx::FloatRange* src, VTX::FloatRange& dst) {
-    if (!src) return;
-    dst.min = src->min(); 
-    dst.max = src->max(); 
+    if (!src)
+        return;
+    dst.min = src->min();
+    dst.max = src->max();
     dst.value_normalized = src->value_normalized();
 }
 
 void VTX::Serialization::FromFlat(const fbsvtx::MapContainer* src, VTX::MapContainer& dst) {
-    if (!src) return;
+    if (!src)
+        return;
     if (src->keys()) {
         dst.keys.reserve(src->keys()->size());
-        for (auto k : *src->keys()) dst.keys.push_back(k->str());
+        for (auto k : *src->keys())
+            dst.keys.push_back(k->str());
     }
-    
+
     if (src->values()) {
         dst.values.resize(src->values()->size());
         for (size_t i = 0; i < src->values()->size(); ++i) {
@@ -50,10 +56,11 @@ void VTX::Serialization::FromFlat(const fbsvtx::MapContainer* src, VTX::MapConta
 
 // --- PROPERTY CONTAINER ---
 void VTX::Serialization::FromFlat(const fbsvtx::PropertyContainer* src, VTX::PropertyContainer& dst) {
-    if (!src) return;
+    if (!src)
+        return;
     dst.entity_type_id = src->type_id();
     dst.content_hash = src->content_hash();
-    
+
     // 1. Scalars
     if (auto v = src->bool_properties()) {
         dst.bool_properties.clear();
@@ -62,66 +69,80 @@ void VTX::Serialization::FromFlat(const fbsvtx::PropertyContainer* src, VTX::Pro
             dst.bool_properties.push_back(b != 0);
         }
     }
-    
-    if (auto v = src->int32_properties())  dst.int32_properties.assign(v->begin(), v->end());
-    if (auto v = src->int64_properties())  dst.int64_properties.assign(v->begin(), v->end());
-    if (auto v = src->float_properties())  dst.float_properties.assign(v->begin(), v->end());
-    if (auto v = src->double_properties()) dst.double_properties.assign(v->begin(), v->end());
-    
+
+    if (auto v = src->int32_properties())
+        dst.int32_properties.assign(v->begin(), v->end());
+    if (auto v = src->int64_properties())
+        dst.int64_properties.assign(v->begin(), v->end());
+    if (auto v = src->float_properties())
+        dst.float_properties.assign(v->begin(), v->end());
+    if (auto v = src->double_properties())
+        dst.double_properties.assign(v->begin(), v->end());
+
     if (auto v = src->string_properties()) {
         dst.string_properties.reserve(v->size());
-        for(auto s : *v) dst.string_properties.push_back(s->str());
+        for (auto s : *v)
+            dst.string_properties.push_back(s->str());
     }
 
     // 2. Structs (Vector of Structs)
     auto unpackStructs = [](auto* fbsVec, auto& nativeVec) {
-        if (!fbsVec) return;
+        if (!fbsVec)
+            return;
         nativeVec.resize(fbsVec->size());
-        for (size_t i = 0; i < fbsVec->size(); ++i) FromFlat(fbsVec->Get(i), nativeVec[i]);
+        for (size_t i = 0; i < fbsVec->size(); ++i)
+            FromFlat(fbsVec->Get(i), nativeVec[i]);
     };
 
-    unpackStructs(src->vector_properties(),    dst.vector_properties);
-    unpackStructs(src->quat_properties(),      dst.quat_properties);
+    unpackStructs(src->vector_properties(), dst.vector_properties);
+    unpackStructs(src->quat_properties(), dst.quat_properties);
     unpackStructs(src->transform_properties(), dst.transform_properties);
-    unpackStructs(src->range_properties(),     dst.range_properties);
+    unpackStructs(src->range_properties(), dst.range_properties);
 
     // 3. Flat Arrays (SoA)
     auto unpackArray = [](auto* fbsArr, auto& nativeArr) {
-        if (!fbsArr) return;
-        if (fbsArr->data()) nativeArr.data.assign(fbsArr->data()->begin(), fbsArr->data()->end());
-        if (fbsArr->offsets()) nativeArr.offsets.assign(fbsArr->offsets()->begin(), fbsArr->offsets()->end());
+        if (!fbsArr)
+            return;
+        if (fbsArr->data())
+            nativeArr.data.assign(fbsArr->data()->begin(), fbsArr->data()->end());
+        if (fbsArr->offsets())
+            nativeArr.offsets.assign(fbsArr->offsets()->begin(), fbsArr->offsets()->end());
     };
 
     // Special handling for BoolArray if it uses uint8 internally in FBS
     if (auto arr = src->bool_arrays()) {
         if (arr->data()) {
             // Conversion implicit uint8 -> bool
-            dst.bool_arrays.data.assign(arr->data()->begin(), arr->data()->end()); 
+            dst.bool_arrays.data.assign(arr->data()->begin(), arr->data()->end());
         }
-        if (arr->offsets()) dst.bool_arrays.offsets.assign(arr->offsets()->begin(), arr->offsets()->end());
+        if (arr->offsets())
+            dst.bool_arrays.offsets.assign(arr->offsets()->begin(), arr->offsets()->end());
     }
 
     unpackArray(src->byte_array_properties(), dst.byte_array_properties);
-    unpackArray(src->int32_arrays(),    dst.int32_arrays);
-    unpackArray(src->int64_arrays(),    dst.int64_arrays);
-    unpackArray(src->float_arrays(),    dst.float_arrays);
-    unpackArray(src->double_arrays(),   dst.double_arrays);
-    
+    unpackArray(src->int32_arrays(), dst.int32_arrays);
+    unpackArray(src->int64_arrays(), dst.int64_arrays);
+    unpackArray(src->float_arrays(), dst.float_arrays);
+    unpackArray(src->double_arrays(), dst.double_arrays);
+
     // String Array
     if (auto arr = src->string_arrays()) {
         if (auto d = arr->data()) {
             dst.string_arrays.data.reserve(d->size());
-            for(auto s : *d) dst.string_arrays.data.push_back(s->str());
+            for (auto s : *d)
+                dst.string_arrays.data.push_back(s->str());
         }
-        if (auto o = arr->offsets()) dst.string_arrays.offsets.assign(o->begin(), o->end());
+        if (auto o = arr->offsets())
+            dst.string_arrays.offsets.assign(o->begin(), o->end());
     }
 
     // Struct Arrays (Needs conversion per element)
     auto unpackStructArray = [](auto* fbsArr, auto& nativeArr) {
-        if (!fbsArr) return;
+        if (!fbsArr)
+            return;
         if (auto d = fbsArr->data()) {
             nativeArr.data.resize(d->size());
-            for(size_t i = 0; i < d->size(); ++i) {
+            for (size_t i = 0; i < d->size(); ++i) {
                 FromFlat(d->Get(i), nativeArr.data[i]);
             }
         }
@@ -135,125 +156,125 @@ void VTX::Serialization::FromFlat(const fbsvtx::PropertyContainer* src, VTX::Pro
     // 4. Recursive
     if (auto v = src->any_struct_properties()) {
         dst.any_struct_properties.resize(v->size());
-        for(size_t i = 0; i < v->size(); ++i) FromFlat(v->Get(i), dst.any_struct_properties[i]);
+        for (size_t i = 0; i < v->size(); ++i)
+            FromFlat(v->Get(i), dst.any_struct_properties[i]);
     }
 
     if (auto arr = src->any_struct_arrays()) {
         if (auto d = arr->data()) {
             dst.any_struct_arrays.data.resize(d->size());
-            for(size_t i = 0; i < d->size(); ++i) FromFlat(d->Get(i), dst.any_struct_arrays.data[i]);
+            for (size_t i = 0; i < d->size(); ++i)
+                FromFlat(d->Get(i), dst.any_struct_arrays.data[i]);
         }
-        if (auto o = arr->offsets()) dst.any_struct_arrays.offsets.assign(o->begin(), o->end());
+        if (auto o = arr->offsets())
+            dst.any_struct_arrays.offsets.assign(o->begin(), o->end());
     }
 
     // 5. Maps
     if (auto v = src->map_properties()) {
         dst.map_properties.resize(v->size());
-        for(size_t i = 0; i < v->size(); ++i) FromFlat(v->Get(i), dst.map_properties[i]);
+        for (size_t i = 0; i < v->size(); ++i)
+            FromFlat(v->Get(i), dst.map_properties[i]);
     }
-    
+
     if (auto arr = src->map_arrays()) {
-         if (auto d = arr->data()) {
+        if (auto d = arr->data()) {
             dst.map_arrays.data.resize(d->size());
-            for(size_t i = 0; i < d->size(); ++i) FromFlat(d->Get(i), dst.map_arrays.data[i]);
+            for (size_t i = 0; i < d->size(); ++i)
+                FromFlat(d->Get(i), dst.map_arrays.data[i]);
         }
-        if (auto o = arr->offsets()) dst.map_arrays.offsets.assign(o->begin(), o->end());
+        if (auto o = arr->offsets())
+            dst.map_arrays.offsets.assign(o->begin(), o->end());
     }
 }
 
 // --- DATA & FRAME ---
 void VTX::Serialization::FromFlat(const fbsvtx::Bucket* src, VTX::Bucket& dst) {
-    if(!src) return;
-    if(src->unique_ids()) {
+    if (!src)
+        return;
+    if (src->unique_ids()) {
         dst.unique_ids.reserve(src->unique_ids()->size());
-        for(auto s : *src->unique_ids()) dst.unique_ids.push_back(s->str());
+        for (auto s : *src->unique_ids())
+            dst.unique_ids.push_back(s->str());
     }
-    if(src->entities()) {
+    if (src->entities()) {
         dst.entities.resize(src->entities()->size());
-        for(size_t i = 0; i < src->entities()->size(); ++i) FromFlat(src->entities()->Get(i), dst.entities[i]);
+        for (size_t i = 0; i < src->entities()->size(); ++i)
+            FromFlat(src->entities()->Get(i), dst.entities[i]);
     }
-    
+
     if (src->type_ranges()) {
         const auto* ranges = src->type_ranges();
         dst.type_ranges.reserve(ranges->size());
 
         for (size_t i = 0; i < ranges->size(); ++i) {
             const auto* r = ranges->Get(i);
-            dst.type_ranges.push_back(VTX::EntityRange{
-                r->start_index(), 
-                r->count()
-            });
+            dst.type_ranges.push_back(VTX::EntityRange {r->start_index(), r->count()});
         }
     }
 }
 
 void VTX::Serialization::FromFlat(const fbsvtx::Frame* src, VTX::Frame& dst) {
-    if(!src || !src->data()) return;
+    if (!src || !src->data())
+        return;
     auto& buckets = dst.GetMutableBuckets();
     buckets.resize(src->data()->size());
-    for(size_t i = 0; i < src->data()->size(); ++i) {
+    for (size_t i = 0; i < src->data()->size(); ++i) {
         FromFlat(src->data()->Get(i), buckets[i]);
     }
 }
 
-void VTX::Serialization::FromFlat(const fbsvtx::FileFooter* src, VTX::FileFooter& dst)
-{
+void VTX::Serialization::FromFlat(const fbsvtx::FileFooter* src, VTX::FileFooter& dst) {
     dst.total_frames = src->total_frames();
     dst.duration_seconds = src->duration_seconds();
-    
-    FromFlat(src->times(),dst.times);
-    
+
+    FromFlat(src->times(), dst.times);
+
     dst.chunk_index.reserve(src->chunk_index()->size());
-    for(size_t i = 0; i < src->chunk_index()->size(); ++i) {
-        FromFlat(src->chunk_index()->Get(i),  dst.chunk_index[i]);
+    for (size_t i = 0; i < src->chunk_index()->size(); ++i) {
+        FromFlat(src->chunk_index()->Get(i), dst.chunk_index[i]);
     }
-    
+
     dst.events.reserve(src->events()->size());
-    for(size_t i = 0; i < src->events()->size(); ++i) {
-        FromFlat(src->events()->Get(i),  dst.events[i]);
+    for (size_t i = 0; i < src->events()->size(); ++i) {
+        FromFlat(src->events()->Get(i), dst.events[i]);
     }
-    
+
     dst.payload_checksum = src->payload_checksum();
 }
 
-void VTX::Serialization::FromFlat(const fbsvtx::FileHeader* src, VTX::FileHeader& dst)
-{
-}
+void VTX::Serialization::FromFlat(const fbsvtx::FileHeader* src, VTX::FileHeader& dst) {}
 
-void VTX::Serialization::FromFlat(const fbsvtx::ChunkIndexEntry* src, VTX::ChunkIndexEntry& dst)
-{
+void VTX::Serialization::FromFlat(const fbsvtx::ChunkIndexEntry* src, VTX::ChunkIndexEntry& dst) {
     dst.chunk_index = src->chunk_index();
     dst.start_frame = src->start_frame();
     dst.end_frame = src->end_frame();
     dst.file_offset = src->file_offset();
     dst.chunk_size_bytes = src->chunk_size_bytes();
-    
 }
 
-void VTX::Serialization::FromFlat(const fbsvtx::ReplayTimeData* src, VTX::ReplayTimeData& dst)
-{
-    for(size_t i = 0; i < src->game_time()->size(); ++i) {
+void VTX::Serialization::FromFlat(const fbsvtx::ReplayTimeData* src, VTX::ReplayTimeData& dst) {
+    for (size_t i = 0; i < src->game_time()->size(); ++i) {
         dst.game_time.push_back(src->game_time()->Get(i));
     }
-    
-    for(size_t i = 0; i < src->created_utc()->size(); ++i) {
+
+    for (size_t i = 0; i < src->created_utc()->size(); ++i) {
         dst.created_utc.push_back(src->created_utc()->Get(i));
     }
-    
-    for(size_t i = 0; i < src->gaps()->size(); ++i) {
+
+    for (size_t i = 0; i < src->gaps()->size(); ++i) {
         dst.gaps.push_back(src->gaps()->Get(i));
     }
-    
-    for(size_t i = 0; i < src->segments()->size(); ++i) {
+
+    for (size_t i = 0; i < src->segments()->size(); ++i) {
         dst.segments.push_back(src->segments()->Get(i));
     }
 }
 
-void VTX::Serialization::FromFlat(const fbsvtx::TimelineEvent* src, VTX::TimelineEvent& dst)
-{
+void VTX::Serialization::FromFlat(const fbsvtx::TimelineEvent* src, VTX::TimelineEvent& dst) {
     dst.game_time = src->game_time();
     dst.event_type = *src->event_type();
     dst.label = *src->label();
-    FromFlat(src->location(),dst.location);
+    FromFlat(src->location(), dst.location);
     dst.entity_unique_id = *src->entity_unique_id();
 }
diff --git a/sdk/src/vtx_reader/src/vtx/reader/serialization/proto_to_vtx.cpp b/sdk/src/vtx_reader/src/vtx/reader/serialization/proto_to_vtx.cpp
index 1f1c995..3ec4109 100644
--- a/sdk/src/vtx_reader/src/vtx/reader/serialization/proto_to_vtx.cpp
+++ b/sdk/src/vtx_reader/src/vtx/reader/serialization/proto_to_vtx.cpp
@@ -3,22 +3,23 @@
 #include "vtx_schema.pb.h"
 namespace VTX {
     namespace Serialization {
-        
-        template<typename TProtoArr, typename TNativeArr>
+
+        template <typename TProtoArr, typename TNativeArr>
         void FromProtoVec(const TProtoArr& src, TNativeArr& dst) {
             dst.data.clear();
             dst.offsets.clear();
-            
+
             dst.data.reserve(src.data_size());
             dst.offsets.reserve(src.offsets_size());
 
             for (const auto& v : src.data()) {
-                dst.data.push_back(v); 
+                dst.data.push_back(v);
             }
-            for (auto o : src.offsets()) dst.offsets.push_back(o);
+            for (auto o : src.offsets())
+                dst.offsets.push_back(o);
         }
 
-        template<typename TProtoArr, typename TNativeArr, typename TFunc>
+        template <typename TProtoArr, typename TNativeArr, typename TFunc>
         void FromProtoComplexVec(const TProtoArr& src, TNativeArr& dst, TFunc unpackFunc) {
             dst.data.resize(src.data_size());
             for (int i = 0; i < src.data_size(); ++i) {
@@ -26,7 +27,7 @@ namespace VTX {
             }
             dst.offsets.assign(src.offsets().begin(), src.offsets().end());
         }
-        
+
 
         void FromProto(const cppvtx::Vector& src, VTX::Vector& dst) {
             dst.x = src.x();
@@ -60,11 +61,11 @@ namespace VTX {
 
             out.entity_type_id = proto.type_id();
             out.content_hash = proto.content_hash();
-            
-            Copy(out.bool_properties,   proto.bool_properties());
-            Copy(out.int32_properties,  proto.int32_properties());
-            Copy(out.int64_properties,  proto.int64_properties());
-            Copy(out.float_properties,  proto.float_properties());
+
+            Copy(out.bool_properties, proto.bool_properties());
+            Copy(out.int32_properties, proto.int32_properties());
+            Copy(out.int64_properties, proto.int64_properties());
+            Copy(out.float_properties, proto.float_properties());
             Copy(out.double_properties, proto.double_properties());
             Copy(out.string_properties, proto.string_properties());
 
@@ -75,11 +76,11 @@ namespace VTX {
                 }
             };
 
-            Unpack(proto.vector_properties(),    out.vector_properties);
-            Unpack(proto.quat_properties(),      out.quat_properties);
+            Unpack(proto.vector_properties(), out.vector_properties);
+            Unpack(proto.quat_properties(), out.quat_properties);
             Unpack(proto.transform_properties(), out.transform_properties);
-            Unpack(proto.range_properties(),     out.range_properties);
-            
+            Unpack(proto.range_properties(), out.range_properties);
+
             if (proto.has_byte_array_properties()) {
                 const auto& proto_bytes = proto.byte_array_properties();
                 auto& native_bytes = out.byte_array_properties;
@@ -96,50 +97,60 @@ namespace VTX {
                     native_bytes.offsets.push_back(o);
                 }
             }
-            
-            if (proto.has_int32_arrays())     FromProtoVec(proto.int32_arrays(),     out.int32_arrays);
-            if (proto.has_int64_arrays())     FromProtoVec(proto.int64_arrays(),     out.int64_arrays);
-            if (proto.has_float_arrays())     FromProtoVec(proto.float_arrays(),     out.float_arrays);
-            if (proto.has_double_arrays())    FromProtoVec(proto.double_arrays(),    out.double_arrays);
-            if (proto.has_bool_arrays())      FromProtoVec(proto.bool_arrays(),      out.bool_arrays);
-            if (proto.has_string_arrays())    FromProtoVec(proto.string_arrays(),    out.string_arrays);
-
-            if (proto.has_vector_arrays())    FromProtoComplexVec(proto.vector_arrays(),    out.vector_arrays,    [](auto& p, auto& n){ FromProto(p, n); });
-            if (proto.has_quat_arrays())      FromProtoComplexVec(proto.quat_arrays(),      out.quat_arrays,      [](auto& p, auto& n){ FromProto(p, n); });
-            if (proto.has_transform_arrays()) FromProtoComplexVec(proto.transform_arrays(), out.transform_arrays, [](auto& p, auto& n){ FromProto(p, n); });
-            if (proto.has_range_arrays())     FromProtoComplexVec(proto.range_arrays(),     out.range_arrays,     [](auto& p, auto& n){ FromProto(p, n); });
+
+            if (proto.has_int32_arrays())
+                FromProtoVec(proto.int32_arrays(), out.int32_arrays);
+            if (proto.has_int64_arrays())
+                FromProtoVec(proto.int64_arrays(), out.int64_arrays);
+            if (proto.has_float_arrays())
+                FromProtoVec(proto.float_arrays(), out.float_arrays);
+            if (proto.has_double_arrays())
+                FromProtoVec(proto.double_arrays(), out.double_arrays);
+            if (proto.has_bool_arrays())
+                FromProtoVec(proto.bool_arrays(), out.bool_arrays);
+            if (proto.has_string_arrays())
+                FromProtoVec(proto.string_arrays(), out.string_arrays);
+
+            if (proto.has_vector_arrays())
+                FromProtoComplexVec(proto.vector_arrays(), out.vector_arrays,
+                                    [](auto& p, auto& n) { FromProto(p, n); });
+            if (proto.has_quat_arrays())
+                FromProtoComplexVec(proto.quat_arrays(), out.quat_arrays, [](auto& p, auto& n) { FromProto(p, n); });
+            if (proto.has_transform_arrays())
+                FromProtoComplexVec(proto.transform_arrays(), out.transform_arrays,
+                                    [](auto& p, auto& n) { FromProto(p, n); });
+            if (proto.has_range_arrays())
+                FromProtoComplexVec(proto.range_arrays(), out.range_arrays, [](auto& p, auto& n) { FromProto(p, n); });
 
             out.any_struct_properties.resize(proto.any_struct_properties_size());
-            for(int i = 0; i < proto.any_struct_properties_size(); ++i) {
+            for (int i = 0; i < proto.any_struct_properties_size(); ++i) {
                 FromProto(proto.any_struct_properties(i), out.any_struct_properties[i]);
             }
 
             if (proto.has_any_struct_arrays()) {
-                FromProtoComplexVec(proto.any_struct_arrays(), out.any_struct_arrays, [](auto& p, auto& n){ FromProto(p, n); });
+                FromProtoComplexVec(proto.any_struct_arrays(), out.any_struct_arrays,
+                                    [](auto& p, auto& n) { FromProto(p, n); });
             }
         }
 
         void FromProto(const cppvtx::Bucket& proto, VTX::Bucket& out) {
             out.unique_ids.clear();
             out.unique_ids.reserve(proto.unique_ids_size());
-            for(const auto& id : proto.unique_ids()) {
+            for (const auto& id : proto.unique_ids()) {
                 out.unique_ids.push_back(id);
             }
-            
+
             out.entities.clear();
-            out.entities.resize(proto.entities_size()); 
-    
+            out.entities.resize(proto.entities_size());
+
             for (int i = 0; i < proto.entities_size(); ++i) {
                 FromProto(proto.entities(i), out.entities[i]);
             }
-            
+
             out.type_ranges.reserve(proto.type_ranges_size());
             for (int i = 0; i < proto.type_ranges_size(); ++i) {
                 const auto& r = proto.type_ranges(i);
-                out.type_ranges.push_back(VTX::EntityRange{
-                    r.start_index(), 
-                    r.count()
-                });
+                out.type_ranges.push_back(VTX::EntityRange {r.start_index(), r.count()});
             }
         }
 
@@ -150,5 +161,5 @@ namespace VTX {
                 FromProto(proto.data(i), buckets[i]);
             }
         }
-    }
-}
\ No newline at end of file
+    } // namespace Serialization
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/src/vtx_writer/src/vtx/writer/core/vtx_record_pipeline.cpp b/sdk/src/vtx_writer/src/vtx/writer/core/vtx_record_pipeline.cpp
index a4abc6e..82bf154 100644
--- a/sdk/src/vtx_writer/src/vtx/writer/core/vtx_record_pipeline.cpp
+++ b/sdk/src/vtx_writer/src/vtx/writer/core/vtx_record_pipeline.cpp
@@ -1,12 +1,12 @@
 #include "vtx/writer/core/vtx_record_pipeline.h"
 
-VTX::RecordPipeline::RecordPipeline(std::unique_ptr<IFrameDataSource> source,std::unique_ptr<IVtxWriterFacade> writer)
-: source_(std::move(source)), writer_(std::move(writer)) 
-{
-}
+VTX::RecordPipeline::RecordPipeline(std::unique_ptr<IFrameDataSource> source, std::unique_ptr<IVtxWriterFacade> writer)
+    : source_(std::move(source))
+    , writer_(std::move(writer)) {}
 
-bool VTX::RecordPipeline::Run(std::function<void(float, std::string)> on_progress ) {
-    if (!source_ || !writer_) return false;
+bool VTX::RecordPipeline::Run(std::function<void(float, std::string)> on_progress) {
+    if (!source_ || !writer_)
+        return false;
 
     if (!source_->Initialize()) {
         return false;
@@ -21,7 +21,6 @@ bool VTX::RecordPipeline::Run(std::function<void(float, std::string)> on_progres
 
 
     while (source_->GetNextFrame(native_frame, time_register)) {
-        
         writer_->RecordFrame(native_frame, time_register);
         frames_processed++;
 
@@ -43,6 +42,7 @@ bool VTX::RecordPipeline::Run(std::function<void(float, std::string)> on_progres
     }
 
     writer_->Stop();
-    if (on_progress) on_progress(1.0f,"");
+    if (on_progress)
+        on_progress(1.0f, "");
     return frames_processed > 0;
 }
diff --git a/sdk/src/vtx_writer/src/vtx/writer/core/vtx_writer_facade.cpp b/sdk/src/vtx_writer/src/vtx/writer/core/vtx_writer_facade.cpp
index 3597cbc..f04fe3d 100644
--- a/sdk/src/vtx_writer/src/vtx/writer/core/vtx_writer_facade.cpp
+++ b/sdk/src/vtx_writer/src/vtx/writer/core/vtx_writer_facade.cpp
@@ -14,63 +14,57 @@ namespace VTX {
     class WriterFacadeImpl : public IVtxWriterFacade {
     public:
         WriterFacadeImpl(typename ReplayWriter<SinkPolicyType>::Config internal_config)
-            : writer_(internal_config)
-        {
-        }
+            : writer_(internal_config) {}
 
         // RecordFrame / Flush / Stop are no-ops after the first Stop().  The
         // on-disk file was finalised (header + chunks + footer) there, and
         // letting further writes through would rewrite/corrupt the footer.
         void RecordFrame(VTX::Frame& native_frame, const VTX::GameTime::GameTimeRegister& game_time_register) override {
-            if (stopped_) return;
+            if (stopped_)
+                return;
             writer_.RecordFrame(native_frame, game_time_register);
         }
 
         void Flush() override {
-            if (stopped_) return;
+            if (stopped_)
+                return;
             writer_.Flush();
         }
 
         void Stop() override {
-            if (stopped_) return;          // idempotent: second Stop() is a no-op
+            if (stopped_)
+                return; // idempotent: second Stop() is a no-op
             writer_.Stop();
             stopped_ = true;
         }
 
-        VTX::SchemaRegistry& GetSchema()override
-        {
-            return writer_.GetRegistry();
-        }
+        VTX::SchemaRegistry& GetSchema() override { return writer_.GetRegistry(); }
 
     private:
         ReplayWriter<SinkPolicyType> writer_;
         bool stopped_ = false;
     };
-    
-    
-    std::unique_ptr<IVtxWriterFacade> CreateFlatBuffersWriterFacade(
-        const WriterFacadeConfig& config) 
-    {
+
+
+    std::unique_ptr<IVtxWriterFacade> CreateFlatBuffersWriterFacade(const WriterFacadeConfig& config) {
         using SinkType = ChunkedFileSink<VTX::FlatBuffersVtxPolicy>;
-        
+
         ReplayWriter<SinkType>::Config internal_cfg;
         internal_cfg.default_fps = config.default_fps;
         internal_cfg.is_increasing = config.is_increasing;
         internal_cfg.chunker_config.max_frames = config.chunk_max_frames;
         internal_cfg.chunker_config.max_bytes = config.chunk_max_bytes;
-        
+
         internal_cfg.sink_config.filename = config.output_filepath;
         internal_cfg.schema_json_path = config.schema_json_path;
-         internal_cfg.sink_config.header_config.replay_name = config.replay_name;
+        internal_cfg.sink_config.header_config.replay_name = config.replay_name;
         internal_cfg.sink_config.header_config.replay_uuid = config.replay_uuid;
         internal_cfg.sink_config.b_use_compression = config.use_compression;
 
         return std::make_unique<WriterFacadeImpl<SinkType>>(internal_cfg);
     }
 
-    std::unique_ptr<IVtxWriterFacade> CreateProtobuffWriterFacade(
-        const WriterFacadeConfig& config) 
-    {
+    std::unique_ptr<IVtxWriterFacade> CreateProtobuffWriterFacade(const WriterFacadeConfig& config) {
         using SinkType = VTX::ChunkedFileSink<VTX::ProtobufVtxPolicy>;
 
         ReplayWriter<SinkType>::Config internal_cfg;
@@ -80,11 +74,11 @@ namespace VTX {
         internal_cfg.is_increasing = config.is_increasing;
         internal_cfg.chunker_config.max_frames = config.chunk_max_frames;
         internal_cfg.chunker_config.max_bytes = config.chunk_max_bytes;
-        
+
         internal_cfg.sink_config.filename = config.output_filepath;
         internal_cfg.schema_json_path = config.schema_json_path;
 
         internal_cfg.sink_config.b_use_compression = config.use_compression;
         return std::make_unique<WriterFacadeImpl<SinkType>>(internal_cfg);
     }
-}
\ No newline at end of file
+} // namespace VTX
\ No newline at end of file
diff --git a/sdk/src/vtx_writer/src/vtx/writer/formatters/flatbuffers_vtx_policy.cpp b/sdk/src/vtx_writer/src/vtx/writer/formatters/flatbuffers_vtx_policy.cpp
index a378c52..ddf103c 100644
--- a/sdk/src/vtx_writer/src/vtx/writer/formatters/flatbuffers_vtx_policy.cpp
+++ b/sdk/src/vtx_writer/src/vtx/writer/formatters/flatbuffers_vtx_policy.cpp
@@ -9,14 +9,15 @@
 #include "vtx/writer/policies/formatters/flatbuffers_vtx_policy.h"
 
 std::string VTX::FlatBuffersVtxPolicy::GetMagicBytes() {
-    return "VTXF"; 
+    return "VTXF";
 }
 
 std::unique_ptr<VTX::FlatBuffersVtxPolicy::FrameType> VTX::FlatBuffersVtxPolicy::FromNative(VTX::Frame&& native) {
     auto sorted_frame = std::make_unique<VTX::Frame>();
-    
+
     const auto& native_buckets = native.GetBuckets();
-    if (native_buckets.empty()) return sorted_frame;
+    if (native_buckets.empty())
+        return sorted_frame;
 
     const auto& native_data = native_buckets[0];
     auto& sorted_data = sorted_frame->GetBucket("data");
@@ -33,7 +34,7 @@ std::unique_ptr<VTX::FlatBuffersVtxPolicy::FrameType> VTX::FlatBuffersVtxPolicy:
     for (const auto& ent : entities) {
         max_type = std::max(ent.entity_type_id, max_type);
     }
-    
+
     if (max_type < 0) {
         sorted_data = native_data;
         return sorted_frame;
@@ -55,7 +56,7 @@ std::unique_ptr<VTX::FlatBuffersVtxPolicy::FrameType> VTX::FlatBuffersVtxPolicy:
 
     for (int32_t type_id = 0; type_id <= max_type; ++type_id) {
         const auto& indices = indices_by_type[type_id];
-        
+
         sorted_data.type_ranges[type_id].start_index = current_index;
         sorted_data.type_ranges[type_id].count = static_cast<int32_t>(indices.size());
 
@@ -72,13 +73,13 @@ std::unique_ptr<VTX::FlatBuffersVtxPolicy::FrameType> VTX::FlatBuffersVtxPolicy:
         auto& sorted_bones = sorted_frame->GetBucket("bone_data");
         sorted_bones = native_buckets[1];
     }
-    
+
     return sorted_frame;
 }
 
 size_t VTX::FlatBuffersVtxPolicy::GetFrameSize(const FrameType& /*frame*/) {
     // FlatBuffers doesnt know the size until is serialized
-    return 0; 
+    return 0;
 }
 
 VTX::FlatBuffersVtxPolicy::SchemaType VTX::FlatBuffersVtxPolicy::CreateSchema(const SchemaRegistry& registry) {
@@ -95,100 +96,83 @@ VTX::FlatBuffersVtxPolicy::SchemaType VTX::FlatBuffersVtxPolicy::CreateSchema(co
 
 std::string VTX::FlatBuffersVtxPolicy::SerializeHeader(const VTX::SessionConfig& config, const SchemaType& schema) {
     flatbuffers::FlatBufferBuilder builder(1024);
-    
+
     auto replay_name = builder.CreateString(config.replay_name);
-    auto uuid       = builder.CreateString(config.replay_uuid.empty() ? "uuid_placeholder" : config.replay_uuid);
-    auto meta       = builder.CreateString(config.custom_json_metadata);
-    
-    auto release    = builder.CreateString("1.0.0"); 
-    auto hash       = builder.CreateString("UNKNOWN_HASH");
+    auto uuid = builder.CreateString(config.replay_uuid.empty() ? "uuid_placeholder" : config.replay_uuid);
+    auto meta = builder.CreateString(config.custom_json_metadata);
+
+    auto release = builder.CreateString("1.0.0");
+    auto hash = builder.CreateString("UNKNOWN_HASH");
 
-    auto version = fbsvtx::CreateVersionInfo(builder, 
-        1, 0, // Major, Minor
-        config.schema_version);
+    auto version = fbsvtx::CreateVersionInfo(builder, 1, 0, // Major, Minor
+                                             config.schema_version);
 
     auto now = std::chrono::system_clock::now();
     int64_t timestamp = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
-    
+
     auto schema_off = fbsvtx::ContextualSchema::Pack(builder, schema.get());
-    
-    auto header_off = fbsvtx::CreateFileHeader(builder,
-        version, 
-        schema_off, 
-        uuid, 
-        replay_name, 
-        timestamp,
-        meta);
+
+    auto header_off = fbsvtx::CreateFileHeader(builder, version, schema_off, uuid, replay_name, timestamp, meta);
 
     builder.Finish(header_off);
     return {reinterpret_cast<const char*>(builder.GetBufferPointer()), builder.GetSize()};
 }
 
 
-std::string VTX::FlatBuffersVtxPolicy::SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames, int32_t chunk_idx, bool is_compressed) {
-    if (frames.empty()) return "";
+std::string VTX::FlatBuffersVtxPolicy::SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames,
+                                                      int32_t chunk_idx, bool is_compressed) {
+    if (frames.empty())
+        return "";
 
-    flatbuffers::FlatBufferBuilder builder(1024 * 1024); 
+    flatbuffers::FlatBufferBuilder builder(1024 * 1024);
 
     std::vector<flatbuffers::Offset<fbsvtx::Frame>> frame_offsets;
     frame_offsets.reserve(frames.size());
 
-    for(const auto& f : frames) {
-        if(f) {
+    for (const auto& f : frames) {
+        if (f) {
             frame_offsets.push_back(VTX::Serialization::ToFlat(builder, *f));
         }
     }
     auto frames_vector = builder.CreateVector(frame_offsets);
-    
-    auto chunk_off = fbsvtx::CreateChunk(builder, 
-        chunk_idx, 
-        is_compressed,
-        0,
-        frames_vector, 
-        0
-    );
+
+    auto chunk_off = fbsvtx::CreateChunk(builder, chunk_idx, is_compressed, 0, frames_vector, 0);
 
     builder.Finish(chunk_off);
     return {reinterpret_cast<const char*>(builder.GetBufferPointer()), builder.GetSize()};
 }
 
 
-std::string VTX::FlatBuffersVtxPolicy::SerializeFooter(const std::vector<ChunkIndexData>& seek_table, const SessionFooter& footer_data) {
+std::string VTX::FlatBuffersVtxPolicy::SerializeFooter(const std::vector<ChunkIndexData>& seek_table,
+                                                       const SessionFooter& footer_data) {
     flatbuffers::FlatBufferBuilder builder(2048);
 
     flatbuffers::Offset<fbsvtx::ReplayTimeData> time_data_offsets = 0;
-    
-    if(footer_data.game_times || footer_data.created_utc || footer_data.gaps || footer_data.segments) {
-        auto gt   = (footer_data.game_times)  ? builder.CreateVector(*footer_data.game_times)  : 0;
-        auto cu   = (footer_data.created_utc) ? builder.CreateVector(*footer_data.created_utc) : 0;
-        auto gaps = (footer_data.gaps)        ? builder.CreateVector(*footer_data.gaps)        : 0;
-        auto segs = (footer_data.segments)    ? builder.CreateVector(*footer_data.segments)    : 0;
-        
+
+    if (footer_data.game_times || footer_data.created_utc || footer_data.gaps || footer_data.segments) {
+        auto gt = (footer_data.game_times) ? builder.CreateVector(*footer_data.game_times) : 0;
+        auto cu = (footer_data.created_utc) ? builder.CreateVector(*footer_data.created_utc) : 0;
+        auto gaps = (footer_data.gaps) ? builder.CreateVector(*footer_data.gaps) : 0;
+        auto segs = (footer_data.segments) ? builder.CreateVector(*footer_data.segments) : 0;
+
         time_data_offsets = fbsvtx::CreateReplayTimeData(builder, gt, cu, gaps, segs);
     }
 
     std::vector<flatbuffers::Offset<fbsvtx::ChunkIndexEntry>> index_offsets;
     index_offsets.reserve(seek_table.size());
-    
-    for(const auto& e : seek_table) {
-        index_offsets.push_back(fbsvtx::CreateChunkIndexEntry(builder, 
-            e.chunk_index, 
-            e.start_frame, 
-            e.end_frame, 
-            static_cast<uint64_t>(e.file_offset), 
-            e.chunk_size_bytes));
+
+    for (const auto& e : seek_table) {
+        index_offsets.push_back(fbsvtx::CreateChunkIndexEntry(builder, e.chunk_index, e.start_frame, e.end_frame,
+                                                              static_cast<uint64_t>(e.file_offset),
+                                                              e.chunk_size_bytes));
     }
     auto index_vector = builder.CreateVector(index_offsets);
 
-    auto events_vec = builder.CreateVector(std::vector<flatbuffers::Offset<fbsvtx::TimelineEvent>>{});
+    auto events_vec = builder.CreateVector(std::vector<flatbuffers::Offset<fbsvtx::TimelineEvent>> {});
 
-    auto footer_offset = fbsvtx::CreateFileFooter(builder, 
-        footer_data.total_frames, 
-        static_cast<float>(footer_data.duration_seconds), 
-        time_data_offsets, 
-        index_vector, 
-        events_vec, 
-        0);
+    auto footer_offset =
+        fbsvtx::CreateFileFooter(builder, footer_data.total_frames, static_cast<float>(footer_data.duration_seconds),
+                                 time_data_offsets, index_vector, events_vec, 0);
 
     builder.Finish(footer_offset);
     return {reinterpret_cast<const char*>(builder.GetBufferPointer()), builder.GetSize()};
diff --git a/sdk/src/vtx_writer/src/vtx/writer/formatters/protobuff_vtx_policy.cpp b/sdk/src/vtx_writer/src/vtx/writer/formatters/protobuff_vtx_policy.cpp
index 9d45bae..50fe6d3 100644
--- a/sdk/src/vtx_writer/src/vtx/writer/formatters/protobuff_vtx_policy.cpp
+++ b/sdk/src/vtx_writer/src/vtx/writer/formatters/protobuff_vtx_policy.cpp
@@ -5,20 +5,19 @@
 #include "vtx_schema.pb.h"
 
 std::string VTX::ProtobufVtxPolicy::GetMagicBytes() {
-    return "VTXP"; 
+    return "VTXP";
 }
 
 std::unique_ptr<VTX::ProtobufVtxPolicy::FrameType> VTX::ProtobufVtxPolicy::FromNative(VTX::Frame&& native) {
     const auto& native_buckets = native.GetBuckets();
     VTX::Frame sorted_native;
     sorted_native.GetMutableBuckets().resize(native_buckets.size());
-    
+
     for (size_t b_idx = 0; b_idx < native_buckets.size(); ++b_idx) {
         const auto& src_bucket = native_buckets[b_idx];
         auto& dst_bucket = sorted_native.GetBucket(static_cast<int>(b_idx));
 
-        if (b_idx == 0 && !src_bucket.entities.empty())
-        {
+        if (b_idx == 0 && !src_bucket.entities.empty()) {
             const auto& entities = src_bucket.entities;
             const auto& ids = src_bucket.unique_ids;
             int32_t max_type = -1;
@@ -57,24 +56,21 @@ std::unique_ptr<VTX::ProtobufVtxPolicy::FrameType> VTX::ProtobufVtxPolicy::FromN
             } else {
                 dst_bucket = src_bucket;
             }
-        }
-        else
-        {
+        } else {
             dst_bucket = src_bucket;
         }
     }
-        
+
     auto proto = std::make_unique<cppvtx::Frame>();
     VTX::Serialization::ToProto(sorted_native, proto.get());
     return proto;
 }
-        
+
 size_t VTX::ProtobufVtxPolicy::GetFrameSize(const VTX::ProtobufVtxPolicy::FrameType& frame) {
     return frame.ByteSizeLong();
 }
 
 VTX::ProtobufVtxPolicy::SchemaType VTX::ProtobufVtxPolicy::CreateSchema(const SchemaRegistry& registry) {
-    
     SchemaType proto_schema;
     proto_schema.set_data_indentifier("VTX_GameData"); // Default VTX data format identifier
     proto_schema.set_data_version(1);
@@ -89,15 +85,15 @@ std::string VTX::ProtobufVtxPolicy::SerializeHeader(const VTX::SessionConfig& co
     proto_header.set_replay_name(config.replay_name);
     proto_header.set_replay_uuid(config.replay_uuid.empty() ? "uuid_placeholder" : config.replay_uuid);
     proto_header.set_custom_json_metadata(config.custom_json_metadata);
-    
+
     auto* v = proto_header.mutable_version();
-    v->set_format_major(1); v->set_format_minor(0);
+    v->set_format_major(1);
+    v->set_format_minor(0);
     v->set_schema_version(config.schema_version);
 
     auto now = std::chrono::system_clock::now();
     proto_header.set_recorded_utc_timestamp(
-        std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count()
-    );
+        std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count());
 
     proto_header.mutable_prop_schema()->CopyFrom(schema);
 
@@ -106,15 +102,17 @@ std::string VTX::ProtobufVtxPolicy::SerializeHeader(const VTX::SessionConfig& co
     return payload;
 }
 
-std::string VTX::ProtobufVtxPolicy::SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames, int32_t chunkIdx, bool is_compressed) {
-    if (frames.empty()) return "";
+std::string VTX::ProtobufVtxPolicy::SerializeChunk(const std::vector<std::unique_ptr<FrameType>>& frames,
+                                                   int32_t chunkIdx, bool is_compressed) {
+    if (frames.empty())
+        return "";
 
     cppvtx::FrameChunk chunk_msg;
     chunk_msg.set_chunk_index(chunkIdx);
-    chunk_msg.set_is_compressed(is_compressed); 
-    
+    chunk_msg.set_is_compressed(is_compressed);
+
     for (const auto& frame_ptr : frames) {
-        if(frame_ptr) {
+        if (frame_ptr) {
             chunk_msg.add_frames()->Swap(frame_ptr.get());
         }
     }
@@ -124,19 +122,17 @@ std::string VTX::ProtobufVtxPolicy::SerializeChunk(const std::vector<std::unique
         throw std::runtime_error("VTX [ProtobufPolicy]: Error serializing Chunk.");
     }
 
-    return uncompressed_payload; 
+    return uncompressed_payload;
 }
 
-std::string VTX::ProtobufVtxPolicy::SerializeFooter(const std::vector<ChunkIndexData>& seekTable, 
-                                   const SessionFooter& footerData) 
-{
+std::string VTX::ProtobufVtxPolicy::SerializeFooter(const std::vector<ChunkIndexData>& seekTable,
+                                                    const SessionFooter& footerData) {
     cppvtx::FileFooter footer_msg;
-    
+
     footer_msg.set_total_frames(footerData.total_frames);
     footer_msg.set_duration_seconds(static_cast<float>(footerData.duration_seconds));
-    
-   if (footerData.game_times || footerData.created_utc || footerData.gaps || footerData.segments) {
-        
+
+    if (footerData.game_times || footerData.created_utc || footerData.gaps || footerData.segments) {
         auto* times_msg = footer_msg.mutable_times();
 
         if (footerData.game_times && !footerData.game_times->empty()) {
@@ -171,9 +167,9 @@ std::string VTX::ProtobufVtxPolicy::SerializeFooter(const std::vector<ChunkIndex
             }
         }
     }
-    
+
     footer_msg.mutable_chunk_index()->Reserve(static_cast<int>(seekTable.size()));
-    
+
     for (const auto& entry : seekTable) {
         auto* proto_entry = footer_msg.add_chunk_index();
         proto_entry->set_chunk_index(entry.chunk_index);
@@ -185,8 +181,8 @@ std::string VTX::ProtobufVtxPolicy::SerializeFooter(const std::vector<ChunkIndex
 
     std::string payload;
     if (!footer_msg.SerializeToString(&payload)) {
-         throw std::runtime_error("VTX [ProtobufPolicy]: Failed to serialize Footer.");
+        throw std::runtime_error("VTX [ProtobufPolicy]: Failed to serialize Footer.");
     }
-    
+
     return payload;
 }
diff --git a/sdk/src/vtx_writer/src/vtx/writer/serialization/vtx_to_flatbuffer.cpp b/sdk/src/vtx_writer/src/vtx/writer/serialization/vtx_to_flatbuffer.cpp
index abebb2c..7d14472 100644
--- a/sdk/src/vtx_writer/src/vtx/writer/serialization/vtx_to_flatbuffer.cpp
+++ b/sdk/src/vtx_writer/src/vtx/writer/serialization/vtx_to_flatbuffer.cpp
@@ -5,28 +5,29 @@
 
 #include "vtx/common/vtx_types_helpers.h"
 
-namespace VTX
-{
-    namespace Serialization
-    {
+namespace VTX {
+    namespace Serialization {
         template <typename T, typename CreateFunc>
-        auto CreateScalarArray(flatbuffers::FlatBufferBuilder& builder, const std::vector<T>& data, const std::vector<uint32_t>& offsets, CreateFunc func) 
-        {
-            if (data.empty()) return decltype(func(builder, 0, 0))(0);
-        
+        auto CreateScalarArray(flatbuffers::FlatBufferBuilder& builder, const std::vector<T>& data,
+                               const std::vector<uint32_t>& offsets, CreateFunc func) {
+            if (data.empty())
+                return decltype(func(builder, 0, 0))(0);
+
             auto data_vec = builder.CreateVector(data);
             auto offs_vec = builder.CreateVector(offsets);
             return func(builder, data_vec, offs_vec);
         }
 
         template <typename NativeT, typename FbsT, typename CreateFunc>
-        auto CreateStructArray(flatbuffers::FlatBufferBuilder& builder, std::vector<NativeT>& data, const std::vector<uint32_t>& offsets, CreateFunc func) 
-        {
-            if (data.empty()) return decltype(func(builder, 0, 0))(0);
+        auto CreateStructArray(flatbuffers::FlatBufferBuilder& builder, std::vector<NativeT>& data,
+                               const std::vector<uint32_t>& offsets, CreateFunc func) {
+            if (data.empty())
+                return decltype(func(builder, 0, 0))(0);
 
-            std::vector<FbsT> temp; 
+            std::vector<FbsT> temp;
             temp.reserve(data.size());
-            for(auto& x : data) temp.push_back(ToFlat(x)); 
+            for (auto& x : data)
+                temp.push_back(ToFlat(x));
 
             auto data_vec = builder.CreateVectorOfStructs(temp);
             auto offs_vec = builder.CreateVector(offsets);
@@ -34,13 +35,15 @@ namespace VTX
         }
 
         template <typename CreateFunc>
-        static auto CreateStringArray(flatbuffers::FlatBufferBuilder& builder, const std::vector<std::string>& data, const std::vector<uint32_t>& offsets, CreateFunc func) 
-        {
-            if (data.empty()) return decltype(func(builder, 0, 0))(0);
+        static auto CreateStringArray(flatbuffers::FlatBufferBuilder& builder, const std::vector<std::string>& data,
+                                      const std::vector<uint32_t>& offsets, CreateFunc func) {
+            if (data.empty())
+                return decltype(func(builder, 0, 0))(0);
 
             std::vector<flatbuffers::Offset<flatbuffers::String>> str_offsets;
             str_offsets.reserve(data.size());
-            for(const auto& s : data) str_offsets.push_back(builder.CreateString(s));
+            for (const auto& s : data)
+                str_offsets.push_back(builder.CreateString(s));
 
             auto data_vec = builder.CreateVector(str_offsets);
             auto offs_vec = builder.CreateVector(offsets);
@@ -48,17 +51,18 @@ namespace VTX
         }
 
         template <typename CreateFunc>
-        static auto CreateBoolFromBitArray(flatbuffers::FlatBufferBuilder& builder, const std::vector<bool>& data, const std::vector<uint32_t>& offsets, CreateFunc func) 
-        {
-            if (data.empty()) return decltype(func(builder, 0, 0))(0);
-        
+        static auto CreateBoolFromBitArray(flatbuffers::FlatBufferBuilder& builder, const std::vector<bool>& data,
+                                           const std::vector<uint32_t>& offsets, CreateFunc func) {
+            if (data.empty())
+                return decltype(func(builder, 0, 0))(0);
+
             std::vector<uint8_t> temp_bool(data.begin(), data.end());
             auto dataVec = builder.CreateVector(temp_bool);
             auto offsVec = builder.CreateVector(offsets);
             return func(builder, dataVec, offsVec);
         }
-    }
-};
+    } // namespace Serialization
+};    // namespace VTX
 // =========================================================================
 // IMPLEMENTACIÓN DE LA API (Sin inlines)
 // =========================================================================
@@ -79,29 +83,33 @@ fbsvtx::FloatRange VTX::Serialization::ToFlat(VTX::FloatRange& r) {
     return {r.min, r.max, r.value_normalized};
 }
 
-flatbuffers::Offset<fbsvtx::MapContainer> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::MapContainer& src) {
-    if (src.keys.empty()) return 0;
-    
+flatbuffers::Offset<fbsvtx::MapContainer> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder,
+                                                                     VTX::MapContainer& src) {
+    if (src.keys.empty())
+        return 0;
+
     std::vector<flatbuffers::Offset<flatbuffers::String>> k;
     k.reserve(src.keys.size());
-    for(const auto& s : src.keys) k.push_back(builder.CreateString(s));
-    
+    for (const auto& s : src.keys)
+        k.push_back(builder.CreateString(s));
+
     std::vector<flatbuffers::Offset<fbsvtx::PropertyContainer>> v;
     v.reserve(src.values.size());
-    for(auto& p : src.values) v.push_back(ToFlat(builder, p)); 
+    for (auto& p : src.values)
+        v.push_back(ToFlat(builder, p));
 
     return fbsvtx::CreateMapContainer(builder, builder.CreateVector(k), builder.CreateVector(v));
 }
 
-flatbuffers::Offset<fbsvtx::PropertyContainer> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::PropertyContainer& src) {
-    
+flatbuffers::Offset<fbsvtx::PropertyContainer> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder,
+                                                                          VTX::PropertyContainer& src) {
     src.content_hash = VTX::Helpers::CalculateContainerHash(src);
     // --- SCALARS ---
-    auto int32Off   = src.int32_properties.empty() ? 0 : builder.CreateVector(src.int32_properties);
-    auto int64Off   = src.int64_properties.empty() ? 0 : builder.CreateVector(src.int64_properties);
-    auto floatOff   = src.float_properties.empty() ? 0 : builder.CreateVector(src.float_properties);
-    auto doubleOff  = src.double_properties.empty() ? 0 : builder.CreateVector(src.double_properties);
-    
+    auto int32Off = src.int32_properties.empty() ? 0 : builder.CreateVector(src.int32_properties);
+    auto int64Off = src.int64_properties.empty() ? 0 : builder.CreateVector(src.int64_properties);
+    auto floatOff = src.float_properties.empty() ? 0 : builder.CreateVector(src.float_properties);
+    auto doubleOff = src.double_properties.empty() ? 0 : builder.CreateVector(src.double_properties);
+
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> boolOff = 0;
     if (!src.bool_properties.empty()) {
         std::vector<uint8_t> temp(src.bool_properties.begin(), src.bool_properties.end());
@@ -111,164 +119,209 @@ flatbuffers::Offset<fbsvtx::PropertyContainer> VTX::Serialization::ToFlat(flatbu
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> stringOff = 0;
     if (!src.string_properties.empty()) {
         std::vector<flatbuffers::Offset<flatbuffers::String>> strs;
-        for(const auto& s : src.string_properties) strs.push_back(builder.CreateString(s));
+        for (const auto& s : src.string_properties)
+            strs.push_back(builder.CreateString(s));
         stringOff = builder.CreateVector(strs);
     }
 
     // --- MATH PROPS ---
     flatbuffers::Offset<flatbuffers::Vector<const fbsvtx::Vector*>> vecPropOff = 0;
-    if(!src.vector_properties.empty()){
-        std::vector<fbsvtx::Vector> temp; temp.reserve(src.vector_properties.size());
-        for(auto& v : src.vector_properties) temp.push_back(ToFlat(v));
+    if (!src.vector_properties.empty()) {
+        std::vector<fbsvtx::Vector> temp;
+        temp.reserve(src.vector_properties.size());
+        for (auto& v : src.vector_properties)
+            temp.push_back(ToFlat(v));
         vecPropOff = builder.CreateVectorOfStructs(temp);
     }
-    
+
     flatbuffers::Offset<flatbuffers::Vector<const fbsvtx::Quat*>> quatPropOff = 0;
-    if(!src.quat_properties.empty()){
-        std::vector<fbsvtx::Quat> temp; temp.reserve(src.quat_properties.size());
-        for(auto& v : src.quat_properties) temp.push_back(ToFlat(v));
+    if (!src.quat_properties.empty()) {
+        std::vector<fbsvtx::Quat> temp;
+        temp.reserve(src.quat_properties.size());
+        for (auto& v : src.quat_properties)
+            temp.push_back(ToFlat(v));
         quatPropOff = builder.CreateVectorOfStructs(temp);
     }
 
     flatbuffers::Offset<flatbuffers::Vector<const fbsvtx::Transform*>> transPropOff = 0;
-    if(!src.transform_properties.empty()){
-        std::vector<fbsvtx::Transform> temp; temp.reserve(src.transform_properties.size());
-        for(auto& v : src.transform_properties) temp.push_back(ToFlat(v));
+    if (!src.transform_properties.empty()) {
+        std::vector<fbsvtx::Transform> temp;
+        temp.reserve(src.transform_properties.size());
+        for (auto& v : src.transform_properties)
+            temp.push_back(ToFlat(v));
         transPropOff = builder.CreateVectorOfStructs(temp);
     }
 
     flatbuffers::Offset<flatbuffers::Vector<const fbsvtx::FloatRange*>> rangePropOff = 0;
-    if(!src.range_properties.empty()){
-        std::vector<fbsvtx::FloatRange> temp; temp.reserve(src.range_properties.size());
-        for(auto& v : src.range_properties) temp.push_back(ToFlat(v));
+    if (!src.range_properties.empty()) {
+        std::vector<fbsvtx::FloatRange> temp;
+        temp.reserve(src.range_properties.size());
+        for (auto& v : src.range_properties)
+            temp.push_back(ToFlat(v));
         rangePropOff = builder.CreateVectorOfStructs(temp);
     }
 
     // --- FLAT ARRAYS (SoA) ---
-    auto flatBytes = CreateScalarArray(builder, src.byte_array_properties.data, src.byte_array_properties.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatBytesArray(b, d, o); });
+    auto flatBytes = CreateScalarArray(builder, src.byte_array_properties.data, src.byte_array_properties.offsets,
+                                       [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatBytesArray(b, d, o); });
 
-    auto flatInt32 = CreateScalarArray(builder, src.int32_arrays.data, src.int32_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatIntArray(b, d, o); });
+    auto flatInt32 = CreateScalarArray(builder, src.int32_arrays.data, src.int32_arrays.offsets,
+                                       [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatIntArray(b, d, o); });
 
-    auto flatInt64 = CreateScalarArray(builder, src.int64_arrays.data, src.int64_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatInt64Array(b, d, o); });
+    auto flatInt64 = CreateScalarArray(builder, src.int64_arrays.data, src.int64_arrays.offsets,
+                                       [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatInt64Array(b, d, o); });
 
-    auto flatFloat = CreateScalarArray(builder, src.float_arrays.data, src.float_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatFloatArray(b, d, o); });
+    auto flatFloat = CreateScalarArray(builder, src.float_arrays.data, src.float_arrays.offsets,
+                                       [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatFloatArray(b, d, o); });
 
-    auto flatDouble = CreateScalarArray(builder, src.double_arrays.data, src.double_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatDoubleArray(b, d, o); });
-    
-    auto flatString = CreateStringArray(builder, src.string_arrays.data, src.string_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatStringArray(b, d, o); });
-    
-    auto flatBool = CreateScalarArray(builder, src.bool_arrays.data, src.bool_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatBoolArray(b, d, o); });
+    auto flatDouble = CreateScalarArray(builder, src.double_arrays.data, src.double_arrays.offsets,
+                                        [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatDoubleArray(b, d, o); });
+
+    auto flatString = CreateStringArray(builder, src.string_arrays.data, src.string_arrays.offsets,
+                                        [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatStringArray(b, d, o); });
+
+    auto flatBool = CreateScalarArray(builder, src.bool_arrays.data, src.bool_arrays.offsets,
+                                      [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatBoolArray(b, d, o); });
 
     // Struct Arrays
-    auto flatVec = CreateStructArray<VTX::Vector, fbsvtx::Vector>(builder, src.vector_arrays.data, src.vector_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatVectorArray(b, d, o); });
+    auto flatVec = CreateStructArray<VTX::Vector, fbsvtx::Vector>(
+        builder, src.vector_arrays.data, src.vector_arrays.offsets,
+        [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatVectorArray(b, d, o); });
 
-    auto flatQuat = CreateStructArray<VTX::Quat, fbsvtx::Quat>(builder, src.quat_arrays.data, src.quat_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatQuatArray(b, d, o); });
+    auto flatQuat = CreateStructArray<VTX::Quat, fbsvtx::Quat>(
+        builder, src.quat_arrays.data, src.quat_arrays.offsets,
+        [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatQuatArray(b, d, o); });
 
-    auto flatTrans = CreateStructArray<VTX::Transform, fbsvtx::Transform>(builder, src.transform_arrays.data, src.transform_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatTransformArray(b, d, o); });
+    auto flatTrans = CreateStructArray<VTX::Transform, fbsvtx::Transform>(
+        builder, src.transform_arrays.data, src.transform_arrays.offsets,
+        [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatTransformArray(b, d, o); });
 
-    auto flatRange = CreateStructArray<VTX::FloatRange, fbsvtx::FloatRange>(builder, src.range_arrays.data, src.range_arrays.offsets, 
-        [](auto& b, auto d, auto o){ return fbsvtx::CreateFlatRangeArray(b, d, o); });
+    auto flatRange = CreateStructArray<VTX::FloatRange, fbsvtx::FloatRange>(
+        builder, src.range_arrays.data, src.range_arrays.offsets,
+        [](auto& b, auto d, auto o) { return fbsvtx::CreateFlatRangeArray(b, d, o); });
 
     // --- RECURSIVE ---
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbsvtx::PropertyContainer>>> anyStructOff = 0;
     if (!src.any_struct_properties.empty()) {
         std::vector<flatbuffers::Offset<fbsvtx::PropertyContainer>> offs;
-        for (auto& child : src.any_struct_properties) offs.push_back(ToFlat(builder, child));
+        for (auto& child : src.any_struct_properties)
+            offs.push_back(ToFlat(builder, child));
         anyStructOff = builder.CreateVector(offs);
     }
 
     flatbuffers::Offset<fbsvtx::FlatPropertyContainerArray> anyStructArrOff = 0;
-    if(!src.any_struct_arrays.data.empty()) {
+    if (!src.any_struct_arrays.data.empty()) {
         std::vector<flatbuffers::Offset<fbsvtx::PropertyContainer>> d;
-        for(auto& item : src.any_struct_arrays.data) d.push_back(ToFlat(builder, item));
-        
-        anyStructArrOff = fbsvtx::CreateFlatPropertyContainerArray(
-            builder, builder.CreateVector(d), builder.CreateVector(src.any_struct_arrays.offsets));
+        for (auto& item : src.any_struct_arrays.data)
+            d.push_back(ToFlat(builder, item));
+
+        anyStructArrOff = fbsvtx::CreateFlatPropertyContainerArray(builder, builder.CreateVector(d),
+                                                                   builder.CreateVector(src.any_struct_arrays.offsets));
     }
 
     // --- MAPS ---
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbsvtx::MapContainer>>> mapPropOff = 0;
-    if(!src.map_properties.empty()) {
+    if (!src.map_properties.empty()) {
         std::vector<flatbuffers::Offset<fbsvtx::MapContainer>> m;
-        for(auto& item : src.map_properties) m.push_back(ToFlat(builder, item));
+        for (auto& item : src.map_properties)
+            m.push_back(ToFlat(builder, item));
         mapPropOff = builder.CreateVector(m);
     }
 
     flatbuffers::Offset<fbsvtx::FlatMapArray> mapArrOff = 0;
-    if(!src.map_arrays.data.empty()) {
+    if (!src.map_arrays.data.empty()) {
         std::vector<flatbuffers::Offset<fbsvtx::MapContainer>> d;
-        for(auto& item : src.map_arrays.data) d.push_back(ToFlat(builder, item));
-        mapArrOff = fbsvtx::CreateFlatMapArray(
-            builder, builder.CreateVector(d), builder.CreateVector(src.map_arrays.offsets));
+        for (auto& item : src.map_arrays.data)
+            d.push_back(ToFlat(builder, item));
+        mapArrOff =
+            fbsvtx::CreateFlatMapArray(builder, builder.CreateVector(d), builder.CreateVector(src.map_arrays.offsets));
     }
 
     // --- FINAL BUILD ---
     fbsvtx::PropertyContainerBuilder containerBuilder(builder);
-    
+
     containerBuilder.add_type_id(src.entity_type_id);
     containerBuilder.add_content_hash(src.content_hash);
-    
-    if(!boolOff.IsNull())   containerBuilder.add_bool_properties(boolOff);
-    if(!int32Off.IsNull())  containerBuilder.add_int32_properties(int32Off);
-    if(!int64Off.IsNull())  containerBuilder.add_int64_properties(int64Off);
-    if(!floatOff.IsNull())  containerBuilder.add_float_properties(floatOff);
-    if(!doubleOff.IsNull()) containerBuilder.add_double_properties(doubleOff);
-    if(!stringOff.IsNull()) containerBuilder.add_string_properties(stringOff);
-    
-    if(!vecPropOff.IsNull())   containerBuilder.add_vector_properties(vecPropOff);
-    if(!quatPropOff.IsNull())  containerBuilder.add_quat_properties(quatPropOff);
-    if(!transPropOff.IsNull()) containerBuilder.add_transform_properties(transPropOff);
-    if(!rangePropOff.IsNull()) containerBuilder.add_range_properties(rangePropOff);
-
-    if(!flatBytes.IsNull())  containerBuilder.add_byte_array_properties(flatBytes);
-    if(!flatInt32.IsNull())  containerBuilder.add_int32_arrays(flatInt32);
-    if(!flatInt64.IsNull())  containerBuilder.add_int64_arrays(flatInt64);
-    if(!flatFloat.IsNull())  containerBuilder.add_float_arrays(flatFloat);
-    if(!flatDouble.IsNull()) containerBuilder.add_double_arrays(flatDouble);
-    if(!flatString.IsNull()) containerBuilder.add_string_arrays(flatString);
-    if(!flatBool.IsNull())   containerBuilder.add_bool_arrays(flatBool);
-    
-    if(!flatVec.IsNull())    containerBuilder.add_vector_arrays(flatVec);
-    if(!flatQuat.IsNull())   containerBuilder.add_quat_arrays(flatQuat);
-    if(!flatTrans.IsNull())  containerBuilder.add_transform_arrays(flatTrans);
-    if(!flatRange.IsNull())  containerBuilder.add_range_arrays(flatRange);
-
-    if(!anyStructOff.IsNull())    containerBuilder.add_any_struct_properties(anyStructOff);
-    if(!anyStructArrOff.IsNull()) containerBuilder.add_any_struct_arrays(anyStructArrOff);
-    if(!mapPropOff.IsNull())      containerBuilder.add_map_properties(mapPropOff);
-    if(!mapArrOff.IsNull())       containerBuilder.add_map_arrays(mapArrOff);
+
+    if (!boolOff.IsNull())
+        containerBuilder.add_bool_properties(boolOff);
+    if (!int32Off.IsNull())
+        containerBuilder.add_int32_properties(int32Off);
+    if (!int64Off.IsNull())
+        containerBuilder.add_int64_properties(int64Off);
+    if (!floatOff.IsNull())
+        containerBuilder.add_float_properties(floatOff);
+    if (!doubleOff.IsNull())
+        containerBuilder.add_double_properties(doubleOff);
+    if (!stringOff.IsNull())
+        containerBuilder.add_string_properties(stringOff);
+
+    if (!vecPropOff.IsNull())
+        containerBuilder.add_vector_properties(vecPropOff);
+    if (!quatPropOff.IsNull())
+        containerBuilder.add_quat_properties(quatPropOff);
+    if (!transPropOff.IsNull())
+        containerBuilder.add_transform_properties(transPropOff);
+    if (!rangePropOff.IsNull())
+        containerBuilder.add_range_properties(rangePropOff);
+
+    if (!flatBytes.IsNull())
+        containerBuilder.add_byte_array_properties(flatBytes);
+    if (!flatInt32.IsNull())
+        containerBuilder.add_int32_arrays(flatInt32);
+    if (!flatInt64.IsNull())
+        containerBuilder.add_int64_arrays(flatInt64);
+    if (!flatFloat.IsNull())
+        containerBuilder.add_float_arrays(flatFloat);
+    if (!flatDouble.IsNull())
+        containerBuilder.add_double_arrays(flatDouble);
+    if (!flatString.IsNull())
+        containerBuilder.add_string_arrays(flatString);
+    if (!flatBool.IsNull())
+        containerBuilder.add_bool_arrays(flatBool);
+
+    if (!flatVec.IsNull())
+        containerBuilder.add_vector_arrays(flatVec);
+    if (!flatQuat.IsNull())
+        containerBuilder.add_quat_arrays(flatQuat);
+    if (!flatTrans.IsNull())
+        containerBuilder.add_transform_arrays(flatTrans);
+    if (!flatRange.IsNull())
+        containerBuilder.add_range_arrays(flatRange);
+
+    if (!anyStructOff.IsNull())
+        containerBuilder.add_any_struct_properties(anyStructOff);
+    if (!anyStructArrOff.IsNull())
+        containerBuilder.add_any_struct_arrays(anyStructArrOff);
+    if (!mapPropOff.IsNull())
+        containerBuilder.add_map_properties(mapPropOff);
+    if (!mapArrOff.IsNull())
+        containerBuilder.add_map_arrays(mapArrOff);
 
     return containerBuilder.Finish();
 }
 
-flatbuffers::Offset<fbsvtx::Bucket> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::Bucket& src) {
+flatbuffers::Offset<fbsvtx::Bucket> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder,
+                                                               VTX::Bucket& src) {
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> idsOff = 0;
-    if(!src.unique_ids.empty()) {
+    if (!src.unique_ids.empty()) {
         std::vector<flatbuffers::Offset<flatbuffers::String>> offsets;
-        for(const auto& s : src.unique_ids) offsets.push_back(builder.CreateString(s));
+        for (const auto& s : src.unique_ids)
+            offsets.push_back(builder.CreateString(s));
         idsOff = builder.CreateVector(offsets);
     }
 
     std::vector<flatbuffers::Offset<fbsvtx::PropertyContainer>> entOffsets;
-    for(auto& e : src.entities) entOffsets.push_back(ToFlat(builder, e));
+    for (auto& e : src.entities)
+        entOffsets.push_back(ToFlat(builder, e));
     auto entitiesOff = builder.CreateVector(entOffsets);
-    
+
     flatbuffers::Offset<flatbuffers::Vector<const fbsvtx::EntityRange*>> rangesOff = 0;
     if (!src.type_ranges.empty()) {
         std::vector<fbsvtx::EntityRange> fbRanges;
         fbRanges.reserve(src.type_ranges.size());
         for (const auto& r : src.type_ranges) {
-            fbRanges.emplace_back(r.start_index, r.count); 
+            fbRanges.emplace_back(r.start_index, r.count);
         }
         rangesOff = builder.CreateVectorOfStructs(fbRanges);
     }
@@ -276,9 +329,10 @@ flatbuffers::Offset<fbsvtx::Bucket> VTX::Serialization::ToFlat(flatbuffers::Flat
     return fbsvtx::CreateBucket(builder, idsOff, entitiesOff, rangesOff);
 }
 
-flatbuffers::Offset<fbsvtx::Frame> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder, VTX::Frame& src) {
+flatbuffers::Offset<fbsvtx::Frame> VTX::Serialization::ToFlat(flatbuffers::FlatBufferBuilder& builder,
+                                                              VTX::Frame& src) {
     auto& src_buckets = src.GetMutableBuckets();
-    
+
     std::vector<flatbuffers::Offset<fbsvtx::Bucket>> fbs_buckets;
     fbs_buckets.reserve(src_buckets.size());
 
diff --git a/tests/common/test_bucket_frame.cpp b/tests/common/test_bucket_frame.cpp
index 8e1a73b..e8d4d84 100644
--- a/tests/common/test_bucket_frame.cpp
+++ b/tests/common/test_bucket_frame.cpp
@@ -25,9 +25,9 @@ TEST(Frame, CreateBucketIsIdempotent) {
     auto& b2 = frame.CreateBucket("entity");
     b2.unique_ids.push_back("id_1");
 
-    EXPECT_EQ(frame.GetBuckets().size(), 1u);            // same bucket
+    EXPECT_EQ(frame.GetBuckets().size(), 1u); // same bucket
     EXPECT_EQ(frame.GetBuckets()[0].unique_ids.size(), 2u);
-    EXPECT_EQ(&b1, &b2);                                  // same reference
+    EXPECT_EQ(&b1, &b2); // same reference
 }
 
 TEST(Frame, MultipleBucketsKeepStableIndices) {
@@ -61,22 +61,24 @@ TEST(Bucket, GetEntitiesOfTypeReturnsCorrectSpan) {
         bucket.unique_ids.push_back("proj_" + std::to_string(i));
     }
     bucket.type_ranges = {
-        {0, 3},  // type 0: indices 0..2
-        {3, 2},  // type 1: indices 3..4
+        {0, 3}, // type 0: indices 0..2
+        {3, 2}, // type 1: indices 3..4
     };
 
     auto players = bucket.GetEntitiesOfType(0);
-    auto projs   = bucket.GetEntitiesOfType(1);
+    auto projs = bucket.GetEntitiesOfType(1);
 
     EXPECT_EQ(players.size(), 3u);
-    EXPECT_EQ(projs.size(),   2u);
-    for (const auto& p : players) EXPECT_EQ(p.entity_type_id, 0);
-    for (const auto& p : projs)   EXPECT_EQ(p.entity_type_id, 1);
+    EXPECT_EQ(projs.size(), 2u);
+    for (const auto& p : players)
+        EXPECT_EQ(p.entity_type_id, 0);
+    for (const auto& p : projs)
+        EXPECT_EQ(p.entity_type_id, 1);
 }
 
 TEST(Bucket, GetEntitiesOfTypeReturnsEmptyForUnknownId) {
     VTX::Bucket bucket;
-    bucket.type_ranges = { {0, 1} };  // only type 0 registered
+    bucket.type_ranges = {{0, 1}}; // only type 0 registered
     auto span = bucket.GetEntitiesOfType(5);
     EXPECT_TRUE(span.empty());
 }
@@ -87,7 +89,7 @@ TEST(Bucket, GetEntitiesOfTypeWithEnumOverloadCompiles) {
     enum class ArenaEntity : int32_t { Player = 0, Projectile = 1 };
     VTX::Bucket bucket;
     bucket.entities.emplace_back();
-    bucket.type_ranges = { {0, 1} };
+    bucket.type_ranges = {{0, 1}};
 
     auto players = bucket.GetEntitiesOfType(ArenaEntity::Player);
     EXPECT_EQ(players.size(), 1u);
diff --git a/tests/common/test_content_hash_edges.cpp b/tests/common/test_content_hash_edges.cpp
index 56173de..e7e0bdc 100644
--- a/tests/common/test_content_hash_edges.cpp
+++ b/tests/common/test_content_hash_edges.cpp
@@ -42,7 +42,7 @@ TEST(ContentHashEdges, HashDistinguishesDifferentNaNBitPatterns) {
     // diffs between containers that happened to land on different NaNs.
     float qnan = std::nanf("");
     float snan = 0.0f;
-    const uint32_t snan_bits = 0x7FA00000u;   // quiet bit clear, payload set
+    const uint32_t snan_bits = 0x7FA00000u; // quiet bit clear, payload set
     std::memcpy(&snan, &snan_bits, sizeof(snan));
 
     PropertyContainer a, b;
@@ -54,7 +54,7 @@ TEST(ContentHashEdges, HashDistinguishesDifferentNaNBitPatterns) {
     // long as it's consistent, but we expect a bitwise hasher to differ.
     (void)CalculateContainerHash(a);
     (void)CalculateContainerHash(b);
-    SUCCEED();  // the real invariant: no crash on NaN of any kind
+    SUCCEED(); // the real invariant: no crash on NaN of any kind
 }
 
 // ---------------------------------------------------------------------------
@@ -68,7 +68,7 @@ TEST(ContentHashEdges, HashDistinguishesEmptyVsDefault_DocumentsInvariant) {
     // change makes them differ, the test surfaces the contract shift.
     PropertyContainer a;
     PropertyContainer b;
-    b.float_properties = {};    // explicitly empty
+    b.float_properties = {}; // explicitly empty
 
     EXPECT_EQ(CalculateContainerHash(a), CalculateContainerHash(b));
 }
@@ -121,11 +121,11 @@ TEST(ContentHashEdges, HashLargeStringVectorsDoesntCrashAndIsStable) {
 
 TEST(ContentHashEdges, HashIsStableAcrossMove) {
     PropertyContainer original;
-    original.entity_type_id   = 7;
+    original.entity_type_id = 7;
     original.int32_properties = {1, 2, 3};
     original.string_properties = {"alpha", "bravo"};
     original.float_properties = {3.14f, -2.71f};
-    original.vector_properties = {VTX::Vector{1.0, 2.0, 3.0}};
+    original.vector_properties = {VTX::Vector {1.0, 2.0, 3.0}};
 
     const uint64_t before = CalculateContainerHash(original);
 
diff --git a/tests/common/test_flat_array.cpp b/tests/common/test_flat_array.cpp
index 9079d08..3d84482 100644
--- a/tests/common/test_flat_array.cpp
+++ b/tests/common/test_flat_array.cpp
@@ -16,7 +16,7 @@ TEST(FlatArray, DefaultConstructsEmpty) {
     FlatArray<int> arr;
     EXPECT_EQ(arr.SubArrayCount(), 0u);
     EXPECT_EQ(arr.TotalElementCount(), 0u);
-    EXPECT_TRUE(arr.GetSubArray(0).empty());  // OOB read is silent-empty
+    EXPECT_TRUE(arr.GetSubArray(0).empty()); // OOB read is silent-empty
 }
 
 TEST(FlatArray, ClearResetsEverything) {
@@ -45,8 +45,11 @@ TEST(FlatArray, AppendSubArrayStoresItemsContiguously) {
     auto sub1 = arr.GetSubArray(1);
     ASSERT_EQ(sub0.size(), 3u);
     ASSERT_EQ(sub1.size(), 2u);
-    EXPECT_EQ(sub0[0], 10); EXPECT_EQ(sub0[1], 20); EXPECT_EQ(sub0[2], 30);
-    EXPECT_EQ(sub1[0], 40); EXPECT_EQ(sub1[1], 50);
+    EXPECT_EQ(sub0[0], 10);
+    EXPECT_EQ(sub0[1], 20);
+    EXPECT_EQ(sub0[2], 30);
+    EXPECT_EQ(sub1[0], 40);
+    EXPECT_EQ(sub1[1], 50);
 }
 
 TEST(FlatArray, AppendEmptySubArrayStillCountsAsOne) {
@@ -107,7 +110,7 @@ TEST(FlatArray, EraseSubArrayRemovesElementsAndShifts) {
     EXPECT_EQ(arr.GetSubArray(0).size(), 2u);
     EXPECT_EQ(arr.GetSubArray(1).size(), 1u);
     EXPECT_EQ(arr.GetSubArray(1)[0], 6);
-    EXPECT_EQ(arr.TotalElementCount(), 3u);  // 2 + 1
+    EXPECT_EQ(arr.TotalElementCount(), 3u); // 2 + 1
 }
 
 TEST(FlatArray, EraseSubArrayOutOfBoundsReturnsFalse) {
@@ -190,7 +193,7 @@ TEST(FlatArray, ReplaceAtPositionUpdatesInPlace) {
 TEST(FlatArray, EraseRangeRemovesContiguousRun) {
     FlatArray<int> arr;
     arr.AppendSubArray({1, 2, 3, 4, 5});
-    ASSERT_TRUE(arr.EraseRange(0, 1, 4));  // remove indexes [1,4)  = 2,3,4
+    ASSERT_TRUE(arr.EraseRange(0, 1, 4)); // remove indexes [1,4)  = 2,3,4
     auto sub = arr.GetSubArray(0);
     ASSERT_EQ(sub.size(), 2u);
     EXPECT_EQ(sub[0], 1);
diff --git a/tests/common/test_flat_array_edges.cpp b/tests/common/test_flat_array_edges.cpp
index 2a27302..96a0a74 100644
--- a/tests/common/test_flat_array_edges.cpp
+++ b/tests/common/test_flat_array_edges.cpp
@@ -71,7 +71,7 @@ TEST(FlatArrayEdges, InsertSubArrayAtSizeEqualsAppend) {
     FlatArray<int> a, b;
     a.AppendSubArray({1, 2});
     a.AppendSubArray({3});
-    a.AppendSubArray({4, 5, 6});          // append via AppendSubArray
+    a.AppendSubArray({4, 5, 6}); // append via AppendSubArray
 
     b.AppendSubArray({1, 2});
     b.AppendSubArray({3});
@@ -142,7 +142,7 @@ TEST(FlatArrayEdges, EraseLastRemainingSubArray) {
 
     EXPECT_EQ(arr.SubArrayCount(), 0u);
     EXPECT_EQ(arr.TotalElementCount(), 0u);
-    EXPECT_TRUE(arr.GetSubArray(0).empty());  // OOB -> empty silently
+    EXPECT_TRUE(arr.GetSubArray(0).empty()); // OOB -> empty silently
 }
 
 TEST(FlatArrayEdges, EraseRangeZeroLengthIsNoOp) {
@@ -156,7 +156,9 @@ TEST(FlatArrayEdges, EraseRangeZeroLengthIsNoOp) {
 
     auto sub = arr.GetSubArray(0);
     ASSERT_EQ(sub.size(), 5u);
-    EXPECT_EQ(sub[0], 1);  EXPECT_EQ(sub[2], 3);  EXPECT_EQ(sub[4], 5);
+    EXPECT_EQ(sub[0], 1);
+    EXPECT_EQ(sub[2], 3);
+    EXPECT_EQ(sub[4], 5);
 }
 
 // ---------------------------------------------------------------------------
@@ -168,13 +170,14 @@ TEST(FlatArrayEdges, InsertAtEndEqualsPushBack) {
     a.AppendSubArray({10, 20, 30});
     b.AppendSubArray({10, 20, 30});
 
-    ASSERT_TRUE(a.Insert(0, a.GetSubArray(0).size(), 99));   // Insert at end
-    ASSERT_TRUE(b.PushBack(0, 99));                           // PushBack
+    ASSERT_TRUE(a.Insert(0, a.GetSubArray(0).size(), 99)); // Insert at end
+    ASSERT_TRUE(b.PushBack(0, 99));                        // PushBack
 
     auto sa = a.GetSubArray(0);
     auto sb = b.GetSubArray(0);
     ASSERT_EQ(sa.size(), sb.size());
-    for (size_t i = 0; i < sa.size(); ++i) EXPECT_EQ(sa[i], sb[i]);
+    for (size_t i = 0; i < sa.size(); ++i)
+        EXPECT_EQ(sa[i], sb[i]);
 }
 
 // ---------------------------------------------------------------------------
@@ -183,8 +186,8 @@ TEST(FlatArrayEdges, InsertAtEndEqualsPushBack) {
 
 TEST(FlatArrayEdges, DoubleCreateEmptyThenPushBackOnLast) {
     FlatArray<int> arr;
-    arr.CreateEmptySubArray();  // sub 0
-    arr.CreateEmptySubArray();  // sub 1
+    arr.CreateEmptySubArray(); // sub 0
+    arr.CreateEmptySubArray(); // sub 1
     ASSERT_TRUE(arr.PushBack(1, 42));
 
     EXPECT_EQ(arr.SubArrayCount(), 2u);
@@ -204,12 +207,10 @@ TEST(FlatArrayEdges, ReplaceSubArrayWithLargerSpanContainingMoves) {
     arr.AppendSubArray({std::string("alpha"), std::string("beta")});
     arr.AppendSubArray({std::string("gamma")});
 
-    const std::vector<std::string> replacement = {
-        std::string(128, 'x'),              // large string (no SSO)
-        std::string("short"),
-        std::string(""),                    // empty
-        std::string(64, 'y')
-    };
+    const std::vector<std::string> replacement = {std::string(128, 'x'), // large string (no SSO)
+                                                  std::string("short"),
+                                                  std::string(""), // empty
+                                                  std::string(64, 'y')};
     ASSERT_TRUE(arr.ReplaceSubArray(0, std::span<const std::string>(replacement)));
 
     ASSERT_EQ(arr.GetSubArray(0).size(), 4u);
@@ -225,13 +226,8 @@ TEST(FlatArrayEdges, OpsOnStringFlatArrayAcrossSsoBoundary) {
     // SSO (small string optimization) typically crosses around 15-22 chars.
     // Mix short and long strings in the same sub-array, then erase/insert.
     FlatArray<std::string> arr;
-    arr.AppendSubArray({
-        std::string("a"),
-        std::string(""),
-        std::string("short-ish"),
-        std::string(100, 'A'),
-        std::string(1, 'Z')
-    });
+    arr.AppendSubArray(
+        {std::string("a"), std::string(""), std::string("short-ish"), std::string(100, 'A'), std::string(1, 'Z')});
 
     // Delete the middle (long) element.
     ASSERT_TRUE(arr.Erase(0, 3));
@@ -263,7 +259,7 @@ TEST(FlatArrayEdges, FlatBoolArrayIsUint8Based_Regression) {
                   "FlatBoolArray must remain FlatArray<uint8_t> for SoA safety");
 
     VTX::FlatBoolArray arr;
-    arr.AppendSubArray({uint8_t{1}, uint8_t{0}, uint8_t{1}});
+    arr.AppendSubArray({uint8_t {1}, uint8_t {0}, uint8_t {1}});
     ASSERT_EQ(arr.GetSubArray(0).size(), 3u);
     EXPECT_EQ(arr.GetSubArray(0)[0], 1);
     EXPECT_EQ(arr.GetSubArray(0)[1], 0);
diff --git a/tests/common/test_frame_accessor.cpp b/tests/common/test_frame_accessor.cpp
index fd62788..d10c470 100644
--- a/tests/common/test_frame_accessor.cpp
+++ b/tests/common/test_frame_accessor.cpp
@@ -9,91 +9,63 @@
 
 namespace {
 
-VTX::PropertyContainer MakeCompanion(int32_t level)
-{
-    VTX::PropertyContainer pc;
-    pc.int32_properties = {level};
-    return pc;
-}
-
-VTX::PropertyAddressCache BuildCache()
-{
-    VTX::PropertyAddressCache cache;
-
-    cache.name_to_id["Player"] = 7;
-    auto& player = cache.structs[7];
-    player.name = "Player";
-    player.properties["Name"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::String,
-        .container_type = VTX::FieldContainerType::None
-    };
-    player.properties["Score"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Int32,
-        .container_type = VTX::FieldContainerType::None
-    };
-    player.properties["Health"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Float,
-        .container_type = VTX::FieldContainerType::None
-    };
-    player.properties["IsAlive"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Bool,
-        .container_type = VTX::FieldContainerType::None
-    };
-    player.properties["Inventory"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Int32,
-        .container_type = VTX::FieldContainerType::Array
-    };
-    player.properties["Companion"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Struct,
-        .container_type = VTX::FieldContainerType::None,
-        .child_type_name = "Companion"
-    };
-    player.properties["History"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Struct,
-        .container_type = VTX::FieldContainerType::Array,
-        .child_type_name = "Companion"
-    };
-    player.property_order = {
-        "Name", "Score", "Health", "IsAlive", "Inventory", "Companion", "History"
-    };
-
-    cache.name_to_id["Companion"] = 8;
-    auto& companion = cache.structs[8];
-    companion.name = "Companion";
-    companion.properties["Level"] = {
-        .index = 0,
-        .type_id = VTX::FieldType::Int32,
-        .container_type = VTX::FieldContainerType::None
-    };
-    companion.property_order = {"Level"};
-
-    return cache;
-}
-
-VTX::PropertyContainer BuildEntity()
-{
-    VTX::PropertyContainer pc;
-    pc.string_properties = {"Alpha"};
-    pc.int32_properties = {7};
-    pc.float_properties = {75.0f};
-    pc.bool_properties = {true};
-    pc.int32_arrays.AppendSubArray({10, 20, 30});
-    pc.any_struct_properties = {MakeCompanion(42)};
-    pc.any_struct_arrays.AppendSubArray({MakeCompanion(1), MakeCompanion(2)});
-    return pc;
-}
+    VTX::PropertyContainer MakeCompanion(int32_t level) {
+        VTX::PropertyContainer pc;
+        pc.int32_properties = {level};
+        return pc;
+    }
+
+    VTX::PropertyAddressCache BuildCache() {
+        VTX::PropertyAddressCache cache;
+
+        cache.name_to_id["Player"] = 7;
+        auto& player = cache.structs[7];
+        player.name = "Player";
+        player.properties["Name"] = {
+            .index = 0, .type_id = VTX::FieldType::String, .container_type = VTX::FieldContainerType::None};
+        player.properties["Score"] = {
+            .index = 0, .type_id = VTX::FieldType::Int32, .container_type = VTX::FieldContainerType::None};
+        player.properties["Health"] = {
+            .index = 0, .type_id = VTX::FieldType::Float, .container_type = VTX::FieldContainerType::None};
+        player.properties["IsAlive"] = {
+            .index = 0, .type_id = VTX::FieldType::Bool, .container_type = VTX::FieldContainerType::None};
+        player.properties["Inventory"] = {
+            .index = 0, .type_id = VTX::FieldType::Int32, .container_type = VTX::FieldContainerType::Array};
+        player.properties["Companion"] = {.index = 0,
+                                          .type_id = VTX::FieldType::Struct,
+                                          .container_type = VTX::FieldContainerType::None,
+                                          .child_type_name = "Companion"};
+        player.properties["History"] = {.index = 0,
+                                        .type_id = VTX::FieldType::Struct,
+                                        .container_type = VTX::FieldContainerType::Array,
+                                        .child_type_name = "Companion"};
+        player.property_order = {"Name", "Score", "Health", "IsAlive", "Inventory", "Companion", "History"};
+
+        cache.name_to_id["Companion"] = 8;
+        auto& companion = cache.structs[8];
+        companion.name = "Companion";
+        companion.properties["Level"] = {
+            .index = 0, .type_id = VTX::FieldType::Int32, .container_type = VTX::FieldContainerType::None};
+        companion.property_order = {"Level"};
+
+        return cache;
+    }
+
+    VTX::PropertyContainer BuildEntity() {
+        VTX::PropertyContainer pc;
+        pc.string_properties = {"Alpha"};
+        pc.int32_properties = {7};
+        pc.float_properties = {75.0f};
+        pc.bool_properties = {true};
+        pc.int32_arrays.AppendSubArray({10, 20, 30});
+        pc.any_struct_properties = {MakeCompanion(42)};
+        pc.any_struct_arrays.AppendSubArray({MakeCompanion(1), MakeCompanion(2)});
+        return pc;
+    }
 
 } // namespace
 
-TEST(FrameAccessor, ResolvesKeysAndReportsAvailableMetadata)
-{
+TEST(FrameAccessor, ResolvesKeysAndReportsAvailableMetadata) {
     VTX::FrameAccessor accessor;
     accessor.InitializeFromCache(BuildCache());
 
@@ -119,8 +91,7 @@ TEST(FrameAccessor, ResolvesKeysAndReportsAvailableMetadata)
     EXPECT_TRUE(accessor.GetPropertiesForStruct("Ghost").empty());
 }
 
-TEST(FrameAccessor, EntityViewReadsScalarArrayAndNestedProperties)
-{
+TEST(FrameAccessor, EntityViewReadsScalarArrayAndNestedProperties) {
     VTX::FrameAccessor accessor;
     accessor.InitializeFromCache(BuildCache());
 
@@ -155,8 +126,7 @@ TEST(FrameAccessor, EntityViewReadsScalarArrayAndNestedProperties)
     EXPECT_EQ(VTX::EntityView(history[1]).Get(level_key), 2);
 }
 
-TEST(FrameAccessor, InvalidKeysReturnDefaultsOrEmptyViews)
-{
+TEST(FrameAccessor, InvalidKeysReturnDefaultsOrEmptyViews) {
     VTX::FrameAccessor accessor;
     accessor.InitializeFromCache(BuildCache());
 
diff --git a/tests/common/test_property_address_cache.cpp b/tests/common/test_property_address_cache.cpp
index 87990be..567220d 100644
--- a/tests/common/test_property_address_cache.cpp
+++ b/tests/common/test_property_address_cache.cpp
@@ -8,8 +8,10 @@
 #include "util/test_fixtures.h"
 
 namespace {
-    std::string SchemaPath() { return VtxTest::FixturePath("test_schema.json"); }
-}
+    std::string SchemaPath() {
+        return VtxTest::FixturePath("test_schema.json");
+    }
+} // namespace
 
 TEST(PropertyAddressCache, PopulatedAfterSchemaLoad) {
     VTX::SchemaRegistry schema;
@@ -41,10 +43,11 @@ TEST(PropertyAddressCache, PlayerPropertiesResolveToValidAddresses) {
     const auto& cache = schema.GetPropertyCache();
 
     const int32_t player_id = cache.name_to_id.at("Player");
-    const auto&   player    = cache.structs.at(player_id);
+    const auto& player = cache.structs.at(player_id);
     EXPECT_EQ(player.name, "Player");
 
-    for (const char* field : {"UniqueID","Name","Team","Health","Armor","Position","Rotation","Velocity","IsAlive","Score","Deaths"}) {
+    for (const char* field : {"UniqueID", "Name", "Team", "Health", "Armor", "Position", "Rotation", "Velocity",
+                              "IsAlive", "Score", "Deaths"}) {
         ASSERT_TRUE(player.properties.contains(field)) << field;
         const auto& addr = player.properties.at(field);
         EXPECT_TRUE(addr.IsValid()) << field;
@@ -57,17 +60,17 @@ TEST(PropertyAddressCache, PropertyOrderMatchesSchemaFieldOrder) {
     const auto& cache = schema.GetPropertyCache();
 
     const int32_t player_id = cache.name_to_id.at("Player");
-    const auto&   player    = cache.structs.at(player_id);
+    const auto& player = cache.structs.at(player_id);
     auto ordered = player.GetPropertiesInOrder();
     ASSERT_EQ(ordered.size(), 11u);
-    EXPECT_EQ(ordered[0].name,  "UniqueID");
+    EXPECT_EQ(ordered[0].name, "UniqueID");
     EXPECT_EQ(ordered[10].name, "Deaths");
 }
 
 TEST(PropertyAddressCache, MakeLookupKeyIsDeterministic) {
-    using VTX::MakePropertyLookupKey;
-    using VTX::FieldType;
     using VTX::FieldContainerType;
+    using VTX::FieldType;
+    using VTX::MakePropertyLookupKey;
     EXPECT_EQ(MakePropertyLookupKey(0, FieldType::Float, FieldContainerType::None),
               MakePropertyLookupKey(0, FieldType::Float, FieldContainerType::None));
     EXPECT_NE(MakePropertyLookupKey(0, FieldType::Float, FieldContainerType::None),
diff --git a/tests/common/test_property_container.cpp b/tests/common/test_property_container.cpp
index cf69938..509047c 100644
--- a/tests/common/test_property_container.cpp
+++ b/tests/common/test_property_container.cpp
@@ -18,10 +18,10 @@ using VTX::Helpers::CalculateContainerHash;
 
 TEST(PropertyContainer, HashIsDeterministicAcrossCalls) {
     PropertyContainer a;
-    a.entity_type_id    = 0;
+    a.entity_type_id = 0;
     a.string_properties = {"player_1"};
-    a.float_properties  = {100.0f};
-    a.vector_properties = {VTX::Vector{1.0, 2.0, 3.0}};
+    a.float_properties = {100.0f};
+    a.vector_properties = {VTX::Vector {1.0, 2.0, 3.0}};
 
     const uint64_t h1 = CalculateContainerHash(a);
     const uint64_t h2 = CalculateContainerHash(a);
@@ -31,7 +31,7 @@ TEST(PropertyContainer, HashIsDeterministicAcrossCalls) {
 
 TEST(PropertyContainer, HashDiffersWhenFloatValueChanges) {
     PropertyContainer a;
-    a.entity_type_id   = 0;
+    a.entity_type_id = 0;
     a.float_properties = {100.0f};
 
     PropertyContainer b = a;
@@ -87,7 +87,7 @@ TEST(PropertyContainer, HashIncludesNestedAnyStruct) {
 TEST(PropertyContainer, DefaultConstructedHasExpectedDefaults) {
     PropertyContainer pc;
     EXPECT_EQ(pc.entity_type_id, -1);
-    EXPECT_EQ(pc.content_hash,   0u);
+    EXPECT_EQ(pc.content_hash, 0u);
     EXPECT_TRUE(pc.bool_properties.empty());
     EXPECT_TRUE(pc.float_properties.empty());
     EXPECT_TRUE(pc.string_properties.empty());
diff --git a/tests/common/test_schema_registry.cpp b/tests/common/test_schema_registry.cpp
index ca0a333..7832f7f 100644
--- a/tests/common/test_schema_registry.cpp
+++ b/tests/common/test_schema_registry.cpp
@@ -10,8 +10,10 @@
 #include "util/test_fixtures.h"
 
 namespace {
-    std::string SchemaPath() { return VtxTest::FixturePath("test_schema.json"); }
-}
+    std::string SchemaPath() {
+        return VtxTest::FixturePath("test_schema.json");
+    }
+} // namespace
 
 // ---------------------------------------------------------------------------
 // LoadFromJson
@@ -80,7 +82,7 @@ TEST(SchemaRegistry, GetFieldResolvesKnownFields) {
     ASSERT_TRUE(schema.LoadFromJson(SchemaPath()));
 
     EXPECT_NE(schema.GetField("Player", "UniqueID"), nullptr);
-    EXPECT_NE(schema.GetField("Player", "Health"),   nullptr);
+    EXPECT_NE(schema.GetField("Player", "Health"), nullptr);
     EXPECT_NE(schema.GetField("Player", "Position"), nullptr);
 }
 
@@ -89,7 +91,7 @@ TEST(SchemaRegistry, GetFieldReturnsNullForUnknown) {
     ASSERT_TRUE(schema.LoadFromJson(SchemaPath()));
 
     EXPECT_EQ(schema.GetField("Player", "DoesNotExist"), nullptr);
-    EXPECT_EQ(schema.GetField("Ghost",  "Health"),       nullptr);
+    EXPECT_EQ(schema.GetField("Ghost", "Health"), nullptr);
 }
 
 TEST(SchemaRegistry, GetStructTypeIdReturnsStableId) {
diff --git a/tests/common/test_schema_registry_errors.cpp b/tests/common/test_schema_registry_errors.cpp
index 637bf31..2e754f6 100644
--- a/tests/common/test_schema_registry_errors.cpp
+++ b/tests/common/test_schema_registry_errors.cpp
@@ -86,7 +86,7 @@ TEST(SchemaRegistryErrors, LoadFromRawStringDuplicateStructIsDeterministic) {
     (void)ok2;
 
     // Both registries must agree on Player existence or absence.
-    const bool player1_exists = (schema.GetStruct("Player")  != nullptr);
+    const bool player1_exists = (schema.GetStruct("Player") != nullptr);
     const bool player2_exists = (schema2.GetStruct("Player") != nullptr);
     EXPECT_EQ(player1_exists, player2_exists);
 }
@@ -117,7 +117,7 @@ TEST(SchemaRegistryErrors, LoadFromRawStringUnknownTypeIdDoesntCrash) {
 
     // If the struct was accepted, looking up the bogus field must not crash.
     if (const auto* s = schema.GetStruct("Ghost")) {
-        (void)s;  // just don't crash
+        (void)s; // just don't crash
     }
     // If not accepted, that's also fine -- both outcomes are valid.
     SUCCEED();
diff --git a/tests/common/test_time_utils.cpp b/tests/common/test_time_utils.cpp
index f6da65f..4a77381 100644
--- a/tests/common/test_time_utils.cpp
+++ b/tests/common/test_time_utils.cpp
@@ -8,15 +8,13 @@
 
 namespace {
 
-size_t FieldIndex(VTX::FieldType type)
-{
-    return static_cast<size_t>(type);
-}
+    size_t FieldIndex(VTX::FieldType type) {
+        return static_cast<size_t>(type);
+    }
 
 } // namespace
 
-TEST(TimeUtils, PreparePropertyContainerSizesVectorsFromSchema)
-{
+TEST(TimeUtils, PreparePropertyContainerSizesVectorsFromSchema) {
     VTX::SchemaStruct schema;
     schema.type_max_indices.resize(FieldIndex(VTX::FieldType::Struct) + 1, 0);
     schema.type_max_indices[FieldIndex(VTX::FieldType::Bool)] = 2;
@@ -43,8 +41,7 @@ TEST(TimeUtils, PreparePropertyContainerSizesVectorsFromSchema)
     EXPECT_EQ(pc.any_struct_properties.size(), 1u);
 }
 
-TEST(TimeUtils, ConvertToUeTicksSupportsNumericFormats)
-{
+TEST(TimeUtils, ConvertToUeTicksSupportsNumericFormats) {
     using namespace VTX::TimeUtils;
 
     // Use int64{N} (not N##LL) to pick the int64 overload unambiguously.
@@ -59,25 +56,19 @@ TEST(TimeUtils, ConvertToUeTicksSupportsNumericFormats)
     EXPECT_EQ(ConvertToUeTicks(TimeFormat::Seconds, int64 {7}), 0LL);
 }
 
-TEST(TimeUtils, ConvertToUeTicksParsesIso8601AndRejectsInvalidStrings)
-{
+TEST(TimeUtils, ConvertToUeTicksParsesIso8601AndRejectsInvalidStrings) {
     using namespace VTX::TimeUtils;
 
-    EXPECT_EQ(ConvertToUeTicks(TimeFormat::ISO8601, std::string("1970-01-01T00:00:00")),
-              TICKS_AT_UNIX_EPOCH);
+    EXPECT_EQ(ConvertToUeTicks(TimeFormat::ISO8601, std::string("1970-01-01T00:00:00")), TICKS_AT_UNIX_EPOCH);
     EXPECT_EQ(ConvertToUeTicks(TimeFormat::ISO8601, std::string("invalid")), 0LL);
     EXPECT_EQ(ConvertToUeTicks(TimeFormat::UnixUTC, std::string("1970-01-01T00:00:00")), 0LL);
 }
 
-TEST(TimeUtils, DurationHelpersFormatPredictably)
-{
+TEST(TimeUtils, DurationHelpersFormatPredictably) {
     using namespace VTX::TimeUtils;
 
-    const int64 ticks =
-        (3LL * 3600 * TICKS_PER_SECOND) +
-        (2LL * 60 * TICKS_PER_SECOND) +
-        (5LL * TICKS_PER_SECOND) +
-        (123LL * TICKS_PER_MILLISECOND);
+    const int64 ticks = (3LL * 3600 * TICKS_PER_SECOND) + (2LL * 60 * TICKS_PER_SECOND) + (5LL * TICKS_PER_SECOND) +
+                        (123LL * TICKS_PER_MILLISECOND);
 
     const auto duration = TicksToDuration(ticks);
     EXPECT_EQ(duration.hours, 3);
@@ -89,8 +80,7 @@ TEST(TimeUtils, DurationHelpersFormatPredictably)
     EXPECT_NEAR(TicksToSeconds(ticks), 10'925.123, 1e-9);
 }
 
-TEST(TimeUtils, FormatUtcTicksAcceptsUnixAndUeEpochTicks)
-{
+TEST(TimeUtils, FormatUtcTicksAcceptsUnixAndUeEpochTicks) {
     using namespace VTX::TimeUtils;
 
     const std::string unix_epoch = FormatUtcTicks(0);
@@ -101,8 +91,7 @@ TEST(TimeUtils, FormatUtcTicksAcceptsUnixAndUeEpochTicks)
     EXPECT_TRUE(unix_epoch.ends_with("00:00:00.000 UTC"));
 }
 
-TEST(TimeUtils, CalculateContainerHashIncludesFlatArrayOffsets)
-{
+TEST(TimeUtils, CalculateContainerHashIncludesFlatArrayOffsets) {
     VTX::PropertyContainer a;
     a.int32_arrays.AppendSubArray({1, 2});
     a.int32_arrays.AppendSubArray({3});
@@ -111,6 +100,5 @@ TEST(TimeUtils, CalculateContainerHashIncludesFlatArrayOffsets)
     b.int32_arrays.AppendSubArray({1});
     b.int32_arrays.AppendSubArray({2, 3});
 
-    EXPECT_NE(VTX::Helpers::CalculateContainerHash(a),
-              VTX::Helpers::CalculateContainerHash(b));
+    EXPECT_NE(VTX::Helpers::CalculateContainerHash(a), VTX::Helpers::CalculateContainerHash(b));
 }
diff --git a/tests/common/test_vtx_game_times.cpp b/tests/common/test_vtx_game_times.cpp
index 9f06e36..e1d12f5 100644
--- a/tests/common/test_vtx_game_times.cpp
+++ b/tests/common/test_vtx_game_times.cpp
@@ -14,9 +14,9 @@
 #include <gtest/gtest.h>
 #include "vtx/common/vtx_types.h"
 
-using VTX::GameTime::VTXGameTimes;
-using VTX::GameTime::GameTimeRegister;
 using VTX::GameTime::EFilterType;
+using VTX::GameTime::GameTimeRegister;
+using VTX::GameTime::VTXGameTimes;
 
 // ---------------------------------------------------------------------------
 // Regression: historical UTC must be accepted
@@ -32,9 +32,9 @@ TEST(VTXGameTimes, AcceptsHistoricalUtcOnFirstFrame_Regression) {
     const int64_t historical_utc = 1'745'000'000LL * 10'000'000LL;
 
     GameTimeRegister reg;
-    reg.game_time        = 0.0f;
+    reg.game_time = 0.0f;
     reg.created_utc_time = historical_utc;
-    reg.FrameFilterType  = EFilterType::OnlyIncreasing;
+    reg.FrameFilterType = EFilterType::OnlyIncreasing;
 
     EXPECT_TRUE(times.AddTimeRegistry(reg));
     EXPECT_EQ(times.LastCreatedUtc(), historical_utc);
@@ -47,7 +47,7 @@ TEST(VTXGameTimes, AcceptsFutureUtcOnFirstFrame) {
     const int64_t future_utc = VTXGameTimes::GetUtcNowTicks() + 1'000'000'000LL;
 
     GameTimeRegister reg;
-    reg.game_time        = 0.0f;
+    reg.game_time = 0.0f;
     reg.created_utc_time = future_utc;
 
     EXPECT_TRUE(times.AddTimeRegistry(reg));
@@ -59,16 +59,16 @@ TEST(VTXGameTimes, RejectsUtcRegressionAfterFirstFrame) {
     VTXGameTimes times;
 
     GameTimeRegister first;
-    first.game_time        = 0.0f;
-    first.created_utc_time = 1'745'000'000'000'000'0LL;  // 2025
+    first.game_time = 0.0f;
+    first.created_utc_time = 1'745'000'000'000'000'0LL; // 2025
     ASSERT_TRUE(times.AddTimeRegistry(first));
 
     // Simulate the "per-frame" finalize so add_used_ clears.
     times.ResolveGameTimes(1);
 
     GameTimeRegister regressing;
-    regressing.game_time        = 0.016f;
-    regressing.created_utc_time = *first.created_utc_time - 1;  // goes BACKWARD
+    regressing.game_time = 0.016f;
+    regressing.created_utc_time = *first.created_utc_time - 1; // goes BACKWARD
 
     EXPECT_FALSE(times.AddTimeRegistry(regressing));
 }
@@ -83,7 +83,7 @@ TEST(VTXGameTimes, OnlyIncreasingAcceptsGameTimeZeroOnFirstFrame_Regression) {
     VTXGameTimes times;
 
     GameTimeRegister reg;
-    reg.game_time       = 0.0f;
+    reg.game_time = 0.0f;
     reg.FrameFilterType = EFilterType::OnlyIncreasing;
 
     EXPECT_TRUE(times.AddTimeRegistry(reg));
@@ -93,7 +93,7 @@ TEST(VTXGameTimes, OnlyDecreasingAcceptsGameTimeZeroOnFirstFrame_Regression) {
     VTXGameTimes times;
 
     GameTimeRegister reg;
-    reg.game_time       = 0.0f;
+    reg.game_time = 0.0f;
     reg.FrameFilterType = EFilterType::OnlyDecreasing;
 
     EXPECT_TRUE(times.AddTimeRegistry(reg));
@@ -104,13 +104,13 @@ TEST(VTXGameTimes, OnlyIncreasingRejectsRegressionOnLaterFrame) {
     VTXGameTimes times;
 
     GameTimeRegister a;
-    a.game_time       = 1.0f;
+    a.game_time = 1.0f;
     a.FrameFilterType = EFilterType::OnlyIncreasing;
     ASSERT_TRUE(times.AddTimeRegistry(a));
     times.ResolveGameTimes(1);
 
     GameTimeRegister b;
-    b.game_time       = 0.5f;  // less than previous
+    b.game_time = 0.5f; // less than previous
     b.FrameFilterType = EFilterType::OnlyIncreasing;
 
     EXPECT_FALSE(times.AddTimeRegistry(b));
@@ -120,13 +120,13 @@ TEST(VTXGameTimes, OnlyDecreasingRejectsAscentOnLaterFrame) {
     VTXGameTimes times;
 
     GameTimeRegister a;
-    a.game_time       = 10.0f;
+    a.game_time = 10.0f;
     a.FrameFilterType = EFilterType::OnlyDecreasing;
     ASSERT_TRUE(times.AddTimeRegistry(a));
     times.ResolveGameTimes(1);
 
     GameTimeRegister b;
-    b.game_time       = 20.0f;  // greater than previous
+    b.game_time = 20.0f; // greater than previous
     b.FrameFilterType = EFilterType::OnlyDecreasing;
 
     EXPECT_FALSE(times.AddTimeRegistry(b));
@@ -147,7 +147,7 @@ TEST(VTXGameTimes, ClearResetsStartUtcToZero_Regression) {
     VTXGameTimes times;
 
     GameTimeRegister reg;
-    reg.game_time        = 0.0f;
+    reg.game_time = 0.0f;
     reg.created_utc_time = 1'745'000'000'000'000'0LL;
     ASSERT_TRUE(times.AddTimeRegistry(reg));
 
@@ -167,9 +167,9 @@ TEST(VTXGameTimes, AcceptsManyMonotonicFrames) {
 
     for (int i = 0; i < kFrames; ++i) {
         GameTimeRegister reg;
-        reg.game_time        = float(i) / 60.0f;
+        reg.game_time = float(i) / 60.0f;
         reg.created_utc_time = base_utc + int64_t(i) * 166'666LL;
-        reg.FrameFilterType  = EFilterType::OnlyIncreasing;
+        reg.FrameFilterType = EFilterType::OnlyIncreasing;
 
         EXPECT_TRUE(times.AddTimeRegistry(reg)) << "frame " << i;
         times.ResolveGameTimes(i + 1);
@@ -197,9 +197,9 @@ TEST(VTXGameTimes, RejectsSecondAddInSameFrame) {
 // ---------------------------------------------------------------------------
 
 TEST(VTXGameTimes, SecondsToTicksMatchesConventional) {
-    EXPECT_EQ(VTXGameTimes::SecondsToTicks(0.0f),    0);
-    EXPECT_EQ(VTXGameTimes::SecondsToTicks(1.0f),    10'000'000);
-    EXPECT_EQ(VTXGameTimes::SecondsToTicks(0.5f),    5'000'000);
+    EXPECT_EQ(VTXGameTimes::SecondsToTicks(0.0f), 0);
+    EXPECT_EQ(VTXGameTimes::SecondsToTicks(1.0f), 10'000'000);
+    EXPECT_EQ(VTXGameTimes::SecondsToTicks(0.5f), 5'000'000);
 }
 
 TEST(VTXGameTimes, GetUtcNowTicksIsMonotonic) {
diff --git a/tests/common/test_vtx_game_times_extended.cpp b/tests/common/test_vtx_game_times_extended.cpp
index 64c6d6f..2cd42e4 100644
--- a/tests/common/test_vtx_game_times_extended.cpp
+++ b/tests/common/test_vtx_game_times_extended.cpp
@@ -10,18 +10,16 @@ using VTX::GameTime::VTXGameTimes;
 
 namespace {
 
-GameTimeRegister MakeBoth(float game_time, int64_t created_utc)
-{
-    GameTimeRegister reg;
-    reg.game_time = game_time;
-    reg.created_utc_time = created_utc;
-    return reg;
-}
+    GameTimeRegister MakeBoth(float game_time, int64_t created_utc) {
+        GameTimeRegister reg;
+        reg.game_time = game_time;
+        reg.created_utc_time = created_utc;
+        return reg;
+    }
 
 } // namespace
 
-TEST(VTXGameTimesExtended, SetupUsesExplicitStartUtcAndImplicitStartUtc)
-{
+TEST(VTXGameTimesExtended, SetupUsesExplicitStartUtcAndImplicitStartUtc) {
     VTXGameTimes explicit_start;
     explicit_start.Setup(60.0f, true, 123456789LL);
     EXPECT_EQ(explicit_start.StartUtc(), 123456789LL);
@@ -31,8 +29,7 @@ TEST(VTXGameTimesExtended, SetupUsesExplicitStartUtcAndImplicitStartUtc)
     EXPECT_GT(implicit_start.StartUtc(), 0);
 }
 
-TEST(VTXGameTimesExtended, ResolveWithOnlyGameTimeSynthesizesIncreasingUtc)
-{
+TEST(VTXGameTimesExtended, ResolveWithOnlyGameTimeSynthesizesIncreasingUtc) {
     VTXGameTimes times;
     times.Setup(2.0f, true, 1000LL);
 
@@ -53,8 +50,7 @@ TEST(VTXGameTimesExtended, ResolveWithOnlyGameTimeSynthesizesIncreasingUtc)
     EXPECT_EQ(times.GetCreatedUtc()[1], times.GetCreatedUtc()[0] + 5'000'000LL);
 }
 
-TEST(VTXGameTimesExtended, ResolveWithOnlyCreatedUtcSynthesizesRelativeGameTime)
-{
+TEST(VTXGameTimesExtended, ResolveWithOnlyCreatedUtcSynthesizesRelativeGameTime) {
     VTXGameTimes times;
     times.Setup(60.0f, true, 0);
 
@@ -73,8 +69,7 @@ TEST(VTXGameTimesExtended, ResolveWithOnlyCreatedUtcSynthesizesRelativeGameTime)
     EXPECT_EQ(times.GetGameTime()[1], 2250LL);
 }
 
-TEST(VTXGameTimesExtended, ResolveWithoutInputsSynthesizesBothTimesFromFps)
-{
+TEST(VTXGameTimesExtended, ResolveWithoutInputsSynthesizesBothTimesFromFps) {
     VTXGameTimes times;
     times.Setup(2.0f, true, 1000LL);
 
@@ -90,8 +85,7 @@ TEST(VTXGameTimesExtended, ResolveWithoutInputsSynthesizesBothTimesFromFps)
     EXPECT_EQ(times.GetCreatedUtc()[1], 5'001'000LL);
 }
 
-TEST(VTXGameTimesExtended, DetectsTimelineGapWhenUtcJumpExceedsThreshold)
-{
+TEST(VTXGameTimesExtended, DetectsTimelineGapWhenUtcJumpExceedsThreshold) {
     VTXGameTimes times;
     times.Setup(60.0f, true, 0);
 
@@ -105,8 +99,7 @@ TEST(VTXGameTimesExtended, DetectsTimelineGapWhenUtcJumpExceedsThreshold)
     EXPECT_EQ(times.GetTimelineGaps()[0], 2);
 }
 
-TEST(VTXGameTimesExtended, DetectsGameSegmentWhenGameTimeDirectionReverses)
-{
+TEST(VTXGameTimesExtended, DetectsGameSegmentWhenGameTimeDirectionReverses) {
     VTXGameTimes times;
     times.Setup(60.0f, true, 0);
 
@@ -120,8 +113,7 @@ TEST(VTXGameTimesExtended, DetectsGameSegmentWhenGameTimeDirectionReverses)
     EXPECT_EQ(times.GetGameSegments()[0], 2);
 }
 
-TEST(VTXGameTimesExtended, CopyFromKeepsOnlyCurrentChunkAndInsertLiveChunkTimesAppends)
-{
+TEST(VTXGameTimesExtended, CopyFromKeepsOnlyCurrentChunkAndInsertLiveChunkTimesAppends) {
     VTXGameTimes source;
     source.Setup(60.0f, true, 1000LL);
 
@@ -152,8 +144,7 @@ TEST(VTXGameTimesExtended, CopyFromKeepsOnlyCurrentChunkAndInsertLiveChunkTimesA
     EXPECT_EQ(appended.GetCreatedUtc()[0], 3000LL);
 }
 
-TEST(VTXGameTimesExtended, SnapshotRollbackRestoresPreviousState)
-{
+TEST(VTXGameTimesExtended, SnapshotRollbackRestoresPreviousState) {
     VTXGameTimes times;
     times.Setup(60.0f, true, 1000LL);
 
@@ -167,8 +158,7 @@ TEST(VTXGameTimesExtended, SnapshotRollbackRestoresPreviousState)
     EXPECT_TRUE(times.GetCreatedUtc().empty());
 }
 
-TEST(VTXGameTimesExtended, ResolveRejectsZeroFrameCount)
-{
+TEST(VTXGameTimesExtended, ResolveRejectsZeroFrameCount) {
     VTXGameTimes times;
     EXPECT_FALSE(times.ResolveGameTimes(0));
 }
diff --git a/tests/common/test_vtx_game_times_state.cpp b/tests/common/test_vtx_game_times_state.cpp
index b388baf..7786232 100644
--- a/tests/common/test_vtx_game_times_state.cpp
+++ b/tests/common/test_vtx_game_times_state.cpp
@@ -7,19 +7,20 @@
 #include <gtest/gtest.h>
 #include "vtx/common/vtx_types.h"
 
-using VTX::GameTime::VTXGameTimes;
-using VTX::GameTime::GameTimeRegister;
 using VTX::GameTime::EFilterType;
+using VTX::GameTime::GameTimeRegister;
+using VTX::GameTime::VTXGameTimes;
 
 namespace {
 
-GameTimeRegister MakeReg(float game_time, int64_t utc = -1) {
-    GameTimeRegister r;
-    r.game_time = game_time;
-    if (utc >= 0) r.created_utc_time = utc;
-    r.FrameFilterType = EFilterType::OnlyIncreasing;
-    return r;
-}
+    GameTimeRegister MakeReg(float game_time, int64_t utc = -1) {
+        GameTimeRegister r;
+        r.game_time = game_time;
+        if (utc >= 0)
+            r.created_utc_time = utc;
+        r.FrameFilterType = EFilterType::OnlyIncreasing;
+        return r;
+    }
 
 } // namespace
 
@@ -38,7 +39,7 @@ TEST(VTXGameTimesState, RollbackWithoutPriorSnapshotIsSafe) {
     ASSERT_TRUE(t.AddTimeRegistry(MakeReg(0.1f)));
     t.ResolveGameTimes(2);
 
-    t.Rollback();  // no snapshot -- must not crash
+    t.Rollback(); // no snapshot -- must not crash
     SUCCEED();
 
     // After Rollback with no snapshot, we must still be able to Clear safely.
@@ -102,7 +103,7 @@ TEST(VTXGameTimesState, ClearThenReuseReturnsToEmptyState) {
 
     t.Clear();
     EXPECT_TRUE(t.IsEmpty());
-    EXPECT_EQ(t.StartUtc(), 0);   // regression for the 2026-04-17 fix
+    EXPECT_EQ(t.StartUtc(), 0); // regression for the 2026-04-17 fix
 
     // Fresh state must accept the same data again, including the first frame
     // being t=0 without triggering the monotonicity filter.
diff --git a/tests/differ/test_diff_basic.cpp b/tests/differ/test_diff_basic.cpp
index 2bcc6e1..1022ce5 100644
--- a/tests/differ/test_diff_basic.cpp
+++ b/tests/differ/test_diff_basic.cpp
@@ -18,75 +18,73 @@
 
 namespace {
 
-VTX::PropertyContainer MakePlayer(
-    const std::string& uid,
-    const std::string& name,
-    int team, float health, float armor,
-    VTX::Vector pos,
-    bool is_alive = true,
-    int score = 0, int deaths = 0)
-{
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 0;
-    pc.string_properties = {uid, name};
-    pc.int32_properties  = {team, score, deaths};
-    pc.float_properties  = {health, armor};
-    pc.vector_properties = {pos, VTX::Vector{0.0, 0.0, 0.0}};
-    pc.quat_properties   = {VTX::Quat{0.0f, 0.0f, 0.0f, 1.0f}};
-    pc.bool_properties   = {is_alive};
-    return pc;
-}
-
-/// Builds a two-frame .vtx file from raw frame-builder callbacks.  Returns the
-/// path of the written file.
-template <typename F1, typename F2>
-std::string WriteTwoFrameFile(const std::string& uuid, F1 build_frame_0, F2 build_frame_1)
-{
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath("diff_" + uuid + ".vtx");
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "DiffTest";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = 16;
-    cfg.use_compression  = true;
-
-    auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
-    {
-        VTX::Frame f0 = build_frame_0();
-        VTX::GameTime::GameTimeRegister t;
-        t.game_time = 0.0f;
-        writer->RecordFrame(f0, t);
+    VTX::PropertyContainer MakePlayer(const std::string& uid, const std::string& name, int team, float health,
+                                      float armor, VTX::Vector pos, bool is_alive = true, int score = 0,
+                                      int deaths = 0) {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {uid, name};
+        pc.int32_properties = {team, score, deaths};
+        pc.float_properties = {health, armor};
+        pc.vector_properties = {pos, VTX::Vector {0.0, 0.0, 0.0}};
+        pc.quat_properties = {VTX::Quat {0.0f, 0.0f, 0.0f, 1.0f}};
+        pc.bool_properties = {is_alive};
+        return pc;
     }
-    {
-        VTX::Frame f1 = build_frame_1();
-        VTX::GameTime::GameTimeRegister t;
-        t.game_time = 1.0f / 60.0f;
-        writer->RecordFrame(f1, t);
+
+    /// Builds a two-frame .vtx file from raw frame-builder callbacks.  Returns the
+    /// path of the written file.
+    template <typename F1, typename F2>
+    std::string WriteTwoFrameFile(const std::string& uuid, F1 build_frame_0, F2 build_frame_1) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath("diff_" + uuid + ".vtx");
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "DiffTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 16;
+        cfg.use_compression = true;
+
+        auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
+        {
+            VTX::Frame f0 = build_frame_0();
+            VTX::GameTime::GameTimeRegister t;
+            t.game_time = 0.0f;
+            writer->RecordFrame(f0, t);
+        }
+        {
+            VTX::Frame f1 = build_frame_1();
+            VTX::GameTime::GameTimeRegister t;
+            t.game_time = 1.0f / 60.0f;
+            writer->RecordFrame(f1, t);
+        }
+        writer->Flush();
+        writer->Stop();
+        return cfg.output_filepath;
     }
-    writer->Flush();
-    writer->Stop();
-    return cfg.output_filepath;
-}
 
-/// Opens a file, pulls raw bytes of frames 0 and 1, and runs the differ.
-/// Returns the PatchIndex.  We need to copy A's bytes because loading B may
-/// evict A's chunk.
-VtxDiff::PatchIndex DiffFile(const std::string& path,
-                             const VtxDiff::DiffOptions& opts = {})
-{
-    auto ctx = VTX::OpenReplayFile(path);
-    if (!ctx) { ADD_FAILURE() << ctx.error; return {}; }
+    /// Opens a file, pulls raw bytes of frames 0 and 1, and runs the differ.
+    /// Returns the PatchIndex.  We need to copy A's bytes because loading B may
+    /// evict A's chunk.
+    VtxDiff::PatchIndex DiffFile(const std::string& path, const VtxDiff::DiffOptions& opts = {}) {
+        auto ctx = VTX::OpenReplayFile(path);
+        if (!ctx) {
+            ADD_FAILURE() << ctx.error;
+            return {};
+        }
 
-    auto differ = VtxDiff::CreateDifferFacade(ctx.format);
-    if (!differ) { ADD_FAILURE() << "CreateDifferFacade returned nullptr"; return {}; }
+        auto differ = VtxDiff::CreateDifferFacade(ctx.format);
+        if (!differ) {
+            ADD_FAILURE() << "CreateDifferFacade returned nullptr";
+            return {};
+        }
 
-    auto raw_a = ctx.reader->GetRawFrameBytes(0);
-    std::vector<std::byte> bytes_a(raw_a.begin(), raw_a.end());
+        auto raw_a = ctx.reader->GetRawFrameBytes(0);
+        std::vector<std::byte> bytes_a(raw_a.begin(), raw_a.end());
 
-    auto raw_b = ctx.reader->GetRawFrameBytes(1);
-    return differ->DiffRawFrames(bytes_a, raw_b, opts);
-}
+        auto raw_b = ctx.reader->GetRawFrameBytes(1);
+        return differ->DiffRawFrames(bytes_a, raw_b, opts);
+    }
 
 } // namespace
 
@@ -115,8 +113,7 @@ TEST(Differ, IdenticalFramesProduceZeroOps) {
         VTX::Frame f;
         auto& bucket = f.CreateBucket("entity");
         bucket.unique_ids.push_back("player_0");
-        bucket.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f,
-                                             VTX::Vector{0.0, 0.0, 0.0}));
+        bucket.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("identical", build, build);
@@ -134,8 +131,7 @@ TEST(Differ, FloatPropertyChangeShowsUpAsReplace) {
         VTX::Frame f;
         auto& bucket = f.CreateBucket("entity");
         bucket.unique_ids.push_back("player_0");
-        bucket.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f,
-                                             VTX::Vector{0.0, 0.0, 0.0}));
+        bucket.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto build1 = [] {
@@ -143,8 +139,7 @@ TEST(Differ, FloatPropertyChangeShowsUpAsReplace) {
         auto& bucket = f.CreateBucket("entity");
         bucket.unique_ids.push_back("player_0");
         // Health dropped from 100 -> 75.  Everything else identical.
-        bucket.entities.push_back(MakePlayer("player_0", "Alpha", 1, 75.0f, 50.0f,
-                                             VTX::Vector{0.0, 0.0, 0.0}));
+        bucket.entities.push_back(MakePlayer("player_0", "Alpha", 1, 75.0f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("replace_float", build0, build1);
@@ -155,9 +150,7 @@ TEST(Differ, FloatPropertyChangeShowsUpAsReplace) {
     bool saw_float_replace = false;
     for (const auto& op : patch.operations) {
         if (op.ContainerType == VtxDiff::EVTXContainerType::FloatProperties &&
-            (op.Operation == VtxDiff::DiffOperation::Replace ||
-             op.Operation == VtxDiff::DiffOperation::ReplaceRange))
-        {
+            (op.Operation == VtxDiff::DiffOperation::Replace || op.Operation == VtxDiff::DiffOperation::ReplaceRange)) {
             saw_float_replace = true;
             EXPECT_EQ(op.ActorId, "player_0");
         }
@@ -170,16 +163,14 @@ TEST(Differ, VectorPropertyChangeShowsUpAsReplace) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f,
-                                        VTX::Vector{0.0, 0.0, 0.0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto build1 = [] {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f,
-                                        VTX::Vector{10.0, 0.0, 0.0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {10.0, 0.0, 0.0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("replace_vec", build0, build1);
@@ -206,23 +197,21 @@ TEST(Differ, FloatWithinEpsilonProducesNoOp) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.000001f, 50.0f,
-                                        VTX::Vector{0.0, 0.0, 0.0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.000001f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto build1 = [] {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.000002f, 50.0f,
-                                        VTX::Vector{0.0, 0.0, 0.0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.000002f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("epsilon_ignored", build0, build1);
 
     VtxDiff::DiffOptions opts;
     opts.compare_floats_with_epsilon = true;
-    opts.float_epsilon               = 1e-3f;
+    opts.float_epsilon = 1e-3f;
     auto patch = DiffFile(path, opts);
 
     // Any float-containing op would be unexpected with epsilon this large.
@@ -236,23 +225,21 @@ TEST(Differ, FloatOutsideEpsilonProducesOp) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f,
-                                        VTX::Vector{0.0, 0.0, 0.0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto build1 = [] {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 110.0f, 50.0f,
-                                        VTX::Vector{0.0, 0.0, 0.0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 110.0f, 50.0f, VTX::Vector {0.0, 0.0, 0.0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("epsilon_exceeded", build0, build1);
 
     VtxDiff::DiffOptions opts;
     opts.compare_floats_with_epsilon = true;
-    opts.float_epsilon               = 1e-3f;
+    opts.float_epsilon = 1e-3f;
     auto patch = DiffFile(path, opts);
 
     bool saw_float = false;
@@ -273,15 +260,15 @@ TEST(Differ, EntityAddedBetweenFramesYieldsAddOp) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector{0,0,0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0, 0, 0}));
         return f;
     };
     const auto build1 = [] {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids = {"player_0", "player_1"};
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector{0,0,0}));
-        b.entities.push_back(MakePlayer("player_1", "Bravo", 2,  80.0f, 40.0f, VTX::Vector{5,0,0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0, 0, 0}));
+        b.entities.push_back(MakePlayer("player_1", "Bravo", 2, 80.0f, 40.0f, VTX::Vector {5, 0, 0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("added_entity", build0, build1);
@@ -289,7 +276,8 @@ TEST(Differ, EntityAddedBetweenFramesYieldsAddOp) {
 
     bool saw_add = false;
     for (const auto& op : patch.operations) {
-        if (op.Operation == VtxDiff::DiffOperation::Add) saw_add = true;
+        if (op.Operation == VtxDiff::DiffOperation::Add)
+            saw_add = true;
     }
     EXPECT_TRUE(saw_add);
 }
@@ -299,15 +287,15 @@ TEST(Differ, EntityRemovedBetweenFramesYieldsRemoveOp) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids = {"player_0", "player_1"};
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector{0,0,0}));
-        b.entities.push_back(MakePlayer("player_1", "Bravo", 2,  80.0f, 40.0f, VTX::Vector{5,0,0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0, 0, 0}));
+        b.entities.push_back(MakePlayer("player_1", "Bravo", 2, 80.0f, 40.0f, VTX::Vector {5, 0, 0}));
         return f;
     };
     const auto build1 = [] {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         b.unique_ids.push_back("player_0");
-        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector{0,0,0}));
+        b.entities.push_back(MakePlayer("player_0", "Alpha", 1, 100.0f, 50.0f, VTX::Vector {0, 0, 0}));
         return f;
     };
     const auto path = WriteTwoFrameFile("removed_entity", build0, build1);
@@ -315,7 +303,8 @@ TEST(Differ, EntityRemovedBetweenFramesYieldsRemoveOp) {
 
     bool saw_remove = false;
     for (const auto& op : patch.operations) {
-        if (op.Operation == VtxDiff::DiffOperation::Remove) saw_remove = true;
+        if (op.Operation == VtxDiff::DiffOperation::Remove)
+            saw_remove = true;
     }
     EXPECT_TRUE(saw_remove);
 }
@@ -336,14 +325,15 @@ TEST(DiffIndexPath, AppendProducesExpectedSequence) {
 
 TEST(DiffIndexPath, PushBackSilentlyDropsOverflow) {
     VtxDiff::DiffIndexPath p;
-    for (int i = 0; i < 20; ++i) p.push_back(i);  // capacity is 16
+    for (int i = 0; i < 20; ++i)
+        p.push_back(i); // capacity is 16
     EXPECT_EQ(p.count, 16);
 }
 
 TEST(DiffIndexPath, EqualityUsesCountAndContents) {
-    auto a = VtxDiff::DiffIndexPath{}.Append(1).Append(2);
-    auto b = VtxDiff::DiffIndexPath{}.Append(1).Append(2);
-    auto c = VtxDiff::DiffIndexPath{}.Append(1).Append(3);
+    auto a = VtxDiff::DiffIndexPath {}.Append(1).Append(2);
+    auto b = VtxDiff::DiffIndexPath {}.Append(1).Append(2);
+    auto c = VtxDiff::DiffIndexPath {}.Append(1).Append(3);
     EXPECT_EQ(a, b);
     EXPECT_FALSE(a == c);
 }
diff --git a/tests/differ/test_diff_edges.cpp b/tests/differ/test_diff_edges.cpp
index 704d59f..918827e 100644
--- a/tests/differ/test_diff_edges.cpp
+++ b/tests/differ/test_diff_edges.cpp
@@ -20,57 +20,63 @@
 
 namespace {
 
-template <typename F0, typename F1>
-std::string WriteTwoFrameFile(const std::string& uuid, F0 build0, F1 build1) {
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath("diffedge_" + uuid + ".vtx");
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "DiffEdgeTest";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = 16;
-    cfg.use_compression  = true;
+    template <typename F0, typename F1>
+    std::string WriteTwoFrameFile(const std::string& uuid, F0 build0, F1 build1) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath("diffedge_" + uuid + ".vtx");
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "DiffEdgeTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 16;
+        cfg.use_compression = true;
 
-    {
-        auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
-        VTX::Frame f0 = build0();
-        VTX::Frame f1 = build1();
-        VTX::GameTime::GameTimeRegister t0; t0.game_time = 0.0f;
-        VTX::GameTime::GameTimeRegister t1; t1.game_time = 1.0f / 60.0f;
-        writer->RecordFrame(f0, t0);
-        writer->RecordFrame(f1, t1);
-        writer->Flush();
-        writer->Stop();
+        {
+            auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
+            VTX::Frame f0 = build0();
+            VTX::Frame f1 = build1();
+            VTX::GameTime::GameTimeRegister t0;
+            t0.game_time = 0.0f;
+            VTX::GameTime::GameTimeRegister t1;
+            t1.game_time = 1.0f / 60.0f;
+            writer->RecordFrame(f0, t0);
+            writer->RecordFrame(f1, t1);
+            writer->Flush();
+            writer->Stop();
+        }
+        return cfg.output_filepath;
     }
-    return cfg.output_filepath;
-}
 
-VtxDiff::PatchIndex DiffFile(const std::string& path,
-                             const VtxDiff::DiffOptions& opts = {})
-{
-    auto ctx = VTX::OpenReplayFile(path);
-    if (!ctx) { ADD_FAILURE() << ctx.error; return {}; }
-    auto differ = VtxDiff::CreateDifferFacade(ctx.format);
-    if (!differ) { ADD_FAILURE() << "no differ"; return {}; }
+    VtxDiff::PatchIndex DiffFile(const std::string& path, const VtxDiff::DiffOptions& opts = {}) {
+        auto ctx = VTX::OpenReplayFile(path);
+        if (!ctx) {
+            ADD_FAILURE() << ctx.error;
+            return {};
+        }
+        auto differ = VtxDiff::CreateDifferFacade(ctx.format);
+        if (!differ) {
+            ADD_FAILURE() << "no differ";
+            return {};
+        }
 
-    auto raw_a = ctx.reader->GetRawFrameBytes(0);
-    std::vector<std::byte> bytes_a(raw_a.begin(), raw_a.end());
-    auto raw_b = ctx.reader->GetRawFrameBytes(1);
-    return differ->DiffRawFrames(bytes_a, raw_b, opts);
-}
+        auto raw_a = ctx.reader->GetRawFrameBytes(0);
+        std::vector<std::byte> bytes_a(raw_a.begin(), raw_a.end());
+        auto raw_b = ctx.reader->GetRawFrameBytes(1);
+        return differ->DiffRawFrames(bytes_a, raw_b, opts);
+    }
 
-// Minimal entity with only unique_id + entity_type_id so tests stay readable.
-VTX::PropertyContainer MakeMinimalPlayer(const std::string& uid) {
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 0;
-    pc.string_properties = {uid, "name"};
-    pc.int32_properties  = {1, 0, 0};
-    pc.float_properties  = {100.0f, 50.0f};
-    pc.vector_properties = {VTX::Vector{}, VTX::Vector{}};
-    pc.quat_properties   = {VTX::Quat{}};
-    pc.bool_properties   = {true};
-    return pc;
-}
+    // Minimal entity with only unique_id + entity_type_id so tests stay readable.
+    VTX::PropertyContainer MakeMinimalPlayer(const std::string& uid) {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {uid, "name"};
+        pc.int32_properties = {1, 0, 0};
+        pc.float_properties = {100.0f, 50.0f};
+        pc.vector_properties = {VTX::Vector {}, VTX::Vector {}};
+        pc.quat_properties = {VTX::Quat {}};
+        pc.bool_properties = {true};
+        return pc;
+    }
 
 } // namespace
 
@@ -90,7 +96,7 @@ TEST(DiffEdges, DiffBetweenFramesWithEmptyBuckets) {
     const auto build = [] {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
-        (void)b;  // empty bucket, no entities
+        (void)b; // empty bucket, no entities
         return f;
     };
     const auto path = WriteTwoFrameFile("empty_buckets", build, build);
@@ -142,8 +148,7 @@ TEST(DiffEdges, DiffWithByteArrays) {
         auto& b = f.CreateBucket("entity");
         auto pc = MakeMinimalPlayer("bytes_owner");
         pc.byte_array_properties.AppendSubArray(
-            std::span<const uint8_t>(
-                reinterpret_cast<const uint8_t*>("\x01\x02\x03\x04"), 4));
+            std::span<const uint8_t>(reinterpret_cast<const uint8_t*>("\x01\x02\x03\x04"), 4));
         b.unique_ids.push_back("bytes_owner");
         b.entities.push_back(std::move(pc));
         return f;
@@ -153,8 +158,7 @@ TEST(DiffEdges, DiffWithByteArrays) {
         auto& b = f.CreateBucket("entity");
         auto pc = MakeMinimalPlayer("bytes_owner");
         pc.byte_array_properties.AppendSubArray(
-            std::span<const uint8_t>(
-                reinterpret_cast<const uint8_t*>("\x01\x02\x99\x04"), 4));
+            std::span<const uint8_t>(reinterpret_cast<const uint8_t*>("\x01\x02\x99\x04"), 4));
         b.unique_ids.push_back("bytes_owner");
         b.entities.push_back(std::move(pc));
         return f;
@@ -188,7 +192,7 @@ TEST(DiffEdges, DiffWithNestedAnyStructProperties) {
         auto pc = MakeMinimalPlayer("nested_owner");
 
         VTX::PropertyContainer inner;
-        inner.float_properties = {2.71f};  // changed
+        inner.float_properties = {2.71f}; // changed
         pc.any_struct_properties.push_back(std::move(inner));
 
         b.unique_ids.push_back("nested_owner");
@@ -229,7 +233,7 @@ TEST(DiffEdges, DiffWithEntityReplacedUnderSameUniqueId) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         auto pc = MakeMinimalPlayer("same_id");
-        pc.int32_properties = {1, 100, 5};  // score=100, deaths=5
+        pc.int32_properties = {1, 100, 5}; // score=100, deaths=5
         b.unique_ids.push_back("same_id");
         b.entities.push_back(std::move(pc));
         return f;
@@ -238,7 +242,7 @@ TEST(DiffEdges, DiffWithEntityReplacedUnderSameUniqueId) {
         VTX::Frame f;
         auto& b = f.CreateBucket("entity");
         auto pc = MakeMinimalPlayer("same_id");
-        pc.int32_properties = {2, 999, 0};  // totally different stats
+        pc.int32_properties = {2, 999, 0}; // totally different stats
         pc.float_properties = {25.0f, 0.0f};
         b.unique_ids.push_back("same_id");
         b.entities.push_back(std::move(pc));
@@ -251,7 +255,10 @@ TEST(DiffEdges, DiffWithEntityReplacedUnderSameUniqueId) {
     // At least one op should reference the shared actor id.
     bool found = false;
     for (const auto& op : patch.operations) {
-        if (op.ActorId == "same_id") { found = true; break; }
+        if (op.ActorId == "same_id") {
+            found = true;
+            break;
+        }
     }
     EXPECT_TRUE(found);
 }
diff --git a/tests/differ/test_diff_parametrized.cpp b/tests/differ/test_diff_parametrized.cpp
index e7b2325..c76de2e 100644
--- a/tests/differ/test_diff_parametrized.cpp
+++ b/tests/differ/test_diff_parametrized.cpp
@@ -14,100 +14,87 @@
 
 namespace {
 
-const char* FormatName(VTX::VtxFormat format)
-{
-    return format == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
-}
-
-std::string UniqueOutputPath(VTX::VtxFormat format, const std::string& suffix)
-{
-    const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
-    return VtxTest::OutputPath(
-        VtxTest::SanitizePathComponent(std::string(info->test_suite_name())) + "_" +
-        VtxTest::SanitizePathComponent(std::string(info->name())) + "_" +
-        FormatName(format) + "_" + suffix + ".vtx");
-}
-
-std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(VTX::VtxFormat format,
-                                                    const VTX::WriterFacadeConfig& cfg)
-{
-    return format == VTX::VtxFormat::FlatBuffers
-        ? VTX::CreateFlatBuffersWriterFacade(cfg)
-        : VTX::CreateProtobuffWriterFacade(cfg);
-}
-
-VTX::PropertyContainer MakePlayer(float health)
-{
-    VTX::PropertyContainer pc;
-    pc.entity_type_id = 0;
-    pc.string_properties = {"player_0", "Alpha"};
-    pc.int32_properties = {1, 0, 0};
-    pc.float_properties = {health, 50.0f};
-    pc.vector_properties = {VTX::Vector{0.0, 0.0, 0.0}, VTX::Vector{1.0, 0.0, 0.0}};
-    pc.quat_properties = {VTX::Quat{0.0f, 0.0f, 0.0f, 1.0f}};
-    pc.bool_properties = {true};
-    return pc;
-}
+    const char* FormatName(VTX::VtxFormat format) {
+        return format == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
+    }
 
-template <typename F0, typename F1>
-std::string WriteTwoFrameReplay(VTX::VtxFormat format,
-                                const std::string& path,
-                                F0 build0,
-                                F1 build1)
-{
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath = path;
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name = "DiffParametrized";
-    cfg.replay_uuid = "diff-param";
-    cfg.default_fps = 60.0f;
-    cfg.chunk_max_frames = 8;
-    cfg.use_compression = true;
-
-    auto writer = CreateWriter(format, cfg);
-    {
-        auto frame = build0();
-        VTX::GameTime::GameTimeRegister t;
-        t.game_time = 0.0f;
-        writer->RecordFrame(frame, t);
+    std::string UniqueOutputPath(VTX::VtxFormat format, const std::string& suffix) {
+        const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
+        return VtxTest::OutputPath(VtxTest::SanitizePathComponent(std::string(info->test_suite_name())) + "_" +
+                                   VtxTest::SanitizePathComponent(std::string(info->name())) + "_" +
+                                   FormatName(format) + "_" + suffix + ".vtx");
     }
-    {
-        auto frame = build1();
-        VTX::GameTime::GameTimeRegister t;
-        t.game_time = 1.0f / 60.0f;
-        writer->RecordFrame(frame, t);
+
+    std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(VTX::VtxFormat format, const VTX::WriterFacadeConfig& cfg) {
+        return format == VTX::VtxFormat::FlatBuffers ? VTX::CreateFlatBuffersWriterFacade(cfg)
+                                                     : VTX::CreateProtobuffWriterFacade(cfg);
     }
-    writer->Stop();
-    return path;
-}
 
-VtxDiff::PatchIndex DiffFrames(VTX::VtxFormat format, const std::string& path)
-{
-    auto ctx = VTX::OpenReplayFile(path);
-    if (!ctx) {
-        ADD_FAILURE() << ctx.error;
-        return {};
+    VTX::PropertyContainer MakePlayer(float health) {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {"player_0", "Alpha"};
+        pc.int32_properties = {1, 0, 0};
+        pc.float_properties = {health, 50.0f};
+        pc.vector_properties = {VTX::Vector {0.0, 0.0, 0.0}, VTX::Vector {1.0, 0.0, 0.0}};
+        pc.quat_properties = {VTX::Quat {0.0f, 0.0f, 0.0f, 1.0f}};
+        pc.bool_properties = {true};
+        return pc;
     }
-    EXPECT_EQ(ctx.format, format);
 
-    auto differ = VtxDiff::CreateDifferFacade(format);
-    if (!differ) {
-        ADD_FAILURE() << "CreateDifferFacade returned nullptr";
-        return {};
+    template <typename F0, typename F1>
+    std::string WriteTwoFrameReplay(VTX::VtxFormat format, const std::string& path, F0 build0, F1 build1) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = path;
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "DiffParametrized";
+        cfg.replay_uuid = "diff-param";
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 8;
+        cfg.use_compression = true;
+
+        auto writer = CreateWriter(format, cfg);
+        {
+            auto frame = build0();
+            VTX::GameTime::GameTimeRegister t;
+            t.game_time = 0.0f;
+            writer->RecordFrame(frame, t);
+        }
+        {
+            auto frame = build1();
+            VTX::GameTime::GameTimeRegister t;
+            t.game_time = 1.0f / 60.0f;
+            writer->RecordFrame(frame, t);
+        }
+        writer->Stop();
+        return path;
     }
 
-    auto raw_a = ctx.reader->GetRawFrameBytes(0);
-    std::vector<std::byte> bytes_a(raw_a.begin(), raw_a.end());
-    const auto raw_b = ctx.reader->GetRawFrameBytes(1);
-    return differ->DiffRawFrames(bytes_a, raw_b);
-}
+    VtxDiff::PatchIndex DiffFrames(VTX::VtxFormat format, const std::string& path) {
+        auto ctx = VTX::OpenReplayFile(path);
+        if (!ctx) {
+            ADD_FAILURE() << ctx.error;
+            return {};
+        }
+        EXPECT_EQ(ctx.format, format);
+
+        auto differ = VtxDiff::CreateDifferFacade(format);
+        if (!differ) {
+            ADD_FAILURE() << "CreateDifferFacade returned nullptr";
+            return {};
+        }
+
+        auto raw_a = ctx.reader->GetRawFrameBytes(0);
+        std::vector<std::byte> bytes_a(raw_a.begin(), raw_a.end());
+        const auto raw_b = ctx.reader->GetRawFrameBytes(1);
+        return differ->DiffRawFrames(bytes_a, raw_b);
+    }
 
 } // namespace
 
 class DifferParametrizedTest : public ::testing::TestWithParam<VTX::VtxFormat> {};
 
-TEST_P(DifferParametrizedTest, IdenticalFramesProduceZeroOpsOnBothBackends)
-{
+TEST_P(DifferParametrizedTest, IdenticalFramesProduceZeroOpsOnBothBackends) {
     const auto build = [] {
         VTX::Frame f;
         auto& bucket = f.CreateBucket("entity");
@@ -121,8 +108,7 @@ TEST_P(DifferParametrizedTest, IdenticalFramesProduceZeroOpsOnBothBackends)
     EXPECT_TRUE(patch.operations.empty());
 }
 
-TEST_P(DifferParametrizedTest, FloatReplaceIsDetectedOnBothBackends)
-{
+TEST_P(DifferParametrizedTest, FloatReplaceIsDetectedOnBothBackends) {
     const auto build0 = [] {
         VTX::Frame f;
         auto& bucket = f.CreateBucket("entity");
@@ -144,8 +130,7 @@ TEST_P(DifferParametrizedTest, FloatReplaceIsDetectedOnBothBackends)
     bool saw_float_replace = false;
     for (const auto& op : patch.operations) {
         if (op.ContainerType == VtxDiff::EVTXContainerType::FloatProperties &&
-            (op.Operation == VtxDiff::DiffOperation::Replace ||
-             op.Operation == VtxDiff::DiffOperation::ReplaceRange)) {
+            (op.Operation == VtxDiff::DiffOperation::Replace || op.Operation == VtxDiff::DiffOperation::ReplaceRange)) {
             saw_float_replace = true;
             EXPECT_EQ(op.ActorId, "player_0");
         }
@@ -153,8 +138,7 @@ TEST_P(DifferParametrizedTest, FloatReplaceIsDetectedOnBothBackends)
     EXPECT_TRUE(saw_float_replace);
 }
 
-TEST_P(DifferParametrizedTest, EmptyInputsReturnEmptyPatch)
-{
+TEST_P(DifferParametrizedTest, EmptyInputsReturnEmptyPatch) {
     auto differ = VtxDiff::CreateDifferFacade(GetParam());
     ASSERT_TRUE(differ);
 
@@ -164,10 +148,8 @@ TEST_P(DifferParametrizedTest, EmptyInputsReturnEmptyPatch)
     EXPECT_TRUE(patch.operations.empty());
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    BothBackends,
-    DifferParametrizedTest,
-    ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
-    [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
-        return std::string(FormatName(info.param));
-    });
+INSTANTIATE_TEST_SUITE_P(BothBackends, DifferParametrizedTest,
+                         ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
+                         [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
+                             return std::string(FormatName(info.param));
+                         });
diff --git a/tests/differ/test_diff_utils.cpp b/tests/differ/test_diff_utils.cpp
index ea27699..60606b9 100644
--- a/tests/differ/test_diff_utils.cpp
+++ b/tests/differ/test_diff_utils.cpp
@@ -10,35 +10,28 @@
 
 namespace {
 
-template <typename T>
-std::span<const std::byte> BytesOf(const T& value)
-{
-    return std::as_bytes(std::span(&value, 1));
-}
+    template <typename T>
+    std::span<const std::byte> BytesOf(const T& value) {
+        return std::as_bytes(std::span(&value, 1));
+    }
 
-template <typename T, size_t N>
-std::span<const std::byte> BytesOf(const std::array<T, N>& value)
-{
-    return std::as_bytes(std::span(value));
-}
+    template <typename T, size_t N>
+    std::span<const std::byte> BytesOf(const std::array<T, N>& value) {
+        return std::as_bytes(std::span(value));
+    }
 
 } // namespace
 
-TEST(DiffUtils, TypeToFieldNameReturnsExpectedNames)
-{
-    EXPECT_EQ(VtxDiff::TypeToFieldName(VtxDiff::EVTXContainerType::FloatProperties),
-              "float_properties");
-    EXPECT_EQ(VtxDiff::TypeToFieldName(VtxDiff::EVTXContainerType::AnyStructArrays),
-              "any_struct_arrays");
+TEST(DiffUtils, TypeToFieldNameReturnsExpectedNames) {
+    EXPECT_EQ(VtxDiff::TypeToFieldName(VtxDiff::EVTXContainerType::FloatProperties), "float_properties");
+    EXPECT_EQ(VtxDiff::TypeToFieldName(VtxDiff::EVTXContainerType::AnyStructArrays), "any_struct_arrays");
     EXPECT_EQ(VtxDiff::TypeToFieldName(VtxDiff::EVTXContainerType::Unknown), "Unknown");
     EXPECT_EQ(VtxDiff::TypeToFieldName(static_cast<VtxDiff::EVTXContainerType>(255)), "");
 }
 
-TEST(DiffUtils, PathHelpersBuildCanonicalRepresentations)
-{
+TEST(DiffUtils, PathHelpersBuildCanonicalRepresentations) {
     VtxDiff::PathS path("Root");
-    EXPECT_EQ(path.Append("Field").Index(3).Key("player_0").ToString(),
-              "Root.Field[3]{player_0}");
+    EXPECT_EQ(path.Append("Field").Index(3).Key("player_0").ToString(), "Root.Field[3]{player_0}");
 
     EXPECT_EQ(VtxDiff::MakeFieldPath("", "Field"), "Field");
     EXPECT_EQ(VtxDiff::MakeFieldPath("Root", "Field"), "Root.Field");
@@ -48,44 +41,42 @@ TEST(DiffUtils, PathHelpersBuildCanonicalRepresentations)
     EXPECT_FALSE(VtxDiff::EndsWith("Root.Field", ".Other"));
 }
 
-TEST(DiffUtils, IsArraysTypeRecognizesArrayContainers)
-{
+TEST(DiffUtils, IsArraysTypeRecognizesArrayContainers) {
     EXPECT_TRUE(VtxDiff::IsArraysType(VtxDiff::EVTXContainerType::Int32Arrays));
     EXPECT_TRUE(VtxDiff::IsArraysType(VtxDiff::EVTXContainerType::AnyStructArrays));
     EXPECT_FALSE(VtxDiff::IsArraysType(VtxDiff::EVTXContainerType::Int32Properties));
     EXPECT_FALSE(VtxDiff::IsArraysType(VtxDiff::EVTXContainerType::Unknown));
 }
 
-TEST(DiffUtils, AreScalarsEqualUsesEpsilonAndFallsBackToByteComparison)
-{
+TEST(DiffUtils, AreScalarsEqualUsesEpsilonAndFallsBackToByteComparison) {
     VtxDiff::DiffOptions relaxed;
     relaxed.compare_floats_with_epsilon = true;
     relaxed.float_epsilon = 1e-3f;
 
     const float fa = 1.0f;
     const float fb = 1.0005f;
-    EXPECT_TRUE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::FloatProperties,
-                                         BytesOf(fa), BytesOf(fb), relaxed));
+    EXPECT_TRUE(
+        VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::FloatProperties, BytesOf(fa), BytesOf(fb), relaxed));
 
     std::array<float, 3> vec_a = {1.0f, 2.0f, 3.0f};
     std::array<float, 3> vec_b = {1.0f, 2.0005f, 3.0f};
-    EXPECT_TRUE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::VectorProperties,
-                                         BytesOf(vec_a), BytesOf(vec_b), relaxed));
+    EXPECT_TRUE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::VectorProperties, BytesOf(vec_a), BytesOf(vec_b),
+                                         relaxed));
 
     std::array<float, 4> quat_a = {0.0f, 0.0f, 0.0f, 1.0f};
     std::array<float, 4> quat_b = {0.0f, 0.0f, 0.0f, 1.0005f};
-    EXPECT_TRUE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::QuatProperties,
-                                         BytesOf(quat_a), BytesOf(quat_b), relaxed));
+    EXPECT_TRUE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::QuatProperties, BytesOf(quat_a), BytesOf(quat_b),
+                                         relaxed));
 
     VtxDiff::DiffOptions strict;
     strict.compare_floats_with_epsilon = false;
-    EXPECT_FALSE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::FloatProperties,
-                                          BytesOf(fa), BytesOf(fb), strict));
+    EXPECT_FALSE(
+        VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::FloatProperties, BytesOf(fa), BytesOf(fb), strict));
 
     const int32_t ia = 7;
     const int32_t ib = 8;
-    EXPECT_TRUE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::Int32Properties,
-                                         BytesOf(ia), BytesOf(ia), relaxed));
-    EXPECT_FALSE(VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::Int32Properties,
-                                          BytesOf(ia), BytesOf(ib), relaxed));
+    EXPECT_TRUE(
+        VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::Int32Properties, BytesOf(ia), BytesOf(ia), relaxed));
+    EXPECT_FALSE(
+        VtxDiff::AreScalarsEqual(VtxDiff::EVTXContainerType::Int32Properties, BytesOf(ia), BytesOf(ib), relaxed));
 }
diff --git a/tests/reader/test_corrupt_files.cpp b/tests/reader/test_corrupt_files.cpp
index 77f2e1b..4732d8a 100644
--- a/tests/reader/test_corrupt_files.cpp
+++ b/tests/reader/test_corrupt_files.cpp
@@ -22,59 +22,59 @@
 
 namespace {
 
-// Writes a tiny valid FlatBuffers replay so we have a baseline file we can
-// then mutate for each corruption test.
-std::string WriteValidFlatBuffersFile(const std::string& uuid) {
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath("corrupt_" + uuid + ".vtx");
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "CorruptFileTest";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = 10;
-    cfg.use_compression  = true;
-
-    {
-        auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
-        for (int i = 0; i < 5; ++i) {
-            VTX::Frame f;
-            auto& bucket = f.CreateBucket("entity");
-
-            VTX::PropertyContainer pc;
-            pc.entity_type_id    = 0;
-            pc.string_properties = {"p", "name"};
-            pc.int32_properties  = {1, 0, 0};
-            pc.float_properties  = {100.0f, 50.0f};
-            pc.vector_properties = {VTX::Vector{}, VTX::Vector{}};
-            pc.quat_properties   = {VTX::Quat{}};
-            pc.bool_properties   = {true};
-
-            bucket.unique_ids.push_back("p");
-            bucket.entities.push_back(std::move(pc));
-
-            VTX::GameTime::GameTimeRegister t;
-            t.game_time = float(i) / 60.0f;
-            writer->RecordFrame(f, t);
+    // Writes a tiny valid FlatBuffers replay so we have a baseline file we can
+    // then mutate for each corruption test.
+    std::string WriteValidFlatBuffersFile(const std::string& uuid) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath("corrupt_" + uuid + ".vtx");
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "CorruptFileTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 10;
+        cfg.use_compression = true;
+
+        {
+            auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
+            for (int i = 0; i < 5; ++i) {
+                VTX::Frame f;
+                auto& bucket = f.CreateBucket("entity");
+
+                VTX::PropertyContainer pc;
+                pc.entity_type_id = 0;
+                pc.string_properties = {"p", "name"};
+                pc.int32_properties = {1, 0, 0};
+                pc.float_properties = {100.0f, 50.0f};
+                pc.vector_properties = {VTX::Vector {}, VTX::Vector {}};
+                pc.quat_properties = {VTX::Quat {}};
+                pc.bool_properties = {true};
+
+                bucket.unique_ids.push_back("p");
+                bucket.entities.push_back(std::move(pc));
+
+                VTX::GameTime::GameTimeRegister t;
+                t.game_time = float(i) / 60.0f;
+                writer->RecordFrame(f, t);
+            }
+            writer->Flush();
+            writer->Stop();
         }
-        writer->Flush();
-        writer->Stop();
+        return cfg.output_filepath;
     }
-    return cfg.output_filepath;
-}
 
-// Writes `content` verbatim to disk and returns the path.
-std::string WriteRawBytes(const std::string& name, std::span<const uint8_t> content) {
-    const auto path = VtxTest::OutputPath(name);
-    std::ofstream ofs(path, std::ios::binary | std::ios::trunc);
-    ofs.write(reinterpret_cast<const char*>(content.data()), static_cast<std::streamsize>(content.size()));
-    ofs.close();
-    return path;
-}
+    // Writes `content` verbatim to disk and returns the path.
+    std::string WriteRawBytes(const std::string& name, std::span<const uint8_t> content) {
+        const auto path = VtxTest::OutputPath(name);
+        std::ofstream ofs(path, std::ios::binary | std::ios::trunc);
+        ofs.write(reinterpret_cast<const char*>(content.data()), static_cast<std::streamsize>(content.size()));
+        ofs.close();
+        return path;
+    }
 
-// Truncates an existing file down to `target_size` bytes.
-void TruncateFile(const std::string& path, std::uintmax_t target_size) {
-    std::filesystem::resize_file(path, target_size);
-}
+    // Truncates an existing file down to `target_size` bytes.
+    void TruncateFile(const std::string& path, std::uintmax_t target_size) {
+        std::filesystem::resize_file(path, target_size);
+    }
 
 } // namespace
 
@@ -83,7 +83,7 @@ void TruncateFile(const std::string& path, std::uintmax_t target_size) {
 // ===========================================================================
 
 TEST(CorruptFile, EmptyFileReturnsError) {
-    const auto path = WriteRawBytes("empty.vtx", std::span<const uint8_t>{});
+    const auto path = WriteRawBytes("empty.vtx", std::span<const uint8_t> {});
     auto ctx = VTX::OpenReplayFile(path);
     EXPECT_FALSE(ctx);
     EXPECT_FALSE(ctx.error.empty());
@@ -104,8 +104,7 @@ TEST(CorruptFile, ValidMagicButTruncatedHeader) {
     // Just the magic bytes "VTXF" -- nothing else.  The header reader must
     // detect truncation instead of reading past EOF.
     const uint8_t bytes[] = {'V', 'T', 'X', 'F'};
-    const auto path = WriteRawBytes("truncated_magic.vtx",
-                                    std::span<const uint8_t>(bytes, sizeof(bytes)));
+    const auto path = WriteRawBytes("truncated_magic.vtx", std::span<const uint8_t>(bytes, sizeof(bytes)));
 
     auto ctx = VTX::OpenReplayFile(path);
     EXPECT_FALSE(ctx);
@@ -125,13 +124,12 @@ TEST(CorruptFile, TruncatedBeforeFooter) {
     ASSERT_GT(file_size, 100u);
 
     const auto truncated = VtxTest::OutputPath("truncated_before_footer.mutated.vtx");
-    std::filesystem::copy_file(original, truncated,
-                               std::filesystem::copy_options::overwrite_existing);
+    std::filesystem::copy_file(original, truncated, std::filesystem::copy_options::overwrite_existing);
     TruncateFile(truncated, file_size / 2);
 
     auto ctx = VTX::OpenReplayFile(truncated);
     EXPECT_FALSE(ctx);
-    EXPECT_FALSE(ctx.error.empty());  // must surface something, not crash
+    EXPECT_FALSE(ctx.error.empty()); // must surface something, not crash
 }
 
 TEST(CorruptFile, CorruptFooterSize) {
@@ -140,8 +138,7 @@ TEST(CorruptFile, CorruptFooterSize) {
     // instead of seeking to garbage (bug A1 variant).
     const auto original = WriteValidFlatBuffersFile("corrupt_footer_size");
     const auto mutated = VtxTest::OutputPath("corrupt_footer_size.mutated.vtx");
-    std::filesystem::copy_file(original, mutated,
-                               std::filesystem::copy_options::overwrite_existing);
+    std::filesystem::copy_file(original, mutated, std::filesystem::copy_options::overwrite_existing);
 
     {
         std::fstream f(mutated, std::ios::in | std::ios::out | std::ios::binary);
@@ -168,9 +165,8 @@ TEST(CorruptFile, ChunkOffsetBeyondEof) {
     // GetFrameSync must refuse to read past EOF and return nullptr rather than
     // returning stale bytes (bug A3).
     const auto original = WriteValidFlatBuffersFile("chunk_past_eof");
-    const auto mutated  = VtxTest::OutputPath("chunk_past_eof.mutated.vtx");
-    std::filesystem::copy_file(original, mutated,
-                               std::filesystem::copy_options::overwrite_existing);
+    const auto mutated = VtxTest::OutputPath("chunk_past_eof.mutated.vtx");
+    std::filesystem::copy_file(original, mutated, std::filesystem::copy_options::overwrite_existing);
 
     const auto size = std::filesystem::file_size(mutated);
     ASSERT_GT(size, 100u);
@@ -189,7 +185,7 @@ TEST(CorruptFile, ChunkOffsetBeyondEof) {
     // is that nothing crashes.
     for (int i = 0; i < ctx.reader->GetTotalFrames(); ++i) {
         const VTX::Frame* f = ctx.reader->GetFrameSync(i);
-        (void)f;  // may be null, may not -- but must not crash
+        (void)f; // may be null, may not -- but must not crash
     }
 }
 
@@ -202,8 +198,8 @@ TEST(CorruptFile, GetFrameSyncNegativeIndex) {
     auto ctx = VTX::OpenReplayFile(path);
     ASSERT_TRUE(ctx);
 
-    EXPECT_EQ(ctx.reader->GetFrameSync(-1),    nullptr);
-    EXPECT_EQ(ctx.reader->GetFrameSync(-100),  nullptr);
+    EXPECT_EQ(ctx.reader->GetFrameSync(-1), nullptr);
+    EXPECT_EQ(ctx.reader->GetFrameSync(-100), nullptr);
 }
 
 TEST(CorruptFile, GetFrameSyncIndexTooLarge) {
@@ -212,7 +208,7 @@ TEST(CorruptFile, GetFrameSyncIndexTooLarge) {
     ASSERT_TRUE(ctx);
 
     const int total = ctx.reader->GetTotalFrames();
-    EXPECT_EQ(ctx.reader->GetFrameSync(total),          nullptr);
-    EXPECT_EQ(ctx.reader->GetFrameSync(total + 100),    nullptr);
-    EXPECT_EQ(ctx.reader->GetFrameSync(1'000'000'000),  nullptr);
+    EXPECT_EQ(ctx.reader->GetFrameSync(total), nullptr);
+    EXPECT_EQ(ctx.reader->GetFrameSync(total + 100), nullptr);
+    EXPECT_EQ(ctx.reader->GetFrameSync(1'000'000'000), nullptr);
 }
diff --git a/tests/reader/test_open_replay_edges.cpp b/tests/reader/test_open_replay_edges.cpp
index a2d4eb7..6177e3c 100644
--- a/tests/reader/test_open_replay_edges.cpp
+++ b/tests/reader/test_open_replay_edges.cpp
@@ -17,36 +17,36 @@
 
 namespace {
 
-std::string WriteTinyReplay(const std::string& uuid) {
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath("open_edge_" + uuid + ".vtx");
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "OpenReplayEdges";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = 10;
-    cfg.use_compression  = true;
-
-    auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 0;
-    pc.string_properties = {"p", "name"};
-    pc.int32_properties  = {1, 0, 0};
-    pc.float_properties  = {100.0f, 50.0f};
-    pc.vector_properties = {VTX::Vector{}, VTX::Vector{}};
-    pc.quat_properties   = {VTX::Quat{}};
-    pc.bool_properties   = {true};
-    bucket.unique_ids.push_back("p");
-    bucket.entities.push_back(std::move(pc));
-    VTX::GameTime::GameTimeRegister t;
-    t.game_time = 0.0f;
-    writer->RecordFrame(f, t);
-    writer->Flush();
-    writer->Stop();
-    return cfg.output_filepath;
-}
+    std::string WriteTinyReplay(const std::string& uuid) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath("open_edge_" + uuid + ".vtx");
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "OpenReplayEdges";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 10;
+        cfg.use_compression = true;
+
+        auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {"p", "name"};
+        pc.int32_properties = {1, 0, 0};
+        pc.float_properties = {100.0f, 50.0f};
+        pc.vector_properties = {VTX::Vector {}, VTX::Vector {}};
+        pc.quat_properties = {VTX::Quat {}};
+        pc.bool_properties = {true};
+        bucket.unique_ids.push_back("p");
+        bucket.entities.push_back(std::move(pc));
+        VTX::GameTime::GameTimeRegister t;
+        t.game_time = 0.0f;
+        writer->RecordFrame(f, t);
+        writer->Flush();
+        writer->Stop();
+        return cfg.output_filepath;
+    }
 
 } // namespace
 
@@ -91,8 +91,7 @@ TEST(OpenReplayEdges, RelativePathResolvesAgainstCurrentWorkingDir) {
     // Compute the relative path from cwd.
     const auto cwd = std::filesystem::current_path();
     std::error_code ec;
-    const auto relative_path =
-        std::filesystem::relative(absolute_path, cwd, ec);
+    const auto relative_path = std::filesystem::relative(absolute_path, cwd, ec);
     ASSERT_FALSE(ec) << ec.message();
     ASSERT_FALSE(relative_path.empty());
 
@@ -114,8 +113,7 @@ TEST(OpenReplayEdges, UnicodeFilenameDoesNotCrash) {
 
     const auto unicode_path = VtxTest::OutputPath("replay_\xc3\xa1\xe3\x83\x86_tests.vtx");
     std::error_code ec;
-    std::filesystem::copy_file(good_path, unicode_path,
-                               std::filesystem::copy_options::overwrite_existing, ec);
+    std::filesystem::copy_file(good_path, unicode_path, std::filesystem::copy_options::overwrite_existing, ec);
     if (ec) {
         // Some filesystems / locales reject non-ASCII filenames.  In that
         // case we've still shown the API doesn't crash on the attempt.
diff --git a/tests/reader/test_reader_api.cpp b/tests/reader/test_reader_api.cpp
index 5ea29ad..7f1d558 100644
--- a/tests/reader/test_reader_api.cpp
+++ b/tests/reader/test_reader_api.cpp
@@ -15,100 +15,81 @@
 
 namespace {
 
-const char* FormatName(VTX::VtxFormat format)
-{
-    return format == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
-}
+    const char* FormatName(VTX::VtxFormat format) {
+        return format == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
+    }
 
-std::string UniqueOutputPath(VTX::VtxFormat format, const std::string& suffix)
-{
-    const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
-    return VtxTest::OutputPath(
-        VtxTest::SanitizePathComponent(std::string(info->test_suite_name())) + "_" +
-        VtxTest::SanitizePathComponent(std::string(info->name())) + "_" +
-        FormatName(format) + "_" + suffix + ".vtx");
-}
+    std::string UniqueOutputPath(VTX::VtxFormat format, const std::string& suffix) {
+        const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
+        return VtxTest::OutputPath(VtxTest::SanitizePathComponent(std::string(info->test_suite_name())) + "_" +
+                                   VtxTest::SanitizePathComponent(std::string(info->name())) + "_" +
+                                   FormatName(format) + "_" + suffix + ".vtx");
+    }
 
-VTX::WriterFacadeConfig MakeConfig(VTX::VtxFormat format,
-                                   const std::string& suffix,
-                                   int32_t chunk_max_frames)
-{
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath = UniqueOutputPath(format, suffix);
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name = "ReaderApiTest";
-    cfg.replay_uuid = "reader-api";
-    cfg.default_fps = 60.0f;
-    cfg.chunk_max_frames = chunk_max_frames;
-    cfg.use_compression = true;
-    return cfg;
-}
+    VTX::WriterFacadeConfig MakeConfig(VTX::VtxFormat format, const std::string& suffix, int32_t chunk_max_frames) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = UniqueOutputPath(format, suffix);
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "ReaderApiTest";
+        cfg.replay_uuid = "reader-api";
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = chunk_max_frames;
+        cfg.use_compression = true;
+        return cfg;
+    }
 
-std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(VTX::VtxFormat format,
-                                                    const VTX::WriterFacadeConfig& cfg)
-{
-    return format == VTX::VtxFormat::FlatBuffers
-        ? VTX::CreateFlatBuffersWriterFacade(cfg)
-        : VTX::CreateProtobuffWriterFacade(cfg);
-}
+    std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(VTX::VtxFormat format, const VTX::WriterFacadeConfig& cfg) {
+        return format == VTX::VtxFormat::FlatBuffers ? VTX::CreateFlatBuffersWriterFacade(cfg)
+                                                     : VTX::CreateProtobuffWriterFacade(cfg);
+    }
 
-VTX::Frame MakePlayerFrame(int frame_index)
-{
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
-
-    VTX::PropertyContainer pc;
-    pc.entity_type_id = 0;
-    pc.string_properties = {"player_0", "Alpha"};
-    pc.int32_properties = {1, frame_index, 0};
-    pc.float_properties = {100.0f - float(frame_index), 50.0f};
-    pc.vector_properties = {
-        VTX::Vector{double(frame_index), 0.0, 0.0},
-        VTX::Vector{1.0, 0.0, 0.0}
-    };
-    pc.quat_properties = {VTX::Quat{0.0f, 0.0f, 0.0f, 1.0f}};
-    pc.bool_properties = {true};
-
-    bucket.unique_ids.push_back("player_0");
-    bucket.entities.push_back(std::move(pc));
-    return f;
-}
+    VTX::Frame MakePlayerFrame(int frame_index) {
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
+
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {"player_0", "Alpha"};
+        pc.int32_properties = {1, frame_index, 0};
+        pc.float_properties = {100.0f - float(frame_index), 50.0f};
+        pc.vector_properties = {VTX::Vector {double(frame_index), 0.0, 0.0}, VTX::Vector {1.0, 0.0, 0.0}};
+        pc.quat_properties = {VTX::Quat {0.0f, 0.0f, 0.0f, 1.0f}};
+        pc.bool_properties = {true};
+
+        bucket.unique_ids.push_back("player_0");
+        bucket.entities.push_back(std::move(pc));
+        return f;
+    }
 
-void WriteReplay(VTX::VtxFormat format,
-                 const std::string& path,
-                 int frames,
-                 int32_t chunk_max_frames)
-{
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath = path;
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name = "ReaderApiTest";
-    cfg.replay_uuid = "reader-api";
-    cfg.default_fps = 60.0f;
-    cfg.chunk_max_frames = chunk_max_frames;
-    cfg.use_compression = true;
-
-    auto writer = CreateWriter(format, cfg);
-    for (int i = 0; i < frames; ++i) {
-        auto frame = MakePlayerFrame(i);
-        VTX::GameTime::GameTimeRegister t;
-        t.game_time = float(i) / 60.0f;
-        writer->RecordFrame(frame, t);
+    void WriteReplay(VTX::VtxFormat format, const std::string& path, int frames, int32_t chunk_max_frames) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = path;
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "ReaderApiTest";
+        cfg.replay_uuid = "reader-api";
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = chunk_max_frames;
+        cfg.use_compression = true;
+
+        auto writer = CreateWriter(format, cfg);
+        for (int i = 0; i < frames; ++i) {
+            auto frame = MakePlayerFrame(i);
+            VTX::GameTime::GameTimeRegister t;
+            t.game_time = float(i) / 60.0f;
+            writer->RecordFrame(frame, t);
+        }
+        writer->Stop();
     }
-    writer->Stop();
-}
 
-int ReadScore(const VTX::Frame& frame)
-{
-    return frame.GetBuckets()[0].entities[0].int32_properties[1];
-}
+    int ReadScore(const VTX::Frame& frame) {
+        return frame.GetBuckets()[0].entities[0].int32_properties[1];
+    }
 
 } // namespace
 
 class ReaderApiTest : public ::testing::TestWithParam<VTX::VtxFormat> {};
 
-TEST_P(ReaderApiTest, CreateAccessorReadsSchemaDrivenEntityValues)
-{
+TEST_P(ReaderApiTest, CreateAccessorReadsSchemaDrivenEntityValues) {
     const auto cfg = MakeConfig(GetParam(), "accessor", 8);
     WriteReplay(GetParam(), cfg.output_filepath, 1, 8);
 
@@ -136,8 +117,7 @@ TEST_P(ReaderApiTest, CreateAccessorReadsSchemaDrivenEntityValues)
     EXPECT_FALSE(accessor.Get<float>("Player", "Name").IsValid());
 }
 
-TEST_P(ReaderApiTest, FrameRangeAndContextReturnExpectedFrames)
-{
+TEST_P(ReaderApiTest, FrameRangeAndContextReturnExpectedFrames) {
     const auto cfg = MakeConfig(GetParam(), "range_context", 8);
     WriteReplay(GetParam(), cfg.output_filepath, 5, 8);
 
@@ -159,8 +139,7 @@ TEST_P(ReaderApiTest, FrameRangeAndContextReturnExpectedFrames)
     EXPECT_EQ(ReadScore(context[2]), 3);
 }
 
-TEST_P(ReaderApiTest, OutOfBoundsQueriesReturnEmptyResults)
-{
+TEST_P(ReaderApiTest, OutOfBoundsQueriesReturnEmptyResults) {
     const auto cfg = MakeConfig(GetParam(), "oob", 8);
     WriteReplay(GetParam(), cfg.output_filepath, 2, 8);
 
@@ -175,8 +154,7 @@ TEST_P(ReaderApiTest, OutOfBoundsQueriesReturnEmptyResults)
     EXPECT_TRUE(range.empty());
 }
 
-TEST(ReaderApiFlatBuffers, CacheWindowZeroEvictsPreviousChunks)
-{
+TEST(ReaderApiFlatBuffers, CacheWindowZeroEvictsPreviousChunks) {
     const auto path = VtxTest::OutputPath("ReaderApiFlatBuffers_CacheWindowZeroEvictsPreviousChunks.vtx");
     WriteReplay(VTX::VtxFormat::FlatBuffers, path, 3, 1);
 
@@ -225,10 +203,8 @@ TEST(ReaderApiFlatBuffers, CacheWindowZeroEvictsPreviousChunks)
 // the EWMA and still trigger laterals.  This catches a regression of
 // the EWMA logic (hitting >= 5*N) while tolerating reasonable
 // variations in bootstrap behaviour.
-TEST(ReaderApiFlatBuffers, RandomAccessSkipsLateralPrefetches)
-{
-    const auto path = VtxTest::OutputPath(
-        "ReaderApiFlatBuffers_RandomAccessSkipsLateralPrefetches.vtx");
+TEST(ReaderApiFlatBuffers, RandomAccessSkipsLateralPrefetches) {
+    const auto path = VtxTest::OutputPath("ReaderApiFlatBuffers_RandomAccessSkipsLateralPrefetches.vtx");
     // 20 chunks of 5 frames each -> 100 frames total.  Small enough
     // to run in milliseconds, big enough that jumps of 10 exceed the
     // window of 2.
@@ -242,9 +218,7 @@ TEST(ReaderApiFlatBuffers, RandomAccessSkipsLateralPrefetches)
     // The indices below map to 10 chunks, each jump distance 10 chunks
     // (well above window=2), guaranteeing the EWMA crosses its
     // threshold after ~2 jumps.
-    const std::vector<int32_t> jump_frames{
-        0, 50, 10, 60, 20, 70, 30, 80, 40, 90
-    };
+    const std::vector<int32_t> jump_frames {0, 50, 10, 60, 20, 70, 30, 80, 40, 90};
 
     for (int32_t f : jump_frames) {
         ASSERT_NE(ctx.reader->GetFrameSync(f), nullptr);
@@ -261,8 +235,7 @@ TEST(ReaderApiFlatBuffers, RandomAccessSkipsLateralPrefetches)
     // this would be ~5x.
     EXPECT_LE(total_seen, jump_frames.size() * 2)
         << "Expected random access to skip lateral prefetches "
-        << "but saw " << total_seen << " chunks loaded vs "
-        << jump_frames.size() << " jumps.";
+        << "but saw " << total_seen << " chunks loaded vs " << jump_frames.size() << " jumps.";
 }
 
 // Regression for the "stale-cancelled prefetch blocks re-entry" bug.
@@ -313,11 +286,9 @@ TEST(ReaderApiFlatBuffers, CancelledPrefetchReEntersWindow) {
 // §3.A regression coverage.  WarmAt must trigger an asynchronous load
 // of the chunk containing `frame_index` without blocking the caller,
 // and without requiring a subsequent GetFrame to fire the load.
-TEST(ReaderApiFlatBuffers, WarmAtTriggersAsyncLoadWithoutReading)
-{
-    const auto path = VtxTest::OutputPath(
-        "ReaderApiFlatBuffers_WarmAtTriggersAsyncLoadWithoutReading.vtx");
-    WriteReplay(VTX::VtxFormat::FlatBuffers, path, 50, 10);  // 5 chunks
+TEST(ReaderApiFlatBuffers, WarmAtTriggersAsyncLoadWithoutReading) {
+    const auto path = VtxTest::OutputPath("ReaderApiFlatBuffers_WarmAtTriggersAsyncLoadWithoutReading.vtx");
+    WriteReplay(VTX::VtxFormat::FlatBuffers, path, 50, 10); // 5 chunks
 
     auto ctx = VTX::OpenReplayFile(path);
     ASSERT_TRUE(ctx) << ctx.error;
@@ -339,8 +310,7 @@ TEST(ReaderApiFlatBuffers, WarmAtTriggersAsyncLoadWithoutReading)
     const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5);
     while (std::chrono::steady_clock::now() < deadline) {
         auto snap = ctx.chunk_state->GetSnapshot();
-        if (std::find(snap.loaded_chunks.begin(), snap.loaded_chunks.end(), 3)
-            != snap.loaded_chunks.end()) {
+        if (std::find(snap.loaded_chunks.begin(), snap.loaded_chunks.end(), 3) != snap.loaded_chunks.end()) {
             break;
         }
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -350,14 +320,11 @@ TEST(ReaderApiFlatBuffers, WarmAtTriggersAsyncLoadWithoutReading)
 
     auto snap = ctx.chunk_state->GetSnapshot();
     ASSERT_FALSE(snap.loaded_chunks.empty());
-    EXPECT_NE(std::find(snap.loaded_chunks.begin(), snap.loaded_chunks.end(), 3),
-              snap.loaded_chunks.end());
+    EXPECT_NE(std::find(snap.loaded_chunks.begin(), snap.loaded_chunks.end(), 3), snap.loaded_chunks.end());
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    BothBackends,
-    ReaderApiTest,
-    ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
-    [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
-        return std::string(FormatName(info.param));
-    });
+INSTANTIATE_TEST_SUITE_P(BothBackends, ReaderApiTest,
+                         ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
+                         [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
+                             return std::string(FormatName(info.param));
+                         });
diff --git a/tests/reader/test_reader_context.cpp b/tests/reader/test_reader_context.cpp
index 688b1ee..2b083c7 100644
--- a/tests/reader/test_reader_context.cpp
+++ b/tests/reader/test_reader_context.cpp
@@ -19,46 +19,46 @@
 
 namespace {
 
-// Writes a tiny 5-frame FlatBuffers replay and returns the path.
-// uuid is used both as the filename tail and as the replay UUID so it's easy
-// to identify which test produced which artefact on disk.
-std::string WriteTinyFlatBuffersFile(const std::string& uuid) {
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath("reader_" + uuid + ".vtx");
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "ReaderContextTest";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = 10;
-    cfg.use_compression  = true;
-
-    {
-        auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
-        for (int i = 0; i < 5; ++i) {
-            VTX::Frame f;
-            auto& bucket = f.CreateBucket("entity");
-
-            VTX::PropertyContainer pc;
-            pc.entity_type_id    = 0;
-            pc.string_properties = {"p", "name"};
-            pc.int32_properties  = {1, 0, 0};
-            pc.float_properties  = {100.0f, 50.0f};
-            pc.vector_properties = {VTX::Vector{}, VTX::Vector{}};
-            pc.quat_properties   = {VTX::Quat{}};
-            pc.bool_properties   = {true};
-
-            bucket.unique_ids.push_back("p");
-            bucket.entities.push_back(std::move(pc));
-
-            VTX::GameTime::GameTimeRegister t;
-            t.game_time = float(i) / 60.0f;
-            writer->RecordFrame(f, t);
-        }
-        writer->Flush();
-        writer->Stop();
-    }  // release -- file is fully closed before returning
-    return cfg.output_filepath;
-}
+    // Writes a tiny 5-frame FlatBuffers replay and returns the path.
+    // uuid is used both as the filename tail and as the replay UUID so it's easy
+    // to identify which test produced which artefact on disk.
+    std::string WriteTinyFlatBuffersFile(const std::string& uuid) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath("reader_" + uuid + ".vtx");
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "ReaderContextTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 10;
+        cfg.use_compression = true;
+
+        {
+            auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
+            for (int i = 0; i < 5; ++i) {
+                VTX::Frame f;
+                auto& bucket = f.CreateBucket("entity");
+
+                VTX::PropertyContainer pc;
+                pc.entity_type_id = 0;
+                pc.string_properties = {"p", "name"};
+                pc.int32_properties = {1, 0, 0};
+                pc.float_properties = {100.0f, 50.0f};
+                pc.vector_properties = {VTX::Vector {}, VTX::Vector {}};
+                pc.quat_properties = {VTX::Quat {}};
+                pc.bool_properties = {true};
+
+                bucket.unique_ids.push_back("p");
+                bucket.entities.push_back(std::move(pc));
+
+                VTX::GameTime::GameTimeRegister t;
+                t.game_time = float(i) / 60.0f;
+                writer->RecordFrame(f, t);
+            }
+            writer->Flush();
+            writer->Stop();
+        } // release -- file is fully closed before returning
+        return cfg.output_filepath;
+    }
 
 } // namespace
 
@@ -73,15 +73,14 @@ class ReaderContextHappy : public ::testing::Test {
         // Name output after the current test so parallel ctest invocations
         // don't race over the same filename.
         const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
-        const std::string uuid =
-            std::string(info->test_suite_name()) + "_" + info->name();
+        const std::string uuid = std::string(info->test_suite_name()) + "_" + info->name();
 
         path_ = WriteTinyFlatBuffersFile(uuid);
-        ctx_  = VTX::OpenReplayFile(path_);
+        ctx_ = VTX::OpenReplayFile(path_);
         ASSERT_TRUE(ctx_) << ctx_.error;
     }
 
-    std::string        path_;
+    std::string path_;
     VTX::ReaderContext ctx_;
 };
 
diff --git a/tests/util/test_fixtures.h b/tests/util/test_fixtures.h
index f363d66..cc07bef 100644
--- a/tests/util/test_fixtures.h
+++ b/tests/util/test_fixtures.h
@@ -20,59 +20,57 @@
 
 namespace VtxTest {
 
-/// Absolute path to the read-only fixtures directory.
-inline std::string FixturePath(const std::string& name) {
-    return std::string(VTX_TEST_FIXTURES_DIR) + "/" + name;
-}
+    /// Absolute path to the read-only fixtures directory.
+    inline std::string FixturePath(const std::string& name) {
+        return std::string(VTX_TEST_FIXTURES_DIR) + "/" + name;
+    }
 
-/// Absolute path for transient test artefacts.  Directory is created by the
-/// build system but we recreate on demand in case the tester nuked it.
-inline std::string OutputPath(const std::string& name) {
-    std::filesystem::path p = VTX_TEST_OUTPUT_DIR;
-    std::filesystem::create_directories(p);
-    return (p / name).string();
-}
+    /// Absolute path for transient test artefacts.  Directory is created by the
+    /// build system but we recreate on demand in case the tester nuked it.
+    inline std::string OutputPath(const std::string& name) {
+        std::filesystem::path p = VTX_TEST_OUTPUT_DIR;
+        std::filesystem::create_directories(p);
+        return (p / name).string();
+    }
 
-/// Replaces path separators and other problematic filename characters so test
-/// names can be embedded safely into OutputPath() results.
-inline std::string SanitizePathComponent(std::string value) {
-    for (char& ch : value) {
-        const unsigned char uch = static_cast<unsigned char>(ch);
-        if (std::isalnum(uch) || ch == '.' || ch == '_' || ch == '-') {
-            continue;
+    /// Replaces path separators and other problematic filename characters so test
+    /// names can be embedded safely into OutputPath() results.
+    inline std::string SanitizePathComponent(std::string value) {
+        for (char& ch : value) {
+            const unsigned char uch = static_cast<unsigned char>(ch);
+            if (std::isalnum(uch) || ch == '.' || ch == '_' || ch == '-') {
+                continue;
+            }
+            ch = '_';
         }
-        ch = '_';
+        return value;
     }
-    return value;
-}
 
-/// Reads an entire file into memory.  Returns empty on failure.
-inline std::vector<std::byte> ReadAllBytes(const std::string& path) {
-    std::ifstream ifs(path, std::ios::binary | std::ios::ate);
-    if (!ifs) return {};
-    const auto sz = ifs.tellg();
-    if (sz <= 0) return {};
-    ifs.seekg(0);
-    std::vector<std::byte> buf(static_cast<size_t>(sz));
-    ifs.read(reinterpret_cast<char*>(buf.data()), sz);
-    return buf;
-}
+    /// Reads an entire file into memory.  Returns empty on failure.
+    inline std::vector<std::byte> ReadAllBytes(const std::string& path) {
+        std::ifstream ifs(path, std::ios::binary | std::ios::ate);
+        if (!ifs)
+            return {};
+        const auto sz = ifs.tellg();
+        if (sz <= 0)
+            return {};
+        ifs.seekg(0);
+        std::vector<std::byte> buf(static_cast<size_t>(sz));
+        ifs.read(reinterpret_cast<char*>(buf.data()), sz);
+        return buf;
+    }
 
-/// Builds a minimal PropertyContainer with a predictable shape.  Useful for
-/// content_hash and diff assertions that don't need a full schema.
-inline VTX::PropertyContainer MakeSimpleEntity(
-    int32_t  type_id,
-    float    health,
-    VTX::Vector position,
-    const std::string& name = "entity")
-{
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = type_id;
-    pc.string_properties = { name };
-    pc.float_properties  = { health };
-    pc.vector_properties = { position };
-    pc.content_hash      = VTX::Helpers::CalculateContainerHash(pc);
-    return pc;
-}
+    /// Builds a minimal PropertyContainer with a predictable shape.  Useful for
+    /// content_hash and diff assertions that don't need a full schema.
+    inline VTX::PropertyContainer MakeSimpleEntity(int32_t type_id, float health, VTX::Vector position,
+                                                   const std::string& name = "entity") {
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = type_id;
+        pc.string_properties = {name};
+        pc.float_properties = {health};
+        pc.vector_properties = {position};
+        pc.content_hash = VTX::Helpers::CalculateContainerHash(pc);
+        return pc;
+    }
 
 } // namespace VtxTest
diff --git a/tests/util/test_main.cpp b/tests/util/test_main.cpp
index b8e2031..6cc2d14 100644
--- a/tests/util/test_main.cpp
+++ b/tests/util/test_main.cpp
@@ -6,18 +6,16 @@
 
 namespace {
 
-// Install a silent sink on the VTX logger so info/debug noise doesn't spam the
-// test runner.  Tests that want to assert on logger output can pull from an
-// override sink instead (see util/test_fixtures.h).
-void InstallSilentLoggerSink()
-{
-    VTX::Logger::Instance().AddSink([](const VTX::Logger::Entry&) {});
-}
+    // Install a silent sink on the VTX logger so info/debug noise doesn't spam the
+    // test runner.  Tests that want to assert on logger output can pull from an
+    // override sink instead (see util/test_fixtures.h).
+    void InstallSilentLoggerSink() {
+        VTX::Logger::Instance().AddSink([](const VTX::Logger::Entry&) {});
+    }
 
 } // namespace
 
-int main(int argc, char** argv)
-{
+int main(int argc, char** argv) {
     InstallSilentLoggerSink();
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
diff --git a/tests/writer/test_roundtrip.cpp b/tests/writer/test_roundtrip.cpp
index 7c61e68..3fa3121 100644
--- a/tests/writer/test_roundtrip.cpp
+++ b/tests/writer/test_roundtrip.cpp
@@ -17,34 +17,31 @@
 
 namespace {
 
-constexpr int   kTotalFrames    = 120;     // enough to force multiple chunks
-constexpr int   kChunkMaxFrames = 40;      // = 3 chunks
-constexpr float kFps            = 60.0f;
+    constexpr int kTotalFrames = 120;   // enough to force multiple chunks
+    constexpr int kChunkMaxFrames = 40; // = 3 chunks
+    constexpr float kFps = 60.0f;
 
-const char* FormatName(VTX::VtxFormat f) {
-    return f == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
-}
+    const char* FormatName(VTX::VtxFormat f) {
+        return f == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
+    }
 
-VTX::Frame BuildFrame(int frame_index) {
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
-
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 0;
-    pc.string_properties = { "player_0", "Alpha" };
-    pc.int32_properties  = { 1, frame_index, 0 };                // Team, Score(=frame), Deaths
-    pc.float_properties  = { 100.0f - float(frame_index), 50.0f };
-    pc.vector_properties = {
-        VTX::Vector{ double(frame_index), 0.0, 0.0 },
-        VTX::Vector{ 1.0, 0.0, 0.0 }
-    };
-    pc.quat_properties = { VTX::Quat{0.0f, 0.0f, 0.0f, 1.0f} };
-    pc.bool_properties = { true };
-
-    bucket.unique_ids.push_back("player_0");
-    bucket.entities.push_back(std::move(pc));
-    return f;
-}
+    VTX::Frame BuildFrame(int frame_index) {
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
+
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {"player_0", "Alpha"};
+        pc.int32_properties = {1, frame_index, 0}; // Team, Score(=frame), Deaths
+        pc.float_properties = {100.0f - float(frame_index), 50.0f};
+        pc.vector_properties = {VTX::Vector {double(frame_index), 0.0, 0.0}, VTX::Vector {1.0, 0.0, 0.0}};
+        pc.quat_properties = {VTX::Quat {0.0f, 0.0f, 0.0f, 1.0f}};
+        pc.bool_properties = {true};
+
+        bucket.unique_ids.push_back("player_0");
+        bucket.entities.push_back(std::move(pc));
+        return f;
+    }
 
 } // namespace
 
@@ -55,27 +52,22 @@ VTX::Frame BuildFrame(int frame_index) {
 
 class RoundtripTest : public ::testing::TestWithParam<VTX::VtxFormat> {
 protected:
-    VTX::WriterFacadeConfig MakeConfig(const std::string& suffix,
-                                       const std::string& uuid) const
-    {
+    VTX::WriterFacadeConfig MakeConfig(const std::string& suffix, const std::string& uuid) const {
         VTX::WriterFacadeConfig cfg;
-        cfg.output_filepath  = VtxTest::OutputPath(
-            std::string("roundtrip_") + FormatName(GetParam()) + "_" + suffix + ".vtx");
+        cfg.output_filepath =
+            VtxTest::OutputPath(std::string("roundtrip_") + FormatName(GetParam()) + "_" + suffix + ".vtx");
         cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-        cfg.replay_name      = "RoundtripTest";
-        cfg.replay_uuid      = uuid;
-        cfg.default_fps      = kFps;
+        cfg.replay_name = "RoundtripTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = kFps;
         cfg.chunk_max_frames = kChunkMaxFrames;
-        cfg.use_compression  = true;
+        cfg.use_compression = true;
         return cfg;
     }
 
-    std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(
-        const VTX::WriterFacadeConfig& cfg) const
-    {
-        return GetParam() == VTX::VtxFormat::FlatBuffers
-            ? VTX::CreateFlatBuffersWriterFacade(cfg)
-            : VTX::CreateProtobuffWriterFacade(cfg);
+    std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(const VTX::WriterFacadeConfig& cfg) const {
+        return GetParam() == VTX::VtxFormat::FlatBuffers ? VTX::CreateFlatBuffersWriterFacade(cfg)
+                                                         : VTX::CreateProtobuffWriterFacade(cfg);
     }
 };
 
@@ -147,11 +139,11 @@ TEST_P(RoundtripTest, AcceptsHistoricalUtc) {
         auto writer = CreateWriter(cfg);
         ASSERT_TRUE(writer);
 
-        const int64_t base_utc = 1'745'000'000LL * 10'000'000LL;  // 2025-04-19
+        const int64_t base_utc = 1'745'000'000LL * 10'000'000LL; // 2025-04-19
         for (int i = 0; i < 20; ++i) {
             auto frame = BuildFrame(i);
             VTX::GameTime::GameTimeRegister t;
-            t.game_time        = float(i) / kFps;
+            t.game_time = float(i) / kFps;
             t.created_utc_time = base_utc + int64_t(i) * 166'666LL;
             writer->RecordFrame(frame, t);
         }
@@ -172,11 +164,8 @@ TEST_P(RoundtripTest, AcceptsHistoricalUtc) {
 //   BothBackends/RoundtripTest.AcceptsHistoricalUtc/Protobuf
 // ---------------------------------------------------------------------------
 
-INSTANTIATE_TEST_SUITE_P(
-    BothBackends,
-    RoundtripTest,
-    ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
-    [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
-        return std::string(FormatName(info.param));
-    }
-);
+INSTANTIATE_TEST_SUITE_P(BothBackends, RoundtripTest,
+                         ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
+                         [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
+                             return std::string(FormatName(info.param));
+                         });
diff --git a/tests/writer/test_writer_advanced.cpp b/tests/writer/test_writer_advanced.cpp
index 73a61de..8c3a81a 100644
--- a/tests/writer/test_writer_advanced.cpp
+++ b/tests/writer/test_writer_advanced.cpp
@@ -14,96 +14,81 @@
 
 namespace {
 
-const char* FormatName(VTX::VtxFormat format)
-{
-    return format == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
-}
+    const char* FormatName(VTX::VtxFormat format) {
+        return format == VTX::VtxFormat::FlatBuffers ? "FlatBuffers" : "Protobuf";
+    }
 
-std::string UniqueOutputPath(VTX::VtxFormat format, const std::string& suffix)
-{
-    const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
-    return VtxTest::OutputPath(
-        VtxTest::SanitizePathComponent(std::string(info->test_suite_name())) + "_" +
-        VtxTest::SanitizePathComponent(std::string(info->name())) + "_" +
-        FormatName(format) + "_" + suffix + ".vtx");
-}
+    std::string UniqueOutputPath(VTX::VtxFormat format, const std::string& suffix) {
+        const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
+        return VtxTest::OutputPath(VtxTest::SanitizePathComponent(std::string(info->test_suite_name())) + "_" +
+                                   VtxTest::SanitizePathComponent(std::string(info->name())) + "_" +
+                                   FormatName(format) + "_" + suffix + ".vtx");
+    }
 
-VTX::WriterFacadeConfig MakeConfig(VTX::VtxFormat format,
-                                   const std::string& suffix,
-                                   int32_t chunk_max_frames,
-                                   bool use_compression)
-{
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath = UniqueOutputPath(format, suffix);
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name = "WriterAdvancedTest";
-    cfg.replay_uuid = "";
-    cfg.default_fps = 60.0f;
-    cfg.chunk_max_frames = chunk_max_frames;
-    cfg.use_compression = use_compression;
-    return cfg;
-}
+    VTX::WriterFacadeConfig MakeConfig(VTX::VtxFormat format, const std::string& suffix, int32_t chunk_max_frames,
+                                       bool use_compression) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = UniqueOutputPath(format, suffix);
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "WriterAdvancedTest";
+        cfg.replay_uuid = "";
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = chunk_max_frames;
+        cfg.use_compression = use_compression;
+        return cfg;
+    }
 
-std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(VTX::VtxFormat format,
-                                                    const VTX::WriterFacadeConfig& cfg)
-{
-    return format == VTX::VtxFormat::FlatBuffers
-        ? VTX::CreateFlatBuffersWriterFacade(cfg)
-        : VTX::CreateProtobuffWriterFacade(cfg);
-}
+    std::unique_ptr<VTX::IVtxWriterFacade> CreateWriter(VTX::VtxFormat format, const VTX::WriterFacadeConfig& cfg) {
+        return format == VTX::VtxFormat::FlatBuffers ? VTX::CreateFlatBuffersWriterFacade(cfg)
+                                                     : VTX::CreateProtobuffWriterFacade(cfg);
+    }
 
-VTX::Frame MakeSimpleFrame(int frame_index)
-{
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
-
-    VTX::PropertyContainer pc;
-    pc.entity_type_id = 0;
-    pc.string_properties = {"player_0", "Alpha"};
-    pc.int32_properties = {1, frame_index, 0};
-    pc.float_properties = {100.0f - float(frame_index), 50.0f};
-    pc.vector_properties = {
-        VTX::Vector{double(frame_index), 0.0, 0.0},
-        VTX::Vector{1.0, 0.0, 0.0}
-    };
-    pc.quat_properties = {VTX::Quat{0.0f, 0.0f, 0.0f, 1.0f}};
-    pc.bool_properties = {true};
-
-    bucket.unique_ids.push_back("player_0");
-    bucket.entities.push_back(std::move(pc));
-    return f;
-}
+    VTX::Frame MakeSimpleFrame(int frame_index) {
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
+
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {"player_0", "Alpha"};
+        pc.int32_properties = {1, frame_index, 0};
+        pc.float_properties = {100.0f - float(frame_index), 50.0f};
+        pc.vector_properties = {VTX::Vector {double(frame_index), 0.0, 0.0}, VTX::Vector {1.0, 0.0, 0.0}};
+        pc.quat_properties = {VTX::Quat {0.0f, 0.0f, 0.0f, 1.0f}};
+        pc.bool_properties = {true};
+
+        bucket.unique_ids.push_back("player_0");
+        bucket.entities.push_back(std::move(pc));
+        return f;
+    }
 
-VTX::Frame MakeUnsortedTypesFrame()
-{
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
+    VTX::Frame MakeUnsortedTypesFrame() {
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
 
-    VTX::PropertyContainer type1_a;
-    type1_a.entity_type_id = 1;
-    type1_a.string_properties = {"id_b", "Bravo"};
+        VTX::PropertyContainer type1_a;
+        type1_a.entity_type_id = 1;
+        type1_a.string_properties = {"id_b", "Bravo"};
 
-    VTX::PropertyContainer type0;
-    type0.entity_type_id = 0;
-    type0.string_properties = {"id_a", "Alpha"};
+        VTX::PropertyContainer type0;
+        type0.entity_type_id = 0;
+        type0.string_properties = {"id_a", "Alpha"};
 
-    VTX::PropertyContainer type1_b;
-    type1_b.entity_type_id = 1;
-    type1_b.string_properties = {"id_c", "Charlie"};
+        VTX::PropertyContainer type1_b;
+        type1_b.entity_type_id = 1;
+        type1_b.string_properties = {"id_c", "Charlie"};
 
-    bucket.unique_ids = {"id_b", "id_a", "id_c"};
-    bucket.entities.push_back(type1_a);
-    bucket.entities.push_back(type0);
-    bucket.entities.push_back(type1_b);
-    return f;
-}
+        bucket.unique_ids = {"id_b", "id_a", "id_c"};
+        bucket.entities.push_back(type1_a);
+        bucket.entities.push_back(type0);
+        bucket.entities.push_back(type1_b);
+        return f;
+    }
 
 } // namespace
 
 class WriterAdvancedTest : public ::testing::TestWithParam<VTX::VtxFormat> {};
 
-TEST_P(WriterAdvancedTest, ChunkMaxFramesProducesExpectedSeekTable)
-{
+TEST_P(WriterAdvancedTest, ChunkMaxFramesProducesExpectedSeekTable) {
     const auto cfg = MakeConfig(GetParam(), "chunking", 1, false);
 
     {
@@ -134,8 +119,7 @@ TEST_P(WriterAdvancedTest, ChunkMaxFramesProducesExpectedSeekTable)
     EXPECT_EQ(seek_table[2].end_frame, 2);
 }
 
-TEST_P(WriterAdvancedTest, SortsEntitiesByTypeAndBuildsTypeRanges)
-{
+TEST_P(WriterAdvancedTest, SortsEntitiesByTypeAndBuildsTypeRanges) {
     const auto cfg = MakeConfig(GetParam(), "sorted_types", 8, true);
 
     {
@@ -173,8 +157,7 @@ TEST_P(WriterAdvancedTest, SortsEntitiesByTypeAndBuildsTypeRanges)
     EXPECT_EQ(bucket.type_ranges[1].count, 2);
 }
 
-TEST_P(WriterAdvancedTest, UncompressedFilesRemainReadableAndUseDefaultUuid)
-{
+TEST_P(WriterAdvancedTest, UncompressedFilesRemainReadableAndUseDefaultUuid) {
     const auto cfg = MakeConfig(GetParam(), "uncompressed", 8, false);
 
     {
@@ -201,8 +184,7 @@ TEST_P(WriterAdvancedTest, UncompressedFilesRemainReadableAndUseDefaultUuid)
     EXPECT_EQ(footer.total_frames, 2);
 }
 
-TEST_P(WriterAdvancedTest, StopWithoutFramesProducesReadableEmptyReplay)
-{
+TEST_P(WriterAdvancedTest, StopWithoutFramesProducesReadableEmptyReplay) {
     const auto cfg = MakeConfig(GetParam(), "empty", 8, true);
 
     {
@@ -217,8 +199,7 @@ TEST_P(WriterAdvancedTest, StopWithoutFramesProducesReadableEmptyReplay)
     EXPECT_TRUE(ctx.reader->GetSeekTable().empty());
 }
 
-TEST_P(WriterAdvancedTest, ThrowsWhenParentDirectoryDoesNotExist)
-{
+TEST_P(WriterAdvancedTest, ThrowsWhenParentDirectoryDoesNotExist) {
     auto cfg = MakeConfig(GetParam(), "missing_dir", 8, true);
     const std::filesystem::path missing_dir =
         std::filesystem::path(VtxTest::OutputPath("writer_missing_dir")) / "nested";
@@ -233,10 +214,8 @@ TEST_P(WriterAdvancedTest, ThrowsWhenParentDirectoryDoesNotExist)
         std::runtime_error);
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    BothBackends,
-    WriterAdvancedTest,
-    ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
-    [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
-        return std::string(FormatName(info.param));
-    });
+INSTANTIATE_TEST_SUITE_P(BothBackends, WriterAdvancedTest,
+                         ::testing::Values(VTX::VtxFormat::FlatBuffers, VTX::VtxFormat::Protobuf),
+                         [](const ::testing::TestParamInfo<VTX::VtxFormat>& info) {
+                             return std::string(FormatName(info.param));
+                         });
diff --git a/tests/writer/test_writer_basic.cpp b/tests/writer/test_writer_basic.cpp
index a2b0310..764f763 100644
--- a/tests/writer/test_writer_basic.cpp
+++ b/tests/writer/test_writer_basic.cpp
@@ -10,35 +10,35 @@
 
 namespace {
 
-VTX::WriterFacadeConfig MakeConfig(const std::string& out_name, const std::string& uuid) {
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath(out_name);
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "WriterBasicTest";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = 50;
-    cfg.use_compression  = true;
-    return cfg;
-}
+    VTX::WriterFacadeConfig MakeConfig(const std::string& out_name, const std::string& uuid) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath(out_name);
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "WriterBasicTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = 50;
+        cfg.use_compression = true;
+        return cfg;
+    }
 
-VTX::Frame MakeOneEntityFrame() {
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
+    VTX::Frame MakeOneEntityFrame() {
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
 
-    VTX::PropertyContainer pc;
-    pc.entity_type_id = 0;  // Player
-    pc.string_properties = {"id_a", "Alpha"};
-    pc.int32_properties  = {1, 0, 0};                  // Team, Score, Deaths
-    pc.float_properties  = {100.0f, 50.0f};            // Health, Armor
-    pc.vector_properties = {VTX::Vector{0.0, 0.0, 0.0}, VTX::Vector{0.0, 0.0, 0.0}};
-    pc.quat_properties   = {VTX::Quat{0.0f, 0.0f, 0.0f, 1.0f}};
-    pc.bool_properties   = {true};
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0; // Player
+        pc.string_properties = {"id_a", "Alpha"};
+        pc.int32_properties = {1, 0, 0};       // Team, Score, Deaths
+        pc.float_properties = {100.0f, 50.0f}; // Health, Armor
+        pc.vector_properties = {VTX::Vector {0.0, 0.0, 0.0}, VTX::Vector {0.0, 0.0, 0.0}};
+        pc.quat_properties = {VTX::Quat {0.0f, 0.0f, 0.0f, 1.0f}};
+        pc.bool_properties = {true};
 
-    bucket.unique_ids.push_back("id_a");
-    bucket.entities.push_back(std::move(pc));
-    return f;
-}
+        bucket.unique_ids.push_back("id_a");
+        bucket.entities.push_back(std::move(pc));
+        return f;
+    }
 
 } // namespace
 
@@ -48,7 +48,7 @@ TEST(WriterBasic, FlatBuffersFactoryProducesValidWriter) {
         auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
         ASSERT_TRUE(writer);
         writer->Stop();
-    }  // destructor releases any remaining file handles
+    } // destructor releases any remaining file handles
     EXPECT_TRUE(std::filesystem::exists(cfg.output_filepath));
     EXPECT_GT(std::filesystem::file_size(cfg.output_filepath), 0u);
 }
@@ -78,7 +78,7 @@ TEST(WriterBasic, RecordAndStopWritesNonEmptyFile) {
         }
         writer->Flush();
         writer->Stop();
-    }  // release writer so the file is fully closed before we inspect it
+    } // release writer so the file is fully closed before we inspect it
 
     ASSERT_TRUE(std::filesystem::exists(cfg.output_filepath));
     EXPECT_GT(std::filesystem::file_size(cfg.output_filepath), 100u);
diff --git a/tests/writer/test_writer_edges.cpp b/tests/writer/test_writer_edges.cpp
index 7265cb3..c8bacf9 100644
--- a/tests/writer/test_writer_edges.cpp
+++ b/tests/writer/test_writer_edges.cpp
@@ -17,40 +17,37 @@
 
 namespace {
 
-VTX::WriterFacadeConfig MakeBaseConfig(const std::string& out_name,
-                                       const std::string& uuid,
-                                       int32_t chunk_max_frames = 500,
-                                       size_t chunk_max_bytes = 10 * 1024 * 1024)
-{
-    VTX::WriterFacadeConfig cfg;
-    cfg.output_filepath  = VtxTest::OutputPath(out_name);
-    cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
-    cfg.replay_name      = "WriterEdgeTest";
-    cfg.replay_uuid      = uuid;
-    cfg.default_fps      = 60.0f;
-    cfg.chunk_max_frames = chunk_max_frames;
-    cfg.chunk_max_bytes  = chunk_max_bytes;
-    cfg.use_compression  = true;
-    return cfg;
-}
+    VTX::WriterFacadeConfig MakeBaseConfig(const std::string& out_name, const std::string& uuid,
+                                           int32_t chunk_max_frames = 500, size_t chunk_max_bytes = 10 * 1024 * 1024) {
+        VTX::WriterFacadeConfig cfg;
+        cfg.output_filepath = VtxTest::OutputPath(out_name);
+        cfg.schema_json_path = VtxTest::FixturePath("test_schema.json");
+        cfg.replay_name = "WriterEdgeTest";
+        cfg.replay_uuid = uuid;
+        cfg.default_fps = 60.0f;
+        cfg.chunk_max_frames = chunk_max_frames;
+        cfg.chunk_max_bytes = chunk_max_bytes;
+        cfg.use_compression = true;
+        return cfg;
+    }
 
-VTX::Frame MakeTrivialFrame(int frame_index = 0) {
-    VTX::Frame f;
-    auto& bucket = f.CreateBucket("entity");
-
-    VTX::PropertyContainer pc;
-    pc.entity_type_id    = 0;
-    pc.string_properties = { "p", "player" };
-    pc.int32_properties  = { 1, frame_index, 0 };
-    pc.float_properties  = { 100.0f, 50.0f };
-    pc.vector_properties = { VTX::Vector{}, VTX::Vector{} };
-    pc.quat_properties   = { VTX::Quat{} };
-    pc.bool_properties   = { true };
-
-    bucket.unique_ids.push_back("p");
-    bucket.entities.push_back(std::move(pc));
-    return f;
-}
+    VTX::Frame MakeTrivialFrame(int frame_index = 0) {
+        VTX::Frame f;
+        auto& bucket = f.CreateBucket("entity");
+
+        VTX::PropertyContainer pc;
+        pc.entity_type_id = 0;
+        pc.string_properties = {"p", "player"};
+        pc.int32_properties = {1, frame_index, 0};
+        pc.float_properties = {100.0f, 50.0f};
+        pc.vector_properties = {VTX::Vector {}, VTX::Vector {}};
+        pc.quat_properties = {VTX::Quat {}};
+        pc.bool_properties = {true};
+
+        bucket.unique_ids.push_back("p");
+        bucket.entities.push_back(std::move(pc));
+        return f;
+    }
 
 } // namespace
 
@@ -63,7 +60,7 @@ TEST(WriterEdges, WriteZeroFramesThenStop) {
     {
         auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
         ASSERT_TRUE(writer);
-        writer->Stop();   // no RecordFrame calls
+        writer->Stop(); // no RecordFrame calls
     }
 
     ASSERT_TRUE(std::filesystem::exists(cfg.output_filepath));
@@ -87,7 +84,7 @@ TEST(WriterEdges, WriteSingleFrame) {
     const auto cfg = MakeBaseConfig("edge_single_frame.vtx", "edge-single");
     {
         auto writer = VTX::CreateFlatBuffersWriterFacade(cfg);
-        auto frame  = MakeTrivialFrame(0);
+        auto frame = MakeTrivialFrame(0);
         VTX::GameTime::GameTimeRegister t;
         t.game_time = 0.0f;
         writer->RecordFrame(frame, t);
@@ -138,7 +135,7 @@ TEST(WriterEdges, ChunkMaxFramesIsOne) {
     EXPECT_EQ(seek.size(), static_cast<size_t>(kFrames));
     for (size_t i = 0; i < seek.size(); ++i) {
         EXPECT_EQ(seek[i].start_frame, static_cast<int32_t>(i));
-        EXPECT_EQ(seek[i].end_frame,   static_cast<int32_t>(i));
+        EXPECT_EQ(seek[i].end_frame, static_cast<int32_t>(i));
     }
 }
 
@@ -165,13 +162,13 @@ TEST(WriterEdges, RecordFrameAfterStopIsSafe) {
     writer->RecordFrame(f2, t);
     writer->Flush();
 
-    writer.reset();  // release before inspecting
+    writer.reset(); // release before inspecting
 
     auto ctx = VTX::OpenReplayFile(cfg.output_filepath);
     ASSERT_TRUE(ctx);
     // Whatever total_frames ends up being, the file should be readable.
     const int total = ctx.reader->GetTotalFrames();
-    EXPECT_GE(total, 1);  // at least the frame recorded before Stop
+    EXPECT_GE(total, 1); // at least the frame recorded before Stop
 }
 
 TEST(WriterEdges, DoubleStopIsIdempotent) {
@@ -186,8 +183,8 @@ TEST(WriterEdges, DoubleStopIsIdempotent) {
     writer->Flush();
 
     writer->Stop();
-    writer->Stop();   // second call must be a safe no-op
-    writer->Stop();   // third for good measure
+    writer->Stop(); // second call must be a safe no-op
+    writer->Stop(); // third for good measure
 
     writer.reset();
 
@@ -215,15 +212,12 @@ TEST(WriterEdges, GiantFrameLargerThanChunkMaxBytes) {
         auto& bucket = f.CreateBucket("entity");
         VTX::PropertyContainer pc;
         pc.entity_type_id = 0;
-        pc.string_properties = {
-            "giant",
-            std::string(64 * 1024, 'X')
-        };
-        pc.int32_properties  = {1, 0, 0};
-        pc.float_properties  = {100.0f, 50.0f};
-        pc.vector_properties = {VTX::Vector{}, VTX::Vector{}};
-        pc.quat_properties   = {VTX::Quat{}};
-        pc.bool_properties   = {true};
+        pc.string_properties = {"giant", std::string(64 * 1024, 'X')};
+        pc.int32_properties = {1, 0, 0};
+        pc.float_properties = {100.0f, 50.0f};
+        pc.vector_properties = {VTX::Vector {}, VTX::Vector {}};
+        pc.quat_properties = {VTX::Quat {}};
+        pc.bool_properties = {true};
         bucket.unique_ids.push_back("giant_id");
         bucket.entities.push_back(std::move(pc));
 
diff --git a/tools/cli/include/commands/analysis_commands.h b/tools/cli/include/commands/analysis_commands.h
index e0d0b4a..fdcb3a6 100644
--- a/tools/cli/include/commands/analysis_commands.h
+++ b/tools/cli/include/commands/analysis_commands.h
@@ -16,123 +16,172 @@ namespace VtxCli {
     namespace detail {
 
         inline bool CompareNumeric(double a, const std::string& op, double b) {
-            if (op == "==") return a == b;
-            if (op == "!=") return a != b;
-            if (op == ">")  return a > b;
-            if (op == "<")  return a < b;
-            if (op == ">=") return a >= b;
-            if (op == "<=") return a <= b;
+            if (op == "==")
+                return a == b;
+            if (op == "!=")
+                return a != b;
+            if (op == ">")
+                return a > b;
+            if (op == "<")
+                return a < b;
+            if (op == ">=")
+                return a >= b;
+            if (op == "<=")
+                return a <= b;
             return false;
         }
 
-        inline bool MatchesScalar(
-            const VTX::PropertyContainer& pc,
-            const VTX::PropertyAddress& addr,
-            const std::string& op,
-            const std::string& target)
-        {
-            if (addr.container_type != VTX::FieldContainerType::None) return false;
+        inline bool MatchesScalar(const VTX::PropertyContainer& pc, const VTX::PropertyAddress& addr,
+                                  const std::string& op, const std::string& target) {
+            if (addr.container_type != VTX::FieldContainerType::None)
+                return false;
             auto idx = static_cast<size_t>(addr.index);
 
             switch (addr.type_id) {
-                case VTX::FieldType::Bool: {
-                    if (idx >= pc.bool_properties.size()) return false;
-                    bool val = static_cast<bool>(pc.bool_properties[idx]);
-                    bool tgt = (target == "true" || target == "1");
-                    if (op == "==") return val == tgt;
-                    if (op == "!=") return val != tgt;
+            case VTX::FieldType::Bool: {
+                if (idx >= pc.bool_properties.size())
+                    return false;
+                bool val = static_cast<bool>(pc.bool_properties[idx]);
+                bool tgt = (target == "true" || target == "1");
+                if (op == "==")
+                    return val == tgt;
+                if (op == "!=")
+                    return val != tgt;
+                return false;
+            }
+            case VTX::FieldType::Int32:
+            case VTX::FieldType::Enum: {
+                if (idx >= pc.int32_properties.size())
+                    return false;
+                try {
+                    return CompareNumeric(pc.int32_properties[idx], op, std::stod(target));
+                } catch (...) {
                     return false;
                 }
-                case VTX::FieldType::Int32:
-                case VTX::FieldType::Enum: {
-                    if (idx >= pc.int32_properties.size()) return false;
-                    try { return CompareNumeric(pc.int32_properties[idx], op, std::stod(target)); }
-                    catch (...) { return false; }
-                }
-                case VTX::FieldType::Int64: {
-                    if (idx >= pc.int64_properties.size()) return false;
-                    try { return CompareNumeric(static_cast<double>(pc.int64_properties[idx]), op, std::stod(target)); }
-                    catch (...) { return false; }
-                }
-                case VTX::FieldType::Float: {
-                    if (idx >= pc.float_properties.size()) return false;
-                    try { return CompareNumeric(pc.float_properties[idx], op, std::stod(target)); }
-                    catch (...) { return false; }
+            }
+            case VTX::FieldType::Int64: {
+                if (idx >= pc.int64_properties.size())
+                    return false;
+                try {
+                    return CompareNumeric(static_cast<double>(pc.int64_properties[idx]), op, std::stod(target));
+                } catch (...) {
+                    return false;
                 }
-                case VTX::FieldType::Double: {
-                    if (idx >= pc.double_properties.size()) return false;
-                    try { return CompareNumeric(pc.double_properties[idx], op, std::stod(target)); }
-                    catch (...) { return false; }
+            }
+            case VTX::FieldType::Float: {
+                if (idx >= pc.float_properties.size())
+                    return false;
+                try {
+                    return CompareNumeric(pc.float_properties[idx], op, std::stod(target));
+                } catch (...) {
+                    return false;
                 }
-                case VTX::FieldType::String: {
-                    if (idx >= pc.string_properties.size()) return false;
-                    if (op == "==") return pc.string_properties[idx] == target;
-                    if (op == "!=") return pc.string_properties[idx] != target;
+            }
+            case VTX::FieldType::Double: {
+                if (idx >= pc.double_properties.size())
+                    return false;
+                try {
+                    return CompareNumeric(pc.double_properties[idx], op, std::stod(target));
+                } catch (...) {
                     return false;
                 }
-                default: return false;
+            }
+            case VTX::FieldType::String: {
+                if (idx >= pc.string_properties.size())
+                    return false;
+                if (op == "==")
+                    return pc.string_properties[idx] == target;
+                if (op == "!=")
+                    return pc.string_properties[idx] != target;
+                return false;
+            }
+            default:
+                return false;
             }
         }
 
         //Map EVTXContainerType (FieldType, FieldContainerType) for schema lookup ──
 
-        inline std::pair<VTX::FieldType, VTX::FieldContainerType>
-        MapContainerType(VtxDiff::EVTXContainerType ct) {
+        inline std::pair<VTX::FieldType, VTX::FieldContainerType> MapContainerType(VtxDiff::EVTXContainerType ct) {
             using CT = VtxDiff::EVTXContainerType;
             using FT = VTX::FieldType;
             using FCT = VTX::FieldContainerType;
             switch (ct) {
-                case CT::BoolProperties:       return {FT::Bool,       FCT::None};
-                case CT::Int32Properties:      return {FT::Int32,      FCT::None};
-                case CT::Int64Properties:      return {FT::Int64,      FCT::None};
-                case CT::FloatProperties:      return {FT::Float,      FCT::None};
-                case CT::DoubleProperties:     return {FT::Double,     FCT::None};
-                case CT::StringProperties:     return {FT::String,     FCT::None};
-                case CT::TransformProperties:  return {FT::Transform,  FCT::None};
-                case CT::VectorProperties:     return {FT::Vector,     FCT::None};
-                case CT::QuatProperties:       return {FT::Quat,       FCT::None};
-                case CT::RangeProperties:      return {FT::FloatRange, FCT::None};
-                case CT::AnyStructProperties:  return {FT::Struct,     FCT::None};
-                case CT::BoolArrays:           return {FT::Bool,       FCT::Array};
-                case CT::Int32Arrays:          return {FT::Int32,      FCT::Array};
-                case CT::Int64Arrays:          return {FT::Int64,      FCT::Array};
-                case CT::FloatArrays:          return {FT::Float,      FCT::Array};
-                case CT::DoubleArrays:         return {FT::Double,     FCT::Array};
-                case CT::StringArrays:         return {FT::String,     FCT::Array};
-                case CT::TransformArrays:      return {FT::Transform,  FCT::Array};
-                case CT::VectorArrays:         return {FT::Vector,     FCT::Array};
-                case CT::QuatArrays:           return {FT::Quat,       FCT::Array};
-                case CT::RangeArrays:          return {FT::FloatRange, FCT::Array};
-                case CT::AnyStructArrays:      return {FT::Struct,     FCT::Array};
-                case CT::MapProperties:        return {FT::Struct,     FCT::Map};
-                case CT::MapArrays:            return {FT::Struct,     FCT::Map};
-                default:                       return {FT::None,       FCT::None};
+            case CT::BoolProperties:
+                return {FT::Bool, FCT::None};
+            case CT::Int32Properties:
+                return {FT::Int32, FCT::None};
+            case CT::Int64Properties:
+                return {FT::Int64, FCT::None};
+            case CT::FloatProperties:
+                return {FT::Float, FCT::None};
+            case CT::DoubleProperties:
+                return {FT::Double, FCT::None};
+            case CT::StringProperties:
+                return {FT::String, FCT::None};
+            case CT::TransformProperties:
+                return {FT::Transform, FCT::None};
+            case CT::VectorProperties:
+                return {FT::Vector, FCT::None};
+            case CT::QuatProperties:
+                return {FT::Quat, FCT::None};
+            case CT::RangeProperties:
+                return {FT::FloatRange, FCT::None};
+            case CT::AnyStructProperties:
+                return {FT::Struct, FCT::None};
+            case CT::BoolArrays:
+                return {FT::Bool, FCT::Array};
+            case CT::Int32Arrays:
+                return {FT::Int32, FCT::Array};
+            case CT::Int64Arrays:
+                return {FT::Int64, FCT::Array};
+            case CT::FloatArrays:
+                return {FT::Float, FCT::Array};
+            case CT::DoubleArrays:
+                return {FT::Double, FCT::Array};
+            case CT::StringArrays:
+                return {FT::String, FCT::Array};
+            case CT::TransformArrays:
+                return {FT::Transform, FCT::Array};
+            case CT::VectorArrays:
+                return {FT::Vector, FCT::Array};
+            case CT::QuatArrays:
+                return {FT::Quat, FCT::Array};
+            case CT::RangeArrays:
+                return {FT::FloatRange, FCT::Array};
+            case CT::AnyStructArrays:
+                return {FT::Struct, FCT::Array};
+            case CT::MapProperties:
+                return {FT::Struct, FCT::Map};
+            case CT::MapArrays:
+                return {FT::Struct, FCT::Map};
+            default:
+                return {FT::None, FCT::None};
             }
         }
 
-        inline std::string ResolvePropertyName(
-            const VTX::StructSchemaCache& schema,
-            VtxDiff::EVTXContainerType ct, int32_t index)
-        {
+        inline std::string ResolvePropertyName(const VTX::StructSchemaCache& schema, VtxDiff::EVTXContainerType ct,
+                                               int32_t index) {
             auto [ft, fct] = MapContainerType(ct);
             uint64_t key = VTX::MakePropertyLookupKey(index, ft, fct);
             auto it = schema.names_by_lookup_key.find(key);
-            if (it != schema.names_by_lookup_key.end()) return it->second;
+            if (it != schema.names_by_lookup_key.end())
+                return it->second;
             return VtxDiff::TypeToFieldName(ct) + "[" + std::to_string(index) + "]";
         }
 
     } // namespace detail
 
-    
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     struct DiffCommand {
         static constexpr std::string_view Name = "diff";
         static constexpr std::string_view Help =
             "diff <frame_a> <frame_b> [--epsilon <val>] - Compare entities between two frames";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             if (args.size() < 2) {
                 ResponseError(w, Name, "Usage: diff <frame_a> <frame_b> [--epsilon <value>]");
@@ -155,8 +204,9 @@ namespace VtxCli {
             // Parse optional --epsilon
             for (size_t i = 2; i + 1 < args.size(); ++i) {
                 if (args[i] == "--epsilon") {
-                    try { opts.float_epsilon = std::stof(std::string(args[i + 1])); }
-                    catch (...) {
+                    try {
+                        opts.float_epsilon = std::stof(std::string(args[i + 1]));
+                    } catch (...) {
                         ResponseError(w, Name, "Invalid epsilon value: " + std::string(args[i + 1]));
                         return;
                     }
@@ -173,17 +223,23 @@ namespace VtxCli {
             auto patch = ctx.session.DiffFrames(frame_a, frame_b, opts);
 
             if (patch.operations.empty()) {
-                std::string reason = (frame_a == frame_b)
-                    ? "Same frame index; no diff possible"
-                    : "Frames are identical";
+                std::string reason =
+                    (frame_a == frame_b) ? "Same frame index; no diff possible" : "Frames are identical";
                 ResponseOk(w, Name)
-                    .Key("frame_a").WriteInt(frame_a)
-                    .Key("frame_b").WriteInt(frame_b)
-                    .Key("total_ops").WriteInt(0)
-                    .Key("reason").WriteString(reason);
-                w.Key("changed"); w.BeginArray().EndArray();
-                w.Key("added");   w.BeginArray().EndArray();
-                w.Key("removed"); w.BeginArray().EndArray();
+                    .Key("frame_a")
+                    .WriteInt(frame_a)
+                    .Key("frame_b")
+                    .WriteInt(frame_b)
+                    .Key("total_ops")
+                    .WriteInt(0)
+                    .Key("reason")
+                    .WriteString(reason);
+                w.Key("changed");
+                w.BeginArray().EndArray();
+                w.Key("added");
+                w.BeginArray().EndArray();
+                w.Key("removed");
+                w.BeginArray().EndArray();
                 EndResponse(w);
                 return;
             }
@@ -239,16 +295,19 @@ namespace VtxCli {
                         }
                     }
                     // Fallback: use container type name
-                    changed_map[op.ActorId].insert(
-                        VtxDiff::TypeToFieldName(container_type) + "[" + std::to_string(prop_index) + "]");
+                    changed_map[op.ActorId].insert(VtxDiff::TypeToFieldName(container_type) + "[" +
+                                                   std::to_string(prop_index) + "]");
                 }
             }
 
             // Write output
             ResponseOk(w, Name)
-                .Key("frame_a").WriteInt(frame_a)
-                .Key("frame_b").WriteInt(frame_b)
-                .Key("total_ops").WriteInt(static_cast<int32_t>(patch.operations.size()));
+                .Key("frame_a")
+                .WriteInt(frame_a)
+                .Key("frame_b")
+                .WriteInt(frame_b)
+                .Key("total_ops")
+                .WriteInt(static_cast<int32_t>(patch.operations.size()));
 
             // Helper: resolve type_name from uid, always writes the key
             auto writeTypeName = [&](const std::string& uid) {
@@ -266,14 +325,13 @@ namespace VtxCli {
             w.Key("changed");
             w.BeginArray();
             for (const auto& [uid, props] : changed_map) {
-                w.BeginObject()
-                    .Key("unique_id").WriteString(uid)
-                    .Key("operation").WriteString("modify");
+                w.BeginObject().Key("unique_id").WriteString(uid).Key("operation").WriteString("modify");
                 writeTypeName(uid);
                 w.Key("property_count").WriteInt(static_cast<int32_t>(props.size()));
                 w.Key("properties");
                 w.BeginArray();
-                for (const auto& prop : props) w.WriteString(prop);
+                for (const auto& prop : props)
+                    w.WriteString(prop);
                 w.EndArray();
                 w.EndObject();
             }
@@ -282,9 +340,7 @@ namespace VtxCli {
             w.Key("added");
             w.BeginArray();
             for (const auto& uid : added_ids) {
-                w.BeginObject()
-                    .Key("unique_id").WriteString(uid)
-                    .Key("operation").WriteString("add");
+                w.BeginObject().Key("unique_id").WriteString(uid).Key("operation").WriteString("add");
                 writeTypeName(uid);
                 w.EndObject();
             }
@@ -293,9 +349,7 @@ namespace VtxCli {
             w.Key("removed");
             w.BeginArray();
             for (const auto& uid : removed_ids) {
-                w.BeginObject()
-                    .Key("unique_id").WriteString(uid)
-                    .Key("operation").WriteString("remove");
+                w.BeginObject().Key("unique_id").WriteString(uid).Key("operation").WriteString("remove");
                 writeTypeName(uid);
                 w.EndObject();
             }
@@ -304,22 +358,22 @@ namespace VtxCli {
             EndResponse(w);
         }
     };
-    
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     struct TrackCommand {
         static constexpr std::string_view Name = "track";
         static constexpr std::string_view Help =
             "track <bucket> <entity> <prop> <start> <end> [step] | --index <n> | --id <uid>";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             if (args.size() < 5) {
                 ResponseError(w, Name,
-                    "Usage: track <bucket> <entity> <property> <start> <end> [step]\n"
-                    "       track <bucket> --index <n> <property> <start> <end> [step]\n"
-                    "       track <bucket> --id <uid> <property> <start> <end> [step]");
+                              "Usage: track <bucket> <entity> <property> <start> <end> [step]\n"
+                              "       track <bucket> --index <n> <property> <start> <end> [step]\n"
+                              "       track <bucket> --id <uid> <property> <start> <end> [step]");
                 return;
             }
 
@@ -342,15 +396,22 @@ namespace VtxCli {
             int32_t start_frame, end_frame, step = 1;
             try {
                 start_frame = std::stoi(std::string(args[next + 1]));
-                end_frame   = std::stoi(std::string(args[next + 2]));
-                if (next + 3 < args.size()) step = std::stoi(std::string(args[next + 3]));
+                end_frame = std::stoi(std::string(args[next + 2]));
+                if (next + 3 < args.size())
+                    step = std::stoi(std::string(args[next + 3]));
             } catch (...) {
                 ResponseError(w, Name, "Invalid frame range or step");
                 return;
             }
 
-            if (step <= 0) { ResponseError(w, Name, "Step must be > 0"); return; }
-            if (start_frame > end_frame) { ResponseError(w, Name, "start must be <= end"); return; }
+            if (step <= 0) {
+                ResponseError(w, Name, "Step must be > 0");
+                return;
+            }
+            if (start_frame > end_frame) {
+                ResponseError(w, Name, "start must be <= end");
+                return;
+            }
 
             int32_t total = ctx.session.GetTotalFrames();
             if (start_frame < 0 || start_frame >= total || end_frame < 0 || end_frame >= total) {
@@ -385,9 +446,8 @@ namespace VtxCli {
             if (!sc_it->second.properties.contains(prop_name)) {
                 std::string suggestion = SuggestProperty(cache, first_entity.entity_type_id, prop_name);
                 if (!suggestion.empty()) {
-                    ResponseErrorHint(w, Name,
-                        "Property not found: " + prop_name,
-                        "Did you mean '" + suggestion + "'?");
+                    ResponseErrorHint(w, Name, "Property not found: " + prop_name,
+                                      "Did you mean '" + suggestion + "'?");
                 } else {
                     ResponseError(w, Name, "Property not found: " + prop_name);
                 }
@@ -395,29 +455,36 @@ namespace VtxCli {
             }
 
             ResponseOk(w, Name)
-                .Key("entity").WriteString(sel.value)
-                .Key("property").WriteString(prop_name)
-                .Key("start_frame").WriteInt(start_frame)
-                .Key("end_frame").WriteInt(end_frame)
-                .Key("step").WriteInt(step);
+                .Key("entity")
+                .WriteString(sel.value)
+                .Key("property")
+                .WriteString(prop_name)
+                .Key("start_frame")
+                .WriteInt(start_frame)
+                .Key("end_frame")
+                .WriteInt(end_frame)
+                .Key("step")
+                .WriteInt(step);
 
             w.Key("samples");
             w.BeginArray();
 
             for (int32_t f = start_frame; f <= end_frame; f += step) {
                 const auto* frame = ctx.session.GetFrameData(f);
-                if (!frame) continue;
+                if (!frame)
+                    continue;
 
                 auto ref = detail::ResolveBucket(ctx, *frame, bucket_arg);
-                if (!ref.bucket) continue;
+                if (!ref.bucket)
+                    continue;
 
                 int eidx = detail::ResolveEntity(*ref.bucket, sel);
-                if (eidx < 0) continue;
+                if (eidx < 0)
+                    continue;
 
                 const auto& entity = ref.bucket->entities[eidx];
 
-                w.BeginObject()
-                    .Key("frame").WriteInt(f);
+                w.BeginObject().Key("frame").WriteInt(f);
 
                 w.Key("value");
                 if (!SerializeProperty(w, entity, prop_name, cache)) {
@@ -431,15 +498,16 @@ namespace VtxCli {
             EndResponse(w);
         }
     };
-    
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     struct SearchCommand {
         static constexpr std::string_view Name = "search";
-        static constexpr std::string_view Help = "search <property> <op> <value> [bucket] - Find entities by property value";
+        static constexpr std::string_view Help =
+            "search <property> <op> <value> [bucket] - Find entities by property value";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             if (args.size() < 3) {
                 ResponseError(w, Name, "Usage: search <property> <op> <value> [bucket]  (ops: == != > < >= <=)");
@@ -450,7 +518,7 @@ namespace VtxCli {
             const std::string op(args[1]);
             const std::string target(args[2]);
 
-            static const std::unordered_set<std::string> valid_ops = {"==","!=",">","<",">=","<="};
+            static const std::unordered_set<std::string> valid_ops = {"==", "!=", ">", "<", ">=", "<="};
             if (!valid_ops.contains(op)) {
                 ResponseError(w, Name, "Invalid operator: " + op + "  (use == != > < >= <=)");
                 return;
@@ -488,16 +556,17 @@ namespace VtxCli {
                 for (const auto& [_, sc] : cache.structs) {
                     for (const auto& [pname, __] : sc.properties) {
                         size_t d = EditDistance(prop_name, pname);
-                        if (d < best_dist) { best_dist = d; suggestion = pname; }
+                        if (d < best_dist) {
+                            best_dist = d;
+                            suggestion = pname;
+                        }
                     }
                 }
                 if (!suggestion.empty()) {
-                    ResponseErrorHint(w, Name,
-                        "Property '" + prop_name + "' not found in any entity type",
-                        "Did you mean '" + suggestion + "'?");
+                    ResponseErrorHint(w, Name, "Property '" + prop_name + "' not found in any entity type",
+                                      "Did you mean '" + suggestion + "'?");
                 } else {
-                    ResponseError(w, Name,
-                        "Property '" + prop_name + "' not found in any entity type");
+                    ResponseError(w, Name, "Property '" + prop_name + "' not found in any entity type");
                 }
                 return;
             }
@@ -505,45 +574,59 @@ namespace VtxCli {
             // Collect matches
             int32_t match_count = 0;
             struct Match {
-                int32_t bi; int32_t ei;
-                std::string uid; std::string type;
+                int32_t bi;
+                int32_t ei;
+                std::string uid;
+                std::string type;
                 const VTX::PropertyContainer* entity;
             };
             std::vector<Match> matches;
 
             const auto& buckets = frame->GetBuckets();
             for (size_t bi = 0; bi < buckets.size(); ++bi) {
-                if (only_bucket >= 0 && static_cast<int32_t>(bi) != only_bucket) continue;
+                if (only_bucket >= 0 && static_cast<int32_t>(bi) != only_bucket)
+                    continue;
                 const auto& bucket = buckets[bi];
                 for (size_t ei = 0; ei < bucket.entities.size(); ++ei) {
                     const auto& entity = bucket.entities[ei];
                     auto sc_it = cache.structs.find(entity.entity_type_id);
-                    if (sc_it == cache.structs.end()) continue;
+                    if (sc_it == cache.structs.end())
+                        continue;
                     auto pr_it = sc_it->second.properties.find(prop_name);
-                    if (pr_it == sc_it->second.properties.end()) continue;
-                    if (!detail::MatchesScalar(entity, pr_it->second, op, target)) continue;
-                    matches.push_back({
-                        static_cast<int32_t>(bi), static_cast<int32_t>(ei),
-                        ei < bucket.unique_ids.size() ? bucket.unique_ids[ei] : std::string{},
-                        sc_it->second.name, &entity});
+                    if (pr_it == sc_it->second.properties.end())
+                        continue;
+                    if (!detail::MatchesScalar(entity, pr_it->second, op, target))
+                        continue;
+                    matches.push_back({static_cast<int32_t>(bi), static_cast<int32_t>(ei),
+                                       ei < bucket.unique_ids.size() ? bucket.unique_ids[ei] : std::string {},
+                                       sc_it->second.name, &entity});
                 }
             }
 
             ResponseOk(w, Name)
-                .Key("frame").WriteInt(ctx.session.GetCurrentFrame())
-                .Key("property").WriteString(prop_name)
-                .Key("operator").WriteString(op)
-                .Key("value").WriteString(target)
-                .Key("match_count").WriteInt(static_cast<int32_t>(matches.size()));
+                .Key("frame")
+                .WriteInt(ctx.session.GetCurrentFrame())
+                .Key("property")
+                .WriteString(prop_name)
+                .Key("operator")
+                .WriteString(op)
+                .Key("value")
+                .WriteString(target)
+                .Key("match_count")
+                .WriteInt(static_cast<int32_t>(matches.size()));
 
             w.Key("matches");
             w.BeginArray();
             for (const auto& m : matches) {
                 w.BeginObject()
-                    .Key("bucket_index").WriteInt(m.bi)
-                    .Key("entity_index").WriteInt(m.ei)
-                    .Key("unique_id").WriteString(m.uid)
-                    .Key("type_name").WriteString(m.type);
+                    .Key("bucket_index")
+                    .WriteInt(m.bi)
+                    .Key("entity_index")
+                    .WriteInt(m.ei)
+                    .Key("unique_id")
+                    .WriteString(m.uid)
+                    .Key("type_name")
+                    .WriteString(m.type);
                 w.Key("current_value");
                 SerializeProperty(w, *m.entity, prop_name, cache);
                 w.EndObject();
diff --git a/tools/cli/include/commands/command_helpers.h b/tools/cli/include/commands/command_helpers.h
index fa8a64b..ede11d2 100644
--- a/tools/cli/include/commands/command_helpers.h
+++ b/tools/cli/include/commands/command_helpers.h
@@ -10,72 +10,77 @@
 
 namespace VtxCli {
 
-    template<FormatWriter Fmt>
-    Fmt& ResponseOk(Fmt& writer, std::string_view command_name)
-    {
+    template <FormatWriter Fmt>
+    Fmt& ResponseOk(Fmt& writer, std::string_view command_name) {
         writer.BeginObject()
-            .Key("status").WriteString("ok")
-            .Key("command").WriteString(std::string(command_name))
+            .Key("status")
+            .WriteString("ok")
+            .Key("command")
+            .WriteString(std::string(command_name))
             .Key("data");
         return writer.BeginObject();
     }
 
-    template<FormatWriter Fmt>
-    void EndResponse(Fmt& w)
-    {
-        w.EndObject()
-         .EndObject();
+    template <FormatWriter Fmt>
+    void EndResponse(Fmt& w) {
+        w.EndObject().EndObject();
     }
 
-    template<FormatWriter Fmt>
-    Fmt& ResponseError(Fmt& writer, std::string_view command_name, const std::string& message)
-    {
+    template <FormatWriter Fmt>
+    Fmt& ResponseError(Fmt& writer, std::string_view command_name, const std::string& message) {
         writer.BeginObject()
-            .Key("status").WriteString("error")
-            .Key("command").WriteString(std::string(command_name))
-            .Key("error").WriteString(message)
-            .Key("hint").WriteNull()
+            .Key("status")
+            .WriteString("error")
+            .Key("command")
+            .WriteString(std::string(command_name))
+            .Key("error")
+            .WriteString(message)
+            .Key("hint")
+            .WriteNull()
             .EndObject();
         return writer;
     }
 
     /// Error response with a hint (e.g. "did you mean X?")
-    template<FormatWriter Fmt>
-    Fmt& ResponseErrorHint(Fmt& writer, std::string_view command_name,
-                           const std::string& message, const std::string& hint)
-    {
+    template <FormatWriter Fmt>
+    Fmt& ResponseErrorHint(Fmt& writer, std::string_view command_name, const std::string& message,
+                           const std::string& hint) {
         writer.BeginObject()
-            .Key("status").WriteString("error")
-            .Key("command").WriteString(std::string(command_name))
-            .Key("error").WriteString(message)
-            .Key("hint").WriteString(hint)
+            .Key("status")
+            .WriteString("error")
+            .Key("command")
+            .WriteString(std::string(command_name))
+            .Key("error")
+            .WriteString(message)
+            .Key("hint")
+            .WriteString(hint)
             .EndObject();
         return writer;
     }
 
     //returns true if a file is loaded, false after writing error.
-    template<FormatWriter Fmt>
-    bool RequireLoaded(const CommandContext& context, Fmt& writer, std::string_view command_name)
-    {
-        if (context.session.IsLoaded()) return true;
+    template <FormatWriter Fmt>
+    bool RequireLoaded(const CommandContext& context, Fmt& writer, std::string_view command_name) {
+        if (context.session.IsLoaded())
+            return true;
         ResponseError(writer, command_name, "No file loaded");
         return false;
     }
 
 
-
     /// Case-insensitive Levenshtein distance (for short strings).
     inline size_t EditDistance(std::string_view a, std::string_view b) {
         const size_t m = a.size(), n = b.size();
         std::vector<size_t> prev(n + 1), curr(n + 1);
-        for (size_t j = 0; j <= n; ++j) prev[j] = j;
+        for (size_t j = 0; j <= n; ++j)
+            prev[j] = j;
         for (size_t i = 1; i <= m; ++i) {
             curr[0] = i;
             for (size_t j = 1; j <= n; ++j) {
-                char ca = static_cast<char>(std::tolower(static_cast<unsigned char>(a[i-1])));
-                char cb = static_cast<char>(std::tolower(static_cast<unsigned char>(b[j-1])));
+                char ca = static_cast<char>(std::tolower(static_cast<unsigned char>(a[i - 1])));
+                char cb = static_cast<char>(std::tolower(static_cast<unsigned char>(b[j - 1])));
                 size_t cost = (ca == cb) ? 0 : 1;
-                curr[j] = std::min({curr[j-1] + 1, prev[j] + 1, prev[j-1] + cost});
+                curr[j] = std::min({curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost});
             }
             std::swap(prev, curr);
         }
@@ -84,10 +89,8 @@ namespace VtxCli {
 
     /// Find the closest match from a set of candidates.
     /// Returns empty string if no match is close enough (threshold = max edit distance).
-    inline std::string FindClosestMatch(const std::string& input,
-                                        const std::vector<std::string>& candidates,
-                                        size_t threshold = 3)
-    {
+    inline std::string FindClosestMatch(const std::string& input, const std::vector<std::string>& candidates,
+                                        size_t threshold = 3) {
         std::string best;
         size_t best_dist = threshold + 1;
         for (const auto& c : candidates) {
@@ -101,12 +104,11 @@ namespace VtxCli {
     }
 
     /// Find closest property name for a given entity type.
-    inline std::string SuggestProperty(const VTX::PropertyAddressCache& cache,
-                                       int32_t entity_type_id,
-                                       const std::string& input)
-    {
+    inline std::string SuggestProperty(const VTX::PropertyAddressCache& cache, int32_t entity_type_id,
+                                       const std::string& input) {
         auto it = cache.structs.find(entity_type_id);
-        if (it == cache.structs.end()) return {};
+        if (it == cache.structs.end())
+            return {};
         std::vector<std::string> names;
         names.reserve(it->second.properties.size());
         for (const auto& [name, _] : it->second.properties) {
@@ -116,9 +118,7 @@ namespace VtxCli {
     }
 
     /// Find closest type name.
-    inline std::string SuggestTypeName(const VTX::PropertyAddressCache& cache,
-                                       const std::string& input)
-    {
+    inline std::string SuggestTypeName(const VTX::PropertyAddressCache& cache, const std::string& input) {
         std::vector<std::string> names;
         names.reserve(cache.name_to_id.size());
         for (const auto& [name, _] : cache.name_to_id) {
diff --git a/tools/cli/include/commands/command_registry.h b/tools/cli/include/commands/command_registry.h
index df7ee4d..56bf249 100644
--- a/tools/cli/include/commands/command_registry.h
+++ b/tools/cli/include/commands/command_registry.h
@@ -19,24 +19,23 @@ namespace VtxCli {
     inline size_t CmdEditDistance(std::string_view a, std::string_view b) {
         const size_t m = a.size(), n = b.size();
         std::vector<size_t> prev(n + 1), curr(n + 1);
-        for (size_t j = 0; j <= n; ++j) prev[j] = j;
+        for (size_t j = 0; j <= n; ++j)
+            prev[j] = j;
         for (size_t i = 1; i <= m; ++i) {
             curr[0] = i;
             for (size_t j = 1; j <= n; ++j) {
-                char ca = static_cast<char>(std::tolower(static_cast<unsigned char>(a[i-1])));
-                char cb = static_cast<char>(std::tolower(static_cast<unsigned char>(b[j-1])));
+                char ca = static_cast<char>(std::tolower(static_cast<unsigned char>(a[i - 1])));
+                char cb = static_cast<char>(std::tolower(static_cast<unsigned char>(b[j - 1])));
                 size_t cost = (ca == cb) ? 0 : 1;
-                curr[j] = std::min({curr[j-1] + 1, prev[j] + 1, prev[j-1] + cost});
+                curr[j] = std::min({curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost});
             }
             std::swap(prev, curr);
         }
         return prev[n];
     }
 
-    inline std::string FindClosestCommand(const std::string& input,
-                                          const std::vector<std::string>& candidates,
-                                          size_t threshold = 3)
-    {
+    inline std::string FindClosestCommand(const std::string& input, const std::vector<std::string>& candidates,
+                                          size_t threshold = 3) {
         std::string best;
         size_t best_dist = threshold + 1;
         for (const auto& c : candidates) {
@@ -54,33 +53,37 @@ namespace VtxCli {
         std::string description;
     };
 
-    
+
     struct CommandContext {
         CliSession& session;
         bool exit_requested = false;
         const std::vector<CommandMeta>* help_entries = nullptr;
     };
-    
 
-    inline std::vector<std::string> Tokenize(const std::string& line)
-    {
+
+    inline std::vector<std::string> Tokenize(const std::string& line) {
         std::vector<std::string> tokens;
         std::string current;
         bool in_quotes = false;
 
         for (char c : line) {
             if (in_quotes) {
-                if (c == '"') { in_quotes = false; }
-                else          { current += c; }
+                if (c == '"') {
+                    in_quotes = false;
+                } else {
+                    current += c;
+                }
             } else {
-                if (c == '"')              { in_quotes = true; }
-                else if (c == ' ' || c == '\t') {
+                if (c == '"') {
+                    in_quotes = true;
+                } else if (c == ' ' || c == '\t') {
                     if (!current.empty()) {
                         tokens.push_back(std::move(current));
                         current.clear();
                     }
+                } else {
+                    current += c;
                 }
-                else { current += c; }
             }
         }
         if (!current.empty()) {
@@ -88,25 +91,21 @@ namespace VtxCli {
         }
         return tokens;
     }
-    
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     class CommandRegistry {
     public:
-
         /// Register a command template.  Cmd must expose:
         ///   static constexpr std::string_view Name;
         ///   static constexpr std::string_view Help;
         ///   void Run(CommandContext&, std::span<const std::string>, Fmt&);
-        template<template<typename> typename Cmd>
-        void Register()
-        {
+        template <template <typename> typename Cmd>
+        void Register() {
             Cmd<Fmt> cmd;
-            std::string name{Cmd<Fmt>::Name};
-            help_entries_.push_back({name, std::string{Cmd<Fmt>::Help}});
-            handlers_[name] = [cmd = std::move(cmd)](
-                CommandContext& ctx,
-                std::span<const std::string> args) mutable -> std::string
-            {
+            std::string name {Cmd<Fmt>::Name};
+            help_entries_.push_back({name, std::string {Cmd<Fmt>::Help}});
+            handlers_[name] = [cmd = std::move(cmd)](CommandContext& ctx,
+                                                     std::span<const std::string> args) mutable -> std::string {
                 Fmt w;
                 cmd.Run(ctx, args, w);
                 return w.Finalize("");
@@ -114,10 +113,10 @@ namespace VtxCli {
         }
 
         /// Tokenize the line, look up the handler, execute, return response JSON.
-        std::string Dispatch(CommandContext& ctx, const std::string& line)
-        {
+        std::string Dispatch(CommandContext& ctx, const std::string& line) {
             auto tokens = Tokenize(line);
-            if (tokens.empty()) return {};
+            if (tokens.empty())
+                return {};
 
             const std::string& cmd_name = tokens[0];
             auto it = handlers_.find(cmd_name);
@@ -125,14 +124,18 @@ namespace VtxCli {
             if (it == handlers_.end()) {
                 Fmt w;
                 w.BeginObject()
-                 .Key("status").WriteString("error")
-                 .Key("command").WriteString(cmd_name)
-                 .Key("error").WriteString("Unknown command. Type 'help' for available commands.");
+                    .Key("status")
+                    .WriteString("error")
+                    .Key("command")
+                    .WriteString(cmd_name)
+                    .Key("error")
+                    .WriteString("Unknown command. Type 'help' for available commands.");
 
                 // Suggest closest command name
                 std::vector<std::string> names;
                 names.reserve(handlers_.size());
-                for (const auto& [n, _] : handlers_) names.push_back(n);
+                for (const auto& [n, _] : handlers_)
+                    names.push_back(n);
                 std::string closest = FindClosestCommand(cmd_name, names);
                 if (!closest.empty()) {
                     w.Key("hint").WriteString("Did you mean '" + closest + "'?");
diff --git a/tools/cli/include/commands/file_commands.h b/tools/cli/include/commands/file_commands.h
index b50ac58..5202122 100644
--- a/tools/cli/include/commands/file_commands.h
+++ b/tools/cli/include/commands/file_commands.h
@@ -10,86 +10,89 @@
 
 namespace VtxCli {
 
-template<FormatWriter Fmt>
-struct OpenCommand {
-    static constexpr std::string_view Name = "open";
-    static constexpr std::string_view Help = "open <path> [--json-only] - Open a VTX replay file";
-
-    void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-    {
-        if (args.empty()) {
-            ResponseError(writer, Name, "Usage: open <path> [--json-only]");
-            return;
-        }
-
-        bool json_only = false;
-        std::vector<std::string> path_tokens;
-        path_tokens.reserve(args.size());
-        for (const auto& token : args) {
-            if (token == "--json-only") {
-                json_only = true;
-                continue;
+    template <FormatWriter Fmt>
+    struct OpenCommand {
+        static constexpr std::string_view Name = "open";
+        static constexpr std::string_view Help = "open <path> [--json-only] - Open a VTX replay file";
+
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (args.empty()) {
+                ResponseError(writer, Name, "Usage: open <path> [--json-only]");
+                return;
             }
-            path_tokens.push_back(token);
-        }
-        if (path_tokens.empty()) {
-            ResponseError(writer, Name, "Usage: open <path> [--json-only]");
-            return;
-        }
-
-        std::string path = path_tokens[0];
-        for (size_t i = 1; i < path_tokens.size(); ++i) {
-            path += ' ';
-            path += path_tokens[i];
-        }
 
-        if (context.session.IsLoaded()) {
-            context.session.Close();
-        }
+            bool json_only = false;
+            std::vector<std::string> path_tokens;
+            path_tokens.reserve(args.size());
+            for (const auto& token : args) {
+                if (token == "--json-only") {
+                    json_only = true;
+                    continue;
+                }
+                path_tokens.push_back(token);
+            }
+            if (path_tokens.empty()) {
+                ResponseError(writer, Name, "Usage: open <path> [--json-only]");
+                return;
+            }
 
-        std::streambuf* old_stdout = nullptr;
-        if (json_only) {
-            old_stdout = std::cout.rdbuf(std::cerr.rdbuf());
-        }
+            std::string path = path_tokens[0];
+            for (size_t i = 1; i < path_tokens.size(); ++i) {
+                path += ' ';
+                path += path_tokens[i];
+            }
 
-        const bool open_ok = context.session.Open(path);
+            if (context.session.IsLoaded()) {
+                context.session.Close();
+            }
 
-        if (old_stdout) {
-            std::cout.rdbuf(old_stdout);
-        }
+            std::streambuf* old_stdout = nullptr;
+            if (json_only) {
+                old_stdout = std::cout.rdbuf(std::cerr.rdbuf());
+            }
 
-        if (!open_ok) {
-            ResponseError(writer, Name, context.session.GetLastError());
-            return;
-        }
+            const bool open_ok = context.session.Open(path);
 
-        const auto& footer = context.session.GetFooter();
+            if (old_stdout) {
+                std::cout.rdbuf(old_stdout);
+            }
 
-        ResponseOk(writer, Name)
-         .Key("file").WriteString(context.session.GetFilePath())
-         .Key("format").WriteString(context.session.GetFormat() == VTX::VtxFormat::FlatBuffers ? "flatbuffers" : "protobuf")
-         .Key("total_frames").WriteInt(context.session.GetTotalFrames())
-         .Key("duration_seconds").WriteFloat(footer.duration_seconds)
-         .Key("file_size_mb").WriteFloat(context.session.GetFileSizeMb());
-        EndResponse(writer);
-    }
-};
+            if (!open_ok) {
+                ResponseError(writer, Name, context.session.GetLastError());
+                return;
+            }
 
+            const auto& footer = context.session.GetFooter();
+
+            ResponseOk(writer, Name)
+                .Key("file")
+                .WriteString(context.session.GetFilePath())
+                .Key("format")
+                .WriteString(context.session.GetFormat() == VTX::VtxFormat::FlatBuffers ? "flatbuffers" : "protobuf")
+                .Key("total_frames")
+                .WriteInt(context.session.GetTotalFrames())
+                .Key("duration_seconds")
+                .WriteFloat(footer.duration_seconds)
+                .Key("file_size_mb")
+                .WriteFloat(context.session.GetFileSizeMb());
+            EndResponse(writer);
+        }
+    };
 
 
-template<FormatWriter Fmt>
-struct CloseCommand {
-    static constexpr std::string_view Name = "close";
-    static constexpr std::string_view Help = "close - Close the current replay file";
+    template <FormatWriter Fmt>
+    struct CloseCommand {
+        static constexpr std::string_view Name = "close";
+        static constexpr std::string_view Help = "close - Close the current replay file";
 
-    void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-    {
-        if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
-        context.session.Close();
-        ResponseOk(writer, Name);
-        EndResponse(writer);
-    }
-};
+            context.session.Close();
+            ResponseOk(writer, Name);
+            EndResponse(writer);
+        }
+    };
 
 } // namespace VtxCli
diff --git a/tools/cli/include/commands/info_commands.h b/tools/cli/include/commands/info_commands.h
index 2fa1dee..4611649 100644
--- a/tools/cli/include/commands/info_commands.h
+++ b/tools/cli/include/commands/info_commands.h
@@ -8,42 +8,51 @@
 
 namespace VtxCli {
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct InfoCommand {
         static constexpr std::string_view Name = "info";
         static constexpr std::string_view Help = "info - Show summary of the loaded replay";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
-            if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
             const auto& header = context.session.GetHeader();
             const auto& footer = context.session.GetFooter();
 
             ResponseOk(writer, Name)
-             .Key("file").WriteString(context.session.GetFilePath())
-             .Key("format").WriteString(context.session.GetFormat() == VTX::VtxFormat::FlatBuffers ? "flatbuffers" : "protobuf")
-             .Key("file_size_mb").WriteFloat(context.session.GetFileSizeMb())
-             .Key("replay_name").WriteString(header.replay_name)
-             .Key("replay_uuid").WriteString(header.replay_uuid)
-             .Key("total_frames").WriteInt(context.session.GetTotalFrames())
-             .Key("duration_seconds").WriteFloat(footer.duration_seconds)
-             .Key("current_frame").WriteInt(context.session.GetCurrentFrame())
-             .Key("chunk_count").WriteInt(static_cast<int32_t>(footer.chunk_index.size()))
-             .Key("event_count").WriteInt(static_cast<int32_t>(footer.events.size()));
+                .Key("file")
+                .WriteString(context.session.GetFilePath())
+                .Key("format")
+                .WriteString(context.session.GetFormat() == VTX::VtxFormat::FlatBuffers ? "flatbuffers" : "protobuf")
+                .Key("file_size_mb")
+                .WriteFloat(context.session.GetFileSizeMb())
+                .Key("replay_name")
+                .WriteString(header.replay_name)
+                .Key("replay_uuid")
+                .WriteString(header.replay_uuid)
+                .Key("total_frames")
+                .WriteInt(context.session.GetTotalFrames())
+                .Key("duration_seconds")
+                .WriteFloat(footer.duration_seconds)
+                .Key("current_frame")
+                .WriteInt(context.session.GetCurrentFrame())
+                .Key("chunk_count")
+                .WriteInt(static_cast<int32_t>(footer.chunk_index.size()))
+                .Key("event_count")
+                .WriteInt(static_cast<int32_t>(footer.events.size()));
             EndResponse(writer);
         }
     };
 
-    template<FormatWriter Fmt>
-    struct HeaderCommand
-    {
+    template <FormatWriter Fmt>
+    struct HeaderCommand {
         static constexpr std::string_view Name = "header";
         static constexpr std::string_view Help = "header - Show file header details";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
-            if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
             const auto& header = context.session.GetHeader();
             const auto& version = header.version;
@@ -53,14 +62,20 @@ namespace VtxCli {
             // version info
             writer.Key("version");
             writer.BeginObject()
-                .Key("format_major").WriteUInt(version.format_major)
-                .Key("format_minor").WriteUInt(version.format_minor)
-                .Key("schema_version").WriteUInt(version.schema_version)
-            .EndObject();
-
-            writer.Key("replay_name").WriteString(header.replay_name)
-                .Key("replay_uuid").WriteString(header.replay_uuid)
-                .Key("recorded_utc_timestamp").WriteInt64(header.recorded_utc_timestamp);
+                .Key("format_major")
+                .WriteUInt(version.format_major)
+                .Key("format_minor")
+                .WriteUInt(version.format_minor)
+                .Key("schema_version")
+                .WriteUInt(version.schema_version)
+                .EndObject();
+
+            writer.Key("replay_name")
+                .WriteString(header.replay_name)
+                .Key("replay_uuid")
+                .WriteString(header.replay_uuid)
+                .Key("recorded_utc_timestamp")
+                .WriteInt64(header.recorded_utc_timestamp);
 
             if (!header.custom_json_metadata.empty()) {
                 writer.Key("custom_metadata").WriteRaw(header.custom_json_metadata);
@@ -72,43 +87,51 @@ namespace VtxCli {
         }
     };
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct FooterCommand {
         static constexpr std::string_view Name = "footer";
         static constexpr std::string_view Help = "footer - Show file footer details";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
-            if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
             const auto& footer = context.session.GetFooter();
 
             ResponseOk(writer, Name)
-             .Key("total_frames").WriteInt(footer.total_frames)
-             .Key("duration_seconds").WriteFloat(footer.duration_seconds)
-             .Key("chunk_count").WriteInt(static_cast<int32_t>(footer.chunk_index.size()))
-             .Key("event_count").WriteInt(static_cast<int32_t>(footer.events.size()))
-             .Key("payload_checksum").WriteUInt64(footer.payload_checksum);
+                .Key("total_frames")
+                .WriteInt(footer.total_frames)
+                .Key("duration_seconds")
+                .WriteFloat(footer.duration_seconds)
+                .Key("chunk_count")
+                .WriteInt(static_cast<int32_t>(footer.chunk_index.size()))
+                .Key("event_count")
+                .WriteInt(static_cast<int32_t>(footer.events.size()))
+                .Key("payload_checksum")
+                .WriteUInt64(footer.payload_checksum);
             EndResponse(writer);
         }
     };
 
     // schema, raw json
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct SchemaCommand {
         static constexpr std::string_view Name = "schema";
         static constexpr std::string_view Help = "schema - Show the contextual schema";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
-            if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
             const auto& schema = context.session.GetContextualSchema();
 
             ResponseOk(writer, Name)
-             .Key("data_identifier").WriteString(schema.data_identifier)
-             .Key("data_version").WriteInt(schema.data_version)
-             .Key("data_version_string").WriteString(schema.data_version_string);
+                .Key("data_identifier")
+                .WriteString(schema.data_identifier)
+                .Key("data_version")
+                .WriteInt(schema.data_version)
+                .Key("data_version_string")
+                .WriteString(schema.data_version_string);
 
             // property_mapping is already JSON ,pass through raw
             if (!schema.property_mapping.empty()) {
@@ -121,63 +144,70 @@ namespace VtxCli {
         }
     };
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct ChunksCommand {
         static constexpr std::string_view Name = "chunks";
         static constexpr std::string_view Help = "chunks - Show chunk seek table";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
-            if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
             const auto& footer = context.session.GetFooter();
 
-            ResponseOk(writer, Name)
-             .Key("count").WriteInt(static_cast<int32_t>(footer.chunk_index.size()));
+            ResponseOk(writer, Name).Key("count").WriteInt(static_cast<int32_t>(footer.chunk_index.size()));
 
             writer.Key("chunks");
             writer.BeginArray();
             for (const auto& chunk : footer.chunk_index) {
                 writer.BeginObject()
-                 .Key("chunk_index").WriteInt(chunk.chunk_index)
-                 .Key("start_frame").WriteInt(chunk.start_frame)
-                 .Key("end_frame").WriteInt(chunk.end_frame)
-                 .Key("file_offset").WriteUInt64(chunk.file_offset)
-                 .Key("chunk_size_bytes").WriteUInt(chunk.chunk_size_bytes)
-                 .EndObject();
+                    .Key("chunk_index")
+                    .WriteInt(chunk.chunk_index)
+                    .Key("start_frame")
+                    .WriteInt(chunk.start_frame)
+                    .Key("end_frame")
+                    .WriteInt(chunk.end_frame)
+                    .Key("file_offset")
+                    .WriteUInt64(chunk.file_offset)
+                    .Key("chunk_size_bytes")
+                    .WriteUInt(chunk.chunk_size_bytes)
+                    .EndObject();
             }
             writer.EndArray();
             EndResponse(writer);
         }
     };
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct EventsCommand {
         static constexpr std::string_view Name = "events";
         static constexpr std::string_view Help = "events - Show timeline events";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
-            if (!RequireLoaded(context, writer, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
+            if (!RequireLoaded(context, writer, Name))
+                return;
 
             const auto& footer = context.session.GetFooter();
 
-            ResponseOk(writer, Name)
-                .Key("count").WriteInt(static_cast<int32_t>(footer.events.size()));
-
-                writer.Key("events");
-                writer.BeginArray();
-                for (const auto& evt : footer.events) {
-                    writer.BeginObject()
-                     .Key("game_time").WriteFloat(evt.game_time)
-                     .Key("event_type").WriteString(evt.event_type)
-                     .Key("label").WriteString(evt.label)
-                     .Key("entity_unique_id").WriteString(evt.entity_unique_id);
-                    writer.Key("location");
-                    Serialize(writer, evt.location);
-                    writer.EndObject();
-                }
-                writer.EndArray();
+            ResponseOk(writer, Name).Key("count").WriteInt(static_cast<int32_t>(footer.events.size()));
+
+            writer.Key("events");
+            writer.BeginArray();
+            for (const auto& evt : footer.events) {
+                writer.BeginObject()
+                    .Key("game_time")
+                    .WriteFloat(evt.game_time)
+                    .Key("event_type")
+                    .WriteString(evt.event_type)
+                    .Key("label")
+                    .WriteString(evt.label)
+                    .Key("entity_unique_id")
+                    .WriteString(evt.entity_unique_id);
+                writer.Key("location");
+                Serialize(writer, evt.location);
+                writer.EndObject();
+            }
+            writer.EndArray();
             EndResponse(writer);
         }
     };
diff --git a/tools/cli/include/commands/inspect_commands.h b/tools/cli/include/commands/inspect_commands.h
index d4e40dc..1fba3f8 100644
--- a/tools/cli/include/commands/inspect_commands.h
+++ b/tools/cli/include/commands/inspect_commands.h
@@ -15,28 +15,45 @@ namespace VtxCli {
 
         inline const char* FieldTypeName(VTX::FieldType t) {
             switch (t) {
-                case VTX::FieldType::Bool:       return "bool";
-                case VTX::FieldType::Int8:       return "int8";
-                case VTX::FieldType::Int32:      return "int32";
-                case VTX::FieldType::Int64:      return "int64";
-                case VTX::FieldType::Float:      return "float";
-                case VTX::FieldType::Double:     return "double";
-                case VTX::FieldType::String:     return "string";
-                case VTX::FieldType::Vector:     return "vector";
-                case VTX::FieldType::Quat:       return "quat";
-                case VTX::FieldType::Transform:  return "transform";
-                case VTX::FieldType::FloatRange: return "float_range";
-                case VTX::FieldType::Struct:     return "struct";
-                case VTX::FieldType::Enum:       return "enum";
-                default:                         return "unknown";
+            case VTX::FieldType::Bool:
+                return "bool";
+            case VTX::FieldType::Int8:
+                return "int8";
+            case VTX::FieldType::Int32:
+                return "int32";
+            case VTX::FieldType::Int64:
+                return "int64";
+            case VTX::FieldType::Float:
+                return "float";
+            case VTX::FieldType::Double:
+                return "double";
+            case VTX::FieldType::String:
+                return "string";
+            case VTX::FieldType::Vector:
+                return "vector";
+            case VTX::FieldType::Quat:
+                return "quat";
+            case VTX::FieldType::Transform:
+                return "transform";
+            case VTX::FieldType::FloatRange:
+                return "float_range";
+            case VTX::FieldType::Struct:
+                return "struct";
+            case VTX::FieldType::Enum:
+                return "enum";
+            default:
+                return "unknown";
             }
         }
 
         inline const char* ContainerTypeName(VTX::FieldContainerType t) {
             switch (t) {
-                case VTX::FieldContainerType::Array: return "array";
-                case VTX::FieldContainerType::Map:   return "map";
-                default:                             return "scalar";
+            case VTX::FieldContainerType::Array:
+                return "array";
+            case VTX::FieldContainerType::Map:
+                return "map";
+            default:
+                return "scalar";
             }
         }
 
@@ -46,25 +63,26 @@ namespace VtxCli {
             int32_t index = -1;
         };
 
-        inline std::string ToLowerCopy(const std::string& value)
-        {
+        inline std::string ToLowerCopy(const std::string& value) {
             std::string lowered = value;
             std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
             return lowered;
         }
 
-        inline std::vector<std::string> ExtractBucketNamesFromPropertyMapping(const std::string& property_mapping)
-        {
+        inline std::vector<std::string> ExtractBucketNamesFromPropertyMapping(const std::string& property_mapping) {
             std::vector<std::string> names;
-            if (property_mapping.empty()) return names;
+            if (property_mapping.empty())
+                return names;
 
             const std::string key = "\"buckets\"";
             size_t key_pos = property_mapping.find(key);
-            if (key_pos == std::string::npos) return names;
+            if (key_pos == std::string::npos)
+                return names;
 
             size_t open_bracket = property_mapping.find('[', key_pos + key.size());
-            if (open_bracket == std::string::npos) return names;
+            if (open_bracket == std::string::npos)
+                return names;
 
             bool in_string = false;
             bool escaping = false;
@@ -72,7 +90,8 @@ namespace VtxCli {
             for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
                 char c = property_mapping[i];
                 if (!in_string) {
-                    if (c == ']') break;
+                    if (c == ']')
+                        break;
                     if (c == '"') {
                         in_string = true;
                         current.clear();
@@ -90,7 +109,8 @@ namespace VtxCli {
                 }
                 if (c == '"') {
                     in_string = false;
-                    if (!current.empty()) names.push_back(current);
+                    if (!current.empty())
+                        names.push_back(current);
                     continue;
                 }
                 current.push_back(c);
@@ -100,17 +120,18 @@ namespace VtxCli {
 
         inline BucketRef ResolveBucket(const CommandContext& ctx, const VTX::Frame& frame, const std::string& arg) {
             const auto& buckets = frame.GetBuckets();
-            const auto schema_bucket_names = ExtractBucketNamesFromPropertyMapping(
-                ctx.session.GetContextualSchema().property_mapping);
+            const auto schema_bucket_names =
+                ExtractBucketNamesFromPropertyMapping(ctx.session.GetContextualSchema().property_mapping);
 
-            bool is_number = !arg.empty() && std::all_of(arg.begin(), arg.end(),
-                [](unsigned char c) { return std::isdigit(c); });
+            bool is_number =
+                !arg.empty() && std::all_of(arg.begin(), arg.end(), [](unsigned char c) { return std::isdigit(c); });
 
             if (is_number) {
                 auto idx = static_cast<size_t>(std::stoul(arg));
                 if (idx < buckets.size()) {
                     for (const auto& [bname, bidx] : frame.bucket_map) {
-                        if (bidx == idx) return {&buckets[idx], bname, static_cast<int32_t>(idx)};
+                        if (bidx == idx)
+                            return {&buckets[idx], bname, static_cast<int32_t>(idx)};
                     }
                     if (idx < schema_bucket_names.size()) {
                         return {&buckets[idx], schema_bucket_names[idx], static_cast<int32_t>(idx)};
@@ -142,18 +163,20 @@ namespace VtxCli {
         }
 
         inline int ResolveEntityIndex(const VTX::Bucket& bucket, const std::string& arg) {
-            bool is_number = !arg.empty() && std::all_of(arg.begin(), arg.end(),
-                [](unsigned char c) { return std::isdigit(c); });
+            bool is_number =
+                !arg.empty() && std::all_of(arg.begin(), arg.end(), [](unsigned char c) { return std::isdigit(c); });
 
             if (is_number) {
                 try {
                     int idx = std::stoi(arg);
-                    if (idx >= 0 && static_cast<size_t>(idx) < bucket.entities.size()) return idx;
+                    if (idx >= 0 && static_cast<size_t>(idx) < bucket.entities.size())
+                        return idx;
                 } catch (...) {}
             }
 
             for (size_t i = 0; i < bucket.unique_ids.size(); ++i) {
-                if (bucket.unique_ids[i] == arg) return static_cast<int>(i);
+                if (bucket.unique_ids[i] == arg)
+                    return static_cast<int>(i);
             }
             return -1;
         }
@@ -165,9 +188,8 @@ namespace VtxCli {
             std::string value;
         };
 
-        inline std::pair<EntitySelector, size_t> ParseEntitySelector(
-            std::span<const std::string> args, size_t start = 0)
-        {
+        inline std::pair<EntitySelector, size_t> ParseEntitySelector(std::span<const std::string> args,
+                                                                     size_t start = 0) {
             if (start + 1 < args.size()) {
                 if (args[start] == "--index") {
                     return {{EntitySelector::Mode::ByIndex, std::string(args[start + 1])}, 2};
@@ -185,37 +207,37 @@ namespace VtxCli {
         /// Resolve entity from selector. Returns index or -1.
         inline int ResolveEntity(const VTX::Bucket& bucket, const EntitySelector& sel) {
             switch (sel.mode) {
-                case EntitySelector::Mode::ByIndex: {
-                    try {
-                        int idx = std::stoi(sel.value);
-                        if (idx >= 0 && static_cast<size_t>(idx) < bucket.entities.size())
-                            return idx;
-                    } catch (...) {}
-                    return -1;
-                }
-                case EntitySelector::Mode::ById: {
-                    for (size_t i = 0; i < bucket.unique_ids.size(); ++i) {
-                        if (bucket.unique_ids[i] == sel.value) return static_cast<int>(i);
-                    }
-                    return -1;
+            case EntitySelector::Mode::ByIndex: {
+                try {
+                    int idx = std::stoi(sel.value);
+                    if (idx >= 0 && static_cast<size_t>(idx) < bucket.entities.size())
+                        return idx;
+                } catch (...) {}
+                return -1;
+            }
+            case EntitySelector::Mode::ById: {
+                for (size_t i = 0; i < bucket.unique_ids.size(); ++i) {
+                    if (bucket.unique_ids[i] == sel.value)
+                        return static_cast<int>(i);
                 }
-                default:
-                    return ResolveEntityIndex(bucket, sel.value);
+                return -1;
+            }
+            default:
+                return ResolveEntityIndex(bucket, sel.value);
             }
         }
 
     } // namespace detail
 
 
-
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct BucketsCommand {
         static constexpr std::string_view Name = "buckets";
         static constexpr std::string_view Help = "buckets - List buckets in current frame";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             const auto* frame = ctx.session.GetCurrentFrameData();
             if (!frame) {
@@ -226,15 +248,17 @@ namespace VtxCli {
             const auto& buckets = frame->GetBuckets();
 
             ResponseOk(w, Name)
-                .Key("frame").WriteInt(ctx.session.GetCurrentFrame())
-                .Key("count").WriteInt(static_cast<int32_t>(buckets.size()));
+                .Key("frame")
+                .WriteInt(ctx.session.GetCurrentFrame())
+                .Key("count")
+                .WriteInt(static_cast<int32_t>(buckets.size()));
 
             std::unordered_map<size_t, std::string> idx_to_name;
             for (const auto& [bname, bidx] : frame->bucket_map) {
                 idx_to_name[bidx] = bname;
             }
-            const auto schema_bucket_names = detail::ExtractBucketNamesFromPropertyMapping(
-                ctx.session.GetContextualSchema().property_mapping);
+            const auto schema_bucket_names =
+                detail::ExtractBucketNamesFromPropertyMapping(ctx.session.GetContextualSchema().property_mapping);
             for (size_t i = 0; i < schema_bucket_names.size() && i < buckets.size(); ++i) {
                 if (!idx_to_name.contains(i) && !schema_bucket_names[i].empty()) {
                     idx_to_name[i] = schema_bucket_names[i];
@@ -247,8 +271,7 @@ namespace VtxCli {
                 const auto& bucket = buckets[i];
                 auto name_it = idx_to_name.find(i);
 
-                w.BeginObject()
-                    .Key("index").WriteInt(static_cast<int32_t>(i));
+                w.BeginObject().Key("index").WriteInt(static_cast<int32_t>(i));
 
                 if (name_it != idx_to_name.end()) {
                     w.Key("name").WriteString(name_it->second);
@@ -256,8 +279,7 @@ namespace VtxCli {
                     w.Key("name").WriteNull();
                 }
 
-                w.Key("entity_count").WriteInt(static_cast<int32_t>(bucket.entities.size()))
-                    .EndObject();
+                w.Key("entity_count").WriteInt(static_cast<int32_t>(bucket.entities.size())).EndObject();
             }
             w.EndArray();
             EndResponse(w);
@@ -265,15 +287,14 @@ namespace VtxCli {
     };
 
 
-
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct EntitiesCommand {
         static constexpr std::string_view Name = "entities";
         static constexpr std::string_view Help = "entities <bucket> - List entities (by bucket name or index)";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             if (args.empty()) {
                 ResponseError(w, Name, "Usage: entities <bucket_name_or_index>");
@@ -296,19 +317,24 @@ namespace VtxCli {
             const auto& bucket = *ref.bucket;
 
             ResponseOk(w, Name)
-                .Key("bucket_index").WriteInt(ref.index)
-                .Key("bucket_name").WriteString(ref.name)
-                .Key("count").WriteInt(static_cast<int32_t>(bucket.entities.size()));
+                .Key("bucket_index")
+                .WriteInt(ref.index)
+                .Key("bucket_name")
+                .WriteString(ref.name)
+                .Key("count")
+                .WriteInt(static_cast<int32_t>(bucket.entities.size()));
 
             w.Key("entities");
             w.BeginArray();
             for (size_t i = 0; i < bucket.entities.size(); ++i) {
                 const auto& entity = bucket.entities[i];
                 w.BeginObject()
-                    .Key("index").WriteInt(static_cast<int32_t>(i))
-                    .Key("unique_id").WriteString(
-                        i < bucket.unique_ids.size() ? bucket.unique_ids[i] : "")
-                    .Key("entity_type_id").WriteInt(entity.entity_type_id);
+                    .Key("index")
+                    .WriteInt(static_cast<int32_t>(i))
+                    .Key("unique_id")
+                    .WriteString(i < bucket.unique_ids.size() ? bucket.unique_ids[i] : "")
+                    .Key("entity_type_id")
+                    .WriteInt(entity.entity_type_id);
 
                 auto it = cache.structs.find(entity.entity_type_id);
                 if (it != cache.structs.end()) {
@@ -323,23 +349,23 @@ namespace VtxCli {
             EndResponse(w);
         }
     };
-    
 
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     struct EntityCommand {
         static constexpr std::string_view Name = "entity";
         static constexpr std::string_view Help =
             "entity <bucket> <id_or_index> | --index <n> | --id <uid> - Show all properties";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             if (args.size() < 2) {
                 ResponseError(w, Name,
-                    "Usage: entity <bucket> <entity_id_or_index>\n"
-                    "       entity <bucket> --index <n>\n"
-                    "       entity <bucket> --id <uid>");
+                              "Usage: entity <bucket> <entity_id_or_index>\n"
+                              "       entity <bucket> --index <n>\n"
+                              "       entity <bucket> --id <uid>");
                 return;
             }
 
@@ -371,35 +397,38 @@ namespace VtxCli {
             const auto& cache = ctx.session.GetPropertyCache();
 
             ResponseOk(w, Name)
-                .Key("bucket_index").WriteInt(ref.index)
-                .Key("bucket_name").WriteString(ref.name)
-                .Key("entity_index").WriteInt(idx)
-                .Key("unique_id").WriteString(
-                    static_cast<size_t>(idx) < ref.bucket->unique_ids.size()
-                        ? ref.bucket->unique_ids[idx] : "");
+                .Key("bucket_index")
+                .WriteInt(ref.index)
+                .Key("bucket_name")
+                .WriteString(ref.name)
+                .Key("entity_index")
+                .WriteInt(idx)
+                .Key("unique_id")
+                .WriteString(static_cast<size_t>(idx) < ref.bucket->unique_ids.size() ? ref.bucket->unique_ids[idx]
+                                                                                      : "");
 
             w.Key("entity");
             Serialize(w, entity, cache);
             EndResponse(w);
         }
     };
-    
 
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     struct PropertyCommand {
         static constexpr std::string_view Name = "property";
         static constexpr std::string_view Help =
             "property <bucket> <entity> <name> | --index <n> <name> | --id <uid> <name>";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             if (args.size() < 3) {
                 ResponseError(w, Name,
-                    "Usage: property <bucket> <entity> <property_name>\n"
-                    "       property <bucket> --index <n> <property_name>\n"
-                    "       property <bucket> --id <uid> <property_name>");
+                              "Usage: property <bucket> <entity> <property_name>\n"
+                              "       property <bucket> --index <n> <property_name>\n"
+                              "       property <bucket> --id <uid> <property_name>");
                 return;
             }
 
@@ -447,9 +476,8 @@ namespace VtxCli {
             if (prop_it == struct_it->second.properties.end()) {
                 std::string suggestion = SuggestProperty(cache, entity.entity_type_id, prop_name);
                 if (!suggestion.empty()) {
-                    ResponseErrorHint(w, Name,
-                        "Property not found: " + prop_name,
-                        "Did you mean '" + suggestion + "'?");
+                    ResponseErrorHint(w, Name, "Property not found: " + prop_name,
+                                      "Did you mean '" + suggestion + "'?");
                 } else {
                     ResponseError(w, Name, "Property not found: " + prop_name);
                 }
@@ -457,15 +485,21 @@ namespace VtxCli {
             }
 
             ResponseOk(w, Name)
-                .Key("bucket_index").WriteInt(ref.index)
-                .Key("bucket_name").WriteString(ref.name)
-                .Key("entity_index").WriteInt(idx)
-                .Key("unique_id").WriteString(
-                    static_cast<size_t>(idx) < ref.bucket->unique_ids.size()
-                        ? ref.bucket->unique_ids[idx] : "")
-                .Key("property").WriteString(prop_name)
-                .Key("type").WriteString(detail::FieldTypeName(prop_it->second.type_id))
-                .Key("container").WriteString(detail::ContainerTypeName(prop_it->second.container_type));
+                .Key("bucket_index")
+                .WriteInt(ref.index)
+                .Key("bucket_name")
+                .WriteString(ref.name)
+                .Key("entity_index")
+                .WriteInt(idx)
+                .Key("unique_id")
+                .WriteString(static_cast<size_t>(idx) < ref.bucket->unique_ids.size() ? ref.bucket->unique_ids[idx]
+                                                                                      : "")
+                .Key("property")
+                .WriteString(prop_name)
+                .Key("type")
+                .WriteString(detail::FieldTypeName(prop_it->second.type_id))
+                .Key("container")
+                .WriteString(detail::ContainerTypeName(prop_it->second.container_type));
 
             w.Key("value");
             SerializeProperty(w, entity, prop_name, cache);
@@ -476,14 +510,14 @@ namespace VtxCli {
 
     // ── types [name] — discover struct types and their properties ───────
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct TypesCommand {
         static constexpr std::string_view Name = "types";
         static constexpr std::string_view Help = "types [name] - List struct types or inspect a type's properties";
 
-        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(ctx, w, Name)) return;
+        void Run(CommandContext& ctx, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(ctx, w, Name))
+                return;
 
             const auto& cache = ctx.session.GetPropertyCache();
 
@@ -493,9 +527,7 @@ namespace VtxCli {
                 if (name_it == cache.name_to_id.end()) {
                     std::string suggestion = SuggestTypeName(cache, type_name);
                     if (!suggestion.empty()) {
-                        ResponseErrorHint(w, Name,
-                            "Unknown type: " + type_name,
-                            "Did you mean '" + suggestion + "'?");
+                        ResponseErrorHint(w, Name, "Unknown type: " + type_name, "Did you mean '" + suggestion + "'?");
                     } else {
                         ResponseError(w, Name, "Unknown type: " + type_name);
                     }
@@ -511,18 +543,22 @@ namespace VtxCli {
                 const auto& sc = struct_it->second;
 
                 ResponseOk(w, Name)
-                    .Key("type_name").WriteString(sc.name)
-                    .Key("type_id").WriteInt(name_it->second)
-                    .Key("property_count").WriteInt(static_cast<int32_t>(sc.properties.size()));
+                    .Key("type_name")
+                    .WriteString(sc.name)
+                    .Key("type_id")
+                    .WriteInt(name_it->second)
+                    .Key("property_count")
+                    .WriteInt(static_cast<int32_t>(sc.properties.size()));
 
                 w.Key("properties");
                 w.BeginArray();
                 for (const auto& prop_view : sc.GetPropertiesInOrder()) {
-                    w.BeginObject()
-                        .Key("name").WriteString(std::string(prop_view.name));
+                    w.BeginObject().Key("name").WriteString(std::string(prop_view.name));
                     if (prop_view.address) {
-                        w.Key("type").WriteString(detail::FieldTypeName(prop_view.address->type_id))
-                         .Key("container").WriteString(detail::ContainerTypeName(prop_view.address->container_type));
+                        w.Key("type")
+                            .WriteString(detail::FieldTypeName(prop_view.address->type_id))
+                            .Key("container")
+                            .WriteString(detail::ContainerTypeName(prop_view.address->container_type));
                         if (!prop_view.address->child_type_name.empty()) {
                             w.Key("child_type").WriteString(prop_view.address->child_type_name);
                         }
@@ -534,19 +570,21 @@ namespace VtxCli {
                 return;
             }
 
-            ResponseOk(w, Name)
-                .Key("count").WriteInt(static_cast<int32_t>(cache.name_to_id.size()));
+            ResponseOk(w, Name).Key("count").WriteInt(static_cast<int32_t>(cache.name_to_id.size()));
 
             w.Key("types");
             w.BeginArray();
             for (const auto& [name, id] : cache.name_to_id) {
                 auto struct_it = cache.structs.find(id);
                 w.BeginObject()
-                    .Key("name").WriteString(name)
-                    .Key("type_id").WriteInt(id)
-                    .Key("property_count").WriteInt(
-                        struct_it != cache.structs.end()
-                            ? static_cast<int32_t>(struct_it->second.properties.size()) : 0)
+                    .Key("name")
+                    .WriteString(name)
+                    .Key("type_id")
+                    .WriteInt(id)
+                    .Key("property_count")
+                    .WriteInt(struct_it != cache.structs.end()
+                                  ? static_cast<int32_t>(struct_it->second.properties.size())
+                                  : 0)
                     .EndObject();
             }
             w.EndArray();
diff --git a/tools/cli/include/commands/navigation_commands.h b/tools/cli/include/commands/navigation_commands.h
index 5758c29..526ed59 100644
--- a/tools/cli/include/commands/navigation_commands.h
+++ b/tools/cli/include/commands/navigation_commands.h
@@ -9,9 +9,8 @@ namespace VtxCli {
     namespace detail {
         /// Write bucket_count and entity_count for a given frame.
         /// Always writes both keys (0 if frame is null).
-        template<FormatWriter Fmt>
-        void WriteFrameStats(Fmt& w, const VTX::Frame* frame)
-        {
+        template <FormatWriter Fmt>
+        void WriteFrameStats(Fmt& w, const VTX::Frame* frame) {
             if (frame) {
                 const auto& buckets = frame->GetBuckets();
                 w.Key("bucket_count").WriteInt(static_cast<int32_t>(buckets.size()));
@@ -25,24 +24,26 @@ namespace VtxCli {
                 w.Key("entity_count").WriteInt(0);
             }
         }
-    }
+    } // namespace detail
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct FrameCommand {
         static constexpr std::string_view Name = "frame";
         static constexpr std::string_view Help = "frame [n] - Query or navigate to frame n";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& w)
-        {
-            if (!RequireLoaded(context, w, Name)) return;
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& w) {
+            if (!RequireLoaded(context, w, Name))
+                return;
 
             // No args: query current frame
             if (args.empty()) {
                 const auto* frame = context.session.GetCurrentFrameData();
 
                 ResponseOk(w, Name)
-                    .Key("current_frame").WriteInt(context.session.GetCurrentFrame())
-                    .Key("total_frames").WriteInt(context.session.GetTotalFrames());
+                    .Key("current_frame")
+                    .WriteInt(context.session.GetCurrentFrame())
+                    .Key("total_frames")
+                    .WriteInt(context.session.GetTotalFrames());
                 detail::WriteFrameStats(w, frame);
                 EndResponse(w);
                 return;
@@ -51,7 +52,7 @@ namespace VtxCli {
             // Parse frame number
             int32_t frame_number;
             try {
-               frame_number = std::stoi(std::string(args[0]));
+                frame_number = std::stoi(std::string(args[0]));
             } catch (...) {
                 ResponseError(w, Name, "Invalid frame number: " + std::string(args[0]));
                 return;
@@ -65,8 +66,10 @@ namespace VtxCli {
             const auto* frame = context.session.GetCurrentFrameData();
 
             ResponseOk(w, Name)
-                .Key("current_frame").WriteInt(context.session.GetCurrentFrame())
-                .Key("total_frames").WriteInt(context.session.GetTotalFrames());
+                .Key("current_frame")
+                .WriteInt(context.session.GetCurrentFrame())
+                .Key("total_frames")
+                .WriteInt(context.session.GetTotalFrames());
             detail::WriteFrameStats(w, frame);
             EndResponse(w);
         }
diff --git a/tools/cli/include/commands/session_commands.h b/tools/cli/include/commands/session_commands.h
index c40d9da..31600e6 100644
--- a/tools/cli/include/commands/session_commands.h
+++ b/tools/cli/include/commands/session_commands.h
@@ -7,26 +7,24 @@
 namespace VtxCli {
 
     // exit / quit
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct ExitCommand {
         static constexpr std::string_view Name = "exit";
         static constexpr std::string_view Help = "exit - End the session";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
             context.exit_requested = true;
             ResponseOk(writer, Name);
             EndResponse(writer);
         }
     };
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct QuitCommand {
         static constexpr std::string_view Name = "quit";
         static constexpr std::string_view Help = "quit - End the session (alias for exit)";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
             context.exit_requested = true;
             ResponseOk(writer, Name);
             EndResponse(writer);
@@ -34,22 +32,23 @@ namespace VtxCli {
     };
 
     // help
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     struct HelpCommand {
         static constexpr std::string_view Name = "help";
         static constexpr std::string_view Help = "help - List all available commands";
 
-        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer)
-        {
+        void Run(CommandContext& context, std::span<const std::string> args, Fmt& writer) {
             ResponseOk(writer, Name);
             writer.Key("commands");
             writer.BeginArray();
             if (context.help_entries) {
                 for (const auto& entry : *context.help_entries) {
                     writer.BeginObject()
-                     .Key("name").WriteString(entry.name)
-                     .Key("description").WriteString(entry.description)
-                     .EndObject();
+                        .Key("name")
+                        .WriteString(entry.name)
+                        .Key("description")
+                        .WriteString(entry.description)
+                        .EndObject();
                 }
             }
             writer.EndArray();
diff --git a/tools/cli/include/core/cli_concepts.h b/tools/cli/include/core/cli_concepts.h
index ea63bb3..02d921f 100644
--- a/tools/cli/include/core/cli_concepts.h
+++ b/tools/cli/include/core/cli_concepts.h
@@ -6,51 +6,42 @@
 
 namespace VtxCli {
 
-    template<typename T>
-    concept FormatWriter = requires(T writer, 
-                                    bool bool_value,
-                                    int32_t int32_value,
-                                    uint32_t uint32_value,
-                                    int64_t int64_value,
-                                    uint64_t uint64_value,
-                                    float float_value,
-                                    double double_value,
-                                    const std::string& string_value
-                            )
-    {
-        //structure
-        {writer.BeginObject()}->std::same_as<T&>;
-        {writer.EndObject()}->std::same_as<T&>;
-        {writer.BeginArray()}->std::same_as<T&>;
-        {writer.EndArray()}->std::same_as<T&>;
-        //key
-        {writer.Key(string_value)}-> std::same_as<T&>;
-        //primitive values
-        {writer.WriteBool(bool_value)};
-        {writer.WriteInt(int32_value)};
-        {writer.WriteUInt(uint32_value)};
-        {writer.WriteInt64(int64_value)};
-        {writer.WriteUInt64(uint64_value)};
-        {writer.WriteFloat(float_value)};
-        {writer.WriteDouble(double_value)};
-        {writer.WriteString(string_value)};
-        {writer.WriteNull()};
-        
-        //To pass preformatted content
-        {writer.WriteRaw(string_value)} -> std::same_as<T&>;
-        
-        //Finelize
-        {writer.Finalize(string_value)} ->std::convertible_to<std::string>;//convertible_to allows to return const string&
-            
-    };
-    
-    template<typename T>
-    concept Transport = requires(T transport,
-                                const std::string& string_value)
-    {
-        {transport.ReadLine()}->std::convertible_to<std::optional<std::string>>;
-        {transport.WriteLine(string_value)};
-        {transport.IsOpen() }   -> std::convertible_to<bool>;
-    };
+    template <typename T>
+    concept FormatWriter =
+        requires(T writer, bool bool_value, int32_t int32_value, uint32_t uint32_value, int64_t int64_value,
+                 uint64_t uint64_value, float float_value, double double_value, const std::string& string_value) {
+            //structure
+            { writer.BeginObject() } -> std::same_as<T&>;
+            { writer.EndObject() } -> std::same_as<T&>;
+            { writer.BeginArray() } -> std::same_as<T&>;
+            { writer.EndArray() } -> std::same_as<T&>;
+            //key
+            { writer.Key(string_value) } -> std::same_as<T&>;
+            //primitive values
+            { writer.WriteBool(bool_value) };
+            { writer.WriteInt(int32_value) };
+            { writer.WriteUInt(uint32_value) };
+            { writer.WriteInt64(int64_value) };
+            { writer.WriteUInt64(uint64_value) };
+            { writer.WriteFloat(float_value) };
+            { writer.WriteDouble(double_value) };
+            { writer.WriteString(string_value) };
+            { writer.WriteNull() };
+
+            //To pass preformatted content
+            { writer.WriteRaw(string_value) } -> std::same_as<T&>;
+
+            //Finelize
+            {
+                writer.Finalize(string_value)
+                } -> std::convertible_to<std::string>; //convertible_to allows to return const string&
+        };
+
+    template <typename T>
+    concept Transport = requires(T transport, const std::string& string_value) {
+                            { transport.ReadLine() } -> std::convertible_to<std::optional<std::string>>;
+                            { transport.WriteLine(string_value) };
+                            { transport.IsOpen() } -> std::convertible_to<bool>;
+                        };
 
 } // namespace VtxCli
diff --git a/tools/cli/include/core/cli_engine.h b/tools/cli/include/core/cli_engine.h
index f95b8cb..b9a8832 100644
--- a/tools/cli/include/core/cli_engine.h
+++ b/tools/cli/include/core/cli_engine.h
@@ -12,135 +12,135 @@
 
 namespace VtxCli {
 
-inline constexpr const char* kCliVersion = "0.1.0";
-
-template<FormatWriter Fmt, Transport IO>
-class CliEngine {
-public:
-    template<typename... Args>
-    explicit CliEngine(Args&&... transport_args)
-        : transport_(std::forward<Args>(transport_args)...)
-    {
-        RegisterCommands();
-    }
-
-    void Run()
-    {
-        CommandContext ctx{session_};
-        ctx.help_entries = &registry_.GetHelpEntries();
-
-        bool verbose = false;
-        if constexpr (requires { transport_.IsVerbose(); }) {
-            verbose = transport_.IsVerbose();
+    inline constexpr const char* kCliVersion = "0.1.0";
+
+    template <FormatWriter Fmt, Transport IO>
+    class CliEngine {
+    public:
+        template <typename... Args>
+        explicit CliEngine(Args&&... transport_args)
+            : transport_(std::forward<Args>(transport_args)...) {
+            RegisterCommands();
         }
 
-        if (verbose) {
-            transport_.WriteLog("------------------------------------------");
-            transport_.WriteLog("  VTX CLI v" + std::string(kCliVersion) + " - Headless Inspector");
-            transport_.WriteLog("  Type 'help' for available commands");
-            transport_.WriteLog("------------------------------------------");
-        }
+        void Run() {
+            CommandContext ctx {session_};
+            ctx.help_entries = &registry_.GetHelpEntries();
 
-        {
-            Fmt w;
-            w.BeginObject()
-             .Key("status").WriteString("ready")
-             .Key("tool").WriteString("vtx_cli")
-             .Key("version").WriteString(kCliVersion)
-             .Key("commands");
-            w.BeginArray();
-            for (const auto& entry : registry_.GetHelpEntries()) {
-                w.WriteString(entry.name);
+            bool verbose = false;
+            if constexpr (requires { transport_.IsVerbose(); }) {
+                verbose = transport_.IsVerbose();
             }
-            w.EndArray()
-             .EndObject();
-            transport_.WriteLine(w.Finalize(""));
-        }
 
-        while (!ctx.exit_requested && transport_.IsOpen()) {
-            auto line = transport_.ReadLine();
-            if (!line) break;
-            if (line->empty()) continue;
+            if (verbose) {
+                transport_.WriteLog("------------------------------------------");
+                transport_.WriteLog("  VTX CLI v" + std::string(kCliVersion) + " - Headless Inspector");
+                transport_.WriteLog("  Type 'help' for available commands");
+                transport_.WriteLog("------------------------------------------");
+            }
+
+            {
+                Fmt w;
+                w.BeginObject()
+                    .Key("status")
+                    .WriteString("ready")
+                    .Key("tool")
+                    .WriteString("vtx_cli")
+                    .Key("version")
+                    .WriteString(kCliVersion)
+                    .Key("commands");
+                w.BeginArray();
+                for (const auto& entry : registry_.GetHelpEntries()) {
+                    w.WriteString(entry.name);
+                }
+                w.EndArray().EndObject();
+                transport_.WriteLine(w.Finalize(""));
+            }
 
-            auto response = registry_.Dispatch(ctx, *line);
-            if (!response.empty()) {
-                transport_.WriteLine(response);
+            while (!ctx.exit_requested && transport_.IsOpen()) {
+                auto line = transport_.ReadLine();
+                if (!line)
+                    break;
+                if (line->empty())
+                    continue;
+
+                auto response = registry_.Dispatch(ctx, *line);
+                if (!response.empty()) {
+                    transport_.WriteLine(response);
+                }
             }
         }
-    }
-
-private:
-    void RegisterCommands()
-    {
-        // File
-        registry_.template Register<OpenCommand>();
-        registry_.template Register<CloseCommand>();
-
-        // Session
-        registry_.template Register<HelpCommand>();
-        registry_.template Register<ExitCommand>();
-        registry_.template Register<QuitCommand>();
-
-        // Info
-        registry_.template Register<InfoCommand>();
-        registry_.template Register<HeaderCommand>();
-        registry_.template Register<FooterCommand>();
-        registry_.template Register<SchemaCommand>();
-        registry_.template Register<ChunksCommand>();
-        registry_.template Register<EventsCommand>();
-
-        // Navigation
-        registry_.template Register<FrameCommand>();
-
-        // Inspect
-        registry_.template Register<BucketsCommand>();
-        registry_.template Register<EntitiesCommand>();
-        registry_.template Register<EntityCommand>();
-        registry_.template Register<PropertyCommand>();
-        registry_.template Register<TypesCommand>();
-
-        // Analysis
-        registry_.template Register<DiffCommand>();
-        registry_.template Register<TrackCommand>();
-        registry_.template Register<SearchCommand>();
-    }
-
-    CliSession  session_;
-    CommandRegistry<Fmt> registry_;
-    IO transport_;
-
-public:
-    /// Print the list of interactive commands to an output stream.
-    /// Can be called without a running engine (static-like via temp instance).
-    static void PrintCommandHelp(std::ostream& out)
-    {
-        CommandRegistry<Fmt> reg;
-        // Register all commands into a temporary registry
-        reg.template Register<OpenCommand>();
-        reg.template Register<CloseCommand>();
-        reg.template Register<HelpCommand>();
-        reg.template Register<ExitCommand>();
-        reg.template Register<QuitCommand>();
-        reg.template Register<InfoCommand>();
-        reg.template Register<HeaderCommand>();
-        reg.template Register<FooterCommand>();
-        reg.template Register<SchemaCommand>();
-        reg.template Register<ChunksCommand>();
-        reg.template Register<EventsCommand>();
-        reg.template Register<FrameCommand>();
-        reg.template Register<BucketsCommand>();
-        reg.template Register<EntitiesCommand>();
-        reg.template Register<EntityCommand>();
-        reg.template Register<PropertyCommand>();
-        reg.template Register<TypesCommand>();
-        reg.template Register<DiffCommand>();
-        reg.template Register<TrackCommand>();
-        reg.template Register<SearchCommand>();
-
-        for (const auto& entry : reg.GetHelpEntries()) {
-            out << "  " << entry.description << "\n";
+
+    private:
+        void RegisterCommands() {
+            // File
+            registry_.template Register<OpenCommand>();
+            registry_.template Register<CloseCommand>();
+
+            // Session
+            registry_.template Register<HelpCommand>();
+            registry_.template Register<ExitCommand>();
+            registry_.template Register<QuitCommand>();
+
+            // Info
+            registry_.template Register<InfoCommand>();
+            registry_.template Register<HeaderCommand>();
+            registry_.template Register<FooterCommand>();
+            registry_.template Register<SchemaCommand>();
+            registry_.template Register<ChunksCommand>();
+            registry_.template Register<EventsCommand>();
+
+            // Navigation
+            registry_.template Register<FrameCommand>();
+
+            // Inspect
+            registry_.template Register<BucketsCommand>();
+            registry_.template Register<EntitiesCommand>();
+            registry_.template Register<EntityCommand>();
+            registry_.template Register<PropertyCommand>();
+            registry_.template Register<TypesCommand>();
+
+            // Analysis
+            registry_.template Register<DiffCommand>();
+            registry_.template Register<TrackCommand>();
+            registry_.template Register<SearchCommand>();
+        }
+
+        CliSession session_;
+        CommandRegistry<Fmt> registry_;
+        IO transport_;
+
+    public:
+        /// Print the list of interactive commands to an output stream.
+        /// Can be called without a running engine (static-like via temp instance).
+        static void PrintCommandHelp(std::ostream& out) {
+            CommandRegistry<Fmt> reg;
+            // Register all commands into a temporary registry
+            reg.template Register<OpenCommand>();
+            reg.template Register<CloseCommand>();
+            reg.template Register<HelpCommand>();
+            reg.template Register<ExitCommand>();
+            reg.template Register<QuitCommand>();
+            reg.template Register<InfoCommand>();
+            reg.template Register<HeaderCommand>();
+            reg.template Register<FooterCommand>();
+            reg.template Register<SchemaCommand>();
+            reg.template Register<ChunksCommand>();
+            reg.template Register<EventsCommand>();
+            reg.template Register<FrameCommand>();
+            reg.template Register<BucketsCommand>();
+            reg.template Register<EntitiesCommand>();
+            reg.template Register<EntityCommand>();
+            reg.template Register<PropertyCommand>();
+            reg.template Register<TypesCommand>();
+            reg.template Register<DiffCommand>();
+            reg.template Register<TrackCommand>();
+            reg.template Register<SearchCommand>();
+
+            for (const auto& entry : reg.GetHelpEntries()) {
+                out << "  " << entry.description << "\n";
+            }
         }
-    }
-};
+    };
 
 } // namespace VtxCli
diff --git a/tools/cli/include/core/cli_session.h b/tools/cli/include/core/cli_session.h
index b560ef3..e67d842 100644
--- a/tools/cli/include/core/cli_session.h
+++ b/tools/cli/include/core/cli_session.h
@@ -14,72 +14,73 @@
 
 namespace VtxCli {
 
-class CliSession {
-public:
-    CliSession() = default;
-    ~CliSession() = default;
-
-    CliSession(const CliSession&) = delete;
-    CliSession& operator=(const CliSession&) = delete;
-
-    bool Open(const std::string& filepath);
-    void Close();
-
-    bool IsLoaded() const { return reader_context_.Loaded(); }
-    const std::string& GetFilePath() const { return file_path_; }
-    VTX::VtxFormat GetFormat() const { return reader_context_.GetFormat(); }
-    int GetTotalFrames() const { return reader_context_->GetTotalFrames(); }
-    int GetCurrentFrame() const { return current_frame_; }
-
-    bool SetFrame(int32_t frame);
-
-    VTX::IVtxReaderFacade* GetReader() const { return reader_context_.operator->(); }
-    VTX::FileHeader GetHeader() const { return reader_context_->GetHeader(); }
-    VTX::FileFooter GetFooter() const { return reader_context_->GetFooter(); }
-    VTX::ContextualSchema GetContextualSchema() const { return reader_context_->GetContextualSchema(); }
-    VTX::PropertyAddressCache GetPropertyCache() const { return reader_context_->GetPropertyAddressCache(); }
-    float GetFileSizeMb() const { return reader_context_.size_in_mb; }
-    const VTX::Frame* GetCurrentFrameData();
-    const VTX::Frame* GetFrameData(int frame_index) const;
-
-    /// Pin a frame: deep-copies it from the reader cache and recomputes
-    /// content_hashes with the current hash function.  The returned pointer
-    /// stays valid until UnpinFrame() is called (unaffected by reader eviction).
-    const VTX::Frame* PinFrame(int frame_index);
-    void UnpinFrame(int frame_index);
-
-    /// Diff two frames using vtx_differ (binary tree-diff on raw serialized data).
-    VtxDiff::PatchIndex DiffFrames(int frame_a, int frame_b,
-                                   const VtxDiff::DiffOptions& opts = {});
-
-    const std::string& GetLastError() const { return last_error_; }
-
-private:
-    std::string file_path_;
-    int32_t current_frame_ = 0;
-    std::string last_error_;
-
-    VTX::ReaderContext reader_context_;
-    std::unique_ptr<VtxDiff::IVtxDifferFacade> differ_;
-    std::unordered_map<int, VTX::Frame> pinned_frames_;
-};
-
-
-struct FramePin {
-    CliSession& session;
-    int frame_index;
-    const VTX::Frame* frame;
-
-    FramePin(CliSession& s, int idx)
-        : session(s), frame_index(idx), frame(s.PinFrame(idx)) {}
-    ~FramePin() { session.UnpinFrame(frame_index); }
-
-    FramePin(const FramePin&) = delete;
-    FramePin& operator=(const FramePin&) = delete;
-
-    explicit operator bool() const { return frame != nullptr; }
-    const VTX::Frame& operator*() const { return *frame; }
-    const VTX::Frame* operator->() const { return frame; }
-};
+    class CliSession {
+    public:
+        CliSession() = default;
+        ~CliSession() = default;
+
+        CliSession(const CliSession&) = delete;
+        CliSession& operator=(const CliSession&) = delete;
+
+        bool Open(const std::string& filepath);
+        void Close();
+
+        bool IsLoaded() const { return reader_context_.Loaded(); }
+        const std::string& GetFilePath() const { return file_path_; }
+        VTX::VtxFormat GetFormat() const { return reader_context_.GetFormat(); }
+        int GetTotalFrames() const { return reader_context_->GetTotalFrames(); }
+        int GetCurrentFrame() const { return current_frame_; }
+
+        bool SetFrame(int32_t frame);
+
+        VTX::IVtxReaderFacade* GetReader() const { return reader_context_.operator->(); }
+        VTX::FileHeader GetHeader() const { return reader_context_->GetHeader(); }
+        VTX::FileFooter GetFooter() const { return reader_context_->GetFooter(); }
+        VTX::ContextualSchema GetContextualSchema() const { return reader_context_->GetContextualSchema(); }
+        VTX::PropertyAddressCache GetPropertyCache() const { return reader_context_->GetPropertyAddressCache(); }
+        float GetFileSizeMb() const { return reader_context_.size_in_mb; }
+        const VTX::Frame* GetCurrentFrameData();
+        const VTX::Frame* GetFrameData(int frame_index) const;
+
+        /// Pin a frame: deep-copies it from the reader cache and recomputes
+        /// content_hashes with the current hash function.  The returned pointer
+        /// stays valid until UnpinFrame() is called (unaffected by reader eviction).
+        const VTX::Frame* PinFrame(int frame_index);
+        void UnpinFrame(int frame_index);
+
+        /// Diff two frames using vtx_differ (binary tree-diff on raw serialized data).
+        VtxDiff::PatchIndex DiffFrames(int frame_a, int frame_b, const VtxDiff::DiffOptions& opts = {});
+
+        const std::string& GetLastError() const { return last_error_; }
+
+    private:
+        std::string file_path_;
+        int32_t current_frame_ = 0;
+        std::string last_error_;
+
+        VTX::ReaderContext reader_context_;
+        std::unique_ptr<VtxDiff::IVtxDifferFacade> differ_;
+        std::unordered_map<int, VTX::Frame> pinned_frames_;
+    };
+
+
+    struct FramePin {
+        CliSession& session;
+        int frame_index;
+        const VTX::Frame* frame;
+
+        FramePin(CliSession& s, int idx)
+            : session(s)
+            , frame_index(idx)
+            , frame(s.PinFrame(idx)) {}
+        ~FramePin() { session.UnpinFrame(frame_index); }
+
+        FramePin(const FramePin&) = delete;
+        FramePin& operator=(const FramePin&) = delete;
+
+        explicit operator bool() const { return frame != nullptr; }
+        const VTX::Frame& operator*() const { return *frame; }
+        const VTX::Frame* operator->() const { return frame; }
+    };
 
 } // namespace VtxCli
diff --git a/tools/cli/include/format/json_format.h b/tools/cli/include/format/json_format.h
index 1c7bd00..1860801 100644
--- a/tools/cli/include/format/json_format.h
+++ b/tools/cli/include/format/json_format.h
@@ -7,36 +7,34 @@
 namespace VtxCli {
 
 
-class JsonFormat
-{
-    
-public:
-    
-    JsonFormat& BeginObject();
-    JsonFormat& EndObject();
-    
-    JsonFormat& BeginArray();
-    JsonFormat& EndArray();
-    
-    JsonFormat& Key(const std::string& key);
-    
-    JsonFormat& WriteBool(bool value);
-    JsonFormat& WriteInt(int32_t value);
-    JsonFormat& WriteUInt(uint32_t value);
-    JsonFormat& WriteInt64(int64_t value);
-    JsonFormat& WriteUInt64(uint64_t value);
-    JsonFormat& WriteFloat(float value);
-    JsonFormat& WriteDouble(double value);
-    JsonFormat& WriteString(const std::string& value);
-    JsonFormat& WriteNull();
-    JsonFormat& WriteRaw(const std::string& value);
-    std::string Finalize(const std::string& optional_data);
-private:
-    void WriteSeparator();
-    static std::string Escape(const std::string& s);
-    
-    std::ostringstream stream_;
-    std::vector<bool> first_;
-};
-static_assert(FormatWriter<JsonFormat>, "JsonFormat must satisfy FormatWriter");
+    class JsonFormat {
+    public:
+        JsonFormat& BeginObject();
+        JsonFormat& EndObject();
+
+        JsonFormat& BeginArray();
+        JsonFormat& EndArray();
+
+        JsonFormat& Key(const std::string& key);
+
+        JsonFormat& WriteBool(bool value);
+        JsonFormat& WriteInt(int32_t value);
+        JsonFormat& WriteUInt(uint32_t value);
+        JsonFormat& WriteInt64(int64_t value);
+        JsonFormat& WriteUInt64(uint64_t value);
+        JsonFormat& WriteFloat(float value);
+        JsonFormat& WriteDouble(double value);
+        JsonFormat& WriteString(const std::string& value);
+        JsonFormat& WriteNull();
+        JsonFormat& WriteRaw(const std::string& value);
+        std::string Finalize(const std::string& optional_data);
+
+    private:
+        void WriteSeparator();
+        static std::string Escape(const std::string& s);
+
+        std::ostringstream stream_;
+        std::vector<bool> first_;
+    };
+    static_assert(FormatWriter<JsonFormat>, "JsonFormat must satisfy FormatWriter");
 } // namespace VtxCli
diff --git a/tools/cli/include/format/vtx_type_serializer.h b/tools/cli/include/format/vtx_type_serializer.h
index cfec719..5153b8f 100644
--- a/tools/cli/include/format/vtx_type_serializer.h
+++ b/tools/cli/include/format/vtx_type_serializer.h
@@ -11,59 +11,64 @@
 
 #include "core/cli_concepts.h"
 
-#include "vtx/common/vtx_property_cache.h"   
+#include "vtx/common/vtx_property_cache.h"
 
 #include <string>
 #include <cstdint>
 
 namespace VtxCli {
-        
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     void Serialize(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddressCache& cache);
-        
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     void Serialize(Fmt& w, const VTX::Vector& v) {
-        w.BeginObject()
-         .Key("x").WriteDouble(v.x)
-         .Key("y").WriteDouble(v.y)
-         .Key("z").WriteDouble(v.z)
-         .EndObject();
+        w.BeginObject().Key("x").WriteDouble(v.x).Key("y").WriteDouble(v.y).Key("z").WriteDouble(v.z).EndObject();
     }
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     void Serialize(Fmt& w, const VTX::Quat& q) {
         w.BeginObject()
-         .Key("x").WriteFloat(q.x)
-         .Key("y").WriteFloat(q.y)
-         .Key("z").WriteFloat(q.z)
-         .Key("w").WriteFloat(q.w)
-         .EndObject();
+            .Key("x")
+            .WriteFloat(q.x)
+            .Key("y")
+            .WriteFloat(q.y)
+            .Key("z")
+            .WriteFloat(q.z)
+            .Key("w")
+            .WriteFloat(q.w)
+            .EndObject();
     }
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     void Serialize(Fmt& w, const VTX::Transform& t) {
         w.BeginObject();
-        w.Key("translation"); Serialize(w, t.translation);
-        w.Key("rotation");    Serialize(w, t.rotation);
-        w.Key("scale");       Serialize(w, t.scale);
+        w.Key("translation");
+        Serialize(w, t.translation);
+        w.Key("rotation");
+        Serialize(w, t.rotation);
+        w.Key("scale");
+        Serialize(w, t.scale);
         w.EndObject();
     }
 
-    template<FormatWriter Fmt>
+    template <FormatWriter Fmt>
     void Serialize(Fmt& w, const VTX::FloatRange& r) {
         w.BeginObject()
-         .Key("min").WriteFloat(r.min)
-         .Key("max").WriteFloat(r.max)
-         .Key("value_normalized").WriteFloat(r.value_normalized)
-         .EndObject();
+            .Key("min")
+            .WriteFloat(r.min)
+            .Key("max")
+            .WriteFloat(r.max)
+            .Key("value_normalized")
+            .WriteFloat(r.value_normalized)
+            .EndObject();
     }
-    
-    template<FormatWriter Fmt>
+
+    template <FormatWriter Fmt>
     void Serialize(Fmt& w, const VTX::MapContainer& m, const VTX::PropertyAddressCache& cache) {
         w.BeginObject();
         const size_t count = std::min(m.keys.size(), m.values.size());
-        for (size_t i = 0; i < count; ++i) 
-        {
+        for (size_t i = 0; i < count; ++i) {
             w.Key(m.keys[i]);
             Serialize(w, m.values[i], cache);
         }
@@ -73,137 +78,103 @@ namespace VtxCli {
 
     namespace detail {
 
-    /// Bounds-checked read. Returns true if index is within the container.
-    template<typename Container>
-    inline bool InBounds(const Container& c, size_t idx) {
-        return idx < c.size();
-    }
-        
-    template<FormatWriter Fmt>
-    void WriteScalarValue(Fmt& w,const VTX::PropertyContainer& pc,const VTX::PropertyAddress& addr,const VTX::PropertyAddressCache& cache)
-    {
-        const auto idx = static_cast<size_t>(addr.index);
-        switch (addr.type_id) {
+        /// Bounds-checked read. Returns true if index is within the container.
+        template <typename Container>
+        inline bool InBounds(const Container& c, size_t idx) {
+            return idx < c.size();
+        }
 
+        template <FormatWriter Fmt>
+        void WriteScalarValue(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddress& addr,
+                              const VTX::PropertyAddressCache& cache) {
+            const auto idx = static_cast<size_t>(addr.index);
+            switch (addr.type_id) {
             case VTX::FieldType::Bool:
                 // std::vector<bool> returns proxy — cast explicitly
-                if (InBounds(pc.bool_properties, idx))
-                {
+                if (InBounds(pc.bool_properties, idx)) {
                     w.WriteBool(static_cast<bool>(pc.bool_properties[idx]));
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Int32:
-            case VTX::FieldType::Enum:// enums stored as int32
-                if (InBounds(pc.int32_properties, idx))
-                {
+            case VTX::FieldType::Enum: // enums stored as int32
+                if (InBounds(pc.int32_properties, idx)) {
                     w.WriteInt(pc.int32_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Int64:
-                if (InBounds(pc.int64_properties, idx))
-                {
+                if (InBounds(pc.int64_properties, idx)) {
                     w.WriteInt64(pc.int64_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Float:
-                if (InBounds(pc.float_properties, idx))
-                {
+                if (InBounds(pc.float_properties, idx)) {
                     w.WriteFloat(pc.float_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Double:
-                if (InBounds(pc.double_properties, idx))
-                {
+                if (InBounds(pc.double_properties, idx)) {
                     w.WriteDouble(pc.double_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::String:
-                if (InBounds(pc.string_properties, idx))
-                {
+                if (InBounds(pc.string_properties, idx)) {
                     w.WriteString(pc.string_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Vector:
-                if (InBounds(pc.vector_properties, idx))
-                {
+                if (InBounds(pc.vector_properties, idx)) {
                     Serialize(w, pc.vector_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Quat:
-                if (InBounds(pc.quat_properties, idx))
-                {
+                if (InBounds(pc.quat_properties, idx)) {
                     Serialize(w, pc.quat_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Transform:
-                if (InBounds(pc.transform_properties, idx))
-                {
+                if (InBounds(pc.transform_properties, idx)) {
                     Serialize(w, pc.transform_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::FloatRange:
-                if (InBounds(pc.range_properties, idx))
-                {
+                if (InBounds(pc.range_properties, idx)) {
                     Serialize(w, pc.range_properties[idx]);
-                }
-                else
-                {
+                } else {
                     w.WriteNull();
                 }
                 break;
 
             case VTX::FieldType::Struct:
-                if (InBounds(pc.any_struct_properties, idx))
-                {
-                    Serialize(w, pc.any_struct_properties[idx], cache);   // recursion
-                }
-                else
-                {
+                if (InBounds(pc.any_struct_properties, idx)) {
+                    Serialize(w, pc.any_struct_properties[idx], cache); // recursion
+                } else {
                     w.WriteNull();
                 }
                 break;
@@ -211,21 +182,20 @@ namespace VtxCli {
             default:
                 w.WriteNull();
                 break;
+            }
         }
-    }
 
 
-    template<FormatWriter Fmt>
-    void WriteArrayValue(Fmt& w,const VTX::PropertyContainer& pc,const VTX::PropertyAddress& addr,const VTX::PropertyAddressCache& cache)
-    {
-        const auto idx = static_cast<size_t>(addr.index);
+        template <FormatWriter Fmt>
+        void WriteArrayValue(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddress& addr,
+                             const VTX::PropertyAddressCache& cache) {
+            const auto idx = static_cast<size_t>(addr.index);
 
-        switch (addr.type_id) {
+            switch (addr.type_id) {
             case VTX::FieldType::Bool: {
                 auto span = pc.bool_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (auto v : span)
-                {
+                for (auto v : span) {
                     w.WriteBool(v != 0);
                 }
                 w.EndArray();
@@ -236,8 +206,7 @@ namespace VtxCli {
             case VTX::FieldType::Enum: {
                 auto span = pc.int32_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (auto v : span)
-                {
+                for (auto v : span) {
                     w.WriteInt(v);
                 }
                 w.EndArray();
@@ -247,8 +216,7 @@ namespace VtxCli {
             case VTX::FieldType::Int64: {
                 auto span = pc.int64_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (auto v : span)
-                {
+                for (auto v : span) {
                     w.WriteInt64(v);
                 }
                 w.EndArray();
@@ -258,8 +226,7 @@ namespace VtxCli {
             case VTX::FieldType::Float: {
                 auto span = pc.float_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (auto v : span)
-                {
+                for (auto v : span) {
                     w.WriteFloat(v);
                 }
                 w.EndArray();
@@ -269,8 +236,7 @@ namespace VtxCli {
             case VTX::FieldType::Double: {
                 auto span = pc.double_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (auto v : span)
-                {
+                for (auto v : span) {
                     w.WriteDouble(v);
                 }
                 w.EndArray();
@@ -280,8 +246,7 @@ namespace VtxCli {
             case VTX::FieldType::String: {
                 auto span = pc.string_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (const auto& v : span)
-                {
+                for (const auto& v : span) {
                     w.WriteString(v);
                 }
                 w.EndArray();
@@ -291,8 +256,7 @@ namespace VtxCli {
             case VTX::FieldType::Vector: {
                 auto span = pc.vector_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (const auto& v : span)
-                {
+                for (const auto& v : span) {
                     Serialize(w, v);
                 }
                 w.EndArray();
@@ -302,8 +266,7 @@ namespace VtxCli {
             case VTX::FieldType::Quat: {
                 auto span = pc.quat_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (const auto& v : span)
-                {
+                for (const auto& v : span) {
                     Serialize(w, v);
                 }
                 w.EndArray();
@@ -313,8 +276,7 @@ namespace VtxCli {
             case VTX::FieldType::Transform: {
                 auto span = pc.transform_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (const auto& v : span)
-                {
+                for (const auto& v : span) {
                     Serialize(w, v);
                 }
                 w.EndArray();
@@ -324,8 +286,7 @@ namespace VtxCli {
             case VTX::FieldType::FloatRange: {
                 auto span = pc.range_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (const auto& v : span)
-                {
+                for (const auto& v : span) {
                     Serialize(w, v);
                 }
                 w.EndArray();
@@ -335,8 +296,7 @@ namespace VtxCli {
             case VTX::FieldType::Struct: {
                 auto span = pc.any_struct_arrays.GetSubArray(idx);
                 w.BeginArray();
-                for (const auto& v : span)
-                {
+                for (const auto& v : span) {
                     Serialize(w, v, cache);
                 }
                 w.EndArray();
@@ -344,84 +304,85 @@ namespace VtxCli {
             }
 
             default:
-                w.BeginArray().EndArray();   // empty array for unknown types
+                w.BeginArray().EndArray(); // empty array for unknown types
                 break;
                 break;
+            }
         }
-    }
 
 
-    template<FormatWriter Fmt>
-    void WriteMapValue(Fmt& w,const VTX::PropertyContainer& pc,const VTX::PropertyAddress& addr,const VTX::PropertyAddressCache& cache)
-    {
-        const auto idx = static_cast<size_t>(addr.index);
-        if (InBounds(pc.map_properties, idx)) {
-            Serialize(w, pc.map_properties[idx], cache);
-        } else {
-            w.WriteNull();
+        template <FormatWriter Fmt>
+        void WriteMapValue(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddress& addr,
+                           const VTX::PropertyAddressCache& cache) {
+            const auto idx = static_cast<size_t>(addr.index);
+            if (InBounds(pc.map_properties, idx)) {
+                Serialize(w, pc.map_properties[idx], cache);
+            } else {
+                w.WriteNull();
+            }
         }
-    }
-        
-    template<FormatWriter Fmt>
-    void WritePropertyValue(Fmt& w,const VTX::PropertyContainer& pc,const VTX::PropertyAddress& addr,const VTX::PropertyAddressCache& cache)
-    {
-        switch (addr.container_type) {
+
+        template <FormatWriter Fmt>
+        void WritePropertyValue(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddress& addr,
+                                const VTX::PropertyAddressCache& cache) {
+            switch (addr.container_type) {
             case VTX::FieldContainerType::Array:
                 WriteArrayValue(w, pc, addr, cache);
                 break;
             case VTX::FieldContainerType::Map:
                 WriteMapValue(w, pc, addr, cache);
                 break;
-            default: 
+            default:
                 WriteScalarValue(w, pc, addr, cache);
                 break;
+            }
         }
-    }
-
 
-    template<FormatWriter Fmt>
-    void SerializeRawPropertyContainer(Fmt& w, const VTX::PropertyContainer& pc)
-    {
 
-        for (size_t i = 0; i < pc.bool_properties.size(); ++i) {
-            w.Key("bool_" + std::to_string(i)).WriteBool(static_cast<bool>(pc.bool_properties[i]));
-        }
-        for (size_t i = 0; i < pc.int32_properties.size(); ++i) {
-            w.Key("int32_" + std::to_string(i)).WriteInt(pc.int32_properties[i]);
-        }
-        for (size_t i = 0; i < pc.int64_properties.size(); ++i) {
-            w.Key("int64_" + std::to_string(i)).WriteInt64(pc.int64_properties[i]);
-        }
-        for (size_t i = 0; i < pc.float_properties.size(); ++i) {
-            w.Key("float_" + std::to_string(i)).WriteFloat(pc.float_properties[i]);
-        }
-        for (size_t i = 0; i < pc.double_properties.size(); ++i) {
-            w.Key("double_" + std::to_string(i)).WriteDouble(pc.double_properties[i]);
-        }
-        for (size_t i = 0; i < pc.string_properties.size(); ++i) {
-            w.Key("string_" + std::to_string(i)).WriteString(pc.string_properties[i]);
-        }
+        template <FormatWriter Fmt>
+        void SerializeRawPropertyContainer(Fmt& w, const VTX::PropertyContainer& pc) {
+            for (size_t i = 0; i < pc.bool_properties.size(); ++i) {
+                w.Key("bool_" + std::to_string(i)).WriteBool(static_cast<bool>(pc.bool_properties[i]));
+            }
+            for (size_t i = 0; i < pc.int32_properties.size(); ++i) {
+                w.Key("int32_" + std::to_string(i)).WriteInt(pc.int32_properties[i]);
+            }
+            for (size_t i = 0; i < pc.int64_properties.size(); ++i) {
+                w.Key("int64_" + std::to_string(i)).WriteInt64(pc.int64_properties[i]);
+            }
+            for (size_t i = 0; i < pc.float_properties.size(); ++i) {
+                w.Key("float_" + std::to_string(i)).WriteFloat(pc.float_properties[i]);
+            }
+            for (size_t i = 0; i < pc.double_properties.size(); ++i) {
+                w.Key("double_" + std::to_string(i)).WriteDouble(pc.double_properties[i]);
+            }
+            for (size_t i = 0; i < pc.string_properties.size(); ++i) {
+                w.Key("string_" + std::to_string(i)).WriteString(pc.string_properties[i]);
+            }
 
-        for (size_t i = 0; i < pc.vector_properties.size(); ++i) {
-            w.Key("vector_" + std::to_string(i)); Serialize(w, pc.vector_properties[i]);
-        }
-        for (size_t i = 0; i < pc.quat_properties.size(); ++i) {
-            w.Key("quat_" + std::to_string(i)); Serialize(w, pc.quat_properties[i]);
-        }
-        for (size_t i = 0; i < pc.transform_properties.size(); ++i) {
-            w.Key("transform_" + std::to_string(i)); Serialize(w, pc.transform_properties[i]);
-        }
-        for (size_t i = 0; i < pc.range_properties.size(); ++i) {
-            w.Key("range_" + std::to_string(i)); Serialize(w, pc.range_properties[i]);
+            for (size_t i = 0; i < pc.vector_properties.size(); ++i) {
+                w.Key("vector_" + std::to_string(i));
+                Serialize(w, pc.vector_properties[i]);
+            }
+            for (size_t i = 0; i < pc.quat_properties.size(); ++i) {
+                w.Key("quat_" + std::to_string(i));
+                Serialize(w, pc.quat_properties[i]);
+            }
+            for (size_t i = 0; i < pc.transform_properties.size(); ++i) {
+                w.Key("transform_" + std::to_string(i));
+                Serialize(w, pc.transform_properties[i]);
+            }
+            for (size_t i = 0; i < pc.range_properties.size(); ++i) {
+                w.Key("range_" + std::to_string(i));
+                Serialize(w, pc.range_properties[i]);
+            }
         }
-    }
 
     } // namespace detail
-    
 
-    template<FormatWriter Fmt>
-    void Serialize(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddressCache& cache)
-    {
+
+    template <FormatWriter Fmt>
+    void Serialize(Fmt& w, const VTX::PropertyContainer& pc, const VTX::PropertyAddressCache& cache) {
         w.BeginObject();
 
         w.Key("entity_type_id").WriteInt(pc.entity_type_id);
@@ -459,19 +420,17 @@ namespace VtxCli {
     }
 
 
-    template<FormatWriter Fmt>
-    bool SerializeProperty(Fmt& w,const VTX::PropertyContainer& pc,const std::string& property_name,const VTX::PropertyAddressCache& cache)
-    {
+    template <FormatWriter Fmt>
+    bool SerializeProperty(Fmt& w, const VTX::PropertyContainer& pc, const std::string& property_name,
+                           const VTX::PropertyAddressCache& cache) {
         auto struct_it = cache.structs.find(pc.entity_type_id);
-        if (struct_it == cache.structs.end())
-        {
+        if (struct_it == cache.structs.end()) {
             return false;
         }
 
         const VTX::StructSchemaCache& struct_cache = struct_it->second;
         auto prop_it = struct_cache.properties.find(property_name);
-        if (prop_it == struct_cache.properties.end())
-        {
+        if (prop_it == struct_cache.properties.end()) {
             return false;
         }
 
diff --git a/tools/cli/include/transport/stdio_transport.h b/tools/cli/include/transport/stdio_transport.h
index bfa8d25..543d778 100644
--- a/tools/cli/include/transport/stdio_transport.h
+++ b/tools/cli/include/transport/stdio_transport.h
@@ -5,30 +5,26 @@
 
 namespace VtxCli {
 
-    class StdioTransport
-    {
+    class StdioTransport {
     public:
         explicit StdioTransport(bool verbose = false, bool json_only = false)
-            : verbose_(verbose), json_only_(json_only) {}
+            : verbose_(verbose)
+            , json_only_(json_only) {}
 
-        std::optional<std::string> ReadLine()
-        {
+        std::optional<std::string> ReadLine() {
             std::string line;
-            if(std::getline(std::cin,line))
-            {
+            if (std::getline(std::cin, line)) {
                 return line;
             }
             return std::nullopt;
         }
 
-        void WriteLine(const std::string& value)
-        {
+        void WriteLine(const std::string& value) {
             std::cout << value << '\n';
             std::cout.flush();
         }
 
-        void WriteLog(const std::string& value)
-        {
+        void WriteLog(const std::string& value) {
             if (json_only_) {
                 std::cerr << value << '\n';
                 std::cerr.flush();
@@ -38,10 +34,7 @@ namespace VtxCli {
             }
         }
 
-        bool IsOpen()
-        {
-          return !std::cin.eof();
-        }
+        bool IsOpen() { return !std::cin.eof(); }
 
         bool IsVerbose() const { return verbose_; }
         bool IsJsonOnly() const { return json_only_; }
diff --git a/tools/cli/include/transport/tcp_transport.h b/tools/cli/include/transport/tcp_transport.h
index ec6c67e..7700475 100644
--- a/tools/cli/include/transport/tcp_transport.h
+++ b/tools/cli/include/transport/tcp_transport.h
@@ -7,50 +7,52 @@
 #include <string>
 
 #ifdef _WIN32
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    using SocketHandle = SOCKET;
-    constexpr SocketHandle kInvalidSocket = INVALID_SOCKET;
+#include <winsock2.h>
+#include <ws2tcpip.h>
+using SocketHandle = SOCKET;
+constexpr SocketHandle kInvalidSocket = INVALID_SOCKET;
 #else
-    #include <sys/socket.h>
-    #include <netinet/in.h>
-    #include <arpa/inet.h>
-    #include <unistd.h>
-    using SocketHandle = int;
-    constexpr SocketHandle kInvalidSocket = -1;
-    inline int closesocket(int fd) { return ::close(fd); }
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+using SocketHandle = int;
+constexpr SocketHandle kInvalidSocket = -1;
+inline int closesocket(int fd) {
+    return ::close(fd);
+}
 #endif
 
 namespace VtxCli {
 
-class TcpTransport {
-public:
-    explicit TcpTransport(uint16_t port, bool verbose = false, bool json_only = false);
-    ~TcpTransport();
-
-    TcpTransport(const TcpTransport&) = delete;
-    TcpTransport& operator=(const TcpTransport&) = delete;
-
-    std::optional<std::string> ReadLine();
-    void WriteLine(const std::string& s);
-    void WriteLog(const std::string& s);
-    bool IsOpen() const;
-    bool IsVerbose() const;
-    bool IsJsonOnly() const;
-
-private:
-    SocketHandle server_socket_ = kInvalidSocket;
-    SocketHandle client_socket_ = kInvalidSocket;
-    std::string read_buffer_;
-    bool verbose_ = false;
-    bool json_only_ = false;
-    bool connected_ = false;
+    class TcpTransport {
+    public:
+        explicit TcpTransport(uint16_t port, bool verbose = false, bool json_only = false);
+        ~TcpTransport();
+
+        TcpTransport(const TcpTransport&) = delete;
+        TcpTransport& operator=(const TcpTransport&) = delete;
+
+        std::optional<std::string> ReadLine();
+        void WriteLine(const std::string& s);
+        void WriteLog(const std::string& s);
+        bool IsOpen() const;
+        bool IsVerbose() const;
+        bool IsJsonOnly() const;
+
+    private:
+        SocketHandle server_socket_ = kInvalidSocket;
+        SocketHandle client_socket_ = kInvalidSocket;
+        std::string read_buffer_;
+        bool verbose_ = false;
+        bool json_only_ = false;
+        bool connected_ = false;
 
 #ifdef _WIN32
-    bool wsa_initialized_ = false;
+        bool wsa_initialized_ = false;
 #endif
-};
+    };
 
-static_assert(Transport<TcpTransport>, "TcpTransport must satisfy Transport");
+    static_assert(Transport<TcpTransport>, "TcpTransport must satisfy Transport");
 
 } // namespace VtxCli
diff --git a/tools/cli/src/core/cli_session.cpp b/tools/cli/src/core/cli_session.cpp
index b71dd1c..8b08345 100644
--- a/tools/cli/src/core/cli_session.cpp
+++ b/tools/cli/src/core/cli_session.cpp
@@ -6,107 +6,107 @@
 
 namespace VtxCli {
 
-bool CliSession::Open(const std::string& filepath) {
-    Close();
+    bool CliSession::Open(const std::string& filepath) {
+        Close();
 
-    reader_context_ = VTX::OpenReplayFile(filepath);
-    if (!reader_context_) {
-        last_error_ = reader_context_.error;
-        return false;
-    }
-
-    // Init diff factory for the detected wire format
-    differ_ = VtxDiff::CreateDifferFacade(reader_context_.format);
+        reader_context_ = VTX::OpenReplayFile(filepath);
+        if (!reader_context_) {
+            last_error_ = reader_context_.error;
+            return false;
+        }
 
-    current_frame_ = 0;
-    file_path_ = filepath;
-    last_error_.clear();
-    return true;
-}
+        // Init diff factory for the detected wire format
+        differ_ = VtxDiff::CreateDifferFacade(reader_context_.format);
 
-void CliSession::Close() {
-    reader_context_.Reset();
-    pinned_frames_.clear();
+        current_frame_ = 0;
+        file_path_ = filepath;
+        last_error_.clear();
+        return true;
+    }
 
-    differ_.reset();
+    void CliSession::Close() {
+        reader_context_.Reset();
+        pinned_frames_.clear();
 
-    file_path_.clear();
-    current_frame_ = 0;
-    last_error_.clear();
-}
+        differ_.reset();
 
-bool CliSession::SetFrame(int32_t frame) {
-    if (!reader_context_.Loaded()) {
-        last_error_ = "No file loaded.";
-        return false;
+        file_path_.clear();
+        current_frame_ = 0;
+        last_error_.clear();
     }
-    if (frame < 0 || frame >= reader_context_->GetTotalFrames()) {
-        last_error_ = "Frame out of range [0, " + std::to_string(reader_context_->GetTotalFrames() - 1) + "].";
-        return false;
+
+    bool CliSession::SetFrame(int32_t frame) {
+        if (!reader_context_.Loaded()) {
+            last_error_ = "No file loaded.";
+            return false;
+        }
+        if (frame < 0 || frame >= reader_context_->GetTotalFrames()) {
+            last_error_ = "Frame out of range [0, " + std::to_string(reader_context_->GetTotalFrames() - 1) + "].";
+            return false;
+        }
+        current_frame_ = frame;
+        return true;
     }
-    current_frame_ = frame;
-    return true;
-}
 
-const VTX::Frame* CliSession::GetCurrentFrameData() {
-    return GetFrameData(current_frame_);
-}
+    const VTX::Frame* CliSession::GetCurrentFrameData() {
+        return GetFrameData(current_frame_);
+    }
 
-const VTX::Frame* CliSession::GetFrameData(int frame_index) const {
+    const VTX::Frame* CliSession::GetFrameData(int frame_index) const {
+        if (!reader_context_.Loaded()) {
+            return nullptr;
+        }
 
-    if (!reader_context_.Loaded())
-    {
-        return nullptr;
-    }
+        if (frame_index < 0 || frame_index >= reader_context_->GetTotalFrames()) {
+            return nullptr;
+        }
 
-    if (frame_index < 0 || frame_index >= reader_context_->GetTotalFrames())
-    {
-        return nullptr;
+        return reader_context_->GetFrameSync(frame_index);
     }
 
-    return reader_context_->GetFrameSync(frame_index);
-}
-
-const VTX::Frame* CliSession::PinFrame(int frame_index) {
-    // Already pinned — return existing copy
-    auto it = pinned_frames_.find(frame_index);
-    if (it != pinned_frames_.end()) return &it->second;
+    const VTX::Frame* CliSession::PinFrame(int frame_index) {
+        // Already pinned — return existing copy
+        auto it = pinned_frames_.find(frame_index);
+        if (it != pinned_frames_.end())
+            return &it->second;
 
-    const VTX::Frame* src = GetFrameData(frame_index);
-    if (!src) return nullptr;
+        const VTX::Frame* src = GetFrameData(frame_index);
+        if (!src)
+            return nullptr;
 
-    // Deep-copy and recompute hashes with the current (fixed) hash function
-    auto& copy = pinned_frames_[frame_index];
-    copy = *src;
+        // Deep-copy and recompute hashes with the current (fixed) hash function
+        auto& copy = pinned_frames_[frame_index];
+        copy = *src;
 
-    for (auto& bucket : copy.GetMutableBuckets()) {
-        for (auto& entity : bucket.entities) {
-            entity.content_hash = VTX::Helpers::CalculateContainerHash(entity);
+        for (auto& bucket : copy.GetMutableBuckets()) {
+            for (auto& entity : bucket.entities) {
+                entity.content_hash = VTX::Helpers::CalculateContainerHash(entity);
+            }
         }
-    }
 
-    return &copy;
-}
+        return &copy;
+    }
 
-void CliSession::UnpinFrame(int frame_index) {
-    pinned_frames_.erase(frame_index);
-}
+    void CliSession::UnpinFrame(int frame_index) {
+        pinned_frames_.erase(frame_index);
+    }
 
-VtxDiff::PatchIndex CliSession::DiffFrames(int frame_a, int frame_b,
-                                            const VtxDiff::DiffOptions& opts)
-{
-    if (!reader_context_.Loaded()) return {};
+    VtxDiff::PatchIndex CliSession::DiffFrames(int frame_a, int frame_b, const VtxDiff::DiffOptions& opts) {
+        if (!reader_context_.Loaded())
+            return {};
 
-    // Get raw binary for frame A and copy (loading B may evict A's chunk)
-    auto span_a = reader_context_->GetRawFrameBytes(frame_a);
-    if (span_a.empty()) return {};
-    std::vector<std::byte> bytes_a(span_a.begin(), span_a.end());
+        // Get raw binary for frame A and copy (loading B may evict A's chunk)
+        auto span_a = reader_context_->GetRawFrameBytes(frame_a);
+        if (span_a.empty())
+            return {};
+        std::vector<std::byte> bytes_a(span_a.begin(), span_a.end());
 
-    auto span_b = reader_context_->GetRawFrameBytes(frame_b);
-    if (span_b.empty()) return {};
+        auto span_b = reader_context_->GetRawFrameBytes(frame_b);
+        if (span_b.empty())
+            return {};
 
-    differ_->DiffRawFrames(span_a, span_b, opts);
-    return {};
-}
+        differ_->DiffRawFrames(span_a, span_b, opts);
+        return {};
+    }
 
 } // namespace VtxCli
diff --git a/tools/cli/src/format/json_format.cpp b/tools/cli/src/format/json_format.cpp
index 6cd01cf..6980f8f 100644
--- a/tools/cli/src/format/json_format.cpp
+++ b/tools/cli/src/format/json_format.cpp
@@ -2,85 +2,73 @@
 
 namespace VtxCli {
 
-    JsonFormat& JsonFormat::BeginObject()
-    {
+    JsonFormat& JsonFormat::BeginObject() {
         WriteSeparator();
         stream_ << '{';
         first_.push_back(true);
         return *this;
     }
-    
-    JsonFormat& JsonFormat::EndObject()
-    {
+
+    JsonFormat& JsonFormat::EndObject() {
         first_.pop_back();
         stream_ << '}';
         return *this;
     }
-    
-    JsonFormat& JsonFormat::BeginArray()
-    {
+
+    JsonFormat& JsonFormat::BeginArray() {
         WriteSeparator();
         stream_ << '[';
         first_.push_back(true);
         return *this;
     }
-    
-    JsonFormat& JsonFormat::EndArray()
-    {
+
+    JsonFormat& JsonFormat::EndArray() {
         first_.pop_back();
         stream_ << ']';
         return *this;
     }
-    
-    JsonFormat& JsonFormat::Key(const std::string& key)
-    {
+
+    JsonFormat& JsonFormat::Key(const std::string& key) {
         WriteSeparator();
         stream_ << '"' << Escape(key) << "\":";
         first_.back() = true;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteBool(bool value)
-    {
+
+    JsonFormat& JsonFormat::WriteBool(bool value) {
         WriteSeparator();
         stream_ << (value ? "true" : "false");
         return *this;
     }
-        
-    JsonFormat& JsonFormat::WriteInt(int32_t value)
-    {
+
+    JsonFormat& JsonFormat::WriteInt(int32_t value) {
         WriteSeparator();
         stream_ << value;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteUInt(uint32_t value)
-    {
+
+    JsonFormat& JsonFormat::WriteUInt(uint32_t value) {
         WriteSeparator();
         stream_ << value;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteInt64(int64_t value)
-    {
+
+    JsonFormat& JsonFormat::WriteInt64(int64_t value) {
         WriteSeparator();
         stream_ << value;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteUInt64(uint64_t value)
-    {
+
+    JsonFormat& JsonFormat::WriteUInt64(uint64_t value) {
         WriteSeparator();
         stream_ << value;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteFloat(float value)
-    {
+
+    JsonFormat& JsonFormat::WriteFloat(float value) {
         WriteSeparator();
         //dont include nan or infinete in json
-        if (std::isnan(value) || std::isinf(value))
-        {
+        if (std::isnan(value) || std::isinf(value)) {
             stream_ << "null";
             return *this;
         }
@@ -89,13 +77,11 @@ namespace VtxCli {
         stream_ << buff;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteDouble(double value)
-    {
+
+    JsonFormat& JsonFormat::WriteDouble(double value) {
         WriteSeparator();
         //dont include nan or infinete in json
-        if (std::isnan(value) || std::isinf(value))
-        {
+        if (std::isnan(value) || std::isinf(value)) {
             stream_ << "null";
             return *this;
         }
@@ -104,68 +90,73 @@ namespace VtxCli {
         stream_ << buff;
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteString(const std::string& value)
-    {
+
+    JsonFormat& JsonFormat::WriteString(const std::string& value) {
         WriteSeparator();
         stream_ << '"' << Escape(value) << '"';
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteNull()
-    {
+
+    JsonFormat& JsonFormat::WriteNull() {
         WriteSeparator();
         stream_ << "null";
         return *this;
     }
-    
-    JsonFormat& JsonFormat::WriteRaw(const std::string& value)
-    {
+
+    JsonFormat& JsonFormat::WriteRaw(const std::string& value) {
         WriteSeparator();
         stream_ << value;
         return *this;
     }
-    
-    std::string JsonFormat::Finalize(const std::string& optional_data)
-    {
+
+    std::string JsonFormat::Finalize(const std::string& optional_data) {
         return stream_.str();
     }
-    
 
-    void JsonFormat::WriteSeparator()
-    {
-        if (first_.empty() == false)
-        {
-            if (first_.back() == false)
-            {
+
+    void JsonFormat::WriteSeparator() {
+        if (first_.empty() == false) {
+            if (first_.back() == false) {
                 stream_ << ',';
-            }
-            else
-            {
+            } else {
                 first_.back() = false;
             }
         }
     }
-    
+
     std::string JsonFormat::Escape(const std::string& s) {
         std::string result;
-    
+
         result.reserve(s.size());
 
         for (char c : s) {
             unsigned char uc = static_cast<unsigned char>(c);
 
             switch (uc) {
-            case '"':  result += "\\\""; break;
-            case '\\': result += "\\\\"; break;
-            case '\n': result += "\\n"; break;
-            case '\r': result += "\\r"; break;
-            case '\t': result += "\\t"; break;
-            case '\b': result += "\\b"; break;
-            case '\f': result += "\\f"; break;
+            case '"':
+                result += "\\\"";
+                break;
+            case '\\':
+                result += "\\\\";
+                break;
+            case '\n':
+                result += "\\n";
+                break;
+            case '\r':
+                result += "\\r";
+                break;
+            case '\t':
+                result += "\\t";
+                break;
+            case '\b':
+                result += "\\b";
+                break;
+            case '\f':
+                result += "\\f";
+                break;
             default:
                 if (uc < 0x20) {
-                    char buf[7]; 
+                    char buf[7];
                     snprintf(buf, sizeof(buf), "\\u%04x", uc);
                     result += buf;
                 } else {
@@ -177,6 +168,6 @@ namespace VtxCli {
 
         return result;
     }
-    
+
 
 } // namespace VtxCli
diff --git a/tools/cli/src/main.cpp b/tools/cli/src/main.cpp
index 25231bb..d66edb0 100644
--- a/tools/cli/src/main.cpp
+++ b/tools/cli/src/main.cpp
@@ -10,21 +10,19 @@
 using DefaultEngine = VtxCli::CliEngine<VtxCli::JsonFormat, VtxCli::StdioTransport>;
 
 static void PrintUsage(const char* prog) {
-    std::cerr
-        << "Usage: " << prog << " [options]\n"
-        << "\n"
-        << "Options:\n"
-        << "  --help, -h          Show this help and exit\n"
-        << "  --version           Print version and exit\n"
-        << "  --verbose, -v       Enable human-readable banner on startup\n"
-        << "  --port, -p <port>   Listen on TCP port instead of stdin/stdout\n"
-        << "\n"
-        << "Interactive commands:\n";
+    std::cerr << "Usage: " << prog << " [options]\n"
+              << "\n"
+              << "Options:\n"
+              << "  --help, -h          Show this help and exit\n"
+              << "  --version           Print version and exit\n"
+              << "  --verbose, -v       Enable human-readable banner on startup\n"
+              << "  --port, -p <port>   Listen on TCP port instead of stdin/stdout\n"
+              << "\n"
+              << "Interactive commands:\n";
     DefaultEngine::PrintCommandHelp(std::cerr);
 }
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
     bool verbose = false;
     int port = -1;
 
@@ -33,18 +31,14 @@ int main(int argc, char* argv[])
         if (arg == "--help" || arg == "-h") {
             PrintUsage(argv[0]);
             return 0;
-        }
-        else if (arg == "--version") {
+        } else if (arg == "--version") {
             std::cout << "vtx_cli " << VtxCli::kCliVersion << "\n";
             return 0;
-        }
-        else if (arg == "--verbose" || arg == "-v") {
+        } else if (arg == "--verbose" || arg == "-v") {
             verbose = true;
-        }
-        else if ((arg == "--port" || arg == "-p") && i + 1 < argc) {
+        } else if ((arg == "--port" || arg == "-p") && i + 1 < argc) {
             port = std::atoi(argv[++i]);
-        }
-        else {
+        } else {
             std::cerr << "Unknown argument: " << arg << "\n";
             PrintUsage(argv[0]);
             return 1;
@@ -52,12 +46,10 @@ int main(int argc, char* argv[])
     }
 
     if (port > 0) {
-        VtxCli::CliEngine<VtxCli::JsonFormat, VtxCli::TcpTransport> engine(
-            static_cast<uint16_t>(port), verbose);
+        VtxCli::CliEngine<VtxCli::JsonFormat, VtxCli::TcpTransport> engine(static_cast<uint16_t>(port), verbose);
         engine.Run();
     } else {
-        VtxCli::CliEngine<VtxCli::JsonFormat, VtxCli::StdioTransport> engine(
-            verbose);
+        VtxCli::CliEngine<VtxCli::JsonFormat, VtxCli::StdioTransport> engine(verbose);
         engine.Run();
     }
 
diff --git a/tools/cli/src/transport/tcp_transport.cpp b/tools/cli/src/transport/tcp_transport.cpp
index 6266a59..1695922 100644
--- a/tools/cli/src/transport/tcp_transport.cpp
+++ b/tools/cli/src/transport/tcp_transport.cpp
@@ -4,153 +4,146 @@
 
 namespace VtxCli {
 
-TcpTransport::TcpTransport(uint16_t port, bool verbose, bool json_only)
-    : verbose_(verbose), json_only_(json_only)
-{
+    TcpTransport::TcpTransport(uint16_t port, bool verbose, bool json_only)
+        : verbose_(verbose)
+        , json_only_(json_only) {
 #ifdef _WIN32
-    WSADATA wsa_data{};
-    if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
-        std::cerr << "[tcp] WSAStartup failed.\n";
-        return;
-    }
-    wsa_initialized_ = true;
+        WSADATA wsa_data {};
+        if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
+            std::cerr << "[tcp] WSAStartup failed.\n";
+            return;
+        }
+        wsa_initialized_ = true;
 #endif
 
-    server_socket_ = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (server_socket_ == kInvalidSocket) {
-        std::cerr << "[tcp] Failed to create socket.\n";
-        return;
-    }
+        server_socket_ = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (server_socket_ == kInvalidSocket) {
+            std::cerr << "[tcp] Failed to create socket.\n";
+            return;
+        }
 
-    // Allow port reuse (avoids "address already in use" on quick restart)
-    int opt = 1;
-    setsockopt(server_socket_, SOL_SOCKET, SO_REUSEADDR,
-               reinterpret_cast<const char*>(&opt), sizeof(opt));
-
-    sockaddr_in addr{};
-    addr.sin_family = AF_INET;
-    addr.sin_addr.s_addr = INADDR_ANY;
-    addr.sin_port = htons(port);
-
-    if (::bind(server_socket_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) != 0) {
-        std::cerr << "[tcp] Failed to bind on port " << port << ".\n";
-        closesocket(server_socket_);
-        server_socket_ = kInvalidSocket;
-        return;
-    }
+        // Allow port reuse (avoids "address already in use" on quick restart)
+        int opt = 1;
+        setsockopt(server_socket_, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&opt), sizeof(opt));
 
-    if (::listen(server_socket_, 1) != 0) {
-        std::cerr << "[tcp] Failed to listen.\n";
-        closesocket(server_socket_);
-        server_socket_ = kInvalidSocket;
-        return;
-    }
+        sockaddr_in addr {};
+        addr.sin_family = AF_INET;
+        addr.sin_addr.s_addr = INADDR_ANY;
+        addr.sin_port = htons(port);
 
-    if (verbose_) {
-        std::cerr << "[tcp] Listening on port " << port << " ...\n";
-    }
+        if (::bind(server_socket_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) != 0) {
+            std::cerr << "[tcp] Failed to bind on port " << port << ".\n";
+            closesocket(server_socket_);
+            server_socket_ = kInvalidSocket;
+            return;
+        }
 
-    // Blocks until a client connects
-    client_socket_ = ::accept(server_socket_, nullptr, nullptr);
-    if (client_socket_ == kInvalidSocket) {
-        std::cerr << "[tcp] Accept failed.\n";
-        closesocket(server_socket_);
-        server_socket_ = kInvalidSocket;
-        return;
-    }
+        if (::listen(server_socket_, 1) != 0) {
+            std::cerr << "[tcp] Failed to listen.\n";
+            closesocket(server_socket_);
+            server_socket_ = kInvalidSocket;
+            return;
+        }
 
-    connected_ = true;
+        if (verbose_) {
+            std::cerr << "[tcp] Listening on port " << port << " ...\n";
+        }
 
-    if (verbose_) {
-        std::cerr << "[tcp] Client connected.\n";
-    }
-}
+        // Blocks until a client connects
+        client_socket_ = ::accept(server_socket_, nullptr, nullptr);
+        if (client_socket_ == kInvalidSocket) {
+            std::cerr << "[tcp] Accept failed.\n";
+            closesocket(server_socket_);
+            server_socket_ = kInvalidSocket;
+            return;
+        }
 
-TcpTransport::~TcpTransport()
-{
-    if (client_socket_ != kInvalidSocket) {
-        closesocket(client_socket_);
-    }
-    if (server_socket_ != kInvalidSocket) {
-        closesocket(server_socket_);
+        connected_ = true;
+
+        if (verbose_) {
+            std::cerr << "[tcp] Client connected.\n";
+        }
     }
 
+    TcpTransport::~TcpTransport() {
+        if (client_socket_ != kInvalidSocket) {
+            closesocket(client_socket_);
+        }
+        if (server_socket_ != kInvalidSocket) {
+            closesocket(server_socket_);
+        }
+
 #ifdef _WIN32
-    if (wsa_initialized_) {
-        WSACleanup();
-    }
+        if (wsa_initialized_) {
+            WSACleanup();
+        }
 #endif
 
-    if (verbose_) {
-        std::cerr << "[tcp] Sockets closed.\n";
+        if (verbose_) {
+            std::cerr << "[tcp] Sockets closed.\n";
+        }
     }
-}
-
-std::optional<std::string> TcpTransport::ReadLine()
-{
-    while (true) {
-        // Check buffer for a complete line
-        auto pos = read_buffer_.find('\n');
-        if (pos != std::string::npos) {
-            std::string line = read_buffer_.substr(0, pos);
-            read_buffer_.erase(0, pos + 1);
-            // Strip \r if present (telnet / Windows clients send \r\n)
-            if (!line.empty() && line.back() == '\r') {
-                line.pop_back();
+
+    std::optional<std::string> TcpTransport::ReadLine() {
+        while (true) {
+            // Check buffer for a complete line
+            auto pos = read_buffer_.find('\n');
+            if (pos != std::string::npos) {
+                std::string line = read_buffer_.substr(0, pos);
+                read_buffer_.erase(0, pos + 1);
+                // Strip \r if present (telnet / Windows clients send \r\n)
+                if (!line.empty() && line.back() == '\r') {
+                    line.pop_back();
+                }
+                return line;
             }
-            return line;
-        }
 
-        // Need more data from socket
-        char chunk[4096];
-        int received = ::recv(client_socket_, chunk, sizeof(chunk), 0);
-        if (received <= 0) {
-            connected_ = false;
-            return std::nullopt;
+            // Need more data from socket
+            char chunk[4096];
+            int received = ::recv(client_socket_, chunk, sizeof(chunk), 0);
+            if (received <= 0) {
+                connected_ = false;
+                return std::nullopt;
+            }
+            read_buffer_.append(chunk, static_cast<size_t>(received));
         }
-        read_buffer_.append(chunk, static_cast<size_t>(received));
     }
-}
 
-void TcpTransport::WriteLine(const std::string& s)
-{
-    if (!connected_) return;
+    void TcpTransport::WriteLine(const std::string& s) {
+        if (!connected_)
+            return;
 
-    std::string data = s + "\n";
-    const char* ptr = data.c_str();
-    int remaining = static_cast<int>(data.size());
+        std::string data = s + "\n";
+        const char* ptr = data.c_str();
+        int remaining = static_cast<int>(data.size());
 
-    // Loop to handle partial sends
-    while (remaining > 0) {
-        int sent = ::send(client_socket_, ptr, remaining, 0);
-        if (sent <= 0) {
-            connected_ = false;
-            return;
+        // Loop to handle partial sends
+        while (remaining > 0) {
+            int sent = ::send(client_socket_, ptr, remaining, 0);
+            if (sent <= 0) {
+                connected_ = false;
+                return;
+            }
+            ptr += sent;
+            remaining -= sent;
         }
-        ptr += sent;
-        remaining -= sent;
     }
-}
-
-bool TcpTransport::IsOpen() const
-{
-    return connected_;
-}
-
-bool TcpTransport::IsVerbose() const
-{
-    return verbose_;
-}
-
-bool TcpTransport::IsJsonOnly() const
-{
-    return json_only_;
-}
-
-void TcpTransport::WriteLog(const std::string& s)
-{
-    // TCP: logs go to stderr (never to the client socket)
-    std::cerr << s << "\n";
-}
+
+    bool TcpTransport::IsOpen() const {
+        return connected_;
+    }
+
+    bool TcpTransport::IsVerbose() const {
+        return verbose_;
+    }
+
+    bool TcpTransport::IsJsonOnly() const {
+        return json_only_;
+    }
+
+    void TcpTransport::WriteLog(const std::string& s) {
+        // TCP: logs go to stderr (never to the client socket)
+        std::cerr << s << "\n";
+    }
 
 } // namespace VtxCli
diff --git a/tools/inspector/include/inspector_layout.h b/tools/inspector/include/inspector_layout.h
index 8ae6236..d9f9280 100644
--- a/tools/inspector/include/inspector_layout.h
+++ b/tools/inspector/include/inspector_layout.h
@@ -8,7 +8,8 @@ class InspectorSession;
 
 class InspectorLayout : public IGuiLayer {
 public:
-    InspectorLayout(const std::shared_ptr<InspectorSession>& session, const std::shared_ptr<GuiScaleController>& scale_controller);
+    InspectorLayout(const std::shared_ptr<InspectorSession>& session,
+                    const std::shared_ptr<GuiScaleController>& scale_controller);
     ~InspectorLayout() override = default;
     void OnUpdate() override;
     void OnRender() override;
diff --git a/tools/inspector/include/inspector_session.h b/tools/inspector/include/inspector_session.h
index 1197069..7518a77 100644
--- a/tools/inspector/include/inspector_session.h
+++ b/tools/inspector/include/inspector_session.h
@@ -48,7 +48,8 @@ class InspectorSession : public VtxSessionBase {
 
     /// Chunk state snapshot from the SDK reader (events wired automatically).
     VTX::ReaderChunkSnapshot GetReaderChunkSnapshot() const {
-        if (reader_context_.chunk_state) return reader_context_.chunk_state->GetSnapshot();
+        if (reader_context_.chunk_state)
+            return reader_context_.chunk_state->GetSnapshot();
         return {};
     }
 
diff --git a/tools/inspector/include/services/analysis_scanner.h b/tools/inspector/include/services/analysis_scanner.h
index e8fee4f..346b7b0 100644
--- a/tools/inspector/include/services/analysis_scanner.h
+++ b/tools/inspector/include/services/analysis_scanner.h
@@ -11,84 +11,76 @@
 
 namespace VtxServices {
 
-class AnalysisScanner {
-public:
-    struct ScanConfig {
-        int32_t start_frame = 0;
-        int32_t end_frame = 0;
-        int32_t bucket_index = 0;           // Index into Frame::GetBuckets()
-        std::string bucket_name;            // Display name (from schema)
-        std::vector<std::string> filter_unique_ids;
-        std::vector<std::string> property_names;
-    };
+    class AnalysisScanner {
+    public:
+        struct ScanConfig {
+            int32_t start_frame = 0;
+            int32_t end_frame = 0;
+            int32_t bucket_index = 0; // Index into Frame::GetBuckets()
+            std::string bucket_name;  // Display name (from schema)
+            std::vector<std::string> filter_unique_ids;
+            std::vector<std::string> property_names;
+        };
 
-    enum class ScanType { EntityLifeTime, UniqueProperties, TrackProperty };
+        enum class ScanType { EntityLifeTime, UniqueProperties, TrackProperty };
 
-    AnalysisScanner() = default;
-    ~AnalysisScanner();
+        AnalysisScanner() = default;
+        ~AnalysisScanner();
 
-    // Not copyable or movable (owns atomics and a future).
-    AnalysisScanner(const AnalysisScanner&) = delete;
-    AnalysisScanner& operator=(const AnalysisScanner&) = delete;
-    AnalysisScanner(AnalysisScanner&&) = delete;
-    AnalysisScanner& operator=(AnalysisScanner&&) = delete;
+        // Not copyable or movable (owns atomics and a future).
+        AnalysisScanner(const AnalysisScanner&) = delete;
+        AnalysisScanner& operator=(const AnalysisScanner&) = delete;
+        AnalysisScanner(AnalysisScanner&&) = delete;
+        AnalysisScanner& operator=(AnalysisScanner&&) = delete;
 
-    // Resets the scanner to idle state so it can be reused for a new scan.
-    void Reset();
+        // Resets the scanner to idle state so it can be reused for a new scan.
+        void Reset();
 
-    void Start(ScanType type, const ScanConfig& config,
-               VTX::IVtxReaderFacade* reader,
-               const VTX::PropertyAddressCache& cache,
-               const VTX::FileFooter& footer);
+        void Start(ScanType type, const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                   const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer);
 
-    void Cancel();
+        void Cancel();
 
-    bool IsRunning() const { return is_running_.load(); }
-    float GetProgress() const { return progress_.load(); }
-    int32_t GetCurrentFrame() const { return current_frame_.load(); }
-    std::string GetStatus() const;
+        bool IsRunning() const { return is_running_.load(); }
+        float GetProgress() const { return progress_.load(); }
+        int32_t GetCurrentFrame() const { return current_frame_.load(); }
+        std::string GetStatus() const;
 
-    const EntityLifeTimeResult& GetLifeTimeResult() const { return lifetime_result_; }
-    const UniquePropertiesResult& GetUniquePropsResult() const { return unique_props_result_; }
-    const TrackPropertyResult& GetTrackPropResult() const { return track_prop_result_; }
+        const EntityLifeTimeResult& GetLifeTimeResult() const { return lifetime_result_; }
+        const UniquePropertiesResult& GetUniquePropsResult() const { return unique_props_result_; }
+        const TrackPropertyResult& GetTrackPropResult() const { return track_prop_result_; }
 
-private:
-    void RunEntityLifeTime(const ScanConfig& config,
-                           VTX::IVtxReaderFacade* reader,
-                           const VTX::PropertyAddressCache& cache,
-                           const VTX::FileFooter& footer);
+    private:
+        void RunEntityLifeTime(const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                               const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer);
 
-    void RunUniqueProperties(const ScanConfig& config,
-                             VTX::IVtxReaderFacade* reader,
-                             const VTX::PropertyAddressCache& cache,
-                             const VTX::FileFooter& footer);
+        void RunUniqueProperties(const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                                 const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer);
 
-    void RunTrackProperty(const ScanConfig& config,
-                          VTX::IVtxReaderFacade* reader,
-                          const VTX::PropertyAddressCache& cache,
-                          const VTX::FileFooter& footer);
+        void RunTrackProperty(const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                              const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer);
 
-    void SetStatus(const std::string& msg);
+        void SetStatus(const std::string& msg);
 
-    // Returns game time for a frame index, or 0 if unavailable.
-    static uint64_t GetGameTime(const VTX::FileFooter& footer, int32_t frame_index);
+        // Returns game time for a frame index, or 0 if unavailable.
+        static uint64_t GetGameTime(const VTX::FileFooter& footer, int32_t frame_index);
 
-    // Checks if a uid passes the filter (empty filter = all pass).
-    static bool PassesUidFilter(const std::vector<std::string>& filter, const std::string& uid);
+        // Checks if a uid passes the filter (empty filter = all pass).
+        static bool PassesUidFilter(const std::vector<std::string>& filter, const std::string& uid);
 
-    std::atomic<bool> is_running_{false};
-    std::atomic<bool> cancel_requested_{false};
-    std::atomic<float> progress_{0.0f};
-    std::atomic<int32_t> current_frame_{-1};
+        std::atomic<bool> is_running_ {false};
+        std::atomic<bool> cancel_requested_ {false};
+        std::atomic<float> progress_ {0.0f};
+        std::atomic<int32_t> current_frame_ {-1};
 
-    mutable std::mutex status_mutex_;
-    std::string status_message_;
+        mutable std::mutex status_mutex_;
+        std::string status_message_;
 
-    std::future<void> worker_;
+        std::future<void> worker_;
 
-    EntityLifeTimeResult lifetime_result_;
-    UniquePropertiesResult unique_props_result_;
-    TrackPropertyResult track_prop_result_;
-};
+        EntityLifeTimeResult lifetime_result_;
+        UniquePropertiesResult unique_props_result_;
+        TrackPropertyResult track_prop_result_;
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/analysis_types.h b/tools/inspector/include/services/analysis_types.h
index 07c3d3a..374f9c2 100644
--- a/tools/inspector/include/services/analysis_types.h
+++ b/tools/inspector/include/services/analysis_types.h
@@ -9,78 +9,76 @@
 
 namespace VtxServices {
 
-// -- Shared types --
-
-struct FrameRange {
-    int32_t start_frame = 0;
-    int32_t end_frame = 0;
-    uint64_t start_game_time = 0;
-    uint64_t end_game_time = 0;
-};
-
-// -- EntityLifeTime --
-
-struct EntityLifeTimeEntry {
-    std::string unique_id;
-    std::string type_name;
-    int32_t type_id = -1;
-    std::vector<FrameRange> ranges;
-};
-
-struct EntityLifeTimeResult {
-    std::vector<EntityLifeTimeEntry> entries;
-    bool is_complete = false;
-    std::string error_message;
-};
-
-// -- UniqueProperties --
-
-struct UniquePropertiesGroup {
-    std::vector<std::string> property_values;
-    std::vector<std::string> contributing_uids;
-    int32_t count = 0;
-};
-
-struct UniquePropertiesResult {
-    std::vector<std::string> property_names;
-    std::vector<UniquePropertiesGroup> groups;
-    bool is_complete = false;
-    std::string error_message;
-};
-
-// -- TrackProperty --
-
-struct PropertyValueSpan {
-    std::string unique_id;
-    std::string property_name;
-    std::string value;
-    FrameRange range;
-};
-
-struct TrackPropertyResult {
-    std::vector<std::string> property_names;
-    std::vector<PropertyValueSpan> spans;
-    bool is_complete = false;
-    std::string error_message;
-};
-
-// -- Utility: extract scalar property value as string --
-
-std::string ExtractScalarAsString(
-    const VTX::PropertyContainer& entity,
-    const VTX::PropertyAddress& addr);
-
-// -- CSV export --
-
-bool ExportEntityLifeTimeCsv(const std::string& path, const EntityLifeTimeResult& result);
-bool ExportUniquePropertiesCsv(const std::string& path, const UniquePropertiesResult& result);
-bool ExportTrackPropertyCsv(const std::string& path, const TrackPropertyResult& result);
-
-// -- Formatting helpers --
-
-std::string FormatFrameRanges(const std::vector<FrameRange>& ranges);
-std::string FormatGameTimeRanges(const std::vector<FrameRange>& ranges);
-std::string FormatSingleFrameRange(const FrameRange& range);
-std::string FormatSingleGameTimeRange(const FrameRange& range);
+    // -- Shared types --
+
+    struct FrameRange {
+        int32_t start_frame = 0;
+        int32_t end_frame = 0;
+        uint64_t start_game_time = 0;
+        uint64_t end_game_time = 0;
+    };
+
+    // -- EntityLifeTime --
+
+    struct EntityLifeTimeEntry {
+        std::string unique_id;
+        std::string type_name;
+        int32_t type_id = -1;
+        std::vector<FrameRange> ranges;
+    };
+
+    struct EntityLifeTimeResult {
+        std::vector<EntityLifeTimeEntry> entries;
+        bool is_complete = false;
+        std::string error_message;
+    };
+
+    // -- UniqueProperties --
+
+    struct UniquePropertiesGroup {
+        std::vector<std::string> property_values;
+        std::vector<std::string> contributing_uids;
+        int32_t count = 0;
+    };
+
+    struct UniquePropertiesResult {
+        std::vector<std::string> property_names;
+        std::vector<UniquePropertiesGroup> groups;
+        bool is_complete = false;
+        std::string error_message;
+    };
+
+    // -- TrackProperty --
+
+    struct PropertyValueSpan {
+        std::string unique_id;
+        std::string property_name;
+        std::string value;
+        FrameRange range;
+    };
+
+    struct TrackPropertyResult {
+        std::vector<std::string> property_names;
+        std::vector<PropertyValueSpan> spans;
+        bool is_complete = false;
+        std::string error_message;
+    };
+
+    // -- Utility: extract scalar property value as string --
+
+    std::string ExtractScalarAsString(const VTX::PropertyContainer& entity, const VTX::PropertyAddress& addr);
+
+    // -- CSV export --
+
+    bool ExportEntityLifeTimeCsv(const std::string& path, const EntityLifeTimeResult& result);
+    bool ExportUniquePropertiesCsv(const std::string& path, const UniquePropertiesResult& result);
+    bool ExportTrackPropertyCsv(const std::string& path, const TrackPropertyResult& result);
+
+    // -- Formatting helpers --
+
+    std::string FormatFrameRanges(const std::vector<FrameRange>& ranges);
+    std::string FormatGameTimeRanges(const std::vector<FrameRange>& ranges);
+    std::string FormatSingleFrameRange(const FrameRange& range);
+    std::string FormatSingleGameTimeRange(const FrameRange& range);
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/entity_inspector_view_service.h b/tools/inspector/include/services/entity_inspector_view_service.h
index edd11a4..e7d1bb3 100644
--- a/tools/inspector/include/services/entity_inspector_view_service.h
+++ b/tools/inspector/include/services/entity_inspector_view_service.h
@@ -8,187 +8,169 @@
 #include "vtx/reader/core/vtx_reader_facade.h"
 
 namespace VTX {
-class IVtxReaderFacade;
-struct Frame;
-}
+    class IVtxReaderFacade;
+    struct Frame;
+} // namespace VTX
 
 namespace VtxServices {
 
-struct EntityListItem {
-    std::string entity_id;
-    int entity_type_id = -1;
-    std::string entity_type_name;
-    bool is_selected = false;
-};
-
-struct EntityBucketView {
-    std::string id;
-    std::string label;
-    int bucket_index = -1;
-    std::vector<EntityListItem> entities;
-};
-
-struct FrameResolveContext {
-    bool is_scrubbing = false;
-    int current_frame = 0;
-    int last_drawn_frame_index = -1;
-};
-
-struct FrameResolveResult {
-    const VTX::Frame* frame_to_draw = nullptr;
-    bool is_loading = false;
-    bool showing_stale_frame = false;
-    int stale_frame_index = -1;
-    std::string status_message;
-    int next_last_drawn_frame_index = -1;
-};
-
-struct EntityPropertyNode {
-    std::string id;
-    std::string label;
-    std::string schema_label;
-    std::string value;
-    std::string raw_value;
-    std::string struct_name;
-    std::string schema_focus_struct_name;
-    std::string schema_focus_property_name;
-    int schema_index = -1;
-    VTX::FieldType schema_type = VTX::FieldType::None;
-    VTX::FieldContainerType schema_container_type = VTX::FieldContainerType::None;
-    bool is_property = false;
-    bool open_by_default = false;
-    bool schema_focus_on_secondary_click = false;
-    std::vector<EntityPropertyNode> children;
-};
-
-struct EntityPropertiesViewModel {
-    std::vector<EntityPropertyNode> roots;
-};
-
-struct EntityPropertyCommand {
-    bool copy_to_clipboard = false;
-    std::string clipboard_text;
-    bool request_schema_focus = false;
-    std::string struct_name;
-    std::string property_name;
-};
-
-enum class EntityStatusTone {
-    Normal,
-    Warning,
-    Error,
-};
-
-struct EntityInspectorState {
-    int last_drawn_frame_index = -1;
-    int selected_bucket_index = -1;
-    std::string selected_entity_id;
-};
-
-struct EntityInspectorHeaderViewModel {
-    std::string entity_label;
-    std::string type_label;
-    std::string type_name;
-    std::string hash_label;
-    bool show_hash = false;
-    std::vector<std::string> missing_field_names;
-};
-
-struct EntityInspectorViewModel {
-    bool has_replay = false;
-    bool is_loading = false;
-    bool disable_panels = false;
-    bool has_frame = false;
-    std::string status_message;
-    std::string stale_frame_message;
-    EntityStatusTone status_tone = EntityStatusTone::Normal;
-    std::vector<EntityBucketView> buckets;
-    EntityPropertiesViewModel properties;
-    EntityInspectorHeaderViewModel header;
-    std::string empty_properties_message;
-};
-
-struct EntityInspectorEffect {
-    bool copy_to_clipboard = false;
-    std::string clipboard_text;
-    bool request_schema_focus = false;
-    bool focus_schema_window = false;
-    std::string schema_struct_name;
-    std::string schema_property_name;
-};
-
-struct EntityInspectorScreenResult {
-    EntityInspectorState state;
-    EntityInspectorViewModel view_model;
-};
-
-class EntityInspectorViewService {
-public:
-    static FrameResolveResult ResolveFrameToDraw(VTX::IVtxReaderFacade& reader, const FrameResolveContext& context);
-    static std::vector<EntityBucketView> BuildEntityBuckets(
-        const VTX::Frame& frame,
-        const EntityInspectorState& state,
-        const VTX::PropertyAddressCache* global_cache);
-    static EntityPropertiesViewModel BuildPropertyTree(
-        const VTX::PropertyContainer& pc,
-        const VTX::PropertyAddressCache* global_cache);
-    static EntityInspectorScreenResult BuildScreen(
-        VTX::IVtxReaderFacade* reader,
-        bool has_loaded_replay,
-        bool is_scrubbing_timeline,
-        int current_frame,
-        const EntityInspectorState& state);
-    static EntityInspectorState SelectEntity(
-        const EntityInspectorState& state,
-        int bucket_index,
-        const std::string& entity_id);
-    static EntityInspectorEffect BuildPropertyActivateEffect(
-        const EntityPropertyNode& node,
-        const VTX::PropertyAddressCache* global_cache);
-    static EntityInspectorEffect BuildPropertyContextEffect(
-        const EntityPropertyNode& node,
-        const VTX::PropertyAddressCache* global_cache);
-    static const VTX::PropertyContainer* FindSelectedEntity(
-        const VTX::Frame& frame,
-        const EntityInspectorState& state);
-    static EntityInspectorViewModel BuildFrameViewModel(
-        const VTX::Frame& frame,
-        const EntityInspectorState& state,
-        const VTX::PropertyAddressCache* global_cache);
-
-    static const VTX::StructSchemaCache* ResolveStructCache(const VTX::PropertyAddressCache* global_cache, int32_t entity_type_id);
-    static const VTX::StructSchemaCache* ResolveStructCache(
-        const VTX::PropertyAddressCache* global_cache,
-        const std::string& struct_name);
-    static std::string ResolveSchemaName(
-        const VTX::StructSchemaCache* struct_cache,
-        VTX::FieldType expected_type,
-        VTX::FieldContainerType container_type,
-        size_t index);
-    static std::string ResolveSchemaName(
-        const VTX::PropertyAddressCache* global_cache,
-        const EntityPropertyNode& node);
-    static std::string ResolveStructName(const VTX::StructSchemaCache* struct_cache);
-    static std::string FormatVector(const VTX::Vector& v);
-    static std::string FormatQuat(const VTX::Quat& q);
-    static std::string FormatTransform(const VTX::Transform& t);
-    static std::string FormatRange(const VTX::FloatRange& r);
-    static std::string FormatFloat(float value);
-    static std::string FormatDouble(double value);
-    static std::string FormatRawVector(const VTX::Vector& v);
-    static std::string FormatRawQuat(const VTX::Quat& q);
-    static std::string FormatRawTransform(const VTX::Transform& t);
-    static std::string FormatRawRange(const VTX::FloatRange& r);
-    static std::string FormatRawFloat(float value);
-    static std::string FormatRawDouble(double value);
-
-private:
-    static EntityPropertyCommand BuildActivateCommand(
-        const EntityPropertyNode& node,
-        const VTX::PropertyAddressCache* global_cache);
-    static EntityPropertyCommand BuildSchemaFocusCommand(
-        const EntityPropertyNode& node,
-        const VTX::PropertyAddressCache* global_cache);
-};
+    struct EntityListItem {
+        std::string entity_id;
+        int entity_type_id = -1;
+        std::string entity_type_name;
+        bool is_selected = false;
+    };
+
+    struct EntityBucketView {
+        std::string id;
+        std::string label;
+        int bucket_index = -1;
+        std::vector<EntityListItem> entities;
+    };
+
+    struct FrameResolveContext {
+        bool is_scrubbing = false;
+        int current_frame = 0;
+        int last_drawn_frame_index = -1;
+    };
+
+    struct FrameResolveResult {
+        const VTX::Frame* frame_to_draw = nullptr;
+        bool is_loading = false;
+        bool showing_stale_frame = false;
+        int stale_frame_index = -1;
+        std::string status_message;
+        int next_last_drawn_frame_index = -1;
+    };
+
+    struct EntityPropertyNode {
+        std::string id;
+        std::string label;
+        std::string schema_label;
+        std::string value;
+        std::string raw_value;
+        std::string struct_name;
+        std::string schema_focus_struct_name;
+        std::string schema_focus_property_name;
+        int schema_index = -1;
+        VTX::FieldType schema_type = VTX::FieldType::None;
+        VTX::FieldContainerType schema_container_type = VTX::FieldContainerType::None;
+        bool is_property = false;
+        bool open_by_default = false;
+        bool schema_focus_on_secondary_click = false;
+        std::vector<EntityPropertyNode> children;
+    };
+
+    struct EntityPropertiesViewModel {
+        std::vector<EntityPropertyNode> roots;
+    };
+
+    struct EntityPropertyCommand {
+        bool copy_to_clipboard = false;
+        std::string clipboard_text;
+        bool request_schema_focus = false;
+        std::string struct_name;
+        std::string property_name;
+    };
+
+    enum class EntityStatusTone {
+        Normal,
+        Warning,
+        Error,
+    };
+
+    struct EntityInspectorState {
+        int last_drawn_frame_index = -1;
+        int selected_bucket_index = -1;
+        std::string selected_entity_id;
+    };
+
+    struct EntityInspectorHeaderViewModel {
+        std::string entity_label;
+        std::string type_label;
+        std::string type_name;
+        std::string hash_label;
+        bool show_hash = false;
+        std::vector<std::string> missing_field_names;
+    };
+
+    struct EntityInspectorViewModel {
+        bool has_replay = false;
+        bool is_loading = false;
+        bool disable_panels = false;
+        bool has_frame = false;
+        std::string status_message;
+        std::string stale_frame_message;
+        EntityStatusTone status_tone = EntityStatusTone::Normal;
+        std::vector<EntityBucketView> buckets;
+        EntityPropertiesViewModel properties;
+        EntityInspectorHeaderViewModel header;
+        std::string empty_properties_message;
+    };
+
+    struct EntityInspectorEffect {
+        bool copy_to_clipboard = false;
+        std::string clipboard_text;
+        bool request_schema_focus = false;
+        bool focus_schema_window = false;
+        std::string schema_struct_name;
+        std::string schema_property_name;
+    };
+
+    struct EntityInspectorScreenResult {
+        EntityInspectorState state;
+        EntityInspectorViewModel view_model;
+    };
+
+    class EntityInspectorViewService {
+    public:
+        static FrameResolveResult ResolveFrameToDraw(VTX::IVtxReaderFacade& reader, const FrameResolveContext& context);
+        static std::vector<EntityBucketView> BuildEntityBuckets(const VTX::Frame& frame,
+                                                                const EntityInspectorState& state,
+                                                                const VTX::PropertyAddressCache* global_cache);
+        static EntityPropertiesViewModel BuildPropertyTree(const VTX::PropertyContainer& pc,
+                                                           const VTX::PropertyAddressCache* global_cache);
+        static EntityInspectorScreenResult BuildScreen(VTX::IVtxReaderFacade* reader, bool has_loaded_replay,
+                                                       bool is_scrubbing_timeline, int current_frame,
+                                                       const EntityInspectorState& state);
+        static EntityInspectorState SelectEntity(const EntityInspectorState& state, int bucket_index,
+                                                 const std::string& entity_id);
+        static EntityInspectorEffect BuildPropertyActivateEffect(const EntityPropertyNode& node,
+                                                                 const VTX::PropertyAddressCache* global_cache);
+        static EntityInspectorEffect BuildPropertyContextEffect(const EntityPropertyNode& node,
+                                                                const VTX::PropertyAddressCache* global_cache);
+        static const VTX::PropertyContainer* FindSelectedEntity(const VTX::Frame& frame,
+                                                                const EntityInspectorState& state);
+        static EntityInspectorViewModel BuildFrameViewModel(const VTX::Frame& frame, const EntityInspectorState& state,
+                                                            const VTX::PropertyAddressCache* global_cache);
+
+        static const VTX::StructSchemaCache* ResolveStructCache(const VTX::PropertyAddressCache* global_cache,
+                                                                int32_t entity_type_id);
+        static const VTX::StructSchemaCache* ResolveStructCache(const VTX::PropertyAddressCache* global_cache,
+                                                                const std::string& struct_name);
+        static std::string ResolveSchemaName(const VTX::StructSchemaCache* struct_cache, VTX::FieldType expected_type,
+                                             VTX::FieldContainerType container_type, size_t index);
+        static std::string ResolveSchemaName(const VTX::PropertyAddressCache* global_cache,
+                                             const EntityPropertyNode& node);
+        static std::string ResolveStructName(const VTX::StructSchemaCache* struct_cache);
+        static std::string FormatVector(const VTX::Vector& v);
+        static std::string FormatQuat(const VTX::Quat& q);
+        static std::string FormatTransform(const VTX::Transform& t);
+        static std::string FormatRange(const VTX::FloatRange& r);
+        static std::string FormatFloat(float value);
+        static std::string FormatDouble(double value);
+        static std::string FormatRawVector(const VTX::Vector& v);
+        static std::string FormatRawQuat(const VTX::Quat& q);
+        static std::string FormatRawTransform(const VTX::Transform& t);
+        static std::string FormatRawRange(const VTX::FloatRange& r);
+        static std::string FormatRawFloat(float value);
+        static std::string FormatRawDouble(double value);
+
+    private:
+        static EntityPropertyCommand BuildActivateCommand(const EntityPropertyNode& node,
+                                                          const VTX::PropertyAddressCache* global_cache);
+        static EntityPropertyCommand BuildSchemaFocusCommand(const EntityPropertyNode& node,
+                                                             const VTX::PropertyAddressCache* global_cache);
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/field_type_utils.h b/tools/inspector/include/services/field_type_utils.h
index bf397f7..557ed45 100644
--- a/tools/inspector/include/services/field_type_utils.h
+++ b/tools/inspector/include/services/field_type_utils.h
@@ -9,8 +9,8 @@
 
 namespace VtxServices {
 
-/// Convert a VTX::FieldType enum to a human-readable string.
-/// Pure logic, no GUI dependency — first candidate for SDK migration.
-const char* FieldTypeToString(VTX::FieldType type_id);
+    /// Convert a VTX::FieldType enum to a human-readable string.
+    /// Pure logic, no GUI dependency — first candidate for SDK migration.
+    const char* FieldTypeToString(VTX::FieldType type_id);
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/footer_summary_service.h b/tools/inspector/include/services/footer_summary_service.h
index d1982dc..e0b93cc 100644
--- a/tools/inspector/include/services/footer_summary_service.h
+++ b/tools/inspector/include/services/footer_summary_service.h
@@ -9,114 +9,110 @@
 
 namespace VtxServices {
 
-enum class FileInfoTone {
-    Normal,
-    Highlight,
-    Success,
-    Disabled,
-};
-
-struct FileInfoRow {
-    std::string label;
-    std::string value;
-    FileInfoTone tone = FileInfoTone::Normal;
-};
-
-struct FileInfoSection {
-    std::string title;
-    bool default_open = false;
-    bool render_as_raw_text = false;
-    std::string raw_text;
-    std::vector<FileInfoRow> rows;
-};
-
-struct FileInfoViewModel {
-    std::string file_path;
-    std::vector<FileInfoSection> sections;
-};
-
-struct SummaryRow {
-    std::string label;
-    std::string value;
-};
-
-struct ChunkIndexRow {
-    int chunk_index = 0;
-    std::string frame_range;
-    std::string file_offset;
-    std::string chunk_size;
-    int frames_per_chunk = 0;
-};
-
-struct TimelineEventRow {
-    std::string game_time;
-    std::string event_type;
-    std::string label;
-    std::string location;
-    std::string entity_id;
-};
-
-struct FooterTableColumn {
-    std::string label;
-    float width = 0.0f;
-    bool stretch = false;
-    bool disabled = false;
-    bool highlighted = false;
-};
-
-struct FooterTableCell {
-    std::string text;
-    bool disabled = false;
-    bool highlighted = false;
-};
-
-struct FooterTableRow {
-    std::vector<FooterTableCell> cells;
-};
-
-struct FooterTableViewModel {
-    std::string empty_message;
-    std::string count_label;
-    std::vector<FooterTableColumn> columns;
-    std::vector<FooterTableRow> rows;
-};
-
-struct ReplayTimeTabViewModel {
-    std::string label;
-    std::string value_column_label = "Value";
-    std::vector<std::string> values;
-};
-
-struct ReplayTimeViewModel {
-    std::vector<SummaryRow> summary_rows;
-    std::vector<ReplayTimeTabViewModel> tabs;
-};
-
-class FooterSummaryService {
-public:
-    static FileInfoViewModel BuildFileInfoViewModel(
-        const std::string& file_path,
-        float file_size_mb,
-        VTX::VtxFormat format,
-        const VTX::FileHeader& header,
-        const VTX::FileFooter& footer);
-    static std::string ResolvePayloadFormatLabel(VTX::VtxFormat format);
-    static std::string FormatChunkSize(uint32_t chunk_size_bytes);
-    static std::string FormatFileOffset(uint64_t file_offset);
-    static std::string FormatLocation(const VTX::Vector& location);
-    static std::string FormatGameTime(float game_time_seconds);
-
-    static std::vector<SummaryRow> BuildReplayTimeSummaryRows(const VTX::ReplayTimeData& time_data);
-    static std::vector<SummaryRow> BuildPropertySchemaSummaryRows(const VTX::PropertySchema& prop_schema);
-    static std::vector<std::string> BuildReplayTimeTabLabels(const VTX::ReplayTimeData& time_data);
-    static std::vector<SummaryRow> BuildFooterSummaryRows(const VTX::FileFooter& footer);
-    static std::vector<ChunkIndexRow> BuildChunkRows(const std::vector<VTX::ChunkIndexEntry>& chunk_index);
-    static std::vector<TimelineEventRow> BuildTimelineEventRows(const std::vector<VTX::TimelineEvent>& events);
-    static ReplayTimeViewModel BuildReplayTimeViewModel(
-        const VTX::ReplayTimeData& time_data,
-        TimeDisplayFormat time_display_format);
-    static FooterTableViewModel BuildChunkTableViewModel(const std::vector<VTX::ChunkIndexEntry>& chunk_index);
-    static FooterTableViewModel BuildTimelineEventsTableViewModel(const std::vector<VTX::TimelineEvent>& events);
-};
+    enum class FileInfoTone {
+        Normal,
+        Highlight,
+        Success,
+        Disabled,
+    };
+
+    struct FileInfoRow {
+        std::string label;
+        std::string value;
+        FileInfoTone tone = FileInfoTone::Normal;
+    };
+
+    struct FileInfoSection {
+        std::string title;
+        bool default_open = false;
+        bool render_as_raw_text = false;
+        std::string raw_text;
+        std::vector<FileInfoRow> rows;
+    };
+
+    struct FileInfoViewModel {
+        std::string file_path;
+        std::vector<FileInfoSection> sections;
+    };
+
+    struct SummaryRow {
+        std::string label;
+        std::string value;
+    };
+
+    struct ChunkIndexRow {
+        int chunk_index = 0;
+        std::string frame_range;
+        std::string file_offset;
+        std::string chunk_size;
+        int frames_per_chunk = 0;
+    };
+
+    struct TimelineEventRow {
+        std::string game_time;
+        std::string event_type;
+        std::string label;
+        std::string location;
+        std::string entity_id;
+    };
+
+    struct FooterTableColumn {
+        std::string label;
+        float width = 0.0f;
+        bool stretch = false;
+        bool disabled = false;
+        bool highlighted = false;
+    };
+
+    struct FooterTableCell {
+        std::string text;
+        bool disabled = false;
+        bool highlighted = false;
+    };
+
+    struct FooterTableRow {
+        std::vector<FooterTableCell> cells;
+    };
+
+    struct FooterTableViewModel {
+        std::string empty_message;
+        std::string count_label;
+        std::vector<FooterTableColumn> columns;
+        std::vector<FooterTableRow> rows;
+    };
+
+    struct ReplayTimeTabViewModel {
+        std::string label;
+        std::string value_column_label = "Value";
+        std::vector<std::string> values;
+    };
+
+    struct ReplayTimeViewModel {
+        std::vector<SummaryRow> summary_rows;
+        std::vector<ReplayTimeTabViewModel> tabs;
+    };
+
+    class FooterSummaryService {
+    public:
+        static FileInfoViewModel BuildFileInfoViewModel(const std::string& file_path, float file_size_mb,
+                                                        VTX::VtxFormat format, const VTX::FileHeader& header,
+                                                        const VTX::FileFooter& footer);
+        static std::string ResolvePayloadFormatLabel(VTX::VtxFormat format);
+        static std::string FormatChunkSize(uint32_t chunk_size_bytes);
+        static std::string FormatFileOffset(uint64_t file_offset);
+        static std::string FormatLocation(const VTX::Vector& location);
+        static std::string FormatGameTime(float game_time_seconds);
+
+        static std::vector<SummaryRow> BuildReplayTimeSummaryRows(const VTX::ReplayTimeData& time_data);
+        static std::vector<SummaryRow> BuildPropertySchemaSummaryRows(const VTX::PropertySchema& prop_schema);
+        static std::vector<std::string> BuildReplayTimeTabLabels(const VTX::ReplayTimeData& time_data);
+        static std::vector<SummaryRow> BuildFooterSummaryRows(const VTX::FileFooter& footer);
+        static std::vector<ChunkIndexRow> BuildChunkRows(const std::vector<VTX::ChunkIndexEntry>& chunk_index);
+        static std::vector<TimelineEventRow> BuildTimelineEventRows(const std::vector<VTX::TimelineEvent>& events);
+        static ReplayTimeViewModel BuildReplayTimeViewModel(const VTX::ReplayTimeData& time_data,
+                                                            TimeDisplayFormat time_display_format);
+        static FooterTableViewModel BuildChunkTableViewModel(const std::vector<VTX::ChunkIndexEntry>& chunk_index);
+        static FooterTableViewModel BuildTimelineEventsTableViewModel(const std::vector<VTX::TimelineEvent>& events);
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/playback_service.h b/tools/inspector/include/services/playback_service.h
index cd6508b..ed85c37 100644
--- a/tools/inspector/include/services/playback_service.h
+++ b/tools/inspector/include/services/playback_service.h
@@ -12,25 +12,25 @@
 
 namespace VtxServices {
 
-class PlaybackService {
-public:
-    /// Advance playback by the given wall-clock delta (seconds).
-    /// Returns the (possibly updated) current frame index.
-    /// Does nothing when paused or when replay metadata is invalid.
-    int Update(float delta_time_seconds, int current_frame, int total_frames, float duration_seconds);
+    class PlaybackService {
+    public:
+        /// Advance playback by the given wall-clock delta (seconds).
+        /// Returns the (possibly updated) current frame index.
+        /// Does nothing when paused or when replay metadata is invalid.
+        int Update(float delta_time_seconds, int current_frame, int total_frames, float duration_seconds);
 
-    void Play(int current_frame, int total_frames);
-    void Pause();
-    void Stop();
+        void Play(int current_frame, int total_frames);
+        void Pause();
+        void Stop();
 
-    bool IsPlaying() const { return is_playing_; }
-    float GetSpeed() const { return playback_speed_; }
-    void SetSpeed(float speed) { playback_speed_ = std::clamp(speed, 0.1f, 10.0f); }
+        bool IsPlaying() const { return is_playing_; }
+        float GetSpeed() const { return playback_speed_; }
+        void SetSpeed(float speed) { playback_speed_ = std::clamp(speed, 0.1f, 10.0f); }
 
-private:
-    bool is_playing_ = false;
-    float playback_speed_ = 1.0f;
-    float time_accumulator_ = 0.0f;
-};
+    private:
+        bool is_playing_ = false;
+        float playback_speed_ = 1.0f;
+        float time_accumulator_ = 0.0f;
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/reader_chunk_state_service.h b/tools/inspector/include/services/reader_chunk_state_service.h
index 342bdc7..13b3042 100644
--- a/tools/inspector/include/services/reader_chunk_state_service.h
+++ b/tools/inspector/include/services/reader_chunk_state_service.h
@@ -8,41 +8,39 @@
 
 namespace VtxServices {
 
-/// Cached state for avoiding redundant string rebuilds each frame.
-struct ReaderProfileCacheState {
-    std::vector<int32_t> last_loaded;
-    std::vector<int32_t> last_loading;
-    std::string cached_loaded_str;
-    std::string cached_loading_str;
-};
-
-/// Presentation model for the reader profiler widget.
-struct ReaderProfileViewModel {
-    size_t loaded_count = 0;
-    size_t loading_count = 0;
-    std::string loaded_chunk_ids;
-    std::string loading_chunk_ids;
-    bool has_pending_chunks = false;
-    char spinner = '|';
-};
-
-/// Single row in the reader profile table.
-struct ReaderProfileRow {
-    std::string state_label;
-    std::string chunk_text;
-    bool highlighted = false;
-    bool disabled = false;
-};
-
-/// UI presentation helpers for chunk-state visualization.
-/// Core state tracking now lives in the SDK (VTX::ReaderChunkState).
-class ReaderChunkStateService {
-public:
-    static ReaderProfileViewModel BuildProfileViewModel(
-        const VTX::ReaderChunkSnapshot& snapshot,
-        double ui_time_seconds,
-        ReaderProfileCacheState& io_cache);
-    static std::vector<ReaderProfileRow> BuildProfileRows(const ReaderProfileViewModel& view_model);
-};
+    /// Cached state for avoiding redundant string rebuilds each frame.
+    struct ReaderProfileCacheState {
+        std::vector<int32_t> last_loaded;
+        std::vector<int32_t> last_loading;
+        std::string cached_loaded_str;
+        std::string cached_loading_str;
+    };
+
+    /// Presentation model for the reader profiler widget.
+    struct ReaderProfileViewModel {
+        size_t loaded_count = 0;
+        size_t loading_count = 0;
+        std::string loaded_chunk_ids;
+        std::string loading_chunk_ids;
+        bool has_pending_chunks = false;
+        char spinner = '|';
+    };
+
+    /// Single row in the reader profile table.
+    struct ReaderProfileRow {
+        std::string state_label;
+        std::string chunk_text;
+        bool highlighted = false;
+        bool disabled = false;
+    };
+
+    /// UI presentation helpers for chunk-state visualization.
+    /// Core state tracking now lives in the SDK (VTX::ReaderChunkState).
+    class ReaderChunkStateService {
+    public:
+        static ReaderProfileViewModel BuildProfileViewModel(const VTX::ReaderChunkSnapshot& snapshot,
+                                                            double ui_time_seconds, ReaderProfileCacheState& io_cache);
+        static std::vector<ReaderProfileRow> BuildProfileRows(const ReaderProfileViewModel& view_model);
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/schema_view_service.h b/tools/inspector/include/services/schema_view_service.h
index a4e458d..f3bb418 100644
--- a/tools/inspector/include/services/schema_view_service.h
+++ b/tools/inspector/include/services/schema_view_service.h
@@ -6,23 +6,24 @@
 
 namespace VtxServices {
 
-struct SchemaHighlightState {
-    std::string struct_name;
-    std::string property_name;
-    float time_remaining = 0.0f;
-    bool do_scroll = false;
-};
-
-class SchemaViewService {
-public:
-    static void RequestHighlight(SchemaHighlightState& highlight, const std::string& struct_name, const std::string& property_name, float ttl_seconds = 2.0f);
-    static void TickHighlight(SchemaHighlightState& highlight, float delta_seconds);
-    static bool IsHighlightActive(const SchemaHighlightState& highlight);
-
-    static bool ExportJsonToFile(const std::string& path, const std::string& json_content);
-
-    static std::string ResolveDisplayType(const VTX::PropertyAddress& address);
-    static VTX::FieldContainerType ResolveContainerType(const VTX::PropertyAddress& address);
-};
+    struct SchemaHighlightState {
+        std::string struct_name;
+        std::string property_name;
+        float time_remaining = 0.0f;
+        bool do_scroll = false;
+    };
+
+    class SchemaViewService {
+    public:
+        static void RequestHighlight(SchemaHighlightState& highlight, const std::string& struct_name,
+                                     const std::string& property_name, float ttl_seconds = 2.0f);
+        static void TickHighlight(SchemaHighlightState& highlight, float delta_seconds);
+        static bool IsHighlightActive(const SchemaHighlightState& highlight);
+
+        static bool ExportJsonToFile(const std::string& path, const std::string& json_content);
+
+        static std::string ResolveDisplayType(const VTX::PropertyAddress& address);
+        static VTX::FieldContainerType ResolveContainerType(const VTX::PropertyAddress& address);
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/services/time_display_service.h b/tools/inspector/include/services/time_display_service.h
index 0a9f0bc..4d17469 100644
--- a/tools/inspector/include/services/time_display_service.h
+++ b/tools/inspector/include/services/time_display_service.h
@@ -7,29 +7,28 @@
 
 namespace VtxServices {
 
-class TimeDisplayService {
-public:
-    // Formats raw tick value as an integer string.
-    static std::string FormatTicksRaw(uint64_t ticks);
+    class TimeDisplayService {
+    public:
+        // Formats raw tick value as an integer string.
+        static std::string FormatTicksRaw(uint64_t ticks);
 
-    // Formats tick duration as "xh xm xs xms", omitting h/m when zero.
-    static std::string FormatDurationFromTicks(uint64_t ticks);
+        // Formats tick duration as "xh xm xs xms", omitting h/m when zero.
+        static std::string FormatDurationFromTicks(uint64_t ticks);
 
-    // Formats UTC ticks as RSS text.
-    static std::string FormatUtcTicksAsRss(uint64_t ticks);
+        // Formats UTC ticks as RSS text.
+        static std::string FormatUtcTicksAsRss(uint64_t ticks);
 
-    // Formats UTC ticks as RSS text plus the raw tick value.
-    static std::string FormatUtcTicksAsRssWithRaw(uint64_t ticks);
+        // Formats UTC ticks as RSS text plus the raw tick value.
+        static std::string FormatUtcTicksAsRssWithRaw(uint64_t ticks);
 
-    // Formats unix-seconds UTC as RSS text plus the raw seconds value.
-    static std::string FormatUnixSecondsAsRssWithRaw(int64_t unix_seconds);
+        // Formats unix-seconds UTC as RSS text plus the raw seconds value.
+        static std::string FormatUnixSecondsAsRssWithRaw(int64_t unix_seconds);
 
-    // Formats game-time ticks according to selected display mode.
-    static std::string FormatGameTimeTicks(uint64_t ticks, TimeDisplayFormat format);
+        // Formats game-time ticks according to selected display mode.
+        static std::string FormatGameTimeTicks(uint64_t ticks, TimeDisplayFormat format);
 
-    // Formats UTC ticks according to selected display mode.
-    static std::string FormatUtcTicks(uint64_t ticks, TimeDisplayFormat format);
-};
+        // Formats UTC ticks according to selected display mode.
+        static std::string FormatUtcTicks(uint64_t ticks, TimeDisplayFormat format);
+    };
 
 } // namespace VtxServices
-
diff --git a/tools/inspector/include/services/timeline_view_service.h b/tools/inspector/include/services/timeline_view_service.h
index a77c935..6393153 100644
--- a/tools/inspector/include/services/timeline_view_service.h
+++ b/tools/inspector/include/services/timeline_view_service.h
@@ -2,53 +2,53 @@
 
 namespace VtxServices {
 
-struct ClockTime {
-    int minutes = 0;
-    int seconds = 0;
-};
-
-struct DurationSplit {
-    int minutes = 0;
-    float seconds = 0.0f;
-};
-
-struct TimelineClockSpan {
-    ClockTime current;
-    ClockTime total;
-    float fps = 30.0f;
-};
-
-struct TimelineBarState {
-    float bar_width = 2.0f;
-    float bar_spacing = 1.0f;
-    float min_bar_width = 0.5f;
-    float max_bar_width = 50.0f;
-    int last_tracked_frame = -1;
-};
-
-struct TimelineVisibleRange {
-    int first_visible_idx = 0;
-    int last_visible_idx = 0;
-    float item_full_width = 0.0f;
-    float total_content_width = 0.0f;
-};
-
-class TimelineViewService {
-public:
-    static float ComputePlaybackFps(int total_frames, float duration_seconds, float fallback_fps = 30.0f);
-    static ClockTime ToClockTime(float total_seconds);
-    static DurationSplit SplitDuration(float total_seconds);
-    static TimelineClockSpan BuildTimelineClockSpan(
-        int current_frame,
-        int total_frames,
-        float duration_seconds,
-        float fallback_fps = 30.0f);
-    static int ClampFrame(int frame, int total_frames);
-    static float ComputeItemFullWidth(const TimelineBarState& bar_state);
-    static float ComputeCenteredScroll(int frame_index, float item_full_width, float view_width);
-    static TimelineVisibleRange ComputeVisibleRange(float scroll_x, float view_width, int total_frames, const TimelineBarState& bar_state);
-    static float ComputeZoomedScroll(float wheel, float mouse_x_in_child, float scroll_x, TimelineBarState& bar_state);
-    static int ResolveHoveredFrame(float mouse_x, float mouse_y, float origin_x, float origin_y, float timeline_height, const TimelineVisibleRange& range);
-};
+    struct ClockTime {
+        int minutes = 0;
+        int seconds = 0;
+    };
+
+    struct DurationSplit {
+        int minutes = 0;
+        float seconds = 0.0f;
+    };
+
+    struct TimelineClockSpan {
+        ClockTime current;
+        ClockTime total;
+        float fps = 30.0f;
+    };
+
+    struct TimelineBarState {
+        float bar_width = 2.0f;
+        float bar_spacing = 1.0f;
+        float min_bar_width = 0.5f;
+        float max_bar_width = 50.0f;
+        int last_tracked_frame = -1;
+    };
+
+    struct TimelineVisibleRange {
+        int first_visible_idx = 0;
+        int last_visible_idx = 0;
+        float item_full_width = 0.0f;
+        float total_content_width = 0.0f;
+    };
+
+    class TimelineViewService {
+    public:
+        static float ComputePlaybackFps(int total_frames, float duration_seconds, float fallback_fps = 30.0f);
+        static ClockTime ToClockTime(float total_seconds);
+        static DurationSplit SplitDuration(float total_seconds);
+        static TimelineClockSpan BuildTimelineClockSpan(int current_frame, int total_frames, float duration_seconds,
+                                                        float fallback_fps = 30.0f);
+        static int ClampFrame(int frame, int total_frames);
+        static float ComputeItemFullWidth(const TimelineBarState& bar_state);
+        static float ComputeCenteredScroll(int frame_index, float item_full_width, float view_width);
+        static TimelineVisibleRange ComputeVisibleRange(float scroll_x, float view_width, int total_frames,
+                                                        const TimelineBarState& bar_state);
+        static float ComputeZoomedScroll(float wheel, float mouse_x_in_child, float scroll_x,
+                                         TimelineBarState& bar_state);
+        static int ResolveHoveredFrame(float mouse_x, float mouse_y, float origin_x, float origin_y,
+                                       float timeline_height, const TimelineVisibleRange& range);
+    };
 
 } // namespace VtxServices
diff --git a/tools/inspector/include/windows/analysis_window_factory.h b/tools/inspector/include/windows/analysis_window_factory.h
index dfc8b07..7c1fee7 100644
--- a/tools/inspector/include/windows/analysis_window_factory.h
+++ b/tools/inspector/include/windows/analysis_window_factory.h
@@ -10,16 +10,13 @@ class InspectorSession;
 
 namespace AnalysisWindowFactory {
 
-std::shared_ptr<IGuiLayer> CreateEntityLifeTimeWindow(
-    std::shared_ptr<InspectorSession> session, int instance_id);
+    std::shared_ptr<IGuiLayer> CreateEntityLifeTimeWindow(std::shared_ptr<InspectorSession> session, int instance_id);
 
-std::shared_ptr<IGuiLayer> CreateUniquePropertiesWindow(
-    std::shared_ptr<InspectorSession> session, int instance_id);
+    std::shared_ptr<IGuiLayer> CreateUniquePropertiesWindow(std::shared_ptr<InspectorSession> session, int instance_id);
 
-std::shared_ptr<IGuiLayer> CreateTrackPropertyWindow(
-    std::shared_ptr<InspectorSession> session, int instance_id);
+    std::shared_ptr<IGuiLayer> CreateTrackPropertyWindow(std::shared_ptr<InspectorSession> session, int instance_id);
 
-// Returns true if the analysis window layer is still open.
-bool IsAnalysisWindowOpen(const std::shared_ptr<IGuiLayer>& layer);
+    // Returns true if the analysis window layer is still open.
+    bool IsAnalysisWindowOpen(const std::shared_ptr<IGuiLayer>& layer);
 
 } // namespace AnalysisWindowFactory
diff --git a/tools/inspector/include/windows/buckets_window.h b/tools/inspector/include/windows/buckets_window.h
index 1ec2449..c7b2ff8 100644
--- a/tools/inspector/include/windows/buckets_window.h
+++ b/tools/inspector/include/windows/buckets_window.h
@@ -14,7 +14,7 @@ namespace VTX {
 class BucketsWindow : public ImGuiWindow {
 public:
     BucketsWindow(std::shared_ptr<InspectorSession> session);
-    
+
 protected:
     void DrawContent() override;
 
diff --git a/tools/inspector/include/windows/entity_details_window.h b/tools/inspector/include/windows/entity_details_window.h
index 58724a0..848f3e0 100644
--- a/tools/inspector/include/windows/entity_details_window.h
+++ b/tools/inspector/include/windows/entity_details_window.h
@@ -13,14 +13,11 @@ class EntityDetailsWindow : public ImGuiWindow {
     void DrawContent() override;
 
 private:
-    void DrawPropertiesPanel(
-        const VtxServices::EntityInspectorViewModel& view_model,
-        const VTX::PropertyAddressCache* global_cache);
-    void RenderPropertyNode(
-        const VtxServices::EntityPropertyNode& node,
-        const VTX::PropertyAddressCache* global_cache,
-        bool show_schema_names);
-    
+    void DrawPropertiesPanel(const VtxServices::EntityInspectorViewModel& view_model,
+                             const VTX::PropertyAddressCache* global_cache);
+    void RenderPropertyNode(const VtxServices::EntityPropertyNode& node, const VTX::PropertyAddressCache* global_cache,
+                            bool show_schema_names);
+
     void DrawHexViewerForNode(const VtxServices::EntityPropertyNode& node);
     std::shared_ptr<InspectorSession> inspector_session_;
 };
diff --git a/tools/inspector/include/windows/reader_inspector_window.h b/tools/inspector/include/windows/reader_inspector_window.h
index 28b992f..dccc773 100644
--- a/tools/inspector/include/windows/reader_inspector_window.h
+++ b/tools/inspector/include/windows/reader_inspector_window.h
@@ -5,7 +5,7 @@
 
 class InspectorSession;
 namespace VTX {
-class IVtxReaderFacade;
+    class IVtxReaderFacade;
 }
 
 class ReaderInspectorWindow : public ImGuiWindow {
diff --git a/tools/inspector/include/windows/replay_time_data_window.h b/tools/inspector/include/windows/replay_time_data_window.h
index 916625a..9ce5281 100644
--- a/tools/inspector/include/windows/replay_time_data_window.h
+++ b/tools/inspector/include/windows/replay_time_data_window.h
@@ -5,7 +5,7 @@
 class InspectorSession;
 
 class ReplayTimeDataWindow : public ImGuiWindow {
-public:    
+public:
     ReplayTimeDataWindow(std::shared_ptr<InspectorSession> session);
 
 protected:
diff --git a/tools/inspector/include/windows/timeline_window.h b/tools/inspector/include/windows/timeline_window.h
index c4cbf7e..4c3c960 100644
--- a/tools/inspector/include/windows/timeline_window.h
+++ b/tools/inspector/include/windows/timeline_window.h
@@ -5,7 +5,6 @@
 class InspectorSession;
 
 class TimelineWindow : public ImGuiWindow {
-
 public:
     TimelineWindow(const std::shared_ptr<InspectorSession>& session);
 
@@ -15,11 +14,11 @@ class TimelineWindow : public ImGuiWindow {
 private:
     void DrawTimelineSlider(int total_frames, float duration_seconds);
     void DrawTimeAndFrameInfo(int total_frames, float duration);
-    
+
     //dynamic timeline
     void DrawFrameStripTimeline(int total_frames);
-    
+
 private:
-    VtxServices::TimelineBarState timeline_bar_state_{};
+    VtxServices::TimelineBarState timeline_bar_state_ {};
     std::shared_ptr<InspectorSession> inspector_session_;
 };
diff --git a/tools/inspector/src/inspector_layout.cpp b/tools/inspector/src/inspector_layout.cpp
index 11f1fda..0e88920 100644
--- a/tools/inspector/src/inspector_layout.cpp
+++ b/tools/inspector/src/inspector_layout.cpp
@@ -14,136 +14,131 @@
 
 namespace {
 
-struct DockWindowPlacement {
-    std::string window_name;
-    std::string region;
-};
-
-struct DockLayoutSpec {
-    float left_ratio = 0.25f;
-    float left_top_ratio = 0.75f;
-    float bottom_ratio = 0.25f;
-    float top_right_details_ratio = 0.50f;
-    std::vector<DockWindowPlacement> placements;
-};
-
-struct CommandResult {
-    bool success = true;
-    bool warning = false;
-    std::string log_message;
-};
-
-// Returns the canonical dock placement spec for the Inspector workspace.
-DockLayoutSpec BuildDefaultDockLayout() {
-    DockLayoutSpec spec;
-    spec.placements = {
-        DockWindowPlacement{VtxGuiNames::FilePropertiesWindow, "left_top"},
-        DockWindowPlacement{VtxGuiNames::ReaderProfilerWindow, "left_bottom"},
-        DockWindowPlacement{VtxGuiNames::BucketsWindow, "tabs"},
-        DockWindowPlacement{VtxGuiNames::ChunkIndexWindow, "tabs"},
-        DockWindowPlacement{VtxGuiNames::TimelineEventsWindow, "tabs"},
-        DockWindowPlacement{VtxGuiNames::ReplayTimeDataWindow, "tabs"},
-        DockWindowPlacement{VtxGuiNames::SchemaViewerWindow, "details"},
-        DockWindowPlacement{VtxGuiNames::EntityDetailsWindow, "details"},
-        DockWindowPlacement{VtxGuiNames::TimelineWindow, "bottom"},
-        DockWindowPlacement{VtxGuiNames::LogWindow, "bottom"},
+    struct DockWindowPlacement {
+        std::string window_name;
+        std::string region;
+    };
+
+    struct DockLayoutSpec {
+        float left_ratio = 0.25f;
+        float left_top_ratio = 0.75f;
+        float bottom_ratio = 0.25f;
+        float top_right_details_ratio = 0.50f;
+        std::vector<DockWindowPlacement> placements;
+    };
+
+    struct CommandResult {
+        bool success = true;
+        bool warning = false;
+        std::string log_message;
     };
-    return spec;
-}
 
-// Validates file picker output before replay-open flow starts.
-CommandResult ValidateOpenReplaySelection(const std::string& selected_path) {
-    CommandResult result;
-    if (selected_path.empty()) {
-        result.success = false;
-        result.warning = true;
-        result.log_message = "No replay selected.";
+    // Returns the canonical dock placement spec for the Inspector workspace.
+    DockLayoutSpec BuildDefaultDockLayout() {
+        DockLayoutSpec spec;
+        spec.placements = {
+            DockWindowPlacement {VtxGuiNames::FilePropertiesWindow, "left_top"},
+            DockWindowPlacement {VtxGuiNames::ReaderProfilerWindow, "left_bottom"},
+            DockWindowPlacement {VtxGuiNames::BucketsWindow, "tabs"},
+            DockWindowPlacement {VtxGuiNames::ChunkIndexWindow, "tabs"},
+            DockWindowPlacement {VtxGuiNames::TimelineEventsWindow, "tabs"},
+            DockWindowPlacement {VtxGuiNames::ReplayTimeDataWindow, "tabs"},
+            DockWindowPlacement {VtxGuiNames::SchemaViewerWindow, "details"},
+            DockWindowPlacement {VtxGuiNames::EntityDetailsWindow, "details"},
+            DockWindowPlacement {VtxGuiNames::TimelineWindow, "bottom"},
+            DockWindowPlacement {VtxGuiNames::LogWindow, "bottom"},
+        };
+        return spec;
     }
-    return result;
-}
 
-// Builds success/failure feedback for replay-open commands.
-CommandResult BuildOpenReplayResult(const std::string& selected_path, bool success) {
-    CommandResult result;
-    result.success = success;
-    result.warning = !success;
-    result.log_message = success
-        ? "Replay opened: " + selected_path
-        : "Failed to open replay: " + selected_path;
-    return result;
-}
+    // Validates file picker output before replay-open flow starts.
+    CommandResult ValidateOpenReplaySelection(const std::string& selected_path) {
+        CommandResult result;
+        if (selected_path.empty()) {
+            result.success = false;
+            result.warning = true;
+            result.log_message = "No replay selected.";
+        }
+        return result;
+    }
 
-// Builds feedback for replay-close commands.
-CommandResult BuildCloseReplayResult(bool had_loaded_replay) {
-    CommandResult result;
-    if (!had_loaded_replay) {
-        result.success = false;
-        result.warning = true;
-        result.log_message = "No replay is currently loaded.";
+    // Builds success/failure feedback for replay-open commands.
+    CommandResult BuildOpenReplayResult(const std::string& selected_path, bool success) {
+        CommandResult result;
+        result.success = success;
+        result.warning = !success;
+        result.log_message = success ? "Replay opened: " + selected_path : "Failed to open replay: " + selected_path;
         return result;
     }
 
-    result.log_message = "Replay closed.";
-    return result;
-}
+    // Builds feedback for replay-close commands.
+    CommandResult BuildCloseReplayResult(bool had_loaded_replay) {
+        CommandResult result;
+        if (!had_loaded_replay) {
+            result.success = false;
+            result.warning = true;
+            result.log_message = "No replay is currently loaded.";
+            return result;
+        }
 
-// Routes command feedback to warning/info GUI log channel.
-void LogCommandResult(InspectorSession& session, const CommandResult& result) {
-    if (result.warning) {
-        session.AddGuiWarningLog(result.log_message);
-        return;
+        result.log_message = "Replay closed.";
+        return result;
     }
-    session.AddGuiInfoLog(result.log_message);
-}
 
-// Renders shared DPI scaling controls for the desktop tools.
-void DrawViewMenu(const std::shared_ptr<GuiScaleController>& scale_controller) {
-    if (!scale_controller || !ImGui::BeginMenu("View")) {
-        return;
+    // Routes command feedback to warning/info GUI log channel.
+    void LogCommandResult(InspectorSession& session, const CommandResult& result) {
+        if (result.warning) {
+            session.AddGuiWarningLog(result.log_message);
+            return;
+        }
+        session.AddGuiInfoLog(result.log_message);
     }
 
-    ImGui::TextDisabled("Auto Scale: %.0f%%", scale_controller->GetAutoScale() * 100.0f);
-    ImGui::TextDisabled("Effective Scale: %.0f%%", scale_controller->GetEffectiveScale() * 100.0f);
-    if (scale_controller->HasOverride()) {
-        ImGui::TextDisabled("Adjustment: %.0f%%", scale_controller->GetScaleAdjustment() * 100.0f);
-    } else {
-        ImGui::TextDisabled("Adjustment: Auto");
-    }
+    // Renders shared DPI scaling controls for the desktop tools.
+    void DrawViewMenu(const std::shared_ptr<GuiScaleController>& scale_controller) {
+        if (!scale_controller || !ImGui::BeginMenu("View")) {
+            return;
+        }
 
-    ImGui::Separator();
+        ImGui::TextDisabled("Auto Scale: %.0f%%", scale_controller->GetAutoScale() * 100.0f);
+        ImGui::TextDisabled("Effective Scale: %.0f%%", scale_controller->GetEffectiveScale() * 100.0f);
+        if (scale_controller->HasOverride()) {
+            ImGui::TextDisabled("Adjustment: %.0f%%", scale_controller->GetScaleAdjustment() * 100.0f);
+        } else {
+            ImGui::TextDisabled("Adjustment: Auto");
+        }
 
-    const float adjustment = scale_controller->GetScaleAdjustment();
-    if (ImGui::MenuItem("Scale Down", nullptr, false, adjustment > 0.76f)) {
-        scale_controller->DecreaseAdjustment();
-    }
-    if (ImGui::MenuItem("Scale Up")) {
-        scale_controller->IncreaseAdjustment();
-    }
+        ImGui::Separator();
 
-    float adjustment_slider = adjustment;
-    ImGui::PushItemWidth(160.0f);
-    if (ImGui::SliderFloat("Scale Adjustment", &adjustment_slider, 0.75f, 2.0f, "%.2fx")) {
-        scale_controller->SetScaleAdjustment(adjustment_slider);
-    }
-    ImGui::PopItemWidth();
+        const float adjustment = scale_controller->GetScaleAdjustment();
+        if (ImGui::MenuItem("Scale Down", nullptr, false, adjustment > 0.76f)) {
+            scale_controller->DecreaseAdjustment();
+        }
+        if (ImGui::MenuItem("Scale Up")) {
+            scale_controller->IncreaseAdjustment();
+        }
 
-    if (ImGui::MenuItem("Reset to Auto", nullptr, false, scale_controller->HasOverride())) {
-        scale_controller->ResetToAuto();
-    }
+        float adjustment_slider = adjustment;
+        ImGui::PushItemWidth(160.0f);
+        if (ImGui::SliderFloat("Scale Adjustment", &adjustment_slider, 0.75f, 2.0f, "%.2fx")) {
+            scale_controller->SetScaleAdjustment(adjustment_slider);
+        }
+        ImGui::PopItemWidth();
 
-    ImGui::EndMenu();
-}
+        if (ImGui::MenuItem("Reset to Auto", nullptr, false, scale_controller->HasOverride())) {
+            scale_controller->ResetToAuto();
+        }
+
+        ImGui::EndMenu();
+    }
 
 } // namespace
 
 // Constructs the top-level Inspector layout shell.
-InspectorLayout::InspectorLayout(
-    const std::shared_ptr<InspectorSession>& session,
-    const std::shared_ptr<GuiScaleController>& scale_controller)
-    : session_(session),
-      scale_controller_(scale_controller)
-{
-}
+InspectorLayout::InspectorLayout(const std::shared_ptr<InspectorSession>& session,
+                                 const std::shared_ptr<GuiScaleController>& scale_controller)
+    : session_(session)
+    , scale_controller_(scale_controller) {}
 
 // Inspector layout has no per-frame update state today.
 void InspectorLayout::OnUpdate() {}
@@ -152,15 +147,16 @@ void InspectorLayout::OnUpdate() {}
 void InspectorLayout::OnRender() {
     ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
     const ImGuiViewport* viewport = ImGui::GetMainViewport();
-    
+
     ImGui::SetNextWindowPos(viewport->WorkPos);
     ImGui::SetNextWindowSize(viewport->WorkSize);
     ImGui::SetNextWindowViewport(viewport->ID);
-    
+
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    
-    window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
+
+    window_flags |=
+        ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
     window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
 
     ImGui::Begin("VTX DockSpace Base", nullptr, window_flags);
@@ -180,17 +176,16 @@ void InspectorLayout::OnRender() {
 
         ImGuiID dock_main_id = dockspace_id;
 
-        ImGuiID dock_id_left = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, layout_spec.left_ratio, nullptr, &dock_main_id);
-        ImGuiID dock_id_left_top = ImGui::DockBuilderSplitNode(dock_id_left, ImGuiDir_Up, layout_spec.left_top_ratio, nullptr, &dock_id_left);
+        ImGuiID dock_id_left =
+            ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, layout_spec.left_ratio, nullptr, &dock_main_id);
+        ImGuiID dock_id_left_top =
+            ImGui::DockBuilderSplitNode(dock_id_left, ImGuiDir_Up, layout_spec.left_top_ratio, nullptr, &dock_id_left);
         ImGuiID dock_id_left_bottom = dock_id_left;
 
-        ImGuiID dock_id_bottom = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Down, layout_spec.bottom_ratio, nullptr, &dock_main_id);
+        ImGuiID dock_id_bottom =
+            ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Down, layout_spec.bottom_ratio, nullptr, &dock_main_id);
         ImGuiID dock_id_details = ImGui::DockBuilderSplitNode(
-            dock_main_id,
-            ImGuiDir_Right,
-            layout_spec.top_right_details_ratio,
-            nullptr,
-            &dock_main_id);
+            dock_main_id, ImGuiDir_Right, layout_spec.top_right_details_ratio, nullptr, &dock_main_id);
         ImGuiID dock_id_tabs = dock_main_id;
 
         for (const auto& placement : layout_spec.placements) {
@@ -208,7 +203,7 @@ void InspectorLayout::OnRender() {
             }
             ImGui::DockBuilderDockWindow(placement.window_name.c_str(), target);
         }
-        
+
         ImGui::DockBuilderFinish(dockspace_id);
     }
 
@@ -217,16 +212,14 @@ void InspectorLayout::OnRender() {
     // Step 2: Render top menu actions.
     if (ImGui::BeginMenuBar()) {
         if (ImGui::BeginMenu("File")) {
-            
             if (ImGui::MenuItem("Open VTX Replay...")) {
-                auto f = pfd::open_file("Select a VTX Replay", ".", 
-                                        { "VTX Files (.vtx)", "*.vtx", "All Files", "*" });
+                auto f = pfd::open_file("Select a VTX Replay", ".", {"VTX Files (.vtx)", "*.vtx", "All Files", "*"});
 
-                const std::string selected_path = f.result().empty() ? std::string{} : f.result()[0];
+                const std::string selected_path = f.result().empty() ? std::string {} : f.result()[0];
                 const auto selection = ValidateOpenReplaySelection(selected_path);
                 const auto result = selection.success
-                    ? BuildOpenReplayResult(selected_path, session_->LoadReplay(selected_path))
-                    : selection;
+                                        ? BuildOpenReplayResult(selected_path, session_->LoadReplay(selected_path))
+                                        : selection;
                 LogCommandResult(*session_, result);
             }
 
@@ -256,8 +249,7 @@ void InspectorLayout::OnRender() {
 
             ImGui::Separator();
 
-            if (ImGui::MenuItem("Exit"))
-            {
+            if (ImGui::MenuItem("Exit")) {
                 if (GLFWwindow* current_window = glfwGetCurrentContext()) {
                     glfwSetWindowShouldClose(current_window, GLFW_TRUE);
                 }
@@ -266,7 +258,7 @@ void InspectorLayout::OnRender() {
         }
 
         DrawViewMenu(scale_controller_);
-        
+
         if (ImGui::BeginMenu("Windows")) {
             ImGui::MenuItem(VtxGuiNames::FilePropertiesWindow, nullptr, true);
             ImGui::MenuItem(VtxGuiNames::BucketsWindow, nullptr, true);
@@ -278,30 +270,27 @@ void InspectorLayout::OnRender() {
             ImGui::MenuItem(VtxGuiNames::EntityDetailsWindow, nullptr, true);
             ImGui::MenuItem(VtxGuiNames::TimelineWindow, nullptr, true);
             ImGui::MenuItem(VtxGuiNames::LogWindow, nullptr, true);
-            
+
             ImGui::Separator();
-            
+
             if (ImGui::MenuItem("Reset Layout to Default")) {
                 force_layout_reset_ = true;
             }
             ImGui::EndMenu();
         }
-        
+
         if (ImGui::BeginMenu("Analysis", session_->HasLoadedReplay())) {
             if (ImGui::MenuItem("Entity LifeTime")) {
                 analysis_windows_.push_back(
-                    AnalysisWindowFactory::CreateEntityLifeTimeWindow(
-                        session_, ++analysis_window_counter_));
+                    AnalysisWindowFactory::CreateEntityLifeTimeWindow(session_, ++analysis_window_counter_));
             }
             if (ImGui::MenuItem("Unique Properties")) {
                 analysis_windows_.push_back(
-                    AnalysisWindowFactory::CreateUniquePropertiesWindow(
-                        session_, ++analysis_window_counter_));
+                    AnalysisWindowFactory::CreateUniquePropertiesWindow(session_, ++analysis_window_counter_));
             }
             if (ImGui::MenuItem("Track Property")) {
                 analysis_windows_.push_back(
-                    AnalysisWindowFactory::CreateTrackPropertyWindow(
-                        session_, ++analysis_window_counter_));
+                    AnalysisWindowFactory::CreateTrackPropertyWindow(session_, ++analysis_window_counter_));
             }
             ImGui::EndMenu();
         }
diff --git a/tools/inspector/src/main.cpp b/tools/inspector/src/main.cpp
index 16c9762..dafab37 100644
--- a/tools/inspector/src/main.cpp
+++ b/tools/inspector/src/main.cpp
@@ -18,26 +18,26 @@
 
 namespace {
 
-// Boots Inspector app, registers all windows/layers, and runs UI loop.
-int RunInspector() {
-    GuiApplication app("vtx_inspector", "VTX Inspector v1.0", 1600, 900);
-    auto session = std::make_shared<InspectorSession>();
+    // Boots Inspector app, registers all windows/layers, and runs UI loop.
+    int RunInspector() {
+        GuiApplication app("vtx_inspector", "VTX Inspector v1.0", 1600, 900);
+        auto session = std::make_shared<InspectorSession>();
 
-    app.AddLayer(std::make_shared<InspectorLayout>(session, app.GetScaleController()));
-    app.AddLayer(std::make_shared<TimelineWindow>(session));
-    app.AddLayer(std::make_shared<BucketsWindow>(session));
-    app.AddLayer(std::make_shared<ReaderInspectorWindow>(session));
-    app.AddLayer(std::make_shared<EntityDetailsWindow>(session));
-    app.AddLayer(std::make_shared<SchemaViewerWindow>(session));
-    app.AddLayer(std::make_shared<ReplayTimeDataWindow>(session));
-    app.AddLayer(std::make_shared<ChunkIndexWindow>(session));
-    app.AddLayer(std::make_shared<TimelineEventsWindow>(session));
-    app.AddLayer(std::make_shared<LogsWindow>(session));
-    app.AddLayer(std::make_shared<FileInfoWindow>(session));
+        app.AddLayer(std::make_shared<InspectorLayout>(session, app.GetScaleController()));
+        app.AddLayer(std::make_shared<TimelineWindow>(session));
+        app.AddLayer(std::make_shared<BucketsWindow>(session));
+        app.AddLayer(std::make_shared<ReaderInspectorWindow>(session));
+        app.AddLayer(std::make_shared<EntityDetailsWindow>(session));
+        app.AddLayer(std::make_shared<SchemaViewerWindow>(session));
+        app.AddLayer(std::make_shared<ReplayTimeDataWindow>(session));
+        app.AddLayer(std::make_shared<ChunkIndexWindow>(session));
+        app.AddLayer(std::make_shared<TimelineEventsWindow>(session));
+        app.AddLayer(std::make_shared<LogsWindow>(session));
+        app.AddLayer(std::make_shared<FileInfoWindow>(session));
 
-    app.Run();
-    return 0;
-}
+        app.Run();
+        return 0;
+    }
 
 } // namespace
 
diff --git a/tools/inspector/src/services/analysis_scanner.cpp b/tools/inspector/src/services/analysis_scanner.cpp
index e82ef18..63b63db 100644
--- a/tools/inspector/src/services/analysis_scanner.cpp
+++ b/tools/inspector/src/services/analysis_scanner.cpp
@@ -7,63 +7,55 @@
 
 namespace VtxServices {
 
-namespace {
-
-// Resolves the selected analysis bucket using the same index ordering as the bucket tree.
-const VTX::Bucket* ResolveScanBucket(
-    const VTX::Frame& frame,
-    const AnalysisScanner::ScanConfig& config)
-{
-    const auto& buckets = frame.GetBuckets();
-    if (config.bucket_index >= 0 &&
-        static_cast<size_t>(config.bucket_index) < buckets.size()) {
-        return &buckets[static_cast<size_t>(config.bucket_index)];
-    }
+    namespace {
 
-    const auto bucket_it = frame.bucket_map.find(config.bucket_name);
-    if (bucket_it == frame.bucket_map.end()) {
-        return nullptr;
-    }
+        // Resolves the selected analysis bucket using the same index ordering as the bucket tree.
+        const VTX::Bucket* ResolveScanBucket(const VTX::Frame& frame, const AnalysisScanner::ScanConfig& config) {
+            const auto& buckets = frame.GetBuckets();
+            if (config.bucket_index >= 0 && static_cast<size_t>(config.bucket_index) < buckets.size()) {
+                return &buckets[static_cast<size_t>(config.bucket_index)];
+            }
 
-    const size_t resolved_index = static_cast<size_t>(bucket_it->second);
-    return resolved_index < buckets.size() ? &buckets[resolved_index] : nullptr;
-}
+            const auto bucket_it = frame.bucket_map.find(config.bucket_name);
+            if (bucket_it == frame.bucket_map.end()) {
+                return nullptr;
+            }
 
-// Builds a readable label for bucket-related scan diagnostics.
-std::string BuildBucketDebugLabel(const AnalysisScanner::ScanConfig& config) {
-    return std::format("'{}' (index {})", config.bucket_name, config.bucket_index);
-}
+            const size_t resolved_index = static_cast<size_t>(bucket_it->second);
+            return resolved_index < buckets.size() ? &buckets[resolved_index] : nullptr;
+        }
 
-} // namespace
+        // Builds a readable label for bucket-related scan diagnostics.
+        std::string BuildBucketDebugLabel(const AnalysisScanner::ScanConfig& config) {
+            return std::format("'{}' (index {})", config.bucket_name, config.bucket_index);
+        }
 
-AnalysisScanner::~AnalysisScanner() {
-    cancel_requested_.store(true);
-    if (worker_.valid()) {
-        worker_.wait();
+    } // namespace
+
+    AnalysisScanner::~AnalysisScanner() {
+        cancel_requested_.store(true);
+        if (worker_.valid()) {
+            worker_.wait();
+        }
     }
-}
-
-void AnalysisScanner::Start(
-    ScanType type,
-    const ScanConfig& config,
-    VTX::IVtxReaderFacade* reader,
-    const VTX::PropertyAddressCache& cache,
-    const VTX::FileFooter& footer)
-{
-    if (is_running_.load()) return;
-
-    // Step 1: Reset the reusable scanner state before starting a new worker task.
-    cancel_requested_.store(false);
-    progress_.store(0.0f);
-    current_frame_.store(-1);
-    lifetime_result_ = {};
-    unique_props_result_ = {};
-    track_prop_result_ = {};
-    is_running_.store(true);
-
-    // Step 2: Run the selected scan on a worker thread and mark the scanner idle on exit.
-    worker_ = std::async(std::launch::async, [this, type, config, reader, cache, footer]() {
-        switch (type) {
+
+    void AnalysisScanner::Start(ScanType type, const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                                const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer) {
+        if (is_running_.load())
+            return;
+
+        // Step 1: Reset the reusable scanner state before starting a new worker task.
+        cancel_requested_.store(false);
+        progress_.store(0.0f);
+        current_frame_.store(-1);
+        lifetime_result_ = {};
+        unique_props_result_ = {};
+        track_prop_result_ = {};
+        is_running_.store(true);
+
+        // Step 2: Run the selected scan on a worker thread and mark the scanner idle on exit.
+        worker_ = std::async(std::launch::async, [this, type, config, reader, cache, footer]() {
+            switch (type) {
             case ScanType::EntityLifeTime:
                 RunEntityLifeTime(config, reader, cache, footer);
                 break;
@@ -73,440 +65,439 @@ void AnalysisScanner::Start(
             case ScanType::TrackProperty:
                 RunTrackProperty(config, reader, cache, footer);
                 break;
-        }
-        is_running_.store(false);
-    });
-}
+            }
+            is_running_.store(false);
+        });
+    }
 
-void AnalysisScanner::Cancel() {
-    cancel_requested_.store(true);
-}
+    void AnalysisScanner::Cancel() {
+        cancel_requested_.store(true);
+    }
 
-void AnalysisScanner::Reset() {
-    Cancel();
-    if (worker_.valid()) {
-        worker_.wait();
+    void AnalysisScanner::Reset() {
+        Cancel();
+        if (worker_.valid()) {
+            worker_.wait();
+        }
+        is_running_.store(false);
+        cancel_requested_.store(false);
+        progress_.store(0.0f);
+        current_frame_.store(-1);
+        {
+            std::scoped_lock lock(status_mutex_);
+            status_message_.clear();
+        }
+        lifetime_result_ = {};
+        unique_props_result_ = {};
+        track_prop_result_ = {};
     }
-    is_running_.store(false);
-    cancel_requested_.store(false);
-    progress_.store(0.0f);
-    current_frame_.store(-1);
-    {
+
+    std::string AnalysisScanner::GetStatus() const {
         std::scoped_lock lock(status_mutex_);
-        status_message_.clear();
+        return status_message_;
     }
-    lifetime_result_ = {};
-    unique_props_result_ = {};
-    track_prop_result_ = {};
-}
-
-std::string AnalysisScanner::GetStatus() const {
-    std::scoped_lock lock(status_mutex_);
-    return status_message_;
-}
-
-void AnalysisScanner::SetStatus(const std::string& msg) {
-    std::scoped_lock lock(status_mutex_);
-    status_message_ = msg;
-}
-
-uint64_t AnalysisScanner::GetGameTime(const VTX::FileFooter& footer, int32_t frame_index) {
-    auto idx = static_cast<size_t>(frame_index);
-    if (idx < footer.times.game_time.size()) {
-        return footer.times.game_time[idx];
+
+    void AnalysisScanner::SetStatus(const std::string& msg) {
+        std::scoped_lock lock(status_mutex_);
+        status_message_ = msg;
     }
-    return 0;
-}
-
-bool AnalysisScanner::PassesUidFilter(const std::vector<std::string>& filter, const std::string& uid) {
-    if (filter.empty()) return true;
-    return std::find(filter.begin(), filter.end(), uid) != filter.end();
-}
-
-// Scans the requested frame span and records every contiguous lifetime range per entity.
-void AnalysisScanner::RunEntityLifeTime(
-    const ScanConfig& config,
-    VTX::IVtxReaderFacade* reader,
-    const VTX::PropertyAddressCache& cache,
-    const VTX::FileFooter& footer)
-{
-    SetStatus("Scanning entity lifetimes...");
-
-    const int32_t total_range = config.end_frame - config.start_frame + 1;
-    int32_t frames_with_bucket = 0;
-
-    // Step 1: Track every entity that appears in the selected bucket.
-    std::unordered_map<std::string, EntityLifeTimeEntry> entity_map;
-    std::unordered_set<std::string> present_last_frame;
-    std::unordered_set<std::string> has_open_range;
-
-    for (int32_t f = config.start_frame; f <= config.end_frame; ++f) {
-        if (cancel_requested_.load()) {
-            SetStatus("Cancelled.");
-            lifetime_result_.error_message = "Cancelled by user.";
-            return;
+
+    uint64_t AnalysisScanner::GetGameTime(const VTX::FileFooter& footer, int32_t frame_index) {
+        auto idx = static_cast<size_t>(frame_index);
+        if (idx < footer.times.game_time.size()) {
+            return footer.times.game_time[idx];
         }
+        return 0;
+    }
+
+    bool AnalysisScanner::PassesUidFilter(const std::vector<std::string>& filter, const std::string& uid) {
+        if (filter.empty())
+            return true;
+        return std::find(filter.begin(), filter.end(), uid) != filter.end();
+    }
+
+    // Scans the requested frame span and records every contiguous lifetime range per entity.
+    void AnalysisScanner::RunEntityLifeTime(const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                                            const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer) {
+        SetStatus("Scanning entity lifetimes...");
+
+        const int32_t total_range = config.end_frame - config.start_frame + 1;
+        int32_t frames_with_bucket = 0;
+
+        // Step 1: Track every entity that appears in the selected bucket.
+        std::unordered_map<std::string, EntityLifeTimeEntry> entity_map;
+        std::unordered_set<std::string> present_last_frame;
+        std::unordered_set<std::string> has_open_range;
 
-        current_frame_.store(f);
-        progress_.store(static_cast<float>(f - config.start_frame + 1) / static_cast<float>(total_range));
-        SetStatus(std::format("Scanning entity lifetimes... frame {} / {}", f, config.end_frame));
-
-        const auto* frame = reader->GetFrameSync(f);
-        if (!frame) continue;
-
-        const auto* bucket = ResolveScanBucket(*frame, config);
-        if (!bucket) continue;
-        ++frames_with_bucket;
-
-        // Step 2: Open or extend ranges for entities present in the current frame.
-        std::unordered_set<std::string> present_this_frame;
-        for (size_t i = 0; i < bucket->unique_ids.size(); ++i) {
-            const auto& uid = bucket->unique_ids[i];
-            if (!PassesUidFilter(config.filter_unique_ids, uid)) continue;
-            present_this_frame.insert(uid);
-
-            if (!has_open_range.contains(uid)) {
-                auto& entry = entity_map[uid];
-                if (entry.unique_id.empty()) {
-                    entry.unique_id = uid;
-                    if (i < bucket->entities.size()) {
-                        entry.type_id = bucket->entities[i].entity_type_id;
-                        auto sc_it = cache.structs.find(entry.type_id);
-                        if (sc_it != cache.structs.end()) {
-                            entry.type_name = sc_it->second.name;
+        for (int32_t f = config.start_frame; f <= config.end_frame; ++f) {
+            if (cancel_requested_.load()) {
+                SetStatus("Cancelled.");
+                lifetime_result_.error_message = "Cancelled by user.";
+                return;
+            }
+
+            current_frame_.store(f);
+            progress_.store(static_cast<float>(f - config.start_frame + 1) / static_cast<float>(total_range));
+            SetStatus(std::format("Scanning entity lifetimes... frame {} / {}", f, config.end_frame));
+
+            const auto* frame = reader->GetFrameSync(f);
+            if (!frame)
+                continue;
+
+            const auto* bucket = ResolveScanBucket(*frame, config);
+            if (!bucket)
+                continue;
+            ++frames_with_bucket;
+
+            // Step 2: Open or extend ranges for entities present in the current frame.
+            std::unordered_set<std::string> present_this_frame;
+            for (size_t i = 0; i < bucket->unique_ids.size(); ++i) {
+                const auto& uid = bucket->unique_ids[i];
+                if (!PassesUidFilter(config.filter_unique_ids, uid))
+                    continue;
+                present_this_frame.insert(uid);
+
+                if (!has_open_range.contains(uid)) {
+                    auto& entry = entity_map[uid];
+                    if (entry.unique_id.empty()) {
+                        entry.unique_id = uid;
+                        if (i < bucket->entities.size()) {
+                            entry.type_id = bucket->entities[i].entity_type_id;
+                            auto sc_it = cache.structs.find(entry.type_id);
+                            if (sc_it != cache.structs.end()) {
+                                entry.type_name = sc_it->second.name;
+                            }
                         }
                     }
-                }
-                entry.ranges.push_back(FrameRange{
-                    .start_frame = f,
-                    .end_frame = f,
-                    .start_game_time = GetGameTime(footer, f),
-                    .end_game_time = GetGameTime(footer, f),
-                });
-                has_open_range.insert(uid);
-            } else {
-                auto& entry = entity_map[uid];
-                if (!entry.ranges.empty()) {
-                    entry.ranges.back().end_frame = f;
-                    entry.ranges.back().end_game_time = GetGameTime(footer, f);
+                    entry.ranges.push_back(FrameRange {
+                        .start_frame = f,
+                        .end_frame = f,
+                        .start_game_time = GetGameTime(footer, f),
+                        .end_game_time = GetGameTime(footer, f),
+                    });
+                    has_open_range.insert(uid);
+                } else {
+                    auto& entry = entity_map[uid];
+                    if (!entry.ranges.empty()) {
+                        entry.ranges.back().end_frame = f;
+                        entry.ranges.back().end_game_time = GetGameTime(footer, f);
+                    }
                 }
             }
-        }
 
-        // Step 3: Close ranges for entities that disappeared in this frame.
-        for (const auto& uid : present_last_frame) {
-            if (!present_this_frame.contains(uid)) {
-                has_open_range.erase(uid);
+            // Step 3: Close ranges for entities that disappeared in this frame.
+            for (const auto& uid : present_last_frame) {
+                if (!present_this_frame.contains(uid)) {
+                    has_open_range.erase(uid);
+                }
             }
-        }
 
-        present_last_frame = std::move(present_this_frame);
-    }
-
-    // Step 4: Build the final result set and surface empty-result diagnostics.
-    lifetime_result_.entries.reserve(entity_map.size());
-    for (auto& [uid, entry] : entity_map) {
-        lifetime_result_.entries.push_back(std::move(entry));
-    }
-
-    std::sort(lifetime_result_.entries.begin(), lifetime_result_.entries.end(),
-        [](const EntityLifeTimeEntry& a, const EntityLifeTimeEntry& b) {
-            int32_t a_start = a.ranges.empty() ? 0 : a.ranges.front().start_frame;
-            int32_t b_start = b.ranges.empty() ? 0 : b.ranges.front().start_frame;
-            return a_start < b_start;
-        });
-
-    lifetime_result_.is_complete = true;
-    progress_.store(1.0f);
-    if (frames_with_bucket == 0) {
-        lifetime_result_.error_message = std::format(
-            "Selected bucket {} was not present in frames {}-{}.",
-            BuildBucketDebugLabel(config),
-            config.start_frame,
-            config.end_frame);
-    } else if (lifetime_result_.entries.empty()) {
-        lifetime_result_.error_message = "No entities matched the selected filters in the scanned range.";
-    }
-    SetStatus(std::format("Done. {} entities found.", lifetime_result_.entries.size()));
-}
-
-// Scans scalar property combinations and groups unique value sets by contributing entity IDs.
-void AnalysisScanner::RunUniqueProperties(
-    const ScanConfig& config,
-    VTX::IVtxReaderFacade* reader,
-    const VTX::PropertyAddressCache& cache,
-    const VTX::FileFooter& footer)
-{
-    SetStatus("Scanning unique property combinations...");
-
-    const int32_t total_range = config.end_frame - config.start_frame + 1;
-    int32_t frames_with_bucket = 0;
-    int32_t matched_entities = 0;
-    int32_t entities_with_all_properties = 0;
-
-    // Step 1: Collect unique (uid, prop_values) tuples across the requested frame range.
-    std::unordered_set<std::string> unique_combinations;
-
-    for (int32_t f = config.start_frame; f <= config.end_frame; ++f) {
-        if (cancel_requested_.load()) {
-            SetStatus("Cancelled.");
-            unique_props_result_.error_message = "Cancelled by user.";
-            return;
+            present_last_frame = std::move(present_this_frame);
         }
 
-        current_frame_.store(f);
-        progress_.store(static_cast<float>(f - config.start_frame + 1) / static_cast<float>(total_range));
-        SetStatus(std::format("Scanning unique property combinations... frame {} / {}", f, config.end_frame));
-
-        const auto* frame = reader->GetFrameSync(f);
-        if (!frame) continue;
+        // Step 4: Build the final result set and surface empty-result diagnostics.
+        lifetime_result_.entries.reserve(entity_map.size());
+        for (auto& [uid, entry] : entity_map) {
+            lifetime_result_.entries.push_back(std::move(entry));
+        }
 
-        const auto* bucket = ResolveScanBucket(*frame, config);
-        if (!bucket) continue;
-        ++frames_with_bucket;
+        std::sort(lifetime_result_.entries.begin(), lifetime_result_.entries.end(),
+                  [](const EntityLifeTimeEntry& a, const EntityLifeTimeEntry& b) {
+                      int32_t a_start = a.ranges.empty() ? 0 : a.ranges.front().start_frame;
+                      int32_t b_start = b.ranges.empty() ? 0 : b.ranges.front().start_frame;
+                      return a_start < b_start;
+                  });
+
+        lifetime_result_.is_complete = true;
+        progress_.store(1.0f);
+        if (frames_with_bucket == 0) {
+            lifetime_result_.error_message =
+                std::format("Selected bucket {} was not present in frames {}-{}.", BuildBucketDebugLabel(config),
+                            config.start_frame, config.end_frame);
+        } else if (lifetime_result_.entries.empty()) {
+            lifetime_result_.error_message = "No entities matched the selected filters in the scanned range.";
+        }
+        SetStatus(std::format("Done. {} entities found.", lifetime_result_.entries.size()));
+    }
 
-        for (size_t i = 0; i < bucket->entities.size(); ++i) {
-            const std::string& uid = i < bucket->unique_ids.size() ? bucket->unique_ids[i] : "";
-            if (!PassesUidFilter(config.filter_unique_ids, uid)) continue;
-            ++matched_entities;
+    // Scans scalar property combinations and groups unique value sets by contributing entity IDs.
+    void AnalysisScanner::RunUniqueProperties(const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                                              const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer) {
+        SetStatus("Scanning unique property combinations...");
 
-            const auto& entity = bucket->entities[i];
-            auto sc_it = cache.structs.find(entity.entity_type_id);
-            if (sc_it == cache.structs.end()) continue;
+        const int32_t total_range = config.end_frame - config.start_frame + 1;
+        int32_t frames_with_bucket = 0;
+        int32_t matched_entities = 0;
+        int32_t entities_with_all_properties = 0;
 
-            std::string combined_key = uid;
-            combined_key += '\0';
+        // Step 1: Collect unique (uid, prop_values) tuples across the requested frame range.
+        std::unordered_set<std::string> unique_combinations;
 
-            bool has_all_props = true;
-            for (size_t p = 0; p < config.property_names.size(); ++p) {
-                if (p > 0) combined_key += '|';
+        for (int32_t f = config.start_frame; f <= config.end_frame; ++f) {
+            if (cancel_requested_.load()) {
+                SetStatus("Cancelled.");
+                unique_props_result_.error_message = "Cancelled by user.";
+                return;
+            }
 
-                auto prop_it = sc_it->second.properties.find(config.property_names[p]);
-                if (prop_it == sc_it->second.properties.end()) {
-                    has_all_props = false;
-                    break;
+            current_frame_.store(f);
+            progress_.store(static_cast<float>(f - config.start_frame + 1) / static_cast<float>(total_range));
+            SetStatus(std::format("Scanning unique property combinations... frame {} / {}", f, config.end_frame));
+
+            const auto* frame = reader->GetFrameSync(f);
+            if (!frame)
+                continue;
+
+            const auto* bucket = ResolveScanBucket(*frame, config);
+            if (!bucket)
+                continue;
+            ++frames_with_bucket;
+
+            for (size_t i = 0; i < bucket->entities.size(); ++i) {
+                const std::string& uid = i < bucket->unique_ids.size() ? bucket->unique_ids[i] : "";
+                if (!PassesUidFilter(config.filter_unique_ids, uid))
+                    continue;
+                ++matched_entities;
+
+                const auto& entity = bucket->entities[i];
+                auto sc_it = cache.structs.find(entity.entity_type_id);
+                if (sc_it == cache.structs.end())
+                    continue;
+
+                std::string combined_key = uid;
+                combined_key += '\0';
+
+                bool has_all_props = true;
+                for (size_t p = 0; p < config.property_names.size(); ++p) {
+                    if (p > 0)
+                        combined_key += '|';
+
+                    auto prop_it = sc_it->second.properties.find(config.property_names[p]);
+                    if (prop_it == sc_it->second.properties.end()) {
+                        has_all_props = false;
+                        break;
+                    }
+                    combined_key += ExtractScalarAsString(entity, prop_it->second);
                 }
-                combined_key += ExtractScalarAsString(entity, prop_it->second);
-            }
 
-            if (has_all_props) {
-                ++entities_with_all_properties;
-                unique_combinations.insert(combined_key);
+                if (has_all_props) {
+                    ++entities_with_all_properties;
+                    unique_combinations.insert(combined_key);
+                }
             }
         }
-    }
 
-    // Step 2: Group identical property sets and count distinct contributing entities.
-    std::unordered_map<std::string, UniquePropertiesGroup> groups;
-
-    for (const auto& combined_key : unique_combinations) {
-        auto sep_pos = combined_key.find('\0');
-        std::string uid = combined_key.substr(0, sep_pos);
-        std::string props_key = combined_key.substr(sep_pos + 1);
-
-        auto& group = groups[props_key];
-        if (group.property_values.empty()) {
-            size_t start = 0;
-            for (size_t j = 0; j < config.property_names.size(); ++j) {
-                size_t pipe_pos = props_key.find('|', start);
-                if (pipe_pos == std::string::npos) {
-                    group.property_values.push_back(props_key.substr(start));
-                    start = props_key.size();
-                } else {
-                    group.property_values.push_back(props_key.substr(start, pipe_pos - start));
-                    start = pipe_pos + 1;
+        // Step 2: Group identical property sets and count distinct contributing entities.
+        std::unordered_map<std::string, UniquePropertiesGroup> groups;
+
+        for (const auto& combined_key : unique_combinations) {
+            auto sep_pos = combined_key.find('\0');
+            std::string uid = combined_key.substr(0, sep_pos);
+            std::string props_key = combined_key.substr(sep_pos + 1);
+
+            auto& group = groups[props_key];
+            if (group.property_values.empty()) {
+                size_t start = 0;
+                for (size_t j = 0; j < config.property_names.size(); ++j) {
+                    size_t pipe_pos = props_key.find('|', start);
+                    if (pipe_pos == std::string::npos) {
+                        group.property_values.push_back(props_key.substr(start));
+                        start = props_key.size();
+                    } else {
+                        group.property_values.push_back(props_key.substr(start, pipe_pos - start));
+                        start = pipe_pos + 1;
+                    }
                 }
             }
+            group.contributing_uids.push_back(uid);
+            group.count = static_cast<int32_t>(group.contributing_uids.size());
+        }
+
+        // Step 3: Finalize, sort, and explain empty outputs when nothing matched.
+        unique_props_result_.property_names = config.property_names;
+        unique_props_result_.groups.reserve(groups.size());
+        for (auto& [key, group] : groups) {
+            std::sort(group.contributing_uids.begin(), group.contributing_uids.end());
+            unique_props_result_.groups.push_back(std::move(group));
         }
-        group.contributing_uids.push_back(uid);
-        group.count = static_cast<int32_t>(group.contributing_uids.size());
-    }
 
-    // Step 3: Finalize, sort, and explain empty outputs when nothing matched.
-    unique_props_result_.property_names = config.property_names;
-    unique_props_result_.groups.reserve(groups.size());
-    for (auto& [key, group] : groups) {
-        std::sort(group.contributing_uids.begin(), group.contributing_uids.end());
-        unique_props_result_.groups.push_back(std::move(group));
+        std::sort(unique_props_result_.groups.begin(), unique_props_result_.groups.end(),
+                  [](const UniquePropertiesGroup& a, const UniquePropertiesGroup& b) { return a.count > b.count; });
+
+        unique_props_result_.is_complete = true;
+        progress_.store(1.0f);
+        if (frames_with_bucket == 0) {
+            unique_props_result_.error_message =
+                std::format("Selected bucket {} was not present in frames {}-{}.", BuildBucketDebugLabel(config),
+                            config.start_frame, config.end_frame);
+        } else if (matched_entities == 0) {
+            unique_props_result_.error_message = "No entities matched the selected filters in the scanned range.";
+        } else if (entities_with_all_properties == 0) {
+            unique_props_result_.error_message =
+                "None of the matched entities contained all requested scalar properties.";
+        }
+        SetStatus(std::format("Done. {} unique combinations found.", unique_props_result_.groups.size()));
     }
 
-    std::sort(unique_props_result_.groups.begin(), unique_props_result_.groups.end(),
-        [](const UniquePropertiesGroup& a, const UniquePropertiesGroup& b) {
-            return a.count > b.count;
-        });
+    // Tracks contiguous spans for each requested scalar property value per entity.
+    void AnalysisScanner::RunTrackProperty(const ScanConfig& config, VTX::IVtxReaderFacade* reader,
+                                           const VTX::PropertyAddressCache& cache, const VTX::FileFooter& footer) {
+        SetStatus("Tracking property changes...");
+
+        const int32_t total_range = config.end_frame - config.start_frame + 1;
+        int32_t frames_with_bucket = 0;
+        int32_t matched_entities = 0;
+        int32_t tracked_property_hits = 0;
+
+        // Step 1: Maintain one open span per entity/property pair while walking frames in order.
+        struct OpenSpan {
+            std::string value;
+            FrameRange range;
+        };
+        std::unordered_map<std::string, OpenSpan> open_spans;
+
+        auto make_span_key = [](const std::string& uid, const std::string& prop) {
+            return uid + '\0' + prop;
+        };
+
+        for (int32_t f = config.start_frame; f <= config.end_frame; ++f) {
+            if (cancel_requested_.load()) {
+                SetStatus("Cancelled.");
+                track_prop_result_.error_message = "Cancelled by user.";
+                return;
+            }
 
-    unique_props_result_.is_complete = true;
-    progress_.store(1.0f);
-    if (frames_with_bucket == 0) {
-        unique_props_result_.error_message = std::format(
-            "Selected bucket {} was not present in frames {}-{}.",
-            BuildBucketDebugLabel(config),
-            config.start_frame,
-            config.end_frame);
-    } else if (matched_entities == 0) {
-        unique_props_result_.error_message = "No entities matched the selected filters in the scanned range.";
-    } else if (entities_with_all_properties == 0) {
-        unique_props_result_.error_message = "None of the matched entities contained all requested scalar properties.";
-    }
-    SetStatus(std::format("Done. {} unique combinations found.", unique_props_result_.groups.size()));
-}
-
-// Tracks contiguous spans for each requested scalar property value per entity.
-void AnalysisScanner::RunTrackProperty(
-    const ScanConfig& config,
-    VTX::IVtxReaderFacade* reader,
-    const VTX::PropertyAddressCache& cache,
-    const VTX::FileFooter& footer)
-{
-    SetStatus("Tracking property changes...");
-
-    const int32_t total_range = config.end_frame - config.start_frame + 1;
-    int32_t frames_with_bucket = 0;
-    int32_t matched_entities = 0;
-    int32_t tracked_property_hits = 0;
-
-    // Step 1: Maintain one open span per entity/property pair while walking frames in order.
-    struct OpenSpan {
-        std::string value;
-        FrameRange range;
-    };
-    std::unordered_map<std::string, OpenSpan> open_spans;
-
-    auto make_span_key = [](const std::string& uid, const std::string& prop) {
-        return uid + '\0' + prop;
-    };
-
-    for (int32_t f = config.start_frame; f <= config.end_frame; ++f) {
-        if (cancel_requested_.load()) {
-            SetStatus("Cancelled.");
-            track_prop_result_.error_message = "Cancelled by user.";
-            return;
-        }
+            current_frame_.store(f);
+            progress_.store(static_cast<float>(f - config.start_frame + 1) / static_cast<float>(total_range));
+            SetStatus(std::format("Tracking property changes... frame {} / {}", f, config.end_frame));
+
+            const auto* frame = reader->GetFrameSync(f);
+            if (!frame)
+                continue;
+
+            const auto* bucket = ResolveScanBucket(*frame, config);
+            if (!bucket)
+                continue;
+            ++frames_with_bucket;
+
+            // Step 2: Update active spans with the values present in this frame.
+            std::unordered_set<std::string> active_keys;
+
+            for (size_t i = 0; i < bucket->entities.size(); ++i) {
+                const std::string& uid = i < bucket->unique_ids.size() ? bucket->unique_ids[i] : "";
+                if (!PassesUidFilter(config.filter_unique_ids, uid))
+                    continue;
+                ++matched_entities;
+
+                const auto& entity = bucket->entities[i];
+                auto sc_it = cache.structs.find(entity.entity_type_id);
+                if (sc_it == cache.structs.end())
+                    continue;
+
+                for (const auto& prop_name : config.property_names) {
+                    auto prop_it = sc_it->second.properties.find(prop_name);
+                    if (prop_it == sc_it->second.properties.end())
+                        continue;
+                    ++tracked_property_hits;
+
+                    std::string value = ExtractScalarAsString(entity, prop_it->second);
+                    std::string span_key = make_span_key(uid, prop_name);
+                    active_keys.insert(span_key);
+
+                    auto it = open_spans.find(span_key);
+                    if (it == open_spans.end()) {
+                        open_spans[span_key] = OpenSpan {
+                            .value = value,
+                            .range =
+                                FrameRange {
+                                    .start_frame = f,
+                                    .end_frame = f,
+                                    .start_game_time = GetGameTime(footer, f),
+                                    .end_game_time = GetGameTime(footer, f),
+                                },
+                        };
+                    } else if (it->second.value != value) {
+                        auto& old_span = it->second;
+                        track_prop_result_.spans.push_back(PropertyValueSpan {
+                            .unique_id = uid,
+                            .property_name = prop_name,
+                            .value = old_span.value,
+                            .range = old_span.range,
+                        });
+
+                        it->second = OpenSpan {
+                            .value = value,
+                            .range =
+                                FrameRange {
+                                    .start_frame = f,
+                                    .end_frame = f,
+                                    .start_game_time = GetGameTime(footer, f),
+                                    .end_game_time = GetGameTime(footer, f),
+                                },
+                        };
+                    } else {
+                        it->second.range.end_frame = f;
+                        it->second.range.end_game_time = GetGameTime(footer, f);
+                    }
+                }
+            }
 
-        current_frame_.store(f);
-        progress_.store(static_cast<float>(f - config.start_frame + 1) / static_cast<float>(total_range));
-        SetStatus(std::format("Tracking property changes... frame {} / {}", f, config.end_frame));
-
-        const auto* frame = reader->GetFrameSync(f);
-        if (!frame) continue;
-
-        const auto* bucket = ResolveScanBucket(*frame, config);
-        if (!bucket) continue;
-        ++frames_with_bucket;
-
-        // Step 2: Update active spans with the values present in this frame.
-        std::unordered_set<std::string> active_keys;
-
-        for (size_t i = 0; i < bucket->entities.size(); ++i) {
-            const std::string& uid = i < bucket->unique_ids.size() ? bucket->unique_ids[i] : "";
-            if (!PassesUidFilter(config.filter_unique_ids, uid)) continue;
-            ++matched_entities;
-
-            const auto& entity = bucket->entities[i];
-            auto sc_it = cache.structs.find(entity.entity_type_id);
-            if (sc_it == cache.structs.end()) continue;
-
-            for (const auto& prop_name : config.property_names) {
-                auto prop_it = sc_it->second.properties.find(prop_name);
-                if (prop_it == sc_it->second.properties.end()) continue;
-                ++tracked_property_hits;
-
-                std::string value = ExtractScalarAsString(entity, prop_it->second);
-                std::string span_key = make_span_key(uid, prop_name);
-                active_keys.insert(span_key);
-
-                auto it = open_spans.find(span_key);
-                if (it == open_spans.end()) {
-                    open_spans[span_key] = OpenSpan{
-                        .value = value,
-                        .range = FrameRange{
-                            .start_frame = f,
-                            .end_frame = f,
-                            .start_game_time = GetGameTime(footer, f),
-                            .end_game_time = GetGameTime(footer, f),
-                        },
-                    };
-                } else if (it->second.value != value) {
-                    auto& old_span = it->second;
-                    track_prop_result_.spans.push_back(PropertyValueSpan{
+            // Step 3: Close spans that are no longer present in the current frame.
+            for (auto it = open_spans.begin(); it != open_spans.end();) {
+                if (!active_keys.contains(it->first)) {
+                    auto sep_pos = it->first.find('\0');
+                    std::string uid = it->first.substr(0, sep_pos);
+                    std::string prop_name = it->first.substr(sep_pos + 1);
+
+                    track_prop_result_.spans.push_back(PropertyValueSpan {
                         .unique_id = uid,
                         .property_name = prop_name,
-                        .value = old_span.value,
-                        .range = old_span.range,
+                        .value = it->second.value,
+                        .range = it->second.range,
                     });
-
-                    it->second = OpenSpan{
-                        .value = value,
-                        .range = FrameRange{
-                            .start_frame = f,
-                            .end_frame = f,
-                            .start_game_time = GetGameTime(footer, f),
-                            .end_game_time = GetGameTime(footer, f),
-                        },
-                    };
+                    it = open_spans.erase(it);
                 } else {
-                    it->second.range.end_frame = f;
-                    it->second.range.end_game_time = GetGameTime(footer, f);
+                    ++it;
                 }
             }
         }
 
-        // Step 3: Close spans that are no longer present in the current frame.
-        for (auto it = open_spans.begin(); it != open_spans.end(); ) {
-            if (!active_keys.contains(it->first)) {
-                auto sep_pos = it->first.find('\0');
-                std::string uid = it->first.substr(0, sep_pos);
-                std::string prop_name = it->first.substr(sep_pos + 1);
-
-                track_prop_result_.spans.push_back(PropertyValueSpan{
-                    .unique_id = uid,
-                    .property_name = prop_name,
-                    .value = it->second.value,
-                    .range = it->second.range,
-                });
-                it = open_spans.erase(it);
-            } else {
-                ++it;
-            }
+        // Step 4: Flush the remaining spans and explain empty outputs clearly.
+        for (auto& [span_key, open_span] : open_spans) {
+            auto sep_pos = span_key.find('\0');
+            std::string uid = span_key.substr(0, sep_pos);
+            std::string prop_name = span_key.substr(sep_pos + 1);
+
+            track_prop_result_.spans.push_back(PropertyValueSpan {
+                .unique_id = uid,
+                .property_name = prop_name,
+                .value = open_span.value,
+                .range = open_span.range,
+            });
         }
-    }
-
-    // Step 4: Flush the remaining spans and explain empty outputs clearly.
-    for (auto& [span_key, open_span] : open_spans) {
-        auto sep_pos = span_key.find('\0');
-        std::string uid = span_key.substr(0, sep_pos);
-        std::string prop_name = span_key.substr(sep_pos + 1);
-
-        track_prop_result_.spans.push_back(PropertyValueSpan{
-            .unique_id = uid,
-            .property_name = prop_name,
-            .value = open_span.value,
-            .range = open_span.range,
-        });
-    }
 
-    std::sort(track_prop_result_.spans.begin(), track_prop_result_.spans.end(),
-        [](const PropertyValueSpan& a, const PropertyValueSpan& b) {
-            if (a.unique_id != b.unique_id) return a.unique_id < b.unique_id;
-            if (a.property_name != b.property_name) return a.property_name < b.property_name;
-            return a.range.start_frame < b.range.start_frame;
-        });
-
-    track_prop_result_.property_names = config.property_names;
-    track_prop_result_.is_complete = true;
-    progress_.store(1.0f);
-    if (frames_with_bucket == 0) {
-        track_prop_result_.error_message = std::format(
-            "Selected bucket {} was not present in frames {}-{}.",
-            BuildBucketDebugLabel(config),
-            config.start_frame,
-            config.end_frame);
-    } else if (matched_entities == 0) {
-        track_prop_result_.error_message = "No entities matched the selected filters in the scanned range.";
-    } else if (tracked_property_hits == 0) {
-        track_prop_result_.error_message = "None of the requested properties were found on the matched entities.";
+        std::sort(track_prop_result_.spans.begin(), track_prop_result_.spans.end(),
+                  [](const PropertyValueSpan& a, const PropertyValueSpan& b) {
+                      if (a.unique_id != b.unique_id)
+                          return a.unique_id < b.unique_id;
+                      if (a.property_name != b.property_name)
+                          return a.property_name < b.property_name;
+                      return a.range.start_frame < b.range.start_frame;
+                  });
+
+        track_prop_result_.property_names = config.property_names;
+        track_prop_result_.is_complete = true;
+        progress_.store(1.0f);
+        if (frames_with_bucket == 0) {
+            track_prop_result_.error_message =
+                std::format("Selected bucket {} was not present in frames {}-{}.", BuildBucketDebugLabel(config),
+                            config.start_frame, config.end_frame);
+        } else if (matched_entities == 0) {
+            track_prop_result_.error_message = "No entities matched the selected filters in the scanned range.";
+        } else if (tracked_property_hits == 0) {
+            track_prop_result_.error_message = "None of the requested properties were found on the matched entities.";
+        }
+        SetStatus(std::format("Done. {} value spans recorded.", track_prop_result_.spans.size()));
     }
-    SetStatus(std::format("Done. {} value spans recorded.", track_prop_result_.spans.size()));
-}
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/analysis_types.cpp b/tools/inspector/src/services/analysis_types.cpp
index b429000..9f81fac 100644
--- a/tools/inspector/src/services/analysis_types.cpp
+++ b/tools/inspector/src/services/analysis_types.cpp
@@ -8,185 +8,187 @@
 
 namespace VtxServices {
 
-namespace {
+    namespace {
 
-constexpr int64_t kTicksPerSecond = 10'000'000;
+        constexpr int64_t kTicksPerSecond = 10'000'000;
 
-// Converts game time ticks to seconds string with 2 decimal places.
-std::string GameTimeToSeconds(uint64_t ticks) {
-    double seconds = static_cast<double>(ticks) / static_cast<double>(kTicksPerSecond);
-    return std::format("{:.2f}s", seconds);
-}
+        // Converts game time ticks to seconds string with 2 decimal places.
+        std::string GameTimeToSeconds(uint64_t ticks) {
+            double seconds = static_cast<double>(ticks) / static_cast<double>(kTicksPerSecond);
+            return std::format("{:.2f}s", seconds);
+        }
 
-// Escapes a CSV field: wraps in quotes if it contains commas, quotes, or newlines.
-std::string CsvEscape(const std::string& field) {
-    if (field.find_first_of(",\"\n") == std::string::npos) {
-        return field;
-    }
-    std::string escaped = "\"";
-    for (char c : field) {
-        if (c == '"') escaped += "\"\"";
-        else escaped += c;
-    }
-    escaped += '"';
-    return escaped;
-}
+        // Escapes a CSV field: wraps in quotes if it contains commas, quotes, or newlines.
+        std::string CsvEscape(const std::string& field) {
+            if (field.find_first_of(",\"\n") == std::string::npos) {
+                return field;
+            }
+            std::string escaped = "\"";
+            for (char c : field) {
+                if (c == '"')
+                    escaped += "\"\"";
+                else
+                    escaped += c;
+            }
+            escaped += '"';
+            return escaped;
+        }
 
-} // namespace
+    } // namespace
 
-// -- Property value extraction --
+    // -- Property value extraction --
 
-std::string ExtractScalarAsString(
-    const VTX::PropertyContainer& entity,
-    const VTX::PropertyAddress& addr)
-{
-    if (!addr.IsValid() || addr.container_type != VTX::FieldContainerType::None) {
-        return "";
-    }
+    std::string ExtractScalarAsString(const VTX::PropertyContainer& entity, const VTX::PropertyAddress& addr) {
+        if (!addr.IsValid() || addr.container_type != VTX::FieldContainerType::None) {
+            return "";
+        }
 
-    auto idx = static_cast<size_t>(addr.index);
+        auto idx = static_cast<size_t>(addr.index);
 
-    switch (addr.type_id) {
+        switch (addr.type_id) {
         case VTX::FieldType::Bool:
-            if (idx >= entity.bool_properties.size()) return "";
+            if (idx >= entity.bool_properties.size())
+                return "";
             return entity.bool_properties[idx] ? "true" : "false";
         case VTX::FieldType::Int32:
         case VTX::FieldType::Enum:
-            if (idx >= entity.int32_properties.size()) return "";
+            if (idx >= entity.int32_properties.size())
+                return "";
             return std::to_string(entity.int32_properties[idx]);
         case VTX::FieldType::Int64:
-            if (idx >= entity.int64_properties.size()) return "";
+            if (idx >= entity.int64_properties.size())
+                return "";
             return std::to_string(entity.int64_properties[idx]);
         case VTX::FieldType::Float:
-            if (idx >= entity.float_properties.size()) return "";
+            if (idx >= entity.float_properties.size())
+                return "";
             return std::format("{:.6g}", entity.float_properties[idx]);
         case VTX::FieldType::Double:
-            if (idx >= entity.double_properties.size()) return "";
+            if (idx >= entity.double_properties.size())
+                return "";
             return std::format("{:.6g}", entity.double_properties[idx]);
         case VTX::FieldType::String:
-            if (idx >= entity.string_properties.size()) return "";
+            if (idx >= entity.string_properties.size())
+                return "";
             return entity.string_properties[idx];
         case VTX::FieldType::Vector:
-            if (idx >= entity.vector_properties.size()) return "";
-            return std::format("({:.2f},{:.2f},{:.2f})",
-                entity.vector_properties[idx].x,
-                entity.vector_properties[idx].y,
-                entity.vector_properties[idx].z);
+            if (idx >= entity.vector_properties.size())
+                return "";
+            return std::format("({:.2f},{:.2f},{:.2f})", entity.vector_properties[idx].x,
+                               entity.vector_properties[idx].y, entity.vector_properties[idx].z);
         case VTX::FieldType::Quat:
-            if (idx >= entity.quat_properties.size()) return "";
-            return std::format("({:.4f},{:.4f},{:.4f},{:.4f})",
-                entity.quat_properties[idx].x,
-                entity.quat_properties[idx].y,
-                entity.quat_properties[idx].z,
-                entity.quat_properties[idx].w);
+            if (idx >= entity.quat_properties.size())
+                return "";
+            return std::format("({:.4f},{:.4f},{:.4f},{:.4f})", entity.quat_properties[idx].x,
+                               entity.quat_properties[idx].y, entity.quat_properties[idx].z,
+                               entity.quat_properties[idx].w);
         case VTX::FieldType::Transform:
-            if (idx >= entity.transform_properties.size()) return "";
-            return std::format("T({:.2f},{:.2f},{:.2f})",
-                entity.transform_properties[idx].translation.x,
-                entity.transform_properties[idx].translation.y,
-                entity.transform_properties[idx].translation.z);
+            if (idx >= entity.transform_properties.size())
+                return "";
+            return std::format("T({:.2f},{:.2f},{:.2f})", entity.transform_properties[idx].translation.x,
+                               entity.transform_properties[idx].translation.y,
+                               entity.transform_properties[idx].translation.z);
         case VTX::FieldType::FloatRange:
-            if (idx >= entity.range_properties.size()) return "";
-            return std::format("[{:.2f}-{:.2f}]",
-                entity.range_properties[idx].min,
-                entity.range_properties[idx].max);
+            if (idx >= entity.range_properties.size())
+                return "";
+            return std::format("[{:.2f}-{:.2f}]", entity.range_properties[idx].min, entity.range_properties[idx].max);
         default:
             return "";
+        }
     }
-}
-
-// -- Formatting helpers --
 
-std::string FormatSingleFrameRange(const FrameRange& range) {
-    return std::format("[{}-{}]", range.start_frame, range.end_frame);
-}
+    // -- Formatting helpers --
 
-std::string FormatSingleGameTimeRange(const FrameRange& range) {
-    return std::format("[{}-{}]",
-        GameTimeToSeconds(range.start_game_time),
-        GameTimeToSeconds(range.end_game_time));
-}
-
-std::string FormatFrameRanges(const std::vector<FrameRange>& ranges) {
-    std::string result;
-    for (size_t i = 0; i < ranges.size(); ++i) {
-        if (i > 0) result += ", ";
-        result += FormatSingleFrameRange(ranges[i]);
+    std::string FormatSingleFrameRange(const FrameRange& range) {
+        return std::format("[{}-{}]", range.start_frame, range.end_frame);
     }
-    return result;
-}
-
-std::string FormatGameTimeRanges(const std::vector<FrameRange>& ranges) {
-    std::string result;
-    for (size_t i = 0; i < ranges.size(); ++i) {
-        if (i > 0) result += ", ";
-        result += FormatSingleGameTimeRange(ranges[i]);
+
+    std::string FormatSingleGameTimeRange(const FrameRange& range) {
+        return std::format("[{}-{}]", GameTimeToSeconds(range.start_game_time), GameTimeToSeconds(range.end_game_time));
     }
-    return result;
-}
 
-// -- CSV export --
+    std::string FormatFrameRanges(const std::vector<FrameRange>& ranges) {
+        std::string result;
+        for (size_t i = 0; i < ranges.size(); ++i) {
+            if (i > 0)
+                result += ", ";
+            result += FormatSingleFrameRange(ranges[i]);
+        }
+        return result;
+    }
 
-bool ExportEntityLifeTimeCsv(const std::string& path, const EntityLifeTimeResult& result) {
-    std::ofstream file(path);
-    if (!file.is_open()) return false;
+    std::string FormatGameTimeRanges(const std::vector<FrameRange>& ranges) {
+        std::string result;
+        for (size_t i = 0; i < ranges.size(); ++i) {
+            if (i > 0)
+                result += ", ";
+            result += FormatSingleGameTimeRange(ranges[i]);
+        }
+        return result;
+    }
 
-    file << "UniqueId,TypeName,TypeId,RangesFrame,RangesGameTime\n";
+    // -- CSV export --
 
-    for (const auto& entry : result.entries) {
-        file << CsvEscape(entry.unique_id) << ","
-             << CsvEscape(entry.type_name) << ","
-             << entry.type_id << ","
-             << CsvEscape(FormatFrameRanges(entry.ranges)) << ","
-             << CsvEscape(FormatGameTimeRanges(entry.ranges)) << "\n";
-    }
+    bool ExportEntityLifeTimeCsv(const std::string& path, const EntityLifeTimeResult& result) {
+        std::ofstream file(path);
+        if (!file.is_open())
+            return false;
 
-    return file.good();
-}
+        file << "UniqueId,TypeName,TypeId,RangesFrame,RangesGameTime\n";
 
-bool ExportUniquePropertiesCsv(const std::string& path, const UniquePropertiesResult& result) {
-    std::ofstream file(path);
-    if (!file.is_open()) return false;
+        for (const auto& entry : result.entries) {
+            file << CsvEscape(entry.unique_id) << "," << CsvEscape(entry.type_name) << "," << entry.type_id << ","
+                 << CsvEscape(FormatFrameRanges(entry.ranges)) << "," << CsvEscape(FormatGameTimeRanges(entry.ranges))
+                 << "\n";
+        }
 
-    // Header: Prop1,Prop2,...,Count,UniqueIds
-    for (const auto& name : result.property_names) {
-        file << CsvEscape(name) << ",";
+        return file.good();
     }
-    file << "Count,UniqueIds\n";
 
-    for (const auto& group : result.groups) {
-        for (const auto& val : group.property_values) {
-            file << CsvEscape(val) << ",";
-        }
-        file << group.count << ",";
+    bool ExportUniquePropertiesCsv(const std::string& path, const UniquePropertiesResult& result) {
+        std::ofstream file(path);
+        if (!file.is_open())
+            return false;
 
-        // Semicolon-separated UIDs
-        std::string uids;
-        for (size_t i = 0; i < group.contributing_uids.size(); ++i) {
-            if (i > 0) uids += ";";
-            uids += group.contributing_uids[i];
+        // Header: Prop1,Prop2,...,Count,UniqueIds
+        for (const auto& name : result.property_names) {
+            file << CsvEscape(name) << ",";
+        }
+        file << "Count,UniqueIds\n";
+
+        for (const auto& group : result.groups) {
+            for (const auto& val : group.property_values) {
+                file << CsvEscape(val) << ",";
+            }
+            file << group.count << ",";
+
+            // Semicolon-separated UIDs
+            std::string uids;
+            for (size_t i = 0; i < group.contributing_uids.size(); ++i) {
+                if (i > 0)
+                    uids += ";";
+                uids += group.contributing_uids[i];
+            }
+            file << CsvEscape(uids) << "\n";
         }
-        file << CsvEscape(uids) << "\n";
+
+        return file.good();
     }
 
-    return file.good();
-}
+    bool ExportTrackPropertyCsv(const std::string& path, const TrackPropertyResult& result) {
+        std::ofstream file(path);
+        if (!file.is_open())
+            return false;
 
-bool ExportTrackPropertyCsv(const std::string& path, const TrackPropertyResult& result) {
-    std::ofstream file(path);
-    if (!file.is_open()) return false;
+        file << "UniqueId,Property,Value,RangeFrame,RangeGameTime\n";
 
-    file << "UniqueId,Property,Value,RangeFrame,RangeGameTime\n";
+        for (const auto& span : result.spans) {
+            file << CsvEscape(span.unique_id) << "," << CsvEscape(span.property_name) << "," << CsvEscape(span.value)
+                 << "," << CsvEscape(FormatSingleFrameRange(span.range)) << ","
+                 << CsvEscape(FormatSingleGameTimeRange(span.range)) << "\n";
+        }
 
-    for (const auto& span : result.spans) {
-        file << CsvEscape(span.unique_id) << ","
-             << CsvEscape(span.property_name) << ","
-             << CsvEscape(span.value) << ","
-             << CsvEscape(FormatSingleFrameRange(span.range)) << ","
-             << CsvEscape(FormatSingleGameTimeRange(span.range)) << "\n";
+        return file.good();
     }
 
-    return file.good();
-}
-
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/entity_inspector_view_service.cpp b/tools/inspector/src/services/entity_inspector_view_service.cpp
index 7468caf..da357ec 100644
--- a/tools/inspector/src/services/entity_inspector_view_service.cpp
+++ b/tools/inspector/src/services/entity_inspector_view_service.cpp
@@ -5,1287 +5,1002 @@
 
 namespace VtxServices {
 
-namespace {
-
-using Node = EntityPropertyNode;
-
-void BuildPropertyNodesRecursive(
-    const VTX::PropertyContainer& pc,
-    const VTX::PropertyAddressCache* global_cache,
-    const std::string& id_prefix,
-    std::vector<Node>& out_nodes);
-
-Node MakeGroupNode(const std::string& id, const std::string& label, bool open_by_default = true) {
-    Node node;
-    node.id = id;
-    node.label = label;
-    node.open_by_default = open_by_default;
-    return node;
-}
-
-Node MakePropertyNode(
-    const std::string& id,
-    const std::string& label,
-    const std::string& value,
-    const std::string& raw_value,
-    const std::string& struct_name,
-    int schema_index,
-    VTX::FieldType schema_type,
-    VTX::FieldContainerType schema_container_type) {
-    Node node;
-    node.id = id;
-    node.label = label;
-    node.value = value;
-    node.raw_value = raw_value;
-    node.struct_name = struct_name;
-    node.schema_index = schema_index;
-    node.schema_type = schema_type;
-    node.schema_container_type = schema_container_type;
-    node.is_property = true;
-    return node;
-}
-
-void AttachSchemaLookup(
-    Node& node,
-    const std::string& struct_name,
-    int schema_index,
-    VTX::FieldType schema_type,
-    VTX::FieldContainerType schema_container_type,
-    bool schema_focus_on_secondary_click = false) {
-    node.struct_name = struct_name;
-    node.schema_index = schema_index;
-    node.schema_type = schema_type;
-    node.schema_container_type = schema_container_type;
-    node.schema_focus_on_secondary_click = schema_focus_on_secondary_click;
-}
-
-const VTX::PropertyAddress* FindSchemaAddress(
-    const VTX::StructSchemaCache* struct_cache,
-    VTX::FieldType expected_type,
-    VTX::FieldContainerType container_type,
-    size_t index) {
-    if (!struct_cache) {
-        return nullptr;
-    }
+    namespace {
+
+        using Node = EntityPropertyNode;
 
-    const auto exact_it = struct_cache->names_by_lookup_key.find(
-        VTX::MakePropertyLookupKey(static_cast<int32_t>(index), expected_type, container_type));
-    if (exact_it != struct_cache->names_by_lookup_key.end()) {
-        const auto property_it = struct_cache->properties.find(exact_it->second);
-        if (property_it != struct_cache->properties.end()) {
-            return &property_it->second;
+        void BuildPropertyNodesRecursive(const VTX::PropertyContainer& pc,
+                                         const VTX::PropertyAddressCache* global_cache, const std::string& id_prefix,
+                                         std::vector<Node>& out_nodes);
+
+        Node MakeGroupNode(const std::string& id, const std::string& label, bool open_by_default = true) {
+            Node node;
+            node.id = id;
+            node.label = label;
+            node.open_by_default = open_by_default;
+            return node;
         }
-    }
 
-    if (expected_type == VTX::FieldType::Int32) {
-        const auto enum_it = struct_cache->names_by_lookup_key.find(
-            VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Enum, container_type));
-        if (enum_it != struct_cache->names_by_lookup_key.end()) {
-            const auto property_it = struct_cache->properties.find(enum_it->second);
-            if (property_it != struct_cache->properties.end()) {
-                return &property_it->second;
-            }
+        Node MakePropertyNode(const std::string& id, const std::string& label, const std::string& value,
+                              const std::string& raw_value, const std::string& struct_name, int schema_index,
+                              VTX::FieldType schema_type, VTX::FieldContainerType schema_container_type) {
+            Node node;
+            node.id = id;
+            node.label = label;
+            node.value = value;
+            node.raw_value = raw_value;
+            node.struct_name = struct_name;
+            node.schema_index = schema_index;
+            node.schema_type = schema_type;
+            node.schema_container_type = schema_container_type;
+            node.is_property = true;
+            return node;
         }
 
-        const auto int8_it = struct_cache->names_by_lookup_key.find(
-            VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Int8, container_type));
-        if (int8_it != struct_cache->names_by_lookup_key.end()) {
-            const auto property_it = struct_cache->properties.find(int8_it->second);
-            if (property_it != struct_cache->properties.end()) {
-                return &property_it->second;
-            }
+        void AttachSchemaLookup(Node& node, const std::string& struct_name, int schema_index,
+                                VTX::FieldType schema_type, VTX::FieldContainerType schema_container_type,
+                                bool schema_focus_on_secondary_click = false) {
+            node.struct_name = struct_name;
+            node.schema_index = schema_index;
+            node.schema_type = schema_type;
+            node.schema_container_type = schema_container_type;
+            node.schema_focus_on_secondary_click = schema_focus_on_secondary_click;
         }
-    }
 
-    return nullptr;
-}
+        const VTX::PropertyAddress* FindSchemaAddress(const VTX::StructSchemaCache* struct_cache,
+                                                      VTX::FieldType expected_type,
+                                                      VTX::FieldContainerType container_type, size_t index) {
+            if (!struct_cache) {
+                return nullptr;
+            }
 
-void AttachSchemaPropertyLabel(
-    Node& node,
-    const std::string& parent_struct_name,
-    const std::string& property_name,
-    size_t index) {
-    if (property_name.empty()) {
-        return;
-    }
+            const auto exact_it = struct_cache->names_by_lookup_key.find(
+                VTX::MakePropertyLookupKey(static_cast<int32_t>(index), expected_type, container_type));
+            if (exact_it != struct_cache->names_by_lookup_key.end()) {
+                const auto property_it = struct_cache->properties.find(exact_it->second);
+                if (property_it != struct_cache->properties.end()) {
+                    return &property_it->second;
+                }
+            }
 
-    node.schema_label = property_name + " [" + std::to_string(index) + "]";
-    node.schema_focus_struct_name = parent_struct_name;
-    node.schema_focus_property_name = property_name;
-    node.schema_focus_on_secondary_click = true;
-}
-
-void AttachSchemaStructLabel(
-    Node& node,
-    const std::string& child_struct_name,
-    const std::string& label) {
-    if (child_struct_name.empty()) {
-        return;
-    }
+            if (expected_type == VTX::FieldType::Int32) {
+                const auto enum_it = struct_cache->names_by_lookup_key.find(
+                    VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Enum, container_type));
+                if (enum_it != struct_cache->names_by_lookup_key.end()) {
+                    const auto property_it = struct_cache->properties.find(enum_it->second);
+                    if (property_it != struct_cache->properties.end()) {
+                        return &property_it->second;
+                    }
+                }
 
-    node.schema_label = label;
-    node.schema_focus_struct_name = child_struct_name;
-    node.schema_focus_on_secondary_click = true;
-}
-
-// Checks whether a schema-addressed field currently has any stored value in the container.
-bool HasFieldValue(const VTX::PropertyContainer& pc, const VTX::PropertyAddress& address) {
-    const auto has_index = [index = address.index](size_t size) {
-        return index >= 0 && static_cast<size_t>(index) < size;
-    };
-    const auto has_subarray_slot = [index = address.index](const auto& flat_array) {
-        return index >= 0 &&
-            static_cast<size_t>(index) < flat_array.SubArrayCount();
-    };
-
-    if (address.container_type == VTX::FieldContainerType::Array) {
-        switch (address.type_id) {
-            case VTX::FieldType::Int8:       return has_subarray_slot(pc.byte_array_properties) || has_subarray_slot(pc.int32_arrays);
-            case VTX::FieldType::Int32:
-            case VTX::FieldType::Enum:       return has_subarray_slot(pc.int32_arrays);
-            case VTX::FieldType::Int64:      return has_subarray_slot(pc.int64_arrays);
-            case VTX::FieldType::Float:      return has_subarray_slot(pc.float_arrays);
-            case VTX::FieldType::Double:     return has_subarray_slot(pc.double_arrays);
-            case VTX::FieldType::Bool:       return has_subarray_slot(pc.bool_arrays);
-            case VTX::FieldType::String:     return has_subarray_slot(pc.string_arrays);
-            case VTX::FieldType::Vector:     return has_subarray_slot(pc.vector_arrays);
-            case VTX::FieldType::Quat:       return has_subarray_slot(pc.quat_arrays);
-            case VTX::FieldType::Transform:  return has_subarray_slot(pc.transform_arrays);
-            case VTX::FieldType::FloatRange: return has_subarray_slot(pc.range_arrays);
-            case VTX::FieldType::Struct:     return has_subarray_slot(pc.any_struct_arrays);
-            case VTX::FieldType::None:
-            default:                         return false;
-        }
-    }
+                const auto int8_it = struct_cache->names_by_lookup_key.find(
+                    VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Int8, container_type));
+                if (int8_it != struct_cache->names_by_lookup_key.end()) {
+                    const auto property_it = struct_cache->properties.find(int8_it->second);
+                    if (property_it != struct_cache->properties.end()) {
+                        return &property_it->second;
+                    }
+                }
+            }
 
-    if (address.container_type == VTX::FieldContainerType::Map) {
-        if (address.type_id != VTX::FieldType::Struct) {
-            return false;
+            return nullptr;
         }
-        return has_index(pc.map_properties.size());
-    }
 
-    switch (address.type_id) {
-        case VTX::FieldType::Int8:
-        case VTX::FieldType::Int32:
-        case VTX::FieldType::Enum:       return has_index(pc.int32_properties.size());
-        case VTX::FieldType::Int64:      return has_index(pc.int64_properties.size());
-        case VTX::FieldType::Float:      return has_index(pc.float_properties.size());
-        case VTX::FieldType::Double:     return has_index(pc.double_properties.size());
-        case VTX::FieldType::Bool:       return has_index(pc.bool_properties.size());
-        case VTX::FieldType::String:     return has_index(pc.string_properties.size());
-        case VTX::FieldType::Vector:     return has_index(pc.vector_properties.size());
-        case VTX::FieldType::Quat:       return has_index(pc.quat_properties.size());
-        case VTX::FieldType::Transform:  return has_index(pc.transform_properties.size());
-        case VTX::FieldType::FloatRange: return has_index(pc.range_properties.size());
-        case VTX::FieldType::Struct:
-            return has_index(pc.any_struct_properties.size()) &&
-                pc.any_struct_properties[static_cast<size_t>(address.index)].entity_type_id != -1;
-        case VTX::FieldType::None:
-        default:
-            return false;
-    }
-}
-
-// Produces schema field names that currently have no value stored in the selected entity.
-std::vector<std::string> BuildMissingFieldNames(
-    const VTX::PropertyContainer& pc,
-    const VTX::StructSchemaCache* struct_cache) {
-    std::vector<std::string> missing_fields;
-    if (!struct_cache) {
-        return missing_fields;
-    }
+        void AttachSchemaPropertyLabel(Node& node, const std::string& parent_struct_name,
+                                       const std::string& property_name, size_t index) {
+            if (property_name.empty()) {
+                return;
+            }
 
-    const auto ordered_properties = struct_cache->GetPropertiesInOrder();
-    missing_fields.reserve(ordered_properties.size());
-    for (const auto& ordered_property : ordered_properties) {
-        if (!ordered_property.address) {
-            continue;
+            node.schema_label = property_name + " [" + std::to_string(index) + "]";
+            node.schema_focus_struct_name = parent_struct_name;
+            node.schema_focus_property_name = property_name;
+            node.schema_focus_on_secondary_click = true;
         }
-        if (!HasFieldValue(pc, *ordered_property.address)) {
-            missing_fields.emplace_back(ordered_property.name);
+
+        void AttachSchemaStructLabel(Node& node, const std::string& child_struct_name, const std::string& label) {
+            if (child_struct_name.empty()) {
+                return;
+            }
+
+            node.schema_label = label;
+            node.schema_focus_struct_name = child_struct_name;
+            node.schema_focus_on_secondary_click = true;
         }
-    }
-    return missing_fields;
-}
-
-template <typename T, typename DisplayFormatFn, typename RawFormatFn>
-void AppendPrimitiveNodes(
-    std::vector<Node>& parent_children,
-    const std::string& id_prefix,
-    const char* group_title,
-    const std::vector<T>& values,
-    VTX::FieldType type_id,
-    const VTX::StructSchemaCache* struct_cache,
-    const std::string& struct_name,
-    const char* label_prefix,
-    DisplayFormatFn&& display_format_fn,
-    RawFormatFn&& raw_format_fn) {
-    if (values.empty()) {
-        return;
-    }
 
-    Node group = MakeGroupNode(
-        id_prefix + "/" + group_title,
-        std::string(group_title) + " (" + std::to_string(values.size()) + ")");
-
-    group.children.reserve(values.size());
-    for (size_t i = 0; i < values.size(); ++i) {
-        char label[64];
-        std::snprintf(label, sizeof(label), "%s [%zu]", label_prefix, i);
-        group.children.push_back(MakePropertyNode(
-            group.id + "/" + std::to_string(i),
-            label,
-            display_format_fn(values[i]),
-            raw_format_fn(values[i]),
-            struct_name,
-            static_cast<int>(i),
-            type_id,
-            VTX::FieldContainerType::None));
-    }
+        // Checks whether a schema-addressed field currently has any stored value in the container.
+        bool HasFieldValue(const VTX::PropertyContainer& pc, const VTX::PropertyAddress& address) {
+            const auto has_index = [index = address.index](size_t size) {
+                return index >= 0 && static_cast<size_t>(index) < size;
+            };
+            const auto has_subarray_slot = [index = address.index](const auto& flat_array) {
+                return index >= 0 && static_cast<size_t>(index) < flat_array.SubArrayCount();
+            };
+
+            if (address.container_type == VTX::FieldContainerType::Array) {
+                switch (address.type_id) {
+                case VTX::FieldType::Int8:
+                    return has_subarray_slot(pc.byte_array_properties) || has_subarray_slot(pc.int32_arrays);
+                case VTX::FieldType::Int32:
+                case VTX::FieldType::Enum:
+                    return has_subarray_slot(pc.int32_arrays);
+                case VTX::FieldType::Int64:
+                    return has_subarray_slot(pc.int64_arrays);
+                case VTX::FieldType::Float:
+                    return has_subarray_slot(pc.float_arrays);
+                case VTX::FieldType::Double:
+                    return has_subarray_slot(pc.double_arrays);
+                case VTX::FieldType::Bool:
+                    return has_subarray_slot(pc.bool_arrays);
+                case VTX::FieldType::String:
+                    return has_subarray_slot(pc.string_arrays);
+                case VTX::FieldType::Vector:
+                    return has_subarray_slot(pc.vector_arrays);
+                case VTX::FieldType::Quat:
+                    return has_subarray_slot(pc.quat_arrays);
+                case VTX::FieldType::Transform:
+                    return has_subarray_slot(pc.transform_arrays);
+                case VTX::FieldType::FloatRange:
+                    return has_subarray_slot(pc.range_arrays);
+                case VTX::FieldType::Struct:
+                    return has_subarray_slot(pc.any_struct_arrays);
+                case VTX::FieldType::None:
+                default:
+                    return false;
+                }
+            }
 
-    parent_children.push_back(std::move(group));
-}
-
-template <typename FlatArrayT, typename DisplayFormatFn, typename RawFormatFn>
-void AppendFlatArrayGroup(
-    std::vector<Node>& parent_children,
-    const std::string& id_prefix,
-    const char* group_title,
-    const FlatArrayT& flat_array,
-    VTX::FieldType type_id,
-    const VTX::StructSchemaCache* struct_cache,
-    const std::string& struct_name,
-    DisplayFormatFn&& display_format_fn,
-    RawFormatFn&& raw_format_fn) {
-    if (flat_array.SubArrayCount() == 0) {
-        return;
-    }
+            if (address.container_type == VTX::FieldContainerType::Map) {
+                if (address.type_id != VTX::FieldType::Struct) {
+                    return false;
+                }
+                return has_index(pc.map_properties.size());
+            }
 
-    Node arrays_group = MakeGroupNode(
-        id_prefix + "/" + group_title,
-        std::string(group_title) + " (" + std::to_string(flat_array.SubArrayCount()) + " arrays)");
-
-    arrays_group.children.reserve(flat_array.SubArrayCount());
-    for (size_t i = 0; i < flat_array.SubArrayCount(); ++i) {
-        const auto sub_array = flat_array.GetSubArray(i);
-        Node array_node = MakeGroupNode(
-            arrays_group.id + "/" + std::to_string(i),
-            "Array [" + std::to_string(i) + "] (" + std::to_string(sub_array.size()) + " items)");
-        const std::string array_schema_name = EntityInspectorViewService::ResolveSchemaName(
-            struct_cache,
-            type_id,
-            VTX::FieldContainerType::Array,
-            i);
-        AttachSchemaLookup(
-            array_node,
-            struct_name,
-            static_cast<int>(i),
-            type_id,
-            VTX::FieldContainerType::Array,
-            true);
-        AttachSchemaPropertyLabel(array_node, struct_name, array_schema_name, i);
-
-        for (size_t j = 0; j < sub_array.size(); ++j) {
-            char label[64];
-            std::snprintf(label, sizeof(label), "Item [%zu]", j);
-            Node item_node = MakePropertyNode(
-                array_node.id + "/" + std::to_string(j),
-                label,
-                display_format_fn(sub_array[j]),
-                raw_format_fn(sub_array[j]),
-                struct_name,
-                static_cast<int>(i),
-                type_id,
-                VTX::FieldContainerType::Array);
-            if (!array_schema_name.empty()) {
-                item_node.schema_label = std::string(label);
+            switch (address.type_id) {
+            case VTX::FieldType::Int8:
+            case VTX::FieldType::Int32:
+            case VTX::FieldType::Enum:
+                return has_index(pc.int32_properties.size());
+            case VTX::FieldType::Int64:
+                return has_index(pc.int64_properties.size());
+            case VTX::FieldType::Float:
+                return has_index(pc.float_properties.size());
+            case VTX::FieldType::Double:
+                return has_index(pc.double_properties.size());
+            case VTX::FieldType::Bool:
+                return has_index(pc.bool_properties.size());
+            case VTX::FieldType::String:
+                return has_index(pc.string_properties.size());
+            case VTX::FieldType::Vector:
+                return has_index(pc.vector_properties.size());
+            case VTX::FieldType::Quat:
+                return has_index(pc.quat_properties.size());
+            case VTX::FieldType::Transform:
+                return has_index(pc.transform_properties.size());
+            case VTX::FieldType::FloatRange:
+                return has_index(pc.range_properties.size());
+            case VTX::FieldType::Struct:
+                return has_index(pc.any_struct_properties.size()) &&
+                       pc.any_struct_properties[static_cast<size_t>(address.index)].entity_type_id != -1;
+            case VTX::FieldType::None:
+            default:
+                return false;
             }
-            array_node.children.push_back(std::move(item_node));
-        }
-        if (sub_array.empty()) {
-            array_node.children.push_back(MakeGroupNode(array_node.id + "/empty", "Empty Array"));
         }
 
-        arrays_group.children.push_back(std::move(array_node));
-    }
+        // Produces schema field names that currently have no value stored in the selected entity.
+        std::vector<std::string> BuildMissingFieldNames(const VTX::PropertyContainer& pc,
+                                                        const VTX::StructSchemaCache* struct_cache) {
+            std::vector<std::string> missing_fields;
+            if (!struct_cache) {
+                return missing_fields;
+            }
 
-    parent_children.push_back(std::move(arrays_group));
-}
-
-void AppendMapEntries(
-    Node& parent_node,
-    const VTX::MapContainer& map_cont,
-    const VTX::PropertyAddressCache* global_cache) {
-    parent_node.children.reserve(map_cont.keys.size());
-    for (size_t j = 0; j < map_cont.keys.size(); ++j) {
-        Node key_node = MakeGroupNode(
-            parent_node.id + "/" + std::to_string(j),
-            "Key: " + map_cont.keys[j]);
-        if (j < map_cont.values.size()) {
-            const auto& map_value = map_cont.values[j];
-            const std::string nested_struct_name = EntityInspectorViewService::ResolveStructName(
-                EntityInspectorViewService::ResolveStructCache(global_cache, map_value.entity_type_id));
-            if (!nested_struct_name.empty()) {
-                AttachSchemaStructLabel(
-                    key_node,
-                    nested_struct_name,
-                    nested_struct_name + " [" + map_cont.keys[j] + "]");
+            const auto ordered_properties = struct_cache->GetPropertiesInOrder();
+            missing_fields.reserve(ordered_properties.size());
+            for (const auto& ordered_property : ordered_properties) {
+                if (!ordered_property.address) {
+                    continue;
+                }
+                if (!HasFieldValue(pc, *ordered_property.address)) {
+                    missing_fields.emplace_back(ordered_property.name);
+                }
             }
-            BuildPropertyNodesRecursive(map_cont.values[j], global_cache, key_node.id, key_node.children);
+            return missing_fields;
         }
-        parent_node.children.push_back(std::move(key_node));
-    }
-}
-
-void BuildPropertyNodesRecursive(
-    const VTX::PropertyContainer& pc,
-    const VTX::PropertyAddressCache* global_cache,
-    const std::string& id_prefix,
-    std::vector<Node>& out_nodes) {
-    const VTX::StructSchemaCache* struct_cache =
-        EntityInspectorViewService::ResolveStructCache(global_cache, pc.entity_type_id);
-    const std::string struct_name = EntityInspectorViewService::ResolveStructName(struct_cache);
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Booleans",
-        pc.bool_properties,
-        VTX::FieldType::Bool,
-        struct_cache,
-        struct_name,
-        "Bool",
-        [](bool value) { return value ? "True" : "False"; },
-        [](bool value) { return value ? "True" : "False"; });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Int32",
-        pc.int32_properties,
-        VTX::FieldType::Int32,
-        struct_cache,
-        struct_name,
-        "Int32",
-        [](int32_t value) { return std::to_string(value); },
-        [](int32_t value) { return std::to_string(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Int64",
-        pc.int64_properties,
-        VTX::FieldType::Int64,
-        struct_cache,
-        struct_name,
-        "Int64",
-        [](int64_t value) { return std::to_string(value); },
-        [](int64_t value) { return std::to_string(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Floats",
-        pc.float_properties,
-        VTX::FieldType::Float,
-        struct_cache,
-        struct_name,
-        "Float",
-        [](float value) { return EntityInspectorViewService::FormatFloat(value); },
-        [](float value) { return EntityInspectorViewService::FormatRawFloat(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Doubles",
-        pc.double_properties,
-        VTX::FieldType::Double,
-        struct_cache,
-        struct_name,
-        "Double",
-        [](double value) { return EntityInspectorViewService::FormatDouble(value); },
-        [](double value) { return EntityInspectorViewService::FormatRawDouble(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Strings",
-        pc.string_properties,
-        VTX::FieldType::String,
-        struct_cache,
-        struct_name,
-        "String",
-        [](const std::string& value) { return value; },
-        [](const std::string& value) { return value; });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Vectors",
-        pc.vector_properties,
-        VTX::FieldType::Vector,
-        struct_cache,
-        struct_name,
-        "Vector",
-        [](const VTX::Vector& value) { return EntityInspectorViewService::FormatVector(value); },
-        [](const VTX::Vector& value) { return EntityInspectorViewService::FormatRawVector(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Quaternions",
-        pc.quat_properties,
-        VTX::FieldType::Quat,
-        struct_cache,
-        struct_name,
-        "Quat",
-        [](const VTX::Quat& value) { return EntityInspectorViewService::FormatQuat(value); },
-        [](const VTX::Quat& value) { return EntityInspectorViewService::FormatRawQuat(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Transforms",
-        pc.transform_properties,
-        VTX::FieldType::Transform,
-        struct_cache,
-        struct_name,
-        "Transform",
-        [](const VTX::Transform& value) { return EntityInspectorViewService::FormatTransform(value); },
-        [](const VTX::Transform& value) { return EntityInspectorViewService::FormatRawTransform(value); });
-
-    AppendPrimitiveNodes(
-        out_nodes,
-        id_prefix,
-        "Ranges",
-        pc.range_properties,
-        VTX::FieldType::FloatRange,
-        struct_cache,
-        struct_name,
-        "Range",
-        [](const VTX::FloatRange& value) { return EntityInspectorViewService::FormatRange(value); },
-        [](const VTX::FloatRange& value) { return EntityInspectorViewService::FormatRawRange(value); });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Byte Arrays",
-        pc.byte_array_properties,
-        VTX::FieldType::Int8,
-        struct_cache,
-        struct_name,
-        [](uint8_t value) {
-            char val[32];
-            std::snprintf(val, sizeof(val), "0x%02X", static_cast<unsigned int>(value));
-            return std::string(val);
-        },
-        [](uint8_t value) { return std::to_string(static_cast<unsigned int>(value)); });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Bool Arrays",
-        pc.bool_arrays,
-        VTX::FieldType::Bool,
-        struct_cache,
-        struct_name,
-        [](uint8_t value) { return value != 0 ? std::string("True") : std::string("False"); },
-        [](uint8_t value) { return value != 0 ? std::string("1") : std::string("0"); });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Int32 Arrays",
-        pc.int32_arrays,
-        VTX::FieldType::Int32,
-        struct_cache,
-        struct_name,
-        [](int32_t value) { return std::to_string(value); },
-        [](int32_t value) { return std::to_string(value); });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Int64 Arrays",
-        pc.int64_arrays,
-        VTX::FieldType::Int64,
-        struct_cache,
-        struct_name,
-        [](int64_t value) { return std::to_string(value); },
-        [](int64_t value) { return std::to_string(value); });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Float Arrays",
-        pc.float_arrays,
-        VTX::FieldType::Float,
-        struct_cache,
-        struct_name,
-        [](float value) {
-            return EntityInspectorViewService::FormatFloat(value);
-        },
-        [](float value) {
-            return EntityInspectorViewService::FormatRawFloat(value);
-        });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Double Arrays",
-        pc.double_arrays,
-        VTX::FieldType::Double,
-        struct_cache,
-        struct_name,
-        [](double value) {
-            return EntityInspectorViewService::FormatDouble(value);
-        },
-        [](double value) {
-            return EntityInspectorViewService::FormatRawDouble(value);
-        });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "String Arrays",
-        pc.string_arrays,
-        VTX::FieldType::String,
-        struct_cache,
-        struct_name,
-        [](const std::string& value) { return value; },
-        [](const std::string& value) { return value; });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Vector Arrays",
-        pc.vector_arrays,
-        VTX::FieldType::Vector,
-        struct_cache,
-        struct_name,
-        [](const VTX::Vector& value) {
-            return EntityInspectorViewService::FormatVector(value);
-        },
-        [](const VTX::Vector& value) {
-            return EntityInspectorViewService::FormatRawVector(value);
-        });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Quat Arrays",
-        pc.quat_arrays,
-        VTX::FieldType::Quat,
-        struct_cache,
-        struct_name,
-        [](const VTX::Quat& value) {
-            return EntityInspectorViewService::FormatQuat(value);
-        },
-        [](const VTX::Quat& value) {
-            return EntityInspectorViewService::FormatRawQuat(value);
-        });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Transform Arrays",
-        pc.transform_arrays,
-        VTX::FieldType::Transform,
-        struct_cache,
-        struct_name,
-        [](const VTX::Transform& value) {
-            return EntityInspectorViewService::FormatTransform(value);
-        },
-        [](const VTX::Transform& value) {
-            return EntityInspectorViewService::FormatRawTransform(value);
-        });
-
-    AppendFlatArrayGroup(
-        out_nodes,
-        id_prefix,
-        "Range Arrays",
-        pc.range_arrays,
-        VTX::FieldType::FloatRange,
-        struct_cache,
-        struct_name,
-        [](const VTX::FloatRange& value) {
-            return EntityInspectorViewService::FormatRange(value);
-        },
-        [](const VTX::FloatRange& value) {
-            return EntityInspectorViewService::FormatRawRange(value);
-        });
-
-    if (!pc.any_struct_properties.empty()) {
-        Node group = MakeGroupNode(
-            id_prefix + "/structs",
-            "Structs (" + std::to_string(pc.any_struct_properties.size()) + ")");
-
-        for (size_t i = 0; i < pc.any_struct_properties.size(); ++i) {
-            const auto& nested = pc.any_struct_properties[i];
-            
-            Node struct_node = MakeGroupNode(
-                group.id + "/" + std::to_string(i),
-                "Struct [" + std::to_string(i) + "] (Type ID: " + std::to_string(nested.entity_type_id) + ")");
-            const std::string struct_schema_name = EntityInspectorViewService::ResolveSchemaName(
-                struct_cache,
-                VTX::FieldType::Struct,
-                VTX::FieldContainerType::None,
-                i);
-            AttachSchemaLookup(
-                struct_node,
-                struct_name,
-                static_cast<int>(i),
-                VTX::FieldType::Struct,
-                VTX::FieldContainerType::None,
-                true);
-            AttachSchemaPropertyLabel(struct_node, struct_name, struct_schema_name, i);
-            BuildPropertyNodesRecursive(nested, global_cache, struct_node.id, struct_node.children);
-            group.children.push_back(std::move(struct_node));
+
+        template <typename T, typename DisplayFormatFn, typename RawFormatFn>
+        void AppendPrimitiveNodes(std::vector<Node>& parent_children, const std::string& id_prefix,
+                                  const char* group_title, const std::vector<T>& values, VTX::FieldType type_id,
+                                  const VTX::StructSchemaCache* struct_cache, const std::string& struct_name,
+                                  const char* label_prefix, DisplayFormatFn&& display_format_fn,
+                                  RawFormatFn&& raw_format_fn) {
+            if (values.empty()) {
+                return;
+            }
+
+            Node group = MakeGroupNode(id_prefix + "/" + group_title,
+                                       std::string(group_title) + " (" + std::to_string(values.size()) + ")");
+
+            group.children.reserve(values.size());
+            for (size_t i = 0; i < values.size(); ++i) {
+                char label[64];
+                std::snprintf(label, sizeof(label), "%s [%zu]", label_prefix, i);
+                group.children.push_back(MakePropertyNode(
+                    group.id + "/" + std::to_string(i), label, display_format_fn(values[i]), raw_format_fn(values[i]),
+                    struct_name, static_cast<int>(i), type_id, VTX::FieldContainerType::None));
+            }
+
+            parent_children.push_back(std::move(group));
         }
 
-        out_nodes.push_back(std::move(group));
-    }
+        template <typename FlatArrayT, typename DisplayFormatFn, typename RawFormatFn>
+        void AppendFlatArrayGroup(std::vector<Node>& parent_children, const std::string& id_prefix,
+                                  const char* group_title, const FlatArrayT& flat_array, VTX::FieldType type_id,
+                                  const VTX::StructSchemaCache* struct_cache, const std::string& struct_name,
+                                  DisplayFormatFn&& display_format_fn, RawFormatFn&& raw_format_fn) {
+            if (flat_array.SubArrayCount() == 0) {
+                return;
+            }
 
-    if (pc.any_struct_arrays.SubArrayCount() > 0) {
-        Node group = MakeGroupNode(
-            id_prefix + "/struct_arrays",
-            "Struct Arrays (" + std::to_string(pc.any_struct_arrays.SubArrayCount()) + " arrays)");
-
-        for (size_t i = 0; i < pc.any_struct_arrays.SubArrayCount(); ++i) {
-            const auto sub_array = pc.any_struct_arrays.GetSubArray(i);
-            const std::string array_schema_name = EntityInspectorViewService::ResolveSchemaName(
-                struct_cache,
-                VTX::FieldType::Struct,
-                VTX::FieldContainerType::Array,
-                i);
-            const int32_t nested_type_id = !sub_array.empty() ? sub_array.front().entity_type_id : -1;
-            Node array_node = MakeGroupNode(
-                group.id + "/" + std::to_string(i),
-                nested_type_id >= 0
-                    ? "Array [" + std::to_string(i) + "] (Type ID: " + std::to_string(nested_type_id) + ")"
-                    : "Array [" + std::to_string(i) + "] (" + std::to_string(sub_array.size()) + " structs)");
-            AttachSchemaLookup(
-                array_node,
-                struct_name,
-                static_cast<int>(i),
-                VTX::FieldType::Struct,
-                VTX::FieldContainerType::Array,
-                true);
-            AttachSchemaPropertyLabel(array_node, struct_name, array_schema_name, i);
-
-            const std::string nested_schema_struct_name = [&]() -> std::string {
-                const auto* address = FindSchemaAddress(
-                    struct_cache,
-                    VTX::FieldType::Struct,
-                    VTX::FieldContainerType::Array,
-                    i);
-                return address ? address->child_type_name : std::string{};
-            }();
-
-            for (size_t j = 0; j < sub_array.size(); ++j) {
-                const auto& nested = sub_array[j];
-                Node item_node = MakeGroupNode(
-                    array_node.id + "/" + std::to_string(j),
-                    "Item [" + std::to_string(j) + "]");
-                std::string nested_struct_name = EntityInspectorViewService::ResolveStructName(
-                    EntityInspectorViewService::ResolveStructCache(global_cache, nested.entity_type_id));
-                if (nested_struct_name.empty()) {
-                    nested_struct_name = nested_schema_struct_name;
+            Node arrays_group = MakeGroupNode(id_prefix + "/" + group_title,
+                                              std::string(group_title) + " (" +
+                                                  std::to_string(flat_array.SubArrayCount()) + " arrays)");
+
+            arrays_group.children.reserve(flat_array.SubArrayCount());
+            for (size_t i = 0; i < flat_array.SubArrayCount(); ++i) {
+                const auto sub_array = flat_array.GetSubArray(i);
+                Node array_node =
+                    MakeGroupNode(arrays_group.id + "/" + std::to_string(i),
+                                  "Array [" + std::to_string(i) + "] (" + std::to_string(sub_array.size()) + " items)");
+                const std::string array_schema_name = EntityInspectorViewService::ResolveSchemaName(
+                    struct_cache, type_id, VTX::FieldContainerType::Array, i);
+                AttachSchemaLookup(array_node, struct_name, static_cast<int>(i), type_id,
+                                   VTX::FieldContainerType::Array, true);
+                AttachSchemaPropertyLabel(array_node, struct_name, array_schema_name, i);
+
+                for (size_t j = 0; j < sub_array.size(); ++j) {
+                    char label[64];
+                    std::snprintf(label, sizeof(label), "Item [%zu]", j);
+                    Node item_node =
+                        MakePropertyNode(array_node.id + "/" + std::to_string(j), label,
+                                         display_format_fn(sub_array[j]), raw_format_fn(sub_array[j]), struct_name,
+                                         static_cast<int>(i), type_id, VTX::FieldContainerType::Array);
+                    if (!array_schema_name.empty()) {
+                        item_node.schema_label = std::string(label);
+                    }
+                    array_node.children.push_back(std::move(item_node));
                 }
-                if (!nested_struct_name.empty()) {
-                    AttachSchemaStructLabel(
-                        item_node,
-                        nested_struct_name,
-                        nested_struct_name + " [" + std::to_string(j) + "]");
+                if (sub_array.empty()) {
+                    array_node.children.push_back(MakeGroupNode(array_node.id + "/empty", "Empty Array"));
                 }
-                BuildPropertyNodesRecursive(nested, global_cache, item_node.id, item_node.children);
-                array_node.children.push_back(std::move(item_node));
-            }
-            if (sub_array.empty()) {
-                array_node.children.push_back(MakeGroupNode(array_node.id + "/empty", "Empty Array"));
+
+                arrays_group.children.push_back(std::move(array_node));
             }
 
-            group.children.push_back(std::move(array_node));
+            parent_children.push_back(std::move(arrays_group));
         }
 
-        out_nodes.push_back(std::move(group));
-    }
-
-    if (!pc.map_properties.empty()) {
-        Node group = MakeGroupNode(
-            id_prefix + "/maps",
-            "Maps (" + std::to_string(pc.map_properties.size()) + ")");
-
-        for (size_t i = 0; i < pc.map_properties.size(); ++i) {
-            const auto& map_cont = pc.map_properties[i];
-            Node map_node = MakeGroupNode(
-                group.id + "/" + std::to_string(i),
-                "Map [" + std::to_string(i) + "] (" + std::to_string(map_cont.keys.size()) + " pairs)");
-            const std::string map_schema_name = EntityInspectorViewService::ResolveSchemaName(
-                struct_cache,
-                VTX::FieldType::Struct,
-                VTX::FieldContainerType::Map,
-                i);
-            AttachSchemaPropertyLabel(map_node, struct_name, map_schema_name, i);
-            AppendMapEntries(map_node, map_cont, global_cache);
-
-            group.children.push_back(std::move(map_node));
+        void AppendMapEntries(Node& parent_node, const VTX::MapContainer& map_cont,
+                              const VTX::PropertyAddressCache* global_cache) {
+            parent_node.children.reserve(map_cont.keys.size());
+            for (size_t j = 0; j < map_cont.keys.size(); ++j) {
+                Node key_node = MakeGroupNode(parent_node.id + "/" + std::to_string(j), "Key: " + map_cont.keys[j]);
+                if (j < map_cont.values.size()) {
+                    const auto& map_value = map_cont.values[j];
+                    const std::string nested_struct_name = EntityInspectorViewService::ResolveStructName(
+                        EntityInspectorViewService::ResolveStructCache(global_cache, map_value.entity_type_id));
+                    if (!nested_struct_name.empty()) {
+                        AttachSchemaStructLabel(key_node, nested_struct_name,
+                                                nested_struct_name + " [" + map_cont.keys[j] + "]");
+                    }
+                    BuildPropertyNodesRecursive(map_cont.values[j], global_cache, key_node.id, key_node.children);
+                }
+                parent_node.children.push_back(std::move(key_node));
+            }
         }
 
-        out_nodes.push_back(std::move(group));
-    }
+        void BuildPropertyNodesRecursive(const VTX::PropertyContainer& pc,
+                                         const VTX::PropertyAddressCache* global_cache, const std::string& id_prefix,
+                                         std::vector<Node>& out_nodes) {
+            const VTX::StructSchemaCache* struct_cache =
+                EntityInspectorViewService::ResolveStructCache(global_cache, pc.entity_type_id);
+            const std::string struct_name = EntityInspectorViewService::ResolveStructName(struct_cache);
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Booleans", pc.bool_properties, VTX::FieldType::Bool, struct_cache, struct_name,
+                "Bool", [](bool value) { return value ? "True" : "False"; },
+                [](bool value) { return value ? "True" : "False"; });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Int32", pc.int32_properties, VTX::FieldType::Int32, struct_cache, struct_name,
+                "Int32", [](int32_t value) { return std::to_string(value); },
+                [](int32_t value) { return std::to_string(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Int64", pc.int64_properties, VTX::FieldType::Int64, struct_cache, struct_name,
+                "Int64", [](int64_t value) { return std::to_string(value); },
+                [](int64_t value) { return std::to_string(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Floats", pc.float_properties, VTX::FieldType::Float, struct_cache, struct_name,
+                "Float", [](float value) { return EntityInspectorViewService::FormatFloat(value); },
+                [](float value) { return EntityInspectorViewService::FormatRawFloat(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Doubles", pc.double_properties, VTX::FieldType::Double, struct_cache,
+                struct_name, "Double", [](double value) { return EntityInspectorViewService::FormatDouble(value); },
+                [](double value) { return EntityInspectorViewService::FormatRawDouble(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Strings", pc.string_properties, VTX::FieldType::String, struct_cache,
+                struct_name, "String", [](const std::string& value) { return value; },
+                [](const std::string& value) { return value; });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Vectors", pc.vector_properties, VTX::FieldType::Vector, struct_cache,
+                struct_name, "Vector",
+                [](const VTX::Vector& value) { return EntityInspectorViewService::FormatVector(value); },
+                [](const VTX::Vector& value) { return EntityInspectorViewService::FormatRawVector(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Quaternions", pc.quat_properties, VTX::FieldType::Quat, struct_cache,
+                struct_name, "Quat",
+                [](const VTX::Quat& value) { return EntityInspectorViewService::FormatQuat(value); },
+                [](const VTX::Quat& value) { return EntityInspectorViewService::FormatRawQuat(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Transforms", pc.transform_properties, VTX::FieldType::Transform, struct_cache,
+                struct_name, "Transform",
+                [](const VTX::Transform& value) { return EntityInspectorViewService::FormatTransform(value); },
+                [](const VTX::Transform& value) { return EntityInspectorViewService::FormatRawTransform(value); });
+
+            AppendPrimitiveNodes(
+                out_nodes, id_prefix, "Ranges", pc.range_properties, VTX::FieldType::FloatRange, struct_cache,
+                struct_name, "Range",
+                [](const VTX::FloatRange& value) { return EntityInspectorViewService::FormatRange(value); },
+                [](const VTX::FloatRange& value) { return EntityInspectorViewService::FormatRawRange(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Byte Arrays", pc.byte_array_properties, VTX::FieldType::Int8, struct_cache,
+                struct_name,
+                [](uint8_t value) {
+                    char val[32];
+                    std::snprintf(val, sizeof(val), "0x%02X", static_cast<unsigned int>(value));
+                    return std::string(val);
+                },
+                [](uint8_t value) { return std::to_string(static_cast<unsigned int>(value)); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Bool Arrays", pc.bool_arrays, VTX::FieldType::Bool, struct_cache, struct_name,
+                [](uint8_t value) { return value != 0 ? std::string("True") : std::string("False"); },
+                [](uint8_t value) { return value != 0 ? std::string("1") : std::string("0"); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Int32 Arrays", pc.int32_arrays, VTX::FieldType::Int32, struct_cache, struct_name,
+                [](int32_t value) { return std::to_string(value); },
+                [](int32_t value) { return std::to_string(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Int64 Arrays", pc.int64_arrays, VTX::FieldType::Int64, struct_cache, struct_name,
+                [](int64_t value) { return std::to_string(value); },
+                [](int64_t value) { return std::to_string(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Float Arrays", pc.float_arrays, VTX::FieldType::Float, struct_cache, struct_name,
+                [](float value) { return EntityInspectorViewService::FormatFloat(value); },
+                [](float value) { return EntityInspectorViewService::FormatRawFloat(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Double Arrays", pc.double_arrays, VTX::FieldType::Double, struct_cache,
+                struct_name, [](double value) { return EntityInspectorViewService::FormatDouble(value); },
+                [](double value) { return EntityInspectorViewService::FormatRawDouble(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "String Arrays", pc.string_arrays, VTX::FieldType::String, struct_cache,
+                struct_name, [](const std::string& value) { return value; },
+                [](const std::string& value) { return value; });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Vector Arrays", pc.vector_arrays, VTX::FieldType::Vector, struct_cache,
+                struct_name, [](const VTX::Vector& value) { return EntityInspectorViewService::FormatVector(value); },
+                [](const VTX::Vector& value) { return EntityInspectorViewService::FormatRawVector(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Quat Arrays", pc.quat_arrays, VTX::FieldType::Quat, struct_cache, struct_name,
+                [](const VTX::Quat& value) { return EntityInspectorViewService::FormatQuat(value); },
+                [](const VTX::Quat& value) { return EntityInspectorViewService::FormatRawQuat(value); });
+
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Transform Arrays", pc.transform_arrays, VTX::FieldType::Transform, struct_cache,
+                struct_name,
+                [](const VTX::Transform& value) { return EntityInspectorViewService::FormatTransform(value); },
+                [](const VTX::Transform& value) { return EntityInspectorViewService::FormatRawTransform(value); });
 
-    if (pc.map_arrays.SubArrayCount() > 0) {
-        Node group = MakeGroupNode(
-            id_prefix + "/map_arrays",
-            "Map Arrays (" + std::to_string(pc.map_arrays.SubArrayCount()) + " arrays)");
-
-        for (size_t i = 0; i < pc.map_arrays.SubArrayCount(); ++i) {
-            const auto sub_array = pc.map_arrays.GetSubArray(i);
-            Node array_node = MakeGroupNode(
-                group.id + "/" + std::to_string(i),
-                "Array [" + std::to_string(i) + "] (" + std::to_string(sub_array.size()) + " maps)");
-            const std::string map_array_schema_name = EntityInspectorViewService::ResolveSchemaName(
-                struct_cache,
-                VTX::FieldType::Struct,
-                VTX::FieldContainerType::Array,
-                i);
-            AttachSchemaPropertyLabel(array_node, struct_name, map_array_schema_name, i);
-
-            for (size_t j = 0; j < sub_array.size(); ++j) {
-                const auto& map_cont = sub_array[j];
-                Node map_node = MakeGroupNode(
-                    array_node.id + "/" + std::to_string(j),
-                    "Map [" + std::to_string(j) + "] (" + std::to_string(map_cont.keys.size()) + " pairs)");
-                if (!map_array_schema_name.empty()) {
-                    map_node.schema_label = "Item [" + std::to_string(j) + "]";
-                    map_node.schema_focus_struct_name = struct_name;
-                    map_node.schema_focus_property_name = map_array_schema_name;
-                    map_node.schema_focus_on_secondary_click = true;
+            AppendFlatArrayGroup(
+                out_nodes, id_prefix, "Range Arrays", pc.range_arrays, VTX::FieldType::FloatRange, struct_cache,
+                struct_name,
+                [](const VTX::FloatRange& value) { return EntityInspectorViewService::FormatRange(value); },
+                [](const VTX::FloatRange& value) { return EntityInspectorViewService::FormatRawRange(value); });
+
+            if (!pc.any_struct_properties.empty()) {
+                Node group = MakeGroupNode(id_prefix + "/structs",
+                                           "Structs (" + std::to_string(pc.any_struct_properties.size()) + ")");
+
+                for (size_t i = 0; i < pc.any_struct_properties.size(); ++i) {
+                    const auto& nested = pc.any_struct_properties[i];
+
+                    Node struct_node = MakeGroupNode(group.id + "/" + std::to_string(i),
+                                                     "Struct [" + std::to_string(i) +
+                                                         "] (Type ID: " + std::to_string(nested.entity_type_id) + ")");
+                    const std::string struct_schema_name = EntityInspectorViewService::ResolveSchemaName(
+                        struct_cache, VTX::FieldType::Struct, VTX::FieldContainerType::None, i);
+                    AttachSchemaLookup(struct_node, struct_name, static_cast<int>(i), VTX::FieldType::Struct,
+                                       VTX::FieldContainerType::None, true);
+                    AttachSchemaPropertyLabel(struct_node, struct_name, struct_schema_name, i);
+                    BuildPropertyNodesRecursive(nested, global_cache, struct_node.id, struct_node.children);
+                    group.children.push_back(std::move(struct_node));
+                }
+
+                out_nodes.push_back(std::move(group));
+            }
+
+            if (pc.any_struct_arrays.SubArrayCount() > 0) {
+                Node group = MakeGroupNode(id_prefix + "/struct_arrays",
+                                           "Struct Arrays (" + std::to_string(pc.any_struct_arrays.SubArrayCount()) +
+                                               " arrays)");
+
+                for (size_t i = 0; i < pc.any_struct_arrays.SubArrayCount(); ++i) {
+                    const auto sub_array = pc.any_struct_arrays.GetSubArray(i);
+                    const std::string array_schema_name = EntityInspectorViewService::ResolveSchemaName(
+                        struct_cache, VTX::FieldType::Struct, VTX::FieldContainerType::Array, i);
+                    const int32_t nested_type_id = !sub_array.empty() ? sub_array.front().entity_type_id : -1;
+                    Node array_node = MakeGroupNode(
+                        group.id + "/" + std::to_string(i),
+                        nested_type_id >= 0
+                            ? "Array [" + std::to_string(i) + "] (Type ID: " + std::to_string(nested_type_id) + ")"
+                            : "Array [" + std::to_string(i) + "] (" + std::to_string(sub_array.size()) + " structs)");
+                    AttachSchemaLookup(array_node, struct_name, static_cast<int>(i), VTX::FieldType::Struct,
+                                       VTX::FieldContainerType::Array, true);
+                    AttachSchemaPropertyLabel(array_node, struct_name, array_schema_name, i);
+
+                    const std::string nested_schema_struct_name = [&]() -> std::string {
+                        const auto* address =
+                            FindSchemaAddress(struct_cache, VTX::FieldType::Struct, VTX::FieldContainerType::Array, i);
+                        return address ? address->child_type_name : std::string {};
+                    }();
+
+                    for (size_t j = 0; j < sub_array.size(); ++j) {
+                        const auto& nested = sub_array[j];
+                        Node item_node =
+                            MakeGroupNode(array_node.id + "/" + std::to_string(j), "Item [" + std::to_string(j) + "]");
+                        std::string nested_struct_name = EntityInspectorViewService::ResolveStructName(
+                            EntityInspectorViewService::ResolveStructCache(global_cache, nested.entity_type_id));
+                        if (nested_struct_name.empty()) {
+                            nested_struct_name = nested_schema_struct_name;
+                        }
+                        if (!nested_struct_name.empty()) {
+                            AttachSchemaStructLabel(item_node, nested_struct_name,
+                                                    nested_struct_name + " [" + std::to_string(j) + "]");
+                        }
+                        BuildPropertyNodesRecursive(nested, global_cache, item_node.id, item_node.children);
+                        array_node.children.push_back(std::move(item_node));
+                    }
+                    if (sub_array.empty()) {
+                        array_node.children.push_back(MakeGroupNode(array_node.id + "/empty", "Empty Array"));
+                    }
+
+                    group.children.push_back(std::move(array_node));
                 }
-                AppendMapEntries(map_node, map_cont, global_cache);
-                array_node.children.push_back(std::move(map_node));
+
+                out_nodes.push_back(std::move(group));
+            }
+
+            if (!pc.map_properties.empty()) {
+                Node group =
+                    MakeGroupNode(id_prefix + "/maps", "Maps (" + std::to_string(pc.map_properties.size()) + ")");
+
+                for (size_t i = 0; i < pc.map_properties.size(); ++i) {
+                    const auto& map_cont = pc.map_properties[i];
+                    Node map_node = MakeGroupNode(group.id + "/" + std::to_string(i),
+                                                  "Map [" + std::to_string(i) + "] (" +
+                                                      std::to_string(map_cont.keys.size()) + " pairs)");
+                    const std::string map_schema_name = EntityInspectorViewService::ResolveSchemaName(
+                        struct_cache, VTX::FieldType::Struct, VTX::FieldContainerType::Map, i);
+                    AttachSchemaPropertyLabel(map_node, struct_name, map_schema_name, i);
+                    AppendMapEntries(map_node, map_cont, global_cache);
+
+                    group.children.push_back(std::move(map_node));
+                }
+
+                out_nodes.push_back(std::move(group));
             }
 
-            group.children.push_back(std::move(array_node));
+            if (pc.map_arrays.SubArrayCount() > 0) {
+                Node group = MakeGroupNode(id_prefix + "/map_arrays",
+                                           "Map Arrays (" + std::to_string(pc.map_arrays.SubArrayCount()) + " arrays)");
+
+                for (size_t i = 0; i < pc.map_arrays.SubArrayCount(); ++i) {
+                    const auto sub_array = pc.map_arrays.GetSubArray(i);
+                    Node array_node = MakeGroupNode(group.id + "/" + std::to_string(i),
+                                                    "Array [" + std::to_string(i) + "] (" +
+                                                        std::to_string(sub_array.size()) + " maps)");
+                    const std::string map_array_schema_name = EntityInspectorViewService::ResolveSchemaName(
+                        struct_cache, VTX::FieldType::Struct, VTX::FieldContainerType::Array, i);
+                    AttachSchemaPropertyLabel(array_node, struct_name, map_array_schema_name, i);
+
+                    for (size_t j = 0; j < sub_array.size(); ++j) {
+                        const auto& map_cont = sub_array[j];
+                        Node map_node = MakeGroupNode(array_node.id + "/" + std::to_string(j),
+                                                      "Map [" + std::to_string(j) + "] (" +
+                                                          std::to_string(map_cont.keys.size()) + " pairs)");
+                        if (!map_array_schema_name.empty()) {
+                            map_node.schema_label = "Item [" + std::to_string(j) + "]";
+                            map_node.schema_focus_struct_name = struct_name;
+                            map_node.schema_focus_property_name = map_array_schema_name;
+                            map_node.schema_focus_on_secondary_click = true;
+                        }
+                        AppendMapEntries(map_node, map_cont, global_cache);
+                        array_node.children.push_back(std::move(map_node));
+                    }
+
+                    group.children.push_back(std::move(array_node));
+                }
+
+                out_nodes.push_back(std::move(group));
+            }
         }
 
-        out_nodes.push_back(std::move(group));
-    }
-}
-
-} // namespace
-
-FrameResolveResult EntityInspectorViewService::ResolveFrameToDraw(VTX::IVtxReaderFacade& reader, const FrameResolveContext& context) {
-    FrameResolveResult result;
-    result.next_last_drawn_frame_index = context.last_drawn_frame_index;
-
-    if (context.is_scrubbing) {
-        result.is_loading = true;
-        result.status_message = "Scrubbing to Frame " + std::to_string(context.current_frame) + "...";
-        if (context.last_drawn_frame_index != -1) {
-            result.frame_to_draw = reader.GetFrame(context.last_drawn_frame_index);
-            if (result.frame_to_draw) {
-                result.showing_stale_frame = true;
-                result.stale_frame_index = context.last_drawn_frame_index;
+    } // namespace
+
+    FrameResolveResult EntityInspectorViewService::ResolveFrameToDraw(VTX::IVtxReaderFacade& reader,
+                                                                      const FrameResolveContext& context) {
+        FrameResolveResult result;
+        result.next_last_drawn_frame_index = context.last_drawn_frame_index;
+
+        if (context.is_scrubbing) {
+            result.is_loading = true;
+            result.status_message = "Scrubbing to Frame " + std::to_string(context.current_frame) + "...";
+            if (context.last_drawn_frame_index != -1) {
+                result.frame_to_draw = reader.GetFrame(context.last_drawn_frame_index);
+                if (result.frame_to_draw) {
+                    result.showing_stale_frame = true;
+                    result.stale_frame_index = context.last_drawn_frame_index;
+                }
             }
+            return result;
         }
-        return result;
-    }
 
-    result.frame_to_draw = reader.GetFrame(context.current_frame);
-    if (!result.frame_to_draw) {
-        result.is_loading = true;
-        result.status_message = "Loading chunk data for frame " + std::to_string(context.current_frame) + "...";
-        if (context.last_drawn_frame_index != -1) {
-            result.frame_to_draw = reader.GetFrame(context.last_drawn_frame_index);
-            if (result.frame_to_draw) {
-                result.showing_stale_frame = true;
-                result.stale_frame_index = context.last_drawn_frame_index;
+        result.frame_to_draw = reader.GetFrame(context.current_frame);
+        if (!result.frame_to_draw) {
+            result.is_loading = true;
+            result.status_message = "Loading chunk data for frame " + std::to_string(context.current_frame) + "...";
+            if (context.last_drawn_frame_index != -1) {
+                result.frame_to_draw = reader.GetFrame(context.last_drawn_frame_index);
+                if (result.frame_to_draw) {
+                    result.showing_stale_frame = true;
+                    result.stale_frame_index = context.last_drawn_frame_index;
+                }
             }
+            return result;
         }
+
+        result.status_message = "Inspecting Frame: " + std::to_string(context.current_frame);
+        result.next_last_drawn_frame_index = context.current_frame;
         return result;
     }
 
-    result.status_message = "Inspecting Frame: " + std::to_string(context.current_frame);
-    result.next_last_drawn_frame_index = context.current_frame;
-    return result;
-}
-
-std::vector<EntityBucketView> EntityInspectorViewService::BuildEntityBuckets(
-    const VTX::Frame& frame,
-    const EntityInspectorState& state,
-    const VTX::PropertyAddressCache* global_cache) {
-    // Build bucket/entity list items with selection matched by bucket + unique ID.
-    std::vector<EntityBucketView> buckets_vm;
-    const auto& buckets = frame.GetBuckets();
-    buckets_vm.reserve(buckets.size());
-
-    int bucket_idx = 0;
-    for (const auto& bucket : buckets) {
-        const int current_bucket_idx = bucket_idx++;
-        EntityBucketView bucket_vm;
-        bucket_vm.id = "bucket_" + std::to_string(current_bucket_idx);
-        bucket_vm.label = "Bucket " + std::to_string(current_bucket_idx) + " (" + std::to_string(bucket.entities.size()) + ")";
-        bucket_vm.bucket_index = current_bucket_idx;
-        bucket_vm.entities.reserve(bucket.entities.size());
+    std::vector<EntityBucketView>
+    EntityInspectorViewService::BuildEntityBuckets(const VTX::Frame& frame, const EntityInspectorState& state,
+                                                   const VTX::PropertyAddressCache* global_cache) {
+        // Build bucket/entity list items with selection matched by bucket + unique ID.
+        std::vector<EntityBucketView> buckets_vm;
+        const auto& buckets = frame.GetBuckets();
+        buckets_vm.reserve(buckets.size());
+
+        int bucket_idx = 0;
+        for (const auto& bucket : buckets) {
+            const int current_bucket_idx = bucket_idx++;
+            EntityBucketView bucket_vm;
+            bucket_vm.id = "bucket_" + std::to_string(current_bucket_idx);
+            bucket_vm.label =
+                "Bucket " + std::to_string(current_bucket_idx) + " (" + std::to_string(bucket.entities.size()) + ")";
+            bucket_vm.bucket_index = current_bucket_idx;
+            bucket_vm.entities.reserve(bucket.entities.size());
+
+            for (size_t i = 0; i < bucket.entities.size(); ++i) {
+                const std::string entity_id =
+                    (i < bucket.unique_ids.size()) ? bucket.unique_ids[i] : "UnknownEntity_" + std::to_string(i);
+                const int entity_type_id = bucket.entities[i].entity_type_id;
+                const std::string entity_type_name =
+                    ResolveStructName(ResolveStructCache(global_cache, entity_type_id));
+                bucket_vm.entities.push_back(EntityListItem {
+                    .entity_id = entity_id,
+                    .entity_type_id = entity_type_id,
+                    .entity_type_name = entity_type_name,
+                    .is_selected = (state.selected_bucket_index == bucket_vm.bucket_index) &&
+                                   (state.selected_entity_id == entity_id),
+                });
+            }
 
-        for (size_t i = 0; i < bucket.entities.size(); ++i) {
-            const std::string entity_id = (i < bucket.unique_ids.size())
-                ? bucket.unique_ids[i]
-                : "UnknownEntity_" + std::to_string(i);
-            const int entity_type_id = bucket.entities[i].entity_type_id;
-            const std::string entity_type_name = ResolveStructName(ResolveStructCache(global_cache, entity_type_id));
-            bucket_vm.entities.push_back(EntityListItem{
-                .entity_id = entity_id,
-                .entity_type_id = entity_type_id,
-                .entity_type_name = entity_type_name,
-                .is_selected = (state.selected_bucket_index == bucket_vm.bucket_index)
-                    && (state.selected_entity_id == entity_id),
-            });
+            buckets_vm.push_back(std::move(bucket_vm));
         }
 
-        buckets_vm.push_back(std::move(bucket_vm));
+        return buckets_vm;
     }
 
-    return buckets_vm;
-}
-
-EntityPropertiesViewModel EntityInspectorViewService::BuildPropertyTree(
-    const VTX::PropertyContainer& pc,
-    const VTX::PropertyAddressCache* global_cache) {
-    EntityPropertiesViewModel vm;
-    BuildPropertyNodesRecursive(pc, global_cache, "root", vm.roots);
-    return vm;
-}
-
-EntityPropertyCommand EntityInspectorViewService::BuildActivateCommand(
-    const EntityPropertyNode& node,
-    const VTX::PropertyAddressCache* global_cache) {
-    EntityPropertyCommand command;
-    if (!node.is_property) {
-        return command;
+    EntityPropertiesViewModel
+    EntityInspectorViewService::BuildPropertyTree(const VTX::PropertyContainer& pc,
+                                                  const VTX::PropertyAddressCache* global_cache) {
+        EntityPropertiesViewModel vm;
+        BuildPropertyNodesRecursive(pc, global_cache, "root", vm.roots);
+        return vm;
     }
 
-    command.copy_to_clipboard = true;
-    command.clipboard_text = node.raw_value;
-    const std::string schema_name = ResolveSchemaName(global_cache, node);
-    if (!schema_name.empty() && !node.struct_name.empty()) {
-        command.request_schema_focus = true;
-        command.struct_name = node.struct_name;
-        command.property_name = schema_name;
-    }
-    return command;
-}
-
-EntityPropertyCommand EntityInspectorViewService::BuildSchemaFocusCommand(
-    const EntityPropertyNode& node,
-    const VTX::PropertyAddressCache* global_cache) {
-    EntityPropertyCommand command;
-    if (!node.schema_focus_on_secondary_click) {
+    EntityPropertyCommand
+    EntityInspectorViewService::BuildActivateCommand(const EntityPropertyNode& node,
+                                                     const VTX::PropertyAddressCache* global_cache) {
+        EntityPropertyCommand command;
+        if (!node.is_property) {
+            return command;
+        }
+
+        command.copy_to_clipboard = true;
+        command.clipboard_text = node.raw_value;
+        const std::string schema_name = ResolveSchemaName(global_cache, node);
+        if (!schema_name.empty() && !node.struct_name.empty()) {
+            command.request_schema_focus = true;
+            command.struct_name = node.struct_name;
+            command.property_name = schema_name;
+        }
         return command;
     }
 
-    if (!node.schema_focus_struct_name.empty()) {
+    EntityPropertyCommand
+    EntityInspectorViewService::BuildSchemaFocusCommand(const EntityPropertyNode& node,
+                                                        const VTX::PropertyAddressCache* global_cache) {
+        EntityPropertyCommand command;
+        if (!node.schema_focus_on_secondary_click) {
+            return command;
+        }
+
+        if (!node.schema_focus_struct_name.empty()) {
+            command.request_schema_focus = true;
+            command.struct_name = node.schema_focus_struct_name;
+            command.property_name = node.schema_focus_property_name;
+            return command;
+        }
+
+        if (node.struct_name.empty()) {
+            return command;
+        }
+
+        const std::string schema_name = ResolveSchemaName(global_cache, node);
+        if (schema_name.empty()) {
+            return command;
+        }
+
         command.request_schema_focus = true;
-        command.struct_name = node.schema_focus_struct_name;
-        command.property_name = node.schema_focus_property_name;
+        command.struct_name = node.struct_name;
+        command.property_name = schema_name;
         return command;
     }
 
-    if (node.struct_name.empty()) {
-        return command;
-    }
+    EntityInspectorScreenResult EntityInspectorViewService::BuildScreen(VTX::IVtxReaderFacade* reader,
+                                                                        bool has_loaded_replay,
+                                                                        bool is_scrubbing_timeline, int current_frame,
+                                                                        const EntityInspectorState& state) {
+        EntityInspectorScreenResult result;
+        result.state = state;
+        result.view_model.has_replay = has_loaded_replay && reader != nullptr;
+        if (!result.view_model.has_replay) {
+            return result;
+        }
 
-    const std::string schema_name = ResolveSchemaName(global_cache, node);
-    if (schema_name.empty()) {
-        return command;
-    }
+        const auto frame_result =
+            ResolveFrameToDraw(*reader, FrameResolveContext {
+                                            .is_scrubbing = is_scrubbing_timeline,
+                                            .current_frame = current_frame,
+                                            .last_drawn_frame_index = state.last_drawn_frame_index,
+                                        });
+        result.state.last_drawn_frame_index = frame_result.next_last_drawn_frame_index;
+        result.view_model.is_loading = frame_result.is_loading;
+        result.view_model.disable_panels = frame_result.is_loading;
+        result.view_model.status_message = frame_result.status_message;
+        result.view_model.status_tone =
+            frame_result.is_loading ? (is_scrubbing_timeline ? EntityStatusTone::Warning : EntityStatusTone::Error)
+                                    : EntityStatusTone::Normal;
+        if (frame_result.showing_stale_frame) {
+            result.view_model.stale_frame_message =
+                "(Showing stale frame " + std::to_string(frame_result.stale_frame_index) + ")";
+        }
+        if (!frame_result.frame_to_draw) {
+            result.view_model.empty_properties_message = "Waiting for frame data to stream from disk...";
+            return result;
+        }
 
-    command.request_schema_focus = true;
-    command.struct_name = node.struct_name;
-    command.property_name = schema_name;
-    return command;
-}
-
-EntityInspectorScreenResult EntityInspectorViewService::BuildScreen(
-    VTX::IVtxReaderFacade* reader,
-    bool has_loaded_replay,
-    bool is_scrubbing_timeline,
-    int current_frame,
-    const EntityInspectorState& state) {
-    EntityInspectorScreenResult result;
-    result.state = state;
-    result.view_model.has_replay = has_loaded_replay && reader != nullptr;
-    if (!result.view_model.has_replay) {
+        result.view_model.has_frame = true;
+        VTX::PropertyAddressCache cache_copy;
+        const VTX::PropertyAddressCache* global_cache = nullptr;
+        if (reader) {
+            cache_copy = reader->GetPropertyAddressCache();
+            global_cache = &cache_copy;
+        }
+        result.view_model = BuildFrameViewModel(*frame_result.frame_to_draw, state, global_cache);
+        result.view_model.has_replay = true;
+        result.view_model.has_frame = true;
+        result.view_model.is_loading = frame_result.is_loading;
+        result.view_model.disable_panels = frame_result.is_loading;
+        result.view_model.status_message = frame_result.status_message;
+        result.view_model.status_tone =
+            frame_result.is_loading ? (is_scrubbing_timeline ? EntityStatusTone::Warning : EntityStatusTone::Error)
+                                    : EntityStatusTone::Normal;
+        result.view_model.stale_frame_message =
+            frame_result.showing_stale_frame
+                ? "(Showing stale frame " + std::to_string(frame_result.stale_frame_index) + ")"
+                : std::string {};
         return result;
     }
 
-    const auto frame_result = ResolveFrameToDraw(
-        *reader,
-        FrameResolveContext{
-            .is_scrubbing = is_scrubbing_timeline,
-            .current_frame = current_frame,
-            .last_drawn_frame_index = state.last_drawn_frame_index,
-        });
-    result.state.last_drawn_frame_index = frame_result.next_last_drawn_frame_index;
-    result.view_model.is_loading = frame_result.is_loading;
-    result.view_model.disable_panels = frame_result.is_loading;
-    result.view_model.status_message = frame_result.status_message;
-    result.view_model.status_tone = frame_result.is_loading
-        ? (is_scrubbing_timeline ? EntityStatusTone::Warning : EntityStatusTone::Error)
-        : EntityStatusTone::Normal;
-    if (frame_result.showing_stale_frame) {
-        result.view_model.stale_frame_message = "(Showing stale frame " + std::to_string(frame_result.stale_frame_index) + ")";
-    }
-    if (!frame_result.frame_to_draw) {
-        result.view_model.empty_properties_message = "Waiting for frame data to stream from disk...";
-        return result;
-    }
+    EntityInspectorState EntityInspectorViewService::SelectEntity(const EntityInspectorState& state, int bucket_index,
+                                                                  const std::string& entity_id) {
+        // Persist the selected entity identity as (bucket index, unique ID).
+        EntityInspectorState next_state = state;
+        next_state.selected_bucket_index = bucket_index;
+        next_state.selected_entity_id = entity_id;
+        return next_state;
+    }
+
+    EntityInspectorEffect
+    EntityInspectorViewService::BuildPropertyActivateEffect(const EntityPropertyNode& node,
+                                                            const VTX::PropertyAddressCache* global_cache) {
+        const auto command = BuildActivateCommand(node, global_cache);
+        return EntityInspectorEffect {
+            .copy_to_clipboard = command.copy_to_clipboard,
+            .clipboard_text = command.clipboard_text,
+            .request_schema_focus = command.request_schema_focus,
+            .focus_schema_window = command.request_schema_focus,
+            .schema_struct_name = command.struct_name,
+            .schema_property_name = command.property_name,
+        };
+    }
+
+    EntityInspectorEffect
+    EntityInspectorViewService::BuildPropertyContextEffect(const EntityPropertyNode& node,
+                                                           const VTX::PropertyAddressCache* global_cache) {
+        const auto command = BuildSchemaFocusCommand(node, global_cache);
+        return EntityInspectorEffect {
+            .request_schema_focus = command.request_schema_focus,
+            .schema_struct_name = command.struct_name,
+            .schema_property_name = command.property_name,
+        };
+    }
+
+    const VTX::PropertyContainer* EntityInspectorViewService::FindSelectedEntity(const VTX::Frame& frame,
+                                                                                 const EntityInspectorState& state) {
+        // Resolve selected entity inside the selected bucket first to avoid cross-bucket ID collisions.
+        if (state.selected_entity_id.empty() || state.selected_bucket_index < 0) {
+            return nullptr;
+        }
 
-    result.view_model.has_frame = true;
-    VTX::PropertyAddressCache cache_copy;
-    const VTX::PropertyAddressCache* global_cache = nullptr;
-    if (reader) {
-        cache_copy = reader->GetPropertyAddressCache();
-        global_cache = &cache_copy;
-    }
-    result.view_model = BuildFrameViewModel(*frame_result.frame_to_draw, state, global_cache);
-    result.view_model.has_replay = true;
-    result.view_model.has_frame = true;
-    result.view_model.is_loading = frame_result.is_loading;
-    result.view_model.disable_panels = frame_result.is_loading;
-    result.view_model.status_message = frame_result.status_message;
-    result.view_model.status_tone = frame_result.is_loading
-        ? (is_scrubbing_timeline ? EntityStatusTone::Warning : EntityStatusTone::Error)
-        : EntityStatusTone::Normal;
-    result.view_model.stale_frame_message = frame_result.showing_stale_frame
-        ? "(Showing stale frame " + std::to_string(frame_result.stale_frame_index) + ")"
-        : std::string{};
-    return result;
-}
-
-EntityInspectorState EntityInspectorViewService::SelectEntity(
-    const EntityInspectorState& state,
-    int bucket_index,
-    const std::string& entity_id) {
-    // Persist the selected entity identity as (bucket index, unique ID).
-    EntityInspectorState next_state = state;
-    next_state.selected_bucket_index = bucket_index;
-    next_state.selected_entity_id = entity_id;
-    return next_state;
-}
-
-EntityInspectorEffect EntityInspectorViewService::BuildPropertyActivateEffect(
-    const EntityPropertyNode& node,
-    const VTX::PropertyAddressCache* global_cache) {
-    const auto command = BuildActivateCommand(node, global_cache);
-    return EntityInspectorEffect{
-        .copy_to_clipboard = command.copy_to_clipboard,
-        .clipboard_text = command.clipboard_text,
-        .request_schema_focus = command.request_schema_focus,
-        .focus_schema_window = command.request_schema_focus,
-        .schema_struct_name = command.struct_name,
-        .schema_property_name = command.property_name,
-    };
-}
-
-EntityInspectorEffect EntityInspectorViewService::BuildPropertyContextEffect(
-    const EntityPropertyNode& node,
-    const VTX::PropertyAddressCache* global_cache) {
-    const auto command = BuildSchemaFocusCommand(node, global_cache);
-    return EntityInspectorEffect{
-        .request_schema_focus = command.request_schema_focus,
-        .schema_struct_name = command.struct_name,
-        .schema_property_name = command.property_name,
-    };
-}
-
-const VTX::PropertyContainer* EntityInspectorViewService::FindSelectedEntity(
-    const VTX::Frame& frame,
-    const EntityInspectorState& state) {
-    // Resolve selected entity inside the selected bucket first to avoid cross-bucket ID collisions.
-    if (state.selected_entity_id.empty() || state.selected_bucket_index < 0) {
-        return nullptr;
-    }
+        const auto& buckets = frame.GetBuckets();
+        if (state.selected_bucket_index >= static_cast<int>(buckets.size())) {
+            return nullptr;
+        }
 
-    const auto& buckets = frame.GetBuckets();
-    if (state.selected_bucket_index >= static_cast<int>(buckets.size())) {
+        const auto& bucket = buckets[static_cast<size_t>(state.selected_bucket_index)];
+        for (size_t i = 0; i < bucket.entities.size(); ++i) {
+            const std::string id =
+                (i < bucket.unique_ids.size()) ? bucket.unique_ids[i] : "UnknownEntity_" + std::to_string(i);
+            if (id == state.selected_entity_id) {
+                return &bucket.entities[i];
+            }
+        }
         return nullptr;
     }
 
-    const auto& bucket = buckets[static_cast<size_t>(state.selected_bucket_index)];
-    for (size_t i = 0; i < bucket.entities.size(); ++i) {
-        const std::string id = (i < bucket.unique_ids.size())
-            ? bucket.unique_ids[i]
-            : "UnknownEntity_" + std::to_string(i);
-        if (id == state.selected_entity_id) {
-            return &bucket.entities[i];
+    EntityInspectorViewModel
+    EntityInspectorViewService::BuildFrameViewModel(const VTX::Frame& frame, const EntityInspectorState& state,
+                                                    const VTX::PropertyAddressCache* global_cache) {
+        // Build details view model using the exact selected bucket/entity tuple.
+        EntityInspectorViewModel view_model;
+        view_model.buckets = BuildEntityBuckets(frame, state, global_cache);
+        if (view_model.buckets.empty()) {
+            view_model.empty_properties_message = "No buckets in this frame.";
+            return view_model;
         }
-    }
-    return nullptr;
-}
-
-EntityInspectorViewModel EntityInspectorViewService::BuildFrameViewModel(
-    const VTX::Frame& frame,
-    const EntityInspectorState& state,
-    const VTX::PropertyAddressCache* global_cache) {
-    // Build details view model using the exact selected bucket/entity tuple.
-    EntityInspectorViewModel view_model;
-    view_model.buckets = BuildEntityBuckets(frame, state, global_cache);
-    if (view_model.buckets.empty()) {
-        view_model.empty_properties_message = "No buckets in this frame.";
+
+        if (state.selected_entity_id.empty() || state.selected_bucket_index < 0) {
+            view_model.empty_properties_message = "Select an entity from the list to view its properties.";
+            return view_model;
+        }
+
+        const VTX::PropertyContainer* pc = FindSelectedEntity(frame, state);
+        if (!pc) {
+            view_model.empty_properties_message = "Entity '" + state.selected_entity_id + "' in Bucket " +
+                                                  std::to_string(state.selected_bucket_index) + " no longer exists.";
+            return view_model;
+        }
+
+        view_model.header.entity_label =
+            "Entity: " + state.selected_entity_id + " (Bucket " + std::to_string(state.selected_bucket_index) + ")";
+        view_model.header.type_label = "Type ID: " + std::to_string(pc->entity_type_id);
+        const VTX::StructSchemaCache* selected_struct_cache = ResolveStructCache(global_cache, pc->entity_type_id);
+        view_model.header.type_name = ResolveStructName(selected_struct_cache);
+        view_model.header.missing_field_names = BuildMissingFieldNames(*pc, selected_struct_cache);
+        view_model.header.show_hash = pc->content_hash != 0;
+        if (view_model.header.show_hash) {
+            char buffer[64];
+            std::snprintf(buffer, sizeof(buffer), "Hash: 0x%llX", static_cast<unsigned long long>(pc->content_hash));
+            view_model.header.hash_label = buffer;
+        }
+        view_model.properties = BuildPropertyTree(*pc, global_cache);
         return view_model;
     }
 
-    if (state.selected_entity_id.empty() || state.selected_bucket_index < 0) {
-        view_model.empty_properties_message = "Select an entity from the list to view its properties.";
-        return view_model;
+    const VTX::StructSchemaCache*
+    EntityInspectorViewService::ResolveStructCache(const VTX::PropertyAddressCache* global_cache,
+                                                   int32_t entity_type_id) {
+        if (!global_cache) {
+            return nullptr;
+        }
+
+        auto it = global_cache->structs.find(entity_type_id);
+        if (it == global_cache->structs.end()) {
+            return nullptr;
+        }
+
+        return &it->second;
     }
 
-    const VTX::PropertyContainer* pc = FindSelectedEntity(frame, state);
-    if (!pc) {
-        view_model.empty_properties_message = "Entity '" + state.selected_entity_id + "' in Bucket " +
-            std::to_string(state.selected_bucket_index) + " no longer exists.";
-        return view_model;
+    std::string EntityInspectorViewService::ResolveSchemaName(const VTX::StructSchemaCache* struct_cache,
+                                                              VTX::FieldType expected_type,
+                                                              VTX::FieldContainerType container_type, size_t index) {
+        if (!struct_cache) {
+            return "";
+        }
+
+        const auto exact_it = struct_cache->names_by_lookup_key.find(
+            VTX::MakePropertyLookupKey(static_cast<int32_t>(index), expected_type, container_type));
+        if (exact_it != struct_cache->names_by_lookup_key.end()) {
+            return exact_it->second;
+        }
+
+        if (expected_type == VTX::FieldType::Int32) {
+            const auto enum_it = struct_cache->names_by_lookup_key.find(
+                VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Enum, container_type));
+            if (enum_it != struct_cache->names_by_lookup_key.end()) {
+                return enum_it->second;
+            }
+
+            const auto int8_it = struct_cache->names_by_lookup_key.find(
+                VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Int8, container_type));
+            if (int8_it != struct_cache->names_by_lookup_key.end()) {
+                return int8_it->second;
+            }
+        }
+
+        return "";
     }
 
-    view_model.header.entity_label = "Entity: " + state.selected_entity_id + " (Bucket " +
-        std::to_string(state.selected_bucket_index) + ")";
-    view_model.header.type_label = "Type ID: " + std::to_string(pc->entity_type_id);
-    const VTX::StructSchemaCache* selected_struct_cache = ResolveStructCache(global_cache, pc->entity_type_id);
-    view_model.header.type_name = ResolveStructName(selected_struct_cache);
-    view_model.header.missing_field_names = BuildMissingFieldNames(*pc, selected_struct_cache);
-    view_model.header.show_hash = pc->content_hash != 0;
-    if (view_model.header.show_hash) {
-        char buffer[64];
-        std::snprintf(buffer, sizeof(buffer), "Hash: 0x%llX", static_cast<unsigned long long>(pc->content_hash));
-        view_model.header.hash_label = buffer;
+    const VTX::StructSchemaCache*
+    EntityInspectorViewService::ResolveStructCache(const VTX::PropertyAddressCache* global_cache,
+                                                   const std::string& struct_name) {
+        if (!global_cache || struct_name.empty()) {
+            return nullptr;
+        }
+
+        const auto type_it = global_cache->name_to_id.find(struct_name);
+        if (type_it == global_cache->name_to_id.end()) {
+            return nullptr;
+        }
+
+        return ResolveStructCache(global_cache, type_it->second);
     }
-    view_model.properties = BuildPropertyTree(*pc, global_cache);
-    return view_model;
-}
-
-const VTX::StructSchemaCache* EntityInspectorViewService::ResolveStructCache(
-    const VTX::PropertyAddressCache* global_cache,
-    int32_t entity_type_id) {
-    if (!global_cache) {
-        return nullptr;
+
+    std::string EntityInspectorViewService::ResolveSchemaName(const VTX::PropertyAddressCache* global_cache,
+                                                              const EntityPropertyNode& node) {
+        if (!global_cache || node.schema_index < 0 || node.struct_name.empty()) {
+            return "";
+        }
+
+        const auto* struct_cache = ResolveStructCache(global_cache, node.struct_name);
+        return ResolveSchemaName(struct_cache, node.schema_type, node.schema_container_type,
+                                 static_cast<size_t>(node.schema_index));
     }
 
-    auto it = global_cache->structs.find(entity_type_id);
-    if (it == global_cache->structs.end()) {
-        return nullptr;
+    std::string EntityInspectorViewService::ResolveStructName(const VTX::StructSchemaCache* struct_cache) {
+        if (!struct_cache) {
+            return "";
+        }
+        return struct_cache->name;
     }
 
-    return &it->second;
-}
+    std::string EntityInspectorViewService::FormatVector(const VTX::Vector& v) {
+        char val[128];
+        std::snprintf(val, sizeof(val), "X: %.3f Y: %.3f Z: %.3f", v.x, v.y, v.z);
+        return val;
+    }
 
-std::string EntityInspectorViewService::ResolveSchemaName(
-    const VTX::StructSchemaCache* struct_cache,
-    VTX::FieldType expected_type,
-    VTX::FieldContainerType container_type,
-    size_t index) {
-    if (!struct_cache) {
-        return "";
+    std::string EntityInspectorViewService::FormatQuat(const VTX::Quat& q) {
+        char val[128];
+        std::snprintf(val, sizeof(val), "X: %.3f Y: %.3f Z: %.3f W: %.3f", q.x, q.y, q.z, q.w);
+        return val;
     }
 
-    const auto exact_it = struct_cache->names_by_lookup_key.find(
-        VTX::MakePropertyLookupKey(static_cast<int32_t>(index), expected_type, container_type));
-    if (exact_it != struct_cache->names_by_lookup_key.end()) {
-        return exact_it->second;
+    std::string EntityInspectorViewService::FormatTransform(const VTX::Transform& t) {
+        char val[320];
+        std::snprintf(val, sizeof(val), "Loc(%.1f, %.1f, %.1f) Rot(%.2f, %.2f, %.2f, %.2f) Scale(%.2f, %.2f, %.2f)",
+                      t.translation.x, t.translation.y, t.translation.z, t.rotation.x, t.rotation.y, t.rotation.z,
+                      t.rotation.w, t.scale.x, t.scale.y, t.scale.z);
+        return val;
     }
 
-    if (expected_type == VTX::FieldType::Int32) {
-        const auto enum_it = struct_cache->names_by_lookup_key.find(
-            VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Enum, container_type));
-        if (enum_it != struct_cache->names_by_lookup_key.end()) {
-            return enum_it->second;
-        }
+    std::string EntityInspectorViewService::FormatRange(const VTX::FloatRange& r) {
+        char val[128];
+        std::snprintf(val, sizeof(val), "Min: %.2f Max: %.2f ValNorm: %.2f", r.min, r.max, r.value_normalized);
+        return val;
+    }
 
-        const auto int8_it = struct_cache->names_by_lookup_key.find(
-            VTX::MakePropertyLookupKey(static_cast<int32_t>(index), VTX::FieldType::Int8, container_type));
-        if (int8_it != struct_cache->names_by_lookup_key.end()) {
-            return int8_it->second;
-        }
+    std::string EntityInspectorViewService::FormatFloat(float value) {
+        char val[64];
+        std::snprintf(val, sizeof(val), "%.4f", value);
+        return val;
     }
 
-    return "";
-}
+    std::string EntityInspectorViewService::FormatDouble(double value) {
+        char val[64];
+        std::snprintf(val, sizeof(val), "%.6f", value);
+        return val;
+    }
 
-const VTX::StructSchemaCache* EntityInspectorViewService::ResolveStructCache(
-    const VTX::PropertyAddressCache* global_cache,
-    const std::string& struct_name) {
-    if (!global_cache || struct_name.empty()) {
-        return nullptr;
+    std::string EntityInspectorViewService::FormatRawVector(const VTX::Vector& v) {
+        char val[160];
+        std::snprintf(val, sizeof(val), "X: %.*g Y: %.*g Z: %.*g", std::numeric_limits<float>::max_digits10, v.x,
+                      std::numeric_limits<float>::max_digits10, v.y, std::numeric_limits<float>::max_digits10, v.z);
+        return val;
     }
 
-    const auto type_it = global_cache->name_to_id.find(struct_name);
-    if (type_it == global_cache->name_to_id.end()) {
-        return nullptr;
+    std::string EntityInspectorViewService::FormatRawQuat(const VTX::Quat& q) {
+        char val[192];
+        std::snprintf(val, sizeof(val), "X: %.*g Y: %.*g Z: %.*g W: %.*g", std::numeric_limits<float>::max_digits10,
+                      q.x, std::numeric_limits<float>::max_digits10, q.y, std::numeric_limits<float>::max_digits10, q.z,
+                      std::numeric_limits<float>::max_digits10, q.w);
+        return val;
     }
 
-    return ResolveStructCache(global_cache, type_it->second);
-}
+    std::string EntityInspectorViewService::FormatRawTransform(const VTX::Transform& t) {
+        char val[384];
+        std::snprintf(
+            val, sizeof(val), "Loc(%.*g, %.*g, %.*g) Rot(%.*g, %.*g, %.*g, %.*g) Scale(%.*g, %.*g, %.*g)",
+            std::numeric_limits<float>::max_digits10, t.translation.x, std::numeric_limits<float>::max_digits10,
+            t.translation.y, std::numeric_limits<float>::max_digits10, t.translation.z,
+            std::numeric_limits<float>::max_digits10, t.rotation.x, std::numeric_limits<float>::max_digits10,
+            t.rotation.y, std::numeric_limits<float>::max_digits10, t.rotation.z,
+            std::numeric_limits<float>::max_digits10, t.rotation.w, std::numeric_limits<float>::max_digits10, t.scale.x,
+            std::numeric_limits<float>::max_digits10, t.scale.y, std::numeric_limits<float>::max_digits10, t.scale.z);
+        return val;
+    }
 
-std::string EntityInspectorViewService::ResolveSchemaName(
-    const VTX::PropertyAddressCache* global_cache,
-    const EntityPropertyNode& node) {
-    if (!global_cache || node.schema_index < 0 || node.struct_name.empty()) {
-        return "";
+    std::string EntityInspectorViewService::FormatRawRange(const VTX::FloatRange& r) {
+        char val[192];
+        std::snprintf(val, sizeof(val), "Min: %.*g Max: %.*g ValNorm: %.*g", std::numeric_limits<float>::max_digits10,
+                      r.min, std::numeric_limits<float>::max_digits10, r.max, std::numeric_limits<float>::max_digits10,
+                      r.value_normalized);
+        return val;
     }
 
-    const auto* struct_cache = ResolveStructCache(global_cache, node.struct_name);
-    return ResolveSchemaName(
-        struct_cache,
-        node.schema_type,
-        node.schema_container_type,
-        static_cast<size_t>(node.schema_index));
-}
+    std::string EntityInspectorViewService::FormatRawFloat(float value) {
+        char val[64];
+        std::snprintf(val, sizeof(val), "%.*g", std::numeric_limits<float>::max_digits10, value);
+        return val;
+    }
 
-std::string EntityInspectorViewService::ResolveStructName(const VTX::StructSchemaCache* struct_cache) {
-    if (!struct_cache) {
-        return "";
+    std::string EntityInspectorViewService::FormatRawDouble(double value) {
+        char val[64];
+        std::snprintf(val, sizeof(val), "%.*g", std::numeric_limits<double>::max_digits10, value);
+        return val;
     }
-    return struct_cache->name;
-}
-
-std::string EntityInspectorViewService::FormatVector(const VTX::Vector& v) {
-    char val[128];
-    std::snprintf(val, sizeof(val), "X: %.3f Y: %.3f Z: %.3f", v.x, v.y, v.z);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatQuat(const VTX::Quat& q) {
-    char val[128];
-    std::snprintf(val, sizeof(val), "X: %.3f Y: %.3f Z: %.3f W: %.3f", q.x, q.y, q.z, q.w);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatTransform(const VTX::Transform& t) {
-    char val[320];
-    std::snprintf(
-        val,
-        sizeof(val),
-        "Loc(%.1f, %.1f, %.1f) Rot(%.2f, %.2f, %.2f, %.2f) Scale(%.2f, %.2f, %.2f)",
-        t.translation.x,
-        t.translation.y,
-        t.translation.z,
-        t.rotation.x,
-        t.rotation.y,
-        t.rotation.z,
-        t.rotation.w,
-        t.scale.x,
-        t.scale.y,
-        t.scale.z);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRange(const VTX::FloatRange& r) {
-    char val[128];
-    std::snprintf(val, sizeof(val), "Min: %.2f Max: %.2f ValNorm: %.2f", r.min, r.max, r.value_normalized);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatFloat(float value) {
-    char val[64];
-    std::snprintf(val, sizeof(val), "%.4f", value);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatDouble(double value) {
-    char val[64];
-    std::snprintf(val, sizeof(val), "%.6f", value);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRawVector(const VTX::Vector& v) {
-    char val[160];
-    std::snprintf(
-        val,
-        sizeof(val),
-        "X: %.*g Y: %.*g Z: %.*g",
-        std::numeric_limits<float>::max_digits10,
-        v.x,
-        std::numeric_limits<float>::max_digits10,
-        v.y,
-        std::numeric_limits<float>::max_digits10,
-        v.z);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRawQuat(const VTX::Quat& q) {
-    char val[192];
-    std::snprintf(
-        val,
-        sizeof(val),
-        "X: %.*g Y: %.*g Z: %.*g W: %.*g",
-        std::numeric_limits<float>::max_digits10,
-        q.x,
-        std::numeric_limits<float>::max_digits10,
-        q.y,
-        std::numeric_limits<float>::max_digits10,
-        q.z,
-        std::numeric_limits<float>::max_digits10,
-        q.w);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRawTransform(const VTX::Transform& t) {
-    char val[384];
-    std::snprintf(
-        val,
-        sizeof(val),
-        "Loc(%.*g, %.*g, %.*g) Rot(%.*g, %.*g, %.*g, %.*g) Scale(%.*g, %.*g, %.*g)",
-        std::numeric_limits<float>::max_digits10,
-        t.translation.x,
-        std::numeric_limits<float>::max_digits10,
-        t.translation.y,
-        std::numeric_limits<float>::max_digits10,
-        t.translation.z,
-        std::numeric_limits<float>::max_digits10,
-        t.rotation.x,
-        std::numeric_limits<float>::max_digits10,
-        t.rotation.y,
-        std::numeric_limits<float>::max_digits10,
-        t.rotation.z,
-        std::numeric_limits<float>::max_digits10,
-        t.rotation.w,
-        std::numeric_limits<float>::max_digits10,
-        t.scale.x,
-        std::numeric_limits<float>::max_digits10,
-        t.scale.y,
-        std::numeric_limits<float>::max_digits10,
-        t.scale.z);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRawRange(const VTX::FloatRange& r) {
-    char val[192];
-    std::snprintf(
-        val,
-        sizeof(val),
-        "Min: %.*g Max: %.*g ValNorm: %.*g",
-        std::numeric_limits<float>::max_digits10,
-        r.min,
-        std::numeric_limits<float>::max_digits10,
-        r.max,
-        std::numeric_limits<float>::max_digits10,
-        r.value_normalized);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRawFloat(float value) {
-    char val[64];
-    std::snprintf(val, sizeof(val), "%.*g", std::numeric_limits<float>::max_digits10, value);
-    return val;
-}
-
-std::string EntityInspectorViewService::FormatRawDouble(double value) {
-    char val[64];
-    std::snprintf(val, sizeof(val), "%.*g", std::numeric_limits<double>::max_digits10, value);
-    return val;
-}
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/field_type_utils.cpp b/tools/inspector/src/services/field_type_utils.cpp
index c389439..df9c956 100644
--- a/tools/inspector/src/services/field_type_utils.cpp
+++ b/tools/inspector/src/services/field_type_utils.cpp
@@ -2,24 +2,39 @@
 
 namespace VtxServices {
 
-const char* FieldTypeToString(VTX::FieldType type_id) {
-    switch (type_id) {
-        case VTX::FieldType::None:          return "None";
-        case VTX::FieldType::Int8:          return "Int8";
-        case VTX::FieldType::Int32:         return "Int32";
-        case VTX::FieldType::Int64:         return "Int64";
-        case VTX::FieldType::Float:         return "Float";
-        case VTX::FieldType::Double:        return "Double";
-        case VTX::FieldType::Bool:          return "Bool";
-        case VTX::FieldType::String:        return "String";
-        case VTX::FieldType::Vector:        return "Vector";
-        case VTX::FieldType::Quat:          return "Quat";
-        case VTX::FieldType::Transform:     return "Transform";
-        case VTX::FieldType::FloatRange:    return "FloatRange";
-        case VTX::FieldType::Struct: return "Struct";
-        case VTX::FieldType::Enum:          return "Enum";
-        default:                            return "Unknown";
+    const char* FieldTypeToString(VTX::FieldType type_id) {
+        switch (type_id) {
+        case VTX::FieldType::None:
+            return "None";
+        case VTX::FieldType::Int8:
+            return "Int8";
+        case VTX::FieldType::Int32:
+            return "Int32";
+        case VTX::FieldType::Int64:
+            return "Int64";
+        case VTX::FieldType::Float:
+            return "Float";
+        case VTX::FieldType::Double:
+            return "Double";
+        case VTX::FieldType::Bool:
+            return "Bool";
+        case VTX::FieldType::String:
+            return "String";
+        case VTX::FieldType::Vector:
+            return "Vector";
+        case VTX::FieldType::Quat:
+            return "Quat";
+        case VTX::FieldType::Transform:
+            return "Transform";
+        case VTX::FieldType::FloatRange:
+            return "FloatRange";
+        case VTX::FieldType::Struct:
+            return "Struct";
+        case VTX::FieldType::Enum:
+            return "Enum";
+        default:
+            return "Unknown";
+        }
     }
-}
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/footer_summary_service.cpp b/tools/inspector/src/services/footer_summary_service.cpp
index 2ea8315..0f587b9 100644
--- a/tools/inspector/src/services/footer_summary_service.cpp
+++ b/tools/inspector/src/services/footer_summary_service.cpp
@@ -6,334 +6,314 @@
 
 #include "services/time_display_service.h"
 namespace {
-// Formats replay duration using compact h/m/s/ms units plus total seconds.
-std::string FormatDurationLabel(float duration_seconds) {
-    const float clamped_seconds = std::max(0.0f, duration_seconds);
-    const int64_t total_milliseconds = static_cast<int64_t>(clamped_seconds * 1000.0f + 0.5f);
-    const int64_t hours = total_milliseconds / 3600000;
-    const int64_t minutes = (total_milliseconds % 3600000) / 60000;
-    const int64_t seconds = (total_milliseconds % 60000) / 1000;
-    const int64_t milliseconds = total_milliseconds % 1000;
-
-    char units_buffer[128];
-    if (hours > 0) {
-        std::snprintf(
-            units_buffer,
-            sizeof(units_buffer),
-            "%lldh %lldm %llds %lldms",
-            static_cast<long long>(hours),
-            static_cast<long long>(minutes),
-            static_cast<long long>(seconds),
-            static_cast<long long>(milliseconds));
-    } else if (minutes > 0) {
-        std::snprintf(
-            units_buffer,
-            sizeof(units_buffer),
-            "%lldm %llds %lldms",
-            static_cast<long long>(minutes),
-            static_cast<long long>(seconds),
-            static_cast<long long>(milliseconds));
-    } else {
-        std::snprintf(
-            units_buffer,
-            sizeof(units_buffer),
-            "%llds %lldms",
-            static_cast<long long>(seconds),
-            static_cast<long long>(milliseconds));
-    }
+    // Formats replay duration using compact h/m/s/ms units plus total seconds.
+    std::string FormatDurationLabel(float duration_seconds) {
+        const float clamped_seconds = std::max(0.0f, duration_seconds);
+        const int64_t total_milliseconds = static_cast<int64_t>(clamped_seconds * 1000.0f + 0.5f);
+        const int64_t hours = total_milliseconds / 3600000;
+        const int64_t minutes = (total_milliseconds % 3600000) / 60000;
+        const int64_t seconds = (total_milliseconds % 60000) / 1000;
+        const int64_t milliseconds = total_milliseconds % 1000;
+
+        char units_buffer[128];
+        if (hours > 0) {
+            std::snprintf(units_buffer, sizeof(units_buffer), "%lldh %lldm %llds %lldms", static_cast<long long>(hours),
+                          static_cast<long long>(minutes), static_cast<long long>(seconds),
+                          static_cast<long long>(milliseconds));
+        } else if (minutes > 0) {
+            std::snprintf(units_buffer, sizeof(units_buffer), "%lldm %llds %lldms", static_cast<long long>(minutes),
+                          static_cast<long long>(seconds), static_cast<long long>(milliseconds));
+        } else {
+            std::snprintf(units_buffer, sizeof(units_buffer), "%llds %lldms", static_cast<long long>(seconds),
+                          static_cast<long long>(milliseconds));
+        }
 
-    char final_buffer[160];
-    std::snprintf(final_buffer, sizeof(final_buffer), "%s (%.1f sec)", units_buffer, clamped_seconds);
-    return final_buffer;
-}
+        char final_buffer[160];
+        std::snprintf(final_buffer, sizeof(final_buffer), "%s (%.1f sec)", units_buffer, clamped_seconds);
+        return final_buffer;
+    }
 } // namespace
 
 namespace VtxServices {
 
-FileInfoViewModel FooterSummaryService::BuildFileInfoViewModel(
-    const std::string& file_path,
-    float file_size_mb,
-    VTX::VtxFormat format,
-    const VTX::FileHeader& header,
-    const VTX::FileFooter& footer) {
-    FileInfoViewModel view_model;
-    view_model.file_path = file_path;
-
-    FileInfoSection header_section;
-    header_section.title = "File Header";
-    header_section.default_open = true;
-    header_section.rows = {
-        FileInfoRow{"Internal Format", ResolvePayloadFormatLabel(format), FileInfoTone::Success},
-        FileInfoRow{"File Size", [&]() {
-            char buffer[64];
-            std::snprintf(buffer, sizeof(buffer), "%.2f MB", file_size_mb);
-            return std::string(buffer);
-        }(), FileInfoTone::Highlight},
-        FileInfoRow{"Replay Name", header.replay_name, FileInfoTone::Highlight},
-        FileInfoRow{"UUID", header.replay_uuid, FileInfoTone::Disabled},
-        FileInfoRow{
-            "Recorded UTC",
-            TimeDisplayService::FormatUnixSecondsAsRssWithRaw(header.recorded_utc_timestamp),
-            FileInfoTone::Normal},
-    };
-
-    FileInfoSection version_section;
-    version_section.title = "Version Info";
-    version_section.default_open = true;
-    version_section.rows = {
-        FileInfoRow{"Format Version", "v" + std::to_string(header.version.format_major) + "." + std::to_string(header.version.format_minor)},
-        FileInfoRow{"Schema Version", "v" + std::to_string(header.version.schema_version)},
-    };
-
-    FileInfoSection metadata_section;
-    metadata_section.title = "Custom Metadata";
-    metadata_section.render_as_raw_text = true;
-    metadata_section.raw_text = header.custom_json_metadata;
-
-    FileInfoSection footer_section;
-    footer_section.title = "File Footer";
-    footer_section.default_open = true;
-    for (const auto& row : BuildFooterSummaryRows(footer)) {
-        footer_section.rows.push_back(FileInfoRow{
-            .label = row.label,
-            .value = row.value,
-            .tone = row.label == "Payload Checksum" ? FileInfoTone::Disabled : FileInfoTone::Normal,
-        });
+    FileInfoViewModel FooterSummaryService::BuildFileInfoViewModel(const std::string& file_path, float file_size_mb,
+                                                                   VTX::VtxFormat format, const VTX::FileHeader& header,
+                                                                   const VTX::FileFooter& footer) {
+        FileInfoViewModel view_model;
+        view_model.file_path = file_path;
+
+        FileInfoSection header_section;
+        header_section.title = "File Header";
+        header_section.default_open = true;
+        header_section.rows = {
+            FileInfoRow {"Internal Format", ResolvePayloadFormatLabel(format), FileInfoTone::Success},
+            FileInfoRow {"File Size",
+                         [&]() {
+                             char buffer[64];
+                             std::snprintf(buffer, sizeof(buffer), "%.2f MB", file_size_mb);
+                             return std::string(buffer);
+                         }(),
+                         FileInfoTone::Highlight},
+            FileInfoRow {"Replay Name", header.replay_name, FileInfoTone::Highlight},
+            FileInfoRow {"UUID", header.replay_uuid, FileInfoTone::Disabled},
+            FileInfoRow {"Recorded UTC",
+                         TimeDisplayService::FormatUnixSecondsAsRssWithRaw(header.recorded_utc_timestamp),
+                         FileInfoTone::Normal},
+        };
+
+        FileInfoSection version_section;
+        version_section.title = "Version Info";
+        version_section.default_open = true;
+        version_section.rows = {
+            FileInfoRow {"Format Version", "v" + std::to_string(header.version.format_major) + "." +
+                                               std::to_string(header.version.format_minor)},
+            FileInfoRow {"Schema Version", "v" + std::to_string(header.version.schema_version)},
+        };
+
+        FileInfoSection metadata_section;
+        metadata_section.title = "Custom Metadata";
+        metadata_section.render_as_raw_text = true;
+        metadata_section.raw_text = header.custom_json_metadata;
+
+        FileInfoSection footer_section;
+        footer_section.title = "File Footer";
+        footer_section.default_open = true;
+        for (const auto& row : BuildFooterSummaryRows(footer)) {
+            footer_section.rows.push_back(FileInfoRow {
+                .label = row.label,
+                .value = row.value,
+                .tone = row.label == "Payload Checksum" ? FileInfoTone::Disabled : FileInfoTone::Normal,
+            });
+        }
+
+        view_model.sections = {
+            std::move(header_section),
+            std::move(version_section),
+            std::move(metadata_section),
+            std::move(footer_section),
+        };
+        return view_model;
     }
 
-    view_model.sections = {
-        std::move(header_section),
-        std::move(version_section),
-        std::move(metadata_section),
-        std::move(footer_section),
-    };
-    return view_model;
-}
-
-std::string FooterSummaryService::ResolvePayloadFormatLabel(VTX::VtxFormat format) {
-    return format == VTX::VtxFormat::Protobuf ? "Protobuf" : "FlatBuffers";
-}
-
-std::string FooterSummaryService::FormatChunkSize(uint32_t chunk_size_bytes) {
-    char buffer[64];
-    if (chunk_size_bytes >= 1024 * 1024) {
-        std::snprintf(buffer, sizeof(buffer), "%.2f MB", static_cast<float>(chunk_size_bytes) / (1024.0f * 1024.0f));
-    } else if (chunk_size_bytes >= 1024) {
-        std::snprintf(buffer, sizeof(buffer), "%.1f KB", static_cast<float>(chunk_size_bytes) / 1024.0f);
-    } else {
-        std::snprintf(buffer, sizeof(buffer), "%u B", chunk_size_bytes);
+    std::string FooterSummaryService::ResolvePayloadFormatLabel(VTX::VtxFormat format) {
+        return format == VTX::VtxFormat::Protobuf ? "Protobuf" : "FlatBuffers";
     }
-    return buffer;
-}
-
-std::string FooterSummaryService::FormatFileOffset(uint64_t file_offset) {
-    char buffer[64];
-    std::snprintf(buffer, sizeof(buffer), "0x%llX", static_cast<unsigned long long>(file_offset));
-    return buffer;
-}
-
-std::string FooterSummaryService::FormatLocation(const VTX::Vector& location) {
-    char buffer[96];
-    std::snprintf(buffer, sizeof(buffer), "(%.0f, %.0f, %.0f)", location.x, location.y, location.z);
-    return buffer;
-}
-
-std::string FooterSummaryService::FormatGameTime(float game_time_seconds) {
-    char buffer[32];
-    std::snprintf(buffer, sizeof(buffer), "%.2fs", game_time_seconds);
-    return buffer;
-}
-
-std::vector<SummaryRow> FooterSummaryService::BuildReplayTimeSummaryRows(const VTX::ReplayTimeData& time_data) {
-    return {
-        {"Game Timestamps", std::to_string(time_data.game_time.size())},
-        {"UTC Timestamps", std::to_string(time_data.created_utc.size())},
-        {"Gaps", std::to_string(time_data.gaps.size())},
-        {"Segments", std::to_string(time_data.segments.size())},
-    };
-}
-
-std::vector<SummaryRow> FooterSummaryService::BuildPropertySchemaSummaryRows(const VTX::PropertySchema& prop_schema) {
-    return {
-        {"Int Mappings", std::to_string(prop_schema.int_mapping.size())},
-        {"Float Mappings", std::to_string(prop_schema.float_mapping.size())},
-        {"Bool Mappings", std::to_string(prop_schema.bool_mapping.size())},
-        {"String Mappings", std::to_string(prop_schema.string_mapping.size())},
-        {"Vector Mappings", std::to_string(prop_schema.vector_mapping.size())},
-        {"Transform Mappings", std::to_string(prop_schema.transform_mapping.size())},
-    };
-}
-
-std::vector<std::string> FooterSummaryService::BuildReplayTimeTabLabels(const VTX::ReplayTimeData& time_data) {
-    return {
-        "Game Timestamps (" + std::to_string(time_data.game_time.size()) + ")###GameTimeTab",
-        "UTC Timestamps (" + std::to_string(time_data.created_utc.size()) + ")###UTCTab",
-        "Gaps (" + std::to_string(time_data.gaps.size()) + ")###GapsTab",
-        "Segments (" + std::to_string(time_data.segments.size()) + ")###SegsTab",
-    };
-}
-
-std::vector<SummaryRow> FooterSummaryService::BuildFooterSummaryRows(const VTX::FileFooter& footer) {
-    const std::string duration_label = FormatDurationLabel(footer.duration_seconds);
-
-    std::vector<SummaryRow> rows = {
-        {"Total Frames", std::to_string(footer.total_frames)},
-        {"Duration", duration_label},
-        {"Data Chunks", std::to_string(footer.chunk_index.size())},
-        {"Timeline Events", std::to_string(footer.events.size())},
-    };
-
-    if (footer.total_frames > 0 && footer.duration_seconds > 0.0f) {
-        char fps_buffer[32];
-        const float fps = static_cast<float>(footer.total_frames) / footer.duration_seconds;
-        std::snprintf(fps_buffer, sizeof(fps_buffer), "%.1f", fps);
-        rows.insert(rows.begin() + 2, SummaryRow{"Avg FPS", fps_buffer});
+
+    std::string FooterSummaryService::FormatChunkSize(uint32_t chunk_size_bytes) {
+        char buffer[64];
+        if (chunk_size_bytes >= 1024 * 1024) {
+            std::snprintf(buffer, sizeof(buffer), "%.2f MB",
+                          static_cast<float>(chunk_size_bytes) / (1024.0f * 1024.0f));
+        } else if (chunk_size_bytes >= 1024) {
+            std::snprintf(buffer, sizeof(buffer), "%.1f KB", static_cast<float>(chunk_size_bytes) / 1024.0f);
+        } else {
+            std::snprintf(buffer, sizeof(buffer), "%u B", chunk_size_bytes);
+        }
+        return buffer;
     }
 
-    char checksum_buffer[64];
-    std::snprintf(checksum_buffer, sizeof(checksum_buffer), "0x%llX",
-                  static_cast<unsigned long long>(footer.payload_checksum));
-    rows.push_back({"Payload Checksum", checksum_buffer});
-    return rows;
-}
-
-// Builds chunk index rows for chunk metadata columns.
-std::vector<ChunkIndexRow> FooterSummaryService::BuildChunkRows(
-    const std::vector<VTX::ChunkIndexEntry>& chunk_index) {
-    std::vector<ChunkIndexRow> rows;
-    rows.reserve(chunk_index.size());
-    for (const auto& c : chunk_index) {
-        ChunkIndexRow row;
-        row.chunk_index = c.chunk_index;
-
-        char frame_range[64];
-        std::snprintf(frame_range, sizeof(frame_range), "%d - %d", c.start_frame, c.end_frame);
-        row.frame_range = frame_range;
-
-        row.file_offset = FormatFileOffset(c.file_offset);
-        row.chunk_size = FormatChunkSize(c.chunk_size_bytes);
-        row.frames_per_chunk = c.end_frame - c.start_frame + 1;
-        rows.push_back(std::move(row));
+    std::string FooterSummaryService::FormatFileOffset(uint64_t file_offset) {
+        char buffer[64];
+        std::snprintf(buffer, sizeof(buffer), "0x%llX", static_cast<unsigned long long>(file_offset));
+        return buffer;
     }
 
-    return rows;
-}
-
-std::vector<TimelineEventRow> FooterSummaryService::BuildTimelineEventRows(const std::vector<VTX::TimelineEvent>& events) {
-    std::vector<TimelineEventRow> rows;
-    rows.reserve(events.size());
-    for (const auto& ev : events) {
-        rows.push_back(TimelineEventRow{
-            .game_time = FormatGameTime(ev.game_time),
-            .event_type = ev.event_type,
-            .label = ev.label,
-            .location = FormatLocation(ev.location),
-            .entity_id = ev.entity_unique_id,
-        });
+    std::string FooterSummaryService::FormatLocation(const VTX::Vector& location) {
+        char buffer[96];
+        std::snprintf(buffer, sizeof(buffer), "(%.0f, %.0f, %.0f)", location.x, location.y, location.z);
+        return buffer;
+    }
+
+    std::string FooterSummaryService::FormatGameTime(float game_time_seconds) {
+        char buffer[32];
+        std::snprintf(buffer, sizeof(buffer), "%.2fs", game_time_seconds);
+        return buffer;
+    }
+
+    std::vector<SummaryRow> FooterSummaryService::BuildReplayTimeSummaryRows(const VTX::ReplayTimeData& time_data) {
+        return {
+            {"Game Timestamps", std::to_string(time_data.game_time.size())},
+            {"UTC Timestamps", std::to_string(time_data.created_utc.size())},
+            {"Gaps", std::to_string(time_data.gaps.size())},
+            {"Segments", std::to_string(time_data.segments.size())},
+        };
+    }
+
+    std::vector<SummaryRow>
+    FooterSummaryService::BuildPropertySchemaSummaryRows(const VTX::PropertySchema& prop_schema) {
+        return {
+            {"Int Mappings", std::to_string(prop_schema.int_mapping.size())},
+            {"Float Mappings", std::to_string(prop_schema.float_mapping.size())},
+            {"Bool Mappings", std::to_string(prop_schema.bool_mapping.size())},
+            {"String Mappings", std::to_string(prop_schema.string_mapping.size())},
+            {"Vector Mappings", std::to_string(prop_schema.vector_mapping.size())},
+            {"Transform Mappings", std::to_string(prop_schema.transform_mapping.size())},
+        };
+    }
+
+    std::vector<std::string> FooterSummaryService::BuildReplayTimeTabLabels(const VTX::ReplayTimeData& time_data) {
+        return {
+            "Game Timestamps (" + std::to_string(time_data.game_time.size()) + ")###GameTimeTab",
+            "UTC Timestamps (" + std::to_string(time_data.created_utc.size()) + ")###UTCTab",
+            "Gaps (" + std::to_string(time_data.gaps.size()) + ")###GapsTab",
+            "Segments (" + std::to_string(time_data.segments.size()) + ")###SegsTab",
+        };
     }
-    return rows;
-}
-
-// Builds replay-time tab values with synchronized tick/format display modes.
-ReplayTimeViewModel FooterSummaryService::BuildReplayTimeViewModel(
-    const VTX::ReplayTimeData& time_data,
-    TimeDisplayFormat time_display_format) {
-    ReplayTimeViewModel view_model;
-    view_model.summary_rows = BuildReplayTimeSummaryRows(time_data);
-    const auto labels = BuildReplayTimeTabLabels(time_data);
-
-    auto append_tick_tab = [
-        &view_model,
-        time_display_format](
-        const std::string& label,
-        const std::string& value_column_label,
-        const auto& values,
-        const auto& formatter) {
-        ReplayTimeTabViewModel tab;
-        tab.label = label;
-        tab.value_column_label = value_column_label;
-        tab.values.reserve(values.size());
-        for (const auto& value : values) {
-            tab.values.push_back(formatter(static_cast<uint64_t>(value), time_display_format));
+
+    std::vector<SummaryRow> FooterSummaryService::BuildFooterSummaryRows(const VTX::FileFooter& footer) {
+        const std::string duration_label = FormatDurationLabel(footer.duration_seconds);
+
+        std::vector<SummaryRow> rows = {
+            {"Total Frames", std::to_string(footer.total_frames)},
+            {"Duration", duration_label},
+            {"Data Chunks", std::to_string(footer.chunk_index.size())},
+            {"Timeline Events", std::to_string(footer.events.size())},
+        };
+
+        if (footer.total_frames > 0 && footer.duration_seconds > 0.0f) {
+            char fps_buffer[32];
+            const float fps = static_cast<float>(footer.total_frames) / footer.duration_seconds;
+            std::snprintf(fps_buffer, sizeof(fps_buffer), "%.1f", fps);
+            rows.insert(rows.begin() + 2, SummaryRow {"Avg FPS", fps_buffer});
         }
-        view_model.tabs.push_back(std::move(tab));
-    };
-
-    auto append_raw_tab = [&view_model](
-        const std::string& label,
-        const std::string& value_column_label,
-        const auto& values) {
-        ReplayTimeTabViewModel tab;
-        tab.label = label;
-        tab.value_column_label = value_column_label;
-        tab.values.reserve(values.size());
-        for (const auto& value : values) {
-            tab.values.push_back(std::to_string(value));
+
+        char checksum_buffer[64];
+        std::snprintf(checksum_buffer, sizeof(checksum_buffer), "0x%llX",
+                      static_cast<unsigned long long>(footer.payload_checksum));
+        rows.push_back({"Payload Checksum", checksum_buffer});
+        return rows;
+    }
+
+    // Builds chunk index rows for chunk metadata columns.
+    std::vector<ChunkIndexRow>
+    FooterSummaryService::BuildChunkRows(const std::vector<VTX::ChunkIndexEntry>& chunk_index) {
+        std::vector<ChunkIndexRow> rows;
+        rows.reserve(chunk_index.size());
+        for (const auto& c : chunk_index) {
+            ChunkIndexRow row;
+            row.chunk_index = c.chunk_index;
+
+            char frame_range[64];
+            std::snprintf(frame_range, sizeof(frame_range), "%d - %d", c.start_frame, c.end_frame);
+            row.frame_range = frame_range;
+
+            row.file_offset = FormatFileOffset(c.file_offset);
+            row.chunk_size = FormatChunkSize(c.chunk_size_bytes);
+            row.frames_per_chunk = c.end_frame - c.start_frame + 1;
+            rows.push_back(std::move(row));
+        }
+
+        return rows;
+    }
+
+    std::vector<TimelineEventRow>
+    FooterSummaryService::BuildTimelineEventRows(const std::vector<VTX::TimelineEvent>& events) {
+        std::vector<TimelineEventRow> rows;
+        rows.reserve(events.size());
+        for (const auto& ev : events) {
+            rows.push_back(TimelineEventRow {
+                .game_time = FormatGameTime(ev.game_time),
+                .event_type = ev.event_type,
+                .label = ev.label,
+                .location = FormatLocation(ev.location),
+                .entity_id = ev.entity_unique_id,
+            });
         }
-        view_model.tabs.push_back(std::move(tab));
-    };
-
-    append_tick_tab(labels[0], "Game Timestamps", time_data.game_time, TimeDisplayService::FormatGameTimeTicks);
-    append_tick_tab(labels[1], "UTC Timestamps", time_data.created_utc, TimeDisplayService::FormatUtcTicks);
-    append_raw_tab(labels[2], "Frame Index", time_data.gaps);
-    append_raw_tab(labels[3], "Frame Index", time_data.segments);
-    return view_model;
-}
-
-// Builds chunk index table presentation from chunk metadata.
-FooterTableViewModel FooterSummaryService::BuildChunkTableViewModel(
-    const std::vector<VTX::ChunkIndexEntry>& chunk_index) {
-    FooterTableViewModel view_model;
-    const auto rows = BuildChunkRows(chunk_index);
-    view_model.empty_message = "No chunks.";
-    view_model.count_label = std::to_string(rows.size()) + " chunks";
-    view_model.columns = {
-        FooterTableColumn{"Chunk", 50.0f, false, false, false},
-        FooterTableColumn{"Frames", 100.0f, false, false, false},
-        FooterTableColumn{"Offset", 100.0f, false, true, false},
-        FooterTableColumn{"Size", 90.0f, false, false, false},
-        FooterTableColumn{"Frames/Chunk", 90.0f, false, false, false},
-    };
-    view_model.rows.reserve(rows.size());
-    for (const auto& row : rows) {
-        FooterTableRow vm_row;
-        vm_row.cells = {
-            FooterTableCell{std::to_string(row.chunk_index)},
-            FooterTableCell{row.frame_range},
-            FooterTableCell{row.file_offset, true, false},
-            FooterTableCell{row.chunk_size},
-            FooterTableCell{std::to_string(row.frames_per_chunk)},
+        return rows;
+    }
+
+    // Builds replay-time tab values with synchronized tick/format display modes.
+    ReplayTimeViewModel FooterSummaryService::BuildReplayTimeViewModel(const VTX::ReplayTimeData& time_data,
+                                                                       TimeDisplayFormat time_display_format) {
+        ReplayTimeViewModel view_model;
+        view_model.summary_rows = BuildReplayTimeSummaryRows(time_data);
+        const auto labels = BuildReplayTimeTabLabels(time_data);
+
+        auto append_tick_tab = [&view_model, time_display_format](const std::string& label,
+                                                                  const std::string& value_column_label,
+                                                                  const auto& values, const auto& formatter) {
+            ReplayTimeTabViewModel tab;
+            tab.label = label;
+            tab.value_column_label = value_column_label;
+            tab.values.reserve(values.size());
+            for (const auto& value : values) {
+                tab.values.push_back(formatter(static_cast<uint64_t>(value), time_display_format));
+            }
+            view_model.tabs.push_back(std::move(tab));
+        };
+
+        auto append_raw_tab = [&view_model](const std::string& label, const std::string& value_column_label,
+                                            const auto& values) {
+            ReplayTimeTabViewModel tab;
+            tab.label = label;
+            tab.value_column_label = value_column_label;
+            tab.values.reserve(values.size());
+            for (const auto& value : values) {
+                tab.values.push_back(std::to_string(value));
+            }
+            view_model.tabs.push_back(std::move(tab));
         };
-        view_model.rows.push_back(std::move(vm_row));
+
+        append_tick_tab(labels[0], "Game Timestamps", time_data.game_time, TimeDisplayService::FormatGameTimeTicks);
+        append_tick_tab(labels[1], "UTC Timestamps", time_data.created_utc, TimeDisplayService::FormatUtcTicks);
+        append_raw_tab(labels[2], "Frame Index", time_data.gaps);
+        append_raw_tab(labels[3], "Frame Index", time_data.segments);
+        return view_model;
     }
-    return view_model;
-}
-
-FooterTableViewModel FooterSummaryService::BuildTimelineEventsTableViewModel(const std::vector<VTX::TimelineEvent>& events) {
-    FooterTableViewModel view_model;
-    const auto rows = BuildTimelineEventRows(events);
-    view_model.empty_message = "No events.";
-    view_model.count_label = std::to_string(rows.size()) + " events";
-    view_model.columns = {
-        FooterTableColumn{"Time", 70.0f, false, false, false},
-        FooterTableColumn{"Type", 100.0f, false, false, true},
-        FooterTableColumn{"Label", 0.0f, true, false, false},
-        FooterTableColumn{"Location", 180.0f, false, true, false},
-        FooterTableColumn{"Entity ID", 120.0f, false, true, false},
-    };
-    view_model.rows.reserve(rows.size());
-    for (const auto& row : rows) {
-        FooterTableRow vm_row;
-        vm_row.cells = {
-            FooterTableCell{row.game_time},
-            FooterTableCell{row.event_type, false, true},
-            FooterTableCell{row.label},
-            FooterTableCell{row.location, true, false},
-            FooterTableCell{row.entity_id, true, false},
+
+    // Builds chunk index table presentation from chunk metadata.
+    FooterTableViewModel
+    FooterSummaryService::BuildChunkTableViewModel(const std::vector<VTX::ChunkIndexEntry>& chunk_index) {
+        FooterTableViewModel view_model;
+        const auto rows = BuildChunkRows(chunk_index);
+        view_model.empty_message = "No chunks.";
+        view_model.count_label = std::to_string(rows.size()) + " chunks";
+        view_model.columns = {
+            FooterTableColumn {"Chunk", 50.0f, false, false, false},
+            FooterTableColumn {"Frames", 100.0f, false, false, false},
+            FooterTableColumn {"Offset", 100.0f, false, true, false},
+            FooterTableColumn {"Size", 90.0f, false, false, false},
+            FooterTableColumn {"Frames/Chunk", 90.0f, false, false, false},
         };
-        view_model.rows.push_back(std::move(vm_row));
+        view_model.rows.reserve(rows.size());
+        for (const auto& row : rows) {
+            FooterTableRow vm_row;
+            vm_row.cells = {
+                FooterTableCell {std::to_string(row.chunk_index)},      FooterTableCell {row.frame_range},
+                FooterTableCell {row.file_offset, true, false},         FooterTableCell {row.chunk_size},
+                FooterTableCell {std::to_string(row.frames_per_chunk)},
+            };
+            view_model.rows.push_back(std::move(vm_row));
+        }
+        return view_model;
+    }
+
+    FooterTableViewModel
+    FooterSummaryService::BuildTimelineEventsTableViewModel(const std::vector<VTX::TimelineEvent>& events) {
+        FooterTableViewModel view_model;
+        const auto rows = BuildTimelineEventRows(events);
+        view_model.empty_message = "No events.";
+        view_model.count_label = std::to_string(rows.size()) + " events";
+        view_model.columns = {
+            FooterTableColumn {"Time", 70.0f, false, false, false},
+            FooterTableColumn {"Type", 100.0f, false, false, true},
+            FooterTableColumn {"Label", 0.0f, true, false, false},
+            FooterTableColumn {"Location", 180.0f, false, true, false},
+            FooterTableColumn {"Entity ID", 120.0f, false, true, false},
+        };
+        view_model.rows.reserve(rows.size());
+        for (const auto& row : rows) {
+            FooterTableRow vm_row;
+            vm_row.cells = {
+                FooterTableCell {row.game_time},
+                FooterTableCell {row.event_type, false, true},
+                FooterTableCell {row.label},
+                FooterTableCell {row.location, true, false},
+                FooterTableCell {row.entity_id, true, false},
+            };
+            view_model.rows.push_back(std::move(vm_row));
+        }
+        return view_model;
     }
-    return view_model;
-}
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/playback_service.cpp b/tools/inspector/src/services/playback_service.cpp
index f99b108..aa041ae 100644
--- a/tools/inspector/src/services/playback_service.cpp
+++ b/tools/inspector/src/services/playback_service.cpp
@@ -2,45 +2,45 @@
 
 namespace VtxServices {
 
-int PlaybackService::Update(float delta_time_seconds, int current_frame, int total_frames, float duration_seconds) {
-    if (!is_playing_ || total_frames <= 0 || duration_seconds <= 0.0f) {
-        return current_frame;
-    }
+    int PlaybackService::Update(float delta_time_seconds, int current_frame, int total_frames, float duration_seconds) {
+        if (!is_playing_ || total_frames <= 0 || duration_seconds <= 0.0f) {
+            return current_frame;
+        }
 
-    float fps = static_cast<float>(total_frames) / duration_seconds;
-    float time_per_frame = 1.0f / fps;
+        float fps = static_cast<float>(total_frames) / duration_seconds;
+        float time_per_frame = 1.0f / fps;
 
-    time_accumulator_ += delta_time_seconds * playback_speed_;
+        time_accumulator_ += delta_time_seconds * playback_speed_;
 
-    while (time_accumulator_ >= time_per_frame) {
-        current_frame++;
-        time_accumulator_ -= time_per_frame;
+        while (time_accumulator_ >= time_per_frame) {
+            current_frame++;
+            time_accumulator_ -= time_per_frame;
 
-        if (current_frame >= total_frames) {
-            current_frame = total_frames - 1;
-            is_playing_ = false;
-            break;
+            if (current_frame >= total_frames) {
+                current_frame = total_frames - 1;
+                is_playing_ = false;
+                break;
+            }
         }
-    }
 
-    return current_frame;
-}
+        return current_frame;
+    }
 
-void PlaybackService::Play(int current_frame, int total_frames) {
-    if (current_frame >= total_frames - 1) {
-        // Reset if at end
-        time_accumulator_ = 0.0f;
+    void PlaybackService::Play(int current_frame, int total_frames) {
+        if (current_frame >= total_frames - 1) {
+            // Reset if at end
+            time_accumulator_ = 0.0f;
+        }
+        is_playing_ = true;
     }
-    is_playing_ = true;
-}
 
-void PlaybackService::Pause() {
-    is_playing_ = false;
-}
+    void PlaybackService::Pause() {
+        is_playing_ = false;
+    }
 
-void PlaybackService::Stop() {
-    is_playing_ = false;
-    time_accumulator_ = 0.0f;
-}
+    void PlaybackService::Stop() {
+        is_playing_ = false;
+        time_accumulator_ = 0.0f;
+    }
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/reader_chunk_state_service.cpp b/tools/inspector/src/services/reader_chunk_state_service.cpp
index 11ba747..63580a2 100644
--- a/tools/inspector/src/services/reader_chunk_state_service.cpp
+++ b/tools/inspector/src/services/reader_chunk_state_service.cpp
@@ -2,55 +2,55 @@
 
 namespace VtxServices {
 
-ReaderProfileViewModel ReaderChunkStateService::BuildProfileViewModel(
-    const VTX::ReaderChunkSnapshot& snapshot,
-    double ui_time_seconds,
-    ReaderProfileCacheState& io_cache) {
-    if (io_cache.last_loaded != snapshot.loaded_chunks || io_cache.last_loading != snapshot.loading_chunks) {
-        io_cache.last_loaded = snapshot.loaded_chunks;
-        io_cache.last_loading = snapshot.loading_chunks;
-
-        io_cache.cached_loaded_str.clear();
-        for (int id : io_cache.last_loaded) {
-            io_cache.cached_loaded_str += std::to_string(id) + " ";
+    ReaderProfileViewModel ReaderChunkStateService::BuildProfileViewModel(const VTX::ReaderChunkSnapshot& snapshot,
+                                                                          double ui_time_seconds,
+                                                                          ReaderProfileCacheState& io_cache) {
+        if (io_cache.last_loaded != snapshot.loaded_chunks || io_cache.last_loading != snapshot.loading_chunks) {
+            io_cache.last_loaded = snapshot.loaded_chunks;
+            io_cache.last_loading = snapshot.loading_chunks;
+
+            io_cache.cached_loaded_str.clear();
+            for (int id : io_cache.last_loaded) {
+                io_cache.cached_loaded_str += std::to_string(id) + " ";
+            }
+
+            io_cache.cached_loading_str.clear();
+            for (int id : io_cache.last_loading) {
+                io_cache.cached_loading_str += std::to_string(id) + " ";
+            }
         }
 
-        io_cache.cached_loading_str.clear();
-        for (int id : io_cache.last_loading) {
-            io_cache.cached_loading_str += std::to_string(id) + " ";
-        }
+        const char* spinner = "|/-\\";
+        const int spinner_idx = static_cast<int>(ui_time_seconds * 10.0) % 4;
+
+        ReaderProfileViewModel vm;
+        vm.loaded_count = io_cache.last_loaded.size();
+        vm.loading_count = io_cache.last_loading.size();
+        vm.loaded_chunk_ids = io_cache.cached_loaded_str;
+        vm.loading_chunk_ids = io_cache.cached_loading_str;
+        vm.has_pending_chunks = !io_cache.last_loading.empty();
+        vm.spinner = spinner[spinner_idx];
+        return vm;
     }
 
-    const char* spinner = "|/-\\";
-    const int spinner_idx = static_cast<int>(ui_time_seconds * 10.0) % 4;
-
-    ReaderProfileViewModel vm;
-    vm.loaded_count = io_cache.last_loaded.size();
-    vm.loading_count = io_cache.last_loading.size();
-    vm.loaded_chunk_ids = io_cache.cached_loaded_str;
-    vm.loading_chunk_ids = io_cache.cached_loading_str;
-    vm.has_pending_chunks = !io_cache.last_loading.empty();
-    vm.spinner = spinner[spinner_idx];
-    return vm;
-}
-
-std::vector<ReaderProfileRow> ReaderChunkStateService::BuildProfileRows(const ReaderProfileViewModel& view_model) {
-    std::vector<ReaderProfileRow> rows;
-    rows.push_back(ReaderProfileRow{
-        .state_label = "Loaded (RAM) [" + std::to_string(view_model.loaded_count) + "]",
-        .chunk_text = view_model.loaded_count == 0 ? "None" : view_model.loaded_chunk_ids,
-        .highlighted = true,
-        .disabled = view_model.loaded_count == 0,
-    });
-    rows.push_back(ReaderProfileRow{
-        .state_label = view_model.has_pending_chunks
-            ? "Pending (I/O) " + std::string(1, view_model.spinner) + " [" + std::to_string(view_model.loading_count) + "]"
-            : "Pending (I/O) [" + std::to_string(view_model.loading_count) + "]",
-        .chunk_text = view_model.has_pending_chunks ? view_model.loading_chunk_ids : "Idle",
-        .highlighted = view_model.has_pending_chunks,
-        .disabled = !view_model.has_pending_chunks,
-    });
-    return rows;
-}
+    std::vector<ReaderProfileRow> ReaderChunkStateService::BuildProfileRows(const ReaderProfileViewModel& view_model) {
+        std::vector<ReaderProfileRow> rows;
+        rows.push_back(ReaderProfileRow {
+            .state_label = "Loaded (RAM) [" + std::to_string(view_model.loaded_count) + "]",
+            .chunk_text = view_model.loaded_count == 0 ? "None" : view_model.loaded_chunk_ids,
+            .highlighted = true,
+            .disabled = view_model.loaded_count == 0,
+        });
+        rows.push_back(ReaderProfileRow {
+            .state_label = view_model.has_pending_chunks
+                               ? "Pending (I/O) " + std::string(1, view_model.spinner) + " [" +
+                                     std::to_string(view_model.loading_count) + "]"
+                               : "Pending (I/O) [" + std::to_string(view_model.loading_count) + "]",
+            .chunk_text = view_model.has_pending_chunks ? view_model.loading_chunk_ids : "Idle",
+            .highlighted = view_model.has_pending_chunks,
+            .disabled = !view_model.has_pending_chunks,
+        });
+        return rows;
+    }
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/schema_view_service.cpp b/tools/inspector/src/services/schema_view_service.cpp
index f59a3fc..0dfa4d9 100644
--- a/tools/inspector/src/services/schema_view_service.cpp
+++ b/tools/inspector/src/services/schema_view_service.cpp
@@ -5,50 +5,47 @@
 
 namespace VtxServices {
 
-void SchemaViewService::RequestHighlight(
-    SchemaHighlightState& highlight,
-    const std::string& struct_name,
-    const std::string& property_name,
-    float ttl_seconds) {
-    highlight.struct_name = struct_name;
-    highlight.property_name = property_name;
-    highlight.time_remaining = ttl_seconds;
-    highlight.do_scroll = true;
-}
-
-void SchemaViewService::TickHighlight(SchemaHighlightState& highlight, float delta_seconds) {
-    if (highlight.time_remaining <= 0.0f) {
-        return;
+    void SchemaViewService::RequestHighlight(SchemaHighlightState& highlight, const std::string& struct_name,
+                                             const std::string& property_name, float ttl_seconds) {
+        highlight.struct_name = struct_name;
+        highlight.property_name = property_name;
+        highlight.time_remaining = ttl_seconds;
+        highlight.do_scroll = true;
     }
-    highlight.time_remaining -= delta_seconds;
-    if (highlight.time_remaining < 0.0f) {
-        highlight.time_remaining = 0.0f;
-    }
-}
 
-bool SchemaViewService::IsHighlightActive(const SchemaHighlightState& highlight) {
-    return highlight.time_remaining > 0.0f;
-}
+    void SchemaViewService::TickHighlight(SchemaHighlightState& highlight, float delta_seconds) {
+        if (highlight.time_remaining <= 0.0f) {
+            return;
+        }
+        highlight.time_remaining -= delta_seconds;
+        if (highlight.time_remaining < 0.0f) {
+            highlight.time_remaining = 0.0f;
+        }
+    }
 
-bool SchemaViewService::ExportJsonToFile(const std::string& path, const std::string& json_content) {
-    std::ofstream out(path, std::ios::out | std::ios::trunc);
-    if (!out.is_open()) {
-        return false;
+    bool SchemaViewService::IsHighlightActive(const SchemaHighlightState& highlight) {
+        return highlight.time_remaining > 0.0f;
     }
-    out << json_content;
-    return true;
-}
 
-std::string SchemaViewService::ResolveDisplayType(const VTX::PropertyAddress& address) {
-    if (!address.child_type_name.empty()) {
-        return address.child_type_name;
+    bool SchemaViewService::ExportJsonToFile(const std::string& path, const std::string& json_content) {
+        std::ofstream out(path, std::ios::out | std::ios::trunc);
+        if (!out.is_open()) {
+            return false;
+        }
+        out << json_content;
+        return true;
     }
 
-    return FieldTypeToString(address.type_id);
-}
+    std::string SchemaViewService::ResolveDisplayType(const VTX::PropertyAddress& address) {
+        if (!address.child_type_name.empty()) {
+            return address.child_type_name;
+        }
 
-VTX::FieldContainerType SchemaViewService::ResolveContainerType(const VTX::PropertyAddress& address) {
-    return address.container_type;
-}
+        return FieldTypeToString(address.type_id);
+    }
+
+    VTX::FieldContainerType SchemaViewService::ResolveContainerType(const VTX::PropertyAddress& address) {
+        return address.container_type;
+    }
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/services/time_display_service.cpp b/tools/inspector/src/services/time_display_service.cpp
index 0830cc1..f12ff70 100644
--- a/tools/inspector/src/services/time_display_service.cpp
+++ b/tools/inspector/src/services/time_display_service.cpp
@@ -6,96 +6,89 @@
 
 namespace {
 
-constexpr int64_t kTicksPerSecond = 10'000'000;
-constexpr int64_t kTicksPerMillisecond = 10'000;
-constexpr int64_t kTicksAtUnixEpoch = 621'355'968'000'000'000;
-
-// Converts mixed tick epochs into unix-relative ticks for display.
-int64_t NormalizeToUnixTicks(uint64_t ticks) {
-    const int64_t signed_ticks = static_cast<int64_t>(ticks);
-    if (signed_ticks >= kTicksAtUnixEpoch) {
-        return signed_ticks - kTicksAtUnixEpoch;
+    constexpr int64_t kTicksPerSecond = 10'000'000;
+    constexpr int64_t kTicksPerMillisecond = 10'000;
+    constexpr int64_t kTicksAtUnixEpoch = 621'355'968'000'000'000;
+
+    // Converts mixed tick epochs into unix-relative ticks for display.
+    int64_t NormalizeToUnixTicks(uint64_t ticks) {
+        const int64_t signed_ticks = static_cast<int64_t>(ticks);
+        if (signed_ticks >= kTicksAtUnixEpoch) {
+            return signed_ticks - kTicksAtUnixEpoch;
+        }
+        return signed_ticks;
     }
-    return signed_ticks;
-}
 
-// Formats a unix-seconds timestamp as an RSS-like UTC string with milliseconds.
-std::string FormatUnixSecondsAsRss(int64_t unix_seconds, int32_t milliseconds) {
-    const std::time_t time_value = static_cast<std::time_t>(unix_seconds);
-    std::tm utc_time {};
+    // Formats a unix-seconds timestamp as an RSS-like UTC string with milliseconds.
+    std::string FormatUnixSecondsAsRss(int64_t unix_seconds, int32_t milliseconds) {
+        const std::time_t time_value = static_cast<std::time_t>(unix_seconds);
+        std::tm utc_time {};
 #if defined(_WIN32)
-    if (gmtime_s(&utc_time, &time_value) != 0) {
-        return "Invalid UTC";
-    }
+        if (gmtime_s(&utc_time, &time_value) != 0) {
+            return "Invalid UTC";
+        }
 #else
-    if (gmtime_r(&time_value, &utc_time) == nullptr) {
-        return "Invalid UTC";
-    }
+        if (gmtime_r(&time_value, &utc_time) == nullptr) {
+            return "Invalid UTC";
+        }
 #endif
 
-    std::ostringstream stream;
-    stream << std::put_time(&utc_time, "%d %b %Y %H:%M:%S")
-           << "."
-           << std::setw(3) << std::setfill('0') << milliseconds
-           << " UTC";
-    return stream.str();
-}
+        std::ostringstream stream;
+        stream << std::put_time(&utc_time, "%d %b %Y %H:%M:%S") << "." << std::setw(3) << std::setfill('0')
+               << milliseconds << " UTC";
+        return stream.str();
+    }
 
 } // namespace
 
 namespace VtxServices {
 
-std::string TimeDisplayService::FormatTicksRaw(uint64_t ticks) {
-    return std::to_string(ticks);
-}
+    std::string TimeDisplayService::FormatTicksRaw(uint64_t ticks) {
+        return std::to_string(ticks);
+    }
 
-std::string TimeDisplayService::FormatDurationFromTicks(uint64_t ticks) {
-    const int64_t total_milliseconds = static_cast<int64_t>((ticks + (kTicksPerMillisecond / 2)) / kTicksPerMillisecond);
-    const int64_t hours = total_milliseconds / 3'600'000;
-    const int64_t minutes = (total_milliseconds % 3'600'000) / 60'000;
-    const int64_t seconds = (total_milliseconds % 60'000) / 1'000;
-    const int64_t milliseconds = total_milliseconds % 1'000;
+    std::string TimeDisplayService::FormatDurationFromTicks(uint64_t ticks) {
+        const int64_t total_milliseconds =
+            static_cast<int64_t>((ticks + (kTicksPerMillisecond / 2)) / kTicksPerMillisecond);
+        const int64_t hours = total_milliseconds / 3'600'000;
+        const int64_t minutes = (total_milliseconds % 3'600'000) / 60'000;
+        const int64_t seconds = (total_milliseconds % 60'000) / 1'000;
+        const int64_t milliseconds = total_milliseconds % 1'000;
+
+        std::ostringstream stream;
+        if (hours > 0) {
+            stream << hours << "h ";
+        }
+        if (minutes > 0 || hours > 0) {
+            stream << minutes << "m ";
+        }
+        stream << seconds << "s " << milliseconds << "ms";
+        return stream.str();
+    }
 
-    std::ostringstream stream;
-    if (hours > 0) {
-        stream << hours << "h ";
+    std::string TimeDisplayService::FormatUtcTicksAsRss(uint64_t ticks) {
+        const int64_t unix_ticks = NormalizeToUnixTicks(ticks);
+        const int64_t unix_seconds = unix_ticks / kTicksPerSecond;
+        const int64_t milliseconds_part = (unix_ticks % kTicksPerSecond) / kTicksPerMillisecond;
+        const int32_t milliseconds = milliseconds_part >= 0 ? static_cast<int32_t>(milliseconds_part)
+                                                            : static_cast<int32_t>(milliseconds_part + 1000);
+        return FormatUnixSecondsAsRss(unix_seconds, milliseconds);
     }
-    if (minutes > 0 || hours > 0) {
-        stream << minutes << "m ";
+
+    std::string TimeDisplayService::FormatUtcTicksAsRssWithRaw(uint64_t ticks) {
+        return FormatUtcTicksAsRss(ticks) + " (" + FormatTicksRaw(ticks) + ")";
     }
-    stream << seconds << "s " << milliseconds << "ms";
-    return stream.str();
-}
-
-std::string TimeDisplayService::FormatUtcTicksAsRss(uint64_t ticks) {
-    const int64_t unix_ticks = NormalizeToUnixTicks(ticks);
-    const int64_t unix_seconds = unix_ticks / kTicksPerSecond;
-    const int64_t milliseconds_part = (unix_ticks % kTicksPerSecond) / kTicksPerMillisecond;
-    const int32_t milliseconds = milliseconds_part >= 0
-        ? static_cast<int32_t>(milliseconds_part)
-        : static_cast<int32_t>(milliseconds_part + 1000);
-    return FormatUnixSecondsAsRss(unix_seconds, milliseconds);
-}
-
-std::string TimeDisplayService::FormatUtcTicksAsRssWithRaw(uint64_t ticks) {
-    return FormatUtcTicksAsRss(ticks) + " (" + FormatTicksRaw(ticks) + ")";
-}
-
-std::string TimeDisplayService::FormatUnixSecondsAsRssWithRaw(int64_t unix_seconds) {
-    return FormatUnixSecondsAsRss(unix_seconds, 0) + " (" + std::to_string(unix_seconds) + ")";
-}
-
-std::string TimeDisplayService::FormatGameTimeTicks(uint64_t ticks, TimeDisplayFormat format) {
-    return format == TimeDisplayFormat::Formatted
-        ? FormatDurationFromTicks(ticks)
-        : FormatTicksRaw(ticks);
-}
-
-std::string TimeDisplayService::FormatUtcTicks(uint64_t ticks, TimeDisplayFormat format) {
-    return format == TimeDisplayFormat::Formatted
-        ? FormatUtcTicksAsRss(ticks)
-        : FormatTicksRaw(ticks);
-}
 
-} // namespace VtxServices
+    std::string TimeDisplayService::FormatUnixSecondsAsRssWithRaw(int64_t unix_seconds) {
+        return FormatUnixSecondsAsRss(unix_seconds, 0) + " (" + std::to_string(unix_seconds) + ")";
+    }
+
+    std::string TimeDisplayService::FormatGameTimeTicks(uint64_t ticks, TimeDisplayFormat format) {
+        return format == TimeDisplayFormat::Formatted ? FormatDurationFromTicks(ticks) : FormatTicksRaw(ticks);
+    }
 
+    std::string TimeDisplayService::FormatUtcTicks(uint64_t ticks, TimeDisplayFormat format) {
+        return format == TimeDisplayFormat::Formatted ? FormatUtcTicksAsRss(ticks) : FormatTicksRaw(ticks);
+    }
+
+} // namespace VtxServices
diff --git a/tools/inspector/src/services/timeline_view_service.cpp b/tools/inspector/src/services/timeline_view_service.cpp
index 6310a94..a9e08ac 100644
--- a/tools/inspector/src/services/timeline_view_service.cpp
+++ b/tools/inspector/src/services/timeline_view_service.cpp
@@ -4,116 +4,92 @@
 
 namespace VtxServices {
 
-float TimelineViewService::ComputePlaybackFps(int total_frames, float duration_seconds, float fallback_fps) {
-    if (total_frames <= 0 || duration_seconds <= 0.0f) {
-        return fallback_fps;
+    float TimelineViewService::ComputePlaybackFps(int total_frames, float duration_seconds, float fallback_fps) {
+        if (total_frames <= 0 || duration_seconds <= 0.0f) {
+            return fallback_fps;
+        }
+        return static_cast<float>(total_frames) / duration_seconds;
+    }
+
+    ClockTime TimelineViewService::ToClockTime(float total_seconds) {
+        const float safe_seconds = std::max(total_seconds, 0.0f);
+        const int whole_seconds = static_cast<int>(safe_seconds);
+        return ClockTime {.minutes = whole_seconds / 60, .seconds = whole_seconds % 60};
+    }
+
+    DurationSplit TimelineViewService::SplitDuration(float total_seconds) {
+        const float safe_seconds = std::max(total_seconds, 0.0f);
+        const int minutes = static_cast<int>(safe_seconds) / 60;
+        const float seconds = safe_seconds - (minutes * 60.0f);
+        return DurationSplit {.minutes = minutes, .seconds = seconds};
+    }
+
+    TimelineClockSpan TimelineViewService::BuildTimelineClockSpan(int current_frame, int total_frames,
+                                                                  float duration_seconds, float fallback_fps) {
+        const float fps = ComputePlaybackFps(total_frames, duration_seconds, fallback_fps);
+        const float current_time_sec = static_cast<float>(current_frame) / fps;
+        return TimelineClockSpan {
+            .current = ToClockTime(current_time_sec), .total = ToClockTime(duration_seconds), .fps = fps};
+    }
+
+    int TimelineViewService::ClampFrame(int frame, int total_frames) {
+        if (total_frames <= 0) {
+            return 0;
+        }
+        return std::clamp(frame, 0, total_frames - 1);
     }
-    return static_cast<float>(total_frames) / duration_seconds;
-}
-
-ClockTime TimelineViewService::ToClockTime(float total_seconds) {
-    const float safe_seconds = std::max(total_seconds, 0.0f);
-    const int whole_seconds = static_cast<int>(safe_seconds);
-    return ClockTime{
-        .minutes = whole_seconds / 60,
-        .seconds = whole_seconds % 60
-    };
-}
-
-DurationSplit TimelineViewService::SplitDuration(float total_seconds) {
-    const float safe_seconds = std::max(total_seconds, 0.0f);
-    const int minutes = static_cast<int>(safe_seconds) / 60;
-    const float seconds = safe_seconds - (minutes * 60.0f);
-    return DurationSplit{
-        .minutes = minutes,
-        .seconds = seconds
-    };
-}
-
-TimelineClockSpan TimelineViewService::BuildTimelineClockSpan(
-    int current_frame,
-    int total_frames,
-    float duration_seconds,
-    float fallback_fps) {
-    const float fps = ComputePlaybackFps(total_frames, duration_seconds, fallback_fps);
-    const float current_time_sec = static_cast<float>(current_frame) / fps;
-    return TimelineClockSpan{
-        .current = ToClockTime(current_time_sec),
-        .total = ToClockTime(duration_seconds),
-        .fps = fps
-    };
-}
-
-int TimelineViewService::ClampFrame(int frame, int total_frames) {
-    if (total_frames <= 0) {
-        return 0;
+
+    float TimelineViewService::ComputeItemFullWidth(const TimelineBarState& bar_state) {
+        return bar_state.bar_width + bar_state.bar_spacing;
     }
-    return std::clamp(frame, 0, total_frames - 1);
-}
-
-float TimelineViewService::ComputeItemFullWidth(const TimelineBarState& bar_state) {
-    return bar_state.bar_width + bar_state.bar_spacing;
-}
-
-float TimelineViewService::ComputeCenteredScroll(int frame_index, float item_full_width, float view_width) {
-    const float target_x = frame_index * item_full_width;
-    const float desired_scroll = target_x - (view_width * 0.5f) + (item_full_width * 0.5f);
-    return std::max(0.0f, desired_scroll);
-}
-
-TimelineVisibleRange TimelineViewService::ComputeVisibleRange(
-    float scroll_x,
-    float view_width,
-    int total_frames,
-    const TimelineBarState& bar_state) {
-    TimelineVisibleRange range;
-    range.item_full_width = ComputeItemFullWidth(bar_state);
-    range.total_content_width = total_frames * range.item_full_width;
-
-    int first_visible_idx = static_cast<int>(scroll_x / range.item_full_width);
-    int last_visible_idx = static_cast<int>((scroll_x + view_width) / range.item_full_width) + 2;
-
-    range.first_visible_idx = std::clamp(first_visible_idx, 0, total_frames);
-    range.last_visible_idx = std::clamp(last_visible_idx, 0, total_frames);
-    return range;
-}
-
-float TimelineViewService::ComputeZoomedScroll(
-    float wheel,
-    float mouse_x_in_child,
-    float scroll_x,
-    TimelineBarState& bar_state) {
-    const float item_full_width = ComputeItemFullWidth(bar_state);
-    const float local_mouse_x = mouse_x_in_child + scroll_x;
-    const float anchor_frame_pos = local_mouse_x / item_full_width;
-
-    bar_state.bar_width += wheel * (bar_state.bar_width * 0.2f);
-    bar_state.bar_width = std::clamp(bar_state.bar_width, bar_state.min_bar_width, bar_state.max_bar_width);
-
-    const float target_item_full_width = ComputeItemFullWidth(bar_state);
-    const float target_local_mouse_x = anchor_frame_pos * target_item_full_width;
-    const float desired_scroll = target_local_mouse_x - mouse_x_in_child;
-    return std::max(0.0f, desired_scroll);
-}
-
-int TimelineViewService::ResolveHoveredFrame(
-    float mouse_x,
-    float mouse_y,
-    float origin_x,
-    float origin_y,
-    float timeline_height,
-    const TimelineVisibleRange& range) {
-    for (int i = range.first_visible_idx; i < range.last_visible_idx; ++i) {
-        const float x_start = origin_x + (i * range.item_full_width);
-        const float x_end = x_start + range.item_full_width;
-        const float y_end = origin_y + timeline_height;
-
-        if (mouse_x >= x_start && mouse_x < x_end &&
-            mouse_y >= origin_y && mouse_y <= y_end) {
-            return i;
+
+    float TimelineViewService::ComputeCenteredScroll(int frame_index, float item_full_width, float view_width) {
+        const float target_x = frame_index * item_full_width;
+        const float desired_scroll = target_x - (view_width * 0.5f) + (item_full_width * 0.5f);
+        return std::max(0.0f, desired_scroll);
+    }
+
+    TimelineVisibleRange TimelineViewService::ComputeVisibleRange(float scroll_x, float view_width, int total_frames,
+                                                                  const TimelineBarState& bar_state) {
+        TimelineVisibleRange range;
+        range.item_full_width = ComputeItemFullWidth(bar_state);
+        range.total_content_width = total_frames * range.item_full_width;
+
+        int first_visible_idx = static_cast<int>(scroll_x / range.item_full_width);
+        int last_visible_idx = static_cast<int>((scroll_x + view_width) / range.item_full_width) + 2;
+
+        range.first_visible_idx = std::clamp(first_visible_idx, 0, total_frames);
+        range.last_visible_idx = std::clamp(last_visible_idx, 0, total_frames);
+        return range;
+    }
+
+    float TimelineViewService::ComputeZoomedScroll(float wheel, float mouse_x_in_child, float scroll_x,
+                                                   TimelineBarState& bar_state) {
+        const float item_full_width = ComputeItemFullWidth(bar_state);
+        const float local_mouse_x = mouse_x_in_child + scroll_x;
+        const float anchor_frame_pos = local_mouse_x / item_full_width;
+
+        bar_state.bar_width += wheel * (bar_state.bar_width * 0.2f);
+        bar_state.bar_width = std::clamp(bar_state.bar_width, bar_state.min_bar_width, bar_state.max_bar_width);
+
+        const float target_item_full_width = ComputeItemFullWidth(bar_state);
+        const float target_local_mouse_x = anchor_frame_pos * target_item_full_width;
+        const float desired_scroll = target_local_mouse_x - mouse_x_in_child;
+        return std::max(0.0f, desired_scroll);
+    }
+
+    int TimelineViewService::ResolveHoveredFrame(float mouse_x, float mouse_y, float origin_x, float origin_y,
+                                                 float timeline_height, const TimelineVisibleRange& range) {
+        for (int i = range.first_visible_idx; i < range.last_visible_idx; ++i) {
+            const float x_start = origin_x + (i * range.item_full_width);
+            const float x_end = x_start + range.item_full_width;
+            const float y_end = origin_y + timeline_height;
+
+            if (mouse_x >= x_start && mouse_x < x_end && mouse_y >= origin_y && mouse_y <= y_end) {
+                return i;
+            }
         }
+        return -1;
     }
-    return -1;
-}
 
 } // namespace VtxServices
diff --git a/tools/inspector/src/windows/analysis_window_factory.cpp b/tools/inspector/src/windows/analysis_window_factory.cpp
index b1eaba1..4f90ac9 100644
--- a/tools/inspector/src/windows/analysis_window_factory.cpp
+++ b/tools/inspector/src/windows/analysis_window_factory.cpp
@@ -6,34 +6,29 @@
 
 namespace AnalysisWindowFactory {
 
-std::shared_ptr<IGuiLayer> CreateEntityLifeTimeWindow(
-    std::shared_ptr<InspectorSession> session, int instance_id)
-{
-    return std::make_shared<EntityLifeTimeWindow>(std::move(session), instance_id);
-}
+    std::shared_ptr<IGuiLayer> CreateEntityLifeTimeWindow(std::shared_ptr<InspectorSession> session, int instance_id) {
+        return std::make_shared<EntityLifeTimeWindow>(std::move(session), instance_id);
+    }
 
-std::shared_ptr<IGuiLayer> CreateUniquePropertiesWindow(
-    std::shared_ptr<InspectorSession> session, int instance_id)
-{
-    return std::make_shared<UniquePropertiesWindow>(std::move(session), instance_id);
-}
+    std::shared_ptr<IGuiLayer> CreateUniquePropertiesWindow(std::shared_ptr<InspectorSession> session,
+                                                            int instance_id) {
+        return std::make_shared<UniquePropertiesWindow>(std::move(session), instance_id);
+    }
 
-std::shared_ptr<IGuiLayer> CreateTrackPropertyWindow(
-    std::shared_ptr<InspectorSession> session, int instance_id)
-{
-    return std::make_shared<TrackPropertyWindow>(std::move(session), instance_id);
-}
+    std::shared_ptr<IGuiLayer> CreateTrackPropertyWindow(std::shared_ptr<InspectorSession> session, int instance_id) {
+        return std::make_shared<TrackPropertyWindow>(std::move(session), instance_id);
+    }
 
-bool IsAnalysisWindowOpen(const std::shared_ptr<IGuiLayer>& layer) {
-    // Check each concrete type — they all inherit IsOpen() from the project's
-    // gui_window base class, which we can't name here due to the imgui collision.
-    if (auto* w = dynamic_cast<EntityLifeTimeWindow*>(layer.get()))
-        return w->IsOpen();
-    if (auto* w = dynamic_cast<UniquePropertiesWindow*>(layer.get()))
-        return w->IsOpen();
-    if (auto* w = dynamic_cast<TrackPropertyWindow*>(layer.get()))
-        return w->IsOpen();
-    return false;
-}
+    bool IsAnalysisWindowOpen(const std::shared_ptr<IGuiLayer>& layer) {
+        // Check each concrete type — they all inherit IsOpen() from the project's
+        // gui_window base class, which we can't name here due to the imgui collision.
+        if (auto* w = dynamic_cast<EntityLifeTimeWindow*>(layer.get()))
+            return w->IsOpen();
+        if (auto* w = dynamic_cast<UniquePropertiesWindow*>(layer.get()))
+            return w->IsOpen();
+        if (auto* w = dynamic_cast<TrackPropertyWindow*>(layer.get()))
+            return w->IsOpen();
+        return false;
+    }
 
 } // namespace AnalysisWindowFactory
diff --git a/tools/inspector/src/windows/buckets_window.cpp b/tools/inspector/src/windows/buckets_window.cpp
index 9b39793..a4cfb2f 100644
--- a/tools/inspector/src/windows/buckets_window.cpp
+++ b/tools/inspector/src/windows/buckets_window.cpp
@@ -11,38 +11,35 @@
 
 namespace {
 
-std::string ToLowerCopy(const std::string& value) {
-    std::string lower = value;
-    std::transform(
-        lower.begin(),
-        lower.end(),
-        lower.begin(),
-        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    return lower;
-}
-
-bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
-    if (query_lower.empty()) {
-        return true;
+    std::string ToLowerCopy(const std::string& value) {
+        std::string lower = value;
+        std::transform(lower.begin(), lower.end(), lower.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return lower;
     }
-    return ToLowerCopy(text).find(query_lower) != std::string::npos;
-}
 
-bool EntityMatchesFilter(const VtxServices::EntityListItem& entity, const std::string& query_lower) {
-    if (query_lower.empty()) {
-        return true;
+    bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
+        if (query_lower.empty()) {
+            return true;
+        }
+        return ToLowerCopy(text).find(query_lower) != std::string::npos;
     }
 
-    if (ContainsCaseInsensitive(entity.entity_id, query_lower)) {
-        return true;
-    }
+    bool EntityMatchesFilter(const VtxServices::EntityListItem& entity, const std::string& query_lower) {
+        if (query_lower.empty()) {
+            return true;
+        }
 
-    if (ContainsCaseInsensitive(entity.entity_type_name, query_lower)) {
-        return true;
-    }
+        if (ContainsCaseInsensitive(entity.entity_id, query_lower)) {
+            return true;
+        }
 
-    return ContainsCaseInsensitive("type " + std::to_string(entity.entity_type_id), query_lower);
-}
+        if (ContainsCaseInsensitive(entity.entity_type_name, query_lower)) {
+            return true;
+        }
+
+        return ContainsCaseInsensitive("type " + std::to_string(entity.entity_type_id), query_lower);
+    }
 
 } // namespace
 
@@ -59,17 +56,14 @@ void BucketsWindow::DrawContent() {
 
     auto& state = inspector_session_->MutableEntityInspectorState();
     const auto screen = VtxServices::EntityInspectorViewService::BuildScreen(
-        reader,
-        inspector_session_->HasLoadedReplay(),
-        inspector_session_->IsScrubbingTimeline(),
-        inspector_session_->GetCurrentFrame(),
-        state);
+        reader, inspector_session_->HasLoadedReplay(), inspector_session_->IsScrubbingTimeline(),
+        inspector_session_->GetCurrentFrame(), state);
     state = screen.state;
 
     if (screen.view_model.is_loading) {
         const ImVec4 color = screen.view_model.status_tone == VtxServices::EntityStatusTone::Warning
-            ? ImVec4(1.0f, 0.8f, 0.0f, 1.0f)
-            : ImVec4(1.0f, 0.4f, 0.4f, 1.0f);
+                                 ? ImVec4(1.0f, 0.8f, 0.0f, 1.0f)
+                                 : ImVec4(1.0f, 0.4f, 0.4f, 1.0f);
         ImGui::TextColored(color, "%s", screen.view_model.status_message.c_str());
         if (!screen.view_model.stale_frame_message.empty()) {
             ImGui::SameLine();
@@ -105,11 +99,8 @@ void BucketsWindow::DrawEntityListPanel(const VtxServices::EntityInspectorViewMo
     bool& show_schema_names = inspector_session_->MutableShowSchemaNames();
     ImGui::Checkbox("Show Schema Names", &show_schema_names);
     ImGui::SetNextItemWidth(-1.0f);
-    ImGui::InputTextWithHint(
-        "##EntityFilter",
-        "Filter by UniqueID or Type...",
-        entity_filter_,
-        IM_ARRAYSIZE(entity_filter_));
+    ImGui::InputTextWithHint("##EntityFilter", "Filter by UniqueID or Type...", entity_filter_,
+                             IM_ARRAYSIZE(entity_filter_));
     ImGui::Separator();
 
     const std::string filter_query = ToLowerCopy(entity_filter_);
@@ -128,11 +119,8 @@ void BucketsWindow::DrawEntityListPanel(const VtxServices::EntityInspectorViewMo
         }
         has_visible_entities = true;
 
-        if (ImGui::TreeNodeEx(
-                bucket_view.id.c_str(),
-                ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_DefaultOpen,
-                "%s",
-                bucket_view.label.c_str())) {
+        if (ImGui::TreeNodeEx(bucket_view.id.c_str(), ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_DefaultOpen, "%s",
+                              bucket_view.label.c_str())) {
             for (const size_t i : visible_indices) {
                 const auto& entity = bucket_view.entities[i];
                 ImGuiTreeNodeFlags node_flags = ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;
@@ -142,18 +130,16 @@ void BucketsWindow::DrawEntityListPanel(const VtxServices::EntityInspectorViewMo
 
                 const std::string node_id = bucket_view.id + "_entity_" + std::to_string(i);
                 const std::string type_label = show_schema_names && !entity.entity_type_name.empty()
-                    ? entity.entity_type_name
-                    : "Type " + std::to_string(entity.entity_type_id);
-                const std::string display_label = "Entity " + std::to_string(i) +
-                    " (UniqueID: " + entity.entity_id + ") - " + type_label;
+                                                   ? entity.entity_type_name
+                                                   : "Type " + std::to_string(entity.entity_type_id);
+                const std::string display_label =
+                    "Entity " + std::to_string(i) + " (UniqueID: " + entity.entity_id + ") - " + type_label;
 
                 ImGui::TreeNodeEx(node_id.c_str(), node_flags, "%s", display_label.c_str());
                 if (ImGui::IsItemClicked() && !ImGui::IsItemToggledOpen()) {
                     auto& state = inspector_session_->MutableEntityInspectorState();
-                    state = VtxServices::EntityInspectorViewService::SelectEntity(
-                        state,
-                        bucket_view.bucket_index,
-                        entity.entity_id);
+                    state = VtxServices::EntityInspectorViewService::SelectEntity(state, bucket_view.bucket_index,
+                                                                                  entity.entity_id);
                     ImGui::SetWindowFocus(VtxGuiNames::EntityDetailsWindow);
                 }
             }
diff --git a/tools/inspector/src/windows/chunk_index_window.cpp b/tools/inspector/src/windows/chunk_index_window.cpp
index 65b68a4..531be16 100644
--- a/tools/inspector/src/windows/chunk_index_window.cpp
+++ b/tools/inspector/src/windows/chunk_index_window.cpp
@@ -9,8 +9,7 @@
 
 ChunkIndexWindow::ChunkIndexWindow(std::shared_ptr<InspectorSession> session)
     : ImGuiWindow(VtxGuiNames::ChunkIndexWindow, session)
-    , inspector_session_(std::move(session)) {
-}
+    , inspector_session_(std::move(session)) {}
 
 void ChunkIndexWindow::DrawContent() {
     if (!inspector_session_->HasLoadedReplay()) {
@@ -18,8 +17,8 @@ void ChunkIndexWindow::DrawContent() {
         return;
     }
 
-    const auto view_model = VtxServices::FooterSummaryService::BuildChunkTableViewModel(
-        inspector_session_->GetFooter().chunk_index);
+    const auto view_model =
+        VtxServices::FooterSummaryService::BuildChunkTableViewModel(inspector_session_->GetFooter().chunk_index);
 
     if (view_model.rows.empty()) {
         ImGui::TextDisabled("%s", view_model.empty_message.c_str());
@@ -29,18 +28,15 @@ void ChunkIndexWindow::DrawContent() {
     ImGui::TextDisabled("%s", view_model.count_label.c_str());
     ImGui::Spacing();
 
-    if (ImGui::BeginTable(
-            "ChunkTable",
-            static_cast<int>(view_model.columns.size()),
-            ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
-                ImGuiTableFlags_ScrollY,
-            ImVec2(0, ImGui::GetContentRegionAvail().y))) {
+    if (ImGui::BeginTable("ChunkTable", static_cast<int>(view_model.columns.size()),
+                          ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
+                              ImGuiTableFlags_ScrollY,
+                          ImVec2(0, ImGui::GetContentRegionAvail().y))) {
         ImGui::TableSetupScrollFreeze(0, 1);
         for (const auto& column : view_model.columns) {
             ImGui::TableSetupColumn(
                 column.label.c_str(),
-                column.stretch ? ImGuiTableColumnFlags_WidthStretch : ImGuiTableColumnFlags_WidthFixed,
-                column.width);
+                column.stretch ? ImGuiTableColumnFlags_WidthStretch : ImGuiTableColumnFlags_WidthFixed, column.width);
         }
         ImGui::TableHeadersRow();
 
diff --git a/tools/inspector/src/windows/entity_details_window.cpp b/tools/inspector/src/windows/entity_details_window.cpp
index 29838c6..34f9675 100644
--- a/tools/inspector/src/windows/entity_details_window.cpp
+++ b/tools/inspector/src/windows/entity_details_window.cpp
@@ -11,8 +11,7 @@
 
 EntityDetailsWindow::EntityDetailsWindow(std::shared_ptr<InspectorSession> session)
     : ImGuiWindow(VtxGuiNames::EntityDetailsWindow, session)
-    , inspector_session_(std::move(session)) {
-}
+    , inspector_session_(std::move(session)) {}
 
 void EntityDetailsWindow::DrawContent() {
     auto* reader = inspector_session_->GetReader();
@@ -23,17 +22,14 @@ void EntityDetailsWindow::DrawContent() {
 
     auto& state = inspector_session_->MutableEntityInspectorState();
     const auto screen = VtxServices::EntityInspectorViewService::BuildScreen(
-        reader,
-        inspector_session_->HasLoadedReplay(),
-        inspector_session_->IsScrubbingTimeline(),
-        inspector_session_->GetCurrentFrame(),
-        state);
+        reader, inspector_session_->HasLoadedReplay(), inspector_session_->IsScrubbingTimeline(),
+        inspector_session_->GetCurrentFrame(), state);
     state = screen.state;
 
     if (screen.view_model.is_loading) {
         const ImVec4 color = screen.view_model.status_tone == VtxServices::EntityStatusTone::Warning
-            ? ImVec4(1.0f, 0.8f, 0.0f, 1.0f)
-            : ImVec4(1.0f, 0.4f, 0.4f, 1.0f);
+                                 ? ImVec4(1.0f, 0.8f, 0.0f, 1.0f)
+                                 : ImVec4(1.0f, 0.4f, 0.4f, 1.0f);
         ImGui::TextColored(color, "%s", screen.view_model.status_message.c_str());
         if (!screen.view_model.stale_frame_message.empty()) {
             ImGui::SameLine();
@@ -66,14 +62,14 @@ void EntityDetailsWindow::DrawContent() {
     }
 }
 
-void EntityDetailsWindow::DrawPropertiesPanel(
-    const VtxServices::EntityInspectorViewModel& view_model,
-    const VTX::PropertyAddressCache* global_cache) {
+void EntityDetailsWindow::DrawPropertiesPanel(const VtxServices::EntityInspectorViewModel& view_model,
+                                              const VTX::PropertyAddressCache* global_cache) {
     // Render the selected entity details with shared schema/type name display preferences.
     const auto& state = inspector_session_->GetEntityInspectorState();
     bool& show_schema_names = inspector_session_->MutableShowSchemaNames();
     if (!view_model.empty_properties_message.empty() && view_model.properties.roots.empty()) {
-        const bool is_missing_entity = !state.selected_entity_id.empty() &&
+        const bool is_missing_entity =
+            !state.selected_entity_id.empty() &&
             view_model.empty_properties_message.find("no longer exists") != std::string::npos;
         if (is_missing_entity) {
             ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "%s", view_model.empty_properties_message.c_str());
@@ -118,26 +114,20 @@ void EntityDetailsWindow::DrawPropertiesPanel(
         ImGui::Separator();
         ImGui::Spacing();
         ImGui::SetCursorPosX(section_start_x);
-        ImGui::TextColored(
-            ImVec4(1.0f, 0.55f, 0.3f, 1.0f),
-            "Missing Fields (%zu):",
-            view_model.header.missing_field_names.size());
+        ImGui::TextColored(ImVec4(1.0f, 0.55f, 0.3f, 1.0f),
+                           "Missing Fields (%zu):", view_model.header.missing_field_names.size());
         for (const auto& missing_field_name : view_model.header.missing_field_names) {
             ImGui::SetCursorPosX(section_start_x);
             ImGui::BulletText("%s", missing_field_name.c_str());
         }
     }
-    
+
     ImGui::Separator();
     ImGui::Spacing();
-
 }
 
-void EntityDetailsWindow::RenderPropertyNode(
-    const VtxServices::EntityPropertyNode& node,
-    const VTX::PropertyAddressCache* global_cache,
-    bool show_schema_names) {
-    
+void EntityDetailsWindow::RenderPropertyNode(const VtxServices::EntityPropertyNode& node,
+                                             const VTX::PropertyAddressCache* global_cache, bool show_schema_names) {
     if (node.is_property) {
         std::string display_label = node.label;
         if (show_schema_names) {
@@ -154,7 +144,8 @@ void EntityDetailsWindow::RenderPropertyNode(
 
         const std::string display_text = display_label + ": " + node.value;
         if (ImGui::Selectable(display_text.c_str())) {
-            const auto effect = VtxServices::EntityInspectorViewService::BuildPropertyActivateEffect(node, global_cache);
+            const auto effect =
+                VtxServices::EntityInspectorViewService::BuildPropertyActivateEffect(node, global_cache);
             if (effect.request_schema_focus) {
                 inspector_session_->RequestSchemaHighlight(effect.schema_struct_name, effect.schema_property_name);
                 if (effect.focus_schema_window) {
@@ -203,7 +194,8 @@ void EntityDetailsWindow::RenderPropertyNode(
         if (effect.request_schema_focus) {
             ImGui::BeginTooltip();
             if (!effect.schema_property_name.empty()) {
-                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Schema Name: %s", effect.schema_property_name.c_str());
+                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Schema Name: %s",
+                                   effect.schema_property_name.c_str());
             } else {
                 ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Struct: %s", effect.schema_struct_name.c_str());
             }
@@ -229,19 +221,19 @@ void EntityDetailsWindow::RenderPropertyNode(
             ImGui::Indent(nested_indent);
             DrawHexViewerForNode(node);
             ImGui::Unindent(nested_indent);
-        } 
-        else {
-           //Draw array elements as before, by child
-            const bool should_extra_indent = std::all_of(
-                node.children.begin(),
-                node.children.end(),
-                [](const VtxServices::EntityPropertyNode& child) { return child.is_property; });
-            
-            if (should_extra_indent) ImGui::Indent(nested_indent);
+        } else {
+            //Draw array elements as before, by child
+            const bool should_extra_indent =
+                std::all_of(node.children.begin(), node.children.end(),
+                            [](const VtxServices::EntityPropertyNode& child) { return child.is_property; });
+
+            if (should_extra_indent)
+                ImGui::Indent(nested_indent);
             for (const auto& child : node.children) {
                 RenderPropertyNode(child, global_cache, show_schema_names);
             }
-            if (should_extra_indent) ImGui::Unindent(nested_indent);
+            if (should_extra_indent)
+                ImGui::Unindent(nested_indent);
         }
     }
 
@@ -263,7 +255,8 @@ void EntityDetailsWindow::DrawHexViewerForNode(const VtxServices::EntityProperty
         }
     }
 
-    if (raw_bytes.empty()) return;
+    if (raw_bytes.empty())
+        return;
 
     // 2. Extended state system: Save [Data Type] and [Display Base] per node
     static std::unordered_map<std::string, std::pair<int, int>> format_selections;
@@ -271,13 +264,14 @@ void EntityDetailsWindow::DrawHexViewerForNode(const VtxServices::EntityProperty
     int& data_type = selection.first;
     int& display_base = selection.second;
 
-    const char* type_names[] = { "8-bit Integer", "16-bit Integer", "32-bit Integer", "64-bit Integer", "32-bit Float", "64-bit Double" };
-    const char* base_names[] = { "Hexadecimal", "Unsigned Decimal", "Signed Decimal" };
+    const char* type_names[] = {"8-bit Integer",  "16-bit Integer", "32-bit Integer",
+                                "64-bit Integer", "32-bit Float",   "64-bit Double"};
+    const char* base_names[] = {"Hexadecimal", "Unsigned Decimal", "Signed Decimal"};
 
     // 3. User Interface (Two combos on the same line)
     ImGui::SetNextItemWidth(150.0f);
     ImGui::Combo(("Type##" + node.id).c_str(), &data_type, type_names, IM_ARRAYSIZE(type_names));
-    
+
     // Only show base selector if NOT Float or Double
     bool is_float = (data_type == 4 || data_type == 5);
     if (!is_float) {
@@ -291,79 +285,109 @@ void EntityDetailsWindow::DrawHexViewerForNode(const VtxServices::EntityProperty
     size_t bytes_per_item = 1;
     int item_width = 3; // Character width of each printed block (to align ASCII)
 
-    if (data_type == 0) { bytes_per_item = 1; item_width = (display_base == 0) ? 3 : (display_base == 1) ? 4 : 5; }
-    else if (data_type == 1) { bytes_per_item = 2; item_width = (display_base == 0) ? 5 : (display_base == 1) ? 6 : 7; }
-    else if (data_type == 2) { bytes_per_item = 4; item_width = (display_base == 0) ? 9 : (display_base == 1) ? 11 : 12; }
-    else if (data_type == 3) { bytes_per_item = 8; item_width = (display_base == 0) ? 17 : 21; } // Signed/Unsigned 64-bit occupy max ~20 + space
-    else if (data_type == 4) { bytes_per_item = 4; item_width = 11; }
-    else if (data_type == 5) { bytes_per_item = 8; item_width = 15; }
+    if (data_type == 0) {
+        bytes_per_item = 1;
+        item_width = (display_base == 0) ? 3 : (display_base == 1) ? 4 : 5;
+    } else if (data_type == 1) {
+        bytes_per_item = 2;
+        item_width = (display_base == 0) ? 5 : (display_base == 1) ? 6 : 7;
+    } else if (data_type == 2) {
+        bytes_per_item = 4;
+        item_width = (display_base == 0) ? 9 : (display_base == 1) ? 11 : 12;
+    } else if (data_type == 3) {
+        bytes_per_item = 8;
+        item_width = (display_base == 0) ? 17 : 21;
+    } // Signed/Unsigned 64-bit occupy max ~20 + space
+    else if (data_type == 4) {
+        bytes_per_item = 4;
+        item_width = 11;
+    } else if (data_type == 5) {
+        bytes_per_item = 8;
+        item_width = 15;
+    }
 
     // 5. Display Panel
     ImGui::BeginChild((node.id + "_HexDump").c_str(), ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
-    
-    const size_t bytes_per_line = 16; 
-    
+
+    const size_t bytes_per_line = 16;
+
     for (size_t i = 0; i < raw_bytes.size(); i += bytes_per_line) {
         char line_buffer[512]; // Increased buffer size for printing large 64-bit decimals
         char* ptr = line_buffer;
-        
+
         // Offset Column
         ptr += snprintf(ptr, sizeof(line_buffer) - (ptr - line_buffer), "%04zX: ", i);
-        
+
         // Formatted Data Column
         for (size_t j = 0; j < bytes_per_line; j += bytes_per_item) {
-            
             if (i + j + bytes_per_item <= raw_bytes.size()) {
                 const uint8_t* data_ptr = &raw_bytes[i + j];
 
                 switch (data_type) {
-                    case 0: { // 8-bit
-                        uint8_t v = *data_ptr;
-                        if (display_base == 0) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%02X ", v);
-                        else if (display_base == 1) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%3u ", v);
-                        else ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%4d ", (int8_t)v);
-                        break;
-                    }
-                    case 1: { // 16-bit
-                        uint16_t v; std::memcpy(&v, data_ptr, sizeof(v));
-                        if (display_base == 0) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%04X ", v);
-                        else if (display_base == 1) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%5u ", v);
-                        else ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%6d ", (int16_t)v);
-                        break;
-                    }
-                    case 2: { // 32-bit
-                        uint32_t v; std::memcpy(&v, data_ptr, sizeof(v));
-                        if (display_base == 0) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%08X ", v);
-                        else if (display_base == 1) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%10u ", v);
-                        else ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%11d ", (int32_t)v);
-                        break;
-                    }
-                    case 3: { // 64-bit
-                        uint64_t v; std::memcpy(&v, data_ptr, sizeof(v));
-                        if (display_base == 0) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%016llX ", (unsigned long long)v);
-                        else if (display_base == 1) ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%20llu ", (unsigned long long)v);
-                        else ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%20lld ", (long long)v);
-                        break;
-                    }
-                    case 4: { // 32-bit Float
-                        float v; std::memcpy(&v, data_ptr, sizeof(v));
-                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%10.4f ", v);
-                        break;
-                    }
-                    case 5: { // 64-bit Double
-                        double v; std::memcpy(&v, data_ptr, sizeof(v));
-                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%14.6f ", v);
-                        break;
-                    }
+                case 0: { // 8-bit
+                    uint8_t v = *data_ptr;
+                    if (display_base == 0)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%02X ", v);
+                    else if (display_base == 1)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%3u ", v);
+                    else
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%4d ", (int8_t)v);
+                    break;
+                }
+                case 1: { // 16-bit
+                    uint16_t v;
+                    std::memcpy(&v, data_ptr, sizeof(v));
+                    if (display_base == 0)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%04X ", v);
+                    else if (display_base == 1)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%5u ", v);
+                    else
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%6d ", (int16_t)v);
+                    break;
+                }
+                case 2: { // 32-bit
+                    uint32_t v;
+                    std::memcpy(&v, data_ptr, sizeof(v));
+                    if (display_base == 0)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%08X ", v);
+                    else if (display_base == 1)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%10u ", v);
+                    else
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%11d ", (int32_t)v);
+                    break;
+                }
+                case 3: { // 64-bit
+                    uint64_t v;
+                    std::memcpy(&v, data_ptr, sizeof(v));
+                    if (display_base == 0)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%016llX ", (unsigned long long)v);
+                    else if (display_base == 1)
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%20llu ", (unsigned long long)v);
+                    else
+                        ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%20lld ", (long long)v);
+                    break;
+                }
+                case 4: { // 32-bit Float
+                    float v;
+                    std::memcpy(&v, data_ptr, sizeof(v));
+                    ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%10.4f ", v);
+                    break;
+                }
+                case 5: { // 64-bit Double
+                    double v;
+                    std::memcpy(&v, data_ptr, sizeof(v));
+                    ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%14.6f ", v);
+                    break;
+                }
                 }
             } else {
                 // Dynamic Padding: Print exact spaces if the line is cut at the end of the buffer
-                ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%*s", item_width, ""); 
+                ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%*s", item_width, "");
             }
         }
-        
+
         ptr += snprintf(ptr, 512 - (ptr - line_buffer), "  |  ");
-        
+
         // ASCII Column (raw text)
         for (size_t j = 0; j < bytes_per_line; ++j) {
             if (i + j < raw_bytes.size()) {
@@ -371,9 +395,9 @@ void EntityDetailsWindow::DrawHexViewerForNode(const VtxServices::EntityProperty
                 ptr += snprintf(ptr, 512 - (ptr - line_buffer), "%c", (c >= 32 && c < 128) ? c : '.');
             }
         }
-        
+
         ImGui::TextUnformatted(line_buffer);
     }
-    
+
     ImGui::EndChild();
 }
diff --git a/tools/inspector/src/windows/entity_lifetime_window.cpp b/tools/inspector/src/windows/entity_lifetime_window.cpp
index 5627a93..8d042af 100644
--- a/tools/inspector/src/windows/entity_lifetime_window.cpp
+++ b/tools/inspector/src/windows/entity_lifetime_window.cpp
@@ -10,79 +10,91 @@
 
 namespace {
 
-// Extracts bucket names from the ContextualSchema property_mapping JSON.
-// The schema stores bucket names in a "buckets" array — this is the
-// authoritative source, as Frame::bucket_map may not have string keys.
-std::vector<std::string> ExtractBucketNamesFromSchema(const std::string& property_mapping) {
-    std::vector<std::string> names;
-    if (property_mapping.empty()) return names;
-
-    const std::string key = "\"buckets\"";
-    size_t key_pos = property_mapping.find(key);
-    if (key_pos == std::string::npos) return names;
-
-    size_t open_bracket = property_mapping.find('[', key_pos + key.size());
-    if (open_bracket == std::string::npos) return names;
-
-    bool in_string = false;
-    bool escaping = false;
-    std::string current;
-    for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
-        char c = property_mapping[i];
-        if (c == ']' && !in_string) break;
-        if (!in_string) {
-            if (c == '"') { in_string = true; current.clear(); }
-            continue;
-        }
-        if (escaping) { current.push_back(c); escaping = false; continue; }
-        if (c == '\\') { escaping = true; continue; }
-        if (c == '"') {
-            in_string = false;
-            if (!current.empty()) names.push_back(current);
-            continue;
+    // Extracts bucket names from the ContextualSchema property_mapping JSON.
+    // The schema stores bucket names in a "buckets" array — this is the
+    // authoritative source, as Frame::bucket_map may not have string keys.
+    std::vector<std::string> ExtractBucketNamesFromSchema(const std::string& property_mapping) {
+        std::vector<std::string> names;
+        if (property_mapping.empty())
+            return names;
+
+        const std::string key = "\"buckets\"";
+        size_t key_pos = property_mapping.find(key);
+        if (key_pos == std::string::npos)
+            return names;
+
+        size_t open_bracket = property_mapping.find('[', key_pos + key.size());
+        if (open_bracket == std::string::npos)
+            return names;
+
+        bool in_string = false;
+        bool escaping = false;
+        std::string current;
+        for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
+            char c = property_mapping[i];
+            if (c == ']' && !in_string)
+                break;
+            if (!in_string) {
+                if (c == '"') {
+                    in_string = true;
+                    current.clear();
+                }
+                continue;
+            }
+            if (escaping) {
+                current.push_back(c);
+                escaping = false;
+                continue;
+            }
+            if (c == '\\') {
+                escaping = true;
+                continue;
+            }
+            if (c == '"') {
+                in_string = false;
+                if (!current.empty())
+                    names.push_back(current);
+                continue;
+            }
+            current.push_back(c);
         }
-        current.push_back(c);
+        return names;
     }
-    return names;
-}
 
-std::string ToLowerCopy(const std::string& value) {
-    std::string lower = value;
-    std::transform(lower.begin(), lower.end(), lower.begin(),
-        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    return lower;
-}
+    std::string ToLowerCopy(const std::string& value) {
+        std::string lower = value;
+        std::transform(lower.begin(), lower.end(), lower.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return lower;
+    }
 
-bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
-    if (query_lower.empty()) return true;
-    return ToLowerCopy(text).find(query_lower) != std::string::npos;
-}
+    bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
+        if (query_lower.empty())
+            return true;
+        return ToLowerCopy(text).find(query_lower) != std::string::npos;
+    }
 
-// Parses comma-separated UIDs from input, trimming whitespace.
-std::vector<std::string> ParseCommaSeparated(const char* input) {
-    std::vector<std::string> result;
-    std::istringstream stream(input);
-    std::string token;
-    while (std::getline(stream, token, ',')) {
-        // Trim whitespace
-        auto start = token.find_first_not_of(" \t");
-        auto end = token.find_last_not_of(" \t");
-        if (start != std::string::npos) {
-            result.push_back(token.substr(start, end - start + 1));
+    // Parses comma-separated UIDs from input, trimming whitespace.
+    std::vector<std::string> ParseCommaSeparated(const char* input) {
+        std::vector<std::string> result;
+        std::istringstream stream(input);
+        std::string token;
+        while (std::getline(stream, token, ',')) {
+            // Trim whitespace
+            auto start = token.find_first_not_of(" \t");
+            auto end = token.find_last_not_of(" \t");
+            if (start != std::string::npos) {
+                result.push_back(token.substr(start, end - start + 1));
+            }
         }
+        return result;
     }
-    return result;
-}
 
 } // namespace
 
-EntityLifeTimeWindow::EntityLifeTimeWindow(
-    std::shared_ptr<InspectorSession> session,
-    int instance_id)
+EntityLifeTimeWindow::EntityLifeTimeWindow(std::shared_ptr<InspectorSession> session, int instance_id)
     : ImGuiWindow("Entity LifeTime #" + std::to_string(instance_id), session)
-    , inspector_session_(std::move(session))
-{
-}
+    , inspector_session_(std::move(session)) {}
 
 void EntityLifeTimeWindow::PopulateBucketNames() {
     bucket_names_.clear();
@@ -94,9 +106,11 @@ void EntityLifeTimeWindow::PopulateBucketNames() {
     if (bucket_names_.empty()) {
         // Fallback: try to read bucket names from the current frame's bucket_map
         auto* reader = inspector_session_->GetReader();
-        if (!reader) return;
+        if (!reader)
+            return;
         const auto* frame = reader->GetFrame(inspector_session_->GetCurrentFrame());
-        if (!frame || frame->bucket_map.empty()) return;
+        if (!frame || frame->bucket_map.empty())
+            return;
         for (const auto& [name, idx] : frame->bucket_map) {
             bucket_names_.push_back(name);
         }
@@ -160,14 +174,15 @@ void EntityLifeTimeWindow::DrawConfigPanel() {
     }
 
     // UID filter
-    ImGui::InputTextWithHint("##UidFilter", "Filter by UniqueIDs (comma-separated, empty = all)",
-        uid_filter_input_, IM_ARRAYSIZE(uid_filter_input_));
+    ImGui::InputTextWithHint("##UidFilter", "Filter by UniqueIDs (comma-separated, empty = all)", uid_filter_input_,
+                             IM_ARRAYSIZE(uid_filter_input_));
 
     ImGui::Spacing();
 
     // Run button
     bool can_run = !bucket_names_.empty() && start_frame_ <= end_frame_;
-    if (!can_run) ImGui::BeginDisabled();
+    if (!can_run)
+        ImGui::BeginDisabled();
     if (ImGui::Button("Run Analysis", ImVec2(140.0f, 0.0f))) {
         VtxServices::AnalysisScanner::ScanConfig config;
         config.start_frame = start_frame_;
@@ -180,10 +195,10 @@ void EntityLifeTimeWindow::DrawConfigPanel() {
         auto cache = reader->GetPropertyAddressCache();
         auto footer = reader->GetFooter();
 
-        scanner_.Start(VtxServices::AnalysisScanner::ScanType::EntityLifeTime,
-            config, reader, cache, footer);
+        scanner_.Start(VtxServices::AnalysisScanner::ScanType::EntityLifeTime, config, reader, cache, footer);
     }
-    if (!can_run) ImGui::EndDisabled();
+    if (!can_run)
+        ImGui::EndDisabled();
 }
 
 void EntityLifeTimeWindow::DrawProgressPanel() {
@@ -209,12 +224,11 @@ void EntityLifeTimeWindow::DrawResultsPanel() {
 
     // Top bar: search + export + new scan
     ImGui::SetNextItemWidth(250.0f);
-    ImGui::InputTextWithHint("##SearchFilter", "Search results...",
-        search_filter_, IM_ARRAYSIZE(search_filter_));
+    ImGui::InputTextWithHint("##SearchFilter", "Search results...", search_filter_, IM_ARRAYSIZE(search_filter_));
     ImGui::SameLine();
     if (ImGui::Button("Export CSV")) {
         auto dest = pfd::save_file("Export Entity LifeTime CSV", "entity_lifetime.csv",
-            { "CSV Files (.csv)", "*.csv", "All Files", "*" });
+                                   {"CSV Files (.csv)", "*.csv", "All Files", "*"});
         if (!dest.result().empty()) {
             VtxServices::ExportEntityLifeTimeCsv(dest.result(), result);
         }
@@ -244,10 +258,9 @@ void EntityLifeTimeWindow::DrawResultsPanel() {
     }
 
     // Results table
-    constexpr ImGuiTableFlags table_flags =
-        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
-        ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY |
-        ImGuiTableFlags_Sortable;
+    constexpr ImGuiTableFlags table_flags = ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
+                                            ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY |
+                                            ImGuiTableFlags_Sortable;
 
     if (ImGui::BeginTable("##LifeTimeTable", 4, table_flags)) {
         ImGui::TableSetupScrollFreeze(0, 1);
@@ -266,11 +279,12 @@ void EntityLifeTimeWindow::DrawResultsPanel() {
 
             // Apply search filter across all columns
             if (!filter_query.empty()) {
-                bool matches = ContainsCaseInsensitive(entry.unique_id, filter_query)
-                    || ContainsCaseInsensitive(type_label, filter_query)
-                    || ContainsCaseInsensitive(frame_ranges, filter_query)
-                    || ContainsCaseInsensitive(time_ranges, filter_query);
-                if (!matches) continue;
+                bool matches = ContainsCaseInsensitive(entry.unique_id, filter_query) ||
+                               ContainsCaseInsensitive(type_label, filter_query) ||
+                               ContainsCaseInsensitive(frame_ranges, filter_query) ||
+                               ContainsCaseInsensitive(time_ranges, filter_query);
+                if (!matches)
+                    continue;
             }
 
             ImGui::TableNextRow();
diff --git a/tools/inspector/src/windows/file_info_window.cpp b/tools/inspector/src/windows/file_info_window.cpp
index 2a1d814..aa6bd18 100644
--- a/tools/inspector/src/windows/file_info_window.cpp
+++ b/tools/inspector/src/windows/file_info_window.cpp
@@ -9,32 +9,31 @@
 
 namespace {
 
-bool BeginPropertyTable(const char* id, float label_width = 160.0f) {
-    if (ImGui::BeginTable(id, 2, ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_RowBg)) {
-        ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed, label_width);
-        ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
-        return true;
+    bool BeginPropertyTable(const char* id, float label_width = 160.0f) {
+        if (ImGui::BeginTable(id, 2, ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_RowBg)) {
+            ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed, label_width);
+            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
+            return true;
+        }
+        return false;
     }
-    return false;
-}
 
-ImVec4 ResolveToneColor(VtxServices::FileInfoTone tone) {
-    switch (tone) {
+    ImVec4 ResolveToneColor(VtxServices::FileInfoTone tone) {
+        switch (tone) {
         case VtxServices::FileInfoTone::Highlight:
             return ImVec4(0.4f, 0.8f, 1.0f, 1.0f);
         case VtxServices::FileInfoTone::Success:
             return ImVec4(0.0f, 1.0f, 0.0f, 1.0f);
         default:
             return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+        }
     }
-}
 
 } // namespace
 
 FileInfoWindow::FileInfoWindow(std::shared_ptr<InspectorSession> session)
     : ImGuiWindow(VtxGuiNames::FilePropertiesWindow, session)
-    , inspector_session_(std::move(session)) {
-}
+    , inspector_session_(std::move(session)) {}
 
 void FileInfoWindow::DrawContent() {
     if (!inspector_session_->HasLoadedReplay()) {
@@ -43,11 +42,8 @@ void FileInfoWindow::DrawContent() {
     }
 
     const auto view_model = VtxServices::FooterSummaryService::BuildFileInfoViewModel(
-        inspector_session_->current_file_path_,
-        inspector_session_->GetFileSizeMb(),
-        inspector_session_->GetFormat(),
-        inspector_session_->GetHeader(),
-        inspector_session_->GetFooter());
+        inspector_session_->current_file_path_, inspector_session_->GetFileSizeMb(), inspector_session_->GetFormat(),
+        inspector_session_->GetHeader(), inspector_session_->GetFooter());
 
     ImGui::TextWrapped("File: %s", view_model.file_path.c_str());
     ImGui::Separator();
@@ -62,12 +58,8 @@ void FileInfoWindow::DrawContent() {
                     ImGui::TextDisabled("No custom metadata in this file.");
                 } else {
                     ImVec2 text_size = ImVec2(-FLT_MIN, 200.0f);
-                    ImGui::InputTextMultiline(
-                        "##CustomMeta",
-                        const_cast<char*>(section.raw_text.c_str()),
-                        section.raw_text.size(),
-                        text_size,
-                        ImGuiInputTextFlags_ReadOnly);
+                    ImGui::InputTextMultiline("##CustomMeta", const_cast<char*>(section.raw_text.c_str()),
+                                              section.raw_text.size(), text_size, ImGuiInputTextFlags_ReadOnly);
                 }
             } else if (BeginPropertyTable((section.title + "Table").c_str())) {
                 for (const auto& row : section.rows) {
diff --git a/tools/inspector/src/windows/reader_inspector_window.cpp b/tools/inspector/src/windows/reader_inspector_window.cpp
index c598808..5b5a957 100644
--- a/tools/inspector/src/windows/reader_inspector_window.cpp
+++ b/tools/inspector/src/windows/reader_inspector_window.cpp
@@ -8,91 +8,83 @@
 
 namespace {
 
-// Resolves which chunk currently owns the requested frame.
-int FindActiveChunkIndex(const std::vector<VTX::ChunkIndexEntry>& seek_table, int frame_index) {
-    const auto it = std::lower_bound(
-        seek_table.begin(),
-        seek_table.end(),
-        frame_index,
-        [](const VTX::ChunkIndexEntry& entry, int value) { return entry.end_frame < value; });
-
-    if (it == seek_table.end() || frame_index < it->start_frame) {
-        return -1;
+    // Resolves which chunk currently owns the requested frame.
+    int FindActiveChunkIndex(const std::vector<VTX::ChunkIndexEntry>& seek_table, int frame_index) {
+        const auto it =
+            std::lower_bound(seek_table.begin(), seek_table.end(), frame_index,
+                             [](const VTX::ChunkIndexEntry& entry, int value) { return entry.end_frame < value; });
+
+        if (it == seek_table.end() || frame_index < it->start_frame) {
+            return -1;
+        }
+
+        return it->chunk_index;
     }
 
-    return it->chunk_index;
-}
+    // Builds text showing active chunk and neighborhood window.
+    std::string BuildActiveChunkWindowText(const std::vector<VTX::ChunkIndexEntry>& seek_table, int active_chunk_index,
+                                           int backward_count, int forward_count) {
+        if (seek_table.empty() || active_chunk_index < 0) {
+            return "Unavailable";
+        }
 
-// Builds text showing active chunk and neighborhood window.
-std::string BuildActiveChunkWindowText(
-    const std::vector<VTX::ChunkIndexEntry>& seek_table,
-    int active_chunk_index,
-    int backward_count,
-    int forward_count) {
-    if (seek_table.empty() || active_chunk_index < 0) {
-        return "Unavailable";
-    }
+        const int start = std::max(0, active_chunk_index - backward_count);
+        const int end = std::min(static_cast<int>(seek_table.size()) - 1, active_chunk_index + forward_count);
 
-    const int start = std::max(0, active_chunk_index - backward_count);
-    const int end = std::min(static_cast<int>(seek_table.size()) - 1, active_chunk_index + forward_count);
+        std::string text;
+        for (int chunk_index = start; chunk_index <= end; ++chunk_index) {
+            if (!text.empty()) {
+                text += ' ';
+            }
 
-    std::string text;
-    for (int chunk_index = start; chunk_index <= end; ++chunk_index) {
-        if (!text.empty()) {
-            text += ' ';
-        }
+            if (chunk_index == active_chunk_index) {
+                text += '[';
+                text += std::to_string(chunk_index);
+                text += ']';
+                continue;
+            }
 
-        if (chunk_index == active_chunk_index) {
-            text += '[';
             text += std::to_string(chunk_index);
-            text += ']';
-            continue;
         }
 
-        text += std::to_string(chunk_index);
+        return text;
     }
 
-    return text;
-}
+    // Builds text showing loaded chunks within the configured cache window.
+    std::string BuildLoadedChunkWindowText(const std::vector<int32_t>& loaded_chunks,
+                                           const std::vector<VTX::ChunkIndexEntry>& seek_table, int active_chunk_index,
+                                           int backward_count, int forward_count) {
+        if (seek_table.empty() || active_chunk_index < 0) {
+            return "Unavailable";
+        }
 
-// Builds text showing loaded chunks within the configured cache window.
-std::string BuildLoadedChunkWindowText(
-    const std::vector<int32_t>& loaded_chunks,
-    const std::vector<VTX::ChunkIndexEntry>& seek_table,
-    int active_chunk_index,
-    int backward_count,
-    int forward_count) {
-    if (seek_table.empty() || active_chunk_index < 0) {
-        return "Unavailable";
-    }
+        const int start = std::max(0, active_chunk_index - backward_count);
+        const int end = std::min(static_cast<int>(seek_table.size()) - 1, active_chunk_index + forward_count);
 
-    const int start = std::max(0, active_chunk_index - backward_count);
-    const int end = std::min(static_cast<int>(seek_table.size()) - 1, active_chunk_index + forward_count);
+        std::string text;
+        for (int chunk_index = start; chunk_index <= end; ++chunk_index) {
+            // Show only chunks that are currently resident in memory.
+            if (std::find(loaded_chunks.begin(), loaded_chunks.end(), chunk_index) == loaded_chunks.end()) {
+                continue;
+            }
 
-    std::string text;
-    for (int chunk_index = start; chunk_index <= end; ++chunk_index) {
-        // Show only chunks that are currently resident in memory.
-        if (std::find(loaded_chunks.begin(), loaded_chunks.end(), chunk_index) == loaded_chunks.end()) {
-            continue;
-        }
+            if (!text.empty()) {
+                text += ' ';
+            }
 
-        if (!text.empty()) {
-            text += ' ';
-        }
+            if (chunk_index == active_chunk_index) {
+                text += '[';
+                text += std::to_string(chunk_index);
+                text += ']';
+                continue;
+            }
 
-        if (chunk_index == active_chunk_index) {
-            text += '[';
             text += std::to_string(chunk_index);
-            text += ']';
-            continue;
         }
 
-        text += std::to_string(chunk_index);
+        return text.empty() ? "None" : text;
     }
 
-    return text.empty() ? "None" : text;
-}
-
 } // namespace
 
 // Constructs reader profiler window bound to Inspector session.
@@ -137,16 +129,13 @@ void ReaderInspectorWindow::DrawContent() {
 
     // Step 2: Build and render current profile rows.
     const auto snapshot = inspector_session_->GetReaderChunkSnapshot();
-    const auto vm = VtxServices::ReaderChunkStateService::BuildProfileViewModel(snapshot, ImGui::GetTime(), profile_cache_);
+    const auto vm =
+        VtxServices::ReaderChunkStateService::BuildProfileViewModel(snapshot, ImGui::GetTime(), profile_cache_);
     auto rows = VtxServices::ReaderChunkStateService::BuildProfileRows(vm);
     if (!rows.empty()) {
         // Replace the "Loaded" row with a focused cache-window snapshot.
         const std::string loaded_chunk_window = BuildLoadedChunkWindowText(
-            snapshot.loaded_chunks,
-            seek_table,
-            active_chunk_index,
-            cache_window_backward_,
-            cache_window_forward_);
+            snapshot.loaded_chunks, seek_table, active_chunk_index, cache_window_backward_, cache_window_forward_);
         rows.front().chunk_text = loaded_chunk_window;
         rows.front().disabled = loaded_chunk_window == "Unavailable" || loaded_chunk_window == "None";
     }
@@ -164,10 +153,9 @@ void ReaderInspectorWindow::DrawContent() {
             ImGui::TableNextRow();
             ImGui::TableNextColumn();
             if (row.highlighted) {
-                ImGui::TextColored(
-                    row.state_label.rfind("Loaded", 0) == 0 ? ImVec4(0.2f, 1.0f, 0.2f, 1.0f) : ImVec4(1.0f, 0.8f, 0.2f, 1.0f),
-                    "%s",
-                    row.state_label.c_str());
+                ImGui::TextColored(row.state_label.rfind("Loaded", 0) == 0 ? ImVec4(0.2f, 1.0f, 0.2f, 1.0f)
+                                                                           : ImVec4(1.0f, 0.8f, 0.2f, 1.0f),
+                                   "%s", row.state_label.c_str());
             } else if (row.disabled) {
                 ImGui::TextDisabled("%s", row.state_label.c_str());
             } else {
@@ -194,17 +182,13 @@ void ReaderInspectorWindow::ApplyCacheWindowIfNeeded(VTX::IVtxReaderFacade* read
         return;
     }
 
-    if (!force_apply &&
-        last_applied_reader_ == reader &&
-        last_applied_backward_ == cache_window_backward_ &&
+    if (!force_apply && last_applied_reader_ == reader && last_applied_backward_ == cache_window_backward_ &&
         last_applied_forward_ == cache_window_forward_) {
         // Avoid redundant SetCacheWindow calls while values are unchanged.
         return;
     }
 
-    reader->SetCacheWindow(
-        static_cast<uint32_t>(cache_window_backward_),
-        static_cast<uint32_t>(cache_window_forward_));
+    reader->SetCacheWindow(static_cast<uint32_t>(cache_window_backward_), static_cast<uint32_t>(cache_window_forward_));
 
     last_applied_reader_ = reader;
     last_applied_backward_ = cache_window_backward_;
diff --git a/tools/inspector/src/windows/replay_time_data_window.cpp b/tools/inspector/src/windows/replay_time_data_window.cpp
index 5972ee8..73f34f5 100644
--- a/tools/inspector/src/windows/replay_time_data_window.cpp
+++ b/tools/inspector/src/windows/replay_time_data_window.cpp
@@ -11,32 +11,32 @@
 
 namespace {
 
-enum class TimeDataTabKind : int {
-    GameTimestamps = 0,
-    UtcTimestamps = 1,
-    Gaps = 2,
-    Segments = 3,
-};
+    enum class TimeDataTabKind : int {
+        GameTimestamps = 0,
+        UtcTimestamps = 1,
+        Gaps = 2,
+        Segments = 3,
+    };
 
-struct TimeDataTabInteraction {
-    bool should_seek = false;
-    int seek_frame = 0;
-    bool should_switch_to_game_timestamp_tab = false;
-    bool consumed_scroll_request = false;
-    bool tab_opened = false;
-};
+    struct TimeDataTabInteraction {
+        bool should_seek = false;
+        int seek_frame = 0;
+        bool should_switch_to_game_timestamp_tab = false;
+        bool consumed_scroll_request = false;
+        bool tab_opened = false;
+    };
 
-// Clamps requested frame index into currently loaded replay frame bounds.
-int ClampFrameIndex(int frame_index, int total_frames) {
-    if (total_frames <= 0) {
-        return 0;
+    // Clamps requested frame index into currently loaded replay frame bounds.
+    int ClampFrameIndex(int frame_index, int total_frames) {
+        if (total_frames <= 0) {
+            return 0;
+        }
+        return std::clamp(frame_index, 0, total_frames - 1);
     }
-    return std::clamp(frame_index, 0, total_frames - 1);
-}
 
-// Resolves clicked row to target replay frame index for each time-data tab.
-int ResolveFrameForTabRow(TimeDataTabKind tab_kind, int row, const VTX::ReplayTimeData& time_data) {
-    switch (tab_kind) {
+    // Resolves clicked row to target replay frame index for each time-data tab.
+    int ResolveFrameForTabRow(TimeDataTabKind tab_kind, int row, const VTX::ReplayTimeData& time_data) {
+        switch (tab_kind) {
         case TimeDataTabKind::GameTimestamps:
         case TimeDataTabKind::UtcTimestamps:
             return row;
@@ -50,111 +50,98 @@ int ResolveFrameForTabRow(TimeDataTabKind tab_kind, int row, const VTX::ReplayTi
                 return time_data.segments[static_cast<size_t>(row)];
             }
             return row;
+        }
+        return row;
     }
-    return row;
-}
 
-// Draws a styled bullet entry for the time-data guide panel.
-void DrawTimeDataGuideItem(const char* title, const char* description) {
-    ImGui::Bullet();
-    ImGui::SameLine();
-    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.35f, 0.72f, 0.96f, 1.0f));
-    ImGui::TextUnformatted(title);
-    ImGui::PopStyleColor();
-    ImGui::Indent();
-    ImGui::PushTextWrapPos();
-    ImGui::TextWrapped("%s", description);
-    ImGui::PopTextWrapPos();
-    ImGui::Unindent();
-    ImGui::Spacing();
-}
+    // Draws a styled bullet entry for the time-data guide panel.
+    void DrawTimeDataGuideItem(const char* title, const char* description) {
+        ImGui::Bullet();
+        ImGui::SameLine();
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.35f, 0.72f, 0.96f, 1.0f));
+        ImGui::TextUnformatted(title);
+        ImGui::PopStyleColor();
+        ImGui::Indent();
+        ImGui::PushTextWrapPos();
+        ImGui::TextWrapped("%s", description);
+        ImGui::PopTextWrapPos();
+        ImGui::Unindent();
+        ImGui::Spacing();
+    }
 
-// Draws a quick reference for the meaning and usage of each replay time stream.
-void DrawTimeDataGuide() {
-    ImGui::SetNextItemOpen(false, ImGuiCond_FirstUseEver);
-    if (ImGui::CollapsingHeader("Time Data Guide")) {
-        if (ImGui::BeginChild("TimeDataGuideBody", ImVec2(0.0f, 220.0f), true)) {
-            ImGui::Spacing();
-            DrawTimeDataGuideItem(
-                "GameTime",
-                "The internal timer captured directly from the source. It can increase, decrease, or jump "
-                "forward/backward depending on the source, and it can be affected by engine time dilation. "
-                "Use this mainly for display purposes. When the source supports it, it can also help binary "
-                "search to locate the correct frame.");
-            DrawTimeDataGuideItem(
-                "UTC Timestamp",
-                "The time each frame was captured. This is guaranteed to be monotonically increasing. If the "
-                "source start UTC is known, timestamps begin from that value; otherwise they begin when data "
-                "is written to VTX. Use this for internal playback timing by making values relative to the "
-                "first entry.");
-            DrawTimeDataGuideItem(
-                "Gaps",
-                "Frame numbers where a gap is detected in UTC timestamps. This can represent pauses, frame "
-                "loss, or similar capture interruptions.");
-            DrawTimeDataGuideItem(
-                "Segments",
-                "Frame numbers where game-time direction changes, or where developers manually mark important "
-                "parts of the data. This is commonly used to indicate new rounds.");
+    // Draws a quick reference for the meaning and usage of each replay time stream.
+    void DrawTimeDataGuide() {
+        ImGui::SetNextItemOpen(false, ImGuiCond_FirstUseEver);
+        if (ImGui::CollapsingHeader("Time Data Guide")) {
+            if (ImGui::BeginChild("TimeDataGuideBody", ImVec2(0.0f, 220.0f), true)) {
+                ImGui::Spacing();
+                DrawTimeDataGuideItem(
+                    "GameTime",
+                    "The internal timer captured directly from the source. It can increase, decrease, or jump "
+                    "forward/backward depending on the source, and it can be affected by engine time dilation. "
+                    "Use this mainly for display purposes. When the source supports it, it can also help binary "
+                    "search to locate the correct frame.");
+                DrawTimeDataGuideItem(
+                    "UTC Timestamp",
+                    "The time each frame was captured. This is guaranteed to be monotonically increasing. If the "
+                    "source start UTC is known, timestamps begin from that value; otherwise they begin when data "
+                    "is written to VTX. Use this for internal playback timing by making values relative to the "
+                    "first entry.");
+                DrawTimeDataGuideItem(
+                    "Gaps", "Frame numbers where a gap is detected in UTC timestamps. This can represent pauses, frame "
+                            "loss, or similar capture interruptions.");
+                DrawTimeDataGuideItem(
+                    "Segments",
+                    "Frame numbers where game-time direction changes, or where developers manually mark important "
+                    "parts of the data. This is commonly used to indicate new rounds.");
+            }
+            ImGui::EndChild();
         }
-        ImGui::EndChild();
     }
-}
 
-// Renders one time-data tab as a clickable table and emits navigation actions.
-TimeDataTabInteraction DrawTimeDataTab(
-    const VtxServices::ReplayTimeTabViewModel& tab,
-    const char* table_id,
-    TimeDataTabKind tab_kind,
-    const VTX::ReplayTimeData& time_data,
-    int total_frames,
-    int highlighted_frame_row,
-    bool should_scroll_to_highlighted_game_row,
-    bool should_select_tab) {
-    TimeDataTabInteraction interaction;
-    const ImGuiTabItemFlags tab_flags = should_select_tab ? ImGuiTabItemFlags_SetSelected : ImGuiTabItemFlags_None;
-    if (ImGui::BeginTabItem(tab.label.c_str(), nullptr, tab_flags)) {
-        interaction.tab_opened = true;
-        if (tab.values.empty()) {
-            ImGui::TextDisabled("No entries.");
-        } else if (ImGui::BeginTable(
-                       table_id,
-                       2,
-                       ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
-                           ImGuiTableFlags_ScrollY | ImGuiTableFlags_Resizable,
-                       ImVec2(0, ImGui::GetContentRegionAvail().y))) {
-            ImGui::TableSetupScrollFreeze(0, 1);
-            ImGui::TableSetupColumn("Index", ImGuiTableColumnFlags_WidthFixed, 80.0f);
-            ImGui::TableSetupColumn(tab.value_column_label.c_str(), ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableHeadersRow();
+    // Renders one time-data tab as a clickable table and emits navigation actions.
+    TimeDataTabInteraction DrawTimeDataTab(const VtxServices::ReplayTimeTabViewModel& tab, const char* table_id,
+                                           TimeDataTabKind tab_kind, const VTX::ReplayTimeData& time_data,
+                                           int total_frames, int highlighted_frame_row,
+                                           bool should_scroll_to_highlighted_game_row, bool should_select_tab) {
+        TimeDataTabInteraction interaction;
+        const ImGuiTabItemFlags tab_flags = should_select_tab ? ImGuiTabItemFlags_SetSelected : ImGuiTabItemFlags_None;
+        if (ImGui::BeginTabItem(tab.label.c_str(), nullptr, tab_flags)) {
+            interaction.tab_opened = true;
+            if (tab.values.empty()) {
+                ImGui::TextDisabled("No entries.");
+            } else if (ImGui::BeginTable(table_id, 2,
+                                         ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY |
+                                             ImGuiTableFlags_Resizable,
+                                         ImVec2(0, ImGui::GetContentRegionAvail().y))) {
+                ImGui::TableSetupScrollFreeze(0, 1);
+                ImGui::TableSetupColumn("Index", ImGuiTableColumnFlags_WidthFixed, 80.0f);
+                ImGui::TableSetupColumn(tab.value_column_label.c_str(), ImGuiTableColumnFlags_WidthStretch);
+                ImGui::TableHeadersRow();
 
-            const bool render_all_rows_for_scroll =
-                should_scroll_to_highlighted_game_row && tab_kind == TimeDataTabKind::GameTimestamps;
+                const bool render_all_rows_for_scroll =
+                    should_scroll_to_highlighted_game_row && tab_kind == TimeDataTabKind::GameTimestamps;
 
-            auto render_row = [&](int row) {
+                auto render_row = [&](int row) {
                     const bool is_highlighted_timeline_row =
-                        (tab_kind == TimeDataTabKind::GameTimestamps ||
-                         tab_kind == TimeDataTabKind::UtcTimestamps) &&
+                        (tab_kind == TimeDataTabKind::GameTimestamps || tab_kind == TimeDataTabKind::UtcTimestamps) &&
                         (row == highlighted_frame_row);
 
                     ImGui::TableNextRow();
                     ImGui::TableSetColumnIndex(0);
-                    const std::string selectable_id =
-                        "[" + std::to_string(row) + "]##TimeDataRow_" +
-                        std::to_string(static_cast<int>(tab_kind)) + "_" + std::to_string(row);
-                    if (ImGui::Selectable(
-                            selectable_id.c_str(),
-                            is_highlighted_timeline_row,
-                            ImGuiSelectableFlags_SpanAllColumns)) {
+                    const std::string selectable_id = "[" + std::to_string(row) + "]##TimeDataRow_" +
+                                                      std::to_string(static_cast<int>(tab_kind)) + "_" +
+                                                      std::to_string(row);
+                    if (ImGui::Selectable(selectable_id.c_str(), is_highlighted_timeline_row,
+                                          ImGuiSelectableFlags_SpanAllColumns)) {
                         interaction.should_seek = true;
-                        interaction.seek_frame = ClampFrameIndex(
-                            ResolveFrameForTabRow(tab_kind, row, time_data),
-                            total_frames);
+                        interaction.seek_frame =
+                            ClampFrameIndex(ResolveFrameForTabRow(tab_kind, row, time_data), total_frames);
                         interaction.should_switch_to_game_timestamp_tab =
                             tab_kind == TimeDataTabKind::Gaps || tab_kind == TimeDataTabKind::Segments;
                     }
 
-                    if ((tab_kind == TimeDataTabKind::GameTimestamps) &&
-                        is_highlighted_timeline_row &&
+                    if ((tab_kind == TimeDataTabKind::GameTimestamps) && is_highlighted_timeline_row &&
                         should_scroll_to_highlighted_game_row) {
                         ImGui::SetScrollHereY(0.25f);
                         interaction.consumed_scroll_request = true;
@@ -162,34 +149,33 @@ TimeDataTabInteraction DrawTimeDataTab(
 
                     ImGui::TableSetColumnIndex(1);
                     ImGui::Text("%s", tab.values[row].c_str());
-            };
+                };
 
-            if (render_all_rows_for_scroll) {
-                for (int row = 0; row < static_cast<int>(tab.values.size()); ++row) {
-                    render_row(row);
-                }
-            } else {
-                ImGuiListClipper clipper;
-                clipper.Begin(static_cast<int>(tab.values.size()));
-                while (clipper.Step()) {
-                    for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; ++row) {
+                if (render_all_rows_for_scroll) {
+                    for (int row = 0; row < static_cast<int>(tab.values.size()); ++row) {
                         render_row(row);
                     }
+                } else {
+                    ImGuiListClipper clipper;
+                    clipper.Begin(static_cast<int>(tab.values.size()));
+                    while (clipper.Step()) {
+                        for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; ++row) {
+                            render_row(row);
+                        }
+                    }
                 }
+                ImGui::EndTable();
             }
-            ImGui::EndTable();
+            ImGui::EndTabItem();
         }
-        ImGui::EndTabItem();
+        return interaction;
     }
-    return interaction;
-}
 
 } // namespace
 
 ReplayTimeDataWindow::ReplayTimeDataWindow(std::shared_ptr<InspectorSession> session)
     : ImGuiWindow(VtxGuiNames::ReplayTimeDataWindow, session)
-    , inspector_session_(std::move(session)) {
-}
+    , inspector_session_(std::move(session)) {}
 
 void ReplayTimeDataWindow::DrawContent() {
     if (!inspector_session_->HasLoadedReplay()) {
@@ -199,10 +185,9 @@ void ReplayTimeDataWindow::DrawContent() {
 
     // Step 1: Build the view model with the current display format.
     TimeDisplayFormat current_format = inspector_session_->GetTimeDisplayFormat();
-    
-    auto view_model = VtxServices::FooterSummaryService::BuildReplayTimeViewModel(
-        inspector_session_->GetFooter().times,
-        current_format);
+
+    auto view_model = VtxServices::FooterSummaryService::BuildReplayTimeViewModel(inspector_session_->GetFooter().times,
+                                                                                  current_format);
 
     // Step 2: Draw summary and format controls.
     if (ImGui::BeginTable("TimeDataSummary", 2, ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_RowBg)) {
@@ -228,9 +213,8 @@ void ReplayTimeDataWindow::DrawContent() {
     if (ImGui::Checkbox("Formatted", &formatted)) {
         current_format = formatted ? TimeDisplayFormat::Formatted : TimeDisplayFormat::Ticks;
         inspector_session_->SetTimeDisplayFormat(current_format);
-        view_model = VtxServices::FooterSummaryService::BuildReplayTimeViewModel(
-            inspector_session_->GetFooter().times,
-            current_format);
+        view_model = VtxServices::FooterSummaryService::BuildReplayTimeViewModel(inspector_session_->GetFooter().times,
+                                                                                 current_format);
     }
     ImGui::Separator();
 
@@ -257,14 +241,8 @@ void ReplayTimeDataWindow::DrawContent() {
                 pending_scroll_to_highlighted_game_row_ && (tab_kind == TimeDataTabKind::GameTimestamps);
 
             const TimeDataTabInteraction interaction = DrawTimeDataTab(
-                view_model.tabs[i],
-                kTableIds[i],
-                tab_kind,
-                time_data,
-                total_frames,
-                highlighted_game_timestamp_row_,
-                should_scroll_to_highlighted_game_row,
-                should_select_tab);
+                view_model.tabs[i], kTableIds[i], tab_kind, time_data, total_frames, highlighted_game_timestamp_row_,
+                should_scroll_to_highlighted_game_row, should_select_tab);
 
             if (interaction.should_seek) {
                 inspector_session_->SetCurrentFrame(interaction.seek_frame);
diff --git a/tools/inspector/src/windows/schema_viewer_window.cpp b/tools/inspector/src/windows/schema_viewer_window.cpp
index 4d12149..365fcdf 100644
--- a/tools/inspector/src/windows/schema_viewer_window.cpp
+++ b/tools/inspector/src/windows/schema_viewer_window.cpp
@@ -12,68 +12,82 @@
 
 namespace {
 
-ImVec4 ResolveFieldTypeColor(VTX::FieldType type_id) {
-    switch (type_id) {
-        case VTX::FieldType::Bool: return ImVec4(0.86f, 0.32f, 0.32f, 1.0f);
-        case VTX::FieldType::Int8: return ImVec4(0.23f, 0.68f, 0.37f, 1.0f);
-        case VTX::FieldType::Int32: return ImVec4(0.16f, 0.62f, 0.56f, 1.0f);
-        case VTX::FieldType::Int64: return ImVec4(0.24f, 0.54f, 0.86f, 1.0f);
-        case VTX::FieldType::Float: return ImVec4(0.72f, 0.74f, 0.22f, 1.0f);
-        case VTX::FieldType::Double: return ImVec4(0.82f, 0.60f, 0.20f, 1.0f);
-        case VTX::FieldType::String: return ImVec4(0.72f, 0.45f, 0.86f, 1.0f);
-        case VTX::FieldType::Vector: return ImVec4(0.19f, 0.74f, 0.78f, 1.0f);
-        case VTX::FieldType::Quat: return ImVec4(0.38f, 0.64f, 0.93f, 1.0f);
-        case VTX::FieldType::Transform: return ImVec4(0.94f, 0.44f, 0.22f, 1.0f);
-        case VTX::FieldType::FloatRange: return ImVec4(0.58f, 0.78f, 0.30f, 1.0f);
-        case VTX::FieldType::Struct: return ImVec4(0.20f, 0.33f, 0.64f, 1.0f);
-        case VTX::FieldType::Enum: return ImVec4(0.60f, 0.52f, 0.86f, 1.0f);
-        default: return ImVec4(0.62f, 0.62f, 0.68f, 1.0f);
+    ImVec4 ResolveFieldTypeColor(VTX::FieldType type_id) {
+        switch (type_id) {
+        case VTX::FieldType::Bool:
+            return ImVec4(0.86f, 0.32f, 0.32f, 1.0f);
+        case VTX::FieldType::Int8:
+            return ImVec4(0.23f, 0.68f, 0.37f, 1.0f);
+        case VTX::FieldType::Int32:
+            return ImVec4(0.16f, 0.62f, 0.56f, 1.0f);
+        case VTX::FieldType::Int64:
+            return ImVec4(0.24f, 0.54f, 0.86f, 1.0f);
+        case VTX::FieldType::Float:
+            return ImVec4(0.72f, 0.74f, 0.22f, 1.0f);
+        case VTX::FieldType::Double:
+            return ImVec4(0.82f, 0.60f, 0.20f, 1.0f);
+        case VTX::FieldType::String:
+            return ImVec4(0.72f, 0.45f, 0.86f, 1.0f);
+        case VTX::FieldType::Vector:
+            return ImVec4(0.19f, 0.74f, 0.78f, 1.0f);
+        case VTX::FieldType::Quat:
+            return ImVec4(0.38f, 0.64f, 0.93f, 1.0f);
+        case VTX::FieldType::Transform:
+            return ImVec4(0.94f, 0.44f, 0.22f, 1.0f);
+        case VTX::FieldType::FloatRange:
+            return ImVec4(0.58f, 0.78f, 0.30f, 1.0f);
+        case VTX::FieldType::Struct:
+            return ImVec4(0.20f, 0.33f, 0.64f, 1.0f);
+        case VTX::FieldType::Enum:
+            return ImVec4(0.60f, 0.52f, 0.86f, 1.0f);
+        default:
+            return ImVec4(0.62f, 0.62f, 0.68f, 1.0f);
+        }
     }
-}
-
-bool ShouldOpenHighlightedStruct(const VtxServices::SchemaHighlightState& highlight, const std::string& struct_name) {
-    return VtxServices::SchemaViewService::IsHighlightActive(highlight) &&
-        highlight.do_scroll &&
-        highlight.struct_name == struct_name;
-}
 
-bool ConsumeScrollRequest(VtxServices::SchemaHighlightState& highlight) {
-    if (!highlight.do_scroll) {
-        return false;
+    bool ShouldOpenHighlightedStruct(const VtxServices::SchemaHighlightState& highlight,
+                                     const std::string& struct_name) {
+        return VtxServices::SchemaViewService::IsHighlightActive(highlight) && highlight.do_scroll &&
+               highlight.struct_name == struct_name;
     }
 
-    highlight.do_scroll = false;
-    return true;
-}
+    bool ConsumeScrollRequest(VtxServices::SchemaHighlightState& highlight) {
+        if (!highlight.do_scroll) {
+            return false;
+        }
 
-float ComputeHighlightAlpha(const VtxServices::SchemaHighlightState& highlight) {
-    if (!VtxServices::SchemaViewService::IsHighlightActive(highlight)) {
-        return 0.0f;
+        highlight.do_scroll = false;
+        return true;
     }
 
-    return highlight.time_remaining / 2.0f;
-}
+    float ComputeHighlightAlpha(const VtxServices::SchemaHighlightState& highlight) {
+        if (!VtxServices::SchemaViewService::IsHighlightActive(highlight)) {
+            return 0.0f;
+        }
 
-bool DrawStructLinkButton(const std::string& label, const std::string& id_suffix, const ImVec4& text_color) {
-    ImGui::PushStyleColor(ImGuiCol_Text, text_color);
-    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.12f, 0.18f, 0.24f, 0.55f));
-    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.18f, 0.31f, 0.45f, 0.85f));
-    ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.16f, 0.42f, 0.64f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 2.0f));
-    const bool clicked = ImGui::Button((label + id_suffix).c_str());
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor(4);
-    return clicked;
-}
+        return highlight.time_remaining / 2.0f;
+    }
+
+    bool DrawStructLinkButton(const std::string& label, const std::string& id_suffix, const ImVec4& text_color) {
+        ImGui::PushStyleColor(ImGuiCol_Text, text_color);
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.12f, 0.18f, 0.24f, 0.55f));
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.18f, 0.31f, 0.45f, 0.85f));
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.16f, 0.42f, 0.64f, 1.0f));
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 2.0f));
+        const bool clicked = ImGui::Button((label + id_suffix).c_str());
+        ImGui::PopStyleVar();
+        ImGui::PopStyleColor(4);
+        return clicked;
+    }
 
 } // namespace
 
 SchemaViewerWindow::SchemaViewerWindow(std::shared_ptr<InspectorSession> session)
     : ImGuiWindow(VtxGuiNames::SchemaViewerWindow, session)
-    , inspector_session_(std::move(session)) {
-}
+    , inspector_session_(std::move(session)) {}
 
-void SchemaViewerWindow::DrawTypeIcon(VTX::FieldType type_id, VTX::FieldContainerType container_type, float size) const {
+void SchemaViewerWindow::DrawTypeIcon(VTX::FieldType type_id, VTX::FieldContainerType container_type,
+                                      float size) const {
     const ImVec4 base = ResolveFieldTypeColor(type_id);
     const float icon = size > 0.0f ? size : std::max(11.0f, ImGui::GetTextLineHeight() - 2.0f);
     const ImVec2 p = ImGui::GetCursorScreenPos();
@@ -81,23 +95,26 @@ void SchemaViewerWindow::DrawTypeIcon(VTX::FieldType type_id, VTX::FieldContaine
     const bool is_array = container_type == VTX::FieldContainerType::Array;
     const bool is_map = container_type == VTX::FieldContainerType::Map;
 
-    const ImVec4 array_tint = ImVec4(
-        std::min(base.x + 0.14f, 1.0f),
-        std::min(base.y + 0.14f, 1.0f),
-        std::min(base.z + 0.08f, 1.0f),
-        1.0f);
+    const ImVec4 array_tint =
+        ImVec4(std::min(base.x + 0.14f, 1.0f), std::min(base.y + 0.14f, 1.0f), std::min(base.z + 0.08f, 1.0f), 1.0f);
 
     if (is_array) {
-        draw->AddRectFilled(ImVec2(p.x + 2.5f, p.y + 2.5f), ImVec2(p.x + 2.5f + icon, p.y + 2.5f + icon), ImGui::ColorConvertFloat4ToU32(base), 3.0f);
-        draw->AddRect(ImVec2(p.x + 2.5f, p.y + 2.5f), ImVec2(p.x + 2.5f + icon, p.y + 2.5f + icon), IM_COL32(16, 18, 24, 220), 3.0f, 0, 1.0f);
+        draw->AddRectFilled(ImVec2(p.x + 2.5f, p.y + 2.5f), ImVec2(p.x + 2.5f + icon, p.y + 2.5f + icon),
+                            ImGui::ColorConvertFloat4ToU32(base), 3.0f);
+        draw->AddRect(ImVec2(p.x + 2.5f, p.y + 2.5f), ImVec2(p.x + 2.5f + icon, p.y + 2.5f + icon),
+                      IM_COL32(16, 18, 24, 220), 3.0f, 0, 1.0f);
 
-        draw->AddRectFilled(ImVec2(p.x, p.y), ImVec2(p.x + icon, p.y + icon), ImGui::ColorConvertFloat4ToU32(array_tint), 3.0f);
+        draw->AddRectFilled(ImVec2(p.x, p.y), ImVec2(p.x + icon, p.y + icon),
+                            ImGui::ColorConvertFloat4ToU32(array_tint), 3.0f);
         draw->AddRect(ImVec2(p.x, p.y), ImVec2(p.x + icon, p.y + icon), IM_COL32(16, 18, 24, 230), 3.0f, 0, 1.0f);
     } else if (is_map) {
-        draw->AddCircleFilled(ImVec2(p.x + icon * 0.5f, p.y + icon * 0.5f), icon * 0.48f, ImGui::ColorConvertFloat4ToU32(base), 18);
-        draw->AddCircle(ImVec2(p.x + icon * 0.5f, p.y + icon * 0.5f), icon * 0.48f, IM_COL32(16, 18, 24, 230), 18, 1.0f);
+        draw->AddCircleFilled(ImVec2(p.x + icon * 0.5f, p.y + icon * 0.5f), icon * 0.48f,
+                              ImGui::ColorConvertFloat4ToU32(base), 18);
+        draw->AddCircle(ImVec2(p.x + icon * 0.5f, p.y + icon * 0.5f), icon * 0.48f, IM_COL32(16, 18, 24, 230), 18,
+                        1.0f);
     } else {
-        draw->AddRectFilled(ImVec2(p.x, p.y), ImVec2(p.x + icon, p.y + icon), ImGui::ColorConvertFloat4ToU32(base), 3.0f);
+        draw->AddRectFilled(ImVec2(p.x, p.y), ImVec2(p.x + icon, p.y + icon), ImGui::ColorConvertFloat4ToU32(base),
+                            3.0f);
         draw->AddRect(ImVec2(p.x, p.y), ImVec2(p.x + icon, p.y + icon), IM_COL32(16, 18, 24, 230), 3.0f, 0, 1.0f);
     }
 
@@ -127,10 +144,11 @@ void SchemaViewerWindow::DrawContent() {
 
     ImGui::SameLine(ImGui::GetContentRegionAvail().x - 80.0f);
     if (ImGui::Button("Export JSON", ImVec2(90.0f, 0.0f))) {
-        auto dest = pfd::save_file("Export Schema JSON", "schema.json",
-            { "JSON Files (.json)", "*.json", "All Files", "*" });
+        auto dest =
+            pfd::save_file("Export Schema JSON", "schema.json", {"JSON Files (.json)", "*.json", "All Files", "*"});
         if (!dest.result().empty()) {
-            const bool success = VtxServices::SchemaViewService::ExportJsonToFile(dest.result(), schema.property_mapping);
+            const bool success =
+                VtxServices::SchemaViewService::ExportJsonToFile(dest.result(), schema.property_mapping);
             if (success) {
                 inspector_session_->AddGuiInfoLog("Schema JSON exported successfully.");
             } else {
@@ -144,14 +162,14 @@ void SchemaViewerWindow::DrawContent() {
     ImGui::Spacing();
     ImGui::TextDisabled("Total Structs Mapped: %zu", parsed_cache.structs.size());
     ImGui::Spacing();
-    
+
     auto& highlight = inspector_session_->MutableSchemaHighlight();
     VtxServices::SchemaViewService::TickHighlight(highlight, ImGui::GetIO().DeltaTime);
     const bool is_highlight_active = VtxServices::SchemaViewService::IsHighlightActive(highlight);
 
     for (const auto& [struct_id, struct_cache] : parsed_cache.structs) {
         const std::string& struct_name = struct_cache.name;
-        
+
         bool struct_is_highlighted = is_highlight_active && (highlight.struct_name == struct_name);
         if (highlight.do_scroll) {
             ImGui::SetNextItemOpen(struct_name == highlight.struct_name, ImGuiCond_Always);
@@ -160,7 +178,8 @@ void SchemaViewerWindow::DrawContent() {
         if (struct_is_highlighted) {
             ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.86f, 0.25f, 1.0f));
         }
-        const bool open = ImGui::TreeNode(struct_name.c_str(), "%s (%zu properties)", struct_name.c_str(), struct_cache.properties.size());
+        const bool open = ImGui::TreeNode(struct_name.c_str(), "%s (%zu properties)", struct_name.c_str(),
+                                          struct_cache.properties.size());
         if (struct_is_highlighted) {
             ImGui::PopStyleColor();
         }
@@ -170,7 +189,8 @@ void SchemaViewerWindow::DrawContent() {
 
         if (open) {
             ImGui::PushID(struct_id);
-            if (ImGui::BeginTable("StructPropsTable", 3, ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable)) {
+            if (ImGui::BeginTable("StructPropsTable", 3,
+                                  ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable)) {
                 ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthFixed, 150.0f);
                 ImGui::TableSetupColumn("Property Name", ImGuiTableColumnFlags_WidthStretch);
                 ImGui::TableSetupColumn("Array Index", ImGuiTableColumnFlags_WidthFixed, 90.0f);
@@ -181,33 +201,34 @@ void SchemaViewerWindow::DrawContent() {
                     const std::string_view prop_name = property_view.name;
                     const auto& address = *property_view.address;
                     bool is_target_prop = struct_is_highlighted && (highlight.property_name == prop_name);
-                    
+
                     ImGui::TableNextRow();
                     ImGui::TableNextColumn();
-                    
+
                     if (is_target_prop) {
-                        float alpha = ComputeHighlightAlpha(highlight); 
-                        int alpha_int = static_cast<int>(255.0f * alpha); 
-                        
+                        float alpha = ComputeHighlightAlpha(highlight);
+                        int alpha_int = static_cast<int>(255.0f * alpha);
+
                         ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, IM_COL32(220, 160, 0, alpha_int));
-                        
+
                         if (ConsumeScrollRequest(highlight)) {
-                            ImGui::SetScrollHereY(0.5f); 
+                            ImGui::SetScrollHereY(0.5f);
                         }
                     }
 
                     const VTX::FieldContainerType container_type =
                         VtxServices::SchemaViewService::ResolveContainerType(address);
-                    const std::string display_type =
-                        VtxServices::SchemaViewService::ResolveDisplayType(address);
+                    const std::string display_type = VtxServices::SchemaViewService::ResolveDisplayType(address);
 
                     DrawTypeIcon(address.type_id, container_type);
                     ImGui::SameLine(0.0f, 4.0f);
                     const ImVec4 color = ResolveFieldTypeColor(address.type_id);
-                    const bool is_known_struct = !address.child_type_name.empty() &&
+                    const bool is_known_struct =
+                        !address.child_type_name.empty() &&
                         parsed_cache.name_to_id.find(address.child_type_name) != parsed_cache.name_to_id.end();
                     if (is_known_struct) {
-                        if (DrawStructLinkButton(display_type, "##SchemaType_" + struct_name + "_" + std::string(prop_name), color)) {
+                        if (DrawStructLinkButton(display_type,
+                                                 "##SchemaType_" + struct_name + "_" + std::string(prop_name), color)) {
                             VtxServices::SchemaViewService::RequestHighlight(highlight, address.child_type_name, "");
                         }
                         if (ImGui::IsItemHovered()) {
@@ -226,10 +247,10 @@ void SchemaViewerWindow::DrawContent() {
                         ImGui::PopStyleColor();
                     }
 
-                    ImGui::TableNextColumn(); 
+                    ImGui::TableNextColumn();
                     ImGui::TextColored(ImVec4(0.5f, 1.0f, 0.5f, 1.0f), "[%d]", address.index);
                 }
-                
+
                 ImGui::EndTable();
             }
             ImGui::PopID();
diff --git a/tools/inspector/src/windows/timeline_events_window.cpp b/tools/inspector/src/windows/timeline_events_window.cpp
index fbf0af5..8fe39d7 100644
--- a/tools/inspector/src/windows/timeline_events_window.cpp
+++ b/tools/inspector/src/windows/timeline_events_window.cpp
@@ -9,8 +9,7 @@
 
 TimelineEventsWindow::TimelineEventsWindow(std::shared_ptr<InspectorSession> session)
     : ImGuiWindow(VtxGuiNames::TimelineEventsWindow, session)
-    , inspector_session_(std::move(session)) {
-}
+    , inspector_session_(std::move(session)) {}
 
 void TimelineEventsWindow::DrawContent() {
     if (!inspector_session_->HasLoadedReplay()) {
@@ -18,8 +17,8 @@ void TimelineEventsWindow::DrawContent() {
         return;
     }
 
-    const auto view_model = VtxServices::FooterSummaryService::BuildTimelineEventsTableViewModel(
-        inspector_session_->GetFooter().events);
+    const auto view_model =
+        VtxServices::FooterSummaryService::BuildTimelineEventsTableViewModel(inspector_session_->GetFooter().events);
 
     if (view_model.rows.empty()) {
         ImGui::TextDisabled("%s", view_model.empty_message.c_str());
@@ -29,18 +28,15 @@ void TimelineEventsWindow::DrawContent() {
     ImGui::TextDisabled("%s", view_model.count_label.c_str());
     ImGui::Spacing();
 
-    if (ImGui::BeginTable(
-            "EventsTable",
-            static_cast<int>(view_model.columns.size()),
-            ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
-                ImGuiTableFlags_ScrollY,
-            ImVec2(0, ImGui::GetContentRegionAvail().y))) {
+    if (ImGui::BeginTable("EventsTable", static_cast<int>(view_model.columns.size()),
+                          ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
+                              ImGuiTableFlags_ScrollY,
+                          ImVec2(0, ImGui::GetContentRegionAvail().y))) {
         ImGui::TableSetupScrollFreeze(0, 1);
         for (const auto& column : view_model.columns) {
             ImGui::TableSetupColumn(
                 column.label.c_str(),
-                column.stretch ? ImGuiTableColumnFlags_WidthStretch : ImGuiTableColumnFlags_WidthFixed,
-                column.width);
+                column.stretch ? ImGuiTableColumnFlags_WidthStretch : ImGuiTableColumnFlags_WidthFixed, column.width);
         }
         ImGui::TableHeadersRow();
 
diff --git a/tools/inspector/src/windows/timeline_window.cpp b/tools/inspector/src/windows/timeline_window.cpp
index 8c84220..9bc9943 100644
--- a/tools/inspector/src/windows/timeline_window.cpp
+++ b/tools/inspector/src/windows/timeline_window.cpp
@@ -9,144 +9,119 @@
 
 namespace {
 
-struct TimelineHoverInfo {
-    bool has_hover = false;
-    int frame_index = -1;
-    float frame_time_seconds = 0.0f;
-    VtxServices::ClockTime frame_time_clock;
-};
-
-struct TimelineFrameBarView {
-    int frame_index = 0;
-    float x_start = 0.0f;
-    float x_end = 0.0f;
-    float y_top = 0.0f;
-    float y_bottom = 0.0f;
-    bool is_current = false;
-    bool is_hovered = false;
-};
-
-struct TimelineStripViewModel {
-    float total_content_width = 0.0f;
-    float item_full_width = 0.0f;
-    std::vector<TimelineFrameBarView> bars;
-    TimelineHoverInfo hover_info;
-    bool request_scroll = false;
-    float desired_scroll_x = 0.0f;
-};
-
-// Clamps a requested frame into valid timeline range.
-int HandleGoToFrame(int requested_frame, int total_frames) {
-    return VtxServices::TimelineViewService::ClampFrame(requested_frame, total_frames);
-}
+    struct TimelineHoverInfo {
+        bool has_hover = false;
+        int frame_index = -1;
+        float frame_time_seconds = 0.0f;
+        VtxServices::ClockTime frame_time_clock;
+    };
+
+    struct TimelineFrameBarView {
+        int frame_index = 0;
+        float x_start = 0.0f;
+        float x_end = 0.0f;
+        float y_top = 0.0f;
+        float y_bottom = 0.0f;
+        bool is_current = false;
+        bool is_hovered = false;
+    };
+
+    struct TimelineStripViewModel {
+        float total_content_width = 0.0f;
+        float item_full_width = 0.0f;
+        std::vector<TimelineFrameBarView> bars;
+        TimelineHoverInfo hover_info;
+        bool request_scroll = false;
+        float desired_scroll_x = 0.0f;
+    };
+
+    // Clamps a requested frame into valid timeline range.
+    int HandleGoToFrame(int requested_frame, int total_frames) {
+        return VtxServices::TimelineViewService::ClampFrame(requested_frame, total_frames);
+    }
 
-// Computes per-bar width including bar+spacing budget.
-float ComputeItemFullWidth(const VtxServices::TimelineBarState& timeline_bar_state) {
-    return VtxServices::TimelineViewService::ComputeItemFullWidth(timeline_bar_state);
-}
+    // Computes per-bar width including bar+spacing budget.
+    float ComputeItemFullWidth(const VtxServices::TimelineBarState& timeline_bar_state) {
+        return VtxServices::TimelineViewService::ComputeItemFullWidth(timeline_bar_state);
+    }
 
-// Computes scroll offset that places the selected frame near the center.
-float ComputeCenteredScroll(
-    const VtxServices::TimelineBarState& timeline_bar_state,
-    int frame_index,
-    float view_width) {
-    return VtxServices::TimelineViewService::ComputeCenteredScroll(
-        frame_index,
-        ComputeItemFullWidth(timeline_bar_state),
-        view_width);
-}
+    // Computes scroll offset that places the selected frame near the center.
+    float ComputeCenteredScroll(const VtxServices::TimelineBarState& timeline_bar_state, int frame_index,
+                                float view_width) {
+        return VtxServices::TimelineViewService::ComputeCenteredScroll(
+            frame_index, ComputeItemFullWidth(timeline_bar_state), view_width);
+    }
+
+    // Builds hover payload (frame index + derived time labels) for tooltip rendering.
+    TimelineHoverInfo BuildHoverInfo(int hovered_frame, int total_frames, float duration_seconds) {
+        TimelineHoverInfo info;
+        if (hovered_frame < 0) {
+            return info;
+        }
 
-// Builds hover payload (frame index + derived time labels) for tooltip rendering.
-TimelineHoverInfo BuildHoverInfo(int hovered_frame, int total_frames, float duration_seconds) {
-    TimelineHoverInfo info;
-    if (hovered_frame < 0) {
+        const float fps = VtxServices::TimelineViewService::ComputePlaybackFps(total_frames, duration_seconds);
+        const float frame_time_sec = static_cast<float>(hovered_frame) / fps;
+        info.has_hover = true;
+        info.frame_index = hovered_frame;
+        info.frame_time_seconds = frame_time_sec;
+        info.frame_time_clock = VtxServices::TimelineViewService::ToClockTime(frame_time_sec);
         return info;
     }
 
-    const float fps = VtxServices::TimelineViewService::ComputePlaybackFps(total_frames, duration_seconds);
-    const float frame_time_sec = static_cast<float>(hovered_frame) / fps;
-    info.has_hover = true;
-    info.frame_index = hovered_frame;
-    info.frame_time_seconds = frame_time_sec;
-    info.frame_time_clock = VtxServices::TimelineViewService::ToClockTime(frame_time_sec);
-    return info;
-}
+    // Builds strip bars, hover state, and optional scroll requests for current frame.
+    TimelineStripViewModel BuildStripViewModel(VtxServices::TimelineBarState& timeline_bar_state, int total_frames,
+                                               int current_frame, float duration_seconds, float scroll_x,
+                                               float view_width, float origin_x, float origin_y, float timeline_height,
+                                               bool ctrl_down, float wheel, bool is_window_hovered, float mouse_x,
+                                               float mouse_y) {
+        TimelineStripViewModel view_model;
+        float working_scroll_x = scroll_x;
+
+        // Zoom is anchored around mouse position to avoid losing context.
+        if (is_window_hovered && ctrl_down && wheel != 0.0f) {
+            const float mouse_x_in_child = mouse_x - origin_x;
+            view_model.request_scroll = true;
+            view_model.desired_scroll_x = VtxServices::TimelineViewService::ComputeZoomedScroll(
+                wheel, mouse_x_in_child, scroll_x, timeline_bar_state);
+            working_scroll_x = view_model.desired_scroll_x;
+        } else if (current_frame != timeline_bar_state.last_tracked_frame) {
+            // When frame changes externally, keep the active frame near center.
+            view_model.request_scroll = true;
+            view_model.desired_scroll_x = ComputeCenteredScroll(timeline_bar_state, current_frame, view_width);
+            working_scroll_x = view_model.desired_scroll_x;
+        }
 
-// Builds strip bars, hover state, and optional scroll requests for current frame.
-TimelineStripViewModel BuildStripViewModel(
-    VtxServices::TimelineBarState& timeline_bar_state,
-    int total_frames,
-    int current_frame,
-    float duration_seconds,
-    float scroll_x,
-    float view_width,
-    float origin_x,
-    float origin_y,
-    float timeline_height,
-    bool ctrl_down,
-    float wheel,
-    bool is_window_hovered,
-    float mouse_x,
-    float mouse_y) {
-    TimelineStripViewModel view_model;
-    float working_scroll_x = scroll_x;
-
-    // Zoom is anchored around mouse position to avoid losing context.
-    if (is_window_hovered && ctrl_down && wheel != 0.0f) {
-        const float mouse_x_in_child = mouse_x - origin_x;
-        view_model.request_scroll = true;
-        view_model.desired_scroll_x = VtxServices::TimelineViewService::ComputeZoomedScroll(
-            wheel,
-            mouse_x_in_child,
-            scroll_x,
-            timeline_bar_state);
-        working_scroll_x = view_model.desired_scroll_x;
-    } else if (current_frame != timeline_bar_state.last_tracked_frame) {
-        // When frame changes externally, keep the active frame near center.
-        view_model.request_scroll = true;
-        view_model.desired_scroll_x = ComputeCenteredScroll(timeline_bar_state, current_frame, view_width);
-        working_scroll_x = view_model.desired_scroll_x;
-    }
+        const auto range = VtxServices::TimelineViewService::ComputeVisibleRange(working_scroll_x, view_width,
+                                                                                 total_frames, timeline_bar_state);
+        view_model.total_content_width = range.total_content_width;
+        view_model.item_full_width = range.item_full_width;
+        view_model.bars.reserve(std::max(0, range.last_visible_idx - range.first_visible_idx));
+
+        const int hovered_frame_idx = VtxServices::TimelineViewService::ResolveHoveredFrame(
+            mouse_x, mouse_y, origin_x, origin_y, timeline_height, range);
+
+        for (int i = range.first_visible_idx; i < range.last_visible_idx; ++i) {
+            const float bar_height = 0.8f * (timeline_height - 5.0f);
+            const float x_start = origin_x + (i * range.item_full_width);
+            const float x_end = x_start + timeline_bar_state.bar_width;
+            const float y_bottom = origin_y + timeline_height;
+            const float y_top = y_bottom - bar_height;
+
+            view_model.bars.push_back(TimelineFrameBarView {
+                .frame_index = i,
+                .x_start = x_start,
+                .x_end = x_end,
+                .y_top = y_top,
+                .y_bottom = y_bottom,
+                .is_current = i == current_frame,
+                .is_hovered = i == hovered_frame_idx,
+            });
+        }
 
-    const auto range = VtxServices::TimelineViewService::ComputeVisibleRange(
-        working_scroll_x,
-        view_width,
-        total_frames,
-        timeline_bar_state);
-    view_model.total_content_width = range.total_content_width;
-    view_model.item_full_width = range.item_full_width;
-    view_model.bars.reserve(std::max(0, range.last_visible_idx - range.first_visible_idx));
-
-    const int hovered_frame_idx = VtxServices::TimelineViewService::ResolveHoveredFrame(
-        mouse_x,
-        mouse_y,
-        origin_x,
-        origin_y,
-        timeline_height,
-        range);
-
-    for (int i = range.first_visible_idx; i < range.last_visible_idx; ++i) {
-        const float bar_height = 0.8f * (timeline_height - 5.0f);
-        const float x_start = origin_x + (i * range.item_full_width);
-        const float x_end = x_start + timeline_bar_state.bar_width;
-        const float y_bottom = origin_y + timeline_height;
-        const float y_top = y_bottom - bar_height;
-
-        view_model.bars.push_back(TimelineFrameBarView{
-            .frame_index = i,
-            .x_start = x_start,
-            .x_end = x_end,
-            .y_top = y_top,
-            .y_bottom = y_bottom,
-            .is_current = i == current_frame,
-            .is_hovered = i == hovered_frame_idx,
-        });
+        view_model.hover_info = BuildHoverInfo(hovered_frame_idx, total_frames, duration_seconds);
+        return view_model;
     }
 
-    view_model.hover_info = BuildHoverInfo(hovered_frame_idx, total_frames, duration_seconds);
-    return view_model;
-}
-
 } // namespace
 
 // Constructs the timeline window bound to Inspector session state.
@@ -176,17 +151,11 @@ void TimelineWindow::DrawTimeAndFrameInfo(int total_frames, float duration) {
     (void)duration;
     if (ImGui::BeginChild("InfoPanel", ImVec2(0, 45), true)) {
         const auto time_span = VtxServices::TimelineViewService::BuildTimelineClockSpan(
-            inspector_session_->GetCurrentFrame(),
-            total_frames,
-            inspector_session_->GetFooter().duration_seconds);
+            inspector_session_->GetCurrentFrame(), total_frames, inspector_session_->GetFooter().duration_seconds);
 
         ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "Time: %02d:%02d / %02d:%02d",
-            time_span.current.minutes,
-            time_span.current.seconds,
-            time_span.total.minutes,
-            time_span.total.seconds);
+        ImGui::Text("Time: %02d:%02d / %02d:%02d", time_span.current.minutes, time_span.current.seconds,
+                    time_span.total.minutes, time_span.total.seconds);
 
         ImGui::SameLine(ImGui::GetWindowWidth() - 320.0f);
         ImGui::Text("Frame: %d / %d", inspector_session_->GetCurrentFrame(), total_frames);
@@ -221,31 +190,19 @@ void TimelineWindow::DrawFrameStripTimeline(int total_frames) {
     ImGui::TextDisabled("Zoom: %.1fx (Ctrl+Wheel to zoom)", timeline_bar_state_.bar_width / 2.0f);
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-    const bool child_visible = ImGui::BeginChild(
-        "FrameTimelineScroll",
-        ImVec2(avail_width, timeline_height + ImGui::GetStyle().ScrollbarSize),
-        true,
-        ImGuiWindowFlags_HorizontalScrollbar);
+    const bool child_visible =
+        ImGui::BeginChild("FrameTimelineScroll", ImVec2(avail_width, timeline_height + ImGui::GetStyle().ScrollbarSize),
+                          true, ImGuiWindowFlags_HorizontalScrollbar);
 
     if (child_visible) {
         // Step 1: Build strip model from current viewport + input state.
         const ImVec2 p = ImGui::GetCursorScreenPos();
         const auto mouse_pos = ImGui::GetMousePos();
-        const auto strip_vm = BuildStripViewModel(
-            timeline_bar_state_,
-            total_frames,
-            inspector_session_->GetCurrentFrame(),
-            inspector_session_->GetFooter().duration_seconds,
-            ImGui::GetScrollX(),
-            ImGui::GetWindowWidth(),
-            p.x,
-            p.y,
-            timeline_height,
-            ImGui::GetIO().KeyCtrl,
-            ImGui::GetIO().MouseWheel,
-            ImGui::IsWindowHovered(),
-            mouse_pos.x,
-            mouse_pos.y);
+        const auto strip_vm =
+            BuildStripViewModel(timeline_bar_state_, total_frames, inspector_session_->GetCurrentFrame(),
+                                inspector_session_->GetFooter().duration_seconds, ImGui::GetScrollX(),
+                                ImGui::GetWindowWidth(), p.x, p.y, timeline_height, ImGui::GetIO().KeyCtrl,
+                                ImGui::GetIO().MouseWheel, ImGui::IsWindowHovered(), mouse_pos.x, mouse_pos.y);
         if (strip_vm.request_scroll) {
             ImGui::SetScrollX(strip_vm.desired_scroll_x);
             timeline_bar_state_.last_tracked_frame = inspector_session_->GetCurrentFrame();
@@ -254,18 +211,14 @@ void TimelineWindow::DrawFrameStripTimeline(int total_frames) {
         ImDrawList* child_draw_list = ImGui::GetWindowDrawList();
 
         ImGui::Dummy(ImVec2(strip_vm.total_content_width, timeline_height));
-        child_draw_list->AddRectFilled(
-            p,
-            ImVec2(p.x + strip_vm.total_content_width, p.y + timeline_height),
-            IM_COL32(30, 30, 30, 255));
+        child_draw_list->AddRectFilled(p, ImVec2(p.x + strip_vm.total_content_width, p.y + timeline_height),
+                                       IM_COL32(30, 30, 30, 255));
 
         for (const auto& bar : strip_vm.bars) {
             ImU32 bar_color = IM_COL32(128, 128, 128, 255);
             if (bar.is_current) {
-                child_draw_list->AddRectFilled(
-                    ImVec2(bar.x_start - 1.0f, p.y),
-                    ImVec2(bar.x_end + 1.0f, bar.y_bottom),
-                    IM_COL32(255, 255, 255, 100));
+                child_draw_list->AddRectFilled(ImVec2(bar.x_start - 1.0f, p.y), ImVec2(bar.x_end + 1.0f, bar.y_bottom),
+                                               IM_COL32(255, 255, 255, 100));
                 bar_color = IM_COL32(100, 100, 255, 255);
             }
 
@@ -277,11 +230,8 @@ void TimelineWindow::DrawFrameStripTimeline(int total_frames) {
             const auto& hover_info = strip_vm.hover_info;
             ImGui::BeginTooltip();
             ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Frame: %d", hover_info.frame_index);
-            ImGui::Text(
-                "Time: %02d:%02d (%.2fs)",
-                hover_info.frame_time_clock.minutes,
-                hover_info.frame_time_clock.seconds,
-                hover_info.frame_time_seconds);
+            ImGui::Text("Time: %02d:%02d (%.2fs)", hover_info.frame_time_clock.minutes,
+                        hover_info.frame_time_clock.seconds, hover_info.frame_time_seconds);
             ImGui::Separator();
             ImGui::TextDisabled("(Click to seek)");
             ImGui::EndTooltip();
diff --git a/tools/inspector/src/windows/track_property_window.cpp b/tools/inspector/src/windows/track_property_window.cpp
index b1ddbbe..e5a460a 100644
--- a/tools/inspector/src/windows/track_property_window.cpp
+++ b/tools/inspector/src/windows/track_property_window.cpp
@@ -10,64 +10,83 @@
 
 namespace {
 
-std::vector<std::string> ExtractBucketNamesFromSchema(const std::string& property_mapping) {
-    std::vector<std::string> names;
-    if (property_mapping.empty()) return names;
-    const std::string key = "\"buckets\"";
-    size_t key_pos = property_mapping.find(key);
-    if (key_pos == std::string::npos) return names;
-    size_t open_bracket = property_mapping.find('[', key_pos + key.size());
-    if (open_bracket == std::string::npos) return names;
-    bool in_string = false;
-    bool escaping = false;
-    std::string current;
-    for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
-        char c = property_mapping[i];
-        if (c == ']' && !in_string) break;
-        if (!in_string) { if (c == '"') { in_string = true; current.clear(); } continue; }
-        if (escaping) { current.push_back(c); escaping = false; continue; }
-        if (c == '\\') { escaping = true; continue; }
-        if (c == '"') { in_string = false; if (!current.empty()) names.push_back(current); continue; }
-        current.push_back(c);
+    std::vector<std::string> ExtractBucketNamesFromSchema(const std::string& property_mapping) {
+        std::vector<std::string> names;
+        if (property_mapping.empty())
+            return names;
+        const std::string key = "\"buckets\"";
+        size_t key_pos = property_mapping.find(key);
+        if (key_pos == std::string::npos)
+            return names;
+        size_t open_bracket = property_mapping.find('[', key_pos + key.size());
+        if (open_bracket == std::string::npos)
+            return names;
+        bool in_string = false;
+        bool escaping = false;
+        std::string current;
+        for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
+            char c = property_mapping[i];
+            if (c == ']' && !in_string)
+                break;
+            if (!in_string) {
+                if (c == '"') {
+                    in_string = true;
+                    current.clear();
+                }
+                continue;
+            }
+            if (escaping) {
+                current.push_back(c);
+                escaping = false;
+                continue;
+            }
+            if (c == '\\') {
+                escaping = true;
+                continue;
+            }
+            if (c == '"') {
+                in_string = false;
+                if (!current.empty())
+                    names.push_back(current);
+                continue;
+            }
+            current.push_back(c);
+        }
+        return names;
     }
-    return names;
-}
 
-std::string ToLowerCopy(const std::string& value) {
-    std::string lower = value;
-    std::transform(lower.begin(), lower.end(), lower.begin(),
-        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    return lower;
-}
+    std::string ToLowerCopy(const std::string& value) {
+        std::string lower = value;
+        std::transform(lower.begin(), lower.end(), lower.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return lower;
+    }
 
-bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
-    if (query_lower.empty()) return true;
-    return ToLowerCopy(text).find(query_lower) != std::string::npos;
-}
+    bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
+        if (query_lower.empty())
+            return true;
+        return ToLowerCopy(text).find(query_lower) != std::string::npos;
+    }
 
-std::vector<std::string> ParseCommaSeparated(const char* input) {
-    std::vector<std::string> result;
-    std::istringstream stream(input);
-    std::string token;
-    while (std::getline(stream, token, ',')) {
-        auto start = token.find_first_not_of(" \t");
-        auto end = token.find_last_not_of(" \t");
-        if (start != std::string::npos) {
-            result.push_back(token.substr(start, end - start + 1));
+    std::vector<std::string> ParseCommaSeparated(const char* input) {
+        std::vector<std::string> result;
+        std::istringstream stream(input);
+        std::string token;
+        while (std::getline(stream, token, ',')) {
+            auto start = token.find_first_not_of(" \t");
+            auto end = token.find_last_not_of(" \t");
+            if (start != std::string::npos) {
+                result.push_back(token.substr(start, end - start + 1));
+            }
         }
+        return result;
     }
-    return result;
-}
 
 } // namespace
 
-TrackPropertyWindow::TrackPropertyWindow(
-    std::shared_ptr<InspectorSession> session,
-    int instance_id)
+TrackPropertyWindow::TrackPropertyWindow(std::shared_ptr<InspectorSession> session, int instance_id)
     : ImGuiWindow("Track Property #" + std::to_string(instance_id), session)
-    , inspector_session_(std::move(session))
-{
-}
+    , inspector_session_(std::move(session)) {}
 
 void TrackPropertyWindow::PopulateBucketNames() {
     bucket_names_.clear();
@@ -77,9 +96,11 @@ void TrackPropertyWindow::PopulateBucketNames() {
 
     if (bucket_names_.empty()) {
         auto* reader = inspector_session_->GetReader();
-        if (!reader) return;
+        if (!reader)
+            return;
         const auto* frame = reader->GetFrame(inspector_session_->GetCurrentFrame());
-        if (!frame || frame->bucket_map.empty()) return;
+        if (!frame || frame->bucket_map.empty())
+            return;
         for (const auto& [name, idx] : frame->bucket_map) {
             bucket_names_.push_back(name);
         }
@@ -142,19 +163,19 @@ void TrackPropertyWindow::DrawConfigPanel() {
     }
 
     // UID filter
-    ImGui::InputTextWithHint("##UidFilter", "Filter by UniqueIDs (comma-separated, empty = all)",
-        uid_filter_input_, IM_ARRAYSIZE(uid_filter_input_));
+    ImGui::InputTextWithHint("##UidFilter", "Filter by UniqueIDs (comma-separated, empty = all)", uid_filter_input_,
+                             IM_ARRAYSIZE(uid_filter_input_));
 
     // Property names (required)
-    ImGui::InputTextWithHint("##PropertyNames",
-        "Property names to track (comma-separated, e.g. Health,Score)",
-        property_names_input_, IM_ARRAYSIZE(property_names_input_));
+    ImGui::InputTextWithHint("##PropertyNames", "Property names to track (comma-separated, e.g. Health,Score)",
+                             property_names_input_, IM_ARRAYSIZE(property_names_input_));
 
     ImGui::Spacing();
 
     auto prop_names = ParseCommaSeparated(property_names_input_);
     bool can_run = !bucket_names_.empty() && start_frame_ <= end_frame_ && !prop_names.empty();
-    if (!can_run) ImGui::BeginDisabled();
+    if (!can_run)
+        ImGui::BeginDisabled();
     if (ImGui::Button("Run Analysis", ImVec2(140.0f, 0.0f))) {
         VtxServices::AnalysisScanner::ScanConfig config;
         config.start_frame = start_frame_;
@@ -168,10 +189,10 @@ void TrackPropertyWindow::DrawConfigPanel() {
         auto cache = reader->GetPropertyAddressCache();
         auto footer = reader->GetFooter();
 
-        scanner_.Start(VtxServices::AnalysisScanner::ScanType::TrackProperty,
-            config, reader, cache, footer);
+        scanner_.Start(VtxServices::AnalysisScanner::ScanType::TrackProperty, config, reader, cache, footer);
     }
-    if (!can_run) ImGui::EndDisabled();
+    if (!can_run)
+        ImGui::EndDisabled();
 
     if (prop_names.empty() && property_names_input_[0] != '\0') {
         ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "Enter at least one property name.");
@@ -201,12 +222,11 @@ void TrackPropertyWindow::DrawResultsPanel() {
 
     // Top bar: search + export + new scan
     ImGui::SetNextItemWidth(250.0f);
-    ImGui::InputTextWithHint("##SearchFilter", "Search results...",
-        search_filter_, IM_ARRAYSIZE(search_filter_));
+    ImGui::InputTextWithHint("##SearchFilter", "Search results...", search_filter_, IM_ARRAYSIZE(search_filter_));
     ImGui::SameLine();
     if (ImGui::Button("Export CSV")) {
         auto dest = pfd::save_file("Export Track Property CSV", "track_property.csv",
-            { "CSV Files (.csv)", "*.csv", "All Files", "*" });
+                                   {"CSV Files (.csv)", "*.csv", "All Files", "*"});
         if (!dest.result().empty()) {
             VtxServices::ExportTrackPropertyCsv(dest.result(), result);
         }
@@ -234,10 +254,9 @@ void TrackPropertyWindow::DrawResultsPanel() {
         return;
     }
 
-    constexpr ImGuiTableFlags table_flags =
-        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
-        ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY |
-        ImGuiTableFlags_Sortable;
+    constexpr ImGuiTableFlags table_flags = ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
+                                            ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY |
+                                            ImGuiTableFlags_Sortable;
 
     if (ImGui::BeginTable("##TrackPropTable", 5, table_flags)) {
         ImGui::TableSetupScrollFreeze(0, 1);
@@ -255,12 +274,13 @@ void TrackPropertyWindow::DrawResultsPanel() {
             std::string time_range = VtxServices::FormatSingleGameTimeRange(span.range);
 
             if (!filter_query.empty()) {
-                bool matches = ContainsCaseInsensitive(span.unique_id, filter_query)
-                    || ContainsCaseInsensitive(span.property_name, filter_query)
-                    || ContainsCaseInsensitive(span.value, filter_query)
-                    || ContainsCaseInsensitive(frame_range, filter_query)
-                    || ContainsCaseInsensitive(time_range, filter_query);
-                if (!matches) continue;
+                bool matches = ContainsCaseInsensitive(span.unique_id, filter_query) ||
+                               ContainsCaseInsensitive(span.property_name, filter_query) ||
+                               ContainsCaseInsensitive(span.value, filter_query) ||
+                               ContainsCaseInsensitive(frame_range, filter_query) ||
+                               ContainsCaseInsensitive(time_range, filter_query);
+                if (!matches)
+                    continue;
             }
 
             ImGui::TableNextRow();
diff --git a/tools/inspector/src/windows/unique_properties_window.cpp b/tools/inspector/src/windows/unique_properties_window.cpp
index 6028359..f5c08ee 100644
--- a/tools/inspector/src/windows/unique_properties_window.cpp
+++ b/tools/inspector/src/windows/unique_properties_window.cpp
@@ -10,64 +10,83 @@
 
 namespace {
 
-std::vector<std::string> ExtractBucketNamesFromSchema(const std::string& property_mapping) {
-    std::vector<std::string> names;
-    if (property_mapping.empty()) return names;
-    const std::string key = "\"buckets\"";
-    size_t key_pos = property_mapping.find(key);
-    if (key_pos == std::string::npos) return names;
-    size_t open_bracket = property_mapping.find('[', key_pos + key.size());
-    if (open_bracket == std::string::npos) return names;
-    bool in_string = false;
-    bool escaping = false;
-    std::string current;
-    for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
-        char c = property_mapping[i];
-        if (c == ']' && !in_string) break;
-        if (!in_string) { if (c == '"') { in_string = true; current.clear(); } continue; }
-        if (escaping) { current.push_back(c); escaping = false; continue; }
-        if (c == '\\') { escaping = true; continue; }
-        if (c == '"') { in_string = false; if (!current.empty()) names.push_back(current); continue; }
-        current.push_back(c);
+    std::vector<std::string> ExtractBucketNamesFromSchema(const std::string& property_mapping) {
+        std::vector<std::string> names;
+        if (property_mapping.empty())
+            return names;
+        const std::string key = "\"buckets\"";
+        size_t key_pos = property_mapping.find(key);
+        if (key_pos == std::string::npos)
+            return names;
+        size_t open_bracket = property_mapping.find('[', key_pos + key.size());
+        if (open_bracket == std::string::npos)
+            return names;
+        bool in_string = false;
+        bool escaping = false;
+        std::string current;
+        for (size_t i = open_bracket + 1; i < property_mapping.size(); ++i) {
+            char c = property_mapping[i];
+            if (c == ']' && !in_string)
+                break;
+            if (!in_string) {
+                if (c == '"') {
+                    in_string = true;
+                    current.clear();
+                }
+                continue;
+            }
+            if (escaping) {
+                current.push_back(c);
+                escaping = false;
+                continue;
+            }
+            if (c == '\\') {
+                escaping = true;
+                continue;
+            }
+            if (c == '"') {
+                in_string = false;
+                if (!current.empty())
+                    names.push_back(current);
+                continue;
+            }
+            current.push_back(c);
+        }
+        return names;
     }
-    return names;
-}
 
-std::string ToLowerCopy(const std::string& value) {
-    std::string lower = value;
-    std::transform(lower.begin(), lower.end(), lower.begin(),
-        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    return lower;
-}
+    std::string ToLowerCopy(const std::string& value) {
+        std::string lower = value;
+        std::transform(lower.begin(), lower.end(), lower.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return lower;
+    }
 
-bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
-    if (query_lower.empty()) return true;
-    return ToLowerCopy(text).find(query_lower) != std::string::npos;
-}
+    bool ContainsCaseInsensitive(const std::string& text, const std::string& query_lower) {
+        if (query_lower.empty())
+            return true;
+        return ToLowerCopy(text).find(query_lower) != std::string::npos;
+    }
 
-std::vector<std::string> ParseCommaSeparated(const char* input) {
-    std::vector<std::string> result;
-    std::istringstream stream(input);
-    std::string token;
-    while (std::getline(stream, token, ',')) {
-        auto start = token.find_first_not_of(" \t");
-        auto end = token.find_last_not_of(" \t");
-        if (start != std::string::npos) {
-            result.push_back(token.substr(start, end - start + 1));
+    std::vector<std::string> ParseCommaSeparated(const char* input) {
+        std::vector<std::string> result;
+        std::istringstream stream(input);
+        std::string token;
+        while (std::getline(stream, token, ',')) {
+            auto start = token.find_first_not_of(" \t");
+            auto end = token.find_last_not_of(" \t");
+            if (start != std::string::npos) {
+                result.push_back(token.substr(start, end - start + 1));
+            }
         }
+        return result;
     }
-    return result;
-}
 
 } // namespace
 
-UniquePropertiesWindow::UniquePropertiesWindow(
-    std::shared_ptr<InspectorSession> session,
-    int instance_id)
+UniquePropertiesWindow::UniquePropertiesWindow(std::shared_ptr<InspectorSession> session, int instance_id)
     : ImGuiWindow("Unique Properties #" + std::to_string(instance_id), session)
-    , inspector_session_(std::move(session))
-{
-}
+    , inspector_session_(std::move(session)) {}
 
 void UniquePropertiesWindow::PopulateBucketNames() {
     bucket_names_.clear();
@@ -77,9 +96,11 @@ void UniquePropertiesWindow::PopulateBucketNames() {
 
     if (bucket_names_.empty()) {
         auto* reader = inspector_session_->GetReader();
-        if (!reader) return;
+        if (!reader)
+            return;
         const auto* frame = reader->GetFrame(inspector_session_->GetCurrentFrame());
-        if (!frame || frame->bucket_map.empty()) return;
+        if (!frame || frame->bucket_map.empty())
+            return;
         for (const auto& [name, idx] : frame->bucket_map) {
             bucket_names_.push_back(name);
         }
@@ -142,19 +163,19 @@ void UniquePropertiesWindow::DrawConfigPanel() {
     }
 
     // UID filter
-    ImGui::InputTextWithHint("##UidFilter", "Filter by UniqueIDs (comma-separated, empty = all)",
-        uid_filter_input_, IM_ARRAYSIZE(uid_filter_input_));
+    ImGui::InputTextWithHint("##UidFilter", "Filter by UniqueIDs (comma-separated, empty = all)", uid_filter_input_,
+                             IM_ARRAYSIZE(uid_filter_input_));
 
     // Property names (required)
-    ImGui::InputTextWithHint("##PropertyNames",
-        "Property names (comma-separated, e.g. Identifier,ClassIdentifier)",
-        property_names_input_, IM_ARRAYSIZE(property_names_input_));
+    ImGui::InputTextWithHint("##PropertyNames", "Property names (comma-separated, e.g. Identifier,ClassIdentifier)",
+                             property_names_input_, IM_ARRAYSIZE(property_names_input_));
 
     ImGui::Spacing();
 
     auto prop_names = ParseCommaSeparated(property_names_input_);
     bool can_run = !bucket_names_.empty() && start_frame_ <= end_frame_ && !prop_names.empty();
-    if (!can_run) ImGui::BeginDisabled();
+    if (!can_run)
+        ImGui::BeginDisabled();
     if (ImGui::Button("Run Analysis", ImVec2(140.0f, 0.0f))) {
         VtxServices::AnalysisScanner::ScanConfig config;
         config.start_frame = start_frame_;
@@ -168,10 +189,10 @@ void UniquePropertiesWindow::DrawConfigPanel() {
         auto cache = reader->GetPropertyAddressCache();
         auto footer = reader->GetFooter();
 
-        scanner_.Start(VtxServices::AnalysisScanner::ScanType::UniqueProperties,
-            config, reader, cache, footer);
+        scanner_.Start(VtxServices::AnalysisScanner::ScanType::UniqueProperties, config, reader, cache, footer);
     }
-    if (!can_run) ImGui::EndDisabled();
+    if (!can_run)
+        ImGui::EndDisabled();
 
     if (prop_names.empty() && property_names_input_[0] != '\0') {
         ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "Enter at least one property name.");
@@ -201,12 +222,11 @@ void UniquePropertiesWindow::DrawResultsPanel() {
 
     // Top bar: search + export + new scan
     ImGui::SetNextItemWidth(250.0f);
-    ImGui::InputTextWithHint("##SearchFilter", "Search results...",
-        search_filter_, IM_ARRAYSIZE(search_filter_));
+    ImGui::InputTextWithHint("##SearchFilter", "Search results...", search_filter_, IM_ARRAYSIZE(search_filter_));
     ImGui::SameLine();
     if (ImGui::Button("Export CSV")) {
         auto dest = pfd::save_file("Export Unique Properties CSV", "unique_properties.csv",
-            { "CSV Files (.csv)", "*.csv", "All Files", "*" });
+                                   {"CSV Files (.csv)", "*.csv", "All Files", "*"});
         if (!dest.result().empty()) {
             VtxServices::ExportUniquePropertiesCsv(dest.result(), result);
         }
@@ -238,8 +258,7 @@ void UniquePropertiesWindow::DrawResultsPanel() {
     int col_count = static_cast<int>(result.property_names.size()) + 1;
 
     constexpr ImGuiTableFlags table_flags =
-        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
-        ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY;
+        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY;
 
     if (ImGui::BeginTable("##UniquePropsTable", col_count, table_flags)) {
         ImGui::TableSetupScrollFreeze(0, 1);
@@ -258,7 +277,10 @@ void UniquePropertiesWindow::DrawResultsPanel() {
             if (!filter_query.empty()) {
                 bool matches = false;
                 for (const auto& val : group.property_values) {
-                    if (ContainsCaseInsensitive(val, filter_query)) { matches = true; break; }
+                    if (ContainsCaseInsensitive(val, filter_query)) {
+                        matches = true;
+                        break;
+                    }
                 }
                 if (!matches && ContainsCaseInsensitive(std::to_string(group.count), filter_query)) {
                     matches = true;
@@ -266,10 +288,14 @@ void UniquePropertiesWindow::DrawResultsPanel() {
                 // Also search in contributing UIDs
                 if (!matches) {
                     for (const auto& uid : group.contributing_uids) {
-                        if (ContainsCaseInsensitive(uid, filter_query)) { matches = true; break; }
+                        if (ContainsCaseInsensitive(uid, filter_query)) {
+                            matches = true;
+                            break;
+                        }
                     }
                 }
-                if (!matches) continue;
+                if (!matches)
+                    continue;
             }
 
             ImGui::TableNextRow();
@@ -278,9 +304,7 @@ void UniquePropertiesWindow::DrawResultsPanel() {
             ImGui::TableNextColumn();
             std::string first_val = group.property_values.empty() ? "" : group.property_values[0];
             std::string tree_id = "##group_" + std::to_string(g);
-            bool is_open = ImGui::TreeNodeEx(
-                (first_val + tree_id).c_str(),
-                ImGuiTreeNodeFlags_SpanFullWidth);
+            bool is_open = ImGui::TreeNodeEx((first_val + tree_id).c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
 
             // Remaining property columns
             for (size_t p = 1; p < result.property_names.size(); ++p) {
diff --git a/tools/schema_creator/include/schema_creator_layout.h b/tools/schema_creator/include/schema_creator_layout.h
index 49eb803..6a8bffd 100644
--- a/tools/schema_creator/include/schema_creator_layout.h
+++ b/tools/schema_creator/include/schema_creator_layout.h
@@ -10,7 +10,8 @@ class SchemaCreatorSession;
 
 class SchemaCreatorLayout : public IGuiLayer {
 public:
-    SchemaCreatorLayout(const std::shared_ptr<SchemaCreatorSession>& session, const std::shared_ptr<GuiScaleController>& scale_controller);
+    SchemaCreatorLayout(const std::shared_ptr<SchemaCreatorSession>& session,
+                        const std::shared_ptr<GuiScaleController>& scale_controller);
     ~SchemaCreatorLayout() override = default;
 
     void OnUpdate() override;
diff --git a/tools/schema_creator/include/services/schema_creator_service.h b/tools/schema_creator/include/services/schema_creator_service.h
index 44020c8..c9f0120 100644
--- a/tools/schema_creator/include/services/schema_creator_service.h
+++ b/tools/schema_creator/include/services/schema_creator_service.h
@@ -6,101 +6,102 @@
 
 namespace VtxServices {
 
-struct SchemaFieldMetaDoc {
-    std::string type;
-    std::string key_type;
-    std::string category;
-    std::string display_name;
-    std::string tooltip;
-    std::string default_value;
-    int32_t version = 1;
-    int32_t fixed_array_dim = 0;
-};
-
-struct SchemaFieldDoc {
-    std::string name;
-    std::string struct_type;
-    std::string type_id;
-    std::string key_id;
-    std::string container_type;
-    int32_t index = 0;
-    SchemaFieldMetaDoc meta;
-};
-
-struct SchemaStructDoc {
-    std::string struct_name;
-    std::vector<SchemaFieldDoc> fields;
-    std::vector<int32_t> type_max_indices;
-};
-
-struct SchemaBoneMappingDoc {
-    std::string model_name;
-    std::vector<std::string> bones;
-};
-
-struct SchemaDocument {
-    std::string version = "1.0.0";
-    std::vector<std::string> buckets;
-    std::vector<SchemaBoneMappingDoc> bone_mapping;
-    std::vector<SchemaStructDoc> structs;
-};
-
-enum class ValidationSeverity : uint8_t {
-    Info = 0,
-    Warning,
-    Error,
-};
-
-struct ValidationIssue {
-    ValidationSeverity severity = ValidationSeverity::Info;
-    std::string message;
-    std::string struct_name;
-    std::string field_name;
-};
-
-struct ValidationReport {
-    bool is_valid = true;
-    std::vector<ValidationIssue> issues;
-};
-
-enum class EvolutionChangeKind : uint8_t {
-    StructAdded = 0,
-    StructRemoved,
-    FieldAdded,
-    FieldRemoved,
-    FieldChanged,
-    FieldMetaChanged,
-};
-
-struct EvolutionIssue {
-    ValidationSeverity severity = ValidationSeverity::Info;
-    EvolutionChangeKind kind = EvolutionChangeKind::FieldChanged;
-    std::string message;
-    std::string struct_name;
-    std::string field_name;
-};
-
-struct EvolutionReport {
-    bool has_breaking_changes = false;
-    std::vector<EvolutionIssue> issues;
-};
-
-class SchemaCreatorService {
-public:
-    static SchemaDocument CreateEmptyDocument();
-
-    static bool LoadFromFile(const std::string& path, SchemaDocument& out_document, std::string& out_error);
-    static bool SaveToFile(const SchemaDocument& document, const std::string& path, std::string& out_error);
-
-    static bool ParseFromJsonString(const std::string& raw_json, SchemaDocument& out_document, std::string& out_error);
-    static std::string SerializeToJson(const SchemaDocument& document, bool pretty = true);
-
-    static ValidationReport ValidateSchema(const SchemaDocument& document);
-    static EvolutionReport BuildEvolutionReport(const SchemaDocument& baseline, const SchemaDocument& candidate);
-
-    static int32_t ComputeNextGenerationVersion(const SchemaDocument& document);
-    static void ApplyNextGenerationVersion(SchemaDocument& candidate, const SchemaDocument& baseline);
-    static std::string BuildSuggestedNextGenerationPath(const std::string& current_path);
-};
+    struct SchemaFieldMetaDoc {
+        std::string type;
+        std::string key_type;
+        std::string category;
+        std::string display_name;
+        std::string tooltip;
+        std::string default_value;
+        int32_t version = 1;
+        int32_t fixed_array_dim = 0;
+    };
+
+    struct SchemaFieldDoc {
+        std::string name;
+        std::string struct_type;
+        std::string type_id;
+        std::string key_id;
+        std::string container_type;
+        int32_t index = 0;
+        SchemaFieldMetaDoc meta;
+    };
+
+    struct SchemaStructDoc {
+        std::string struct_name;
+        std::vector<SchemaFieldDoc> fields;
+        std::vector<int32_t> type_max_indices;
+    };
+
+    struct SchemaBoneMappingDoc {
+        std::string model_name;
+        std::vector<std::string> bones;
+    };
+
+    struct SchemaDocument {
+        std::string version = "1.0.0";
+        std::vector<std::string> buckets;
+        std::vector<SchemaBoneMappingDoc> bone_mapping;
+        std::vector<SchemaStructDoc> structs;
+    };
+
+    enum class ValidationSeverity : uint8_t {
+        Info = 0,
+        Warning,
+        Error,
+    };
+
+    struct ValidationIssue {
+        ValidationSeverity severity = ValidationSeverity::Info;
+        std::string message;
+        std::string struct_name;
+        std::string field_name;
+    };
+
+    struct ValidationReport {
+        bool is_valid = true;
+        std::vector<ValidationIssue> issues;
+    };
+
+    enum class EvolutionChangeKind : uint8_t {
+        StructAdded = 0,
+        StructRemoved,
+        FieldAdded,
+        FieldRemoved,
+        FieldChanged,
+        FieldMetaChanged,
+    };
+
+    struct EvolutionIssue {
+        ValidationSeverity severity = ValidationSeverity::Info;
+        EvolutionChangeKind kind = EvolutionChangeKind::FieldChanged;
+        std::string message;
+        std::string struct_name;
+        std::string field_name;
+    };
+
+    struct EvolutionReport {
+        bool has_breaking_changes = false;
+        std::vector<EvolutionIssue> issues;
+    };
+
+    class SchemaCreatorService {
+    public:
+        static SchemaDocument CreateEmptyDocument();
+
+        static bool LoadFromFile(const std::string& path, SchemaDocument& out_document, std::string& out_error);
+        static bool SaveToFile(const SchemaDocument& document, const std::string& path, std::string& out_error);
+
+        static bool ParseFromJsonString(const std::string& raw_json, SchemaDocument& out_document,
+                                        std::string& out_error);
+        static std::string SerializeToJson(const SchemaDocument& document, bool pretty = true);
+
+        static ValidationReport ValidateSchema(const SchemaDocument& document);
+        static EvolutionReport BuildEvolutionReport(const SchemaDocument& baseline, const SchemaDocument& candidate);
+
+        static int32_t ComputeNextGenerationVersion(const SchemaDocument& document);
+        static void ApplyNextGenerationVersion(SchemaDocument& candidate, const SchemaDocument& baseline);
+        static std::string BuildSuggestedNextGenerationPath(const std::string& current_path);
+    };
 
 } // namespace VtxServices
diff --git a/tools/schema_creator/include/windows/schema_buckets_mapping_window.h b/tools/schema_creator/include/windows/schema_buckets_mapping_window.h
index 76673cf..e04ae88 100644
--- a/tools/schema_creator/include/windows/schema_buckets_mapping_window.h
+++ b/tools/schema_creator/include/windows/schema_buckets_mapping_window.h
@@ -34,4 +34,3 @@ class SchemaBucketsMappingWindow : public ImGuiWindow {
     std::string pending_model_name_;
     std::string pending_bone_name_;
 };
-
diff --git a/tools/schema_creator/include/windows/schema_general_info_window.h b/tools/schema_creator/include/windows/schema_general_info_window.h
index 3ac4ba4..721be85 100644
--- a/tools/schema_creator/include/windows/schema_general_info_window.h
+++ b/tools/schema_creator/include/windows/schema_general_info_window.h
@@ -20,4 +20,3 @@ class SchemaGeneralInfoWindow : public ImGuiWindow {
 private:
     std::shared_ptr<SchemaCreatorSession> schema_session_;
 };
-
diff --git a/tools/schema_creator/src/main.cpp b/tools/schema_creator/src/main.cpp
index ff34865..a113c89 100644
--- a/tools/schema_creator/src/main.cpp
+++ b/tools/schema_creator/src/main.cpp
@@ -14,24 +14,24 @@
 
 namespace {
 
-// Boots Schema Creator app, registers editor/validation/evolution layers, and runs UI loop.
-int RunSchemaCreator() {
-    GuiApplication app("vtx_schema_creator", "Schema Creator v1.0", 1600, 950);
-    auto session = std::make_shared<SchemaCreatorSession>();
-    session->SetMappingsWindowVisible(true);
-    session->SetGeneralInfoWindowVisible(true);
-    session->SetBucketsMappingWindowVisible(true);
+    // Boots Schema Creator app, registers editor/validation/evolution layers, and runs UI loop.
+    int RunSchemaCreator() {
+        GuiApplication app("vtx_schema_creator", "Schema Creator v1.0", 1600, 950);
+        auto session = std::make_shared<SchemaCreatorSession>();
+        session->SetMappingsWindowVisible(true);
+        session->SetGeneralInfoWindowVisible(true);
+        session->SetBucketsMappingWindowVisible(true);
 
-    app.AddLayer(std::make_shared<SchemaCreatorLayout>(session, app.GetScaleController()));
-    app.AddLayer(std::make_shared<SchemaCreatorWindow>(session));
-    app.AddLayer(std::make_shared<SchemaGeneralInfoWindow>(session));
-    app.AddLayer(std::make_shared<SchemaBucketsMappingWindow>(session));
-    app.AddLayer(std::make_shared<SchemaValidationWindow>(session));
-    app.AddLayer(std::make_shared<SchemaEvolutionWindow>(session));
-    app.AddLayer(std::make_shared<LogsWindow>(session));
-    app.Run();
-    return 0;
-}
+        app.AddLayer(std::make_shared<SchemaCreatorLayout>(session, app.GetScaleController()));
+        app.AddLayer(std::make_shared<SchemaCreatorWindow>(session));
+        app.AddLayer(std::make_shared<SchemaGeneralInfoWindow>(session));
+        app.AddLayer(std::make_shared<SchemaBucketsMappingWindow>(session));
+        app.AddLayer(std::make_shared<SchemaValidationWindow>(session));
+        app.AddLayer(std::make_shared<SchemaEvolutionWindow>(session));
+        app.AddLayer(std::make_shared<LogsWindow>(session));
+        app.Run();
+        return 0;
+    }
 
 } // namespace
 
diff --git a/tools/schema_creator/src/schema_creator_layout.cpp b/tools/schema_creator/src/schema_creator_layout.cpp
index 8459afd..871a36f 100644
--- a/tools/schema_creator/src/schema_creator_layout.cpp
+++ b/tools/schema_creator/src/schema_creator_layout.cpp
@@ -12,129 +12,127 @@
 
 namespace {
 
-struct DockWindowPlacement {
-    std::string window_name;
-    std::string region;
-};
+    struct DockWindowPlacement {
+        std::string window_name;
+        std::string region;
+    };
 
-constexpr float kStatusTtlSeconds = 3.0f;
+    constexpr float kStatusTtlSeconds = 3.0f;
 
-// Builds save dialog suggestion path for current generation mode.
-std::string BuildSaveSuggestionPath(const SchemaCreatorSession& session, bool apply_next_generation_rules) {
-    if (apply_next_generation_rules) {
-        return VtxServices::SchemaCreatorService::BuildSuggestedNextGenerationPath(session.GetActivePath());
-    }
-    if (session.HasActivePath()) {
-        return session.GetActivePath();
+    // Builds save dialog suggestion path for current generation mode.
+    std::string BuildSaveSuggestionPath(const SchemaCreatorSession& session, bool apply_next_generation_rules) {
+        if (apply_next_generation_rules) {
+            return VtxServices::SchemaCreatorService::BuildSuggestedNextGenerationPath(session.GetActivePath());
+        }
+        if (session.HasActivePath()) {
+            return session.GetActivePath();
+        }
+        return "schema.json";
     }
-    return "schema.json";
-}
 
-// Executes save/save-as flow based on generation mode and active path state.
-bool SaveSchemaFromMenu(SchemaCreatorSession& session, bool force_save_as) {
-    const bool next_generation_mode = session.IsNextGenerationMode();
-    const bool apply_next_generation_rules = next_generation_mode && session.HasBaseline();
+    // Executes save/save-as flow based on generation mode and active path state.
+    bool SaveSchemaFromMenu(SchemaCreatorSession& session, bool force_save_as) {
+        const bool next_generation_mode = session.IsNextGenerationMode();
+        const bool apply_next_generation_rules = next_generation_mode && session.HasBaseline();
 
-    if (!force_save_as && !next_generation_mode && session.HasActivePath()) {
-        // Fast path: plain save can reuse current file without opening dialog.
-        return session.SaveSchema(false);
-    }
+        if (!force_save_as && !next_generation_mode && session.HasActivePath()) {
+            // Fast path: plain save can reuse current file without opening dialog.
+            return session.SaveSchema(false);
+        }
 
-    const std::string dialog_title = force_save_as
-        ? (next_generation_mode ? "Save next generation schema as..." : "Save schema as...")
-        : (next_generation_mode ? "Save next generation schema" : "Save schema");
+        const std::string dialog_title =
+            force_save_as ? (next_generation_mode ? "Save next generation schema as..." : "Save schema as...")
+                          : (next_generation_mode ? "Save next generation schema" : "Save schema");
 
-    auto save_dialog = pfd::save_file(
-        dialog_title,
-        BuildSaveSuggestionPath(session, apply_next_generation_rules),
-        { "JSON Files (.json)", "*.json", "All Files", "*" });
+        auto save_dialog = pfd::save_file(dialog_title, BuildSaveSuggestionPath(session, apply_next_generation_rules),
+                                          {"JSON Files (.json)", "*.json", "All Files", "*"});
 
-    if (save_dialog.result().empty()) {
-        return false;
+        if (save_dialog.result().empty()) {
+            return false;
+        }
+        return session.SaveSchemaToPath(save_dialog.result(), apply_next_generation_rules);
     }
-    return session.SaveSchemaToPath(save_dialog.result(), apply_next_generation_rules);
-}
-
-// Builds canonical dock layout for Schema Creator workspace.
-void BuildDockLayout(ImGuiID dockspace_id, const ImVec2& workspace_size) {
-    ImGui::DockBuilderRemoveNode(dockspace_id);
-    ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace);
-    ImGui::DockBuilderSetNodeSize(dockspace_id, workspace_size);
-
-    ImGuiID dock_main_id = dockspace_id;
-    ImGuiID dock_bottom_id = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Down, 0.20f, nullptr, &dock_main_id);
-    ImGuiID dock_top_left_id = dock_main_id;
-    ImGuiID dock_top_right_id = ImGui::DockBuilderSplitNode(dock_top_left_id, ImGuiDir_Right, 0.30f, nullptr, &dock_top_left_id);
-
-    const std::vector<DockWindowPlacement> placements = {
-        DockWindowPlacement{"Property Mappings", "top_left"},
-        DockWindowPlacement{"General Info", "top_left"},
-        DockWindowPlacement{"Buckets & Bone Mapping", "top_left"},
-        DockWindowPlacement{"Schema Validation", "top_right"},
-        DockWindowPlacement{"Schema Evolution", "top_right"},
-        DockWindowPlacement{VtxGuiNames::LogWindow, "bottom"},
-    };
 
-    for (const auto& placement : placements) {
-        ImGuiID target = dock_top_left_id;
-        if (placement.region == "bottom") {
-            target = dock_bottom_id;
-        } else if (placement.region == "top_right") {
-            target = dock_top_right_id;
+    // Builds canonical dock layout for Schema Creator workspace.
+    void BuildDockLayout(ImGuiID dockspace_id, const ImVec2& workspace_size) {
+        ImGui::DockBuilderRemoveNode(dockspace_id);
+        ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace);
+        ImGui::DockBuilderSetNodeSize(dockspace_id, workspace_size);
+
+        ImGuiID dock_main_id = dockspace_id;
+        ImGuiID dock_bottom_id =
+            ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Down, 0.20f, nullptr, &dock_main_id);
+        ImGuiID dock_top_left_id = dock_main_id;
+        ImGuiID dock_top_right_id =
+            ImGui::DockBuilderSplitNode(dock_top_left_id, ImGuiDir_Right, 0.30f, nullptr, &dock_top_left_id);
+
+        const std::vector<DockWindowPlacement> placements = {
+            DockWindowPlacement {"Property Mappings", "top_left"},
+            DockWindowPlacement {"General Info", "top_left"},
+            DockWindowPlacement {"Buckets & Bone Mapping", "top_left"},
+            DockWindowPlacement {"Schema Validation", "top_right"},
+            DockWindowPlacement {"Schema Evolution", "top_right"},
+            DockWindowPlacement {VtxGuiNames::LogWindow, "bottom"},
+        };
+
+        for (const auto& placement : placements) {
+            ImGuiID target = dock_top_left_id;
+            if (placement.region == "bottom") {
+                target = dock_bottom_id;
+            } else if (placement.region == "top_right") {
+                target = dock_top_right_id;
+            }
+            ImGui::DockBuilderDockWindow(placement.window_name.c_str(), target);
         }
-        ImGui::DockBuilderDockWindow(placement.window_name.c_str(), target);
+
+        ImGui::DockBuilderFinish(dockspace_id);
     }
 
-    ImGui::DockBuilderFinish(dockspace_id);
-}
+    // Renders shared DPI scaling controls for the desktop tools.
+    void DrawViewMenu(const std::shared_ptr<GuiScaleController>& scale_controller) {
+        if (!scale_controller || !ImGui::BeginMenu("View")) {
+            return;
+        }
 
-// Renders shared DPI scaling controls for the desktop tools.
-void DrawViewMenu(const std::shared_ptr<GuiScaleController>& scale_controller) {
-    if (!scale_controller || !ImGui::BeginMenu("View")) {
-        return;
-    }
+        ImGui::TextDisabled("Auto Scale: %.0f%%", scale_controller->GetAutoScale() * 100.0f);
+        ImGui::TextDisabled("Effective Scale: %.0f%%", scale_controller->GetEffectiveScale() * 100.0f);
+        if (scale_controller->HasOverride()) {
+            ImGui::TextDisabled("Adjustment: %.0f%%", scale_controller->GetScaleAdjustment() * 100.0f);
+        } else {
+            ImGui::TextDisabled("Adjustment: Auto");
+        }
 
-    ImGui::TextDisabled("Auto Scale: %.0f%%", scale_controller->GetAutoScale() * 100.0f);
-    ImGui::TextDisabled("Effective Scale: %.0f%%", scale_controller->GetEffectiveScale() * 100.0f);
-    if (scale_controller->HasOverride()) {
-        ImGui::TextDisabled("Adjustment: %.0f%%", scale_controller->GetScaleAdjustment() * 100.0f);
-    } else {
-        ImGui::TextDisabled("Adjustment: Auto");
-    }
+        ImGui::Separator();
 
-    ImGui::Separator();
+        const float adjustment = scale_controller->GetScaleAdjustment();
+        if (ImGui::MenuItem("Scale Down", nullptr, false, adjustment > 0.76f)) {
+            scale_controller->DecreaseAdjustment();
+        }
+        if (ImGui::MenuItem("Scale Up")) {
+            scale_controller->IncreaseAdjustment();
+        }
 
-    const float adjustment = scale_controller->GetScaleAdjustment();
-    if (ImGui::MenuItem("Scale Down", nullptr, false, adjustment > 0.76f)) {
-        scale_controller->DecreaseAdjustment();
-    }
-    if (ImGui::MenuItem("Scale Up")) {
-        scale_controller->IncreaseAdjustment();
-    }
+        float adjustment_slider = adjustment;
+        ImGui::PushItemWidth(160.0f);
+        if (ImGui::SliderFloat("Scale Adjustment", &adjustment_slider, 0.75f, 2.0f, "%.2fx")) {
+            scale_controller->SetScaleAdjustment(adjustment_slider);
+        }
+        ImGui::PopItemWidth();
 
-    float adjustment_slider = adjustment;
-    ImGui::PushItemWidth(160.0f);
-    if (ImGui::SliderFloat("Scale Adjustment", &adjustment_slider, 0.75f, 2.0f, "%.2fx")) {
-        scale_controller->SetScaleAdjustment(adjustment_slider);
-    }
-    ImGui::PopItemWidth();
+        if (ImGui::MenuItem("Reset to Auto", nullptr, false, scale_controller->HasOverride())) {
+            scale_controller->ResetToAuto();
+        }
 
-    if (ImGui::MenuItem("Reset to Auto", nullptr, false, scale_controller->HasOverride())) {
-        scale_controller->ResetToAuto();
+        ImGui::EndMenu();
     }
 
-    ImGui::EndMenu();
-}
-
 } // namespace
 
 // Constructs top-level Schema Creator layout shell.
-SchemaCreatorLayout::SchemaCreatorLayout(
-    const std::shared_ptr<SchemaCreatorSession>& session,
-    const std::shared_ptr<GuiScaleController>& scale_controller)
-    : session_(session),
-      scale_controller_(scale_controller) {
-}
+SchemaCreatorLayout::SchemaCreatorLayout(const std::shared_ptr<SchemaCreatorSession>& session,
+                                         const std::shared_ptr<GuiScaleController>& scale_controller)
+    : session_(session)
+    , scale_controller_(scale_controller) {}
 
 // Updates transient status banner TTL and clears expired messages.
 void SchemaCreatorLayout::OnUpdate() {
@@ -160,7 +158,8 @@ void SchemaCreatorLayout::OnRender() {
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
+    window_flags |=
+        ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
     window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
 
     ImGui::Begin("Schema Creator DockSpace Base", nullptr, window_flags);
@@ -184,10 +183,8 @@ void SchemaCreatorLayout::OnRender() {
             }
 
             if (ImGui::MenuItem("Open Schema...")) {
-                auto chooser = pfd::open_file(
-                    "Open schema JSON",
-                    ".",
-                    { "JSON Files (.json)", "*.json", "All Files", "*" });
+                auto chooser =
+                    pfd::open_file("Open schema JSON", ".", {"JSON Files (.json)", "*.json", "All Files", "*"});
                 if (!chooser.result().empty()) {
                     const bool loaded = session_->LoadSchemaFromPath(chooser.result()[0]);
                     SetStatus(loaded ? "Schema loaded." : "Failed to load schema.", !loaded);
@@ -202,9 +199,9 @@ void SchemaCreatorLayout::OnRender() {
                     for (const auto& recent_path : recent_files) {
                         if (ImGui::MenuItem(recent_path.c_str())) {
                             const bool loaded = session_->LoadSchemaFromPath(recent_path);
-                            SetStatus(
-                                loaded ? "Schema loaded: " + recent_path : "Failed to load schema: " + recent_path,
-                                !loaded);
+                            SetStatus(loaded ? "Schema loaded: " + recent_path
+                                             : "Failed to load schema: " + recent_path,
+                                      !loaded);
                         }
                     }
                 }
@@ -213,11 +210,9 @@ void SchemaCreatorLayout::OnRender() {
 
             if (ImGui::MenuItem("Validate")) {
                 session_->ValidateNow();
-                SetStatus(
-                    session_->GetValidationReport().is_valid
-                        ? "Validation completed (no blocking errors)."
-                        : "Validation completed (errors found).",
-                    !session_->GetValidationReport().is_valid);
+                SetStatus(session_->GetValidationReport().is_valid ? "Validation completed (no blocking errors)."
+                                                                   : "Validation completed (errors found).",
+                          !session_->GetValidationReport().is_valid);
             }
 
             ImGui::Separator();
@@ -281,9 +276,7 @@ void SchemaCreatorLayout::OnRender() {
 
     // Step 3: Render transient status line.
     if (!status_message_.empty()) {
-        const ImVec4 color = status_is_error_
-            ? ImVec4(1.0f, 0.45f, 0.45f, 1.0f)
-            : ImVec4(0.55f, 0.95f, 0.65f, 1.0f);
+        const ImVec4 color = status_is_error_ ? ImVec4(1.0f, 0.45f, 0.45f, 1.0f) : ImVec4(0.55f, 0.95f, 0.65f, 1.0f);
         ImGui::TextColored(color, "%s", status_message_.c_str());
     }
 
diff --git a/tools/schema_creator/src/services/schema_creator_service.cpp b/tools/schema_creator/src/services/schema_creator_service.cpp
index 0125b67..a510bdc 100644
--- a/tools/schema_creator/src/services/schema_creator_service.cpp
+++ b/tools/schema_creator/src/services/schema_creator_service.cpp
@@ -15,779 +15,721 @@
 
 namespace {
 
-using json = nlohmann::json;
-
-// Returns lowercase copy of input string for case-insensitive comparisons.
-std::string ToLowerCopy(const std::string& value) {
-    std::string out = value;
-    std::transform(out.begin(), out.end(), out.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    return out;
-}
-
-// Converts type token to canonical schema typeId.
-std::string CanonicalizeTypeId(const std::string& type_id) {
-    const std::string normalized = ToLowerCopy(type_id);
-    if (normalized == "int8" || normalized == "uint8" || normalized == "byte") {
-        return "Int8";
-    }
-    if (normalized == "int32" || normalized == "uint32" || normalized == "int") {
-        return "Int32";
-    }
-    if (normalized == "int64" || normalized == "uint64" || normalized == "long") {
-        return "Int64";
-    }
-    if (normalized == "float") {
-        return "Float";
-    }
-    if (normalized == "double") {
-        return "Double";
-    }
-    if (normalized == "bool" || normalized == "boolean") {
-        return "Bool";
-    }
-    if (normalized == "string" || normalized == "fname" || normalized == "fstring") {
-        return "String";
-    }
-    if (normalized == "vector") {
-        return "Vector";
-    }
-    if (normalized == "quat") {
-        return "Quat";
-    }
-    if (normalized == "transform") {
-        return "Transform";
-    }
-    if (normalized == "range" || normalized == "floatrange") {
-        return "FloatRange";
-    }
-    if (normalized == "struct") {
-        return "Struct";
-    }
-    if (normalized == "enum") {
-        return "Enum";
-    }
-    if (normalized == "none" || normalized.empty()) {
-        return "None";
-    }
-    return type_id;
-}
-
-// Normalizes containerType token for comparisons.
-std::string NormalizeContainerType(const std::string& container_type) {
-    const std::string normalized = ToLowerCopy(container_type);
-    if (normalized == "none" || normalized.empty()) {
-        return "none";
-    }
-    if (normalized == "array") {
-        return "array";
-    }
-    if (normalized == "map") {
-        return "map";
-    }
-    return "";
-}
-
-// Converts containerType token to canonical schema containerType.
-std::string CanonicalizeContainerType(const std::string& container_type) {
-    const std::string normalized = NormalizeContainerType(container_type);
-    if (normalized == "array") {
-        return "Array";
+    using json = nlohmann::json;
+
+    // Returns lowercase copy of input string for case-insensitive comparisons.
+    std::string ToLowerCopy(const std::string& value) {
+        std::string out = value;
+        std::transform(out.begin(), out.end(), out.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return out;
     }
-    if (normalized == "map") {
-        return "Map";
+
+    // Converts type token to canonical schema typeId.
+    std::string CanonicalizeTypeId(const std::string& type_id) {
+        const std::string normalized = ToLowerCopy(type_id);
+        if (normalized == "int8" || normalized == "uint8" || normalized == "byte") {
+            return "Int8";
+        }
+        if (normalized == "int32" || normalized == "uint32" || normalized == "int") {
+            return "Int32";
+        }
+        if (normalized == "int64" || normalized == "uint64" || normalized == "long") {
+            return "Int64";
+        }
+        if (normalized == "float") {
+            return "Float";
+        }
+        if (normalized == "double") {
+            return "Double";
+        }
+        if (normalized == "bool" || normalized == "boolean") {
+            return "Bool";
+        }
+        if (normalized == "string" || normalized == "fname" || normalized == "fstring") {
+            return "String";
+        }
+        if (normalized == "vector") {
+            return "Vector";
+        }
+        if (normalized == "quat") {
+            return "Quat";
+        }
+        if (normalized == "transform") {
+            return "Transform";
+        }
+        if (normalized == "range" || normalized == "floatrange") {
+            return "FloatRange";
+        }
+        if (normalized == "struct") {
+            return "Struct";
+        }
+        if (normalized == "enum") {
+            return "Enum";
+        }
+        if (normalized == "none" || normalized.empty()) {
+            return "None";
+        }
+        return type_id;
     }
-    return "None";
-}
 
-// Suggests lowercase meta.type token when not explicitly provided.
-std::string InferMetaTypeFromTypeId(const std::string& type_id) {
-    const std::string canonical = CanonicalizeTypeId(type_id);
-    if (canonical == "None") {
+    // Normalizes containerType token for comparisons.
+    std::string NormalizeContainerType(const std::string& container_type) {
+        const std::string normalized = ToLowerCopy(container_type);
+        if (normalized == "none" || normalized.empty()) {
+            return "none";
+        }
+        if (normalized == "array") {
+            return "array";
+        }
+        if (normalized == "map") {
+            return "map";
+        }
         return "";
     }
-    if (canonical == "FloatRange") {
-        return "floatrange";
+
+    // Converts containerType token to canonical schema containerType.
+    std::string CanonicalizeContainerType(const std::string& container_type) {
+        const std::string normalized = NormalizeContainerType(container_type);
+        if (normalized == "array") {
+            return "Array";
+        }
+        if (normalized == "map") {
+            return "Map";
+        }
+        return "None";
     }
-    return ToLowerCopy(canonical);
-}
 
-// Suggests lowercase meta.keyType token when not explicitly provided.
-std::string InferMetaKeyTypeFromKeyId(const std::string& key_id) {
-    const std::string canonical = CanonicalizeTypeId(key_id);
-    if (canonical == "None") {
-        return "";
+    // Suggests lowercase meta.type token when not explicitly provided.
+    std::string InferMetaTypeFromTypeId(const std::string& type_id) {
+        const std::string canonical = CanonicalizeTypeId(type_id);
+        if (canonical == "None") {
+            return "";
+        }
+        if (canonical == "FloatRange") {
+            return "floatrange";
+        }
+        return ToLowerCopy(canonical);
     }
-    if (canonical == "FloatRange") {
-        return "floatrange";
+
+    // Suggests lowercase meta.keyType token when not explicitly provided.
+    std::string InferMetaKeyTypeFromKeyId(const std::string& key_id) {
+        const std::string canonical = CanonicalizeTypeId(key_id);
+        if (canonical == "None") {
+            return "";
+        }
+        if (canonical == "FloatRange") {
+            return "floatrange";
+        }
+        return ToLowerCopy(canonical);
     }
-    return ToLowerCopy(canonical);
-}
 
-// Resolves typeId token tuple into SDK field type enum.
-VTX::FieldType ResolveFieldTypeFromTypeId(const std::string& raw_type_id, const std::string& struct_type) {
-    const std::string type = ToLowerCopy(raw_type_id);
-    const std::string nested = ToLowerCopy(struct_type);
+    // Resolves typeId token tuple into SDK field type enum.
+    VTX::FieldType ResolveFieldTypeFromTypeId(const std::string& raw_type_id, const std::string& struct_type) {
+        const std::string type = ToLowerCopy(raw_type_id);
+        const std::string nested = ToLowerCopy(struct_type);
+
+        if (type == "struct") {
+            if (nested == "vector") {
+                return VTX::FieldType::Vector;
+            }
+            if (nested == "quat") {
+                return VTX::FieldType::Quat;
+            }
+            if (nested == "transform") {
+                return VTX::FieldType::Transform;
+            }
+            if (nested == "floatrange") {
+                return VTX::FieldType::FloatRange;
+            }
+            return VTX::FieldType::Struct;
+        }
+        if (type == "enum") {
+            return VTX::FieldType::Enum;
+        }
 
-    if (type == "struct") {
-        if (nested == "vector") {
+        if (type == "uint8" || type == "int8" || type == "byte") {
+            return VTX::FieldType::Int8;
+        }
+        if (type == "int32" || type == "int" || type == "uint32") {
+            return VTX::FieldType::Int32;
+        }
+        if (type == "int64" || type == "long" || type == "uint64") {
+            return VTX::FieldType::Int64;
+        }
+        if (type == "float") {
+            return VTX::FieldType::Float;
+        }
+        if (type == "double") {
+            return VTX::FieldType::Double;
+        }
+        if (type == "bool" || type == "boolean") {
+            return VTX::FieldType::Bool;
+        }
+        if (type == "string" || type == "fname" || type == "fstring") {
+            return VTX::FieldType::String;
+        }
+        if (type == "vector") {
             return VTX::FieldType::Vector;
         }
-        if (nested == "quat") {
+        if (type == "quat") {
             return VTX::FieldType::Quat;
         }
-        if (nested == "transform") {
+        if (type == "transform") {
             return VTX::FieldType::Transform;
         }
-        if (nested == "floatrange") {
+        if (type == "range" || type == "floatrange") {
             return VTX::FieldType::FloatRange;
         }
-        return VTX::FieldType::Struct;
-    }
-    if (type == "enum") {
-        return VTX::FieldType::Enum;
-    }
 
-    if (type == "uint8" || type == "int8" || type == "byte") {
-        return VTX::FieldType::Int8;
-    }
-    if (type == "int32" || type == "int" || type == "uint32") {
-        return VTX::FieldType::Int32;
-    }
-    if (type == "int64" || type == "long" || type == "uint64") {
-        return VTX::FieldType::Int64;
-    }
-    if (type == "float") {
-        return VTX::FieldType::Float;
-    }
-    if (type == "double") {
-        return VTX::FieldType::Double;
-    }
-    if (type == "bool" || type == "boolean") {
-        return VTX::FieldType::Bool;
+        return VTX::FieldType::None;
     }
-    if (type == "string" || type == "fname" || type == "fstring") {
-        return VTX::FieldType::String;
-    }
-    if (type == "vector") {
-        return VTX::FieldType::Vector;
-    }
-    if (type == "quat") {
-        return VTX::FieldType::Quat;
+
+    // Checks whether raw field type token is recognized by schema validation rules.
+    bool IsKnownTypeToken(const std::string& raw_type_id) {
+        const std::string canonical = CanonicalizeTypeId(raw_type_id);
+        if (canonical == "None") {
+            return false;
+        }
+        return ResolveFieldTypeFromTypeId(canonical, "") != VTX::FieldType::None;
     }
-    if (type == "transform") {
-        return VTX::FieldType::Transform;
+
+    // Recomputes SDK runtime indices from ordered typeId+containerType groups.
+    void RecomputeFieldIndices(VtxServices::SchemaStructDoc& schema_struct) {
+        std::unordered_map<std::string, int32_t> index_counters;
+        for (auto& field : schema_struct.fields) {
+            const std::string index_key =
+                CanonicalizeTypeId(field.type_id) + "|" + CanonicalizeContainerType(field.container_type);
+            field.index = index_counters[index_key]++;
+        }
     }
-    if (type == "range" || type == "floatrange") {
-        return VTX::FieldType::FloatRange;
+
+    // Returns a normalized copy with canonical tokens and derived indices.
+    VtxServices::SchemaDocument NormalizeDocumentForSchemaRegistry(const VtxServices::SchemaDocument& document) {
+        VtxServices::SchemaDocument normalized = document;
+        normalized.version = normalized.version.empty() ? "1.0.0" : normalized.version;
+        for (auto& schema_struct : normalized.structs) {
+            for (auto& field : schema_struct.fields) {
+                field.type_id = CanonicalizeTypeId(field.type_id);
+                field.key_id = CanonicalizeTypeId(field.key_id);
+                field.container_type = CanonicalizeContainerType(field.container_type);
+                if (field.meta.type.empty()) {
+                    field.meta.type = InferMetaTypeFromTypeId(field.type_id);
+                }
+                if (field.meta.key_type.empty()) {
+                    field.meta.key_type = InferMetaKeyTypeFromKeyId(field.key_id);
+                }
+            }
+            RecomputeFieldIndices(schema_struct);
+        }
+        return normalized;
     }
 
-    return VTX::FieldType::None;
-}
+    struct FieldSignature {
+        std::string type_id;
+        std::string struct_type;
+        std::string key_id;
+        std::string container_type;
+        int32_t index = 0;
+    };
 
-// Checks whether raw field type token is recognized by schema validation rules.
-bool IsKnownTypeToken(const std::string& raw_type_id) {
-    const std::string canonical = CanonicalizeTypeId(raw_type_id);
-    if (canonical == "None") {
-        return false;
+    // Builds normalized signature used for compatibility comparisons.
+    FieldSignature BuildFieldSignature(const VtxServices::SchemaFieldDoc& field) {
+        return FieldSignature {
+            .type_id = ToLowerCopy(CanonicalizeTypeId(field.type_id)),
+            .struct_type = ToLowerCopy(field.struct_type),
+            .key_id = ToLowerCopy(CanonicalizeTypeId(field.key_id)),
+            .container_type = ToLowerCopy(CanonicalizeContainerType(field.container_type)),
+            .index = field.index,
+        };
     }
-    return ResolveFieldTypeFromTypeId(canonical, "") != VTX::FieldType::None;
-}
-
-// Recomputes SDK runtime indices from ordered typeId+containerType groups.
-void RecomputeFieldIndices(VtxServices::SchemaStructDoc& schema_struct) {
-    std::unordered_map<std::string, int32_t> index_counters;
-    for (auto& field : schema_struct.fields) {
-        const std::string index_key = CanonicalizeTypeId(field.type_id) + "|" + CanonicalizeContainerType(field.container_type);
-        field.index = index_counters[index_key]++;
+
+    // Compares field signatures for compatibility-relevant differences.
+    bool AreSignaturesEqual(const FieldSignature& lhs, const FieldSignature& rhs) {
+        return lhs.type_id == rhs.type_id && lhs.struct_type == rhs.struct_type && lhs.key_id == rhs.key_id &&
+               lhs.container_type == rhs.container_type && lhs.index == rhs.index;
     }
-}
 
-// Returns a normalized copy with canonical tokens and derived indices.
-VtxServices::SchemaDocument NormalizeDocumentForSchemaRegistry(const VtxServices::SchemaDocument& document) {
-    VtxServices::SchemaDocument normalized = document;
-    normalized.version = normalized.version.empty() ? "1.0.0" : normalized.version;
-    for (auto& schema_struct : normalized.structs) {
-        for (auto& field : schema_struct.fields) {
-            field.type_id = CanonicalizeTypeId(field.type_id);
-            field.key_id = CanonicalizeTypeId(field.key_id);
-            field.container_type = CanonicalizeContainerType(field.container_type);
-            if (field.meta.type.empty()) {
-                field.meta.type = InferMetaTypeFromTypeId(field.type_id);
-            }
-            if (field.meta.key_type.empty()) {
-                field.meta.key_type = InferMetaKeyTypeFromKeyId(field.key_id);
+    // Compares field metadata block for non-signature changes.
+    bool AreMetadataEqual(const VtxServices::SchemaFieldDoc& lhs, const VtxServices::SchemaFieldDoc& rhs) {
+        return lhs.meta.type == rhs.meta.type && lhs.meta.key_type == rhs.meta.key_type &&
+               lhs.meta.category == rhs.meta.category && lhs.meta.display_name == rhs.meta.display_name &&
+               lhs.meta.tooltip == rhs.meta.tooltip && lhs.meta.default_value == rhs.meta.default_value &&
+               lhs.meta.version == rhs.meta.version && lhs.meta.fixed_array_dim == rhs.meta.fixed_array_dim;
+    }
+
+    // Finds a field by logical name in a schema struct.
+    const VtxServices::SchemaFieldDoc* FindFieldByName(const VtxServices::SchemaStructDoc& schema_struct,
+                                                       const std::string& field_name) {
+        for (const auto& field : schema_struct.fields) {
+            if (field.name == field_name) {
+                return &field;
             }
         }
-        RecomputeFieldIndices(schema_struct);
-    }
-    return normalized;
-}
-
-struct FieldSignature {
-    std::string type_id;
-    std::string struct_type;
-    std::string key_id;
-    std::string container_type;
-    int32_t index = 0;
-};
-
-// Builds normalized signature used for compatibility comparisons.
-FieldSignature BuildFieldSignature(const VtxServices::SchemaFieldDoc& field) {
-    return FieldSignature{
-        .type_id = ToLowerCopy(CanonicalizeTypeId(field.type_id)),
-        .struct_type = ToLowerCopy(field.struct_type),
-        .key_id = ToLowerCopy(CanonicalizeTypeId(field.key_id)),
-        .container_type = ToLowerCopy(CanonicalizeContainerType(field.container_type)),
-        .index = field.index,
-    };
-}
-
-// Compares field signatures for compatibility-relevant differences.
-bool AreSignaturesEqual(const FieldSignature& lhs, const FieldSignature& rhs) {
-    return lhs.type_id == rhs.type_id &&
-           lhs.struct_type == rhs.struct_type &&
-           lhs.key_id == rhs.key_id &&
-           lhs.container_type == rhs.container_type &&
-           lhs.index == rhs.index;
-}
-
-// Compares field metadata block for non-signature changes.
-bool AreMetadataEqual(const VtxServices::SchemaFieldDoc& lhs, const VtxServices::SchemaFieldDoc& rhs) {
-    return lhs.meta.type == rhs.meta.type &&
-           lhs.meta.key_type == rhs.meta.key_type &&
-           lhs.meta.category == rhs.meta.category &&
-           lhs.meta.display_name == rhs.meta.display_name &&
-           lhs.meta.tooltip == rhs.meta.tooltip &&
-           lhs.meta.default_value == rhs.meta.default_value &&
-           lhs.meta.version == rhs.meta.version &&
-           lhs.meta.fixed_array_dim == rhs.meta.fixed_array_dim;
-}
-
-// Finds a field by logical name in a schema struct.
-const VtxServices::SchemaFieldDoc* FindFieldByName(const VtxServices::SchemaStructDoc& schema_struct, const std::string& field_name) {
-    for (const auto& field : schema_struct.fields) {
-        if (field.name == field_name) {
-            return &field;
+        return nullptr;
+    }
+
+    // Appends a validation issue entry into report.
+    void AddValidationIssue(VtxServices::ValidationReport& report, VtxServices::ValidationSeverity severity,
+                            const std::string& message, const std::string& struct_name = {},
+                            const std::string& field_name = {}) {
+        report.issues.push_back(VtxServices::ValidationIssue {
+            .severity = severity,
+            .message = message,
+            .struct_name = struct_name,
+            .field_name = field_name,
+        });
+    }
+
+    // Appends evolution issue and updates breaking-change flag when needed.
+    void AddEvolutionIssue(VtxServices::EvolutionReport& report, VtxServices::ValidationSeverity severity,
+                           VtxServices::EvolutionChangeKind kind, const std::string& message,
+                           const std::string& struct_name = {}, const std::string& field_name = {}) {
+        report.issues.push_back(VtxServices::EvolutionIssue {
+            .severity = severity,
+            .kind = kind,
+            .message = message,
+            .struct_name = struct_name,
+            .field_name = field_name,
+        });
+        if (severity == VtxServices::ValidationSeverity::Error) {
+            report.has_breaking_changes = true;
         }
     }
-    return nullptr;
-}
-
-// Appends a validation issue entry into report.
-void AddValidationIssue(
-    VtxServices::ValidationReport& report,
-    VtxServices::ValidationSeverity severity,
-    const std::string& message,
-    const std::string& struct_name = {},
-    const std::string& field_name = {}) {
-    report.issues.push_back(VtxServices::ValidationIssue{
-        .severity = severity,
-        .message = message,
-        .struct_name = struct_name,
-        .field_name = field_name,
-    });
-}
-
-// Appends evolution issue and updates breaking-change flag when needed.
-void AddEvolutionIssue(
-    VtxServices::EvolutionReport& report,
-    VtxServices::ValidationSeverity severity,
-    VtxServices::EvolutionChangeKind kind,
-    const std::string& message,
-    const std::string& struct_name = {},
-    const std::string& field_name = {}) {
-    report.issues.push_back(VtxServices::EvolutionIssue{
-        .severity = severity,
-        .kind = kind,
-        .message = message,
-        .struct_name = struct_name,
-        .field_name = field_name,
-    });
-    if (severity == VtxServices::ValidationSeverity::Error) {
-        report.has_breaking_changes = true;
-    }
-}
 
-// Builds struct-name lookup for diff/validation flows.
-std::unordered_map<std::string, const VtxServices::SchemaStructDoc*> BuildStructLookup(const VtxServices::SchemaDocument& document) {
-    std::unordered_map<std::string, const VtxServices::SchemaStructDoc*> lookup;
-    for (const auto& schema_struct : document.structs) {
-        lookup[schema_struct.struct_name] = &schema_struct;
+    // Builds struct-name lookup for diff/validation flows.
+    std::unordered_map<std::string, const VtxServices::SchemaStructDoc*>
+    BuildStructLookup(const VtxServices::SchemaDocument& document) {
+        std::unordered_map<std::string, const VtxServices::SchemaStructDoc*> lookup;
+        for (const auto& schema_struct : document.structs) {
+            lookup[schema_struct.struct_name] = &schema_struct;
+        }
+        return lookup;
     }
-    return lookup;
-}
-
-// Builds field-name lookup for a single struct.
-std::unordered_map<std::string, const VtxServices::SchemaFieldDoc*> BuildFieldLookup(const VtxServices::SchemaStructDoc& schema_struct) {
-    std::unordered_map<std::string, const VtxServices::SchemaFieldDoc*> lookup;
-    for (const auto& field : schema_struct.fields) {
-        lookup[field.name] = &field;
+
+    // Builds field-name lookup for a single struct.
+    std::unordered_map<std::string, const VtxServices::SchemaFieldDoc*>
+    BuildFieldLookup(const VtxServices::SchemaStructDoc& schema_struct) {
+        std::unordered_map<std::string, const VtxServices::SchemaFieldDoc*> lookup;
+        for (const auto& field : schema_struct.fields) {
+            lookup[field.name] = &field;
+        }
+        return lookup;
     }
-    return lookup;
-}
 
 } // namespace
 
 namespace VtxServices {
 
-// Creates a new empty schema document model.
-SchemaDocument SchemaCreatorService::CreateEmptyDocument() {
-    return SchemaDocument{};
-}
-
-// Loads schema JSON file and parses into in-memory document model.
-bool SchemaCreatorService::LoadFromFile(const std::string& path, SchemaDocument& out_document, std::string& out_error) {
-    out_error.clear();
-    std::ifstream file(path, std::ios::in);
-    if (!file.is_open()) {
-        out_error = "Unable to open schema file.";
-        return false;
+    // Creates a new empty schema document model.
+    SchemaDocument SchemaCreatorService::CreateEmptyDocument() {
+        return SchemaDocument {};
     }
 
-    std::stringstream buffer;
-    buffer << file.rdbuf();
-    file.close();
+    // Loads schema JSON file and parses into in-memory document model.
+    bool SchemaCreatorService::LoadFromFile(const std::string& path, SchemaDocument& out_document,
+                                            std::string& out_error) {
+        out_error.clear();
+        std::ifstream file(path, std::ios::in);
+        if (!file.is_open()) {
+            out_error = "Unable to open schema file.";
+            return false;
+        }
 
-    return ParseFromJsonString(buffer.str(), out_document, out_error);
-}
+        std::stringstream buffer;
+        buffer << file.rdbuf();
+        file.close();
 
-// Serializes in-memory document and writes it to disk.
-bool SchemaCreatorService::SaveToFile(const SchemaDocument& document, const std::string& path, std::string& out_error) {
-    out_error.clear();
-    std::ofstream file(path, std::ios::out | std::ios::trunc);
-    if (!file.is_open()) {
-        out_error = "Unable to write schema file.";
-        return false;
+        return ParseFromJsonString(buffer.str(), out_document, out_error);
     }
 
-    file << SerializeToJson(document, true);
-    return true;
-}
-
-// Parses schema JSON string into editable document representation.
-bool SchemaCreatorService::ParseFromJsonString(const std::string& raw_json, SchemaDocument& out_document, std::string& out_error) {
-    out_error.clear();
-    json root;
-    try {
-        root = json::parse(raw_json);
-    } catch (const std::exception& ex) {
-        out_error = std::string("JSON parse error: ") + ex.what();
-        return false;
-    }
+    // Serializes in-memory document and writes it to disk.
+    bool SchemaCreatorService::SaveToFile(const SchemaDocument& document, const std::string& path,
+                                          std::string& out_error) {
+        out_error.clear();
+        std::ofstream file(path, std::ios::out | std::ios::trunc);
+        if (!file.is_open()) {
+            out_error = "Unable to write schema file.";
+            return false;
+        }
 
-    if (!root.contains("property_mapping") || !root["property_mapping"].is_array()) {
-        out_error = "Invalid schema JSON: missing 'property_mapping' array.";
-        return false;
+        file << SerializeToJson(document, true);
+        return true;
     }
 
-    // Step 1: Parse top-level new-schema metadata.
-    SchemaDocument parsed;
-    parsed.version = root.value("version", "1.0.0");
-    if (root.contains("buckets") && root["buckets"].is_array()) {
-        for (const auto& bucket_json : root["buckets"]) {
-            if (bucket_json.is_string()) {
-                parsed.buckets.push_back(bucket_json.get<std::string>());
+    // Parses schema JSON string into editable document representation.
+    bool SchemaCreatorService::ParseFromJsonString(const std::string& raw_json, SchemaDocument& out_document,
+                                                   std::string& out_error) {
+        out_error.clear();
+        json root;
+        try {
+            root = json::parse(raw_json);
+        } catch (const std::exception& ex) {
+            out_error = std::string("JSON parse error: ") + ex.what();
+            return false;
+        }
+
+        if (!root.contains("property_mapping") || !root["property_mapping"].is_array()) {
+            out_error = "Invalid schema JSON: missing 'property_mapping' array.";
+            return false;
+        }
+
+        // Step 1: Parse top-level new-schema metadata.
+        SchemaDocument parsed;
+        parsed.version = root.value("version", "1.0.0");
+        if (root.contains("buckets") && root["buckets"].is_array()) {
+            for (const auto& bucket_json : root["buckets"]) {
+                if (bucket_json.is_string()) {
+                    parsed.buckets.push_back(bucket_json.get<std::string>());
+                }
             }
         }
-    }
 
-    if (root.contains("bone_mapping") && root["bone_mapping"].is_object()) {
-        for (auto it = root["bone_mapping"].begin(); it != root["bone_mapping"].end(); ++it) {
-            SchemaBoneMappingDoc mapping;
-            mapping.model_name = it.key();
-            if (it.value().is_array()) {
-                for (const auto& bone_json : it.value()) {
-                    if (bone_json.is_string()) {
-                        mapping.bones.push_back(bone_json.get<std::string>());
+        if (root.contains("bone_mapping") && root["bone_mapping"].is_object()) {
+            for (auto it = root["bone_mapping"].begin(); it != root["bone_mapping"].end(); ++it) {
+                SchemaBoneMappingDoc mapping;
+                mapping.model_name = it.key();
+                if (it.value().is_array()) {
+                    for (const auto& bone_json : it.value()) {
+                        if (bone_json.is_string()) {
+                            mapping.bones.push_back(bone_json.get<std::string>());
+                        }
                     }
                 }
+                parsed.bone_mapping.push_back(std::move(mapping));
             }
-            parsed.bone_mapping.push_back(std::move(mapping));
         }
-    }
 
-    // Step 2: Walk struct entries and map them into document model.
-    for (const auto& struct_json : root["property_mapping"]) {
-        if (!struct_json.is_object()) {
-            continue;
-        }
+        // Step 2: Walk struct entries and map them into document model.
+        for (const auto& struct_json : root["property_mapping"]) {
+            if (!struct_json.is_object()) {
+                continue;
+            }
 
-        SchemaStructDoc schema_struct;
-        schema_struct.struct_name = struct_json.value("struct", "");
+            SchemaStructDoc schema_struct;
+            schema_struct.struct_name = struct_json.value("struct", "");
 
-        // Step 3: Parse field list and metadata payload.
-        if (struct_json.contains("values") && struct_json["values"].is_array()) {
-            for (const auto& field_json : struct_json["values"]) {
-                if (!field_json.is_object()) {
-                    continue;
-                }
+            // Step 3: Parse field list and metadata payload.
+            if (struct_json.contains("values") && struct_json["values"].is_array()) {
+                for (const auto& field_json : struct_json["values"]) {
+                    if (!field_json.is_object()) {
+                        continue;
+                    }
 
-                SchemaFieldDoc field;
-                field.name = field_json.value("name", "");
-                field.struct_type = field_json.value("structType", "");
-                field.type_id = field_json.value("typeId", "");
-                field.key_id = field_json.value("keyId", "None");
-                field.container_type = field_json.value("containerType", "None");
-
-                if (field_json.contains("meta") && field_json["meta"].is_object()) {
-                    const auto& meta_json = field_json["meta"];
-                    field.meta.type = meta_json.value("type", "");
-                    field.meta.key_type = meta_json.value("keyType", "");
-                    field.meta.category = meta_json.value("category", "");
-                    field.meta.display_name = meta_json.value("displayName", "");
-                    field.meta.tooltip = meta_json.value("tooltip", "");
-                    field.meta.default_value = meta_json.value("defaultValue", "");
-                    field.meta.version = meta_json.value("version", 1);
-                    field.meta.fixed_array_dim = meta_json.value("fixedArrayDim", 0);
-                }
+                    SchemaFieldDoc field;
+                    field.name = field_json.value("name", "");
+                    field.struct_type = field_json.value("structType", "");
+                    field.type_id = field_json.value("typeId", "");
+                    field.key_id = field_json.value("keyId", "None");
+                    field.container_type = field_json.value("containerType", "None");
+
+                    if (field_json.contains("meta") && field_json["meta"].is_object()) {
+                        const auto& meta_json = field_json["meta"];
+                        field.meta.type = meta_json.value("type", "");
+                        field.meta.key_type = meta_json.value("keyType", "");
+                        field.meta.category = meta_json.value("category", "");
+                        field.meta.display_name = meta_json.value("displayName", "");
+                        field.meta.tooltip = meta_json.value("tooltip", "");
+                        field.meta.default_value = meta_json.value("defaultValue", "");
+                        field.meta.version = meta_json.value("version", 1);
+                        field.meta.fixed_array_dim = meta_json.value("fixedArrayDim", 0);
+                    }
 
-                schema_struct.fields.push_back(std::move(field));
+                    schema_struct.fields.push_back(std::move(field));
+                }
             }
+
+            RecomputeFieldIndices(schema_struct);
+            parsed.structs.push_back(std::move(schema_struct));
         }
 
-        RecomputeFieldIndices(schema_struct);
-        parsed.structs.push_back(std::move(schema_struct));
+        out_document = NormalizeDocumentForSchemaRegistry(parsed);
+        return true;
     }
 
-    out_document = NormalizeDocumentForSchemaRegistry(parsed);
-    return true;
-}
+    // Serializes editable document model to canonical schema JSON payload.
+    std::string SchemaCreatorService::SerializeToJson(const SchemaDocument& document, bool pretty) {
+        const SchemaDocument normalized = NormalizeDocumentForSchemaRegistry(document);
 
-// Serializes editable document model to canonical schema JSON payload.
-std::string SchemaCreatorService::SerializeToJson(const SchemaDocument& document, bool pretty) {
-    const SchemaDocument normalized = NormalizeDocumentForSchemaRegistry(document);
+        json root;
+        root["version"] = normalized.version.empty() ? "1.0.0" : normalized.version;
+        root["buckets"] = json::array();
+        for (const auto& bucket_name : normalized.buckets) {
+            root["buckets"].push_back(bucket_name);
+        }
 
-    json root;
-    root["version"] = normalized.version.empty() ? "1.0.0" : normalized.version;
-    root["buckets"] = json::array();
-    for (const auto& bucket_name : normalized.buckets) {
-        root["buckets"].push_back(bucket_name);
-    }
+        root["bone_mapping"] = json::object();
+        for (const auto& mapping : normalized.bone_mapping) {
+            root["bone_mapping"][mapping.model_name] = mapping.bones;
+        }
 
-    root["bone_mapping"] = json::object();
-    for (const auto& mapping : normalized.bone_mapping) {
-        root["bone_mapping"][mapping.model_name] = mapping.bones;
-    }
+        root["property_mapping"] = json::array();
+        for (const auto& schema_struct : normalized.structs) {
+            json struct_json;
+            struct_json["struct"] = schema_struct.struct_name;
+            struct_json["values"] = json::array();
+
+            for (const auto& field : schema_struct.fields) {
+                json field_json;
+                field_json["name"] = field.name;
+                field_json["structType"] = field.struct_type;
+                field_json["typeId"] = CanonicalizeTypeId(field.type_id);
+                field_json["keyId"] = CanonicalizeTypeId(field.key_id);
+                field_json["containerType"] = CanonicalizeContainerType(field.container_type);
+
+                json meta_json;
+                meta_json["type"] = field.meta.type.empty() ? InferMetaTypeFromTypeId(field.type_id) : field.meta.type;
+                meta_json["keyType"] =
+                    field.meta.key_type.empty() ? InferMetaKeyTypeFromKeyId(field.key_id) : field.meta.key_type;
+                meta_json["category"] = field.meta.category;
+                meta_json["displayName"] = field.meta.display_name;
+                meta_json["tooltip"] = field.meta.tooltip;
+                meta_json["defaultValue"] = field.meta.default_value;
+                meta_json["version"] = field.meta.version;
+                meta_json["fixedArrayDim"] = field.meta.fixed_array_dim;
+                field_json["meta"] = std::move(meta_json);
+
+                struct_json["values"].push_back(std::move(field_json));
+            }
 
-    root["property_mapping"] = json::array();
-    for (const auto& schema_struct : normalized.structs) {
-        json struct_json;
-        struct_json["struct"] = schema_struct.struct_name;
-        struct_json["values"] = json::array();
+            root["property_mapping"].push_back(std::move(struct_json));
+        }
 
-        for (const auto& field : schema_struct.fields) {
-            json field_json;
-            field_json["name"] = field.name;
-            field_json["structType"] = field.struct_type;
-            field_json["typeId"] = CanonicalizeTypeId(field.type_id);
-            field_json["keyId"] = CanonicalizeTypeId(field.key_id);
-            field_json["containerType"] = CanonicalizeContainerType(field.container_type);
-
-            json meta_json;
-            meta_json["type"] = field.meta.type.empty() ? InferMetaTypeFromTypeId(field.type_id) : field.meta.type;
-            meta_json["keyType"] = field.meta.key_type.empty() ? InferMetaKeyTypeFromKeyId(field.key_id) : field.meta.key_type;
-            meta_json["category"] = field.meta.category;
-            meta_json["displayName"] = field.meta.display_name;
-            meta_json["tooltip"] = field.meta.tooltip;
-            meta_json["defaultValue"] = field.meta.default_value;
-            meta_json["version"] = field.meta.version;
-            meta_json["fixedArrayDim"] = field.meta.fixed_array_dim;
-            field_json["meta"] = std::move(meta_json);
-
-            struct_json["values"].push_back(std::move(field_json));
-        }
-
-        root["property_mapping"].push_back(std::move(struct_json));
+        return pretty ? root.dump(4) : root.dump();
     }
 
-    return pretty ? root.dump(4) : root.dump();
-}
-
-// Validates schema document for structural and compatibility issues.
-ValidationReport SchemaCreatorService::ValidateSchema(const SchemaDocument& document) {
-    ValidationReport report;
-    const SchemaDocument normalized = NormalizeDocumentForSchemaRegistry(document);
-
-    if (normalized.structs.empty()) {
-        AddValidationIssue(report, ValidationSeverity::Warning, "Schema is empty. Add at least one struct.");
-    }
+    // Validates schema document for structural and compatibility issues.
+    ValidationReport SchemaCreatorService::ValidateSchema(const SchemaDocument& document) {
+        ValidationReport report;
+        const SchemaDocument normalized = NormalizeDocumentForSchemaRegistry(document);
 
-    // Step 1: Validate struct/field names and local field constraints.
-    std::unordered_set<std::string> struct_names;
-    for (const auto& schema_struct : normalized.structs) {
-        if (schema_struct.struct_name.empty()) {
-            AddValidationIssue(report, ValidationSeverity::Error, "Struct name is empty.");
-            continue;
-        }
-        if (!struct_names.insert(schema_struct.struct_name).second) {
-            AddValidationIssue(
-                report,
-                ValidationSeverity::Error,
-                "Duplicate struct name: '" + schema_struct.struct_name + "'.",
-                schema_struct.struct_name);
+        if (normalized.structs.empty()) {
+            AddValidationIssue(report, ValidationSeverity::Warning, "Schema is empty. Add at least one struct.");
         }
 
-        // Track duplicates by logical field name within each struct scope.
-        std::unordered_set<std::string> field_names;
-        for (const auto& field : schema_struct.fields) {
-            if (field.name.empty()) {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Error,
-                    "Field name is empty.",
-                    schema_struct.struct_name);
+        // Step 1: Validate struct/field names and local field constraints.
+        std::unordered_set<std::string> struct_names;
+        for (const auto& schema_struct : normalized.structs) {
+            if (schema_struct.struct_name.empty()) {
+                AddValidationIssue(report, ValidationSeverity::Error, "Struct name is empty.");
                 continue;
             }
-            if (!field_names.insert(field.name).second) {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Error,
-                    "Duplicate field name: '" + field.name + "'.",
-                    schema_struct.struct_name,
-                    field.name);
+            if (!struct_names.insert(schema_struct.struct_name).second) {
+                AddValidationIssue(report, ValidationSeverity::Error,
+                                   "Duplicate struct name: '" + schema_struct.struct_name + "'.",
+                                   schema_struct.struct_name);
             }
 
-            const std::string container = NormalizeContainerType(field.container_type);
-            if (container.empty()) {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Warning,
-                    "containerType should be one of: 'None', 'Array', 'Map'.",
-                    schema_struct.struct_name,
-                    field.name);
-            }
+            // Track duplicates by logical field name within each struct scope.
+            std::unordered_set<std::string> field_names;
+            for (const auto& field : schema_struct.fields) {
+                if (field.name.empty()) {
+                    AddValidationIssue(report, ValidationSeverity::Error, "Field name is empty.",
+                                       schema_struct.struct_name);
+                    continue;
+                }
+                if (!field_names.insert(field.name).second) {
+                    AddValidationIssue(report, ValidationSeverity::Error, "Duplicate field name: '" + field.name + "'.",
+                                       schema_struct.struct_name, field.name);
+                }
 
-            if (CanonicalizeTypeId(field.type_id) == "Struct" &&
-                field.struct_type.empty()) {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Error,
-                    "Field with typeId 'Struct' requires 'structType'.",
-                    schema_struct.struct_name,
-                    field.name);
-            }
+                const std::string container = NormalizeContainerType(field.container_type);
+                if (container.empty()) {
+                    AddValidationIssue(report, ValidationSeverity::Warning,
+                                       "containerType should be one of: 'None', 'Array', 'Map'.",
+                                       schema_struct.struct_name, field.name);
+                }
 
-            if (container == "map" && CanonicalizeTypeId(field.key_id) == "None") {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Warning,
-                    "Map field should define 'keyId'.",
-                    schema_struct.struct_name,
-                    field.name);
-            }
+                if (CanonicalizeTypeId(field.type_id) == "Struct" && field.struct_type.empty()) {
+                    AddValidationIssue(report, ValidationSeverity::Error,
+                                       "Field with typeId 'Struct' requires 'structType'.", schema_struct.struct_name,
+                                       field.name);
+                }
 
-            if (CanonicalizeTypeId(field.type_id) == "None") {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Error,
-                    "Field typeId cannot be empty/None.",
-                    schema_struct.struct_name,
-                    field.name);
-            } else if (!IsKnownTypeToken(field.type_id)) {
-                AddValidationIssue(
-                    report,
-                    ValidationSeverity::Warning,
-                    "Unknown field typeId token '" + field.type_id + "'.",
-                    schema_struct.struct_name,
-                    field.name);
+                if (container == "map" && CanonicalizeTypeId(field.key_id) == "None") {
+                    AddValidationIssue(report, ValidationSeverity::Warning, "Map field should define 'keyId'.",
+                                       schema_struct.struct_name, field.name);
+                }
+
+                if (CanonicalizeTypeId(field.type_id) == "None") {
+                    AddValidationIssue(report, ValidationSeverity::Error, "Field typeId cannot be empty/None.",
+                                       schema_struct.struct_name, field.name);
+                } else if (!IsKnownTypeToken(field.type_id)) {
+                    AddValidationIssue(report, ValidationSeverity::Warning,
+                                       "Unknown field typeId token '" + field.type_id + "'.", schema_struct.struct_name,
+                                       field.name);
+                }
             }
         }
-    }
 
-    // Step 2: Ensure SDK parser accepts produced schema JSON.
-    VTX::SchemaRegistry registry;
-    if (!registry.LoadFromRawString(SerializeToJson(normalized, true))) {
-        AddValidationIssue(
-            report,
-            ValidationSeverity::Error,
-            "SDK SchemaRegistry failed to parse the current schema JSON.");
-    }
-
-    // Step 3: Compute report validity from issue severities.
-    report.is_valid = true;
-    for (const auto& issue : report.issues) {
-        if (issue.severity == ValidationSeverity::Error) {
-            report.is_valid = false;
-            break;
+        // Step 2: Ensure SDK parser accepts produced schema JSON.
+        VTX::SchemaRegistry registry;
+        if (!registry.LoadFromRawString(SerializeToJson(normalized, true))) {
+            AddValidationIssue(report, ValidationSeverity::Error,
+                               "SDK SchemaRegistry failed to parse the current schema JSON.");
         }
-    }
-    return report;
-}
-
-// Compares baseline vs candidate and reports additive vs breaking evolution deltas.
-EvolutionReport SchemaCreatorService::BuildEvolutionReport(const SchemaDocument& baseline, const SchemaDocument& candidate) {
-    EvolutionReport report;
-    const SchemaDocument normalized_baseline = NormalizeDocumentForSchemaRegistry(baseline);
-    const SchemaDocument normalized_candidate = NormalizeDocumentForSchemaRegistry(candidate);
-
-    const auto baseline_structs = BuildStructLookup(normalized_baseline);
-    const auto candidate_structs = BuildStructLookup(normalized_candidate);
-
-    // Pass 1: additive structs.
-    for (const auto& [struct_name, candidate_struct] : candidate_structs) {
-        (void)candidate_struct;
-        if (baseline_structs.find(struct_name) == baseline_structs.end()) {
-            AddEvolutionIssue(
-                report,
-                ValidationSeverity::Info,
-                EvolutionChangeKind::StructAdded,
-                "Struct added.",
-                struct_name);
+
+        // Step 3: Compute report validity from issue severities.
+        report.is_valid = true;
+        for (const auto& issue : report.issues) {
+            if (issue.severity == ValidationSeverity::Error) {
+                report.is_valid = false;
+                break;
+            }
         }
+        return report;
     }
 
-    // Pass 2: breaking/removal/signature changes against baseline.
-    for (const auto& [struct_name, baseline_struct] : baseline_structs) {
-        if (candidate_structs.find(struct_name) == candidate_structs.end()) {
-            AddEvolutionIssue(
-                report,
-                ValidationSeverity::Error,
-                EvolutionChangeKind::StructRemoved,
-                "Struct removed. Breaking change.",
-                struct_name);
-            continue;
-        }
-
-        const auto* candidate_struct = candidate_structs.at(struct_name);
-        const auto baseline_fields = BuildFieldLookup(*baseline_struct);
-        const auto candidate_fields = BuildFieldLookup(*candidate_struct);
-
-        for (const auto& [field_name, candidate_field] : candidate_fields) {
-            if (baseline_fields.find(field_name) == baseline_fields.end()) {
-                AddEvolutionIssue(
-                    report,
-                    ValidationSeverity::Info,
-                    EvolutionChangeKind::FieldAdded,
-                    "Field added (compatible additive change).",
-                    struct_name,
-                    field_name);
-                continue;
+    // Compares baseline vs candidate and reports additive vs breaking evolution deltas.
+    EvolutionReport SchemaCreatorService::BuildEvolutionReport(const SchemaDocument& baseline,
+                                                               const SchemaDocument& candidate) {
+        EvolutionReport report;
+        const SchemaDocument normalized_baseline = NormalizeDocumentForSchemaRegistry(baseline);
+        const SchemaDocument normalized_candidate = NormalizeDocumentForSchemaRegistry(candidate);
+
+        const auto baseline_structs = BuildStructLookup(normalized_baseline);
+        const auto candidate_structs = BuildStructLookup(normalized_candidate);
+
+        // Pass 1: additive structs.
+        for (const auto& [struct_name, candidate_struct] : candidate_structs) {
+            (void)candidate_struct;
+            if (baseline_structs.find(struct_name) == baseline_structs.end()) {
+                AddEvolutionIssue(report, ValidationSeverity::Info, EvolutionChangeKind::StructAdded, "Struct added.",
+                                  struct_name);
             }
+        }
 
-            const auto* baseline_field = baseline_fields.at(field_name);
-            if (!AreSignaturesEqual(BuildFieldSignature(*baseline_field), BuildFieldSignature(*candidate_field))) {
-                AddEvolutionIssue(
-                    report,
-                    ValidationSeverity::Error,
-                    EvolutionChangeKind::FieldChanged,
-                    "Field signature changed (typeId/keyId/containerType/index/structType). Breaking change.",
-                    struct_name,
-                    field_name);
+        // Pass 2: breaking/removal/signature changes against baseline.
+        for (const auto& [struct_name, baseline_struct] : baseline_structs) {
+            if (candidate_structs.find(struct_name) == candidate_structs.end()) {
+                AddEvolutionIssue(report, ValidationSeverity::Error, EvolutionChangeKind::StructRemoved,
+                                  "Struct removed. Breaking change.", struct_name);
                 continue;
             }
 
-            if (!AreMetadataEqual(*baseline_field, *candidate_field)) {
-                AddEvolutionIssue(
-                    report,
-                    ValidationSeverity::Warning,
-                    EvolutionChangeKind::FieldMetaChanged,
-                    "Field metadata changed (non-breaking, review downstream usage).",
-                    struct_name,
-                    field_name);
+            const auto* candidate_struct = candidate_structs.at(struct_name);
+            const auto baseline_fields = BuildFieldLookup(*baseline_struct);
+            const auto candidate_fields = BuildFieldLookup(*candidate_struct);
+
+            for (const auto& [field_name, candidate_field] : candidate_fields) {
+                if (baseline_fields.find(field_name) == baseline_fields.end()) {
+                    AddEvolutionIssue(report, ValidationSeverity::Info, EvolutionChangeKind::FieldAdded,
+                                      "Field added (compatible additive change).", struct_name, field_name);
+                    continue;
+                }
+
+                const auto* baseline_field = baseline_fields.at(field_name);
+                if (!AreSignaturesEqual(BuildFieldSignature(*baseline_field), BuildFieldSignature(*candidate_field))) {
+                    AddEvolutionIssue(
+                        report, ValidationSeverity::Error, EvolutionChangeKind::FieldChanged,
+                        "Field signature changed (typeId/keyId/containerType/index/structType). Breaking change.",
+                        struct_name, field_name);
+                    continue;
+                }
+
+                if (!AreMetadataEqual(*baseline_field, *candidate_field)) {
+                    AddEvolutionIssue(report, ValidationSeverity::Warning, EvolutionChangeKind::FieldMetaChanged,
+                                      "Field metadata changed (non-breaking, review downstream usage).", struct_name,
+                                      field_name);
+                }
             }
-        }
 
-        for (const auto& [field_name, baseline_field] : baseline_fields) {
-            (void)baseline_field;
-            if (candidate_fields.find(field_name) == candidate_fields.end()) {
-                AddEvolutionIssue(
-                    report,
-                    ValidationSeverity::Error,
-                    EvolutionChangeKind::FieldRemoved,
-                    "Field removed. Breaking change.",
-                    struct_name,
-                    field_name);
+            for (const auto& [field_name, baseline_field] : baseline_fields) {
+                (void)baseline_field;
+                if (candidate_fields.find(field_name) == candidate_fields.end()) {
+                    AddEvolutionIssue(report, ValidationSeverity::Error, EvolutionChangeKind::FieldRemoved,
+                                      "Field removed. Breaking change.", struct_name, field_name);
+                }
             }
         }
-    }
-
-    return report;
-}
 
-// Computes highest version marker across all fields in document.
-int32_t SchemaCreatorService::ComputeNextGenerationVersion(const SchemaDocument& document) {
-    int32_t max_version = 1;
-    for (const auto& schema_struct : document.structs) {
-        for (const auto& field : schema_struct.fields) {
-            max_version = std::max(max_version, field.meta.version);
-        }
+        return report;
     }
-    return max_version;
-}
-
-// Applies next-generation version stamping to changed/new fields.
-void SchemaCreatorService::ApplyNextGenerationVersion(SchemaDocument& candidate, const SchemaDocument& baseline) {
-    const SchemaDocument normalized_baseline = NormalizeDocumentForSchemaRegistry(baseline);
-    const SchemaDocument normalized_candidate = NormalizeDocumentForSchemaRegistry(candidate);
-
-    const int32_t next_version = std::max(
-        ComputeNextGenerationVersion(normalized_baseline),
-        ComputeNextGenerationVersion(normalized_candidate)) + 1;
-    const auto baseline_structs = BuildStructLookup(normalized_baseline);
-    const auto normalized_candidate_structs = BuildStructLookup(normalized_candidate);
-
-    // Step 1: Walk candidate structs and align against baseline counterpart.
-    for (auto& candidate_struct : candidate.structs) {
-        const auto baseline_struct_it = baseline_structs.find(candidate_struct.struct_name);
-        if (baseline_struct_it == baseline_structs.end()) {
-            // New struct in next generation: stamp all fields with the new version.
-            for (auto& field : candidate_struct.fields) {
-                field.meta.version = next_version;
-            }
-            continue;
-        }
 
-        const auto normalized_candidate_struct_it = normalized_candidate_structs.find(candidate_struct.struct_name);
-        if (normalized_candidate_struct_it == normalized_candidate_structs.end()) {
-            continue;
+    // Computes highest version marker across all fields in document.
+    int32_t SchemaCreatorService::ComputeNextGenerationVersion(const SchemaDocument& document) {
+        int32_t max_version = 1;
+        for (const auto& schema_struct : document.structs) {
+            for (const auto& field : schema_struct.fields) {
+                max_version = std::max(max_version, field.meta.version);
+            }
         }
+        return max_version;
+    }
+
+    // Applies next-generation version stamping to changed/new fields.
+    void SchemaCreatorService::ApplyNextGenerationVersion(SchemaDocument& candidate, const SchemaDocument& baseline) {
+        const SchemaDocument normalized_baseline = NormalizeDocumentForSchemaRegistry(baseline);
+        const SchemaDocument normalized_candidate = NormalizeDocumentForSchemaRegistry(candidate);
+
+        const int32_t next_version = std::max(ComputeNextGenerationVersion(normalized_baseline),
+                                              ComputeNextGenerationVersion(normalized_candidate)) +
+                                     1;
+        const auto baseline_structs = BuildStructLookup(normalized_baseline);
+        const auto normalized_candidate_structs = BuildStructLookup(normalized_candidate);
+
+        // Step 1: Walk candidate structs and align against baseline counterpart.
+        for (auto& candidate_struct : candidate.structs) {
+            const auto baseline_struct_it = baseline_structs.find(candidate_struct.struct_name);
+            if (baseline_struct_it == baseline_structs.end()) {
+                // New struct in next generation: stamp all fields with the new version.
+                for (auto& field : candidate_struct.fields) {
+                    field.meta.version = next_version;
+                }
+                continue;
+            }
 
-        const auto* baseline_struct = baseline_struct_it->second;
-        const auto* normalized_candidate_struct = normalized_candidate_struct_it->second;
+            const auto normalized_candidate_struct_it = normalized_candidate_structs.find(candidate_struct.struct_name);
+            if (normalized_candidate_struct_it == normalized_candidate_structs.end()) {
+                continue;
+            }
 
-        // Step 2: Bump version only for added/changed fields.
-        for (auto& field : candidate_struct.fields) {
-            const auto* baseline_field = FindFieldByName(*baseline_struct, field.name);
-            const auto* normalized_candidate_field = FindFieldByName(*normalized_candidate_struct, field.name);
-            const bool should_bump = (baseline_field == nullptr) ||
-                (normalized_candidate_field == nullptr) ||
-                !AreSignaturesEqual(BuildFieldSignature(*baseline_field), BuildFieldSignature(*normalized_candidate_field)) ||
-                !AreMetadataEqual(*baseline_field, *normalized_candidate_field);
+            const auto* baseline_struct = baseline_struct_it->second;
+            const auto* normalized_candidate_struct = normalized_candidate_struct_it->second;
 
-            if (should_bump) {
-                field.meta.version = next_version;
-            } else if (field.meta.version <= 0) {
-                // Preserve existing stable version for untouched fields.
-                field.meta.version = std::max<int32_t>(1, baseline_field->meta.version);
+            // Step 2: Bump version only for added/changed fields.
+            for (auto& field : candidate_struct.fields) {
+                const auto* baseline_field = FindFieldByName(*baseline_struct, field.name);
+                const auto* normalized_candidate_field = FindFieldByName(*normalized_candidate_struct, field.name);
+                const bool should_bump = (baseline_field == nullptr) || (normalized_candidate_field == nullptr) ||
+                                         !AreSignaturesEqual(BuildFieldSignature(*baseline_field),
+                                                             BuildFieldSignature(*normalized_candidate_field)) ||
+                                         !AreMetadataEqual(*baseline_field, *normalized_candidate_field);
+
+                if (should_bump) {
+                    field.meta.version = next_version;
+                } else if (field.meta.version <= 0) {
+                    // Preserve existing stable version for untouched fields.
+                    field.meta.version = std::max<int32_t>(1, baseline_field->meta.version);
+                }
             }
         }
     }
-}
 
-// Suggests a save path with incremented version suffix for next-generation saves.
-std::string SchemaCreatorService::BuildSuggestedNextGenerationPath(const std::string& current_path) {
-    if (current_path.empty()) {
-        return "schema_v2.json";
-    }
+    // Suggests a save path with incremented version suffix for next-generation saves.
+    std::string SchemaCreatorService::BuildSuggestedNextGenerationPath(const std::string& current_path) {
+        if (current_path.empty()) {
+            return "schema_v2.json";
+        }
 
-    std::filesystem::path source_path(current_path);
-    std::string stem = source_path.stem().string();
-    std::string extension = source_path.extension().string();
-    if (extension.empty()) {
-        extension = ".json";
-    }
+        std::filesystem::path source_path(current_path);
+        std::string stem = source_path.stem().string();
+        std::string extension = source_path.extension().string();
+        if (extension.empty()) {
+            extension = ".json";
+        }
 
-    const std::regex version_suffix("(.*)_v([0-9]+)$");
-    std::smatch match;
-    if (std::regex_match(stem, match, version_suffix) && match.size() == 3) {
-        const int version = std::max(1, std::stoi(match[2].str()));
-        stem = match[1].str() + "_v" + std::to_string(version + 1);
-    } else {
-        stem += "_v2";
-    }
+        const std::regex version_suffix("(.*)_v([0-9]+)$");
+        std::smatch match;
+        if (std::regex_match(stem, match, version_suffix) && match.size() == 3) {
+            const int version = std::max(1, std::stoi(match[2].str()));
+            stem = match[1].str() + "_v" + std::to_string(version + 1);
+        } else {
+            stem += "_v2";
+        }
 
-    const std::filesystem::path suggested = source_path.parent_path() / (stem + extension);
-    return suggested.string();
-}
+        const std::filesystem::path suggested = source_path.parent_path() / (stem + extension);
+        return suggested.string();
+    }
 
 } // namespace VtxServices
diff --git a/tools/schema_creator/src/windows/schema_buckets_mapping_window.cpp b/tools/schema_creator/src/windows/schema_buckets_mapping_window.cpp
index 78f278a..3dc7690 100644
--- a/tools/schema_creator/src/windows/schema_buckets_mapping_window.cpp
+++ b/tools/schema_creator/src/windows/schema_buckets_mapping_window.cpp
@@ -11,26 +11,26 @@
 
 namespace {
 
-// Renders editable std::string via fixed temporary buffer for ImGui input APIs.
-bool InputTextString(const char* label, std::string& value, size_t min_buffer_size = 256, ImGuiInputTextFlags flags = 0) {
-    const size_t buffer_size = std::max(min_buffer_size, value.size() + 64);
-    std::vector<char> buffer(buffer_size, '\0');
-    std::snprintf(buffer.data(), buffer.size(), "%s", value.c_str());
-
-    if (!ImGui::InputText(label, buffer.data(), buffer.size(), flags)) {
-        return false;
+    // Renders editable std::string via fixed temporary buffer for ImGui input APIs.
+    bool InputTextString(const char* label, std::string& value, size_t min_buffer_size = 256,
+                         ImGuiInputTextFlags flags = 0) {
+        const size_t buffer_size = std::max(min_buffer_size, value.size() + 64);
+        std::vector<char> buffer(buffer_size, '\0');
+        std::snprintf(buffer.data(), buffer.size(), "%s", value.c_str());
+
+        if (!ImGui::InputText(label, buffer.data(), buffer.size(), flags)) {
+            return false;
+        }
+        value = buffer.data();
+        return true;
     }
-    value = buffer.data();
-    return true;
-}
 
 } // namespace
 
 // Constructs buckets/bone-mapping window bound to schema creator session.
 SchemaBucketsMappingWindow::SchemaBucketsMappingWindow(std::shared_ptr<SchemaCreatorSession> session)
     : ImGuiWindow("Buckets & Bone Mapping", session)
-    , schema_session_(std::move(session)) {
-}
+    , schema_session_(std::move(session)) {}
 
 // Renders window shell only while buckets/mapping panel visibility is enabled.
 void SchemaBucketsMappingWindow::OnRender() {
@@ -53,11 +53,9 @@ void SchemaBucketsMappingWindow::DrawContent() {
     auto& document = schema_session_->MutableDocument();
     ClampSelectionIndices();
 
-    if (ImGui::BeginTable(
-            "BucketsMappingRoot",
-            2,
-            ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp,
-            ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
+    if (ImGui::BeginTable("BucketsMappingRoot", 2,
+                          ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp,
+                          ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
         ImGui::TableSetupColumn("Buckets", ImGuiTableColumnFlags_WidthStretch, 0.42f);
         ImGui::TableSetupColumn("Bone Mapping", ImGuiTableColumnFlags_WidthStretch, 0.58f);
         ImGui::TableNextRow();
@@ -110,8 +108,8 @@ void SchemaBucketsMappingWindow::DrawContent() {
                 for (int i = 0; i < static_cast<int>(document.buckets.size()); ++i) {
                     const bool is_selected = selected_bucket_index_ == i;
                     const std::string label = document.buckets[i].empty()
-                        ? ("<unnamed bucket##" + std::to_string(i) + ">")
-                        : (document.buckets[i] + "##" + std::to_string(i));
+                                                  ? ("<unnamed bucket##" + std::to_string(i) + ">")
+                                                  : (document.buckets[i] + "##" + std::to_string(i));
                     if (ImGui::Selectable(label.c_str(), is_selected, ImGuiSelectableFlags_SpanAllColumns)) {
                         selected_bucket_index_ = i;
                     }
@@ -200,11 +198,10 @@ void SchemaBucketsMappingWindow::DrawContent() {
             ImGui::Separator();
             ImGui::Spacing();
 
-            if (ImGui::BeginTable(
-                    "BoneMappingTables",
-                    2,
-                    ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp,
-                    ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
+            if (ImGui::BeginTable("BoneMappingTables", 2,
+                                  ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders |
+                                      ImGuiTableFlags_SizingStretchProp,
+                                  ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
                 ImGui::TableSetupColumn("Models", ImGuiTableColumnFlags_WidthStretch, 0.45f);
                 ImGui::TableSetupColumn("Bones", ImGuiTableColumnFlags_WidthStretch, 0.55f);
                 ImGui::TableNextRow();
@@ -215,8 +212,8 @@ void SchemaBucketsMappingWindow::DrawContent() {
                         const auto& mapping = document.bone_mapping[i];
                         const bool is_selected = selected_model_index_ == i;
                         const std::string label = mapping.model_name.empty()
-                            ? ("<unnamed model##" + std::to_string(i) + ">")
-                            : (mapping.model_name + "##" + std::to_string(i));
+                                                      ? ("<unnamed model##" + std::to_string(i) + ">")
+                                                      : (mapping.model_name + "##" + std::to_string(i));
                         if (ImGui::Selectable(label.c_str(), is_selected, ImGuiSelectableFlags_SpanAllColumns)) {
                             selected_model_index_ = i;
                             selected_bone_index_ = document.bone_mapping[i].bones.empty() ? -1 : 0;
@@ -232,8 +229,8 @@ void SchemaBucketsMappingWindow::DrawContent() {
                         for (int i = 0; i < static_cast<int>(selected_mapping.bones.size()); ++i) {
                             const bool is_selected = selected_bone_index_ == i;
                             const std::string label = selected_mapping.bones[i].empty()
-                                ? ("<unnamed bone##" + std::to_string(i) + ">")
-                                : (selected_mapping.bones[i] + "##" + std::to_string(i));
+                                                          ? ("<unnamed bone##" + std::to_string(i) + ">")
+                                                          : (selected_mapping.bones[i] + "##" + std::to_string(i));
                             if (ImGui::Selectable(label.c_str(), is_selected, ImGuiSelectableFlags_SpanAllColumns)) {
                                 selected_bone_index_ = i;
                             }
diff --git a/tools/schema_creator/src/windows/schema_creator_window.cpp b/tools/schema_creator/src/windows/schema_creator_window.cpp
index 6d988cc..e85ed26 100644
--- a/tools/schema_creator/src/windows/schema_creator_window.cpp
+++ b/tools/schema_creator/src/windows/schema_creator_window.cpp
@@ -11,111 +11,108 @@
 
 namespace {
 
-// Converts selected type token to default meta text token.
-std::string BuildMetaTypeToken(const std::string& type_id) {
-    if (type_id.empty()) {
-        return "";
-    }
-
-    std::string out = type_id;
-    std::transform(out.begin(), out.end(), out.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    if (out == "none") {
-        return "";
-    }
-    return out;
-}
-
-// Renders editable string using temporary buffer sized for ImGui input widget.
-bool InputTextString(const char* label, std::string& value, size_t min_buffer_size = 256, ImGuiInputTextFlags flags = 0) {
-    const size_t buffer_size = std::max(min_buffer_size, value.size() + 64);
-    std::vector<char> buffer(buffer_size, '\0');
-    std::snprintf(buffer.data(), buffer.size(), "%s", value.c_str());
+    // Converts selected type token to default meta text token.
+    std::string BuildMetaTypeToken(const std::string& type_id) {
+        if (type_id.empty()) {
+            return "";
+        }
 
-    if (!ImGui::InputText(label, buffer.data(), buffer.size(), flags)) {
-        return false;
+        std::string out = type_id;
+        std::transform(out.begin(), out.end(), out.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        if (out == "none") {
+            return "";
+        }
+        return out;
     }
-    value = buffer.data();
-    return true;
-}
 
-// Renders containerType combo and writes selection into provided field.
-bool DrawContainerCombo(const char* label, std::string& container_type) {
-    static const char* kLabels[] = {"None", "Array", "Map"};
-    static const char* kValues[] = {"None", "Array", "Map"};
+    // Renders editable string using temporary buffer sized for ImGui input widget.
+    bool InputTextString(const char* label, std::string& value, size_t min_buffer_size = 256,
+                         ImGuiInputTextFlags flags = 0) {
+        const size_t buffer_size = std::max(min_buffer_size, value.size() + 64);
+        std::vector<char> buffer(buffer_size, '\0');
+        std::snprintf(buffer.data(), buffer.size(), "%s", value.c_str());
 
-    int current_index = 0;
-    for (int i = 0; i < 3; ++i) {
-        if (container_type == kValues[i]) {
-            current_index = i;
-            break;
+        if (!ImGui::InputText(label, buffer.data(), buffer.size(), flags)) {
+            return false;
         }
+        value = buffer.data();
+        return true;
     }
 
-    bool changed = false;
-    if (ImGui::BeginCombo(label, kLabels[current_index])) {
+    // Renders containerType combo and writes selection into provided field.
+    bool DrawContainerCombo(const char* label, std::string& container_type) {
+        static const char* kLabels[] = {"None", "Array", "Map"};
+        static const char* kValues[] = {"None", "Array", "Map"};
+
+        int current_index = 0;
         for (int i = 0; i < 3; ++i) {
-            const bool is_selected = current_index == i;
-            if (ImGui::Selectable(kLabels[i], is_selected)) {
-                container_type = kValues[i];
-                changed = true;
-            }
-            if (is_selected) {
-                ImGui::SetItemDefaultFocus();
+            if (container_type == kValues[i]) {
+                current_index = i;
+                break;
             }
         }
-        ImGui::EndCombo();
-    }
-    return changed;
-}
-
-// Renders typeId/keyId preset combo to speed up authoring.
-bool DrawTypePresetCombo(const char* label, std::string& type_id, bool include_none) {
-    static const char* kTypePresets[] = {
-        "Int8", "Int32", "Int64", "Float", "Double", "Bool", "String",
-        "Vector", "Quat", "Transform", "FloatRange", "Struct"
-    };
-    static const char* kKeyPresets[] = {
-        "None", "Int8", "Int32", "Int64", "Float", "Double", "Bool", "String"
-    };
 
-    const char* preview = type_id.empty() ? "<unset>" : type_id.c_str();
-    bool changed = false;
-    if (ImGui::BeginCombo(label, preview)) {
-        if (include_none) {
-            for (const char* preset : kKeyPresets) {
-                const bool is_selected = type_id == preset;
-                if (ImGui::Selectable(preset, is_selected)) {
-                    type_id = preset;
+        bool changed = false;
+        if (ImGui::BeginCombo(label, kLabels[current_index])) {
+            for (int i = 0; i < 3; ++i) {
+                const bool is_selected = current_index == i;
+                if (ImGui::Selectable(kLabels[i], is_selected)) {
+                    container_type = kValues[i];
                     changed = true;
                 }
                 if (is_selected) {
                     ImGui::SetItemDefaultFocus();
                 }
             }
-        } else {
-            for (const char* preset : kTypePresets) {
-                const bool is_selected = type_id == preset;
-                if (ImGui::Selectable(preset, is_selected)) {
-                    type_id = preset;
-                    changed = true;
+            ImGui::EndCombo();
+        }
+        return changed;
+    }
+
+    // Renders typeId/keyId preset combo to speed up authoring.
+    bool DrawTypePresetCombo(const char* label, std::string& type_id, bool include_none) {
+        static const char* kTypePresets[] = {"Int8",   "Int32",  "Int64", "Float",     "Double",     "Bool",
+                                             "String", "Vector", "Quat",  "Transform", "FloatRange", "Struct"};
+        static const char* kKeyPresets[] = {"None", "Int8", "Int32", "Int64", "Float", "Double", "Bool", "String"};
+
+        const char* preview = type_id.empty() ? "<unset>" : type_id.c_str();
+        bool changed = false;
+        if (ImGui::BeginCombo(label, preview)) {
+            if (include_none) {
+                for (const char* preset : kKeyPresets) {
+                    const bool is_selected = type_id == preset;
+                    if (ImGui::Selectable(preset, is_selected)) {
+                        type_id = preset;
+                        changed = true;
+                    }
+                    if (is_selected) {
+                        ImGui::SetItemDefaultFocus();
+                    }
                 }
-                if (is_selected) {
-                    ImGui::SetItemDefaultFocus();
+            } else {
+                for (const char* preset : kTypePresets) {
+                    const bool is_selected = type_id == preset;
+                    if (ImGui::Selectable(preset, is_selected)) {
+                        type_id = preset;
+                        changed = true;
+                    }
+                    if (is_selected) {
+                        ImGui::SetItemDefaultFocus();
+                    }
                 }
             }
+            ImGui::EndCombo();
         }
-        ImGui::EndCombo();
+        return changed;
     }
-    return changed;
-}
 
 } // namespace
 
 // Constructs schema editor window bound to schema creator session.
 SchemaCreatorWindow::SchemaCreatorWindow(std::shared_ptr<SchemaCreatorSession> session)
     : ImGuiWindow("Property Mappings", session)
-    , schema_session_(std::move(session)) {
-}
+    , schema_session_(std::move(session)) {}
 
 // Renders window shell while editor visibility is enabled.
 void SchemaCreatorWindow::OnRender() {
@@ -143,15 +140,10 @@ void SchemaCreatorWindow::DrawContent() {
     ImGui::Spacing();
 
     const ImVec2 available = ImGui::GetContentRegionAvail();
-    if (ImGui::BeginTable(
-            "SchemaCreatorMain",
-            2,
-            ImGuiTableFlags_Resizable |
-                ImGuiTableFlags_Borders |
-                ImGuiTableFlags_SizingStretchProp |
-                ImGuiTableFlags_NoPadOuterX |
-                ImGuiTableFlags_NoPadInnerX,
-            ImVec2(-FLT_MIN, available.y))) {
+    if (ImGui::BeginTable("SchemaCreatorMain", 2,
+                          ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp |
+                              ImGuiTableFlags_NoPadOuterX | ImGuiTableFlags_NoPadInnerX,
+                          ImVec2(-FLT_MIN, available.y))) {
         ImGui::TableSetupColumn("Structs", ImGuiTableColumnFlags_WidthStretch, 0.30f);
         ImGui::TableSetupColumn("Editor", ImGuiTableColumnFlags_WidthStretch, 0.70f);
         ImGui::TableNextRow();
@@ -168,9 +160,7 @@ void SchemaCreatorWindow::DrawContent() {
 
 // Renders top toolbar with document status and quick actions.
 void SchemaCreatorWindow::DrawToolbar() {
-    const std::string path_text = schema_session_->HasActivePath()
-        ? schema_session_->GetActivePath()
-        : "<unsaved>";
+    const std::string path_text = schema_session_->HasActivePath() ? schema_session_->GetActivePath() : "<unsaved>";
 
     ImGui::TextColored(ImVec4(0.55f, 0.82f, 1.0f, 1.0f), "Schema Document");
     ImGui::Text("Path: %s", path_text.c_str());
@@ -183,10 +173,8 @@ void SchemaCreatorWindow::DrawToolbar() {
     bool next_generation_mode = schema_session_->IsNextGenerationMode();
     if (ImGui::Checkbox("Next Generation (additive only)", &next_generation_mode)) {
         schema_session_->SetNextGenerationMode(next_generation_mode);
-        schema_session_->AddGuiInfoLog(
-            next_generation_mode
-                ? "Mode changed: Next Generation."
-                : "Mode changed: Overwrite Current Generation.");
+        schema_session_->AddGuiInfoLog(next_generation_mode ? "Mode changed: Next Generation."
+                                                            : "Mode changed: Overwrite Current Generation.");
     }
     if (ImGui::IsItemHovered()) {
         ImGui::SetTooltip("When enabled, save enforces schema evolution checks and blocks removals/signature breaks.");
@@ -227,8 +215,8 @@ void SchemaCreatorWindow::DrawStructListPane() {
             ImGui::EndDisabled();
         }
 
-        const bool has_selected_struct = selected_struct_index_ >= 0 &&
-            selected_struct_index_ < static_cast<int>(document.structs.size());
+        const bool has_selected_struct =
+            selected_struct_index_ >= 0 && selected_struct_index_ < static_cast<int>(document.structs.size());
         ImGui::SameLine();
         if (!has_selected_struct) {
             ImGui::BeginDisabled();
@@ -260,8 +248,8 @@ void SchemaCreatorWindow::DrawStructListPane() {
             for (int i = 0; i < static_cast<int>(document.structs.size()); ++i) {
                 const bool is_selected = selected_struct_index_ == i;
                 const std::string label = document.structs[i].struct_name.empty()
-                    ? ("<unnamed struct##" + std::to_string(i) + ">")
-                    : document.structs[i].struct_name;
+                                              ? ("<unnamed struct##" + std::to_string(i) + ">")
+                                              : document.structs[i].struct_name;
                 if (ImGui::Selectable(label.c_str(), is_selected, ImGuiSelectableFlags_SpanAllColumns)) {
                     selected_struct_index_ = i;
                     selected_field_index_ = document.structs[i].fields.empty() ? -1 : 0;
@@ -328,13 +316,9 @@ void SchemaCreatorWindow::DrawStructEditorPane() {
         ImGui::Spacing();
 
         // Step 1: Render field list and field details side-by-side.
-        if (ImGui::BeginTable(
-                "FieldEditorTable",
-                2,
-                ImGuiTableFlags_Resizable |
-                    ImGuiTableFlags_Borders |
-                    ImGuiTableFlags_SizingStretchProp,
-                ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
+        if (ImGui::BeginTable("FieldEditorTable", 2,
+                              ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp,
+                              ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
             ImGui::TableSetupColumn("Field List", ImGuiTableColumnFlags_WidthStretch, 0.33f);
             ImGui::TableSetupColumn("Field Details", ImGuiTableColumnFlags_WidthStretch, 0.67f);
             ImGui::TableNextRow();
@@ -343,10 +327,10 @@ void SchemaCreatorWindow::DrawStructEditorPane() {
             if (ImGui::BeginChild("FieldList", ImVec2(0.0f, 0.0f), true, ImGuiWindowFlags_NavFlattened)) {
                 for (int i = 0; i < static_cast<int>(schema_struct.fields.size()); ++i) {
                     const auto& field = schema_struct.fields[i];
-                    const std::string label = field.name.empty()
-                        ? ("<unnamed field##" + std::to_string(i) + ">")
-                        : (field.name + "##" + std::to_string(i));
-                    if (ImGui::Selectable(label.c_str(), selected_field_index_ == i, ImGuiSelectableFlags_SpanAllColumns)) {
+                    const std::string label = field.name.empty() ? ("<unnamed field##" + std::to_string(i) + ">")
+                                                                 : (field.name + "##" + std::to_string(i));
+                    if (ImGui::Selectable(label.c_str(), selected_field_index_ == i,
+                                          ImGuiSelectableFlags_SpanAllColumns)) {
                         selected_field_index_ = i;
                     }
                 }
@@ -355,7 +339,8 @@ void SchemaCreatorWindow::DrawStructEditorPane() {
 
             ImGui::TableSetColumnIndex(1);
             if (ImGui::BeginChild("FieldDetails", ImVec2(0.0f, 0.0f), true)) {
-                if (selected_field_index_ < 0 || selected_field_index_ >= static_cast<int>(schema_struct.fields.size())) {
+                if (selected_field_index_ < 0 ||
+                    selected_field_index_ >= static_cast<int>(schema_struct.fields.size())) {
                     ImGui::TextDisabled("Select a field to edit.");
                 } else {
                     // Edit the selected field in-place; dirty mark is applied once per frame.
diff --git a/tools/schema_creator/src/windows/schema_evolution_window.cpp b/tools/schema_creator/src/windows/schema_evolution_window.cpp
index 5b5d3cb..5b6a67f 100644
--- a/tools/schema_creator/src/windows/schema_evolution_window.cpp
+++ b/tools/schema_creator/src/windows/schema_evolution_window.cpp
@@ -7,40 +7,47 @@
 
 namespace {
 
-const char* SeverityToString(VtxServices::ValidationSeverity severity) {
-    switch (severity) {
-        case VtxServices::ValidationSeverity::Info: return "Info";
-        case VtxServices::ValidationSeverity::Warning: return "Warning";
-        case VtxServices::ValidationSeverity::Error: return "Error";
-        default: return "Unknown";
+    const char* SeverityToString(VtxServices::ValidationSeverity severity) {
+        switch (severity) {
+        case VtxServices::ValidationSeverity::Info:
+            return "Info";
+        case VtxServices::ValidationSeverity::Warning:
+            return "Warning";
+        case VtxServices::ValidationSeverity::Error:
+            return "Error";
+        default:
+            return "Unknown";
+        }
     }
-}
 
-ImVec4 SeverityColor(VtxServices::ValidationSeverity severity) {
-    switch (severity) {
-        case VtxServices::ValidationSeverity::Info: return ImVec4(0.60f, 0.83f, 1.0f, 1.0f);
-        case VtxServices::ValidationSeverity::Warning: return ImVec4(1.0f, 0.78f, 0.35f, 1.0f);
-        case VtxServices::ValidationSeverity::Error: return ImVec4(1.0f, 0.45f, 0.45f, 1.0f);
-        default: return ImVec4(0.70f, 0.70f, 0.70f, 1.0f);
+    ImVec4 SeverityColor(VtxServices::ValidationSeverity severity) {
+        switch (severity) {
+        case VtxServices::ValidationSeverity::Info:
+            return ImVec4(0.60f, 0.83f, 1.0f, 1.0f);
+        case VtxServices::ValidationSeverity::Warning:
+            return ImVec4(1.0f, 0.78f, 0.35f, 1.0f);
+        case VtxServices::ValidationSeverity::Error:
+            return ImVec4(1.0f, 0.45f, 0.45f, 1.0f);
+        default:
+            return ImVec4(0.70f, 0.70f, 0.70f, 1.0f);
+        }
     }
-}
 
-std::string BuildLocationLabel(const std::string& struct_name, const std::string& field_name) {
-    if (struct_name.empty()) {
-        return "-";
-    }
-    if (field_name.empty()) {
-        return struct_name;
+    std::string BuildLocationLabel(const std::string& struct_name, const std::string& field_name) {
+        if (struct_name.empty()) {
+            return "-";
+        }
+        if (field_name.empty()) {
+            return struct_name;
+        }
+        return struct_name + "." + field_name;
     }
-    return struct_name + "." + field_name;
-}
 
 } // namespace
 
 SchemaEvolutionWindow::SchemaEvolutionWindow(std::shared_ptr<SchemaCreatorSession> session)
     : ImGuiWindow("Schema Evolution", session)
-    , schema_session_(std::move(session)) {
-}
+    , schema_session_(std::move(session)) {}
 
 void SchemaEvolutionWindow::OnRender() {
     if (!schema_session_->IsEvolutionWindowVisible()) {
@@ -65,11 +72,9 @@ void SchemaEvolutionWindow::DrawContent() {
     }
 
     const auto& report = schema_session_->GetEvolutionReport();
-    ImGui::Text(
-        "Result: %s",
-        report.has_breaking_changes
-            ? "Breaking changes detected (not allowed in next generation mode)"
-            : "No breaking changes");
+    ImGui::Text("Result: %s", report.has_breaking_changes
+                                  ? "Breaking changes detected (not allowed in next generation mode)"
+                                  : "No breaking changes");
     ImGui::Text("Entries: %zu", report.issues.size());
     ImGui::Spacing();
     ImGui::Separator();
@@ -80,11 +85,10 @@ void SchemaEvolutionWindow::DrawContent() {
         return;
     }
 
-    if (ImGui::BeginTable(
-            "EvolutionIssuesTable",
-            3,
-            ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY,
-            ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
+    if (ImGui::BeginTable("EvolutionIssuesTable", 3,
+                          ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable |
+                              ImGuiTableFlags_ScrollY,
+                          ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
         ImGui::TableSetupColumn("Severity", ImGuiTableColumnFlags_WidthFixed, 90.0f);
         ImGui::TableSetupColumn("Location", ImGuiTableColumnFlags_WidthFixed, 230.0f);
         ImGui::TableSetupColumn("Change", ImGuiTableColumnFlags_WidthStretch);
diff --git a/tools/schema_creator/src/windows/schema_general_info_window.cpp b/tools/schema_creator/src/windows/schema_general_info_window.cpp
index 5452df9..664f4ac 100644
--- a/tools/schema_creator/src/windows/schema_general_info_window.cpp
+++ b/tools/schema_creator/src/windows/schema_general_info_window.cpp
@@ -10,26 +10,26 @@
 
 namespace {
 
-// Renders editable std::string via fixed temporary buffer for ImGui input APIs.
-bool InputTextString(const char* label, std::string& value, size_t min_buffer_size = 256, ImGuiInputTextFlags flags = 0) {
-    const size_t buffer_size = std::max(min_buffer_size, value.size() + 64);
-    std::vector<char> buffer(buffer_size, '\0');
-    std::snprintf(buffer.data(), buffer.size(), "%s", value.c_str());
-
-    if (!ImGui::InputText(label, buffer.data(), buffer.size(), flags)) {
-        return false;
+    // Renders editable std::string via fixed temporary buffer for ImGui input APIs.
+    bool InputTextString(const char* label, std::string& value, size_t min_buffer_size = 256,
+                         ImGuiInputTextFlags flags = 0) {
+        const size_t buffer_size = std::max(min_buffer_size, value.size() + 64);
+        std::vector<char> buffer(buffer_size, '\0');
+        std::snprintf(buffer.data(), buffer.size(), "%s", value.c_str());
+
+        if (!ImGui::InputText(label, buffer.data(), buffer.size(), flags)) {
+            return false;
+        }
+        value = buffer.data();
+        return true;
     }
-    value = buffer.data();
-    return true;
-}
 
 } // namespace
 
 // Constructs schema general-info window bound to schema creator session.
 SchemaGeneralInfoWindow::SchemaGeneralInfoWindow(std::shared_ptr<SchemaCreatorSession> session)
     : ImGuiWindow("General Info", session)
-    , schema_session_(std::move(session)) {
-}
+    , schema_session_(std::move(session)) {}
 
 // Renders window shell only while general-info panel visibility is enabled.
 void SchemaGeneralInfoWindow::OnRender() {
@@ -52,9 +52,7 @@ void SchemaGeneralInfoWindow::DrawContent() {
     auto& document = schema_session_->MutableDocument();
 
     // Step 1: Show session/document state summary.
-    const std::string path_text = schema_session_->HasActivePath()
-        ? schema_session_->GetActivePath()
-        : "<unsaved>";
+    const std::string path_text = schema_session_->HasActivePath() ? schema_session_->GetActivePath() : "<unsaved>";
     ImGui::Text("Path: %s", path_text.c_str());
     ImGui::Text("Baseline: %s", schema_session_->HasBaseline() ? "Available" : "Not loaded yet");
     ImGui::Text("Unsaved Changes: %s", schema_session_->HasUnsavedChanges() ? "Yes" : "No");
@@ -90,4 +88,3 @@ void SchemaGeneralInfoWindow::DrawContent() {
     ImGui::Text("Bone Models: %d", static_cast<int>(document.bone_mapping.size()));
     ImGui::Text("Bone Entries: %d", static_cast<int>(total_bones));
 }
-
diff --git a/tools/schema_creator/src/windows/schema_validation_window.cpp b/tools/schema_creator/src/windows/schema_validation_window.cpp
index 853a537..df4d70d 100644
--- a/tools/schema_creator/src/windows/schema_validation_window.cpp
+++ b/tools/schema_creator/src/windows/schema_validation_window.cpp
@@ -7,44 +7,51 @@
 
 namespace {
 
-// Converts validation severity enum to table label.
-const char* SeverityToString(VtxServices::ValidationSeverity severity) {
-    switch (severity) {
-        case VtxServices::ValidationSeverity::Info: return "Info";
-        case VtxServices::ValidationSeverity::Warning: return "Warning";
-        case VtxServices::ValidationSeverity::Error: return "Error";
-        default: return "Unknown";
+    // Converts validation severity enum to table label.
+    const char* SeverityToString(VtxServices::ValidationSeverity severity) {
+        switch (severity) {
+        case VtxServices::ValidationSeverity::Info:
+            return "Info";
+        case VtxServices::ValidationSeverity::Warning:
+            return "Warning";
+        case VtxServices::ValidationSeverity::Error:
+            return "Error";
+        default:
+            return "Unknown";
+        }
     }
-}
 
-// Returns severity color used for table highlight text.
-ImVec4 SeverityColor(VtxServices::ValidationSeverity severity) {
-    switch (severity) {
-        case VtxServices::ValidationSeverity::Info: return ImVec4(0.60f, 0.83f, 1.0f, 1.0f);
-        case VtxServices::ValidationSeverity::Warning: return ImVec4(1.0f, 0.78f, 0.35f, 1.0f);
-        case VtxServices::ValidationSeverity::Error: return ImVec4(1.0f, 0.45f, 0.45f, 1.0f);
-        default: return ImVec4(0.70f, 0.70f, 0.70f, 1.0f);
+    // Returns severity color used for table highlight text.
+    ImVec4 SeverityColor(VtxServices::ValidationSeverity severity) {
+        switch (severity) {
+        case VtxServices::ValidationSeverity::Info:
+            return ImVec4(0.60f, 0.83f, 1.0f, 1.0f);
+        case VtxServices::ValidationSeverity::Warning:
+            return ImVec4(1.0f, 0.78f, 0.35f, 1.0f);
+        case VtxServices::ValidationSeverity::Error:
+            return ImVec4(1.0f, 0.45f, 0.45f, 1.0f);
+        default:
+            return ImVec4(0.70f, 0.70f, 0.70f, 1.0f);
+        }
     }
-}
 
-// Builds "Struct.Field" location label for issue table rows.
-std::string BuildLocationLabel(const std::string& struct_name, const std::string& field_name) {
-    if (struct_name.empty()) {
-        return "-";
-    }
-    if (field_name.empty()) {
-        return struct_name;
+    // Builds "Struct.Field" location label for issue table rows.
+    std::string BuildLocationLabel(const std::string& struct_name, const std::string& field_name) {
+        if (struct_name.empty()) {
+            return "-";
+        }
+        if (field_name.empty()) {
+            return struct_name;
+        }
+        return struct_name + "." + field_name;
     }
-    return struct_name + "." + field_name;
-}
 
 } // namespace
 
 // Constructs schema validation window bound to schema creator session.
 SchemaValidationWindow::SchemaValidationWindow(std::shared_ptr<SchemaCreatorSession> session)
     : ImGuiWindow("Schema Validation", session)
-    , schema_session_(std::move(session)) {
-}
+    , schema_session_(std::move(session)) {}
 
 // Renders window shell only while validation panel visibility is enabled.
 void SchemaValidationWindow::OnRender() {
@@ -89,11 +96,10 @@ void SchemaValidationWindow::DrawContent() {
     }
 
     // Step 1: Build and render issue table rows.
-    if (ImGui::BeginTable(
-            "ValidationIssuesTable",
-            3,
-            ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY,
-            ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
+    if (ImGui::BeginTable("ValidationIssuesTable", 3,
+                          ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable |
+                              ImGuiTableFlags_ScrollY,
+                          ImVec2(-FLT_MIN, ImGui::GetContentRegionAvail().y))) {
         ImGui::TableSetupColumn("Severity", ImGuiTableColumnFlags_WidthFixed, 90.0f);
         ImGui::TableSetupColumn("Location", ImGuiTableColumnFlags_WidthFixed, 230.0f);
         ImGui::TableSetupColumn("Message", ImGuiTableColumnFlags_WidthStretch);
diff --git a/tools/shared/include/gui/gui_layer.h b/tools/shared/include/gui/gui_layer.h
index 2972f7e..b1b3dcf 100644
--- a/tools/shared/include/gui/gui_layer.h
+++ b/tools/shared/include/gui/gui_layer.h
@@ -4,5 +4,5 @@ class IGuiLayer {
 public:
     virtual ~IGuiLayer() = default;
     virtual void OnUpdate() = 0;
-    virtual void OnRender() = 0; 
+    virtual void OnRender() = 0;
 };
\ No newline at end of file
diff --git a/tools/shared/include/gui/gui_manager.h b/tools/shared/include/gui/gui_manager.h
index 8b0d40b..9ffffcb 100644
--- a/tools/shared/include/gui/gui_manager.h
+++ b/tools/shared/include/gui/gui_manager.h
@@ -15,7 +15,7 @@ class GuiManager {
     GuiManager& operator=(const GuiManager&) = delete;
 
     void AddLayer(std::shared_ptr<IGuiLayer> layer);
-    
+
     void BeginFrame();
     void Update();
     void Render();
diff --git a/tools/shared/include/gui/gui_scale_controller.h b/tools/shared/include/gui/gui_scale_controller.h
index bd976a5..7f3252c 100644
--- a/tools/shared/include/gui/gui_scale_controller.h
+++ b/tools/shared/include/gui/gui_scale_controller.h
@@ -47,7 +47,7 @@ class GuiScaleController {
     std::string tool_id_;
     std::filesystem::path settings_path_;
     GLFWwindow* window_ = nullptr;
-    ImGuiStyle base_style_{};
+    ImGuiStyle base_style_ {};
     bool has_base_style_ = false;
     float auto_scale_ = 1.0f;
     float effective_scale_ = 1.0f;
diff --git a/tools/shared/include/gui/gui_types.h b/tools/shared/include/gui/gui_types.h
index 4fcbacd..b4926bf 100644
--- a/tools/shared/include/gui/gui_types.h
+++ b/tools/shared/include/gui/gui_types.h
@@ -3,8 +3,7 @@
 #include <memory>
 #include "gui/gui_manager.h"
 
-namespace VtxGuiNames
-{
+namespace VtxGuiNames {
     inline const char* SessionName = "VtxSessionBase";
     inline const char* TimelineWindow = "Timeline";
     inline const char* FilePropertiesWindow = "File Properties";
@@ -16,10 +15,7 @@ namespace VtxGuiNames
     inline const char* TimelineEventsWindow = "Timeline Events";
     inline const char* EntityDetailsWindow = "Entity Details";
     inline const char* LogWindow = "Logs";
-}
+} // namespace VtxGuiNames
 
 
-enum class TimeDisplayFormat {
-    Ticks = 0,
-    Formatted
-};
+enum class TimeDisplayFormat { Ticks = 0, Formatted };
diff --git a/tools/shared/include/gui/gui_window.h b/tools/shared/include/gui/gui_window.h
index bd89f35..7db27ff 100644
--- a/tools/shared/include/gui/gui_window.h
+++ b/tools/shared/include/gui/gui_window.h
@@ -13,7 +13,7 @@ class ImGuiWindow : public IGuiLayer {
     ImGuiWindowFlags flags_ = 0;
 
 public:
-    ImGuiWindow(const std::string& title, const std::shared_ptr<VtxSessionBase>& session, ImGuiWindowFlags flags = 0) ;
+    ImGuiWindow(const std::string& title, const std::shared_ptr<VtxSessionBase>& session, ImGuiWindowFlags flags = 0);
     virtual ~ImGuiWindow() = default;
 
     void OnUpdate() final;
@@ -25,9 +25,9 @@ class ImGuiWindow : public IGuiLayer {
 
 protected:
     //Child classes only need to override these two methods
-    virtual void UpdateLogic() {} 
+    virtual void UpdateLogic() {}
     virtual void DrawContent() = 0;
-    
+
     //pointer to global session
     std::shared_ptr<VtxSessionBase> session_;
 };
diff --git a/tools/shared/src/gui/gui_app.cpp b/tools/shared/src/gui/gui_app.cpp
index ba222b0..657eef2 100644
--- a/tools/shared/src/gui/gui_app.cpp
+++ b/tools/shared/src/gui/gui_app.cpp
@@ -1,8 +1,8 @@
 #include "GLFW/glfw3.h"
 
 #if defined(_WIN32)
-    #define GLFW_EXPOSE_NATIVE_WIN32
-    #include "GLFW/glfw3native.h"
+#define GLFW_EXPOSE_NATIVE_WIN32
+#include "GLFW/glfw3native.h"
 #endif
 
 #include <GL/gl.h>
@@ -12,78 +12,70 @@
 #include "gui/gui_scale_controller.h"
 
 namespace {
-constexpr float kClearColor = 0.1f;
+    constexpr float kClearColor = 0.1f;
 
 #if defined(_WIN32)
-using SetProcessDpiAwarenessContextFn = BOOL(WINAPI*)(HANDLE);
-using SetProcessDpiAwarenessFn = HRESULT(WINAPI*)(int);
-
-// Opts the process into per-monitor DPI awareness before GLFW creates any windows.
-void ApplyProcessDpiAwareness() {
-    const HMODULE user32_module = GetModuleHandleW(L"user32.dll");
-    if (user32_module != nullptr) {
-        const auto set_context = reinterpret_cast<SetProcessDpiAwarenessContextFn>(
-            GetProcAddress(user32_module, "SetProcessDpiAwarenessContext"));
-        if (set_context != nullptr && set_context(reinterpret_cast<HANDLE>(-4))) {
-            return;
+    using SetProcessDpiAwarenessContextFn = BOOL(WINAPI*)(HANDLE);
+    using SetProcessDpiAwarenessFn = HRESULT(WINAPI*)(int);
+
+    // Opts the process into per-monitor DPI awareness before GLFW creates any windows.
+    void ApplyProcessDpiAwareness() {
+        const HMODULE user32_module = GetModuleHandleW(L"user32.dll");
+        if (user32_module != nullptr) {
+            const auto set_context = reinterpret_cast<SetProcessDpiAwarenessContextFn>(
+                GetProcAddress(user32_module, "SetProcessDpiAwarenessContext"));
+            if (set_context != nullptr && set_context(reinterpret_cast<HANDLE>(-4))) {
+                return;
+            }
         }
-    }
 
-    const HMODULE shcore_module = LoadLibraryW(L"shcore.dll");
-    if (shcore_module != nullptr) {
-        const auto set_awareness = reinterpret_cast<SetProcessDpiAwarenessFn>(
-            GetProcAddress(shcore_module, "SetProcessDpiAwareness"));
-        if (set_awareness != nullptr && SUCCEEDED(set_awareness(2))) {
+        const HMODULE shcore_module = LoadLibraryW(L"shcore.dll");
+        if (shcore_module != nullptr) {
+            const auto set_awareness =
+                reinterpret_cast<SetProcessDpiAwarenessFn>(GetProcAddress(shcore_module, "SetProcessDpiAwareness"));
+            if (set_awareness != nullptr && SUCCEEDED(set_awareness(2))) {
+                FreeLibrary(shcore_module);
+                return;
+            }
             FreeLibrary(shcore_module);
-            return;
         }
-        FreeLibrary(shcore_module);
-    }
-
-    SetProcessDPIAware();
-}
 
-void ApplyWindowIcon(GLFWwindow* window) {
-    if (!window) {
-        return;
+        SetProcessDPIAware();
     }
 
-    const HMODULE module_handle = GetModuleHandleW(nullptr);
-    if (!module_handle) {
-        return;
-    }
+    void ApplyWindowIcon(GLFWwindow* window) {
+        if (!window) {
+            return;
+        }
 
-    const auto* resource_name = L"IDI_ICON1";
-    HICON large_icon = static_cast<HICON>(LoadImageW(
-        module_handle,
-        resource_name,
-        IMAGE_ICON,
-        GetSystemMetrics(SM_CXICON),
-        GetSystemMetrics(SM_CYICON),
-        LR_DEFAULTCOLOR | LR_SHARED));
-    HICON small_icon = static_cast<HICON>(LoadImageW(
-        module_handle,
-        resource_name,
-        IMAGE_ICON,
-        GetSystemMetrics(SM_CXSMICON),
-        GetSystemMetrics(SM_CYSMICON),
-        LR_DEFAULTCOLOR | LR_SHARED));
-    if (!large_icon && !small_icon) {
-        return;
-    }
+        const HMODULE module_handle = GetModuleHandleW(nullptr);
+        if (!module_handle) {
+            return;
+        }
 
-    HWND hwnd = glfwGetWin32Window(window);
-    if (!hwnd) {
-        return;
-    }
+        const auto* resource_name = L"IDI_ICON1";
+        HICON large_icon =
+            static_cast<HICON>(LoadImageW(module_handle, resource_name, IMAGE_ICON, GetSystemMetrics(SM_CXICON),
+                                          GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR | LR_SHARED));
+        HICON small_icon =
+            static_cast<HICON>(LoadImageW(module_handle, resource_name, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON),
+                                          GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR | LR_SHARED));
+        if (!large_icon && !small_icon) {
+            return;
+        }
 
-    if (large_icon) {
-        SendMessageW(hwnd, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(large_icon));
-    }
-    if (small_icon) {
-        SendMessageW(hwnd, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(small_icon));
+        HWND hwnd = glfwGetWin32Window(window);
+        if (!hwnd) {
+            return;
+        }
+
+        if (large_icon) {
+            SendMessageW(hwnd, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(large_icon));
+        }
+        if (small_icon) {
+            SendMessageW(hwnd, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(small_icon));
+        }
     }
-}
 #endif
 
 } // namespace
@@ -104,8 +96,7 @@ GuiApplication::~GuiApplication() {
 }
 
 // Legacy hook kept for compatibility with older monolithic startup flow.
-void GuiApplication::CreateMainLayout()
-{
+void GuiApplication::CreateMainLayout() {
     // No-op in shared build. Each tool sets up its own layout via AddLayer().
 }
 
@@ -163,8 +154,7 @@ void GuiApplication::AddLayer(std::shared_ptr<IGuiLayer> layer) {
 }
 
 // Reports whether app window has been closed or destroyed.
-bool GuiApplication::ShouldClose() const
-{
+bool GuiApplication::ShouldClose() const {
     return window_ == nullptr || glfwWindowShouldClose(window_) != 0;
 }
 
diff --git a/tools/shared/src/gui/gui_manager.cpp b/tools/shared/src/gui/gui_manager.cpp
index b4d53b3..0f1d471 100644
--- a/tools/shared/src/gui/gui_manager.cpp
+++ b/tools/shared/src/gui/gui_manager.cpp
@@ -8,8 +8,8 @@
 
 // Initializes ImGui runtime and backend bindings for the active GLFW window.
 GuiManager::GuiManager(GLFWwindow* window, const std::shared_ptr<GuiScaleController>& scale_controller)
-    : window_(window),
-      scale_controller_(scale_controller) {
+    : window_(window)
+    , scale_controller_(scale_controller) {
     IMGUI_CHECKVERSION();
     ImGui::CreateContext();
 
@@ -73,7 +73,7 @@ void GuiManager::EndFrame() {
         GLFWwindow* backup_current_context = glfwGetCurrentContext();
         ImGui::UpdatePlatformWindows();
         ImGui::RenderPlatformWindowsDefault();
-        
+
         glfwMakeContextCurrent(backup_current_context);
     }
 }
diff --git a/tools/shared/src/gui/gui_scale_controller.cpp b/tools/shared/src/gui/gui_scale_controller.cpp
index 760dc03..0b28758 100644
--- a/tools/shared/src/gui/gui_scale_controller.cpp
+++ b/tools/shared/src/gui/gui_scale_controller.cpp
@@ -13,53 +13,53 @@
 #include <sstream>
 
 namespace {
-constexpr float kMinEffectiveScale = 0.75f;
-constexpr float kMaxEffectiveScale = 4.00f;
-constexpr float kMinScaleAdjustment = 0.75f;
-constexpr float kMaxScaleAdjustment = 2.00f;
-constexpr float kScaleEpsilon = 0.01f;
-constexpr char kSettingsFileName[] = "gui_settings.ini";
-constexpr char kScaleKey[] = "scale_adjustment";
-constexpr char kAutoValue[] = "auto";
-
-// Returns a stable LOCALAPPDATA-backed settings path for shared GUI preferences.
-std::filesystem::path BuildSettingsPath() {
+    constexpr float kMinEffectiveScale = 0.75f;
+    constexpr float kMaxEffectiveScale = 4.00f;
+    constexpr float kMinScaleAdjustment = 0.75f;
+    constexpr float kMaxScaleAdjustment = 2.00f;
+    constexpr float kScaleEpsilon = 0.01f;
+    constexpr char kSettingsFileName[] = "gui_settings.ini";
+    constexpr char kScaleKey[] = "scale_adjustment";
+    constexpr char kAutoValue[] = "auto";
+
+    // Returns a stable LOCALAPPDATA-backed settings path for shared GUI preferences.
+    std::filesystem::path BuildSettingsPath() {
 #if defined(_WIN32)
-    char* local_app_data = nullptr;
-    size_t size = 0;
-    if (_dupenv_s(&local_app_data, &size, "LOCALAPPDATA") == 0 && local_app_data != nullptr) {
-        std::filesystem::path path = std::filesystem::path(local_app_data) / "VTX" / kSettingsFileName;
-        free(local_app_data);
-        return path;
-    }
+        char* local_app_data = nullptr;
+        size_t size = 0;
+        if (_dupenv_s(&local_app_data, &size, "LOCALAPPDATA") == 0 && local_app_data != nullptr) {
+            std::filesystem::path path = std::filesystem::path(local_app_data) / "VTX" / kSettingsFileName;
+            free(local_app_data);
+            return path;
+        }
 #endif
-    return std::filesystem::current_path() / kSettingsFileName;
-}
+        return std::filesystem::current_path() / kSettingsFileName;
+    }
 
-// Formats float values consistently for INI persistence.
-std::string FormatScaleValue(float value) {
-    std::ostringstream stream;
-    stream.setf(std::ios::fixed, std::ios::floatfield);
-    stream.precision(2);
-    stream << value;
-    return stream.str();
-}
+    // Formats float values consistently for INI persistence.
+    std::string FormatScaleValue(float value) {
+        std::ostringstream stream;
+        stream.setf(std::ios::fixed, std::ios::floatfield);
+        stream.precision(2);
+        stream << value;
+        return stream.str();
+    }
 
-// Chooses a single scale factor from GLFW's platform-provided content scale pair.
-float ResolveContentScale(float x_scale, float y_scale) {
-    const float resolved = std::max(x_scale, y_scale);
-    if (resolved <= 0.0f) {
-        return 1.0f;
+    // Chooses a single scale factor from GLFW's platform-provided content scale pair.
+    float ResolveContentScale(float x_scale, float y_scale) {
+        const float resolved = std::max(x_scale, y_scale);
+        if (resolved <= 0.0f) {
+            return 1.0f;
+        }
+        return resolved;
     }
-    return resolved;
-}
 
 } // namespace
 
 // Seeds scale state from persisted per-tool preferences.
 GuiScaleController::GuiScaleController(std::string tool_id)
-    : tool_id_(std::move(tool_id)),
-      settings_path_(BuildSettingsPath()) {
+    : tool_id_(std::move(tool_id))
+    , settings_path_(BuildSettingsPath()) {
     LoadSettings();
 }
 
@@ -198,7 +198,8 @@ void GuiScaleController::LoadSettings() {
     }
 
     char buffer[64] = {};
-    GetPrivateProfileStringA(tool_id_.c_str(), kScaleKey, kAutoValue, buffer, static_cast<DWORD>(std::size(buffer)), settings_path_.string().c_str());
+    GetPrivateProfileStringA(tool_id_.c_str(), kScaleKey, kAutoValue, buffer, static_cast<DWORD>(std::size(buffer)),
+                             settings_path_.string().c_str());
     const std::string stored_value = buffer;
     if (stored_value.empty() || stored_value == kAutoValue) {
         return;
@@ -218,9 +219,8 @@ void GuiScaleController::SaveSettings() const {
     std::error_code error;
     std::filesystem::create_directories(settings_path_.parent_path(), error);
 
-    const std::string value = scale_adjustment_.has_value()
-        ? FormatScaleValue(scale_adjustment_.value())
-        : std::string(kAutoValue);
+    const std::string value =
+        scale_adjustment_.has_value() ? FormatScaleValue(scale_adjustment_.value()) : std::string(kAutoValue);
     WritePrivateProfileStringA(tool_id_.c_str(), kScaleKey, value.c_str(), settings_path_.string().c_str());
 #endif
 }
diff --git a/tools/shared/src/gui/gui_window.cpp b/tools/shared/src/gui/gui_window.cpp
index 3ed2d74..2b37644 100644
--- a/tools/shared/src/gui/gui_window.cpp
+++ b/tools/shared/src/gui/gui_window.cpp
@@ -2,10 +2,11 @@
 #include <imgui.h>
 
 // Constructs a reusable ImGui window shell bound to a shared session.
-ImGuiWindow::ImGuiWindow(const std::string& title, const std::shared_ptr<VtxSessionBase>& session, ImGuiWindowFlags flags)
-: title_(title), session_(session), flags_(flags)
-{
-}
+ImGuiWindow::ImGuiWindow(const std::string& title, const std::shared_ptr<VtxSessionBase>& session,
+                         ImGuiWindowFlags flags)
+    : title_(title)
+    , session_(session)
+    , flags_(flags) {}
 
 // Updates window-specific state only while the window is visible.
 void ImGuiWindow::OnUpdate() {
@@ -28,19 +29,16 @@ void ImGuiWindow::OnRender() {
 }
 
 // Flips open/closed visibility state.
-void ImGuiWindow::Toggle()
-{
+void ImGuiWindow::Toggle() {
     is_open_ = !is_open_;
 }
 
 // Sets visibility explicitly.
-void ImGuiWindow::SetOpen(bool open)
-{
+void ImGuiWindow::SetOpen(bool open) {
     is_open_ = open;
 }
 
 // Returns current visibility state.
-bool ImGuiWindow::IsOpen() const
-{
+bool ImGuiWindow::IsOpen() const {
     return is_open_;
 }
diff --git a/tools/shared/src/logging/logs_window.cpp b/tools/shared/src/logging/logs_window.cpp
index 10a593a..9667962 100644
--- a/tools/shared/src/logging/logs_window.cpp
+++ b/tools/shared/src/logging/logs_window.cpp
@@ -8,43 +8,43 @@
 
 namespace {
 
-struct LogColor {
-    float r = 1.0f;
-    float g = 1.0f;
-    float b = 1.0f;
-    float a = 1.0f;
-};
-
-struct LogRowViewModel {
-    uint64_t sequence = 0;
-    std::string timestamp;
-    std::string level_label;
-    std::string message;
-    LogColor level_color;
-};
-
-struct LogsInputState {
-    bool auto_scroll_enabled = true;
-    bool clear_requested = false;
-};
-
-struct LogsEffect {
-    bool clear_entries = false;
-};
-
-struct LogsViewModel {
-    size_t entry_count = 0;
-    std::vector<LogRowViewModel> rows;
-};
-
-struct LogsScreenResult {
-    LogsViewModel view_model;
-    LogsEffect effects;
-};
-
-// Maps logger level enum to a short on-screen label.
-const char* ToLevelLabel(VTX::Logger::Level level) {
-    switch (level) {
+    struct LogColor {
+        float r = 1.0f;
+        float g = 1.0f;
+        float b = 1.0f;
+        float a = 1.0f;
+    };
+
+    struct LogRowViewModel {
+        uint64_t sequence = 0;
+        std::string timestamp;
+        std::string level_label;
+        std::string message;
+        LogColor level_color;
+    };
+
+    struct LogsInputState {
+        bool auto_scroll_enabled = true;
+        bool clear_requested = false;
+    };
+
+    struct LogsEffect {
+        bool clear_entries = false;
+    };
+
+    struct LogsViewModel {
+        size_t entry_count = 0;
+        std::vector<LogRowViewModel> rows;
+    };
+
+    struct LogsScreenResult {
+        LogsViewModel view_model;
+        LogsEffect effects;
+    };
+
+    // Maps logger level enum to a short on-screen label.
+    const char* ToLevelLabel(VTX::Logger::Level level) {
+        switch (level) {
         case VTX::Logger::Level::Info:
             return "Info";
         case VTX::Logger::Level::Warning:
@@ -55,55 +55,55 @@ const char* ToLevelLabel(VTX::Logger::Level level) {
             return "Debug";
         default:
             return "Unknown";
+        }
     }
-}
 
-// Maps logger level enum to the row color used in the log panel.
-LogColor ToLevelColor(VTX::Logger::Level level) {
-    switch (level) {
+    // Maps logger level enum to the row color used in the log panel.
+    LogColor ToLevelColor(VTX::Logger::Level level) {
+        switch (level) {
         case VTX::Logger::Level::Info:
-            return LogColor{0.55f, 0.80f, 1.00f, 1.00f};
+            return LogColor {0.55f, 0.80f, 1.00f, 1.00f};
         case VTX::Logger::Level::Warning:
-            return LogColor{1.00f, 0.80f, 0.35f, 1.00f};
+            return LogColor {1.00f, 0.80f, 0.35f, 1.00f};
         case VTX::Logger::Level::Error:
-            return LogColor{1.00f, 0.45f, 0.45f, 1.00f};
+            return LogColor {1.00f, 0.45f, 0.45f, 1.00f};
         case VTX::Logger::Level::Debug:
-            return LogColor{0.60f, 0.95f, 0.95f, 1.00f};
+            return LogColor {0.60f, 0.95f, 0.95f, 1.00f};
         default:
-            return LogColor{};
+            return LogColor {};
+        }
     }
-}
 
-// Converts raw log entries into view-model rows for rendering.
-std::vector<LogRowViewModel> BuildLogRows(const std::vector<VtxLogEntry>& entries) {
-    std::vector<LogRowViewModel> rows;
-    rows.reserve(entries.size());
-    for (const auto& entry : entries) {
-        rows.push_back(LogRowViewModel{
-            .sequence = entry.sequence,
-            .timestamp = entry.timestamp,
-            .level_label = ToLevelLabel(entry.level),
-            .message = entry.message,
-            .level_color = ToLevelColor(entry.level),
-        });
+    // Converts raw log entries into view-model rows for rendering.
+    std::vector<LogRowViewModel> BuildLogRows(const std::vector<VtxLogEntry>& entries) {
+        std::vector<LogRowViewModel> rows;
+        rows.reserve(entries.size());
+        for (const auto& entry : entries) {
+            rows.push_back(LogRowViewModel {
+                .sequence = entry.sequence,
+                .timestamp = entry.timestamp,
+                .level_label = ToLevelLabel(entry.level),
+                .message = entry.message,
+                .level_color = ToLevelColor(entry.level),
+            });
+        }
+        return rows;
     }
-    return rows;
-}
 
-// Computes render data and side effects from current logs + UI input.
-LogsScreenResult BuildLogScreen(const std::vector<VtxLogEntry>& entries, const LogsInputState& input) {
-    LogsScreenResult result;
-    result.effects.clear_entries = input.clear_requested;
+    // Computes render data and side effects from current logs + UI input.
+    LogsScreenResult BuildLogScreen(const std::vector<VtxLogEntry>& entries, const LogsInputState& input) {
+        LogsScreenResult result;
+        result.effects.clear_entries = input.clear_requested;
+
+        if (input.clear_requested) {
+            return result;
+        }
 
-    if (input.clear_requested) {
+        result.view_model.rows = BuildLogRows(entries);
+        result.view_model.entry_count = result.view_model.rows.size();
         return result;
     }
 
-    result.view_model.rows = BuildLogRows(entries);
-    result.view_model.entry_count = result.view_model.rows.size();
-    return result;
-}
-
 } // namespace
 
 // Creates the logs window and applies non-focus-stealing behavior.
@@ -122,12 +122,10 @@ void LogsWindow::DrawContent() {
     ImGui::Checkbox("Auto-scroll", &auto_scroll_);
 
     const bool was_scrolled_to_bottom = ImGui::GetScrollY() >= ImGui::GetScrollMaxY() - 20.0f;
-    const auto screen = BuildLogScreen(
-        logs,
-        LogsInputState{
-            .auto_scroll_enabled = auto_scroll_,
-            .clear_requested = clear_requested,
-        });
+    const auto screen = BuildLogScreen(logs, LogsInputState {
+                                                 .auto_scroll_enabled = auto_scroll_,
+                                                 .clear_requested = clear_requested,
+                                             });
 
     ImGui::SameLine();
     ImGui::TextDisabled("%zu entries", screen.view_model.entry_count);
@@ -145,10 +143,8 @@ void LogsWindow::DrawContent() {
             ImGui::SameLine();
             ImGui::TextDisabled("[%s]", row.timestamp.c_str());
             ImGui::SameLine();
-            ImGui::TextColored(
-                ImVec4(row.level_color.r, row.level_color.g, row.level_color.b, row.level_color.a),
-                "[%s]",
-                row.level_label.c_str());
+            ImGui::TextColored(ImVec4(row.level_color.r, row.level_color.g, row.level_color.b, row.level_color.a),
+                               "[%s]", row.level_label.c_str());
             ImGui::SameLine();
             ImGui::TextWrapped("%s", row.message.c_str());
         }
diff --git a/tools/shared/src/session/vtx_session_base.cpp b/tools/shared/src/session/vtx_session_base.cpp
index 90fbef8..2801110 100644
--- a/tools/shared/src/session/vtx_session_base.cpp
+++ b/tools/shared/src/session/vtx_session_base.cpp
@@ -3,9 +3,7 @@
 #include <vector>
 
 VtxSessionBase::VtxSessionBase() {
-    logger_sink_id_ = VTX::Logger::Instance().AddSink([this](const VTX::Logger::Entry& entry) {
-        AppendLog(entry);
-    });
+    logger_sink_id_ = VTX::Logger::Instance().AddSink([this](const VTX::Logger::Entry& entry) { AppendLog(entry); });
 
     AddGuiInfoLog("Log sink connected to VTX::Logger.");
 }
@@ -67,12 +65,7 @@ std::vector<std::string> VtxSessionBase::GetRecentFilesSnapshot() const {
 void VtxSessionBase::AppendLog(const VTX::Logger::Entry& entry) {
     std::lock_guard<std::mutex> lock(logs_mutex_);
 
-    logs_.push_back(VtxLogEntry{
-        next_log_sequence_++,
-        entry.level,
-        entry.timestamp,
-        entry.message
-    });
+    logs_.push_back(VtxLogEntry {next_log_sequence_++, entry.level, entry.timestamp, entry.message});
 
     while (logs_.size() > kMaxLogEntries) {
         logs_.pop_front();