Emit incremental turtle snapshots on sleep and fix stacking

When user code calls time.sleep(), emit the current turtle SVG so the
drawing updates live rather than only appearing at the end. Deduplicate
via _last_emitted_turtle_svg so identical frames are never sent twice,
and apply the same dedup to _render_turtle and turtle.done()/mainloop().

Consolidate the three separate SVG-fetch-encode-emit blocks (turtle_hook
render closure, debug frame_callback, _render_turtle) into the single
_emit_turtle_snapshot helper.

Fix the frontend regression where incremental SVGs were appended instead
of replacing the previous frame by removing the debugger-only guard from
the "show only latest SVG" filter in Output.ts.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: TomNaessens

src/backend/workers/python/papyros/papyros.py

@@ -49,6 +49,7 @@ def __init__(
         self._tracking_files = False
         self._original_open = builtins.open
         self._last_emitted_snapshot = None
+        self._last_emitted_turtle_svg = None
         self._install_open_tracking()
         self.limit = limit
         self.override_globals()
@@ -76,6 +77,7 @@ def cb(typ, dat, contentType=None, **kwargs):
             elif event_type == "input":
                 return cb("input", data["prompt"])
             elif event_type == "sleep":
+                self._emit_turtle_snapshot()
                 return cb("sleep", data["seconds"]*1000, contentType="application/number")
             else:
                 return cb(event_type, data.get("data", ""), contentType=data.get("contentType"))
@@ -90,13 +92,23 @@ def override_globals(self):
         self.override_matplotlib()
         self.override_turtle()
 
-    def _render_turtle(self):
+    def _emit_turtle_snapshot(self):
+        """Emit the current turtle drawing if it has changed since the last snapshot."""
         hook = getattr(self, '_turtle_hook', None)
-        if hook and hook.render:
-            try:
-                hook.render()
-            except Exception:
-                pass
+        if not hook or not hook.render:
+            return
+        try:
+            from svg_turtle import SvgTurtle
+            svg_string = SvgTurtle._pen.to_svg()
+            if svg_string and svg_string != self._last_emitted_turtle_svg:
+                self._last_emitted_turtle_svg = svg_string
+                img = base64.b64encode(svg_string.encode("utf-8")).decode("utf-8")
+                self.output("img", img, contentType="img/svg+xml;base64")
+        except Exception:
+            pass
+
+    def _render_turtle(self):
+        self._emit_turtle_snapshot()
 
     def override_turtle(self):
         if not hasattr(self, '_turtle_hook'):
@@ -222,6 +234,7 @@ def _execute_context(self):
         self._tracked_files.clear()
         self._tracking_files = True
         self._last_emitted_snapshot = None
+        self._last_emitted_turtle_svg = None
         with (
             redirect_stdout(python_runner.output.SysStream("output", self.output_buffer)),
             redirect_stderr(python_runner.output.SysStream("error", self.output_buffer)),
@@ -256,24 +269,11 @@ async def run_async(self, source_code, mode="exec", top_level_await=True):
                     self.callback("start", data="RunCode", contentType="text/plain")
                     if mode == "debug":
                         from tracer import JSONTracer
-                        _last_turtle_svg = [None]
 
                         def frame_callback(frame):
                             self._flush_open_files()
                             self._emit_created_files(emit_empty=True)
-                            # The hook fires lazily when user code runs `import turtle`, so the
-                            # pen only exists partway through the trace — check per frame.
-                            hook = getattr(self, '_turtle_hook', None)
-                            if hook and hook.render:
-                                try:
-                                    from svg_turtle import SvgTurtle
-                                    svg_string = SvgTurtle._pen.to_svg()
-                                    if svg_string and svg_string != _last_turtle_svg[0]:
-                                        _last_turtle_svg[0] = svg_string
-                                        img = base64.b64encode(svg_string.encode("utf-8")).decode("utf-8")
-                                        self.output("img", img, contentType="img/svg+xml;base64")
-                                except Exception:
-                                    pass
+                            self._emit_turtle_snapshot()
                             self.callback("frame", data=frame, contentType="application/json")
 
                         result = JSONTracer(frame_callback=frame_callback, module_name=MODULE_NAME).runscript(source_code)

src/backend/workers/python/papyros/turtle_hook.py

@@ -1,4 +1,3 @@
-import base64
 import sys
 
 
@@ -58,17 +57,10 @@ def __init__(self):
             SvgTurtle._screen = screen
             SvgTurtle._pen = PapyrosTurtle()
 
-            rendered = [False]
             papyros = self.papyros
 
             def render():
-                if rendered[0]:
-                    return
-                rendered[0] = True
-                svg_string = SvgTurtle._pen.to_svg()
-                if svg_string:
-                    img = base64.b64encode(svg_string.encode("utf-8")).decode("utf-8")
-                    papyros.output("img", img, contentType="img/svg+xml;base64")
+                papyros._emit_turtle_snapshot()
 
             turtle_mod.Turtle = PapyrosTurtle
             turtle_mod.done = render

src/frontend/components/Output.ts

@@ -98,16 +98,16 @@ export class Output extends PapyrosElement {
 
     get renderedOutputs(): TemplateResult[] {
         let outputsToRender = this.outputs;
-        if (this.papyros.debugger.active) {
-            // Only show the latest SVG snapshot so the debugger slider shows progressive rendering.
-            const lastSvgIdx = outputsToRender.findLastIndex(
-                (o) => o.type === OutputType.img && o.contentType?.includes("svg"),
+        // Only render the latest SVG snapshot — intermediate frames from sleep/debug are kept in
+        // the output array (so the debugger slider can step through them) but only the current
+        // one should be visible at any given time.
+        const lastSvgIdx = outputsToRender.findLastIndex(
+            (o) => o.type === OutputType.img && o.contentType?.includes("svg"),
+        );
+        if (lastSvgIdx >= 0) {
+            outputsToRender = outputsToRender.filter(
+                (o, i) => !(o.type === OutputType.img && o.contentType?.includes("svg")) || i === lastSvgIdx,
             );
-            if (lastSvgIdx >= 0) {
-                outputsToRender = outputsToRender.filter(
-                    (o, i) => !(o.type === OutputType.img && o.contentType?.includes("svg")) || i === lastSvgIdx,
-                );
-            }
         }
         return outputsToRender.map((o) => {
             if (o.type === OutputType.stdout) {