Fix another issue, with Dereferencing SIGNAL output bound to input.

hhenson · hhenson · commit 7d1f99ab5a3d · 2026-01-31T13:48:41.000+04:00
diff --git a/cpp/include/hgraph/builders/time_series_types/time_series_signal_input_builder.h b/cpp/include/hgraph/builders/time_series_types/time_series_signal_input_builder.h
@@ -12,7 +12,12 @@ namespace hgraph {
 
     struct HGRAPH_EXPORT TimeSeriesSignalInputBuilder : InputBuilder {
         using ptr = nb::ref<TimeSeriesSignalInputBuilder>;
-        using InputBuilder::InputBuilder;
+
+        // Constructor for signal without impl (basic signal)
+        TimeSeriesSignalInputBuilder() = default;
+
+        // Constructor for signal with impl (signal bound to a dereferenced type)
+        explicit TimeSeriesSignalInputBuilder(InputBuilder::ptr impl_builder);
 
         time_series_input_s_ptr make_instance(node_ptr owning_node) const override;
 
@@ -27,7 +32,10 @@ namespace hgraph {
         [[nodiscard]] size_t type_alignment() const override;
 
         static void register_with_nanobind(nb::module_ &m);
+
+    private:
+        InputBuilder::ptr impl_builder_{nullptr};
     };
 } // namespace hgraph
 
-#endif  // TIME_SERIES_SIGNAL_INPUT_BUILDER_H
+#endif  // TIME_SERIES_SIGNAL_INPUT_BUILDER_H
diff --git a/cpp/include/hgraph/types/ts_signal.h b/cpp/include/hgraph/types/ts_signal.h
@@ -36,14 +36,22 @@ namespace hgraph {
 
         void make_passive() override;
 
+        // Override to delegate to impl or propagate to children
+        bool bind_output(time_series_output_s_ptr output) override;
+
+        void un_bind_output(bool unbind_refs) override;
+
         void do_un_bind_output(bool unbind_refs) override;
 
+        [[nodiscard]] bool bound() const override;
+
         VISITOR_SUPPORT()
 
     private:
         friend TimeSeriesSignalInputBuilder;
+        TimeSeriesInput::s_ptr _impl; // Delegate input for when bound to dereferenced type
         mutable std::vector<TimeSeriesInput::s_ptr> _ts_values; // Lazily created child signals
     };
 }
 
-#endif //TS_SIGNAL_H
+#endif //TS_SIGNAL_H
diff --git a/cpp/src/cpp/builders/time_series_types/time_series_signal_input_builder.cpp b/cpp/src/cpp/builders/time_series_types/time_series_signal_input_builder.cpp
@@ -4,12 +4,27 @@
 #include <hgraph/util/arena_enable_shared_from_this.h>
 
 namespace hgraph {
+    TimeSeriesSignalInputBuilder::TimeSeriesSignalInputBuilder(InputBuilder::ptr impl_builder)
+        : impl_builder_{std::move(impl_builder)} {}
+
     time_series_input_s_ptr TimeSeriesSignalInputBuilder::make_instance(node_ptr owning_node) const {
-        return arena_make_shared_as<TimeSeriesSignalInput, TimeSeriesInput>(owning_node);
+        auto sig = arena_make_shared_as<TimeSeriesSignalInput, TimeSeriesInput>(owning_node);
+        if (impl_builder_) {
+            // Create the impl input with the signal as its parent, matching Python behavior
+            auto signal_ptr = static_cast<TimeSeriesSignalInput*>(sig.get());
+            signal_ptr->_impl = impl_builder_->make_instance(signal_ptr);
+        }
+        return sig;
     }
 
     time_series_input_s_ptr TimeSeriesSignalInputBuilder::make_instance(time_series_input_ptr owning_input) const {
-        return arena_make_shared_as<TimeSeriesSignalInput, TimeSeriesInput>(owning_input);
+        auto sig = arena_make_shared_as<TimeSeriesSignalInput, TimeSeriesInput>(owning_input);
+        if (impl_builder_) {
+            // Create the impl input with the signal as its parent, matching Python behavior
+            auto signal_ptr = static_cast<TimeSeriesSignalInput*>(sig.get());
+            signal_ptr->_impl = impl_builder_->make_instance(signal_ptr);
+        }
+        return sig;
     }
 
     void TimeSeriesSignalInputBuilder::release_instance(time_series_input_ptr item) const {
@@ -21,19 +36,30 @@ namespace hgraph {
             throw std::runtime_error("TimeSeriesSignalInputBuilder::release_instance: expected TimeSeriesSignalInput but got different type");
         }
         InputBuilder::release_instance(signal_input);
+        // Release impl if present
+        if (signal_input->_impl && impl_builder_) {
+            impl_builder_->release_instance(signal_input->_impl.get());
+        }
         if (signal_input->_ts_values.empty()) { return; }
         for (auto &ts_value: signal_input->_ts_values) { release_instance(ts_value.get()); }
     }
 
     size_t TimeSeriesSignalInputBuilder::memory_size() const {
-        return add_canary_size(sizeof(TimeSeriesSignalInput));
+        size_t total = add_canary_size(sizeof(TimeSeriesSignalInput));
+        if (impl_builder_) {
+            total = align_size(total, impl_builder_->type_alignment());
+            total += impl_builder_->memory_size();
+        }
+        return total;
     }
 
     size_t TimeSeriesSignalInputBuilder::type_alignment() const {
         return alignof(TimeSeriesSignalInput);
     }
 
     void TimeSeriesSignalInputBuilder::register_with_nanobind(nb::module_ &m) {
-        nb::class_<TimeSeriesSignalInputBuilder, InputBuilder>(m, "InputBuilder_TS_Signal").def(nb::init<>());
+        nb::class_<TimeSeriesSignalInputBuilder, InputBuilder>(m, "InputBuilder_TS_Signal")
+            .def(nb::init<>())
+            .def(nb::init<InputBuilder::ptr>(), "impl_builder"_a);
     }
 } // namespace hgraph
