@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-rt/lib/include/service.h

@@ -0,0 +1,190 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+
+#include <types/types.h>
+#include <log_entry.h>
+#include <mounts.h>
+
+namespace hkp {
+
+class Runtime;
+class SubRuntime;
+class RuntimeHost;
+struct ProcessContext;
+
+class Service
+{
+public:
+  Service(const std::string& instanceName = "");
+  Service(const std::string& instanceId, const std::string& instanceName);
+  virtual json configure(Data data);
+  virtual json getState() const;
+
+  Data startProcess(const Data& data = Undefined());
+
+  // Attach this service to a host (Runtime or SubRuntime).
+  // setParentRuntime is a convenience overload kept for backward compatibility.
+  void setParentHost(RuntimeHost& host);
+  void setParentRuntime(Runtime& runtime);
+
+  // The host this service is attached to, or null before it has one.
+  //
+  // A service that has a credential to send needs the runtime's secrets, and a
+  // service in a nested pipeline needs the ones the pipeline delegates to.
+  // Both come from here.
+  RuntimeHost* parentHost() const { return m_host; }
+
+  Data next(Data data = Undefined(), bool immediately = true);
+  void nextAsync(Data data = Undefined(), std::function<void(Data)> callback = nullptr);
+  Data nextInRun(Data data, const ProcessContext& context,
+                 std::function<void(Data)> callback = nullptr);
+  bool isConnected() const;
+
+  // ── Sub-runtime support ──────────────────────────────────────────────────
+  // Create a nested pipeline from a JSON array of service configs.
+  // Services are instantiated via the parent runtime's registry and parented
+  // to the new SubRuntime so that next() / nextAsync() work inside it.
+  // See sub_runtime.h for the config schema and usage.
+  //
+  //   // configure():
+  //   m_pipeline = createSubRuntime((*j)["pipeline"]);
+  //
+  //   // process():
+  //   return m_pipeline->process(data);
+  //
+  std::shared_ptr<SubRuntime> createSubRuntime(const json& servicesConfig);
+
+  // ── Multi-emit support ───────────────────────────────────────────────────
+  // Push a partial result through the rest of the outer pipeline without
+  // ending the current process() call.  Thread-safe — posts via the App's
+  // io_context, so it can also be called from a background thread.
+  // Equivalent to nextAsync() but communicates intent: this service produces
+  // more than one output for a single input.  emit() also closes the process
+  // lifecycle bracket for this service (sends "call-process-finished" with the
+  // result), so a service that deferCompletion()'d has its processing indicator
+  // reflect the true end of the async work rather than the instant return.
+  void emit(Data partialResult);
+
+  // Runtime-facing: returns true (and resets) if the most recent process() call
+  // deferred its completion via deferCompletion().  The runtime uses this to
+  // withhold the synchronous "call-process-finished" for that call — emit()
+  // sends it later, when the deferred work actually finishes.
+  bool takeProcessDeferred();
+
+  inline const std::string &getId() const { return m_instanceId; }
+  inline const std::string &getName() const { return m_instanceName; }
+  virtual std::string getServiceId() const = 0;
+
+  // Called by the host (Runtime) before it tears itself down, while the host and
+  // its service list are still fully alive. A service that runs work on a
+  // background thread joins it here, so its final emit() drives the pipeline
+  // through a live host rather than half-destroyed state. Default: nothing.
+  virtual void shutdown() {}
+
+  // Inputs are a static property of a service, and are not supposed to change through lifetime.
+  // Usually services don't provide additional inputs, examples that do are websocket_server_service.h,
+  // or in general any "-T-shaped" service.
+  virtual std::vector<ExternalServiceInput> getExternalInputs() const;
+
+  virtual Data process(Data data = Undefined()) = 0;
+
+  // The service one segment of a scoped address names inside this one.
+  //
+  // Only a service holding a pipeline answers: it is what lets an address
+  // reach past the runtime's flat list into what a scope contains. A service
+  // with several pipelines searches them in declaration order. See address.h.
+  virtual std::shared_ptr<Service> findNested(const std::string& instanceId) const;
+
+  // Runs from a service inside this one to the end of the pipeline holding it,
+  // the way processAt does at the top level. Answers Undefined where this
+  // service holds no pipeline that can be entered.
+  //
+  // Only a service whose pipeline is a chain answers. An endpoint's entries
+  // and a Tracks branch are driven by the thing that owns them — a request
+  // arriving, a fan-out — so entering one from outside would run half of an
+  // arrangement whose other half never happened. Those stay readable and
+  // configurable by address without being enterable by one.
+  virtual bool processNested(const std::string& address, Data data, Data& result);
+
+protected:
+  virtual bool supportsSubservices() const;
+  virtual bool onBypassChanged(bool bypass);
+  json& mergeBypassState(json &state) const;
+  void sendNotification(const Data& params) const;
+
+  // Record something about the run in progress. The run and this service are
+  // taken from the call the host is inside, so a service says only what
+  // happened. Dropped when nothing is collecting, or outside a call.
+  void log(LogLevel level, const std::string& event,
+           const nlohmann::json& data = nullptr) const;
+  void setBypass(bool bypass);
+  bool isBypass() const;
+
+  // Call from process() (as the return value) when the real output will be
+  // produced later via emit() on a worker thread.  Returns Null() to stop the
+  // synchronous push and marks the call deferred so the runtime withholds the
+  // "call-process-finished" lifecycle event until emit() actually delivers.
+  Data deferCompletion();
+
+  // Call from the worker when a deferred call is over with nothing to pass on
+  // — it produced nothing, or it failed. emit() is how such a call ends when
+  // there is a result; this is how it ends otherwise, so that the processing
+  // bracket closes and the run the call was made in is given up. Does nothing
+  // when emit() already ended it.
+  void endDeferred();
+
+  // A path on the runtime server's own port for this service, held for as
+  // long as the handle is; empty when the server serves none. See
+  // RuntimeHost::mountEndpoint.
+  MountHandle mountEndpoint(const std::string& name, MountAdopter adopter);
+
+  json mergeStateWith(const json& update) const
+  {
+    auto state = Service::getState();
+    state.update(update);
+    return state;
+  }
+
+private:
+  RuntimeHost* m_host = nullptr;
+  // Set by deferCompletion(), consumed by the runtime's processFrom right after
+  // process() returns — both on the pipeline thread, so a plain bool is enough
+  // (emit(), which runs on the worker, never touches it).
+  bool m_processDeferred = false;
+  // One-shot authority captured by deferCompletion(). Further emissions are
+  // autonomous board work, not delegation of the person who began this call.
+  //
+  // Written on the pipeline thread and read and consumed on the worker, so it
+  // is only touched under its mutex. `open` is what the paths
+  // that report many times a second look at first: a service that never
+  // defers never takes the lock.
+  //
+  // A copy of a service is in no call, whatever the one it was made from is
+  // in the middle of — so copying carries none of this over.
+  struct DeferredCall
+  {
+    std::shared_ptr<const ProcessContext> context;
+    mutable std::mutex mutex;
+    std::atomic<bool> open{false};
+
+    DeferredCall() = default;
+    DeferredCall(const DeferredCall&) {}
+    DeferredCall& operator=(const DeferredCall&) { return *this; }
+  };
+  DeferredCall m_deferred;
+
+  // The run a deferred call is still open in, if one is.
+  std::shared_ptr<const ProcessContext> deferredContext() const;
+  // Ends the deferred call, answering whether one was open and in which run.
+  bool takeDeferred(std::shared_ptr<const ProcessContext>& context);
+
+protected:
+  std::string m_instanceName;
+  std::string m_instanceId;
+  std::optional<bool> m_bypass;
+};
+
+}

