feat: add recursion check and separate threads table

Align with upstream canonical ABI changes:
- Add ComponentInstance::parent for component hierarchy tracking
- Add reflexive_ancestors() and is_reflexive_ancestor_of() methods
- Add call_might_be_recursive() to detect recursive cross-component calls
- Separate thread entries into dedicated ComponentInstance::threads table
- Wrap Store::invoke caller in host Supertask with instance=nullptr
- Update all thread operations to use threads table instead of table
- Add tests for ancestry methods and recursion detection
- Bump canonical reference submodules

Refs: component-model commits 3a00c74, 5f49720

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: GordonSmith

include/cmcpp/context.hpp

@@ -15,6 +15,7 @@
 #include <thread>
 #include <condition_variable>
 #include <typeindex>
+#include <set>
 #include <unordered_map>
 #include <vector>
 #include <cstring>
@@ -1475,13 +1476,40 @@ namespace cmcpp
     struct ComponentInstance
     {
         Store *store = nullptr;
+        ComponentInstance *parent = nullptr;
         bool may_leave = true;
         bool may_enter = true;
         bool exclusive = false;
         uint32_t backpressure = 0;
         uint32_t num_waiting_to_enter = 0;
         HandleTables handles;
         InstanceTable table;
+        InstanceTable threads;
+
+        std::set<const ComponentInstance *> reflexive_ancestors() const
+        {
+            std::set<const ComponentInstance *> s;
+            const ComponentInstance *inst = this;
+            while (inst != nullptr)
+            {
+                s.insert(inst);
+                inst = inst->parent;
+            }
+            return s;
+        }
+
+        bool is_reflexive_ancestor_of(const ComponentInstance *other) const
+        {
+            while (other != nullptr)
+            {
+                if (this == other)
+                {
+                    return true;
+                }
+                other = other->parent;
+            }
+            return false;
+        }
     };
 
     inline void ensure_may_leave(ComponentInstance &inst, const HostTrap &trap)
@@ -1509,6 +1537,40 @@ namespace cmcpp
         inst.backpressure -= 1;
     }
 
+    inline bool call_might_be_recursive(const SupertaskPtr &caller, const ComponentInstance *callee_inst)
+    {
+        if (!caller || !callee_inst)
+        {
+            return false;
+        }
+        if (caller->instance == nullptr)
+        {
+            auto current = caller.get();
+            while (current != nullptr)
+            {
+                if (current->instance)
+                {
+                    auto caller_ancestors = current->instance->reflexive_ancestors();
+                    auto callee_ancestors = callee_inst->reflexive_ancestors();
+                    for (auto *a : caller_ancestors)
+                    {
+                        if (callee_ancestors.count(a))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                current = current->parent.get();
+            }
+            return false;
+        }
+        else
+        {
+            return caller->instance->is_reflexive_ancestor_of(callee_inst) ||
+                   callee_inst->is_reflexive_ancestor_of(caller->instance);
+        }
+    }
+
     class Task : public std::enable_shared_from_this<Task>
     {
     public:
@@ -1796,7 +1858,7 @@ namespace cmcpp
         trap_if(trap_cx, inst == nullptr, "thread.resume-later missing component instance");
         ensure_may_leave(*inst, trap);
 
-        auto entry = inst->table.get<ThreadEntry>(thread_index, trap);
+        auto entry = inst->threads.get<ThreadEntry>(thread_index, trap);
         auto other_thread = entry->thread();
         trap_if(trap_cx, !other_thread, "thread.resume-later null thread");
         trap_if(trap_cx, !other_thread->suspended(), "thread not suspended");
@@ -1810,7 +1872,7 @@ namespace cmcpp
         trap_if(trap_cx, inst == nullptr, "thread.yield-to missing component instance");
         ensure_may_leave(*inst, trap);
 
-        auto entry = inst->table.get<ThreadEntry>(thread_index, trap);
+        auto entry = inst->threads.get<ThreadEntry>(thread_index, trap);
         auto other_thread = entry->thread();
         trap_if(trap_cx, !other_thread, "thread.yield-to null thread");
         trap_if(trap_cx, !other_thread->suspended(), "thread not suspended");
@@ -1836,7 +1898,7 @@ namespace cmcpp
         trap_if(trap_cx, inst == nullptr, "thread.switch-to missing component instance");
         ensure_may_leave(*inst, trap);
 
-        auto entry = inst->table.get<ThreadEntry>(thread_index, trap);
+        auto entry = inst->threads.get<ThreadEntry>(thread_index, trap);
         auto other_thread = entry->thread();
         trap_if(trap_cx, !other_thread, "thread.switch-to null thread");
         trap_if(trap_cx, !other_thread->suspended(), "thread not suspended");
@@ -1881,7 +1943,7 @@ namespace cmcpp
             {});
         trap_if(trap_cx, !thread || !thread->suspended(), "thread.new-ref failed to create suspended thread");
 
-        uint32_t index = inst->table.add(std::make_shared<ThreadEntry>(thread), trap);
+        uint32_t index = inst->threads.add(std::make_shared<ThreadEntry>(thread), trap);
         thread->set_index(index);
         return index;
     }

include/cmcpp/runtime.hpp

@@ -443,7 +443,10 @@ namespace cmcpp
         {
             return Call();
         }
-        return func(*this, std::move(caller), std::move(on_start), std::move(on_resolve));
+        auto host_caller = std::make_shared<Supertask>();
+        host_caller->instance = nullptr;
+        host_caller->parent = std::move(caller);
+        return func(*this, std::move(host_caller), std::move(on_start), std::move(on_resolve));
     }
 
     inline void Store::tick()