diff --git a/cpp/src/cpp/types/ts_signal.cpp b/cpp/src/cpp/types/ts_signal.cpp
@@ -7,6 +7,10 @@ namespace hgraph {
     nb::object TimeSeriesSignalInput::py_delta_value() const { return py_value(); }
 
     TimeSeriesInput::s_ptr TimeSeriesSignalInput::get_input(size_t index) {
+        // If we have an impl, delegate to it
+        if (_impl) {
+            return _impl->get_input(index);
+        }
         // This signal has been bound to a free bundle or a TSL so will be bound item-wise
         // Create child signals on demand, similar to Python implementation
         while (index >= _ts_values.size()) {
@@ -19,20 +23,29 @@ namespace hgraph {
     }
 
     bool TimeSeriesSignalInput::valid() const {
+        if (_impl) {
+            return _impl->valid();
+        }
         if (!_ts_values.empty()) {
             return std::ranges::any_of(_ts_values, [](const auto &item) { return item->valid(); });
         }
         return BaseTimeSeriesInput::valid();
     }
 
     bool TimeSeriesSignalInput::modified() const {
+        if (_impl) {
+            return _impl->modified();
+        }
         if (!_ts_values.empty()) {
             return std::ranges::any_of(_ts_values, [](const auto &item) { return item->modified(); });
         }
         return BaseTimeSeriesInput::modified();
     }
 
     engine_time_t TimeSeriesSignalInput::last_modified_time() const {
+        if (_impl) {
+            return _impl->last_modified_time();
+        }
         if (!_ts_values.empty()) {
             engine_time_t max_time = MIN_DT;
             for (const auto &item: _ts_values) { max_time = std::max(max_time, item->last_modified_time()); }
@@ -44,23 +57,53 @@ namespace hgraph {
     void TimeSeriesSignalInput::make_active() {
         if (active()) { return; }
         BaseTimeSeriesInput::make_active();
-        if (!_ts_values.empty()) {
+        if (_impl) {
+            _impl->make_active();
+        } else if (!_ts_values.empty()) {
             for (auto &item: _ts_values) { item->make_active(); }
         }
     }
 
     void TimeSeriesSignalInput::make_passive() {
         if (!active()) { return; }
         BaseTimeSeriesInput::make_passive();
-        if (!_ts_values.empty()) {
+        if (_impl) {
+            _impl->make_passive();
+        } else if (!_ts_values.empty()) {
             for (auto &item: _ts_values) { item->make_passive(); }
         }
     }
 
+    bool TimeSeriesSignalInput::bind_output(time_series_output_s_ptr output) {
+        if (_impl) {
+            return _impl->bind_output(output);
+        }
+        return BaseTimeSeriesInput::bind_output(output);
+    }
+
+    void TimeSeriesSignalInput::un_bind_output(bool unbind_refs) {
+        if (_impl) {
+            _impl->un_bind_output(unbind_refs);
+        } else {
+            BaseTimeSeriesInput::un_bind_output(unbind_refs);
+        }
+    }
+
     void TimeSeriesSignalInput::do_un_bind_output(bool unbind_refs) {
+        if (_impl) {
+            _impl->un_bind_output(unbind_refs);
+        }
         if (!_ts_values.empty()) {
             for (auto &item: _ts_values) { item->un_bind_output(unbind_refs); }
+            _ts_values.clear();
+        }
+    }
+
+    bool TimeSeriesSignalInput::bound() const {
+        if (_impl) {
+            return _impl->bound();
         }
+        return BaseTimeSeriesInput::bound() || !_ts_values.empty();
     }
 
-} // namespace hgraph
+} // namespace hgraph
diff --git a/hgraph/_use_cpp_runtime.py b/hgraph/_use_cpp_runtime.py
@@ -93,7 +93,10 @@ def _make_tsw_input_builder(self, value_tp):
 
             def make_input_builder(self, value_tp):
                 return {
-                    hgraph.HgSignalMetaData: lambda: _hgraph.InputBuilder_TS_Signal(),
+                    hgraph.HgSignalMetaData: lambda: (
+                        _hgraph.InputBuilder_TS_Signal(self.make_input_builder(value_tp.value_tp))
+                        if value_tp.value_tp else _hgraph.InputBuilder_TS_Signal()
+                    ),
                     hgraph.HgTSTypeMetaData: lambda: _ts_input_builder_type_for(value_tp.value_scalar_tp)(),
                     hgraph.HgTSWTypeMetaData: lambda: self._make_tsw_input_builder(value_tp),
                     hgraph.HgTSLTypeMetaData: lambda: _hgraph.InputBuilder_TSL(
