• Sync/coroutine mixing is a built-in capability: Within one request, "sync-pre auth → coro-handler DB lookup" and "coro-pre → sync-handler" can be declared directly. The framework auto-dispatches based on each entry's pre_kind/reg_kind. Developers never need to manually switch threads or wrap in std::async. This is a different design philosophy from Drogon's "handler picks one form, CoroMapper is a separate type" — Paozhu treats "is this a coroutine" as a property of each registration slot, not the handler as a whole.
• Built-in urlpath pre interception: Each route's pre_sync/co_pre chain up in declaration order into a serial pre chain; classify_step() decides direction based on return value — @ok (pass), same-name (continue), @exit (explicit stop), jump name (router.cpp:76-87). First non-empty return short-circuits; empty string is the only "pass" signal (router.cpp:458-461). Additionally, site-level pre/after hooks: run_site_hooks (sync :462) and co_run_site_hooks (coro :478) batch-run action_pre_lists/action_after_lists. When the list exceeds the limit, it truncates to the first site_hook_limit entries rather than dropping the whole thing (avoids silent auth failures).
• Flow stack draining: When the orchestration stack drains (pop_flow_index), if the driver is a sync chain but the popped entry is a coroutine, draining stops (:364-368); if coroutine-driven, it co_awaits inline (:865-873).

Drogon: Pre-handler logic lives in Filters (HttpFilter + ADD_FILTER_TO / GlobalFilters.cc) and Middlewares (HttpMiddleware, MiddlewaresFunction.cc + HttpAppFramework.h:718). The framework executes them before handlers, ordered by path / global ordering, decoupled from the routing table, reusable, sortable. The sync/async choice lives on the individual method form (binder's Blocking/Callback/future triad, or coroutines via separate CoroMapper). There is no slot-based mixed declaration

like "one route declares a sync-pre + coro-handler together".

auto ulink = std::make_unique("cms");
ulink->begin_commit();                 // BEGIN / BEGIN IMMEDIATE
ulink->edit_query("UPDATE sysuser set ...");
ulink->edit_query("INSERT INTO sysuser ...");
// Queries also go through the same write connection (reads what we just wrote, no master-replica replication lag)
orm::cms::LocalusersqlStruct row;
ulink->edit_query("SELECT * FROM sysuser WHERE ...", row);
if (ulink->iserror) ulink->rollback();
else                ulink->commit();

auto txnlink = std::make_unique("cms");
txnlink->begin_commit();// Multiple different model objects all lock onto the same transaction connection — cross-object transaction
orm::cms::Sysuser user_m;
user_m.lock_conn(txnlink->mysql_edit_conn);
user_m.where("adminid", 10000);
user_m.update("nickname");orm::cms::Sysroles role_m;              // Different table, different model class
role_m.lock_conn(txnlink->mysql_edit_conn);  // Also locks onto the same one
role_m.where("roleid", 50);
role_m.update("remark");user_m.unlock_conn();
role_m.unlock_conn();
txnlink->commit();                      // Unified commit or rollback

// The model object itself is the builder; conditions, caching, and query all chained in one go
Article art;
art.where("isopen", 1).whereEQ(art.Alias::aid, aid).use_cache();  // Chained conditions + query cache
co_await art.fetch_one();                          // Coroutine query, result backfills art
client << "
title:" << art.getTitle();
if (art.is_hit_cache()) { /* cache hit branch */ }// Pagination: directly returns (nav_min, nav_max, cur_page, total_page)
unsigned int page = client.get["page"].to_int();
auto [nav_min, nav_max, cur_page, total_page] = art.page(page, 10, 5); // page, per_page, nav width

using namespace drogon_model::postgres;
Mapper mapper(clientPtr);          // clientPtr = app().getDbClient()
Users user;
user.setUserId("pg"); user.setUserName("alice");
mapper.insert(user);                      // Sync write
auto u = mapper.findByPrimaryKey(2);      // PK lookup// Coroutine form
CoroMapper cmapper(clientPtr);
auto cu  = co_await cmapper.findByPrimaryKey(2);
auto us  = co_await cmapper.orderBy(Users::Cols::_user_id).limit(2).findAll();
auto one = co_await cmapper.findOne(Criteria(Users::Cols::_id, CompareOperator::EQ, 1));

1. Business code calls httppeer.add_timeloop_task("frametasks_timeloop", 100)→ peer.linktype = 7, timeloop_num = 100
2. server.cpp main loop: fps++ every frame
3. When fps % 100 == 0 AND timeloop_inflight == false:→ CAS sets timeloop_inflight→ Dispatches to clientrunpool thread pool (linktype==7 → timetasks_run)
4. Inside thread pool (threadpool.cpp:603):→ router.run_timeloop_task(peer, "frametasks_timeloop")→ call_sync_regfun finds the controller function with the same name (registered at serverwatch.cpp:67)→ After execution, inflight_release() resets timeloop_inflight

auto loop = drogon::app().getMainEventLoop();
// Run every 5 seconds
auto tid = loop->runEvery(5.0, [] { doSomething(); });
// Cancel
loop->cancel(tid);

#include "httppeer.h"
namespace http
{
//@urlpath(null,testrand)        // site(null = global slot) + URL path; no pre-filter
std::string testrand(std::shared_ptr peer)
{httppeer &client = peer->get_peer();client << "

class TestCtrl : public drogon::HttpController
{public:METHOD_LIST_BEGIN// Path "/testrand", GET method, binds testrand methodADD_METHOD_TO(TestCtrl::testrand, "/testrand", Get);METHOD_LIST_ENDvoid testrand(const HttpRequestPtr &req,std::function &&cb) const{auto resp = HttpResponse::newHttpResponse();resp->setBody("