ref/component-model

@@ -800,7 +800,7 @@ TEST_CASE("thread.yield-to resumes suspended thread")
         true,
         {});
     REQUIRE(other->suspended());
-    uint32_t other_index = inst.table.add(std::make_shared<ThreadEntry>(other), trap);
+    uint32_t other_index = inst.threads.add(std::make_shared<ThreadEntry>(other), trap);
 
     auto task = std::make_shared<Task>(inst, async_opts);
     auto current = Thread::create(
@@ -855,7 +855,7 @@ TEST_CASE("thread.yield-to traps if target not suspended")
         },
         true,
         {});
-    uint32_t other_index = inst.table.add(std::make_shared<ThreadEntry>(other), trap);
+    uint32_t other_index = inst.threads.add(std::make_shared<ThreadEntry>(other), trap);
 
     auto task = std::make_shared<Task>(inst, async_opts);
     auto current = Thread::create(
@@ -912,7 +912,7 @@ TEST_CASE("thread.new-indirect creates a suspended thread")
         [task, &inst, &trap, &table, ran](bool)
         {
             uint32_t idx = canon_thread_new_indirect(false, *task, table, 1, 123, trap);
-            auto entry = inst.table.get<ThreadEntry>(idx, trap);
+            auto entry = inst.threads.get<ThreadEntry>(idx, trap);
             REQUIRE(entry->thread());
             CHECK(entry->thread()->suspended());
 
@@ -964,7 +964,7 @@ TEST_CASE("thread.new-ref and spawn-ref create threads")
                                                     {
                                                         CHECK(c == 7u);
                                                         *ran_new = true; }, 7, trap);
-            auto new_entry = inst.table.get<ThreadEntry>(idx_new, trap);
+            auto new_entry = inst.threads.get<ThreadEntry>(idx_new, trap);
             REQUIRE(new_entry->thread());
             CHECK(new_entry->thread()->suspended());
             canon_thread_resume_later(*task, idx_new, trap);
@@ -973,7 +973,7 @@ TEST_CASE("thread.new-ref and spawn-ref create threads")
                                                         {
                                                             CHECK(c == 9u);
                                                             *ran_spawn = true; }, 9, trap);
-            auto spawn_entry = inst.table.get<ThreadEntry>(idx_spawn, trap);
+            auto spawn_entry = inst.threads.get<ThreadEntry>(idx_spawn, trap);
             REQUIRE(spawn_entry->thread());
             CHECK_FALSE(spawn_entry->thread()->suspended());
             return false;
@@ -1025,7 +1025,7 @@ TEST_CASE("thread.spawn-indirect resumes and runs")
         [task, &inst, &trap, &table](bool)
         {
             uint32_t idx = canon_thread_spawn_indirect(false, *task, table, 1, 55, trap);
-            auto entry = inst.table.get<ThreadEntry>(idx, trap);
+            auto entry = inst.threads.get<ThreadEntry>(idx, trap);
             REQUIRE(entry->thread());
             CHECK_FALSE(entry->thread()->suspended());
             return false;
@@ -1089,7 +1089,7 @@ TEST_CASE("thread.switch-to schedules a suspended thread")
         },
         true,
         {});
