gwchq-textjam 0.2.28 → 0.2.30

package/dist/assets/{PyodideWorkerdeabb0560f66f0f43f49.js → PyodideWorkerb1409749c37aedc47dc8.js}

@@ -88,7 +88,7 @@ const PyodideWorker = () => {
     assets.pyodideBaseUrl = `${packageApiUrl}/pyodide.js`;
     importScripts(toAbsoluteFromOrigin(assets.pyodideBaseUrl));
 
-    initialisePyodide();
+    initialisePyodide(data);
   };
 
   const supportsAllFeatures = typeof SharedArrayBuffer !== "undefined";
@@ -115,8 +115,24 @@ const PyodideWorker = () => {
     );
   }
   let pyodide, pyodidePromise, stdinBuffer, interruptBuffer, stopped;
+  let currentRunId = null;
+  let stdinStrategy = "sab";
+  let supportsJspi = false;
+  let stdinFallbackConfig = null;
+  const STDIN_CANCELLED_RESPONSE_CODE = 499;
+  const STDIN_TIMEOUT_RESPONSE_CODE = 408;
+  const STDIN_ABORTED_RESPONSE_CODE = 410;
+  const STDIN_ROUTE_NOT_FOUND_RESPONSE_CODE = 404;
+  // HTTP 204 No Content from the stdin Service Worker signals end-of-file —
+  // distinct from a cancellation/interrupt so input() raises EOFError and the
+  // user's `try/except EOFError` blocks keep working under the sync-XHR fallback.
+  const STDIN_EOF_RESPONSE_CODE = 204;
   /** When true, input() uses postMessage + run_sync(getInputAsync) instead of setStdin (requires JSPI). */
   let useMessageStdin = false;
+  /** When true, input() uses sync XHR via the Service Worker fallback. */
+  let useSyncXhrStdin = false;
+  /** True when current input request was cancelled from outside the worker. */
+  let stdinCancelled = 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.
@@ -167,6 +183,8 @@ const PyodideWorker = () => {
         break;
       }
       case "runPython":
