Table/YAML-driven refactor (Layer 1 start)

Move equipment capabilities and the E30 control state machine out of C++
code and into YAML data files; introduce a Router for SECS dispatch;
consolidate small files.

Behavioural changes: none.  Demo identical (15 SxFy transactions +
3 equipment-initiated primaries), 67 test cases / 384 assertions still
all green.  Structural changes only.

Why
---

The previous server.cpp held the equipment data dictionary (3 SVIDs,
2 ECIDs, 3 CEIDs, 2 alarms, 2 recipes, 4 host commands) as imperative
C++ in a 50-line `populate()` function, and routed inbound messages
through a 150-line if-ladder.  Adding a new SVID required a recompile.
Adding a new state transition required editing two switch statements
(`operator_*` and `on_host_request_*`).  The control state machine's
behavioural rules were spread across imperative code in two methods.

This is exactly what implementation_plan.md calls out as the wrong
shape: behavioural rules should live in versioned data, and every
runtime/test/analyzer should read from that data rather than re-encode
it.  This commit starts that move.

What's new
----------

data/equipment.yaml
  Equipment data dictionary.  Declarative SVIDs / ECIDs / CEIDs /
  alarms / recipes / host commands.  Host commands carry their HCACK
  ack code plus optional `emit_ceid` and `set_alarm` side-effects.
  Adding a new SVID or command is a YAML edit, no recompile.

data/control_state.yaml
  The E30 §6.2 control state transition table as data.  Each row is
  (from, on) -> (to [, then] [, ack]).  `then` chains an auto-advance
  through the transient AttemptOnline state.  The previous
  imperative switch is gone.

include/secsgem/config/loader.hpp + src/config/loader.cpp
  yaml-cpp-backed loader.  `load_control_state(path)` returns a
  ControlTransitionTable + initial state; `load_equipment(path, model)`
  populates the EquipmentDataModel and returns the device descriptor
  (id, MDLN, SOFTREV, optional auto-emit CEID).  Surfaces config
  errors with file path + field name via ConfigError.

include/secsgem/gem/router.hpp  (header-only)
  Small (stream, function) -> handler map.  Server registers all
  handlers once at startup, then the Connection's message handler is
  just `router.dispatch(msg)`.  Unhandled primaries with W set get
  SxF0 by default.  Replaces the if-ladder in secs_server.cpp.

include/secsgem/gem/control_state.hpp + .cpp
  ControlTransitionTable is the new pure data type.  ControlStateMachine
  is now a thin engine over the table: `fire(event)` looks up the row,
  optionally transitions, optionally chains a `then` transition, returns
  the ack code.  Behaviour rules no longer live in C++ switches.
  The default in-code table matches data/control_state.yaml row for row;
  tests rely on it so they don't need the YAML file.

include/secsgem/gem/data_model.hpp + .cpp
  `register_command(rcmd, CommandSpec)` replaces the function-handler
  signature.  CommandSpec = (HostCmdAck, optional emit_ceid, optional
  set_alarm).  `dispatch_command` returns a CommandResult so the server
  can fire the side-effects after S2F42 is sent.

apps/secs_server.cpp
  No populate(), no if-ladder.  Loads equipment.yaml + control_state.yaml
  at startup (clean error on bad config), wires the Router once,
  delegates dispatch.  Sm change handler reads emit_on_control_change
  from the YAML.  Welcome S10F3 removed for parity with config (a future
  YAML rule could re-introduce it declaratively).

tests/test_loader.cpp  (new)
  Verifies the YAML loader produces the same shape as the in-code
  default table, and that equipment.yaml populates every section
  (SVIDs/ECIDs/CEIDs/alarms/recipes/commands).  SECSGEM_DATA_DIR
  CMake define points at ${CMAKE_SOURCE_DIR}/data so tests don't
  depend on cwd.

CMakeLists.txt, Dockerfile
  find_package(yaml-cpp) and link.  libyaml-cpp-dev added to the
  Ubuntu base image (yaml-cpp 0.8 ships the modern target name).

