browser-py 0.1.0__tar.gz

browser_py-0.1.0/AGENTS.md

@@ -0,0 +1,45 @@
+# Working rules
+
+browser-py is an independent experimental Python-to-browser compiler competing with Transcrypt. Its numeric backend emits JavaScript from mypyc IR; its browser-source backend emits a deliberately limited native-browser subset. Do not present either as general Python support. PScript is a numeric comparison baseline, never a compilation fallback.
+
+Keep runnable Python in `source/`, regression checks in `tests/`, and frozen benchmark outputs in `benchmarks/`. Keep these folders flat. The root compiler command is the `browser_py.py` symlink; supporting comparisons and GPU demos run through `source/__comparison__.py`. Do not import the double-underscore entry files.
+
+Use synchronous procedural execution, three-space indentation, top-level `from` imports, explicit dispatch, and plain dataclasses without slots or methods. Do not add callbacks, global mutable application state, compatibility layers, or handwritten JavaScript. JavaScript emitted by the compiler is generated output, not application source.
+
+Keep generated pages, compiler copies, logs, reports, bytecode, environments, and tool caches on tmpfs. Do not add ignore files. Do not change installed dependencies during builds.
+
+## Boundaries and invariants
+
+- The compiler command owns admission, compilation, and output publication; the comparison entry owns build, server, browser, and verification lifetimes in that order. `browser_compile.py` admits the whole local graph, builds mypyc IR once, and stages one module's emitted ES module/IR pair at a time before publication; an admission or emission failure leaves existing outputs untouched. `javascript_output.py` owns independent rjsmin compression. Benchmark output uses minified browser-py as its speedup reference.
+- `browser_source.py` owns browser-source admission and iterative ES module emission: direct positional calls, native DOM/GPU values, required-field dataclasses, ordered loops, and native try/catch/finally. `from browser import document, window` names native browser globals at compile time; it emits no runtime import or shim. Reject unsupported imports, expressions, annotations, state, and dispatch instead of delegating to another compiler. Range emission evaluates bounds in order and keeps its private counter separate from the Python target.
+- Benchmark and GPU builders own their source selection, staged sources, and generated pages; GPU builds must not import numeric benchmark compilers. Transcrypt compilation and its patch were removed only after the independent browser build passed every workload payload and native/browser GPU pixel verification.
+- `http_process.py` owns check-server startup and cleanup; `__http_server__.py` owns a single-threaded listener and ordered static-file requests. Read the little-endian uint16 readiness port once with an unbuffered two-byte read, never by parsing human status output. Park silent browser preconnections in native sockets until readable or their idle deadline expires; native handlers run synchronously with bounded socket I/O. A shutdown timeout kills and reaps the process, then still fails the check; cleanup closes its stdout pipe, while the caller owns the log.
+- The benchmark browser entry owns one blocking measurement, its binary download, and its untimed preview. Page navigation starts a fresh run; no event subscription controls application decisions. The preview owns the mesh-kind check, projects each vertex once into packed native float64 XY pairs, preserves triangle order, and never mutates the workload buffer.
+- `triangle_render.py` owns the shared shader and rendering commands. `triangle_native.py` owns synchronous native GPU/window lifetimes and ordered frames. `__browser_triangle__.py` owns browser GPU/canvas initialization, one rendered frame, and binary pixel readback.
+- Adapter selection rejects software/fallback GPUs before device creation; native frames block on GPU completion before presentation. Teardown scopes nest so one failing cleanup cannot skip another owner's cleanup, while a successful browser preview keeps its configured device for the page lifetime.
+- Only the GPU browser entry may use explicit async/await for browser-required adapter/device initialization and mapped-buffer readback. Native execution, compilation, host orchestration, and benchmarks stay synchronous; do not introduce callbacks or a scheduling framework.
+- `webgpu_bindings.py` lowers a deliberately small, typed, straight-line wgpu subset to direct browser API calls at build time, then the browser-source backend emits the app. It is not the mypyc IR backend and must reject unsupported imports, receivers, calls, descriptors, and statements instead of guessing or providing runtime shims.
+- GPU lowering checks descriptor fields, RGBA shape, sequence elements, and positional argument types before emission; aliases retain those checked types. GPU APIs own scalar-value and resource-state validation.
+- The GPU check validates every native pixel against the shader's independent triangle geometry, opens a native window, then compares every browser RGBA8 value with native output, allowing one quantization unit. Validate the fixed byte count and bound reads before comparing.
+- The host spools one workload's CPython reference payloads to a scoped tmpfs binary file and keeps only record metadata and timing summaries in memory. It validates peer headers before one-record float64-array reads, reconciles each payload and the warmup/component checksum, and rewinds the reference for each compiler. The host scope closes the file; generating the next workload replaces its contents.
+- Component buffers and procedural dataclass vectors deliberately represent different benchmark subjects. Preserve their numeric equivalence; do not scalarize away the vector allocation workload.
+- Preserve the density model, negative halo, edge ownership, triangle winding, and area-weighted normals. Frozen outputs and oriented geometry hashes guard these properties.
+- `numeric_source.py` owns numeric annotation admission, dataclass field order, and acyclic direct-call/import graphs for both numeric backends; each backend owns emission and rejects its unsupported operations. Function signatures, dataclass fields, and present local annotations use the same admitted numeric shapes; reject unsupported annotation expressions before collecting call edges instead of letting a backend erase them. Imports name functions defined directly by the target module, never reexports, classes, or entry files. Admission checks positional arity against actual definitions and field counts, keeps named callables unshadowed and nonescaping, and rejects global/nonlocal state before emission.
+- The compiler consumes actual mypyc IR, emits structured control flow without recursion, and rejects unsupported operations rather than substituting another compiler.
+- Timing is observational, not deterministic; workload inputs, execution order, generated numeric code, and output validation must be deterministic. Build-duration metadata is observational too.
+
+## Dependency limitations
+
+Compilation and minification require neither Transcrypt nor Java. Numeric and browser-source emission produce native ES modules; the GPU entry additionally uses browser-required async/await. Every numeric compiler configuration has separate `-minified` and `-unminified` modes, including shared browser code; report each separately.
+
+wgpu 0.29.0 has no `py.typed` marker. Mypy follows its installed Python definitions; import GPU types from the public `wgpu.classes` module so their definitions remain visible. Do not add local stubs or invented browser types.
+
+A GPU check has aborted during native shutdown after passing pixel verification; the cause is not isolated and repeated comparisons did not reproduce it. A native abort still fails the check: do not retry automatically, suppress its exit code, or skip teardown.
+
+Native browser APIs remain untyped external boundaries. Keep DOM and typed-array calls at the browser boundary; do not invent Python browser types or embed stubs in application files. Playwright exposes a synchronous interface used by the host; its internal implementation is outside application ownership.
+
+## Checks
+
+Install the `test` extra for validation or the `tools` extra for comparison/demo dependencies; direct compilation needs neither. Run `python -B browser_py.py validate` for Ruff, mypy, and Python regressions. Run `python -B source/__comparison__.py check --browser firefox` for all ten workloads under every configured compiler mode in Firefox. Install the matching Playwright Firefox before the browser check. Preserve frozen fixtures until a replacement has demonstrated the same outputs.
+
+Run `python -B source/__comparison__.py triangle check` for shared rendering in a native window and headed Firefox; headless Firefox does not expose WebGPU here. A working GPU/display is required, with no headless or software-rendering fallback. In the isolated X11 check environment, select the actual available display with `PYGLFW_LIBRARY_VARIANT=x11 MOZ_ENABLE_WAYLAND=0`. The browser entry reports native WebGPU failures and rethrows them so the host can retain the browser diagnostic.

