struct-frame 0.10.7__tar.gz → 0.10.9__tar.gz

{struct_frame-0.10.7 → struct_frame-0.10.9}/CHANGELOG.md

@@ -6,9 +6,21 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 <!-- insertion marker -->
-## [0.10.7](https://github.com/mylonics/struct-frame/releases/tag/0.10.7) - 2026-09-01
+## [0.10.9](https://github.com/mylonics/struct-frame/releases/tag/0.10.9) - 2026-10-07
 
-<small>[Compare with v0.10.6](https://github.com/mylonics/struct-frame/compare/v0.10.6...0.10.7)</small>
+<small>[Compare with v0.10.8](https://github.com/mylonics/struct-frame/compare/v0.10.8...0.10.9)</small>
+
+## [v0.10.8](https://github.com/mylonics/struct-frame/releases/tag/v0.10.8) - 2026-09-08
+
+<small>[Compare with v0.10.7](https://github.com/mylonics/struct-frame/compare/v0.10.7...v0.10.8)</small>
+
+### Fixed
+
+- fixing_one_of_with_default (#370) ([c3b44ff](https://github.com/mylonics/struct-frame/commit/c3b44ff403ad5c83acbc21c185ea9e286d331ab0) by Rijesh Augustine).
+
+## [v0.10.7](https://github.com/mylonics/struct-frame/releases/tag/v0.10.7) - 2026-09-01
+
+<small>[Compare with v0.10.6](https://github.com/mylonics/struct-frame/compare/v0.10.6...v0.10.7)</small>
 
 ### Fixed
 

{struct_frame-0.10.7 → struct_frame-0.10.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: struct-frame
-Version: 0.10.7
+Version: 0.10.9
 Summary: A framework for serializing data with headers
 Project-URL: Homepage, https://github.com/mylonics/struct-frame
 Project-URL: Issues, https://github.com/mylonics/struct-frame/issues

{struct_frame-0.10.7 → struct_frame-0.10.9}/docs/src/content/docs/extended-features/cpp-sdk.md

@@ -169,5 +169,35 @@ ProfileSensorWriter sensor_writer(buffer, sizeof(buffer));
 ProfileSensorAccumulatingReader sensor_reader(get_message_info);
 ```
 
-See [Framing Details](/basic-usage/framing-details/) for more profiles.
+### Contiguous buffer overloads
+
+The C++ APIs retain their pointer-and-length overloads and also accept any
+contiguous buffer exposing `data()` and `size()`. This includes
+`std::array`, `std::span`, `etl::array`, and `etl::span` when those libraries
+are available:
+
+```cpp
+#include <array>
+#include <span>
+
+std::array<uint8_t, 1024> storage{};
+auto encoded = FrameEncoderWithCrc<ProfileStandardConfig>::encode(storage, msg);
+
+std::span<const uint8_t> frame(storage.data(), encoded);
+auto parsed = BufferParserWithCrc<ProfileStandardConfig>::parse(frame, get_message_info);
 
+BasicTypesMessage decoded{};
+decoded.deserialize(frame.subspan(parsed.msg_data - frame.data(), parsed.msg_len));
+
+ProfileStandardWriter writer(storage);
+writer.write(msg);
+ProfileStandardReader reader(frame, get_message_info);
+```
+
+The same overloads are available on generated message `serialize`/`deserialize`,
+`BufferWriter`, `BufferReader`, `AccumulatingReader::add_data`, frame checksum
+helpers, SDK `Feed`/`SendRaw`, and transport `Send`. These overloads do not
+allocate or change the existing raw-pointer APIs, so ETL containers and views
+can be used without conversions.
+
+See [Framing Details](/basic-usage/framing-details/) for more profiles.

{struct_frame-0.10.7 → struct_frame-0.10.9}/docs/src/content/docs/reference/test-coverage.md

@@ -115,9 +115,15 @@ Test file: `ComprehensiveArrayMessage` in `tests/proto/test_messages.sf`
 | `oneof` with `discriminator = none` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Multiple `oneof` fields in one message | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Envelope messages (`is_envelope`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Discriminator (not declaration order) selects the serialized union payload | N/A | N/A | N/A | N/A | N/A | ✅ | N/A |
+| `oneof` with `option variable = true` decoded in both the wire layout and the minimal-profile fixed layout | N/A | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 > **All gaps closed.** `discriminator = none` and multi-oneof encode/decode tested in all 7 languages: Python via `tests/test_proto_field_types.py`; C and C++ via compiled binaries in the same file; TS/JS via `checkDiscriminatorNone()`/`checkMultiOneof()` in their standard test helpers; C# via `CheckDiscriminatorNone()`/`CheckMultiOneof()` in `tests/csharp/include/StandardMessages.cs`; Rust via the `test_oneof_special` runner in `tests/rust/src/main.rs`. A standalone `test_oneof_special.*` runner (same scenarios: `NoneDiscriminatorMessage`, `MultiOneofMessage`) now also exists for C++, Python, TS, JS, and C# alongside Rust's; C is N/A (no generated oneof accessors).
 
+> **Payload selection.** Only C# can hold more than one union member at once -- they are separate nullable properties, and a variant whose type carries schema defaults is constructed eagerly -- so only there can serialization pick the wrong one. `DefaultedOneofEnvelope` in `tests/csharp/test_oneof_special.cs` covers all three C# serialization paths (fixed/MAX_SIZE, `SerializeTo` into a reused buffer, and both variable-length forms). Elsewhere the union is a single storage location (C/C++/Rust union, TS/JS payload buffer, Python `_which` key), so there is no non-active member to pick by mistake.
+
+> **Variable oneof decode.** A `oneof` with `option variable = true` puts a uint16 length prefix in front of the union payload that the fixed (MAX_SIZE) layout does not have, so its largest variant produces a wire frame exactly MAX_SIZE bytes long — the same length as the fixed layout a minimal profile (no length field) sends. Only the framing profile can tell the two layouts apart, so the auto decode path resolves that length as the fixed layout and a max-length wire frame is decoded explicitly (`mode="wire"` in TS/JS, `DeserializeVariable()` in C#, `_deserialize_variable()` in Python). Each `test_oneof_special` runner round-trips `VariableOneofMessage` in the wire layout at that exact length plus the minimal-profile fixed layout through the auto path. C is N/A: it already skips the length check for every message with a oneof, and has no generated oneof accessors to test with.
+
 ### 2.7 Message Options
 
 | Option | C | C++ | Python | TS | JS | C# | Rust |

{struct_frame-0.10.7 → struct_frame-0.10.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "struct-frame"
-version = "0.10.7"
+version = "0.10.9"
 authors = [
   { name="Rijesh Augustine", email="rijesh@mylonics.com" },
 ]

{struct_frame-0.10.7 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/frame_base.hpp

@@ -48,6 +48,15 @@ inline FrameChecksum fletcher_checksum(const uint8_t* data, size_t length, uint8
   return ck;
 }
 
+template <typename Buffer>
+  requires requires(const Buffer& buffer) {
+    buffer.data();
+    buffer.size();
+  }
+inline FrameChecksum fletcher_checksum(const Buffer& data, uint8_t magic1 = 0, uint8_t magic2 = 0) {
+  return fletcher_checksum(data.data(), data.size(), magic1, magic2);
+}
+
 // Extension-aware Fletcher-16 checksum.
 // Computes: Fletcher(data[0..base_len]) → mix magic1/magic2 → Fletcher(data[base_len..total_len]).
 // When base_len == total_len the result is identical to fletcher_checksum.
@@ -58,6 +67,7 @@ inline FrameChecksum fletcher_checksum_ext(const uint8_t* data, size_t base_len,
     ck.byte1 = static_cast<uint8_t>(ck.byte1 + data[i]);
     ck.byte2 = static_cast<uint8_t>(ck.byte2 + ck.byte1);
   }
+
   ck.byte1 = static_cast<uint8_t>(ck.byte1 + magic1);
   ck.byte2 = static_cast<uint8_t>(ck.byte2 + ck.byte1);
   ck.byte1 = static_cast<uint8_t>(ck.byte1 + magic2);
@@ -69,6 +79,16 @@ inline FrameChecksum fletcher_checksum_ext(const uint8_t* data, size_t base_len,
   return ck;
 }
 
+template <typename Buffer>
+  requires requires(const Buffer& buffer) {
+    buffer.data();
+    buffer.size();
+  }
+inline FrameChecksum fletcher_checksum_ext(const Buffer& data, size_t base_len, uint8_t magic1 = 0,
+                                           uint8_t magic2 = 0) {
+  return fletcher_checksum_ext(data.data(), base_len, data.size(), magic1, magic2);
+}
+
 // Parse result status.
 //
 // Buffer parsers (BufferParserWithCrc/BufferParserMinimal) report on failure:

{struct_frame-0.10.7 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/frame_profiles.hpp

@@ -192,6 +192,11 @@ class FrameEncoderWithCrc {
 
     return idx;
   }
+
+  template <typename Buffer, FramedMessage T>
+  static size_t encode(Buffer& buffer, const T& msg, uint8_t seq = 0, uint8_t sys_id = 0, uint8_t comp_id = 0) {
+    return encode(buffer.data(), buffer.size(), msg, seq, sys_id, comp_id);
+  }
 };
 
 /**
@@ -248,6 +253,11 @@ class FrameEncoderMinimal {
 
     return idx;
   }
+
+  template <typename Buffer, FramedMessage T>
+  static size_t encode(Buffer& buffer, const T& msg) {
+    return encode(buffer.data(), buffer.size(), msg);
+  }
 };
 
 /**
@@ -358,6 +368,11 @@ class BufferParserWithCrc {
     return FrameMsgInfo(true, msg_id, msg_len, total_size,
                         buffer + Config::header_size, buffer);
   }
+
+  template <typename Buffer, typename GetMessageInfoFn = std::nullptr_t>
+  static FrameMsgInfo parse(const Buffer& buffer, GetMessageInfoFn get_message_info = nullptr) {
+    return parse(buffer.data(), buffer.size(), get_message_info);
+  }
 };
 
 /**
@@ -433,6 +448,11 @@ class BufferParserMinimal {
     r.status = FrameMsgStatus::WaitingForStart;
     return r;
   }
+
+  template <typename Buffer, typename GetMessageInfoFn = std::nullptr_t>
+  static FrameMsgInfo parse(const Buffer& buffer, GetMessageInfoFn get_message_info = nullptr) {
+    return parse(buffer.data(), buffer.size(), get_message_info);
+  }
 };
 
 /*===========================================================================
@@ -493,6 +513,13 @@ class BufferReader {
   BufferReader(const uint8_t* buffer, size_t size, GetMessageInfoFn get_message_info)
       : buffer_(buffer), size_(size), offset_(0), get_message_info_(get_message_info) {}
 
+  template <typename Buffer>
+  explicit BufferReader(const Buffer& buffer) : BufferReader(buffer.data(), buffer.size()) {}
+
+  template <typename Buffer>
+  BufferReader(const Buffer& buffer, GetMessageInfoFn get_message_info)
+      : BufferReader(buffer.data(), buffer.size(), get_message_info) {}
+
   /**
    * Parse the next frame in the buffer.
    * Returns FrameMsgInfo with valid=true if successful, valid=false if no more frames.
@@ -603,6 +630,9 @@ class BufferWriter {
  public:
   BufferWriter(uint8_t* buffer, size_t capacity) : buffer_(buffer), capacity_(capacity), offset_(0) {}
 
+  template <typename Buffer>
+  explicit BufferWriter(Buffer& buffer) : BufferWriter(buffer.data(), buffer.size()) {}
+
   /**
    * Write a message to the buffer.
    * Returns the number of bytes written, or 0 on failure.
@@ -803,6 +833,11 @@ class AccumulatingReader {
     }
   }
 
+  template <typename Buffer>
+  void add_data(const Buffer& buffer) {
+    add_data(buffer.data(), buffer.size());
+  }
+
   /**
    * Parse the next frame (buffer mode).
    * Returns FrameMsgInfo with valid=true if successful, valid=false if no more complete frames.

{struct_frame-0.10.7 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/struct_frame_sdk/struct_frame_sdk.hpp

@@ -355,6 +355,11 @@ class StructFrameSdkT : public IStructFrameSdk {
     ParseBuffer();
   }
 
+  template <typename Buffer>
+  void Feed(const Buffer& data) {
+    Feed(data.data(), data.size());
+  }
+
   // -----------------------------------------------------------------------
   // Send
   // -----------------------------------------------------------------------
@@ -405,6 +410,11 @@ class StructFrameSdkT : public IStructFrameSdk {
     return SendResult{written == framedLen, framedLen, written};
   }
 
+  template <typename Buffer>
+  SendResult SendRaw(uint16_t msgId, const Buffer& data) {
+    return SendRaw(msgId, data.data(), data.size());
+  }
+
   /**
    * Forward a parsed FrameMsgInfo through this SDK's transport.
    *

{struct_frame-0.10.7 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/struct_frame_sdk/transport.hpp

@@ -128,6 +128,9 @@ public:
      * @return Number of bytes sent.
      */
     size_t Send(const uint8_t*, size_t) { return 0; }
+
+    template <typename Buffer>
+    size_t Send(const Buffer& data) { return Send(data.data(), data.size()); }
 };
 
 } // namespace sdk

{struct_frame-0.10.7 → struct_frame-0.10.9}/src/struct_frame/cpp_gen.py

@@ -615,6 +615,10 @@ class MessageCppGen():
         
         result += f'        return offset;\n'
         result += f'    }}\n'
+        result += f'\n    template <typename Buffer>\n'
+        result += f'    size_t serialize(Buffer& buffer) const {{\n'
+        result += f'        return serialize(buffer.data());\n'
+        result += f'    }}\n'
         
         # Generate _deserialize_variable method (was unpack_variable, now private)
         result += f'\n    /**\n'
@@ -784,6 +788,10 @@ class MessageCppGen():
         result += f'    size_t deserialize(const structframe::FrameMsgInfo& frame_info) {{\n'
         result += f'        return deserialize(frame_info.msg_data, frame_info.msg_len);\n'
         result += f'    }}\n'
+        result += f'\n    template <typename Buffer>\n'
+        result += f'    size_t deserialize(const Buffer& buffer) {{\n'
+        result += f'        return deserialize(buffer.data(), buffer.size());\n'
+        result += f'    }}\n'
         
         # Add serialize method for non-variable messages (simple case)
         if not msg.variable:
@@ -796,6 +804,10 @@ class MessageCppGen():
             result += f'        std::memcpy(buffer, this, MAX_SIZE);\n'
             result += f'        return MAX_SIZE;\n'
             result += f'    }}\n'
+            result += f'\n    template <typename Buffer>\n'
+            result += f'    size_t serialize(Buffer& buffer) const {{\n'
+            result += f'        return serialize(buffer.data());\n'
+            result += f'    }}\n'
         
         return result
 

{struct_frame-0.10.7 → struct_frame-0.10.9}/src/struct_frame/csharp_gen.py

@@ -71,6 +71,79 @@ def _csharp_scalar_default_literal(field, base_type):
     return f"{field.default}"
 
 
+def _oneof_payload_cases(oneof):
+    """Return ``(discriminator_value, field_name, field)`` for each union variant.
+
+    Variants repeating a discriminator value already emitted are dropped so the
+    generated ``switch`` can never carry duplicate case labels (first wins --
+    which is what the old declaration-order chain did for such a schema too).
+    """
+    cases = []
+    seen = set()
+    for disc_val, field_name, _field_size in oneof.variant_info:
+        if disc_val in seen:
+            continue
+        seen.add(disc_val)
+        cases.append((disc_val, field_name, oneof.fields[field_name]))
+    return cases
+
+
+def _oneof_payload_switch(oneof, oneof_name, indent, target_offset, clear_span=None):
+    """Generate the union-payload write as a ``switch`` on the discriminator.
+
+    The discriminator -- not property nullability or declaration order -- decides
+    which union member is serialized. Members of the other variants may well be
+    non-null (a nested type carrying schema defaults is constructed eagerly, and
+    a reused message object keeps whatever was assigned before), so picking the
+    first non-null property would happily write variant A's bytes underneath
+    variant B's discriminator.
+
+    Args:
+        oneof: the oneof model (must have a discriminator).
+        oneof_name: the oneof's schema name, source of the property name.
+        indent: leading whitespace for the emitted ``switch``.
+        target_offset: C# expression for where the payload starts in ``buffer``.
+        clear_span: optional C# span expression covering the union bytes. When
+            given, that range is zeroed before the ``switch`` runs, so a
+            caller-supplied buffer cannot leak stale bytes into the frame when
+            the selected member is null or a shorter variant follows a longer
+            one.
+    """
+    oneof_pascal = pascal_case(oneof_name)
+    body = ''
+    if clear_span:
+        body += f'{indent}// Clear the full union span first: the selected member may be null\n'
+        body += f'{indent}// or shorter than a variant previously written into this buffer.\n'
+        body += f'{indent}{clear_span}.Clear();\n'
+    body += f'{indent}switch ((int){oneof_pascal}Discriminator)\n'
+    body += indent + '{\n'
+    for disc_val, field_name, _field in _oneof_payload_cases(oneof):
+        field_var = pascal_case(field_name)
+        body += f'{indent}    case {disc_val}:  // {field_name}\n'
+        body += f'{indent}        if ({field_var} != null) {field_var}.SerializeTo(buffer, {target_offset});\n'
+        body += f'{indent}        break;\n'
+    body += indent + '}\n'
+    return body
+
+
+def _oneof_payload_declaration_order(oneof, indent, target_offset):
+    """Union write for ``discriminator = none`` oneofs.
+
+    Nothing on the wire identifies the active variant, so the first non-null
+    member wins -- the application is responsible for keeping exactly one set.
+    """
+    body = ''
+    first = True
+    for field_name, _field in oneof.fields.items():
+        field_var = pascal_case(field_name)
+        body += f'{indent}{"if" if first else "else if"} ({field_var} != null)\n'
+        first = False
+        body += indent + '{\n'
+        body += f'{indent}    {field_var}.SerializeTo(buffer, {target_offset});\n'
+        body += indent + '}\n'
+    return body
+
+
 def format_xml_summary(comments, indent='    ', fallback=None):
     """
     Format multi-line comments into a single XML summary block.
@@ -705,49 +778,109 @@ class MessageCSharpGen():
                     offset += 1
             
             result += f'            // Oneof {oneof_name} payload (union size: {oneof.size})\n'
-            first = True
-            for field_name, field in oneof.fields.items():
-                type_name = field.field_type
-                field_var = pascal_case(field_name)
-                if first:
-                    result += f'            if ({field_var} != null)\n'
-                    first = False
-                else:
-                    result += f'            else if ({field_var} != null)\n'
-                result += '            {\n'
-                result += f'                {field_var}.SerializeTo(buffer, offset + {offset});\n'
-                result += '            }\n'
+            if oneof.discriminator_type is not None:
+                # SerializeTo writes into a caller-owned buffer, so the union
+                # bytes are zeroed when no payload is written -- otherwise a
+                # reused buffer would keep a previous message's variant bytes.
+                result += _oneof_payload_switch(
+                    oneof, oneof_name, '            ', f'offset + {offset}',
+                    clear_span=f'buffer.AsSpan(offset + {offset}, {oneof.size})')
+            else:
+                result += _oneof_payload_declaration_order(
+                    oneof, '            ', f'offset + {offset}')
             offset += oneof.size
 
         result += f'            return MaxSize;\n'
         result += '        }\n'
 
+        # A variable-length oneof puts a uint16 length prefix in front of the
+        # union payload that the MAX_SIZE layout does not have, so once the
+        # largest variant is active the two encodings are different byte
+        # layouts of the same length. The layout cannot be derived from the
+        # schema or from the payload length alone -- the profile that framed
+        # the payload decides it: length-bearing profiles always carry the
+        # wire form, while minimal profiles (HasLength == false) carry the
+        # fixed form produced by SerializeMaxSize().
+        #
+        # Deserialize() therefore keeps the length heuristic: a MaxSize
+        # payload is read with the fixed-layout decoder, anything else with
+        # the wire decoder. That is correct in the only ambiguous case
+        # (MaxSize bytes) whenever the sender was a minimal profile, and it
+        # keeps SerializeMaxSize() -> Deserialize() round-trips working for
+        # ProfileSensor/ProfileIPC. A caller holding a length-bearing
+        # profile's wire frame that happens to be exactly MaxSize bytes must
+        # pass an explicit layout -- DeserializeFixed()/DeserializeVariable()
+        # below -- just like the generated C struct reader does.
+        #
+        # Exception: a discriminator-less oneof (discriminator = none) has
+        # nothing on the fixed layout telling the reader which union member
+        # is active, so its MAX_SIZE read cannot populate the variant. Such
+        # a message is always read with the wire decoder, matching C, C++
+        # and Rust.
+        wire_only_variable_oneof = any(
+            o.variable and o.discriminator_type is None for o in msg.oneofs.values())
+
         # Generate Deserialize() static method
         result += '\n'
         result += '        /// <summary>\n'
         result += '        /// Deserialize a <c>ReadOnlySpan&lt;byte&gt;</c> into this message type.\n'
         result += '        /// This is the primary implementation - the <c>byte[]</c> and\n'
         result += '        /// <see cref="FrameMsgInfo"/> overloads delegate here.\n'
-        if msg.variable:
+        if msg.variable and wire_only_variable_oneof:
+            result += '        /// This message carries a variable-length oneof without a\n'
+            result += '        /// discriminator, which only the wire encoding records - so it\n'
+            result += '        /// is always read with the variable decoder, never the MAX_SIZE one.\n'
+        elif msg.variable and any(o.variable for o in msg.oneofs.values()):
+            result += '        /// For variable messages: auto-detects MAX_SIZE vs variable encoding.\n'
+            result += '        /// This message carries a variable-length oneof, whose wire form is\n'
+            result += '        /// exactly MaxSize bytes when the largest variant is active; a minimal\n'
+            result += '        /// profile (no length field) sends the fixed layout at that length, so\n'
+            result += '        /// the length check resolves it. A length-bearing profile frame of\n'
+            result += '        /// exactly MaxSize bytes needs an explicit layout: use\n'
+            result += '        /// <see cref="DeserializeVariable"/>.\n'
+        elif msg.variable:
             result += '        /// For variable messages: auto-detects MAX_SIZE vs variable encoding.\n'
         result += '        /// </summary>\n'
         result += f'        public static {structName} Deserialize(ReadOnlySpan<byte> data)\n'
         result += '        {\n'
-        
+
         # For variable messages, detect format based on size
         if msg.variable:
-            result += f'            // Variable message - detect encoding format\n'
-            result += f'            if (data.Length == MaxSize)\n'
-            result += '            {\n'
-            result += f'                // MAX_SIZE encoding (minimal profiles)\n'
-            result += f'                return _DeserializeMaxSize(data);\n'
-            result += '            }\n'
-            result += '            else\n'
-            result += '            {\n'
-            result += f'                // Variable-length encoding\n'
-            result += f'                return _DeserializeVariable(data);\n'
-            result += '            }\n'
+            if wire_only_variable_oneof:
+                result += f'            // Discriminator-less variable oneof - only the wire encoding\n'
+                result += f'            // records the active variant, so the fixed layout cannot be read.\n'
+                result += f'            return _DeserializeVariable(data);\n'
+            else:
+                result += f'            // Variable message - detect encoding format\n'
+                result += f'            if (data.Length == MaxSize)\n'
+                result += '            {\n'
+                result += f'                // MAX_SIZE encoding (minimal profiles)\n'
+                result += f'                return _DeserializeMaxSize(data);\n'
+                result += '            }\n'
+                result += '            else\n'
+                result += '            {\n'
+                result += f'                // Variable-length encoding\n'
+                result += f'                return _DeserializeVariable(data);\n'
+                result += '            }\n'
             result += '        }\n'
+
+            # Public explicit-layout decode entry points. The length heuristic
+            # in Deserialize() resolves the ambiguous MaxSize case as the fixed
+            # (minimal profile) layout; a caller holding a length-bearing
+            # profile's wire frame of exactly MaxSize bytes uses
+            # DeserializeVariable() instead.
+            result += '\n'
+            result += '        /// <summary>\n'
+            result += '        /// Deserialize a fixed-layout (MAX_SIZE) payload, as produced by\n'
+            result += '        /// <see cref="SerializeMaxSize"/> for minimal profiles (no length field).\n'
+            result += '        /// </summary>\n'
+            result += f'        public static {structName} DeserializeFixed(ReadOnlySpan<byte> data) => _DeserializeMaxSize(data);\n'
+            result += '\n'
+            result += '        /// <summary>\n'
+            result += '        /// Deserialize a variable-length (wire) payload, as produced by\n'
+            result += '        /// <see cref="Serialize"/> on length-bearing profiles.\n'
+            result += '        /// </summary>\n'
+            result += f'        public static {structName} DeserializeVariable(ReadOnlySpan<byte> data) => _DeserializeVariable(data);\n'
             
             # Add _DeserializeMaxSize for variable messages
             result += '\n'
@@ -1086,22 +1219,26 @@ class MessageCSharpGen():
                 else:  # field_order
                     result += f'            buffer[offset++] = (byte){oneof_pascal}Discriminator;\n'
             if oneof.variable:
+                # The discriminator picks the variant; the length prefix and the
+                # offset advance must match SerializedSize() for every value it
+                # can hold, including one whose union member was left null.
                 result += f'            // Oneof {oneof_name} variable-length union payload\n'
-                for disc_val, field_name, field_size in oneof.variant_info:
+                result += f'            switch ((int){oneof_pascal}Discriminator)\n'
+                result += '            {\n'
+                for disc_val, field_name, field in _oneof_payload_cases(oneof):
                     field_var = pascal_case(field_name)
-                    effective_size = max(field_size, oneof.min_size_override) if oneof.min_size_override else field_size
-                    result += f'            if ((int){oneof_pascal}Discriminator == {disc_val} && {field_var} != null)\n'
-                    result += f'            {{\n'
-                    result += f'                BinaryPrimitives.WriteUInt16LittleEndian(buffer.AsSpan(offset, 2), (ushort){effective_size});\n'
-                    result += f'                offset += 2;\n'
-                    result += f'                {field_var}.SerializeTo(buffer, offset);\n'
-                    result += f'                offset += {effective_size};\n'
-                    result += f'            }}\n'
-                result += f'            else if ({oneof_pascal}Discriminator == 0 || ({" && ".join(f"(int){oneof_pascal}Discriminator != {dv}" for dv, _, _ in oneof.variant_info)}))\n'
-                result += f'            {{\n'
-                result += f'                // Unknown or NONE discriminator: write 0-length payload\n'
-                result += f'                BinaryPrimitives.WriteUInt16LittleEndian(buffer.AsSpan(offset, 2), 0); offset += 2;\n'
-                result += f'            }}\n'
+                    effective_size = max(field.size, oneof.min_size_override) if oneof.min_size_override else field.size
+                    result += f'                case {disc_val}:  // {field_name}\n'
+                    result += f'                    BinaryPrimitives.WriteUInt16LittleEndian(buffer.AsSpan(offset, 2), (ushort){effective_size});\n'
+                    result += f'                    offset += 2;\n'
+                    result += f'                    if ({field_var} != null) {field_var}.SerializeTo(buffer, offset);\n'
+                    result += f'                    offset += {effective_size};\n'
+                    result += f'                    break;\n'
+                result += '                default:\n'
+                result += '                    // Unknown or NONE discriminator: write 0-length payload\n'
+                result += '                    BinaryPrimitives.WriteUInt16LittleEndian(buffer.AsSpan(offset, 2), 0); offset += 2;\n'
+                result += '                    break;\n'
+                result += '            }\n'
             elif oneof.discriminator_type is not None:
                 _trim_label = f'trimmed union (min_size={oneof.min_size_override})' if oneof.min_size_override else 'trimmed union'
                 result += f'            // Oneof {oneof_name} {_trim_label}\n'
@@ -1111,32 +1248,14 @@ class MessageCSharpGen():
                     result += f'                if ((int){oneof_pascal}Discriminator == {disc_val}) _{oneof_name}_tlen = {field_size};\n'
                 if oneof.min_size_override:
                     result += f'                if (_{oneof_name}_tlen < {oneof.min_size_override}) _{oneof_name}_tlen = {oneof.min_size_override};\n'
-                first = True
-                for field_name, field in oneof.fields.items():
-                    field_var = pascal_case(field_name)
-                    if first:
-                        result += f'                if ({field_var} != null)\n'
-                        first = False
-                    else:
-                        result += f'                else if ({field_var} != null)\n'
-                    result += '                {\n'
-                    result += f'                    {field_var}.SerializeTo(buffer, offset);\n'
-                    result += '                }\n'
+                # The buffer is freshly allocated (and therefore zeroed) here, so
+                # an unset variant needs no explicit clear.
+                result += _oneof_payload_switch(oneof, oneof_name, '                ', 'offset')
                 result += f'                offset += _{oneof_name}_tlen;\n'
                 result += f'            }}\n'
             else:
                 result += f'            // Oneof {oneof_name} union payload\n'
-                first = True
-                for field_name, field in oneof.fields.items():
-                    field_var = pascal_case(field_name)
-                    if first:
-                        result += f'            if ({field_var} != null)\n'
-                        first = False
-                    else:
-                        result += f'            else if ({field_var} != null)\n'
-                    result += '            {\n'
-                    result += f'                {field_var}.SerializeTo(buffer, offset);\n'
-                    result += '            }\n'
+                result += _oneof_payload_declaration_order(oneof, '            ', 'offset')
                 result += f'            offset += {oneof.size};\n'
         
         result += '            return buffer;\n'