hyperbook 0.99.1 → 0.100.0

package/dist/assets/directive-pyide/client.js

@@ -23,6 +23,7 @@
   var PYODIDE_CDN = "https://cdn.jsdelivr.net/pyodide/v0.29.4/full/pyodide.js";
   var PYTAMARO_URI_BEGIN = "@@@PYTAMARO_DATA_URI_BEGIN@@@";
   var PYTAMARO_URI_END = "@@@PYTAMARO_DATA_URI_END@@@";
+  var scriptLooksLikeTurtle = (script) => /\bfrom\s+turtle\s+import\b|\bimport\s+turtle\b/.test(String(script || ""));
 
   // assets/directive-pyide/src/output.js
   var getOutput = (id) => {
@@ -184,11 +185,77 @@
     pytamaroStdoutCarry.delete(id);
   };
 
+  // assets/directive-pyide/src/stdin.js
+  var pending = /* @__PURE__ */ new Map();
+  var parts = (id) => {
+    const elem = document.getElementById(id);
+    if (!elem) return null;
+    const form = elem.getElementsByClassName("stdin")[0];
+    const field = elem.getElementsByClassName("stdin-field")[0];
+    if (!form || !field) return null;
+    const label = elem.getElementsByClassName("stdin-prompt")[0] || null;
+    return { form, field, label };
+  };
+  var hideStdinField = (id) => {
+    const found = parts(id);
+    if (!found) return;
+    found.form.classList.add("hidden");
+    found.field.value = "";
+    if (found.label) found.label.textContent = "";
+  };
+  var cancelStdin = (id, value = "") => {
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id);
+    entry.cleanup();
+    hideStdinField(id);
+    entry.resolve(value);
+  };
+  var askStdinAsync = (id, promptText = "") => {
+    const found = parts(id);
+    if (!found) return Promise.resolve(askStdinSync(id, promptText));
+    cancelStdin(id);
+    const { form, field, label } = found;
+    if (label) label.textContent = String(promptText ?? "").trimEnd();
+    return new Promise((resolve) => {
+      const onSubmit = (event) => {
+        event.preventDefault();
+        const value = field.value;
+        pending.delete(id);
+        cleanup();
+        hideStdinField(id);
+        resolve(value);
+      };
+      const cleanup = () => form.removeEventListener("submit", onSubmit);
+      pending.set(id, { resolve, cleanup });
+      form.addEventListener("submit", onSubmit);
+      form.classList.remove("hidden");
+      field.value = "";
+      field.focus();
+      form.scrollIntoView?.({ block: "nearest" });
+    });
+  };
+  var askStdinSync = (id, promptText = "") => {
+    const text = promptText || hyperbook.i18n.get("pyide-input-prompt");
+    const value = window.prompt(text);
+    return value === null ? "" : value;
+  };
+
   // assets/directive-pyide/src/turtle-ffi.js
   var createTurtleJsFFI = (id) => {
     const DEFAULT_LINE_WIDTH = 1;
     const DEFAULT_FONT_SIZE = 8;
     const DEFAULT_SHAPE = "classic";
+    const DEFAULT_SPEED = 3;
+    const DEFAULT_DELAY_MS = 80;
+    const DEFAULT_UNDO_BUFFER = 1e3;
+    const SPEED_NAMES = {
+      fastest: 0,
+      fast: 10,
+      normal: 6,
+      slow: 3,
+      slowest: 1
+    };
     const TURTLE_SHAPES = {
       classic: [
         [0, 0],
@@ -212,8 +279,9 @@
         [10, 10],
         [-10, 10]
       ],
-      circle: null,
+      circle: "arc",
       // rendered as arc, not polygon
+      blank: [],
       turtle: [
         [16, 0],
         [14, 2],
@@ -251,16 +319,25 @@
     let backgroundColor = "#ffffff";
     let backgroundImage = null;
     let colorMode = 1;
-    let delayMs = 80;
-    let turtleSpeed = 3;
+    let delayMs = DEFAULT_DELAY_MS;
+    let turtleSpeed = DEFAULT_SPEED;
     let screenWidth = 640;
     let screenHeight = 480;
+    let screenMode = "standard";
+    let screenTitle = "";
+    let tracerN = 1;
+    let tracerCounter = 0;
     let operationQueue = [];
     let queueGeneration = 0;
     let queueRunning = false;
+    let stampCounter = 0;
+    let undoBufferSize = DEFAULT_UNDO_BUFFER;
+    let eventCleanups = [];
+    let pendingTimers = [];
     const textMeasureCanvas = document.createElement("canvas");
     const textMeasureContext = textMeasureCanvas.getContext("2d");
     const allPens = [];
+    const getCanvas = (elementId) => document.getElementById(elementId)?.getElementsByClassName("canvas")[0] || null;
     const normalizeAngle = (angle) => {
       const value = Number(angle) || 0;
       return (value % 360 + 360) % 360;
@@ -358,9 +435,9 @@
     const normalizeFontStyle = (value) => {
       const style = toPlainString(value, "normal").trim().toLowerCase();
       if (!style || style === "normal") return "";
-      const parts = style.split(/\s+/).filter(Boolean);
-      const hasItalic = parts.includes("italic");
-      const hasBold = parts.includes("bold");
+      const parts2 = style.split(/\s+/).filter(Boolean);
+      const hasItalic = parts2.includes("italic");
+      const hasBold = parts2.includes("bold");
       if (hasItalic && hasBold) return "italic bold";
       if (hasBold) return "bold";
       if (hasItalic) return "italic";
@@ -407,28 +484,33 @@
         return toColorString(value.toJs({ pyproxies: [] }));
       }
       if (Array.isArray(value) || value && typeof value === "object" && "length" in value) {
-        const parts = Array.from(value).slice(0, 3).map((part) => Number(part));
-        if (parts.length !== 3 || parts.some((part) => !Number.isFinite(part))) {
+        const parts2 = Array.from(value).slice(0, 3).map((part) => Number(part));
+        if (parts2.length !== 3 || parts2.some((part) => !Number.isFinite(part))) {
           throw new Error(`bad color sequence: ${String(value)}`);
         }
         if (colorMode === 1) {
-          if (parts.some((part) => part < 0 || part > 1)) {
+          if (parts2.some((part) => part < 0 || part > 1)) {
             throw new Error(`bad color sequence: ${String(value)}`);
           }
-          const [r, g, b] = parts.map((part) => Math.round(part * 255));
+          const [r, g, b] = parts2.map((part) => Math.round(part * 255));
           return `rgb(${r}, ${g}, ${b})`;
         }
         if (colorMode === 255) {
-          if (parts.some((part) => part < 0 || part > 255)) {
+          if (parts2.some((part) => part < 0 || part > 255)) {
             throw new Error(`bad color sequence: ${String(value)}`);
           }
-          const [r, g, b] = parts.map((part) => Math.round(part));
+          const [r, g, b] = parts2.map((part) => Math.round(part));
           return `rgb(${r}, ${g}, ${b})`;
         }
         throw new Error(`bad color sequence: ${String(value)}`);
       }
       return "#000000";
     };
+    const colorFromArgs = (args) => {
+      if (args.length === 0) return null;
+      if (args.length === 1) return toColorString(args[0]);
+      return toColorString(args.map((part) => toPlainNumber(part, Number.NaN)));
+    };
     const sleep = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
     const clearQueue = () => {
       queueGeneration += 1;
@@ -436,7 +518,7 @@
       queueRunning = false;
     };
     const enqueueOperation = (fn) => {
-      if (delayMs <= 0) {
+      if (delayMs <= 0 || tracerN === 0) {
         fn();
         return;
       }
@@ -504,7 +586,36 @@
       }
       context.restore();
     };
+    const drawCursor = (cursor) => {
+      const points = TURTLE_SHAPES[cursor.shapeName] ?? TURTLE_SHAPES[DEFAULT_SHAPE];
+      if (Array.isArray(points) && points.length === 0) return;
+      context.save();
+      context.translate(toCanvasX(cursor.x), toCanvasY(cursor.y));
+      context.rotate(-toRadians(cursor.heading + (cursor.tilt || 0)));
+      context.scale(cursor.stretchLen || 1, cursor.stretchWid || 1);
+      context.fillStyle = cursor.fillColor;
+      context.strokeStyle = cursor.penColor;
+      context.lineWidth = cursor.outline || 1;
+      if (cursor.shapeName === "circle" || !Array.isArray(points)) {
+        context.beginPath();
+        context.arc(0, 0, 10, 0, 2 * Math.PI);
+      } else {
+        context.beginPath();
+        context.moveTo(points[0][0], points[0][1]);
+        for (let i = 1; i < points.length; i++) {
+          context.lineTo(points[i][0], points[i][1]);
+        }
+        context.closePath();
+      }
+      context.fill();
+      context.stroke();
+      context.restore();
+    };
     const drawPathSegment = (path) => {
+      if (path?.stamp) {
+        drawCursor(path.stamp);
+        return;
+      }
       if (!path?.points?.length) return;
       if (path.fill) {
         context.beginPath();
@@ -565,32 +676,21 @@
     };
     const drawTurtleShape = (pen) => {
       if (!pen.renderedTurtleVisible) return;
-      context.save();
-      context.translate(toCanvasX(pen.renderedX), toCanvasY(pen.renderedY));
-      context.rotate(-toRadians(pen.renderedHeading));
-      context.fillStyle = pen.shapeColor;
-      context.strokeStyle = pen.shapeColor;
-      context.lineWidth = 1;
-      const shapeName = pen.shapeName || DEFAULT_SHAPE;
-      if (shapeName === "circle") {
-        context.beginPath();
-        context.arc(0, 0, 10, 0, 2 * Math.PI);
-        context.fill();
-        context.stroke();
-      } else {
-        const points = TURTLE_SHAPES[shapeName] || TURTLE_SHAPES[DEFAULT_SHAPE];
-        context.beginPath();
-        context.moveTo(points[0][0], points[0][1]);
-        for (let i = 1; i < points.length; i++) {
-          context.lineTo(points[i][0], points[i][1]);
-        }
-        context.closePath();
-        context.fill();
-        context.stroke();
-      }
-      context.restore();
+      drawCursor({
+        x: pen.renderedX,
+        y: pen.renderedY,
+        heading: pen.renderedHeading,
+        shapeName: pen.shapeName || DEFAULT_SHAPE,
+        // CPython fills the cursor with fillcolor and outlines it with pencolor.
+        fillColor: pen.shapeFillColor,
+        penColor: pen.shapeColor,
+        stretchLen: pen.stretchLen,
+        stretchWid: pen.stretchWid,
+        outline: pen.outlineWidth,
+        tilt: pen.tilt
+      });
     };
-    const draw = () => {
+    const render = () => {
       if (!active) return;
       if (!setupCanvasResolution()) return;
       drawBackground();
@@ -601,6 +701,12 @@
         drawTurtleShape(pen);
       }
     };
+    const draw = () => {
+      if (tracerN === 0) return;
+      tracerCounter += 1;
+      if (tracerN > 1 && tracerCounter % tracerN !== 0) return;
+      render();
+    };
     const createTurtlePen = () => {
       let x = 0;
       let y = 0;
@@ -609,12 +715,15 @@
       let turtleVisible = true;
       let strokeColor = "#000000";
       let fillColor = "#000000";
+      let penWidth = DEFAULT_LINE_WIDTH;
       let fontSize = DEFAULT_FONT_SIZE;
       let currentFontFamily = "Arial";
       let currentFontStyle = "normal";
       let filling = false;
       let fillPath = null;
       let currentPath = null;
+      let degreesPerUnit = 1;
+      const undoStack = [];
       const pen = {
         paths: [],
         renderedX: 0,
@@ -622,12 +731,29 @@
         renderedHeading: 0,
         renderedTurtleVisible: true,
         shapeColor: "#000000",
-        shapeName: DEFAULT_SHAPE
+        shapeFillColor: "#000000",
+        shapeName: DEFAULT_SHAPE,
+        stretchLen: 1,
+        stretchWid: 1,
+        outlineWidth: 1,
+        tilt: 0
+      };
+      const toUserAngle = (internal) => normalizeAngle(screenMode === "logo" ? 90 - internal : internal) / degreesPerUnit;
+      const toInternalAngle = (user) => {
+        const degrees = Number(user || 0) * degreesPerUnit;
+        return normalizeAngle(screenMode === "logo" ? 90 - degrees : degrees);
+      };
+      const pushUndo = (entry) => {
+        if (undoBufferSize === 0) return;
+        undoStack.push(entry);
+        if (undoBufferSize > 0 && undoStack.length > undoBufferSize) {
+          undoStack.shift();
+        }
       };
       const makePath = (overrides = {}) => ({
         down: penDown,
         stroke: strokeColor,
-        lineWidth: DEFAULT_LINE_WIDTH,
+        lineWidth: penWidth,
         fontsize: fontSize,
         fontfamily: currentFontFamily,
         fontstyle: currentFontStyle,
@@ -642,10 +768,7 @@
         return currentPath;
       };
       const commitStyleToNewPath = () => {
-        currentPath = makePath({
-          down: penDown,
-          lineWidth: currentPath?.lineWidth ?? DEFAULT_LINE_WIDTH
-        });
+        currentPath = makePath();
         pen.paths.push(currentPath);
         return currentPath;
       };
@@ -659,144 +782,206 @@
         pendown: penDown,
         pencolor: strokeColor,
         fillcolor: fillColor,
-        pensize: currentPath?.lineWidth ?? DEFAULT_LINE_WIDTH,
+        pensize: penWidth,
         speed: turtleSpeed,
-        shown: turtleVisible
+        shown: turtleVisible,
+        stretchfactor: [pen.stretchWid, pen.stretchLen],
+        outline: pen.outlineWidth,
+        tilt: pen.tilt
       });
       beginCurrentPath();
-      const forward = (distance) => {
-        if (!ensureContext()) return;
+      const moveTo = (nextX, nextY) => {
+        const prevX = x;
+        const prevY = y;
         const path = ensurePath();
         const fill = filling ? fillPath : null;
-        const length = Number(distance) || 0;
-        const nextX = x + length * Math.cos(toRadians(heading));
-        const nextY = y + length * Math.sin(toRadians(heading));
         x = nextX;
         y = nextY;
         const point = { x, y, move: !penDown };
+        pushUndo(() => {
+          x = prevX;
+          y = prevY;
+          if (path.points[path.points.length - 1] === point) path.points.pop();
+          if (fill) fill.points.pop();
+          pen.renderedX = prevX;
+          pen.renderedY = prevY;
+        });
         enqueueOperation(() => {
           pen.renderedX = point.x;
           pen.renderedY = point.y;
           path.points.push(point);
           if (fill) {
-            fill.points.push({ x, y });
+            fill.points.push({ x: point.x, y: point.y });
           }
           draw();
         });
       };
-      const backward = (distance) => forward(-Number(distance || 0));
-      const right = (angle) => {
-        heading = normalizeAngle(heading - Number(angle || 0));
-        const nextHeading = heading;
-        enqueueOperation(() => {
-          pen.renderedHeading = nextHeading;
-          draw();
+      const turnTo = (nextHeading) => {
+        const prevHeading = heading;
+        heading = normalizeAngle(nextHeading);
+        const target = heading;
+        pushUndo(() => {
+          heading = prevHeading;
+          pen.renderedHeading = prevHeading;
         });
-      };
-      const left = (angle) => {
-        heading = normalizeAngle(heading + Number(angle || 0));
-        const nextHeading = heading;
         enqueueOperation(() => {
-          pen.renderedHeading = nextHeading;
+          pen.renderedHeading = target;
           draw();
         });
       };
+      const forward = (distance2) => {
+        if (!ensureContext()) return;
+        const length = toPlainNumber(distance2, 0) || 0;
+        moveTo(
+          x + length * Math.cos(toRadians(heading)),
+          y + length * Math.sin(toRadians(heading))
+        );
+      };
+      const backward = (distance2) => forward(-toPlainNumber(distance2, 0));
+      const right = (angle) => turnTo(heading - toPlainNumber(angle, 0) * degreesPerUnit);
+      const left = (angle) => turnTo(heading + toPlainNumber(angle, 0) * degreesPerUnit);
       const penup = () => {
+        const previous = penDown;
         penDown = false;
         commitStyleToNewPath();
+        pushUndo(() => {
+          penDown = previous;
+          commitStyleToNewPath();
+        });
         draw();
       };
       const pendownFn = () => {
+        const previous = penDown;
         penDown = true;
         commitStyleToNewPath();
+        pushUndo(() => {
+          penDown = previous;
+          commitStyleToNewPath();
+        });
         draw();
       };
+      const toPoint = (a, b) => {
+        if (b !== void 0 && b !== null) {
+          return [toPlainNumber(a, 0), toPlainNumber(b, 0)];
+        }
+        const source = toSequence(a);
+        if (source && source.length >= 2) {
+          return [toPlainNumber(source[0], 0), toPlainNumber(source[1], 0)];
+        }
+        const obj = a && typeof a === "object" ? a : null;
+        if (obj && ("x" in obj || "y" in obj)) {
+          return [toPlainNumber(obj.x, 0), toPlainNumber(obj.y, 0)];
+        }
+        return [toPlainNumber(a, 0), 0];
+      };
       const goto_ = (a, b) => {
         if (!ensureContext()) return;
-        let nextX = Number(a);
-        let nextY = Number(b);
-        if (b === void 0 && (Array.isArray(a) || a && typeof a === "object")) {
-          const source = a && typeof a.toJs === "function" ? a.toJs({ pyproxies: [] }) : a;
-          nextX = Number(source?.[0] ?? source?.x ?? 0);
-          nextY = Number(source?.[1] ?? source?.y ?? 0);
-        }
-        x = Number.isFinite(nextX) ? nextX : 0;
-        y = Number.isFinite(nextY) ? nextY : 0;
-        const path = ensurePath();
-        const fill = filling ? fillPath : null;
-        const point = { x, y, move: !penDown };
-        enqueueOperation(() => {
-          pen.renderedX = point.x;
-          pen.renderedY = point.y;
-          path.points.push(point);
-          if (fill) {
-            fill.points.push({ x, y });
-          }
-          draw();
-        });
+        const [nextX, nextY] = toPoint(a, b);
+        moveTo(nextX, nextY);
       };
-      const setx = (value) => goto_(Number(value), y);
-      const sety = (value) => goto_(x, Number(value));
+      const setx = (value) => goto_(toPlainNumber(value, 0), y);
+      const sety = (value) => goto_(x, toPlainNumber(value, 0));
       const position = () => [x, y];
       const xcor = () => x;
       const ycor = () => y;
-      const heading_ = () => heading;
-      const setheading = (angle) => {
-        heading = normalizeAngle(angle);
-        const nextHeading = heading;
-        enqueueOperation(() => {
-          pen.renderedHeading = nextHeading;
-          draw();
-        });
-      };
+      const heading_ = () => toUserAngle(heading);
+      const setheading = (angle) => turnTo(toInternalAngle(angle));
       const home = () => {
         goto_(0, 0);
         setheading(0);
       };
       const towards = (tx, ty) => {
-        const dx = Number(tx) - x;
-        const dy = Number(ty) - y;
+        const [px, py] = toPoint(tx, ty);
+        const dx = px - x;
+        const dy = py - y;
         if (!Number.isFinite(dx) || !Number.isFinite(dy)) return 0;
-        return normalizeAngle(Math.atan2(dy, dx) * 180 / Math.PI);
+        return toUserAngle(Math.atan2(dy, dx) * 180 / Math.PI);
+      };
+      const distance = (tx, ty) => {
+        const [px, py] = toPoint(tx, ty);
+        return Math.hypot(px - x, py - y);
+      };
+      const degreesFn = (fullcircle = 360) => {
+        const circle2 = toPlainNumber(fullcircle, 360) || 360;
+        degreesPerUnit = 360 / circle2;
       };
-      const speed = (value = 0) => {
-        const numeric = Number(value);
-        turtleSpeed = Number.isFinite(numeric) ? numeric : 0;
+      const radians = () => degreesFn(2 * Math.PI);
+      const speed = (value = void 0) => {
+        if (value === void 0 || value === null) return turtleSpeed;
+        const name = typeof value === "string" ? value.trim().toLowerCase() : null;
+        let numeric = name !== null && name in SPEED_NAMES ? SPEED_NAMES[name] : toPlainNumber(value, Number.NaN);
+        if (!Number.isFinite(numeric)) numeric = DEFAULT_SPEED;
+        if (numeric < 0.5 || numeric > 10.5) numeric = 0;
+        turtleSpeed = Math.round(numeric);
         delayMs = turtleSpeed <= 0 ? 0 : Math.max(0, Math.round(300 / turtleSpeed));
-        return delayMs;
+        return turtleSpeed;
       };
-      const color = (...args) => {
-        const stroke = toColorString(args[0]);
-        const fill = args.length > 1 ? toColorString(args[1]) : stroke;
-        strokeColor = stroke;
-        fillColor = fill;
-        pen.shapeColor = stroke;
-        commitStyleToNewPath();
+      const setStroke = (value) => {
+        strokeColor = value;
+        pen.shapeColor = value;
+      };
+      const setFill = (value) => {
+        fillColor = value;
+        pen.shapeFillColor = value;
         if (filling && fillPath) {
-          fillPath.fillstyle = fillColor;
+          fillPath.fillstyle = value;
+        }
+      };
+      const color = (...args) => {
+        if (args.length === 0) return [strokeColor, fillColor];
+        const previous = [strokeColor, fillColor];
+        if (args.length === 2) {
+          setStroke(toColorString(args[0]));
+          setFill(toColorString(args[1]));
+        } else {
+          const value = colorFromArgs(args);
+          setStroke(value);
+          setFill(value);
         }
+        commitStyleToNewPath();
+        pushUndo(() => {
+          setStroke(previous[0]);
+          setFill(previous[1]);
+          commitStyleToNewPath();
+        });
         draw();
       };
-      const pencolor = (value) => {
-        strokeColor = toColorString(value);
-        pen.shapeColor = strokeColor;
+      const pencolor = (...args) => {
+        if (args.length === 0) return strokeColor;
+        const previous = strokeColor;
+        setStroke(colorFromArgs(args));
         commitStyleToNewPath();
+        pushUndo(() => {
+          setStroke(previous);
+          commitStyleToNewPath();
+        });
         draw();
       };
-      const fillcolor = (value) => {
-        fillColor = toColorString(value);
-        if (filling && fillPath) {
-          fillPath.fillstyle = fillColor;
-        }
+      const fillcolor = (...args) => {
+        if (args.length === 0) return fillColor;
+        const previous = fillColor;
+        setFill(colorFromArgs(args));
         commitStyleToNewPath();
+        pushUndo(() => {
+          setFill(previous);
+          commitStyleToNewPath();
+        });
         draw();
       };
-      const pensize = (value) => {
-        ensurePath().lineWidth = Math.max(1, Number(value) || DEFAULT_LINE_WIDTH);
+      const pensize = (value = void 0) => {
+        if (value === void 0 || value === null) return penWidth;
+        const previous = penWidth;
+        penWidth = Math.max(1, toPlainNumber(value, DEFAULT_LINE_WIDTH));
         commitStyleToNewPath();
+        pushUndo(() => {
+          penWidth = previous;
+          commitStyleToNewPath();
+        });
         draw();
+        return penWidth;
       };
-      const width = (value) => pensize(value);
+      const width = (value = void 0) => pensize(value);
+      const isfilling = () => filling;
       const begin_fill = () => {
         if (filling) return;
         filling = true;
@@ -804,48 +989,75 @@
           down: false,
           fill: true,
           stroke: "transparent",
-          lineWidth: 1,
           fillstyle: fillColor
         });
         pen.paths.push(fillPath);
+        commitStyleToNewPath();
+        const started = fillPath;
+        pushUndo(() => {
+          filling = false;
+          fillPath = null;
+          const index = pen.paths.indexOf(started);
+          if (index >= 0) pen.paths.splice(index, 1);
+        });
         draw();
       };
       const end_fill = () => {
+        if (!filling) return;
+        const finished = fillPath;
         filling = false;
         fillPath = null;
         commitStyleToNewPath();
+        pushUndo(() => {
+          filling = true;
+          fillPath = finished;
+        });
         draw();
       };
-      const dot = (size = 5, colorValue = null) => {
+      const dot = (size = void 0, ...colorArgs) => {
+        const requested = toPlainNumber(size, Number.NaN);
+        const diameter = Number.isFinite(requested) ? Math.max(1, requested) : Math.max(penWidth + 4, penWidth * 2);
+        const dotColor = colorArgs.length > 0 ? colorFromArgs(colorArgs) : strokeColor;
         const segment = makePath({
           down: false,
           fill: false,
-          stroke: colorValue ? toColorString(colorValue) : strokeColor,
-          fillstyle: colorValue ? toColorString(colorValue) : strokeColor,
-          points: [
-            {
-              x,
-              y,
-              dotRadius: Math.max(0.5, Number(size) || 5) / 2,
-              color: colorValue ? toColorString(colorValue) : strokeColor
-            }
-          ]
+          stroke: dotColor,
+          fillstyle: dotColor,
+          points: [{ x, y, dotRadius: diameter / 2, color: dotColor }]
+        });
+        pushUndo(() => {
+          const index = pen.paths.indexOf(segment);
+          if (index >= 0) pen.paths.splice(index, 1);
         });
         enqueueOperation(() => {
           pen.paths.push(segment);
           draw();
         });
       };
-      const circle = (radius, steps = 120) => {
-        const numericRadius = Number(radius) || 0;
-        const stepCount = Math.max(8, Number(steps) | 0);
-        const circumference = 2 * Math.PI * Math.abs(numericRadius);
-        const stepLength = circumference / stepCount;
-        const stepTurn = 360 / stepCount * (numericRadius >= 0 ? 1 : -1);
+      const circle = (radius, extent = void 0, steps = void 0) => {
+        const numericRadius = toPlainNumber(radius, 0) || 0;
+        const fullCircle = 360 / degreesPerUnit;
+        const extentUnits = toPlainNumber(extent, fullCircle);
+        const extentDegrees = extentUnits * degreesPerUnit;
+        const requestedSteps = toPlainNumber(steps, Number.NaN);
+        const stepCount = Number.isFinite(requestedSteps) ? Math.max(1, Math.trunc(requestedSteps)) : (
+          // CPython scales the step count with the arc's size.
+          1 + Math.trunc(
+            Math.min(11 + Math.abs(numericRadius) / 6, 59) * (Math.abs(extentUnits) / fullCircle)
+          )
+        );
+        let stepTurn = extentDegrees / stepCount;
+        let stepLength = 2 * numericRadius * Math.sin(toRadians(stepTurn / 2));
+        if (numericRadius < 0) {
+          stepLength = -stepLength;
+          stepTurn = -stepTurn;
+        }
+        turnTo(heading + stepTurn / 2);
         for (let index = 0; index < stepCount; index += 1) {
           forward(stepLength);
-          left(stepTurn);
+          turnTo(heading + stepTurn);
         }
+        turnTo(heading - stepTurn / 2);
       };
       const write = (text, move = false, align = "left", font = null) => {
         let writeText = text;
@@ -916,6 +1128,10 @@
           }
           commitStyleToNewPath();
         }
+        pushUndo(() => {
+          const index = pen.paths.indexOf(segment);
+          if (index >= 0) pen.paths.splice(index, 1);
+        });
         enqueueOperation(() => {
           pen.paths.push(segment);
           draw();
@@ -949,13 +1165,97 @@
         if (name === void 0 || name === null) {
           return pen.shapeName;
         }
-        const nameStr = toPlainString(name, DEFAULT_SHAPE).toLowerCase().trim();
-        if (nameStr in TURTLE_SHAPES) {
-          pen.shapeName = nameStr;
+        const nameStr = toPlainString(name, "").toLowerCase().trim();
+        if (!(nameStr in TURTLE_SHAPES)) {
+          throw new Error(
+            `There is no shape named ${nameStr} (available: ${Object.keys(
+              TURTLE_SHAPES
+            ).join(", ")})`
+          );
         }
+        pen.shapeName = nameStr;
         draw();
         return pen.shapeName;
       };
+      const shapesize = (stretchWid = void 0, stretchLen = void 0, outline = void 0) => {
+        if (stretchWid === void 0 && stretchLen === void 0 && outline === void 0) {
+          return [pen.stretchWid, pen.stretchLen, pen.outlineWidth];
+        }
+        const wid = toPlainNumber(stretchWid, Number.NaN);
+        const len = toPlainNumber(stretchLen, Number.NaN);
+        if (Number.isFinite(wid)) {
+          pen.stretchWid = wid;
+          pen.stretchLen = Number.isFinite(len) ? len : wid;
+        } else if (Number.isFinite(len)) {
+          pen.stretchLen = len;
+        }
+        const outlineWidth = toPlainNumber(outline, Number.NaN);
+        if (Number.isFinite(outlineWidth)) pen.outlineWidth = outlineWidth;
+        draw();
+        return [pen.stretchWid, pen.stretchLen, pen.outlineWidth];
+      };
+      const settiltangle = (angle) => {
+        pen.tilt = toPlainNumber(angle, 0) * degreesPerUnit;
+        draw();
+      };
+      const tilt = (angle) => settiltangle(pen.tilt / degreesPerUnit + toPlainNumber(angle, 0));
+      const tiltangle = (angle = void 0) => {
+        if (angle === void 0 || angle === null) {
+          return normalizeAngle(pen.tilt) / degreesPerUnit;
+        }
+        settiltangle(angle);
+        return normalizeAngle(pen.tilt) / degreesPerUnit;
+      };
+      const cursorSnapshot = () => ({
+        x,
+        y,
+        heading,
+        shapeName: pen.shapeName,
+        fillColor,
+        penColor: strokeColor,
+        stretchLen: pen.stretchLen,
+        stretchWid: pen.stretchWid,
+        outline: pen.outlineWidth,
+        tilt: pen.tilt
+      });
+      const stamp = () => {
+        stampCounter += 1;
+        const segment = { stampId: stampCounter, stamp: cursorSnapshot() };
+        pushUndo(() => {
+          const index = pen.paths.indexOf(segment);
+          if (index >= 0) pen.paths.splice(index, 1);
+        });
+        enqueueOperation(() => {
+          pen.paths.push(segment);
+          draw();
+        });
+        return stampCounter;
+      };
+      const clearstamp = (stampId) => {
+        const wanted = toPlainNumber(stampId, Number.NaN);
+        const index = pen.paths.findIndex((path) => path.stampId === wanted);
+        if (index >= 0) pen.paths.splice(index, 1);
+        draw();
+      };
+      const clearstamps = (n = void 0) => {
+        const count = toPlainNumber(n, Number.NaN);
+        let stamps = pen.paths.filter((path) => path.stampId !== void 0);
+        if (Number.isFinite(count) && count !== 0) {
+          stamps = count > 0 ? stamps.slice(0, count) : stamps.slice(count);
+        }
+        for (const entry of stamps) {
+          const index = pen.paths.indexOf(entry);
+          if (index >= 0) pen.paths.splice(index, 1);
+        }
+        draw();
+      };
+      const undo = () => {
+        const entry = undoStack.pop();
+        if (!entry) return;
+        entry();
+        draw();
+      };
+      const undobufferentries = () => undoStack.length;
       const penFn = (options = void 0) => {
         if (options === void 0) {
           return getPenState();
@@ -966,16 +1266,16 @@
           penDown = !!source.pendown;
         }
         if ("pencolor" in source) {
-          strokeColor = toColorString(source.pencolor);
+          setStroke(toColorString(source.pencolor));
         }
         if ("fillcolor" in source) {
-          fillColor = toColorString(source.fillcolor);
+          setFill(toColorString(source.fillcolor));
         }
         if ("pensize" in source) {
-          ensurePath().lineWidth = Math.max(
-            1,
-            Number(source.pensize) || DEFAULT_LINE_WIDTH
-          );
+          penWidth = Math.max(1, toPlainNumber(source.pensize, penWidth));
+        }
+        if ("speed" in source) {
+          speed(source.speed);
         }
         if ("shown" in source) {
           turtleVisible = !!source.shown;
@@ -989,6 +1289,8 @@
         pen.paths = [];
         currentPath = null;
         fillPath = null;
+        filling = false;
+        undoStack.length = 0;
         beginCurrentPath();
         draw();
       };
@@ -996,22 +1298,30 @@
         pen.paths = [];
         currentPath = null;
         fillPath = null;
+        undoStack.length = 0;
         x = 0;
         y = 0;
-        heading = 0;
+        heading = screenMode === "logo" ? 90 : 0;
         pen.renderedX = 0;
         pen.renderedY = 0;
-        pen.renderedHeading = 0;
+        pen.renderedHeading = heading;
         penDown = true;
         turtleVisible = true;
         pen.renderedTurtleVisible = true;
         strokeColor = "#000000";
         fillColor = "#000000";
+        penWidth = DEFAULT_LINE_WIDTH;
         pen.shapeColor = "#000000";
+        pen.shapeFillColor = "#000000";
         pen.shapeName = DEFAULT_SHAPE;
+        pen.stretchLen = 1;
+        pen.stretchWid = 1;
+        pen.outlineWidth = 1;
+        pen.tilt = 0;
         fontSize = DEFAULT_FONT_SIZE;
         currentFontFamily = "Arial";
         currentFontStyle = "normal";
+        degreesPerUnit = 1;
         filling = false;
         beginCurrentPath();
       };
@@ -1041,6 +1351,9 @@
         ycor,
         heading: heading_,
         towards,
+        distance,
+        degrees: degreesFn,
+        radians,
         pendown: pendownFn,
         pd: pendownFn,
         down: pendownFn,
@@ -1057,6 +1370,7 @@
         fillcolor,
         begin_fill,
         end_fill,
+        filling: isfilling,
         speed,
         showturtle,
         st: showturtle,
@@ -1064,14 +1378,24 @@
         ht: hideturtle,
         isvisible,
         shape,
+        shapesize,
+        turtlesize: shapesize,
+        tilt,
+        tiltangle,
+        settiltangle,
+        stamp,
+        clearstamp,
+        clearstamps,
+        undo,
+        undobufferentries,
         clear,
         reset: resetPen
       };
       return { pen, api: api2, resetPen };
     };
-    const colormode = (mode = void 0) => {
-      if (mode === void 0) return colorMode;
-      const numeric = Number(mode);
+    const colormode = (mode2 = void 0) => {
+      if (mode2 === void 0) return colorMode;
+      const numeric = Number(mode2);
       if (numeric !== 1 && numeric !== 255) {
         throw new Error("colormode must be 1.0 or 255");
       }
@@ -1142,7 +1466,138 @@
         }
       }
     };
+    const mode = (value = void 0) => {
+      if (value === void 0 || value === null) return screenMode;
+      const next = toPlainString(value, "").toLowerCase().trim();
+      if (next !== "standard" && next !== "logo") {
+        throw new Error(`No mode named ${next} (available: standard, logo)`);
+      }
+      screenMode = next;
+      for (const penObj of allPenObjects) penObj.resetPen();
+      draw();
+      return screenMode;
+    };
+    const tracer = (n = void 0, delay2 = void 0) => {
+      if (n === void 0 || n === null) return tracerN;
+      tracerN = Math.max(0, Math.trunc(toPlainNumber(n, 1)));
+      tracerCounter = 0;
+      const nextDelay = toPlainNumber(delay2, Number.NaN);
+      if (Number.isFinite(nextDelay)) delayMs = Math.max(0, nextDelay);
+      if (tracerN !== 0) render();
+      return tracerN;
+    };
+    const update = () => {
+      tracerCounter = 0;
+      render();
+    };
+    const delay = (ms = void 0) => {
+      if (ms === void 0 || ms === null) return delayMs;
+      delayMs = Math.max(0, toPlainNumber(ms, delayMs));
+      return delayMs;
+    };
+    const setundobuffer = (size) => {
+      const next = toPlainNumber(size, DEFAULT_UNDO_BUFFER);
+      undoBufferSize = Number.isFinite(next) ? Math.max(0, next) : 0;
+    };
+    const window_width = () => cssWidth || screenWidth;
+    const window_height = () => cssHeight || screenHeight;
+    const title = (value = void 0) => {
+      if (value === void 0) return screenTitle;
+      screenTitle = toPlainString(value, "");
+      if (canvas) canvas.setAttribute("aria-label", screenTitle);
+      return screenTitle;
+    };
+    const register_shape = (name, shapePoints = void 0) => {
+      const shapeName = toPlainString(name, "").toLowerCase().trim();
+      if (!shapeName) throw new Error("register_shape needs a name");
+      const source = toSequence(shapePoints);
+      if (!source) {
+        throw new Error(`register_shape: no polygon given for ${shapeName}`);
+      }
+      TURTLE_SHAPES[shapeName] = source.map((point) => {
+        const pair = toSequence(point) || [0, 0];
+        const sx = toPlainNumber(pair[0], 0);
+        const sy = toPlainNumber(pair[1], 0);
+        return [sy, -sx];
+      });
+      return shapeName;
+    };
+    const inputLabel = (promptTitle, promptText) => [toPlainString(promptTitle, ""), toPlainString(promptText, "")].filter(Boolean).join(" ").trim();
+    const numinput = (promptTitle = "", promptText = "") => {
+      const answer = askStdinSync(id, inputLabel(promptTitle, promptText));
+      if (!answer) return null;
+      const numeric = Number(answer);
+      return Number.isFinite(numeric) ? numeric : null;
+    };
+    const textinput = (promptTitle = "", promptText = "") => askStdinSync(id, inputLabel(promptTitle, promptText));
+    const addListener = (target, type, handler) => {
+      if (!target) return;
+      target.addEventListener(type, handler);
+      eventCleanups.push(() => target.removeEventListener(type, handler));
+    };
+    const clearListeners = () => {
+      for (const cleanup of eventCleanups) {
+        try {
+          cleanup();
+        } catch {
+        }
+      }
+      eventCleanups = [];
+      for (const timerId of pendingTimers) window.clearTimeout(timerId);
+      pendingTimers = [];
+    };
+    const canvasPoint = (event) => {
+      const rect = canvas?.getBoundingClientRect?.();
+      if (!rect) return [0, 0];
+      return [
+        event.clientX - rect.left - cssWidth / 2,
+        cssHeight / 2 - (event.clientY - rect.top)
+      ];
+    };
+    const onscreenclick = (fn, btn = 1) => {
+      if (!ensureContext()) return;
+      if (!fn) return;
+      const wanted = toPlainNumber(btn, 1) - 1;
+      addListener(canvas, "mousedown", (event) => {
+        if (event.button !== wanted) return;
+        const [px, py] = canvasPoint(event);
+        fn(px, py);
+      });
+    };
+    const onkey = (fn, key = void 0) => {
+      if (!ensureContext()) return;
+      const wanted = toPlainString(key, "");
+      addListener(canvas, "keyup", (event) => {
+        if (wanted && event.key !== wanted && event.code !== wanted) return;
+        if (fn) fn();
+      });
+    };
+    const onkeypress = (fn, key = void 0) => {
+      if (!ensureContext()) return;
+      const wanted = toPlainString(key, "");
+      addListener(canvas, "keydown", (event) => {
+        if (wanted && event.key !== wanted && event.code !== wanted) return;
+        if (fn) fn();
+      });
+    };
+    const listen = () => {
+      if (!ensureContext()) return;
+      canvas.focus?.();
+    };
+    const ontimer = (fn, ms = 0) => {
+      if (!fn) return;
+      const timerId = window.setTimeout(
+        () => {
+          pendingTimers = pendingTimers.filter((entry) => entry !== timerId);
+          fn();
+        },
+        Math.max(0, toPlainNumber(ms, 0))
+      );
+      pendingTimers.push(timerId);
+    };
+    const allPenObjects = [];
     const defaultPenObj = createTurtlePen();
+    allPenObjects.push(defaultPenObj);
     allPens.push(defaultPenObj.pen);
     const bindCanvas = (nextCanvas) => {
       canvas = nextCanvas || getCanvas(id);
@@ -1155,6 +1610,7 @@
     const deactivate = () => {
       active = false;
       clearQueue();
+      clearListeners();
       for (const pen of allPens) {
         pen.paths = [];
         pen.renderedTurtleVisible = false;
@@ -1162,39 +1618,114 @@
     };
     const resetState = () => {
       clearQueue();
+      clearListeners();
       allPens.length = 0;
       allPens.push(defaultPenObj.pen);
+      allPenObjects.length = 0;
+      allPenObjects.push(defaultPenObj);
       defaultPenObj.resetPen();
       backgroundColor = "#ffffff";
       backgroundImage = null;
       colorMode = 1;
       screenWidth = 640;
       screenHeight = 480;
+      screenMode = "standard";
+      screenTitle = "";
+      turtleSpeed = DEFAULT_SPEED;
+      delayMs = DEFAULT_DELAY_MS;
+      tracerN = 1;
+      tracerCounter = 0;
+      stampCounter = 0;
+      undoBufferSize = DEFAULT_UNDO_BUFFER;
       active = true;
+      render();
+    };
+    const clearscreen = () => {
+      for (const penObj of allPenObjects) penObj.resetPen();
+      backgroundColor = "#ffffff";
+      backgroundImage = null;
       draw();
     };
+    const resetscreen = () => {
+      for (const penObj of allPenObjects) penObj.resetPen();
+      draw();
+    };
+    const setup = (width = void 0, height = void 0, startx = void 0, starty = void 0) => {
+      const w = toPlainNumber(width, Number.NaN);
+      const h = toPlainNumber(height, Number.NaN);
+      return screensize(
+        Number.isFinite(w) && w > 1 ? w : void 0,
+        Number.isFinite(h) && h > 1 ? h : void 0
+      );
+    };
     const Turtle = function() {
       const penObj = createTurtlePen();
+      allPenObjects.push(penObj);
       enqueueOperation(() => {
         allPens.push(penObj.pen);
         draw();
       });
       return penObj.api;
     };
+    const screenApi = {
+      colormode,
+      screensize,
+      setup,
+      bgcolor,
+      bgpic,
+      mode,
+      tracer,
+      update,
+      delay,
+      title,
+      register_shape,
+      addshape: register_shape,
+      window_width,
+      window_height,
+      numinput,
+      textinput,
+      listen,
+      onkey,
+      onkeyrelease: onkey,
+      onkeypress,
+      onscreenclick,
+      onclick: onscreenclick,
+      ontimer,
+      clearscreen,
+      clear: clearscreen,
+      resetscreen,
+      reset: resetscreen,
+      // The canvas is always on screen, so there is no event loop to enter or leave.
+      mainloop: () => {
+      },
+      done: () => {
+      },
+      exitonclick: () => {
+      },
+      bye: () => {
+      }
+    };
     const api = {
       __bindCanvas: bindCanvas,
       __deactivate: deactivate,
-      __redraw: draw,
+      __redraw: render,
       __resetState: resetState,
       __setPyodide: (runtime) => {
         pyodide = runtime;
       },
       ...defaultPenObj.api,
       Turtle,
-      colormode,
-      screensize,
-      bgcolor,
-      bgpic
+      Screen: () => screenApi,
+      getscreen: () => screenApi,
+      setundobuffer,
+      // Screen helpers are also exposed at module level, matching `from turtle import *`.
+      ...screenApi,
+      // The turtle's own clear()/reset() win over the screen's at module level,
+      // exactly as CPython's functional interface binds them.
+      clear: defaultPenObj.api.clear,
+      reset: defaultPenObj.api.reset,
+      clearscreen,
+      resetscreen
     };
     return api;
   };
@@ -1737,10 +2268,125 @@
   };
 
   // assets/directive-pyide/src/execution.js
-  var scriptLooksLikeTurtle = (script) => {
-    return /\bfrom\s+turtle\s+import\b|\bimport\s+turtle\b/.test(
-      String(script || "")
-    );
+  var runSyncSupport = /* @__PURE__ */ new Map();
+  var PROBE_RUN_SYNC = `
+def _hyperbook_probe():
+    try:
+        from pyodide.ffi import run_sync
+        import js
+    except Exception:
+        return False
+    try:
+        run_sync(js.Promise.resolve(True))
+        return True
+    except Exception:
+        return False
+
+_hyperbook_probe()
+`;
+  var INPUT_SHIM = `
+def input(prompt=""):
+    import sys
+    from pyodide.ffi import run_sync
+
+    text = "" if prompt is None else str(prompt)
+    if text:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+    answer = run_sync(__hyperbook_ask_stdin(text))
+    answer = "" if answer is None else str(answer)
+    # A terminal echoes what was typed and the Enter that ended it; nothing
+    # does that here, so the transcript has to include it explicitly.
+    sys.stdout.write(answer + "\\n")
+    sys.stdout.flush()
+    return answer
+`;
+  var TURTLE_INPUT_SHIM = `
+def _hyperbook_patch_turtle():
+    import turtle
+    from pyodide.ffi import run_sync
+
+    def _label(title, prompt):
+        return " ".join(str(part) for part in (title, prompt) if part).strip()
+
+    def textinput(title="", prompt=""):
+        return run_sync(__hyperbook_ask_stdin(_label(title, prompt)))
+
+    def numinput(title="", prompt="", default=None, minval=None, maxval=None):
+        hint = ""
+        if minval is not None and maxval is not None:
+            hint = " [{0}, {1}]".format(minval, maxval)
+        elif minval is not None:
+            hint = " [>= {0}]".format(minval)
+        elif maxval is not None:
+            hint = " [<= {0}]".format(maxval)
+        while True:
+            answer = run_sync(__hyperbook_ask_stdin(_label(title, prompt) + hint))
+            # An empty answer stands in for tkinter's Cancel button.
+            if answer is None or str(answer).strip() == "":
+                return default
+            try:
+                value = float(str(answer).strip().replace(",", "."))
+            except ValueError:
+                continue
+            if minval is not None and value < minval:
+                continue
+            if maxval is not None and value > maxval:
+                continue
+            return value
+
+    # Screen() hands back one shared object, so patching it once is enough.
+    try:
+        screen = turtle.Screen()
+        screen.numinput = numinput
+        screen.textinput = textinput
+    except Exception:
+        pass
+
+    try:
+        turtle.numinput = numinput
+        turtle.textinput = textinput
+    except Exception:
+        pass
+    if getattr(turtle, "numinput", None) is not numinput:
+        # The JS module rejected the assignment; shadow it with a real Python
+        # module so \`from turtle import *\` still picks up the patched names.
+        import sys
+        import types
+
+        wrapper = types.ModuleType("turtle")
+        for name in dir(turtle):
+            try:
+                setattr(wrapper, name, getattr(turtle, name))
+            except Exception:
+                pass
+        wrapper.numinput = numinput
+        wrapper.textinput = textinput
+        sys.modules["turtle"] = wrapper
+        sys.modules["jturtle"] = wrapper
+
+_hyperbook_patch_turtle()
+del _hyperbook_patch_turtle
+`;
+  var supportsRunSync = async (id, pyodide) => {
+    if (runSyncSupport.has(id)) return runSyncSupport.get(id);
+    let supported = false;
+    const dict = pyodide.globals.get("dict");
+    const probeGlobals = dict();
+    try {
+      supported = !!await pyodide.runPythonAsync(PROBE_RUN_SYNC, {
+        globals: probeGlobals,
+        locals: probeGlobals,
+        filename: "<hyperbook-probe>"
+      });
+    } catch {
+      supported = false;
+    } finally {
+      probeGlobals.destroy();
+      dict.destroy();
+    }
+    runSyncSupport.set(id, supported);
+    return supported;
   };
   var resetCanvas = (canvas) => {
     if (!canvas) return;
@@ -1912,13 +2558,15 @@
         }
       });
       pyodide.setStdin({
+        // Reached by sys.stdin reads, and by input() when Python cannot be
+        // suspended. Both block the main thread; there is no way around that
+        // without stack switching.
         stdin: () => {
-          const promptText = lastStdinPrompt || hyperbook.i18n.get("pyide-input-prompt");
+          const promptText = lastStdinPrompt;
           lastStdinPrompt = "";
-          const value = window.prompt(promptText);
-          if (value === null) {
-            return "";
-          }
+          const value = askStdinSync(id, promptText);
+          appendOutputLine(id, `${value}
+`);
           return value;
         }
       });
@@ -1931,12 +2579,31 @@
       });
       await ensureMicropipPackages(id, pyodide, packages);
       await pyodide.loadPackagesFromImports(executableScript);
+      const canSuspend = await supportsRunSync(id, pyodide);
       const dict = pyodide.globals.get("dict");
       const globals = dict();
       try {
         for (const [key, value] of Object.entries(globalsContext)) {
           globals.set(key, value);
         }
+        if (canSuspend) {
+          globals.set(
+            "__hyperbook_ask_stdin",
+            (promptText) => askStdinAsync(id, promptText)
+          );
+          await pyodide.runPythonAsync(INPUT_SHIM, {
+            globals,
+            locals: globals,
+            filename: "<hyperbook-stdin>"
+          });
+          if (scriptLooksLikeTurtle(executableScript)) {
+            await pyodide.runPythonAsync(TURTLE_INPUT_SHIM, {
+              globals,
+              locals: globals,
+              filename: "<hyperbook-stdin>"
+            });
+          }
+        }
         const results = await pyodide.runPythonAsync(executableScript, {
           globals,
           locals: globals,
@@ -1944,6 +2611,7 @@
         });
         return { results };
       } finally {
+        hideStdinField(id);
         globals.destroy();
         dict.destroy();
         if (canvas) {
@@ -1974,12 +2642,379 @@ if _pg:
     }
   };
 
+  // assets/directive-pyide/src/turtle-completions.js
+  var TURTLE_MOVE = [
+    [
+      "forward",
+      "forward(distance)",
+      "Move the turtle forward by distance, in the direction it is headed."
+    ],
+    ["fd", "fd(distance)", "Short form of forward()."],
+    [
+      "backward",
+      "backward(distance)",
+      "Move the turtle backward by distance, without changing its heading."
+    ],
+    ["bk", "bk(distance)", "Short form of backward()."],
+    ["back", "back(distance)", "Short form of backward()."],
+    [
+      "right",
+      "right(angle)",
+      "Turn the turtle right (clockwise) by angle units."
+    ],
+    ["rt", "rt(angle)", "Short form of right()."],
+    [
+      "left",
+      "left(angle)",
+      "Turn the turtle left (counterclockwise) by angle units."
+    ],
+    ["lt", "lt(angle)", "Short form of left()."],
+    [
+      "goto",
+      "goto(x, y=None)",
+      "Move the turtle to an absolute position. Draws a line if the pen is down."
+    ],
+    ["setpos", "setpos(x, y=None)", "Same as goto()."],
+    ["setposition", "setposition(x, y=None)", "Same as goto()."],
+    [
+      "setx",
+      "setx(x)",
+      "Set the turtle's first coordinate, leaving the second unchanged."
+    ],
+    [
+      "sety",
+      "sety(y)",
+      "Set the turtle's second coordinate, leaving the first unchanged."
+    ],
+    [
+      "setheading",
+      "setheading(angle)",
+      "Set the turtle's orientation to angle. 0 is east in standard mode, north in logo mode."
+    ],
+    ["seth", "seth(angle)", "Short form of setheading()."],
+    [
+      "home",
+      "home()",
+      "Move the turtle to the origin and set its heading back to 0."
+    ],
+    [
+      "circle",
+      "circle(radius, extent=None, steps=None)",
+      "Draw a circle or, with extent, an arc. A positive radius curves to the left."
+    ],
+    [
+      "dot",
+      "dot(size=None, *color)",
+      "Draw a filled dot at the current position."
+    ],
+    ["position", "position()", "Return the turtle's current position as (x, y)."],
+    ["pos", "pos()", "Short form of position()."],
+    ["xcor", "xcor()", "Return the turtle's x coordinate."],
+    ["ycor", "ycor()", "Return the turtle's y coordinate."],
+    ["heading", "heading()", "Return the turtle's current heading."],
+    [
+      "towards",
+      "towards(x, y=None)",
+      "Return the angle from the turtle to the given position."
+    ],
+    [
+      "distance",
+      "distance(x, y=None)",
+      "Return the distance from the turtle to the given position."
+    ],
+    [
+      "degrees",
+      "degrees(fullcircle=360)",
+      "Measure angles in degrees, or in fullcircle units per revolution."
+    ],
+    ["radians", "radians()", "Measure angles in radians."],
+    [
+      "speed",
+      "speed(speed=None)",
+      "Set the animation speed from 1 (slowest) to 10 (fastest), or 0 for no animation. Also accepts 'fastest', 'fast', 'normal', 'slow' and 'slowest'. Without an argument it returns the current speed."
+    ],
+    ["undo", "undo()", "Undo the most recent turtle action."],
+    [
+      "undobufferentries",
+      "undobufferentries()",
+      "Return the number of actions that can still be undone."
+    ]
+  ];
+  var TURTLE_PEN = [
+    [
+      "pendown",
+      "pendown()",
+      "Put the pen down \u2014 the turtle draws when it moves."
+    ],
+    ["pd", "pd()", "Short form of pendown()."],
+    ["down", "down()", "Short form of pendown()."],
+    ["penup", "penup()", "Pull the pen up \u2014 the turtle moves without drawing."],
+    ["pu", "pu()", "Short form of penup()."],
+    ["up", "up()", "Short form of penup()."],
+    [
+      "pensize",
+      "pensize(width=None)",
+      "Set the line thickness. Without an argument it returns the current width."
+    ],
+    ["width", "width(width=None)", "Same as pensize()."],
+    [
+      "pen",
+      "pen(pen=None, **pendict)",
+      "Read or set the pen's state as a dictionary (pendown, pencolor, fillcolor, pensize, speed, shown)."
+    ],
+    [
+      "color",
+      "color(*args)",
+      "Set pen and fill colour at once: color(c), color(pen, fill) or color(r, g, b). Without arguments it returns both."
+    ],
+    [
+      "pencolor",
+      "pencolor(*args)",
+      "Set the line colour, as a name, an (r, g, b) tuple or three numbers. Without arguments it returns the current colour."
+    ],
+    [
+      "fillcolor",
+      "fillcolor(*args)",
+      "Set the fill colour, as a name, an (r, g, b) tuple or three numbers. Without arguments it returns the current colour."
+    ],
+    [
+      "begin_fill",
+      "begin_fill()",
+      "Start recording a shape to fill. Call end_fill() to fill it."
+    ],
+    [
+      "end_fill",
+      "end_fill()",
+      "Fill the shape drawn since the last begin_fill()."
+    ],
+    ["filling", "filling()", "Return True while a fill is being recorded."],
+    [
+      "write",
+      "write(arg, move=False, align='left', font=('Arial', 8, 'normal'))",
+      "Write text at the turtle's position."
+    ],
+    [
+      "setfontsize",
+      "setfontsize(size)",
+      "Set the default font size used by write()."
+    ],
+    [
+      "clear",
+      "clear()",
+      "Erase this turtle's drawings, leaving its position and pen state alone."
+    ],
+    [
+      "reset",
+      "reset()",
+      "Erase this turtle's drawings and restore its starting state."
+    ]
+  ];
+  var TURTLE_CURSOR = [
+    ["showturtle", "showturtle()", "Make the turtle visible."],
+    ["st", "st()", "Short form of showturtle()."],
+    [
+      "hideturtle",
+      "hideturtle()",
+      "Make the turtle invisible. Drawing is noticeably faster while hidden."
+    ],
+    ["ht", "ht()", "Short form of hideturtle()."],
+    ["isvisible", "isvisible()", "Return True if the turtle is visible."],
+    [
+      "shape",
+      "shape(name=None)",
+      "Set the turtle's shape: 'classic', 'arrow', 'turtle', 'circle', 'square', 'triangle' or 'blank'."
+    ],
+    [
+      "shapesize",
+      "shapesize(stretch_wid=None, stretch_len=None, outline=None)",
+      "Scale the turtle cursor and set its outline width."
+    ],
+    [
+      "turtlesize",
+      "turtlesize(stretch_wid=None, stretch_len=None, outline=None)",
+      "Same as shapesize()."
+    ],
+    [
+      "tilt",
+      "tilt(angle)",
+      "Rotate the turtle's shape by angle, without changing its heading."
+    ],
+    [
+      "tiltangle",
+      "tiltangle(angle=None)",
+      "Read or set the shape's rotation relative to the heading."
+    ],
+    [
+      "settiltangle",
+      "settiltangle(angle)",
+      "Set the shape's rotation relative to the heading."
+    ],
+    [
+      "stamp",
+      "stamp()",
+      "Stamp a copy of the turtle's shape onto the canvas and return its id."
+    ],
+    ["clearstamp", "clearstamp(stampid)", "Remove the stamp with the given id."],
+    [
+      "clearstamps",
+      "clearstamps(n=None)",
+      "Remove all stamps, the first n, or the last n if n is negative."
+    ]
+  ];
+  var TURTLE_SCREEN = [
+    [
+      "Screen",
+      "Screen()",
+      "Return the screen object, which carries the window-level functions."
+    ],
+    ["getscreen", "getscreen()", "Return the screen the turtle draws on."],
+    [
+      "Turtle",
+      "Turtle()",
+      "Create an additional turtle drawing on the same canvas."
+    ],
+    ["bgcolor", "bgcolor(color)", "Set the background colour of the canvas."],
+    [
+      "bgpic",
+      "bgpic(picname=None)",
+      "Set a background image from a file in the IDE's file system."
+    ],
+    [
+      "screensize",
+      "screensize(canvwidth=None, canvheight=None, bg=None)",
+      "Set the size of the drawing canvas in pixels."
+    ],
+    [
+      "setup",
+      "setup(width, height, startx=None, starty=None)",
+      "Set the canvas size in pixels."
+    ],
+    [
+      "colormode",
+      "colormode(cmode=None)",
+      "Use colour values from 0 to 1 (cmode=1.0) or 0 to 255 (cmode=255)."
+    ],
+    [
+      "mode",
+      "mode(mode=None)",
+      "Switch between 'standard' (0 = east) and 'logo' (0 = north). Changing the mode resets every turtle."
+    ],
+    [
+      "tracer",
+      "tracer(n=None, delay=None)",
+      "Draw only every n-th update. tracer(0) turns animation off until update() is called \u2014 the usual way to draw complex figures quickly."
+    ],
+    ["update", "update()", "Redraw the canvas. Needed after tracer(0)."],
+    [
+      "delay",
+      "delay(delay=None)",
+      "Read or set the delay between drawing steps, in milliseconds."
+    ],
+    ["title", "title(titlestring)", "Set the canvas title."],
+    ["window_width", "window_width()", "Return the canvas width in pixels."],
+    ["window_height", "window_height()", "Return the canvas height in pixels."],
+    [
+      "register_shape",
+      "register_shape(name, shape)",
+      "Register a polygon as a new turtle shape."
+    ],
+    ["addshape", "addshape(name, shape)", "Same as register_shape()."],
+    ["clearscreen", "clearscreen()", "Erase everything and reset every turtle."],
+    ["resetscreen", "resetscreen()", "Reset every turtle to its starting state."],
+    [
+      "setundobuffer",
+      "setundobuffer(size)",
+      "Set how many actions undo() can step back through."
+    ],
+    [
+      "numinput",
+      "numinput(title, prompt)",
+      "Ask the user for a number and return it, or None if cancelled."
+    ],
+    [
+      "textinput",
+      "textinput(title, prompt)",
+      "Ask the user for a string and return it, or None if cancelled."
+    ],
+    [
+      "listen",
+      "listen()",
+      "Give the canvas keyboard focus, so key handlers fire."
+    ],
+    [
+      "onkey",
+      "onkey(fun, key)",
+      "Call fun when key is released. Requires listen()."
+    ],
+    [
+      "onkeypress",
+      "onkeypress(fun, key=None)",
+      "Call fun when key is pressed. Requires listen()."
+    ],
+    ["onkeyrelease", "onkeyrelease(fun, key)", "Same as onkey()."],
+    [
+      "onclick",
+      "onclick(fun, btn=1)",
+      "Call fun(x, y) when the canvas is clicked."
+    ],
+    ["onscreenclick", "onscreenclick(fun, btn=1)", "Same as onclick()."],
+    ["ontimer", "ontimer(fun, t=0)", "Call fun after t milliseconds."],
+    ["mainloop", "mainloop()", "No-op here \u2014 the canvas is always on screen."],
+    ["done", "done()", "No-op here \u2014 the canvas is always on screen."],
+    [
+      "exitonclick",
+      "exitonclick()",
+      "No-op here \u2014 the canvas is always on screen."
+    ],
+    ["bye", "bye()", "No-op here \u2014 the canvas is always on screen."]
+  ];
+  var toOptions = (entries, boost = 0) => entries.map(([label, detail, info]) => ({
+    label,
+    type: "function",
+    detail,
+    info,
+    boost
+  }));
+  var isSecondary = ([, detail, info]) => /^(Short form|Same as|No-op)/.test(info);
+  var buildOptions = (groups) => {
+    const entries = groups.flat();
+    return [
+      ...toOptions(
+        entries.filter((entry) => !isSecondary(entry)),
+        1
+      ),
+      ...toOptions(entries.filter(isSecondary), -1)
+    ];
+  };
+  var MODULE_OPTIONS = buildOptions([
+    TURTLE_MOVE,
+    TURTLE_PEN,
+    TURTLE_CURSOR,
+    TURTLE_SCREEN
+  ]);
+  var MEMBER_OPTIONS = MODULE_OPTIONS.filter(
+    (option) => option.label !== "Turtle" && option.label !== "Screen"
+  );
+  var MEMBER_BASE_PATTERN = /(?:^|\n)\s*([A-Za-z_]\w*)\s*=\s*(?:turtle\s*\.\s*)?(?:Turtle|Screen|getscreen)\s*\(/g;
+  var memberBases = (doc) => {
+    const bases = ["turtle"];
+    for (const match of doc.matchAll(MEMBER_BASE_PATTERN)) {
+      if (!bases.includes(match[1])) bases.push(match[1]);
+    }
+    return bases;
+  };
+  var turtleCompletions = {
+    enabled: scriptLooksLikeTurtle,
+    globals: MODULE_OPTIONS,
+    members: MEMBER_OPTIONS,
+    memberBases
+  };
+
   // assets/directive-pyide/src/ui.js
   var updateFullscreenButtonState = (elem, button) => {
     if (!elem || !button) return;
     const isFullscreen = document.fullscreenElement === elem;
     const label = hyperbook.i18n.get("ide-fullscreen-enter");
-    button.textContent = "\u26F6";
     button.title = label;
     button.setAttribute("aria-label", label);
     button.classList.toggle("active", isFullscreen);
@@ -2108,6 +3143,7 @@ if _pg:
     if (!state.running && !hasRuntime || state.stopRequested) return;
     state.stopRequested = true;
     state.stopping = true;
+    cancelStdin(id);
     const interruptBuffer = interruptBuffers.get(id);
     if (interruptBuffer) {
       interruptBuffer[0] = 2;
@@ -2296,6 +3332,7 @@ if _pg:
         const cm = editorDiv ? HyperbookCM.create(editorDiv, {
           lang: editorDiv.dataset.lang || "python",
           value: initialSource,
+          completions: [turtleCompletions],
           onChange: (code) => {
             void persistPyideState({ script: code });
           }