browser_py-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include AGENTS.md README.md pyproject.toml uv.lock
+recursive-include source *.py *.css
+recursive-include tests *.py *.bin
+recursive-include benchmarks *.pickle

browser_py-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: browser-py
+Version: 0.1.0
+Summary: An experimental Python-to-browser compiler and Transcrypt competitor
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: rjsmin==1.2.5
+Requires-Dist: mypy==1.18.2
+Requires-Dist: setuptools>=68
+Provides-Extra: tools
+Requires-Dist: playwright<2,>=1.56; extra == "tools"
+Requires-Dist: pscript<0.9,>=0.8; extra == "tools"
+Requires-Dist: wgpu==0.29.0; extra == "tools"
+Requires-Dist: glfw<3,>=2.9; extra == "tools"
+Provides-Extra: test
+Requires-Dist: browser-py[tools]; extra == "test"
+Requires-Dist: pytest<10,>=9; extra == "test"
+Requires-Dist: ruff<1,>=0.14; extra == "test"
+
+# browser-py
+
+An experimental Python-to-browser compiler, built as a competitor to Transcrypt.
+Write Python and compile it for the browser.
+
+It supports typed numeric code and a small browser-facing subset, not arbitrary
+Python packages. Compilation, browser examples, and checks work without Transcrypt.
+
+Install with Python 3.12:
+
+```sh
+python -m pip install browser-py
+browser-py compile path/to/your_module.py
+browser-py --help
+```
+
+In a source checkout, the equivalent compiler command is:
+
+```sh
+python -B browser_py.py compile source/kernels.py
+```
+
+Compiled files are saved to temporary storage; the command prints their location.
+Compiler comparisons and the triangle demo are supporting tools, available in the
+source checkout or source distribution (not the compiler wheel). Install the `tools`
+extra to use them:
+
+```sh
+python -m pip install 'browser-py[tools]'
+python -B source/__comparison__.py --help
+```
+
+For development, install the `test` extra and run `python -B browser_py.py validate`
+from a source checkout.