File consolidation
------------------

Five small files removed; their content lives in fewer headers:

  - secs2/item.cpp        -> inline in secs2/item.hpp
  - secs2/message.cpp     -> inline in secs2/message.hpp
  - hsms/types.hpp        -> merged into hsms/header.hpp
  - hsms/frame.hpp        -> merged into hsms/header.hpp
  - hsms/frame.cpp        -> merged into hsms/header.cpp

hsms/header.hpp is now "the HSMS wire format" in one place: SType + status
enums + Timers + Header + Frame + constants.  All includers updated.

Net effect
----------

Before: equipment data dictionary lived in 50 lines of imperative
populate() inside secs_server.cpp; dispatch in a 20-branch if-ladder.

After: equipment data dictionary lives in 47 lines of YAML; dispatch
is a Router built once.  Adding a new capability is now a YAML edit
in the common case.

Test count up to 67 cases / 384 assertions (+4 cases / +106 assertions)
covering the loader and the new table-driven SM paths.

What's NOT changed
------------------

The per-SxFy reply construction still lives in C++ (each message has a
unique body shape).  Moving those into YAML/JSON message-shape
definitions is the next refactor step but requires a generic typed
encoder/decoder driven by shape descriptors; out of scope here.

Spooling, the S9 error stream, S1F19/F20, and the other gaps in
COMPLIANCE.md remain unchanged.

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

include/secsgem/config/loader.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+#include "secsgem/gem/control_state.hpp"
+#include "secsgem/gem/data_model.hpp"
+
+// YAML-driven loaders for the E30 control-state transition table and the
+// equipment data dictionary. Behaviour rules live in the YAML; this is the
+// parser that wires them into the runtime structures.
+namespace secsgem::config {
+
+class ConfigError : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+struct ControlStateConfig {
+  gem::ControlTransitionTable table;
+  gem::ControlState initial = gem::ControlState::HostOffline;
+};
+
+// Loads data/control_state.yaml.
+ControlStateConfig load_control_state(const std::string& yaml_path);
+
+struct EquipmentDescriptor {
+  uint16_t device_id = 0;
+  std::string model_name;
+  std::string software_rev;
+  std::optional<uint32_t> emit_on_control_change;
+};
+
+// Loads data/equipment.yaml into the given data model and returns the
+// equipment header (device id, MDLN, SOFTREV, optional auto-emit CEID).
+EquipmentDescriptor load_equipment(const std::string& yaml_path,
+                                   gem::EquipmentDataModel& model);
+
+}  // namespace secsgem::config

include/secsgem/endpoint.hpp

@@ -7,7 +7,7 @@
 #include <string>
 
 #include "secsgem/hsms/connection.hpp"