package/bundle/hkp-rt/lib/include/slot_store.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include <types/data.h>
+
+namespace hkp {
+
+// Named cells two pipelines can share a value through.
+//
+// A pipeline pass carries one value and ends; anything that has to survive
+// until a *different* pipeline runs has nowhere to live. A store gives it a
+// name, and whoever owns the pipelines that must share decides which store they
+// see — which is what keeps the sharing scoped to the arrangement that needs it
+// rather than being ambient across a runtime.
+//
+// Deliberately not a cache: nothing expires, nothing is computed on a miss. It
+// is a cell, and the services that read and write it say what it means.
+//
+// Matches hkp-node's SlotStore and hkp-python's, so a board written against one
+// runtime behaves the same on another.
+class SlotStore
+{
+public:
+  // What is held under `name`, or Undefined where nothing has been written —
+  // which is what a default-constructed Data already is. The service reading
+  // decides what an empty cell means for it; here it is only "not set".
+  Data get(const std::string& name) const
+  {
+    const auto it = m_cells.find(name);
+    return it == m_cells.end() ? Data{} : it->second;
+  }
+
+  void set(const std::string& name, Data value) { m_cells[name] = std::move(value); }
+
+private:
+  std::map<std::string, Data> m_cells;
+};
+
+} // namespace hkp