browser_py-0.1.0/README.md

@@ -0,0 +1,34 @@
+# browser-py
+
+An experimental Python-to-browser compiler, built as a competitor to Transcrypt.
+Write Python and compile it for the browser.
+
+It supports typed numeric code and a small browser-facing subset, not arbitrary
+Python packages. Compilation, browser examples, and checks work without Transcrypt.
+
+Install with Python 3.12:
+
+```sh
+python -m pip install browser-py
+browser-py compile path/to/your_module.py
+browser-py --help
+```
+
+In a source checkout, the equivalent compiler command is:
+
+```sh
+python -B browser_py.py compile source/kernels.py
+```
+
+Compiled files are saved to temporary storage; the command prints their location.
+Compiler comparisons and the triangle demo are supporting tools, available in the
+source checkout or source distribution (not the compiler wheel). Install the `tools`
+extra to use them:
+
+```sh
+python -m pip install 'browser-py[tools]'
+python -B source/__comparison__.py --help
+```
+
+For development, install the `test` extra and run `python -B browser_py.py validate`
+from a source checkout.

browser_py-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "browser-py"
+version = "0.1.0"
+description = "An experimental Python-to-browser compiler and Transcrypt competitor"
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+dependencies = [
+    "rjsmin==1.2.5",
+    "mypy==1.18.2",
+    "setuptools>=68",
+]
+
+[project.scripts]
+browser-py = "compiler_command:main"
+
+[project.optional-dependencies]
+tools = ["playwright>=1.56,<2", "pscript>=0.8,<0.9", "wgpu==0.29.0", "glfw>=2.9,<3"]
+test = ["browser-py[tools]", "pytest>=9,<10", "ruff>=0.14,<1"]
+
+[tool.setuptools]
+packages = []
+package-dir = {"" = "source"}
+py-modules = [
+    "browser_compile",
+    "browser_source",
+    "compiler_command",
+    "javascript_output",
+    "numeric_ir",
+    "numeric_source",
+    "webgpu_bindings",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["source"]
+testpaths = ["tests"]
+cache_dir = "/tmp/python-js-pytest-cache"
+
+[tool.mypy]
+python_version = "3.12"
+mypy_path = "source"
+cache_dir = "/tmp/python-js-mypy-cache"
+exclude = ['(^|/)(__browser_benchmark__|browser_measurement|__browser_triangle__)\.py$']
+disallow_untyped_defs = true
+check_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = ["pscript", "glfw", "rjsmin"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["wgpu", "wgpu.*"]
+follow_untyped_imports = true
+
+[tool.ruff]
+indent-width = 3
+line-length = 110
+cache-dir = "/tmp/python-js-ruff-cache"
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["benchmark_build", "benchmark_host", "browser_compile", "browser_measurement", "browser_source", "compiler_command", "compiler_modes", "http_process", "javascript_output", "kernels", "meshing", "meshing_vectors", "numeric_ir", "numeric_source", "pscript_backend", "triangle_command", "triangle_native", "triangle_render", "webgpu_bindings", "workloads"]

browser_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

browser_py-0.1.0/source/__browser_benchmark__.py

@@ -0,0 +1,14 @@
+# Runtime ownership: page -> synchronous measurement -> binary download and mesh preview.
+from browser import document, window
+
+from browser_measurement import measure_page
+
+try:
+   measure_page(
+      document.body.getAttribute("data-case"),
+      document.body.getAttribute("data-kind"),
+      window.location.search,
+   )
+except Exception as error:
+   document.getElementById("status").textContent = str(error)
+   document.getElementById("status").setAttribute("data-state", "error")

browser_py-0.1.0/source/__browser_py__.py

@@ -0,0 +1,5 @@
+# Runtime ownership: command -> source admission -> mypyc IR -> staged JavaScript and IR -> published files.
+from compiler_command import main
+
+if __name__ == "__main__":
+   main()

browser_py-0.1.0/source/__browser_triangle__.py

@@ -0,0 +1,82 @@
+# Runtime ownership: page -> awaited hardware GPU/device -> canvas preview -> mapped readback -> binary download.
+from browser import document, window
+
+from triangle_render import create_pipeline, draw
+
+
+async def render_page():
+   try:
+      if window.navigator.gpu:
+         adapter = await window.navigator.gpu.requestAdapter({"powerPreference": "high-performance"})
+      else:
+         raise ValueError("This browser does not expose WebGPU")
+      if adapter and adapter.info.isFallbackAdapter is False:
+         device = await adapter.requestDevice()
+      else:
+         raise ValueError("WebGPU requires a hardware adapter")
+      try:
+         device.pushErrorScope("validation")
+         canvas = document.getElementById("screen")
+         context = canvas.getContext("webgpu")
+         texture_format = window.navigator.gpu.getPreferredCanvasFormat()
+         context.configure({"device": device, "format": texture_format, "alphaMode": "opaque"})
+         try:
+            pipeline = create_pipeline(device, texture_format)
+            draw(device, pipeline, context.getCurrentTexture())
+            target = device.createTexture(
+               {
+                  "size": [256, 256, 1],
+                  "format": "rgba8unorm",
+                  "usage": window.GPUTextureUsage.RENDER_ATTACHMENT | window.GPUTextureUsage.COPY_SRC,
+               }
+            )
+            try:
+               readback = device.createBuffer(
+                  {
+                     "size": 256 * 256 * 4,
+                     "usage": window.GPUBufferUsage.COPY_DST | window.GPUBufferUsage.MAP_READ,
+                  }
+               )
+               try:
+                  reference_pipeline = create_pipeline(device, "rgba8unorm")
+                  draw(device, reference_pipeline, target)
+                  encoder = device.createCommandEncoder()
+                  encoder.copyTextureToBuffer(
+                     {"texture": target},
+                     {"buffer": readback, "offset": 0, "bytesPerRow": 256 * 4, "rowsPerImage": 256},
+                     [256, 256, 1],
+                  )
+                  device.queue.submit([encoder.finish()])
+                  await readback.mapAsync(window.GPUMapMode.READ)
+                  try:
+                     pixels = window.Uint8Array.__new__(readback.getMappedRange())
+                     # Blob copies bytes before unmap; the host reconciles the downloaded pixels.
+                     blob = window.Blob.__new__([pixels], {"type": "application/octet-stream"})
+                  finally:
+                     readback.unmap()
+               finally:
+                  readback.destroy()
+            finally:
+               target.destroy()
+            error = await device.popErrorScope()
+            if error:
+               raise ValueError(error.message)
+            link = document.getElementById("download")
+            link.href = window.URL.createObjectURL(blob)
+            link.download = "triangle.rgba"
+            link.hidden = False
+            document.getElementById("status").textContent = "Triangle ready."
+            document.getElementById("status").setAttribute("data-state", "done")
+         except:
+            context.unconfigure()
+            raise
+      except:
+         device.destroy()
+         raise
+   except Exception as error:
+      document.getElementById("status").textContent = str(error)
+      document.getElementById("status").setAttribute("data-state", "error")
+      raise
+
+
+render_page()

browser_py-0.1.0/source/__comparison__.py

@@ -0,0 +1,103 @@
+# Runtime ownership: comparison/demo -> build -> server -> browser -> verification and reports -> cleanup.
+from argparse import ArgumentParser
+from pathlib import Path
+from subprocess import run
+from sys import executable
+from tempfile import mkdtemp
+
+from benchmark_build import build_all
+from benchmark_host import check
+from triangle_command import build_triangle, check_triangle
+from triangle_native import show_triangle
+from workloads import Workload, workloads
+
+if __name__ == "__main__":
+   parser = ArgumentParser(description="Compare browser-py with other compilers or run the GPU demo")
+   commands = parser.add_subparsers(dest="command", required=True)
+   commands.add_parser("build", help="Build comparison pages in temporary memory")
+   serve = commands.add_parser("serve", help="Build and serve the compiler comparisons")
+   serve.add_argument("--host", default="127.0.0.1")
+   serve.add_argument("--port", type=int, default=8000)
+   smoke = commands.add_parser("check", help="Verify every compiler and workload in a browser")
+   measure = commands.add_parser("measure", help="Record verified browser timings")
+   for command in (smoke, measure):
+      command.add_argument("--browser", choices=("firefox", "chromium", "webkit", "all"), default="firefox")
+   measure.add_argument("--suite", choices=("meshing", "scalar", "all"), default="meshing")
+   measure.add_argument(
+      "--case", dest="cases", action="append", choices=tuple(item.name for item in workloads())
+   )
+   measure.add_argument("--rounds", type=int, default=11)
+   triangle = commands.add_parser("triangle", help="Run the shared Python GPU example")
+   triangle_commands = triangle.add_subparsers(dest="triangle_command", required=True)
+   triangle_commands.add_parser("build", help="Build the browser app in temporary memory")
+   triangle_commands.add_parser("check", help="Verify the desktop window and Firefox pixels")
+   triangle_native = triangle_commands.add_parser("native", help="Open the regular Python desktop app")
+   triangle_native.add_argument(
+      "--frames", type=int, default=0, help="Exit after this many frames; zero runs until closed"
+   )
+   triangle_serve = triangle_commands.add_parser("serve", help="Build and serve the browser app")
+   triangle_serve.add_argument("--host", default="127.0.0.1")
+   triangle_serve.add_argument("--port", type=int, default=8000)
+   args = parser.parse_args()
+   if args.command == "measure" and args.rounds < 3:
+      parser.error("--rounds must be at least three")
+   if args.command == "triangle" and args.triangle_command == "native":
+      show_triangle(args.frames)
+      print(
+         "Orchestration: command -> native window -> synchronous GPU initialization -> ordered frames -> present -> cleanup"
+      )
+      raise SystemExit(0)
+   output = Path(mkdtemp(prefix="browser-py-comparisons-", dir="/tmp"))
+   if args.command == "triangle":
+      build_triangle(output)
+   else:
+      build_all(output)
+   if args.command == "serve" or (args.command == "triangle" and args.triangle_command == "serve"):
+      run(
+         [
+            executable,
+            "-B",
+            "-m",
+            "http.server",
+            str(args.port),
+            "--bind",
+            args.host,
+            "--directory",
+            str(output),
+         ],
+         check=True,
+      )
+   elif args.command == "triangle" and args.triangle_command == "check":
+      check_triangle(output)
+   elif args.command == "check":
+      for browser in ("firefox", "chromium", "webkit") if args.browser == "all" else (args.browser,):
+         check(output, workloads(), 3, True, browser)
+   elif args.command == "measure":
+      selected: list[Workload] = []
+      for item in workloads():
+         if args.cases is not None:
+            if item.name in args.cases:
+               selected.append(item)
+         elif args.suite == "all" or (item.kind == "scalar") == (args.suite == "scalar"):
+            selected.append(item)
+      for browser in ("firefox", "chromium", "webkit") if args.browser == "all" else (args.browser,):
+         check(output, tuple(selected), args.rounds, False, browser)
+   if args.command == "triangle":
+      if args.triangle_command == "check":
+         print(
+            "Orchestration: command -> build -> native reference and window -> HTTP process -> Firefox -> pixel verification -> cleanup"
+         )
+      elif args.triangle_command == "serve":
+         print(
+            "Orchestration: command -> build -> HTTP process; page -> awaited GPU initialization -> shared rendering -> pixel download"
+         )
+      else:
+         print("Orchestration: command -> WebGPU bindings -> compiler -> generated browser app")
+   elif args.command == "build":
+      print("Orchestration: command -> build -> generated pages")
+   elif args.command == "serve":
+      print("Orchestration: command -> build -> HTTP process")
+   else:
+      print(
+         "Orchestration: command -> build -> HTTP process -> browser -> ordered pages -> verification -> reports"
+      )

browser_py-0.1.0/source/__http_server__.py

@@ -0,0 +1,44 @@
+# Runtime ownership: host -> HTTP process -> synchronous server -> ordered static-file requests.
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from select import select
+from socket import socket
+from struct import pack
+from sys import stdout
+from time import monotonic
+
+if __name__ == "__main__":
+   with HTTPServer(("127.0.0.1", 0), SimpleHTTPRequestHandler) as server:
+      # The server publishes its bound port as one little-endian uint16; the host validates it before navigation.
+      stdout.buffer.write(pack("<H", server.server_address[1]))
+      stdout.buffer.flush()
+      # Browsers may preconnect silently; the server dispatches readable sockets and closes idle peers.
+      waiting: dict[socket, tuple[tuple[str, int], float]] = {}
+      try:
+         while True:
+            timeout: float | None = None
+            now = monotonic()
+            for pending in waiting.values():
+               remaining = pending[1] - now
+               if timeout is None or remaining < timeout:
+                  timeout = remaining
+            ready = []
+            if timeout is None or timeout > 0:
+               ready = select([server.socket, *waiting], [], [], timeout)[0]
+            if server.socket in ready:
+               incoming = server.get_request()
+               incoming[0].settimeout(10)
+               waiting[incoming[0]] = (incoming[1], monotonic() + 10)
+            for connection in tuple(waiting):
+               pending = waiting[connection]
+               if connection in ready or monotonic() >= pending[1]:
+                  del waiting[connection]
+                  try:
+                     if connection in ready:
+                        SimpleHTTPRequestHandler(connection, pending[0], server)
+                  except (BrokenPipeError, ConnectionResetError):
+                     pass
+                  finally:
+                     server.shutdown_request(connection)
+      finally:
+         for connection in waiting:
+            server.shutdown_request(connection)

browser_py-0.1.0/source/benchmark_build.py

@@ -0,0 +1,81 @@
+from gzip import compress
+from html import escape
+from importlib.metadata import version
+from pathlib import Path
+from shutil import copyfile
+from time import perf_counter
+
+from browser_source import compile_browser_source
+from compiler_modes import MODES
+from javascript_output import write_javascript
+from numeric_ir import compile_js
+from pscript_backend import compile_pscript
+from workloads import Workload, workloads
+
+
+def page(config: Workload, mode: str) -> str:
+   return f'''<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width">
+<title>{escape(config.title)} - {mode}</title><link rel="stylesheet" href="../style.css"></head>
+<body data-case="{config.name}" data-kind="{config.kind}"><main>
+<nav><a href="../index.html">All benchmarks</a></nav><h1>{escape(config.title)}</h1><h2>{mode}</h2>
+<p>Keep this tab visible. Timing covers synchronous CPU work, not loading or drawing.</p>
+<form method="get"><label>Work per sample <input id="iterations" name="n" type="number" min="1" value="{config.iterations}" required></label>
+<label>Samples <input id="rounds" name="rounds" type="number" min="3" value="11" required></label>
+<button type="submit">Rerun benchmarks</button></form>
+<p id="status" data-state="running">Running...</p><pre id="report"></pre>
+<a id="download" hidden>Download binary results</a>
+<canvas id="mesh-view" width="760" height="460" aria-label="Mesh preview, not timed" hidden></canvas>
+</main><script type="module" src="__browser_benchmark__.js"></script></body></html>'''
+
+
+def build_all(output: Path) -> None:
+   source = Path(__file__).resolve().parent
+   copyfile(source / "style.css", output / "style.css")
+   lines = [
+      "<!doctype html><html lang='en'><meta charset='utf-8'><title>browser-py compiler comparisons</title>",
+      "<link rel='stylesheet' href='style.css'><main><h1>browser-py compiler comparisons</h1>",
+      "<p>Compare the same Python workloads in your browser. Keep the tab visible.</p>",
+      "<p>Compare browser-py with PScript on the same typed numeric Python.</p>",
+      "<p>browser-py uses mypyc IR; it is experimental and not an official mypy JavaScript backend.</p>",
+      "<p>Optimized flags change semantics; these workloads use their shared numeric subset.</p>",
+      "<p>Vector records measure procedural calls and allocation costs, not proof of JIT inlining.</p>",
+   ]
+   for mode in MODES:
+      target = output / mode
+      target.mkdir()
+      started = perf_counter()
+      compiler = mode.rsplit("-", 1)[0]
+      minified = mode.endswith("-minified")
+      for name in ("workloads", "browser_measurement", "__browser_benchmark__"):
+         javascript = compile_browser_source(source / f"{name}.py")
+         write_javascript(javascript, target / f"{name}.js", minified)
+      if compiler == "browser-py":
+         for name in ("kernels", "meshing", "meshing_vectors"):
+            compiled = compile_js(source / f"{name}.py")
+            write_javascript(compiled[0], target / f"{name}.js", minified)
+            (target / f"{name}.ir").write_text(compiled[1])
+      if compiler in ("pscript", "pscript-opt"):
+         for name in ("kernels", "meshing", "meshing_vectors"):
+            javascript = compile_pscript(source / f"{name}.py", optimized=compiler == "pscript-opt")
+            write_javascript(javascript, target / f"{name}.js", minified)
+      elapsed = perf_counter() - started
+      size = 0
+      gzip_size = 0
+      for script in target.glob("*.js"):
+         size += script.stat().st_size
+         gzip_size += len(compress(script.read_bytes(), mtime=0))
+      lines.append(
+         f"<h2>{mode}</h2><p>{elapsed:.3f} seconds to build; {size} bytes JS; {gzip_size} bytes gzip</p><ul>"
+      )
+      for config in workloads():
+         (target / f"{config.name}.html").write_text(page(config, mode))
+         lines.append(
+            f'<li><a href="{mode}/{config.name}.html?n={config.iterations}&amp;rounds=11">{escape(config.title)}</a></li>'
+         )
+      lines.append("</ul>")
+   lines.append(
+      f"<p>mypy {version('mypy')}; PScript {version('pscript')}; rjsmin {version('rjsmin')}</p></main></html>"
+   )
+   (output / "index.html").write_text("\n".join(lines))
+   print(f"Built {output / 'index.html'}", flush=True)