-#include "secsgem/hsms/types.hpp"
+#include "secsgem/hsms/header.hpp"
 
 namespace secsgem {
 

include/secsgem/gem/control_state.hpp

@@ -2,25 +2,25 @@
 
 #include <cstdint>
 #include <functional>
+#include <optional>
 #include <string>
+#include <vector>
 
 namespace secsgem::gem {
 
-// E30 Control State Model (§6.2). Drives whether the equipment is
-// communicating with a host and, if so, who is in control.
+// E30 §6.2 Control State Model.
 enum class ControlState {
-  EquipmentOffline,  // equipment is offline; no host comms attempted
-  AttemptOnline,     // transient: equipment trying to come online
-  HostOffline,       // HSMS up but host has not established control
-  OnlineLocal,       // online, operator in control; host observes only
-  OnlineRemote,      // online, host in control
+  EquipmentOffline,
+  AttemptOnline,
+  HostOffline,
+  OnlineLocal,
+  OnlineRemote,
 };
 
 const char* control_state_name(ControlState s);
+std::optional<ControlState> parse_control_state(const std::string& s);
 bool is_online(ControlState s);
 
-// What triggered a state change — surfaced to the on_change handler so the UI
-// or logs can show *why* the state moved.
 enum class ControlEvent {
   OperatorSwitchOnline,
   OperatorSwitchOffline,
@@ -28,72 +28,90 @@ enum class ControlEvent {
   OperatorSwitchRemote,
   AttemptComplete,
   AttemptFailed,
-  HostRequestOnline,    // S1F17
-  HostRequestOffline,   // S1F15
+  HostRequestOnline,
+  HostRequestOffline,
 };
 
 const char* control_event_name(ControlEvent e);
+std::optional<ControlEvent> parse_control_event(const std::string& s);
 
-// S1F18 ONLACK codes.
 enum class OnlineAck : uint8_t {
   Accept = 0,
   NotAccept = 1,
   AlreadyOnline = 2,
 };
 
-// S1F16 OFLACK codes.
 enum class OfflineAck : uint8_t {
   Accept = 0,
 };
 
-// S1F14 COMMACK codes.
 enum class CommAck : uint8_t {
   Accept = 0,
   Denied = 1,
 };
 
-// Drives the E30 control state. Pure state machine — no IO. The Server layer
-// owns one of these per equipment and dispatches host-initiated events and
-// operator actions into it.
+// One row of the control-state transition table (E30 §6.2 + extensions).
+// `to` and `then` are both optional: a row may produce no transition (e.g.
+// host_request_online while already OnlineRemote — ack only); a row may also
+// chain straight through the transient AttemptOnline state via `then`.
+// `ack_code` is the raw uint8_t carried by S1F18 (ONLACK) or S1F16 (OFLACK);
+// its interpretation depends on the triggering event.
+struct ControlTransition {
+  ControlState from;
+  ControlEvent on;
+  std::optional<ControlState> to;
+  std::optional<ControlState> then;
+  std::optional<uint8_t> ack_code;
+};
+
+// Pure data table — no behaviour. Lookup is first-match on (from, on).
+class ControlTransitionTable {
+ public:
+  void add(ControlTransition row);
+  const ControlTransition* find(ControlState from, ControlEvent on) const;
+  std::size_t size() const { return rows_.size(); }
+  const std::vector<ControlTransition>& rows() const { return rows_; }
+
+  // Built-in default table, matching data/control_state.yaml exactly.
+  // Used by tests so they don't depend on the YAML file being present.
+  static ControlTransitionTable default_table();
+
+ private:
+  std::vector<ControlTransition> rows_;
+};
+
+// The E30 control state machine, driven by a transition table. All
+// behavioural rules live in the table; this class is just the engine.
 class ControlStateMachine {
  public:
-  struct Config {
-    ControlState initial = ControlState::HostOffline;
-    // When ATTEMPT_ONLINE completes via a host request, do we land in REMOTE
-    // (host in control) or LOCAL (host observes only)?  For host-initiated
-    // online this defaults to REMOTE; for operator-initiated online it follows
-    // `operator_default_remote`.
-    bool host_request_grants_remote = true;
-    bool operator_default_remote = false;
-  };
-
   using StateChangeHandler =
       std::function<void(ControlState from, ControlState to, ControlEvent trigger)>;
 
   ControlStateMachine();
-  explicit ControlStateMachine(Config cfg);
+  explicit ControlStateMachine(ControlTransitionTable table,
+                               ControlState initial = ControlState::HostOffline);
 
   ControlState state() const { return state_; }
   bool online() const { return is_online(state_); }
 
   void set_state_change_handler(StateChangeHandler h) { on_change_ = std::move(h); }
 
-  // Operator actions. Each returns true if a transition occurred, false if the
-  // current state didn't permit it.
+  // Operator actions. Return true if a transition (or self-ack) was found.
   bool operator_online();
   bool operator_offline();
   bool operator_local();
   bool operator_remote();
 
-  // Host-initiated requests. The SM responds with the SEMI-mandated ack code
-  // and performs any transition.
+  // Host requests. Return the ack code from the matching table row.
   OnlineAck on_host_request_online();
   OfflineAck on_host_request_offline();
 
  private:
+  // Apply the matching row (if any) for (state_, event); returns the row.
+  const ControlTransition* fire(ControlEvent on);
   void transition(ControlState next, ControlEvent trigger);
 
-  Config cfg_;
+  ControlTransitionTable table_;
   ControlState state_;
   StateChangeHandler on_change_;
 };

include/secsgem/gem/data_model.hpp

@@ -161,7 +161,21 @@ class EquipmentDataModel {
     std::string name;
     s2::Item value;
   };
-  using HostCommandHandler = std::function<HostCmdAck(const std::vector<CommandParam>&)>;
+
+  // Declarative host-command effect, loaded from YAML. The server
+  // dispatches a command by looking up the spec and (optionally) firing
+  // a CEID emit / setting an alarm after the S2F42 reply is sent.
+  struct CommandSpec {
+    HostCmdAck ack = HostCmdAck::Accept;
+    std::optional<uint32_t> emit_ceid;
+    std::optional<uint32_t> set_alarm;
+  };
+
+  struct CommandResult {
+    HostCmdAck ack = HostCmdAck::InvalidCommand;
+    std::optional<uint32_t> emit_ceid;
+    std::optional<uint32_t> set_alarm;
+  };
 
   // --- SVID ---------------------------------------------------------------
   void add_status_variable(StatusVariable sv);
@@ -191,9 +205,9 @@ class EquipmentDataModel {
   TimeAck set_time_string(const std::string& time_str);
 
   // --- Host commands ------------------------------------------------------
-  void register_command(const std::string& rcmd, HostCommandHandler handler);
-  HostCmdAck dispatch_command(const std::string& rcmd,
-                              const std::vector<CommandParam>& params) const;
+  void register_command(const std::string& rcmd, CommandSpec spec);
+  CommandResult dispatch_command(const std::string& rcmd,
+                                 const std::vector<CommandParam>& params) const;
   bool has_command(const std::string& rcmd) const;
 
   // --- Collection events --------------------------------------------------
@@ -247,7 +261,7 @@ class EquipmentDataModel {
   std::map<uint32_t, DataVariable> dvids_;
   std::map<uint32_t, EquipmentConstant> ecids_;
   std::int64_t time_offset_seconds_ = 0;
-  std::map<std::string, HostCommandHandler> commands_;
+  std::map<std::string, CommandSpec> commands_;
 
   std::map<uint32_t, CollectionEvent> ceids_;
   std::map<uint32_t, Report> reports_;

include/secsgem/gem/router.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <optional>
+#include <utility>
+
+#include "secsgem/secs2/message.hpp"
+
+namespace secsgem::gem {
+
+namespace s2 = secsgem::secs2;
+
+// A small (stream, function) dispatch table. The Server registers one
+// handler per primary SxFy and calls `dispatch` from the Connection's
+// message handler. Replaces the imperative if-ladder; behaviour stays in
+// the handlers (since each SxFy reply shape is unique), but routing is
+// data.
+//
+// Default behaviour for unregistered primaries:
+//   - If a `fallback` is installed, it runs.
+//   - Otherwise, if the inbound message has W set, reply with SxF0
+//     (Abort) per E5 convention.
+//   - Otherwise, do nothing.
+class Router {
+ public:
+  using Handler = std::function<std::optional<s2::Message>(const s2::Message&)>;
+
+  Router& on(uint8_t stream, uint8_t function, Handler h) {
+    handlers_[{stream, function}] = std::move(h);
+    return *this;
+  }
+
+  Router& fallback(Handler h) {
+    fallback_ = std::move(h);
+    return *this;
+  }
+
+  std::optional<s2::Message> dispatch(const s2::Message& msg) const {
+    auto it = handlers_.find({msg.stream, msg.function});
+    if (it != handlers_.end()) return it->second(msg);
+    if (fallback_) return fallback_(msg);
+    if (msg.reply_expected) return s2::Message(msg.stream, 0, false);
+    return std::nullopt;
+  }
+
+  std::size_t size() const { return handlers_.size(); }
+
+ private:
+  std::map<std::pair<uint8_t, uint8_t>, Handler> handlers_;
+  Handler fallback_;
+};
+
+}  // namespace secsgem::gem

include/secsgem/hsms/connection.hpp

@@ -11,8 +11,7 @@
 #include <string>
 #include <system_error>
 
-#include "secsgem/hsms/frame.hpp"
-#include "secsgem/hsms/types.hpp"
+#include "secsgem/hsms/header.hpp"
 #include "secsgem/secs2/message.hpp"
 
 namespace secsgem::hsms {

include/secsgem/hsms/frame.hpp

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <stdexcept>
-#include <vector>
-
-#include "secsgem/hsms/header.hpp"
-
-namespace secsgem::hsms {
-
-class FrameError : public std::runtime_error {
- public:
-  using std::runtime_error::runtime_error;
-};
-
-// One HSMS message: a header plus an optional SECS-II body (control messages
-// have no body). On the wire it is prefixed by a 4-byte big-endian length that
-// counts the header (10) plus the body.
-struct Frame {
-  Header header;
-  std::vector<uint8_t> body;
-
-  Frame() = default;
-  explicit Frame(Header h, std::vector<uint8_t> b = {})
-      : header(h), body(std::move(b)) {}
-
-  // Full wire bytes including the 4-byte length prefix.
-  std::vector<uint8_t> encode() const;
-
-  // Decode a message from its payload (header + body, i.e. the bytes that
-  // follow the length prefix). `len` must be >= 10.
-  static Frame decode(const uint8_t* payload, std::size_t len);
-};
-
-// HSMS message length prefix is 4 bytes; payload must be at least the 10-byte
-// header.
-inline constexpr std::size_t kLengthPrefixSize = 4;
-inline constexpr std::size_t kHeaderSize = 10;
-
-}  // namespace secsgem::hsms

include/secsgem/hsms/header.hpp

@@ -1,16 +1,64 @@
 #pragma once
 
 #include <array>
+#include <chrono>
 #include <cstdint>
+#include <stdexcept>
 #include <string>
+#include <vector>
 
-#include "secsgem/hsms/types.hpp"
-
+// HSMS wire-format primitives (SEMI E37): SType + status enums, the 10-byte
+// Header, the Frame (header + body, length-prefixed on the wire), and the
+// protocol timer defaults. One header keeps everything that touches the wire
+// format in one place.
 namespace secsgem::hsms {
 
-// The fixed 10-byte HSMS message header (SEMI E37). The interpretation of
-// byte2/byte3 depends on `stype`: for data messages byte2 = (W<<7)|stream and
-// byte3 = function; for control messages they carry status / reason codes.
+// ---- Session type + status / reason enums --------------------------------
+
+enum class SType : uint8_t {
+  Data        = 0,
+  SelectReq   = 1,
+  SelectRsp   = 2,
+  DeselectReq = 3,
+  DeselectRsp = 4,
+  LinktestReq = 5,
+  LinktestRsp = 6,
+  RejectReq   = 7,
+  SeparateReq = 9,
+};
+
+const char* stype_name(SType s);
+
+enum class SelectStatus : uint8_t {
+  Ok = 0, AlreadyActive = 1, NotReady = 2, ConnectExhaust = 3,
+};
+
+enum class DeselectStatus : uint8_t {
+  Ok = 0, NotEstablished = 1, Busy = 2,
+};
+
+enum class RejectReason : uint8_t {
+  StypeNotSupported = 1,
+  PtypeNotSupported = 2,
+  TransactionNotOpen = 3,
+  EntityNotSelected = 4,
+};
+
+inline constexpr uint8_t kPTypeSecsII = 0;
+inline constexpr uint16_t kControlSessionId = 0xFFFF;
+
+// HSMS protocol timer defaults (SEMI E37 §10).
+struct Timers {
+  std::chrono::milliseconds t3{45000};    // reply
+  std::chrono::milliseconds t5{10000};    // connect separation
+  std::chrono::milliseconds t6{5000};     // control transaction
+  std::chrono::milliseconds t7{10000};    // not-selected
+  std::chrono::milliseconds t8{5000};     // intercharacter
+  std::chrono::milliseconds linktest{0};  // 0 disables
+};
+
+// ---- Header (10 bytes) ---------------------------------------------------
+
 struct Header {
   uint16_t session_id = kControlSessionId;
   uint8_t byte2 = 0;
@@ -19,7 +67,6 @@ struct Header {
   SType stype = SType::Data;
   uint32_t system_bytes = 0;
 
-  // Data-message field views.
   bool w_bit() const { return (byte2 & 0x80) != 0; }
   uint8_t stream() const { return byte2 & 0x7F; }
   uint8_t function() const { return byte3; }
@@ -51,10 +98,35 @@ struct Header {
 
   std::array<uint8_t, 10> encode() const;
   static Header decode(const uint8_t* data);  // reads exactly 10 bytes
-
   std::string describe() const;
 
   bool operator==(const Header&) const = default;
 };
 
+// ---- Frame (header + body, length-prefixed) ------------------------------
+
+class FrameError : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+inline constexpr std::size_t kLengthPrefixSize = 4;
+inline constexpr std::size_t kHeaderSize = 10;
+
+struct Frame {
+  Header header;
+  std::vector<uint8_t> body;
+
+  Frame() = default;
+  explicit Frame(Header h, std::vector<uint8_t> b = {})
+      : header(h), body(std::move(b)) {}
+
+  // Full wire bytes including the 4-byte length prefix.
+  std::vector<uint8_t> encode() const;
+
+  // Decode a message from its payload (header + body, i.e. the bytes that
+  // follow the length prefix). `len` must be >= kHeaderSize.
+  static Frame decode(const uint8_t* payload, std::size_t len);
+};
+
 }  // namespace secsgem::hsms

include/secsgem/hsms/types.hpp

@@ -1,62 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include <cstdint>
-
-namespace secsgem::hsms {
-
-// HSMS session type (byte 5 of the message header) — SEMI E37.
-enum class SType : uint8_t {
-  Data = 0,
-  SelectReq = 1,
-  SelectRsp = 2,
-  DeselectReq = 3,
-  DeselectRsp = 4,
-  LinktestReq = 5,
-  LinktestRsp = 6,
-  RejectReq = 7,
-  SeparateReq = 9,
-};
-
-const char* stype_name(SType s);
-
-// Select.rsp status (header byte 3).
-enum class SelectStatus : uint8_t {
-  Ok = 0,
-  AlreadyActive = 1,
-  NotReady = 2,
-  ConnectExhaust = 3,
-};
-
-// Deselect.rsp status (header byte 3).
-enum class DeselectStatus : uint8_t {
-  Ok = 0,
-  NotEstablished = 1,
-  Busy = 2,
-};
-
-// Reject.req reason code (header byte 3).
-enum class RejectReason : uint8_t {
-  StypeNotSupported = 1,
-  PtypeNotSupported = 2,
-  TransactionNotOpen = 3,
-  EntityNotSelected = 4,
-};
-
-// Presentation type 0 == SECS-II message encoding.
-inline constexpr uint8_t kPTypeSecsII = 0;
-
-// Control messages carry no device id; E37 recommends 0xFFFF.
-inline constexpr uint16_t kControlSessionId = 0xFFFF;
-
-// HSMS protocol timers (SEMI E37 defaults).
-struct Timers {
-  std::chrono::milliseconds t3{45000};  // reply timeout
-  std::chrono::milliseconds t5{10000};  // connect separation timeout
-  std::chrono::milliseconds t6{5000};   // control transaction timeout
-  std::chrono::milliseconds t7{10000};  // not-selected timeout
-  std::chrono::milliseconds t8{5000};   // network intercharacter timeout
-  std::chrono::milliseconds linktest{0};  // linktest interval; 0 disables
-};
-
-}  // namespace secsgem::hsms

include/secsgem/secs2/item.hpp

@@ -28,12 +28,48 @@ enum class Format : uint8_t {
   U4      = 054,  // 44
 };
 
-const char* format_name(Format f);
+inline const char* format_name(Format f) {
+  switch (f) {
+    case Format::List:    return "L";
+    case Format::Binary:  return "B";
+    case Format::Boolean: return "BOOLEAN";
+    case Format::ASCII:   return "A";
+    case Format::I8:      return "I8";
+    case Format::I1:      return "I1";
+    case Format::I2:      return "I2";
+    case Format::I4:      return "I4";
+    case Format::F8:      return "F8";
+    case Format::F4:      return "F4";
+    case Format::U8:      return "U8";
+    case Format::U1:      return "U1";
+    case Format::U2:      return "U2";
+    case Format::U4:      return "U4";
+  }
+  return "?";
+}
 
 // Number of bytes one element of the given format occupies on the wire.
 // Lists are special (their length is an element count, not a byte count) and
 // return 0 here.
-std::size_t element_size(Format f);
+inline std::size_t element_size(Format f) {
+  switch (f) {
+    case Format::List:    return 0;
+    case Format::ASCII:
+    case Format::Binary:
+    case Format::Boolean:
+    case Format::U1:
+    case Format::I1:      return 1;
+    case Format::U2:
+    case Format::I2:      return 2;
+    case Format::U4:
+    case Format::I4:
+    case Format::F4:      return 4;
+    case Format::U8:
+    case Format::I8:
+    case Format::F8:      return 8;
+  }
+  return 0;
+}
 
 // A SECS-II data item: a typed, possibly nested value. Lists hold child items;
 // every other format holds a homogeneous array of scalars (a single scalar is
@@ -64,7 +100,9 @@ class Item {
 
   // Number of elements: child count for lists, character count for ASCII,
   // array length for numeric/binary formats.
-  std::size_t size() const;
+  std::size_t size() const {
+    return std::visit([](const auto& v) { return v.size(); }, data_);
+  }
 
   // --- Factory functions -------------------------------------------------
   static Item list(List items) { return Item(Format::List, std::move(items)); }

include/secsgem/secs2/message.hpp

@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 
+#include "secsgem/secs2/codec.hpp"
 #include "secsgem/secs2/item.hpp"
 
 namespace secsgem::secs2 {
@@ -22,16 +23,30 @@ struct Message {
   Message(uint8_t s, uint8_t f, bool w, std::optional<Item> b = std::nullopt)
       : stream(s), function(f), reply_expected(w), body(std::move(b)) {}
 
-  // Encode the body item to bytes (empty if there is no body).
-  std::vector<uint8_t> encode_body() const;
+  std::vector<uint8_t> encode_body() const {
+    if (!body) return {};
+    return encode(*body);
+  }
 
-  // Build a Message from stream/function/W and raw body bytes (empty -> no body).
   static Message from_body(uint8_t stream, uint8_t function, bool reply_expected,
-                           const std::vector<uint8_t>& body_bytes);
+                           const std::vector<uint8_t>& body_bytes) {
+    Message m(stream, function, reply_expected);
+    if (!body_bytes.empty()) m.body = decode(body_bytes);
+    return m;
+  }
 
-  // e.g.  S1F2 W
-  //         <L [2] <A "MDLN"> <A "1.0"> >
-  std::string sml() const;
+  // e.g.  S1F2
+  //         <L [2] <A "MDLN"> <A "1.0"> > .
+  std::string sml() const {
+    std::string out = "S" + std::to_string(stream) + "F" + std::to_string(function);
+    if (reply_expected) out += " W";
+    if (body) {
+      out += "\n  ";
+      out += to_sml(*body);
+    }
+    out += " .";
+    return out;
+  }
 };
 
 }  // namespace secsgem::secs2