gwchq-textjam 0.1.111 → 0.1.112

package/dist/assets/{PyodideWorkerdac22f5bda86eda11d3d.js → PyodideWorkera79b61f3c8f551703270.js}

@@ -1,652 +1,747 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-/* global globalThis, importScripts, loadPyodide, SharedArrayBuffer, Atomics, pygal */
-
-function toAbsoluteFromOrigin(url) {
-  if (url.startsWith("http") || url.startsWith("/")) return url;
-  // eslint-disable-next-line no-restricted-globals
-  return new URL(url, self.location.origin).href;
-}
-
-// removing submodules (matplotlib.pyplot = matplotlib)
-const normalizeImportName = (name) => name.split(".")[0];
-
-const WORKING_DIR = "/home/pyodide";
-
-// Nest the PyodideWorker function inside a globalThis object so we control when its initialised.
-const PyodideWorker = () => {
-  let assets;
-  let packageApiUrl;
-
-  const handleInit = (data) => {
-    assets = data.assets;
-    packageApiUrl = data.packageApiUrl;
-
-    // Import scripts dynamically based on the environment
-    console.log("PyodideWorker", "importing scripts");
-    importScripts(toAbsoluteFromOrigin(assets.pygalUrl));
-
-    assets.pyodideBaseUrl = `${packageApiUrl}/pyodide.js`;
-    importScripts(toAbsoluteFromOrigin(assets.pyodideBaseUrl));
-
-    initialisePyodide();
-  };
-
-  const supportsAllFeatures = typeof SharedArrayBuffer !== "undefined";
-
-  // eslint-disable-next-line no-restricted-globals
-  if (!supportsAllFeatures && name !== "incremental-features") {
-    console.warn(
-      [
-        "The code editor will not be able to capture standard input or stop execution because these HTTP headers are not set:",
-        "  - Cross-Origin-Opener-Policy: same-origin",
-        "  - Cross-Origin-Embedder-Policy: require-corp",
-        "",
-        "If your app can cope with or without these features, please initialize the web worker with { name: 'incremental-features' } to silence this warning.",
-        "You can then check for the presence of { stdinBuffer, interruptBuffer } in the handleLoaded message to check whether these features are supported.",
-        "",
-        "If you definitely need these features, either configure your server to respond with the HTTP headers above, or register a service worker.",
-        "Once the HTTP headers are set, the browser will block cross-domain resources so you will need to add 'crossorigin' to <script> and other tags.",
-        "You may wish to scope the HTTP headers to only those pages that host the code editor to make the browser restriction easier to deal with.",
-        "",
-        "Please refer to these code snippets for registering a service worker:",
-        "  - https://github.com/RaspberryPiFoundation/python-execution-prototypes/blob/fd2c50e032cba3bb0e92e19a88eb62e5b120fe7a/pyodide/index.html#L92-L98",
-        "  - https://github.com/RaspberryPiFoundation/python-execution-prototypes/blob/fd2c50e032cba3bb0e92e19a88eb62e5b120fe7a/pyodide/serviceworker.js",
-      ].join("\n"),
-    );
-  }
-  let pyodide, pyodidePromise, stdinBuffer, interruptBuffer, stopped;
-  /** When true, input() uses postMessage + run_sync(getInputAsync) instead of setStdin (requires JSPI). */
-  let useMessageStdin = false;
-  /** Used when SharedArrayBuffer is unavailable: resolve for the pending input() call. */
-  let pendingStdinResolve = null;
-  // Until Pyodide is fully initialised, keep stdout/stderr in the dev console only.
-  // After initialisation, route them to the UI via postMessage.
-  let userStdStreamsEnabled = false;
-  // When true, suppress internal library / package loader logs from the UI console.
-  let suppressInternalStdStreams = false;
-
-  const onmessage = async ({ data }) => {
-    if (data.method !== "init") {
-      pyodide = await pyodidePromise;
-    }
-
-    switch (data.method) {
-      case "stdinResponse":
-        if (pendingStdinResolve) {
-          let content = data.ctrlD ? null : data.content ?? "";
-          if (content && content.endsWith("\n")) {
-            content = content.slice(0, -1);
-          }
-          pendingStdinResolve(content);
-          pendingStdinResolve = null;
-        }
-        break;
-      case "init":
-        handleInit(data);
-        break;
-      case "createDirectories":
-        if (Array.isArray(data.dirs)) {
-          for (const dir of data.dirs) {
-            try {
-              pyodide.FS.mkdirTree(`${WORKING_DIR}/${dir}`);
-            } catch (e) {
-              console.error(`Failed to create directory ${dir}:`, e);
-            }
-          }
-        }
-        break;
-      case "writeFile":
-        const encoder = new TextEncoder();
-        pyodide.FS.writeFile(
-          `${WORKING_DIR}/${data.filename}`,
-          encoder.encode(data.content),
-        );
-        break;
-      case "runPython":
-        runPython(data.python, data.userModuleNames);
-        break;
-      case "stopPython":
-        // Mark as stopped so future checks can raise KeyboardInterrupt.
-        stopped = true;
-        // If Python is currently blocked in input() via run_sync(getInputAsync),
-        // resolve the pending stdin promise with EOF so execution can unwind
-        // and clearPyodideData can run.
-        if (pendingStdinResolve) {
-          pendingStdinResolve(null);
-          pendingStdinResolve = null;
-        }
-        break;
-      default:
-        throw new Error(`Unsupported method: ${data.method}`);
-    }
-  };
-
-  // eslint-disable-next-line no-restricted-globals
-  addEventListener("message", async (event) => {
-    onmessage(event);
-  });
-
-  const runPython = async (python, userModuleNames) => {
-    stopped = false;
-
-    // When stdin uses postMessage (no SharedArrayBuffer), run_sync() in input() requires
-    // runPythonAsync so that JSPI stack switching can suspend until the main thread sends stdinResponse.
-    const runUserCode = useMessageStdin
-      ? () => pyodide.runPythonAsync(python)
-      : () => pyodide.runPython(python);
-
-    try {
-      await withSupportForPackages(python, async () => {
-        await runUserCode();
-      });
-    } catch (error) {
-      if (!(error instanceof pyodide.ffi.PythonError)) {
-        throw error;
-      }
-      const parsed = parsePythonError(error);
-      // Stop resolves stdin with EOF so input() raises EOFError; show as interrupt, not error.
-      if (stopped && parsed.type === "EOFError") {
-        postMessage({
-          method: "handleError",
-          ...parsed,
-          type: "KeyboardInterrupt",
-          info: "Execution interrupted",
-        });
-      } else {
-        postMessage({ method: "handleError", ...parsed });
-      }
-    }
-
-    await clearPyodideData(userModuleNames);
-  };
-
-  const checkIfStopped = () => {
-    if (stopped) {
-      throw new pyodide.ffi.PythonError("KeyboardInterrupt");
-    }
-  };
-
-  const withSupportForPackages = async (
-    python,
-    runPythonFn = async () => {},
-  ) => {
-    // Suppress internal loader output (e.g. "Loading pyodide-http") from the
-    // user console while resolving imports and loading packages.
-    suppressInternalStdStreams = true;
-    const imports = await pyodide._api.pyodide_code.find_imports(python).toJs();
-    await Promise.all(imports.map((name) => loadDependency(name)));
-
-    checkIfStopped();
-    await pyodide.loadPackagesFromImports(python);
-
-    checkIfStopped();
-    await pyodide.runPythonAsync(
-      `
-      import basthon
-      import builtins
-      import os
-
-      MAX_FILES = 100
-      MAX_FILE_SIZE = 8500000
-
-      def _custom_open(filename, mode="r", *args, **kwargs):
-          if "x" in mode and os.path.exists(filename):
-              raise FileExistsError(f"File '{filename}' already exists")
-          if ("w" in mode or "a" in mode or "x" in mode) and "b" not in mode:
-              if len(os.listdir()) > MAX_FILES and not os.path.exists(filename):
-                  raise OSError(f"File system limit reached, no more than {MAX_FILES} files allowed")
-              class CustomFile:
-                  def __init__(self, filename):
-                      self.filename = filename
-                      self.content = ""
-
-                  def write(self, content):
-                      self.content += content
-                      if len(self.content) > MAX_FILE_SIZE:
-                          raise OSError(f"File '{self.filename}' exceeds maximum file size of {MAX_FILE_SIZE} bytes")
-                      with _original_open(self.filename, mode) as f:
-                          f.write(self.content)
-                      basthon.kernel.write_file({ "filename": self.filename, "content": self.content, "mode": mode })
-
-                  def close(self):
-                      pass
-
-                  def __enter__(self):
-                      return self
-
-                  def __exit__(self, exc_type, exc_val, exc_tb):
-                      self.close()
-
-              return CustomFile(filename)
-          else:
-              return _original_open(filename, mode, *args, **kwargs)
-
-      # Override the built-in open function
-      builtins.open = _custom_open
-      `,
-      { filename: "__custom_open__.py" },
-    );
-
-    // Re-enable user-visible stdout / stderr for the actual user code run.
-    suppressInternalStdStreams = false;
-
-    await runPythonFn();
-
-    for (let name of imports) {
-      checkIfStopped();
-      const pkgName = normalizeImportName(name);
-      await vendoredPackages[pkgName]?.after();
-    }
-  };
-
-  const loadDependency = async (name) => {
-    checkIfStopped();
-
-    const pkgName = normalizeImportName(name);
-    // If the import is for another user file then open it and load its dependencies.
-    if (pyodide.FS.readdir(WORKING_DIR).includes(`${pkgName}.py`)) {
-      const fileContent = pyodide.FS.readFile(`${WORKING_DIR}/${pkgName}.py`, {
-        encoding: "utf8",
-      });
-      await withSupportForPackages(fileContent);
-      return;
-    }
-
-    // If the import is for a vendored package then run its .before() hook.
-    const vendoredPackage = vendoredPackages[pkgName];
-    await vendoredPackage?.before();
-    if (vendoredPackage) {
-      return;
-    }
-
-    // If the import is for a module built into Python then do nothing.
-    try {
-      const pythonModule = pyodide.pyimport(pkgName);
-      if (pythonModule) {
-        return;
-      }
-    } catch (_) {}
-
-    // If the import is for a package built into Pyodide then load it.
-    // Built-ins: https://pyodide.org/en/stable/usage/packages-in-pyodide.html
-    try {
-      await pyodide.loadPackage(pkgName);
-
-      const pyodidePackage = pyodide.pyimport(pkgName);
-      if (pyodidePackage) {
-        return;
-      }
-    } catch (_) {}
-
-    // Ensure micropip is loaded which can fetch packages from PyPi.
-    // See: https://pyodide.org/en/stable/usage/loading-packages.html
-    if (!pyodide.micropip) {
-      await pyodide.loadPackage("micropip");
-      pyodide.micropip = pyodide.pyimport("micropip");
-    }
-
-    // If the import is for a PyPi package then load it.
-    // Otherwise, don't error now so that we get an error later from Python.
-    await pyodide.micropip.install(pkgName).catch(() => {});
-  };
-
-  const vendoredPackages = {
-    // Support for https://pypi.org/project/py-enigma/ due to package not having a whl file on PyPi.
-    enigma: {
-      before: async () => {
-        await pyodide.loadPackage(toAbsoluteFromOrigin(assets.enigmaWhlUrl));
-      },
-      after: () => {},
-    },
-    turtle: {
-      before: async () => {
-        pyodide.registerJsModule("basthon", fakeBasthonPackage);
-        await pyodide.loadPackage(toAbsoluteFromOrigin(assets.turtleWhlUrl));
-      },
-      after: () =>
-        pyodide.runPython(`
-        import turtle
-        import basthon
-
-        svg_dict = turtle.Screen().show_scene()
-        basthon.kernel.display_event({ "display_type": "turtle", "content": svg_dict })
-        turtle.restart()
-      `),
-    },
-    p5: {
-      before: async () => {
-        pyodide.registerJsModule("basthon", fakeBasthonPackage);
-        await pyodide.loadPackage([
-          "setuptools",
-          toAbsoluteFromOrigin(assets.p5WhlUrl),
-        ]);
-      },
-      after: () => {},
-    },
-    pygal: {
-      before: () => {
-        pyodide.registerJsModule("pygal", { ...pygal });
-        pygal.config.renderChart = (content) => {
-          postMessage({ method: "handleVisual", origin: "pygal", content });
-        };
-      },
-      after: () => {},
-    },
-    matplotlib: {
-      before: async () => {
-        pyodide.registerJsModule("basthon", fakeBasthonPackage);
-        // Patch the document object to prevent matplotlib from trying to render. Since we are running in a web worker,
-        // the document object is not available. We will instead capture the image and send it back to the main thread.
-        pyodide.runPython(`
-        import js
-
-        class __DummyDocument__:
-            def __init__(self, *args, **kwargs) -> None:
-                return
-            def __getattr__(self, __name: str):
-                return __DummyDocument__
-        js.document = __DummyDocument__()
-        `);
-        await pyodide.loadPackage("matplotlib")?.catch(() => {});
-        let pyodidePackage;
-        try {
-          pyodidePackage = pyodide.pyimport("matplotlib");
-        } catch (_) {}
-        if (pyodidePackage) {
-          pyodide.runPython(`
-            import matplotlib.pyplot as plt
-            import io
-            import basthon
-
-            def show_chart():
-                bytes_io = io.BytesIO()
-                plt.savefig(bytes_io, format='jpg')
-                bytes_io.seek(0)
-                basthon.kernel.display_event({ "display_type": "matplotlib", "content": bytes_io.read() })
-            plt.show = show_chart
-            `);
-          return;
-        }
-      },
-      after: () => {
-        pyodide.runPython(`
-        import matplotlib.pyplot as plt
-        plt.clf()
-        `);
-      },
-    },
-    seaborn: {
-      before: async () => {
-        pyodide.registerJsModule("basthon", fakeBasthonPackage);
-        // Patch the document object to prevent matplotlib from trying to render. Since we are running in a web worker,
-        // the document object is not available. We will instead capture the image and send it back to the main thread.
-        pyodide.runPython(`
-        import js
-
-        class __DummyDocument__:
-            def __init__(self, *args, **kwargs) -> None:
-                return
-            def __getattr__(self, __name: str):
-                return __DummyDocument__
-        js.document = __DummyDocument__()
-        `);
-
-        // Ensure micropip is loaded which can fetch packages from PyPi.
-        // See: https://pyodide.org/en/stable/usage/loading-packages.html
-        if (!pyodide.micropip) {
-          await pyodide.loadPackage("micropip");
-          pyodide.micropip = pyodide.pyimport("micropip");
-        }
-
-        // If the import is for a PyPi package then load it.
-        // Otherwise, don't error now so that we get an error later from Python.
-        await pyodide.micropip.install("seaborn").catch(() => {});
-      },
-      after: () => {
-        pyodide.runPython(`
-        import matplotlib.pyplot as plt
-        import io
-        import basthon
-
-        def is_plot_empty():
-            fig = plt.gcf()
-            for ax in fig.get_axes():
-                # Check if the axes contain any lines, patches, collections, etc.
-                if ax.lines or ax.patches or ax.collections or ax.images or ax.texts:
-                    return False
-            return True
-
-        if not is_plot_empty():
-            bytes_io = io.BytesIO()
-            plt.savefig(bytes_io, format='jpg')
-            bytes_io.seek(0)
-            basthon.kernel.display_event({ "display_type": "matplotlib", "content": bytes_io.read() })
-
-        plt.clf()
-        `);
-      },
-    },
-    plotly: {
-      before: async () => {
-        if (!pyodide.micropip) {
-          await pyodide.loadPackage("micropip");
-          pyodide.micropip = pyodide.pyimport("micropip");
-        }
-
-        // If the import is for a PyPi package then load it.
-        // Otherwise, don't error now so that we get an error later from Python.
-        await pyodide.micropip.install("plotly").catch(() => {});
-        await pyodide.micropip.install("pandas").catch(() => {});
-        pyodide.registerJsModule("basthon", fakeBasthonPackage);
-        pyodide.runPython(`
-          import plotly.graph_objs as go
-
-          def _hacked_show(self, *args, **kwargs):
-              basthon.kernel.display_event({
-                  "display_type": "plotly",
-                  "content": self.to_json()
-              })
-
-          go.Figure.show = _hacked_show
-      `);
-      },
-      after: () => {},
-    },
-  };
-
-  const fakeBasthonPackage = {
-    kernel: {
-      display_event: (event) => {
-        const origin = event.toJs().get("display_type");
-        const content = event.toJs().get("content");
-
-        postMessage({ method: "handleVisual", origin, content });
-      },
-      write_file: (event) => {
-        const filename = event.toJs().get("filename");
-        const content = event.toJs().get("content");
-        const mode = event.toJs().get("mode");
-        postMessage({ method: "handleFileWrite", filename, content, mode });
-      },
-      locals: () => pyodide.runPython("globals()"),
-      /**
-       * Returns a Promise that resolves with the next line of stdin when the main thread
-       * sends stdinResponse. Resolves with null on EOF (e.g. Ctrl+D).
-       * Used when SharedArrayBuffer is unavailable (no COOP/COEP) so we cannot block via Atomics.wait.
-       * Requires JSPI and runPythonAsync() for run_sync() to work.
-       */
-      getInputAsync: () => {
-        const promise = new Promise((resolve) => {
-          pendingStdinResolve = resolve;
-        });
-        postMessage({ method: "handleInput" });
-        return promise;
-      },
-    },
-  };
-
-  const clearPyodideData = async (userModuleNames) => {
-    postMessage({ method: "handleLoading" });
-    try {
-      await pyodide.runPythonAsync(`
-        # Clear all user-defined variables and modules
-        for name in list(globals()):
-          if not name.startswith('_') and not name=='basthon':
-            del globals()[name]
-
-        import sys
-        # Remove user modules from sys.modules
-        user_modules = ${JSON.stringify(userModuleNames)}
-        for name in user_modules:
-          if name in sys.modules:
-            del sys.modules[name]
-        `);
-    } catch (error) {
-      console.error("Error while clearing Pyodide data:", error);
-    }
-    console.log("clearPyodideData done");
-    postMessage({ method: "handleLoaded", stdinBuffer, interruptBuffer });
-  };
-
-  const initialisePyodide = async () => {
-    postMessage({ method: "handleLoading" });
-
-    pyodidePromise = loadPyodide({
-      stdout: (content) => {
-        if (stopped) return;
-        if (userStdStreamsEnabled && !suppressInternalStdStreams) {
-          postMessage({ method: "handleOutput", stream: "stdout", content });
-        } else {
-          console.log(content);
-        }
-      },
-      stderr: (content) => {
-        if (stopped) return;
-        if (userStdStreamsEnabled && !suppressInternalStdStreams) {
-          postMessage({ method: "handleOutput", stream: "stderr", content });
-        } else {
-          console.error(content);
-        }
-      },
-    });
-
-    pyodide = await pyodidePromise;
-
-    pyodide.registerJsModule("basthon", fakeBasthonPackage);
-
-    // When SharedArrayBuffer is unavailable, always use the postMessage-based
-    // stdin path. JSPI / run_sync will raise at runtime if the environment
-    // cannot stack-switch, but in JSPI-capable browsers this enables
-    // interactive input() without COOP/COEP.
-    useMessageStdin = !supportsAllFeatures;
-    pyodide.globals.set("__stdin_via_message__", useMessageStdin);
-
-    await pyodide.runPythonAsync(`
-    import builtins
-    from pyodide.ffi import run_sync as __run_sync__
-
-    __old_input__ = builtins.input
-    def __patched_input__(prompt=None):
-        if prompt is not None:
-            print(prompt)
-        if __stdin_via_message__:
-            result = __run_sync__(basthon.kernel.getInputAsync())
-            if result is None:
-                raise EOFError("EOF when reading a line")
-            return result
-        return __old_input__()
-    builtins.input = __patched_input__
-    `);
-
-    await pyodide.runPythonAsync(`
-    import builtins
-    # Save the original open function
-    _original_open = builtins.open
-    `);
-
-    await pyodide.loadPackage("pyodide-http");
-    await pyodide.runPythonAsync(`
-        import pyodide_http
-        pyodide_http.patch_all()
-      `);
-
-    if (supportsAllFeatures) {
-      stdinBuffer =
-        stdinBuffer || new Int32Array(new SharedArrayBuffer(1024 * 1024)); // 1 MiB
-      stdinBuffer[0] = 1; // Store the length of content in the buffer at index 0.
-      pyodide.setStdin({ isatty: true, read: readFromStdin });
-
-      interruptBuffer =
-        interruptBuffer || new Uint8Array(new SharedArrayBuffer(1));
-      pyodide.setInterruptBuffer(interruptBuffer);
-    }
-
-    // From this point on, anything written to stdout / stderr is considered
-    // user-visible and will be forwarded to the UI.
-    userStdStreamsEnabled = true;
-
-    postMessage({ method: "handleLoaded", stdinBuffer, interruptBuffer });
-  };
-
-  const readFromStdin = (bufferToWrite) => {
-    const previousLength = stdinBuffer[0];
-    postMessage({ method: "handleInput" });
-
-    while (true) {
-      pyodide.checkInterrupt();
-      const result = Atomics.wait(stdinBuffer, 0, previousLength, 100);
-      if (result === "not-equal") {
-        break;
-      }
-    }
-
-    const currentLength = stdinBuffer[0];
-    if (currentLength === -1) {
-      return 0;
-    } // Signals that stdin was closed.
-
-    const addedBytes = stdinBuffer.slice(previousLength, currentLength);
-    bufferToWrite.set(addedBytes);
-
-    return addedBytes.length;
-  };
-
-  const parsePythonError = (error) => {
-    const type = error.type;
-    const [trace, info] = error.message.split(`${type}:`).map((s) => s?.trim());
-
-    const lines = trace.split("\n");
-
-    // if the third from last line matches /File "__custom_open__\.py", line (\d+)/g then strip off the last three lines
-    if (
-      lines.length > 3 &&
-      /File "__custom_open__\.py", line (\d+)/g.test(lines[lines.length - 3])
-    ) {
-      lines.splice(-3, 3);
-    }
-
-    const snippetLine = lines[lines.length - 2]; //    print("hi")invalid
-    const caretLine = lines[lines.length - 1]; //                 ^^^^^^^
-
-    const showsMistake = caretLine.includes("^");
-    const mistake = showsMistake
-      ? [snippetLine.slice(4), caretLine.slice(4)].join("\n")
-      : "";
-
-    const matches = [
-      ...trace.matchAll(/File "(?!__custom_open__\.py)(.*)", line (\d+)/g),
-    ];
-    const match = matches[matches.length - 1];
-
-    const path = match ? match[1] : "";
-    const base = path.split("/").reverse()[0];
-    const file = base === "<exec>" ? "main.py" : base;
-
-    const line = match ? parseInt(match[2], 10) : "";
-
-    return { file, line, mistake, type, info };
-  };
-};
-
-globalThis.PyodideWorker = PyodideWorker;
-PyodideWorker();
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* global globalThis, importScripts, loadPyodide, SharedArrayBuffer, Atomics, pygal */
+
+function toAbsoluteFromOrigin(url) {
+  if (url.startsWith("http") || url.startsWith("/")) return url;
+  // eslint-disable-next-line no-restricted-globals
+  return new URL(url, self.location.origin).href;
+}
+
+const WORKING_DIR = "/home/pyodide";
+
+const toStructuredCloneable = (value) => {
+  if (value == null) return value;
+
+  if (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return value;
+  }
+
+  if (value instanceof Uint8Array) {
+    return value.slice();
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(
+      value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength),
+    );
+  }
+
+  if (value instanceof ArrayBuffer) {
+    return value.slice(0);
+  }
+
+  if (value instanceof Map) {
+    return Object.fromEntries(
+      [...value.entries()].map(([k, v]) => [k, toStructuredCloneable(v)]),
+    );
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(toStructuredCloneable);
+  }
+
+  if (typeof value?.toJs === "function") {
+    try {
+      const converted = value.toJs({ dict_converter: Object.fromEntries });
+      return toStructuredCloneable(converted);
+    } catch (_) {
+      try {
+        const converted = value.toJs();
+        return toStructuredCloneable(converted);
+      } catch (_) {
+        return String(value);
+      }
+    }
+  }
+
+  if (typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = toStructuredCloneable(val);
+    }
+    return result;
+  }
+
+  return String(value);
+};
+
+// Nest the PyodideWorker function inside a globalThis object so we control when its initialised.
+const PyodideWorker = () => {
+  let assets;
+  let packageApiUrl;
+
+  const handleInit = (data) => {
+    assets = data.assets;
+    packageApiUrl = data.packageApiUrl;
+
+    // Import scripts dynamically based on the environment
+    console.log("PyodideWorker", "importing scripts");
+    importScripts(toAbsoluteFromOrigin(assets.pygalUrl));
+
+    assets.pyodideBaseUrl = `${packageApiUrl}/pyodide.js`;
+    importScripts(toAbsoluteFromOrigin(assets.pyodideBaseUrl));
+
+    initialisePyodide();
+  };
+
+  const supportsAllFeatures = typeof SharedArrayBuffer !== "undefined";
+
+  // eslint-disable-next-line no-restricted-globals
+  if (!supportsAllFeatures && name !== "incremental-features") {
+    console.warn(
+      [
+        "The code editor will not be able to capture standard input or stop execution because these HTTP headers are not set:",
+        "  - Cross-Origin-Opener-Policy: same-origin",
+        "  - Cross-Origin-Embedder-Policy: require-corp",
+        "",
+        "If your app can cope with or without these features, please initialize the web worker with { name: 'incremental-features' } to silence this warning.",
+        "You can then check for the presence of { stdinBuffer, interruptBuffer } in the handleLoaded message to check whether these features are supported.",
+        "",
+        "If you definitely need these features, either configure your server to respond with the HTTP headers above, or register a service worker.",
+        "Once the HTTP headers are set, the browser will block cross-domain resources so you will need to add 'crossorigin' to <script> and other tags.",
+        "You may wish to scope the HTTP headers to only those pages that host the code editor to make the browser restriction easier to deal with.",
+        "",
+        "Please refer to these code snippets for registering a service worker:",
+        "  - https://github.com/RaspberryPiFoundation/python-execution-prototypes/blob/fd2c50e032cba3bb0e92e19a88eb62e5b120fe7a/pyodide/index.html#L92-L98",
+        "  - https://github.com/RaspberryPiFoundation/python-execution-prototypes/blob/fd2c50e032cba3bb0e92e19a88eb62e5b120fe7a/pyodide/serviceworker.js",
+      ].join("\n"),
+    );
+  }
+  let pyodide, pyodidePromise, stdinBuffer, interruptBuffer, stopped;
+  /** When true, input() uses postMessage + run_sync(getInputAsync) instead of setStdin (requires JSPI). */
+  let useMessageStdin = false;
+  /** Used when SharedArrayBuffer is unavailable: resolve for the pending input() call. */
+  let pendingStdinResolve = null;
+  // Until Pyodide is fully initialised, keep stdout/stderr in the dev console only.
+  // After initialisation, route them to the UI via postMessage.
+  let userStdStreamsEnabled = false;
+  // When true, suppress internal library / package loader logs from the UI console.
+  let suppressInternalStdStreams = false;
+
+  const onmessage = async ({ data }) => {
+    pyodide = await pyodidePromise;
+    let encoder = new TextEncoder();
+
+    switch (data.method) {
+      case "stdinResponse":
+        if (pendingStdinResolve) {
+          let content = data.ctrlD ? null : data.content ?? "";
+          if (content && content.endsWith("\n")) {
+            content = content.slice(0, -1);
+          }
+          pendingStdinResolve(content);
+          pendingStdinResolve = null;
+        }
+        break;
+      case "init":
+        handleInit(data);
+        break;
+      case "createDirectories":
+        if (Array.isArray(data.dirs)) {
+          for (const dir of data.dirs) {
+            try {
+              pyodide.FS.mkdirTree(`${WORKING_DIR}/${dir}`);
+            } catch (e) {
+              console.error(`Failed to create directory ${dir}:`, e);
+            }
+          }
+        }
+        break;
+      case "writeFile":
+        pyodide.FS.writeFile(
+          `${WORKING_DIR}/${data.filename}`,
+          encoder.encode(data.content),
+        );
+        break;
+      case "runPython":
+        runPython(data.python, data.userModuleNames);
+        break;
+      case "stopPython":
+        // Mark as stopped so future checks can raise KeyboardInterrupt.
+        stopped = true;
+        // If Python is currently blocked in input() via run_sync(getInputAsync),
+        // resolve the pending stdin promise with EOF so execution can unwind
+        // and clearPyodideData can run.
+        if (pendingStdinResolve) {
+          pendingStdinResolve(null);
+          pendingStdinResolve = null;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported method: ${data.method}`);
+    }
+  };
+
+  // eslint-disable-next-line no-restricted-globals
+  addEventListener("message", async (event) => {
+    onmessage(event);
+  });
+
+  const runPython = async (python, userModuleNames) => {
+    stopped = false;
+
+    // When stdin uses postMessage (no SharedArrayBuffer), run_sync() in input() requires
+    // runPythonAsync so that JSPI stack switching can suspend until the main thread sends stdinResponse.
+    const runUserCode = useMessageStdin
+      ? () => pyodide.runPythonAsync(python)
+      : () => pyodide.runPython(python);
+
+    try {
+      await withSupportForPackages(python, async () => {
+        await runUserCode();
+      });
+    } catch (error) {
+      if (!(error instanceof pyodide.ffi.PythonError)) {
+        throw error;
+      }
+      const parsed = parsePythonError(error);
+      // Stop resolves stdin with EOF so input() raises EOFError; show as interrupt, not error.
+      if (stopped && parsed.type === "EOFError") {
+        postMessage({
+          method: "handleError",
+          ...parsed,
+          type: "KeyboardInterrupt",
+          info: "Execution interrupted",
+        });
+      } else {
+        postMessage({ method: "handleError", ...parsed });
+      }
+    }
+
+    await clearPyodideData(userModuleNames);
+  };
+
+  const checkIfStopped = () => {
+    if (stopped) {
+      throw new pyodide.ffi.PythonError("KeyboardInterrupt");
+    }
+  };
+
+  const withSupportForPackages = async (
+    python,
+    runPythonFn = async () => {},
+  ) => {
+    // Suppress internal loader output (e.g. "Loading pyodide-http") from the
+    // user console while resolving imports and loading packages.
+    suppressInternalStdStreams = true;
+    const imports = await pyodide._api.pyodide_code.find_imports(python).toJs();
+    await Promise.all(imports.map((name) => loadDependency(name)));
+
+    checkIfStopped();
+    await pyodide.loadPackagesFromImports(python);
+
+    checkIfStopped();
+    await pyodide.runPythonAsync(
+      `
+      import basthon
+      import builtins
+      import os
+
+      MAX_FILES = 100
+      MAX_FILE_SIZE = 8500000
+      PROJECT_ROOT = os.path.abspath("${WORKING_DIR}")
+
+      def _is_project_file(filename):
+          abs_path = os.path.abspath(filename)
+          return abs_path == PROJECT_ROOT or abs_path.startswith(PROJECT_ROOT + os.sep)
+
+      def _to_project_relative(filename):
+          abs_path = os.path.abspath(filename)
+          return os.path.relpath(abs_path, PROJECT_ROOT)
+
+      def _custom_open(filename, mode="r", *args, **kwargs):
+          abs_path = os.path.abspath(filename)
+
+          if "x" in mode and os.path.exists(abs_path):
+              raise FileExistsError(f"File '{filename}' already exists")
+
+          is_text_write = ("w" in mode or "a" in mode or "x" in mode) and "b" not in mode
+          is_project_file = _is_project_file(abs_path)
+
+          if is_text_write and is_project_file:
+              if len(os.listdir(PROJECT_ROOT)) > MAX_FILES and not os.path.exists(abs_path):
+                  raise OSError(f"File system limit reached, no more than {MAX_FILES} files allowed")
+              class CustomFile:
+                  def __init__(self, filename):
+                      self.filename = filename
+                      self.content = ""
+
+                  def write(self, content):
+                      self.content += content
+                      if len(self.content) > MAX_FILE_SIZE:
+                          raise OSError(f"File '{self.filename}' exceeds maximum file size of {MAX_FILE_SIZE} bytes")
+                      with _original_open(self.filename, mode, *args, **kwargs) as f:
+                          f.write(self.content)
+                      basthon.kernel.write_file({
+                          "filename": _to_project_relative(self.filename),
+                          "content": self.content,
+                          "mode": mode
+                      })
+
+                  def close(self):
+                      pass
+
+                  def __enter__(self):
+                      return self
+
+                  def __exit__(self, exc_type, exc_val, exc_tb):
+                      self.close()
+
+              return CustomFile(abs_path)
+          else:
+              return _original_open(filename, mode, *args, **kwargs)
+
+      # Override the built-in open function
+      builtins.open = _custom_open
+      `,
+      { filename: "__custom_open__.py" },
+    );
+
+    // Re-enable user-visible stdout / stderr for the actual user code run.
+    suppressInternalStdStreams = false;
+
+    await runPythonFn();
+
+    for (let name of imports) {
+      checkIfStopped();
+      await vendoredPackages[name]?.after();
+    }
+  };
+
+  const loadDependency = async (name) => {
+    checkIfStopped();
+
+    // If the import is for another user file then open it and load its dependencies.
+    if (pyodide.FS.readdir(WORKING_DIR).includes(`${name}.py`)) {
+      const fileContent = pyodide.FS.readFile(`${WORKING_DIR}/${name}.py`, {
+        encoding: "utf8",
+      });
+      await withSupportForPackages(fileContent);
+      return;
+    }
+
+    // If the import is for a vendored package then run its .before() hook.
+    const vendoredPackage = vendoredPackages[name];
+    await vendoredPackage?.before();
+    if (vendoredPackage) {
+      return;
+    }
+
+    // If the import is for a module built into Python then do nothing.
+    let pythonModule;
+    try {
+      pythonModule = pyodide.pyimport(name);
+    } catch (_) {}
+    if (pythonModule) {
+      return;
+    }
+
+    // If the import is for a package built into Pyodide then load it.
+    // Built-ins: https://pyodide.org/en/stable/usage/packages-in-pyodide.html
+    await pyodide.loadPackage(name)?.catch(() => {});
+    let pyodidePackage;
+    try {
+      pyodidePackage = pyodide.pyimport(name);
+    } catch (_) {}
+    if (pyodidePackage) {
+      return;
+    }
+
+    // Ensure micropip is loaded which can fetch packages from PyPi.
+    // See: https://pyodide.org/en/stable/usage/loading-packages.html
+    if (!pyodide.micropip) {
+      await pyodide.loadPackage("micropip");
+      pyodide.micropip = pyodide.pyimport("micropip");
+    }
+
+    // If the import is for a PyPi package then load it.
+    // Otherwise, don't error now so that we get an error later from Python.
+    await pyodide.micropip.install(name).catch(() => {});
+  };
+
+  const vendoredPackages = {
+    // Support for https://pypi.org/project/py-enigma/ due to package not having a whl file on PyPi.
+    enigma: {
+      before: async () => {
+        await pyodide.loadPackage(toAbsoluteFromOrigin(assets.enigmaWhlUrl));
+      },
+      after: () => {},
+    },
+    turtle: {
+      before: async () => {
+        pyodide.registerJsModule("basthon", fakeBasthonPackage);
+        await pyodide.loadPackage(toAbsoluteFromOrigin(assets.turtleWhlUrl));
+      },
+      after: () =>
+        pyodide.runPython(`
+        import turtle
+        import basthon
+
+        svg_dict = turtle.Screen().show_scene()
+        basthon.kernel.display_event({ "display_type": "turtle", "content": svg_dict })
+        turtle.restart()
+      `),
+    },
+    p5: {
+      before: async () => {
+        pyodide.registerJsModule("basthon", fakeBasthonPackage);
+        await pyodide.loadPackage([
+          "setuptools",
+          toAbsoluteFromOrigin(assets.p5WhlUrl),
+        ]);
+      },
+      after: () => {},
+    },
+    pygal: {
+      before: () => {
+        pyodide.registerJsModule("pygal", { ...pygal });
+        pygal.config.renderChart = (content) => {
+          postMessage({ method: "handleVisual", origin: "pygal", content });
+        };
+      },
+      after: () => {},
+    },
+    matplotlib: {
+      before: async () => {
+        pyodide.registerJsModule("basthon", fakeBasthonPackage);
+        // Patch the document object to prevent matplotlib from trying to render. Since we are running in a web worker,
+        // the document object is not available. We will instead capture the image and send it back to the main thread.
+        pyodide.runPython(`
+        import js
+
+        class __DummyDocument__:
+            def __init__(self, *args, **kwargs) -> None:
+                return
+            def __getattr__(self, __name: str):
+                return __DummyDocument__
+        js.document = __DummyDocument__()
+        `);
+        await pyodide.loadPackage("matplotlib")?.catch(() => {});
+        let pyodidePackage;
+        try {
+          pyodidePackage = pyodide.pyimport("matplotlib");
+        } catch (_) {}
+        if (pyodidePackage) {
+          pyodide.runPython(`
+            import matplotlib.pyplot as plt
+            import io
+            import basthon
+
+            def show_chart():
+                bytes_io = io.BytesIO()
+                plt.savefig(bytes_io, format='jpg')
+                bytes_io.seek(0)
+                basthon.kernel.display_event({ "display_type": "matplotlib", "content": bytes_io.read() })
+            plt.show = show_chart
+            `);
+          return;
+        }
+      },
+      after: () => {
+        pyodide.runPython(`
+        import matplotlib.pyplot as plt
+        plt.clf()
+        `);
+      },
+    },
+    seaborn: {
+      before: async () => {
+        pyodide.registerJsModule("basthon", fakeBasthonPackage);
+        // Patch the document object to prevent matplotlib from trying to render. Since we are running in a web worker,
+        // the document object is not available. We will instead capture the image and send it back to the main thread.
+        pyodide.runPython(`
+        import js
+
+        class __DummyDocument__:
+            def __init__(self, *args, **kwargs) -> None:
+                return
+            def __getattr__(self, __name: str):
+                return __DummyDocument__
+        js.document = __DummyDocument__()
+        `);
+
+        // Ensure micropip is loaded which can fetch packages from PyPi.
+        // See: https://pyodide.org/en/stable/usage/loading-packages.html
+        if (!pyodide.micropip) {
+          await pyodide.loadPackage("micropip");
+          pyodide.micropip = pyodide.pyimport("micropip");
+        }
+
+        // If the import is for a PyPi package then load it.
+        // Otherwise, don't error now so that we get an error later from Python.
+        await pyodide.micropip.install("seaborn").catch(() => {});
+      },
+      after: () => {
+        pyodide.runPython(`
+        import matplotlib.pyplot as plt
+        import io
+        import basthon
+
+        def is_plot_empty():
+            fig = plt.gcf()
+            for ax in fig.get_axes():
+                # Check if the axes contain any lines, patches, collections, etc.
+                if ax.lines or ax.patches or ax.collections or ax.images or ax.texts:
+                    return False
+            return True
+
+        if not is_plot_empty():
+            bytes_io = io.BytesIO()
+            plt.savefig(bytes_io, format='jpg')
+            bytes_io.seek(0)
+            basthon.kernel.display_event({ "display_type": "matplotlib", "content": bytes_io.read() })
+
+        plt.clf()
+        `);
+      },
+    },
+    plotly: {
+      before: async () => {
+        if (!pyodide.micropip) {
+          await pyodide.loadPackage("micropip");
+          pyodide.micropip = pyodide.pyimport("micropip");
+        }
+
+        // If the import is for a PyPi package then load it.
+        // Otherwise, don't error now so that we get an error later from Python.
+        await pyodide.micropip.install("plotly").catch(() => {});
+        await pyodide.micropip.install("pandas").catch(() => {});
+        pyodide.registerJsModule("basthon", fakeBasthonPackage);
+        pyodide.runPython(`
+          import plotly.graph_objs as go
+
+          def _hacked_show(self, *args, **kwargs):
+              basthon.kernel.display_event({
+                  "display_type": "plotly",
+                  "content": self.to_json()
+              })
+
+          go.Figure.show = _hacked_show
+      `);
+      },
+      after: () => {},
+    },
+  };
+
+  const fakeBasthonPackage = {
+    kernel: {
+      display_event: (event) => {
+        let payload;
+        try {
+          payload = event.toJs({ dict_converter: Object.fromEntries });
+        } catch (_) {
+          payload = event.toJs();
+        }
+
+        const origin = String(payload.display_type);
+        const content = toStructuredCloneable(payload.content);
+
+        postMessage({ method: "handleVisual", origin, content });
+      },
+      write_file: (event) => {
+        let payload;
+        try {
+          payload = event.toJs({ dict_converter: Object.fromEntries });
+        } catch (_) {
+          payload = event.toJs();
+        }
+
+        const filename = String(payload.filename);
+        const content =
+          typeof payload.content === "string"
+            ? payload.content
+            : toStructuredCloneable(payload.content);
+        const mode = String(payload.mode);
+
+        postMessage({ method: "handleFileWrite", filename, content, mode });
+      },
+      locals: () => pyodide.runPython("globals()"),
+      /**
+       * Returns a Promise that resolves with the next line of stdin when the main thread
+       * sends stdinResponse. Resolves with null on EOF (e.g. Ctrl+D).
+       * Used when SharedArrayBuffer is unavailable (no COOP/COEP) so we cannot block via Atomics.wait.
+       * Requires JSPI and runPythonAsync() for run_sync() to work.
+       */
+      getInputAsync: () => {
+        const promise = new Promise((resolve) => {
+          pendingStdinResolve = resolve;
+        });
+        postMessage({ method: "handleInput" });
+        return promise;
+      },
+    },
+  };
+
+  const clearPyodideData = async (userModuleNames) => {
+    postMessage({ method: "handleLoading" });
+    try {
+      await pyodide.runPythonAsync(`
+        # Clear all user-defined variables and modules
+        for name in list(globals()):
+          if not name.startswith('_') and not name=='basthon':
+            del globals()[name]
+
+        import sys
+        # Remove user modules from sys.modules
+        user_modules = ${JSON.stringify(userModuleNames)}
+        for name in user_modules:
+          if name in sys.modules:
+            del sys.modules[name]
+        `);
+    } catch (error) {
+      console.error("Error while clearing Pyodide data:", error);
+    }
+    console.log("clearPyodideData done");
+    postMessage({ method: "handleLoaded", stdinBuffer, interruptBuffer });
+  };
+
+  const initialisePyodide = async () => {
+    postMessage({ method: "handleLoading" });
+
+    pyodidePromise = loadPyodide({
+      stdout: (content) => {
+        if (userStdStreamsEnabled && !suppressInternalStdStreams) {
+          postMessage({ method: "handleOutput", stream: "stdout", content });
+        } else {
+          console.log(content);
+        }
+      },
+      stderr: (content) => {
+        if (userStdStreamsEnabled && !suppressInternalStdStreams) {
+          postMessage({ method: "handleOutput", stream: "stderr", content });
+        } else {
+          console.error(content);
+        }
+      },
+    });
+
+    pyodide = await pyodidePromise;
+
+    pyodide.registerJsModule("basthon", fakeBasthonPackage);
+
+    // When SharedArrayBuffer is unavailable, always use the postMessage-based
+    // stdin path. JSPI / run_sync will raise at runtime if the environment
+    // cannot stack-switch, but in JSPI-capable browsers this enables
+    // interactive input() without COOP/COEP.
+    useMessageStdin = !supportsAllFeatures;
+    pyodide.globals.set("__stdin_via_message__", useMessageStdin);
+
+    await pyodide.runPythonAsync(`
+    import builtins
+    from pyodide.ffi import run_sync as __run_sync__
+
+    __old_input__ = builtins.input
+    def __patched_input__(prompt=None):
+        if prompt is not None:
+            print(prompt)
+        if __stdin_via_message__:
+            result = __run_sync__(basthon.kernel.getInputAsync())
+            if result is None:
+                raise EOFError("EOF when reading a line")
+            return result
+        return __old_input__()
+    builtins.input = __patched_input__
+    `);
+
+    await pyodide.runPythonAsync(`
+    import builtins
+    # Save the original open function
+    _original_open = builtins.open
+    `);
+
+    await pyodide.loadPackage("pyodide-http");
+    await pyodide.runPythonAsync(`
+        import pyodide_http
+        pyodide_http.patch_all()
+      `);
+
+    if (supportsAllFeatures) {
+      stdinBuffer =
+        stdinBuffer || new Int32Array(new SharedArrayBuffer(1024 * 1024)); // 1 MiB
+      stdinBuffer[0] = 1; // Store the length of content in the buffer at index 0.
+      pyodide.setStdin({ isatty: true, read: readFromStdin });
+
+      interruptBuffer =
+        interruptBuffer || new Uint8Array(new SharedArrayBuffer(1));
+      pyodide.setInterruptBuffer(interruptBuffer);
+    }
+
+    // From this point on, anything written to stdout / stderr is considered
+    // user-visible and will be forwarded to the UI.
+    userStdStreamsEnabled = true;
+
+    postMessage({ method: "handleLoaded", stdinBuffer, interruptBuffer });
+  };
+
+  const readFromStdin = (bufferToWrite) => {
+    const previousLength = stdinBuffer[0];
+    postMessage({ method: "handleInput" });
+
+    while (true) {
+      pyodide.checkInterrupt();
+      const result = Atomics.wait(stdinBuffer, 0, previousLength, 100);
+      if (result === "not-equal") {
+        break;
+      }
+    }
+
+    const currentLength = stdinBuffer[0];
+    if (currentLength === -1) {
+      return 0;
+    } // Signals that stdin was closed.
+
+    const addedBytes = stdinBuffer.slice(previousLength, currentLength);
+    bufferToWrite.set(addedBytes);
+
+    return addedBytes.length;
+  };
+
+  const parsePythonError = (error) => {
+    const type = error.type;
+    const [trace, info] = error.message.split(`${type}:`).map((s) => s?.trim());
+
+    const lines = trace.split("\n");
+
+    // if the third from last line matches /File "__custom_open__\.py", line (\d+)/g then strip off the last three lines
+    if (
+      lines.length > 3 &&
+      /File "__custom_open__\.py", line (\d+)/g.test(lines[lines.length - 3])
+    ) {
+      lines.splice(-3, 3);
+    }
+
+    const snippetLine = lines[lines.length - 2]; //    print("hi")invalid
+    const caretLine = lines[lines.length - 1]; //                 ^^^^^^^
+
+    const showsMistake = caretLine.includes("^");
+    const mistake = showsMistake
+      ? [snippetLine.slice(4), caretLine.slice(4)].join("\n")
+      : "";
+
+    const matches = [
+      ...trace.matchAll(/File "(?!__custom_open__\.py)(.*)", line (\d+)/g),
+    ];
+    const match = matches[matches.length - 1];
+
+    const path = match ? match[1] : "";
+    const base = path.split("/").reverse()[0];
+    const file = base === "<exec>" ? "main.py" : base;
+
+    const line = match ? parseInt(match[2], 10) : "";
+
+    return { file, line, mistake, type, info };
+  };
+
+  // return {
+  //   postMessage,
+  //   onmessage,
+  // };
+};
+
+globalThis.PyodideWorker = PyodideWorker;
+PyodideWorker();
+// export default PyodideWorker;