@@ -1,6 +1,7 @@
 #pragma once
 
 #include <filesystem>
+#include <functional>
 #include <memory>
 #include <string_view>
 #include <vector>
@@ -125,6 +126,24 @@ namespace srt::core {
         ///       specs, (3) call \c ModelRegistry::unbindPackage(pkgId).
         Expected<void> unloadPackage(const std::filesystem::path &path);
 
+        // --- Destruction callbacks (DLL unload ordering) ---
+        // Register a callback to be invoked in ~Runtime(), BEFORE PluginFactory
+        // unloads plugin DLLs. This allows subsystems that hold shared_ptrs to
+        // plugin-DLL-resident objects (e.g. srt::g2p::Manager holding Task/
+        // SessionFactory instances whose vtables live in srt-driver-onnx.dll)
+        // to release those references while the plugin DLLs are still loaded.
+        //
+        // The callback executes during Runtime destruction, which happens
+        // BEFORE static singleton destructors run. Without this hook, a static
+        // singleton (e.g. srt::g2p::Manager) would release its shared_ptrs in
+        // its own destructor (after Runtime destruction), accessing freed
+        // plugin DLL memory through dangling vtable pointers.
+        //
+        // Callbacks run in reverse order of registration (LIFO). The callback
+        // MUST NOT capture a shared_ptr to the Runtime itself (would create a
+        // cycle); capture raw pointers or weak_ptr instead.
+        void addDestructionCallback(std::function<void()> callback);
+
     protected:
         static void registerModuleCategoryFactory(ModuleCategory *(*fac)(Runtime *));
 
 
@@ -119,6 +119,17 @@ namespace srt::g2p {
         std::vector<srt::dependency::ModuleMetadata> getModuleMetadatas(
             const srt::core::ContextKey &ctxKey);
 
+        /// Release all object references held by category ObjectPools and
+        /// clear loaded packages. Called automatically by setupG2pOnnxDriver's
+        /// Runtime destruction callback, so manual invocation is typically
+        /// unnecessary.
+        ///
+        /// This is the counterpart to the constructor: it performs the same
+        /// cleanup as the destructor but can be called early (before plugin
+        /// DLLs are unloaded) to prevent use-after-free when static singleton
+        /// destructors run after Runtime destruction.
+        void shutdown();
+
     protected:
         class Impl;
         std::unique_ptr<Impl> _impl;
 
@@ -39,6 +39,19 @@ namespace srt::core {
     }
 
     Runtime::Impl::~Impl() {
+        // Run destruction callbacks in LIFO order BEFORE deleting module
+        // categories or unloading plugin DLLs (the PluginFactory is owned by
+        // m_services, which is destroyed after this destructor body runs as
+        // part of member destruction). This lets subsystems release shared_ptrs
+        // to plugin-DLL-resident objects while the DLLs are still loaded.
+        for (auto it = m_destructionCallbacks.rbegin();
+             it != m_destructionCallbacks.rend(); ++it) {
+            if (*it) {
+                (*it)();
+            }
+        }
+        m_destructionCallbacks.clear();
+
         for (const auto &[name, cate] : m_moduleCategories) {
             (void) name;
             delete cate;
@@ -60,6 +73,10 @@ namespace srt::core {
 
     Runtime::~Runtime() = default;
 
+    void Runtime::addDestructionCallback(std::function<void()> callback) {
+        _impl->m_destructionCallbacks.push_back(std::move(callback));
+    }
+
     // --- Service registry (ARCH-03) ---
 
     ServiceRegistry &Runtime::services() {
 
@@ -2,6 +2,7 @@
 
 #include <atomic>
 #include <filesystem>
+#include <functional>
 #include <map>
 #include <memory>
 #include <shared_mutex>
@@ -75,6 +76,24 @@ namespace srt::core {
         // Shared mutex protecting category/contribute operations across packages.
         mutable std::shared_mutex m_su_mtx;
 
+        // --- Destruction callbacks (DLL unload ordering) ---
+        // Runtime is typically a local variable in the host (e.g. lite's
+        // SynthrtEngine::m_runtime), while some objects that reference Runtime
+        // resources (e.g. srt::g2p::Manager singleton holding Task/SessionFactory
+        // shared_ptrs that reference plugin DLL code) are static singletons
+        // whose destructors run AFTER the Runtime. When the Runtime destructs,
+        // PluginFactory unloads plugin DLLs (e.g. srt-driver-onnx.dll); the
+        // static singleton's later destructor would then access freed memory
+        // through dangling vtable pointers.
+        //
+        // Destruction callbacks run in ~Runtime::Impl (BEFORE PluginFactory
+        // unloads DLLs) so subsystems can release object references while the
+        // plugin DLLs are still loaded. Callbacks execute in reverse order of
+        // registration (LIFO), and are cleared after execution to break
+        // reference cycles (captured shared_ptrs would otherwise keep the
+        // callback itself alive).
+        std::vector<std::function<void()>> m_destructionCallbacks;
+
     public:
         static llvm::SmallVector<ModuleCategory *(*)(Runtime *)> moduleCategoryFactories;
     };
 
@@ -246,6 +246,16 @@ namespace srt::g2p {
     }
 
     PackageManager::Impl::~Impl() {
+        shutdown();
+    }
+
+    void PackageManager::Impl::shutdown() {
+        // Idempotent: safe to call from both shutdown() and the destructor.
+        // Also safe to call when m_categories is already empty (no-op).
+        if (m_categories.empty() && m_tasks.empty()) {
+            return;
+        }
+
         // Destruction order (matters!):
         //
         // 1. m_tasks.clear() — release the NO<Task> references held by the
@@ -614,6 +624,11 @@ namespace srt::g2p {
 
     PackageManager::~PackageManager() = default;
 
+    void PackageManager::shutdown() {
+        auto &impl = *static_cast<Impl *>(_impl.get());
+        impl.shutdown();
+    }
+
     srt::core::ModuleCategory *PackageManager::category(const std::string_view &name) const {
         auto      &impl = *static_cast<Impl *>(_impl.get());
         const auto it   = impl.m_categories.find(name);
 
@@ -52,6 +52,13 @@ namespace srt::g2p {
         void closeAllLoadedPackages();
         void refreshPackageIndexes(const srt::core::ContextKey &ctxKey);
 
+        /// Release all object references held by category ObjectPools, close
+        /// loaded packages, and delete categories. Idempotent (safe to call
+        /// again from the destructor). Called by PackageManager::shutdown()
+        /// which is invoked from the Runtime destruction callback registered
+        /// in setupG2pOnnxDriver.
+        void shutdown();
+
         /// Erase all per-context state for \p ctxKey (TD-02). Centralizes the
         /// 7-map erase previously duplicated in removeContextsByPrefix
         /// overloads. New per-context state should be added here so retire
 
@@ -223,6 +223,26 @@ namespace srt::g2p {
             driverCat->removeObjects(srt::g2p::kG2pOnnxDriverName);
             driverCat->addObject(srt::g2p::kG2pOnnxDriverName, factory);
 
+            // 5. Register a Runtime destruction callback to call
+            //    Manager::shutdown() BEFORE the Runtime (and its
+            //    PluginFactory) destructs. This releases Task/SessionFactory
+            //    shared_ptrs held by the Manager's category ObjectPools while
+            //    plugin DLLs (e.g. srt-driver-onnx.dll) are still loaded.
+            //
+            //    Without this, the Manager (a static singleton) would destruct
+            //    AFTER the Runtime (a local variable in the host), releasing
+            //    those shared_ptrs and invoking virtual destructors whose
+            //    vtables reside in already-unloaded plugin DLLs — a
+            //    use-after-free that crashes in shared_ptr::_Decref.
+            //
+            //    The callback captures `mgr` as a raw pointer (the Manager is
+            //    a static singleton whose address is stable throughout the
+            //    process lifetime, so raw-pointer capture is safe). shutdown()
+            //    is idempotent, so a later destructor call is a no-op.
+            runtime.addDestructionCallback([mgr]() {
+                mgr->shutdown();
+            });
+
             return srt::core::Expected<void>{};
         } catch (const std::exception &e) {
             // CODING-02 / ROBUST-02: do not let exceptions cross the public