Continue to try and improve code prior to implementing nested graph structures.

Author: hhenson

cpp/include/hgraph/types/time_series/time_series_state.h

@@ -8,6 +8,7 @@
 #include <hgraph/types/value/value_view.h>
 #include <hgraph/util/tagged_ptr.h>
 
+#include <deque>
 #include <memory>
 #include <optional>
 #include <unordered_map>
@@ -43,10 +44,13 @@ namespace hgraph
         struct ViewDispatch;
 
         [[nodiscard]] HGRAPH_EXPORT bool has_local_reference_binding(const TSViewContext &context) noexcept;
+        [[nodiscard]] HGRAPH_EXPORT bool linked_context_valid(const LinkedTSContext &context) noexcept;
+        [[nodiscard]] HGRAPH_EXPORT bool linked_context_all_valid(const LinkedTSContext &context) noexcept;
         [[nodiscard]] HGRAPH_EXPORT const Value *materialized_target_link_value(const TSViewContext &context) noexcept;
         [[nodiscard]] HGRAPH_EXPORT const Value *materialized_reference_value(const TSViewContext &context) noexcept;
         [[nodiscard]] HGRAPH_EXPORT bool reference_all_valid(const TSViewContext &context) noexcept;
         [[nodiscard]] HGRAPH_EXPORT bool linked_context_equal(const LinkedTSContext &lhs, const LinkedTSContext &rhs) noexcept;
+        [[nodiscard]] HGRAPH_EXPORT TSViewContext refresh_native_context(const TSViewContext &context) noexcept;
         [[nodiscard]] HGRAPH_EXPORT Value snapshot_target_value(const LinkedTSContext &target,
                                                                engine_time_t modified_time = MIN_DT);
     }  // namespace detail
@@ -403,7 +407,10 @@ namespace hgraph
      * State carried by a time-series window.
      */
     struct HGRAPH_EXPORT TSWState : BaseState
-    {};
+    {
+        engine_time_t first_observed_time{MIN_DT};
+        bool          ready{false};
+    };
 
     /**
      * Storage carried by a target-linked logical time-series position.

cpp/include/hgraph/types/time_series/ts_value.h

@@ -120,7 +120,7 @@ struct HGRAPH_EXPORT TSValue {
     /**
      * Return the window value surface for this time-series.
      */
