@tishlang/tish 2.10.1 → 2.16.13

package/crates/tish_parser/src/lib.rs

@@ -33,6 +33,33 @@ mod tests {
     use super::*;
     use tishlang_ast::{CallArg, Expr, ObjectProp, Statement};
 
+    /// #381: pathologically nested source must return a catchable `Err`, NOT overflow the native
+    /// stack and abort the process. Exercises expression nesting (`((((…`), array nesting (`[[[[…`),
+    /// and prefix-op nesting (`-!-!…`) — all funnel through the depth-guarded `parse_unary`.
+    #[test]
+    fn deeply_nested_source_errors_instead_of_aborting() {
+        let n = 50_000;
+        for (open, close) in [("(", ")"), ("[", "]")] {
+            let src = format!("let x = {}1{}", open.repeat(n), close.repeat(n));
+            let r = parse(&src);
+            assert!(r.is_err(), "{n}× nested {open} should be a catchable Err, not an abort");
+            assert!(
+                r.unwrap_err().contains("nesting too deep"),
+                "expected a depth-limit error"
+            );
+        }
+        let prefix = format!("let x = {}1", "-".repeat(n));
+        assert!(parse(&prefix).is_err(), "deep prefix-op chain should error, not abort");
+    }
+
+    /// The depth guard must not reject ordinary, modestly-nested code.
+    #[test]
+    fn normal_nesting_still_parses() {
+        assert!(parse("let x = ((((1 + 2))))").is_ok());
+        assert!(parse("let y = [[1, 2], [3, [4, [5]]]]").is_ok());
+        assert!(parse("fn f() { if (a) { if (b) { return 1 } } }").is_ok());
+    }
+
     #[test]
     fn test_async_fn_parse() {
         let program = parse("async fn foo() { }").expect("parse async fn");

package/crates/tish_parser/src/parser.rs

@@ -123,8 +123,17 @@ pub struct Parser<'a> {
     generic_specializations: Vec<Statement>,
     /// Names of specializations already generated (dedup).
     generic_done: HashSet<String>,
+    /// Current recursion depth of the expression/statement descent, bounded by [`MAX_PARSE_DEPTH`] so
+    /// pathologically nested untrusted source (`((((…`, `[[[[…`, `{{{{…`, `-!-!…`) returns a CATCHABLE
+    /// parse error instead of overflowing the native stack and aborting the whole process (#381).
+    depth: usize,
 }
 
+/// Maximum expression/statement nesting the parser will descend before returning a catchable error.
+/// Deep enough for any realistic hand-written or generated source; shallow enough that the descent
+/// stays well within the OS thread stack. Mirrors `MAX_JSON_DEPTH` in the JSON parser.
+const MAX_PARSE_DEPTH: usize = 1024;
+
 impl<'a> Parser<'a> {
     pub fn new(tokens: &'a [Token]) -> Self {
         Self {
@@ -134,9 +143,25 @@ impl<'a> Parser<'a> {
             generic_aliases: HashMap::new(),
             generic_specializations: Vec::new(),
             generic_done: HashSet::new(),
+            depth: 0,
         }
     }
 
+    /// Enter one level of recursive descent. Returns a catchable `Err` (never a panic/abort) once the
+    /// nesting exceeds [`MAX_PARSE_DEPTH`]. Pair every `Ok(())` return with a matching `self.depth -=
+    /// 1` on the way out (the `parse_unary`/`parse_statement` wrappers do this unconditionally). #381
+    fn enter_depth(&mut self) -> Result<(), String> {
+        self.depth += 1;
+        if self.depth > MAX_PARSE_DEPTH {
+            self.depth -= 1;
+            return Err(format!(
+                "parse error: nesting too deep (exceeded {} levels)",
+                MAX_PARSE_DEPTH
+            ));
+        }
+        Ok(())
+    }
+
     /// Close one generic-arg `>`: use a previously-split `>>` debt, consume a `>`, or split a
     /// `>>` (consuming it and owing one `>` to the parent). Returns false if there's no closer.
     fn try_close_angle(&mut self) -> bool {
@@ -259,7 +284,16 @@ impl<'a> Parser<'a> {
         Ok(Program { statements })
     }
 
+    /// Depth-guarded wrapper (#381): bounds block/statement nesting (`{{{{…`, `if(x){if(x){…`) so a
+    /// crafted deeply-nested program returns a catchable error instead of a stack-overflow abort.
     fn parse_statement(&mut self) -> Result<Statement, String> {
+        self.enter_depth()?;
+        let r = stacker::maybe_grow(64 * 1024, 512 * 1024, || self.parse_statement_inner());
+        self.depth -= 1;
+        r
+    }
+
+    fn parse_statement_inner(&mut self) -> Result<Statement, String> {
         let kind = self.peek_kind().ok_or("Unexpected EOF")?;
         let span_start = self.peek().map(|t| t.span.start).unwrap_or((0, 0));
 
@@ -1579,9 +1613,78 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// #305 — consume a `from "..."` clause (`from` is a soft keyword: an `Ident` whose spelling is
+    /// "from"), returning the module path string.
+    fn parse_from_clause(&mut self) -> Result<Arc<str>, String> {
+        let from_tok = self.expect(TokenKind::Ident)?;
+        if from_tok.literal.as_deref() != Some("from") {
+            return Err("Expected 'from' in re-export statement".to_string());
+        }
+        self.expect(TokenKind::String)?
+            .literal
+            .clone()
+            .ok_or_else(|| "Expected string path in re-export".to_string())
+    }
+
     fn parse_export(&mut self) -> Result<Statement, String> {
         let span_start = self.expect(TokenKind::Export)?.span.start;
-        let declaration = if matches!(self.peek_kind(), Some(TokenKind::Default)) {
+        let declaration = if matches!(self.peek_kind(), Some(TokenKind::LBrace)) {
+            // #305: re-export named — `export { foo, bar as inc } from "./m"`
+            self.advance(); // {
+            let mut specifiers = Vec::new();
+            while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
+                let name_tok = self.expect(TokenKind::Ident)?;
+                let name_span = Span {
+                    start: name_tok.span.start,
+                    end: name_tok.span.end,
+                };
+                let name = name_tok
+                    .literal
+                    .clone()
+                    .ok_or("Expected identifier in export")?;
+                let (alias, alias_span) = if matches!(self.peek_kind(), Some(TokenKind::As)) {
+                    self.advance(); // as
+                    let alias_tok = self.expect(TokenKind::Ident)?;
+                    let asp = Span {
+                        start: alias_tok.span.start,
+                        end: alias_tok.span.end,
+                    };
+                    (
+                        Some(alias_tok.literal.clone().ok_or("Expected alias after 'as'")?),
+                        Some(asp),
+                    )
+                } else {
+                    (None, None)
+                };
+                specifiers.push(ImportSpecifier::Named {
+                    name,
+                    name_span,
+                    alias,
+                    alias_span,
+                });
+                if !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
+                    self.expect(TokenKind::Comma)?;
+                }
+            }
+            self.expect(TokenKind::RBrace)?;
+            let from = self.parse_from_clause()?;
+            ExportDeclaration::ReExport {
+                specifiers,
+                all: false,
+                from,
+                span: self.span_end(span_start),
+            }
+        } else if matches!(self.peek_kind(), Some(TokenKind::Star)) {
+            // #305: re-export all — `export * from "./m"`
+            self.advance(); // *
+            let from = self.parse_from_clause()?;
+            ExportDeclaration::ReExport {
+                specifiers: Vec::new(),
+                all: true,
+                from,
+                span: self.span_end(span_start),
+            }
+        } else if matches!(self.peek_kind(), Some(TokenKind::Default)) {
             self.advance();
             let expr = self.parse_expr()?;
             ExportDeclaration::Default(expr)
@@ -1617,6 +1720,73 @@ impl<'a> Parser<'a> {
         self.parse_assign()
     }
 
+    /// #304 — is `e` a side-effect-free l-value whose object/index sub-expressions can be safely
+    /// DUPLICATED by a compound/inc-dec desugar (no Call/New/assignment/inc-dec inside)? The desugar
+    /// reads and writes the same target, so duplicating a side-effecting sub-expression would run it
+    /// twice; those targets keep the existing parse error rather than mis-evaluate.
+    fn is_simple_lvalue(e: &Expr) -> bool {
+        match e {
+            Expr::Ident { .. } | Expr::Literal { .. } => true,
+            Expr::Member { object, prop, .. } => {
+                Self::is_simple_lvalue(object)
+                    && match prop {
+                        MemberProp::Name { .. } => true,
+                        MemberProp::Expr(pe) => Self::is_simple_lvalue(pe),
+                    }
+            }
+            Expr::Index { object, index, .. } => {
+                Self::is_simple_lvalue(object) && Self::is_simple_lvalue(index)
+            }
+            _ => false,
+        }
+    }
+
+    /// #304 — does `e` name a member (`obj.x`) or index (`arr[i]`) target the read-modify-write
+    /// desugar can handle (a simple l-value)?
+    fn is_desugarable_member_target(e: &Expr) -> bool {
+        Self::is_simple_lvalue(e)
+            && matches!(
+                e,
+                Expr::Member { prop: MemberProp::Name { .. }, .. } | Expr::Index { .. }
+            )
+    }
+
+    fn compound_op_to_binop(op: CompoundOp) -> BinOp {
+        match op {
+            CompoundOp::Add => BinOp::Add,
+            CompoundOp::Sub => BinOp::Sub,
+            CompoundOp::Mul => BinOp::Mul,
+            CompoundOp::Div => BinOp::Div,
+            CompoundOp::Mod => BinOp::Mod,
+        }
+    }
+
+    /// #304 — desugar a read-modify-write on a member/index target into the existing
+    /// `MemberAssign`/`IndexAssign` node (so every backend handles it for free). `make_value(read)`
+    /// builds the stored value from a clone of the target read (e.g. `read + 1`, `read || rhs`).
+    /// Caller must have checked [`Self::is_desugarable_member_target`].
+    fn desugar_member_rmw(left: &Expr, span: Span, make_value: impl FnOnce(Expr) -> Expr) -> Expr {
+        match left {
+            Expr::Member {
+                object,
+                prop: MemberProp::Name { name, .. },
+                ..
+            } => Expr::MemberAssign {
+                object: object.clone(),
+                prop: Arc::clone(name),
+                value: Box::new(make_value(left.clone())),
+                span,
+            },
+            Expr::Index { object, index, .. } => Expr::IndexAssign {
+                object: object.clone(),
+                index: index.clone(),
+                value: Box::new(make_value(left.clone())),
+                span,
+            },
+            _ => unreachable!("desugar_member_rmw on non-member/index target"),
+        }
+    }
+
     fn parse_assign(&mut self) -> Result<Expr, String> {
         let left = self.parse_conditional()?;
 
@@ -1686,18 +1856,29 @@ impl<'a> Parser<'a> {
         };
 
         if let Some(op) = compound_op {
-            if let Expr::Ident { name, span } = &left {
-                let name = Arc::clone(name);
-                let start = span.start;
+            let is_ident = matches!(&left, Expr::Ident { .. });
+            if is_ident || Self::is_desugarable_member_target(&left) {
+                let start = left.span().start;
                 self.advance(); // consume the compound operator
                 let value = self.parse_assign()?;
                 let end = value.span().end;
-                return Ok(Expr::CompoundAssign {
-                    name,
-                    op,
-                    value: Box::new(value),
-                    span: Span { start, end },
-                });
+                let span = Span { start, end };
+                if let Expr::Ident { name, .. } = &left {
+                    return Ok(Expr::CompoundAssign {
+                        name: Arc::clone(name),
+                        op,
+                        value: Box::new(value),
+                        span,
+                    });
+                }
+                // #304: `obj.x += e` / `arr[i] *= e` -> MemberAssign/IndexAssign(read <op> e).
+                let binop = Self::compound_op_to_binop(op);
+                return Ok(Self::desugar_member_rmw(&left, span, move |read| Expr::Binary {
+                    left: Box::new(read),
+                    op: binop,
+                    right: Box::new(value),
+                    span,
+                }));
             }
         }
 
@@ -1710,18 +1891,42 @@ impl<'a> Parser<'a> {
         };
 
         if let Some(op) = logical_op {
-            if let Expr::Ident { name, span } = &left {
-                let name = Arc::clone(name);
-                let start = span.start;
+            let is_ident = matches!(&left, Expr::Ident { .. });
+            if is_ident || Self::is_desugarable_member_target(&left) {
+                let start = left.span().start;
                 self.advance(); // consume the logical assign operator
                 let value = self.parse_assign()?;
                 let end = value.span().end;
-                return Ok(Expr::LogicalAssign {
-                    name,
-                    op,
-                    value: Box::new(value),
-                    span: Span { start, end },
-                });
+                let span = Span { start, end };
+                if let Expr::Ident { name, .. } = &left {
+                    return Ok(Expr::LogicalAssign {
+                        name: Arc::clone(name),
+                        op,
+                        value: Box::new(value),
+                        span,
+                    });
+                }
+                // #304: `obj.x ||= e` -> MemberAssign/IndexAssign(read || e) (short-circuit preserved,
+                // since `||`/`&&`/`??` evaluate the RHS lazily).
+                return Ok(Self::desugar_member_rmw(&left, span, move |read| match op {
+                    LogicalAssignOp::OrOr => Expr::Binary {
+                        left: Box::new(read),
+                        op: BinOp::Or,
+                        right: Box::new(value),
+                        span,
+                    },
+                    LogicalAssignOp::AndAnd => Expr::Binary {
+                        left: Box::new(read),
+                        op: BinOp::And,
+                        right: Box::new(value),
+                        span,
+                    },
+                    LogicalAssignOp::Nullish => Expr::NullishCoalesce {
+                        left: Box::new(read),
+                        right: Box::new(value),
+                        span,
+                    },
+                }));
             }
         }
 
@@ -1797,7 +2002,19 @@ impl<'a> Parser<'a> {
         Ok(left)
     }
 
+    /// Depth-guarded wrapper (#381): every expression operand and every nested `(…)`/`[…]`/`{…}`/
+    /// prefix-op re-enters `parse_unary`, so bounding it here bounds all expression nesting. The
+    /// `-= 1` runs on both the `Ok` and `Err` paths, keeping the counter balanced.
     fn parse_unary(&mut self) -> Result<Expr, String> {
+        self.enter_depth()?;
+        // Grow the stack on demand (each nesting level costs a whole precedence-chain of frames), so
+        // we reach the MAX_PARSE_DEPTH bound and return a catchable error rather than overflowing.
+        let r = stacker::maybe_grow(64 * 1024, 512 * 1024, || self.parse_unary_inner());
+        self.depth -= 1;
+        r
+    }
+
+    fn parse_unary_inner(&mut self) -> Result<Expr, String> {
         // Handle prefix ++/-- (consolidated)
         if let Some(is_inc) = match self.peek_kind() {
             Some(TokenKind::PlusPlus) => Some(true),
@@ -1819,6 +2036,24 @@ impl<'a> Parser<'a> {
                     Expr::PrefixDec { name, span }
                 });
             }
+            // #304: prefix `++obj.x` / `--arr[i]` on a member/index target. Desugars to a
+            // read-modify-write, which yields the NEW value — exactly prefix semantics.
+            if Self::is_desugarable_member_target(&operand) {
+                let span = Span {
+                    start: span_start,
+                    end: operand.span().end,
+                };
+                let binop = if is_inc { BinOp::Add } else { BinOp::Sub };
+                return Ok(Self::desugar_member_rmw(&operand, span, |read| Expr::Binary {
+                    left: Box::new(read),
+                    op: binop,
+                    right: Box::new(Expr::Literal {
+                        value: Literal::Number(1.0),
+                        span,
+                    }),
+                    span,
+                }));
+            }
             return Err(format!(
                 "Prefix {} requires an identifier",
                 if is_inc { "++" } else { "--" }
@@ -2049,13 +2284,13 @@ impl<'a> Parser<'a> {
                     };
                 }
                 TokenKind::PlusPlus | TokenKind::MinusMinus => {
+                    let is_inc = kind == TokenKind::PlusPlus;
                     if let Expr::Ident {
                         name,
                         span: ident_span,
                     } = &expr
                     {
                         let name = Arc::clone(name);
-                        let is_inc = kind == TokenKind::PlusPlus;
                         let tok = self.advance().ok_or("Unexpected EOF")?;
                         let span = Span {
                             start: ident_span.start,
@@ -2066,6 +2301,26 @@ impl<'a> Parser<'a> {
                         } else {
                             Expr::PostfixDec { name, span }
                         };
+                    } else if Self::is_desugarable_member_target(&expr) {
+                        // #304: postfix `obj.x++` / `arr[i]--` on a member/index target. Desugars to a
+                        // read-modify-write (statement-position semantics: yields the NEW value; the
+                        // old-value result in expression position is a documented follow-up).
+                        let start = expr.span().start;
+                        let tok = self.advance().ok_or("Unexpected EOF")?;
+                        let span = Span {
+                            start,
+                            end: tok.span.end,
+                        };
+                        let binop = if is_inc { BinOp::Add } else { BinOp::Sub };
+                        expr = Self::desugar_member_rmw(&expr, span, |read| Expr::Binary {
+                            left: Box::new(read),
+                            op: binop,
+                            right: Box::new(Expr::Literal {
+                                value: Literal::Number(1.0),
+                                span,
+                            }),
+                            span,
+                        });
                     } else {
                         break;
                     }
@@ -2102,6 +2357,33 @@ impl<'a> Parser<'a> {
                     span,
                 })
             }
+            TokenKind::Regex => {
+                // #299: `/pattern/flags` desugars to `new RegExp("pattern", "flags")`. Every backend
+                // already lowers `new RegExp(str, str)`, so no codegen change is needed. The lexer
+                // encodes the literal as `pattern\0flags`; the pattern is kept verbatim (e.g. `\d+`).
+                let lit = t.literal.clone().ok_or("Expected regex literal")?;
+                let (pat, flags) = match lit.split_once('\u{0}') {
+                    Some((p, f)) => (Arc::from(p), Arc::from(f)),
+                    None => (Arc::clone(&lit), Arc::from("")),
+                };
+                Ok(Expr::New {
+                    callee: Box::new(Expr::Ident {
+                        name: Arc::from("RegExp"),
+                        span,
+                    }),
+                    args: vec![
+                        CallArg::Expr(Expr::Literal {
+                            value: Literal::String(pat),
+                            span,
+                        }),
+                        CallArg::Expr(Expr::Literal {
+                            value: Literal::String(flags),
+                            span,
+                        }),
+                    ],
+                    span,
+                })
+            }
             TokenKind::True => Ok(Expr::Literal {
                 value: Literal::Bool(true),
                 span,

package/crates/tish_resolve/src/lib.rs

@@ -286,6 +286,7 @@ fn collect_stmt(
                 collect_stmt(inner, source, lsp_line, lsp_char, best)
             }
             ExportDeclaration::Default(e) => collect_expr(e, source, lsp_line, lsp_char, best),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::TypeAlias {
             name, name_span, ..
@@ -1009,6 +1010,7 @@ fn member_chain_collect_stmt(
             ExportDeclaration::Default(e) => {
                 member_chain_collect_expr(e, source, lsp_line, lsp_char, best)
             }
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::Break { .. }
@@ -1598,6 +1600,7 @@ fn walk_stmt_resolve(
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => walk_stmt_resolve(inner, scopes, target),
             ExportDeclaration::Default(e) => walk_expr_resolve(e, scopes, target),
+            ExportDeclaration::ReExport { .. } => None,
         },
         Statement::TypeAlias {
             name, name_span, ..
@@ -2156,6 +2159,7 @@ fn check_unresolved_stmt(
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => check_unresolved_stmt(inner, scopes, out),
             ExportDeclaration::Default(e) => check_unresolved_expr(e, scopes, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::TypeAlias {
             name, name_span, ..
@@ -2489,6 +2493,7 @@ fn enumerate_stmt(stmt: &Statement, exported: bool, out: &mut Vec<BindingSite>)
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => enumerate_stmt(inner, true, out),
             ExportDeclaration::Default(e) => enumerate_expr(e, exported, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::VarDecl {
             name,
@@ -2788,6 +2793,7 @@ fn jsx_tags_stmt(s: &Statement, out: &mut std::collections::HashSet<Arc<str>>) {
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => jsx_tags_stmt(inner, out),
             ExportDeclaration::Default(e) => jsx_tags_expr(e, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::Break { .. }
@@ -3532,6 +3538,7 @@ fn walk_stmt_completion(
             ExportDeclaration::Default(e) => {
                 walk_expr_completion(e, source, lsp_line, lsp_char, stack, best);
             }
+            ExportDeclaration::ReExport { .. } => {}
         },
     }
 }
@@ -3945,6 +3952,7 @@ fn tref_stmt(stmt: &Statement, out: &mut Vec<TypeOcc>) {
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => tref_stmt(inner, out),
             ExportDeclaration::Default(e) => tref_expr(e, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         _ => {}
     }
@@ -4132,6 +4140,7 @@ fn refs_stmt(
                 refs_stmt(inner, program, source, name, def_span, out)
             }
             ExportDeclaration::Default(e) => refs_expr(e, program, source, name, def_span, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::Break { .. }

package/crates/tish_runtime/Cargo.toml

@@ -94,3 +94,8 @@ core_affinity = { version = "0.8", optional = true }
 tokio-tungstenite = { version = "0.29", optional = true }
 futures-util = { version = "0.3", optional = true }
 lazy_static = { version = "1", optional = true }
+
+# #381 native-codegen recursion guard: stack-pressure probe for guarded self-recursive fns.
+# Non-wasm only — wasm traps on overflow inside its own sandbox, so the guard is a no-op there.
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+stacker = "0.1"

package/crates/tish_runtime/src/http.rs

@@ -1110,16 +1110,30 @@ where
     drop(tx);
 
     let mut count = 0usize;
-    while let Ok((req_prim, resp_tx)) = rx.recv() {
-        let req_value = req_prim.into_value();
-        let response_value = handler.call(&[req_value]);
-        let resp_prim = ResponsePrimitive::from_value(&response_value);
-        let _ = resp_tx.send(resp_prim);
-
-        count += 1;
-        if max_requests.map(|m| count >= m).unwrap_or(false) {
-            stop.store(true, Ordering::Relaxed);
-            break;
+    // #384: `recv_timeout` (not a blocking `recv`) so a handler's scheduled timers still fire when the
+    // server is idle. Handler calls all run on this single VM thread, so the timer registry is here.
+    loop {
+        match rx.recv_timeout(Duration::from_millis(250)) {
+            Ok((req_prim, resp_tx)) => {
+                let req_value = req_prim.into_value();
+                let response_value = handler.call(&[req_value]);
+                crate::timers::drain_timers();
+                let resp_prim = ResponsePrimitive::from_value(&response_value);
+                let _ = resp_tx.send(resp_prim);
+
+                count += 1;
+                if max_requests.map(|m| count >= m).unwrap_or(false) {
+                    stop.store(true, Ordering::Relaxed);
+                    break;
+                }
+            }
+            Err(mpsc::RecvTimeoutError::Timeout) => {
+                crate::timers::drain_timers();
+                if stop.load(Ordering::Relaxed) {
+                    break;
+                }
+            }
+            Err(mpsc::RecvTimeoutError::Disconnected) => break,
         }
     }
 
@@ -1181,6 +1195,10 @@ fn worker_loop_direct(
             Ok(None) => {} // timeout; re-check stop flag
             Err(_) => break,
         }
+        // #384: fire any timers a handler scheduled. The handler runs on this accept thread, so its
+        // `setTimeout`/`setInterval` callbacks live in this thread's registry; the ≤250ms `recv_timeout`
+        // above means they fire within that window even when no new requests arrive.
+        crate::timers::drain_timers();
     }
 }