diff --git a/include/cubescript/cubescript.hh b/include/cubescript/cubescript.hh
index 16f26a1..b872bf7 100644
--- a/include/cubescript/cubescript.hh
+++ b/include/cubescript/cubescript.hh
@@ -529,8 +529,6 @@ enum class loop_state {
 };
 
 struct LIBCUBESCRIPT_EXPORT state {
-    thread_state *p_tstate = nullptr;
-
     int identflags = 0;
 
     state();
@@ -695,6 +693,8 @@ struct LIBCUBESCRIPT_EXPORT state {
 
     void print_var(global_var const &v) const;
 
+    thread_state *p_tstate = nullptr;
+
 private:
     hook_func set_call_hook(hook_func func);
     var_print_func set_var_printer(var_print_func func);
@@ -728,15 +728,15 @@ private:
     void *alloc(void *ptr, size_t olds, size_t news);
 };
 
-struct stack_state_node {
-    stack_state_node const *next;
-    ident const *id;
-    int index;
-};
-
 struct stack_state {
+    struct node {
+        node const *next;
+        ident const *id;
+        int index;
+    };
+
     stack_state() = delete;
-    stack_state(state &cs, stack_state_node *nd = nullptr, bool gap = false);
+    stack_state(thread_state &ts, node *nd = nullptr, bool gap = false);
     stack_state(stack_state const &) = delete;
     stack_state(stack_state &&st);
     ~stack_state();
@@ -744,12 +744,12 @@ struct stack_state {
     stack_state &operator=(stack_state const &) = delete;
     stack_state &operator=(stack_state &&);
 
-    stack_state_node const *get() const;
+    node const *get() const;
     bool gap() const;
 
 private:
-    state &p_state;
-    stack_state_node *p_node;
+    thread_state &p_state;
+    node *p_node;
     bool p_gap;
 };
 
@@ -774,25 +774,30 @@ struct LIBCUBESCRIPT_EXPORT error {
         return p_stack;
     }
 
-    error(state &cs, std::string_view msg):
-        p_errmsg(), p_stack(cs)
+    template<typename ...A>
+    error(state &cs, std::string_view msg, A const &...args):
+        error{*cs.p_tstate, msg, args...}
+    {}
+
+    error(thread_state &ts, std::string_view msg):
+        p_errmsg{}, p_stack{ts}
     {
         char *sp;
-        char *buf = request_buf(cs, msg.size(), sp);
+        char *buf = request_buf(ts, msg.size(), sp);
         std::memcpy(buf, msg.data(), msg.size());
         buf[msg.size()] = '\0';
         p_errmsg = std::string_view{sp, buf + msg.size()};
-        p_stack = save_stack(cs);
+        p_stack = save_stack(ts);
     }
 
     template<typename ...A>
-    error(state &cs, std::string_view msg, A const &...args):
-        p_errmsg(), p_stack(cs)
+    error(thread_state &ts, std::string_view msg, A const &...args):
+        p_errmsg{}, p_stack{ts}
     {
         std::size_t sz = msg.size() + 64;
         char *buf, *sp;
         for (;;) {
-            buf = request_buf(cs, sz, sp);
+            buf = request_buf(ts, sz, sp);
             int written = std::snprintf(buf, sz, msg.data(), args...);
             if (written <= 0) {
                 throw internal_error{"format error"};
@@ -802,12 +807,12 @@ struct LIBCUBESCRIPT_EXPORT error {
             sz = std::size_t(written);
         }
         p_errmsg = std::string_view{sp, buf + sz};
-        p_stack = save_stack(cs);
+        p_stack = save_stack(ts);
     }
 
 private:
-    stack_state save_stack(state &cs);
-    char *request_buf(state &cs, std::size_t bufs, char *&sp);
+    stack_state save_stack(thread_state &ts);
+    char *request_buf(thread_state &ts, std::size_t bufs, char *&sp);
 
     std::string_view p_errmsg;
     stack_state p_stack;
diff --git a/src/cs_error.cc b/src/cs_error.cc
index 5f0f6ac..f24d03c 100644
--- a/src/cs_error.cc
+++ b/src/cs_error.cc
@@ -6,10 +6,10 @@
 namespace cubescript {
 
 LIBCUBESCRIPT_EXPORT char *error::request_buf(
-    state &cs, std::size_t bufs, char *&sp
+    thread_state &ts, std::size_t bufs, char *&sp
 ) {
-    charbuf &cb = cs.p_tstate->errbuf;
-    codegen_state *gs = cs.p_tstate->cstate;
+    charbuf &cb = ts.errbuf;
+    codegen_state *gs = ts.cstate;
     cb.clear();
     std::size_t sz = 0;
     if (gs) {
@@ -44,27 +44,26 @@ LIBCUBESCRIPT_EXPORT char *error::request_buf(
     return &cb[sz];
 }
 
-LIBCUBESCRIPT_EXPORT stack_state error::save_stack(state &cs) {
-    auto &ts = *cs.p_tstate;
+LIBCUBESCRIPT_EXPORT stack_state error::save_stack(thread_state &ts) {
     integer_var *dalias = static_cast<integer_var *>(
         ts.istate->identmap[ID_IDX_DBGALIAS]
     );
     if (!dalias->get_value()) {
-        return stack_state(cs, nullptr, !!cs.p_tstate->callstack);
+        return stack_state{ts, nullptr, !!ts.callstack};
     }
     int total = 0, depth = 0;
-    for (ident_link *l = cs.p_tstate->callstack; l; l = l->next) {
+    for (ident_link *l = ts.callstack; l; l = l->next) {
         total++;
     }
     if (!total) {
-        return stack_state(cs, nullptr, false);
+        return stack_state{ts, nullptr, false};
     }
-    stack_state_node *st = ts.istate->create_array<stack_state_node>(
+    stack_state::node *st = ts.istate->create_array<stack_state::node>(
         std::min(total, dalias->get_value())
     );
-    stack_state_node *ret = st, *nd = st;
+    stack_state::node *ret = st, *nd = st;
     ++st;
-    for (ident_link *l = cs.p_tstate->callstack; l; l = l->next) {
+    for (ident_link *l = ts.callstack; l; l = l->next) {
         ++depth;
         if (depth < dalias->get_value()) {
             nd->id = l->id;
@@ -81,7 +80,7 @@ LIBCUBESCRIPT_EXPORT stack_state error::save_stack(state &cs) {
             nd->next = nullptr;
         }
     }
-    return stack_state(cs, ret, total > dalias->get_value());
+    return stack_state{ts, ret, total > dalias->get_value()};
 }
 
 } /* namespace cubescript */
diff --git a/src/cs_gen.cc b/src/cs_gen.cc
index 8f66959..b7059b5 100644
--- a/src/cs_gen.cc
+++ b/src/cs_gen.cc
@@ -69,7 +69,7 @@ void codegen_state::skip_comments() {
         if (current() == '\\') {
             char c = current(1);
             if ((c != '\r') && (c != '\n')) {
-                throw error{*ts.pstate, "invalid line break"};
+                throw error{ts, "invalid line break"};
             }
             /* skip backslash */
             next_char();
@@ -583,7 +583,7 @@ static void compileblockmain(codegen_state &gs, int wordtype, int prevargs) {
     for (int brak = 1; brak;) {
         switch (gs.skip_until("@\"/[]")) {
             case '\0':
-                throw error{*gs.ts.pstate, "missing \"]\""};
+                throw error{gs.ts, "missing \"]\""};
                 return;
             case '\"':
                 gs.get_str();
@@ -612,7 +612,7 @@ static void compileblockmain(codegen_state &gs, int wordtype, int prevargs) {
                 if (brak > level) {
                     continue;
                 } else if (brak < level) {
-                    throw error{*gs.ts.pstate, "too many @s"};
+                    throw error{gs.ts, "too many @s"};
                     return;
                 }
                 if (!concs && prevargs >= MAX_RESULTS) {
@@ -1435,7 +1435,7 @@ endstatement:
         switch (gs.skip_until(")];/\n")) {
             case '\0':
                 if (gs.current() != brak) {
-                    throw error{*gs.ts.pstate, "missing \"%c\"", char(brak)};
+                    throw error{gs.ts, "missing \"%c\"", char(brak)};
                     return;
                 }
                 return;
@@ -1445,7 +1445,7 @@ endstatement:
                     gs.next_char();
                     return;
                 }
-                throw error{*gs.ts.pstate, "unexpected \"%c\"", gs.current()};
+                throw error{gs.ts, "unexpected \"%c\"", gs.current()};
                 return;
             case '/':
                 gs.next_char();
diff --git a/src/cs_parser.cc b/src/cs_parser.cc
index 264d8bd..b86b6ec 100644
--- a/src/cs_parser.cc
+++ b/src/cs_parser.cc
@@ -399,7 +399,7 @@ LIBCUBESCRIPT_EXPORT std::size_t list_parser::count() {
 
 LIBCUBESCRIPT_EXPORT string_ref list_parser::get_item() const {
     if (!p_quoted_item.empty() && (p_quoted_item.front() == '"')) {
-        charbuf buf{p_state->p_tstate->istate};
+        charbuf buf{*p_state};
         unescape_string(std::back_inserter(buf), p_item);
         return string_ref{*p_state, buf.str()};
     }
diff --git a/src/cs_std.cc b/src/cs_std.cc
index f979f22..3234530 100644
--- a/src/cs_std.cc
+++ b/src/cs_std.cc
@@ -5,5 +5,6 @@
 namespace cubescript {
 
 charbuf::charbuf(state &cs): charbuf{cs.p_tstate->istate} {}
+charbuf::charbuf(thread_state &ts): charbuf{ts.istate} {}
 
 } /* namespace cubescript */
diff --git a/src/cs_std.hh b/src/cs_std.hh
index 748b926..e1e590d 100644
--- a/src/cs_std.hh
+++ b/src/cs_std.hh
@@ -13,8 +13,6 @@
 
 namespace cubescript {
 
-struct state;
-
 /* run func, call the second one after finishing */
 
 template<typename F1, typename F2>
@@ -110,6 +108,7 @@ struct valbuf {
 struct charbuf: valbuf<char> {
     charbuf(internal_state *cs): valbuf<char>{cs} {}
     charbuf(state &cs);
+    charbuf(thread_state &ts);
 
     void append(char const *beg, char const *end) {
         valbuf<char>::append(beg, end);
diff --git a/src/cs_vm.cc b/src/cs_vm.cc
index 1ecc733..339a534 100644
--- a/src/cs_vm.cc
+++ b/src/cs_vm.cc
@@ -28,11 +28,11 @@ static inline void pop_alias(ident *id) {
     }
 }
 
-stack_state::stack_state(state &cs, stack_state_node *nd, bool gap):
-    p_state(cs), p_node(nd), p_gap(gap)
+stack_state::stack_state(thread_state &ts, node *nd, bool gap):
+    p_state{ts}, p_node{nd}, p_gap{gap}
 {}
 stack_state::stack_state(stack_state &&st):
-    p_state(st.p_state), p_node(st.p_node), p_gap(st.p_gap)
+    p_state{st.p_state}, p_node{st.p_node}, p_gap{st.p_gap}
 {
     st.p_node = nullptr;
     st.p_gap = false;
@@ -40,10 +40,10 @@ stack_state::stack_state(stack_state &&st):
 
 stack_state::~stack_state() {
     size_t len = 0;
-    for (stack_state_node const *nd = p_node; nd; nd = nd->next) {
+    for (node const *nd = p_node; nd; nd = nd->next) {
         ++len;
     }
-    p_state.p_tstate->istate->destroy_array(p_node, len);
+    p_state.istate->destroy_array(p_node, len);
 }
 
 stack_state &stack_state::operator=(stack_state &&st) {
@@ -54,7 +54,7 @@ stack_state &stack_state::operator=(stack_state &&st) {
     return *this;
 }
 
-stack_state_node const *stack_state::get() const {
+stack_state::node const *stack_state::get() const {
     return p_node;
 }
 
@@ -297,9 +297,9 @@ static thread_local int rundepth = 0;
 
 struct run_depth_guard {
     run_depth_guard() = delete;
-    run_depth_guard(state &cs) {
+    run_depth_guard(thread_state &ts) {
         if (rundepth >= MaxRunDepth) {
-            throw error(cs, "exceeded recursion limit");
+            throw error{ts, "exceeded recursion limit"};
         }
         ++rundepth;
     }
@@ -394,7 +394,7 @@ static std::uint32_t *runcode(
 ) {
     result.set_none();
     auto &cs = *ts.pstate;
-    run_depth_guard level{cs}; /* incr and decr on scope exit */
+    run_depth_guard level{ts}; /* incr and decr on scope exit */
     stack_guard guard{ts}; /* resize back to original */
     auto &args = ts.vmstack;
     auto &chook = cs.get_call_hook();
@@ -1453,38 +1453,38 @@ void state::run(bcode *code, any_value &ret) {
 }
 
 static void do_run(
-    state &cs, std::string_view file, std::string_view code,
+    thread_state &ts, std::string_view file, std::string_view code,
     any_value &ret
 ) {
-    codegen_state gs{*cs.p_tstate};
+    codegen_state gs{ts};
     gs.src_name = file;
     gs.code.reserve(64);
     gs.gen_main(code, VAL_ANY);
     gs.done();
-    std::uint32_t *cbuf = bcode_alloc(cs.p_tstate->istate, gs.code.size());
+    std::uint32_t *cbuf = bcode_alloc(ts.istate, gs.code.size());
     std::memcpy(cbuf, gs.code.data(), gs.code.size() * sizeof(std::uint32_t));
     bcode_incr(cbuf);
-    call_with_cleanup([&cs, cbuf, &ret]() {
-        runcode(*cs.p_tstate, cbuf + 1, ret);
+    call_with_cleanup([&ts, cbuf, &ret]() {
+        runcode(ts, cbuf + 1, ret);
     }, [cbuf]() {
         bcode_decr(cbuf);
     });
 }
 
 void state::run(std::string_view code, any_value &ret) {
-    do_run(*this, std::string_view{}, code, ret);
+    do_run(*p_tstate, std::string_view{}, code, ret);
 }
 
 void state::run(
     std::string_view code, any_value &ret, std::string_view source
 ) {
-    do_run(*this, source, code, ret);
+    do_run(*p_tstate, source, code, ret);
 }
 
 void state::run(ident *id, std::span<any_value> args, any_value &ret) {
     std::size_t nargs = args.size();
     ret.set_none();
-    run_depth_guard level{*this}; /* incr and decr on scope exit */
+    run_depth_guard level{*p_tstate}; /* incr and decr on scope exit */
     if (id) {
         switch (id->get_type()) {
             default:
diff --git a/src/lib_base.cc b/src/lib_base.cc
index 3487ae0..fda6563 100644
--- a/src/lib_base.cc
+++ b/src/lib_base.cc
@@ -63,7 +63,7 @@ end:
 
 void init_lib_base(state &gcs) {
     gcs.new_command("error", "s", [](auto &cs, auto args, auto &) {
-        throw error(cs, args[0].get_str());
+        throw error{cs, args[0].get_str()};
     });
 
     gcs.new_command("pcall", "err", [](auto &cs, auto args, auto &ret) {