-    [[nodiscard]] CyclicBufferView window_value() const;
+    [[nodiscard]] BufferView window_value() const;
 
     /**
      * Return the list delta surface backed by the stored delta-tracking

cpp/include/hgraph/types/time_series/ts_view.h

@@ -140,9 +140,10 @@ namespace hgraph
         struct TSWindowDispatch : TSDispatch
         {
             [[nodiscard]] const TSWindowDispatch *as_window() const noexcept override { return this; }
-            [[nodiscard]] virtual size_t size(const TSViewContext &context) const noexcept = 0;
-            [[nodiscard]] virtual Range<View> values(const TSViewContext &context) const noexcept = 0;
-            [[nodiscard]] virtual Range<engine_time_t> value_times(const TSViewContext &context) const noexcept = 0;
+            [[nodiscard]] virtual size_t size(const TSViewContext &context, engine_time_t evaluation_time) const noexcept = 0;
+            [[nodiscard]] virtual Range<View> values(const TSViewContext &context, engine_time_t evaluation_time) const noexcept = 0;
+            [[nodiscard]] virtual Range<engine_time_t> value_times(const TSViewContext &context,
+                                                                   engine_time_t       evaluation_time) const noexcept = 0;
         };
 
         struct TSInputViewOps
@@ -254,11 +255,15 @@ namespace hgraph
                 resolved_context.value_dispatch = target_context.value_dispatch;
                 resolved_context.ts_dispatch = target_context.ts_dispatch;
                 resolved_context.value_data = target_context.value_data;
+                resolved_context.owning_output = target.owning_output != nullptr ? target.owning_output : resolved_context.owning_output;
+                resolved_context.output_view_ops = target.output_view_ops != nullptr ? target.output_view_ops : resolved_context.output_view_ops;
+                resolved_context.notification_state =
+                    target.notification_state != nullptr ? target.notification_state : resolved_context.notification_state;
             };
 
             if (const LinkedTSContext *target = state->linked_target(); target != nullptr) { apply_target(*target); }
 
-            return resolved_context;
+            return detail::refresh_native_context(resolved_context);
         }
 
         [[nodiscard]] View value() const noexcept
@@ -1044,15 +1049,15 @@ namespace hgraph
     {
         const auto *dispatch = this->view_ref().context_ref().resolved().ts_dispatch;
         const auto *window_dispatch = dispatch != nullptr ? dispatch->as_window() : nullptr;
-        return window_dispatch != nullptr ? window_dispatch->size(this->view_ref().context_ref()) : 0;
+        return window_dispatch != nullptr ? window_dispatch->size(this->view_ref().context_ref(), this->view_ref().evaluation_time()) : 0;
     }
 
     template <typename TView>
     Range<View> TSWView<TView>::values() const noexcept
     {
         const auto *dispatch = this->view_ref().context_ref().resolved().ts_dispatch;
         const auto *window_dispatch = dispatch != nullptr ? dispatch->as_window() : nullptr;
-        return window_dispatch != nullptr ? window_dispatch->values(this->view_ref().context_ref())
+        return window_dispatch != nullptr ? window_dispatch->values(this->view_ref().context_ref(), this->view_ref().evaluation_time())
                                           : Range<View>{nullptr, 0, nullptr, nullptr};
     }
 
@@ -1061,7 +1066,7 @@ namespace hgraph
     {
         const auto *dispatch = this->view_ref().context_ref().resolved().ts_dispatch;
         const auto *window_dispatch = dispatch != nullptr ? dispatch->as_window() : nullptr;
-        return window_dispatch != nullptr ? window_dispatch->value_times(this->view_ref().context_ref())
+        return window_dispatch != nullptr ? window_dispatch->value_times(this->view_ref().context_ref(), this->view_ref().evaluation_time())
                                           : Range<engine_time_t>{nullptr, 0, nullptr, nullptr};
     }
 

cpp/include/hgraph/types/time_series/value/atomic.h

@@ -80,6 +80,11 @@ namespace hgraph
 
         template <typename T> struct AtomicDispatch final : ViewDispatch
         {
+            [[nodiscard]] MutationTracking tracking() const noexcept override
+            {
+                return MutationTracking::Plain;
+            }
+
             [[nodiscard]] size_t hash(const void *data) const override
             {
                 return atomic_hash(state(data)->value);
@@ -112,6 +117,11 @@ namespace hgraph
                 state(dst)->value = state(src)->value;
             }
 
+            void copy_from(void *dst, const View &src) const override
+            {
+                assign(dst, detail::ViewAccess::data(src));
+            }
+
             void set_from_cpp(void *dst, const void *src, const value::TypeMeta *src_schema) const override
             {
                 if (src_schema != value::scalar_type_meta<T>()) {
@@ -150,6 +160,11 @@ namespace hgraph
          */
         template <> struct AtomicDispatch<nb::object> final : ViewDispatch
         {
+            [[nodiscard]] MutationTracking tracking() const noexcept override
+            {
+                return MutationTracking::Plain;
+            }
+
             [[nodiscard]] size_t hash(const void *data) const override
             {
                 const auto &obj = state(data)->value;
@@ -202,6 +217,11 @@ namespace hgraph
                 state(dst)->value = state(src)->value;
             }
 
+            void copy_from(void *dst, const View &src) const override
+            {
+                assign(dst, detail::ViewAccess::data(src));
+            }
+
             void set_from_cpp(void *dst, const void *src, const value::TypeMeta *src_schema) const override
             {
                 if (src_schema != value::scalar_type_meta<nb::object>()) {

cpp/include/hgraph/types/time_series/value/value.h

@@ -290,9 +290,14 @@ namespace hgraph
         Storage             m_storage;
     };
 
+    inline Value View::clone(MutationTracking tracking) const
+    {
+        return Value{*this, tracking};
+    }
+
     inline Value View::clone() const
     {
-        return Value{*this};
+        return clone(MutationTracking::Plain);
     }
 
     template <typename T> inline void View::set(T &&value)

cpp/include/hgraph/types/time_series/value/view.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <hgraph/hgraph_base.h>
+#include <hgraph/types/time_series/value/tracking.h>
 #include <hgraph/types/value/type_meta.h>
 
 #include <compare>
@@ -15,6 +16,12 @@
 namespace hgraph
 {
     struct Value;
+    struct View;
+
+    namespace detail
+    {
+        struct ViewAccess;
+    }
 
     /**
      * Lightweight type-erased range over value-layer results.
@@ -239,12 +246,14 @@ namespace hgraph
              * preventing accidental polymorphic deletion through a base
              * pointer.
              */
+            [[nodiscard]] virtual MutationTracking      tracking() const noexcept                                         = 0;
             [[nodiscard]] virtual size_t                hash(const void *data) const                                     = 0;
             [[nodiscard]] virtual std::string           to_string(const void *data) const                                = 0;
             [[nodiscard]] virtual std::partial_ordering compare(const void *lhs, const void *rhs) const                  = 0;
             [[nodiscard]] virtual nb::object            to_python(const void *data, const value::TypeMeta *schema) const = 0;
             virtual void from_python(void *dst, const nb::object &src, const value::TypeMeta *schema) const              = 0;
             virtual void assign(void *dst, const void *src) const                                                        = 0;
+            virtual void copy_from(void *dst, const View &src) const                                                    = 0;
             virtual void set_from_cpp(void *dst, const void *src, const value::TypeMeta *src_schema) const               = 0;
             virtual void move_from_cpp(void *dst, void *src, const value::TypeMeta *src_schema) const                    = 0;
 
@@ -390,20 +399,20 @@ namespace hgraph
          * This preserves the represented schema and copies the current payload
          * when the view is valid.
          */
+        [[nodiscard]] Value clone(MutationTracking tracking) const;
         [[nodiscard]] Value clone() const;
+        [[nodiscard]] MutationTracking tracking() const noexcept
+        {
+            return context.dispatch != nullptr ? context.dispatch->tracking() : MutationTracking::Plain;
+        }
 
         /**
          * Copy the payload represented by another view into this view.
          *
          * Both views must be valid and must describe the same schema. This
          * copies payload state only; it does not rebind either view.
          */
-        void copy_from(const View &other) {
-            if (!has_value() || !other.has_value()) { throw std::runtime_error("View::copy_from requires non-empty views"); }
-            if (data() == data_of(other)) { return; }
-            if (schema() != other.schema()) { throw std::invalid_argument("View::copy_from requires matching schemas"); }
-            dispatch()->assign(data(), data_of(other));
-        }
+        void copy_from(const View &other);
 
         template <typename T> [[nodiscard]] T       *try_as() noexcept;
         template <typename T> [[nodiscard]] const T *try_as() const noexcept;
@@ -447,7 +456,18 @@ namespace hgraph
         [[nodiscard]] static void *data_of(const View &view) noexcept { return view.context.data; }
 
       private:
+        friend struct detail::ViewAccess;
+
         ValueViewContext context;
     };
 
+    namespace detail
+    {
+        struct ViewAccess
+        {
+            [[nodiscard]] static const ViewDispatch *dispatch(const View &view) noexcept { return view.context.dispatch; }
+            [[nodiscard]] static const void         *data(const View &view) noexcept { return view.context.data; }
+        };
+    }  // namespace detail
+
 }  // namespace hgraph

cpp/include/hgraph/types/v2/evaluation_engine.h

@@ -455,6 +455,7 @@ namespace hgraph::v2
         EvaluationEngineBuilder &evaluation_mode(EvaluationMode evaluation_mode) noexcept;
         EvaluationEngineBuilder &start_time(engine_time_t start_time) noexcept;
         EvaluationEngineBuilder &end_time(engine_time_t end_time) noexcept;
+        EvaluationEngineBuilder &cleanup_on_error(bool cleanup_on_error) noexcept;
         EvaluationEngineBuilder &add_life_cycle_observer(EvaluationLifeCycleObserver *observer);
 
         [[nodiscard]] EvaluationEngine build() const;
@@ -464,6 +465,7 @@ namespace hgraph::v2
         EvaluationMode m_evaluation_mode{EvaluationMode::SIMULATION};
         engine_time_t m_start_time{MIN_DT};
         engine_time_t m_end_time{MAX_DT};
+        bool m_cleanup_on_error{true};
         std::vector<EvaluationLifeCycleObserver *> m_life_cycle_observers;
     };
 }  // namespace hgraph::v2

