1 files changed, 12 insertions, 2 deletions

diff --git a/src/lane.hpp b/src/lane.hpp
index 9b678d6..bd328b1 100644
--- a/src/lane.hpp
+++ b/src/lane.hpp
@@ -56,6 +56,7 @@ class Lane final
     /*
       Pending: The Lua VM hasn't done anything yet.
       Resuming: The user requested the lane to resume execution from Suspended state.
+      Closing: The user is joining the lane, specifically interrupting a suspended Lane.
       Suspended: returned from lua_resume, waiting for the client to request a lua_resume.
       Running, Suspended, Waiting: Thread is inside the Lua VM.
       Done, Error, Cancelled: Thread execution is outside the Lua VM. It can be lua_close()d.
@@ -66,6 +67,7 @@ class Lane final
         Running,
         Suspended,
         Resuming,
+        Closing,
         Waiting,
         Done,
         Error,
@@ -139,6 +141,10 @@ class Lane final
 
     ErrorTraceLevel const errorTraceLevel{ Basic };
 
+    // when Universe is collected, and an uncooperative Lane refuses to terminate, this flag becomes true
+    // in case of crash, that's the Lane's fault!
+    std::atomic_bool flaggedAfterUniverseGC{ false };
+
     [[nodiscard]]
     static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internalAllocator.alloc(size_); }
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
@@ -195,12 +201,14 @@ class Lane final
     static void PushMetatable(lua_State* L_);
     void pushStatusString(lua_State* L_) const;
     void pushIndexedResult(lua_State* L_, int key_) const;
+    [[nodiscard]]
+    int pushStoredResults(lua_State* L_) const;
     void resetResultsStorage(lua_State* L_, StackIndex self_idx_);
     void selfdestructAdd();
     [[nodiscard]]
     bool selfdestructRemove();
     void securizeDebugName(lua_State* L_);
-    void startThread(int priority_);
+    void startThread(lua_State* L_, int priority_, NativePrioFlag native_);
     void storeDebugName( std::string_view const& name_);
     [[nodiscard]]
     int storeResults(lua_State* L_);
@@ -208,7 +216,9 @@ class Lane final
     std::string_view threadStatusString() const;
     // wait until the lane stops working with its state (either Suspended or Done+)
     [[nodiscard]]
-    bool waitForCompletion(std::chrono::time_point<std::chrono::steady_clock> until_);
+    bool waitForCompletion(std::chrono::time_point<std::chrono::steady_clock> until_, bool const _acceptSuspended);
+    [[nodiscard]]
+    bool waitForJoin(lua_State* _L, std::chrono::time_point<std::chrono::steady_clock> until_);
 };
 
 // #################################################################################################