+        currentRunId = data.runId || null;
+        stdinCancelled = false;
         runPython(data.python, data.userModuleNames);
         break;
       case "stopPython": {
@@ -179,6 +197,7 @@ const PyodideWorker = () => {
           pendingStdinResolve(null);
           pendingStdinResolve = null;
         }
+        stdinCancelled = true;
         break;
       }
       default: {
@@ -195,6 +214,19 @@ const PyodideWorker = () => {
   const runPython = async (python, userModuleNames) => {
     stopped = false;
 
+    if (stdinStrategy === "unavailable") {
+      postMessage({
+        method: "handleError",
+        file: "main.py",
+        line: "",
+        mistake: "",
+        type: "RuntimeError",
+        info: "Python input fallback is unavailable. Please enable and activate the stdin Service Worker, then reload the page.",
+      });
+      await clearPyodideData(userModuleNames);
+      return;
+    }
+
     // 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
@@ -206,8 +238,37 @@ const PyodideWorker = () => {
         await runUserCode();
       });
     } catch (error) {
+      const isStdinControlError =
+        error?.message === "PYODIDE_STDIN_CANCELLED" ||
+        error?.message === "PYODIDE_STDIN_TIMEOUT" ||
+        error?.message === "PYODIDE_STDIN_ABORTED";
+
+      if (stdinCancelled || isStdinControlError) {
+        postMessage({
+          method: "handleError",
+          file: "main.py",
+          line: "",
+          mistake: "",
+          type: "KeyboardInterrupt",
+          info: "Execution interrupted",
+        });
+        await clearPyodideData(userModuleNames);
+        return;
+      }
+
       if (!(error instanceof pyodide.ffi.PythonError)) {
-        throw error;
+        postMessage({
+          method: "handleError",
+          file: "main.py",
+          line: "",
+          mistake: "",
+          type: "RuntimeError",
+          info:
+            error?.message ||
+            "Python execution failed while reading stdin fallback input.",
+        });
+        await clearPyodideData(userModuleNames);
+        return;
       }
       const parsed = parsePythonError(error);
       // Stop resolves stdin with EOF so input() raises EOFError; show as interrupt, not error.
@@ -239,7 +300,14 @@ const PyodideWorker = () => {
     // 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();
+
+    // `find_imports` returns a PyProxy whose .toJs() copies the contents but
+    // leaves the underlying Python object alive. Destroy it explicitly so JS
+    // GC can't try to finalise it later from a context where the GIL isn't
+    // held (which would surface as a NoGilError).
+    const importsProxy = pyodide._api.pyodide_code.find_imports(python);
+    const imports = importsProxy.toJs();
+    importsProxy.destroy();
 
     await pyodide.runPythonAsync(`
       import builtins
@@ -247,6 +315,18 @@ const PyodideWorker = () => {
           builtins.open = builtins._original_open
     `);
 
+    // Load packages sequentially rather than in Promise.all. Each
+    // `loadDependency` does multiple `await` hops (vendored .before(),
+    // loadPackage, micropip.install, …). When several run concurrently their
+    // await points interleave and Pyodide ends up servicing multiple in-flight
+    // package loads — that interleaving is the trigger for the NoGilError seen
+    // when complex projects load matplotlib's dependency tree. Sequential
+    // loading costs a few ms on cold start but matches how `loadPackage`
+    // already serialises its own work internally.
+    // for (const name of imports) {
+    //   checkIfStopped();
+    //   await loadDependency(name);
+    // }
     await Promise.all(imports.map((name) => loadDependency(name)));
 
     checkIfStopped();
@@ -358,9 +438,13 @@ const PyodideWorker = () => {
     }
 
     // If the import is for a module built into Python then do nothing.
+    // The PyProxy is only used as a presence check, so destroy it immediately
+    // — leaking it leaves a Python ref for JS GC to finalise later, which
+    // raises NoGilError when GC runs outside a GIL-held context.
     try {
       const pythonModule = pyodide.pyimport(pkgName);
       if (pythonModule) {
+        pythonModule.destroy();
         return;
       }
     } catch (_) {}
@@ -372,6 +456,7 @@ const PyodideWorker = () => {
 
       const pyodidePackage = pyodide.pyimport(pkgName);
       if (pyodidePackage) {
+        pyodidePackage.destroy();
         return;
       }
     } catch (_) {}
@@ -451,6 +536,10 @@ const PyodideWorker = () => {
           pyodidePackage = pyodide.pyimport("matplotlib");
         } catch (_) {}
         if (pyodidePackage) {
+          // Destroy the throwaway proxy before running follow-up Python — the
+          // proxy is only used as a "did matplotlib actually load?" gate, and
+          // leaking it would hand a Python ref to JS GC.
+          pyodidePackage.destroy();
           pyodide.runPython(`
             import matplotlib.pyplot as plt
             import io
@@ -601,6 +690,62 @@ const PyodideWorker = () => {
     },
   };
 
+  const readInputViaSyncXhr = (runId) => {
+    const requestId = crypto.randomUUID();
+    const requestUrl = new URL(
+      stdinFallbackConfig.endpointPath,
+      // eslint-disable-next-line no-restricted-globals
+      self.location.origin,
+    );
+    requestUrl.searchParams.set("runId", runId || "");
+    requestUrl.searchParams.set("requestId", requestId);
+    requestUrl.searchParams.set("clientId", stdinFallbackConfig.clientId);
+
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", requestUrl.toString(), false);
+    xhr.setRequestHeader("X-Pyodide-Stdin-Request", "true");
+    xhr.setRequestHeader("Cache-Control", "no-store");
+
+    try {
+      xhr.send(null);
+    } catch (_) {
+      throw new Error("Failed to read Python input via stdin fallback");
+    }
+
+    if (xhr.status === STDIN_CANCELLED_RESPONSE_CODE) {
+      stdinCancelled = true;
+      throw new Error("PYODIDE_STDIN_CANCELLED");
+    }
+
+    if (xhr.status === STDIN_TIMEOUT_RESPONSE_CODE) {
+      throw new Error("PYODIDE_STDIN_TIMEOUT");
+    }
+
+    if (xhr.status === STDIN_ABORTED_RESPONSE_CODE) {
+      throw new Error("PYODIDE_STDIN_ABORTED");
+    }
+
+    // EOF: orchestrator signalled Ctrl+D / no more input. Returning null tells
+    // Pyodide's line-based stdin handler to raise EOFError at the input() call
+    // site, rather than escalating to a KeyboardInterrupt that tears down the run.
+    if (xhr.status === STDIN_EOF_RESPONSE_CODE) {
+      return null;
+    }
+
+    if (xhr.status !== 200) {
+      throw new Error(
+        `Python input request failed with status ${xhr.status}: ${xhr.responseText}`,
+      );
+    }
+
+    let content = xhr.responseText ?? "";
+    if (!content.endsWith("\n")) {
+      content += "\n";
+    }
+
+    return content;
+  };
+
   const clearPyodideData = async (userModuleNames) => {
     postMessage({ method: "handleLoading" });
     try {
@@ -627,10 +772,17 @@ const PyodideWorker = () => {
       console.error("Error while clearing Pyodide data:", error);
     }
     console.log("clearPyodideData done");
-    postMessage({ method: "handleLoaded", stdinBuffer, interruptBuffer });
+    postMessage({
+      method: "handleLoaded",
+      stdinBuffer,
+      interruptBuffer,
+      stdinStrategy,
+      supportsJspi,
+      stdinFallbackEnabled: Boolean(stdinFallbackConfig?.enabled),
+    });
   };
 
-  const initialisePyodide = async () => {
+  const initialisePyodide = async (data) => {
     postMessage({ method: "handleLoading" });
 
     pyodidePromise = loadPyodide({
@@ -656,11 +808,30 @@ const PyodideWorker = () => {
 
     pyodide.registerJsModule("basthon", fakeBasthonPackage);
 
+    supportsJspi =
+      typeof WebAssembly?.Suspending === "function" &&
+      typeof WebAssembly?.promising === "function";
+
+    stdinFallbackConfig = {
+      enabled: Boolean(data?.stdinFallback?.enabled),
+      endpointPath: data?.stdinFallback?.endpointPath || "/pyodide-stdin",
+      clientId: data?.stdinFallback?.clientId || "",
+    };
+
     // 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;
+    useMessageStdin = !supportsAllFeatures && supportsJspi;
+    useSyncXhrStdin =
+      !supportsAllFeatures && !supportsJspi && stdinFallbackConfig.enabled;
+    stdinStrategy = supportsAllFeatures
+      ? "sab"
+      : useMessageStdin
+      ? "jspi"
+      : useSyncXhrStdin
+      ? "sync-xhr"
+      : "unavailable";
     pyodide.globals.set("__stdin_via_message__", useMessageStdin);
 
     await pyodide.runPythonAsync(`
@@ -703,13 +874,25 @@ const PyodideWorker = () => {
       interruptBuffer =
         interruptBuffer || new Uint8Array(new SharedArrayBuffer(1));
       pyodide.setInterruptBuffer(interruptBuffer);
+    } else if (useSyncXhrStdin) {
+      pyodide.setStdin({
+        stdin: () => readInputViaSyncXhr(currentRunId),
+        isatty: true,
+      });
     }
 
     // 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 });
+    postMessage({
+      method: "handleLoaded",
+      stdinBuffer,
+      interruptBuffer,
+      stdinStrategy,
+      supportsJspi,
+      stdinFallbackEnabled: stdinFallbackConfig.enabled,
+    });
   };
 
   const readFromStdin = (bufferToWrite) => {

package/dist/assets/pyodide-stdin-sw.js

@@ -0,0 +1,231 @@
+/* eslint-disable no-restricted-globals */
+
+const DEBUG_STDIN_SW = false;
+const STDIN_ENDPOINT_PATH = "/pyodide-stdin";
+const DEFAULT_INPUT_TIMEOUT_MS = 120000;
+const CANCELLED_STATUS = 499;
+const TIMEOUT_STATUS = 408;
+const ABORTED_STATUS = 410;
+// HTTP 204 = clean EOF (Ctrl+D, persistent stdinClosed). Distinguished from
+// 499 cancel so the Pyodide worker can raise EOFError instead of KeyboardInterrupt.
+const EOF_STATUS = 204;
+
+/** @type {Map<string, { resolve: (response: Response) => void, timeoutId: number, runId: string, requestId: string, clientId: string }>} */
+const pendingRequests = new Map();
+/** @type {Map<string, string>} */
+const tabClientToWindowClient = new Map();
+
+const log = (...args) => {
+  if (!DEBUG_STDIN_SW) return;
+  console.log("[pyodide-stdin-sw]", ...args);
+};
+
+const pendingKey = (clientId, runId, requestId) =>
+  [clientId || "", runId || "", requestId || ""].join(":");
+
+const noStoreHeaders = {
+  "Content-Type": "text/plain; charset=utf-8",
+  "Cache-Control": "no-store",
+};
+
+const responseWith = (status, body) =>
+  new Response(body, {
+    status,
+    headers: noStoreHeaders,
+  });
+
+const finishPending = (key, status, body) => {
+  const pending = pendingRequests.get(key);
+  if (!pending) {
+    return false;
+  }
+
+  clearTimeout(pending.timeoutId);
+  pending.resolve(responseWith(status, body));
+  pendingRequests.delete(key);
+  return true;
+};
+
+const findPendingEntries = (clientId, runId, requestId) => {
+  const matches = [];
+  for (const [key, pending] of pendingRequests.entries()) {
+    if (clientId && pending.clientId !== clientId) continue;
+    if (runId && pending.runId !== runId) continue;
+    if (requestId && pending.requestId !== requestId) continue;
+    matches.push([key, pending]);
+  }
+  return matches;
+};
+
+self.addEventListener("install", (event) => {
+  log("install");
+  event.waitUntil(self.skipWaiting());
+});
+
+self.addEventListener("activate", (event) => {
+  log("activate");
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("fetch", (event) => {
+  const requestUrl = new URL(event.request.url);
+  if (
+    event.request.method !== "GET" ||
+    requestUrl.pathname !== STDIN_ENDPOINT_PATH
+  ) {
+    return;
+  }
+
+  event.respondWith(handleStdinFetch(event, requestUrl));
+});
+
+const handleStdinFetch = async (event, requestUrl) => {
+  const runId = requestUrl.searchParams.get("runId") || "";
+  const requestId = requestUrl.searchParams.get("requestId") || "";
+  const tabClientId = requestUrl.searchParams.get("clientId") || "";
+  const timeoutMsRaw = Number.parseInt(
+    requestUrl.searchParams.get("timeoutMs") || "",
+    10,
+  );
+  const timeoutMs =
+    Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0
+      ? timeoutMsRaw
+      : DEFAULT_INPUT_TIMEOUT_MS;
+
+  const fetchClientId = event.clientId || "";
+  const clientId = tabClientId || fetchClientId;
+
+  if (!runId || !requestId || !clientId) {
+    return responseWith(400, "Invalid stdin request identifiers");
+  }
+
+  const key = pendingKey(clientId, runId, requestId);
+  if (pendingRequests.has(key)) {
+    return responseWith(409, "Duplicate stdin request");
+  }
+
+  log("stdin request pending", { clientId, runId, requestId });
+
+  const responsePromise = new Promise((resolve) => {
+    const timeoutId = self.setTimeout(() => {
+      log("stdin request timeout", { clientId, runId, requestId });
+      finishPending(key, TIMEOUT_STATUS, "stdin request timed out");
+    }, timeoutMs);
+
+    pendingRequests.set(key, {
+      resolve,
+      timeoutId,
+      runId,
+      requestId,
+      clientId,
+    });
+  });
+
+  const registeredWindowClientId = tabClientToWindowClient.get(clientId) || "";
+  let targetClient = null;
+
+  if (registeredWindowClientId) {
+    targetClient = await self.clients.get(registeredWindowClientId);
+  }
+
+  if (!targetClient && fetchClientId) {
+    const fetchClient = await self.clients.get(fetchClientId);
+    if (fetchClient?.type === "window") {
+      targetClient = fetchClient;
+    }
+  }
+
+  const message = {
+    type: "PYODIDE_STDIN_REQUEST",
+    clientId,
+    runId,
+    requestId,
+  };
+
+  if (targetClient) {
+    targetClient.postMessage(message);
+    return responsePromise;
+  }
+
+  const matchedClients = await self.clients.matchAll({
+    includeUncontrolled: true,
+  });
+  const windowClients = matchedClients.filter(
+    (client) => client.type === "window",
+  );
+  if (!windowClients.length) {
+    finishPending(key, ABORTED_STATUS, "stdin client unavailable");
+    return responseWith(ABORTED_STATUS, "stdin client unavailable");
+  }
+
+  for (const client of windowClients) {
+    client.postMessage(message);
+  }
+
+  return responsePromise;
+};
+
+self.addEventListener("message", (event) => {
+  const data = event.data;
+  if (!data || typeof data !== "object") {
+    return;
+  }
+
+  const eventClientId =
+    event.source && "id" in event.source ? event.source.id : "";
+  const clientId = data.clientId || eventClientId || "";
+
+  if (data.type === "PYODIDE_STDIN_REGISTER") {
+    if (data.clientId && eventClientId) {
+      tabClientToWindowClient.set(String(data.clientId), String(eventClientId));
+      log("registered stdin tab client", {
+        clientId: String(data.clientId),
+        windowClientId: String(eventClientId),
+      });
+    }
+    return;
+  }
+
+  if (data.type === "PYODIDE_STDIN_RESPONSE") {
+    const key = pendingKey(clientId, data.runId, data.requestId);
+    const submitted = finishPending(key, 200, String(data.value ?? ""));
+    if (!submitted) {
+      log("stdin response for unknown request", {
+        clientId,
+        runId: data.runId,
+        requestId: data.requestId,
+      });
+    }
+    return;
+  }
+
+  if (data.type === "PYODIDE_STDIN_EOF") {
+    // EOF is targeted at a specific (runId, requestId) just like a normal response.
+    // The worker maps HTTP 204 → null, which Pyodide's line-based stdin treats as EOF.
+    const key = pendingKey(clientId, data.runId, data.requestId);
+    const submitted = finishPending(key, EOF_STATUS, "");
+    if (!submitted) {
+      log("stdin EOF for unknown request", {
+        clientId,
+        runId: data.runId,
+        requestId: data.requestId,
+      });
+    }
+    return;
+  }
+
+  if (data.type === "PYODIDE_STDIN_CANCEL") {
+    const matches = findPendingEntries(clientId, data.runId, data.requestId);
+    for (const [key] of matches) {
+      finishPending(key, CANCELLED_STATUS, "stdin request cancelled");
+    }
+
+    if (!matches.length) {
+      log("stdin cancel for unknown request", {
+        clientId,
+        runId: data.runId,
+        requestId: data.requestId,
+      });
+    }
+  }
+});