pll-python 0.4.0 → 0.5.0

package/cli.cjs

@@ -30,7 +30,7 @@ var path8 = __toESM(require("node:path"));
 // src/cli/args.ts
 var import_node_util = require("node:util");
 
-// src/common/errorText.ts
+// src/core/errorText.ts
 function errorText(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -101,7 +101,7 @@ var path4 = __toESM(require("node:path"));
 var fs3 = __toESM(require("node:fs/promises"));
 var path3 = __toESM(require("node:path"));
 
-// src/common/editDistance.ts
+// src/core/editDistance.ts
 function editDistance(a, b) {
   let twoBack = [];
   let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
@@ -123,7 +123,7 @@ function editDistance(a, b) {
   return previous[b.length];
 }
 
-// src/common/level.ts
+// src/core/level.ts
 var LEVEL_RAW = "raw";
 var LEVEL_BEGINNER = "beginner";
 var LEVEL_INTERMEDIATE = "intermediate";
@@ -273,38 +273,11 @@ function closestLevel(named) {
   }
   return best !== null && bestDistance <= Math.max(2, Math.floor(best.length / 3)) ? best : null;
 }
-function levelRejectsBoolAsNumber(level) {
-  return level === LEVEL_BEGINNER || level === LEVEL_INTERMEDIATE;
-}
-function levelRefusesReassignment(level, scope) {
-  return level === LEVEL_BEGINNER || level === LEVEL_INTERMEDIATE && scope === "module";
-}
 function levelHasStaticChecks(level) {
   return level === LEVEL_BEGINNER || level === LEVEL_INTERMEDIATE;
 }
 
-// src/common/analyzers/levelHeaderFinding.ts
-function levelHeaderFinding(source, fileName, level) {
-  const problem = levelHeaderProblem(source);
-  if (problem === null) {
-    return null;
-  }
-  return {
-    id: "level-header",
-    errorType: "Level",
-    headline: problem.message,
-    howToFix: problem.howToFix,
-    fileName,
-    lineNumber: problem.line,
-    column: null,
-    nameToken: null,
-    severity: "error",
-    origin: "static",
-    level
-  };
-}
-
-// src/common/analyzers/findingLocation.ts
+// src/run/finding.ts
 function serializeFinding(finding) {
   return {
     errorType: finding.errorType,
@@ -329,2687 +302,498 @@ function findingLocation(finding) {
     label
   };
 }
-
-// src/common/pythonFiles.ts
-var PLL_LIBRARY_FILES = {
-  image: "<pll:image>",
-  table: "<pll:table>",
-  reactor: "<pll:reactor>",
-  examplar: "<pll:examplar>",
-  matplotlib: "<pll:matplotlib>"
-};
-
-// src/common/errors/libraryFacts.ts
-var FUNCTION_TAKERS = {
-  filter: {
-    calls: "`filter` calls your function with one row at a time",
-    each: "each row",
-    param: "r: dict",
-    keeps: "keeps the rows where it returns `True`"
-  },
-  transform_column: {
-    calls: "`transform_column` calls your function with one *value* from the column, not a row",
-    each: "each value in the column",
-    param: "v",
-    keeps: "puts what it returns in place of the value"
-  },
-  add_column: {
-    calls: "`add_column` calls your function with one row at a time",
-    each: "each row",
-    param: "r: dict",
-    keeps: "puts what it returns in the new column"
-  },
-  animate: { calls: "`animate` calls your function with the tick count, a number" },
-  big_bang: { calls: "`big_bang` calls your handlers with the state" }
-};
-var FUNCTION_TAKER_NAMES = Object.keys(FUNCTION_TAKERS);
-function libraryCaller(frames) {
-  for (const { fileName, functionName } of frames) {
-    if (fileName === PLL_LIBRARY_FILES.reactor) {
-      return "reactor";
-    }
-    const inLibrary = fileName === PLL_LIBRARY_FILES.table || fileName === PLL_LIBRARY_FILES.image;
-    if (inLibrary && functionName !== null && FUNCTION_TAKER_NAMES.includes(functionName)) {
-      return functionName;
-    }
-  }
-  return null;
-}
-var HANDLER_KEYWORDS = ["to_draw", "on_tick", "stop_when", "on_key", "on_mouse", "on_receive"];
-var LIBRARY_HINTS = {
-  table: [
-    'The column names come first, as a list of strings, then all the rows inside one more list: `table(["month", "riders"], [["Jan", 1], ["Feb", 2]])`.'
-  ],
-  table_from_columns: [
-    '`table_from_columns` takes one dictionary: `table_from_columns({"month": [...], "riders": [...]})`.'
-  ]
-};
-function libraryHint(name) {
-  return Object.prototype.hasOwnProperty.call(LIBRARY_HINTS, name) ? LIBRARY_HINTS[name] : [];
-}
-var TABLE_METHODS = [
-  "columns",
-  "length",
-  "column",
-  "row",
-  "rows",
-  "filter",
-  "transform_column",
-  "add_column",
-  "add_row",
-  "select_columns",
-  "order_by",
-  "head",
-  "tail",
-  "sum",
-  "mean",
-  "min",
-  "max",
-  "count",
-  "bar_chart",
-  "scatter_chart",
-  "scatter_plot",
-  "line_chart",
-  "histogram",
-  "labeled_scatter_plot",
-  "pie_chart",
-  "dot_plot",
-  "labeled_dot_plot",
-  "freq_bar_chart",
-  "box_plot",
-  "lr_plot",
-  "labeled_lr_plot",
-  "linear_regression",
-  "to_pandas"
-];
-
-// src/common/errors/nameErrorExplainer.ts
-var IMPORT_FOR = {
-  dataclass: "from dataclasses import dataclass",
-  field: "from dataclasses import field",
-  pd: "import pandas as pd",
-  pandas: "import pandas",
-  np: "import numpy as np",
-  numpy: "import numpy",
-  math: "import math",
-  pytest: "import pytest",
-  statistics: "import statistics",
-  random: "import random",
-  Callable: "from typing import Callable",
-  Optional: "from typing import Optional",
-  Any: "from typing import Any",
-  datetime: "import datetime",
-  json: "import json",
-  csv: "import csv",
-  re: "import re"
-};
-function definedLaterAt(source, name, usedOn) {
-  if (source === void 0 || usedOn === null) {
-    return null;
+function formatFriendlyError(finding) {
+  const lines = [];
+  lines.push(`${finding.errorType}: ${finding.headline}`);
+  const location = findingLocation(finding);
+  if (location) {
+    lines.push(`  at ${location.label}`);
   }
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const defined = new RegExp(
-    `^[ \\t]*(?:def[ \\t]+${escaped}[ \\t]*\\(|class[ \\t]+${escaped}\\b|${escaped}[ \\t]*(?::[^=]+)?=[^=])`
-  );
-  const lines = source.split(/\r?\n/);
-  for (let i = usedOn; i < lines.length; i++) {
-    if (defined.test(lines[i])) {
-      return i + 1;
+  if (finding.howToFix.length > 0) {
+    lines.push("");
+    lines.push("How to fix:");
+    for (const item of finding.howToFix) {
+      lines.push(`  - ${item}`);
     }
   }
-  return null;
+  return lines;
 }
-function annotationTarget(line, name) {
-  if (line === null) {
+function levelHeaderFinding(source, fileName, level) {
+  const problem = levelHeaderProblem(source);
+  if (problem === null) {
     return null;
   }
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const named = new RegExp(`^\\s*([A-Za-z_]\\w*)\\s*:\\s*${escaped}\\b`).exec(line) ?? new RegExp(`[(,]\\s*([A-Za-z_]\\w*)\\s*:\\s*${escaped}\\b`).exec(line);
-  if (named !== null) {
-    return named[1];
-  }
-  return new RegExp(`->\\s*${escaped}\\b`).test(line) ? "" : null;
+  return {
+    id: "level-header",
+    errorType: "Level",
+    headline: problem.message,
+    howToFix: problem.howToFix,
+    fileName,
+    lineNumber: problem.line,
+    column: null,
+    nameToken: null,
+    severity: "error",
+    origin: "static",
+    level
+  };
 }
-function passedResultNotFunction(line, name) {
-  if (line === null) {
-    return null;
-  }
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  for (const taker of FUNCTION_TAKER_NAMES) {
-    const pattern = new RegExp(
-      `\\b${taker}\\s*\\(\\s*([A-Za-z_]\\w*)\\s*\\(\\s*${escaped}\\s*\\)`
-    );
-    const match = pattern.exec(line);
-    if (match !== null) {
-      return `${taker}:${match[1]}`;
-    }
-  }
-  return null;
+function findRuntimeFinding(fileName, level, error) {
+  return { ...error.finding, fileName: error.finding.fileName ?? fileName, level };
 }
-function hyphenated(line, name) {
-  if (line === null) {
-    return null;
-  }
-  for (const found of line.matchAll(/(?<![.\w])([A-Za-z_]\w*(?:-[A-Za-z_]\w*)+)(?=\s*\()/g)) {
-    if (found[1].split("-").includes(name)) {
-      return found[1];
+function explainTestReport(event, fileName, level) {
+  return {
+    ...event,
+    tests: event.tests.map(
+      ({ error, ...test }) => error ? { ...test, finding: serializeFinding(findRuntimeFinding(fileName, level, error)) } : test
+    )
+  };
+}
+
+// src/run/examplarSource.ts
+var MAX_BUNDLE_BYTES = 4 * 1024 * 1024;
+var DIRECTIVE_RE = /^#\s*examplar\s+(\S+)\s*$/;
+function parseExamplarDirective(source) {
+  const hits = [];
+  const lines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const match = DIRECTIVE_RE.exec(lines[i].trim());
+    if (match) {
+      hits.push({ url: match[1], line: i + 1 });
     }
   }
-  return null;
-}
-function methodCalledAsFunction(line, name) {
-  if (line === null || !TABLE_METHODS.includes(name)) {
-    return null;
+  if (hits.length === 0) {
+    return { kind: "none" };
   }
-  const found = new RegExp(`\\b${name}\\s*\\(\\s*([A-Za-z_][\\w.]*)\\s*(?:,\\s*([^)]*))?\\)`).exec(line);
-  return found ? { table: found[1], rest: (found[2] ?? "").trim() } : null;
-}
-function unboundKind(message) {
-  const m = message.match(/cannot access (free|local) variable '/);
-  return m ? m[1] : null;
-}
-function explainNameError(parsed, context = {}) {
-  const named = parsed.nameToken !== null;
-  const name = parsed.nameToken ?? "this name";
-  const didYouMean = extractDidYouMean(parsed.message);
-  const unbound = unboundKind(parsed.message);
-  if (unbound !== null) {
+  if (hits.length > 1) {
     return {
-      headline: `\`${name}\` has not been given a value yet on this line.`,
-      howToFix: [
-        `Move the line that sets \`${name}\` above this one.`,
-        unbound === "local" ? `If you meant a \`${name}\` from outside this function: assigning to it anywhere inside makes it local to the whole function, so the outer one is not visible here. Pass it in as a parameter instead.` : `The \`${name}\` here belongs to the function around this one, which sets it after this line runs.`
-      ]
+      kind: "error",
+      line: hits[1].line,
+      message: `there is more than one \`#examplar\` line (lines ${hits.map((h) => h.line).join(" and ")}). Keep the one you want.`
     };
   }
-  const passed = named ? passedResultNotFunction(context.line ?? null, name) : null;
-  if (passed !== null) {
-    const [taker, fn] = passed.split(":");
-    return {
-      headline: `\`${taker}\` calls \`${fn}\` for you, so \`${name}\` is not something you write here.`,
-      howToFix: [
-        `Pass the function itself: \`${taker}(${fn})\`.`,
-        `\`${taker}\` supplies the argument for each row, so \`${fn}\` is never called by hand.`
-      ]
-    };
+  const { url, line } = hits[0];
+  const problem = validateBundleUrl(url);
+  return problem ? { kind: "error", message: problem, line } : { kind: "found", url, line };
+}
+function validateBundleUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return `\`${url}\` is not a URL.`;
   }
-  const hyphen = named ? hyphenated(context.line ?? null, name) : null;
-  if (hyphen !== null) {
-    return {
-      headline: `Python reads \`${hyphen}\` as \`${hyphen.split("-").join("` minus `")}\`: a name cannot have a \`-\` in it.`,
-      howToFix: [`Write \`${hyphen.replace(/-/g, "_")}\`, with an underscore.`]
-    };
+  if (parsed.protocol === "https:") {
+    return null;
   }
-  const method = named ? methodCalledAsFunction(context.line ?? null, name) : null;
-  if (method !== null) {
-    return {
-      headline: `\`${name}\` is a method of a table, so it is called on one.`,
-      howToFix: [`Write \`${method.table}.${name}(${method.rest})\`.`]
-    };
+  if (parsed.protocol === "http:") {
+    const local = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+    return local ? null : `\`${url}\` must use https (plain http is only allowed for localhost).`;
   }
-  const importLine = named ? IMPORT_FOR[name] : void 0;
-  if (importLine !== void 0) {
-    return {
-      headline: `\`${name}\` comes from an import, and this file has not imported it.`,
-      howToFix: [`Add \`${importLine}\` at the top of the file.`]
-    };
+  return `\`${url}\` must be an https address.`;
+}
+async function loadBundle(url, store, fetchImpl = globalThis.fetch) {
+  const cached = await store.read(url).catch(() => void 0);
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      headers: cached?.etag ? { "If-None-Match": cached.etag } : {}
+    });
+  } catch (err) {
+    const why = errorText(err);
+    return cached ? { json: cached.json, fromCache: true, note: `could not reach ${url} (${why}); using the cached copy` } : { fromCache: false, error: `could not reach ${url} (${why}), and nothing is cached` };
   }
-  const laterOn = named ? definedLaterAt(context.source, name, parsed.lineNumber) : null;
-  if (laterOn !== null) {
-    const annotated = annotationTarget(context.line ?? null, name);
-    if (annotated !== null) {
-      const example = annotated ? `${annotated}: "${name}"` : `-> "${name}"`;
-      return {
-        headline: `\`${name}\` is defined on line ${laterOn}, after this line, and an annotation is read as the file runs.`,
-        howToFix: [
-          `Write the type as a string - \`${example}\` - and Python looks it up later, once it exists.`,
-          "A type that names itself can only be written that way: the union needs the class, and the class needs the union."
-        ]
-      };
-    }
-    return {
-      headline: `\`${name}\` is defined on line ${laterOn}, after this line.`,
-      howToFix: [
-        "Python runs a file from the top, so nothing further down exists yet.",
-        `Move the definition of \`${name}\` above this line.`
-      ]
-    };
+  if (response.status === 304 && cached) {
+    return { json: cached.json, fromCache: true };
   }
-  const headline = `Python doesn't know what \`${name}\` means.`;
-  if (didYouMean.length === 1) {
-    const [meant] = didYouMean;
-    return {
-      headline,
-      howToFix: [
-        meant.toLowerCase() === name.toLowerCase() ? `Did you mean \`${meant}\`? Python names are case-sensitive, so \`${name}\` and \`${meant}\` are different names.` : `Did you mean \`${meant}\`?`
-      ]
+  if (!response.ok) {
+    return cached ? {
+      json: cached.json,
+      fromCache: true,
+      note: `${url} returned ${response.status}; using the cached copy`
+    } : { fromCache: false, error: `${url} returned ${response.status}` };
+  }
+  const json = await response.text();
+  if (json.length > MAX_BUNDLE_BYTES) {
+    return cached ? { json: cached.json, fromCache: true, note: `${url} is unexpectedly large; using the cached copy` } : {
+      fromCache: false,
+      error: `${url} is ${json.length} bytes, past the ${MAX_BUNDLE_BYTES}-byte limit`
     };
   }
-  const howToFix = [
-    `Check the spelling of \`${name}\` (Python is case-sensitive).`,
-    `Make sure \`${name}\` is defined before this line runs.`
-  ];
-  if (named) {
-    howToFix.push(`If \`${name}\` should be text, put it in quotes: \`"${name}"\`.`);
+  if (!looksLikeBundle(json)) {
+    return cached ? { json: cached.json, fromCache: true, note: `${url} did not return a bundle; using the cached copy` } : { fromCache: false, error: `${url} did not return an Examplar bundle` };
   }
-  if (didYouMean.length > 1) {
-    howToFix.unshift(
-      `Did you mean one of ${didYouMean.map((s) => "`" + s + "`").join(", ")}?`
-    );
+  const etag = response.headers.get("etag") ?? void 0;
+  try {
+    await store.write(url, { json, etag });
+  } catch (err) {
+    return { json, fromCache: false, note: `could not keep a copy for offline use (${errorText(err)})` };
   }
-  return { headline, howToFix };
+  return { json, fromCache: false };
 }
-function extractDidYouMean(message) {
-  const m = message.match(/Did you mean:\s*([^?]+)\??/i);
-  if (!m) {
-    return [];
+function looksLikeBundle(json) {
+  try {
+    const bundle = JSON.parse(json);
+    return typeof bundle === "object" && bundle !== null && "examplar" in bundle && Array.isArray(bundle.wheats) && Array.isArray(bundle.chaffs);
+  } catch {
+    return false;
   }
-  return m[1].split(/,|\bor\b/).map((s) => s.trim().replace(/^['"`]|['"`]$/g, "")).filter((s) => s.length > 0);
-}
-
-// src/common/errors/pythonError.ts
-function userFrames(error) {
-  return error.frames.filter((frame) => frame.user);
-}
-function innermostUserFrame(error) {
-  const frames = userFrames(error);
-  return frames.length > 0 ? frames[frames.length - 1] : null;
 }
 
-// src/common/errors/sourceFacts.ts
-function sourceLine(source, line) {
-  if (line === null) {
+// src/pyodide/sharedMemory.ts
+var STDIN_SAB_BYTES = 64 * 1024;
+var STDIN_STATE_INDEX = 0;
+var STDIN_LENGTH_INDEX = 1;
+var STDIN_REQUEST_INDEX = 2;
+var STDIN_PAYLOAD_OFFSET = 16;
+var STDIN_STATE_WAITING = 0;
+var STDIN_STATE_DATA = 1;
+var STDIN_STATE_EOF = 2;
+var STDIN_STATE_INTERRUPTED = 3;
+function tryCreateStdinBuffer() {
+  try {
+    return new SharedArrayBuffer(STDIN_SAB_BYTES);
+  } catch {
     return null;
   }
-  const lines = source.split(/\r?\n/);
-  return line >= 1 && line <= lines.length ? lines[line - 1] : null;
 }
-var WRAPPERS = /* @__PURE__ */ new Set([
-  "print",
-  "str",
-  "int",
-  "float",
-  "bool",
-  "len",
-  "list",
-  "sorted",
-  "round",
-  "abs",
-  "sum",
-  "min",
-  "max",
-  "type",
-  "repr"
-]);
-function callOn(line) {
-  const names = Array.from(
-    (line ?? "").matchAll(/([A-Za-z_][\w.]*)\s*\(/g),
-    (m) => m[1]
-  );
-  if (names.length === 0) {
-    return null;
+function writeStdin(sab, request, bytes) {
+  const state = new Int32Array(sab);
+  if (Atomics.load(state, STDIN_REQUEST_INDEX) !== request || Atomics.load(state, STDIN_STATE_INDEX) !== STDIN_STATE_WAITING) {
+    return -1;
   }
-  return names.find((name) => !WRAPPERS.has(name)) ?? names[0];
-}
-function tokenize(line) {
-  const tokens = [];
-  let i = 0;
-  while (i < line.length) {
-    const c = line[i];
-    if (c === "#") break;
-    if (/\s/.test(c)) {
-      i++;
-      continue;
-    }
-    const start = i;
-    if (c === '"' || c === "'") {
-      i++;
-      while (i < line.length && line[i] !== c) i += line[i] === "\\" ? 2 : 1;
-      i = Math.min(i + 1, line.length);
-      tokens.push({ kind: "str", text: line.slice(start, i), start, end: i });
-    } else if (/[A-Za-z_]/.test(c)) {
-      while (i < line.length && /\w/.test(line[i])) i++;
-      tokens.push({ kind: "name", text: line.slice(start, i), start, end: i });
-    } else if (/\d/.test(c)) {
-      while (i < line.length && /[\d.]/.test(line[i])) i++;
-      tokens.push({ kind: "num", text: line.slice(start, i), start, end: i });
-    } else if ("([{".includes(c)) {
-      i++;
-      tokens.push({ kind: "open", text: c, start, end: i });
-    } else if (")]}".includes(c)) {
-      i++;
-      tokens.push({ kind: "close", text: c, start, end: i });
-    } else {
-      const two = line.slice(i, i + 2);
-      const op = ["<=", ">=", "==", "!=", "**", "//"].includes(two) ? two : c;
-      i += op.length;
-      tokens.push({ kind: "op", text: op, start, end: i });
-    }
+  let n = 0;
+  if (bytes !== null) {
+    n = Math.min(bytes.length, sab.byteLength - STDIN_PAYLOAD_OFFSET);
+    new Uint8Array(sab, STDIN_PAYLOAD_OFFSET).set(bytes.subarray(0, n));
+    Atomics.store(state, STDIN_LENGTH_INDEX, n);
   }
-  return tokens;
-}
-function closing(tokens, open) {
-  let depth = 0;
-  for (let i = open; i < tokens.length; i++) {
-    if (tokens[i].kind === "open") depth++;
-    if (tokens[i].kind === "close" && --depth === 0) return i;
+  const answer = bytes === null ? STDIN_STATE_EOF : STDIN_STATE_DATA;
+  const was = Atomics.compareExchange(state, STDIN_STATE_INDEX, STDIN_STATE_WAITING, answer);
+  if (was !== STDIN_STATE_WAITING) {
+    return -1;
   }
-  return -1;
+  Atomics.notify(state, STDIN_STATE_INDEX);
+  return n;
 }
-function operandFrom(line, tokens, at) {
-  if (at >= tokens.length || tokens[at].kind !== "name" && tokens[at].kind !== "num") {
-    return null;
-  }
-  let last = at;
-  for (let i = at + 1; i < tokens.length; ) {
-    if (tokens[i].text === "." && tokens[i + 1]?.kind === "name") {
-      last = i + 1;
-      i += 2;
-    } else if (tokens[i].kind === "open" && tokens[i].text !== "{") {
-      const shut = closing(tokens, i);
-      if (shut < 0) return null;
-      last = shut;
-      i = shut + 1;
-    } else {
-      break;
-    }
+function interruptStdin(sab) {
+  const state = new Int32Array(sab);
+  if (Atomics.compareExchange(state, STDIN_STATE_INDEX, STDIN_STATE_WAITING, STDIN_STATE_INTERRUPTED) === STDIN_STATE_WAITING) {
+    Atomics.notify(state, STDIN_STATE_INDEX);
   }
-  return line.slice(tokens[at].start, tokens[last].end);
 }
-function operandBefore(line, tokens, at) {
-  let first = at;
-  let i = at;
-  while (i >= 0) {
-    if (tokens[i].kind === "close") {
-      let depth = 0;
-      let j = i;
-      for (; j >= 0; j--) {
-        if (tokens[j].kind === "close") depth++;
-        if (tokens[j].kind === "open" && --depth === 0) break;
-      }
-      if (j < 0) return null;
-      first = j;
-      i = j - 1;
-      continue;
-    }
-    if (tokens[i].kind === "name" || tokens[i].kind === "num") {
-      first = i;
-      if (tokens[i - 1]?.text === "." && tokens[i - 2]?.kind === "name") {
-        i -= 2;
-        continue;
-      }
-      break;
-    }
-    if (i === at) return null;
-    break;
+var INTERRUPT_SAB_BYTES = 2;
+var INTERRUPT_SIGINT = 2;
+var INTERRUPT_ACK_INDEX = 1;
+var INTERRUPT_RETRY_MS = 15;
+var INTERRUPT_RETRY_LIMIT_MS = 1e4;
+function tryCreateInterruptBuffer() {
+  try {
+    return new SharedArrayBuffer(INTERRUPT_SAB_BYTES);
+  } catch {
+    return null;
   }
-  if (tokens[first].kind !== "name" && tokens[first].kind !== "num") return null;
-  return line.slice(tokens[first].start, tokens[at].end);
 }
-function concatOperands(line) {
-  const tokens = tokenize(line);
-  for (let i = 0; i < tokens.length; i++) {
-    if (tokens[i].kind !== "str") continue;
-    if (tokens[i + 1]?.text === "+") {
-      const value = operandFrom(line, tokens, i + 2);
-      if (value !== null) return { text: tokens[i].text, value, textFirst: true };
-    }
-    if (tokens[i - 1]?.text === "+" && i >= 2) {
-      const value = operandBefore(line, tokens, i - 2);
-      if (value !== null) return { text: tokens[i].text, value, textFirst: false };
-    }
+function requestInterrupt(sab, stillRunning, retryMs = INTERRUPT_RETRY_MS, limitMs = INTERRUPT_RETRY_LIMIT_MS) {
+  const view = new Uint8Array(sab);
+  if (view.length > INTERRUPT_ACK_INDEX) {
+    Atomics.store(view, INTERRUPT_ACK_INDEX, 0);
   }
-  return null;
-}
-function attributeReceiver(line, attr) {
-  if (line === null) return null;
-  const tokens = tokenize(line);
-  for (let i = 2; i < tokens.length; i++) {
-    if (tokens[i].text === attr && tokens[i - 1].text === ".") {
-      return operandBefore(line, tokens, i - 2);
-    }
+  Atomics.store(view, 0, INTERRUPT_SIGINT);
+  if (view.length <= INTERRUPT_ACK_INDEX) {
+    return;
   }
-  return null;
-}
-function subscriptReceiver(line) {
-  if (line === null) return null;
-  const tokens = tokenize(line);
-  for (let i = 1; i < tokens.length; i++) {
-    const before = tokens[i - 1];
-    if (tokens[i].text === "[" && (before.kind === "name" || before.text === ")" || before.text === "]")) {
-      return operandBefore(line, tokens, i - 1);
-    }
-  }
-  return null;
-}
-function loopedOver(line) {
-  if (line === null) return null;
-  const tokens = tokenize(line);
-  const at = tokens.findIndex((t) => t.text === "in" && tokens[0]?.text === "for");
-  return at < 0 ? null : operandFrom(line, tokens, at + 1);
-}
-function operandBeside(line, operator, side) {
-  if (line === null) return null;
-  const tokens = tokenize(line);
-  const at = tokens.findIndex((t) => t.kind === "op" && t.text === operator);
-  if (at < 0) return null;
-  return side === "left" ? operandBefore(line, tokens, at - 1) : operandFrom(line, tokens, at + 1);
-}
-function listNames(names) {
-  const quoted = names.map((name) => `\`${name}\``);
-  if (quoted.length <= 1) {
-    return quoted.join("");
-  }
-  return `${quoted.slice(0, -1).join(", ")} and ${quoted[quoted.length - 1]}`;
-}
-function closestName(name, candidates) {
-  let best = null;
-  let bestDistance = Infinity;
-  for (const candidate of candidates) {
-    const distance = editDistance(name.toLowerCase(), candidate.toLowerCase());
-    if (distance < bestDistance) {
-      best = candidate;
-      bestDistance = distance;
-    }
-  }
-  if (best === null) {
-    return null;
-  }
-  return bestDistance <= Math.max(1, Math.floor(best.length / 3)) ? best : null;
-}
-function tableRowLine(source, callLine, index) {
-  const lines = source.split(/\r?\n/);
-  if (callLine < 1 || callLine > lines.length) {
-    return null;
-  }
-  const call = /\b(?:table|Table)\s*\(/.exec(lines[callLine - 1]);
-  if (call === null) {
-    return null;
-  }
-  let offset = 0;
-  for (let i2 = 0; i2 < callLine - 1; i2++) {
-    offset += lines[i2].length + 1;
-  }
-  const text = lines.join("\n");
-  let i = offset + call.index + call[0].length;
-  let depth = 1;
-  let argument = 0;
-  let row = -1;
-  let rowsOpen = false;
-  let awaitingRow = false;
-  const lineAt = (at) => text.slice(0, at).split("\n").length;
-  while (i < text.length && depth > 0) {
-    const c = text[i];
-    if (c === '"' || c === "'") {
-      const quote = text.startsWith(c.repeat(3), i) ? c.repeat(3) : c;
-      i += quote.length;
-      while (i < text.length && !text.startsWith(quote, i)) {
-        i += text[i] === "\\" ? 2 : 1;
-      }
-      i += quote.length;
-      continue;
-    }
-    if (c === "#") {
-      while (i < text.length && text[i] !== "\n") i++;
-      continue;
-    }
-    if (/\s/.test(c)) {
-      i++;
-      continue;
-    }
-    if (awaitingRow && c !== "]") {
-      row++;
-      if (row === index) {
-        return lineAt(i);
-      }
-      awaitingRow = false;
+  const deadline = Date.now() + limitMs;
+  const retry = () => {
+    if (Atomics.load(view, INTERRUPT_ACK_INDEX) !== 0 || !stillRunning() || Date.now() > deadline) {
+      return;
     }
-    if (c === "(" || c === "[" || c === "{") {
-      depth++;
-      if (depth === 2 && argument === 1 && c === "[" && !rowsOpen) {
-        rowsOpen = true;
-        awaitingRow = true;
-      }
-    } else if (c === ")" || c === "]" || c === "}") {
-      depth--;
-      if (rowsOpen && depth === 1) {
-        return null;
-      }
-    } else if (c === ",") {
-      if (depth === 1) {
-        argument++;
-        if (argument > 1) return null;
-      } else if (depth === 2 && rowsOpen) {
-        awaitingRow = true;
-      }
-    } else if (depth === 1 && argument === 1 && !rowsOpen) {
-      return null;
+    if (Atomics.load(view, 0) === 0) {
+      Atomics.store(view, 0, INTERRUPT_SIGINT);
     }
-    i++;
-  }
-  return null;
-}
-
-// src/common/analyzers/errorPlace.ts
-var PLACED_BY_PYTHON = ["SyntaxError", "IndentationError", "TabError"];
-function placeOf(input) {
-  const { error, fileName } = input;
-  if (PLACED_BY_PYTHON.includes(error.errorType) || error.frames.length === 0) {
-    const file = error.fileName ?? fileName;
-    return {
-      fileName: file,
-      lineNumber: error.lineNumber,
-      column: error.column,
-      text: error.text ?? lineOfRun(input, file, error.lineNumber)
-    };
-  }
-  const frame = innermostUserFrame(error);
-  if (frame === null) {
-    return { fileName, lineNumber: null, column: null, text: null };
-  }
-  return {
-    fileName: frame.fileName,
-    lineNumber: frame.line,
-    // A caret is about the frame that raised; only there is it theirs.
-    column: frame === error.frames[error.frames.length - 1] ? frame.column : null,
-    text: frameText(input, frame)
-  };
-}
-function frameText(input, frame) {
-  if (frame === null) return null;
-  return frame.text ?? lineOfRun(input, frame.fileName, frame.line);
-}
-function inRunFile(input, place) {
-  return place.fileName === input.fileName;
-}
-function lineOfRun(input, file, line) {
-  return file === input.fileName ? sourceLine(input.source, line) : null;
-}
-
-// src/common/analyzers/types.ts
-function runtimeFindingFor(input, fields) {
-  const { error, level } = input;
-  const place = placeOf(input);
-  return {
-    errorType: error.errorType,
-    fileName: place.fileName,
-    lineNumber: place.lineNumber,
-    column: place.column,
-    nameToken: error.nameToken,
-    severity: "error",
-    origin: "runtime",
-    level,
-    ...fields
-  };
-}
-function staticFindingFor(raw, level, fileName, fields) {
-  return {
-    id: raw.id,
-    errorType: raw.errorType,
-    fileName,
-    lineNumber: raw.lineNumber,
-    column: raw.column,
-    nameToken: raw.nameToken,
-    severity: raw.severity,
-    origin: "static",
-    level,
-    ...fields
+    setTimeout(retry, retryMs);
   };
+  setTimeout(retry, retryMs);
 }
 
-// src/common/analyzers/nameErrorAnalyzer.ts
-var HANDLED = ["NameError", "UnboundLocalError"];
-var nameErrorAnalyzer = {
-  handles: HANDLED,
-  analyze(input) {
-    const { error, source } = input;
-    const place = placeOf(input);
-    const context = { source: inRunFile(input, place) ? source : "", line: place.text };
-    return runtimeFindingFor(input, { id: "name-error", ...explainNameError(error, context) });
+// src/pyodide/runtime.ts
+var NOT_RUNNING = "Python is not running.";
+var PythonLostError = class extends Error {
+  constructor() {
+    super("Python stopped completely.");
+    this.name = "PythonLostError";
   }
 };
-
-// src/common/analyzers/static/shadowingExplainer.ts
-function outerScopeNoun(kind) {
-  switch (kind) {
-    case "module":
-      return "the file";
-    case "function":
-    case "lambda":
-      return "an enclosing function";
-    case "class":
-      return "an enclosing class";
-    case "comprehension":
-      return "an enclosing comprehension";
-    default:
-      return "an outer scope";
-  }
-}
-function bindingNoun(binding) {
-  switch (binding) {
-    case "argument":
-      return "parameter";
-    case "for":
-      return "loop variable";
-    case "functiondef":
-      return "function";
-    case "classdef":
-      return "class";
-    case "import":
-    case "importfrom":
-      return "import";
-    case "capture":
-      return "name in a `case`";
-    case "assign":
-    case "annassign":
-    case "augassign":
-    case "walrus":
-    case "with":
-      return "variable";
-    default:
-      return "name";
+var StoppedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoppedError";
   }
+};
+function deliverDisplay(display, onEvent, fileName) {
+  onEvent(display.kind === "image" || display.kind === "table" ? { ...display, source: fileName } : display);
 }
-function explainShadowing(raw, level, fileName) {
-  const name = raw.nameToken ?? "this name";
-  const outerLine = raw.outerLineNumber ?? null;
-  const outerNoun = outerScopeNoun(raw.outerScopeKind);
-  const knownOuterLine = outerLine !== null && outerLine > 0;
-  const inner = bindingNoun(raw.binding);
-  const outer = bindingNoun(raw.outerBinding);
-  if (knownOuterLine && raw.lineNumber !== null && raw.lineNumber !== void 0 && outerLine > raw.lineNumber) {
-    return staticFindingFor(raw, level, fileName, {
-      headline: `\`${name}\` names two things: this ${inner}, and a ${outer} in ${outerNoun}, on line ${outerLine}.`,
-      howToFix: [
-        `Give one of them another name - this ${inner}, or the ${outer} on line ${outerLine} - so each name means one thing.`
-      ]
-    });
+var WorkerConnection = class {
+  constructor(options) {
+    this.options = options;
   }
-  const outerHint = knownOuterLine ? ` (first defined on line ${outerLine}, in ${outerNoun})` : ` in ${outerNoun}`;
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name}\` is already defined${outerHint}.`,
-    howToFix: [
-      `Rename this ${inner} to something distinct (e.g. \`${name}_inner\`, \`local_${name}\`, or whatever describes its role).`,
-      `Or, if you want to use the outer \`${name}\`, just read it directly without making a new ${inner === "parameter" ? "parameter" : "variable"}.`
-    ]
-  });
-}
-function explainShadowingBuiltin(raw, level, fileName) {
-  const name = raw.nameToken ?? "this name";
-  const headline = `\`${name}\` is the name of a Python built-in.`;
-  return staticFindingFor(raw, level, fileName, {
-    headline,
-    howToFix: [
-      `Pick a different name. Common patterns: \`my_${name}\`, \`${name}_value\`, \`${name}s\` (plural), or a more specific noun describing what this value represents.`
-    ]
-  });
-}
-function libraryNoun(library) {
-  switch (library) {
-    case "image":
-      return "the image library";
-    case "table":
-      return "the table library";
-    case "reactor":
-      return "the reactor library";
-    default:
-      return "the PLL libraries";
+  options;
+  worker = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  initPromise = null;
+  stdinBuffer = null;
+  interruptBuffer = null;
+  stdinHandler = null;
+  /** The stdin request being answered, or null; a Stop ends it. */
+  stdinRequest = null;
+  /** Stdin read but not yet given: what did not fit, or what came after a Stop. */
+  stdinCarry = new Uint8Array(0);
+  /** The handler's answer being waited for, which the next request shares. */
+  stdinNext = null;
+  packageNoteHandler = null;
+  pythonLostHandler = null;
+  /** Start the worker, once - or again, if the last attempt failed. */
+  async initialize() {
+    if (!this.initPromise) {
+      this.initPromise = this.doInitialize().catch((err) => {
+        this.initPromise = null;
+        this.worker?.terminate();
+        this.worker = null;
+        throw err;
+      });
+    }
+    await this.initPromise;
   }
-}
-function explainShadowingLibrary(raw, level, fileName) {
-  const name = raw.nameToken ?? "this name";
-  const noun = libraryNoun(raw.library);
-  if (raw.binding === "import" || raw.binding === "importfrom") {
-    const root = (raw.module ?? "module").split(".")[0];
-    const alias = `${root}${name.charAt(0).toUpperCase()}${name.slice(1)}`;
-    const written = raw.binding === "importfrom" ? `from ${raw.module} import ${name} as ${alias}` : `import ${name} as ${alias}`;
-    return staticFindingFor(raw, level, fileName, {
-      headline: `\`${name}\` is already defined by ${noun}, and this import replaces it.`,
-      howToFix: [
-        `Import it under another name: \`${written}\`, and use \`${alias}\` where you mean that one.`
-      ]
+  async doInitialize() {
+    const indexUrl = this.options.indexUrl();
+    const worker = this.options.spawn({
+      onMessage: (msg) => this.handleMessage(msg, worker),
+      onError: (err) => this.rejectAllPending(err),
+      onExit: () => this.pythonLost(worker)
     });
-  }
-  if (raw.binding === "argument" || raw.binding === "for") {
-    const what = bindingNoun(raw.binding);
-    return staticFindingFor(raw, level, fileName, {
-      headline: `\`${name}\` is already a name in PLL - one of ${noun}'s - and this ${what} hides it.`,
-      howToFix: [
-        `Give the ${what} another name - for example \`${name}_value\`, or a word for what it holds.`
-      ]
+    this.worker = worker;
+    this.stdinBuffer = tryCreateStdinBuffer();
+    this.interruptBuffer = tryCreateInterruptBuffer();
+    const packageCacheDir = this.options.packageCacheDir?.(indexUrl);
+    const started = this.send("init", {
+      indexUrl,
+      ...packageCacheDir ? { packageCacheDir } : {},
+      ...this.stdinBuffer ? { stdinBuffer: this.stdinBuffer } : {},
+      ...this.interruptBuffer ? { interruptBuffer: this.interruptBuffer } : {}
     });
-  }
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name}\` is already defined by ${noun}.`,
-    howToFix: [
-      `Pick a different name for your definition - for example \`my_${name}\`, \`${name}_value\`, or a word that describes what yours represents.`,
-      `If you meant to use the library's \`${name}\`, call it directly instead of defining a new \`${name}\` of your own.`
-    ]
-  });
-}
-
-// src/common/analyzers/static/reassignmentExplainer.ts
-function explainReassignment(raw, level, fileName) {
-  const name = raw.nameToken ?? "this name";
-  const firstLine = raw.firstLineNumber ?? null;
-  const firstLineHint = firstLine !== null && firstLine > 0 ? ` (first assigned on line ${firstLine})` : "";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name}\` is already assigned${firstLineHint}.`,
-    // Refused here, but not inside a function: then the fix is to move the
-    // work into one.
-    howToFix: !levelRefusesReassignment(level, "function") ? [
-      `If you want a different value, give it a different name (e.g. \`${name}_doubled\`, \`new_${name}\`, \`${name}2\`).`,
-      `If you're trying to update a value (\`x = x + 1\`, accumulators, running totals), wrap the work in a function and rebind \`${name}\` from the function's return value: \`${name} = compute_${name}(...)\`.`
-    ] : [
-      `If you want a different value, give it a different name (e.g. \`${name}_doubled\`, \`new_${name}\`, \`${name}2\`).`,
-      `If you're trying to update a value (\`x = x + 1\`, accumulators, running totals), use a built-in like \`sum(...)\`, \`max(...)\`, or a small helper function that returns the new value instead.`,
-      // Inside a function this is exactly what `intermediate` exists
-      // for, and a student has no way to know that from here.
-      ...raw.scopeKind === "function" && !levelRefusesReassignment(LEVEL_INTERMEDIATE, "function") ? [
-        "`#level intermediate` allows changing a variable inside a function, which is what a running total needs."
-      ] : []
-    ]
-  });
-}
-
-// src/common/analyzers/static/disallowedKeywordExplainer.ts
-function explainDisallowedKeyword(raw, level, fileName) {
-  const keyword = raw.keyword === "nonlocal" ? "nonlocal" : "global";
-  const names = Array.isArray(raw.names) ? raw.names : [];
-  const formattedNames = names.map((n) => `\`${n}\``).join(", ");
-  const namesPhrase = formattedNames.length > 0 ? ` ${formattedNames}` : "";
-  const headline = `\`${keyword}\` is not allowed at the ${level} level.`;
-  const howToFix = [];
-  if (keyword === "global") {
-    howToFix.push(
-      `Pass${namesPhrase || " the value"} into this function as an argument instead of declaring it \`global\`.`,
-      `If the function needs to *change* a value, return the new value and let the caller decide what to do with it (e.g. \`x = update(x)\`).`
-    );
-  } else {
-    howToFix.push(
-      `Return${namesPhrase || " the new value"} from this inner function and have the outer function rebind it explicitly (e.g. \`x = inner(x)\`).`,
-      `If the inner function only needs to *read* the outer name, just use it directly - you don't need \`nonlocal\` for that.`
-    );
-  }
-  howToFix.push(
-    `\`#level advanced\` allows \`${keyword}\`, if you have a reason to use it.`
-  );
-  return staticFindingFor(raw, level, fileName, {
-    headline,
-    howToFix
-  });
-}
-
-// src/common/analyzers/static/silenceExplainer.ts
-var TYPE_FOR = {
-  table: "Table",
-  reactor: "Reactor",
-  row: "dict",
-  string: "str",
-  integer: "int",
-  boolean: "bool",
-  number: "float",
-  Float: "float",
-  Int: "int",
-  Str: "str",
-  Bool: "bool",
-  image: "Image",
-  Number: "float",
-  String: "str",
-  Boolean: "bool",
-  Integer: "int"
-};
-var FUNCTION_NOT_TYPE = /* @__PURE__ */ new Set(["table", "reactor"]);
-function explainUnusedComparison(raw, level, fileName) {
-  const shown = raw.expression ? `\`assert ${raw.expression}\`` : "`assert ...`";
-  return staticFindingFor(raw, level, fileName, {
-    headline: "This comparison's answer is not used, so nothing checks it.",
-    howToFix: [
-      `Did you mean ${shown}? Without \`assert\` the comparison is worked out and thrown away, so the test always passes.`,
-      "At the top level a line like this is displayed; inside a function nothing shows it."
-    ]
-  });
-}
-function explainUnusedValue(raw, level, fileName) {
-  const expression = raw.expression ?? null;
-  const field = expression !== null ? /^([A-Za-z_]\w*\.[A-Za-z_]\w*)\s*[-+*/]/.exec(expression) : null;
-  const howToFix = expression === null ? ["Use it: `return` it, assign it to a name, or pass it to `print`."] : field !== null ? [
-    `To change \`${field[1]}\`, assign the result to it: \`${field[1]} = ${expression}\`.`,
-    `Or, if this is the function's answer, return it: \`return ${expression}\`.`
-  ] : [
-    `Did you mean \`return ${expression}\`? On its own, the value is worked out and thrown away.`
-  ];
-  return staticFindingFor(raw, level, fileName, {
-    headline: "This line works out a value and then throws it away.",
-    howToFix: [...howToFix, "Nothing in Python changes as a result of this line."]
-  });
-}
-function explainAssertTuple(raw, level, fileName) {
-  return staticFindingFor(raw, level, fileName, {
-    headline: "This `assert` has brackets around two things, so it is always true.",
-    howToFix: [
-      "`assert(a, b)` checks a pair, and a pair is never false - the test passes whatever happens.",
-      "Write `assert a == b`, with no brackets after `assert`."
-    ]
-  });
-}
-function explainIsLiteral(raw, level, fileName) {
-  const negated = raw.operator === "is not";
-  const literal = raw.literal ?? "a value";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${negated ? "is not" : "is"}\` asks whether two things are the very same object, not whether they are equal.`,
-    howToFix: [
-      `To compare with \`${literal}\`, write \`${negated ? "!=" : "=="}\` instead.`,
-      "`is` is for `None`: `x is None`."
-    ]
-  });
-}
-function explainMethodNotCalled(raw, level, fileName) {
-  const method = raw.nameToken ?? "the method";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${method}\` is named here but never called.`,
-    howToFix: [
-      `Add the brackets: \`.${method}()\`.`,
-      `Without them this is the method itself, which displays as \`<bound method ...>\`.`
-    ]
-  });
-}
-function explainAnnotationNotAType(raw, level, fileName) {
-  const written = raw.nameToken ?? "";
-  const type = TYPE_FOR[written] ?? null;
-  const headline = FUNCTION_NOT_TYPE.has(written) ? `\`${written}\` is the function that makes a ${written}; the type is \`${type}\`.` : `\`${written}\` is not a type Python knows.`;
-  const exists = FUNCTION_NOT_TYPE.has(written);
-  return staticFindingFor(raw, level, fileName, {
-    headline,
-    howToFix: type !== null ? [
-      `Write \`${type}\` instead.`,
-      exists ? "As it stands the annotation is accepted and nothing about this value is checked." : `There is nothing called \`${written}\`, so this line fails as soon as it runs.`
-    ] : ["Nothing about this value is being checked as a result."]
-  });
-}
-function explainTestNotNamed(raw, level, fileName) {
-  const name = raw.nameToken ?? "this function";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name}\` has an \`assert\` in it, but nothing ever runs it.`,
-    howToFix: [
-      `Rename it \`test_${name}\` and it will run with the other tests.`,
-      "Only functions whose names start with `test_` are run automatically."
-    ]
-  });
-}
-function explainFieldNoType(raw, level, fileName) {
-  const name = raw.nameToken ?? "this field";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `The field \`${name}\` has no type, so it is not a field at all.`,
-    howToFix: [
-      `Every field of a dataclass needs a type: \`${name}: int\`, \`${name}: str\`, and so on.`,
-      // Not the NameError it would lead to: this is reported before the
-      // program runs, so that error is never reached.
-      `On a line of its own, \`${name}\` only uses the name; it does not declare anything.`
-    ]
-  });
-}
-function explainFieldAssignedType(raw, level, fileName) {
-  const name = raw.nameToken ?? "this field";
-  const type = raw.writtenType ?? "int";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name} = ${type}\` sets \`${name}\` to the type itself; did you mean \`${name}: ${type}\`?`,
-    howToFix: [
-      "A field is declared with a colon, not an `=`.",
-      `With an \`=\` there is no \`${name}\` field, and the constructor ends up with the wrong number of arguments.`
-    ]
-  });
-}
-function explainClassNeedsDataclass(raw, level, fileName) {
-  const name = raw.nameToken ?? "this class";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name}\` lists fields but has no \`@dataclass\`, so \`${name}(...)\` takes no arguments.`,
-    howToFix: [
-      `Write \`@dataclass\` on the line above \`class ${name}\`.`,
-      "Add `from dataclasses import dataclass` at the top of the file if it is not there."
-    ]
-  });
-}
-function explainComparedWithClass(raw, level, fileName) {
-  const name = raw.nameToken ?? "a class";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `\`${name}\` is a class, so comparing a value with it is always False.`,
-    howToFix: [
-      `Use \`match\` to tell the kinds apart: \`case ${name}(...):\`.`,
-      `\`${name}\` is the blueprint; a value made from it is never equal to it.`
-    ]
-  });
-}
-
-// src/common/analyzers/static/duplicateDefinitionExplainer.ts
-function explainDuplicateDefinition(raw, level, fileName) {
-  const name = raw.nameToken ?? "this name";
-  const kind = raw.definitionKind === "class" ? "classes" : "functions";
-  const first = raw.firstLineNumber;
-  const where = typeof first === "number" && first > 0 ? ` (lines ${first} and ${raw.lineNumber})` : "";
-  return staticFindingFor(raw, level, fileName, {
-    headline: `There are two ${kind} named \`${name}\`${where}.`,
-    howToFix: [
-      "Rename one of them. Python keeps only the second, so the first never runs.",
-      kind === "functions" && name.startsWith("test_") ? "A test copied and not renamed vanishes this way: only the last one is run." : "Both definitions are kept in the file, but only the last name points at anything."
-    ]
-  });
-}
-
-// src/common/analyzers/static/registry.ts
-var explainers = {
-  shadowing: explainShadowing,
-  "shadowing-builtin": explainShadowingBuiltin,
-  "shadowing-library": explainShadowingLibrary,
-  reassignment: explainReassignment,
-  "disallowed-keyword": explainDisallowedKeyword,
-  "unused-comparison": explainUnusedComparison,
-  "unused-value": explainUnusedValue,
-  "assert-tuple": explainAssertTuple,
-  "method-not-called": explainMethodNotCalled,
-  "annotation-not-a-type": explainAnnotationNotAType,
-  "test-not-named": explainTestNotNamed,
-  "field-no-type": explainFieldNoType,
-  "field-assigned-type": explainFieldAssignedType,
-  "class-needs-dataclass": explainClassNeedsDataclass,
-  "compared-with-class": explainComparedWithClass,
-  "is-literal": explainIsLiteral,
-  "duplicate-definition": explainDuplicateDefinition
-};
-function fallbackExplainer(raw, level, fileName) {
-  return staticFindingFor(raw, level, fileName, {
-    headline: `PLL found a problem here (\`${raw.id}\`) but has no explanation for it.`,
-    howToFix: []
-  });
-}
-function enrichStaticFindings(rawFindings, level, fileName) {
-  return rawFindings.map((raw) => {
-    const explainer = explainers[raw.id] ?? fallbackExplainer;
-    return explainer(raw, level, fileName);
-  });
-}
-
-// src/common/analyzers/checksFailedAnalyzer.ts
-var checksFailedAnalyzer = {
-  handles: ["ChecksFailed"],
-  analyze(input) {
-    const checks = input.error.facts.checks;
-    if (checks === void 0) {
-      return null;
+    const limit = this.options.startTimeoutMs;
+    if (limit === void 0) {
+      await started;
+      return;
     }
-    const { file, level, headerProblem } = checks;
-    const problems = headerProblem !== null ? [`Line ${headerProblem.line}: ${headerProblem.message}`] : enrichStaticFindings(checks.findings, level, file).map(
-      (finding) => `Line ${finding.lineNumber}: ${finding.headline}`
-    );
-    const count = problems.length === 1 ? "a problem" : `${problems.length} problems`;
-    return runtimeFindingFor(input, {
-      id: "checks-failed",
-      errorType: "ChecksFailed",
-      headline: headerProblem !== null ? `\`${file}\` was not imported: there is a problem with its \`#level\` line.` : `\`${file}\` was not imported: the checks of \`#level ${level}\` found ${count} in it.`,
-      howToFix: [...problems, `Run \`${file}\` itself to see ${problems.length === 1 ? "it" : "each one"} where it is.`]
+    let timer;
+    const timedOut = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`Python did not start within ${Math.round(limit / 1e3)} seconds`)),
+        limit
+      );
     });
+    try {
+      await Promise.race([started, timedOut]);
+    } finally {
+      clearTimeout(timer);
+    }
   }
-};
-
-// src/common/errors/wording.ts
-var TYPE_WORDS = {
-  int: "whole number",
-  float: "number",
-  complex: "complex number",
-  str: "string",
-  bool: "`True` or `False`",
-  bytes: "bytes",
-  list: "list",
-  dict: "dictionary",
-  set: "set",
-  tuple: "tuple",
-  range: "range",
-  function: "function",
-  None: "`None`",
-  NoneType: "`None`"
-};
-function typeWords(type, { article = false } = {}) {
-  const words = TYPE_WORDS[type];
-  if (words === void 0 || !article || words.startsWith("`") || words === "bytes") {
-    return words;
+  /** Whether Python has been started, or is starting. */
+  get started() {
+    return this.initPromise !== null;
   }
-  return `a ${words}`;
-}
-function plural(count, noun) {
-  return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-function punctuated(text) {
-  const trimmed = text.trim();
-  return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
-}
-
-// src/common/analyzers/runtimeErrorAnalyzer.ts
-function analyzeRuntimeError(input) {
-  const { error } = input;
-  const place = placeOf(input);
-  const row = inRunFile(input, place) ? rowLine(input.source, place.lineNumber, error.message) : null;
-  return runtimeFindingFor(input, {
-    id: "runtime-error",
-    headline: headlineFor(error.errorType, error.message, error.facts?.stop === true, raisedByStudent(input)),
-    // Deliberately empty. A generic error has no generic remedy, and
-    // inventing one would be worse than the message itself.
-    howToFix: [],
-    lineNumber: row ?? place.lineNumber,
-    column: place.column
-  });
-}
-function rowLine(source, callLine, message) {
-  if (callLine === null) {
-    return null;
+  /** A request, once Python has started; `live` is where its output goes as it runs. */
+  async request(type, fields, live = null) {
+    await this.initialize();
+    return this.send(type, fields, live);
   }
-  const ordinal = /\bthe (\d+)(?:st|nd|rd|th) row\b/.exec(message);
-  if (ordinal === null) {
-    return null;
+  /** `fn(*args)` in Python, and what it returns; `live` streams its output. */
+  async call(fn, args, live) {
+    return await this.request("call", { fn, args, live: live !== void 0 }, live ?? null);
   }
-  return tableRowLine(source, callLine, Number(ordinal[1]) - 1);
-}
-function raisedByStudent(input) {
-  const innermost = input.error.frames[input.error.frames.length - 1];
-  return innermost?.user === true && /^\s*raise\b/.test(innermost.text ?? "");
-}
-function headlineFor(errorType, message, stop, theirs) {
-  const text = message.trim();
-  if (errorType === "KeyboardInterrupt" && stop) {
-    return "The program was stopped.";
-  }
-  if (!text) {
-    return `${errorType} while running your program.`;
-  }
-  const finish = theirs ? (sentence2) => sentence2 : punctuated;
-  if (errorType === "KeyError") {
-    const unquoted = text.match(/^'([\s\S]*)'$/) ?? text.match(/^"([\s\S]*)"$/);
-    if (unquoted === null || !/\s/.test(unquoted[1])) {
-      return text;
+  /**
+   * Ask a running program to stop, by raising `KeyboardInterrupt` at the
+   * interpreter's next bytecode check. Synchronous on purpose: the worker is
+   * blocked inside `runPython` and would not read a message until it
+   * returned. Returns false when there is no interrupt channel (no
+   * `SharedArrayBuffer`), so callers can say so rather than appear to work.
+   */
+  interrupt() {
+    if (!this.interruptBuffer) {
+      return false;
     }
-    return finish(unquoted[1]);
-  }
-  return finish(text);
-}
-
-// src/common/errors/stockMessageExplainer.ts
-function explainStockMessage(errorType, message, ctx) {
-  for (const rule of RULES) {
-    if (!rule.types.includes(errorType)) continue;
-    const m = rule.pattern.exec(message);
-    const explanation = m === null ? null : rule.explain(m, ctx, message);
-    if (explanation !== null) {
-      return explanation;
+    if (this.stdinBuffer && this.stdinRequest !== null) {
+      this.stdinRequest = null;
+      interruptStdin(this.stdinBuffer);
     }
-  }
-  return null;
-}
-function stockErrorTypes() {
-  return [...new Set(RULES.flatMap((rule) => rule.types))];
-}
-function friendly(type) {
-  const name = lastSegment(type);
-  return typeWords(name) ?? `\`${name}\``;
-}
-function lastSegment(type) {
-  return type.split(".").pop();
-}
-function takesClause(names, count) {
-  if (names !== null && names.length > 0) {
-    return `takes ${plural(names.length, "argument")} (${listNames(names)})`;
-  }
-  return `takes ${plural(count, "argument")}`;
-}
-function quotedNames(message) {
-  return Array.from(message.matchAll(/'(\w+)'/g), (m) => m[1]);
-}
-function definition(ctx, name) {
-  return ctx.facts.definitions?.[name];
-}
-function parametersOf(ctx, name, which) {
-  const found = definition(ctx, name);
-  return found?.kind === "function" ? found[which] : null;
-}
-function isStudentsClass(ctx, name) {
-  const found = definition(ctx, name);
-  return found?.kind === "class" && found.students;
-}
-function fieldsOf(ctx, name) {
-  const found = definition(ctx, name);
-  return found?.kind === "class" && found.fields.length > 0 ? found.fields : null;
-}
-function unionMembersOf(ctx, name) {
-  const found = definition(ctx, name);
-  return found?.kind === "union" && found.members.length > 1 ? found.members : null;
-}
-var WHY_NONE = [
-  "A function with no `return` gives back `None`.",
-  "A method that changes something in place - `append`, `sort` - also gives back `None`."
-];
-function typedOperand(line, facts) {
-  const tokens = tokenize(line);
-  for (let i = 0; i < tokens.length; i++) {
-    if (tokens[i].text !== "+") continue;
-    for (const [at, side] of [[i - 1, "left"], [i + 1, "right"]]) {
-      const token = tokens[at];
-      if (token?.kind !== "name" || tokens[at + 1]?.text === "(" || tokens[at - 1]?.text === ".") {
-        continue;
-      }
-      if (facts.assigned?.[token.text]?.call !== "input") {
-        continue;
+    const running = new Set(this.pending.keys());
+    requestInterrupt(this.interruptBuffer, () => {
+      for (const id of running) {
+        if (this.pending.has(id)) return true;
       }
-      const left = side === "left" ? `int(${token.text})` : operandBefore(line, tokens, i - 1);
-      const right = side === "right" ? `int(${token.text})` : operandFrom(line, tokens, i + 1);
-      if (left === null || right === null) continue;
-      return { name: token.text, fixed: `${left} + ${right}` };
-    }
+      return false;
+    });
+    return true;
   }
-  return null;
-}
-function whyNone(ctx, receiver, unknown = "This value is `None`") {
-  const call = receiver === null ? null : /^([A-Za-z_][\w.]*)\s*\(/.exec(receiver);
-  if (call !== null) {
-    return { subject: `\`${call[1]}(...)\` gave back \`None\``, howToFix: WHY_NONE };
-  }
-  if (receiver !== null && /^[A-Za-z_][\w.]*$/.test(receiver)) {
-    const subject = `\`${receiver}\` is \`None\``;
-    const frames = ctx.frames.filter((frame) => frame.user);
-    const inside = frames.at(-1)?.functionName ?? null;
-    if (inside !== null && (frames.at(-1)?.parameters ?? []).includes(receiver)) {
-      const caller = frames.at(-2);
-      return {
-        subject,
-        howToFix: [
-          `\`${receiver}\` is a parameter of \`${inside}\`, so the call` + (caller !== void 0 ? ` on line ${caller.line}` : "") + ` gave it \`None\`.`,
-          ...WHY_NONE
-        ]
-      };
-    }
-    const setFrom = ctx.facts.assigned?.[receiver] ?? null;
-    return {
-      subject,
-      howToFix: setFrom === null ? WHY_NONE : [
-        `\`${receiver}\` was set from \`${setFrom.call}(...)\` on line ${setFrom.line}, which gave back \`None\`.`,
-        ...WHY_NONE
-      ]
-    };
+  /**
+   * Told when Python had to be replaced - its worker stopped, or it could
+   * no longer run - and so every session's names are gone. The request in
+   * flight fails with `PythonLostError`; the next starts a new Python.
+   */
+  setPythonLostHandler(handler) {
+    this.pythonLostHandler = handler;
   }
-  const named = Array.from((ctx.offendingLine ?? "").matchAll(/([A-Za-z_][\w.]*)\s*\(/g), (m) => m[1]).find(
-    (name) => !WRAPPERS.has(name)
-  );
-  return {
-    subject: named !== void 0 ? `\`${named}(...)\` gave back \`None\`` : unknown,
-    howToFix: WHY_NONE
-  };
-}
-function withoutJoiningSpace(literal, before) {
-  const quote = literal[0];
-  const inner = literal.slice(1, -1);
-  const trimmed = before ? inner.replace(/ $/, "") : inner.replace(/^ /, "");
-  return `${quote}${trimmed}${quote}`;
-}
-var CALLS_YOUR_FUNCTION = [...FUNCTION_TAKER_NAMES, ...HANDLER_KEYWORDS];
-var functionCalledNotPassed = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\(\) missing \d+ required positional argument/,
-  explain: (m, ctx) => {
-    if (ctx.offendingLine === null) {
-      return null;
-    }
-    const name = m[1];
-    const line = ctx.offendingLine;
-    const taker = CALLS_YOUR_FUNCTION.find(
-      (candidate) => new RegExp(
-        `\\b${candidate}\\b\\s*(?:\\(|=)\\s*(?:[^()]*,\\s*)?${name}\\s*\\(\\s*\\)`
-      ).test(line)
-    );
-    if (taker === void 0) {
-      return null;
-    }
-    const keyword = HANDLER_KEYWORDS.includes(taker);
-    return {
-      headline: `\`${taker}\` calls \`${name}\` for you, so it needs the function itself.`,
-      howToFix: [
-        `Leave the brackets off: \`${keyword ? `${taker}=${name}` : `${taker}(${name})`}\`.`,
-        `\`${name}()\` calls it right here, with nothing to work on.`
-      ]
-    };
-  }
-};
-var tooFewArguments = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\(\) missing (\d+) required positional argument/,
-  explain: (m, ctx, message) => {
-    const [, name, missingText] = m;
-    const missing = Number(missingText);
-    if (name.startsWith("test_")) {
-      return {
-        headline: `\`${name}\` is a test, so it cannot take any parameters.`,
-        howToFix: [
-          `Write \`def ${name}():\` with nothing in the brackets, and make the values it needs inside it.`
-        ]
-      };
-    }
-    const names = parametersOf(ctx, name, "required");
-    if (names === null) {
-      return {
-        headline: needsMore(name, missing, message),
-        howToFix: ["Check the call on this line - one value is needed for each parameter."]
-      };
-    }
-    return {
-      headline: `\`${name}\` ${takesClause(names, names.length)}, but got ${Math.max(names.length - missing, 0)}.`,
-      howToFix: [
-        "Check the call on this line - one value is needed for each parameter.",
-        ...libraryHint(name)
-      ]
-    };
-  }
-};
-function needsMore(name, missing, message) {
-  const absent = quotedNames(message);
-  return `\`${name}\` needs ${plural(missing, "more argument")}` + (absent.length > 0 ? `: ${listNames(absent)}` : "") + ".";
-}
-var tooManyArguments = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\(\) takes (\d+) positional arguments? but (\d+) (?:was|were) given/,
-  explain: (m, ctx) => {
-    const [, name, takesText, givenText] = m;
-    const names = parametersOf(ctx, name, "parameters");
-    const extra = Number(givenText) - (names?.length ?? Number(takesText));
-    return {
-      headline: `\`${name}\` ${takesClause(names, Number(takesText))}, but got ${givenText}.`,
-      howToFix: [
-        extra > 1 ? `Check the call on this line - there are ${extra} values too many.` : "Check the call on this line - there is one value too many.",
-        ...libraryHint(name)
-      ]
-    };
+  /**
+   * Who hears what Pyodide says while it loads a package: "Loading pytest,
+   * ..." or, `failed`, why it could not. Without one, the host's log.
+   */
+  setPackageNoteHandler(handler) {
+    this.packageNoteHandler = handler;
   }
-};
-var missingDataclass = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\(\) takes no arguments/,
-  explain: (m, ctx) => {
-    const className = m[1];
-    const fields = fieldsOf(ctx, className);
-    if (fields === null) {
-      return null;
-    }
-    return {
-      headline: `\`${className}\` lists fields (${listNames(fields)}) but has no \`@dataclass\`, so it takes no arguments.`,
-      howToFix: [
-        `Write \`@dataclass\` on the line above \`class ${className}\`.`,
-        "Add `from dataclasses import dataclass` at the top of the file if it is not there."
-      ]
-    };
+  /**
+   * Register the handler asked for the next of stdin when a running program
+   * reads it - `input()`, `sys.stdin.read()`. It resolves with the next text
+   * or bytes, exactly as the program should read them (a line typed is that
+   * line and its newline), or `null` at the end of stdin. The worker waits
+   * until it does, or until a Stop, which raises `KeyboardInterrupt` in the
+   * read.
+   */
+  setStdinHandler(handler) {
+    this.stdinHandler = handler;
   }
-};
-var dataclassArity = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\.__init__\(\) (?:missing (\d+) required positional argument|takes \d+ positional arguments? but \d+ (?:was|were) given)/,
-  explain: (m, ctx, message) => {
-    const className = m[1];
-    const fields = fieldsOf(ctx, className);
-    if (fields === null) {
-      return {
-        headline: `\`${className}\` was given the wrong number of values.`,
-        howToFix: [`Give one value for each field of \`class ${className}\`, in order.`]
-      };
-    }
-    const given = /takes \d+ positional arguments? but (\d+)/.exec(message);
-    const got = given !== null ? Number(given[1]) - 1 : Math.max(fields.length - Number(m[2]), 0);
-    return {
-      headline: `\`${className}\` needs ${plural(fields.length, "value")} (${listNames(fields)}), but got ${got}.`,
-      howToFix: [
-        `Give one value for each field, in the order they are written in \`class ${className}\`.`
-      ]
-    };
+  dispose() {
+    this.worker?.terminate();
+    this.worker = null;
+    this.initPromise = null;
+    this.stdinBuffer = null;
+    this.interruptBuffer = null;
+    this.rejectAllPending(new Error("Runtime disposed"));
   }
-};
-var methodArity = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\.(\w+)\(\) missing (\d+) required positional argument/,
-  explain: (m, ctx, message) => {
-    if (m[2] === "__init__") {
-      return null;
-    }
-    const [, owner, method, missingText] = m;
-    const missing = Number(missingText);
-    const required = parametersOf(ctx, `${owner}.${method}`, "required");
-    if (required === null) {
-      return { headline: needsMore(method, missing, message), howToFix: [] };
+  /** Send a request to the worker as it is now, and resolve with its reply. */
+  send(type, fields, live = null) {
+    const worker = this.worker;
+    if (!worker) {
+      return Promise.reject(new Error(NOT_RUNNING));
     }
-    return {
-      headline: `\`${method}\` ${takesClause(required, required.length)}, but got ${Math.max(required.length - missing, 0)}.`,
-      howToFix: []
-    };
+    const id = this.nextId++;
+    return new Promise((resolve4, reject) => {
+      this.pending.set(id, { resolve: resolve4, reject, live });
+      worker.post({ id, type, ...fields });
+    });
   }
-};
-var noSuchAttribute = {
-  types: ["AttributeError"],
-  pattern: /^'([\w.]+)' object has no attribute '(\w+)'/,
-  explain: (m, ctx) => {
-    const type = m[1];
-    const asked = m[2];
-    if (lastSegment(type) === "NoneType") {
-      const none = whyNone(ctx, attributeReceiver(ctx.offendingLine, asked));
-      return { headline: `${none.subject}, so it has no \`${asked}\`.`, howToFix: none.howToFix };
-    }
-    const fields = fieldsOf(ctx, lastSegment(type));
-    if (fields === null) {
-      const name = lastSegment(type);
-      if (isStudentsClass(ctx, name)) {
-        return {
-          headline: `\`${name}\` has no fields at all, so it has no \`${asked}\`.`,
-          howToFix: [
-            `A value that might be a \`${name}\` needs a \`case ${name}():\` before \`.${asked}\` is used.`
-          ]
-        };
+  handleMessage(msg, worker) {
+    if (msg.type === "display") {
+      const live = this.pending.get(msg.requestId)?.live;
+      if (live) {
+        deliverDisplay(msg.payload, live.onEvent, live.fileName);
       }
-      return {
-        headline: `A ${friendly(type)} has no \`${asked}\`.`,
-        howToFix: []
-      };
-    }
-    const suggestion = closestName(asked, fields);
-    return {
-      headline: `\`${lastSegment(type)}\` has no field \`${asked}\` (its fields are ${listNames(fields)}).`,
-      howToFix: suggestion !== null ? [`Did you mean \`${suggestion}\`?`] : []
-    };
-  }
-};
-var attributeOnClass = {
-  types: ["AttributeError"],
-  pattern: /^type object '(\w+)' has no attribute '(\w+)'/,
-  explain: (m, ctx) => {
-    const [, className, asked] = m;
-    const fields = fieldsOf(ctx, className);
-    if (fields === null) {
-      return null;
-    }
-    return {
-      headline: `\`${className}\` on its own is the class, not one made from it, so it has no \`${asked}\`.`,
-      howToFix: [
-        `\`${className}(...)\` makes one, with a value for each field (${listNames(fields)}).`,
-        "A field belongs to the value, not to the class it was made from."
-      ]
-    };
-  }
-};
-var notSubscriptable = {
-  types: ["TypeError"],
-  pattern: /^'([\w.]+)' object is not subscriptable/,
-  explain: (m, ctx) => {
-    const type = m[1];
-    if (lastSegment(type) === "NoneType") {
-      const none = whyNone(ctx, subscriptReceiver(ctx.offendingLine));
-      return {
-        headline: `${none.subject}, so square brackets cannot get anything out of it.`,
-        howToFix: none.howToFix
-      };
-    }
-    const method = /([A-Za-z_][\w.]*)\.(\w+)\s*\[\s*([^\]]*)\]/.exec(ctx.offendingLine ?? "");
-    if (lastSegment(type) === "method" && method !== null) {
-      const [, holder2, name, inside] = method;
-      return {
-        headline: `\`${holder2}.${name}\` is a method, so it is called with round brackets, not indexed with square ones.`,
-        howToFix: [
-          name === "row" ? `Write \`${holder2}.row(${inside})\`: the row number goes in the round brackets.` : `Call it first: \`${holder2}.${name}()[${inside}]\`.`
-        ]
-      };
-    }
-    const fields = fieldsOf(ctx, lastSegment(type));
-    if (fields === null) {
-      const caller = libraryCaller(ctx.frames);
-      const taker = caller !== null ? FUNCTION_TAKERS[caller] : void 0;
-      return {
-        headline: `Square brackets do not work on a ${friendly(type)}.`,
-        howToFix: [
-          ...caller === "transform_column" && taker !== void 0 ? [`${taker.calls}, so what your function is given is already the value - there is nothing to take out of it.`] : [],
-          "Square brackets are for lists, dictionaries and table rows."
-        ]
-      };
-    }
-    const subscript = /([A-Za-z_][\w.]*)\s*\[\s*["'](\w+)["']\s*\]/.exec(ctx.offendingLine ?? "");
-    const holder = subscript !== null ? subscript[1] : "value";
-    const field = subscript !== null ? subscript[2] : fields[0];
-    return {
-      headline: `Square brackets do not get a field out of \`${lastSegment(type)}\`.`,
-      howToFix: [
-        `Use a dot instead: \`${holder}.${field}\` rather than \`${holder}["${field}"]\`.`,
-        "Square brackets are for lists, dictionaries and table rows."
-      ]
-    };
-  }
-};
-var notIterable = {
-  types: ["TypeError"],
-  pattern: /^'([\w.]+)' object is not iterable/,
-  explain: (m, ctx) => {
-    const over = /\bfor\s+\w+\s+in\s+len\s*\(\s*([A-Za-z_][\w.]*)\s*\)/.exec(
-      ctx.offendingLine ?? ""
-    );
-    if (over !== null) {
-      return {
-        headline: `\`len(${over[1]})\` is a number, and a number is not something to loop over.`,
-        howToFix: [
-          `To visit each item, write \`for item in ${over[1]}:\`.`,
-          `To count, write \`for i in range(len(${over[1]})):\` - but the first form is usually what you want.`
-        ]
-      };
-    }
-    if (lastSegment(m[1]) === "NoneType") {
-      const none = whyNone(ctx, loopedOver(ctx.offendingLine));
-      return { headline: `${none.subject}, so there is nothing to loop over.`, howToFix: none.howToFix };
-    }
-    const looped = loopedOver(ctx.offendingLine);
-    if (lastSegment(m[1]) === "method" && looped !== null && /\.\w+$/.test(looped)) {
-      return {
-        headline: `\`${looped}\` is the method itself, not what it gives back - it has not been called.`,
-        howToFix: [`Call it, with brackets: \`for ... in ${looped}():\`.`]
-      };
+      return;
     }
-    return {
-      headline: `A ${friendly(m[1])} is not something to loop over.`,
-      howToFix: ["`for` needs a list, a string, a range or something else with items in it."]
-    };
-  }
-};
-var concatMismatch = {
-  types: ["TypeError"],
-  pattern: /can only concatenate (str|list|tuple) \(not "([\w.]+)"\) to \1/,
-  explain: (m, ctx) => {
-    const [, container, other] = m;
-    const headline = `A ${friendly(container)} and a ${friendly(other)} cannot be added together.`;
-    if (container === "str") {
-      const line = ctx.offendingLine ?? "";
-      const pair = concatOperands(line);
-      const howToFix = [];
-      if (pair !== null) {
-        const { text, value, textFirst } = pair;
-        howToFix.push(
-          `To join them as text, convert \`${value}\` with \`str\`: \`${textFirst ? `${text} + str(${value})` : `str(${value}) + ${text}`}\`.`
-        );
-        if (/^\s*print\s*\(/.test(line)) {
-          const spaced = withoutJoiningSpace(text, textFirst);
-          howToFix.push(
-            `In \`print\`, a comma needs no conversion at all, and puts a space in for you: \`print(${textFirst ? `${spaced}, ${value}` : `${value}, ${spaced}`})\`.`
-          );
-        }
-      } else {
-        const typed = typedOperand(line, ctx.facts);
-        if (typed !== null) {
-          return {
-            headline,
-            howToFix: [
-              `\`${typed.name}\` came from \`input\`, which always gives back text - even when a number is typed.`,
-              `Convert it first: \`${typed.fixed}\`.`
-            ]
-          };
-        }
-        howToFix.push(
-          "To join them as text, convert the other value with `str(...)`.",
-          "In `print`, separate them with commas instead, which needs no conversion."
-        );
-      }
-      howToFix.push("To add them as numbers instead, convert the text with `int(...)` or `float(...)`.");
-      return { headline, howToFix };
+    if (msg.type === "stdinRequest") {
+      void this.handleStdinRequest(msg.request);
+      return;
     }
-    const operand = /([A-Za-z_][\w.]*)\s*\+/.exec(ctx.offendingLine ?? "");
-    const named = operand !== null ? operand[1] : "xs";
-    const open = container === "list" ? "[" : "(";
-    const close = container === "list" ? "]" : ",)";
-    return {
-      headline,
-      howToFix: [
-        `\`+\` joins a ${container} to another ${container}. To add one item, put it inside ${container === "list" ? "brackets" : "a tuple"}: \`${named} + ${open}item${close}\`.`,
-        ...container === "list" ? [`Or add it in place with \`${named}.append(item)\`, which changes \`${named}\` and returns nothing.`] : []
-      ]
-    };
-  }
-};
-var operandMismatch = {
-  types: ["TypeError"],
-  pattern: /^unsupported operand type\(s\) for (\S+?): '([\w.]+)' and '([\w.]+)'/,
-  explain: (m, ctx) => {
-    const [, operator, left, right] = m;
-    if (left !== "NoneType" && right !== "NoneType") {
-      return {
-        headline: `\`${operator}\` does not work between a ${friendly(left)} and a ${friendly(right)}.`,
-        howToFix: left === "str" !== (right === "str") ? ["Convert one of them first - `int(...)` for a number, `str(...)` for text."] : []
-      };
+    if (msg.type === "packageNote") {
+      if (this.packageNoteHandler) this.packageNoteHandler(msg.text, msg.failed);
+      else console.error(msg.text);
+      return;
     }
-    const side = left === "NoneType" ? "left" : "right";
-    const none = whyNone(ctx, operandBeside(ctx.offendingLine, operator, side), "One of these values is `None`");
-    return { headline: `${none.subject}, so \`${operator}\` cannot be used on it.`, howToFix: none.howToFix };
-  }
-};
-var COMPARISONS = /* @__PURE__ */ new Set(["<", ">", "<=", ">=", "==", "!="]);
-var conditionNotFunction = {
-  types: ["TypeError"],
-  pattern: /not supported between instances of|unsupported operand type/,
-  explain: (_m, ctx) => {
-    if (ctx.offendingLine === null) {
-      return null;
+    if (msg.type === "error" && msg.kind === "finished") {
+      this.pythonLost(worker);
+      return;
     }
-    const line = ctx.offendingLine;
-    const tokens = tokenize(line);
-    for (let i = 0; i < tokens.length; i++) {
-      const taker = FUNCTION_TAKERS[tokens[i].text];
-      if (taker?.each === void 0 || tokens[i].kind !== "name" || tokens[i + 1]?.text !== "(") {
-        continue;
-      }
-      const shut = closing(tokens, i + 1);
-      if (shut < 0) continue;
-      const inside = tokens.slice(i + 2, shut);
-      let depth = 0;
-      let compares = false;
-      let isFunction = false;
-      for (const token of inside) {
-        if (token.kind === "open") depth++;
-        if (token.kind === "close") depth--;
-        if (depth === 0 && COMPARISONS.has(token.text)) compares = true;
-        if (token.text === "lambda") isFunction = true;
-      }
-      if (!compares || isFunction) continue;
-      const name = tokens[i].text;
-      const receiver = tokens[i - 1]?.text === "." ? tokens[i - 2]?.text ?? null : null;
-      let condition = "";
-      let named = null;
-      let cursor = tokens[i + 2]?.start ?? 0;
-      for (let k = 0; k < inside.length; k++) {
-        const token = inside[k];
-        const nextOp = inside[k + 1]?.text;
-        const prevOp = inside[k - 1]?.text;
-        condition += line.slice(cursor, token.start);
-        if (token.kind === "str" && name !== "transform_column" && (COMPARISONS.has(nextOp ?? "") || COMPARISONS.has(prevOp ?? ""))) {
-          condition += `r[${token.text}]`;
-          named = named ?? token.text;
-        } else {
-          condition += token.text;
-        }
-        cursor = token.end;
-      }
-      condition = condition.trim();
-      const call = receiver !== null ? `${receiver}.${name}(keep)` : `${name}(keep)`;
-      return {
-        headline: `\`${name}\` needs a function, but this gives it a condition.`,
-        howToFix: [
-          `\`${name}\` calls a function on ${taker.each} and ${taker.keeps}, so the condition belongs inside a function. Here it was worked out first - which is what the error is about.`,
-          `Write \`def keep(${taker.param}) -> bool:\` with \`return ${condition}\` as its body, then \`${call}\`.`,
-          ...named !== null ? [
-            `On its own, \`${named}\` is just text. The value in that column of a row is \`r[${named}]\`.`
-          ] : []
-        ]
-      };
+    const pending = this.pending.get(msg.id);
+    if (!pending) {
+      return;
     }
-    return null;
-  }
-};
-var comparisonMismatch = {
-  types: ["TypeError"],
-  pattern: /^'(\S+)' not supported between instances of '([\w.]+)' and '([\w.]+)'/,
-  explain: (m) => {
-    const [, operator, left, right] = m;
-    const howToFix = [];
-    const text = left === "str" ? left : right === "str" ? right : null;
-    const number = numericType(left) ?? numericType(right);
-    if (text !== null && number !== null) {
-      howToFix.push(
-        `Convert the text to a number with \`${number}(...)\`, or the number to text with \`str(...)\` - whichever this comparison is meant to be about.`
-      );
+    this.pending.delete(msg.id);
+    if (msg.type === "error") {
+      pending.reject(msg.kind === "interrupted" ? new StoppedError(msg.message) : new Error(msg.message));
     } else {
-      howToFix.push(
-        `\`${operator}\` only orders values of the same kind; there is no answer to this comparison.`
-      );
-    }
-    return {
-      headline: `\`${operator}\` cannot compare a ${friendly(left)} with a ${friendly(right)}.`,
-      howToFix
-    };
-  }
-};
-function numericType(type) {
-  const name = lastSegment(type);
-  return name === "int" || name === "float" ? name : null;
-}
-var badIntLiteral = {
-  types: ["ValueError"],
-  pattern: /^invalid literal for int\(\) with base 10: (.+)$/,
-  explain: (m, ctx) => {
-    const raw = m[1].trim();
-    const empty = raw === "''" || raw === '""';
-    const shown = /^'[^'"]*'$/.test(raw) ? `"${raw.slice(1, -1)}"` : raw;
-    const howToFix = ['`int` only reads whole numbers written in digits, like `"19"`.'];
-    if (/\binput\s*\(/.test(ctx.offendingLine ?? "")) {
-      howToFix.push(
-        empty ? "Nothing was typed: pressing Enter on its own makes `input` give back an empty string." : "`input` gives back exactly what was typed, as text, so a word cannot become a number."
-      );
-    }
-    return {
-      headline: empty ? "`int` cannot turn an empty string into a whole number." : `\`int\` cannot turn ${shown} into a whole number.`,
-      howToFix
-    };
-  }
-};
-var indexRange = {
-  types: ["IndexError"],
-  pattern: /index out of range/,
-  explain: (_m, ctx) => {
-    const subscript = /([A-Za-z_][\w.]*)\s*\[\s*([^\]]+?)\s*\]/.exec(ctx.offendingLine ?? "");
-    const named = subscript !== null ? `\`${subscript[1]}\`` : "This list";
-    const { sequence, length } = ctx.facts;
-    if (sequence !== void 0 && length !== void 0) {
-      return {
-        headline: `\`${sequence}\` has no item at that position.`,
-        howToFix: [
-          length === 0 ? `\`${sequence}\` is empty, so it has no items at all.` : `\`${sequence}\` has ${length} item${length === 1 ? "" : "s"}, numbered 0 to ${length - 1} - positions start at 0.`
-        ]
-      };
+      pending.resolve(msg.value);
     }
-    return {
-      headline: `${named} has no item at that position.`,
-      howToFix: [
-        "Positions start at 0, so the last item of a list is at position `len(...) - 1`.",
-        subscript !== null ? `\`len(${subscript[1]})\` gives the number of items.` : "`len(...)` gives the number of items."
-      ]
-    };
   }
-};
-var notCallable = {
-  types: ["TypeError"],
-  pattern: /^'([\w.]+)' object is not callable/,
-  explain: (m, ctx) => {
-    if (m[1] === "types.UnionType") {
-      const called = callOn(ctx.offendingLine);
-      const members = called !== null ? unionMembersOf(ctx, called) : null;
-      return {
-        headline: called !== null ? `\`${called}\` is a union of several types, not something to make one of.` : "This is a union of several types, not something to make one of.",
-        howToFix: members !== null ? [`Make one of ${listNames(members)} instead, like \`${members[0]}(...)\`.`] : ["Make one of the types the union is built from."]
-      };
-    }
-    const juxtaposed = /(\d+(?:\.\d+)?)\s*\(([^()]*)\)/.exec(ctx.offendingLine ?? "");
-    const numeric = lastSegment(m[1]) === "int" || lastSegment(m[1]) === "float";
-    if (juxtaposed !== null && numeric) {
-      const [written, number, inside] = juxtaposed;
-      return {
-        headline: `Brackets after \`${number}\` look like a function call, not multiplication.`,
-        howToFix: [
-          `To multiply, write the \`*\`: \`${number} * ${inside.trim() || "..."}\`, not \`${written}\`.`
-        ]
-      };
-    }
-    return {
-      headline: `A ${friendly(m[1])} cannot be called like a function.`,
-      howToFix: ["Brackets after a value mean a call; check whether a `*` or a comma is missing."]
-    };
+  /**
+   * Python is gone: the worker exited (only a Node worker can say so), or
+   * the interpreter in it is finished and refuses everything. Either way
+   * nothing sent to it can succeed. Fail what was waiting, end the worker,
+   * and forget it, so that the next request starts a new Python.
+   *
+   * Every session's names went with the old one - but they were gone
+   * already: this follows Python stopping by itself, and never ends a
+   * Python that could still run. Whoever set `setPythonLostHandler` is told,
+   * so that each file can say so rather than only the one that was running.
+   */
+  pythonLost(worker) {
+    if (this.worker !== worker) return;
+    this.rejectAllPending(new PythonLostError());
+    this.worker = null;
+    this.initPromise = null;
+    worker.terminate();
+    this.pythonLostHandler?.();
   }
-};
-var handlerCalled = {
-  types: ["ValueError"],
-  pattern: /^reactor's `(\w+)` has to be a function/,
-  explain: (m, ctx) => {
-    if (ctx.offendingLine === null) {
-      return null;
-    }
-    const handler = m[1];
-    const line = ctx.offendingLine;
-    const tokens = tokenize(line);
-    for (let i = 0; i < tokens.length; i++) {
-      if (tokens[i].text !== handler || tokens[i + 1]?.text !== "=") continue;
-      const called = operandFrom(line, tokens, i + 2);
-      const fn = tokens[i + 2]?.kind === "name" ? tokens[i + 2].text : null;
-      if (called === null || fn === null || called === fn) continue;
-      return {
-        headline: `\`${handler}\` has to be given the function itself, not what calling it gives back.`,
-        howToFix: [
-          `Write \`${handler}=${fn}\`, not \`${handler}=${called}\`.`,
-          `The reactor calls \`${fn}\` itself, with its state, every time it needs a picture.`
-        ]
-      };
+  rejectAllPending(err) {
+    for (const pending of this.pending.values()) {
+      pending.reject(err);
     }
-    return null;
-  }
-};
-var patternArity = {
-  types: ["TypeError"],
-  pattern: /^(\w+)\(\) accepts (\d+) positional sub-patterns \((\d+) given\)/,
-  explain: (m, ctx) => {
-    const [, className, accepts, given] = m;
-    const fields = fieldsOf(ctx, className);
-    return {
-      headline: `\`${className}\` has ${plural(Number(accepts), "field")}` + (fields !== null ? ` (${listNames(fields)})` : "") + `, but this pattern names ${given}.`,
-      howToFix: fields !== null ? [`Write one name for each field: \`case ${className}(${fields.join(", ")}):\`.`] : ["Write one name for each field, in order."]
-    };
-  }
-};
-var missingComma = {
-  types: ["TypeError"],
-  pattern: /list indices must be integers or slices, not tuple/,
-  explain: () => {
-    return {
-      headline: "A comma is missing between two values in a list.",
-      howToFix: [
-        "`[a, b] [c, d]` with no comma reads as looking `c, d` up inside the first list.",
-        "Write `[[a, b], [c, d]]`, with a comma after every row."
-      ]
-    };
-  }
-};
-var recursionDepth = {
-  types: ["RecursionError"],
-  pattern: /maximum recursion depth/,
-  explain: (_m, ctx) => {
-    const repeated = repeatedFunction(ctx.frames);
-    const named = repeated !== null ? `\`${repeated}\`` : "A function";
-    return {
-      headline: `${named} kept calling itself and never stopped.`,
-      howToFix: [
-        "Each call has to work on something smaller - the rest of the list, a smaller number.",
-        "Check that there is a case that returns without calling again, and that it is reached."
-      ]
-    };
-  }
-};
-function repeatedFunction(frames) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const { functionName } of frames) {
-    if (functionName !== null) counts.set(functionName, (counts.get(functionName) ?? 0) + 1);
+    this.pending.clear();
   }
-  let best = null;
-  let bestCount = 0;
-  for (const [name, count] of counts) {
-    if (count > bestCount) {
-      best = name;
-      bestCount = count;
+  /**
+   * The next of stdin from the handler. One call at a time: a request a
+   * Stop ended leaves its call waiting, and the next request - a program
+   * that caught the `KeyboardInterrupt` and asked again - shares it, so
+   * the line typed answers that one.
+   */
+  nextStdin() {
+    if (this.stdinNext === null) {
+      const call = (async () => {
+        try {
+          const next = this.stdinHandler ? await this.stdinHandler() : null;
+          return typeof next === "string" ? new TextEncoder().encode(next) : next;
+        } catch {
+          return null;
+        }
+      })();
+      this.stdinNext = call;
+      void call.then(() => {
+        if (this.stdinNext === call) this.stdinNext = null;
+      });
     }
+    return this.stdinNext;
   }
-  return bestCount >= 3 ? best : null;
-}
-var unevenColumns = {
-  types: ["ValueError"],
-  pattern: /All arrays must be of the same length/,
-  explain: (_m, ctx) => {
-    return {
-      headline: "The columns of this DataFrame have different numbers of values.",
-      howToFix: [
-        "Each list in the dictionary is one column, and every column needs one value for each row - so the lists have to be the same length.",
-        .../DataFrame\s*\(/.test(ctx.offendingLine ?? "") ? ["Count the values in each list on this line; one has more or fewer than the rest."] : []
-      ]
-    };
-  }
-};
-var pandasKeyError = {
-  types: ["KeyError"],
-  pattern: /^\s*'[\s\S]*'\s*$/,
-  explain: (_m, ctx, message) => {
-    const insidePandas = ctx.frames.some(
-      (frame2) => /[/\\]pandas[/\\]core[/\\]|site-packages[/\\]pandas/.test(frame2.fileName)
-    );
-    if (!insidePandas) {
-      return null;
-    }
-    const key = /^'([\s\S]*)'$/.exec(message.trim());
-    if (key === null) {
-      return null;
-    }
-    const frame = /([A-Za-z_][\w.]*)\s*\[/.exec(ctx.offendingLine ?? "");
-    return {
-      headline: `There is no column named \`${key[1]}\`.`,
-      howToFix: [
-        frame !== null ? `\`print(${frame[1]}.columns)\` lists the columns this DataFrame has.` : "`.columns` lists the columns a DataFrame has.",
-        "Column names are case-sensitive, and spaces count."
-      ]
-    };
-  }
-};
-var missingModule = {
-  types: ["ModuleNotFoundError"],
-  pattern: /^No module named/,
-  explain: (_m, ctx) => {
-    const module2 = ctx.facts.module;
-    if (module2 === void 0) {
-      return null;
-    }
-    const name = module2.name;
-    switch (module2.kind) {
-      case "leftOut":
-        return {
-          headline: `\`${name}.py\` is next to your program, but it was not loaded: ${module2.why}.`,
-          howToFix: ["A file that was not loaded cannot be imported."]
-        };
-      case "notLoaded":
-        return {
-          headline: `\`${name}\` could not be loaded before your program ran.`,
-          howToFix: [
-            `PLL downloads \`${module2.package}\` the first time a program imports it, so this needs the internet once; after that it is kept.`,
-            "Check the connection, and run the program again."
-          ]
-        };
-      case "notSeen":
-        return {
-          headline: `\`${name}\` was not loaded, because PLL did not see it imported.`,
-          howToFix: [
-            `PLL loads a package before the program runs, from its \`import\` lines - and this import is made another way, with a name worked out as it runs.`,
-            `Add \`import ${name}\` near the top of the file.`
-          ]
-        };
-      case "missing":
-        if (module2.close !== null) {
-          return {
-            headline: `There is no module called \`${name}\` - and no file \`${name}.py\` next to your program.`,
-            howToFix: [`Did you mean \`${module2.close}\`, for \`${module2.close}.py\`?`]
-          };
-        }
-        return {
-          headline: `There is no module called \`${name}\` here.`,
-          howToFix: [
-            `PLL runs Python with Pyodide, which has many packages - numpy, pandas, matplotlib, requests and more - but not \`${name}\`.`,
-            `If \`${name}\` is a file of your own, put \`${name}.py\` next to your program.`
-          ]
-        };
-    }
-  }
-};
-var builtinOnTable = {
-  types: ["TypeError"],
-  pattern: /Table|^a table /,
-  explain: (_m, ctx) => {
-    const call = /\b(sum|min|max|len|sorted)\s*\(\s*([A-Za-z_][\w.]*)\s*,\s*("[^"]*"|'[^']*')\s*\)/.exec(
-      ctx.offendingLine ?? ""
-    );
-    if (call === null) {
-      return null;
-    }
-    const [, fn, table, column] = call;
-    const method = fn === "len" ? "length" : fn === "sorted" ? "order_by" : fn;
-    return {
-      headline: `\`${fn}(${table}, ${column})\` is Python's own \`${fn}\`, which knows nothing of tables.`,
-      howToFix: [`A table does this itself: \`${table}.${method}(${method === "length" ? "" : column})\`.`]
-    };
-  }
-};
-var RULES = [
-  missingModule,
-  builtinOnTable,
-  conditionNotFunction,
-  handlerCalled,
-  functionCalledNotPassed,
-  missingDataclass,
-  dataclassArity,
-  tooFewArguments,
-  tooManyArguments,
-  methodArity,
-  attributeOnClass,
-  noSuchAttribute,
-  notSubscriptable,
-  notIterable,
-  concatMismatch,
-  operandMismatch,
-  comparisonMismatch,
-  badIntLiteral,
-  indexRange,
-  notCallable,
-  patternArity,
-  missingComma,
-  recursionDepth,
-  unevenColumns,
-  pandasKeyError
-];
-
-// src/common/analyzers/stockMessageAnalyzer.ts
-var stockMessageAnalyzer = {
-  // Exactly what the rules are for: the list is theirs, not a copy of it.
-  handles: stockErrorTypes(),
-  analyze(input) {
-    const { error } = input;
-    const explanation = explainStockMessage(error.errorType, error.message, {
-      // The line that raised, which several rules need - `for x in len(xs)`
-      // is only told apart from any other `'int' object is not iterable` by
-      // reading it.
-      offendingLine: placeOf(input).text,
-      frames: error.frames,
-      facts: error.facts
-    });
-    if (explanation === null) {
-      return null;
-    }
-    return {
-      ...analyzeRuntimeError(input),
-      id: "stock-message",
-      headline: explanation.headline,
-      howToFix: explanation.howToFix
-    };
-  }
-};
-
-// src/common/errors/syntaxExplainer.ts
-function explainSyntaxError(errorType, message, offendingLine) {
-  const error = { errorType, message, line: (offendingLine ?? "").trim() };
-  for (const rule of RULES2) {
-    const explanation = rule(error);
-    if (explanation !== null) {
-      return explanation;
-    }
-  }
-  return {
-    headline: sentence(message),
-    howToFix: []
-  };
-}
-var tabsAndSpaces = ({ errorType }) => errorType !== "TabError" ? null : {
-  headline: "This line mixes tabs and spaces for its indentation.",
-  howToFix: [
-    "Use spaces throughout. In VS Code, the command **Convert Indentation to Spaces** fixes the whole file.",
-    "A tab and four spaces look identical on screen, which is why this is hard to see."
-  ]
-};
-var badCharacter = ({ message }) => {
-  const bad = /invalid character '(.)' \(U\+[0-9A-F]+\)/.exec(message);
-  if (!bad) return null;
-  const curly = "\u201C\u201D\u2018\u2019".includes(bad[1]);
-  return {
-    headline: `\`${bad[1]}\` is not a character Python can read here.`,
-    howToFix: curly ? [
-      "Use straight quotes (`\"` and `'`) rather than curly ones.",
-      "Curly quotes come from copying out of a document or a web page; retyping the quotes fixes it."
-    ] : ["Retype the line; the character may have come from copying out of a document."]
-  };
-};
-var elseIf = ({ line }) => !/^else\s+if\b/.test(line) ? null : {
-  headline: "Python spells this `elif`, not `else if`.",
-  howToFix: ["Write `elif` as one word, then the condition and a colon."]
-};
-var returnOutsideFunction = ({ message }) => !/'return' outside function/.test(message) ? null : {
-  headline: "`return` only works inside a function.",
-  howToFix: [
-    "To show a value at the top level of a file, use `print(...)` or write the value on a line of its own.",
-    "If this was meant to be inside a function, check that it is indented under the `def`."
-  ]
-};
-var assignedForCompared = ({ message, line }) => {
-  if (!/Maybe you meant '=='/.test(message)) return null;
-  const inAssert = /^assert\b/.test(line);
-  return {
-    headline: inAssert ? "A test compares with `==`, not `=`." : "This compares two values, so it needs `==`.",
-    howToFix: [
-      "`==` asks whether two values are equal; `=` gives a name a value."
-    ]
-  };
-};
-var assertAssigns = ({ line }) => !(/^assert\b/.test(line) && /(^|[^=!<>])=([^=]|$)/.test(line)) ? null : {
-  headline: "A test compares with `==`, not `=`.",
-  howToFix: ["`==` asks whether two values are equal; `=` gives a name a value."]
-};
-var caseCapturesEverything = ({ message }) => {
-  const capture = /name capture '(\w+)' makes remaining patterns unreachable/.exec(message);
-  if (capture === null) return null;
-  return {
-    headline: `\`case ${capture[1]}:\` needs brackets: \`case ${capture[1]}():\`.`,
-    howToFix: [
-      `Without them, \`${capture[1]}\` is a new name that matches anything, so no \`case\` after it can ever run.`,
-      `With them, \`case ${capture[1]}():\` matches only a \`${capture[1]}\`; put one name inside for each field.`
-    ]
-  };
-};
-var keywordAsName = ({ line }) => {
-  const keyword = keywordAssignedTo(line);
-  if (keyword === null) return null;
-  return {
-    headline: `\`${keyword}\` is a word Python reserves, so it cannot be a name.`,
-    howToFix: [`Pick another name, such as \`${keyword}_value\` or something describing what it holds.`]
-  };
-};
-var RULES2 = [
-  tabsAndSpaces,
-  badCharacter,
-  elseIf,
-  returnOutsideFunction,
-  assignedForCompared,
-  assertAssigns,
-  caseCapturesEverything,
-  keywordAsName
-];
-var KEYWORDS = [
-  "False",
-  "None",
-  "True",
-  "and",
-  "as",
-  "assert",
-  "async",
-  "await",
-  "break",
-  "class",
-  "continue",
-  "def",
-  "del",
-  "elif",
-  "else",
-  "except",
-  "finally",
-  "for",
-  "from",
-  "global",
-  "if",
-  "import",
-  "in",
-  "is",
-  "lambda",
-  "nonlocal",
-  "not",
-  "or",
-  "pass",
-  "raise",
-  "return",
-  "try",
-  "while",
-  "with",
-  "yield"
-];
-function keywordAssignedTo(line) {
-  const assignment = /^([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=]+)?=[^=]/.exec(line);
-  if (assignment === null) {
-    return null;
-  }
-  return KEYWORDS.includes(assignment[1]) ? assignment[1] : null;
-}
-function sentence(text) {
-  return text.trim() ? punctuated(text) : "Python could not read this line.";
-}
-
-// src/common/analyzers/syntaxErrorAnalyzer.ts
-var HANDLED2 = ["SyntaxError", "IndentationError", "TabError"];
-var syntaxErrorAnalyzer = {
-  handles: HANDLED2,
-  analyze(input) {
-    const { error } = input;
-    const offendingLine = placeOf(input).text;
-    return runtimeFindingFor(input, {
-      id: "syntax-error",
-      ...explainSyntaxError(error.errorType, error.message, offendingLine),
-      nameToken: null
-    });
-  }
-};
-
-// src/common/errors/typeCheckExplainer.ts
-var MAIN_PREFIX = "__main__.";
-var COURSE_NAME_FOR = { Row: "dict" };
-function cleanTypeName(type) {
-  const cleaned = type.split(MAIN_PREFIX).join("");
-  return COURSE_NAME_FOR[cleaned] ?? cleaned;
-}
-function describeType(type) {
-  const name = cleanTypeName(type);
-  if (name === "None" || name === "NoneType") return "`None`";
-  const friendly2 = typeWords(name, { article: true });
-  return friendly2 ? `${friendly2} (\`${name}\`)` : `\`${name}\``;
-}
-function describeTypes(types) {
-  const described2 = types.map(describeType);
-  if (described2.length === 0) return "a different type";
-  if (described2.length === 1) return described2[0];
-  return `${described2.slice(0, -1).join(", ")} or ${described2[described2.length - 1]}`;
-}
-function boolAsNumberNote(expected, actual, level) {
-  if (actual !== "bool" || expected.length === 0) return null;
-  if (!expected.some((type) => type === "int" || type === "float")) return null;
-  if (level !== void 0 && !levelRejectsBoolAsNumber(level)) return null;
-  return "At `#level beginner` and `#level intermediate`, `True` and `False` are not accepted as numbers, even though Python counts them as `1` and `0`.";
-}
-function fieldBeingReplaced(line, name) {
-  if (line === null || name === null) {
-    return null;
-  }
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const assigns = new RegExp(`^\\s*${escaped}\\s*=(?!=)(.*)$`).exec(line);
-  if (assigns === null) {
-    return null;
-  }
-  const reads = new RegExp(`\\b${escaped}\\.([A-Za-z_]\\w*)\\b(?!\\s*\\()`).exec(assigns[1]);
-  return reads === null ? null : reads[1];
-}
-function withArticle(described2) {
-  if (!described2.startsWith("`") || described2 === "`None`") {
-    return described2;
-  }
-  return `${/^`[AEIOUaeiou]/.test(described2) ? "an" : "a"} ${described2}`;
-}
-function classItself(actual) {
-  const m = actual === null ? null : /^class (.+)$/.exec(actual);
-  return m === null ? null : cleanTypeName(m[1]);
-}
-function conversionFor(expected, actual) {
-  if (expected.length !== 1 || actual === null) return null;
-  const to = expected[0];
-  const numeric = actual === "int" || actual === "float" || actual === "bool";
-  if (to === "int" && (actual === "str" || actual === "float")) return "int";
-  if (to === "float" && actual === "str") return "float";
-  if (to === "str" && numeric) return "str";
-  return null;
-}
-function membersPhrase(element) {
-  if (element.startsWith("the value for key")) return "every value in";
-  if (element.startsWith("key ")) return "every key in";
-  return "every item in";
-}
-function describeElement(element) {
-  if (element.startsWith("value of key ")) {
-    return `the value for key ${plainKey(element.slice("value of key ".length))}`;
-  }
-  if (element.startsWith("key ")) return `key ${plainKey(element.slice("key ".length))}`;
-  if (element.startsWith("[")) return "one of the values";
-  return element;
-}
-function plainKey(key) {
-  const simple = /^'([^'"\\]*)'$/.exec(key);
-  return simple ? `"${simple[1]}"` : key;
-}
-var UNFAMILIAR = { kind: "unknown", name: null, element: null, actual: null, expected: [] };
-function described(check) {
-  if (check === void 0) return UNFAMILIAR;
-  return { ...check, element: check.element === null ? null : describeElement(check.element) };
-}
-var RETURNS_NONE = [
-  "append",
-  "extend",
-  "insert",
-  "remove",
-  "sort",
-  "reverse",
-  "clear",
-  "add",
-  "discard",
-  "update"
-];
-function setFromVoidMethod(facts, name) {
-  const assigned = facts?.assigned?.[name];
-  if (assigned === void 0 || !assigned.call.includes(".")) {
-    return null;
-  }
-  const method = assigned.call.slice(assigned.call.lastIndexOf(".") + 1);
-  return RETURNS_NONE.includes(method) ? { method, line: assigned.line } : null;
-}
-function noneReturn(owner, wanted, context) {
-  const annotate = `Or annotate the return type as \`None\` if ${owner} is not meant to return anything.`;
-  const returned = context?.line != null ? /^\s*return\s+(\S.*?)\s*$/.exec(context.line) : null;
-  if (returned !== null && context !== void 0) {
-    const expression = returned[1];
-    const name = /^[A-Za-z_]\w*$/.test(expression) ? expression : null;
-    const void_ = name !== null ? setFromVoidMethod(context.facts, name) : null;
-    if (void_ !== null) {
-      return {
-        headline: `${owner} returned \`None\`, because \`${name}\` was set to the result of \`.${void_.method}(...)\` on line ${void_.line}.`,
-        howToFix: [
-          `\`.${void_.method}(...)\` changes the list in place and gives back nothing.`,
-          `Call it on its own line - \`${name}.${void_.method}(...)\` - rather than assigning its result back to \`${name}\`.`
-        ]
-      };
-    }
-    if (expression === "None") {
-      return {
-        headline: `${owner} returns \`None\` on this line, but it should return ${wanted}.`,
-        howToFix: [`Return ${wanted} here, or annotate ${owner} as returning \`None\`.`]
-      };
-    }
-    return {
-      headline: `${owner} should return ${wanted}, but \`${expression}\` is \`None\` here.`,
-      howToFix: [
-        "This line did return - what it returned was nothing.",
-        `Check where \`${expression}\` was last set.`,
-        annotate
-      ]
-    };
-  }
-  const match = context?.facts?.returnedNone?.match ?? null;
-  if (match !== null) {
-    const howToFix2 = [];
-    const missing = match.uncovered;
-    if (missing.length > 0) {
-      howToFix2.push(
-        `There is no \`case\` for ${missing.map((name) => `\`${name}\``).join(" or ")}.`
-      );
-    } else {
-      howToFix2.push(`Every possible value of \`${match.subject}\` needs a \`case\`.`);
-      if (match.hasList && !match.patterns.some((pattern) => pattern.trim() === "[]")) {
-        howToFix2.push("The empty list, `case []:`, is the one most often left out.");
-      }
-    }
-    for (const pattern of match.fixedLength) {
-      const parts = pattern.slice(1, -1).split(",").map((part) => part.trim());
-      howToFix2.push(
-        `\`case ${pattern}:\` matches a list of exactly ${parts.length} items; for a first and a rest, write \`[${parts.slice(0, -1).join(", ")}, *${parts[parts.length - 1]}]\`.`
-      );
-    }
-    return {
-      headline: `No \`case\` in ${owner} fitted \`${match.subject}\`, so nothing was returned.`,
-      howToFix: howToFix2
-    };
-  }
-  const printed = context?.facts?.returnedNone?.printed ?? null;
-  if (printed !== null) {
-    return {
-      headline: `${owner} should return ${wanted}, but it finished without returning a value.`,
-      howToFix: [
-        `Line ${printed.line} ends its branch with \`print\`: did you mean ` + (printed.expression !== null ? `\`return ${printed.expression}\`?` : "`return` instead of `print`?"),
-        "`print` shows a value on screen; `return` hands it back to whatever called the function."
-      ]
-    };
-  }
-  const howToFix = [
-    "Make sure every path through the function reaches a `return`.",
-    "An `if` with no `else` falls off the end, and Python then returns `None`."
-  ];
-  howToFix.push(annotate);
-  return {
-    headline: `${owner} should return ${wanted}, but it finished without returning a value.`,
-    howToFix
-  };
-}
-function explainTypeCheckError(message, functionName, level, context) {
-  const parsed = described(context?.facts?.check);
-  const c = {
-    message,
-    parsed,
-    functionName,
-    level,
-    context,
-    wanted: describeTypes(parsed.expected),
-    owner: functionName ? `\`${functionName}\`` : "this function",
-    named: parsed.name ? `\`${parsed.name}\`` : "a value",
-    convert: conversionFor(parsed.expected, parsed.actual),
-    boolNote: boolAsNumberNote(parsed.expected, parsed.actual, parsed.level ?? level),
-    annotation: parsed.expected.length === 1 ? cleanTypeName(parsed.expected[0]) : null
-  };
-  return classGiven(c) ?? BY_KIND[parsed.kind](c);
-}
-var BY_KIND = {
-  argument: explainArgument,
-  field: explainField,
-  return: explainReturn,
-  variable: explainVariable,
-  unknown: explainUnfamiliar
-};
-function classGiven({ parsed, owner, named }) {
-  const classPassed = classItself(parsed.actual);
-  if (classPassed === null || parsed.element !== null) {
-    return null;
-  }
-  const where = parsed.kind === "return" ? `${owner} returned` : parsed.kind === "variable" ? `${named} was given` : `${owner} was given`;
-  return {
-    headline: `${where} the class \`${classPassed}\` itself, not one made from it.`,
-    howToFix: [
-      `\`${classPassed}\` on its own is the blueprint; \`${classPassed}(...)\` makes one.`,
-      `Add the brackets and the values for its fields: \`${classPassed}(...)\`.`
-    ]
-  };
-}
-function explainArgument({
-  parsed,
-  owner,
-  named,
-  wanted,
-  convert,
-  boolNote,
-  annotation,
-  context
-}) {
-  if (parsed.element) {
-    const value = context?.facts?.elementValue;
-    const is = value !== void 0 ? ` is ${value}` : " is not";
-    return {
-      headline: `${owner} expects ${membersPhrase(parsed.element)} ${named} to be ${wanted}, but ${parsed.element}${is}.`,
-      howToFix: [
-        `Look at ${parsed.element} of the ${parsed.actual ?? "value"} you passed for ${named}.`,
-        "Every one has to match the annotation, not just the first."
-      ]
-    };
-  }
-  const got = parsed.actual ? `, but got ${describeType(parsed.actual)}` : "";
-  const supplied = context?.calledBy ?? null;
-  if (supplied !== null) {
-    const howToFix2 = supplied === "reactor" ? [
-      `The reactor calls ${owner} with its state: the \`init\` value to start with, then whatever the handlers return. So ${named} is the reactor's state, not a value from this line.`
-    ] : [
-      `${FUNCTION_TAKERS[supplied]?.calls ?? `\`${supplied}\` calls ${owner} for you`}, so ${named} is whatever it hands over - not a value from this line.`
-    ];
-    if (annotation !== null && parsed.actual !== null) {
-      howToFix2.push(
-        `Annotate ${named} as \`${cleanTypeName(parsed.actual)}\` in ${owner}, or change what ${supplied === "reactor" ? "the reactor" : `\`${supplied}\``} is given so it hands over ${wanted}.`
-      );
-    }
-    if (boolNote) howToFix2.push(boolNote);
-    return { headline: `${owner} expects ${named} to be ${wanted}${got}.`, howToFix: howToFix2 };
-  }
-  const howToFix = [`Check the value you passed for ${named} on this line.`];
-  if (boolNote) howToFix.push(boolNote);
-  if (convert) {
-    howToFix.push(`If it should be ${wanted}, convert it with \`${convert}(...)\`.`);
-  }
-  if (annotation && parsed.actual) {
-    howToFix.push(
-      `Or, if ${named} really should be ${describeType(parsed.actual)}, change its annotation in ${owner} from \`${annotation}\` to \`${cleanTypeName(parsed.actual)}\`.`
-    );
-  }
-  return {
-    headline: `${owner} expects ${named} to be ${wanted}${got}.`,
-    howToFix
-  };
-}
-function explainField({
-  parsed,
-  wanted,
-  convert,
-  annotation,
-  context
-}) {
-  const owner = parsed.owner ?? "this class";
-  const swappedWith = context?.facts?.swappedWith;
-  if (swappedWith !== void 0) {
-    return {
-      headline: `The values for \`${parsed.name}\` and \`${swappedWith}\` of \`${owner}\` look swapped.`,
-      howToFix: [
-        `\`${parsed.name}\` got \`${parsed.value ?? "?"}\`, which fits \`${swappedWith}\` - and the other way round.`,
-        `Give the values in the order the fields are written in \`class ${owner}\`.`
-      ]
-    };
-  }
-  const got = parsed.value !== void 0 ? `\`${parsed.value}\`` : parsed.actual ? describeType(parsed.actual) : "something else";
-  return {
-    headline: `The \`${parsed.name}\` field of \`${owner}\` should be ${wanted}, but got ${got}.`,
-    howToFix: [
-      `Check the values given to \`${owner}(...)\`, in the order its fields are written.`,
-      ...convert !== null ? [`If it should be ${wanted}, convert it with \`${convert}(...)\`.`] : [],
-      ...annotation !== null && parsed.actual !== null ? [
-        `Or change the field's annotation from \`${annotation}\` to \`${cleanTypeName(parsed.actual)}\`.`
-      ] : []
-    ]
-  };
-}
-function explainReturn({
-  parsed,
-  owner,
-  wanted,
-  convert,
-  boolNote,
-  annotation,
-  context
-}) {
-  if (parsed.actual === "None" || parsed.actual === "NoneType") {
-    return noneReturn(owner, wanted, context);
-  }
-  if (parsed.element) {
-    const value = context?.facts?.elementValue;
-    const element = describeElement(parsed.element);
-    const container = parsed.actual ? cleanTypeName(parsed.actual) : "value";
-    const howToFix2 = [
-      `Look at ${element} of the ${container} this line returns: every one has to match the annotation, not just the first.`
-    ];
-    const elementType = context?.facts?.elementType;
-    const written = parsed.annotation ?? null;
-    if (written !== null && annotation !== null && elementType !== void 0) {
-      const type = new RegExp(`\\b${annotation.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
-      if ((written.match(type) ?? []).length === 1) {
-        howToFix2.push(
-          `Or, if that is what it should hold, change the annotation from \`${written}\` to \`${written.replace(type, elementType)}\`.`
-        );
-      }
-    }
-    return {
-      headline: `${owner} says it returns ${written !== null ? `\`${written}\`` : `a ${container}`}, with ${membersPhrase(element)} it ${wanted}, but ${element}${value !== void 0 ? ` is ${value}` : " is not"}.`,
-      howToFix: howToFix2
-    };
-  }
-  const got = parsed.actual ? describeType(parsed.actual) : "something else";
-  const howToFix = [];
-  const wantsNone = parsed.expected.length === 1 && /^(None|NoneType)$/.test(parsed.expected[0]);
-  if (wantsNone) {
-    howToFix.push("Use a bare `return`, or drop the `return` entirely.");
-  } else if (convert) {
-    howToFix.push(`Convert the returned value with \`${convert}(...)\`.`);
-  } else {
-    howToFix.push(`Return ${withArticle(wanted)} from this line.`);
-  }
-  if (boolNote) howToFix.push(boolNote);
-  if (annotation && parsed.actual) {
-    howToFix.push(
-      `Or change ${owner}'s return annotation from \`${annotation}\` to \`${cleanTypeName(parsed.actual)}\`.`
-    );
-  }
-  return {
-    headline: `${owner} says it returns ${wanted}, but this line returns ${got}.`,
-    howToFix
-  };
-}
-function explainVariable({
-  parsed,
-  named,
-  wanted,
-  convert,
-  boolNote,
-  annotation,
-  context
-}) {
-  if (parsed.element) {
-    return {
-      headline: `${named} is annotated so ${membersPhrase(parsed.element)} it is ${wanted}, but ${parsed.element} is not.`,
-      howToFix: [`Look at ${parsed.element} of the value assigned to ${named}.`]
-    };
-  }
-  const got = parsed.actual ? describeType(parsed.actual) : "a different type";
-  const field = fieldBeingReplaced(context?.line ?? null, parsed.name);
-  if (field !== null && parsed.name !== null) {
-    const rhs = (/=\s*(.+)$/.exec(context?.line ?? "") ?? [, "..."])[1].trim();
-    return {
-      headline: `${named} is annotated as ${wanted}, but ${got} was assigned here.`,
-      howToFix: [
-        `To change the \`${field}\` field of ${named}, assign to the field: \`${parsed.name}.${field} = ${rhs}\`.`,
-        `\`${parsed.name} = ...\` replaces the whole ${annotation !== null ? `\`${annotation}\`` : "value"}, field and all.`
-      ]
-    };
-  }
-  const howToFix = [`Assign ${withArticle(wanted)} to ${named}.`];
-  if (boolNote) howToFix.push(boolNote);
-  if (convert) {
-    howToFix.push(`You can convert the value with \`${convert}(...)\`.`);
-  }
-  if (annotation && parsed.actual) {
-    howToFix.push(
-      `Or change ${named}'s annotation from \`${annotation}\` to \`${cleanTypeName(parsed.actual)}\`.`
-    );
-  }
-  return {
-    headline: `${named} is annotated as ${wanted}, but ${got} was assigned here.`,
-    howToFix
-  };
-}
-function explainUnfamiliar({ message }) {
-  return {
-    headline: "A value does not match the type annotation written for it.",
-    howToFix: [
-      message.split(/\r?\n/)[0].trim(),
-      "Either pass a value of the annotated type, or change the annotation."
-    ]
-  };
-}
-
-// src/common/analyzers/typeCheckAnalyzer.ts
-var typeCheckAnalyzer = {
-  handles: ["TypeCheckError"],
-  analyze(input) {
-    const { error, fileName, level } = input;
-    const check = error.facts.check;
-    const frames = userFrames(error);
-    const innermost = frames.length > 0 ? frames[frames.length - 1] : null;
-    const blamed = check?.kind === "argument" && frames.length >= 2 ? frames[frames.length - 2] : innermost;
-    const explanation = explainTypeCheckError(
-      error.message,
-      innermost ? innermost.functionName : null,
-      level,
-      // The line the check fired on, which for a return is the `return`
-      // itself - or, when the function ran off its end, is not one.
-      {
-        line: frameText(input, innermost),
-        calledBy: libraryCaller(error.frames),
-        facts: error.facts
-      }
-    );
-    return runtimeFindingFor(input, {
-      id: "type-check",
-      // Not a real Python exception name; "TypeCheckError" means nothing to
-      // a student, and "TypeError" would name a different Python error.
-      errorType: "TypeMismatch",
-      ...explanation,
-      fileName: blamed ? blamed.fileName : fileName,
-      lineNumber: blamed ? blamed.line : error.lineNumber,
-      column: null,
-      nameToken: check?.name ?? null
-    });
-  }
-};
-
-// src/common/analyzers/registry.ts
-var analyzers = [
-  nameErrorAnalyzer,
-  typeCheckAnalyzer,
-  syntaxErrorAnalyzer,
-  checksFailedAnalyzer,
-  // Last before the catch-all: it only reaches an error no analyzer
-  // above recognised, and claims it only if it can say something better
-  // than Python did.
-  stockMessageAnalyzer
-];
-function findRuntimeFinding(source, fileName, level, error) {
-  for (const analyzer of analyzers) {
-    if (!analyzer.handles.includes(error.errorType)) {
-      continue;
-    }
-    const finding = analyzer.analyze({ source, fileName, level, error });
-    if (finding) {
-      return finding;
-    }
-  }
-  return analyzeRuntimeError({ source, fileName, level, error });
-}
-
-// src/common/analyzers/runtimeFinding.ts
-function findingForErrorEvent(event, source, fileName, level) {
-  return findRuntimeFinding(source, fileName, level, event.error);
-}
-function explainTestReport(event, source, fileName, level) {
-  return {
-    ...event,
-    tests: event.tests.map(
-      ({ error, ...test }) => error ? { ...test, finding: serializeFinding(findRuntimeFinding(source, fileName, level, error)) } : test
-    )
-  };
-}
-
-// src/common/examplarSource.ts
-var MAX_BUNDLE_BYTES = 4 * 1024 * 1024;
-var DIRECTIVE_RE = /^#\s*examplar\s+(\S+)\s*$/;
-function parseExamplarDirective(source) {
-  const hits = [];
-  const lines = source.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const match = DIRECTIVE_RE.exec(lines[i].trim());
-    if (match) {
-      hits.push({ url: match[1], line: i + 1 });
-    }
-  }
-  if (hits.length === 0) {
-    return { kind: "none" };
-  }
-  if (hits.length > 1) {
-    return {
-      kind: "error",
-      line: hits[1].line,
-      message: `there is more than one \`#examplar\` line (lines ${hits.map((h) => h.line).join(" and ")}). Keep the one you want.`
-    };
-  }
-  const { url, line } = hits[0];
-  const problem = validateBundleUrl(url);
-  return problem ? { kind: "error", message: problem, line } : { kind: "found", url, line };
-}
-function validateBundleUrl(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return `\`${url}\` is not a URL.`;
-  }
-  if (parsed.protocol === "https:") {
-    return null;
-  }
-  if (parsed.protocol === "http:") {
-    const local = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
-    return local ? null : `\`${url}\` must use https (plain http is only allowed for localhost).`;
-  }
-  return `\`${url}\` must be an https address.`;
-}
-async function loadBundle(url, store, fetchImpl = globalThis.fetch) {
-  const cached = await store.read(url).catch(() => void 0);
-  let response;
-  try {
-    response = await fetchImpl(url, {
-      headers: cached?.etag ? { "If-None-Match": cached.etag } : {}
-    });
-  } catch (err) {
-    const why = errorText(err);
-    return cached ? { json: cached.json, fromCache: true, note: `could not reach ${url} (${why}); using the cached copy` } : { fromCache: false, error: `could not reach ${url} (${why}), and nothing is cached` };
-  }
-  if (response.status === 304 && cached) {
-    return { json: cached.json, fromCache: true };
-  }
-  if (!response.ok) {
-    return cached ? {
-      json: cached.json,
-      fromCache: true,
-      note: `${url} returned ${response.status}; using the cached copy`
-    } : { fromCache: false, error: `${url} returned ${response.status}` };
-  }
-  const json = await response.text();
-  if (json.length > MAX_BUNDLE_BYTES) {
-    return cached ? { json: cached.json, fromCache: true, note: `${url} is unexpectedly large; using the cached copy` } : {
-      fromCache: false,
-      error: `${url} is ${json.length} bytes, past the ${MAX_BUNDLE_BYTES}-byte limit`
-    };
-  }
-  if (!looksLikeBundle(json)) {
-    return cached ? { json: cached.json, fromCache: true, note: `${url} did not return a bundle; using the cached copy` } : { fromCache: false, error: `${url} did not return an Examplar bundle` };
-  }
-  const etag = response.headers.get("etag") ?? void 0;
-  try {
-    await store.write(url, { json, etag });
-  } catch (err) {
-    return { json, fromCache: false, note: `could not keep a copy for offline use (${errorText(err)})` };
-  }
-  return { json, fromCache: false };
-}
-function looksLikeBundle(json) {
-  try {
-    const bundle = JSON.parse(json);
-    return typeof bundle === "object" && bundle !== null && "examplar" in bundle && Array.isArray(bundle.wheats) && Array.isArray(bundle.chaffs);
-  } catch {
-    return false;
-  }
-}
-
-// src/common/runtimeErrors.ts
-var PythonLostError = class extends Error {
-  constructor() {
-    super("Python stopped completely.");
-    this.name = "PythonLostError";
-  }
-};
-var StoppedError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "StoppedError";
+  async handleStdinRequest(request) {
+    this.stdinRequest = request;
+    let bytes = this.stdinCarry;
+    if (bytes.length === 0) {
+      bytes = await this.nextStdin();
+      if (this.stdinRequest !== request) {
+        if (bytes !== null && this.stdinRequest === null) {
+          this.stdinCarry = concatBytes(this.stdinCarry, bytes);
+        }
+        return;
+      }
+    }
+    this.stdinRequest = null;
+    if (!this.stdinBuffer) {
+      return;
+    }
+    const given = writeStdin(this.stdinBuffer, request, bytes);
+    if (bytes === null) {
+      this.stdinCarry = new Uint8Array(0);
+    } else {
+      this.stdinCarry = bytes.subarray(Math.max(given, 0));
+    }
   }
 };
+function concatBytes(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a);
+  out.set(b, a.length);
+  return out;
+}
 
-// src/common/examplarPhase.ts
+// src/run/examplar.ts
 async function runExamplarStep(runtime, bundles, host, code, fileName) {
   const bundle = await fetchBundle(bundles, host, code);
   if (bundle === null) {
@@ -3211,16 +995,13 @@ function timedOutProblem(stuck) {
   return `\`${stuck.test}\` ran for more than ${stuck.seconds} seconds against ${against}, so the check stopped. ` + (stuck.kind === "wheat" ? "A test that runs that long is usually stuck in a loop." : "That implementation may never finish on what this test gives it; tell your course staff.");
 }
 
-// src/common/packages.ts
-var PANDAS_METHOD_RE = /\.\s*to_pandas\s*\(/;
-var MAY_IMPORT_RE = /\bimport\b|__import__/;
+// src/run/packages.ts
+var MAY_NEED_PACKAGES_RE = /\bimport\b|__import__|\.\s*to_pandas\s*\(/;
 function needsPackages(code, siblings = []) {
-  return [code, ...siblings.map((sibling) => sibling.text)].some(
-    (text) => MAY_IMPORT_RE.test(text) || PANDAS_METHOD_RE.test(text)
-  );
+  return [code, ...siblings.map((sibling) => sibling.text)].some((text) => MAY_NEED_PACKAGES_RE.test(text));
 }
 
-// src/common/workspaceFilePolicy.ts
+// src/core/files.ts
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 var MAX_TOTAL_BYTES = 8 * 1024 * 1024;
 var MAX_FILES = 100;
@@ -3424,7 +1205,7 @@ function errorCode(err) {
   return message.split("\n")[0].slice(0, 80);
 }
 
-// src/common/runPlan.ts
+// src/run/plan.ts
 var STOPPED = {
   beforeStart: "Stopped before the program started. Nothing was run.",
   checking: "Stopped while checking your tests. Your own tests and the program were not run.",
@@ -3467,7 +1248,7 @@ async function runFilePlan(runtime, host, plan) {
     }
     host.status("Running...");
     starting();
-    const onEvent = tally.counting(programEvents(host, code, fileName, level));
+    const onEvent = tally.counting(programEvents(host, fileName, level));
     const program = () => runtime.runFile({ code, fileName, sessionKey, level, withTests }, onEvent);
     await (host.aroundProgram ? host.aroundProgram(program) : program());
     if (withTests) {
@@ -3530,13 +1311,12 @@ async function staticChecks(runtime, host, code, fileName, level, sessionKey) {
   host.status("Checking...");
   let findings;
   try {
-    const raw = await runtime.staticAnalyze({
+    findings = await runtime.staticAnalyze({
       code,
       fileName,
       level,
       ...input ? { sessionKey } : {}
     });
-    findings = enrichStaticFindings(raw, level, fileName);
   } catch (err) {
     if (err instanceof StoppedError) {
       host.say(input ? STOPPED.input : STOPPED.beforeStart, "problem");
@@ -3671,12 +1451,12 @@ async function testsToRun(runtime, host, code) {
     return false;
   }
 }
-function programEvents(host, code, fileName, level) {
+function programEvents(host, fileName, level) {
   return (event) => {
     if (event.kind === "error") {
-      host.runtimeFinding(findingForErrorEvent(event, code, fileName, level));
+      host.runtimeFinding(findRuntimeFinding(fileName, level, event.error));
     } else if (event.kind === "testReport") {
-      host.event(explainTestReport(event, code, fileName, level));
+      host.event(explainTestReport(event, fileName, level));
     } else {
       host.event(event);
     }
@@ -4134,722 +1914,200 @@ async function verify(runtime, view, bundle, testsPath) {
   }
   for (const chaff of result.chaffs ?? []) {
     const where = `chaff ${chaff.targets}/${chaff.id}`;
-    if (!chaff.loaded) {
-      bad += 1;
-      view.problem(`  BAD   ${where}: ${chaff.errorMessage}`);
-      continue;
-    }
-    if (caught(chaff)) {
-      const by = Object.entries(chaff.tests).filter(([, t]) => t.outcome !== "pass").map(([name]) => name);
-      view.note(`  ok    ${where}: caught by ${by.join(", ")}`);
-      continue;
-    }
-    bad += 1;
-    view.problem(`  BAD   ${where}: no test catches it - it would never count`);
-  }
-  const attributed = Object.values(result.attribution ?? {});
-  for (const name of result.chaffsSkipped ?? []) {
-    if (attributed.some((names) => names.includes(name))) {
-      view.problem(`  ---   ${name} chaffs not checked: its tests have to pass first`);
-      continue;
-    }
-    bad += 1;
-    view.problem(
-      `  BAD   your own suite has no tests for ${name}, so its chaffs are unproven`
-    );
-  }
-  if (bad > 0) {
-    view.problem(`pll: ${bad} problem(s) with this bundle; not written.`);
-    return EXIT.testsFailed;
-  }
-  view.problem("verified.");
-  return EXIT.ok;
-}
-
-// src/cli/runtime.ts
-var fs6 = __toESM(require("node:fs"));
-var path6 = __toESM(require("node:path"));
-
-// src/desktop/pyodideRuntime.ts
-var fs5 = __toESM(require("node:fs"));
-var path5 = __toESM(require("node:path"));
-var import_node_worker_threads = require("node:worker_threads");
-
-// src/common/fromPython.ts
-function camelName(name) {
-  return name.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-function camelized(record) {
-  return Object.fromEntries(
-    Object.entries(record).map(([name, value]) => [camelName(name), value])
-  );
-}
-function deliverRunResult(result, onEvent, fileName) {
-  if (result.displays) {
-    for (const display of result.displays) {
-      deliverDisplay(display, onEvent, fileName);
-    }
-  }
-  if (result.result_repr !== null && result.result_repr !== void 0) {
-    onEvent({ kind: "result", repr: result.result_repr });
-  }
-  const error = result.ok ? null : pythonErrorFrom(result);
-  if (error !== null) {
-    onEvent({ kind: "error", error, fileName });
-  }
-  if (result.tests) {
-    onEvent(testReportFrom(result.tests, fileName));
-  }
-  const exitCode = result.exit_code;
-  onEvent({
-    kind: "done",
-    ...typeof exitCode === "number" ? { exitCode } : {},
-    ...result.stopped ? { stopped: true } : {}
-  });
-}
-function deliverDisplay(display, onEvent, fileName) {
-  switch (display.type) {
-    case "stdout":
-      onEvent({ kind: "stdout", text: display.text });
-      break;
-    case "stderr":
-      onEvent({ kind: "stderr", text: display.text });
-      break;
-    case "image":
-      onEvent({
-        kind: "image",
-        svg: display.data,
-        width: display.width,
-        height: display.height,
-        source: fileName
-      });
-      break;
-    case "reactor":
-      onEvent({
-        kind: "reactor",
-        id: display.id,
-        title: display.title,
-        tickRate: display.tick_rate,
-        ticking: display.ticking,
-        wantsKeys: display.wants_keys,
-        wantsMouse: display.wants_mouse,
-        register: display.register,
-        frame: display.frame,
-        index: display.index,
-        length: display.length,
-        atEnd: display.at_end,
-        stopped: display.stopped,
-        valueRepr: display.value_repr
-      });
-      break;
-    case "table":
-      onEvent({
-        kind: "table",
-        columns: display.columns,
-        rows: display.rows,
-        rowCount: display.row_count,
-        shownCount: display.shown_count,
-        truncated: display.truncated,
-        numeric: display.numeric,
-        csv: display.csv,
-        csvRows: display.csv_rows,
-        source: fileName
-      });
-      break;
-  }
-}
-function adaptTestCase(row) {
-  return {
-    name: String(row.name ?? ""),
-    outcome: String(row.outcome ?? "failed"),
-    lineNumber: typeof row.line_number === "number" ? row.line_number : null,
-    message: row.message ?? null,
-    stdout: row.stdout ?? null,
-    error: pythonErrorFrom(row.error)
-  };
-}
-function testReportFrom(result, fileName) {
-  return {
-    kind: "testReport",
-    fileName,
-    passed: result.passed ?? 0,
-    failed: result.failed ?? 0,
-    skipped: result.skipped ?? 0,
-    errors: result.errors ?? 0,
-    tests: Array.isArray(result.tests) ? result.tests.map(adaptTestCase) : [],
-    ...result.stopped ? { stopped: true, stoppedIn: result.stopped_in ?? null } : {}
-  };
-}
-function pythonErrorFrom(wire) {
-  if (!wire || !wire.error_type) {
-    return null;
-  }
-  const facts = wire.error_facts ?? {};
-  return {
-    errorType: wire.error_type,
-    message: wire.error_message ?? "",
-    traceback: wire.traceback ?? "",
-    fileName: wire.error_file ?? null,
-    lineNumber: numberOrNull(wire.line_number),
-    column: numberOrNull(wire.column),
-    text: wire.error_text ?? null,
-    nameToken: facts.name ?? null,
-    frames: (wire.error_frames ?? []).map(frameFrom),
-    facts: {
-      name: facts.name ?? void 0,
-      sequence: facts.sequence ?? void 0,
-      length: numberOrNull(facts.length) ?? void 0,
-      elementValue: facts.element_value ?? void 0,
-      elementType: facts.element_type ?? void 0,
-      swappedWith: facts.swapped_with ?? void 0,
-      check: facts.check ? typeCheckFrom(facts.check) : void 0,
-      definitions: facts.definitions ?? void 0,
-      assigned: facts.assigned ?? void 0,
-      returnedNone: facts.returned_none ? returnedNoneFrom(facts.returned_none) : void 0,
-      stop: facts.stop === true ? true : void 0,
-      module: facts.module ? {
-        name: facts.module.name,
-        kind: facts.module.kind,
-        close: facts.module.close ?? null,
-        why: facts.module.why ?? null,
-        package: facts.module.package ?? null
-      } : void 0,
-      checks: facts.checks ? {
-        file: facts.checks.file,
-        level: isLevel(facts.checks.level) ? facts.checks.level : DEFAULT_LEVEL,
-        findings: staticFindingsFrom(facts.checks.findings),
-        headerProblem: facts.checks.header_problem ?? null
-      } : void 0
-    }
-  };
-}
-function typeCheckFrom(check) {
-  return {
-    kind: check.kind,
-    name: check.name ?? null,
-    element: check.element ?? null,
-    actual: check.actual ?? null,
-    expected: check.expected ?? [],
-    owner: check.owner ?? void 0,
-    value: check.value ?? void 0,
-    level: check.level && isLevel(check.level) ? check.level : void 0,
-    annotation: check.annotation ?? null
-  };
-}
-function returnedNoneFrom(wire) {
-  const match = wire.match;
-  return {
-    match: match ? {
-      subject: match.subject,
-      patterns: match.patterns ?? [],
-      fixedLength: match.fixed_length ?? [],
-      hasList: match.has_list === true,
-      uncovered: match.uncovered ?? []
-    } : null,
-    printed: wire.printed ?? null
-  };
-}
-function frameFrom(frame) {
-  return {
-    fileName: frame.file,
-    line: frame.line,
-    column: numberOrNull(frame.column),
-    functionName: frame.function ?? null,
-    user: frame.user === true,
-    text: frame.text ?? null,
-    parameters: frame.parameters ?? null
-  };
-}
-function numberOrNull(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function replCheckFrom(raw) {
-  return {
-    status: raw.status,
-    errorType: raw.error_type ?? void 0,
-    message: raw.message ?? void 0,
-    lineNumber: raw.lineno ?? void 0,
-    offset: raw.offset ?? void 0
-  };
-}
-function staticFindingsFrom(raw) {
-  return (raw ?? []).map((finding) => camelized(finding));
-}
-function examplarOutcomeFrom(raw) {
-  return {
-    ...camelized(raw),
-    // `tests` and `attribution` are keyed by test name: their keys are the
-    // student's, and stay as they are.
-    wheats: raw.wheats?.map((impl) => camelized(impl)),
-    chaffs: raw.chaffs?.map((impl) => camelized(impl))
-  };
-}
-function reactorStepFrom(raw) {
-  if (raw.gone) {
-    return { kind: "gone" };
-  }
-  if (!raw.ok || !raw.frame) {
-    return { kind: "raised", error: pythonErrorFrom(raw) ?? pythonErrorFrom({ error_type: "Error" }) };
-  }
-  return {
-    kind: "frame",
-    frame: raw.frame,
-    index: raw.index ?? 0,
-    length: raw.length ?? 1,
-    atEnd: raw.at_end === true,
-    stopped: raw.stopped === true,
-    valueRepr: raw.value_repr ?? "",
-    messages: raw.messages ?? []
-  };
-}
-
-// src/common/interruptBuffer.ts
-var INTERRUPT_SAB_BYTES = 2;
-var INTERRUPT_SIGINT = 2;
-var INTERRUPT_ACK_INDEX = 1;
-var INTERRUPT_RETRY_MS = 15;
-var INTERRUPT_RETRY_LIMIT_MS = 1e4;
-function tryCreateInterruptBuffer() {
-  try {
-    return new SharedArrayBuffer(INTERRUPT_SAB_BYTES);
-  } catch {
-    return null;
-  }
-}
-function requestInterrupt(sab, stillRunning, retryMs = INTERRUPT_RETRY_MS, limitMs = INTERRUPT_RETRY_LIMIT_MS) {
-  const view = new Uint8Array(sab);
-  if (view.length > INTERRUPT_ACK_INDEX) {
-    Atomics.store(view, INTERRUPT_ACK_INDEX, 0);
-  }
-  Atomics.store(view, 0, INTERRUPT_SIGINT);
-  if (view.length <= INTERRUPT_ACK_INDEX) {
-    return;
-  }
-  const deadline = Date.now() + limitMs;
-  const retry = () => {
-    if (Atomics.load(view, INTERRUPT_ACK_INDEX) !== 0 || !stillRunning() || Date.now() > deadline) {
-      return;
-    }
-    if (Atomics.load(view, 0) === 0) {
-      Atomics.store(view, 0, INTERRUPT_SIGINT);
-    }
-    setTimeout(retry, retryMs);
-  };
-  setTimeout(retry, retryMs);
-}
-
-// src/common/stdinBuffer.ts
-var STDIN_SAB_BYTES = 64 * 1024;
-var STDIN_STATE_INDEX = 0;
-var STDIN_LENGTH_INDEX = 1;
-var STDIN_REQUEST_INDEX = 2;
-var STDIN_PAYLOAD_OFFSET = 16;
-var STDIN_STATE_WAITING = 0;
-var STDIN_STATE_DATA = 1;
-var STDIN_STATE_EOF = 2;
-var STDIN_STATE_INTERRUPTED = 3;
-function tryCreateStdinBuffer() {
-  try {
-    return new SharedArrayBuffer(STDIN_SAB_BYTES);
-  } catch {
-    return null;
-  }
-}
-function writeStdin(sab, request, bytes) {
-  const state = new Int32Array(sab);
-  if (Atomics.load(state, STDIN_REQUEST_INDEX) !== request || Atomics.load(state, STDIN_STATE_INDEX) !== STDIN_STATE_WAITING) {
-    return -1;
-  }
-  let n = 0;
-  if (bytes !== null) {
-    n = Math.min(bytes.length, sab.byteLength - STDIN_PAYLOAD_OFFSET);
-    new Uint8Array(sab, STDIN_PAYLOAD_OFFSET).set(bytes.subarray(0, n));
-    Atomics.store(state, STDIN_LENGTH_INDEX, n);
-  }
-  const answer = bytes === null ? STDIN_STATE_EOF : STDIN_STATE_DATA;
-  const was = Atomics.compareExchange(state, STDIN_STATE_INDEX, STDIN_STATE_WAITING, answer);
-  if (was !== STDIN_STATE_WAITING) {
-    return -1;
-  }
-  Atomics.notify(state, STDIN_STATE_INDEX);
-  return n;
-}
-function interruptStdin(sab) {
-  const state = new Int32Array(sab);
-  if (Atomics.compareExchange(state, STDIN_STATE_INDEX, STDIN_STATE_WAITING, STDIN_STATE_INTERRUPTED) === STDIN_STATE_WAITING) {
-    Atomics.notify(state, STDIN_STATE_INDEX);
-  }
-}
-
-// src/common/workerProtocol.ts
-var REPLY_TO = {
-  init: "ready",
-  runFile: "result",
-  replEval: "result",
-  checkSyntax: "syntax",
-  loadPackages: "packagesReady",
-  hasTests: "hasTests",
-  loadPytest: "pytestReady",
-  staticAnalyze: "static",
-  mountWorkspace: "workspaceReady",
-  collectWorkspace: "workspaceFiles",
-  reactorStep: "reactorFrame",
-  reactorSeek: "reactorFrame",
-  reactorDispose: "reactorDisposed",
-  endSession: "sessionEnded",
-  examplarBuild: "examplarBuilt",
-  examplarRun: "examplarRan"
-};
-
-// src/common/workerRuntime.ts
-var NOT_RUNNING = "Python is not running.";
-var WorkerPythonRuntime = class {
-  worker = null;
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  initPromise = null;
-  stdinBuffer = null;
-  interruptBuffer = null;
-  stdinHandler = null;
-  /** The stdin request being answered, or null; a Stop ends it. */
-  stdinRequest = null;
-  /** Stdin read but not yet given: what did not fit, or what came after a Stop. */
-  stdinCarry = new Uint8Array(0);
-  /** The handler's answer being waited for, which the next request shares. */
-  stdinNext = null;
-  packageNoteHandler = null;
-  pythonLostHandler = null;
-  /**
-   * Longest Python may take to start, or null for no limit. Pyodide that
-   * fails to load can report it and never settle; a host with no one to
-   * press Stop - an autograder - sets one.
-   */
-  startTimeoutMs = null;
-  /** Where downloaded packages are kept, if not beside Pyodide's assets. */
-  resolvePackageCacheDir(_indexUrl) {
-    return null;
-  }
-  /** Start the worker, once - or again, if the last attempt failed. */
-  async initialize() {
-    if (!this.initPromise) {
-      this.initPromise = this.doInitialize().catch((err) => {
-        this.initPromise = null;
-        this.worker?.terminate();
-        this.worker = null;
-        throw err;
-      });
-    }
-    await this.initPromise;
-  }
-  async doInitialize() {
-    const indexUrl = this.resolveIndexUrl();
-    const worker = this.spawn({
-      onMessage: (msg) => this.handleMessage(msg, worker),
-      onError: (err) => this.rejectAllPending(err),
-      onExit: () => this.pythonLost(worker)
-    });
-    this.worker = worker;
-    this.stdinBuffer = tryCreateStdinBuffer();
-    this.interruptBuffer = tryCreateInterruptBuffer();
-    const packageCacheDir = this.resolvePackageCacheDir(indexUrl);
-    const started = this.request({
-      type: "init",
-      indexUrl,
-      ...packageCacheDir ? { packageCacheDir } : {},
-      ...this.stdinBuffer ? { stdinBuffer: this.stdinBuffer } : {},
-      ...this.interruptBuffer ? { interruptBuffer: this.interruptBuffer } : {}
-    });
-    const limit = this.startTimeoutMs;
-    if (limit === null) {
-      await started;
-      return;
-    }
-    let timer;
-    const timedOut = new Promise((_, reject) => {
-      timer = setTimeout(
-        () => reject(new Error(`Python did not start within ${Math.round(limit / 1e3)} seconds`)),
-        limit
-      );
-    });
-    try {
-      await Promise.race([started, timedOut]);
-    } finally {
-      clearTimeout(timer);
+    if (!chaff.loaded) {
+      bad += 1;
+      view.problem(`  BAD   ${where}: ${chaff.errorMessage}`);
+      continue;
+    }
+    if (caught(chaff)) {
+      const by = Object.entries(chaff.tests).filter(([, t]) => t.outcome !== "pass").map(([name]) => name);
+      view.note(`  ok    ${where}: caught by ${by.join(", ")}`);
+      continue;
+    }
+    bad += 1;
+    view.problem(`  BAD   ${where}: no test catches it - it would never count`);
+  }
+  const attributed = Object.values(result.attribution ?? {});
+  for (const name of result.chaffsSkipped ?? []) {
+    if (attributed.some((names) => names.includes(name))) {
+      view.problem(`  ---   ${name} chaffs not checked: its tests have to pass first`);
+      continue;
     }
+    bad += 1;
+    view.problem(
+      `  BAD   your own suite has no tests for ${name}, so its chaffs are unproven`
+    );
+  }
+  if (bad > 0) {
+    view.problem(`pll: ${bad} problem(s) with this bundle; not written.`);
+    return EXIT.testsFailed;
   }
+  view.problem("verified.");
+  return EXIT.ok;
+}
+
+// src/cli/runtime.ts
+var fs6 = __toESM(require("node:fs"));
+var path6 = __toESM(require("node:path"));
+
+// src/desktop/pyodideRuntime.ts
+var fs5 = __toESM(require("node:fs"));
+var path5 = __toESM(require("node:path"));
+var import_node_worker_threads = require("node:worker_threads");
+
+// src/run/python.ts
+var Python = class extends WorkerConnection {
+  /** Run a file: its output, errors and test report arrive through `onEvent`, then `done`. */
   async runFile(request, onEvent) {
-    await this.initialize();
-    const live = { onEvent, fileName: request.fileName };
-    const { result } = await this.request({ type: "runFile", ...request }, live);
-    deliverRunResult(result, onEvent, request.fileName);
+    const { code, fileName, sessionKey, level = DEFAULT_LEVEL, withTests = false } = request;
+    const live = { onEvent, fileName };
+    const result = await this.call("_pll_run_file", [code, fileName, sessionKey, level, withTests], live);
+    deliverRunResult(result, onEvent, fileName);
   }
+  /** Evaluate a prompt line against its file's session. */
   async replEval(request, onEvent) {
-    await this.initialize();
-    const { result } = await this.request({ type: "replEval", ...request });
+    const { code, sessionKey, level = DEFAULT_LEVEL } = request;
+    const result = await this.call("_pll_repl_eval", [code, sessionKey, level]);
     deliverRunResult(result, onEvent, "<repl>");
   }
-  async checkReplComplete(code, whole = false) {
-    await this.initialize();
-    const { result } = await this.request({ type: "checkSyntax", code, whole });
-    return replCheckFrom(result);
+  /**
+   * Whether `code` is a complete prompt input (`codeop.compile_command`).
+   * `whole` judges several lines submitted at once as one input (`exec`),
+   * not as a shell line.
+   */
+  checkReplComplete(code, whole = false) {
+    return this.call("_pll_repl_check", [code, whole]);
   }
-  async hasTests(code) {
-    await this.initialize();
-    const { result } = await this.request({ type: "hasTests", code });
-    return result;
+  /** True if `code` contains pytest-style `test_*` functions or `Test*` classes. */
+  hasTests(code) {
+    return this.call("_pll_has_tests", [code]);
   }
+  /**
+   * Load any Pyodide packages the code imports (pandas, numpy, ...) - it or
+   * the student's `.py` files beside it - wherever the import is. A no-op
+   * when nothing imported maps to a known package; needs network the first
+   * time it loads one.
+   */
   async ensurePackages(code, siblings = []) {
-    await this.initialize();
-    await this.request({ type: "loadPackages", code, siblings });
+    const found = await this.call("_pll_package_imports", [
+      code,
+      JSON.stringify(siblings)
+    ]);
+    await this.request("load", found);
   }
+  /** Load pytest; needs network the first time. */
   async ensurePytest() {
-    await this.initialize();
-    await this.request({ type: "loadPytest" });
+    await this.request("load", { modules: ["pytest"], network: false });
   }
-  async staticAnalyze(request) {
-    await this.initialize();
-    const { result } = await this.request({ type: "staticAnalyze", ...request });
-    return staticFindingsFrom(result);
+  /**
+   * The language level's static checks of a file, each finding worded.
+   * None for a level without checks, or a file that does not parse - its
+   * run says the SyntaxError.
+   */
+  staticAnalyze(request) {
+    const { code, level, fileName, sessionKey = null } = request;
+    return this.call("_pll_static_findings", [code, level, fileName, sessionKey]);
   }
+  /**
+   * Copy the files under the program's folder into Pyodide's work directory
+   * so `open("data/cars.csv")` / `pd.read_csv("cars.csv")` see them.
+   * Replaces any files from a previous mount. `leftOut` are the files a
+   * limit kept back, so reading one says why it is not there.
+   */
   async mountWorkspaceFiles(files, leftOut = []) {
-    await this.initialize();
-    await this.request({ type: "mountWorkspace", files, leftOut });
+    await this.request("mount", { files, leftOut });
   }
-  async collectWorkspaceFiles() {
-    await this.initialize();
-    const { changes } = await this.request({ type: "collectWorkspace" });
-    return changes;
+  /** What Python made, changed and deleted in the work directory since the last mount. */
+  collectWorkspaceFiles() {
+    return this.request("collect", {});
   }
-  async examplarBuild(sources) {
-    await this.initialize();
-    const { result } = await this.request({ type: "examplarBuild", sources });
-    return result;
+  /**
+   * Compile Examplar wheats and chaffs into a bundle. `sources` is the JSON
+   * of `{wheats: {id: source}, chaffs: {id: source}}`. Authoring only; the
+   * bytecode is produced by *this* interpreter so its magic number matches
+   * by construction.
+   */
+  examplarBuild(sources) {
+    return this.call("_pll_examplar_build", [sources]);
   }
-  async examplarRun(testSource, bundle, fileName) {
-    await this.initialize();
-    const { result } = await this.request({ type: "examplarRun", testSource, bundle, fileName });
-    return examplarOutcomeFrom(result);
+  /**
+   * Run a student's tests against every implementation in a bundle.
+   * `fileName` is the student's file, whose own errors are told from the
+   * implementation's.
+   */
+  examplarRun(testSource, bundle, fileName) {
+    return this.call("_pll_examplar_run", [testSource, bundle, fileName]);
   }
-  async reactorStep(reactorId, event, output) {
-    await this.initialize();
-    const { result } = await this.request({ type: "reactorStep", reactorId, event }, output);
-    return reactorStepFrom(result);
+  /**
+   * Apply one event to a running reactor and get the frame it produced.
+   * `event` is the JSON of `{kind, ...}`; see `Reactor.react`. What its
+   * handlers print or show arrives through `output`, as a run's does.
+   */
+  reactorStep(reactorId, event, output) {
+    return this.call("_pll_reactor_step", [reactorId, event], output);
   }
-  async reactorSeek(reactorId, index) {
-    await this.initialize();
-    const { result } = await this.request({ type: "reactorSeek", reactorId, index });
-    return reactorStepFrom(result);
+  /** Show an earlier or later recorded frame, applying no event. */
+  reactorSeek(reactorId, index) {
+    return this.call("_pll_reactor_seek", [reactorId, index]);
   }
+  /** Forget a reactor, so its recorded states can be collected. */
   async reactorDispose(reactorId) {
-    await this.initialize();
-    await this.request({ type: "reactorDispose", reactorId });
+    await this.call("_pll_reactor_dispose", [reactorId]);
   }
+  /** Forget a session and the names its runs defined. */
   async endSession(sessionKey) {
-    if (!this.initPromise) return;
-    await this.initialize();
-    await this.request({ type: "endSession", sessionKey });
-  }
-  interrupt() {
-    if (!this.interruptBuffer) {
-      return false;
-    }
-    if (this.stdinBuffer && this.stdinRequest !== null) {
-      this.stdinRequest = null;
-      interruptStdin(this.stdinBuffer);
-    }
-    const running = new Set(this.pending.keys());
-    requestInterrupt(this.interruptBuffer, () => {
-      for (const id of running) {
-        if (this.pending.has(id)) return true;
-      }
-      return false;
-    });
-    return true;
-  }
-  setPythonLostHandler(handler) {
-    this.pythonLostHandler = handler;
-  }
-  setPackageNoteHandler(handler) {
-    this.packageNoteHandler = handler;
-  }
-  setStdinHandler(handler) {
-    this.stdinHandler = handler;
-  }
-  dispose() {
-    this.worker?.terminate();
-    this.worker = null;
-    this.initPromise = null;
-    this.stdinBuffer = null;
-    this.interruptBuffer = null;
-    this.rejectAllPending(new Error("Runtime disposed"));
-  }
-  /**
-   * Send `msg` and resolve with its reply - the one `REPLY_TO` names for it.
-   * `live` is where its output goes while it runs, for a request that
-   * streams it.
-   */
-  async request(msg, live = null) {
-    const worker = this.worker;
-    if (!worker) {
-      throw new Error(NOT_RUNNING);
-    }
-    const id = this.nextId++;
-    const reply = await new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject, live });
-      worker.post({ id, ...msg });
-    });
-    const expected = REPLY_TO[msg.type];
-    if (reply.type !== expected) {
-      throw new Error(`Pyodide worker replied "${reply.type}", expected "${expected}"`);
-    }
-    return reply;
-  }
-  handleMessage(msg, worker) {
-    if (msg.type === "display") {
-      const live = this.pending.get(msg.requestId)?.live;
-      if (live) {
-        deliverDisplay(msg.payload, live.onEvent, live.fileName);
-      }
-      return;
-    }
-    if (msg.type === "stdinRequest") {
-      void this.handleStdinRequest(msg.request);
-      return;
-    }
-    if (msg.type === "packageNote") {
-      if (this.packageNoteHandler) this.packageNoteHandler(msg.text, msg.failed);
-      else console.error(msg.text);
-      return;
-    }
-    if (msg.type === "error" && msg.kind === "finished") {
-      this.pythonLost(worker);
-      return;
-    }
-    const pending = this.pending.get(msg.id);
-    if (!pending) {
-      return;
-    }
-    this.pending.delete(msg.id);
-    if (msg.type === "error") {
-      pending.reject(msg.kind === "interrupted" ? new StoppedError(msg.message) : new Error(msg.message));
-    } else {
-      pending.resolve(msg);
-    }
+    if (!this.started) return;
+    await this.call("_pll_end_session", [sessionKey]);
   }
-  /**
-   * Python is gone: the worker exited (only a Node worker can say so), or
-   * the interpreter in it is finished and refuses everything. Either way
-   * nothing sent to it can succeed. Fail what was waiting, end the worker,
-   * and forget it, so that the next request starts a new Python.
-   *
-   * Every session's names went with the old one - but they were gone
-   * already: this follows Python stopping by itself, and never ends a
-   * Python that could still run. Whoever set `setPythonLostHandler` is told,
-   * so that each file can say so rather than only the one that was running.
-   */
-  pythonLost(worker) {
-    if (this.worker !== worker) return;
-    this.rejectAllPending(new PythonLostError());
-    this.worker = null;
-    this.initPromise = null;
-    worker.terminate();
-    this.pythonLostHandler?.();
+};
+function deliverRunResult(result, onEvent, fileName) {
+  for (const display of result.displays) {
+    deliverDisplay(display, onEvent, fileName);
   }
-  rejectAllPending(err) {
-    for (const pending of this.pending.values()) {
-      pending.reject(err);
-    }
-    this.pending.clear();
+  if (result.resultRepr !== null) {
+    onEvent({ kind: "result", repr: result.resultRepr });
   }
-  /**
-   * The next of stdin from the handler. One call at a time: a request a
-   * Stop ended leaves its call waiting, and the next request - a program
-   * that caught the `KeyboardInterrupt` and asked again - shares it, so
-   * the line typed answers that one.
-   */
-  nextStdin() {
-    if (this.stdinNext === null) {
-      const call = (async () => {
-        try {
-          const next = this.stdinHandler ? await this.stdinHandler() : null;
-          return typeof next === "string" ? new TextEncoder().encode(next) : next;
-        } catch {
-          return null;
-        }
-      })();
-      this.stdinNext = call;
-      void call.then(() => {
-        if (this.stdinNext === call) this.stdinNext = null;
-      });
-    }
-    return this.stdinNext;
+  if (result.error !== null) {
+    onEvent({ kind: "error", error: result.error, fileName });
   }
-  async handleStdinRequest(request) {
-    this.stdinRequest = request;
-    let bytes = this.stdinCarry;
-    if (bytes.length === 0) {
-      bytes = await this.nextStdin();
-      if (this.stdinRequest !== request) {
-        if (bytes !== null && this.stdinRequest === null) {
-          this.stdinCarry = concatBytes(this.stdinCarry, bytes);
-        }
-        return;
-      }
-    }
-    this.stdinRequest = null;
-    if (!this.stdinBuffer) {
-      return;
-    }
-    const given = writeStdin(this.stdinBuffer, request, bytes);
-    if (bytes === null) {
-      this.stdinCarry = new Uint8Array(0);
-    } else {
-      this.stdinCarry = bytes.subarray(Math.max(given, 0));
-    }
+  if (result.tests !== null) {
+    onEvent({ kind: "testReport", fileName, ...result.tests });
   }
-};
-function concatBytes(a, b) {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a);
-  out.set(b, a.length);
-  return out;
+  onEvent({
+    kind: "done",
+    ...result.exitCode !== null ? { exitCode: result.exitCode } : {},
+    ...result.stopped ? { stopped: true } : {}
+  });
 }
 
 // src/desktop/pyodideRuntime.ts
-var DesktopPyodideRuntime = class extends WorkerPythonRuntime {
-  constructor(paths) {
-    super();
-    this.paths = paths;
-    this.startTimeoutMs = paths.startTimeoutMs ?? null;
-  }
-  paths;
-  resolveIndexUrl() {
-    const found = this.paths.indexUrlCandidates.find(
-      (dir) => fs5.existsSync(path5.join(dir, "pyodide.asm.wasm"))
-    );
-    if (!found) {
-      throw new Error(this.paths.missingAssetsHint);
+function desktopPython(paths) {
+  return new Python({
+    indexUrl() {
+      const found = paths.indexUrlCandidates.find((dir) => fs5.existsSync(path5.join(dir, "pyodide.asm.wasm")));
+      if (!found) {
+        throw new Error(paths.missingAssetsHint);
+      }
+      return found;
+    },
+    packageCacheDir: paths.packageCacheDir,
+    startTimeoutMs: paths.startTimeoutMs,
+    spawn(handlers) {
+      const worker = new import_node_worker_threads.Worker(paths.workerPath);
+      worker.on("message", (msg) => handlers.onMessage(msg));
+      worker.on("error", (err) => console.error("Pyodide worker failed:", err));
+      worker.on("exit", () => handlers.onExit?.());
+      return {
+        post: (msg) => worker.postMessage(msg),
+        terminate: () => void worker.terminate()
+      };
     }
-    return found;
-  }
-  resolvePackageCacheDir(indexUrl) {
-    return this.paths.packageCacheDir?.(indexUrl) ?? null;
-  }
-  spawn(handlers) {
-    const worker = new import_node_worker_threads.Worker(this.paths.workerPath);
-    worker.on("message", (msg) => handlers.onMessage(msg));
-    worker.on("error", (err) => console.error("Pyodide worker failed:", err));
-    worker.on("exit", () => handlers.onExit?.());
-    return {
-      post: (msg) => worker.postMessage(msg),
-      terminate: () => void worker.terminate()
-    };
-  }
-};
+  });
+}
 
 // src/cli/runtime.ts
 function createCliRuntime() {
-  return new DesktopPyodideRuntime({
+  return desktopPython({
     indexUrlCandidates: pyodideDirectory(),
     workerPath: path6.join(__dirname, "worker.cjs"),
     missingAssetsHint: "Could not find Pyodide's assets. Reinstall pll-python so its `pyodide` dependency is present.",
@@ -4933,26 +2191,6 @@ function createStdinReader() {
 // src/cli/view.ts
 var fs7 = __toESM(require("node:fs"));
 var path7 = __toESM(require("node:path"));
-
-// src/common/errorFormatter.ts
-function formatFriendlyError(finding) {
-  const lines = [];
-  lines.push(`${finding.errorType}: ${finding.headline}`);
-  const location = findingLocation(finding);
-  if (location) {
-    lines.push(`  at ${location.label}`);
-  }
-  if (finding.howToFix.length > 0) {
-    lines.push("");
-    lines.push("How to fix:");
-    for (const item of finding.howToFix) {
-      lines.push(`  - ${item}`);
-    }
-  }
-  return lines;
-}
-
-// src/cli/view.ts
 var ESC = String.fromCharCode(27);
 var CliView = class {
   constructor(opts) {
@@ -5328,7 +2566,7 @@ ${USAGE_HINT}
     return EXIT.ok;
   }
   if (args.version) {
-    process.stdout.write("0.4.0\n");
+    process.stdout.write("0.5.0\n");
     return EXIT.ok;
   }
   if (args.error !== void 0) {