cpp/include/hgraph/types/v2/graph.h

@@ -56,6 +56,7 @@ namespace hgraph::v2
         [[nodiscard]] const Traits &traits() const;
         [[nodiscard]] engine_time_t evaluation_time() const noexcept;
         [[nodiscard]] engine_time_t last_evaluation_time() const noexcept;
+        [[nodiscard]] SenderReceiverState *push_message_receiver() const noexcept;
         /** Prefix length of nodes treated as push sources during evaluation. */
         [[nodiscard]] int64_t push_source_nodes_end() const noexcept;
         [[nodiscard]] engine_time_t scheduled_time(size_t index) const;
@@ -65,6 +66,7 @@ namespace hgraph::v2
 
         void start();
         void stop();
+        void abandon() noexcept;
         void evaluate(engine_time_t when);
         void schedule_node(int64_t node_index, engine_time_t when, bool force_set = false);
 

cpp/include/hgraph/types/v2/graph_builder.h

@@ -39,6 +39,7 @@ namespace hgraph::v2
 
         [[nodiscard]] size_t size() const;
         [[nodiscard]] size_t alignment() const;
+        [[nodiscard]] size_t memory_size() const;
         [[nodiscard]] Graph make_graph(GraphEvaluationEngine evaluation_engine) const;
 
         [[nodiscard]] size_t node_builder_count() const noexcept { return m_node_builders.size(); }