package/bundle/hkp-rt/lib/include/standalone_config.h

@@ -0,0 +1,253 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+#include <exception>
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "auth.h"
+#include "egress.h"
+#include "files.h"
+
+namespace hkp
+{
+
+/**
+ * What a standalone hkp-rt is started with, read from its arguments and its
+ * environment.
+ *
+ * On a person's own machine none of it needs saying: it binds loopback, which
+ * keeps other machines out, and answers no page but the Readymade apps' and
+ * this machine's own (origins.h). Anywhere else — a container, a
+ * server — the bind is opened with `HOST`, and that is only allowed together
+ * with who may use it: a non-loopback bind without `AUTH0_DOMAIN`,
+ * `AUTH0_AUDIENCE` and `ALLOWED_EMAILS` is refused rather than served open.
+ *
+ * The names are hkp-node's, so one environment file describes either server.
+ */
+struct StandaloneConfig
+{
+  unsigned int port = 5556;
+  /** The interface listened on. `HOST`. */
+  std::string bind = "127.0.0.1";
+  /** The address this server tells others it is reached at. `EXTERNAL_HOST`. */
+  std::string externalHost = "127.0.0.1";
+  /** Where it is reached from outside, when that is not `http://<externalHost>:<port>`
+   *  — behind a proxy that terminates TLS, say. `HKP_EXTERNAL_URL`. */
+  std::string externalUrl;
+  /** Origins allowed to call it from a browser; empty means the Readymade
+   *  apps and pages served from this machine (see origins.h). `ALLOWED_ORIGINS`. */
+  std::string allowedOrigins;
+  AuthConfig auth;
+  /** Where coordinator tickets are kept; empty keeps them in memory.
+   *  `HKP_COORDINATOR_LINKS_FILE`. */
+  std::string linksFile;
+  /** Keys the addresses of this server's mounts. `HKP_MOUNT_SECRET`. */
+  std::string mountSecret;
+  /** Where that secret is kept when the environment gives none. */
+  std::string mountSecretFile;
+  /** A runtime config to load at start; the third argument. */
+  std::string runtimeConfigFile;
+  /** Where a board may make this server connect to; open unless it is hosted.
+   *  `HKP_EGRESS`, `HKP_EGRESS_ALLOW` (see egress.h). */
+  egress::Policy egress;
+  /** The folders boards may read and write, the default first (files.h):
+   *  `HKP_FILES_DIR` — `~/.hkp/cpp/files` when unset, none when empty — then
+   *  `HKP_FILES_ALLOW`. */
+  std::vector<std::filesystem::path> fileFolders;
+  /** Set when the configuration must not be served; says what is missing. */
+  std::string error;
+};
+
+using EnvironmentReader = std::function<const char*(const char*)>;
+
+inline std::vector<std::string> splitList(const std::string& value)
+{
+  std::vector<std::string> items;
+  std::string current;
+  const auto flush = [&]() {
+    const auto first = current.find_first_not_of(" \t\r\n");
+    if (first != std::string::npos)
+    {
+      const auto last = current.find_last_not_of(" \t\r\n");
+      items.push_back(current.substr(first, last - first + 1));
+    }
+    current.clear();
+  };
+  for (const char c : value)
+  {
+    if (c == ',')
+    {
+      flush();
+    }
+    else
+    {
+      current.push_back(c);
+    }
+  }
+  flush();
+  return items;
+}
+
+/**
+ * Arguments are `<port> <externalHost> <runtime config>`, each optional, as
+ * they always were; the environment says the rest and is overridden by an
+ * argument where both name the same thing.
+ */
+inline StandaloneConfig readStandaloneConfig(
+  const std::vector<std::string>& arguments,
+  const EnvironmentReader& env = [](const char* name) { return std::getenv(name); })
+{
+  StandaloneConfig config;
+  const auto read = [&env](const char* name) {
+    const char* value = env(name);
+    return value ? std::string(value) : std::string();
+  };
+
+  if (const auto port = read("PORT"); !port.empty())
+  {
+    try { config.port = static_cast<unsigned int>(std::stoul(port)); }
+    catch (const std::exception&) { config.error = "PORT is not a number: " + port; }
+  }
+  if (const auto host = read("HOST"); !host.empty())
+  {
+    config.bind = host;
+  }
+  if (const auto external = read("EXTERNAL_HOST"); !external.empty())
+  {
+    config.externalHost = external;
+  }
+  config.externalUrl = read("HKP_EXTERNAL_URL");
+  {
+    std::string mode = read("HKP_EGRESS");
+    const auto first = mode.find_first_not_of(" \t");
+    const auto last = mode.find_last_not_of(" \t");
+    mode = first == std::string::npos ? "" : mode.substr(first, last - first + 1);
+    std::transform(mode.begin(), mode.end(), mode.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    std::string problem;
+    config.egress = egress::readPolicy(mode, read("HKP_EGRESS_ALLOW"), problem);
+    if (!problem.empty())
+    {
+      config.error = problem;
+    }
+  }
+  while (!config.externalUrl.empty() && config.externalUrl.back() == '/')
+  {
+    config.externalUrl.pop_back();
+  }
+
+  if (arguments.size() > 0)
+  {
+    try { config.port = static_cast<unsigned int>(std::stoul(arguments[0])); }
+    catch (const std::exception&) { config.error = "The port is not a number: " + arguments[0]; }
+  }
+  if (arguments.size() > 1)
+  {
+    config.externalHost = arguments[1];
+  }
+  if (arguments.size() > 2)
+  {
+    config.runtimeConfigFile = arguments[2];
+  }
+
+  // Unset means the default beside this server's other data; set to the empty
+  // string means keep them in memory only.
+  const char* linksFile = env("HKP_COORDINATOR_LINKS_FILE");
+  if (linksFile)
+  {
+    config.linksFile = linksFile;
+  }
+  else if (const auto home = read("HOME"); !home.empty())
+  {
+    config.linksFile = home + "/.hkp/cpp/coordinator-links.json";
+  }
+
+  // Unset means a folder beside this server's other data; set to the empty
+  // string means none, leaving HKP_FILES_ALLOW to name every folder.
+  const char* filesDir = env("HKP_FILES_DIR");
+  if (filesDir)
+  {
+    if (*filesDir && !std::filesystem::path(filesDir).is_absolute())
+    {
+      config.error = std::string("HKP_FILES_DIR: \"") + filesDir + "\" is not an absolute path";
+    }
+    else if (*filesDir)
+    {
+      config.fileFolders.emplace_back(filesDir);
+    }
+  }
+  else if (const auto home = read("HOME"); !home.empty())
+  {
+    config.fileFolders.emplace_back(home + "/.hkp/cpp/files");
+  }
+  {
+    std::string problem;
+    for (auto& folder : files::readFolderList(read("HKP_FILES_ALLOW"), "HKP_FILES_ALLOW", problem))
+    {
+      config.fileFolders.push_back(std::move(folder));
+    }
+    if (!problem.empty())
+    {
+      config.error = problem;
+    }
+  }
+
+  config.mountSecret = read("HKP_MOUNT_SECRET");
+  if (const auto home = read("HOME"); !home.empty())
+  {
+    config.mountSecretFile = home + "/.hkp/cpp/mount-secret";
+  }
+
+  const auto domain = read("AUTH0_DOMAIN");
+  const auto audiences = splitList(read("AUTH0_AUDIENCE"));
+  const auto emails = splitList(read("ALLOWED_EMAILS"));
+  const bool exposed = !isLoopbackHost(config.bind);
+
+  if (!domain.empty() && !audiences.empty())
+  {
+    TrustedIssuer issuer;
+    // Auth0 issues `iss` as the tenant's address with a trailing slash.
+    issuer.iss = (domain.rfind("https://", 0) == 0 ? domain : "https://" + domain);
+    if (issuer.iss.back() != '/')
+    {
+      issuer.iss.push_back('/');
+    }
+    issuer.audiences = audiences;
+    config.auth.mode = AuthMode::Jwt;
+    config.auth.issuers.push_back(std::move(issuer));
+    config.auth.allowedEmails = emails;
+  }
+
+  if (exposed)
+  {
+    std::string missing;
+    const auto need = [&missing](bool present, const char* name) {
+      if (!present)
+      {
+        missing += missing.empty() ? name : std::string(", ") + name;
+      }
+    };
+    need(!domain.empty(), "AUTH0_DOMAIN");
+    need(!audiences.empty(), "AUTH0_AUDIENCE");
+    need(!emails.empty(), "ALLOWED_EMAILS");
+    if (!missing.empty() && config.error.empty())
+    {
+      config.error =
+        "Refusing to listen on " + config.bind + " without saying who may use this "
+        "server: " + missing + " not set. Set them, or leave HOST unset to listen "
+        "on 127.0.0.1 only.";
+    }
+  }
+  if (const auto origins = read("ALLOWED_ORIGINS"); !origins.empty())
+  {
+    config.allowedOrigins = origins;
+  }
+
+  return config;
+}
+
+}

package/bundle/hkp-rt/lib/include/types/audio.h

@@ -0,0 +1,3 @@
+#pragma once
+
+constexpr unsigned int BUFFER_SIZE = 256 * 2;

package/bundle/hkp-rt/lib/include/types/data.h

@@ -0,0 +1,152 @@
+#pragma once
+
+#include <vector>
+
+#include <boost/variant.hpp>
+#include "ringbuffer.h"
+
+#include <nlohmann/json.hpp>
+
+namespace hkp {
+
+using json = nlohmann::json;
+struct Undefined
+{
+};
+
+struct Null
+{
+};
+
+using BinaryData = std::vector<uint8_t>;
+
+class ControlFlowData
+{
+public:
+  enum class Type
+  {
+    kEarlyReturn = 0,
+ };
+  struct Impl;
+  std::shared_ptr<Impl> impl;
+};
+
+struct MixedData
+{
+  json meta;
+  BinaryData binary;
+};
+
+struct CustomData
+{
+  CustomData(const char* t, void* d)
+    : type(t), data(d) {}
+  
+  const char* type; // type of the custom data describing the data structure
+  void* data; // pointer to custom data, can be anything
+};
+
+typedef boost::variant<
+  Undefined,
+  std::shared_ptr<FloatRingBuffer>,
+  json,
+  BinaryData,
+  std::string,
+  Null,
+  ControlFlowData,
+  CustomData,
+  MixedData
+> Data;
+
+std::string stringify(const Data& data);
+
+// put this in a namespace to avoid conflicts with other Data types (since variant holds multiple common types)
+// if you want to log Data instance, make sure to use the namespace hkp before logging
+namespace hkp 
+{
+  std::ostream& operator<<(std::ostream& os, const Data& data);
+}
+
+// from Data to specific types
+std::optional<json> getJSONFromData(const Data &data);
+std::shared_ptr<FloatRingBuffer> getRingBufferFromData(const Data &data);
+std::optional<const BinaryData> getBinaryFromData(const Data& data);
+std::optional<const std::string> getStringFromData(const Data& data);
+std::optional<CustomData> getCustomDataFromData(const Data& data);
+std::optional<MixedData>  getMixedDataFromData(const Data& data);
+
+Data getControlFlowData(const Data &data);
+bool isUndefined(const Data& data);
+bool isNull(const Data& data);
+bool isControlFlowData(const Data& data);
+bool isEarlyReturn(const Data& data);
+bool isCustomData(const Data& data);
+// from specific types to Data
+Data flatBufferToData(FloatRingBuffer::BufferType& buffer, bool isBinary);
+
+// convert between specific types
+
+template <typename T>
+std::optional<T> getProperty(const json& j, const std::string& key);
+
+template <typename T>
+std::optional<T> getPropertyUpdate(const json& j, const std::string& key, const T& old)
+{
+  auto prop = getProperty<T>(j, key);
+  if (prop && *prop != old)
+  {
+    return std::optional<T>(*prop);
+  }
+  return std::nullopt;
+}
+
+ControlFlowData makeEarlyReturn(const Data& data);
+
+template <typename T>
+struct TypeId;
+
+template <> struct TypeId<Undefined> { static constexpr uint16_t value = 0; };
+template <> struct TypeId<FloatRingBuffer> { static constexpr uint16_t value = 1; };
+template <> struct TypeId<std::shared_ptr<FloatRingBuffer>> { static constexpr uint16_t value = 1; };
+template <> struct TypeId<json> { static constexpr uint16_t value = 2; };
+template <> struct TypeId<BinaryData> { static constexpr uint16_t value = 3; };
+template <> struct TypeId<std::string> { static constexpr uint16_t value = 4; };
+template <> struct TypeId<Null> { static constexpr uint16_t value = 5; };
+template <> struct TypeId<ControlFlowData> { static constexpr uint16_t value = 6; };
+template <> struct TypeId<CustomData> { static constexpr uint16_t value = 7; };
+template <> struct TypeId<MixedData>  { static constexpr uint16_t value = 8; };
+
+template <typename T>
+constexpr uint16_t getTypeId() {
+  if constexpr (std::is_base_of_v<TypeId<T>, TypeId<T>>) 
+  {
+    return TypeId<T>::value;
+  } 
+  else 
+  {
+    return static_cast<uint16_t>(-1); // undefined type
+  }
+}
+
+inline uint16_t getTypeId(const Data& data)
+{
+  if (data.type() == typeid(Undefined)) return TypeId<Undefined>::value;
+  if (data.type() == typeid(std::shared_ptr<FloatRingBuffer>)) return TypeId<FloatRingBuffer>::value;
+  if (data.type() == typeid(json)) return TypeId<json>::value;
+  if (data.type() == typeid(BinaryData)) return TypeId<BinaryData>::value;
+  if (data.type() == typeid(std::string)) return TypeId<std::string>::value;
+  if (data.type() == typeid(Null)) return TypeId<Null>::value;
+  if (data.type() == typeid(ControlFlowData)) return TypeId<ControlFlowData>::value;
+  if (data.type() == typeid(CustomData)) return TypeId<CustomData>::value;
+  if (data.type() == typeid(MixedData))  return TypeId<MixedData>::value;
+
+  return static_cast<uint16_t>(-1); // undefined type
+}
+
+inline bool isPlatformLittleEndian() 
+{
+  uint32_t num = 1;
+  return *(reinterpret_cast<uint8_t*>(&num)) == 1;
+};
+
+}

package/bundle/hkp-rt/lib/include/types/message.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <boost/asio/buffer.hpp>
+#include <boost/beast.hpp>
+
+#include <types/data.h>
+
+namespace hkp {
+
+// this is in sync with Message.ts MessagePurpose enum 
+enum MessagePurpose { 
+  NOTIFICATION = 0, 
+  RESULT = 1, 
+  RESULT_AWAITING_RESPONSE = 2,
+  RESULT_WITH_REQUEST_ID = 3
+};
+
+struct MessageHeader
+{
+  uint16_t messagePurpose;
+  uint16_t dataType;
+  std::string sender;
+};
+
+class Message 
+{
+public:
+  using BufferType = boost::beast::basic_flat_buffer<std::allocator<char>>;
+  using WebSocketStream = boost::beast::websocket::stream<boost::beast::tcp_stream>;
+
+  static Data deserialize(BufferType& buffer, MessageHeader* outHeader = nullptr);
+  static void serialize(
+    const Data& data,
+    MessagePurpose purpose,
+    const std::string& sender,
+    WebSocketStream& stream
+  );
+
+  // String-based variants for transports that work in std::string frames
+  // (e.g. Crow WebSocket connections) rather than a Beast stream / flat_buffer.
+  // The wire format is identical: YAS header bytes followed by the payload.
+  static std::string serializeToString(
+    const Data& data,
+    MessagePurpose purpose,
+    const std::string& sender
+  );
+  static Data deserializeFromString(
+    const std::string& bytes,
+    MessageHeader* outHeader = nullptr
+  );
+
+private:
+
+};
+
+}