@@ -140,6 +140,7 @@ fn trigger_signals(vm: &VirtualMachine) -> PyResult<()> {
             .signal_handlers
             .get()
             .expect("should never fail since we check above");
+        let frame = crate::frame::current_complete_frame_for_trace(vm);
 
         for (signum, trigger) in TRIGGERS.iter().enumerate().skip(1) {
             let triggered = trigger.swap(false, Ordering::Relaxed);
@@ -155,10 +156,19 @@ fn trigger_signals(vm: &VirtualMachine) -> PyResult<()> {
             // mutably, and a live read borrow turns that into a panic.
             let handler = signal_handlers.borrow()[signum].clone();
 
-            if let Some(handler) = handler
-                && let Some(callable) = handler.to_callable()
-                && let Err(exc) = callable.invoke((signum.as_i32(), vm.ctx.none()), vm)
-            {
+            let Some(handler) = handler.filter(|handler| !vm.is_none(handler)) else {
+                continue;
+            };
+            #[cfg(feature = "host_env")]
+            if crate::stdlib::_signal::_signal::handler_disposition(&handler, vm).is_some() {
+                continue;
+            }
+
+            // A handler can cease to be callable after registration. Invoke it
+            // normally so that this raises TypeError instead of losing a signal.
+            // Keep the interrupted complete frame alive across every callback,
+            // including handlers which re-enter signal dispatch.
+            if let Err(exc) = handler.call((signum.as_i32(), frame.clone()), vm) {
                 // On error, re-schedule a call to trigger_signals() for the
                 // remaining signals and the pending wakeup errors.
                 set_triggered();
 
@@ -15,7 +15,7 @@ pub(crate) mod _signal {
 
     cfg_select! {
         any(unix, windows, target_os = "wasi") => {
-            use crate::{builtins::PyInt, convert::IntoPyException};
+            use crate::convert::IntoPyException;
             use rustpython_host_env::signal as host_signal;
         }
         _ => {}
@@ -204,20 +204,42 @@ pub(crate) mod _signal {
                 // SAFETY: Trust `SignalNum::VALID_RANGE`
                 let signum = unsafe { SignalNum::new_unchecked(signum) };
 
-                vm.signal_handlers
-                    .get_or_init(SignalHandlers::default)
-                    .borrow_mut()[signum] = py_handler;
+                let signal_handlers = vm.signal_handlers.get_or_init(SignalHandlers::default);
+                let old_handler =
+                    core::mem::replace(&mut signal_handlers.borrow_mut()[signum], py_handler);
+                // Replacing a handler can run its destructor, which may install
+                // another handler. Release the table borrow before dropping it.
+                drop(old_handler);
             }
 
-            let int_handler = module
-                .get_attr("default_int_handler", vm)
-                .expect("_signal does not have this attr?");
-
-            signal(SignalNum::SIGINT.into(), int_handler, vm)
-                .expect("Failed to set sigint handler");
+            let default_sigint = vm
+                .signal_handlers
+                .get()
+                .and_then(|handlers| handlers.borrow()[SignalNum::SIGINT].clone())
+                .is_some_and(|handler| handler_disposition(&handler, vm) == Some(SIG_DFL));
+            if default_sigint {
+                let int_handler = module
+                    .get_attr("default_int_handler", vm)
+                    .expect("_signal does not have this attr?");
+
+                // An inherited ignored or foreign native handler is not ours
+                // to replace, even when installing Python's default handlers.
+                signal(SignalNum::SIGINT.into(), int_handler, vm)
+                    .expect("Failed to set sigint handler");
+            }
         }
     }
 
+    pub(crate) fn handler_disposition(
+        handler: &crate::PyObject,
+        vm: &VirtualMachine,
+    ) -> Option<sighandler_t> {
+        handler
+            .downcast_ref_if_exact::<crate::builtins::PyInt>(vm)
+            .and_then(|value| usize::try_from(value.as_bigint()).ok())
+            .filter(|&value| matches!(value, SIG_DFL | SIG_IGN))
+    }
+
     #[cfg(not(any(unix, windows, target_os = "wasi")))]
     #[pyfunction]
     pub fn signal(
@@ -261,11 +283,8 @@ pub(crate) mod _signal {
             const MSG: &str =
                 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object";
 
-            let disposition = handler
-                .downcast_ref_if_exact::<PyInt>(vm)
-                .and_then(|value| value.try_to_primitive::<usize>(vm).ok())
-                .filter(|&v| matches!(v, SIG_DFL | SIG_IGN))
-                .ok_or_else(|| vm.new_type_error(MSG))?;
+            let disposition =
+                handler_disposition(&handler, vm).ok_or_else(|| vm.new_type_error(MSG))?;
             cfg_select! {
                 target_os = "wasi" => {
                     if disposition == SIG_DFL {