Replace WeightEntry raw ptr+count with a local FloatView

Introduce a KataGo-local non-owning FloatView for WeightEntry::data instead
of a raw const float*/size_t pair; convert to MILBlob::Util::Span only inside
WeightSerializer, keeping the MILBlob dependency out of Operations.hpp.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ChinChangYang

cpp/external/katagocoreml/src/builder/Operations.cpp

@@ -17,8 +17,7 @@ std::string KataGoOps::registerWeight(const std::string& name,
                                        const std::vector<int64_t>& shape) {
     WeightEntry entry;
     entry.name = name;
-    entry.data = data.data();
-    entry.count = data.size();
+    entry.data = FloatView{data.data(), data.size()};
     entry.shape = shape;
     entry.blob_offset = 0;
     m_weights.push_back(std::move(entry));
@@ -32,8 +31,7 @@ std::string KataGoOps::registerOwnedWeight(const std::string& name,
     const std::vector<float>& stored = m_owned.back();
     WeightEntry entry;
     entry.name = name;
-    entry.data = stored.data();
-    entry.count = stored.size();
+    entry.data = FloatView{stored.data(), stored.size()};
     entry.shape = shape;
     entry.blob_offset = 0;
     m_weights.push_back(std::move(entry));

cpp/external/katagocoreml/src/builder/Operations.hpp

@@ -11,12 +11,23 @@
 
 namespace katagocoreml {
 
-/// Weight entry for blob file storage. `data`/`count` are a NON-OWNING view into
-/// the live KataGoModelDesc (or into KataGoOps::m_owned for derived tensors).
+/// Minimal non-owning view over a contiguous float buffer. KataGo-local on
+/// purpose: keeps the MILBlob dependency out of this header (conversion to
+/// MILBlob::Util::Span happens only at the serializer boundary).
+struct FloatView {
+    const float* ptr = nullptr;
+    size_t len = 0;
+    const float* data() const { return ptr; }
+    size_t size() const { return len; }
+    bool empty() const { return len == 0; }
+    float operator[](size_t i) const { return ptr[i]; }
+};
+
+/// Weight entry for blob file storage. `data` is a NON-OWNING view into the live
+/// KataGoModelDesc (or into KataGoOps::m_owned for derived tensors).
 struct WeightEntry {
     std::string name;
-    const float* data = nullptr;
-    size_t count = 0;
+    FloatView data;            // non-owning view (replaces raw ptr + count)
     std::vector<int64_t> shape;
     uint64_t blob_offset = 0;  // Set during serialization
 };

cpp/external/katagocoreml/src/serializer/WeightSerializer.cpp

@@ -15,20 +15,21 @@ size_t WeightSerializer::serialize(std::vector<WeightEntry>& weights,
     size_t total_bytes = 0;
 
     for (auto& entry : weights) {
+        const size_t count = entry.data.size();
         if (use_fp16) {
             // Convert FP32 weights to FP16
-            std::vector<MILBlob::Fp16> fp16_data(entry.count);
-            for (size_t i = 0; i < entry.count; ++i) {
+            std::vector<MILBlob::Fp16> fp16_data(count);
+            for (size_t i = 0; i < count; ++i) {
                 fp16_data[i] = MILBlob::Fp16::FromFloat(entry.data[i]);
             }
             MILBlob::Util::Span<const MILBlob::Fp16> span(fp16_data.data(), fp16_data.size());
             entry.blob_offset = writer.WriteData(span);
-            total_bytes += entry.count * sizeof(MILBlob::Fp16);
+            total_bytes += count * sizeof(MILBlob::Fp16);
         } else {
-            // Write FP32 weights
-            MILBlob::Util::Span<const float> span(entry.data, entry.count);
+            // Write FP32 weights — convert the KataGo-local view to a MILBlob span here.
+            MILBlob::Util::Span<const float> span(entry.data.data(), count);
             entry.blob_offset = writer.WriteData(span);
-            total_bytes += entry.count * sizeof(float);
+            total_bytes += count * sizeof(float);
         }
     }