-    uint32_t other_index = inst.table.add(std::make_shared<ThreadEntry>(other), trap);
+    uint32_t other_index = inst.threads.add(std::make_shared<ThreadEntry>(other), trap);
 
     auto task = std::make_shared<Task>(inst, async_opts);
     auto current = Thread::create(
@@ -1362,6 +1362,141 @@ TEST_CASE("InstanceContext wires canonical options")
     CHECK(observed_events.back().payload == 0xCAFE'BEEFu);
 }
 
+TEST_CASE("ComponentInstance reflexive_ancestors returns self and parents")
+{
+    Store store;
+    ComponentInstance root;
+    root.store = &store;
+
+    ComponentInstance child;
+    child.store = &store;
+    child.parent = &root;
+
+    ComponentInstance grandchild;
+    grandchild.store = &store;
+    grandchild.parent = &child;
+
+    auto root_ancestors = root.reflexive_ancestors();
+    CHECK(root_ancestors.size() == 1);
+    CHECK(root_ancestors.count(&root) == 1);
+
+    auto child_ancestors = child.reflexive_ancestors();
+    CHECK(child_ancestors.size() == 2);
+    CHECK(child_ancestors.count(&child) == 1);
+    CHECK(child_ancestors.count(&root) == 1);
+
+    auto gc_ancestors = grandchild.reflexive_ancestors();
+    CHECK(gc_ancestors.size() == 3);
+    CHECK(gc_ancestors.count(&grandchild) == 1);
+    CHECK(gc_ancestors.count(&child) == 1);
+    CHECK(gc_ancestors.count(&root) == 1);
+}
+
+TEST_CASE("ComponentInstance is_reflexive_ancestor_of checks ancestry")
+{
+    Store store;
+    ComponentInstance root;
+    root.store = &store;
+
+    ComponentInstance child;
+    child.store = &store;
+    child.parent = &root;
+
+    ComponentInstance grandchild;
+    grandchild.store = &store;
+    grandchild.parent = &child;
+
+    ComponentInstance unrelated;
+    unrelated.store = &store;
+
+    CHECK(root.is_reflexive_ancestor_of(&root));
+    CHECK(root.is_reflexive_ancestor_of(&child));
+    CHECK(root.is_reflexive_ancestor_of(&grandchild));
+    CHECK(child.is_reflexive_ancestor_of(&child));
+    CHECK(child.is_reflexive_ancestor_of(&grandchild));
+    CHECK_FALSE(child.is_reflexive_ancestor_of(&root));
+    CHECK_FALSE(grandchild.is_reflexive_ancestor_of(&root));
+    CHECK_FALSE(root.is_reflexive_ancestor_of(&unrelated));
+    CHECK_FALSE(unrelated.is_reflexive_ancestor_of(&root));
+}
+
+TEST_CASE("call_might_be_recursive detects same-instance recursion")
+{
+    Store store;
+    ComponentInstance inst;
+    inst.store = &store;
+
+    auto caller = std::make_shared<Supertask>();
+    caller->instance = &inst;
+
+    CHECK(call_might_be_recursive(caller, &inst));
+}
+
+TEST_CASE("call_might_be_recursive detects ancestor recursion")
+{
+    Store store;
+    ComponentInstance root;
+    root.store = &store;
+
+    ComponentInstance child;
+    child.store = &store;
+    child.parent = &root;
+
+    auto caller = std::make_shared<Supertask>();
+    caller->instance = &root;
+
+    CHECK(call_might_be_recursive(caller, &child));
+    CHECK(call_might_be_recursive(caller, &root));
+
+    auto child_caller = std::make_shared<Supertask>();
+    child_caller->instance = &child;
+
+    CHECK(call_might_be_recursive(child_caller, &root));
+}
+
+TEST_CASE("call_might_be_recursive returns false for unrelated instances")
+{
+    Store store;
+    ComponentInstance inst_a;
+    inst_a.store = &store;
+
+    ComponentInstance inst_b;
+    inst_b.store = &store;
+
+    auto caller = std::make_shared<Supertask>();
+    caller->instance = &inst_a;
+
+    CHECK_FALSE(call_might_be_recursive(caller, &inst_b));
+}
+
+TEST_CASE("call_might_be_recursive walks host caller chain")
+{
+    Store store;
+    ComponentInstance inst;
+    inst.store = &store;
+
+    // Simulate host caller (instance == nullptr) with a parent that has an instance
+    auto inner = std::make_shared<Supertask>();
+    inner->instance = &inst;
+
+    auto host_caller = std::make_shared<Supertask>();
+    host_caller->instance = nullptr;
+    host_caller->parent = inner;
+
+    CHECK(call_might_be_recursive(host_caller, &inst));
+
+    // Unrelated instance should return false
+    ComponentInstance other;
+    other.store = &store;
+    CHECK_FALSE(call_might_be_recursive(host_caller, &other));
+}
+
+TEST_CASE("call_might_be_recursive returns false for null caller")
+{
+    ComponentInstance inst;
+    CHECK_FALSE(call_might_be_recursive(nullptr, &inst));
+}
+
 TEST_CASE("Canonical callbacks surface waitable events")
 {
     ComponentInstance inst;