cpp/include/hgraph/types/v2/node.h

@@ -51,8 +51,12 @@ namespace hgraph::v2
 
         [[nodiscard]] bool (*has_input)(const Node &node) noexcept;
         [[nodiscard]] bool (*has_output)(const Node &node) noexcept;
+        [[nodiscard]] bool (*has_error_output)(const Node &node) noexcept;
+        [[nodiscard]] bool (*has_recordable_state)(const Node &node) noexcept;
         [[nodiscard]] TSInputView (*input_view)(Node &node, engine_time_t evaluation_time);
         [[nodiscard]] TSOutputView (*output_view)(Node &node, engine_time_t evaluation_time);
+        [[nodiscard]] TSOutputView (*error_output_view)(Node &node, engine_time_t evaluation_time);
+        [[nodiscard]] TSOutputView (*recordable_state_view)(Node &node, engine_time_t evaluation_time);
         [[nodiscard]] std::string (*runtime_label)(const Node &node);
     };
 
@@ -82,6 +86,8 @@ namespace hgraph::v2
         NodeTypeEnum node_type{NodeTypeEnum::COMPUTE_NODE};
         const TSMeta *input_schema{nullptr};
         const TSMeta *output_schema{nullptr};
+        const TSMeta *error_output_schema{nullptr};
+        const TSMeta *recordable_state_schema{nullptr};
 
         std::span<const size_t> active_inputs{};
         std::span<const size_t> valid_inputs{};
@@ -156,8 +162,12 @@ namespace hgraph::v2
         [[nodiscard]] bool is_pull_source_node() const noexcept;
         [[nodiscard]] const TSMeta *input_schema() const noexcept;
         [[nodiscard]] const TSMeta *output_schema() const noexcept;
+        [[nodiscard]] const TSMeta *error_output_schema() const noexcept;
+        [[nodiscard]] const TSMeta *recordable_state_schema() const noexcept;
         [[nodiscard]] bool has_input() const noexcept;
         [[nodiscard]] bool has_output() const noexcept;
+        [[nodiscard]] bool has_error_output() const noexcept;
+        [[nodiscard]] bool has_recordable_state() const noexcept;
         [[nodiscard]] bool started() const noexcept;
         [[nodiscard]] bool uses_scheduler() const noexcept;
         [[nodiscard]] bool has_scheduler() const noexcept;
@@ -172,6 +182,8 @@ namespace hgraph::v2
         /** View access is delegated to the node family via NodeRuntimeOps. */
         [[nodiscard]] TSInputView input_view(engine_time_t evaluation_time = MIN_DT);
         [[nodiscard]] TSOutputView output_view(engine_time_t evaluation_time = MIN_DT);
+        [[nodiscard]] TSOutputView error_output_view(engine_time_t evaluation_time = MIN_DT);
+        [[nodiscard]] TSOutputView recordable_state_view(engine_time_t evaluation_time = MIN_DT);
         [[nodiscard]] const BuiltNodeSpec &spec() const noexcept;
 
         /** Apply top-level valid/all_valid gating before calling eval. */