window: implement a debug() function

In order to ease debug log in js world
2025-10-29 07:03:29 +00:00 · 2024-11-28 16:31:30 +01:00
322 changed files with 17053 additions and 60528 deletions
--- a/.github/actions/install/action.yml
+++ b/.github/actions/install/action.yml
@@ -5,7 +5,7 @@ inputs:
  zig:
    description: 'Zig version to install'
    required: false
-    default: '0.15.1'
+    default: '0.13.0'
  arch:
    description: 'CPU arch used to select the v8 lib'
    required: false
@@ -17,11 +17,11 @@ inputs:
  zig-v8:
    description: 'zig v8 version to install'
    required: false
-    default: 'v0.1.33'
+    default: 'v0.1.9'
  v8:
    description: 'v8 version to install'
    required: false
-    default: '14.0.365.4'
+    default: '11.1.134'
  cache-dir:
    description: 'cache dir to use'
    required: false
@@ -34,11 +34,9 @@ runs:
    - name: Install apt deps
      if: ${{ inputs.os == 'linux' }}
      shell: bash
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y wget xz-utils python3 ca-certificates git pkg-config libglib2.0-dev gperf libexpat1-dev cmake clang
+      run: sudo apt-get install -y wget xz-utils python3 ca-certificates git pkg-config libglib2.0-dev gperf libexpat1-dev cmake clang

-    - uses: mlugg/setup-zig@v2
+    - uses: mlugg/setup-zig@v1
      with:
        version: ${{ inputs.zig }}

@@ -61,29 +59,15 @@ runs:
    - name: install v8
      shell: bash
      run: |
-        mkdir -p v8/out/${{ inputs.os }}/debug/obj/zig/
-        ln -s ${{ inputs.cache-dir }}/v8/libc_v8.a v8/out/${{ inputs.os }}/debug/obj/zig/libc_v8.a
+        mkdir -p vendor/zig-js-runtime/vendor/v8/${{inputs.arch}}-${{inputs.os}}/debug
+        ln -s ${{ inputs.cache-dir }}/v8/libc_v8.a vendor/zig-js-runtime/vendor/v8/${{inputs.arch}}-${{inputs.os}}/debug/libc_v8.a

-        mkdir -p v8/out/${{ inputs.os }}/release/obj/zig/
-        ln -s ${{ inputs.cache-dir }}/v8/libc_v8.a v8/out/${{ inputs.os }}/release/obj/zig/libc_v8.a
+        mkdir -p vendor/zig-js-runtime/vendor/v8/${{inputs.arch}}-${{inputs.os}}/release
+        ln -s ${{ inputs.cache-dir }}/v8/libc_v8.a vendor/zig-js-runtime/vendor/v8/${{inputs.arch}}-${{inputs.os}}/release/libc_v8.a

-    - name: Cache libiconv
-      id: cache-libiconv
-      uses: actions/cache@v4
-      env:
-        cache-name: cache-libiconv
-      with:
-        path: ${{ inputs.cache-dir }}/libiconv
-        key: vendor/libiconv/libiconv-1.17
-
-    - name: download libiconv
-      if: ${{ steps.cache-libiconv.outputs.cache-hit != 'true' }}
+    - name: libiconv
      shell: bash
-      run: make download-libiconv
-
-    - name: build libiconv
-      shell: bash
-      run: make build-libiconv
+      run: make install-libiconv

    - name: build mimalloc
      shell: bash
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,11 +1,5 @@
 name: nightly build

-env:
-  AWS_ACCESS_KEY_ID: ${{ vars.NIGHTLY_BUILD_AWS_ACCESS_ID }}
-  AWS_SECRET_ACCESS_KEY: ${{ secrets.NIGHTLY_BUILD_AWS_SECRET_ACCESS_KEY }}
-  AWS_BUCKET: ${{ vars.NIGHTLY_BUILD_AWS_BUCKET }}
-  AWS_REGION: ${{ vars.NIGHTLY_BUILD_AWS_REGION }}
-
 on:
  schedule:
    - cron: "2 2 * * *"
@@ -23,7 +17,6 @@ jobs:
      OS: linux

    runs-on: ubuntu-22.04
-    timeout-minutes: 15

    steps:
      - uses: actions/checkout@v4
@@ -33,59 +26,13 @@ jobs:
          submodules: recursive

      - uses: ./.github/actions/install
-        with:
-          os: ${{env.OS}}
-          arch: ${{env.ARCH}}

      - name: zig build
-        run: zig build --release=safe -Doptimize=ReleaseSafe -Dcpu=x86_64 -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
+        run: zig build --release=safe -Doptimize=ReleaseSafe -Dengine=v8 -Dcpu=x86_64

      - name: Rename binary
        run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}

-      - name: upload on s3
-        run: |
-          export DIR=`git show --no-patch --no-notes --pretty='%cs_%h'`
-          aws s3 cp --storage-class=GLACIER_IR lightpanda-${{ env.ARCH }}-${{ env.OS }} s3://lpd-nightly-build/${DIR}/lightpanda-${{ env.ARCH }}-${{ env.OS }}
-
-      - name: Upload the build
-        uses: ncipollo/release-action@v1
-        with:
-          allowUpdates: true
-          artifacts: lightpanda-${{ env.ARCH }}-${{ env.OS }}
-          tag: nightly
-
-  build-linux-aarch64:
-    env:
-      ARCH: aarch64
-      OS: linux
-
-    runs-on: ubuntu-22.04-arm
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          # fetch submodules recusively, to get zig-js-runtime submodules also.
-          submodules: recursive
-
-      - uses: ./.github/actions/install
-        with:
-          os: ${{env.OS}}
-          arch: ${{env.ARCH}}
-
-      - name: zig build
-        run: zig build --release=safe -Doptimize=ReleaseSafe -Dcpu=generic -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
-
-      - name: Rename binary
-        run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}
-
-      - name: upload on s3
-        run: |
-          export DIR=`git show --no-patch --no-notes --pretty='%cs_%h'`
-          aws s3 cp --storage-class=GLACIER_IR lightpanda-${{ env.ARCH }}-${{ env.OS }} s3://lpd-nightly-build/${DIR}/lightpanda-${{ env.ARCH }}-${{ env.OS }}
-
      - name: Upload the build
        uses: ncipollo/release-action@v1
        with:
@@ -98,10 +45,7 @@ jobs:
      ARCH: aarch64
      OS: macos

-    # macos-14 runs on arm CPU. see
-    # https://github.com/actions/runner-images?tab=readme-ov-file
-    runs-on: macos-14
-    timeout-minutes: 15
+    runs-on: macos-latest

    steps:
      - uses: actions/checkout@v4
@@ -116,59 +60,11 @@ jobs:
          arch: ${{env.ARCH}}

      - name: zig build
-        run: zig build --release=safe -Doptimize=ReleaseSafe -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
+        run: zig build --release=safe -Doptimize=ReleaseSafe -Dengine=v8

      - name: Rename binary
        run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}

-      - name: upload on s3
-        run: |
-          export DIR=`git show --no-patch --no-notes --pretty='%cs_%h'`
-          aws s3 cp --storage-class=GLACIER_IR lightpanda-${{ env.ARCH }}-${{ env.OS }} s3://lpd-nightly-build/${DIR}/lightpanda-${{ env.ARCH }}-${{ env.OS }}
-
-      - name: Upload the build
-        uses: ncipollo/release-action@v1
-        with:
-          allowUpdates: true
-          artifacts: lightpanda-${{ env.ARCH }}-${{ env.OS }}
-          tag: nightly
-
-  build-macos-x86_64:
-    env:
-      ARCH: x86_64
-      OS: macos
-
-    # macos-13 runs on x86 CPU. see
-    # https://github.com/actions/runner-images?tab=readme-ov-file
-    # If we want to build for macos-14 or superior, we need to switch to
-    # macos-14-large.
-    # No need for now, but maybe we will need it in the short term.
-    runs-on: macos-13
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          # fetch submodules recusively, to get zig-js-runtime submodules also.
-          submodules: recursive
-
-      - uses: ./.github/actions/install
-        with:
-          os: ${{env.OS}}
-          arch: ${{env.ARCH}}
-
-      - name: zig build
-        run: zig build --release=safe -Doptimize=ReleaseSafe -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
-
-      - name: Rename binary
-        run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}
-
-      - name: upload on s3
-        run: |
-          export DIR=`git show --no-patch --no-notes --pretty='%cs_%h'`
-          aws s3 cp --storage-class=GLACIER_IR lightpanda-${{ env.ARCH }}-${{ env.OS }} s3://lpd-nightly-build/${DIR}/lightpanda-${{ env.ARCH }}-${{ env.OS }}
-
      - name: Upload the build
        uses: ncipollo/release-action@v1
        with:
--- a/.github/workflows/cla.yml
+++ b/.github/workflows/cla.yml
@@ -14,8 +14,6 @@ permissions:
 jobs:
  CLAAssistant:
    runs-on: ubuntu-latest
-    timeout-minutes: 5
-
    steps:
      - name: "CLA Assistant"
        if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I hereby sign the CLA') || github.event_name == 'pull_request_target'
@@ -28,7 +26,7 @@ jobs:
          path-to-document: 'https://github.com/lightpanda-io/browser/blob/main/CLA.md'
          # branch should not be protected
          branch: 'main'
-          allowlist: krichprollsch,francisbouvier,katie-lpd,sjorsdonkers,bornlex
+          allowlist: krichprollsch,francisbouvier

          remote-organization-name: lightpanda-io
          remote-repository-name: cla
--- a/.github/workflows/e2e-test.yml
+++ b/.github/workflows/e2e-test.yml
@@ -1,232 +0,0 @@
-name: e2e-test
-
-env:
-  AWS_ACCESS_KEY_ID: ${{ vars.LPD_PERF_AWS_ACCESS_KEY_ID }}
-  AWS_SECRET_ACCESS_KEY: ${{ secrets.LPD_PERF_AWS_SECRET_ACCESS_KEY }}
-  AWS_BUCKET: ${{ vars.LPD_PERF_AWS_BUCKET }}
-  AWS_REGION: ${{ vars.LPD_PERF_AWS_REGION }}
-  LIGHTPANDA_DISABLE_TELEMETRY: true
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "build.zig"
-      - "src/**/*.zig"
-      - "src/*.zig"
-      - "vendor/zig-js-runtime"
-      - ".github/**"
-      - "vendor/**"
-  pull_request:
-
-    # By default GH trigger on types opened, synchronize and reopened.
-    # see https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request
-    # Since we skip the job when the PR is in draft state, we want to force CI
-    # running when the PR is marked ready_for_review w/o other change.
-    # see https://github.com/orgs/community/discussions/25722#discussioncomment-3248917
-    types: [opened, synchronize, reopened, ready_for_review]
-
-    paths:
-      - ".github/**"
-      - "build.zig"
-      - "src/**/*.zig"
-      - "src/*.zig"
-      - "vendor/**"
-      - ".github/**"
-      - "vendor/**"
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-jobs:
-  zig-build-release:
-    name: zig build release
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    # Don't run the CI with draft PR.
-    if: github.event.pull_request.draft == false
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          # fetch submodules recusively, to get zig-js-runtime submodules also.
-          submodules: recursive
-
-      - uses: ./.github/actions/install
-
-      - name: zig build release
-        run: zig build -Doptimize=ReleaseFast -Dcpu=x86_64 -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
-
-      - name: upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: lightpanda-build-release
-          path: |
-            zig-out/bin/lightpanda
-          retention-days: 1
-
-  demo-scripts:
-    name: demo-scripts
-    needs: zig-build-release
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          repository: 'lightpanda-io/demo'
-          fetch-depth: 0
-
-      - run: npm install
-
-      - name: download artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: lightpanda-build-release
-
-      - run: chmod a+x ./lightpanda
-
-      - name: run end to end tests
-        run: |
-          ./lightpanda serve & echo $! > LPD.pid
-          go run runner/main.go
-          kill `cat LPD.pid`
-
-      - name: build proxy
-        run: |
-          cd proxy
-          go build
-
-      - name: run end to end tests through proxy
-        run: |
-          ./proxy/proxy & echo $! > PROXY.id
-          ./lightpanda serve --http_proxy 'http://127.0.0.1:3000' & echo $! > LPD.pid
-          go run runner/main.go
-          kill `cat LPD.pid` `cat PROXY.id`
-
-      - name: run request interception through proxy
-        run: |
-          export PROXY_USERNAME=username PROXY_PASSWORD=password
-          ./proxy/proxy & echo $! > PROXY.id
-          ./lightpanda serve & echo $! > LPD.pid
-          URL=https://demo-browser.lightpanda.io/campfire-commerce/ node puppeteer/proxy_auth.js
-          BASE_URL=https://demo-browser.lightpanda.io/ node playwright/proxy_auth.js
-          kill `cat LPD.pid` `cat PROXY.id`
-
-  cdp-and-hyperfine-bench:
-    name: cdp-and-hyperfine-bench
-    needs: zig-build-release
-
-    env:
-      MAX_MEMORY: 27000
-      MAX_AVG_DURATION: 23
-      LIGHTPANDA_DISABLE_TELEMETRY: true
-
-    # use a self host runner.
-    runs-on: lpd-bench-hetzner
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          repository: 'lightpanda-io/demo'
-          fetch-depth: 0
-
-      - run: npm install
-
-      - name: download artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: lightpanda-build-release
-
-      - run: chmod a+x ./lightpanda
-
-      - name: start http
-        run: |
-          go run ws/main.go & echo $! > WS.pid
-          sleep 2
-
-      - name: run puppeteer
-        run: |
-          ./lightpanda serve & echo $! > LPD.pid
-          sleep 2
-          RUNS=100 npm run bench-puppeteer-cdp > puppeteer.out || exit 1
-          cat /proc/`cat LPD.pid`/status |grep VmHWM|grep -oP '\d+' > LPD.VmHWM
-          kill `cat LPD.pid`
-
-      - name: puppeteer result
-        run: cat puppeteer.out
-
-      - name: memory regression
-        run: |
-          export LPD_VmHWM=`cat LPD.VmHWM`
-          echo "Peak resident set size: $LPD_VmHWM"
-          test "$LPD_VmHWM" -le "$MAX_MEMORY"
-
-      - name: duration regression
-        run: |
-          export PUPPETEER_AVG_DURATION=`cat puppeteer.out|grep 'avg run'|sed 's/avg run duration (ms) //'`
-          echo "puppeteer avg duration: $PUPPETEER_AVG_DURATION"
-          test "$PUPPETEER_AVG_DURATION" -le "$MAX_AVG_DURATION"
-
-      - name: json output
-        run: |
-          export AVG_DURATION=`cat puppeteer.out|grep 'avg run'|sed 's/avg run duration (ms) //'`
-          export TOTAL_DURATION=`cat puppeteer.out|grep 'total duration'|sed 's/total duration (ms) //'`
-          export LPD_VmHWM=`cat LPD.VmHWM`
-          echo "{\"duration_total\":${TOTAL_DURATION},\"duration_avg\":${AVG_DURATION},\"mem_peak\":${LPD_VmHWM}}" > bench.json
-          cat bench.json
-
-      - name: run hyperfine
-        run: |
-          hyperfine --export-json=hyperfine.json --warmup 3 --runs 20 --shell=none "./lightpanda --dump http://127.0.0.1:1234/campfire-commerce/"
-
-      - name: stop http
-        run: kill `cat WS.pid`
-
-      - name: write commit
-        run: |
-          echo "${{github.sha}}" > commit.txt
-
-      - name: upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bench-results
-          path: |
-            bench.json
-            hyperfine.json
-            commit.txt
-          retention-days: 10
-
-
-  perf-fmt:
-    name: perf-fmt
-    needs: cdp-and-hyperfine-bench
-
-    # Don't execute on PR
-    if: github.event_name != 'pull_request'
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    container:
-      image: ghcr.io/lightpanda-io/perf-fmt:latest
-      credentials:
-       username: ${{ github.actor }}
-       password: ${{ secrets.GITHUB_TOKEN }}
-
-    steps:
-      - name: download artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bench-results
-
-      - name: format and send json result
-        run: /perf-fmt cdp ${{ github.sha }} bench.json
-
-      - name: format and send json result
-        run: /perf-fmt hyperfine ${{ github.sha }} hyperfine.json
--- a/.github/workflows/wpt.yml
+++ b/.github/workflows/wpt.yml
@@ -5,21 +5,46 @@ env:
  AWS_SECRET_ACCESS_KEY: ${{ secrets.LPD_PERF_AWS_SECRET_ACCESS_KEY }}
  AWS_BUCKET: ${{ vars.LPD_PERF_AWS_BUCKET }}
  AWS_REGION: ${{ vars.LPD_PERF_AWS_REGION }}
-  LIGHTPANDA_DISABLE_TELEMETRY: true

 on:
-  schedule:
-    - cron: "23 2 * * *"
+  push:
+    branches:
+      - main
+    paths:
+      - "build.zig"
+      - "src/**/*.zig"
+      - "src/*.zig"
+      - "tests/wpt/**"
+      - "vendor/**"
+      - ".github/**"
+  pull_request:

+    # By default GH trigger on types opened, synchronize and reopened.
+    # see https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request
+    # Since we skip the job when the PR is in draft state, we want to force CI
+    # running when the PR is marked ready_for_review w/o other change.
+    # see https://github.com/orgs/community/discussions/25722#discussioncomment-3248917
+    types: [opened, synchronize, reopened, ready_for_review]
+
+    paths:
+      - ".github/**"
+      - "build.zig"
+      - "src/**/*.zig"
+      - "src/*.zig"
+      - "tests/wpt/**"
+      - "vendor/**"
+      - ".github/**"
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

 jobs:
  wpt:
-    name: web platform tests json output
+    name: web platform tests
+
+    # Don't run the CI with draft PR.
+    if: github.event.pull_request.draft == false

    runs-on: ubuntu-latest
-    timeout-minutes: 90

    steps:
      - uses: actions/checkout@v4
@@ -30,8 +55,15 @@ jobs:

      - uses: ./.github/actions/install

+      - run: zig build wpt -Dengine=v8 -- --safe --summary
+
+        # For now WPT tests doesn't pass at all.
+        # We accept then to continue the job on failure.
+        # TODO remove the continue-on-error when tests will pass.
+        continue-on-error: true
+
      - name: json output
-        run: zig build wpt -- --json > wpt.json
+        run: zig build wpt -Dengine=v8 -- --safe --json > wpt.json

      - name: write commit
        run: |
@@ -50,9 +82,10 @@ jobs:
    name: perf-fmt
    needs: wpt

-    runs-on: ubuntu-latest
-    timeout-minutes: 15
+    # Don't execute on PR
+    if: github.event_name != 'pull_request'

+    runs-on: ubuntu-latest
    container:
      image: ghcr.io/lightpanda-io/perf-fmt:latest
      credentials:
--- a/.github/workflows/zig-fmt.yml
+++ b/.github/workflows/zig-fmt.yml
@@ -1,7 +1,7 @@
 name: zig-fmt

 env:
-  ZIG_VERSION: 0.15.1
+  ZIG_VERSION: 0.13.0

 on:
  pull_request:
@@ -29,10 +29,9 @@ jobs:
    if: github.event.pull_request.draft == false

    runs-on: ubuntu-latest
-    timeout-minutes: 15

    steps:
-      - uses: mlugg/setup-zig@v2
+      - uses: mlugg/setup-zig@v1
        with:
          version: ${{ env.ZIG_VERSION }}

--- a/.github/workflows/zig-test.yml
+++ b/.github/workflows/zig-test.yml
@@ -16,7 +16,6 @@ on:
      - "src/*.zig"
      - "vendor/zig-js-runtime"
      - ".github/**"
-      - "vendor/**"
  pull_request:

    # By default GH trigger on types opened, synchronize and reopened.
@@ -33,7 +32,6 @@ on:
      - "src/*.zig"
      - "vendor/**"
      - ".github/**"
-      - "vendor/**"
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

@@ -56,38 +54,30 @@ jobs:
      - uses: ./.github/actions/install

      - name: zig build debug
-        run: zig build
+        run: zig build -Dengine=v8

-      - name: upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: lightpanda-build-dev
-          path: |
-            zig-out/bin/lightpanda
-          retention-days: 1
+  zig-build-release:
+    name: zig build release

-  browser-fetch:
-    name: browser fetch
-    needs: zig-build-dev
-
-    # Don't run the CI with draft PR.
-    if: github.event.pull_request.draft == false
+    # Don't run the CI on PR
+    if: github.event_name != 'pull_request'

    runs-on: ubuntu-latest

    steps:
-      - name: download artifact
-        uses: actions/download-artifact@v4
+      - uses: actions/checkout@v4
        with:
-          name: lightpanda-build-dev
+          fetch-depth: 0
+          # fetch submodules recusively, to get zig-js-runtime submodules also.
+          submodules: recursive

-      - run: chmod a+x ./lightpanda
+      - uses: ./.github/actions/install

-      - run: ./lightpanda fetch https://httpbin.io/xhr/get
+      - name: zig build release
+        run: zig build -Doptimize=ReleaseSafe -Dengine=v8

  zig-test:
    name: zig test
-    timeout-minutes: 15

    # Don't run the CI with draft PR.
    if: github.event.pull_request.draft == false
@@ -104,7 +94,7 @@ jobs:
      - uses: ./.github/actions/install

      - name: zig build test
-        run: zig build test -- --json > bench.json
+        run: zig build test -Dengine=v8 -- --json > bench.json

      - name: write commit
        run: |
@@ -127,8 +117,6 @@ jobs:
    if: github.event_name != 'pull_request'

    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
    container:
      image: ghcr.io/lightpanda-io/perf-fmt:latest
      credentials:
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,3 @@ zig-cache
 zig-out
 /vendor/netsurf/out
 /vendor/libiconv/
-lightpanda.id
-/v8/
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,36 +1,30 @@
+[submodule "vendor/zig-js-runtime"]
+	path = vendor/zig-js-runtime
+	url = git@github.com:lightpanda-io/zig-js-runtime.git
 [submodule "vendor/netsurf/libwapcaplet"]
 	path = vendor/netsurf/libwapcaplet
-	url = https://github.com/lightpanda-io/libwapcaplet.git/
+	url = git@github.com:lightpanda-io/libwapcaplet.git
 [submodule "vendor/netsurf/libparserutils"]
 	path = vendor/netsurf/libparserutils
-	url = https://github.com/lightpanda-io/libparserutils.git/
+	url = git@github.com:lightpanda-io/libparserutils.git
 [submodule "vendor/netsurf/libdom"]
 	path = vendor/netsurf/libdom
-	url = https://github.com/lightpanda-io/libdom.git/
+	url = git@github.com:lightpanda-io/libdom.git
 [submodule "vendor/netsurf/share/netsurf-buildsystem"]
 	path = vendor/netsurf/share/netsurf-buildsystem
-	url = https://github.com/lightpanda-io/netsurf-buildsystem.git
+	url = https://source.netsurf-browser.org/buildsystem.git
 [submodule "vendor/netsurf/libhubbub"]
 	path = vendor/netsurf/libhubbub
-	url = https://github.com/lightpanda-io/libhubbub.git/
+	url = git@github.com:lightpanda-io/libhubbub.git
 [submodule "tests/wpt"]
 	path = tests/wpt
 	url = https://github.com/lightpanda-io/wpt
 [submodule "vendor/mimalloc"]
 	path = vendor/mimalloc
-	url = https://github.com/microsoft/mimalloc.git/
-[submodule "vendor/nghttp2"]
-	path = vendor/nghttp2
-	url = https://github.com/nghttp2/nghttp2.git
-[submodule "vendor/mbedtls"]
-	path = vendor/mbedtls
-	url = https://github.com/Mbed-TLS/mbedtls.git
-[submodule "vendor/zlib"]
-	path = vendor/zlib
-	url = https://github.com/madler/zlib.git
-[submodule "vendor/curl"]
-	path = vendor/curl
-	url = https://github.com/curl/curl.git
-[submodule "vendor/brotli"]
-	path = vendor/brotli
-	url = https://github.com/google/brotli
+	url = git@github.com:microsoft/mimalloc.git
+[submodule "vendor/tls.zig"]
+	path = vendor/tls.zig
+	url = git@github.com:ianic/tls.zig.git
+[submodule "vendor/zig-async-io"]
+	path = vendor/zig-async-io
+	url = git@github.com:lightpanda-io/zig-async-io.git
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +0,0 @@
-# Contributing
-
-Lightpanda accepts pull requests through GitHub.
-
-You have to sign our [CLA](CLA.md) during your first pull request process
-otherwise we're not able to accept your contributions.
-
-The process signature uses the [CLA assistant
-lite](https://github.com/marketplace/actions/cla-assistant-lite). You can see
-an example of the process in [#303](https://github.com/lightpanda-io/browser/pull/303).
--- a/69
+++ b/69
@@ -1,11 +1,11 @@
-FROM debian:stable
+FROM ubuntu:22.04

-ARG MINISIG=0.12
-ARG ZIG=0.15.1
+ARG ZIG=0.13.0
 ARG ZIG_MINISIG=RWSGOq2NVecA2UPNdBUZykf1CCb147pkmdtYxgb3Ti+JO/wCYvhbAb/U
-ARG V8=14.0.365.4
-ARG ZIG_V8=v0.1.33
-ARG TARGETPLATFORM
+ARG OS=linux
+ARG ARCH=x86_64
+ARG V8=11.1.134
+ARG ZIG_V8=v0.1.9

 RUN apt-get update -yq && \
    apt-get install -yq xz-utils \
@@ -16,23 +16,34 @@ RUN apt-get update -yq && \
        curl git

 # install minisig
-RUN curl --fail -L -O https://github.com/jedisct1/minisign/releases/download/${MINISIG}/minisign-${MINISIG}-linux.tar.gz && \
-    tar xvzf minisign-${MINISIG}-linux.tar.gz
+RUN curl -L -O https://github.com/jedisct1/minisign/releases/download/0.11/minisign-0.11-linux.tar.gz && \
+    tar xvzf minisign-0.11-linux.tar.gz

 # install zig
-RUN case $TARGETPLATFORM in \
-    "linux/arm64") ARCH="aarch64" ;; \
-    *) ARCH="x86_64" ;; \
-    esac && \
-    curl --fail -L -O https://ziglang.org/download/${ZIG}/zig-${ARCH}-linux-${ZIG}.tar.xz && \
-    curl --fail -L -O https://ziglang.org/download/${ZIG}/zig-${ARCH}-linux-${ZIG}.tar.xz.minisig && \
-    minisign-linux/${ARCH}/minisign -Vm zig-${ARCH}-linux-${ZIG}.tar.xz -P ${ZIG_MINISIG} && \
-    tar xvf zig-${ARCH}-linux-${ZIG}.tar.xz && \
-    mv zig-${ARCH}-linux-${ZIG} /usr/local/lib && \
-    ln -s /usr/local/lib/zig-${ARCH}-linux-${ZIG}/zig /usr/local/bin/zig
+RUN curl -O https://ziglang.org/download/${ZIG}/zig-linux-x86_64-${ZIG}.tar.xz && \
+    curl -O https://ziglang.org/download/${ZIG}/zig-linux-x86_64-${ZIG}.tar.xz.minisig
+
+RUN minisign-linux/x86_64/minisign -Vm zig-linux-x86_64-${ZIG}.tar.xz -P ${ZIG_MINISIG}
+
+# clean minisg
+RUN rm -fr minisign-0.11-linux.tar.gz minisign-linux
+
+# install zig
+RUN tar xvf zig-linux-x86_64-${ZIG}.tar.xz && \
+    mv zig-linux-x86_64-${ZIG} /usr/local/lib && \
+    ln -s /usr/local/lib/zig-linux-x86_64-${ZIG}/zig /usr/local/bin/zig
+
+# clean up zig install
+RUN rm -fr zig-linux-x86_64-${ZIG}.tar.xz zig-linux-x86_64-${ZIG}.tar.xz.minisig
+
+# force use of http instead of ssh with github
+RUN cat <<EOF > /root/.gitconfig
+[url "https://github.com/"]
+    insteadOf="git@github.com:"
+EOF

 # clone lightpanda
-RUN git clone https://github.com/lightpanda-io/browser.git
+RUN git clone git@github.com:lightpanda-io/browser.git

 WORKDIR /browser

@@ -40,29 +51,27 @@ WORKDIR /browser
 RUN git submodule init && \
    git submodule update --recursive

+RUN cd vendor/zig-js-runtime && \
+    git submodule init && \
+    git submodule update --recursive
+
 RUN make install-libiconv && \
    make install-netsurf && \
    make install-mimalloc

 # download and install v8
-RUN case $TARGETPLATFORM in \
-    "linux/arm64") ARCH="aarch64" ;; \
-    *) ARCH="x86_64" ;; \
-    esac && \
-    curl --fail -L -o libc_v8.a https://github.com/lightpanda-io/zig-v8-fork/releases/download/${ZIG_V8}/libc_v8_${V8}_linux_${ARCH}.a && \
-    mkdir -p v8/out/linux/release/obj/zig/ && \
-    mv libc_v8.a v8/out/linux/release/obj/zig/libc_v8.a
+RUN curl -L -o libc_v8.a https://github.com/lightpanda-io/zig-v8-fork/releases/download/${ZIG_V8}/libc_v8_${V8}_${OS}_${ARCH}.a && \
+    mkdir -p vendor/zig-js-runtime/vendor/v8/${ARCH}-${OS}/release && \
+    mv libc_v8.a vendor/zig-js-runtime/vendor/v8/${ARCH}-${OS}/release/libc_v8.a

 # build release
 RUN make build

-FROM debian:stable-slim
+FROM ubuntu:22.04

 # copy ca certificates
 COPY --from=0 /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt

 COPY --from=0 /browser/zig-out/bin/lightpanda /bin/lightpanda

-EXPOSE 9222/tcp
-
-CMD ["/bin/lightpanda", "serve", "--host", "0.0.0.0", "--port", "9222"]
+CMD ["/bin/lightpanda", "--host", "0.0.0.0", "--port", "3245"]
--- a/LICENSING.md
+++ b/LICENSING.md
@@ -10,7 +10,7 @@ The default license for this project is [AGPL-3.0-only](LICENSE).
 The following files are licensed under MIT:

 ```
-src/polyfill/fetch.js
+src/http/Client.zig
 ```

 The following directories and their subdirectories are licensed under their
--- a/70
+++ b/70
@@ -3,17 +3,12 @@

 ZIG := zig
 BC := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
-# option test filter make test F="server"
-F=

 # OS and ARCH
 kernel = $(shell uname -ms)
 ifeq ($(kernel), Darwin arm64)
 	OS := macos
 	ARCH := aarch64
-else ifeq ($(kernel), Darwin x86_64)
-	OS := macos
-	ARCH := x86_64
 else ifeq ($(kernel), Linux aarch64)
 	OS := linux
 	ARCH := aarch64
@@ -47,8 +42,7 @@ help:

 # $(ZIG) commands
 # ------------
-.PHONY: build build-dev run run-release shell test bench download-zig wpt data get-v8 build-v8 build-v8-dev
-.PHONY: end2end
+.PHONY: build build-dev run run-release shell test bench download-zig wpt

 zig_version = $(shell grep 'recommended_zig_version = "' "vendor/zig-js-runtime/build.zig" | cut -d'"' -f2)

@@ -63,74 +57,53 @@ download-zig:
 ## Build in release-safe mode
 build:
 	@printf "\e[36mBuilding (release safe)...\e[0m\n"
-	$(ZIG) build -Doptimize=ReleaseSafe -Dgit_commit=$$(git rev-parse --short HEAD) || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
+	@$(ZIG) build -Doptimize=ReleaseSafe -Dengine=v8 || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
 	@printf "\e[33mBuild OK\e[0m\n"

 ## Build in debug mode
 build-dev:
 	@printf "\e[36mBuilding (debug)...\e[0m\n"
-	@$(ZIG) build -Dgit_commit=$$(git rev-parse --short HEAD) || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
+	@$(ZIG) build -Dengine=v8 || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
 	@printf "\e[33mBuild OK\e[0m\n"

-## Run the server in release mode
-run: build
-	@printf "\e[36mRunning...\e[0m\n"
-	@./zig-out/bin/lightpanda || (printf "\e[33mRun ERROR\e[0m\n"; exit 1;)
-
 ## Run the server in debug mode
-run-debug: build-dev
+run: build
 	@printf "\e[36mRunning...\e[0m\n"
 	@./zig-out/bin/lightpanda || (printf "\e[33mRun ERROR\e[0m\n"; exit 1;)

 ## Run a JS shell in debug mode
 shell:
 	@printf "\e[36mBuilding shell...\e[0m\n"
-	@$(ZIG) build shell || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
+	@$(ZIG) build shell -Dengine=v8 || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)

 ## Run WPT tests
 wpt:
 	@printf "\e[36mBuilding wpt...\e[0m\n"
-	@$(ZIG) build wpt -- $(filter-out $@,$(MAKECMDGOALS)) || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
+	@$(ZIG) build wpt -Dengine=v8 -- --safe $(filter-out $@,$(MAKECMDGOALS)) || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)

 wpt-summary:
 	@printf "\e[36mBuilding wpt...\e[0m\n"
-	@$(ZIG) build wpt -- --summary $(filter-out $@,$(MAKECMDGOALS)) || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)
+	@$(ZIG) build wpt -Dengine=v8 -- --safe --summary $(filter-out $@,$(MAKECMDGOALS)) || (printf "\e[33mBuild ERROR\e[0m\n"; exit 1;)

 ## Test
 test:
-	@TEST_FILTER='${F}' $(ZIG) build test -freference-trace --summary all
-
-## Run demo/runner end to end tests
-end2end:
-	@test -d ../demo
-	cd ../demo && go run runner/main.go
-
-## v8
-get-v8:
-	@printf "\e[36mGetting v8 source...\e[0m\n"
-	@$(ZIG) build get-v8
-
-build-v8-dev:
-	@printf "\e[36mBuilding v8 (dev)...\e[0m\n"
-	@$(ZIG) build build-v8
-
-build-v8:
-	@printf "\e[36mBuilding v8...\e[0m\n"
-	@$(ZIG) build -Doptimize=ReleaseSafe build-v8
+	@printf "\e[36mTesting...\e[0m\n"
+	@$(ZIG) build test -Dengine=v8 || (printf "\e[33mTest ERROR\e[0m\n"; exit 1;)
+	@printf "\e[33mTest OK\e[0m\n"

 # Install and build required dependencies commands
 # ------------
 .PHONY: install-submodule
-.PHONY: install-libiconv
+.PHONY: install-zig-js-runtime install-zig-js-runtime-dev install-libiconv
 .PHONY: _install-netsurf install-netsurf clean-netsurf test-netsurf install-netsurf-dev
 .PHONY: install-mimalloc install-mimalloc-dev clean-mimalloc
 .PHONY: install-dev install

 ## Install and build dependencies for release
-install: install-submodule install-libiconv install-netsurf install-mimalloc
+install: install-submodule install-zig-js-runtime install-libiconv install-netsurf install-mimalloc

 ## Install and build dependencies for dev
-install-dev: install-submodule install-libiconv install-netsurf-dev install-mimalloc-dev
+install-dev: install-submodule install-zig-js-runtime-dev install-libiconv install-netsurf-dev install-mimalloc-dev

 install-netsurf-dev: _install-netsurf
 install-netsurf-dev: OPTCFLAGS := -O0 -g -DNDEBUG
@@ -166,7 +139,7 @@ _install-netsurf: clean-netsurf
 	BUILDDIR=$(BC_NS)/build/libdom make install && \
 	printf "\e[33mRunning libdom example...\e[0m\n" && \
 	cd examples && \
-	$(ZIG) cc \
+	zig cc \
 	-I$(ICONV)/include \
 	-I$(BC_NS)/include \
 	-L$(ICONV)/lib \
@@ -199,24 +172,27 @@ download-libiconv:
 ifeq ("$(wildcard vendor/libiconv/libiconv-1.17)","")
 	@mkdir -p vendor/libiconv
 	@cd vendor/libiconv && \
-	curl -L https://github.com/lightpanda-io/libiconv/releases/download/1.17/libiconv-1.17.tar.gz | tar -xvzf -
+	curl https://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.17.tar.gz | tar -xvzf -
 endif

-build-libiconv: clean-libiconv
+install-libiconv: download-libiconv clean-libiconv
 	@cd vendor/libiconv/libiconv-1.17 && \
 	./configure --prefix=$(ICONV) --enable-static && \
 	make && make install

-install-libiconv: download-libiconv build-libiconv
-
 clean-libiconv:
 ifneq ("$(wildcard vendor/libiconv/libiconv-1.17/Makefile)","")
 	@cd vendor/libiconv/libiconv-1.17 && \
 	make clean
 endif

-data:
-	cd src/data && go run public_suffix_list_gen.go > public_suffix_list.zig
+install-zig-js-runtime-dev:
+	@cd vendor/zig-js-runtime && \
+	make install-dev
+
+install-zig-js-runtime:
+	@cd vendor/zig-js-runtime && \
+	make install

 .PHONY: _build_mimalloc

--- a/README.md
+++ b/README.md
@@ -2,174 +2,85 @@
  <a href="https://lightpanda.io"><img src="https://cdn.lightpanda.io/assets/images/logo/lpd-logo.png" alt="Logo" height=170></a>
 </p>

-<h1 align="center">Lightpanda Browser</h1>
-
-<p align="center"><a href="https://lightpanda.io/">lightpanda.io</a></p>
+<h1 align="center">Lightpanda</h1>

 <div align="center">
-
-[![License](https://img.shields.io/github/license/lightpanda-io/browser)](https://github.com/lightpanda-io/browser/blob/main/LICENSE)
-[![Twitter Follow](https://img.shields.io/twitter/follow/lightpanda_io)](https://twitter.com/lightpanda_io)
-[![GitHub stars](https://img.shields.io/github/stars/lightpanda-io/browser)](https://github.com/lightpanda-io/browser)
-
+	<br />
 </div>

 Lightpanda is the open-source browser made for headless usage:

 - Javascript execution
- Support of Web APIs (partial, WIP)
- Compatible with Playwright[^1], Puppeteer, chromedp through CDP
+- Support of the Web APIs (partial, WIP)
+- Compatible with Playwright, Puppeteer through CDP (WIP)

-Fast web automation for AI agents, LLM training, scraping and testing:
+Fast scraping and web automation with minimal memory footprint:

- Ultra-low memory footprint (9x less than Chrome)
- Exceptionally fast execution (11x faster than Chrome)
- Instant startup
+- Ultra-low memory footprint (12x less than Chrome)
+- Blazingly fast & instant startup (64x faster than Chrome)

-[<img width="350px" src="https://cdn.lightpanda.io/assets/images/github/execution-time.svg">
-](https://github.com/lightpanda-io/demo)
-&emsp;
-[<img width="350px" src="https://cdn.lightpanda.io/assets/images/github/memory-frame.svg">
-](https://github.com/lightpanda-io/demo)
-</div>
+<img width=500px src="https://cdn.lightpanda.io/assets/images/benchmark2.png">

-_Puppeteer requesting 100 pages from a local website on a AWS EC2 m5.large instance.
-See [benchmark details](https://github.com/lightpanda-io/demo)._
+See [benchmark details](https://github.com/lightpanda-io/demo).

-[^1]: **Playwright support disclaimer:**
-Due to the nature of Playwright, a script that works with the current version of the browser may not function correctly with a future version. Playwright uses an intermediate JavaScript layer that selects an execution strategy based on the browser's available features. If Lightpanda adds a new [Web API](https://developer.mozilla.org/en-US/docs/Web/API), Playwright may choose to execute different code for the same script. This new code path could attempt to use features that are not yet implemented. Lightpanda makes an effort to add compatibility tests, but we can't cover all scenarios. If you encounter an issue, please create a [GitHub issue](https://github.com/lightpanda-io/browser/issues) and include the last known working version of the script.
+## Why?

-## Quick start
+### Javascript execution is mandatory for the modern web

-### Install
-**Install from the nightly builds**
+Back in the good old times, grabbing a webpage was as easy as making an HTTP request, cURL-like. It’s not possible anymore, because Javascript is everywhere, like it or not:

-You can download the last binary from the [nightly
-builds](https://github.com/lightpanda-io/browser/releases/tag/nightly) for
-Linux x86_64 and MacOS aarch64.
+- Ajax, Single Page App, Infinite loading, “click to display”, instant search, etc.
+- JS web frameworks: React, Vue, Angular & others

-*For Linux*
-```console
-curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-x86_64-linux && \
-chmod a+x ./lightpanda
-```
+### Chrome is not the right tool

-*For MacOS*
-```console
-curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-aarch64-macos && \
-chmod a+x ./lightpanda
-```
+So if we need Javascript, why not use a real web browser. Let’s take a huge desktop application, hack it, and run it on the server, right? Hundreds of instance of Chrome if you use it at scale. Are you sure it’s such a good idea?

-*For Windows + WSL2*
+- Heavy on RAM and CPU, expensive to run
+- Hard to package, deploy and maintain at scale
+- Bloated, lots of features are not useful in headless usage

-The Lightpanda browser is compatible to run on windows inside WSL. Follow the Linux instruction for installation from a WSL terminal.
-It is recommended to install clients like Puppeteer on the Windows host.
+### Lightpanda is built for performance

-**Install from Docker**
+If we want both Javascript and performance, for a real headless browser, we need to start from scratch. Not yet another iteration of Chromium, really from a blank page. Crazy right? But that’s we did:

-Lightpanda provides [official Docker
-images](https://hub.docker.com/r/lightpanda/browser) for both Linux amd64 and
-arm64 architectures.
-The following command fetches the Docker image and starts a new container exposing Lightpanda's CDP server on port `9222`.
-```console
-docker run -d --name lightpanda -p 9222:9222 lightpanda/browser:nightly
-```
-
-### Dump a URL
-
-```console
-./lightpanda fetch --dump https://lightpanda.io
-```
-```console
-info(browser): GET https://lightpanda.io/ http.Status.ok
-info(browser): fetch script https://api.website.lightpanda.io/js/script.js: http.Status.ok
-info(browser): eval remote https://api.website.lightpanda.io/js/script.js: TypeError: Cannot read properties of undefined (reading 'pushState')
-<!DOCTYPE html>
-```
-
-### Start a CDP server
-
-```console
-./lightpanda serve --host 127.0.0.1 --port 9222
-```
-```console
-info(websocket): starting blocking worker to listen on 127.0.0.1:9222
-info(server): accepting new conn...
-```
-
-Once the CDP server started, you can run a Puppeteer script by configuring the
-`browserWSEndpoint`.
-
-```js
-'use strict'
-
-import puppeteer from 'puppeteer-core';
-
-// use browserWSEndpoint to pass the Lightpanda's CDP server address.
-const browser = await puppeteer.connect({
-  browserWSEndpoint: "ws://127.0.0.1:9222",
-});
-
-// The rest of your script remains the same.
-const context = await browser.createBrowserContext();
-const page = await context.newPage();
-
-// Dump all the links from the page.
-await page.goto('https://wikipedia.com/');
-
-const links = await page.evaluate(() => {
-  return Array.from(document.querySelectorAll('a')).map(row => {
-    return row.getAttribute('href');
-  });
-});
-
-console.log(links);
-
-await page.close();
-await context.close();
-await browser.disconnect();
-```
-
-### Telemetry
-By default, Lightpanda collects and sends usage telemetry. This can be disabled by setting an environment variable `LIGHTPANDA_DISABLE_TELEMETRY=true`. You can read Lightpanda's privacy policy at: [https://lightpanda.io/privacy-policy](https://lightpanda.io/privacy-policy).
+- Not based on Chromium, Blink or WebKit
+- Low-level system programming language (Zig) with optimisations in mind
+- Opinionated, no rendering

 ## Status

-Lightpanda is in Beta and currently a work in progress. Stability and coverage are improving and many websites now work.
-You may still encounter errors or crashes. Please open an issue with specifics if so.
+Lightpanda is still a work in progress and is currently at the Alpha stage.

-Here are the key features we have implemented:
+Here are the key features we want to implement before releasing a Beta version:

- [x] HTTP loader (based on Libcurl)
- [x] HTML parser and DOM tree (based on Netsurf libs)
- [x] Javascript support (v8)
- [x] DOM APIs
+- [x] Loader
+- [x] HTML parser and DOM tree
+- [x] Javascript support
+- [x] Basic DOM APIs
 - [x] Ajax
  - [x] XHR API
-  - [x] Fetch API (polyfill)
+  - [ ] Fetch API
 - [x] DOM dump
- [x] CDP/websockets server
- [x] Click
- [x] Input form
- [x] Cookies
- [x] Custom HTTP headers
- [x] Proxy support
- [x] Network interception
+- [ ] Basic CDP server

-NOTE: There are hundreds of Web APIs. Developing a browser (even just for headless mode) is a huge task. Coverage will increase over time.
+We will not provide binary versions until we reach at least the Beta stage.
+
+NOTE: There are hundreds of Web APIs. Developing a browser, even just for headless mode, is a huge task. It's more about coverage than a _working/not working_ binary situation.

 You can also follow the progress of our Javascript support in our dedicated [zig-js-runtime](https://github.com/lightpanda-io/zig-js-runtime#development) project.

 ## Build from sources

+We do not provide yet binary versions of Lightpanda, you have to compile it from source.
+
 ### Prerequisites

-Lightpanda is written with [Zig](https://ziglang.org/) `0.15.1`. You have to
+Lightpanda is written with [Zig](https://ziglang.org/) `0.13.0`. You have to
 install it with the right version in order to build the project.

 Lightpanda also depends on
 [zig-js-runtime](https://github.com/lightpanda-io/zig-js-runtime/) (with v8),
-[Libcurl](https://curl.se/libcurl/),
 [Netsurf libs](https://www.netsurf-browser.org/) and
 [Mimalloc](https://microsoft.github.io/mimalloc).

@@ -181,15 +92,10 @@ For Debian/Ubuntu based Linux:
 sudo apt install xz-utils \
    python3 ca-certificates git \
    pkg-config libglib2.0-dev \
-    gperf libexpat1-dev unzip rsync \
+    gperf libexpat1-dev \
    cmake clang
 ```

-For systems with [Nix](https://nixos.org/download/), you can use the devShell:
-```
-nix develop
-```
-
 For MacOS, you only need cmake:

 ```
@@ -202,9 +108,9 @@ brew install cmake

 You can run `make install` to install deps all in one (or `make install-dev` if you need the development versions).

-Be aware that the build task is very long and cpu consuming, as you will build from sources all dependencies, including the v8 Javascript engine.
+Be aware that the build task is very long and cpu consuming, as you will build from sources all dependancies, including the v8 Javascript engine.

-#### Step by step build dependency
+#### Step by step build dependancy

 The project uses git submodules for dependencies.

@@ -214,14 +120,6 @@ To init or update the submodules in the `vendor/` directory:
 make install-submodule
 ```

-**iconv**
-
-libiconv is an internationalization library used by Netsurf.
-
-```
-make install-libiconv
-```
-
 **Netsurf libs**

 Netsurf libs are used for HTML parsing and DOM tree generation.
@@ -246,21 +144,17 @@ Note: when Mimalloc is built in dev mode, you can dump memory stats with the
 env var `MIMALLOC_SHOW_STATS=1`. See
 [https://microsoft.github.io/mimalloc/environment.html](https://microsoft.github.io/mimalloc/environment.html).

-**v8**
+**zig-js-runtime**

-First, get the tools necessary for building V8, as well as the V8 source code:
+Our own Zig/Javascript runtime, which includes the v8 Javascript engine.
+
+This build task is very long and cpu consuming, as you will build v8 from sources.

 ```
-make get-v8
+make install-zig-js-runtime
 ```

-Next, build v8. This build task is very long and cpu consuming, as you will build v8 from sources.
-
-```
-make build-v8
-```
-
-For dev env, use `make build-v8-dev`.
+For dev env, use `make iinstall-zig-js-runtime-dev`.

 ## Test

@@ -268,20 +162,6 @@ For dev env, use `make build-v8-dev`.

 You can test Lightpanda by running `make test`.

-### End to end tests
-
-To run end to end tests, you need to clone the [demo
-repository](https://github.com/lightpanda-io/demo) into `../demo` dir.
-
-You have to install the [demo's node
-requirements](https://github.com/lightpanda-io/demo?tab=readme-ov-file#dependencies-1)
-
-You also need to install [Go](https://go.dev) > v1.24.
-
-```
-make end2end
-```
-
 ### Web Platform Tests

 Lightpanda is tested against the standardized [Web Platform
@@ -323,28 +203,3 @@ Lightpanda accepts pull requests through GitHub.

 You have to sign our [CLA](CLA.md) during the pull request process otherwise
 we're not able to accept your contributions.
-
-## Why?
-
-### Javascript execution is mandatory for the modern web
-
-In the good old days, scraping a webpage was as easy as making an HTTP request, cURL-like. It’s not possible anymore, because Javascript is everywhere, like it or not:
-
- Ajax, Single Page App, infinite loading, “click to display”, instant search, etc.
- JS web frameworks: React, Vue, Angular & others
-
-### Chrome is not the right tool
-
-If we need Javascript, why not use a real web browser? Take a huge desktop application, hack it, and run it on the server. Hundreds or thousands of instances of Chrome if you use it at scale. Are you sure it’s such a good idea?
-
- Heavy on RAM and CPU, expensive to run
- Hard to package, deploy and maintain at scale
- Bloated, lots of features are not useful in headless usage
-
-### Lightpanda is built for performance
-
-If we want both Javascript and performance in a true headless browser, we need to start from scratch. Not another iteration of Chromium, really from a blank page. Crazy right? But that’s what we did:
-
- Not based on Chromium, Blink or WebKit
- Low-level system programming language (Zig) with optimisations in mind
- Opinionated: without graphical rendering
--- a/build.zig
+++ b/build.zig
@@ -17,15 +17,18 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

 const std = @import("std");
+
 const builtin = @import("builtin");

-const Build = std.Build;
+const jsruntime_path = "vendor/zig-js-runtime/";
+const jsruntime = @import("vendor/zig-js-runtime/build.zig");
+const jsruntime_pkgs = jsruntime.packages(jsruntime_path);

 /// Do not rename this constant. It is scanned by some scripts to determine
 /// which zig version to install.
-const recommended_zig_version = "0.15.1";
+const recommended_zig_version = jsruntime.recommended_zig_version;

-pub fn build(b: *Build) !void {
+pub fn build(b: *std.Build) !void {
    switch (comptime builtin.zig_version.order(std.SemanticVersion.parse(recommended_zig_version) catch unreachable)) {
        .eq => {},
        .lt => {
@@ -39,399 +42,164 @@ pub fn build(b: *Build) !void {
        },
    }

-    var opts = b.addOptions();
-    opts.addOption(
-        []const u8,
-        "git_commit",
-        b.option([]const u8, "git_commit", "Current git commit") orelse "dev",
-    );
-
    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
+    const mode = b.standardOptimizeOption(.{});

-    // We're still using llvm because the new x86 backend seems to crash
-    // with v8. This can be reproduced in zig-v8-fork.
+    const options = jsruntime.buildOptions(b);

-    const lightpanda_module = b.addModule("lightpanda", .{
+    // browser
+    // -------
+
+    // compile and install
+    const exe = b.addExecutable(.{
+        .name = "lightpanda",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
-        .optimize = optimize,
-        .link_libc = true,
-        .link_libcpp = true,
+        .optimize = mode,
    });
-    try addDependencies(b, lightpanda_module, opts);
+    try common(b, exe, options);
+    b.installArtifact(exe);

-    {
-        // browser
-        // -------
-
-        // compile and install
-        const exe = b.addExecutable(.{
-            .name = "lightpanda",
-            .use_llvm = true,
-            .root_module = lightpanda_module,
-        });
-        b.installArtifact(exe);
-
-        // run
-        const run_cmd = b.addRunArtifact(exe);
-        if (b.args) |args| {
-            run_cmd.addArgs(args);
-        }
-
-        // step
-        const run_step = b.step("run", "Run the app");
-        run_step.dependOn(&run_cmd.step);
+    // run
+    const run_cmd = b.addRunArtifact(exe);
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
    }

-    {
-        // tests
-        // ----
+    // step
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);

-        // compile
-        const tests = b.addTest(.{
-            .root_module = lightpanda_module,
-            .use_llvm = true,
-            .test_runner = .{ .path = b.path("src/test_runner.zig"), .mode = .simple },
-        });
+    // shell
+    // -----

-        const run_tests = b.addRunArtifact(tests);
-        if (b.args) |args| {
-            run_tests.addArgs(args);
-        }
-
-        // step
-        const tests_step = b.step("test", "Run unit tests");
-        tests_step.dependOn(&run_tests.step);
-    }
-
-    {
-        // wpt
-        // -----
-        const wpt_module = b.createModule(.{
-            .root_source_file = b.path("src/main_wpt.zig"),
-            .target = target,
-            .optimize = optimize,
-        });
-        try addDependencies(b, wpt_module, opts);
-
-        // compile and install
-        const wpt = b.addExecutable(.{
-            .name = "lightpanda-wpt",
-            .use_llvm = true,
-            .root_module = wpt_module,
-        });
-
-        // run
-        const wpt_cmd = b.addRunArtifact(wpt);
-        if (b.args) |args| {
-            wpt_cmd.addArgs(args);
-        }
-        // step
-        const wpt_step = b.step("wpt", "WPT tests");
-        wpt_step.dependOn(&wpt_cmd.step);
-    }
-
-    {
-        // get v8
-        // -------
-        const v8 = b.dependency("v8", .{ .target = target, .optimize = optimize });
-        const get_v8 = b.addRunArtifact(v8.artifact("get-v8"));
-        const get_step = b.step("get-v8", "Get v8");
-        get_step.dependOn(&get_v8.step);
-    }
-
-    {
-        // build v8
-        // -------
-        const v8 = b.dependency("v8", .{ .target = target, .optimize = optimize });
-        const build_v8 = b.addRunArtifact(v8.artifact("build-v8"));
-        const build_step = b.step("build-v8", "Build v8");
-        build_step.dependOn(&build_v8.step);
-    }
-}
-
-fn addDependencies(b: *Build, mod: *Build.Module, opts: *Build.Step.Options) !void {
-    try moduleNetSurf(b, mod);
-    mod.addImport("build_config", opts.createModule());
-
-    const target = mod.resolved_target.?;
-    const dep_opts = .{
+    // compile and install
+    const shell = b.addExecutable(.{
+        .name = "lightpanda-shell",
+        .root_source_file = b.path("src/main_shell.zig"),
        .target = target,
-        .optimize = mod.optimize.?,
-    };
+        .optimize = mode,
+    });
+    try common(b, shell, options);
+    try jsruntime_pkgs.add_shell(shell);

-    mod.addIncludePath(b.path("vendor/lightpanda"));
-
-    {
-        // v8
-        const v8_opts = b.addOptions();
-        v8_opts.addOption(bool, "inspector_subtype", false);
-
-        const v8_mod = b.dependency("v8", dep_opts).module("v8");
-        v8_mod.addOptions("default_exports", v8_opts);
-        mod.addImport("v8", v8_mod);
-
-        const release_dir = if (mod.optimize.? == .Debug) "debug" else "release";
-        const os = switch (target.result.os.tag) {
-            .linux => "linux",
-            .macos => "macos",
-            else => return error.UnsupportedPlatform,
-        };
-        var lib_path = try std.fmt.allocPrint(
-            mod.owner.allocator,
-            "v8/out/{s}/{s}/obj/zig/libc_v8.a",
-            .{ os, release_dir },
-        );
-        std.fs.cwd().access(lib_path, .{}) catch {
-            // legacy path
-            lib_path = try std.fmt.allocPrint(
-                mod.owner.allocator,
-                "v8/out/{s}/obj/zig/libc_v8.a",
-                .{release_dir},
-            );
-        };
-        mod.addObjectFile(mod.owner.path(lib_path));
-
-        switch (target.result.os.tag) {
-            .macos => {
-                // v8 has a dependency, abseil-cpp, which, on Mac, uses CoreFoundation
-                mod.addSystemFrameworkPath(.{ .cwd_relative = "/System/Library/Frameworks" });
-                mod.linkFramework("CoreFoundation", .{});
-            },
-            else => {},
-        }
+    // run
+    const shell_cmd = b.addRunArtifact(shell);
+    if (b.args) |args| {
+        shell_cmd.addArgs(args);
    }

-    {
-        //curl
-        {
-            const is_linux = target.result.os.tag == .linux;
-            if (is_linux) {
-                mod.addCMacro("HAVE_LINUX_TCP_H", "1");
-                mod.addCMacro("HAVE_MSG_NOSIGNAL", "1");
-                mod.addCMacro("HAVE_GETHOSTBYNAME_R", "1");
-            }
-            mod.addCMacro("_FILE_OFFSET_BITS", "64");
-            mod.addCMacro("BUILDING_LIBCURL", "1");
-            mod.addCMacro("CURL_DISABLE_AWS", "1");
-            mod.addCMacro("CURL_DISABLE_DICT", "1");
-            mod.addCMacro("CURL_DISABLE_DOH", "1");
-            mod.addCMacro("CURL_DISABLE_FILE", "1");
-            mod.addCMacro("CURL_DISABLE_FTP", "1");
-            mod.addCMacro("CURL_DISABLE_GOPHER", "1");
-            mod.addCMacro("CURL_DISABLE_KERBEROS", "1");
-            mod.addCMacro("CURL_DISABLE_IMAP", "1");
-            mod.addCMacro("CURL_DISABLE_IPFS", "1");
-            mod.addCMacro("CURL_DISABLE_LDAP", "1");
-            mod.addCMacro("CURL_DISABLE_LDAPS", "1");
-            mod.addCMacro("CURL_DISABLE_MQTT", "1");
-            mod.addCMacro("CURL_DISABLE_NTLM", "1");
-            mod.addCMacro("CURL_DISABLE_PROGRESS_METER", "1");
-            mod.addCMacro("CURL_DISABLE_POP3", "1");
-            mod.addCMacro("CURL_DISABLE_RTSP", "1");
-            mod.addCMacro("CURL_DISABLE_SMB", "1");
-            mod.addCMacro("CURL_DISABLE_SMTP", "1");
-            mod.addCMacro("CURL_DISABLE_TELNET", "1");
-            mod.addCMacro("CURL_DISABLE_TFTP", "1");
-            mod.addCMacro("CURL_EXTERN_SYMBOL", "__attribute__ ((__visibility__ (\"default\"))");
-            mod.addCMacro("CURL_OS", if (is_linux) "\"Linux\"" else "\"mac\"");
-            mod.addCMacro("CURL_STATICLIB", "1");
-            mod.addCMacro("ENABLE_IPV6", "1");
-            mod.addCMacro("HAVE_ALARM", "1");
-            mod.addCMacro("HAVE_ALLOCA_H", "1");
-            mod.addCMacro("HAVE_ARPA_INET_H", "1");
-            mod.addCMacro("HAVE_ARPA_TFTP_H", "1");
-            mod.addCMacro("HAVE_ASSERT_H", "1");
-            mod.addCMacro("HAVE_BASENAME", "1");
-            mod.addCMacro("HAVE_BOOL_T", "1");
-            mod.addCMacro("HAVE_BROTLI", "1");
-            mod.addCMacro("HAVE_BUILTIN_AVAILABLE", "1");
-            mod.addCMacro("HAVE_CLOCK_GETTIME_MONOTONIC", "1");
-            mod.addCMacro("HAVE_DLFCN_H", "1");
-            mod.addCMacro("HAVE_ERRNO_H", "1");
-            mod.addCMacro("HAVE_FCNTL", "1");
-            mod.addCMacro("HAVE_FCNTL_H", "1");
-            mod.addCMacro("HAVE_FCNTL_O_NONBLOCK", "1");
-            mod.addCMacro("HAVE_FREEADDRINFO", "1");
-            mod.addCMacro("HAVE_FSETXATTR", "1");
-            mod.addCMacro("HAVE_FSETXATTR_5", "1");
-            mod.addCMacro("HAVE_FTRUNCATE", "1");
-            mod.addCMacro("HAVE_GETADDRINFO", "1");
-            mod.addCMacro("HAVE_GETEUID", "1");
-            mod.addCMacro("HAVE_GETHOSTBYNAME", "1");
-            mod.addCMacro("HAVE_GETHOSTBYNAME_R_6", "1");
-            mod.addCMacro("HAVE_GETHOSTNAME", "1");
-            mod.addCMacro("HAVE_GETPEERNAME", "1");
-            mod.addCMacro("HAVE_GETPPID", "1");
-            mod.addCMacro("HAVE_GETPPID", "1");
-            mod.addCMacro("HAVE_GETPROTOBYNAME", "1");
-            mod.addCMacro("HAVE_GETPWUID", "1");
-            mod.addCMacro("HAVE_GETPWUID_R", "1");
-            mod.addCMacro("HAVE_GETRLIMIT", "1");
-            mod.addCMacro("HAVE_GETSOCKNAME", "1");
-            mod.addCMacro("HAVE_GETTIMEOFDAY", "1");
-            mod.addCMacro("HAVE_GMTIME_R", "1");
-            mod.addCMacro("HAVE_IDN2_H", "1");
-            mod.addCMacro("HAVE_IF_NAMETOINDEX", "1");
-            mod.addCMacro("HAVE_IFADDRS_H", "1");
-            mod.addCMacro("HAVE_INET_ADDR", "1");
-            mod.addCMacro("HAVE_INET_PTON", "1");
-            mod.addCMacro("HAVE_INTTYPES_H", "1");
-            mod.addCMacro("HAVE_IOCTL", "1");
-            mod.addCMacro("HAVE_IOCTL_FIONBIO", "1");
-            mod.addCMacro("HAVE_IOCTL_SIOCGIFADDR", "1");
-            mod.addCMacro("HAVE_LDAP_URL_PARSE", "1");
-            mod.addCMacro("HAVE_LIBGEN_H", "1");
-            mod.addCMacro("HAVE_LIBZ", "1");
-            mod.addCMacro("HAVE_LL", "1");
-            mod.addCMacro("HAVE_LOCALE_H", "1");
-            mod.addCMacro("HAVE_LOCALTIME_R", "1");
-            mod.addCMacro("HAVE_LONGLONG", "1");
-            mod.addCMacro("HAVE_MALLOC_H", "1");
-            mod.addCMacro("HAVE_MEMORY_H", "1");
-            mod.addCMacro("HAVE_NET_IF_H", "1");
-            mod.addCMacro("HAVE_NETDB_H", "1");
-            mod.addCMacro("HAVE_NETINET_IN_H", "1");
-            mod.addCMacro("HAVE_NETINET_TCP_H", "1");
-            mod.addCMacro("HAVE_PIPE", "1");
-            mod.addCMacro("HAVE_POLL", "1");
-            mod.addCMacro("HAVE_POLL_FINE", "1");
-            mod.addCMacro("HAVE_POLL_H", "1");
-            mod.addCMacro("HAVE_POSIX_STRERROR_R", "1");
-            mod.addCMacro("HAVE_PTHREAD_H", "1");
-            mod.addCMacro("HAVE_PWD_H", "1");
-            mod.addCMacro("HAVE_RECV", "1");
-            mod.addCMacro("HAVE_SA_FAMILY_T", "1");
-            mod.addCMacro("HAVE_SELECT", "1");
-            mod.addCMacro("HAVE_SEND", "1");
-            mod.addCMacro("HAVE_SETJMP_H", "1");
-            mod.addCMacro("HAVE_SETLOCALE", "1");
-            mod.addCMacro("HAVE_SETRLIMIT", "1");
-            mod.addCMacro("HAVE_SETSOCKOPT", "1");
-            mod.addCMacro("HAVE_SIGACTION", "1");
-            mod.addCMacro("HAVE_SIGINTERRUPT", "1");
-            mod.addCMacro("HAVE_SIGNAL", "1");
-            mod.addCMacro("HAVE_SIGNAL_H", "1");
-            mod.addCMacro("HAVE_SIGSETJMP", "1");
-            mod.addCMacro("HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID", "1");
-            mod.addCMacro("HAVE_SOCKET", "1");
-            mod.addCMacro("HAVE_STDBOOL_H", "1");
-            mod.addCMacro("HAVE_STDINT_H", "1");
-            mod.addCMacro("HAVE_STDIO_H", "1");
-            mod.addCMacro("HAVE_STDLIB_H", "1");
-            mod.addCMacro("HAVE_STRCASECMP", "1");
-            mod.addCMacro("HAVE_STRDUP", "1");
-            mod.addCMacro("HAVE_STRERROR_R", "1");
-            mod.addCMacro("HAVE_STRING_H", "1");
-            mod.addCMacro("HAVE_STRINGS_H", "1");
-            mod.addCMacro("HAVE_STRSTR", "1");
-            mod.addCMacro("HAVE_STRTOK_R", "1");
-            mod.addCMacro("HAVE_STRTOLL", "1");
-            mod.addCMacro("HAVE_STRUCT_SOCKADDR_STORAGE", "1");
-            mod.addCMacro("HAVE_STRUCT_TIMEVAL", "1");
-            mod.addCMacro("HAVE_SYS_IOCTL_H", "1");
-            mod.addCMacro("HAVE_SYS_PARAM_H", "1");
-            mod.addCMacro("HAVE_SYS_POLL_H", "1");
-            mod.addCMacro("HAVE_SYS_RESOURCE_H", "1");
-            mod.addCMacro("HAVE_SYS_SELECT_H", "1");
-            mod.addCMacro("HAVE_SYS_SOCKET_H", "1");
-            mod.addCMacro("HAVE_SYS_STAT_H", "1");
-            mod.addCMacro("HAVE_SYS_TIME_H", "1");
-            mod.addCMacro("HAVE_SYS_TYPES_H", "1");
-            mod.addCMacro("HAVE_SYS_UIO_H", "1");
-            mod.addCMacro("HAVE_SYS_UN_H", "1");
-            mod.addCMacro("HAVE_TERMIO_H", "1");
-            mod.addCMacro("HAVE_TERMIOS_H", "1");
-            mod.addCMacro("HAVE_TIME_H", "1");
-            mod.addCMacro("HAVE_UNAME", "1");
-            mod.addCMacro("HAVE_UNISTD_H", "1");
-            mod.addCMacro("HAVE_UTIME", "1");
-            mod.addCMacro("HAVE_UTIME_H", "1");
-            mod.addCMacro("HAVE_UTIMES", "1");
-            mod.addCMacro("HAVE_VARIADIC_MACROS_C99", "1");
-            mod.addCMacro("HAVE_VARIADIC_MACROS_GCC", "1");
-            mod.addCMacro("HAVE_ZLIB_H", "1");
-            mod.addCMacro("RANDOM_FILE", "\"/dev/urandom\"");
-            mod.addCMacro("RECV_TYPE_ARG1", "int");
-            mod.addCMacro("RECV_TYPE_ARG2", "void *");
-            mod.addCMacro("RECV_TYPE_ARG3", "size_t");
-            mod.addCMacro("RECV_TYPE_ARG4", "int");
-            mod.addCMacro("RECV_TYPE_RETV", "ssize_t");
-            mod.addCMacro("SEND_QUAL_ARG2", "const");
-            mod.addCMacro("SEND_TYPE_ARG1", "int");
-            mod.addCMacro("SEND_TYPE_ARG2", "void *");
-            mod.addCMacro("SEND_TYPE_ARG3", "size_t");
-            mod.addCMacro("SEND_TYPE_ARG4", "int");
-            mod.addCMacro("SEND_TYPE_RETV", "ssize_t");
-            mod.addCMacro("SIZEOF_CURL_OFF_T", "8");
-            mod.addCMacro("SIZEOF_INT", "4");
-            mod.addCMacro("SIZEOF_LONG", "8");
-            mod.addCMacro("SIZEOF_OFF_T", "8");
-            mod.addCMacro("SIZEOF_SHORT", "2");
-            mod.addCMacro("SIZEOF_SIZE_T", "8");
-            mod.addCMacro("SIZEOF_TIME_T", "8");
-            mod.addCMacro("STDC_HEADERS", "1");
-            mod.addCMacro("TIME_WITH_SYS_TIME", "1");
-            mod.addCMacro("USE_NGHTTP2", "1");
-            mod.addCMacro("USE_MBEDTLS", "1");
-            mod.addCMacro("USE_THREADS_POSIX", "1");
-            mod.addCMacro("USE_UNIX_SOCKETS", "1");
-        }
+    // step
+    const shell_step = b.step("shell", "Run JS shell");
+    shell_step.dependOn(&shell_cmd.step);

-        try buildZlib(b, mod);
-        try buildBrotli(b, mod);
-        try buildMbedtls(b, mod);
-        try buildNghttp2(b, mod);
-        try buildCurl(b, mod);
+    // test
+    // ----

-        switch (target.result.os.tag) {
-            .macos => {
-                // needed for proxying on mac
-                mod.addSystemFrameworkPath(.{ .cwd_relative = "/System/Library/Frameworks" });
-                mod.linkFramework("CoreFoundation", .{});
-                mod.linkFramework("SystemConfiguration", .{});
-            },
-            else => {},
-        }
+    // compile
+    const tests = b.addTest(.{
+        .root_source_file = b.path("src/run_tests.zig"),
+        .test_runner = b.path("src/test_runner.zig"),
+        .target = target,
+        .optimize = mode,
+    });
+    try common(b, tests, options);
+
+    // add jsruntime pretty deps
+    tests.root_module.addAnonymousImport("pretty", .{
+        .root_source_file = b.path("vendor/zig-js-runtime/src/pretty.zig"),
+    });
+
+    const run_tests = b.addRunArtifact(tests);
+    if (b.args) |args| {
+        run_tests.addArgs(args);
    }
+
+    // step
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_tests.step);
+
+    // wpt
+    // -----
+
+    // compile and install
+    const wpt = b.addExecutable(.{
+        .name = "lightpanda-wpt",
+        .root_source_file = b.path("src/main_wpt.zig"),
+        .target = target,
+        .optimize = mode,
+    });
+    try common(b, wpt, options);
+
+    // run
+    const wpt_cmd = b.addRunArtifact(wpt);
+    if (b.args) |args| {
+        wpt_cmd.addArgs(args);
+    }
+    // step
+    const wpt_step = b.step("wpt", "WPT tests");
+    wpt_step.dependOn(&wpt_cmd.step);
 }

-fn moduleNetSurf(b: *Build, mod: *Build.Module) !void {
-    const target = mod.resolved_target.?;
+fn common(
+    b: *std.Build,
+    step: *std.Build.Step.Compile,
+    options: jsruntime.Options,
+) !void {
+    const target = step.root_module.resolved_target.?;
+    const jsruntimemod = try jsruntime_pkgs.module(
+        b,
+        options,
+        step.root_module.optimize.?,
+        target,
+    );
+    step.root_module.addImport("jsruntime", jsruntimemod);
+
+    const netsurf = try moduleNetSurf(b, target);
+    netsurf.addImport("jsruntime", jsruntimemod);
+    step.root_module.addImport("netsurf", netsurf);
+
+    const asyncio = b.addModule("asyncio", .{
+        .root_source_file = b.path("vendor/zig-async-io/src/lib.zig"),
+    });
+    step.root_module.addImport("asyncio", asyncio);
+
+    const tlsmod = b.addModule("tls", .{
+        .root_source_file = b.path("vendor/tls.zig/src/main.zig"),
+    });
+    step.root_module.addImport("tls", tlsmod);
+}
+
+fn moduleNetSurf(b: *std.Build, target: std.Build.ResolvedTarget) !*std.Build.Module {
+    const mod = b.addModule("netsurf", .{
+        .root_source_file = b.path("src/netsurf/netsurf.zig"),
+        .target = target,
+    });
+
    const os = target.result.os.tag;
    const arch = target.result.cpu.arch;

    // iconv
    const libiconv_lib_path = try std.fmt.allocPrint(
-        b.allocator,
+        mod.owner.allocator,
        "vendor/libiconv/out/{s}-{s}/lib/libiconv.a",
        .{ @tagName(os), @tagName(arch) },
    );
    const libiconv_include_path = try std.fmt.allocPrint(
-        b.allocator,
+        mod.owner.allocator,
        "vendor/libiconv/out/{s}-{s}/lib/libiconv.a",
        .{ @tagName(os), @tagName(arch) },
    );
    mod.addObjectFile(b.path(libiconv_lib_path));
    mod.addIncludePath(b.path(libiconv_include_path));

-    {
-        // mimalloc
-        const mimalloc = "vendor/mimalloc";
-        const lib_path = try std.fmt.allocPrint(
-            b.allocator,
-            mimalloc ++ "/out/{s}-{s}/lib/libmimalloc.a",
-            .{ @tagName(os), @tagName(arch) },
-        );
-        mod.addObjectFile(b.path(lib_path));
-        mod.addIncludePath(b.path(mimalloc ++ "/include"));
-    }
+    // mimalloc
+    mod.addImport("mimalloc", (try moduleMimalloc(b, target)));

    // netsurf libs
    const ns = "vendor/netsurf";
    const ns_include_path = try std.fmt.allocPrint(
-        b.allocator,
+        mod.owner.allocator,
        ns ++ "/out/{s}-{s}/include",
        .{ @tagName(os), @tagName(arch) },
    );
@@ -445,407 +213,34 @@ fn moduleNetSurf(b: *Build, mod: *Build.Module) !void {
    };
    inline for (libs) |lib| {
        const ns_lib_path = try std.fmt.allocPrint(
-            b.allocator,
+            mod.owner.allocator,
            ns ++ "/out/{s}-{s}/lib/" ++ lib ++ ".a",
            .{ @tagName(os), @tagName(arch) },
        );
        mod.addObjectFile(b.path(ns_lib_path));
        mod.addIncludePath(b.path(ns ++ "/" ++ lib ++ "/src"));
    }
+
+    return mod;
 }

-fn buildZlib(b: *Build, m: *Build.Module) !void {
-    const zlib = b.addLibrary(.{
-        .name = "zlib",
-        .root_module = m,
+fn moduleMimalloc(b: *std.Build, target: std.Build.ResolvedTarget) !*std.Build.Module {
+    const mod = b.addModule("mimalloc", .{
+        .root_source_file = b.path("src/mimalloc/mimalloc.zig"),
+        .target = target,
    });

-    const root = "vendor/zlib/";
-    zlib.installHeader(b.path(root ++ "zlib.h"), "zlib.h");
-    zlib.installHeader(b.path(root ++ "zconf.h"), "zconf.h");
-    zlib.addCSourceFiles(.{ .flags = &.{
-        "-DHAVE_SYS_TYPES_H",
-        "-DHAVE_STDINT_H",
-        "-DHAVE_STDDEF_H",
-    }, .files = &.{
-        root ++ "adler32.c",
-        root ++ "compress.c",
-        root ++ "crc32.c",
-        root ++ "deflate.c",
-        root ++ "gzclose.c",
-        root ++ "gzlib.c",
-        root ++ "gzread.c",
-        root ++ "gzwrite.c",
-        root ++ "inflate.c",
-        root ++ "infback.c",
-        root ++ "inftrees.c",
-        root ++ "inffast.c",
-        root ++ "trees.c",
-        root ++ "uncompr.c",
-        root ++ "zutil.c",
-    } });
-}
-
-fn buildBrotli(b: *Build, m: *Build.Module) !void {
-    const brotli = b.addLibrary(.{
-        .name = "brotli",
-        .root_module = m,
-    });
-
-    const root = "vendor/brotli/c/";
-    brotli.addIncludePath(b.path(root ++ "include"));
-    brotli.addCSourceFiles(.{ .flags = &.{}, .files = &.{
-        root ++ "common/constants.c",
-        root ++ "common/context.c",
-        root ++ "common/dictionary.c",
-        root ++ "common/platform.c",
-        root ++ "common/shared_dictionary.c",
-        root ++ "common/transform.c",
-        root ++ "dec/bit_reader.c",
-        root ++ "dec/decode.c",
-        root ++ "dec/huffman.c",
-        root ++ "dec/prefix.c",
-        root ++ "dec/state.c",
-        root ++ "dec/static_init.c",
-    } });
-}
-
-fn buildMbedtls(b: *Build, m: *Build.Module) !void {
-    const mbedtls = b.addLibrary(.{
-        .name = "mbedtls",
-        .root_module = m,
-    });
-
-    const root = "vendor/mbedtls/";
-    mbedtls.addIncludePath(b.path(root ++ "include"));
-    mbedtls.addIncludePath(b.path(root ++ "library"));
-
-    mbedtls.addCSourceFiles(.{ .flags = &.{}, .files = &.{
-        root ++ "library/aes.c",
-        root ++ "library/aesni.c",
-        root ++ "library/aesce.c",
-        root ++ "library/aria.c",
-        root ++ "library/asn1parse.c",
-        root ++ "library/asn1write.c",
-        root ++ "library/base64.c",
-        root ++ "library/bignum.c",
-        root ++ "library/bignum_core.c",
-        root ++ "library/bignum_mod.c",
-        root ++ "library/bignum_mod_raw.c",
-        root ++ "library/camellia.c",
-        root ++ "library/ccm.c",
-        root ++ "library/chacha20.c",
-        root ++ "library/chachapoly.c",
-        root ++ "library/cipher.c",
-        root ++ "library/cipher_wrap.c",
-        root ++ "library/constant_time.c",
-        root ++ "library/cmac.c",
-        root ++ "library/ctr_drbg.c",
-        root ++ "library/des.c",
-        root ++ "library/dhm.c",
-        root ++ "library/ecdh.c",
-        root ++ "library/ecdsa.c",
-        root ++ "library/ecjpake.c",
-        root ++ "library/ecp.c",
-        root ++ "library/ecp_curves.c",
-        root ++ "library/entropy.c",
-        root ++ "library/entropy_poll.c",
-        root ++ "library/error.c",
-        root ++ "library/gcm.c",
-        root ++ "library/hkdf.c",
-        root ++ "library/hmac_drbg.c",
-        root ++ "library/lmots.c",
-        root ++ "library/lms.c",
-        root ++ "library/md.c",
-        root ++ "library/md5.c",
-        root ++ "library/memory_buffer_alloc.c",
-        root ++ "library/nist_kw.c",
-        root ++ "library/oid.c",
-        root ++ "library/padlock.c",
-        root ++ "library/pem.c",
-        root ++ "library/pk.c",
-        root ++ "library/pk_ecc.c",
-        root ++ "library/pk_wrap.c",
-        root ++ "library/pkcs12.c",
-        root ++ "library/pkcs5.c",
-        root ++ "library/pkparse.c",
-        root ++ "library/pkwrite.c",
-        root ++ "library/platform.c",
-        root ++ "library/platform_util.c",
-        root ++ "library/poly1305.c",
-        root ++ "library/psa_crypto.c",
-        root ++ "library/psa_crypto_aead.c",
-        root ++ "library/psa_crypto_cipher.c",
-        root ++ "library/psa_crypto_client.c",
-        root ++ "library/psa_crypto_ffdh.c",
-        root ++ "library/psa_crypto_driver_wrappers_no_static.c",
-        root ++ "library/psa_crypto_ecp.c",
-        root ++ "library/psa_crypto_hash.c",
-        root ++ "library/psa_crypto_mac.c",
-        root ++ "library/psa_crypto_pake.c",
-        root ++ "library/psa_crypto_rsa.c",
-        root ++ "library/psa_crypto_se.c",
-        root ++ "library/psa_crypto_slot_management.c",
-        root ++ "library/psa_crypto_storage.c",
-        root ++ "library/psa_its_file.c",
-        root ++ "library/psa_util.c",
-        root ++ "library/ripemd160.c",
-        root ++ "library/rsa.c",
-        root ++ "library/rsa_alt_helpers.c",
-        root ++ "library/sha1.c",
-        root ++ "library/sha3.c",
-        root ++ "library/sha256.c",
-        root ++ "library/sha512.c",
-        root ++ "library/threading.c",
-        root ++ "library/timing.c",
-        root ++ "library/version.c",
-        root ++ "library/version_features.c",
-        root ++ "library/pkcs7.c",
-        root ++ "library/x509.c",
-        root ++ "library/x509_create.c",
-        root ++ "library/x509_crl.c",
-        root ++ "library/x509_crt.c",
-        root ++ "library/x509_csr.c",
-        root ++ "library/x509write.c",
-        root ++ "library/x509write_crt.c",
-        root ++ "library/x509write_csr.c",
-        root ++ "library/debug.c",
-        root ++ "library/mps_reader.c",
-        root ++ "library/mps_trace.c",
-        root ++ "library/net_sockets.c",
-        root ++ "library/ssl_cache.c",
-        root ++ "library/ssl_ciphersuites.c",
-        root ++ "library/ssl_client.c",
-        root ++ "library/ssl_cookie.c",
-        root ++ "library/ssl_debug_helpers_generated.c",
-        root ++ "library/ssl_msg.c",
-        root ++ "library/ssl_ticket.c",
-        root ++ "library/ssl_tls.c",
-        root ++ "library/ssl_tls12_client.c",
-        root ++ "library/ssl_tls12_server.c",
-        root ++ "library/ssl_tls13_keys.c",
-        root ++ "library/ssl_tls13_server.c",
-        root ++ "library/ssl_tls13_client.c",
-        root ++ "library/ssl_tls13_generic.c",
-    } });
-}
-
-fn buildNghttp2(b: *Build, m: *Build.Module) !void {
-    const nghttp2 = b.addLibrary(.{
-        .name = "nghttp2",
-        .root_module = m,
-    });
-
-    const root = "vendor/nghttp2/";
-    nghttp2.addIncludePath(b.path(root ++ "lib"));
-    nghttp2.addIncludePath(b.path(root ++ "lib/includes"));
-    nghttp2.addCSourceFiles(.{ .flags = &.{
-        "-DNGHTTP2_STATICLIB",
-        "-DHAVE_NETINET_IN",
-        "-DHAVE_TIME_H",
-    }, .files = &.{
-        root ++ "lib/sfparse.c",
-        root ++ "lib/nghttp2_alpn.c",
-        root ++ "lib/nghttp2_buf.c",
-        root ++ "lib/nghttp2_callbacks.c",
-        root ++ "lib/nghttp2_debug.c",
-        root ++ "lib/nghttp2_extpri.c",
-        root ++ "lib/nghttp2_frame.c",
-        root ++ "lib/nghttp2_hd.c",
-        root ++ "lib/nghttp2_hd_huffman.c",
-        root ++ "lib/nghttp2_hd_huffman_data.c",
-        root ++ "lib/nghttp2_helper.c",
-        root ++ "lib/nghttp2_http.c",
-        root ++ "lib/nghttp2_map.c",
-        root ++ "lib/nghttp2_mem.c",
-        root ++ "lib/nghttp2_option.c",
-        root ++ "lib/nghttp2_outbound_item.c",
-        root ++ "lib/nghttp2_pq.c",
-        root ++ "lib/nghttp2_priority_spec.c",
-        root ++ "lib/nghttp2_queue.c",
-        root ++ "lib/nghttp2_rcbuf.c",
-        root ++ "lib/nghttp2_session.c",
-        root ++ "lib/nghttp2_stream.c",
-        root ++ "lib/nghttp2_submit.c",
-        root ++ "lib/nghttp2_version.c",
-        root ++ "lib/nghttp2_ratelim.c",
-        root ++ "lib/nghttp2_time.c",
-    } });
-}
-
-fn buildCurl(b: *Build, m: *Build.Module) !void {
-    const curl = b.addLibrary(.{
-        .name = "curl",
-        .root_module = m,
-    });
-
-    const root = "vendor/curl/";
-
-    curl.addIncludePath(b.path(root ++ "lib"));
-    curl.addIncludePath(b.path(root ++ "include"));
-    curl.addCSourceFiles(.{
-        .flags = &.{},
-        .files = &.{
-            root ++ "lib/altsvc.c",
-            root ++ "lib/amigaos.c",
-            root ++ "lib/asyn-ares.c",
-            root ++ "lib/asyn-base.c",
-            root ++ "lib/asyn-thrdd.c",
-            root ++ "lib/bufq.c",
-            root ++ "lib/bufref.c",
-            root ++ "lib/cf-h1-proxy.c",
-            root ++ "lib/cf-h2-proxy.c",
-            root ++ "lib/cf-haproxy.c",
-            root ++ "lib/cf-https-connect.c",
-            root ++ "lib/cf-socket.c",
-            root ++ "lib/cfilters.c",
-            root ++ "lib/conncache.c",
-            root ++ "lib/connect.c",
-            root ++ "lib/content_encoding.c",
-            root ++ "lib/cookie.c",
-            root ++ "lib/cshutdn.c",
-            root ++ "lib/curl_addrinfo.c",
-            root ++ "lib/curl_des.c",
-            root ++ "lib/curl_endian.c",
-            root ++ "lib/curl_fnmatch.c",
-            root ++ "lib/curl_get_line.c",
-            root ++ "lib/curl_gethostname.c",
-            root ++ "lib/curl_gssapi.c",
-            root ++ "lib/curl_memrchr.c",
-            root ++ "lib/curl_ntlm_core.c",
-            root ++ "lib/curl_range.c",
-            root ++ "lib/curl_rtmp.c",
-            root ++ "lib/curl_sasl.c",
-            root ++ "lib/curl_sha512_256.c",
-            root ++ "lib/curl_sspi.c",
-            root ++ "lib/curl_threads.c",
-            root ++ "lib/curl_trc.c",
-            root ++ "lib/cw-out.c",
-            root ++ "lib/cw-pause.c",
-            root ++ "lib/dict.c",
-            root ++ "lib/doh.c",
-            root ++ "lib/dynhds.c",
-            root ++ "lib/easy.c",
-            root ++ "lib/easygetopt.c",
-            root ++ "lib/easyoptions.c",
-            root ++ "lib/escape.c",
-            root ++ "lib/fake_addrinfo.c",
-            root ++ "lib/file.c",
-            root ++ "lib/fileinfo.c",
-            root ++ "lib/fopen.c",
-            root ++ "lib/formdata.c",
-            root ++ "lib/ftp.c",
-            root ++ "lib/ftplistparser.c",
-            root ++ "lib/getenv.c",
-            root ++ "lib/getinfo.c",
-            root ++ "lib/gopher.c",
-            root ++ "lib/hash.c",
-            root ++ "lib/headers.c",
-            root ++ "lib/hmac.c",
-            root ++ "lib/hostip.c",
-            root ++ "lib/hostip4.c",
-            root ++ "lib/hostip6.c",
-            root ++ "lib/hsts.c",
-            root ++ "lib/http.c",
-            root ++ "lib/http1.c",
-            root ++ "lib/http2.c",
-            root ++ "lib/http_aws_sigv4.c",
-            root ++ "lib/http_chunks.c",
-            root ++ "lib/http_digest.c",
-            root ++ "lib/http_negotiate.c",
-            root ++ "lib/http_ntlm.c",
-            root ++ "lib/http_proxy.c",
-            root ++ "lib/httpsrr.c",
-            root ++ "lib/idn.c",
-            root ++ "lib/if2ip.c",
-            root ++ "lib/imap.c",
-            root ++ "lib/krb5.c",
-            root ++ "lib/ldap.c",
-            root ++ "lib/llist.c",
-            root ++ "lib/macos.c",
-            root ++ "lib/md4.c",
-            root ++ "lib/md5.c",
-            root ++ "lib/memdebug.c",
-            root ++ "lib/mime.c",
-            root ++ "lib/mprintf.c",
-            root ++ "lib/mqtt.c",
-            root ++ "lib/multi.c",
-            root ++ "lib/multi_ev.c",
-            root ++ "lib/netrc.c",
-            root ++ "lib/noproxy.c",
-            root ++ "lib/openldap.c",
-            root ++ "lib/parsedate.c",
-            root ++ "lib/pingpong.c",
-            root ++ "lib/pop3.c",
-            root ++ "lib/progress.c",
-            root ++ "lib/psl.c",
-            root ++ "lib/rand.c",
-            root ++ "lib/rename.c",
-            root ++ "lib/request.c",
-            root ++ "lib/rtsp.c",
-            root ++ "lib/select.c",
-            root ++ "lib/sendf.c",
-            root ++ "lib/setopt.c",
-            root ++ "lib/sha256.c",
-            root ++ "lib/share.c",
-            root ++ "lib/slist.c",
-            root ++ "lib/smb.c",
-            root ++ "lib/smtp.c",
-            root ++ "lib/socketpair.c",
-            root ++ "lib/socks.c",
-            root ++ "lib/socks_gssapi.c",
-            root ++ "lib/socks_sspi.c",
-            root ++ "lib/speedcheck.c",
-            root ++ "lib/splay.c",
-            root ++ "lib/strcase.c",
-            root ++ "lib/strdup.c",
-            root ++ "lib/strequal.c",
-            root ++ "lib/strerror.c",
-            root ++ "lib/system_win32.c",
-            root ++ "lib/telnet.c",
-            root ++ "lib/tftp.c",
-            root ++ "lib/transfer.c",
-            root ++ "lib/uint-bset.c",
-            root ++ "lib/uint-hash.c",
-            root ++ "lib/uint-spbset.c",
-            root ++ "lib/uint-table.c",
-            root ++ "lib/url.c",
-            root ++ "lib/urlapi.c",
-            root ++ "lib/version.c",
-            root ++ "lib/ws.c",
-            root ++ "lib/curlx/base64.c",
-            root ++ "lib/curlx/dynbuf.c",
-            root ++ "lib/curlx/inet_ntop.c",
-            root ++ "lib/curlx/nonblock.c",
-            root ++ "lib/curlx/strparse.c",
-            root ++ "lib/curlx/timediff.c",
-            root ++ "lib/curlx/timeval.c",
-            root ++ "lib/curlx/wait.c",
-            root ++ "lib/curlx/warnless.c",
-            root ++ "lib/vquic/curl_ngtcp2.c",
-            root ++ "lib/vquic/curl_osslq.c",
-            root ++ "lib/vquic/curl_quiche.c",
-            root ++ "lib/vquic/vquic.c",
-            root ++ "lib/vquic/vquic-tls.c",
-            root ++ "lib/vauth/cleartext.c",
-            root ++ "lib/vauth/cram.c",
-            root ++ "lib/vauth/digest.c",
-            root ++ "lib/vauth/digest_sspi.c",
-            root ++ "lib/vauth/gsasl.c",
-            root ++ "lib/vauth/krb5_gssapi.c",
-            root ++ "lib/vauth/krb5_sspi.c",
-            root ++ "lib/vauth/ntlm.c",
-            root ++ "lib/vauth/ntlm_sspi.c",
-            root ++ "lib/vauth/oauth2.c",
-            root ++ "lib/vauth/spnego_gssapi.c",
-            root ++ "lib/vauth/spnego_sspi.c",
-            root ++ "lib/vauth/vauth.c",
-            root ++ "lib/vtls/cipher_suite.c",
-            root ++ "lib/vtls/mbedtls.c",
-            root ++ "lib/vtls/mbedtls_threadlock.c",
-            root ++ "lib/vtls/vtls.c",
-            root ++ "lib/vtls/vtls_scache.c",
-            root ++ "lib/vtls/x509asn1.c",
-        },
-    });
+    const os = target.result.os.tag;
+    const arch = target.result.cpu.arch;
+
+    const mimalloc = "vendor/mimalloc";
+    const lib_path = try std.fmt.allocPrint(
+        mod.owner.allocator,
+        mimalloc ++ "/out/{s}-{s}/lib/libmimalloc.a",
+        .{ @tagName(os), @tagName(arch) },
+    );
+    mod.addObjectFile(b.path(lib_path));
+    mod.addIncludePath(b.path(mimalloc ++ "/include"));
+
+    return mod;
 }
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -1,13 +0,0 @@
-.{
-    .name = .browser,
-    .paths = .{""},
-    .version = "0.0.0",
-    .fingerprint = 0xda130f3af836cea0,
-    .dependencies = .{
-        .v8 = .{
-            .url = "https://github.com/lightpanda-io/zig-v8-fork/archive/305bb3706716d32d59b2ffa674731556caa1002b.tar.gz",
-            .hash = "v8-0.0.0-xddH63bVAwBSEobaUok9J0er1FqsvEujCDDVy6ItqKQ5",
-        },
-        //.v8 = .{ .path = "../zig-v8-fork" }
-    },
-}
--- a/flake.lock
+++ b/flake.lock
@@ -1,180 +0,0 @@
-{
-  "nodes": {
-    "flake-compat": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1696426674,
-        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
-        "type": "github"
-      },
-      "original": {
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "flake-utils_2": {
-      "inputs": {
-        "systems": "systems_2"
-      },
-      "locked": {
-        "lastModified": 1705309234,
-        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "gitignore": {
-      "inputs": {
-        "nixpkgs": [
-          "zlsPkg",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1709087332,
-        "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1756822655,
-        "narHash": "sha256-xQAk8xLy7srAkR5NMZFsQFioL02iTHuuEIs3ohGpgdk=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "4bdac60bfe32c41103ae500ddf894c258291dd61",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "release-25.05",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "zigPkgs": "zigPkgs",
-        "zlsPkg": "zlsPkg"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    },
-    "systems_2": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    },
-    "zigPkgs": {
-      "inputs": {
-        "flake-compat": "flake-compat",
-        "flake-utils": "flake-utils_2",
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1756555914,
-        "narHash": "sha256-7yoSPIVEuL+3Wzf6e7NHuW3zmruHizRrYhGerjRHTLI=",
-        "owner": "mitchellh",
-        "repo": "zig-overlay",
-        "rev": "d0df3a2fd0f11134409d6d5ea0e510e5e477f7d6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "mitchellh",
-        "repo": "zig-overlay",
-        "type": "github"
-      }
-    },
-    "zlsPkg": {
-      "inputs": {
-        "gitignore": "gitignore",
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "zig-overlay": [
-          "zigPkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1756048867,
-        "narHash": "sha256-GFzSHUljcxy7sM1PaabbkQUdUnLwpherekPWJFxXtnk=",
-        "owner": "zigtools",
-        "repo": "zls",
-        "rev": "ce6c8f02c78e622421cfc2405c67c5222819ec03",
-        "type": "github"
-      },
-      "original": {
-        "owner": "zigtools",
-        "ref": "0.15.0",
-        "repo": "zls",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
--- a/flake.nix
+++ b/flake.nix
@@ -1,77 +0,0 @@
-{
-  description = "headless browser designed for AI and automation";
-
-  inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/release-25.05";
-
-    zigPkgs.url = "github:mitchellh/zig-overlay";
-    zigPkgs.inputs.nixpkgs.follows = "nixpkgs";
-
-    zlsPkg.url = "github:zigtools/zls/0.15.0";
-    zlsPkg.inputs.zig-overlay.follows = "zigPkgs";
-    zlsPkg.inputs.nixpkgs.follows = "nixpkgs";
-
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs =
-    {
-      nixpkgs,
-      zigPkgs,
-      zlsPkg,
-      flake-utils,
-      ...
-    }:
-    flake-utils.lib.eachDefaultSystem (
-      system:
-      let
-        overlays = [
-          (final: prev: {
-            zigpkgs = zigPkgs.packages.${prev.system};
-            zls = zlsPkg.packages.${prev.system}.default;
-          })
-        ];
-
-        pkgs = import nixpkgs {
-          inherit system overlays;
-        };
-
-        # We need crtbeginS.o for building.
-        crtFiles = pkgs.runCommand "crt-files" { } ''
-          mkdir -p $out/lib
-          cp -r ${pkgs.gcc.cc}/lib/gcc $out/lib/gcc
-        '';
-
-        # This build pipeline is very unhappy without an FHS-compliant env.
-        fhs = pkgs.buildFHSEnv {
-          name = "fhs-shell";
-          multiArch = true;
-          targetPkgs =
-            pkgs: with pkgs; [
-              # Build Tools
-              zigpkgs."0.15.1"
-              zls
-              python3
-              pkg-config
-              cmake
-              gperf
-
-              # GCC
-              gcc
-              gcc.cc.lib
-              crtFiles
-
-              # Libaries
-              expat.dev
-              glib.dev
-              glibc.dev
-              zlib
-              zlib.dev
-            ];
-        };
-      in
-      {
-        devShells.default = fhs.env;
-      }
-    );
-}
--- a/src/TestHTTPServer.zig
+++ b/src/TestHTTPServer.zig
@@ -1,118 +0,0 @@
-const std = @import("std");
-
-const TestHTTPServer = @This();
-
-shutdown: bool,
-listener: ?std.net.Server,
-handler: Handler,
-
-const Handler = *const fn (req: *std.http.Server.Request) anyerror!void;
-
-pub fn init(handler: Handler) TestHTTPServer {
-    return .{
-        .shutdown = true,
-        .listener = null,
-        .handler = handler,
-    };
-}
-
-pub fn deinit(self: *TestHTTPServer) void {
-    self.shutdown = true;
-    if (self.listener) |*listener| {
-        listener.deinit();
-    }
-}
-
-pub fn run(self: *TestHTTPServer, wg: *std.Thread.WaitGroup) !void {
-    const address = try std.net.Address.parseIp("127.0.0.1", 9582);
-
-    self.listener = try address.listen(.{ .reuse_address = true });
-    var listener = &self.listener.?;
-
-    wg.finish();
-
-    while (true) {
-        const conn = listener.accept() catch |err| {
-            if (self.shutdown) {
-                return;
-            }
-            return err;
-        };
-        const thrd = try std.Thread.spawn(.{}, handleConnection, .{ self, conn });
-        thrd.detach();
-    }
-}
-
-fn handleConnection(self: *TestHTTPServer, conn: std.net.Server.Connection) !void {
-    defer conn.stream.close();
-
-    var req_buf: [2048]u8 = undefined;
-    var conn_reader = conn.stream.reader(&req_buf);
-    var conn_writer = conn.stream.writer(&req_buf);
-
-    var http_server = std.http.Server.init(conn_reader.interface(), &conn_writer.interface);
-
-    while (true) {
-        var req = http_server.receiveHead() catch |err| switch (err) {
-            error.ReadFailed => continue,
-            error.HttpConnectionClosing => continue,
-            else => {
-                std.debug.print("Test HTTP Server error: {}\n", .{err});
-                return err;
-            },
-        };
-        self.handler(&req) catch |err| {
-            std.debug.print("test http error '{s}': {}\n", .{ req.head.target, err });
-            try req.respond("server error", .{ .status = .internal_server_error });
-            return;
-        };
-    }
-}
-
-pub fn sendFile(req: *std.http.Server.Request, file_path: []const u8) !void {
-    var file = std.fs.cwd().openFile(file_path, .{}) catch |err| switch (err) {
-        error.FileNotFound => return req.respond("server error", .{ .status = .not_found }),
-        else => return err,
-    };
-    defer file.close();
-
-    const stat = try file.stat();
-    var send_buffer: [4096]u8 = undefined;
-
-    var res = try req.respondStreaming(&send_buffer, .{
-        .content_length = stat.size,
-        .respond_options = .{
-            .extra_headers = &.{
-                .{ .name = "content-type", .value = getContentType(file_path) },
-            },
-        },
-    });
-
-    var read_buffer: [4096]u8 = undefined;
-    var reader = file.reader(&read_buffer);
-    _ = try res.writer.sendFileAll(&reader, .unlimited);
-    try res.writer.flush();
-    try res.end();
-}
-
-fn getContentType(file_path: []const u8) []const u8 {
-    if (std.mem.endsWith(u8, file_path, ".js")) {
-        return "application/json";
-    }
-
-    if (std.mem.endsWith(u8, file_path, ".html")) {
-        return "text/html";
-    }
-
-    if (std.mem.endsWith(u8, file_path, ".htm")) {
-        return "text/html";
-    }
-
-    if (std.mem.endsWith(u8, file_path, ".xml")) {
-        // some wpt tests do this
-        return "text/xml";
-    }
-
-    std.debug.print("TestHTTPServer asked to serve an unknown file type: {s}\n", .{file_path});
-    return "text/html";
-}
--- a/src/browser/cssom/CSSRule.zig
+++ b/src/browser/cssom/CSSRule.zig
@@ -16,26 +16,30 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

-const std = @import("std");
+const generate = @import("generate.zig");

-const CSSStyleSheet = @import("CSSStyleSheet.zig");
+const Console = @import("jsruntime").Console;

-pub const Interfaces = .{
-    CSSRule,
-    CSSImportRule,
-};
+const DOM = @import("dom/dom.zig");
+const HTML = @import("html/html.zig");
+const Events = @import("events/event.zig");
+const XHR = @import("xhr/xhr.zig");
+const Storage = @import("storage/storage.zig");
+const URL = @import("url/url.zig");
+const Iterators = @import("iterator/iterator.zig");

-// https://developer.mozilla.org/en-US/docs/Web/API/CSSRule
-const CSSRule = @This();
-css_text: []const u8,
-parent_rule: ?*CSSRule = null,
-parent_stylesheet: ?*CSSStyleSheet = null,
+pub const HTMLDocument = @import("html/document.zig").HTMLDocument;

-pub const CSSImportRule = struct {
-    pub const prototype = *CSSRule;
-    href: []const u8,
-    layer_name: ?[]const u8,
-    media: void,
-    style_sheet: CSSStyleSheet,
-    supports_text: ?[]const u8,
-};
+// Interfaces
+pub const Interfaces = generate.Tuple(.{
+    Console,
+    DOM.Interfaces,
+    Events.Interfaces,
+    HTML.Interfaces,
+    XHR.Interfaces,
+    Storage.Interfaces,
+    URL.Interfaces,
+    Iterators.Interfaces,
+});
+
+pub const UserContext = @import("user_context.zig").UserContext;
--- a/src/app.zig
+++ b/src/app.zig
@@ -1,115 +0,0 @@
-const std = @import("std");
-
-const Allocator = std.mem.Allocator;
-
-const log = @import("log.zig");
-const Http = @import("http/Http.zig");
-const Platform = @import("browser/js/Platform.zig");
-
-const Telemetry = @import("telemetry/telemetry.zig").Telemetry;
-const Notification = @import("notification.zig").Notification;
-
-// Container for global state / objects that various parts of the system
-// might need.
-pub const App = struct {
-    http: Http,
-    config: Config,
-    platform: Platform,
-    allocator: Allocator,
-    telemetry: Telemetry,
-    app_dir_path: ?[]const u8,
-    notification: *Notification,
-
-    pub const RunMode = enum {
-        help,
-        fetch,
-        serve,
-        version,
-    };
-
-    pub const Config = struct {
-        run_mode: RunMode,
-        tls_verify_host: bool = true,
-        http_proxy: ?[:0]const u8 = null,
-        proxy_bearer_token: ?[:0]const u8 = null,
-        http_timeout_ms: ?u31 = null,
-        http_connect_timeout_ms: ?u31 = null,
-        http_max_host_open: ?u8 = null,
-        http_max_concurrent: ?u8 = null,
-        user_agent: [:0]const u8,
-    };
-
-    pub fn init(allocator: Allocator, config: Config) !*App {
-        const app = try allocator.create(App);
-        errdefer allocator.destroy(app);
-
-        const notification = try Notification.init(allocator, null);
-        errdefer notification.deinit();
-
-        var http = try Http.init(allocator, .{
-            .max_host_open = config.http_max_host_open orelse 4,
-            .max_concurrent = config.http_max_concurrent orelse 10,
-            .timeout_ms = config.http_timeout_ms orelse 5000,
-            .connect_timeout_ms = config.http_connect_timeout_ms orelse 0,
-            .http_proxy = config.http_proxy,
-            .tls_verify_host = config.tls_verify_host,
-            .proxy_bearer_token = config.proxy_bearer_token,
-            .user_agent = config.user_agent,
-        });
-        errdefer http.deinit();
-
-        const platform = try Platform.init();
-        errdefer platform.deinit();
-
-        const app_dir_path = getAndMakeAppDir(allocator);
-
-        app.* = .{
-            .http = http,
-            .allocator = allocator,
-            .telemetry = undefined,
-            .platform = platform,
-            .app_dir_path = app_dir_path,
-            .notification = notification,
-            .config = config,
-        };
-
-        app.telemetry = try Telemetry.init(app, config.run_mode);
-        errdefer app.telemetry.deinit();
-
-        try app.telemetry.register(app.notification);
-
-        return app;
-    }
-
-    pub fn deinit(self: *App) void {
-        const allocator = self.allocator;
-        if (self.app_dir_path) |app_dir_path| {
-            allocator.free(app_dir_path);
-        }
-        self.telemetry.deinit();
-        self.notification.deinit();
-        self.http.deinit();
-        self.platform.deinit();
-        allocator.destroy(self);
-    }
-};
-
-fn getAndMakeAppDir(allocator: Allocator) ?[]const u8 {
-    if (@import("builtin").is_test) {
-        return allocator.dupe(u8, "/tmp") catch unreachable;
-    }
-    const app_dir_path = std.fs.getAppDataDir(allocator, "lightpanda") catch |err| {
-        log.warn(.app, "get data dir", .{ .err = err });
-        return null;
-    };
-
-    std.fs.cwd().makePath(app_dir_path) catch |err| switch (err) {
-        error.PathAlreadyExists => return app_dir_path,
-        else => {
-            allocator.free(app_dir_path);
-            log.warn(.app, "create data dir", .{ .err = err, .path = app_dir_path });
-            return null;
-        },
-    };
-    return app_dir_path;
-}
--- a/src/browser/DataURI.zig
+++ b/src/browser/DataURI.zig
@@ -1,52 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-// Parses data:[<media-type>][;base64],<data>
-pub fn parse(allocator: Allocator, src: []const u8) !?[]const u8 {
-    if (!std.mem.startsWith(u8, src, "data:")) {
-        return null;
-    }
-
-    const uri = src[5..];
-    const data_starts = std.mem.indexOfScalar(u8, uri, ',') orelse return null;
-
-    var data = uri[data_starts + 1 ..];
-
-    // Extract the encoding.
-    const metadata = uri[0..data_starts];
-    if (std.mem.endsWith(u8, metadata, ";base64")) {
-        const decoder = std.base64.standard.Decoder;
-        const decoded_size = try decoder.calcSizeForSlice(data);
-
-        const buffer = try allocator.alloc(u8, decoded_size);
-        errdefer allocator.free(buffer);
-
-        try decoder.decode(buffer, data);
-        data = buffer;
-    }
-
-    return data;
-}
-
-const testing = @import("../testing.zig");
-test "DataURI: parse valid" {
-    try test_valid("data:text/javascript; charset=utf-8;base64,Zm9v", "foo");
-    try test_valid("data:text/javascript; charset=utf-8;,foo", "foo");
-    try test_valid("data:,foo", "foo");
-}
-
-test "DataURI: parse invalid" {
-    try test_cannot_parse("atad:,foo");
-    try test_cannot_parse("data:foo");
-    try test_cannot_parse("data:");
-}
-
-fn test_valid(uri: []const u8, expected: []const u8) !void {
-    defer testing.reset();
-    const data_uri = try parse(testing.arena_allocator, uri) orelse return error.TestFailed;
-    try testing.expectEqual(expected, data_uri);
-}
-
-fn test_cannot_parse(uri: []const u8) !void {
-    try testing.expectEqual(null, parse(undefined, uri));
-}
--- a/src/browser/Scheduler.zig
+++ b/src/browser/Scheduler.zig
@@ -1,163 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const Scheduler = @This();
-
-high_priority: Queue,
-
-// For repeating tasks. We only want to run these if there are other things to
-// do. We don't, for example, want a window.setInterval or the page.runMicrotasks
-// to block the page.wait.
-low_priority: Queue,
-
-// we expect allocator to be the page arena, hence we never call high_priority.deinit
-pub fn init(allocator: Allocator) Scheduler {
-    return .{
-        .high_priority = Queue.init(allocator, {}),
-        .low_priority = Queue.init(allocator, {}),
-    };
-}
-
-pub fn reset(self: *Scheduler) void {
-    // Our allocator is the page arena, it's been reset. We cannot use
-    // clearAndRetainCapacity, since that space is no longer ours
-    self.high_priority.clearAndFree();
-    self.low_priority.clearAndFree();
-}
-
-const AddOpts = struct {
-    name: []const u8 = "",
-    low_priority: bool = false,
-};
-pub fn add(self: *Scheduler, ctx: *anyopaque, func: Task.Func, ms: u32, opts: AddOpts) !void {
-    var low_priority = opts.low_priority;
-    if (ms > 5_000) {
-        // we don't want tasks in the far future to block page.wait from
-        // completing. However, if page.wait is called multiple times (maybe
-        // a CDP driver is wait for something to happen), then we do want
-        // to [eventually] run these when their time is up.
-        low_priority = true;
-    }
-
-    var q = if (low_priority) &self.low_priority else &self.high_priority;
-    return q.add(.{
-        .ms = std.time.milliTimestamp() + ms,
-        .ctx = ctx,
-        .func = func,
-        .name = opts.name,
-    });
-}
-
-pub fn run(self: *Scheduler) !?i32 {
-    _ = try self.runQueue(&self.low_priority);
-    return self.runQueue(&self.high_priority);
-}
-
-fn runQueue(self: *Scheduler, queue: *Queue) !?i32 {
-    // this is O(1)
-    if (queue.count() == 0) {
-        return null;
-    }
-
-    const now = std.time.milliTimestamp();
-
-    var next = queue.peek();
-    while (next) |task| {
-        const time_to_next = task.ms - now;
-        if (time_to_next > 0) {
-            // @intCast is petty safe since we limit tasks to just 5 seconds
-            // in the future
-            return @intCast(time_to_next);
-        }
-
-        if (task.func(task.ctx)) |repeat_delay| {
-            // if we do (now + 0) then our WHILE loop will run endlessly.
-            // no task should ever return 0
-            std.debug.assert(repeat_delay != 0);
-
-            var copy = task;
-            copy.ms = now + repeat_delay;
-            try self.low_priority.add(copy);
-        }
-        _ = queue.remove();
-        next = queue.peek();
-    }
-    return null;
-}
-
-const Task = struct {
-    ms: i64,
-    func: Func,
-    ctx: *anyopaque,
-    name: []const u8,
-
-    const Func = *const fn (ctx: *anyopaque) ?u32;
-};
-
-const Queue = std.PriorityQueue(Task, void, struct {
-    fn compare(_: void, a: Task, b: Task) std.math.Order {
-        return std.math.order(a.ms, b.ms);
-    }
-}.compare);
-
-const testing = @import("../testing.zig");
-test "Scheduler" {
-    defer testing.reset();
-
-    var task = TestTask{ .allocator = testing.arena_allocator };
-
-    var s = Scheduler.init(testing.arena_allocator);
-    try testing.expectEqual(null, s.run());
-    try testing.expectEqual(0, task.calls.items.len);
-
-    try s.add(&task, TestTask.run1, 3, .{});
-
-    try testing.expectDelta(3, try s.run(), 1);
-    try testing.expectEqual(0, task.calls.items.len);
-
-    std.Thread.sleep(std.time.ns_per_ms * 5);
-    try testing.expectEqual(null, s.run());
-    try testing.expectEqualSlices(u32, &.{1}, task.calls.items);
-
-    try s.add(&task, TestTask.run2, 3, .{});
-    try s.add(&task, TestTask.run1, 2, .{});
-
-    std.Thread.sleep(std.time.ns_per_ms * 5);
-    try testing.expectDelta(null, try s.run(), 1);
-    try testing.expectEqualSlices(u32, &.{ 1, 1, 2 }, task.calls.items);
-}
-
-const TestTask = struct {
-    allocator: Allocator,
-    calls: std.ArrayListUnmanaged(u32) = .{},
-
-    fn run1(ctx: *anyopaque) ?u32 {
-        var self: *TestTask = @ptrCast(@alignCast(ctx));
-        self.calls.append(self.allocator, 1) catch unreachable;
-        return null;
-    }
-
-    fn run2(ctx: *anyopaque) ?u32 {
-        var self: *TestTask = @ptrCast(@alignCast(ctx));
-        self.calls.append(self.allocator, 2) catch unreachable;
-        return 2;
-    }
-};
--- a/src/browser/ScriptManager.zig
+++ b/src/browser/ScriptManager.zig
--- a/src/browser/SlotChangeMonitor.zig
+++ b/src/browser/SlotChangeMonitor.zig
@@ -1,189 +0,0 @@
-const std = @import("std");
-
-const log = @import("../log.zig");
-const parser = @import("netsurf.zig");
-const collection = @import("dom/html_collection.zig");
-
-const Page = @import("page.zig").Page;
-
-const SlotChangeMonitor = @This();
-
-page: *Page,
-event_node: parser.EventNode,
-slots_changed: std.ArrayList(*parser.Slot),
-
-// Monitors the document in order to trigger slotchange events.
-pub fn init(page: *Page) !*SlotChangeMonitor {
-    // on the heap, we need a stable address for event_node
-    const self = try page.arena.create(SlotChangeMonitor);
-    self.* = .{
-        .page = page,
-        .slots_changed = .empty,
-        .event_node = .{ .func = mutationCallback },
-    };
-    const root = parser.documentToNode(parser.documentHTMLToDocument(page.window.document));
-
-    _ = try parser.eventTargetAddEventListener(
-        parser.toEventTarget(parser.Node, root),
-        "DOMNodeInserted",
-        &self.event_node,
-        false,
-    );
-
-    _ = try parser.eventTargetAddEventListener(
-        parser.toEventTarget(parser.Node, root),
-        "DOMNodeRemoved",
-        &self.event_node,
-        false,
-    );
-
-    _ = try parser.eventTargetAddEventListener(
-        parser.toEventTarget(parser.Node, root),
-        "DOMAttrModified",
-        &self.event_node,
-        false,
-    );
-
-    return self;
-}
-
-// Given a element, finds its slot, if any.
-pub fn findSlot(element: *parser.Element, page: *const Page) !?*parser.Slot {
-    const target_name = (try parser.elementGetAttribute(element, "slot")) orelse return null;
-    return findNamedSlot(element, target_name, page);
-}
-
-// Given an element and a name, find the slo, if any. This is only useful for
-// MutationEvents where findSlot is unreliable because parser.elementGetAttribute(element, "slot")
-// could return the new or old value.
-fn findNamedSlot(element: *parser.Element, target_name: []const u8, page: *const Page) !?*parser.Slot {
-    // I believe elements need to be added as direct descendents of the host,
-    // so we don't need to go find the host, we just grab the parent.
-    const host = parser.nodeParentNode(@ptrCast(element)) orelse return null;
-    const state = page.getNodeState(host) orelse return null;
-    const shadow_root = state.shadow_root orelse return null;
-
-    // if we're here, we found a host, now find the slot
-    var nodes = collection.HTMLCollectionByTagName(
-        @ptrCast(@alignCast(shadow_root.proto)),
-        "slot",
-        .{ .include_root = false },
-    );
-    for (0..1000) |i| {
-        const n = (try nodes.item(@intCast(i))) orelse return null;
-        const slot_name = (try parser.elementGetAttribute(@ptrCast(n), "name")) orelse "";
-        if (std.mem.eql(u8, target_name, slot_name)) {
-            return @ptrCast(n);
-        }
-    }
-    return null;
-}
-
-// Event callback from the mutation event, signaling either the addition of
-// a node, removal of a node, or a change in attribute
-fn mutationCallback(en: *parser.EventNode, event: *parser.Event) void {
-    const mutation_event = parser.eventToMutationEvent(event);
-    const self: *SlotChangeMonitor = @fieldParentPtr("event_node", en);
-    self._mutationCallback(mutation_event) catch |err| {
-        log.err(.web_api, "slot change callback", .{ .err = err });
-    };
-}
-
-fn _mutationCallback(self: *SlotChangeMonitor, event: *parser.MutationEvent) !void {
-    const event_type = parser.eventType(@ptrCast(event));
-    if (std.mem.eql(u8, event_type, "DOMNodeInserted")) {
-        const event_target = parser.eventTarget(@ptrCast(event)) orelse return;
-        return self.nodeAddedOrRemoved(@ptrCast(event_target));
-    }
-
-    if (std.mem.eql(u8, event_type, "DOMNodeRemoved")) {
-        const event_target = parser.eventTarget(@ptrCast(event)) orelse return;
-        return self.nodeAddedOrRemoved(@ptrCast(event_target));
-    }
-
-    if (std.mem.eql(u8, event_type, "DOMAttrModified")) {
-        const attribute_name = try parser.mutationEventAttributeName(event);
-        if (std.mem.eql(u8, attribute_name, "slot") == false) {
-            return;
-        }
-
-        const new_value = parser.mutationEventNewValue(event);
-        const prev_value = parser.mutationEventPrevValue(event);
-        const event_target = parser.eventTarget(@ptrCast(event)) orelse return;
-        return self.nodeAttributeChanged(@ptrCast(event_target), new_value, prev_value);
-    }
-}
-
-// A node was removed or added. If it's an element, and if it has a slot attribute
-// then we'll dispatch a slotchange event.
-fn nodeAddedOrRemoved(self: *SlotChangeMonitor, node: *parser.Node) !void {
-    if (parser.nodeType(node) != .element) {
-        return;
-    }
-    const el: *parser.Element = @ptrCast(node);
-    if (try findSlot(el, self.page)) |slot| {
-        return self.scheduleSlotChange(slot);
-    }
-}
-
-// An attribute was modified. If the attribute is "slot", then we'll trigger 1
-// slotchange for the old slot (if there was one) and 1 slotchange for the new
-// one (if there is one)
-fn nodeAttributeChanged(self: *SlotChangeMonitor, node: *parser.Node, new_value: ?[]const u8, prev_value: ?[]const u8) !void {
-    if (parser.nodeType(node) != .element) {
-        return;
-    }
-
-    const el: *parser.Element = @ptrCast(node);
-    if (try findNamedSlot(el, prev_value orelse "", self.page)) |slot| {
-        try self.scheduleSlotChange(slot);
-    }
-
-    if (try findNamedSlot(el, new_value orelse "", self.page)) |slot| {
-        try self.scheduleSlotChange(slot);
-    }
-}
-
-// OK. Our MutationEvent is not a MutationObserver - it's an older, deprecated
-// API. It gets dispatched in the middle of the change. While I'm sure it has
-// some rules, from our point of view, it fires too early. DOMAttrModified fires
-// before the attribute is actually updated and DOMNodeRemoved before the node
-// is actually removed. This is a problem if the callback will call
-// `slot.assignedNodes`, since that won't return the new state.
-// So, we use the page schedule to schedule the dispatching of the slotchange
-// event.
-fn scheduleSlotChange(self: *SlotChangeMonitor, slot: *parser.Slot) !void {
-    for (self.slots_changed.items) |changed| {
-        if (slot == changed) {
-            return;
-        }
-    }
-
-    try self.slots_changed.append(self.page.arena, slot);
-    if (self.slots_changed.items.len == 1) {
-        // first item added, schedule the callback
-        try self.page.scheduler.add(self, scheduleCallback, 0, .{ .name = "slot change" });
-    }
-}
-
-// Callback from the schedule. Time to dispatch the slotchange event
-fn scheduleCallback(ctx: *anyopaque) ?u32 {
-    var self: *SlotChangeMonitor = @ptrCast(@alignCast(ctx));
-    self._scheduleCallback() catch |err| {
-        log.err(.app, "slot change schedule", .{ .err = err });
-    };
-    return null;
-}
-
-fn _scheduleCallback(self: *SlotChangeMonitor) !void {
-    for (self.slots_changed.items) |slot| {
-        const event = try parser.eventCreate();
-        defer parser.eventDestroy(event);
-        try parser.eventInit(event, "slotchange", .{});
-        _ = try parser.eventTargetDispatchEvent(
-            parser.toEventTarget(parser.Element, @ptrCast(@alignCast(slot))),
-            event,
-        );
-    }
-    self.slots_changed.clearRetainingCapacity();
-}
--- a/src/browser/State.zig
+++ b/src/browser/State.zig
@@ -1,77 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-// Sometimes we need to extend libdom. For example, its HTMLDocument doesn't
-// have a readyState. We have a couple different options, such as making the
-// correction in libdom directly. Another option stems from the fact that every
-// libdom node has an opaque embedder_data field. This is the struct that we
-// lazily load into that field.
-//
-// It didn't originally start off as a collection of every single extension, but
-// this quickly proved necessary, since different fields are needed on the same
-// data at different levels of the prototype chain. This isn't memory efficient.
-
-const js = @import("js/js.zig");
-const parser = @import("netsurf.zig");
-const DataSet = @import("html/DataSet.zig");
-const ShadowRoot = @import("dom/shadow_root.zig").ShadowRoot;
-const StyleSheet = @import("cssom/StyleSheet.zig");
-const CSSStyleDeclaration = @import("cssom/CSSStyleDeclaration.zig");
-
-// for HTMLScript (but probably needs to be added to more)
-onload: ?js.Function = null,
-onerror: ?js.Function = null,
-
-// for HTMLElement
-style: CSSStyleDeclaration = .empty,
-dataset: ?DataSet = null,
-template_content: ?*parser.DocumentFragment = null,
-
-// For dom/element
-shadow_root: ?*ShadowRoot = null,
-
-// for html/document
-ready_state: ReadyState = .loading,
-
-// for html/HTMLStyleElement
-style_sheet: ?*StyleSheet = null,
-
-// for dom/document
-active_element: ?*parser.Element = null,
-adopted_style_sheets: ?js.Object = null,
-
-// for HTMLSelectElement
-// By default, if no option is explicitly selected, the first option should
-// be selected. However, libdom doesn't do this, and it sets the
-// selectedIndex to -1, which is a valid value for "nothing selected".
-// Therefore, when libdom says the selectedIndex == -1, we don't know if
-// it means that nothing is selected, or if the first option is selected by
-// default.
-// There are cases where this won't work, but when selectedIndex is
-// explicitly set, we set this boolean flag. Then, when we're getting then
-// selectedIndex, if this flag is == false, which is to say that if
-// selectedIndex hasn't been explicitly set AND if we have at least 1 option
-// AND if it isn't a multi select, we can make the 1st item selected by
-// default (by returning selectedIndex == 0).
-explicit_index_set: bool = false,
-
-const ReadyState = enum {
-    loading,
-    interactive,
-    complete,
-};
--- a/src/browser/browser.zig
+++ b/src/browser/browser.zig
@@ -17,103 +17,592 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

 const std = @import("std");
+const builtin = @import("builtin");

-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
+const Types = @import("root").Types;

-const js = @import("js/js.zig");
-const State = @import("State.zig");
-const App = @import("../app.zig").App;
-const Session = @import("session.zig").Session;
-const Notification = @import("../notification.zig").Notification;
+const parser = @import("netsurf");
+const Loader = @import("loader.zig").Loader;
+const Dump = @import("dump.zig");
+const Mime = @import("mime.zig");

-const log = @import("../log.zig");
-const HttpClient = @import("../http/Client.zig");
+const jsruntime = @import("jsruntime");
+const Loop = jsruntime.Loop;
+const Env = jsruntime.Env;
+
+const apiweb = @import("../apiweb.zig");
+
+const Window = @import("../html/window.zig").Window;
+const Walker = @import("../dom/walker.zig").WalkerDepthFirst;
+
+const storage = @import("../storage/storage.zig");
+
+const FetchResult = @import("../http/Client.zig").Client.FetchResult;
+
+const UserContext = @import("../user_context.zig").UserContext;
+const HttpClient = @import("asyncio").Client;
+
+const log = std.log.scoped(.browser);

 // Browser is an instance of the browser.
 // You can create multiple browser instances.
 // A browser contains only one session.
+// TODO allow multiple sessions per browser.
 pub const Browser = struct {
-    env: *js.Env,
-    app: *App,
-    session: ?Session,
-    allocator: Allocator,
-    http_client: *HttpClient,
-    call_arena: ArenaAllocator,
-    page_arena: ArenaAllocator,
-    session_arena: ArenaAllocator,
-    transfer_arena: ArenaAllocator,
-    notification: *Notification,
-    state_pool: std.heap.MemoryPool(State),
+    session: Session = undefined,

-    pub fn init(app: *App) !Browser {
-        const allocator = app.allocator;
+    const uri = "about:blank";

-        const env = try js.Env.init(allocator, &app.platform, .{});
-        errdefer env.deinit();
+    pub fn init(self: *Browser, alloc: std.mem.Allocator, loop: *Loop, vm: jsruntime.VM) !void {
+        // We want to ensure the caller initialised a VM, but the browser
+        // doesn't use it directly...
+        _ = vm;

-        const notification = try Notification.init(allocator, app.notification);
-        app.http.client.notification = notification;
-        app.http.client.next_request_id = 0; // Should we track ids in CDP only?
-        errdefer notification.deinit();
-
-        return .{
-            .app = app,
-            .env = env,
-            .session = null,
-            .allocator = allocator,
-            .notification = notification,
-            .http_client = app.http.client,
-            .call_arena = ArenaAllocator.init(allocator),
-            .page_arena = ArenaAllocator.init(allocator),
-            .session_arena = ArenaAllocator.init(allocator),
-            .transfer_arena = ArenaAllocator.init(allocator),
-            .state_pool = std.heap.MemoryPool(State).init(allocator),
-        };
+        try Session.init(&self.session, alloc, loop, uri);
    }

    pub fn deinit(self: *Browser) void {
-        self.closeSession();
-        self.env.deinit();
-        self.call_arena.deinit();
-        self.page_arena.deinit();
-        self.session_arena.deinit();
-        self.transfer_arena.deinit();
-        self.http_client.notification = null;
-        self.notification.deinit();
-        self.state_pool.deinit();
+        self.session.deinit();
    }

-    pub fn newSession(self: *Browser) !*Session {
-        self.closeSession();
-        self.session = @as(Session, undefined);
-        const session = &self.session.?;
-        try Session.init(session, self);
-        return session;
-    }
-
-    pub fn closeSession(self: *Browser) void {
-        if (self.session) |*session| {
-            session.deinit();
-            self.session = null;
-            _ = self.session_arena.reset(.{ .retain_with_limit = 1 * 1024 * 1024 });
-            self.env.lowMemoryNotification();
-        }
-    }
-
-    pub fn runMicrotasks(self: *const Browser) void {
-        self.env.runMicrotasks();
-    }
-
-    pub fn runMessageLoop(self: *const Browser) void {
-        while (self.env.pumpMessageLoop()) {
-            log.debug(.browser, "pumpMessageLoop", .{});
-        }
-        self.env.runIdleTasks();
+    pub fn newSession(
+        self: *Browser,
+        alloc: std.mem.Allocator,
+        loop: *jsruntime.Loop,
+    ) !void {
+        self.session.deinit();
+        try Session.init(&self.session, alloc, loop, uri);
    }
 };

-const testing = @import("../testing.zig");
-test "Browser" {
-    try testing.htmlRunner("browser.html");
-}
+// Session is like a browser's tab.
+// It owns the js env and the loader for all the pages of the session.
+// You can create successively multiple pages for a session, but you must
+// deinit a page before running another one.
+pub const Session = struct {
+    // allocator used to init the arena.
+    alloc: std.mem.Allocator,
+
+    // The arena is used only to bound the js env init b/c it leaks memory.
+    // see https://github.com/lightpanda-io/jsruntime-lib/issues/181
+    //
+    // The arena is initialised with self.alloc allocator.
+    // all others Session deps use directly self.alloc and not the arena.
+    arena: std.heap.ArenaAllocator,
+
+    uri: []const u8,
+
+    // TODO handle proxy
+    loader: Loader,
+    env: Env = undefined,
+    inspector: ?jsruntime.Inspector = null,
+    window: Window,
+    // TODO move the shed to the browser?
+    storageShed: storage.Shed,
+    page: ?Page = null,
+    httpClient: HttpClient,
+
+    jstypes: [Types.len]usize = undefined,
+
+    fn init(self: *Session, alloc: std.mem.Allocator, loop: *Loop, uri: []const u8) !void {
+        self.* = Session{
+            .uri = uri,
+            .alloc = alloc,
+            .arena = std.heap.ArenaAllocator.init(alloc),
+            .window = Window.create(null),
+            .loader = Loader.init(alloc),
+            .storageShed = storage.Shed.init(alloc),
+            .httpClient = undefined,
+        };
+
+        Env.init(&self.env, self.arena.allocator(), loop, null);
+        self.httpClient = .{ .allocator = alloc };
+        try self.env.load(&self.jstypes);
+    }
+
+    fn deinit(self: *Session) void {
+        if (self.page) |*p| p.end();
+
+        if (self.inspector) |inspector| {
+            inspector.deinit(self.alloc);
+        }
+
+        self.env.deinit();
+        self.arena.deinit();
+
+        self.httpClient.deinit();
+        self.loader.deinit();
+        self.storageShed.deinit();
+    }
+
+    pub fn initInspector(
+        self: *Session,
+        ctx: anytype,
+        onResp: jsruntime.InspectorOnResponseFn,
+        onEvent: jsruntime.InspectorOnEventFn,
+    ) !void {
+        const ctx_opaque = @as(*anyopaque, @ptrCast(ctx));
+        self.inspector = try jsruntime.Inspector.init(self.alloc, self.env, ctx_opaque, onResp, onEvent);
+        self.env.setInspector(self.inspector.?);
+    }
+
+    pub fn callInspector(self: *Session, msg: []const u8) void {
+        if (self.inspector) |inspector| {
+            inspector.send(msg, self.env);
+        } else {
+            @panic("No Inspector");
+        }
+    }
+
+    // NOTE: the caller is not the owner of the returned value,
+    // the pointer on Page is just returned as a convenience
+    pub fn createPage(self: *Session) !*Page {
+        if (self.page != null) return error.SessionPageExists;
+        const p: Page = undefined;
+        self.page = p;
+        Page.init(&self.page.?, self.alloc, self);
+        return &self.page.?;
+    }
+};
+
+// Page navigates to an url.
+// You can navigates multiple urls with the same page, but you have to call
+// end() to stop the previous navigation before starting a new one.
+// The page handle all its memory in an arena allocator. The arena is reseted
+// when end() is called.
+pub const Page = struct {
+    arena: std.heap.ArenaAllocator,
+    session: *Session,
+    doc: ?*parser.Document = null,
+
+    // handle url
+    rawuri: ?[]const u8 = null,
+    uri: std.Uri = undefined,
+    origin: ?[]const u8 = null,
+
+    raw_data: ?[]const u8 = null,
+
+    fn init(
+        self: *Page,
+        alloc: std.mem.Allocator,
+        session: *Session,
+    ) void {
+        self.* = .{
+            .arena = std.heap.ArenaAllocator.init(alloc),
+            .session = session,
+        };
+    }
+
+    // reset js env and mem arena.
+    pub fn end(self: *Page) void {
+        self.session.env.stop();
+        // TODO unload document: https://html.spec.whatwg.org/#unloading-documents
+
+        // clear netsurf memory arena.
+        parser.deinit();
+
+        _ = self.arena.reset(.free_all);
+    }
+
+    pub fn deinit(self: *Page) void {
+        self.arena.deinit();
+        self.session.page = null;
+    }
+
+    // dump writes the page content into the given file.
+    pub fn dump(self: *Page, out: std.fs.File) !void {
+
+        // if no HTML document pointer available, dump the data content only.
+        if (self.doc == null) {
+            // no data loaded, nothing to do.
+            if (self.raw_data == null) return;
+            return try out.writeAll(self.raw_data.?);
+        }
+
+        // if the page has a pointer to a document, dumps the HTML.
+        try Dump.writeHTML(self.doc.?, out);
+    }
+
+    pub fn wait(self: *Page) !void {
+
+        // try catch
+        var try_catch: jsruntime.TryCatch = undefined;
+        try_catch.init(self.session.env);
+        defer try_catch.deinit();
+
+        self.session.env.wait() catch |err| {
+            // the js env could not be started if the document wasn't an HTML.
+            if (err == error.EnvNotStarted) return;
+
+            const alloc = self.arena.allocator();
+            if (try try_catch.err(alloc, self.session.env)) |msg| {
+                defer alloc.free(msg);
+                log.info("wait error: {s}", .{msg});
+                return;
+            }
+        };
+        log.debug("wait: OK", .{});
+    }
+
+    // spec reference: https://html.spec.whatwg.org/#document-lifecycle
+    // - auxData: extra data forwarded to the Inspector
+    // see Inspector.contextCreated
+    pub fn navigate(self: *Page, uri: []const u8, auxData: ?[]const u8) !void {
+        const alloc = self.arena.allocator();
+
+        log.debug("starting GET {s}", .{uri});
+
+        // own the url
+        if (self.rawuri) |prev| alloc.free(prev);
+        self.rawuri = try alloc.dupe(u8, uri);
+        self.uri = std.Uri.parse(self.rawuri.?) catch try std.Uri.parseAfterScheme("", self.rawuri.?);
+
+        // prepare origin value.
+        var buf = std.ArrayList(u8).init(alloc);
+        defer buf.deinit();
+        try self.uri.writeToStream(.{
+            .scheme = true,
+            .authority = true,
+        }, buf.writer());
+        self.origin = try buf.toOwnedSlice();
+
+        // TODO handle fragment in url.
+
+        // load the data
+        var resp = try self.session.loader.get(alloc, self.uri);
+        defer resp.deinit();
+
+        const req = resp.req;
+
+        log.info("GET {any} {d}", .{ self.uri, req.response.status });
+
+        // TODO handle redirection
+        if (req.response.status != .ok) {
+            log.debug("{?} {d} {s}", .{
+                req.response.version,
+                req.response.status,
+                req.response.reason,
+                // TODO log headers
+            });
+            return error.BadStatusCode;
+        }
+
+        // TODO handle charset
+        // https://html.spec.whatwg.org/#content-type
+        var it = req.response.iterateHeaders();
+        var ct: ?[]const u8 = null;
+        while (true) {
+            const h = it.next() orelse break;
+            if (std.ascii.eqlIgnoreCase(h.name, "Content-Type")) {
+                ct = try alloc.dupe(u8, h.value);
+            }
+        }
+        if (ct == null) {
+            // no content type in HTTP headers.
+            // TODO try to sniff mime type from the body.
+            log.info("no content-type HTTP header", .{});
+            return;
+        }
+        defer alloc.free(ct.?);
+
+        log.debug("header content-type: {s}", .{ct.?});
+        const mime = try Mime.parse(ct.?);
+        if (mime.eql(Mime.HTML)) {
+            try self.loadHTMLDoc(req.reader(), mime.charset orelse "utf-8", auxData);
+        } else {
+            log.info("non-HTML document: {s}", .{ct.?});
+
+            // save the body into the page.
+            self.raw_data = try req.reader().readAllAlloc(alloc, 16 * 1024 * 1024);
+        }
+    }
+
+    // https://html.spec.whatwg.org/#read-html
+    fn loadHTMLDoc(self: *Page, reader: anytype, charset: []const u8, auxData: ?[]const u8) !void {
+        const alloc = self.arena.allocator();
+
+        // start netsurf memory arena.
+        try parser.init();
+
+        log.debug("parse html with charset {s}", .{charset});
+
+        const ccharset = try alloc.dupeZ(u8, charset);
+        defer alloc.free(ccharset);
+
+        const html_doc = try parser.documentHTMLParse(reader, ccharset);
+        const doc = parser.documentHTMLToDocument(html_doc);
+
+        // save a document's pointer in the page.
+        self.doc = doc;
+
+        // TODO set document.readyState to interactive
+        // https://html.spec.whatwg.org/#reporting-document-loading-status
+
+        // inject the URL to the document including the fragment.
+        try parser.documentSetDocumentURI(doc, self.rawuri orelse "about:blank");
+
+        // TODO set the referrer to the document.
+
+        self.session.window.replaceDocument(html_doc);
+        self.session.window.setStorageShelf(
+            try self.session.storageShed.getOrPut(self.origin orelse "null"),
+        );
+
+        // https://html.spec.whatwg.org/#read-html
+
+        // start JS env
+        // TODO load the js env concurrently with the HTML parsing.
+        log.debug("start js env", .{});
+        try self.session.env.start();
+
+        // inspector
+        if (self.session.inspector) |inspector| {
+            inspector.contextCreated(self.session.env, "", self.origin.?, auxData);
+        }
+
+        // replace the user context document with the new one.
+        try self.session.env.setUserContext(.{
+            .document = html_doc,
+            .httpClient = &self.session.httpClient,
+        });
+
+        // add global objects
+        log.debug("setup global env", .{});
+        try self.session.env.bindGlobal(&self.session.window);
+
+        // browse the DOM tree to retrieve scripts
+        // TODO execute the synchronous scripts during the HTL parsing.
+        // TODO fetch the script resources concurrently but execute them in the
+        // declaration order for synchronous ones.
+
+        // sasync stores scripts which can be run asynchronously.
+        // for now they are just run after the non-async one in order to
+        // dispatch DOMContentLoaded the sooner as possible.
+        var sasync = std.ArrayList(*parser.Element).init(alloc);
+        defer sasync.deinit();
+
+        const root = parser.documentToNode(doc);
+        const walker = Walker{};
+        var next: ?*parser.Node = null;
+        while (true) {
+            next = try walker.get_next(root, next) orelse break;
+
+            // ignore non-elements nodes.
+            if (try parser.nodeType(next.?) != .element) {
+                continue;
+            }
+
+            const e = parser.nodeToElement(next.?);
+            const tag = try parser.elementHTMLGetTagType(@as(*parser.ElementHTML, @ptrCast(e)));
+
+            // ignore non-script tags
+            if (tag != .script) continue;
+
+            // ignore non-js script.
+            // > type
+            // > Attribute is not set (default), an empty string, or a JavaScript MIME
+            // > type indicates that the script is a "classic script", containing
+            // > JavaScript code.
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attribute_is_not_set_default_an_empty_string_or_a_javascript_mime_type
+            const stype = try parser.elementGetAttribute(e, "type");
+            if (!isJS(stype)) {
+                continue;
+            }
+
+            // Ignore the defer attribute b/c we analyze all script
+            // after the document has been parsed.
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#defer
+
+            // TODO use fetchpriority
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#fetchpriority
+
+            // > async
+            // > For classic scripts, if the async attribute is present,
+            // > then the classic script will be fetched in parallel to
+            // > parsing and evaluated as soon as it is available.
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#async
+            if (try parser.elementGetAttribute(e, "async") != null) {
+                try sasync.append(e);
+                continue;
+            }
+
+            // TODO handle for attribute
+            // TODO handle event attribute
+
+            // TODO defer
+            // > This Boolean attribute is set to indicate to a browser
+            // > that the script is meant to be executed after the
+            // > document has been parsed, but before firing
+            // > DOMContentLoaded.
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#defer
+            // defer allow us to load a script w/o blocking the rest of
+            // evaluations.
+
+            // > Scripts without async, defer or type="module"
+            // > attributes, as well as inline scripts without the
+            // > type="module" attribute, are fetched and executed
+            // > immediately before the browser continues to parse the
+            // > page.
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#notes
+            try parser.documentHTMLSetCurrentScript(html_doc, @ptrCast(e));
+            self.evalScript(e) catch |err| log.warn("evaljs: {any}", .{err});
+            try parser.documentHTMLSetCurrentScript(html_doc, null);
+        }
+
+        // TODO wait for deferred scripts
+
+        // dispatch DOMContentLoaded before the transition to "complete",
+        // at the point where all subresources apart from async script elements
+        // have loaded.
+        // https://html.spec.whatwg.org/#reporting-document-loading-status
+        const evt = try parser.eventCreate();
+        defer parser.eventDestroy(evt);
+
+        try parser.eventInit(evt, "DOMContentLoaded", .{ .bubbles = true, .cancelable = true });
+        _ = try parser.eventTargetDispatchEvent(parser.toEventTarget(parser.DocumentHTML, html_doc), evt);
+
+        // eval async scripts.
+        for (sasync.items) |e| {
+            try parser.documentHTMLSetCurrentScript(html_doc, @ptrCast(e));
+            self.evalScript(e) catch |err| log.warn("evaljs: {any}", .{err});
+            try parser.documentHTMLSetCurrentScript(html_doc, null);
+        }
+
+        // TODO wait for async scripts
+
+        // TODO set document.readyState to complete
+
+        // dispatch window.load event
+        const loadevt = try parser.eventCreate();
+        defer parser.eventDestroy(loadevt);
+
+        try parser.eventInit(loadevt, "load", .{});
+        _ = try parser.eventTargetDispatchEvent(
+            parser.toEventTarget(Window, &self.session.window),
+            loadevt,
+        );
+    }
+
+    // evalScript evaluates the src in priority.
+    // if no src is present, we evaluate the text source.
+    // https://html.spec.whatwg.org/multipage/scripting.html#script-processing-model
+    fn evalScript(self: *Page, e: *parser.Element) !void {
+        const alloc = self.arena.allocator();
+
+        // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-classic-script
+        const opt_src = try parser.elementGetAttribute(e, "src");
+        if (opt_src) |src| {
+            log.debug("starting GET {s}", .{src});
+
+            self.fetchScript(src) catch |err| {
+                switch (err) {
+                    FetchError.BadStatusCode => return err,
+
+                    // TODO If el's result is null, then fire an event named error at
+                    // el, and return.
+                    FetchError.NoBody => return,
+
+                    FetchError.JsErr => {}, // nothing to do here.
+                    else => return err,
+                }
+            };
+
+            // TODO If el's from an external file is true, then fire an event
+            // named load at el.
+
+            return;
+        }
+
+        var try_catch: jsruntime.TryCatch = undefined;
+        try_catch.init(self.session.env);
+        defer try_catch.deinit();
+
+        const opt_text = try parser.nodeTextContent(parser.elementToNode(e));
+        if (opt_text) |text| {
+            // TODO handle charset attribute
+            const res = self.session.env.exec(text, "") catch {
+                if (try try_catch.err(alloc, self.session.env)) |msg| {
+                    defer alloc.free(msg);
+                    log.info("eval inline {s}: {s}", .{ text, msg });
+                }
+                return;
+            };
+
+            if (builtin.mode == .Debug) {
+                const msg = try res.toString(alloc, self.session.env);
+                defer alloc.free(msg);
+                log.debug("eval inline {s}", .{msg});
+            }
+            return;
+        }
+
+        // nothing has been loaded.
+        // TODO If el's result is null, then fire an event named error at
+        // el, and return.
+    }
+
+    const FetchError = error{
+        BadStatusCode,
+        NoBody,
+        JsErr,
+    };
+
+    // fetchScript senf a GET request to the src and execute the script
+    // received.
+    fn fetchScript(self: *Page, src: []const u8) !void {
+        const alloc = self.arena.allocator();
+
+        log.debug("starting fetch script {s}", .{src});
+
+        var buffer: [1024]u8 = undefined;
+        var b: []u8 = buffer[0..];
+        const u = try std.Uri.resolve_inplace(self.uri, src, &b);
+
+        var fetchres = try self.session.loader.get(alloc, u);
+        defer fetchres.deinit();
+
+        const resp = fetchres.req.response;
+
+        log.info("fetch script {any}: {d}", .{ u, resp.status });
+
+        if (resp.status != .ok) return FetchError.BadStatusCode;
+
+        // TODO check content-type
+        const body = try fetchres.req.reader().readAllAlloc(alloc, 16 * 1024 * 1024);
+        defer alloc.free(body);
+
+        // check no body
+        if (body.len == 0) return FetchError.NoBody;
+
+        var try_catch: jsruntime.TryCatch = undefined;
+        try_catch.init(self.session.env);
+        defer try_catch.deinit();
+
+        const res = self.session.env.exec(body, src) catch {
+            if (try try_catch.err(alloc, self.session.env)) |msg| {
+                defer alloc.free(msg);
+                log.info("eval remote {s}: {s}", .{ src, msg });
+            }
+            return FetchError.JsErr;
+        };
+
+        if (builtin.mode == .Debug) {
+            const msg = try res.toString(alloc, self.session.env);
+            defer alloc.free(msg);
+            log.debug("eval remote {s}: {s}", .{ src, msg });
+        }
+    }
+
+    // > type
+    // > Attribute is not set (default), an empty string, or a JavaScript MIME
+    // > type indicates that the script is a "classic script", containing
+    // > JavaScript code.
+    // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attribute_is_not_set_default_an_empty_string_or_a_javascript_mime_type
+    fn isJS(stype: ?[]const u8) bool {
+        if (stype == null or stype.?.len == 0) return true;
+        if (std.mem.eql(u8, stype.?, "application/javascript")) return true;
+        if (!std.mem.eql(u8, stype.?, "module")) return true;
+
+        return false;
+    }
+};
--- a/src/browser/console/console.zig
+++ b/src/browser/console/console.zig
@@ -1,177 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const builtin = @import("builtin");
-const log = @import("../../log.zig");
-
-const js = @import("../js/js.zig");
-const Page = @import("../page.zig").Page;
-
-pub const Console = struct {
-    // TODO: configurable writer
-    timers: std.StringHashMapUnmanaged(u32) = .{},
-    counts: std.StringHashMapUnmanaged(u32) = .{},
-
-    pub fn _lp(values: []js.Object, page: *Page) !void {
-        if (values.len == 0) {
-            return;
-        }
-        log.fatal(.console, "lightpanda", .{ .args = try serializeValues(values, page) });
-    }
-
-    pub fn _log(values: []js.Object, page: *Page) !void {
-        if (values.len == 0) {
-            return;
-        }
-        log.info(.console, "info", .{ .args = try serializeValues(values, page) });
-    }
-
-    pub fn _info(values: []js.Object, page: *Page) !void {
-        return _log(values, page);
-    }
-
-    pub fn _debug(values: []js.Object, page: *Page) !void {
-        if (values.len == 0) {
-            return;
-        }
-        log.debug(.console, "debug", .{ .args = try serializeValues(values, page) });
-    }
-
-    pub fn _warn(values: []js.Object, page: *Page) !void {
-        if (values.len == 0) {
-            return;
-        }
-        log.warn(.console, "warn", .{ .args = try serializeValues(values, page) });
-    }
-
-    pub fn _error(values: []js.Object, page: *Page) !void {
-        if (values.len == 0) {
-            return;
-        }
-
-        log.warn(.console, "error", .{
-            .args = try serializeValues(values, page),
-            .stack = page.stackTrace() catch "???",
-        });
-    }
-
-    pub fn _trace(values: []js.Object, page: *Page) !void {
-        if (values.len == 0) {
-            return;
-        }
-        log.debug(.console, "debug", .{
-            .stack = page.js.stackTrace() catch "???",
-            .args = try serializeValues(values, page),
-        });
-    }
-
-    pub fn _clear() void {}
-
-    pub fn _count(self: *Console, label_: ?[]const u8, page: *Page) !void {
-        const label = label_ orelse "default";
-        const gop = try self.counts.getOrPut(page.arena, label);
-
-        var current: u32 = 0;
-        if (gop.found_existing) {
-            current = gop.value_ptr.*;
-        } else {
-            gop.key_ptr.* = try page.arena.dupe(u8, label);
-        }
-
-        const count = current + 1;
-        gop.value_ptr.* = count;
-
-        log.info(.console, "count", .{ .label = label, .count = count });
-    }
-
-    pub fn _countReset(self: *Console, label_: ?[]const u8) !void {
-        const label = label_ orelse "default";
-        const kv = self.counts.fetchRemove(label) orelse {
-            log.info(.console, "invalid counter", .{ .label = label });
-            return;
-        };
-        log.info(.console, "count reset", .{ .label = label, .count = kv.value });
-    }
-
-    pub fn _time(self: *Console, label_: ?[]const u8, page: *Page) !void {
-        const label = label_ orelse "default";
-        const gop = try self.timers.getOrPut(page.arena, label);
-
-        if (gop.found_existing) {
-            log.info(.console, "duplicate timer", .{ .label = label });
-            return;
-        }
-        gop.key_ptr.* = try page.arena.dupe(u8, label);
-        gop.value_ptr.* = timestamp();
-    }
-
-    pub fn _timeLog(self: *Console, label_: ?[]const u8) void {
-        const elapsed = timestamp();
-        const label = label_ orelse "default";
-        const start = self.timers.get(label) orelse {
-            log.info(.console, "invalid timer", .{ .label = label });
-            return;
-        };
-        log.info(.console, "timer", .{ .label = label, .elapsed = elapsed - start });
-    }
-
-    pub fn _timeStop(self: *Console, label_: ?[]const u8) void {
-        const elapsed = timestamp();
-        const label = label_ orelse "default";
-        const kv = self.timers.fetchRemove(label) orelse {
-            log.info(.console, "invalid timer", .{ .label = label });
-            return;
-        };
-
-        log.warn(.console, "timer stop", .{ .label = label, .elapsed = elapsed - kv.value });
-    }
-
-    pub fn _assert(assertion: js.Object, values: []js.Object, page: *Page) !void {
-        if (assertion.isTruthy()) {
-            return;
-        }
-        var serialized_values: []const u8 = "";
-        if (values.len > 0) {
-            serialized_values = try serializeValues(values, page);
-        }
-        log.info(.console, "assertion failed", .{ .values = serialized_values });
-    }
-
-    fn serializeValues(values: []js.Object, page: *Page) ![]const u8 {
-        if (values.len == 0) {
-            return "";
-        }
-
-        const arena = page.call_arena;
-        const separator = log.separator();
-        var arr: std.ArrayListUnmanaged(u8) = .{};
-
-        for (values, 1..) |value, i| {
-            try arr.appendSlice(arena, separator);
-            try arr.writer(arena).print("{d}: ", .{i});
-            const serialized = if (builtin.mode == .Debug) value.toDetailString() else value.toString();
-            try arr.appendSlice(arena, try serialized);
-        }
-        return arr.items;
-    }
-};
-
-fn timestamp() u32 {
-    return @import("../../datetime.zig").timestamp();
-}
--- a/src/browser/crypto/crypto.zig
+++ b/src/browser/crypto/crypto.zig
@@ -1,71 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const uuidv4 = @import("../../id.zig").uuidv4;
-
-// https://w3c.github.io/webcrypto/#crypto-interface
-pub const Crypto = struct {
-    _not_empty: bool = true,
-
-    pub fn _getRandomValues(_: *const Crypto, js_obj: js.Object) !js.Object {
-        var into = try js_obj.toZig(Crypto, "getRandomValues", RandomValues);
-        const buf = into.asBuffer();
-        if (buf.len > 65_536) {
-            return error.QuotaExceededError;
-        }
-        std.crypto.random.bytes(buf);
-        return js_obj;
-    }
-
-    pub fn _randomUUID(_: *const Crypto) [36]u8 {
-        var hex: [36]u8 = undefined;
-        uuidv4(&hex);
-        return hex;
-    }
-};
-
-const RandomValues = union(enum) {
-    int8: []i8,
-    uint8: []u8,
-    int16: []i16,
-    uint16: []u16,
-    int32: []i32,
-    uint32: []u32,
-    int64: []i64,
-    uint64: []u64,
-
-    fn asBuffer(self: RandomValues) []u8 {
-        return switch (self) {
-            .int8 => |b| (@as([]u8, @ptrCast(b)))[0..b.len],
-            .uint8 => |b| (@as([]u8, @ptrCast(b)))[0..b.len],
-            .int16 => |b| (@as([]u8, @ptrCast(b)))[0 .. b.len * 2],
-            .uint16 => |b| (@as([]u8, @ptrCast(b)))[0 .. b.len * 2],
-            .int32 => |b| (@as([]u8, @ptrCast(b)))[0 .. b.len * 4],
-            .uint32 => |b| (@as([]u8, @ptrCast(b)))[0 .. b.len * 4],
-            .int64 => |b| (@as([]u8, @ptrCast(b)))[0 .. b.len * 8],
-            .uint64 => |b| (@as([]u8, @ptrCast(b)))[0 .. b.len * 8],
-        };
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: Crypto" {
-    try testing.htmlRunner("crypto.html");
-}
--- a/src/browser/css/selector.zig
+++ b/src/browser/css/selector.zig
--- a/src/browser/cssom/CSSParser.zig
+++ b/src/browser/cssom/CSSParser.zig
@@ -1,289 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const CSSConstants = struct {
-    const IMPORTANT = "!important";
-    const URL_PREFIX = "url(";
-};
-
-const CSSParserState = enum {
-    seek_name,
-    in_name,
-    seek_colon,
-    seek_value,
-    in_value,
-    in_quoted_value,
-    in_single_quoted_value,
-    in_url,
-    in_important,
-};
-
-const CSSDeclaration = struct {
-    name: []const u8,
-    value: []const u8,
-    is_important: bool,
-};
-
-const CSSParser = @This();
-state: CSSParserState,
-name_start: usize,
-name_end: usize,
-value_start: usize,
-position: usize,
-paren_depth: usize,
-escape_next: bool,
-
-pub fn init() CSSParser {
-    return .{
-        .state = .seek_name,
-        .name_start = 0,
-        .name_end = 0,
-        .value_start = 0,
-        .position = 0,
-        .paren_depth = 0,
-        .escape_next = false,
-    };
-}
-
-pub fn parseDeclarations(arena: Allocator, text: []const u8) ![]CSSDeclaration {
-    var parser = init();
-    var declarations: std.ArrayListUnmanaged(CSSDeclaration) = .empty;
-
-    while (parser.position < text.len) {
-        const c = text[parser.position];
-
-        switch (parser.state) {
-            .seek_name => {
-                if (!std.ascii.isWhitespace(c)) {
-                    parser.name_start = parser.position;
-                    parser.state = .in_name;
-                    continue;
-                }
-            },
-            .in_name => {
-                if (c == ':') {
-                    parser.name_end = parser.position;
-                    parser.state = .seek_value;
-                } else if (std.ascii.isWhitespace(c)) {
-                    parser.name_end = parser.position;
-                    parser.state = .seek_colon;
-                }
-            },
-            .seek_colon => {
-                if (c == ':') {
-                    parser.state = .seek_value;
-                } else if (!std.ascii.isWhitespace(c)) {
-                    parser.state = .seek_name;
-                    continue;
-                }
-            },
-            .seek_value => {
-                if (!std.ascii.isWhitespace(c)) {
-                    parser.value_start = parser.position;
-                    if (c == '"') {
-                        parser.state = .in_quoted_value;
-                    } else if (c == '\'') {
-                        parser.state = .in_single_quoted_value;
-                    } else if (c == 'u' and parser.position + CSSConstants.URL_PREFIX.len <= text.len and std.mem.startsWith(u8, text[parser.position..], CSSConstants.URL_PREFIX)) {
-                        parser.state = .in_url;
-                        parser.paren_depth = 1;
-                        parser.position += 3;
-                    } else {
-                        parser.state = .in_value;
-                        continue;
-                    }
-                }
-            },
-            .in_value => {
-                if (parser.escape_next) {
-                    parser.escape_next = false;
-                } else if (c == '\\') {
-                    parser.escape_next = true;
-                } else if (c == '(') {
-                    parser.paren_depth += 1;
-                } else if (c == ')' and parser.paren_depth > 0) {
-                    parser.paren_depth -= 1;
-                } else if (c == ';' and parser.paren_depth == 0) {
-                    try parser.finishDeclaration(arena, &declarations, text);
-                    parser.state = .seek_name;
-                }
-            },
-            .in_quoted_value => {
-                if (parser.escape_next) {
-                    parser.escape_next = false;
-                } else if (c == '\\') {
-                    parser.escape_next = true;
-                } else if (c == '"') {
-                    parser.state = .in_value;
-                }
-            },
-            .in_single_quoted_value => {
-                if (parser.escape_next) {
-                    parser.escape_next = false;
-                } else if (c == '\\') {
-                    parser.escape_next = true;
-                } else if (c == '\'') {
-                    parser.state = .in_value;
-                }
-            },
-            .in_url => {
-                if (parser.escape_next) {
-                    parser.escape_next = false;
-                } else if (c == '\\') {
-                    parser.escape_next = true;
-                } else if (c == '(') {
-                    parser.paren_depth += 1;
-                } else if (c == ')') {
-                    parser.paren_depth -= 1;
-                    if (parser.paren_depth == 0) {
-                        parser.state = .in_value;
-                    }
-                }
-            },
-            .in_important => {},
-        }
-
-        parser.position += 1;
-    }
-
-    try parser.finalize(arena, &declarations, text);
-
-    return declarations.items;
-}
-
-fn finishDeclaration(self: *CSSParser, arena: Allocator, declarations: *std.ArrayListUnmanaged(CSSDeclaration), text: []const u8) !void {
-    const name = std.mem.trim(u8, text[self.name_start..self.name_end], &std.ascii.whitespace);
-    if (name.len == 0) return;
-
-    const raw_value = text[self.value_start..self.position];
-    const value = std.mem.trim(u8, raw_value, &std.ascii.whitespace);
-
-    var final_value = value;
-    var is_important = false;
-
-    if (std.mem.endsWith(u8, value, CSSConstants.IMPORTANT)) {
-        is_important = true;
-        final_value = std.mem.trimRight(u8, value[0 .. value.len - CSSConstants.IMPORTANT.len], &std.ascii.whitespace);
-    }
-
-    try declarations.append(arena, .{
-        .name = name,
-        .value = final_value,
-        .is_important = is_important,
-    });
-}
-
-fn finalize(self: *CSSParser, arena: Allocator, declarations: *std.ArrayListUnmanaged(CSSDeclaration), text: []const u8) !void {
-    if (self.state != .in_value) {
-        return;
-    }
-    return self.finishDeclaration(arena, declarations, text);
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: CSS.Parser - Simple property" {
-    defer testing.reset();
-
-    const text = "color: red;";
-    const allocator = testing.arena_allocator;
-
-    const declarations = try CSSParser.parseDeclarations(allocator, text);
-
-    try testing.expectEqual(1, declarations.len);
-    try testing.expectEqual("color", declarations[0].name);
-    try testing.expectEqual("red", declarations[0].value);
-    try testing.expectEqual(false, declarations[0].is_important);
-}
-
-test "Browser: CSS.Parser - Property with !important" {
-    defer testing.reset();
-    const text = "margin: 10px !important;";
-    const allocator = testing.arena_allocator;
-
-    const declarations = try CSSParser.parseDeclarations(allocator, text);
-
-    try testing.expectEqual(1, declarations.len);
-    try testing.expectEqual("margin", declarations[0].name);
-    try testing.expectEqual("10px", declarations[0].value);
-    try testing.expectEqual(true, declarations[0].is_important);
-}
-
-test "Browser: CSS.Parser - Multiple properties" {
-    defer testing.reset();
-    const text = "color: red; font-size: 12px; margin: 5px !important;";
-    const allocator = testing.arena_allocator;
-
-    const declarations = try CSSParser.parseDeclarations(allocator, text);
-
-    try testing.expect(declarations.len == 3);
-
-    try testing.expectEqual("color", declarations[0].name);
-    try testing.expectEqual("red", declarations[0].value);
-    try testing.expectEqual(false, declarations[0].is_important);
-
-    try testing.expectEqual("font-size", declarations[1].name);
-    try testing.expectEqual("12px", declarations[1].value);
-    try testing.expectEqual(false, declarations[1].is_important);
-
-    try testing.expectEqual("margin", declarations[2].name);
-    try testing.expectEqual("5px", declarations[2].value);
-    try testing.expectEqual(true, declarations[2].is_important);
-}
-
-test "Browser: CSS.Parser - Quoted value with semicolon" {
-    defer testing.reset();
-    const text = "content: \"Hello; world!\";";
-    const allocator = testing.arena_allocator;
-
-    const declarations = try CSSParser.parseDeclarations(allocator, text);
-
-    try testing.expectEqual(1, declarations.len);
-    try testing.expectEqual("content", declarations[0].name);
-    try testing.expectEqual("\"Hello; world!\"", declarations[0].value);
-    try testing.expectEqual(false, declarations[0].is_important);
-}
-
-test "Browser: CSS.Parser - URL value" {
-    defer testing.reset();
-    const text = "background-image: url(\"test.png\");";
-    const allocator = testing.arena_allocator;
-
-    const declarations = try CSSParser.parseDeclarations(allocator, text);
-
-    try testing.expectEqual(1, declarations.len);
-    try testing.expectEqual("background-image", declarations[0].name);
-    try testing.expectEqual("url(\"test.png\")", declarations[0].value);
-    try testing.expectEqual(false, declarations[0].is_important);
-}
-
-test "Browser: CSS.Parser - Whitespace handling" {
-    defer testing.reset();
-    const text = "  color  :  purple  ;  margin  :  10px  ;  ";
-    const allocator = testing.arena_allocator;
-
-    const declarations = try CSSParser.parseDeclarations(allocator, text);
-
-    try testing.expectEqual(2, declarations.len);
-    try testing.expectEqual("color", declarations[0].name);
-    try testing.expectEqual("purple", declarations[0].value);
-    try testing.expectEqual("margin", declarations[1].name);
-    try testing.expectEqual("10px", declarations[1].value);
-}
--- a/src/browser/cssom/CSSRuleList.zig
+++ b/src/browser/cssom/CSSRuleList.zig
@@ -1,51 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const CSSRule = @import("CSSRule.zig");
-
-const CSSImportRule = CSSRule.CSSImportRule;
-
-const CSSRuleList = @This();
-list: std.ArrayListUnmanaged([]const u8),
-
-pub fn constructor() CSSRuleList {
-    return .{ .list = .empty };
-}
-
-pub fn _item(self: *CSSRuleList, _index: u32) ?CSSRule {
-    const index: usize = @intCast(_index);
-
-    if (index > self.list.items.len) {
-        return null;
-    }
-
-    // todo: for now, just return null.
-    // this depends on properly parsing CSSRule
-    return null;
-}
-
-pub fn get_length(self: *CSSRuleList) u32 {
-    return @intCast(self.list.items.len);
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: CSS.CSSRuleList" {
-    try testing.htmlRunner("cssom/css_rule_list.html");
-}
--- a/src/browser/cssom/CSSStyleDeclaration.zig
+++ b/src/browser/cssom/CSSStyleDeclaration.zig
@@ -1,958 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const Page = @import("../page.zig").Page;
-const CSSRule = @import("CSSRule.zig");
-const CSSParser = @import("CSSParser.zig");
-
-const Property = struct {
-    value: []const u8,
-    priority: bool,
-};
-
-const CSSStyleDeclaration = @This();
-
-properties: std.StringArrayHashMapUnmanaged(Property),
-
-pub const empty: CSSStyleDeclaration = .{
-    .properties = .empty,
-};
-
-pub fn get_cssFloat(self: *const CSSStyleDeclaration) []const u8 {
-    return self._getPropertyValue("float");
-}
-
-pub fn set_cssFloat(self: *CSSStyleDeclaration, value: ?[]const u8, page: *Page) !void {
-    const final_value = value orelse "";
-    return self._setProperty("float", final_value, null, page);
-}
-
-pub fn get_cssText(self: *const CSSStyleDeclaration, page: *Page) ![]const u8 {
-    var buffer: std.ArrayListUnmanaged(u8) = .empty;
-    const writer = buffer.writer(page.call_arena);
-    var it = self.properties.iterator();
-    while (it.next()) |entry| {
-        const name = entry.key_ptr.*;
-        const property = entry.value_ptr;
-        const escaped = try escapeCSSValue(page.call_arena, property.value);
-        try writer.print("{s}: {s}", .{ name, escaped });
-        if (property.priority) {
-            try writer.writeAll(" !important; ");
-        } else {
-            try writer.writeAll("; ");
-        }
-    }
-    return buffer.items;
-}
-
-// TODO Propagate also upward to parent node
-pub fn set_cssText(self: *CSSStyleDeclaration, text: []const u8, page: *Page) !void {
-    self.properties.clearRetainingCapacity();
-
-    // call_arena is safe here, because _setProperty will dupe the name
-    // using the page's longer-living arena.
-    const declarations = try CSSParser.parseDeclarations(page.call_arena, text);
-
-    for (declarations) |decl| {
-        if (!isValidPropertyName(decl.name)) {
-            continue;
-        }
-        const priority: ?[]const u8 = if (decl.is_important) "important" else null;
-        try self._setProperty(decl.name, decl.value, priority, page);
-    }
-}
-
-pub fn get_length(self: *const CSSStyleDeclaration) usize {
-    return self.properties.count();
-}
-
-pub fn get_parentRule(_: *const CSSStyleDeclaration) ?CSSRule {
-    return null;
-}
-
-pub fn _getPropertyPriority(self: *const CSSStyleDeclaration, name: []const u8) []const u8 {
-    const property = self.properties.getPtr(name) orelse return "";
-    return if (property.priority) "important" else "";
-}
-
-// TODO should handle properly shorthand properties and canonical forms
-pub fn _getPropertyValue(self: *const CSSStyleDeclaration, name: []const u8) []const u8 {
-    if (self.properties.getPtr(name)) |property| {
-        return property.value;
-    }
-
-    // default to everything being visible (unless it's been explicitly set)
-    if (std.mem.eql(u8, name, "visibility")) {
-        return "visible";
-    }
-
-    return "";
-}
-
-pub fn _item(self: *const CSSStyleDeclaration, index: usize) []const u8 {
-    const values = self.properties.entries.items(.key);
-    if (index >= values.len) {
-        return "";
-    }
-    return values[index];
-}
-
-pub fn _removeProperty(self: *CSSStyleDeclaration, name: []const u8) ![]const u8 {
-    const property = self.properties.fetchOrderedRemove(name) orelse return "";
-    return property.value.value;
-}
-
-pub fn _setProperty(self: *CSSStyleDeclaration, name: []const u8, value: []const u8, priority: ?[]const u8, page: *Page) !void {
-    const gop = try self.properties.getOrPut(page.arena, name);
-    if (!gop.found_existing) {
-        const owned_name = try page.arena.dupe(u8, name);
-        gop.key_ptr.* = owned_name;
-    }
-
-    const owned_value = try page.arena.dupe(u8, value);
-    const is_important = priority != null and std.ascii.eqlIgnoreCase(priority.?, "important");
-    gop.value_ptr.* = .{ .value = owned_value, .priority = is_important };
-}
-
-pub fn named_get(self: *const CSSStyleDeclaration, name: []const u8, _: *bool) []const u8 {
-    return self._getPropertyValue(name);
-}
-
-pub fn named_set(self: *CSSStyleDeclaration, name: []const u8, value: []const u8, _: *bool, page: *Page) !void {
-    return self._setProperty(name, value, null, page);
-}
-
-fn isNumericWithUnit(value: []const u8) bool {
-    if (value.len == 0) {
-        return false;
-    }
-
-    const first = value[0];
-
-    if (!std.ascii.isDigit(first) and first != '+' and first != '-' and first != '.') {
-        return false;
-    }
-
-    var i: usize = 0;
-    var has_digit = false;
-    var decimal_point = false;
-
-    while (i < value.len) : (i += 1) {
-        const c = value[i];
-        if (std.ascii.isDigit(c)) {
-            has_digit = true;
-        } else if (c == '.' and !decimal_point) {
-            decimal_point = true;
-        } else if ((c == 'e' or c == 'E') and has_digit) {
-            if (i + 1 >= value.len) return false;
-            if (value[i + 1] != '+' and value[i + 1] != '-' and !std.ascii.isDigit(value[i + 1])) break;
-            i += 1;
-            if (value[i] == '+' or value[i] == '-') {
-                i += 1;
-            }
-            var has_exp_digits = false;
-            while (i < value.len and std.ascii.isDigit(value[i])) : (i += 1) {
-                has_exp_digits = true;
-            }
-            if (!has_exp_digits) return false;
-            break;
-        } else if (c != '-' and c != '+') {
-            break;
-        }
-    }
-
-    if (!has_digit) {
-        return false;
-    }
-
-    if (i == value.len) {
-        return true;
-    }
-
-    const unit = value[i..];
-    return CSSKeywords.isValidUnit(unit);
-}
-
-fn isHexColor(value: []const u8) bool {
-    if (value.len == 0) {
-        return false;
-    }
-    if (value[0] != '#') {
-        return false;
-    }
-
-    const hex_part = value[1..];
-    if (hex_part.len != 3 and hex_part.len != 6 and hex_part.len != 8) {
-        return false;
-    }
-
-    for (hex_part) |c| {
-        if (!std.ascii.isHex(c)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-fn isMultiValueProperty(value: []const u8) bool {
-    var parts = std.mem.splitAny(u8, value, " ");
-    var multi_value_parts: usize = 0;
-    var all_parts_valid = true;
-
-    while (parts.next()) |part| {
-        if (part.len == 0) continue;
-        multi_value_parts += 1;
-
-        if (isNumericWithUnit(part)) {
-            continue;
-        }
-        if (isHexColor(part)) {
-            continue;
-        }
-        if (CSSKeywords.isKnownKeyword(part)) {
-            continue;
-        }
-        if (CSSKeywords.startsWithFunction(part)) {
-            continue;
-        }
-
-        all_parts_valid = false;
-        break;
-    }
-
-    return multi_value_parts >= 2 and all_parts_valid;
-}
-
-fn isAlreadyQuoted(value: []const u8) bool {
-    return value.len >= 2 and ((value[0] == '"' and value[value.len - 1] == '"') or
-        (value[0] == '\'' and value[value.len - 1] == '\''));
-}
-
-fn isValidPropertyName(name: []const u8) bool {
-    if (name.len == 0) return false;
-
-    if (std.mem.startsWith(u8, name, "--")) {
-        if (name.len == 2) return false;
-        for (name[2..]) |c| {
-            if (!std.ascii.isAlphanumeric(c) and c != '-' and c != '_') {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    const first_char = name[0];
-    if (!std.ascii.isAlphabetic(first_char) and first_char != '-') {
-        return false;
-    }
-
-    if (first_char == '-') {
-        if (name.len < 2) return false;
-
-        if (!std.ascii.isAlphabetic(name[1])) {
-            return false;
-        }
-
-        for (name[2..]) |c| {
-            if (!std.ascii.isAlphanumeric(c) and c != '-') {
-                return false;
-            }
-        }
-    } else {
-        for (name[1..]) |c| {
-            if (!std.ascii.isAlphanumeric(c) and c != '-') {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-fn extractImportant(value: []const u8) struct { value: []const u8, is_important: bool } {
-    const trimmed = std.mem.trim(u8, value, &std.ascii.whitespace);
-
-    if (std.mem.endsWith(u8, trimmed, "!important")) {
-        const clean_value = std.mem.trimRight(u8, trimmed[0 .. trimmed.len - 10], &std.ascii.whitespace);
-        return .{ .value = clean_value, .is_important = true };
-    }
-
-    return .{ .value = trimmed, .is_important = false };
-}
-
-fn needsQuotes(value: []const u8) bool {
-    if (value.len == 0) return true;
-    if (isAlreadyQuoted(value)) return false;
-
-    if (CSSKeywords.containsSpecialChar(value)) {
-        return true;
-    }
-
-    if (std.mem.indexOfScalar(u8, value, ' ') == null) {
-        return false;
-    }
-
-    const is_url = std.mem.startsWith(u8, value, "url(");
-    const is_function = CSSKeywords.startsWithFunction(value);
-
-    return !isMultiValueProperty(value) and
-        !is_url and
-        !is_function;
-}
-
-fn escapeCSSValue(arena: std.mem.Allocator, value: []const u8) ![]const u8 {
-    if (!needsQuotes(value)) {
-        return value;
-    }
-    var out: std.ArrayListUnmanaged(u8) = .empty;
-
-    // We'll need at least this much space, +2 for the quotes
-    try out.ensureTotalCapacity(arena, value.len + 2);
-    const writer = out.writer(arena);
-
-    try writer.writeByte('"');
-
-    for (value, 0..) |c, i| {
-        switch (c) {
-            '"' => try writer.writeAll("\\\""),
-            '\\' => try writer.writeAll("\\\\"),
-            '\n' => try writer.writeAll("\\A "),
-            '\r' => try writer.writeAll("\\D "),
-            '\t' => try writer.writeAll("\\9 "),
-            0...8, 11, 12, 14...31, 127 => {
-                try writer.print("\\{x}", .{c});
-                if (i + 1 < value.len and std.ascii.isHex(value[i + 1])) {
-                    try writer.writeByte(' ');
-                }
-            },
-            else => try writer.writeByte(c),
-        }
-    }
-
-    try writer.writeByte('"');
-    return out.items;
-}
-
-fn isKnownKeyword(value: []const u8) bool {
-    return CSSKeywords.isKnownKeyword(value);
-}
-
-fn containsSpecialChar(value: []const u8) bool {
-    return CSSKeywords.containsSpecialChar(value);
-}
-
-const CSSKeywords = struct {
-    const BORDER_STYLES = [_][]const u8{
-        "none", "solid", "dotted", "dashed", "double", "groove", "ridge", "inset", "outset",
-    };
-
-    const COLOR_NAMES = [_][]const u8{
-        "black",        "white",   "red", "green", "blue", "yellow", "purple", "gray", "transparent",
-        "currentColor", "inherit",
-    };
-
-    const POSITION_KEYWORDS = [_][]const u8{
-        "auto", "center", "left", "right", "top", "bottom",
-    };
-
-    const BACKGROUND_REPEAT = [_][]const u8{
-        "repeat", "no-repeat", "repeat-x", "repeat-y", "space", "round",
-    };
-
-    const FONT_STYLES = [_][]const u8{
-        "normal", "italic", "oblique", "bold", "bolder", "lighter",
-    };
-
-    const FONT_SIZES = [_][]const u8{
-        "xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large",
-        "smaller",  "larger",
-    };
-
-    const FONT_FAMILIES = [_][]const u8{
-        "serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui",
-    };
-
-    const CSS_GLOBAL = [_][]const u8{
-        "initial", "inherit", "unset", "revert",
-    };
-
-    const DISPLAY_VALUES = [_][]const u8{
-        "block", "inline", "inline-block", "flex", "grid", "none",
-    };
-
-    const UNITS = [_][]const u8{
-        // LENGTH
-        "px",   "em", "rem", "vw",  "vh",  "vmin", "vmax", "%", "pt", "pc", "in",  "cm",  "mm",
-        "ex",   "ch", "fr",
-
-        // ANGLE
-         "deg", "rad", "grad", "turn",
-
-        // TIME
-        "s", "ms",
-
-        // FREQUENCY
-        "hz", "khz",
-
-        // RESOLUTION
-        "dpi", "dpcm",
-        "dppx",
-    };
-
-    const SPECIAL_CHARS = [_]u8{
-        '"', '\'', ';', '{', '}', '\\', '<', '>', '/', '\n', '\t', '\r', '\x00', '\x7F',
-    };
-
-    const FUNCTIONS = [_][]const u8{
-        "rgb(",             "rgba(",            "hsl(",            "hsla(",      "url(",    "calc(",  "var(",  "attr(",
-        "linear-gradient(", "radial-gradient(", "conic-gradient(", "translate(", "rotate(", "scale(", "skew(", "matrix(",
-    };
-
-    const KEYWORDS = BORDER_STYLES ++ COLOR_NAMES ++ POSITION_KEYWORDS ++
-        BACKGROUND_REPEAT ++ FONT_STYLES ++ FONT_SIZES ++ FONT_FAMILIES ++
-        CSS_GLOBAL ++ DISPLAY_VALUES;
-
-    const MAX_KEYWORD_LEN = lengthOfLongestValue(&KEYWORDS);
-
-    pub fn isKnownKeyword(value: []const u8) bool {
-        if (value.len > MAX_KEYWORD_LEN) {
-            return false;
-        }
-        var buf: [MAX_KEYWORD_LEN]u8 = undefined;
-        const normalized = std.ascii.lowerString(&buf, value);
-
-        for (KEYWORDS) |keyword| {
-            if (std.ascii.eqlIgnoreCase(normalized, keyword)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    pub fn containsSpecialChar(value: []const u8) bool {
-        return std.mem.indexOfAny(u8, value, &SPECIAL_CHARS) != null;
-    }
-
-    const MAX_UNIT_LEN = lengthOfLongestValue(&UNITS);
-
-    pub fn isValidUnit(unit: []const u8) bool {
-        if (unit.len > MAX_UNIT_LEN) {
-            return false;
-        }
-        var buf: [MAX_UNIT_LEN]u8 = undefined;
-        const normalized = std.ascii.lowerString(&buf, unit);
-
-        for (UNITS) |u| {
-            if (std.mem.eql(u8, normalized, u)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    pub fn startsWithFunction(value: []const u8) bool {
-        const pos = std.mem.indexOfScalar(u8, value, '(') orelse return false;
-        if (pos == 0) return false;
-
-        if (std.mem.indexOfScalarPos(u8, value, pos, ')') == null) {
-            return false;
-        }
-        const function_name = value[0..pos];
-        return isValidFunctionName(function_name);
-    }
-
-    fn isValidFunctionName(name: []const u8) bool {
-        if (name.len == 0) return false;
-
-        const first = name[0];
-        if (!std.ascii.isAlphabetic(first) and first != '_' and first != '-') {
-            return false;
-        }
-
-        for (name[1..]) |c| {
-            if (!std.ascii.isAlphanumeric(c) and c != '_' and c != '-') {
-                return false;
-            }
-        }
-
-        return true;
-    }
-};
-
-fn lengthOfLongestValue(values: []const []const u8) usize {
-    var max: usize = 0;
-    for (values) |v| {
-        max = @max(v.len, max);
-    }
-    return max;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: CSS.StyleDeclaration" {
-    try testing.htmlRunner("cssom/css_style_declaration.html");
-}
-
-test "Browser: CSS.StyleDeclaration: isNumericWithUnit - valid numbers with units" {
-    try testing.expect(isNumericWithUnit("10px"));
-    try testing.expect(isNumericWithUnit("3.14em"));
-    try testing.expect(isNumericWithUnit("-5rem"));
-    try testing.expect(isNumericWithUnit("+12.5%"));
-    try testing.expect(isNumericWithUnit("0vh"));
-    try testing.expect(isNumericWithUnit(".5vw"));
-}
-
-test "Browser: CSS.StyleDeclaration: isNumericWithUnit - scientific notation" {
-    try testing.expect(isNumericWithUnit("1e5px"));
-    try testing.expect(isNumericWithUnit("2.5E-3em"));
-    try testing.expect(isNumericWithUnit("1e+2rem"));
-    try testing.expect(isNumericWithUnit("-3.14e10px"));
-}
-
-test "Browser: CSS.StyleDeclaration: isNumericWithUnit - edge cases and invalid inputs" {
-    try testing.expect(!isNumericWithUnit(""));
-
-    try testing.expect(!isNumericWithUnit("px"));
-    try testing.expect(!isNumericWithUnit("--px"));
-    try testing.expect(!isNumericWithUnit(".px"));
-
-    try testing.expect(!isNumericWithUnit("1e"));
-    try testing.expect(!isNumericWithUnit("1epx"));
-    try testing.expect(!isNumericWithUnit("1e+"));
-    try testing.expect(!isNumericWithUnit("1e+px"));
-
-    try testing.expect(!isNumericWithUnit("1.2.3px"));
-
-    try testing.expect(!isNumericWithUnit("10xyz"));
-    try testing.expect(!isNumericWithUnit("5invalid"));
-
-    try testing.expect(isNumericWithUnit("10"));
-    try testing.expect(isNumericWithUnit("3.14"));
-    try testing.expect(isNumericWithUnit("-5"));
-}
-
-test "Browser: CSS.StyleDeclaration: isHexColor - valid hex colors" {
-    try testing.expect(isHexColor("#000"));
-    try testing.expect(isHexColor("#fff"));
-    try testing.expect(isHexColor("#123456"));
-    try testing.expect(isHexColor("#abcdef"));
-    try testing.expect(isHexColor("#ABCDEF"));
-    try testing.expect(isHexColor("#12345678"));
-}
-
-test "Browser: CSS.StyleDeclaration: isHexColor - invalid hex colors" {
-    try testing.expect(!isHexColor(""));
-    try testing.expect(!isHexColor("#"));
-    try testing.expect(!isHexColor("000"));
-    try testing.expect(!isHexColor("#00"));
-    try testing.expect(!isHexColor("#0000"));
-    try testing.expect(!isHexColor("#00000"));
-    try testing.expect(!isHexColor("#0000000"));
-    try testing.expect(!isHexColor("#000000000"));
-    try testing.expect(!isHexColor("#gggggg"));
-    try testing.expect(!isHexColor("#123xyz"));
-}
-
-test "Browser: CSS.StyleDeclaration: isMultiValueProperty - valid multi-value properties" {
-    try testing.expect(isMultiValueProperty("10px 20px"));
-    try testing.expect(isMultiValueProperty("solid red"));
-    try testing.expect(isMultiValueProperty("#fff black"));
-    try testing.expect(isMultiValueProperty("1em 2em 3em 4em"));
-    try testing.expect(isMultiValueProperty("rgb(255,0,0) solid"));
-}
-
-test "Browser: CSS.StyleDeclaration: isMultiValueProperty - invalid multi-value properties" {
-    try testing.expect(!isMultiValueProperty(""));
-    try testing.expect(!isMultiValueProperty("10px"));
-    try testing.expect(!isMultiValueProperty("invalid unknown"));
-    try testing.expect(!isMultiValueProperty("10px invalid"));
-    try testing.expect(!isMultiValueProperty("   "));
-}
-
-test "Browser: CSS.StyleDeclaration: isAlreadyQuoted - various quoting scenarios" {
-    try testing.expect(isAlreadyQuoted("\"hello\""));
-    try testing.expect(isAlreadyQuoted("'world'"));
-    try testing.expect(isAlreadyQuoted("\"\""));
-    try testing.expect(isAlreadyQuoted("''"));
-
-    try testing.expect(!isAlreadyQuoted(""));
-    try testing.expect(!isAlreadyQuoted("hello"));
-    try testing.expect(!isAlreadyQuoted("\""));
-    try testing.expect(!isAlreadyQuoted("'"));
-    try testing.expect(!isAlreadyQuoted("\"hello'"));
-    try testing.expect(!isAlreadyQuoted("'hello\""));
-    try testing.expect(!isAlreadyQuoted("\"hello"));
-    try testing.expect(!isAlreadyQuoted("hello\""));
-}
-
-test "Browser: CSS.StyleDeclaration: isValidPropertyName - valid property names" {
-    try testing.expect(isValidPropertyName("color"));
-    try testing.expect(isValidPropertyName("background-color"));
-    try testing.expect(isValidPropertyName("-webkit-transform"));
-    try testing.expect(isValidPropertyName("font-size"));
-    try testing.expect(isValidPropertyName("margin-top"));
-    try testing.expect(isValidPropertyName("z-index"));
-    try testing.expect(isValidPropertyName("line-height"));
-}
-
-test "Browser: CSS.StyleDeclaration: isValidPropertyName - invalid property names" {
-    try testing.expect(!isValidPropertyName(""));
-    try testing.expect(!isValidPropertyName("123color"));
-    try testing.expect(!isValidPropertyName("color!"));
-    try testing.expect(!isValidPropertyName("color space"));
-    try testing.expect(!isValidPropertyName("@color"));
-    try testing.expect(!isValidPropertyName("color.test"));
-    try testing.expect(!isValidPropertyName("color_test"));
-}
-
-test "Browser: CSS.StyleDeclaration: extractImportant - with and without !important" {
-    var result = extractImportant("red !important");
-    try testing.expect(result.is_important);
-    try testing.expectEqual("red", result.value);
-
-    result = extractImportant("blue");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("blue", result.value);
-
-    result = extractImportant("  green  !important  ");
-    try testing.expect(result.is_important);
-    try testing.expectEqual("green", result.value);
-
-    result = extractImportant("!important");
-    try testing.expect(result.is_important);
-    try testing.expectEqual("", result.value);
-
-    result = extractImportant("important");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("important", result.value);
-}
-
-test "Browser: CSS.StyleDeclaration: needsQuotes - various scenarios" {
-    try testing.expect(needsQuotes(""));
-    try testing.expect(needsQuotes("hello world"));
-    try testing.expect(needsQuotes("test;"));
-    try testing.expect(needsQuotes("a{b}"));
-    try testing.expect(needsQuotes("test\"quote"));
-
-    try testing.expect(!needsQuotes("\"already quoted\""));
-    try testing.expect(!needsQuotes("'already quoted'"));
-    try testing.expect(!needsQuotes("url(image.png)"));
-    try testing.expect(!needsQuotes("rgb(255, 0, 0)"));
-    try testing.expect(!needsQuotes("10px 20px"));
-    try testing.expect(!needsQuotes("simple"));
-}
-
-test "Browser: CSS.StyleDeclaration: escapeCSSValue - escaping various characters" {
-    const allocator = testing.arena_allocator;
-
-    var result = try escapeCSSValue(allocator, "simple");
-    try testing.expectEqual("simple", result);
-
-    result = try escapeCSSValue(allocator, "\"already quoted\"");
-    try testing.expectEqual("\"already quoted\"", result);
-
-    result = try escapeCSSValue(allocator, "test\"quote");
-    try testing.expectEqual("\"test\\\"quote\"", result);
-
-    result = try escapeCSSValue(allocator, "test\nline");
-    try testing.expectEqual("\"test\\A line\"", result);
-
-    result = try escapeCSSValue(allocator, "test\\back");
-    try testing.expectEqual("\"test\\\\back\"", result);
-}
-
-test "Browser: CSS.StyleDeclaration: CSSKeywords.isKnownKeyword - case sensitivity" {
-    try testing.expect(CSSKeywords.isKnownKeyword("red"));
-    try testing.expect(CSSKeywords.isKnownKeyword("solid"));
-    try testing.expect(CSSKeywords.isKnownKeyword("center"));
-    try testing.expect(CSSKeywords.isKnownKeyword("inherit"));
-
-    try testing.expect(CSSKeywords.isKnownKeyword("RED"));
-    try testing.expect(CSSKeywords.isKnownKeyword("Red"));
-    try testing.expect(CSSKeywords.isKnownKeyword("SOLID"));
-    try testing.expect(CSSKeywords.isKnownKeyword("Center"));
-
-    try testing.expect(!CSSKeywords.isKnownKeyword("invalid"));
-    try testing.expect(!CSSKeywords.isKnownKeyword("unknown"));
-    try testing.expect(!CSSKeywords.isKnownKeyword(""));
-}
-
-test "Browser: CSS.StyleDeclaration: CSSKeywords.containsSpecialChar - various special characters" {
-    try testing.expect(CSSKeywords.containsSpecialChar("test\"quote"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test'quote"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test;end"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test{brace"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test}brace"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test\\back"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test<angle"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test>angle"));
-    try testing.expect(CSSKeywords.containsSpecialChar("test/slash"));
-
-    try testing.expect(!CSSKeywords.containsSpecialChar("normal-text"));
-    try testing.expect(!CSSKeywords.containsSpecialChar("text123"));
-    try testing.expect(!CSSKeywords.containsSpecialChar(""));
-}
-
-test "Browser: CSS.StyleDeclaration: CSSKeywords.isValidUnit - various units" {
-    try testing.expect(CSSKeywords.isValidUnit("px"));
-    try testing.expect(CSSKeywords.isValidUnit("em"));
-    try testing.expect(CSSKeywords.isValidUnit("rem"));
-    try testing.expect(CSSKeywords.isValidUnit("%"));
-
-    try testing.expect(CSSKeywords.isValidUnit("deg"));
-    try testing.expect(CSSKeywords.isValidUnit("rad"));
-
-    try testing.expect(CSSKeywords.isValidUnit("s"));
-    try testing.expect(CSSKeywords.isValidUnit("ms"));
-
-    try testing.expect(CSSKeywords.isValidUnit("PX"));
-
-    try testing.expect(!CSSKeywords.isValidUnit("invalid"));
-    try testing.expect(!CSSKeywords.isValidUnit(""));
-}
-
-test "Browser: CSS.StyleDeclaration: CSSKeywords.startsWithFunction - function detection" {
-    try testing.expect(CSSKeywords.startsWithFunction("rgb(255, 0, 0)"));
-    try testing.expect(CSSKeywords.startsWithFunction("rgba(255, 0, 0, 0.5)"));
-    try testing.expect(CSSKeywords.startsWithFunction("url(image.png)"));
-    try testing.expect(CSSKeywords.startsWithFunction("calc(100% - 20px)"));
-    try testing.expect(CSSKeywords.startsWithFunction("var(--custom-property)"));
-    try testing.expect(CSSKeywords.startsWithFunction("linear-gradient(to right, red, blue)"));
-
-    try testing.expect(CSSKeywords.startsWithFunction("custom-function(args)"));
-    try testing.expect(CSSKeywords.startsWithFunction("unknown(test)"));
-
-    try testing.expect(!CSSKeywords.startsWithFunction("not-a-function"));
-    try testing.expect(!CSSKeywords.startsWithFunction("missing-paren)"));
-    try testing.expect(!CSSKeywords.startsWithFunction("missing-close("));
-    try testing.expect(!CSSKeywords.startsWithFunction(""));
-    try testing.expect(!CSSKeywords.startsWithFunction("rgb"));
-}
-
-test "Browser: CSS.StyleDeclaration: isNumericWithUnit - whitespace handling" {
-    try testing.expect(!isNumericWithUnit(" 10px"));
-    try testing.expect(!isNumericWithUnit("10 px"));
-    try testing.expect(!isNumericWithUnit("10px "));
-    try testing.expect(!isNumericWithUnit(" 10 px "));
-}
-
-test "Browser: CSS.StyleDeclaration: extractImportant - whitespace edge cases" {
-    var result = extractImportant("   ");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("", result.value);
-
-    result = extractImportant("\t\n\r !important\t\n");
-    try testing.expect(result.is_important);
-    try testing.expectEqual("", result.value);
-
-    result = extractImportant("red\t!important");
-    try testing.expect(result.is_important);
-    try testing.expectEqual("red", result.value);
-}
-
-test "Browser: CSS.StyleDeclaration: isHexColor - mixed case handling" {
-    try testing.expect(isHexColor("#AbC"));
-    try testing.expect(isHexColor("#123aBc"));
-    try testing.expect(isHexColor("#FFffFF"));
-    try testing.expect(isHexColor("#000FFF"));
-}
-
-test "Browser: CSS.StyleDeclaration: edge case - very long inputs" {
-    const long_valid = "a" ** 1000 ++ "px";
-    try testing.expect(!isNumericWithUnit(long_valid)); // not numeric
-
-    const long_property = "a-" ** 100 ++ "property";
-    try testing.expect(isValidPropertyName(long_property));
-
-    const long_hex = "#" ++ "a" ** 20;
-    try testing.expect(!isHexColor(long_hex));
-}
-
-test "Browser: CSS.StyleDeclaration: boundary conditions - numeric parsing" {
-    try testing.expect(isNumericWithUnit("0px"));
-    try testing.expect(isNumericWithUnit("0.0px"));
-    try testing.expect(isNumericWithUnit(".0px"));
-    try testing.expect(isNumericWithUnit("0.px"));
-
-    try testing.expect(isNumericWithUnit("999999999px"));
-    try testing.expect(isNumericWithUnit("1.7976931348623157e+308px"));
-
-    try testing.expect(isNumericWithUnit("0.000000001px"));
-    try testing.expect(isNumericWithUnit("1e-100px"));
-}
-
-test "Browser: CSS.StyleDeclaration: extractImportant - malformed important declarations" {
-    var result = extractImportant("red ! important");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("red ! important", result.value);
-
-    result = extractImportant("red !Important");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("red !Important", result.value);
-
-    result = extractImportant("red !IMPORTANT");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("red !IMPORTANT", result.value);
-
-    result = extractImportant("!importantred");
-    try testing.expect(!result.is_important);
-    try testing.expectEqual("!importantred", result.value);
-
-    result = extractImportant("red !important !important");
-    try testing.expect(result.is_important);
-    try testing.expectEqual("red !important", result.value);
-}
-
-test "Browser: CSS.StyleDeclaration: isMultiValueProperty - complex spacing scenarios" {
-    try testing.expect(isMultiValueProperty("10px    20px"));
-    try testing.expect(isMultiValueProperty("solid     red"));
-
-    try testing.expect(isMultiValueProperty("  10px 20px  "));
-
-    try testing.expect(!isMultiValueProperty("10px\t20px"));
-    try testing.expect(!isMultiValueProperty("10px\n20px"));
-
-    try testing.expect(isMultiValueProperty("10px   20px   30px"));
-}
-
-test "Browser: CSS.StyleDeclaration: isAlreadyQuoted - edge cases with quotes" {
-    try testing.expect(isAlreadyQuoted("\"'hello'\""));
-    try testing.expect(isAlreadyQuoted("'\"hello\"'"));
-
-    try testing.expect(isAlreadyQuoted("\"hello\\\"world\""));
-    try testing.expect(isAlreadyQuoted("'hello\\'world'"));
-
-    try testing.expect(!isAlreadyQuoted("\"hello"));
-    try testing.expect(!isAlreadyQuoted("hello\""));
-    try testing.expect(!isAlreadyQuoted("'hello"));
-    try testing.expect(!isAlreadyQuoted("hello'"));
-
-    try testing.expect(isAlreadyQuoted("\"a\""));
-    try testing.expect(isAlreadyQuoted("'b'"));
-}
-
-test "Browser: CSS.StyleDeclaration: needsQuotes - function and URL edge cases" {
-    try testing.expect(!needsQuotes("rgb(255, 0, 0)"));
-    try testing.expect(!needsQuotes("calc(100% - 20px)"));
-
-    try testing.expect(!needsQuotes("url(path with spaces.jpg)"));
-
-    try testing.expect(!needsQuotes("linear-gradient(to right, red, blue)"));
-
-    try testing.expect(needsQuotes("rgb(255, 0, 0"));
-}
-
-test "Browser: CSS.StyleDeclaration: escapeCSSValue - control characters and Unicode" {
-    const allocator = testing.arena_allocator;
-
-    var result = try escapeCSSValue(allocator, "test\ttab");
-    try testing.expectEqual("\"test\\9 tab\"", result);
-
-    result = try escapeCSSValue(allocator, "test\rreturn");
-    try testing.expectEqual("\"test\\D return\"", result);
-
-    result = try escapeCSSValue(allocator, "test\x00null");
-    try testing.expectEqual("\"test\\0null\"", result);
-
-    result = try escapeCSSValue(allocator, "test\x7Fdel");
-    try testing.expectEqual("\"test\\7f del\"", result);
-
-    result = try escapeCSSValue(allocator, "test\"quote\nline\\back");
-    try testing.expectEqual("\"test\\\"quote\\A line\\\\back\"", result);
-}
-
-test "Browser: CSS.StyleDeclaration: isValidPropertyName - CSS custom properties and vendor prefixes" {
-    try testing.expect(isValidPropertyName("--custom-color"));
-    try testing.expect(isValidPropertyName("--my-variable"));
-    try testing.expect(isValidPropertyName("--123"));
-
-    try testing.expect(isValidPropertyName("-webkit-transform"));
-    try testing.expect(isValidPropertyName("-moz-border-radius"));
-    try testing.expect(isValidPropertyName("-ms-filter"));
-    try testing.expect(isValidPropertyName("-o-transition"));
-
-    try testing.expect(!isValidPropertyName("-123invalid"));
-    try testing.expect(!isValidPropertyName("--"));
-    try testing.expect(!isValidPropertyName("-"));
-}
-
-test "Browser: CSS.StyleDeclaration: startsWithFunction - case sensitivity and partial matches" {
-    try testing.expect(CSSKeywords.startsWithFunction("RGB(255, 0, 0)"));
-    try testing.expect(CSSKeywords.startsWithFunction("Rgb(255, 0, 0)"));
-    try testing.expect(CSSKeywords.startsWithFunction("URL(image.png)"));
-
-    try testing.expect(CSSKeywords.startsWithFunction("rg(something)"));
-    try testing.expect(CSSKeywords.startsWithFunction("ur(something)"));
-
-    try testing.expect(CSSKeywords.startsWithFunction("rgb(1,2,3)"));
-    try testing.expect(CSSKeywords.startsWithFunction("rgba(1,2,3,4)"));
-
-    try testing.expect(CSSKeywords.startsWithFunction("my-custom-function(args)"));
-    try testing.expect(CSSKeywords.startsWithFunction("function-with-dashes(test)"));
-
-    try testing.expect(!CSSKeywords.startsWithFunction("123function(test)"));
-}
-
-test "Browser: CSS.StyleDeclaration: isHexColor - Unicode and invalid characters" {
-    try testing.expect(!isHexColor("#ghijkl"));
-    try testing.expect(!isHexColor("#12345g"));
-    try testing.expect(!isHexColor("#xyz"));
-
-    try testing.expect(!isHexColor("#АВС"));
-
-    try testing.expect(!isHexColor("#1234567g"));
-    try testing.expect(!isHexColor("#g2345678"));
-}
-
-test "Browser: CSS.StyleDeclaration: complex integration scenarios" {
-    const allocator = testing.arena_allocator;
-
-    try testing.expect(isMultiValueProperty("rgb(255,0,0) url(bg.jpg)"));
-
-    try testing.expect(!needsQuotes("calc(100% - 20px)"));
-
-    const result = try escapeCSSValue(allocator, "fake(function with spaces");
-    try testing.expectEqual("\"fake(function with spaces\"", result);
-
-    const important_result = extractImportant("rgb(255,0,0) !important");
-    try testing.expect(important_result.is_important);
-    try testing.expectEqual("rgb(255,0,0)", important_result.value);
-}
-
-test "Browser: CSS.StyleDeclaration: performance edge cases - empty and minimal inputs" {
-    try testing.expect(!isNumericWithUnit(""));
-    try testing.expect(!isHexColor(""));
-    try testing.expect(!isMultiValueProperty(""));
-    try testing.expect(!isAlreadyQuoted(""));
-    try testing.expect(!isValidPropertyName(""));
-    try testing.expect(needsQuotes(""));
-    try testing.expect(!CSSKeywords.isKnownKeyword(""));
-    try testing.expect(!CSSKeywords.containsSpecialChar(""));
-    try testing.expect(!CSSKeywords.isValidUnit(""));
-    try testing.expect(!CSSKeywords.startsWithFunction(""));
-
-    try testing.expect(!isNumericWithUnit("a"));
-    try testing.expect(!isHexColor("a"));
-    try testing.expect(!isMultiValueProperty("a"));
-    try testing.expect(!isAlreadyQuoted("a"));
-    try testing.expect(isValidPropertyName("a"));
-    try testing.expect(!needsQuotes("a"));
-}
--- a/src/browser/cssom/CSSStyleSheet.zig
+++ b/src/browser/cssom/CSSStyleSheet.zig
@@ -1,95 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const Page = @import("../page.zig").Page;
-const StyleSheet = @import("StyleSheet.zig");
-const CSSRuleList = @import("CSSRuleList.zig");
-const CSSImportRule = @import("CSSRule.zig").CSSImportRule;
-
-const CSSStyleSheet = @This();
-pub const prototype = *StyleSheet;
-
-proto: StyleSheet,
-css_rules: CSSRuleList,
-owner_rule: ?*CSSImportRule,
-
-const CSSStyleSheetOpts = struct {
-    base_url: ?[]const u8 = null,
-    // TODO: Suupport media
-    disabled: bool = false,
-};
-
-pub fn constructor(_opts: ?CSSStyleSheetOpts) !CSSStyleSheet {
-    const opts = _opts orelse CSSStyleSheetOpts{};
-    return .{
-        .proto = .{ .disabled = opts.disabled },
-        .css_rules = .constructor(),
-        .owner_rule = null,
-    };
-}
-
-pub fn get_ownerRule(_: *CSSStyleSheet) ?*CSSImportRule {
-    return null;
-}
-
-pub fn get_cssRules(self: *CSSStyleSheet) *CSSRuleList {
-    return &self.css_rules;
-}
-
-pub fn _insertRule(self: *CSSStyleSheet, rule: []const u8, _index: ?usize, page: *Page) !usize {
-    const index = _index orelse 0;
-    if (index > self.css_rules.list.items.len) {
-        return error.IndexSize;
-    }
-
-    const arena = page.arena;
-    try self.css_rules.list.insert(arena, index, try arena.dupe(u8, rule));
-    return index;
-}
-
-pub fn _deleteRule(self: *CSSStyleSheet, index: usize) !void {
-    if (index > self.css_rules.list.items.len) {
-        return error.IndexSize;
-    }
-
-    _ = self.css_rules.list.orderedRemove(index);
-}
-
-pub fn _replace(self: *CSSStyleSheet, text: []const u8, page: *Page) !js.Promise {
-    _ = self;
-    _ = text;
-    // TODO: clear self.css_rules
-    // parse text and re-populate self.css_rules
-
-    return page.js.resolvePromise({});
-}
-
-pub fn _replaceSync(self: *CSSStyleSheet, text: []const u8) !void {
-    _ = self;
-    _ = text;
-    // TODO: clear self.css_rules
-    // parse text and re-populate self.css_rules
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: CSS.StyleSheet" {
-    try testing.htmlRunner("cssom/css_stylesheet.html");
-}
--- a/src/browser/cssom/StyleSheet.zig
+++ b/src/browser/cssom/StyleSheet.zig
@@ -1,55 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const parser = @import("../netsurf.zig");
-
-// https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet#specifications
-const StyleSheet = @This();
-
-disabled: bool = false,
-href: []const u8 = "",
-owner_node: ?*parser.Node = null,
-parent_stylesheet: ?*StyleSheet = null,
-title: []const u8 = "",
-type: []const u8 = "text/css",
-
-pub fn get_disabled(self: *const StyleSheet) bool {
-    return self.disabled;
-}
-
-pub fn get_href(self: *const StyleSheet) []const u8 {
-    return self.href;
-}
-
-// TODO: media
-
-pub fn get_ownerNode(self: *const StyleSheet) ?*parser.Node {
-    return self.owner_node;
-}
-
-pub fn get_parentStyleSheet(self: *const StyleSheet) ?*StyleSheet {
-    return self.parent_stylesheet;
-}
-
-pub fn get_title(self: *const StyleSheet) []const u8 {
-    return self.title;
-}
-
-pub fn get_type(self: *const StyleSheet) []const u8 {
-    return self.type;
-}
--- a/src/browser/cssom/cssom.zig
+++ b/src/browser/cssom/cssom.zig
@@ -1,25 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-pub const Interfaces = .{
-    @import("StyleSheet.zig"),
-    @import("CSSStyleSheet.zig"),
-    @import("CSSStyleDeclaration.zig"),
-    @import("CSSRuleList.zig"),
-    @import("CSSRule.zig").Interfaces,
-};
--- a/src/browser/dom/Animation.zig
+++ b/src/browser/dom/Animation.zig
@@ -1,107 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const Page = @import("../page.zig").Page;
-
-const Animation = @This();
-
-effect: ?js.Object,
-timeline: ?js.Object,
-ready_resolver: ?js.PromiseResolver,
-finished_resolver: ?js.PromiseResolver,
-
-pub fn constructor(effect: ?js.Object, timeline: ?js.Object) !Animation {
-    return .{
-        .effect = if (effect) |eo| try eo.persist() else null,
-        .timeline = if (timeline) |to| try to.persist() else null,
-        .ready_resolver = null,
-        .finished_resolver = null,
-    };
-}
-
-pub fn get_playState(self: *const Animation) []const u8 {
-    _ = self;
-    return "finished";
-}
-
-pub fn get_pending(self: *const Animation) bool {
-    _ = self;
-    return false;
-}
-
-pub fn get_finished(self: *Animation, page: *Page) !js.Promise {
-    if (self.finished_resolver == null) {
-        const resolver = page.js.createPromiseResolver(.none);
-        try resolver.resolve(self);
-        self.finished_resolver = resolver;
-    }
-    return self.finished_resolver.?.promise();
-}
-
-pub fn get_ready(self: *Animation, page: *Page) !js.Promise {
-    // never resolved, because we're always "finished"
-    if (self.ready_resolver == null) {
-        const resolver = page.js.createPromiseResolver(.none);
-        self.ready_resolver = resolver;
-    }
-    return self.ready_resolver.?.promise();
-}
-
-pub fn get_effect(self: *const Animation) ?js.Object {
-    return self.effect;
-}
-
-pub fn set_effect(self: *Animation, effect: js.Object) !void {
-    self.effect = try effect.persist();
-}
-
-pub fn get_timeline(self: *const Animation) ?js.Object {
-    return self.timeline;
-}
-
-pub fn set_timeline(self: *Animation, timeline: js.Object) !void {
-    self.timeline = try timeline.persist();
-}
-
-pub fn _play(self: *const Animation) void {
-    _ = self;
-}
-
-pub fn _pause(self: *const Animation) void {
-    _ = self;
-}
-
-pub fn _cancel(self: *const Animation) void {
-    _ = self;
-}
-
-pub fn _finish(self: *const Animation) void {
-    _ = self;
-}
-
-pub fn _reverse(self: *const Animation) void {
-    _ = self;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Animation" {
-    try testing.htmlRunner("dom/animation.html");
-}
--- a/src/browser/dom/IntersectionObserver.zig
+++ b/src/browser/dom/IntersectionObserver.zig
@@ -1,329 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-const Node = @import("node.zig").Node;
-const Element = @import("element.zig").Element;
-
-pub const Interfaces = .{
-    IntersectionObserver,
-    Entry,
-};
-
-// This implementation attempts to be as less wrong as possible. Since we don't
-// render, or know how things are positioned, our best guess isn't very good.
-const IntersectionObserver = @This();
-page: *Page,
-root: *parser.Node,
-callback: js.Function,
-event_node: parser.EventNode,
-observed_entries: std.ArrayList(Entry),
-pending_elements: std.ArrayList(*parser.Element),
-ready_elements: std.ArrayList(*parser.Element),
-
-pub fn constructor(callback: js.Function, opts_: ?IntersectionObserverOptions, page: *Page) !*IntersectionObserver {
-    const opts = opts_ orelse IntersectionObserverOptions{};
-
-    const self = try page.arena.create(IntersectionObserver);
-    self.* = .{
-        .page = page,
-        .callback = callback,
-        .ready_elements = .{},
-        .observed_entries = .{},
-        .pending_elements = .{},
-        .event_node = .{ .func = mutationCallback },
-        .root = opts.root orelse parser.documentToNode(parser.documentHTMLToDocument(page.window.document)),
-    };
-
-    _ = try parser.eventTargetAddEventListener(
-        parser.toEventTarget(parser.Node, self.root),
-        "DOMNodeInserted",
-        &self.event_node,
-        false,
-    );
-
-    _ = try parser.eventTargetAddEventListener(
-        parser.toEventTarget(parser.Node, self.root),
-        "DOMNodeRemoved",
-        &self.event_node,
-        false,
-    );
-
-    return self;
-}
-
-pub fn _disconnect(self: *IntersectionObserver) !void {
-    // We don't free as it is on an arena
-    self.ready_elements = .{};
-    self.observed_entries = .{};
-    self.pending_elements = .{};
-}
-
-pub fn _observe(self: *IntersectionObserver, target_element: *parser.Element, page: *Page) !void {
-    for (self.observed_entries.items) |*observer| {
-        if (observer.target == target_element) {
-            return; // Already observed
-        }
-    }
-
-    if (self.isPending(target_element)) {
-        return; // Already pending
-    }
-
-    for (self.ready_elements.items) |element| {
-        if (element == target_element) {
-            return; // Already primed
-        }
-    }
-
-    // We can never fire callbacks synchronously. Code like React expects any
-    // callback to fire in the future (e.g. via microtasks).
-    try self.ready_elements.append(self.page.arena, target_element);
-    if (self.ready_elements.items.len == 1) {
-        // this is our first ready entry, schedule a callback
-        try page.scheduler.add(self, processReady, 0, .{
-            .name = "intersection ready",
-        });
-    }
-}
-
-pub fn _unobserve(self: *IntersectionObserver, target: *parser.Element) !void {
-    if (self.removeObserved(target)) {
-        return;
-    }
-
-    for (self.ready_elements.items, 0..) |el, index| {
-        if (el == target) {
-            _ = self.ready_elements.swapRemove(index);
-            return;
-        }
-    }
-
-    for (self.pending_elements.items, 0..) |el, index| {
-        if (el == target) {
-            _ = self.pending_elements.swapRemove(index);
-            return;
-        }
-    }
-}
-
-pub fn _takeRecords(self: *IntersectionObserver) []Entry {
-    return self.observed_entries.items;
-}
-
-fn processReady(ctx: *anyopaque) ?u32 {
-    const self: *IntersectionObserver = @ptrCast(@alignCast(ctx));
-    self._processReady() catch |err| {
-        log.err(.web_api, "intersection ready", .{ .err = err });
-    };
-    return null;
-}
-
-fn _processReady(self: *IntersectionObserver) !void {
-    defer self.ready_elements.clearRetainingCapacity();
-    for (self.ready_elements.items) |element| {
-        // IntersectionObserver probably doesn't work like what your intuition
-        // thinks. As long as a node has a parent, even if that parent isn't
-        // connected and even if the two nodes don't intersect, it'll fire the
-        // callback once.
-        if (try Node.get_parentNode(@ptrCast(element)) == null) {
-            if (!self.isPending(element)) {
-                try self.pending_elements.append(self.page.arena, element);
-            }
-            continue;
-        }
-        try self.forceObserve(element);
-    }
-}
-
-fn isPending(self: *IntersectionObserver, element: *parser.Element) bool {
-    for (self.pending_elements.items) |el| {
-        if (el == element) {
-            return true;
-        }
-    }
-    return false;
-}
-
-fn mutationCallback(en: *parser.EventNode, event: *parser.Event) void {
-    const mutation_event = parser.eventToMutationEvent(event);
-    const self: *IntersectionObserver = @fieldParentPtr("event_node", en);
-    self._mutationCallback(mutation_event) catch |err| {
-        log.err(.web_api, "mutation callback", .{ .err = err, .source = "intersection observer" });
-    };
-}
-
-fn _mutationCallback(self: *IntersectionObserver, event: *parser.MutationEvent) !void {
-    const event_type = parser.eventType(@ptrCast(event));
-
-    if (std.mem.eql(u8, event_type, "DOMNodeInserted")) {
-        const node = parser.mutationEventRelatedNode(event) catch return orelse return;
-        if (parser.nodeType(node) != .element) {
-            return;
-        }
-        const el: *parser.Element = @ptrCast(node);
-        if (self.removePending(el)) {
-            // It was pending (because it wasn't in the root), but now it is
-            // we should observe it.
-            try self.forceObserve(el);
-        }
-        return;
-    }
-
-    if (std.mem.eql(u8, event_type, "DOMNodeRemoved")) {
-        const node = parser.mutationEventRelatedNode(event) catch return orelse return;
-        if (parser.nodeType(node) != .element) {
-            return;
-        }
-
-        const el: *parser.Element = @ptrCast(node);
-        if (self.removeObserved(el)) {
-            // It _was_ observed, it no longer is in our root, but if it was
-            // to get re-added, it should be observed again (I think), so
-            // we add it to our pending list
-            try self.pending_elements.append(self.page.arena, el);
-        }
-
-        return;
-    }
-
-    // impossible event type
-    unreachable;
-}
-
-// Exists to skip the checks made _observe when called from a DOMNodeInserted
-// event. In such events, the event handler has alread done the necessary
-// checks.
-fn forceObserve(self: *IntersectionObserver, target: *parser.Element) !void {
-    try self.observed_entries.append(self.page.arena, .{
-        .page = self.page,
-        .root = self.root,
-        .target = target,
-    });
-
-    var result: js.Function.Result = undefined;
-    self.callback.tryCall(void, .{self.observed_entries.items}, &result) catch {
-        log.debug(.user_script, "callback error", .{
-            .err = result.exception,
-            .stack = result.stack,
-            .source = "intersection observer",
-        });
-    };
-}
-
-fn removeObserved(self: *IntersectionObserver, target: *parser.Element) bool {
-    for (self.observed_entries.items, 0..) |*observer, index| {
-        if (observer.target == target) {
-            _ = self.observed_entries.swapRemove(index);
-            return true;
-        }
-    }
-    return false;
-}
-
-fn removePending(self: *IntersectionObserver, target: *parser.Element) bool {
-    for (self.pending_elements.items, 0..) |el, index| {
-        if (el == target) {
-            _ = self.pending_elements.swapRemove(index);
-            return true;
-        }
-    }
-    return false;
-}
-
-const IntersectionObserverOptions = struct {
-    root: ?*parser.Node = null, // Element or Document
-    rootMargin: ?[]const u8 = "0px 0px 0px 0px",
-    threshold: ?Threshold = .{ .single = 0.0 },
-
-    const Threshold = union(enum) {
-        single: f32,
-        list: []const f32,
-    };
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Entry
-// https://w3c.github.io/IntersectionObserver/#intersection-observer-entry
-pub const Entry = struct {
-    page: *Page,
-    root: *parser.Node,
-    target: *parser.Element,
-
-    // Returns the bounds rectangle of the target element as a DOMRectReadOnly. The bounds are computed as described in the documentation for Element.getBoundingClientRect().
-    pub fn get_boundingClientRect(self: *const Entry) !Element.DOMRect {
-        return Element._getBoundingClientRect(self.target, self.page);
-    }
-
-    // Returns the ratio of the intersectionRect to the boundingClientRect.
-    pub fn get_intersectionRatio(_: *const Entry) f32 {
-        return 1.0;
-    }
-
-    // Returns a DOMRectReadOnly representing the target's visible area.
-    pub fn get_intersectionRect(self: *const Entry) !Element.DOMRect {
-        return Element._getBoundingClientRect(self.target, self.page);
-    }
-
-    // A Boolean value which is true if the target element intersects with the
-    // intersection observer's root. If this is true, then, the
-    // Entry describes a transition into a state of
-    // intersection; if it's false, then you know the transition is from
-    // intersecting to not-intersecting.
-    pub fn get_isIntersecting(_: *const Entry) bool {
-        return true;
-    }
-
-    // Returns a DOMRectReadOnly for the intersection observer's root.
-    pub fn get_rootBounds(self: *const Entry) !Element.DOMRect {
-        const root = self.root;
-        if (@intFromPtr(root) == @intFromPtr(self.page.window.document)) {
-            return self.page.renderer.boundingRect();
-        }
-
-        const root_type = parser.nodeType(root);
-
-        var element: *parser.Element = undefined;
-        switch (root_type) {
-            .element => element = parser.nodeToElement(root),
-            .document => {
-                const doc = parser.nodeToDocument(root);
-                element = (try parser.documentGetDocumentElement(doc)).?;
-            },
-            else => return error.InvalidState,
-        }
-
-        return Element._getBoundingClientRect(element, self.page);
-    }
-
-    // The Element whose intersection with the root changed.
-    pub fn get_target(self: *const Entry) *parser.Element {
-        return self.target;
-    }
-
-    // TODO: pub fn get_time(self: *const Entry)
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.IntersectionObserver" {
-    try testing.htmlRunner("dom/intersection_observer.html");
-}
--- a/src/browser/dom/MessageChannel.zig
+++ b/src/browser/dom/MessageChannel.zig
@@ -1,288 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-
-const js = @import("../js/js.zig");
-const Page = @import("../page.zig").Page;
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-const EventHandler = @import("../events/event.zig").EventHandler;
-
-const Allocator = std.mem.Allocator;
-
-const MAX_QUEUE_SIZE = 10;
-
-pub const Interfaces = .{ MessageChannel, MessagePort };
-
-const MessageChannel = @This();
-
-port1: *MessagePort,
-port2: *MessagePort,
-
-pub fn constructor(page: *Page) !MessageChannel {
-    // Why do we allocate this rather than storing directly in the struct?
-    // https://github.com/lightpanda-io/project/discussions/165
-    const port1 = try page.arena.create(MessagePort);
-    const port2 = try page.arena.create(MessagePort);
-    port1.* = .{
-        .pair = port2,
-    };
-    port2.* = .{
-        .pair = port1,
-    };
-
-    return .{
-        .port1 = port1,
-        .port2 = port2,
-    };
-}
-
-pub fn get_port1(self: *const MessageChannel) *MessagePort {
-    return self.port1;
-}
-
-pub fn get_port2(self: *const MessageChannel) *MessagePort {
-    return self.port2;
-}
-
-pub const MessagePort = struct {
-    pub const prototype = *EventTarget;
-
-    proto: parser.EventTargetTBase = .{ .internal_target_type = .message_port },
-
-    pair: *MessagePort,
-    closed: bool = false,
-    started: bool = false,
-    onmessage_cbk: ?js.Function = null,
-    onmessageerror_cbk: ?js.Function = null,
-    // This is the queue of messages to dispatch to THIS MessagePort when the
-    // MessagePort is started.
-    queue: std.ArrayListUnmanaged(js.Object) = .empty,
-
-    pub const PostMessageOption = union(enum) {
-        transfer: js.Object,
-        options: Opts,
-
-        pub const Opts = struct {
-            transfer: js.Object,
-        };
-    };
-
-    pub fn _postMessage(self: *MessagePort, obj: js.Object, opts_: ?PostMessageOption, page: *Page) !void {
-        if (self.closed) {
-            return;
-        }
-
-        if (opts_ != null) {
-            log.warn(.web_api, "not implemented", .{ .feature = "MessagePort postMessage options" });
-        }
-
-        try self.pair.dispatchOrQueue(obj, page.arena);
-    }
-
-    // Start impacts the ability to receive a message.
-    // Given pair1 (started) and pair2 (not started), then:
-    //    pair2.postMessage('x'); //will be dispatched to pair1.onmessage
-    //    pair1.postMessage('x'); // will be queued until pair2 is started
-    pub fn _start(self: *MessagePort) !void {
-        if (self.started) {
-            return;
-        }
-        self.started = true;
-        for (self.queue.items) |data| {
-            try self.dispatch(data);
-        }
-        // we'll never use this queue again, but it's allocated with an arena
-        // we don't even need to clear it, but it seems a bit safer to do at
-        // least that
-        self.queue.clearRetainingCapacity();
-    }
-
-    // Closing seems to stop both the publishing and receiving of messages,
-    // effectively rendering the channel useless. It cannot be reversed.
-    pub fn _close(self: *MessagePort) void {
-        self.closed = true;
-        self.pair.closed = true;
-    }
-
-    pub fn get_onmessage(self: *MessagePort) ?js.Function {
-        return self.onmessage_cbk;
-    }
-    pub fn get_onmessageerror(self: *MessagePort) ?js.Function {
-        return self.onmessageerror_cbk;
-    }
-
-    pub fn set_onmessage(self: *MessagePort, listener: EventHandler.Listener, page: *Page) !void {
-        if (self.onmessage_cbk) |cbk| {
-            try self.unregister("message", cbk.id);
-        }
-        self.onmessage_cbk = try self.register(page.arena, "message", listener);
-
-        // When onmessage is set directly, then it's like start() was called.
-        // If addEventListener('message') is used, the app has to call start()
-        // explicitly.
-        try self._start();
-    }
-
-    pub fn set_onmessageerror(self: *MessagePort, listener: EventHandler.Listener, page: *Page) !void {
-        if (self.onmessageerror_cbk) |cbk| {
-            try self.unregister("messageerror", cbk.id);
-        }
-        self.onmessageerror_cbk = try self.register(page.arena, "messageerror", listener);
-    }
-
-    // called from our pair. If port1.postMessage("x") is called, then this
-    // will be called on port2.
-    fn dispatchOrQueue(self: *MessagePort, obj: js.Object, arena: Allocator) !void {
-        // our pair should have checked this already
-        std.debug.assert(self.closed == false);
-
-        if (self.started) {
-            return self.dispatch(try obj.persist());
-        }
-
-        if (self.queue.items.len > MAX_QUEUE_SIZE) {
-            // This isn't part of the spec, but not putting a limit is reckless
-            return error.MessageQueueLimit;
-        }
-        return self.queue.append(arena, try obj.persist());
-    }
-
-    fn dispatch(self: *MessagePort, obj: js.Object) !void {
-        // obj is already persisted, don't use `MessageEvent.constructor`, but
-        // go directly to `init`, which assumes persisted objects.
-        var evt = try MessageEvent.init(.{ .data = obj });
-        _ = try parser.eventTargetDispatchEvent(
-            parser.toEventTarget(MessagePort, self),
-            @as(*parser.Event, @ptrCast(&evt)),
-        );
-    }
-
-    fn register(
-        self: *MessagePort,
-        alloc: Allocator,
-        typ: []const u8,
-        listener: EventHandler.Listener,
-    ) !?js.Function {
-        const target = @as(*parser.EventTarget, @ptrCast(self));
-        const eh = (try EventHandler.register(alloc, target, typ, listener, null)) orelse unreachable;
-        return eh.callback;
-    }
-
-    fn unregister(self: *MessagePort, typ: []const u8, cbk_id: usize) !void {
-        const et = @as(*parser.EventTarget, @ptrCast(self));
-        const lst = try parser.eventTargetHasListener(et, typ, false, cbk_id);
-        if (lst == null) {
-            return;
-        }
-        try parser.eventTargetRemoveEventListener(et, typ, lst.?, false);
-    }
-};
-
-pub const MessageEvent = struct {
-    const Event = @import("../events/event.zig").Event;
-    const DOMException = @import("exceptions.zig").DOMException;
-
-    pub const prototype = *Event;
-    pub const Exception = DOMException;
-    pub const union_make_copy = true;
-
-    proto: parser.Event,
-    data: ?js.Object,
-
-    // You would think if port1 sends to port2, the source would be port2
-    // (which is how I read the documentation), but it appears to always be
-    // null. It can always be set explicitly via the constructor;
-    source: ?js.Object,
-
-    origin: []const u8,
-
-    // This is used for Server-Sent events. Appears to always be an empty
-    // string for MessagePort messages.
-    last_event_id: []const u8,
-
-    // This might be related to the "transfer" option of postMessage which
-    // we don't yet support. For "normal" message, it's always an empty array.
-    // Though it could be set explicitly via the constructor
-    ports: []*MessagePort,
-
-    const Options = struct {
-        data: ?js.Object = null,
-        source: ?js.Object = null,
-        origin: []const u8 = "",
-        lastEventId: []const u8 = "",
-        ports: []*MessagePort = &.{},
-    };
-
-    pub fn constructor(opts: Options) !MessageEvent {
-        return init(.{
-            .data = if (opts.data) |obj| try obj.persist() else null,
-            .source = if (opts.source) |obj| try obj.persist() else null,
-            .ports = opts.ports,
-            .origin = opts.origin,
-            .lastEventId = opts.lastEventId,
-        });
-    }
-
-    // This is like "constructor", but it assumes js.Objects have already been
-    // persisted. Necessary because this `new MessageEvent()` can be called
-    // directly from JS OR from a port.postMessage. In the latter case, data
-    // may have already been persisted (as it might need to be queued);
-    fn init(opts: Options) !MessageEvent {
-        const event = try parser.eventCreate();
-        defer parser.eventDestroy(event);
-        try parser.eventInit(event, "message", .{});
-        parser.eventSetInternalType(event, .message_event);
-
-        return .{
-            .proto = event.*,
-            .data = opts.data,
-            .source = opts.source,
-            .ports = opts.ports,
-            .origin = opts.origin,
-            .last_event_id = opts.lastEventId,
-        };
-    }
-
-    pub fn get_data(self: *const MessageEvent) !?js.Object {
-        return self.data;
-    }
-
-    pub fn get_origin(self: *const MessageEvent) []const u8 {
-        return self.origin;
-    }
-
-    pub fn get_source(self: *const MessageEvent) ?js.Object {
-        return self.source;
-    }
-
-    pub fn get_ports(self: *const MessageEvent) []*MessagePort {
-        return self.ports;
-    }
-
-    pub fn get_lastEventId(self: *const MessageEvent) []const u8 {
-        return self.last_event_id;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.MessageChannel" {
-    try testing.htmlRunner("dom/message_channel.html");
-}
--- a/src/browser/dom/attribute.zig
+++ b/src/browser/dom/attribute.zig
@@ -1,75 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-const parser = @import("../netsurf.zig");
-
-const Node = @import("node.zig").Node;
-
-// WEB IDL https://dom.spec.whatwg.org/#attr
-pub const Attr = struct {
-    pub const Self = parser.Attribute;
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    pub fn get_namespaceURI(self: *parser.Attribute) ?[]const u8 {
-        return parser.nodeGetNamespace(parser.attributeToNode(self));
-    }
-
-    pub fn get_prefix(self: *parser.Attribute) ?[]const u8 {
-        return parser.nodeGetPrefix(parser.attributeToNode(self));
-    }
-
-    pub fn get_localName(self: *parser.Attribute) ![]const u8 {
-        return parser.nodeLocalName(parser.attributeToNode(self));
-    }
-
-    pub fn get_name(self: *parser.Attribute) ![]const u8 {
-        return parser.attributeGetName(self);
-    }
-
-    pub fn get_value(self: *parser.Attribute) !?[]const u8 {
-        return parser.attributeGetValue(self);
-    }
-
-    pub fn set_value(self: *parser.Attribute, v: []const u8) !?[]const u8 {
-        if (try parser.attributeGetOwnerElement(self)) |el| {
-            // if possible, go through the element, as that triggers a
-            // DOMAttrModified event (which MutationObserver cares about)
-            const name = try parser.attributeGetName(self);
-            try parser.elementSetAttribute(el, name, v);
-        } else {
-            try parser.attributeSetValue(self, v);
-        }
-        return v;
-    }
-
-    pub fn get_ownerElement(self: *parser.Attribute) !?*parser.Element {
-        return try parser.attributeGetOwnerElement(self);
-    }
-
-    pub fn get_specified(_: *parser.Attribute) bool {
-        return true;
-    }
-};
-
-// Tests
-// -----
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Attribute" {
-    try testing.htmlRunner("dom/attribute.html");
-}
--- a/src/browser/dom/character_data.zig
+++ b/src/browser/dom/character_data.zig
@@ -1,134 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-
-const Node = @import("node.zig").Node;
-const Comment = @import("comment.zig").Comment;
-const Text = @import("text.zig");
-const ProcessingInstruction = @import("processing_instruction.zig").ProcessingInstruction;
-const Element = @import("element.zig").Element;
-const ElementUnion = @import("element.zig").Union;
-
-// CharacterData interfaces
-pub const Interfaces = .{
-    Comment,
-    Text.Text,
-    Text.Interfaces,
-    ProcessingInstruction,
-};
-
-// CharacterData implementation
-pub const CharacterData = struct {
-    pub const Self = parser.CharacterData;
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    // JS funcs
-    // --------
-
-    // Read attributes
-
-    pub fn get_length(self: *parser.CharacterData) !u32 {
-        return try parser.characterDataLength(self);
-    }
-
-    pub fn get_nextElementSibling(self: *parser.CharacterData) !?ElementUnion {
-        const res = parser.nodeNextElementSibling(parser.characterDataToNode(self));
-        if (res == null) {
-            return null;
-        }
-        return try Element.toInterface(res.?);
-    }
-
-    pub fn get_previousElementSibling(self: *parser.CharacterData) !?ElementUnion {
-        const res = parser.nodePreviousElementSibling(parser.characterDataToNode(self));
-        if (res == null) {
-            return null;
-        }
-        return try Element.toInterface(res.?);
-    }
-
-    // Read/Write attributes
-
-    pub fn get_data(self: *parser.CharacterData) []const u8 {
-        return parser.characterDataData(self);
-    }
-
-    pub fn set_data(self: *parser.CharacterData, data: []const u8) !void {
-        return try parser.characterDataSetData(self, data);
-    }
-
-    // JS methods
-    // ----------
-
-    pub fn _appendData(self: *parser.CharacterData, data: []const u8) !void {
-        return try parser.characterDataAppendData(self, data);
-    }
-
-    pub fn _deleteData(self: *parser.CharacterData, offset: u32, count: u32) !void {
-        return try parser.characterDataDeleteData(self, offset, count);
-    }
-
-    pub fn _insertData(self: *parser.CharacterData, offset: u32, data: []const u8) !void {
-        return try parser.characterDataInsertData(self, offset, data);
-    }
-
-    pub fn _replaceData(self: *parser.CharacterData, offset: u32, count: u32, data: []const u8) !void {
-        return try parser.characterDataReplaceData(self, offset, count, data);
-    }
-
-    pub fn _substringData(self: *parser.CharacterData, offset: u32, count: u32) ![]const u8 {
-        return parser.characterDataSubstringData(self, offset, count);
-    }
-
-    // netsurf's CharacterData (text, comment) doesn't implement the
-    // dom_node_get_attributes and thus will crash if we try to call nodeIsEqualNode.
-    pub fn _isEqualNode(self: *parser.CharacterData, other_node: *parser.Node) bool {
-        if (parser.nodeType(@ptrCast(@alignCast(self))) != parser.nodeType(other_node)) {
-            return false;
-        }
-
-        const other: *parser.CharacterData = @ptrCast(other_node);
-        if (std.mem.eql(u8, get_data(self), get_data(other)) == false) {
-            return false;
-        }
-
-        return true;
-    }
-
-    pub fn _before(self: *parser.CharacterData, nodes: []const Node.NodeOrText) !void {
-        const ref_node = parser.characterDataToNode(self);
-        return Node.before(ref_node, nodes);
-    }
-
-    pub fn _after(self: *parser.CharacterData, nodes: []const Node.NodeOrText) !void {
-        const ref_node = parser.characterDataToNode(self);
-        return Node.after(ref_node, nodes);
-    }
-};
-
-// Tests
-// -----
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.CharacterData" {
-    try testing.htmlRunner("dom/character_data.html");
-}
--- a/src/browser/dom/document.zig
+++ b/src/browser/dom/document.zig
@@ -1,321 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const Node = @import("node.zig").Node;
-const NodeList = @import("nodelist.zig").NodeList;
-const NodeUnion = @import("node.zig").Union;
-
-const collection = @import("html_collection.zig");
-const css = @import("css.zig");
-
-const Element = @import("element.zig").Element;
-const ElementUnion = @import("element.zig").Union;
-const TreeWalker = @import("tree_walker.zig").TreeWalker;
-const CSSStyleSheet = @import("../cssom/CSSStyleSheet.zig");
-const NodeIterator = @import("node_iterator.zig").NodeIterator;
-const Range = @import("range.zig").Range;
-
-const CustomEvent = @import("../events/custom_event.zig").CustomEvent;
-
-const DOMImplementation = @import("implementation.zig").DOMImplementation;
-
-// WEB IDL https://dom.spec.whatwg.org/#document
-pub const Document = struct {
-    pub const Self = parser.Document;
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    pub fn constructor(page: *const Page) !*parser.DocumentHTML {
-        const doc = try parser.documentCreateDocument(
-            try parser.documentHTMLGetTitle(page.window.document),
-        );
-
-        // we have to work w/ document instead of html document.
-        const ddoc = parser.documentHTMLToDocument(doc);
-        const ccur = parser.documentHTMLToDocument(page.window.document);
-        try parser.documentSetDocumentURI(ddoc, try parser.documentGetDocumentURI(ccur));
-        try parser.documentSetInputEncoding(ddoc, try parser.documentGetInputEncoding(ccur));
-
-        return doc;
-    }
-
-    // JS funcs
-    // --------
-    pub fn get_implementation(_: *parser.Document) DOMImplementation {
-        return DOMImplementation{};
-    }
-
-    pub fn get_documentElement(self: *parser.Document) !?ElementUnion {
-        const e = try parser.documentGetDocumentElement(self);
-        if (e == null) return null;
-        return try Element.toInterface(e.?);
-    }
-
-    pub fn get_documentURI(self: *parser.Document) ![]const u8 {
-        return try parser.documentGetDocumentURI(self);
-    }
-
-    pub fn get_URL(self: *parser.Document) ![]const u8 {
-        return try get_documentURI(self);
-    }
-
-    // TODO implement contentType
-    pub fn get_contentType(self: *parser.Document) []const u8 {
-        _ = self;
-        return "text/html";
-    }
-
-    // TODO implement compactMode
-    pub fn get_compatMode(self: *parser.Document) []const u8 {
-        _ = self;
-        return "CSS1Compat";
-    }
-
-    pub fn get_characterSet(self: *parser.Document) ![]const u8 {
-        return try parser.documentGetInputEncoding(self);
-    }
-
-    // alias of get_characterSet
-    pub fn get_charset(self: *parser.Document) ![]const u8 {
-        return try get_characterSet(self);
-    }
-
-    // alias of get_characterSet
-    pub fn get_inputEncoding(self: *parser.Document) ![]const u8 {
-        return try get_characterSet(self);
-    }
-
-    pub fn get_doctype(self: *parser.Document) !?*parser.DocumentType {
-        return try parser.documentGetDoctype(self);
-    }
-
-    pub fn _createEvent(_: *parser.Document, eventCstr: []const u8) !union(enum) {
-        base: *parser.Event,
-        custom: CustomEvent,
-    } {
-        const eqlIgnoreCase = std.ascii.eqlIgnoreCase;
-
-        if (eqlIgnoreCase(eventCstr, "Event") or eqlIgnoreCase(eventCstr, "Events") or eqlIgnoreCase(eventCstr, "HTMLEvents")) {
-            return .{ .base = try parser.eventCreate() };
-        }
-
-        // Not documented in MDN but supported in Chrome.
-        // This is actually both instance of `Event` and `CustomEvent`.
-        if (std.ascii.eqlIgnoreCase(eventCstr, "CustomEvent")) {
-            return .{ .custom = try CustomEvent.constructor(eventCstr, null) };
-        }
-
-        return error.NotSupported;
-    }
-
-    pub fn _getElementById(self: *parser.Document, id: []const u8) !?ElementUnion {
-        const e = try parser.documentGetElementById(self, id) orelse return null;
-        return try Element.toInterface(e);
-    }
-
-    pub fn _createElement(self: *parser.Document, tag_name: []const u8) !ElementUnion {
-        // The element’s namespace is the HTML namespace when document is an HTML document
-        // https://dom.spec.whatwg.org/#ref-for-dom-document-createelement%E2%91%A0
-        const e = try parser.documentCreateElementNS(self, "http://www.w3.org/1999/xhtml", tag_name);
-        return Element.toInterface(e);
-    }
-
-    pub fn _createElementNS(self: *parser.Document, ns: []const u8, tag_name: []const u8) !ElementUnion {
-        const e = try parser.documentCreateElementNS(self, ns, tag_name);
-        return try Element.toInterface(e);
-    }
-
-    // We can't simply use libdom dom_document_get_elements_by_tag_name here.
-    // Indeed, netsurf implemented a previous dom spec when
-    // getElementsByTagName returned a NodeList.
-    // But since
-    // https://github.com/whatwg/dom/commit/190700b7c12ecfd3b5ebdb359ab1d6ea9cbf7749
-    // the spec changed to return an HTMLCollection instead.
-    // That's why we reimplemented getElementsByTagName by using an
-    // HTMLCollection in zig here.
-    pub fn _getElementsByTagName(self: *parser.Document, tag_name: js.String) !collection.HTMLCollection {
-        return collection.HTMLCollectionByTagName(parser.documentToNode(self), tag_name.string, .{
-            .include_root = true,
-        });
-    }
-
-    pub fn _getElementsByClassName(self: *parser.Document, class_names: js.String) !collection.HTMLCollection {
-        return collection.HTMLCollectionByClassName(parser.documentToNode(self), class_names.string, .{
-            .include_root = true,
-        });
-    }
-
-    pub fn _createDocumentFragment(self: *parser.Document) !*parser.DocumentFragment {
-        return try parser.documentCreateDocumentFragment(self);
-    }
-
-    pub fn _createTextNode(self: *parser.Document, data: []const u8) !*parser.Text {
-        return try parser.documentCreateTextNode(self, data);
-    }
-
-    pub fn _createCDATASection(self: *parser.Document, data: []const u8) !*parser.CDATASection {
-        return try parser.documentCreateCDATASection(self, data);
-    }
-
-    pub fn _createComment(self: *parser.Document, data: []const u8) !*parser.Comment {
-        return try parser.documentCreateComment(self, data);
-    }
-
-    pub fn _createProcessingInstruction(self: *parser.Document, target: []const u8, data: []const u8) !*parser.ProcessingInstruction {
-        return try parser.documentCreateProcessingInstruction(self, target, data);
-    }
-
-    pub fn _importNode(self: *parser.Document, node: *parser.Node, deep: ?bool) !NodeUnion {
-        const n = try parser.documentImportNode(self, node, deep orelse false);
-        return try Node.toInterface(n);
-    }
-
-    pub fn _adoptNode(self: *parser.Document, node: *parser.Node) !NodeUnion {
-        const n = try parser.documentAdoptNode(self, node);
-        return try Node.toInterface(n);
-    }
-
-    pub fn _createAttribute(self: *parser.Document, name: []const u8) !*parser.Attribute {
-        return try parser.documentCreateAttribute(self, name);
-    }
-
-    pub fn _createAttributeNS(self: *parser.Document, ns: []const u8, qname: []const u8) !*parser.Attribute {
-        return try parser.documentCreateAttributeNS(self, ns, qname);
-    }
-
-    // ParentNode
-    // https://dom.spec.whatwg.org/#parentnode
-    pub fn get_children(self: *parser.Document) !collection.HTMLCollection {
-        return collection.HTMLCollectionChildren(parser.documentToNode(self), .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_firstElementChild(self: *parser.Document) !?ElementUnion {
-        const elt = try parser.documentGetDocumentElement(self) orelse return null;
-        return try Element.toInterface(elt);
-    }
-
-    pub fn get_lastElementChild(self: *parser.Document) !?ElementUnion {
-        const elt = try parser.documentGetDocumentElement(self) orelse return null;
-        return try Element.toInterface(elt);
-    }
-
-    pub fn get_childElementCount(self: *parser.Document) !u32 {
-        _ = try parser.documentGetDocumentElement(self) orelse return 0;
-        return 1;
-    }
-
-    pub fn _querySelector(self: *parser.Document, selector: []const u8, page: *Page) !?ElementUnion {
-        if (selector.len == 0) return null;
-
-        const n = try css.querySelector(page.call_arena, parser.documentToNode(self), selector);
-
-        if (n == null) return null;
-
-        return try Element.toInterface(parser.nodeToElement(n.?));
-    }
-
-    pub fn _querySelectorAll(self: *parser.Document, selector: []const u8, page: *Page) !NodeList {
-        return css.querySelectorAll(page.arena, parser.documentToNode(self), selector);
-    }
-
-    pub fn _prepend(self: *parser.Document, nodes: []const Node.NodeOrText) !void {
-        return Node.prepend(parser.documentToNode(self), nodes);
-    }
-
-    pub fn _append(self: *parser.Document, nodes: []const Node.NodeOrText) !void {
-        return Node.append(parser.documentToNode(self), nodes);
-    }
-
-    pub fn _replaceChildren(self: *parser.Document, nodes: []const Node.NodeOrText) !void {
-        return Node.replaceChildren(parser.documentToNode(self), nodes);
-    }
-
-    pub fn _createTreeWalker(_: *parser.Document, root: *parser.Node, what_to_show: ?TreeWalker.WhatToShow, filter: ?TreeWalker.TreeWalkerOpts) !TreeWalker {
-        return TreeWalker.init(root, what_to_show, filter);
-    }
-
-    pub fn _createNodeIterator(_: *parser.Document, root: *parser.Node, what_to_show: ?NodeIterator.WhatToShow, filter: ?NodeIterator.NodeIteratorOpts) !NodeIterator {
-        return NodeIterator.init(root, what_to_show, filter);
-    }
-
-    pub fn getActiveElement(self: *parser.Document, page: *Page) !?*parser.Element {
-        if (page.getNodeState(@ptrCast(@alignCast(self)))) |state| {
-            if (state.active_element) |ae| {
-                return ae;
-            }
-        }
-
-        if (try parser.documentHTMLBody(page.window.document)) |body| {
-            return @ptrCast(@alignCast(body));
-        }
-
-        return try parser.documentGetDocumentElement(self);
-    }
-
-    pub fn get_activeElement(self: *parser.Document, page: *Page) !?ElementUnion {
-        const ae = (try getActiveElement(self, page)) orelse return null;
-        return try Element.toInterface(ae);
-    }
-
-    // TODO: some elements can't be focused, like if they're disabled
-    // but there doesn't seem to be a generic way to check this. For example
-    // we could look for the "disabled" attribute, but that's only meaningful
-    // on certain types, and libdom's vtable doesn't seem to expose this.
-    pub fn setFocus(self: *parser.Document, e: *parser.ElementHTML, page: *Page) !void {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        state.active_element = @ptrCast(e);
-    }
-
-    pub fn _createRange(_: *parser.Document, page: *Page) Range {
-        return Range.constructor(page);
-    }
-
-    // TODO: dummy implementation
-    pub fn get_styleSheets(_: *parser.Document) []CSSStyleSheet {
-        return &.{};
-    }
-
-    pub fn get_adoptedStyleSheets(self: *parser.Document, page: *Page) !js.Object {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        if (state.adopted_style_sheets) |obj| {
-            return obj;
-        }
-
-        const obj = try page.js.createArray(0).persist();
-        state.adopted_style_sheets = obj;
-        return obj;
-    }
-
-    pub fn set_adoptedStyleSheets(self: *parser.Document, sheets: js.Object, page: *Page) !void {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        state.adopted_style_sheets = try sheets.persist();
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Document" {
-    try testing.htmlRunner("dom/document.html");
-}
--- a/src/browser/dom/document_fragment.zig
+++ b/src/browser/dom/document_fragment.zig
@@ -1,96 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const css = @import("css.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-const NodeList = @import("nodelist.zig").NodeList;
-const Element = @import("element.zig").Element;
-const ElementUnion = @import("element.zig").Union;
-const collection = @import("html_collection.zig");
-
-const Node = @import("node.zig").Node;
-
-// WEB IDL https://dom.spec.whatwg.org/#documentfragment
-pub const DocumentFragment = struct {
-    pub const Self = parser.DocumentFragment;
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    pub fn constructor(page: *const Page) !*parser.DocumentFragment {
-        return parser.documentCreateDocumentFragment(
-            parser.documentHTMLToDocument(page.window.document),
-        );
-    }
-
-    pub fn _isEqualNode(self: *parser.DocumentFragment, other_node: *parser.Node) bool {
-        const other_type = parser.nodeType(other_node);
-        if (other_type != .document_fragment) {
-            return false;
-        }
-        _ = self;
-        return true;
-    }
-
-    pub fn _prepend(self: *parser.DocumentFragment, nodes: []const Node.NodeOrText) !void {
-        return Node.prepend(parser.documentFragmentToNode(self), nodes);
-    }
-
-    pub fn _append(self: *parser.DocumentFragment, nodes: []const Node.NodeOrText) !void {
-        return Node.append(parser.documentFragmentToNode(self), nodes);
-    }
-
-    pub fn _replaceChildren(self: *parser.DocumentFragment, nodes: []const Node.NodeOrText) !void {
-        return Node.replaceChildren(parser.documentFragmentToNode(self), nodes);
-    }
-
-    pub fn _querySelector(self: *parser.DocumentFragment, selector: []const u8, page: *Page) !?ElementUnion {
-        if (selector.len == 0) return null;
-
-        const n = try css.querySelector(page.call_arena, parser.documentFragmentToNode(self), selector);
-
-        if (n == null) return null;
-
-        return try Element.toInterface(parser.nodeToElement(n.?));
-    }
-
-    pub fn _querySelectorAll(self: *parser.DocumentFragment, selector: []const u8, page: *Page) !NodeList {
-        return css.querySelectorAll(page.arena, parser.documentFragmentToNode(self), selector);
-    }
-
-    pub fn get_childElementCount(self: *parser.DocumentFragment) !u32 {
-        var children = try get_children(self);
-        return children.get_length();
-    }
-
-    pub fn get_children(self: *parser.DocumentFragment) !collection.HTMLCollection {
-        return collection.HTMLCollectionChildren(parser.documentFragmentToNode(self), .{
-            .include_root = false,
-        });
-    }
-
-    pub fn _getElementById(self: *parser.DocumentFragment, id: []const u8) !?ElementUnion {
-        const e = try parser.nodeGetElementById(@ptrCast(@alignCast(self)), id) orelse return null;
-        return try Element.toInterface(e);
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.DocumentFragment" {
-    try testing.htmlRunner("dom/document_fragment.html");
-}
--- a/src/browser/dom/document_type.zig
+++ b/src/browser/dom/document_type.zig
@@ -1,67 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-
-const Node = @import("node.zig").Node;
-
-// WEB IDL https://dom.spec.whatwg.org/#documenttype
-pub const DocumentType = struct {
-    pub const Self = parser.DocumentType;
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    pub fn get_name(self: *parser.DocumentType) ![]const u8 {
-        return parser.documentTypeGetName(self);
-    }
-
-    pub fn get_publicId(self: *parser.DocumentType) []const u8 {
-        return parser.documentTypeGetPublicId(self);
-    }
-
-    pub fn get_systemId(self: *parser.DocumentType) []const u8 {
-        return parser.documentTypeGetSystemId(self);
-    }
-
-    // netsurf's DocumentType doesn't implement the dom_node_get_attributes
-    // and thus will crash if we try to call nodeIsEqualNode.
-    pub fn _isEqualNode(self: *parser.DocumentType, other_node: *parser.Node) !bool {
-        if (parser.nodeType(other_node) != .document_type) {
-            return false;
-        }
-
-        const other: *parser.DocumentType = @ptrCast(other_node);
-        if (std.mem.eql(u8, try get_name(self), try get_name(other)) == false) {
-            return false;
-        }
-        if (std.mem.eql(u8, get_publicId(self), get_publicId(other)) == false) {
-            return false;
-        }
-        if (std.mem.eql(u8, get_systemId(self), get_systemId(other)) == false) {
-            return false;
-        }
-        return true;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.DocumentType" {
-    try testing.htmlRunner("dom/document_type.html");
-}
--- a/src/browser/dom/element.zig
+++ b/src/browser/dom/element.zig
@@ -1,686 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const css = @import("css.zig");
-const log = @import("../../log.zig");
-const dump = @import("../dump.zig");
-const collection = @import("html_collection.zig");
-
-const Node = @import("node.zig").Node;
-const Walker = @import("walker.zig").WalkerDepthFirst;
-const NodeList = @import("nodelist.zig").NodeList;
-const HTMLElem = @import("../html/elements.zig");
-const ShadowRoot = @import("../dom/shadow_root.zig").ShadowRoot;
-
-const Animation = @import("Animation.zig");
-
-pub const Union = @import("../html/elements.zig").Union;
-
-// WEB IDL https://dom.spec.whatwg.org/#element
-pub const Element = struct {
-    pub const Self = parser.Element;
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    pub const DOMRect = struct {
-        x: f64,
-        y: f64,
-        width: f64,
-        height: f64,
-        bottom: f64,
-        right: f64,
-        top: f64,
-        left: f64,
-    };
-
-    pub fn toInterface(e: *parser.Element) !Union {
-        return toInterfaceT(Union, e);
-    }
-
-    pub fn toInterfaceT(comptime T: type, e: *parser.Element) !T {
-        const tagname = try parser.elementGetTagName(e) orelse {
-            // If the owner's document is HTML, assume we have an HTMLElement.
-            const doc = parser.nodeOwnerDocument(parser.elementToNode(e));
-            if (doc != null and !doc.?.is_html) {
-                return .{ .HTMLElement = @as(*parser.ElementHTML, @ptrCast(e)) };
-            }
-
-            return .{ .Element = e };
-        };
-
-        // TODO SVGElement and MathML are not supported yet.
-
-        const tag = parser.Tag.fromString(tagname) catch {
-            // If the owner's document is HTML, assume we have an HTMLElement.
-            const doc = parser.nodeOwnerDocument(parser.elementToNode(e));
-            if (doc != null and doc.?.is_html) {
-                return .{ .HTMLElement = @as(*parser.ElementHTML, @ptrCast(e)) };
-            }
-
-            return .{ .Element = e };
-        };
-
-        return HTMLElem.toInterfaceFromTag(T, e, tag);
-    }
-
-    // JS funcs
-    // --------
-
-    pub fn get_namespaceURI(self: *parser.Element) ?[]const u8 {
-        return parser.nodeGetNamespace(parser.elementToNode(self));
-    }
-
-    pub fn get_prefix(self: *parser.Element) ?[]const u8 {
-        return parser.nodeGetPrefix(parser.elementToNode(self));
-    }
-
-    pub fn get_localName(self: *parser.Element) ![]const u8 {
-        return try parser.nodeLocalName(parser.elementToNode(self));
-    }
-
-    pub fn get_tagName(self: *parser.Element) ![]const u8 {
-        return try parser.nodeName(parser.elementToNode(self));
-    }
-
-    pub fn get_dir(self: *parser.Element) ![]const u8 {
-        return try parser.elementGetAttribute(self, "dir") orelse "";
-    }
-
-    pub fn set_dir(self: *parser.Element, dir: []const u8) !void {
-        return parser.elementSetAttribute(self, "dir", dir);
-    }
-
-    pub fn get_id(self: *parser.Element) ![]const u8 {
-        return try parser.elementGetAttribute(self, "id") orelse "";
-    }
-
-    pub fn set_id(self: *parser.Element, id: []const u8) !void {
-        return try parser.elementSetAttribute(self, "id", id);
-    }
-
-    pub fn get_className(self: *parser.Element) ![]const u8 {
-        return try parser.elementGetAttribute(self, "class") orelse "";
-    }
-
-    pub fn set_className(self: *parser.Element, class: []const u8) !void {
-        return try parser.elementSetAttribute(self, "class", class);
-    }
-
-    pub fn get_slot(self: *parser.Element) ![]const u8 {
-        return try parser.elementGetAttribute(self, "slot") orelse "";
-    }
-
-    pub fn set_slot(self: *parser.Element, slot: []const u8) !void {
-        return try parser.elementSetAttribute(self, "slot", slot);
-    }
-
-    pub fn get_assignedSlot(self: *parser.Element, page: *const Page) !?*parser.Slot {
-        return @import("../SlotChangeMonitor.zig").findSlot(self, page);
-    }
-
-    pub fn get_classList(self: *parser.Element) !*parser.TokenList {
-        return try parser.tokenListCreate(self, "class");
-    }
-
-    pub fn get_attributes(self: *parser.Element) !*parser.NamedNodeMap {
-        // An element must have non-nil attributes.
-        return try parser.nodeGetAttributes(parser.elementToNode(self)) orelse unreachable;
-    }
-
-    pub fn get_innerHTML(self: *parser.Element, page: *Page) ![]const u8 {
-        var aw = std.Io.Writer.Allocating.init(page.call_arena);
-        try dump.writeChildren(parser.elementToNode(self), .{}, &aw.writer);
-        return aw.written();
-    }
-
-    pub fn get_outerHTML(self: *parser.Element, page: *Page) ![]const u8 {
-        var aw = std.Io.Writer.Allocating.init(page.call_arena);
-        try dump.writeNode(parser.elementToNode(self), .{}, &aw.writer);
-        return aw.written();
-    }
-
-    pub fn set_innerHTML(self: *parser.Element, str: []const u8, page: *Page) !void {
-        const node = parser.elementToNode(self);
-        const doc = parser.nodeOwnerDocument(node) orelse return parser.DOMError.WrongDocument;
-        // parse the fragment
-        const fragment = try parser.documentParseFragmentFromStr(doc, str);
-
-        // remove existing children
-        try Node.removeChildren(node);
-
-        const fragment_node = parser.documentFragmentToNode(fragment);
-
-        // I'm not sure what the exact behavior is supposed to be. Initially,
-        // we were only copying the body of the document fragment. But it seems
-        // like head elements should be copied too. Specifically, some sites
-        // create script tags via innerHTML, which we need to capture.
-        // If you play with this in a browser, you should notice that the
-        // behavior is different depending on whether you're in a blank page
-        // or an actual document. In a blank page, something like:
-        //    x.innerHTML = '<script></script>';
-        // does _not_ create an empty script, but in a real page, it does. Weird.
-        const html = parser.nodeFirstChild(fragment_node) orelse return;
-        const head = parser.nodeFirstChild(html) orelse return;
-        const body = parser.nodeNextSibling(head) orelse return;
-
-        if (try parser.elementTag(self) == .template) {
-            // HTMLElementTemplate is special. We don't append these as children
-            // of the template, but instead set its content as the body of the
-            // fragment. Simpler to do this by copying the body children into
-            // a new fragment
-            const clean = try parser.documentCreateDocumentFragment(doc);
-            const children = try parser.nodeGetChildNodes(body);
-            // always index 0, because nodeAppendChild moves the node out of
-            // the nodeList and into the new tree
-            while (parser.nodeListItem(children, 0)) |child| {
-                _ = try parser.nodeAppendChild(@ptrCast(@alignCast(clean)), child);
-            }
-
-            const state = try page.getOrCreateNodeState(node);
-            state.template_content = clean;
-            return;
-        }
-
-        // For any node other than a template, we copy the head and body elements
-        // as child nodes of the element
-        {
-            // First, copy some of the head element
-            const children = try parser.nodeGetChildNodes(head);
-            // always index 0, because nodeAppendChild moves the node out of
-            // the nodeList and into the new tree
-            while (parser.nodeListItem(children, 0)) |child| {
-                _ = try parser.nodeAppendChild(node, child);
-            }
-        }
-
-        {
-            const children = try parser.nodeGetChildNodes(body);
-            // always index 0, because nodeAppendChild moves the node out of
-            // the nodeList and into the new tree
-            while (parser.nodeListItem(children, 0)) |child| {
-                _ = try parser.nodeAppendChild(node, child);
-            }
-        }
-    }
-
-    /// Parses the given `input` string and inserts its children to an element at given `position`.
-    /// https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentHTML
-    ///
-    /// TODO: Support for XML parsing and `TrustedHTML` instances.
-    pub fn _insertAdjacentHTML(self: *parser.Element, position: []const u8, input: []const u8) !void {
-        const self_node = parser.elementToNode(self);
-        const doc = parser.nodeOwnerDocument(self_node) orelse {
-            return parser.DOMError.WrongDocument;
-        };
-
-        // Parse the fragment.
-        // Should return error.Syntax on fail?
-        const fragment = try parser.documentParseFragmentFromStr(doc, input);
-        const fragment_node = parser.documentFragmentToNode(fragment);
-
-        // We always get it wrapped like so:
-        // <html><head></head><body>{ ... }</body></html>
-        // None of the following can be null.
-        const maybe_html = parser.nodeFirstChild(fragment_node);
-        std.debug.assert(maybe_html != null);
-        const html = maybe_html orelse return;
-
-        const maybe_body = parser.nodeLastChild(html);
-        std.debug.assert(maybe_body != null);
-        const body = maybe_body orelse return;
-
-        const children = try parser.nodeGetChildNodes(body);
-
-        // * `target_node` is `*Node` (where we actually insert),
-        // * `prev_node` is `?*Node`.
-        const target_node, const prev_node = blk: {
-            // Prefer case-sensitive match.
-            // "beforeend" was the most common case in my tests; we might adjust the order
-            // depending on which ones websites prefer most.
-            if (std.mem.eql(u8, position, "beforeend")) {
-                break :blk .{ self_node, null };
-            }
-
-            if (std.mem.eql(u8, position, "afterbegin")) {
-                // Get the first child; null indicates there are no children.
-                const first_child = parser.nodeFirstChild(self_node);
-                break :blk .{ self_node, first_child };
-            }
-
-            if (std.mem.eql(u8, position, "beforebegin")) {
-                // The node must have a parent node in order to use this variant.
-                const parent = parser.nodeParentNode(self_node) orelse return error.NoModificationAllowed;
-                // Parent cannot be Document.
-                // Should have checks for document_fragment and document_type?
-                if (parser.nodeType(parent) == .document) {
-                    return error.NoModificationAllowed;
-                }
-
-                break :blk .{ parent, self_node };
-            }
-
-            if (std.mem.eql(u8, position, "afterend")) {
-                // The node must have a parent node in order to use this variant.
-                const parent = parser.nodeParentNode(self_node) orelse return error.NoModificationAllowed;
-                // Parent cannot be Document.
-                if (parser.nodeType(parent) == .document) {
-                    return error.NoModificationAllowed;
-                }
-                // Get the next sibling or null; null indicates our node is the only one.
-                const sibling = parser.nodeNextSibling(self_node);
-                break :blk .{ parent, sibling };
-            }
-
-            // Thrown if:
-            // * position is not one of the four listed values.
-            // * The input is XML that is not well-formed.
-            return error.Syntax;
-        };
-
-        while (parser.nodeListItem(children, 0)) |child| {
-            _ = try parser.nodeInsertBefore(target_node, child, prev_node);
-        }
-    }
-
-    // The closest() method of the Element interface traverses the element and its parents (heading toward the document root) until it finds a node that matches the specified CSS selector.
-    // Returns the closest ancestor Element or itself, which matches the selectors. If there are no such element, null.
-    pub fn _closest(self: *parser.Element, selector: []const u8, page: *Page) !?*parser.Element {
-        const cssParse = @import("../css/css.zig").parse;
-        const CssNodeWrap = @import("../css/libdom.zig").Node;
-        const select = try cssParse(page.call_arena, selector, .{});
-
-        var current: CssNodeWrap = .{ .node = parser.elementToNode(self) };
-        while (true) {
-            if (try select.match(current)) {
-                if (!current.isElement()) {
-                    log.err(.browser, "closest invalid type", .{ .type = try current.tag() });
-                    return null;
-                }
-                return parser.nodeToElement(current.node);
-            }
-            current = current.parent() orelse return null;
-        }
-    }
-
-    // don't use parser.nodeHasAttributes(...) because that returns true/false
-    // based on the type, e.g. a node never as attributes, an element always has
-    // attributes. But, Element.hasAttributes is supposed to return true only
-    // if the element has at least 1 attribute.
-    pub fn _hasAttributes(self: *parser.Element) !bool {
-        // an element _must_ have at least an empty attribute
-        const node_map = try parser.nodeGetAttributes(parser.elementToNode(self)) orelse unreachable;
-        return try parser.namedNodeMapGetLength(node_map) > 0;
-    }
-
-    pub fn _getAttribute(self: *parser.Element, qname: []const u8) !?[]const u8 {
-        return try parser.elementGetAttribute(self, qname);
-    }
-
-    pub fn _getAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8) !?[]const u8 {
-        return try parser.elementGetAttributeNS(self, ns, qname);
-    }
-
-    pub fn _setAttribute(self: *parser.Element, qname: []const u8, value: []const u8) !void {
-        return try parser.elementSetAttribute(self, qname, value);
-    }
-
-    pub fn _setAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8, value: []const u8) !void {
-        return try parser.elementSetAttributeNS(self, ns, qname, value);
-    }
-
-    pub fn _removeAttribute(self: *parser.Element, qname: []const u8) !void {
-        return try parser.elementRemoveAttribute(self, qname);
-    }
-
-    pub fn _removeAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8) !void {
-        return try parser.elementRemoveAttributeNS(self, ns, qname);
-    }
-
-    pub fn _hasAttribute(self: *parser.Element, qname: []const u8) !bool {
-        return try parser.elementHasAttribute(self, qname);
-    }
-
-    pub fn _hasAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8) !bool {
-        return try parser.elementHasAttributeNS(self, ns, qname);
-    }
-
-    // https://dom.spec.whatwg.org/#dom-element-toggleattribute
-    pub fn _toggleAttribute(self: *parser.Element, qname: []u8, force: ?bool) !bool {
-        _ = std.ascii.lowerString(qname, qname);
-        const exists = try parser.elementHasAttribute(self, qname);
-
-        // If attribute is null, then:
-        if (!exists) {
-            // If force is not given or is true, create an attribute whose
-            // local name is qualifiedName, value is the empty string and node
-            // document is this’s node document, then append this attribute to
-            // this, and then return true.
-            if (force == null or force.?) {
-                try parser.elementSetAttribute(self, qname, "");
-                return true;
-            }
-            if (try parser.validateName(qname) == false) {
-                return parser.DOMError.InvalidCharacter;
-            }
-
-            // Return false.
-            return false;
-        }
-
-        // Otherwise, if force is not given or is false, remove an attribute
-        // given qualifiedName and this, and then return false.
-        if (force == null or !force.?) {
-            try parser.elementRemoveAttribute(self, qname);
-            return false;
-        }
-
-        // Return true.
-        return true;
-    }
-
-    pub fn _getAttributeNames(self: *parser.Element, page: *Page) ![]const []const u8 {
-        const attributes = try parser.nodeGetAttributes(@ptrCast(self)) orelse return &.{};
-        const ln = try parser.namedNodeMapGetLength(attributes);
-
-        const names = try page.call_arena.alloc([]const u8, ln);
-        var at: usize = 0;
-
-        for (0..ln) |i| {
-            const attribute = try parser.namedNodeMapItem(attributes, @intCast(i)) orelse break;
-            names[at] = try parser.attributeGetName(attribute);
-            at += 1;
-        }
-
-        return names[0..at];
-    }
-
-    pub fn _getAttributeNode(self: *parser.Element, name: []const u8) !?*parser.Attribute {
-        return try parser.elementGetAttributeNode(self, name);
-    }
-
-    pub fn _getAttributeNodeNS(self: *parser.Element, ns: []const u8, name: []const u8) !?*parser.Attribute {
-        return try parser.elementGetAttributeNodeNS(self, ns, name);
-    }
-
-    pub fn _setAttributeNode(self: *parser.Element, attr: *parser.Attribute) !?*parser.Attribute {
-        return try parser.elementSetAttributeNode(self, attr);
-    }
-
-    pub fn _setAttributeNodeNS(self: *parser.Element, attr: *parser.Attribute) !?*parser.Attribute {
-        return try parser.elementSetAttributeNodeNS(self, attr);
-    }
-
-    pub fn _removeAttributeNode(self: *parser.Element, attr: *parser.Attribute) !*parser.Attribute {
-        return try parser.elementRemoveAttributeNode(self, attr);
-    }
-
-    pub fn _getElementsByTagName(self: *parser.Element, tag_name: js.String) !collection.HTMLCollection {
-        return collection.HTMLCollectionByTagName(
-            parser.elementToNode(self),
-            tag_name.string,
-            .{ .include_root = false },
-        );
-    }
-
-    pub fn _getElementsByClassName(self: *parser.Element, class_names: js.String) !collection.HTMLCollection {
-        return try collection.HTMLCollectionByClassName(
-            parser.elementToNode(self),
-            class_names.string,
-            .{ .include_root = false },
-        );
-    }
-
-    // ParentNode
-    // https://dom.spec.whatwg.org/#parentnode
-    pub fn get_children(self: *parser.Element) !collection.HTMLCollection {
-        return collection.HTMLCollectionChildren(parser.elementToNode(self), .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_firstElementChild(self: *parser.Element) !?Union {
-        var children = try get_children(self);
-        return try children._item(0);
-    }
-
-    pub fn get_lastElementChild(self: *parser.Element) !?Union {
-        // TODO we could check the last child node first, if it's an element,
-        // we can return it directly instead of looping twice over the
-        // children.
-        var children = try get_children(self);
-        const ln = try children.get_length();
-        if (ln == 0) return null;
-        return try children._item(ln - 1);
-    }
-
-    pub fn get_childElementCount(self: *parser.Element) !u32 {
-        var children = try get_children(self);
-        return try children.get_length();
-    }
-
-    // NonDocumentTypeChildNode
-    // https://dom.spec.whatwg.org/#interface-nondocumenttypechildnode
-    pub fn get_previousElementSibling(self: *parser.Element) !?Union {
-        const res = parser.nodePreviousElementSibling(parser.elementToNode(self));
-        if (res == null) return null;
-        return try toInterface(res.?);
-    }
-
-    pub fn get_nextElementSibling(self: *parser.Element) !?Union {
-        const res = parser.nodeNextElementSibling(parser.elementToNode(self));
-        if (res == null) return null;
-        return try toInterface(res.?);
-    }
-
-    fn getElementById(self: *parser.Element, id: []const u8) !?*parser.Node {
-        // walk over the node tree fo find the node by id.
-        const root = parser.elementToNode(self);
-        const walker = Walker{};
-        var next: ?*parser.Node = null;
-        while (true) {
-            next = try walker.get_next(root, next) orelse return null;
-            // ignore non-element nodes.
-            if (parser.nodeType(next.?) != .element) {
-                continue;
-            }
-            const e = parser.nodeToElement(next.?);
-            if (std.mem.eql(u8, id, try get_id(e))) return next;
-        }
-    }
-
-    pub fn _querySelector(self: *parser.Element, selector: []const u8, page: *Page) !?Union {
-        if (selector.len == 0) return null;
-
-        const n = try css.querySelector(page.call_arena, parser.elementToNode(self), selector);
-
-        if (n == null) return null;
-
-        return try toInterface(parser.nodeToElement(n.?));
-    }
-
-    pub fn _querySelectorAll(self: *parser.Element, selector: []const u8, page: *Page) !NodeList {
-        return css.querySelectorAll(page.arena, parser.elementToNode(self), selector);
-    }
-
-    pub fn _prepend(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
-        return Node.prepend(parser.elementToNode(self), nodes);
-    }
-
-    pub fn _append(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
-        return Node.append(parser.elementToNode(self), nodes);
-    }
-
-    pub fn _before(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
-        const ref_node = parser.elementToNode(self);
-        return Node.before(ref_node, nodes);
-    }
-
-    pub fn _after(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
-        const ref_node = parser.elementToNode(self);
-        return Node.after(ref_node, nodes);
-    }
-
-    pub fn _replaceChildren(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
-        return Node.replaceChildren(parser.elementToNode(self), nodes);
-    }
-
-    // A DOMRect object providing information about the size of an element and its position relative to the viewport.
-    // Returns a 0 DOMRect object if the element is eventually detached from the main window
-    pub fn _getBoundingClientRect(self: *parser.Element, page: *Page) !DOMRect {
-        // Since we are lazy rendering we need to do this check. We could store the renderer in a viewport such that it could cache these, but it would require tracking changes.
-        if (!page.isNodeAttached(parser.elementToNode(self))) {
-            return DOMRect{
-                .x = 0,
-                .y = 0,
-                .width = 0,
-                .height = 0,
-                .bottom = 0,
-                .right = 0,
-                .top = 0,
-                .left = 0,
-            };
-        }
-        return page.renderer.getRect(self);
-    }
-
-    // Returns a collection of DOMRect objects that indicate the bounding rectangles for each CSS border box in a client.
-    // We do not render so it only always return the element's bounding rect.
-    // Returns an empty array if the element is eventually detached from the main window
-    pub fn _getClientRects(self: *parser.Element, page: *Page) ![]DOMRect {
-        if (!page.isNodeAttached(parser.elementToNode(self))) {
-            return &.{};
-        }
-        const heap_ptr = try page.call_arena.create(DOMRect);
-        heap_ptr.* = try page.renderer.getRect(self);
-        return heap_ptr[0..1];
-    }
-
-    pub fn get_clientWidth(_: *parser.Element, page: *Page) u32 {
-        return page.renderer.width();
-    }
-
-    pub fn get_clientHeight(_: *parser.Element, page: *Page) u32 {
-        return page.renderer.height();
-    }
-
-    pub fn _matches(self: *parser.Element, selectors: []const u8, page: *Page) !bool {
-        const cssParse = @import("../css/css.zig").parse;
-        const CssNodeWrap = @import("../css/libdom.zig").Node;
-        const s = try cssParse(page.call_arena, selectors, .{});
-        return s.match(CssNodeWrap{ .node = parser.elementToNode(self) });
-    }
-
-    pub fn _scrollIntoViewIfNeeded(_: *parser.Element, center_if_needed: ?bool) void {
-        _ = center_if_needed;
-    }
-
-    const CheckVisibilityOpts = struct {
-        contentVisibilityAuto: bool,
-        opacityProperty: bool,
-        visibilityProperty: bool,
-        checkVisibilityCSS: bool,
-        checkOpacity: bool,
-    };
-
-    pub fn _checkVisibility(self: *parser.Element, opts: ?CheckVisibilityOpts) bool {
-        _ = self;
-        _ = opts;
-        return true;
-    }
-
-    const AttachShadowOpts = struct {
-        mode: []const u8, // must be specified
-    };
-    pub fn _attachShadow(self: *parser.Element, opts: AttachShadowOpts, page: *Page) !*ShadowRoot {
-        const mode = std.meta.stringToEnum(ShadowRoot.Mode, opts.mode) orelse return error.InvalidArgument;
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        if (state.shadow_root) |sr| {
-            if (mode != sr.mode) {
-                // this is the behavior per the spec
-                return error.NotSupportedError;
-            }
-
-            try Node.removeChildren(@ptrCast(@alignCast(sr.proto)));
-            return sr;
-        }
-
-        // Not sure what to do if there is no owner document
-        const doc = parser.nodeOwnerDocument(@ptrCast(self)) orelse return error.InvalidArgument;
-        const fragment = try parser.documentCreateDocumentFragment(doc);
-        const sr = try page.arena.create(ShadowRoot);
-        sr.* = .{
-            .host = self,
-            .mode = mode,
-            .proto = fragment,
-        };
-        state.shadow_root = sr;
-        parser.documentFragmentSetHost(sr.proto, @ptrCast(@alignCast(self)));
-
-        // Storing the ShadowRoot on the element makes sense, it's the ShadowRoot's
-        // parent. When we render, we go top-down, so we'll have the element, get
-        // its shadowroot, and go on. that's what the above code does.
-        // But we sometimes need to go bottom-up, e.g when we have a slot element
-        // and want to find the containing parent. Unforatunately , we don't have
-        // that link, so we need to create it. In the DOM, the ShadowRoot is
-        // represented by this DocumentFragment (it's the ShadowRoot's base prototype)
-        // So we can also store the ShadowRoot in the DocumentFragment's state.
-        const fragment_state = try page.getOrCreateNodeState(@ptrCast(@alignCast(fragment)));
-        fragment_state.shadow_root = sr;
-
-        return sr;
-    }
-
-    pub fn get_shadowRoot(self: *parser.Element, page: *Page) ?*ShadowRoot {
-        const state = page.getNodeState(@ptrCast(@alignCast(self))) orelse return null;
-        const sr = state.shadow_root orelse return null;
-        if (sr.mode == .closed) {
-            return null;
-        }
-        return sr;
-    }
-
-    pub fn _animate(self: *parser.Element, effect: js.Object, opts: js.Object) !Animation {
-        _ = self;
-        _ = opts;
-        return Animation.constructor(effect, null);
-    }
-
-    pub fn _remove(self: *parser.Element) !void {
-        // TODO: This hasn't been tested to make sure all references to this
-        // node are properly updated. A lot of libdom is lazy and will look
-        // for related elements JIT by walking the tree, but there could be
-        // cases in libdom or the Zig WebAPI where this reference is kept
-        const as_node: *parser.Node = @ptrCast(self);
-        const parent = parser.nodeParentNode(as_node) orelse return;
-        _ = try Node._removeChild(parent, as_node);
-    }
-};
-
-// Tests
-// -----
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Element" {
-    try testing.htmlRunner("dom/element.html");
-}
--- a/src/browser/dom/event_target.zig
+++ b/src/browser/dom/event_target.zig
@@ -1,174 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const EventHandler = @import("../events/event.zig").EventHandler;
-
-const DOMException = @import("exceptions.zig").DOMException;
-const nod = @import("node.zig");
-
-pub const Union = union(enum) {
-    node: nod.Union,
-    xhr: *@import("../xhr/xhr.zig").XMLHttpRequest,
-    plain: *parser.EventTarget,
-    message_port: *@import("MessageChannel.zig").MessagePort,
-    screen: *@import("../html/screen.zig").Screen,
-    screen_orientation: *@import("../html/screen.zig").ScreenOrientation,
-    performance: *@import("performance.zig").Performance,
-    media_query_list: *@import("../html/media_query_list.zig").MediaQueryList,
-    navigation: *@import("../navigation/Navigation.zig"),
-};
-
-// EventTarget implementation
-pub const EventTarget = struct {
-    pub const Self = parser.EventTarget;
-    pub const Exception = DOMException;
-
-    // Extend libdom event target for pure zig struct.
-    base: parser.EventTargetTBase = parser.EventTargetTBase{ .internal_target_type = .plain },
-
-    pub fn toInterface(et: *parser.EventTarget, page: *Page) !Union {
-        // libdom assumes that all event targets are libdom nodes. They are not.
-
-        switch (parser.eventTargetInternalType(et)) {
-            .libdom_node => {
-                return .{ .node = try nod.Node.toInterface(@as(*parser.Node, @ptrCast(et))) };
-            },
-            .plain => return .{ .plain = et },
-            .abort_signal => {
-                // AbortSignal is a special case, it has its own internal type.
-                // We return it as a node, but we need to handle it differently.
-                return .{ .node = .{ .AbortSignal = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) } };
-            },
-            .window => {
-                // The window is a common non-node target, but it's easy to handle as its a singleton.
-                std.debug.assert(@intFromPtr(et) == @intFromPtr(&page.window.base));
-                return .{ .node = .{ .Window = &page.window } };
-            },
-            .xhr => {
-                const XMLHttpRequestEventTarget = @import("../xhr/event_target.zig").XMLHttpRequestEventTarget;
-                const base: *XMLHttpRequestEventTarget = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et)));
-                return .{ .xhr = @fieldParentPtr("proto", base) };
-            },
-            .message_port => {
-                return .{ .message_port = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) };
-            },
-            .screen => {
-                return .{ .screen = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) };
-            },
-            .screen_orientation => {
-                return .{ .screen_orientation = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) };
-            },
-            .performance => {
-                return .{ .performance = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et))) };
-            },
-            .media_query_list => {
-                return .{ .media_query_list = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et))) };
-            },
-            .navigation => {
-                const NavigationEventTarget = @import("../navigation/NavigationEventTarget.zig");
-                const base: *NavigationEventTarget = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et)));
-                return .{ .navigation = @fieldParentPtr("proto", base) };
-            },
-        }
-    }
-
-    // JS funcs
-    // --------
-    pub fn constructor(page: *Page) !*parser.EventTarget {
-        const et = try page.arena.create(EventTarget);
-        return @ptrCast(&et.base);
-    }
-
-    pub fn _addEventListener(
-        self: *parser.EventTarget,
-        typ: []const u8,
-        listener: EventHandler.Listener,
-        opts: ?EventHandler.Opts,
-        page: *Page,
-    ) !void {
-        _ = try EventHandler.register(page.arena, self, typ, listener, opts);
-        if (std.mem.eql(u8, typ, "slotchange")) {
-            try page.registerSlotChangeMonitor();
-        }
-    }
-
-    const RemoveEventListenerOpts = union(enum) {
-        opts: Opts,
-        capture: bool,
-
-        const Opts = struct {
-            capture: ?bool,
-        };
-    };
-
-    pub fn _removeEventListener(
-        self: *parser.EventTarget,
-        typ: []const u8,
-        listener: EventHandler.Listener,
-        opts_: ?RemoveEventListenerOpts,
-    ) !void {
-        var capture = false;
-        if (opts_) |opts| {
-            capture = switch (opts) {
-                .capture => |c| c,
-                .opts => |o| o.capture orelse false,
-            };
-        }
-
-        const cbk = (try listener.callback(self)) orelse return;
-
-        // check if event target has already this listener
-        const lst = try parser.eventTargetHasListener(
-            self,
-            typ,
-            capture,
-            cbk.id,
-        );
-        if (lst == null) {
-            return;
-        }
-
-        // remove listener
-        try parser.eventTargetRemoveEventListener(
-            self,
-            typ,
-            lst.?,
-            capture,
-        );
-    }
-
-    pub fn _dispatchEvent(self: *parser.EventTarget, event: *parser.Event, page: *Page) !bool {
-        const res = try parser.eventTargetDispatchEvent(self, event);
-
-        if (!parser.eventBubbles(event) or parser.eventIsStopped(event)) {
-            return res;
-        }
-
-        try page.window.dispatchForDocumentTarget(event);
-        return true;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.EventTarget" {
-    try testing.htmlRunner("dom/event_target.html");
-}
--- a/src/browser/dom/html_collection.zig
+++ b/src/browser/dom/html_collection.zig
@@ -1,454 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const parser = @import("../netsurf.zig");
-
-const Element = @import("element.zig").Element;
-const Union = @import("element.zig").Union;
-const Walker = @import("walker.zig").Walker;
-
-const Matcher = union(enum) {
-    matchByName: MatchByName,
-    matchByTagName: MatchByTagName,
-    matchByClassName: MatchByClassName,
-    matchByLinks: MatchByLinks,
-    matchByAnchors: MatchByAnchors,
-    matchTrue: struct {},
-    matchFalse: struct {},
-
-    pub fn match(self: Matcher, node: *parser.Node) !bool {
-        switch (self) {
-            .matchTrue => return true,
-            .matchFalse => return false,
-            .matchByLinks => return MatchByLinks.match(node),
-            .matchByAnchors => return MatchByAnchors.match(node),
-            inline else => |m| return m.match(node),
-        }
-    }
-};
-
-pub const MatchByTagName = struct {
-    // tag is used to select node against their name.
-    // tag comparison is case insensitive.
-    tag: []const u8,
-    is_wildcard: bool,
-
-    fn init(tag_name: []const u8) MatchByTagName {
-        if (std.mem.eql(u8, tag_name, "*")) {
-            return .{ .tag = "*", .is_wildcard = true };
-        }
-
-        return .{
-            .tag = tag_name,
-            .is_wildcard = false,
-        };
-    }
-
-    pub fn match(self: MatchByTagName, node: *parser.Node) !bool {
-        return self.is_wildcard or std.ascii.eqlIgnoreCase(self.tag, try parser.nodeName(node));
-    }
-};
-
-pub fn HTMLCollectionByTagName(
-    root: ?*parser.Node,
-    tag_name: []const u8,
-    opts: Opts,
-) HTMLCollection {
-    return .{
-        .root = root,
-        .walker = .{ .walkerDepthFirst = .{} },
-        .matcher = .{ .matchByTagName = MatchByTagName.init(tag_name) },
-        .mutable = opts.mutable,
-        .include_root = opts.include_root,
-    };
-}
-
-pub const MatchByClassName = struct {
-    class_names: []const u8,
-
-    fn init(class_names: []const u8) !MatchByClassName {
-        return .{
-            .class_names = class_names,
-        };
-    }
-
-    pub fn match(self: MatchByClassName, node: *parser.Node) !bool {
-        const e = parser.nodeToElement(node);
-
-        var it = std.mem.splitScalar(u8, self.class_names, ' ');
-        while (it.next()) |c| {
-            if (!try parser.elementHasClass(e, c)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-};
-
-pub fn HTMLCollectionByClassName(
-    root: ?*parser.Node,
-    class_names: []const u8,
-    opts: Opts,
-) !HTMLCollection {
-    return HTMLCollection{
-        .root = root,
-        .walker = .{ .walkerDepthFirst = .{} },
-        .matcher = .{ .matchByClassName = try MatchByClassName.init(class_names) },
-        .mutable = opts.mutable,
-        .include_root = opts.include_root,
-    };
-}
-
-pub const MatchByName = struct {
-    name: []const u8,
-
-    fn init(name: []const u8) !MatchByName {
-        return .{ .name = name };
-    }
-
-    pub fn match(self: MatchByName, node: *parser.Node) !bool {
-        const e = parser.nodeToElement(node);
-        const nname = try parser.elementGetAttribute(e, "name") orelse return false;
-        return std.mem.eql(u8, self.name, nname);
-    }
-};
-
-pub fn HTMLCollectionByName(
-    root: ?*parser.Node,
-    name: []const u8,
-    opts: Opts,
-) !HTMLCollection {
-    return HTMLCollection{
-        .root = root,
-        .walker = .{ .walkerDepthFirst = .{} },
-        .matcher = .{ .matchByName = try MatchByName.init(name) },
-        .mutable = opts.mutable,
-        .include_root = opts.include_root,
-    };
-}
-
-// HTMLAllCollection is a special type: instances of it are falsy. It's the only
-// object in the WebAPI that behaves like this - in fact, it's even a special
-// case in the JavaScript spec.
-// This is important, because a lot of browser detection rely on this behavior
-// to determine what browser is running.
-
-// It's also possible to use an instance like a function:
-//   document.all(3)
-//   document.all('some_id')
-pub const HTMLAllCollection = struct {
-    pub const prototype = *HTMLCollection;
-
-    proto: HTMLCollection,
-
-    pub const mark_as_undetectable = true;
-
-    pub fn init(root: ?*parser.Node) HTMLAllCollection {
-        return .{ .proto = .{
-            .root = root,
-            .walker = .{ .walkerDepthFirst = .{} },
-            .matcher = .{ .matchTrue = .{} },
-            .include_root = true,
-        } };
-    }
-
-    const CAllAsFunctionArg = union(enum) {
-        index: u32,
-        id: []const u8,
-    };
-
-    pub fn jsCallAsFunction(self: *HTMLAllCollection, arg: CAllAsFunctionArg) !?Union {
-        return switch (arg) {
-            .index => |i| self.proto._item(i),
-            .id => |id| self.proto._namedItem(id),
-        };
-    }
-};
-
-pub fn HTMLCollectionChildren(
-    root: ?*parser.Node,
-    opts: Opts,
-) HTMLCollection {
-    return HTMLCollection{
-        .root = root,
-        .walker = .{ .walkerChildren = .{} },
-        .matcher = .{ .matchTrue = .{} },
-        .mutable = opts.mutable,
-        .include_root = opts.include_root,
-    };
-}
-
-pub fn HTMLCollectionEmpty() HTMLCollection {
-    return .{
-        .root = null,
-        .walker = .{ .walkerNone = .{} },
-        .matcher = .{ .matchFalse = .{} },
-        .include_root = false,
-    };
-}
-
-// MatchByLinks matches the a and area elements in the Document that have href
-// attributes.
-// https://html.spec.whatwg.org/#dom-document-links
-pub const MatchByLinks = struct {
-    pub fn match(node: *parser.Node) !bool {
-        const tag = try parser.nodeName(node);
-        if (!std.ascii.eqlIgnoreCase(tag, "a") and !std.ascii.eqlIgnoreCase(tag, "area")) {
-            return false;
-        }
-        const elem = @as(*parser.Element, @ptrCast(node));
-        return parser.elementHasAttribute(elem, "href");
-    }
-};
-
-pub fn HTMLCollectionByLinks(root: ?*parser.Node, opts: Opts) HTMLCollection {
-    return .{
-        .root = root,
-        .walker = .{ .walkerDepthFirst = .{} },
-        .matcher = .{ .matchByLinks = .{} },
-        .mutable = opts.mutable,
-        .include_root = opts.include_root,
-    };
-}
-
-// MatchByAnchors matches the a elements in the Document that have name
-// attributes.
-// https://html.spec.whatwg.org/#dom-document-anchors
-pub const MatchByAnchors = struct {
-    pub fn match(node: *parser.Node) !bool {
-        const tag = try parser.nodeName(node);
-        if (!std.ascii.eqlIgnoreCase(tag, "a")) return false;
-
-        const elem = @as(*parser.Element, @ptrCast(node));
-        return parser.elementHasAttribute(elem, "name");
-    }
-};
-
-pub fn HTMLCollectionByAnchors(root: ?*parser.Node, opts: Opts) HTMLCollection {
-    return .{
-        .root = root,
-        .walker = .{ .walkerDepthFirst = .{} },
-        .matcher = .{ .matchByAnchors = .{} },
-        .mutable = opts.mutable,
-        .include_root = opts.include_root,
-    };
-}
-
-pub const HTMLCollectionIterator = struct {
-    coll: *HTMLCollection,
-    index: u32 = 0,
-
-    pub const Return = struct {
-        value: ?Union,
-        done: bool,
-    };
-
-    pub fn _next(self: *HTMLCollectionIterator) !Return {
-        const e = try self.coll._item(self.index);
-        if (e == null) {
-            return Return{
-                .value = null,
-                .done = true,
-            };
-        }
-
-        self.index += 1;
-        return Return{
-            .value = e,
-            .done = false,
-        };
-    }
-};
-
-const Opts = struct {
-    include_root: bool,
-    mutable: bool = false,
-};
-
-// WEB IDL https://dom.spec.whatwg.org/#htmlcollection
-// HTMLCollection is re implemented in zig here because libdom
-// dom_html_collection expects a comparison function callback as arguement.
-// But we wanted a dynamically comparison here, according to the match tagname.
-pub const HTMLCollection = struct {
-    matcher: Matcher,
-    walker: Walker,
-
-    root: ?*parser.Node,
-
-    // By default the HTMLCollection walk on the root's descendant only.
-    // But on somes cases, like for dom document, we want to walk over the root
-    // itself.
-    include_root: bool = false,
-
-    mutable: bool = false,
-
-    // save a state for the collection to improve the _item speed.
-    cur_idx: ?u32 = null,
-    cur_node: ?*parser.Node = null,
-
-    // start returns the first node to walk on.
-    fn start(self: *const HTMLCollection) !?*parser.Node {
-        if (self.root == null) return null;
-
-        if (self.include_root) {
-            return self.root.?;
-        }
-
-        return try self.walker.get_next(self.root.?, null);
-    }
-
-    pub fn _symbol_iterator(self: *HTMLCollection) HTMLCollectionIterator {
-        return HTMLCollectionIterator{
-            .coll = self,
-        };
-    }
-
-    /// get_length computes the collection's length dynamically according to
-    /// the current root structure.
-    // TODO: nodes retrieved must be de-referenced.
-    pub fn get_length(self: *HTMLCollection) !u32 {
-        if (self.root == null) return 0;
-
-        var len: u32 = 0;
-        var node = try self.start() orelse return 0;
-
-        while (true) {
-            if (parser.nodeType(node) == .element) {
-                if (try self.matcher.match(node)) {
-                    len += 1;
-                }
-            }
-
-            node = try self.walker.get_next(self.root.?, node) orelse break;
-        }
-
-        return len;
-    }
-
-    pub fn item(self: *HTMLCollection, index: u32) !?*parser.Node {
-        if (self.root == null) return null;
-
-        var i: u32 = 0;
-        var node: *parser.Node = undefined;
-
-        // Use the current state to improve speed if possible.
-        if (self.mutable == false and self.cur_idx != null and index >= self.cur_idx.?) {
-            i = self.cur_idx.?;
-            node = self.cur_node.?;
-        } else {
-            node = try self.start() orelse return null;
-        }
-
-        while (true) {
-            if (parser.nodeType(node) == .element) {
-                if (try self.matcher.match(node)) {
-                    // check if we found the searched element.
-                    if (i == index) {
-                        // save the current state
-                        self.cur_node = node;
-                        self.cur_idx = i;
-
-                        return node;
-                    }
-
-                    i += 1;
-                }
-            }
-
-            node = try self.walker.get_next(self.root.?, node) orelse break;
-        }
-
-        return null;
-    }
-
-    pub fn _item(self: *HTMLCollection, index: u32) !?Union {
-        const node = try self.item(index) orelse return null;
-        const e = @as(*parser.Element, @ptrCast(node));
-        return try Element.toInterface(e);
-    }
-
-    pub fn _namedItem(self: *const HTMLCollection, name: []const u8) !?Union {
-        if (self.root == null) return null;
-        if (name.len == 0) return null;
-
-        var node = try self.start() orelse return null;
-
-        while (true) {
-            if (parser.nodeType(node) == .element) {
-                if (try self.matcher.match(node)) {
-                    const elem = @as(*parser.Element, @ptrCast(node));
-
-                    var attr = try parser.elementGetAttribute(elem, "id");
-                    // check if the node id corresponds to the name argument.
-                    if (attr != null and std.mem.eql(u8, name, attr.?)) {
-                        return try Element.toInterface(elem);
-                    }
-
-                    attr = try parser.elementGetAttribute(elem, "name");
-                    // check if the node id corresponds to the name argument.
-                    if (attr != null and std.mem.eql(u8, name, attr.?)) {
-                        return try Element.toInterface(elem);
-                    }
-                }
-            }
-
-            node = try self.walker.get_next(self.root.?, node) orelse break;
-        }
-
-        return null;
-    }
-
-    fn item_name(elt: *parser.Element) !?[]const u8 {
-        if (try parser.elementGetAttribute(elt, "id")) |v| {
-            return v;
-        }
-        if (try parser.elementGetAttribute(elt, "name")) |v| {
-            return v;
-        }
-
-        return null;
-    }
-
-    pub fn indexed_get(self: *HTMLCollection, index: u32, has_value: *bool) !?Union {
-        return (try _item(self, index)) orelse {
-            has_value.* = false;
-            return undefined;
-        };
-    }
-
-    pub fn named_get(self: *const HTMLCollection, name: []const u8, has_value: *bool) !?Union {
-        // Even though an entry might have an empty id, the spec says
-        // that namedItem("") should always return null
-        if (name.len == 0) {
-            return null;
-        }
-        return (try _namedItem(self, name)) orelse {
-            has_value.* = false;
-            return undefined;
-        };
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.HTMLCollection" {
-    try testing.htmlRunner("dom/html_collection.html");
-}
--- a/src/browser/dom/implementation.zig
+++ b/src/browser/dom/implementation.zig
@@ -1,56 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const parser = @import("../netsurf.zig");
-const DOMException = @import("exceptions.zig").DOMException;
-
-// WEB IDL https://dom.spec.whatwg.org/#domimplementation
-pub const DOMImplementation = struct {
-    pub const Exception = DOMException;
-
-    pub fn _createDocumentType(
-        _: *DOMImplementation,
-        qname: [:0]const u8,
-        publicId: [:0]const u8,
-        systemId: [:0]const u8,
-    ) !*parser.DocumentType {
-        return try parser.domImplementationCreateDocumentType(qname, publicId, systemId);
-    }
-
-    pub fn _createDocument(
-        _: *DOMImplementation,
-        namespace: ?[:0]const u8,
-        qname: ?[:0]const u8,
-        doctype: ?*parser.DocumentType,
-    ) !*parser.Document {
-        return try parser.domImplementationCreateDocument(namespace, qname, doctype);
-    }
-
-    pub fn _createHTMLDocument(_: *DOMImplementation, title: ?[]const u8) !*parser.DocumentHTML {
-        return try parser.domImplementationCreateHTMLDocument(title);
-    }
-
-    pub fn _hasFeature(_: *DOMImplementation) bool {
-        return true;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Implementation" {
-    try testing.htmlRunner("dom/implementation.html");
-}
--- a/src/browser/dom/mutation_observer.zig
+++ b/src/browser/dom/mutation_observer.zig
@@ -1,407 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const NodeList = @import("nodelist.zig").NodeList;
-
-pub const Interfaces = .{
-    MutationObserver,
-    MutationRecord,
-};
-
-const Walker = @import("../dom/walker.zig").WalkerChildren;
-
-// WEB IDL https://dom.spec.whatwg.org/#interface-mutationobserver
-pub const MutationObserver = struct {
-    page: *Page,
-    cbk: js.Function,
-    scheduled: bool,
-    observers: std.ArrayListUnmanaged(*Observer),
-
-    // List of records which were observed. When the call scope ends, we need to
-    // execute our callback with it.
-    observed: std.ArrayListUnmanaged(MutationRecord),
-
-    pub fn constructor(cbk: js.Function, page: *Page) !MutationObserver {
-        return .{
-            .cbk = cbk,
-            .page = page,
-            .observed = .{},
-            .scheduled = false,
-            .observers = .empty,
-        };
-    }
-
-    pub fn _observe(self: *MutationObserver, node: *parser.Node, options_: ?Options) !void {
-        const arena = self.page.arena;
-        var options = options_ orelse Options{};
-        if (options.attributeFilter.len > 0) {
-            options.attributeFilter = try arena.dupe([]const u8, options.attributeFilter);
-        }
-
-        const observer = try arena.create(Observer);
-        observer.* = .{
-            .node = node,
-            .options = options,
-            .mutation_observer = self,
-            .event_node = .{ .id = self.cbk.id, .func = Observer.handle },
-        };
-
-        try self.observers.append(arena, observer);
-
-        // register node's events
-        if (options.childList or options.subtree) {
-            observer.dom_node_inserted_listener = try parser.eventTargetAddEventListener(
-                parser.toEventTarget(parser.Node, node),
-                "DOMNodeInserted",
-                &observer.event_node,
-                false,
-            );
-            observer.dom_node_removed_listener = try parser.eventTargetAddEventListener(
-                parser.toEventTarget(parser.Node, node),
-                "DOMNodeRemoved",
-                &observer.event_node,
-                false,
-            );
-        }
-        if (options.attr()) {
-            observer.dom_node_attribute_modified_listener = try parser.eventTargetAddEventListener(
-                parser.toEventTarget(parser.Node, node),
-                "DOMAttrModified",
-                &observer.event_node,
-                false,
-            );
-        }
-        if (options.cdata()) {
-            observer.dom_cdata_modified_listener = try parser.eventTargetAddEventListener(
-                parser.toEventTarget(parser.Node, node),
-                "DOMCharacterDataModified",
-                &observer.event_node,
-                false,
-            );
-        }
-        if (options.subtree) {
-            observer.dom_subtree_modified_listener = try parser.eventTargetAddEventListener(
-                parser.toEventTarget(parser.Node, node),
-                "DOMSubtreeModified",
-                &observer.event_node,
-                false,
-            );
-        }
-    }
-
-    fn callback(ctx: *anyopaque) ?u32 {
-        const self: *MutationObserver = @ptrCast(@alignCast(ctx));
-        self.scheduled = false;
-
-        const records = self.observed.items;
-        if (records.len == 0) {
-            return null;
-        }
-
-        defer self.observed.clearRetainingCapacity();
-
-        var result: js.Function.Result = undefined;
-        self.cbk.tryCallWithThis(void, self, .{records}, &result) catch {
-            log.debug(.user_script, "callback error", .{
-                .err = result.exception,
-                .stack = result.stack,
-                .source = "mutation observer",
-            });
-        };
-        return null;
-    }
-
-    pub fn _disconnect(self: *MutationObserver) !void {
-        for (self.observers.items) |observer| {
-            const event_target = parser.toEventTarget(parser.Node, observer.node);
-            if (observer.dom_node_inserted_listener) |listener| {
-                try parser.eventTargetRemoveEventListener(
-                    event_target,
-                    "DOMNodeInserted",
-                    listener,
-                    false,
-                );
-            }
-
-            if (observer.dom_node_removed_listener) |listener| {
-                try parser.eventTargetRemoveEventListener(
-                    event_target,
-                    "DOMNodeRemoved",
-                    listener,
-                    false,
-                );
-            }
-
-            if (observer.dom_node_attribute_modified_listener) |listener| {
-                try parser.eventTargetRemoveEventListener(
-                    event_target,
-                    "DOMAttrModified",
-                    listener,
-                    false,
-                );
-            }
-
-            if (observer.dom_cdata_modified_listener) |listener| {
-                try parser.eventTargetRemoveEventListener(
-                    event_target,
-                    "DOMCharacterDataModified",
-                    listener,
-                    false,
-                );
-            }
-
-            if (observer.dom_subtree_modified_listener) |listener| {
-                try parser.eventTargetRemoveEventListener(
-                    event_target,
-                    "DOMSubtreeModified",
-                    listener,
-                    false,
-                );
-            }
-        }
-        self.observers.clearRetainingCapacity();
-    }
-
-    // TODO
-    pub fn _takeRecords(_: *const MutationObserver) ?[]const u8 {
-        return &[_]u8{};
-    }
-};
-
-pub const MutationRecord = struct {
-    type: []const u8,
-    target: *parser.Node,
-    added_nodes: NodeList = .{},
-    removed_nodes: NodeList = .{},
-    previous_sibling: ?*parser.Node = null,
-    next_sibling: ?*parser.Node = null,
-    attribute_name: ?[]const u8 = null,
-    attribute_namespace: ?[]const u8 = null,
-    old_value: ?[]const u8 = null,
-
-    pub fn get_type(self: *const MutationRecord) []const u8 {
-        return self.type;
-    }
-
-    pub fn get_addedNodes(self: *MutationRecord) *NodeList {
-        return &self.added_nodes;
-    }
-
-    pub fn get_removedNodes(self: *MutationRecord) *NodeList {
-        return &self.removed_nodes;
-    }
-
-    pub fn get_target(self: *const MutationRecord) *parser.Node {
-        return self.target;
-    }
-
-    pub fn get_attributeName(self: *const MutationRecord) ?[]const u8 {
-        return self.attribute_name;
-    }
-
-    pub fn get_attributeNamespace(self: *const MutationRecord) ?[]const u8 {
-        return self.attribute_namespace;
-    }
-
-    pub fn get_previousSibling(self: *const MutationRecord) ?*parser.Node {
-        return self.previous_sibling;
-    }
-
-    pub fn get_nextSibling(self: *const MutationRecord) ?*parser.Node {
-        return self.next_sibling;
-    }
-
-    pub fn get_oldValue(self: *const MutationRecord) ?[]const u8 {
-        return self.old_value;
-    }
-};
-
-const Options = struct {
-    childList: bool = false,
-    attributes: bool = false,
-    characterData: bool = false,
-    subtree: bool = false,
-    attributeOldValue: bool = false,
-    characterDataOldValue: bool = false,
-    attributeFilter: [][]const u8 = &.{},
-
-    fn attr(self: Options) bool {
-        return self.attributes or self.attributeOldValue or self.attributeFilter.len > 0;
-    }
-
-    fn cdata(self: Options) bool {
-        return self.characterData or self.characterDataOldValue;
-    }
-};
-
-const Observer = struct {
-    node: *parser.Node,
-    options: Options,
-
-    // reference back to the MutationObserver so that we can access the arena
-    // and batch the mutation records.
-    mutation_observer: *MutationObserver,
-
-    event_node: parser.EventNode,
-
-    dom_node_inserted_listener: ?*parser.EventListener = null,
-    dom_node_removed_listener: ?*parser.EventListener = null,
-    dom_node_attribute_modified_listener: ?*parser.EventListener = null,
-    dom_cdata_modified_listener: ?*parser.EventListener = null,
-    dom_subtree_modified_listener: ?*parser.EventListener = null,
-
-    fn appliesTo(
-        self: *const Observer,
-        target: *parser.Node,
-        event_type: MutationEventType,
-        event: *parser.MutationEvent,
-    ) !bool {
-        if (event_type == .DOMAttrModified and self.options.attributeFilter.len > 0) {
-            const attribute_name = try parser.mutationEventAttributeName(event);
-            for (self.options.attributeFilter) |needle| blk: {
-                if (std.mem.eql(u8, attribute_name, needle)) {
-                    break :blk;
-                }
-            }
-            return false;
-        }
-
-        // mutation on any target is always ok.
-        if (self.options.subtree) {
-            return true;
-        }
-
-        // if target equals node, alway ok.
-        if (target == self.node) {
-            return true;
-        }
-
-        // no subtree, no same target and no childlist, always noky.
-        if (!self.options.childList) {
-            return false;
-        }
-
-        // target must be a child of o.node
-        const walker = Walker{};
-        var next: ?*parser.Node = null;
-        while (true) {
-            next = walker.get_next(self.node, next) catch break orelse break;
-            if (next.? == target) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    fn handle(en: *parser.EventNode, event: *parser.Event) void {
-        const self: *Observer = @fieldParentPtr("event_node", en);
-        self._handle(event) catch |err| {
-            log.err(.web_api, "handle error", .{ .err = err, .source = "mutation observer" });
-        };
-    }
-
-    fn _handle(self: *Observer, event: *parser.Event) !void {
-        var mutation_observer = self.mutation_observer;
-
-        const node = blk: {
-            const event_target = parser.eventTarget(event) orelse return;
-            break :blk parser.eventTargetToNode(event_target);
-        };
-
-        const mutation_event = parser.eventToMutationEvent(event);
-        const event_type = blk: {
-            const t = parser.eventType(event);
-            break :blk std.meta.stringToEnum(MutationEventType, t) orelse return;
-        };
-
-        if (try self.appliesTo(node, event_type, mutation_event) == false) {
-            return;
-        }
-
-        var record = MutationRecord{
-            .target = self.node,
-            .type = event_type.recordType(),
-        };
-
-        const arena = mutation_observer.page.arena;
-        switch (event_type) {
-            .DOMAttrModified => {
-                record.attribute_name = parser.mutationEventAttributeName(mutation_event) catch null;
-                if (self.options.attributeOldValue) {
-                    record.old_value = parser.mutationEventPrevValue(mutation_event);
-                }
-            },
-            .DOMCharacterDataModified => {
-                if (self.options.characterDataOldValue) {
-                    record.old_value = parser.mutationEventPrevValue(mutation_event);
-                }
-            },
-            .DOMNodeInserted => {
-                if (parser.mutationEventRelatedNode(mutation_event) catch null) |related_node| {
-                    try record.added_nodes.append(arena, related_node);
-                }
-            },
-            .DOMNodeRemoved => {
-                if (parser.mutationEventRelatedNode(mutation_event) catch null) |related_node| {
-                    try record.removed_nodes.append(arena, related_node);
-                }
-            },
-        }
-
-        try mutation_observer.observed.append(arena, record);
-
-        if (mutation_observer.scheduled == false) {
-            mutation_observer.scheduled = true;
-            try mutation_observer.page.scheduler.add(
-                mutation_observer,
-                MutationObserver.callback,
-                0,
-                .{ .name = "mutation_observer" },
-            );
-        }
-    }
-};
-
-const MutationEventType = enum {
-    DOMAttrModified,
-    DOMCharacterDataModified,
-    DOMNodeInserted,
-    DOMNodeRemoved,
-
-    fn recordType(self: MutationEventType) []const u8 {
-        return switch (self) {
-            .DOMAttrModified => "attributes",
-            .DOMCharacterDataModified => "characterData",
-            .DOMNodeInserted => "childList",
-            .DOMNodeRemoved => "childList",
-        };
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.MutationObserver" {
-    try testing.htmlRunner("dom/mutation_observer.html");
-}
--- a/src/browser/dom/node.zig
+++ b/src/browser/dom/node.zig
@@ -1,637 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const generate = @import("../js/generate.zig");
-
-const Page = @import("../page.zig").Page;
-const EventTarget = @import("event_target.zig").EventTarget;
-
-// DOM
-const Attr = @import("attribute.zig").Attr;
-const CData = @import("character_data.zig");
-const Element = @import("element.zig").Element;
-const ElementUnion = @import("element.zig").Union;
-const NodeList = @import("nodelist.zig").NodeList;
-const Document = @import("document.zig").Document;
-const DocumentType = @import("document_type.zig").DocumentType;
-const DocumentFragment = @import("document_fragment.zig").DocumentFragment;
-const HTMLCollection = @import("html_collection.zig").HTMLCollection;
-const HTMLAllCollection = @import("html_collection.zig").HTMLAllCollection;
-const HTMLCollectionIterator = @import("html_collection.zig").HTMLCollectionIterator;
-const ShadowRoot = @import("shadow_root.zig").ShadowRoot;
-const Walker = @import("walker.zig").WalkerDepthFirst;
-
-// HTML
-const HTML = @import("../html/html.zig");
-
-// Node interfaces
-pub const Interfaces = .{
-    Attr,
-    CData.CharacterData,
-    CData.Interfaces,
-    Element,
-    Document,
-    DocumentType,
-    DocumentFragment,
-    HTMLCollection,
-    HTMLAllCollection,
-    HTMLCollectionIterator,
-    HTML.Interfaces,
-};
-
-pub const Union = generate.Union(Interfaces);
-
-// Node implementation
-pub const Node = struct {
-    pub const Self = parser.Node;
-    pub const prototype = *EventTarget;
-    pub const subtype = .node;
-
-    pub fn toInterface(node: *parser.Node) !Union {
-        return switch (parser.nodeType(node)) {
-            .element => try Element.toInterfaceT(
-                Union,
-                @as(*parser.Element, @ptrCast(node)),
-            ),
-            .comment => .{ .Comment = @as(*parser.Comment, @ptrCast(node)) },
-            .text => .{ .Text = @as(*parser.Text, @ptrCast(node)) },
-            .cdata_section => .{ .CDATASection = @as(*parser.CDATASection, @ptrCast(node)) },
-            .processing_instruction => .{ .ProcessingInstruction = @as(*parser.ProcessingInstruction, @ptrCast(node)) },
-            .document => blk: {
-                const doc: *parser.Document = @ptrCast(node);
-                if (doc.is_html) {
-                    break :blk .{ .HTMLDocument = @as(*parser.DocumentHTML, @ptrCast(node)) };
-                }
-
-                break :blk .{ .Document = doc };
-            },
-            .document_type => .{ .DocumentType = @as(*parser.DocumentType, @ptrCast(node)) },
-            .attribute => .{ .Attr = @as(*parser.Attribute, @ptrCast(node)) },
-            .document_fragment => .{ .DocumentFragment = @as(*parser.DocumentFragment, @ptrCast(node)) },
-            else => @panic("node type not handled"), // TODO
-        };
-    }
-
-    // class attributes
-
-    pub const _ELEMENT_NODE = @intFromEnum(parser.NodeType.element);
-    pub const _ATTRIBUTE_NODE = @intFromEnum(parser.NodeType.attribute);
-    pub const _TEXT_NODE = @intFromEnum(parser.NodeType.text);
-    pub const _CDATA_SECTION_NODE = @intFromEnum(parser.NodeType.cdata_section);
-    pub const _PROCESSING_INSTRUCTION_NODE = @intFromEnum(parser.NodeType.processing_instruction);
-    pub const _COMMENT_NODE = @intFromEnum(parser.NodeType.comment);
-    pub const _DOCUMENT_NODE = @intFromEnum(parser.NodeType.document);
-    pub const _DOCUMENT_TYPE_NODE = @intFromEnum(parser.NodeType.document_type);
-    pub const _DOCUMENT_FRAGMENT_NODE = @intFromEnum(parser.NodeType.document_fragment);
-
-    // These 3 are deprecated, but both Chrome and Firefox still expose them
-    pub const _ENTITY_REFERENCE_NODE = @intFromEnum(parser.NodeType.entity_reference);
-    pub const _ENTITY_NODE = @intFromEnum(parser.NodeType.entity);
-    pub const _NOTATION_NODE = @intFromEnum(parser.NodeType.notation);
-
-    pub const _DOCUMENT_POSITION_DISCONNECTED = @intFromEnum(parser.DocumentPosition.disconnected);
-    pub const _DOCUMENT_POSITION_PRECEDING = @intFromEnum(parser.DocumentPosition.preceding);
-    pub const _DOCUMENT_POSITION_FOLLOWING = @intFromEnum(parser.DocumentPosition.following);
-    pub const _DOCUMENT_POSITION_CONTAINS = @intFromEnum(parser.DocumentPosition.contains);
-    pub const _DOCUMENT_POSITION_CONTAINED_BY = @intFromEnum(parser.DocumentPosition.contained_by);
-    pub const _DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = @intFromEnum(parser.DocumentPosition.implementation_specific);
-
-    // JS funcs
-    // --------
-
-    // Read-only attributes
-    pub fn get_baseURI(_: *parser.Node, page: *Page) ![]const u8 {
-        return page.url.raw;
-    }
-
-    pub fn get_firstChild(self: *parser.Node) !?Union {
-        const res = parser.nodeFirstChild(self);
-        if (res == null) {
-            return null;
-        }
-        return try Node.toInterface(res.?);
-    }
-
-    pub fn get_lastChild(self: *parser.Node) !?Union {
-        const res = parser.nodeLastChild(self);
-        if (res == null) {
-            return null;
-        }
-        return try Node.toInterface(res.?);
-    }
-
-    pub fn get_nextSibling(self: *parser.Node) !?Union {
-        const res = parser.nodeNextSibling(self);
-        if (res == null) {
-            return null;
-        }
-        return try Node.toInterface(res.?);
-    }
-
-    pub fn get_previousSibling(self: *parser.Node) !?Union {
-        const res = parser.nodePreviousSibling(self);
-        if (res == null) {
-            return null;
-        }
-        return try Node.toInterface(res.?);
-    }
-
-    pub fn get_parentNode(self: *parser.Node) !?Union {
-        const res = parser.nodeParentNode(self);
-        if (res == null) {
-            return null;
-        }
-        return try Node.toInterface(res.?);
-    }
-
-    pub fn get_parentElement(self: *parser.Node) !?ElementUnion {
-        const res = parser.nodeParentElement(self);
-        if (res == null) {
-            return null;
-        }
-        return try Element.toInterface(res.?);
-    }
-
-    pub fn get_nodeName(self: *parser.Node) ![]const u8 {
-        return try parser.nodeName(self);
-    }
-
-    pub fn get_nodeType(self: *parser.Node) !u8 {
-        return @intFromEnum(parser.nodeType(self));
-    }
-
-    pub fn get_ownerDocument(self: *parser.Node) !?*parser.DocumentHTML {
-        const res = parser.nodeOwnerDocument(self);
-        if (res == null) {
-            return null;
-        }
-        return @as(*parser.DocumentHTML, @ptrCast(res.?));
-    }
-
-    pub fn get_isConnected(self: *parser.Node) !bool {
-        var node = self;
-        while (true) {
-            const node_type = parser.nodeType(node);
-            if (node_type == .document) {
-                return true;
-            }
-
-            if (parser.nodeParentNode(node)) |parent| {
-                // didn't find a document, but node has a parent, let's see
-                // if it's connected;
-                node = parent;
-                continue;
-            }
-
-            if (node_type != .document_fragment) {
-                // doesn't have a parent and isn't a document_fragment
-                // can't be connected
-                return false;
-            }
-
-            if (parser.documentFragmentGetHost(@ptrCast(node))) |host| {
-                // node doesn't have a parent, but it's a document fragment
-                // with a host. The host is like the parent, but we only want to
-                // traverse up (or down) to it in specific cases, like isConnected.
-                node = host;
-                continue;
-            }
-            return false;
-        }
-    }
-
-    // Read/Write attributes
-
-    pub fn get_nodeValue(self: *parser.Node) !?[]const u8 {
-        return parser.nodeValue(self);
-    }
-
-    pub fn set_nodeValue(self: *parser.Node, data: []u8) !void {
-        try parser.nodeSetValue(self, data);
-    }
-
-    pub fn get_textContent(self: *parser.Node) ?[]const u8 {
-        return parser.nodeTextContent(self);
-    }
-
-    pub fn set_textContent(self: *parser.Node, data: []u8) !void {
-        return try parser.nodeSetTextContent(self, data);
-    }
-
-    // Methods
-
-    pub fn _appendChild(self: *parser.Node, child: *parser.Node) !Union {
-        const self_owner = parser.nodeOwnerDocument(self);
-        const child_owner = parser.nodeOwnerDocument(child);
-
-        // If the node to be inserted has a different ownerDocument than the parent node,
-        // modern browsers automatically adopt the node and its descendants into
-        // the parent's ownerDocument.
-        // This process is known as adoption.
-        // (7.1) https://dom.spec.whatwg.org/#concept-node-insert
-        if (child_owner == null or (self_owner != null and child_owner.? != self_owner.?)) {
-            const w = Walker{};
-            var current = child;
-            while (true) {
-                current.owner = self_owner;
-                current = try w.get_next(child, current) orelse break;
-            }
-        }
-
-        // TODO: DocumentFragment special case
-        const res = try parser.nodeAppendChild(self, child);
-        return try Node.toInterface(res);
-    }
-
-    pub fn _cloneNode(self: *parser.Node, deep: ?bool) !Union {
-        const clone = try parser.nodeCloneNode(self, deep orelse false);
-        return try Node.toInterface(clone);
-    }
-
-    pub fn _compareDocumentPosition(self: *parser.Node, other: *parser.Node) !u32 {
-        if (self == other) {
-            return 0;
-        }
-
-        const docself = parser.nodeOwnerDocument(self) orelse blk: {
-            if (parser.nodeType(self) == .document) {
-                break :blk @as(*parser.Document, @ptrCast(self));
-            }
-            break :blk null;
-        };
-        const docother = parser.nodeOwnerDocument(other) orelse blk: {
-            if (parser.nodeType(other) == .document) {
-                break :blk @as(*parser.Document, @ptrCast(other));
-            }
-            break :blk null;
-        };
-
-        // Both are in different document.
-        if (docself == null or docother == null or docself.? != docother.?) {
-            return @intFromEnum(parser.DocumentPosition.disconnected) +
-                @intFromEnum(parser.DocumentPosition.implementation_specific) +
-                @intFromEnum(parser.DocumentPosition.preceding);
-        }
-
-        if (@intFromPtr(self) == @intFromPtr(docself.?)) {
-            // if self is the document, and we already know other is in the
-            // document, then other is contained by and following self.
-            return @intFromEnum(parser.DocumentPosition.following) +
-                @intFromEnum(parser.DocumentPosition.contained_by);
-        }
-
-        const rootself = parser.nodeGetRootNode(self);
-        const rootother = parser.nodeGetRootNode(other);
-        if (rootself != rootother) {
-            return @intFromEnum(parser.DocumentPosition.disconnected) +
-                @intFromEnum(parser.DocumentPosition.implementation_specific) +
-                @intFromEnum(parser.DocumentPosition.preceding);
-        }
-
-        // TODO Both are in a different trees in the same document.
-
-        const w = Walker{};
-        var next: ?*parser.Node = null;
-
-        // Is other a descendant of self?
-        while (true) {
-            next = try w.get_next(self, next) orelse break;
-            if (other == next) {
-                return @intFromEnum(parser.DocumentPosition.following) +
-                    @intFromEnum(parser.DocumentPosition.contained_by);
-            }
-        }
-
-        // Is self a descendant of other?
-        next = null;
-        while (true) {
-            next = try w.get_next(other, next) orelse break;
-            if (self == next) {
-                return @intFromEnum(parser.DocumentPosition.contains) +
-                    @intFromEnum(parser.DocumentPosition.preceding);
-            }
-        }
-
-        next = null;
-        while (true) {
-            next = try w.get_next(parser.documentToNode(docself.?), next) orelse break;
-            if (other == next) {
-                // other precedes self.
-                return @intFromEnum(parser.DocumentPosition.preceding);
-            }
-            if (self == next) {
-                // other follows self.
-                return @intFromEnum(parser.DocumentPosition.following);
-            }
-        }
-
-        return 0;
-    }
-
-    pub fn _contains(self: *parser.Node, other: *parser.Node) bool {
-        return parser.nodeContains(self, other);
-    }
-
-    // Returns itself or ancestor object inheriting from Node.
-    // - An Element inside a standard web page will return an HTMLDocument object representing the entire page (or <iframe>).
-    // - An Element inside a shadow DOM will return the associated ShadowRoot.
-    // - An Element that is not attached to a document or a shadow tree will return the root of the DOM tree it belongs to
-    const GetRootNodeResult = union(enum) {
-        shadow_root: *ShadowRoot,
-        node: Union,
-    };
-    pub fn _getRootNode(self: *parser.Node, options: ?struct { composed: bool = false }, page: *Page) !GetRootNodeResult {
-        if (options) |options_| if (options_.composed) {
-            log.warn(.web_api, "not implemented", .{ .feature = "getRootNode composed" });
-        };
-
-        const root = parser.nodeGetRootNode(self);
-        if (page.getNodeState(root)) |state| {
-            if (state.shadow_root) |sr| {
-                return .{ .shadow_root = sr };
-            }
-        }
-
-        return .{ .node = try Node.toInterface(root) };
-    }
-
-    pub fn _hasChildNodes(self: *parser.Node) bool {
-        return parser.nodeHasChildNodes(self);
-    }
-
-    pub fn get_childNodes(self: *parser.Node, page: *Page) !NodeList {
-        const allocator = page.arena;
-        var list: NodeList = .{};
-
-        var n = parser.nodeFirstChild(self) orelse return list;
-        while (true) {
-            try list.append(allocator, n);
-            n = parser.nodeNextSibling(n) orelse return list;
-        }
-    }
-
-    pub fn _insertBefore(self: *parser.Node, new_node: *parser.Node, ref_node_: ?*parser.Node) !Union {
-        if (ref_node_ == null) {
-            return _appendChild(self, new_node);
-        }
-
-        const self_owner = parser.nodeOwnerDocument(self);
-        const new_node_owner = parser.nodeOwnerDocument(new_node);
-
-        // If the node to be inserted has a different ownerDocument than the parent node,
-        // modern browsers automatically adopt the node and its descendants into
-        // the parent's ownerDocument.
-        // This process is known as adoption.
-        // (7.1) https://dom.spec.whatwg.org/#concept-node-insert
-        if (new_node_owner == null or (self_owner != null and new_node_owner.? != self_owner.?)) {
-            const w = Walker{};
-            var current = new_node;
-            while (true) {
-                current.owner = self_owner;
-                current = try w.get_next(new_node, current) orelse break;
-            }
-        }
-
-        return Node.toInterface(try parser.nodeInsertBefore(self, new_node, ref_node_.?));
-    }
-
-    pub fn _isDefaultNamespace(self: *parser.Node, namespace: ?[]const u8) !bool {
-        return parser.nodeIsDefaultNamespace(self, namespace);
-    }
-
-    pub fn _isEqualNode(self: *parser.Node, other: *parser.Node) !bool {
-        // TODO: other is not an optional parameter, but can be null.
-        return try parser.nodeIsEqualNode(self, other);
-    }
-
-    pub fn _isSameNode(self: *parser.Node, other: *parser.Node) bool {
-        // TODO: other is not an optional parameter, but can be null.
-        // NOTE: there is no need to use isSameNode(); instead use the === strict equality operator
-        return parser.nodeIsSameNode(self, other);
-    }
-
-    pub fn _lookupPrefix(self: *parser.Node, namespace: ?[]const u8) !?[]const u8 {
-        // TODO: other is not an optional parameter, but can be null.
-        if (namespace == null) {
-            return null;
-        }
-        if (std.mem.eql(u8, namespace.?, "")) {
-            return null;
-        }
-        return try parser.nodeLookupPrefix(self, namespace.?);
-    }
-
-    pub fn _lookupNamespaceURI(self: *parser.Node, prefix: ?[]const u8) !?[]const u8 {
-        // TODO: other is not an optional parameter, but can be null.
-        return try parser.nodeLookupNamespaceURI(self, prefix);
-    }
-
-    pub fn _normalize(self: *parser.Node) !void {
-        return try parser.nodeNormalize(self);
-    }
-
-    pub fn _removeChild(self: *parser.Node, child: *parser.Node) !Union {
-        const res = try parser.nodeRemoveChild(self, child);
-        return try Node.toInterface(res);
-    }
-
-    pub fn _replaceChild(self: *parser.Node, new_child: *parser.Node, old_child: *parser.Node) !Union {
-        const res = try parser.nodeReplaceChild(self, new_child, old_child);
-        return try Node.toInterface(res);
-    }
-
-    // Check if the hierarchy node tree constraints are respected.
-    // For now, it checks only if new nodes are not self.
-    // TODO implements the others contraints.
-    // see https://dom.spec.whatwg.org/#concept-node-tree
-    pub fn hierarchy(self: *parser.Node, nodes: []const NodeOrText) bool {
-        for (nodes) |n| {
-            if (n.is(self)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    pub fn prepend(self: *parser.Node, nodes: []const NodeOrText) !void {
-        if (nodes.len == 0) {
-            return;
-        }
-
-        // check hierarchy
-        if (!hierarchy(self, nodes)) {
-            return parser.DOMError.HierarchyRequest;
-        }
-
-        const doc = (parser.nodeOwnerDocument(self)) orelse return;
-
-        if (parser.nodeFirstChild(self)) |first| {
-            for (nodes) |node| {
-                _ = try parser.nodeInsertBefore(self, try node.toNode(doc), first);
-            }
-            return;
-        }
-
-        for (nodes) |node| {
-            _ = try parser.nodeAppendChild(self, try node.toNode(doc));
-        }
-    }
-
-    pub fn append(self: *parser.Node, nodes: []const NodeOrText) !void {
-        if (nodes.len == 0) {
-            return;
-        }
-
-        // check hierarchy
-        if (!hierarchy(self, nodes)) {
-            return parser.DOMError.HierarchyRequest;
-        }
-
-        const doc = (parser.nodeOwnerDocument(self)) orelse return;
-        for (nodes) |node| {
-            _ = try parser.nodeAppendChild(self, try node.toNode(doc));
-        }
-    }
-
-    pub fn replaceChildren(self: *parser.Node, nodes: []const NodeOrText) !void {
-        if (nodes.len == 0) {
-            return;
-        }
-
-        // check hierarchy
-        if (!hierarchy(self, nodes)) {
-            return parser.DOMError.HierarchyRequest;
-        }
-
-        // remove existing children
-        try removeChildren(self);
-
-        const doc = (parser.nodeOwnerDocument(self)) orelse return;
-        // add new children
-        for (nodes) |node| {
-            _ = try parser.nodeAppendChild(self, try node.toNode(doc));
-        }
-    }
-
-    pub fn removeChildren(self: *parser.Node) !void {
-        if (!parser.nodeHasChildNodes(self)) return;
-
-        const children = try parser.nodeGetChildNodes(self);
-        const ln = parser.nodeListLength(children);
-        var i: u32 = 0;
-        while (i < ln) {
-            defer i += 1;
-            // we always retrieve the 0 index child on purpose: libdom nodelist
-            // are dynamic. So the next child to remove is always as pos 0.
-            const child = parser.nodeListItem(children, 0) orelse continue;
-            _ = try parser.nodeRemoveChild(self, child);
-        }
-    }
-
-    pub fn before(self: *parser.Node, nodes: []const NodeOrText) !void {
-        const parent = parser.nodeParentNode(self) orelse return;
-        const doc = (parser.nodeOwnerDocument(parent)) orelse return;
-
-        var sibling: ?*parser.Node = self;
-        // have to find the first sibling that isn't in nodes
-        CHECK: while (sibling) |s| {
-            for (nodes) |n| {
-                if (n.is(s)) {
-                    sibling = parser.nodePreviousSibling(s);
-                    continue :CHECK;
-                }
-            }
-            break;
-        }
-
-        if (sibling == null) {
-            sibling = parser.nodeFirstChild(parent);
-        }
-
-        if (sibling) |ref_node| {
-            for (nodes) |node| {
-                _ = try parser.nodeInsertBefore(parent, try node.toNode(doc), ref_node);
-            }
-            return;
-        }
-
-        return Node.prepend(self, nodes);
-    }
-
-    pub fn after(self: *parser.Node, nodes: []const NodeOrText) !void {
-        const parent = parser.nodeParentNode(self) orelse return;
-        const doc = (parser.nodeOwnerDocument(parent)) orelse return;
-
-        // have to find the first sibling that isn't in nodes
-        var sibling = parser.nodeNextSibling(self);
-        CHECK: while (sibling) |s| {
-            for (nodes) |n| {
-                if (n.is(s)) {
-                    sibling = parser.nodeNextSibling(s);
-                    continue :CHECK;
-                }
-            }
-            break;
-        }
-
-        if (sibling) |ref_node| {
-            for (nodes) |node| {
-                _ = try parser.nodeInsertBefore(parent, try node.toNode(doc), ref_node);
-            }
-            return;
-        }
-
-        for (nodes) |node| {
-            _ = try parser.nodeAppendChild(parent, try node.toNode(doc));
-        }
-    }
-
-    // A lot of functions take either a node or text input.
-    // The text input is to be converted into a Text node.
-    pub const NodeOrText = union(enum) {
-        text: []const u8,
-        node: *parser.Node,
-
-        fn toNode(self: NodeOrText, doc: *parser.Document) !*parser.Node {
-            return switch (self) {
-                .node => |n| n,
-                .text => |txt| @ptrCast(@alignCast(try parser.documentCreateTextNode(doc, txt))),
-            };
-        }
-
-        // Whether the node represented by the NodeOrText is the same as the
-        // given Node. Always false for text values as these represent as-of-yet
-        // created Text nodes.
-        fn is(self: NodeOrText, other: *parser.Node) bool {
-            return switch (self) {
-                .text => false,
-                .node => |n| n == other,
-            };
-        }
-    };
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Node" {
-    try testing.htmlRunner("dom/node.html");
-    try testing.htmlRunner("dom/node_owner.html");
-}
--- a/src/browser/dom/node_filter.zig
+++ b/src/browser/dom/node_filter.zig
@@ -1,83 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const Node = @import("node.zig").Node;
-
-pub const NodeFilter = struct {
-    pub const _FILTER_ACCEPT: u16 = 1;
-    pub const _FILTER_REJECT: u16 = 2;
-    pub const _FILTER_SKIP: u16 = 3;
-
-    pub const _SHOW_ALL: u32 = std.math.maxInt(u32);
-    pub const _SHOW_ELEMENT: u32 = 0b1;
-    pub const _SHOW_ATTRIBUTE: u32 = 0b10;
-    pub const _SHOW_TEXT: u32 = 0b100;
-    pub const _SHOW_CDATA_SECTION: u32 = 0b1000;
-    pub const _SHOW_ENTITY_REFERENCE: u32 = 0b10000;
-    pub const _SHOW_ENTITY: u32 = 0b100000;
-    pub const _SHOW_PROCESSING_INSTRUCTION: u32 = 0b1000000;
-    pub const _SHOW_COMMENT: u32 = 0b10000000;
-    pub const _SHOW_DOCUMENT: u32 = 0b100000000;
-    pub const _SHOW_DOCUMENT_TYPE: u32 = 0b1000000000;
-    pub const _SHOW_DOCUMENT_FRAGMENT: u32 = 0b10000000000;
-    pub const _SHOW_NOTATION: u32 = 0b100000000000;
-};
-
-const VerifyResult = enum { accept, skip, reject };
-
-pub fn verify(what_to_show: u32, filter: ?js.Function, node: *parser.Node) !VerifyResult {
-    const node_type = parser.nodeType(node);
-
-    // Verify that we can show this node type.
-    // Per the DOM spec, what_to_show filters which nodes to return, but should
-    // still traverse children. So we return .skip (not .reject) when the node
-    // type doesn't match.
-    if (!switch (node_type) {
-        .attribute => what_to_show & NodeFilter._SHOW_ATTRIBUTE != 0,
-        .cdata_section => what_to_show & NodeFilter._SHOW_CDATA_SECTION != 0,
-        .comment => what_to_show & NodeFilter._SHOW_COMMENT != 0,
-        .document => what_to_show & NodeFilter._SHOW_DOCUMENT != 0,
-        .document_fragment => what_to_show & NodeFilter._SHOW_DOCUMENT_FRAGMENT != 0,
-        .document_type => what_to_show & NodeFilter._SHOW_DOCUMENT_TYPE != 0,
-        .element => what_to_show & NodeFilter._SHOW_ELEMENT != 0,
-        .entity => what_to_show & NodeFilter._SHOW_ENTITY != 0,
-        .entity_reference => what_to_show & NodeFilter._SHOW_ENTITY_REFERENCE != 0,
-        .notation => what_to_show & NodeFilter._SHOW_NOTATION != 0,
-        .processing_instruction => what_to_show & NodeFilter._SHOW_PROCESSING_INSTRUCTION != 0,
-        .text => what_to_show & NodeFilter._SHOW_TEXT != 0,
-    }) return .skip;
-
-    // Verify that we aren't filtering it out.
-    if (filter) |f| {
-        const acceptance = try f.call(u16, .{try Node.toInterface(node)});
-        return switch (acceptance) {
-            NodeFilter._FILTER_ACCEPT => .accept,
-            NodeFilter._FILTER_REJECT => .reject,
-            NodeFilter._FILTER_SKIP => .skip,
-            else => .reject,
-        };
-    } else return .accept;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.NodeFilter" {
-    try testing.htmlRunner("dom/node_filter.html");
-}
--- a/src/browser/dom/node_iterator.zig
+++ b/src/browser/dom/node_iterator.zig
@@ -1,302 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const NodeFilter = @import("node_filter.zig");
-const Node = @import("node.zig").Node;
-const NodeUnion = @import("node.zig").Union;
-const DOMException = @import("exceptions.zig").DOMException;
-
-// https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator
-// While this is similar to TreeWalker it has its own implementation as there are several subtle differences
-// For example:
-// - nextNode returns the reference node, whereas TreeWalker returns the next node
-// - Skip and reject are equivalent for NodeIterator, for TreeWalker they are different
-pub const NodeIterator = struct {
-    pub const Exception = DOMException;
-
-    root: *parser.Node,
-    reference_node: *parser.Node,
-    what_to_show: u32,
-    filter: ?NodeIteratorOpts,
-    filter_func: ?js.Function,
-    pointer_before_current: bool = true,
-    // used to track / block recursive filters
-    is_in_callback: bool = false,
-
-    // One of the few cases where null and undefined resolve to different default.
-    // We need the raw JsObject so that we can probe the tri state:
-    // null, undefined or i32.
-    pub const WhatToShow = js.Object;
-
-    pub const NodeIteratorOpts = union(enum) {
-        function: js.Function,
-        object: struct { acceptNode: js.Function },
-    };
-
-    pub fn init(node: *parser.Node, what_to_show_: ?WhatToShow, filter: ?NodeIteratorOpts) !NodeIterator {
-        var filter_func: ?js.Function = null;
-        if (filter) |f| {
-            filter_func = switch (f) {
-                .function => |func| func,
-                .object => |o| o.acceptNode,
-            };
-        }
-
-        var what_to_show: u32 = undefined;
-        if (what_to_show_) |wts| {
-            switch (try wts.triState(NodeIterator, "what_to_show", u32)) {
-                .null => what_to_show = 0,
-                .undefined => what_to_show = NodeFilter.NodeFilter._SHOW_ALL,
-                .value => |v| what_to_show = v,
-            }
-        } else {
-            what_to_show = NodeFilter.NodeFilter._SHOW_ALL;
-        }
-
-        return .{
-            .root = node,
-            .filter = filter,
-            .reference_node = node,
-            .filter_func = filter_func,
-            .what_to_show = what_to_show,
-        };
-    }
-
-    pub fn get_filter(self: *const NodeIterator) ?NodeIteratorOpts {
-        return self.filter;
-    }
-
-    pub fn get_pointerBeforeReferenceNode(self: *const NodeIterator) bool {
-        return self.pointer_before_current;
-    }
-
-    pub fn get_referenceNode(self: *const NodeIterator) !NodeUnion {
-        return try Node.toInterface(self.reference_node);
-    }
-
-    pub fn get_root(self: *const NodeIterator) !NodeUnion {
-        return try Node.toInterface(self.root);
-    }
-
-    pub fn get_whatToShow(self: *const NodeIterator) u32 {
-        return self.what_to_show;
-    }
-
-    pub fn _nextNode(self: *NodeIterator) !?NodeUnion {
-        try self.callbackStart();
-        defer self.callbackEnd();
-
-        if (self.pointer_before_current) {
-            self.pointer_before_current = false;
-            // Unlike TreeWalker, NodeIterator starts at the first node
-            if (.accept == try NodeFilter.verify(self.what_to_show, self.filter_func, self.reference_node)) {
-                self.pointer_before_current = false;
-                return try Node.toInterface(self.reference_node);
-            }
-        }
-
-        if (try self.firstChild(self.reference_node)) |child| {
-            self.reference_node = child;
-            return try Node.toInterface(child);
-        }
-
-        var current = self.reference_node;
-        while (current != self.root) {
-            // Try to get next sibling (including .skip/.reject nodes we need to descend into)
-            if (try self.nextSiblingOrSkipReject(current)) |result| {
-                if (result.should_descend) {
-                    // This is a .skip/.reject node - try to find acceptable children within it
-                    if (try self.firstChild(result.node)) |child| {
-                        self.reference_node = child;
-                        return try Node.toInterface(child);
-                    }
-                    // No acceptable children, continue looking at this node's siblings
-                    current = result.node;
-                    continue;
-                }
-                // This is an .accept node - return it
-                self.reference_node = result.node;
-                return try Node.toInterface(result.node);
-            }
-
-            current = (parser.nodeParentNode(current)) orelse break;
-        }
-
-        return null;
-    }
-
-    pub fn _previousNode(self: *NodeIterator) !?NodeUnion {
-        try self.callbackStart();
-        defer self.callbackEnd();
-
-        if (!self.pointer_before_current) {
-            if (.accept == try NodeFilter.verify(self.what_to_show, self.filter_func, self.reference_node)) {
-                self.pointer_before_current = true;
-                // Still need to verify as last may be first as well
-                return try Node.toInterface(self.reference_node);
-            }
-        }
-        if (self.reference_node == self.root) {
-            return null;
-        }
-
-        var current = self.reference_node;
-        while (parser.nodePreviousSibling(current)) |previous| {
-            current = previous;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => {
-                    // Get last child if it has one.
-                    if (try self.lastChild(current)) |child| {
-                        self.reference_node = child;
-                        return try Node.toInterface(child);
-                    }
-
-                    // Otherwise, this node is our previous one.
-                    self.reference_node = current;
-                    return try Node.toInterface(current);
-                },
-                .reject, .skip => {
-                    // Get last child if it has one.
-                    if (try self.lastChild(current)) |child| {
-                        self.reference_node = child;
-                        return try Node.toInterface(child);
-                    }
-                },
-            }
-        }
-
-        if (current != self.root) {
-            if (try self.parentNode(current)) |parent| {
-                self.reference_node = parent;
-                return try Node.toInterface(parent);
-            }
-        }
-
-        return null;
-    }
-
-    pub fn _detach(self: *const NodeIterator) void {
-        // no-op as per spec
-        _ = self;
-    }
-
-    fn firstChild(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
-        const children = try parser.nodeGetChildNodes(node);
-        const child_count = parser.nodeListLength(children);
-
-        for (0..child_count) |i| {
-            const index: u32 = @intCast(i);
-            const child = (parser.nodeListItem(children, index)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
-                .accept => return child, // NOTE: Skip and reject are equivalent for NodeIterator, this is different from TreeWalker
-                .reject, .skip => if (try self.firstChild(child)) |gchild| return gchild,
-            }
-        }
-
-        return null;
-    }
-
-    fn lastChild(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
-        const children = try parser.nodeGetChildNodes(node);
-        const child_count = parser.nodeListLength(children);
-
-        var index: u32 = child_count;
-        while (index > 0) {
-            index -= 1;
-            const child = (parser.nodeListItem(children, index)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
-                .accept => return child, // NOTE: Skip and reject are equivalent for NodeIterator, this is different from TreeWalker
-                .reject, .skip => if (try self.lastChild(child)) |gchild| return gchild,
-            }
-        }
-
-        return null;
-    }
-
-    // This implementation is actually the same as :TreeWalker
-    fn parentNode(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
-        if (self.root == node) return null;
-
-        var current = node;
-        while (true) {
-            if (current == self.root) return null;
-            current = (parser.nodeParentNode(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return current,
-                .reject, .skip => continue,
-            }
-        }
-    }
-
-    // This implementation is actually the same as :TreeWalker
-    fn nextSibling(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
-        var current = node;
-
-        while (true) {
-            current = (parser.nodeNextSibling(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return current,
-                .skip, .reject => continue,
-            }
-        }
-
-        return null;
-    }
-
-    // Get the next sibling that is either acceptable or should be descended into (skip/reject)
-    fn nextSiblingOrSkipReject(self: *const NodeIterator, node: *parser.Node) !?struct { node: *parser.Node, should_descend: bool } {
-        var current = node;
-
-        while (true) {
-            current = (parser.nodeNextSibling(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return .{ .node = current, .should_descend = false },
-                .skip, .reject => return .{ .node = current, .should_descend = true },
-            }
-        }
-
-        return null;
-    }
-
-    fn callbackStart(self: *NodeIterator) !void {
-        if (self.is_in_callback) {
-            // this is the correct DOMExeption
-            return error.InvalidState;
-        }
-        self.is_in_callback = true;
-    }
-
-    fn callbackEnd(self: *NodeIterator) void {
-        self.is_in_callback = false;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.NodeIterator" {
-    try testing.htmlRunner("dom/node_iterator.html");
-}
--- a/src/browser/dom/performance.zig
+++ b/src/browser/dom/performance.zig
@@ -1,206 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-const Page = @import("../page.zig").Page;
-
-const milliTimestamp = @import("../../datetime.zig").milliTimestamp;
-
-pub const Interfaces = .{
-    Performance,
-    PerformanceEntry,
-    PerformanceMark,
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Performance
-pub const Performance = struct {
-    pub const prototype = *EventTarget;
-
-    // Extend libdom event target for pure zig struct.
-    base: parser.EventTargetTBase = parser.EventTargetTBase{ .internal_target_type = .performance },
-
-    time_origin: u64,
-    // if (Window.crossOriginIsolated) -> Resolution in isolated contexts:       5 microseconds
-    // else                            -> Resolution in non-isolated contexts: 100 microseconds
-    const ms_resolution = 100;
-
-    pub fn init() Performance {
-        return .{
-            .time_origin = milliTimestamp(),
-        };
-    }
-
-    pub fn get_timeOrigin(self: *const Performance) u64 {
-        return self.time_origin;
-    }
-
-    pub fn reset(self: *Performance) void {
-        self.time_origin = milliTimestamp();
-    }
-
-    pub fn _now(self: *const Performance) u64 {
-        return milliTimestamp() - self.time_origin;
-    }
-
-    pub fn _mark(_: *Performance, name: js.String, _options: ?PerformanceMark.Options, page: *Page) !PerformanceMark {
-        const mark: PerformanceMark = try .constructor(name, _options, page);
-        // TODO: Should store this in an entries list
-        return mark;
-    }
-
-    // TODO: fn _mark should record the marks in a lookup
-    pub fn _clearMarks(_: *Performance, name: ?[]const u8) void {
-        _ = name;
-    }
-
-    // TODO: fn _measures should record the marks in a lookup
-    pub fn _clearMeasures(_: *Performance, name: ?[]const u8) void {
-        _ = name;
-    }
-
-    // TODO: fn _measures should record the marks in a lookup
-    pub fn _getEntriesByName(_: *Performance, name: []const u8, typ: ?[]const u8) []PerformanceEntry {
-        _ = name;
-        _ = typ;
-        return &.{};
-    }
-
-    // TODO: fn _measures should record the marks in a lookup
-    pub fn _getEntriesByType(_: *Performance, typ: []const u8) []PerformanceEntry {
-        _ = typ;
-        return &.{};
-    }
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry
-pub const PerformanceEntry = struct {
-    const PerformanceEntryType = enum {
-        element,
-        event,
-        first_input,
-        largest_contentful_paint,
-        layout_shift,
-        long_animation_frame,
-        longtask,
-        mark,
-        measure,
-        navigation,
-        paint,
-        resource,
-        taskattribution,
-        visibility_state,
-
-        pub fn toString(self: PerformanceEntryType) []const u8 {
-            return switch (self) {
-                .first_input => "first-input",
-                .largest_contentful_paint => "largest-contentful-paint",
-                .layout_shift => "layout-shift",
-                .long_animation_frame => "long-animation-frame",
-                .visibility_state => "visibility-state",
-                else => @tagName(self),
-            };
-        }
-    };
-
-    duration: f64 = 0.0,
-    entry_type: PerformanceEntryType,
-    name: []const u8,
-    start_time: f64 = 0.0,
-
-    pub fn get_duration(self: *const PerformanceEntry) f64 {
-        return self.duration;
-    }
-
-    pub fn get_entryType(self: *const PerformanceEntry) PerformanceEntryType {
-        return self.entry_type;
-    }
-
-    pub fn get_name(self: *const PerformanceEntry) []const u8 {
-        return self.name;
-    }
-
-    pub fn get_startTime(self: *const PerformanceEntry) f64 {
-        return self.start_time;
-    }
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMark
-pub const PerformanceMark = struct {
-    pub const prototype = *PerformanceEntry;
-
-    proto: PerformanceEntry,
-    detail: ?js.Object,
-
-    const Options = struct {
-        detail: ?js.Object = null,
-        startTime: ?f64 = null,
-    };
-
-    pub fn constructor(name: js.String, _options: ?Options, page: *Page) !PerformanceMark {
-        const perf = &page.window.performance;
-
-        const options = _options orelse Options{};
-        const start_time = options.startTime orelse @as(f64, @floatFromInt(perf._now()));
-
-        if (start_time < 0.0) {
-            return error.TypeError;
-        }
-
-        const detail = if (options.detail) |d| try d.persist() else null;
-        const proto = PerformanceEntry{ .name = name.string, .entry_type = .mark, .start_time = start_time };
-
-        return .{ .proto = proto, .detail = detail };
-    }
-
-    pub fn get_detail(self: *const PerformanceMark) ?js.Object {
-        return self.detail;
-    }
-};
-
-const testing = @import("./../../testing.zig");
-
-test "Performance: get_timeOrigin" {
-    var perf = Performance.init();
-    const time_origin = perf.get_timeOrigin();
-    try testing.expect(time_origin >= 0);
-}
-
-test "Performance: now" {
-    var perf = Performance.init();
-
-    // Monotonically increasing
-    var now = perf._now();
-    while (now <= 0) { // Loop for now to not be 0
-        try testing.expectEqual(now, 0);
-        now = perf._now();
-    }
-
-    var after = perf._now();
-    while (after <= now) { // Loop untill after > now
-        try testing.expectEqual(after, now);
-        after = perf._now();
-    }
-}
-
-test "Browser: Performance.Mark" {
-    try testing.htmlRunner("dom/performance.html");
-}
--- a/src/browser/dom/performance_observer.zig
+++ b/src/browser/dom/performance_observer.zig
@@ -1,58 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-
-const PerformanceEntry = @import("performance.zig").PerformanceEntry;
-
-// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
-pub const PerformanceObserver = struct {
-    pub const _supportedEntryTypes = [0][]const u8{};
-
-    pub fn constructor(cbk: js.Function) PerformanceObserver {
-        _ = cbk;
-        return .{};
-    }
-
-    pub fn _observe(self: *const PerformanceObserver, options_: ?Options) void {
-        _ = self;
-        _ = options_;
-        return;
-    }
-
-    pub fn _disconnect(self: *PerformanceObserver) void {
-        _ = self;
-    }
-
-    pub fn _takeRecords(_: *const PerformanceObserver) []PerformanceEntry {
-        return &[_]PerformanceEntry{};
-    }
-};
-
-const Options = struct {
-    buffered: ?bool = null,
-    durationThreshold: ?f64 = null,
-    entryTypes: ?[]const []const u8 = null,
-    type: ?[]const u8 = null,
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.PerformanceObserver" {
-    try testing.htmlRunner("dom/performance_observer.html");
-}
--- a/src/browser/dom/processing_instruction.zig
+++ b/src/browser/dom/processing_instruction.zig
@@ -1,92 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-const Node = @import("node.zig").Node;
-const Page = @import("../page.zig").Page;
-
-// https://dom.spec.whatwg.org/#processinginstruction
-pub const ProcessingInstruction = struct {
-    pub const Self = parser.ProcessingInstruction;
-
-    // TODO for libdom processing instruction inherit from node.
-    // But the spec says it must inherit from CDATA.
-    pub const prototype = *Node;
-    pub const subtype = .node;
-
-    pub fn get_target(self: *parser.ProcessingInstruction) ![]const u8 {
-        // libdom stores the ProcessingInstruction target in the node's name.
-        return try parser.nodeName(parser.processingInstructionToNode(self));
-    }
-
-    // There's something wrong when we try to clone a ProcessInstruction normally.
-    // The resulting object can't be cast back into a node (it crashes). This is
-    // a simple workaround.
-    pub fn _cloneNode(self: *parser.ProcessingInstruction, _: ?bool, page: *Page) !*parser.ProcessingInstruction {
-        return try parser.documentCreateProcessingInstruction(
-            @ptrCast(page.window.document),
-            try get_target(self),
-            (try get_data(self)) orelse "",
-        );
-    }
-
-    pub fn get_data(self: *parser.ProcessingInstruction) !?[]const u8 {
-        return parser.nodeValue(parser.processingInstructionToNode(self));
-    }
-
-    pub fn set_data(self: *parser.ProcessingInstruction, data: []u8) !void {
-        try parser.nodeSetValue(parser.processingInstructionToNode(self), data);
-    }
-
-    // netsurf's ProcessInstruction doesn't implement the dom_node_get_attributes
-    // and thus will crash if we try to call nodeIsEqualNode.
-    pub fn _isEqualNode(self: *parser.ProcessingInstruction, other_node: *parser.Node) !bool {
-        if (parser.nodeType(other_node) != .processing_instruction) {
-            return false;
-        }
-
-        const other: *parser.ProcessingInstruction = @ptrCast(other_node);
-
-        if (std.mem.eql(u8, try get_target(self), try get_target(other)) == false) {
-            return false;
-        }
-
-        {
-            const self_data = try get_data(self);
-            const other_data = try get_data(other);
-            if (self_data == null and other_data != null) {
-                return false;
-            }
-            if (self_data != null and other_data == null) {
-                return false;
-            }
-            if (std.mem.eql(u8, self_data.?, other_data.?) == false) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.ProcessingInstruction" {
-    try testing.htmlRunner("dom/processing_instruction.html");
-}
--- a/src/browser/dom/range.zig
+++ b/src/browser/dom/range.zig
@@ -1,390 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const Node = @import("node.zig").Node;
-const NodeUnion = @import("node.zig").Union;
-const DOMException = @import("exceptions.zig").DOMException;
-
-pub const Interfaces = .{
-    AbstractRange,
-    Range,
-};
-
-pub const AbstractRange = struct {
-    collapsed: bool,
-    end_node: *parser.Node,
-    end_offset: u32,
-    start_node: *parser.Node,
-    start_offset: u32,
-
-    pub fn updateCollapsed(self: *AbstractRange) void {
-        // TODO: Eventually, compare properly.
-        self.collapsed = false;
-    }
-
-    pub fn get_collapsed(self: *const AbstractRange) bool {
-        return self.collapsed;
-    }
-
-    pub fn get_endContainer(self: *const AbstractRange) !NodeUnion {
-        return Node.toInterface(self.end_node);
-    }
-
-    pub fn get_endOffset(self: *const AbstractRange) u32 {
-        return self.end_offset;
-    }
-
-    pub fn get_startContainer(self: *const AbstractRange) !NodeUnion {
-        return Node.toInterface(self.start_node);
-    }
-
-    pub fn get_startOffset(self: *const AbstractRange) u32 {
-        return self.start_offset;
-    }
-};
-
-pub const Range = struct {
-    pub const Exception = DOMException;
-    pub const prototype = *AbstractRange;
-
-    proto: AbstractRange,
-
-    pub const _START_TO_START = 0;
-    pub const _START_TO_END = 1;
-    pub const _END_TO_END = 2;
-    pub const _END_TO_START = 3;
-
-    // The Range() constructor returns a newly created Range object whose start
-    // and end is the global Document object.
-    // https://developer.mozilla.org/en-US/docs/Web/API/Range/Range
-    pub fn constructor(page: *Page) Range {
-        const proto: AbstractRange = .{
-            .collapsed = true,
-            .end_node = parser.documentHTMLToNode(page.window.document),
-            .end_offset = 0,
-            .start_node = parser.documentHTMLToNode(page.window.document),
-            .start_offset = 0,
-        };
-
-        return .{ .proto = proto };
-    }
-
-    pub fn _setStart(self: *Range, node: *parser.Node, offset_: i32) !void {
-        try ensureValidOffset(node, offset_);
-        const offset: u32 = @intCast(offset_);
-        const position = compare(node, offset, self.proto.start_node, self.proto.start_offset) catch |err| switch (err) {
-            error.WrongDocument => blk: {
-                // allow a node with a different root than the current, or
-                // a disconnected one. Treat it as if it's "after", so that
-                // we also update the end_offset and end_node.
-                break :blk 1;
-            },
-            else => return err,
-        };
-
-        if (position == 1) {
-            // if we're setting the node after the current start, the end must
-            // be set too.
-            self.proto.end_offset = offset;
-            self.proto.end_node = node;
-        }
-        self.proto.start_node = node;
-        self.proto.start_offset = offset;
-        self.proto.updateCollapsed();
-    }
-
-    pub fn _setStartBefore(self: *Range, node: *parser.Node) !void {
-        const parent, const index = try getParentAndIndex(node);
-        self.proto.start_node = parent;
-        self.proto.start_offset = index;
-    }
-
-    pub fn _setStartAfter(self: *Range, node: *parser.Node) !void {
-        const parent, const index = try getParentAndIndex(node);
-        self.proto.start_node = parent;
-        self.proto.start_offset = index + 1;
-    }
-
-    pub fn _setEnd(self: *Range, node: *parser.Node, offset_: i32) !void {
-        try ensureValidOffset(node, offset_);
-        const offset: u32 = @intCast(offset_);
-
-        const position = compare(node, offset, self.proto.start_node, self.proto.start_offset) catch |err| switch (err) {
-            error.WrongDocument => blk: {
-                // allow a node with a different root than the current, or
-                // a disconnected one. Treat it as if it's "before", so that
-                // we also update the end_offset and end_node.
-                break :blk -1;
-            },
-            else => return err,
-        };
-
-        if (position == -1) {
-            // if we're setting the node before the current start, the start
-            // must be set too.
-            self.proto.start_offset = offset;
-            self.proto.start_node = node;
-        }
-
-        self.proto.end_node = node;
-        self.proto.end_offset = offset;
-        self.proto.updateCollapsed();
-    }
-
-    pub fn _setEndBefore(self: *Range, node: *parser.Node) !void {
-        const parent, const index = try getParentAndIndex(node);
-        self.proto.end_node = parent;
-        self.proto.end_offset = index;
-    }
-
-    pub fn _setEndAfter(self: *Range, node: *parser.Node) !void {
-        const parent, const index = try getParentAndIndex(node);
-        self.proto.end_node = parent;
-        self.proto.end_offset = index + 1;
-    }
-
-    pub fn _createContextualFragment(_: *Range, fragment: []const u8, page: *Page) !*parser.DocumentFragment {
-        const document_html = page.window.document;
-        const document = parser.documentHTMLToDocument(document_html);
-        const doc_frag = try parser.documentParseFragmentFromStr(document, fragment);
-        return doc_frag;
-    }
-
-    pub fn _selectNodeContents(self: *Range, node: *parser.Node) !void {
-        self.proto.start_node = node;
-        self.proto.start_offset = 0;
-        self.proto.end_node = node;
-
-        // Set end_offset
-        switch (parser.nodeType(node)) {
-            .text, .cdata_section, .comment, .processing_instruction => {
-                // For text-like nodes, end_offset should be the length of the text data
-                if (parser.nodeValue(node)) |text_data| {
-                    self.proto.end_offset = @intCast(text_data.len);
-                } else {
-                    self.proto.end_offset = 0;
-                }
-            },
-            else => {
-                // For element and other nodes, end_offset is the number of children
-                const child_nodes = try parser.nodeGetChildNodes(node);
-                const child_count = parser.nodeListLength(child_nodes);
-                self.proto.end_offset = @intCast(child_count);
-            },
-        }
-
-        self.proto.updateCollapsed();
-    }
-
-    // creates a copy
-    pub fn _cloneRange(self: *const Range) Range {
-        return .{
-            .proto = .{
-                .collapsed = self.proto.collapsed,
-                .end_node = self.proto.end_node,
-                .end_offset = self.proto.end_offset,
-                .start_node = self.proto.start_node,
-                .start_offset = self.proto.start_offset,
-            },
-        };
-    }
-
-    pub fn _comparePoint(self: *const Range, node: *parser.Node, offset_: i32) !i32 {
-        const start = self.proto.start_node;
-        if (parser.nodeGetRootNode(start) != parser.nodeGetRootNode(node)) {
-            // WPT really wants this error to be first. Later, when we check
-            // if the relative position is 'disconnected', it'll also catch this
-            // case, but WPT will complain because it sometimes also sends
-            // invalid offsets, and it wants WrongDocument to be raised.
-            return error.WrongDocument;
-        }
-
-        if (parser.nodeType(node) == .document_type) {
-            return error.InvalidNodeType;
-        }
-
-        try ensureValidOffset(node, offset_);
-
-        const offset: u32 = @intCast(offset_);
-        if (try compare(node, offset, start, self.proto.start_offset) == -1) {
-            return -1;
-        }
-
-        if (try compare(node, offset, self.proto.end_node, self.proto.end_offset) == 1) {
-            return 1;
-        }
-
-        return 0;
-    }
-
-    pub fn _isPointInRange(self: *const Range, node: *parser.Node, offset_: i32) !bool {
-        return self._comparePoint(node, offset_) catch |err| switch (err) {
-            error.WrongDocument => return false,
-            else => return err,
-        } == 0;
-    }
-
-    pub fn _intersectsNode(self: *const Range, node: *parser.Node) !bool {
-        const start_root = parser.nodeGetRootNode(self.proto.start_node);
-        const node_root = parser.nodeGetRootNode(node);
-        if (start_root != node_root) {
-            return false;
-        }
-
-        const parent, const index = getParentAndIndex(node) catch |err| switch (err) {
-            error.InvalidNodeType => return true, // if node has no parent, we return true.
-            else => return err,
-        };
-
-        if (try compare(parent, index + 1, self.proto.start_node, self.proto.start_offset) != 1) {
-            // node isn't after start, can't intersect
-            return false;
-        }
-
-        if (try compare(parent, index, self.proto.end_node, self.proto.end_offset) != -1) {
-            // node isn't before end, can't intersect
-            return false;
-        }
-
-        return true;
-    }
-
-    pub fn _compareBoundaryPoints(self: *const Range, how: i32, other: *const Range) !i32 {
-        return switch (how) {
-            _START_TO_START => compare(self.proto.start_node, self.proto.start_offset, other.proto.start_node, other.proto.start_offset),
-            _START_TO_END => compare(self.proto.start_node, self.proto.start_offset, other.proto.end_node, other.proto.end_offset),
-            _END_TO_END => compare(self.proto.end_node, self.proto.end_offset, other.proto.end_node, other.proto.end_offset),
-            _END_TO_START => compare(self.proto.end_node, self.proto.end_offset, other.proto.start_node, other.proto.start_offset),
-            else => error.NotSupported, // this is the correct DOM Exception to return
-        };
-    }
-
-    // The Range.detach() method does nothing. It used to disable the Range
-    // object and enable the browser to release associated resources. The
-    // method has been kept for compatibility.
-    // https://developer.mozilla.org/en-US/docs/Web/API/Range/detach
-    pub fn _detach(_: *Range) void {}
-};
-
-fn ensureValidOffset(node: *parser.Node, offset: i32) !void {
-    if (offset < 0) {
-        return error.IndexSize;
-    }
-
-    // not >= because 0 seems to represent the node itself.
-    if (offset > try nodeLength(node)) {
-        return error.IndexSize;
-    }
-}
-
-fn nodeLength(node: *parser.Node) !usize {
-    switch (try isTextual(node)) {
-        true => return ((parser.nodeTextContent(node)) orelse "").len,
-        false => {
-            const children = try parser.nodeGetChildNodes(node);
-            return @intCast(parser.nodeListLength(children));
-        },
-    }
-}
-
-fn isTextual(node: *parser.Node) !bool {
-    return switch (parser.nodeType(node)) {
-        .text, .comment, .cdata_section => true,
-        else => false,
-    };
-}
-
-fn getParentAndIndex(child: *parser.Node) !struct { *parser.Node, u32 } {
-    const parent = (parser.nodeParentNode(child)) orelse return error.InvalidNodeType;
-    const children = try parser.nodeGetChildNodes(parent);
-    const ln = parser.nodeListLength(children);
-    var i: u32 = 0;
-    while (i < ln) {
-        defer i += 1;
-        const c = parser.nodeListItem(children, i) orelse continue;
-        if (c == child) {
-            return .{ parent, i };
-        }
-    }
-
-    // should not be possible to reach this point
-    return error.InvalidNodeType;
-}
-
-// implementation is largely copied from the WPT helper called getPosition in
-// the common.js of the dom folder.
-fn compare(node_a: *parser.Node, offset_a: u32, node_b: *parser.Node, offset_b: u32) !i32 {
-    if (node_a == node_b) {
-        // This is a simple and common case, where the two nodes are the same
-        // We just need to compare their offsets
-        if (offset_a == offset_b) {
-            return 0;
-        }
-        return if (offset_a < offset_b) -1 else 1;
-    }
-
-    // We're probably comparing two different nodes. "Probably", because the
-    // above case on considered the offset if the two nodes were the same
-    // as-is. They could still be the same here, if we first consider the
-    // offset.
-    const position = try Node._compareDocumentPosition(node_b, node_a);
-    if (position & @intFromEnum(parser.DocumentPosition.disconnected) == @intFromEnum(parser.DocumentPosition.disconnected)) {
-        return error.WrongDocument;
-    }
-
-    if (position & @intFromEnum(parser.DocumentPosition.following) == @intFromEnum(parser.DocumentPosition.following)) {
-        return switch (try compare(node_b, offset_b, node_a, offset_a)) {
-            -1 => 1,
-            1 => -1,
-            else => unreachable,
-        };
-    }
-
-    if (position & @intFromEnum(parser.DocumentPosition.contains) == @intFromEnum(parser.DocumentPosition.contains)) {
-        // node_a contains node_b
-        var child = node_b;
-        while (parser.nodeParentNode(child)) |parent| {
-            if (parent == node_a) {
-                // child.parentNode == node_a
-                break;
-            }
-            child = parent;
-        } else {
-            // this should not happen, because  Node._compareDocumentPosition
-            // has told us that node_a contains node_b, so one of node_b's
-            // parent's MUST be node_a. But somehow we do end up here sometimes.
-            return -1;
-        }
-
-        const child_parent, const child_index = try getParentAndIndex(child);
-        std.debug.assert(node_a == child_parent);
-        return if (child_index < offset_a) -1 else 1;
-    }
-
-    return -1;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: Range" {
-    try testing.htmlRunner("dom/range.html");
-}
--- a/src/browser/dom/resize_observer.zig
+++ b/src/browser/dom/resize_observer.zig
@@ -1,54 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-
-pub const Interfaces = .{
-    ResizeObserver,
-};
-
-// WEB IDL https://drafts.csswg.org/resize-observer/#resize-observer-interface
-pub const ResizeObserver = struct {
-    pub fn constructor(cbk: js.Function) ResizeObserver {
-        _ = cbk;
-        return .{};
-    }
-
-    pub fn _observe(self: *const ResizeObserver, element: *parser.Element, options_: ?Options) void {
-        _ = self;
-        _ = element;
-        _ = options_;
-        return;
-    }
-
-    pub fn _unobserve(self: *const ResizeObserver, element: *parser.Element) void {
-        _ = self;
-        _ = element;
-        return;
-    }
-
-    // TODO
-    pub fn _disconnect(self: *ResizeObserver) void {
-        _ = self;
-    }
-};
-
-const Options = struct {
-    box: []const u8,
-};
--- a/src/browser/dom/shadow_root.zig
+++ b/src/browser/dom/shadow_root.zig
@@ -1,101 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const dump = @import("../dump.zig");
-const parser = @import("../netsurf.zig");
-
-const js = @import(".././js/js.zig");
-const Page = @import("../page.zig").Page;
-const Node = @import("node.zig").Node;
-const Element = @import("element.zig").Element;
-const ElementUnion = @import("element.zig").Union;
-
-// WEB IDL https://dom.spec.whatwg.org/#interface-shadowroot
-pub const ShadowRoot = struct {
-    pub const prototype = *parser.DocumentFragment;
-    pub const subtype = .node;
-
-    mode: Mode,
-    host: *parser.Element,
-    proto: *parser.DocumentFragment,
-    adopted_style_sheets: ?js.Object = null,
-
-    pub const Mode = enum {
-        open,
-        closed,
-    };
-
-    pub fn get_host(self: *const ShadowRoot) !ElementUnion {
-        return Element.toInterface(self.host);
-    }
-
-    pub fn get_adoptedStyleSheets(self: *ShadowRoot, page: *Page) !js.Object {
-        if (self.adopted_style_sheets) |obj| {
-            return obj;
-        }
-
-        const obj = try page.js.createArray(0).persist();
-        self.adopted_style_sheets = obj;
-        return obj;
-    }
-
-    pub fn set_adoptedStyleSheets(self: *ShadowRoot, sheets: js.Object) !void {
-        self.adopted_style_sheets = try sheets.persist();
-    }
-
-    pub fn get_innerHTML(self: *ShadowRoot, page: *Page) ![]const u8 {
-        var aw = std.Io.Writer.Allocating.init(page.call_arena);
-        try dump.writeChildren(parser.documentFragmentToNode(self.proto), .{}, &aw.writer);
-        return aw.written();
-    }
-
-    pub fn set_innerHTML(self: *ShadowRoot, str_: ?[]const u8) !void {
-        const sr_doc = parser.documentFragmentToNode(self.proto);
-        const doc = parser.nodeOwnerDocument(sr_doc) orelse return parser.DOMError.WrongDocument;
-        try Node.removeChildren(sr_doc);
-        const str = str_ orelse return;
-
-        const fragment = try parser.documentParseFragmentFromStr(doc, str);
-        const fragment_node = parser.documentFragmentToNode(fragment);
-
-        // Element.set_innerHTML also has some weirdness here. It isn't clear
-        // what should and shouldn't be set. Whatever string you pass to libdom,
-        // it always creates a full HTML document, with an html, head and body
-        // element.
-        // For ShadowRoot, it appears the only the children within the body should
-        // be set.
-        const html = parser.nodeFirstChild(fragment_node) orelse return;
-        const head = parser.nodeFirstChild(html) orelse return;
-        const body = parser.nodeNextSibling(head) orelse return;
-
-        const children = try parser.nodeGetChildNodes(body);
-        const ln = parser.nodeListLength(children);
-        for (0..ln) |_| {
-            // always index 0, because nodeAppendChild moves the node out of
-            // the nodeList and into the new tree
-            const child = parser.nodeListItem(children, 0) orelse continue;
-            _ = try parser.nodeAppendChild(sr_doc, child);
-        }
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.ShadowRoot" {
-    try testing.htmlRunner("dom/shadow_root.html");
-}
--- a/src/browser/dom/text.zig
+++ b/src/browser/dom/text.zig
@@ -1,62 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const CharacterData = @import("character_data.zig").CharacterData;
-const CDATASection = @import("cdata_section.zig").CDATASection;
-
-// Text interfaces
-pub const Interfaces = .{
-    CDATASection,
-};
-
-pub const Text = struct {
-    pub const Self = parser.Text;
-    pub const prototype = *CharacterData;
-    pub const subtype = .node;
-
-    pub fn constructor(data: ?[]const u8, page: *const Page) !*parser.Text {
-        return parser.documentCreateTextNode(
-            parser.documentHTMLToDocument(page.window.document),
-            data orelse "",
-        );
-    }
-
-    // JS funcs
-    // --------
-
-    // Read attributes
-
-    pub fn get_wholeText(self: *parser.Text) ![]const u8 {
-        return try parser.textWholdeText(self);
-    }
-
-    // JS methods
-    // ----------
-
-    pub fn _splitText(self: *parser.Text, offset: u32) !*parser.Text {
-        return try parser.textSplitText(self, offset);
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: DOM.Text" {
-    try testing.htmlRunner("dom/text.html");
-}
--- a/src/browser/dom/tree_walker.zig
+++ b/src/browser/dom/tree_walker.zig
@@ -1,315 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-
-const NodeFilter = @import("node_filter.zig");
-const Node = @import("node.zig").Node;
-const NodeUnion = @import("node.zig").Union;
-
-// https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
-pub const TreeWalker = struct {
-    root: *parser.Node,
-    current_node: *parser.Node,
-    what_to_show: u32,
-    filter: ?TreeWalkerOpts,
-    filter_func: ?js.Function,
-
-    // One of the few cases where null and undefined resolve to different default.
-    // We need the raw JsObject so that we can probe the tri state:
-    // null, undefined or i32.
-    pub const WhatToShow = js.Object;
-
-    pub const TreeWalkerOpts = union(enum) {
-        function: js.Function,
-        object: struct { acceptNode: js.Function },
-    };
-
-    pub fn init(node: *parser.Node, what_to_show_: ?WhatToShow, filter: ?TreeWalkerOpts) !TreeWalker {
-        var filter_func: ?js.Function = null;
-
-        if (filter) |f| {
-            filter_func = switch (f) {
-                .function => |func| func,
-                .object => |o| o.acceptNode,
-            };
-        }
-
-        var what_to_show: u32 = undefined;
-        if (what_to_show_) |wts| {
-            switch (try wts.triState(TreeWalker, "what_to_show", u32)) {
-                .null => what_to_show = 0,
-                .undefined => what_to_show = NodeFilter.NodeFilter._SHOW_ALL,
-                .value => |v| what_to_show = v,
-            }
-        } else {
-            what_to_show = NodeFilter.NodeFilter._SHOW_ALL;
-        }
-
-        return .{
-            .root = node,
-            .current_node = node,
-            .what_to_show = what_to_show,
-            .filter = filter,
-            .filter_func = filter_func,
-        };
-    }
-
-    pub fn get_root(self: *TreeWalker) !NodeUnion {
-        return try Node.toInterface(self.root);
-    }
-
-    pub fn get_currentNode(self: *TreeWalker) !NodeUnion {
-        return try Node.toInterface(self.current_node);
-    }
-
-    pub fn get_whatToShow(self: *TreeWalker) u32 {
-        return self.what_to_show;
-    }
-
-    pub fn get_filter(self: *TreeWalker) ?TreeWalkerOpts {
-        return self.filter;
-    }
-
-    pub fn set_currentNode(self: *TreeWalker, node: *parser.Node) !void {
-        self.current_node = node;
-    }
-
-    fn firstChild(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
-        const children = try parser.nodeGetChildNodes(node);
-        const child_count = parser.nodeListLength(children);
-
-        for (0..child_count) |i| {
-            const index: u32 = @intCast(i);
-            const child = (parser.nodeListItem(children, index)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
-                .accept => return child,
-                .reject => continue,
-                .skip => if (try self.firstChild(child)) |gchild| return gchild,
-            }
-        }
-
-        return null;
-    }
-
-    fn lastChild(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
-        const children = try parser.nodeGetChildNodes(node);
-        const child_count = parser.nodeListLength(children);
-
-        var index: u32 = child_count;
-        while (index > 0) {
-            index -= 1;
-            const child = (parser.nodeListItem(children, index)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
-                .accept => return child,
-                .reject => continue,
-                .skip => if (try self.lastChild(child)) |gchild| return gchild,
-            }
-        }
-
-        return null;
-    }
-
-    fn nextSibling(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
-        var current = node;
-
-        while (true) {
-            current = (parser.nodeNextSibling(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return current,
-                .skip, .reject => continue,
-            }
-        }
-
-        return null;
-    }
-
-    // Get the next sibling that is either acceptable or should be descended into (skip)
-    fn nextSiblingOrSkip(self: *const TreeWalker, node: *parser.Node) !?struct { node: *parser.Node, should_descend: bool } {
-        var current = node;
-
-        while (true) {
-            current = (parser.nodeNextSibling(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return .{ .node = current, .should_descend = false },
-                .skip => return .{ .node = current, .should_descend = true },
-                .reject => continue,
-            }
-        }
-
-        return null;
-    }
-
-    fn previousSibling(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
-        var current = node;
-
-        while (true) {
-            current = (parser.nodePreviousSibling(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return current,
-                .skip, .reject => continue,
-            }
-        }
-
-        return null;
-    }
-
-    fn parentNode(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
-        if (self.root == node) return null;
-
-        var current = node;
-        while (true) {
-            if (current == self.root) return null;
-            current = (parser.nodeParentNode(current)) orelse return null;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => return current,
-                .reject, .skip => continue,
-            }
-        }
-    }
-
-    pub fn _firstChild(self: *TreeWalker) !?NodeUnion {
-        if (try self.firstChild(self.current_node)) |child| {
-            self.current_node = child;
-            return try Node.toInterface(child);
-        }
-
-        return null;
-    }
-
-    pub fn _lastChild(self: *TreeWalker) !?NodeUnion {
-        if (try self.lastChild(self.current_node)) |child| {
-            self.current_node = child;
-            return try Node.toInterface(child);
-        }
-
-        return null;
-    }
-
-    pub fn _nextNode(self: *TreeWalker) !?NodeUnion {
-        var current = self.current_node;
-
-        // First, try to go to first child of current node
-        if (try self.firstChild(current)) |child| {
-            self.current_node = child;
-            return try Node.toInterface(child);
-        }
-
-        // No acceptable children, move to next node in tree
-        while (current != self.root) {
-            const result = try self.nextSiblingOrSkip(current) orelse {
-                // No next sibling, go up to parent and continue
-                // or, if there is no parent, we're done
-                current = (parser.nodeParentNode(current)) orelse break;
-                continue;
-            };
-
-
-            if (!result.should_descend) {
-                // This is an .accept node - return it
-                self.current_node = result.node;
-                return try Node.toInterface(result.node);
-            }
-
-            // This is a .skip node - try to find acceptable children within it
-            if (try self.firstChild(result.node)) |child| {
-                self.current_node = child;
-                return try Node.toInterface(child);
-            }
-            // No acceptable children, continue looking at this node's siblings
-            current = result.node;
-        }
-
-        return null;
-    }
-
-    pub fn _nextSibling(self: *TreeWalker) !?NodeUnion {
-        if (try self.nextSibling(self.current_node)) |sibling| {
-            self.current_node = sibling;
-            return try Node.toInterface(sibling);
-        }
-
-        return null;
-    }
-
-    pub fn _parentNode(self: *TreeWalker) !?NodeUnion {
-        if (try self.parentNode(self.current_node)) |parent| {
-            self.current_node = parent;
-            return try Node.toInterface(parent);
-        }
-
-        return null;
-    }
-
-    pub fn _previousNode(self: *TreeWalker) !?NodeUnion {
-        if (self.current_node == self.root) return null;
-
-        var current = self.current_node;
-        while (parser.nodePreviousSibling(current)) |previous| {
-            current = previous;
-
-            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
-                .accept => {
-                    // Get last child if it has one.
-                    if (try self.lastChild(current)) |child| {
-                        self.current_node = child;
-                        return try Node.toInterface(child);
-                    }
-
-                    // Otherwise, this node is our previous one.
-                    self.current_node = current;
-                    return try Node.toInterface(current);
-                },
-                .reject => continue,
-                .skip => {
-                    // Get last child if it has one.
-                    if (try self.lastChild(current)) |child| {
-                        self.current_node = child;
-                        return try Node.toInterface(child);
-                    }
-                },
-            }
-        }
-
-        if (current != self.root) {
-            if (try self.parentNode(current)) |parent| {
-                self.current_node = parent;
-                return try Node.toInterface(parent);
-            }
-        }
-
-        return null;
-    }
-
-    pub fn _previousSibling(self: *TreeWalker) !?NodeUnion {
-        if (try self.previousSibling(self.current_node)) |sibling| {
-            self.current_node = sibling;
-            return try Node.toInterface(sibling);
-        }
-
-        return null;
-    }
-};
--- a/src/browser/dump.zig
+++ b/src/browser/dump.zig
@@ -17,218 +17,97 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

 const std = @import("std");
+const File = std.fs.File;

-const parser = @import("netsurf.zig");
-const Page = @import("page.zig").Page;
-const Walker = @import("dom/walker.zig").WalkerChildren;
-
-pub const Opts = struct {
-    // set to include element shadowroots in the dump
-    page: ?*const Page = null,
-
-    strip_mode: StripMode = .{},
-
-    pub const StripMode = struct {
-        js: bool = false,
-        ui: bool = false,
-        css: bool = false,
-    };
-};
+const parser = @import("netsurf");
+const Walker = @import("../dom/walker.zig").WalkerChildren;

 // writer must be a std.io.Writer
-pub fn writeHTML(doc: *parser.Document, opts: Opts, writer: *std.Io.Writer) !void {
+pub fn writeHTML(doc: *parser.Document, writer: anytype) !void {
    try writer.writeAll("<!DOCTYPE html>\n");
-    try writeChildren(parser.documentToNode(doc), opts, writer);
+    try writeNode(parser.documentToNode(doc), writer);
    try writer.writeAll("\n");
 }

-// Spec: https://www.w3.org/TR/xml/#sec-prolog-dtd
-pub fn writeDocType(doc_type: *parser.DocumentType, writer: *std.Io.Writer) !void {
-    try writer.writeAll("<!DOCTYPE ");
-    try writer.writeAll(try parser.documentTypeGetName(doc_type));
-
-    const public_id = parser.documentTypeGetPublicId(doc_type);
-    const system_id = parser.documentTypeGetSystemId(doc_type);
-    if (public_id.len != 0 and system_id.len != 0) {
-        try writer.writeAll(" PUBLIC \"");
-        try writeEscapedAttributeValue(writer, public_id);
-        try writer.writeAll("\" \"");
-        try writeEscapedAttributeValue(writer, system_id);
-        try writer.writeAll("\"");
-    } else if (public_id.len != 0) {
-        try writer.writeAll(" PUBLIC \"");
-        try writeEscapedAttributeValue(writer, public_id);
-        try writer.writeAll("\"");
-    } else if (system_id.len != 0) {
-        try writer.writeAll(" SYSTEM \"");
-        try writeEscapedAttributeValue(writer, system_id);
-        try writer.writeAll("\"");
-    }
-    // Internal subset is not implemented
-    try writer.writeAll(">");
-}
-
-pub fn writeNode(node: *parser.Node, opts: Opts, writer: *std.Io.Writer) anyerror!void {
-    switch (parser.nodeType(node)) {
-        .element => {
-            // open the tag
-            const tag_type = try parser.nodeHTMLGetTagType(node) orelse .undef;
-            if (try isStripped(tag_type, node, opts.strip_mode)) {
-                return;
-            }
-
-            const tag = try parser.nodeLocalName(node);
-            try writer.writeAll("<");
-            try writer.writeAll(tag);
-
-            // write the attributes
-            const _map = try parser.nodeGetAttributes(node);
-            if (_map) |map| {
-                const ln = try parser.namedNodeMapGetLength(map);
-                for (0..ln) |i| {
-                    const attr = try parser.namedNodeMapItem(map, @intCast(i)) orelse break;
-                    try writer.writeAll(" ");
-                    try writer.writeAll(try parser.attributeGetName(attr));
-                    try writer.writeAll("=\"");
-                    const attribute_value = try parser.attributeGetValue(attr) orelse "";
-                    try writeEscapedAttributeValue(writer, attribute_value);
-                    try writer.writeAll("\"");
-                }
-            }
-
-            try writer.writeAll(">");
-
-            if (opts.page) |page| {
-                if (page.getNodeState(node)) |state| {
-                    if (state.shadow_root) |sr| {
-                        try writeChildren(@ptrCast(@alignCast(sr.proto)), opts, writer);
-                    }
-                }
-            }
-
-            // void elements can't have any content.
-            if (try isVoid(parser.nodeToElement(node))) return;
-
-            if (tag_type == .script) {
-                try writer.writeAll(parser.nodeTextContent(node) orelse "");
-            } else {
-                // write the children
-                // TODO avoid recursion
-                try writeChildren(node, opts, writer);
-            }
-
-            // close the tag
-            try writer.writeAll("</");
-            try writer.writeAll(tag);
-            try writer.writeAll(">");
-        },
-        .text => {
-            const v = parser.nodeValue(node) orelse return;
-            try writeEscapedTextNode(writer, v);
-        },
-        .cdata_section => {
-            const v = parser.nodeValue(node) orelse return;
-            try writer.writeAll("<![CDATA[");
-            try writer.writeAll(v);
-            try writer.writeAll("]]>");
-        },
-        .comment => {
-            const v = parser.nodeValue(node) orelse return;
-            try writer.writeAll("<!--");
-            try writer.writeAll(v);
-            try writer.writeAll("-->");
-        },
-        // TODO handle processing instruction dump
-        .processing_instruction => return,
-        // document fragment is outside of the main document DOM, so we
-        // don't output it.
-        .document_fragment => return,
-        // document will never be called, but required for completeness.
-        .document => return,
-        // done globally instead, but required for completeness. Only the outer DOCTYPE should be written
-        .document_type => return,
-        // deprecated
-        .attribute => return,
-        .entity_reference => return,
-        .entity => return,
-        .notation => return,
-    }
-}
-
 // writer must be a std.io.Writer
-pub fn writeChildren(root: *parser.Node, opts: Opts, writer: *std.Io.Writer) !void {
+pub fn writeNode(root: *parser.Node, writer: anytype) !void {
    const walker = Walker{};
    var next: ?*parser.Node = null;
    while (true) {
        next = try walker.get_next(root, next) orelse break;
-        try writeNode(next.?, opts, writer);
-    }
-}
+        switch (try parser.nodeType(next.?)) {
+            .element => {
+                // open the tag
+                const tag = try parser.nodeLocalName(next.?);
+                try writer.writeAll("<");
+                try writer.writeAll(tag);

-fn isStripped(tag_type: parser.Tag, node: *parser.Node, strip_mode: Opts.StripMode) !bool {
-    if (strip_mode.js and try isJsRelated(tag_type, node)) {
-        return true;
-    }
+                // write the attributes
+                const map = try parser.nodeGetAttributes(next.?);
+                const ln = try parser.namedNodeMapGetLength(map);
+                var i: u32 = 0;
+                while (i < ln) {
+                    const attr = try parser.namedNodeMapItem(map, i) orelse break;
+                    try writer.writeAll(" ");
+                    try writer.writeAll(try parser.attributeGetName(attr));
+                    try writer.writeAll("=\"");
+                    try writer.writeAll(try parser.attributeGetValue(attr) orelse "");
+                    try writer.writeAll("\"");
+                    i += 1;
+                }

-    if (strip_mode.css and try isCssRelated(tag_type, node)) {
-        return true;
-    }
+                try writer.writeAll(">");

-    if (strip_mode.ui and try isUIRelated(tag_type, node)) {
-        return true;
-    }
-    return false;
-}
+                // void elements can't have any content.
+                if (try isVoid(parser.nodeToElement(next.?))) continue;

-fn isJsRelated(tag_type: parser.Tag, node: *parser.Node) !bool {
-    if (tag_type == .script) {
-        return true;
-    }
-    if (tag_type == .link) {
-        const el = parser.nodeToElement(node);
-        const as = try parser.elementGetAttribute(el, "as") orelse return false;
-        if (!std.ascii.eqlIgnoreCase(as, "script")) {
-            return false;
-        }
+                // write the children
+                // TODO avoid recursion
+                try writeNode(next.?, writer);

-        const rel = try parser.elementGetAttribute(el, "rel") orelse return false;
-        return std.ascii.eqlIgnoreCase(rel, "preload");
-    }
-    return false;
-}
-
-fn isCssRelated(tag_type: parser.Tag, node: *parser.Node) !bool {
-    if (tag_type == .style) {
-        return true;
-    }
-    if (tag_type == .link) {
-        const el = parser.nodeToElement(node);
-        const rel = try parser.elementGetAttribute(el, "rel") orelse return false;
-        return std.ascii.eqlIgnoreCase(rel, "stylesheet");
-    }
-    return false;
-}
-
-fn isUIRelated(tag_type: parser.Tag, node: *parser.Node) !bool {
-    if (try isCssRelated(tag_type, node)) {
-        return true;
-    }
-    if (tag_type == .img or tag_type == .picture or tag_type == .video) {
-        return true;
-    }
-    if (tag_type == .undef) {
-        const name = try parser.nodeLocalName(node);
-        if (std.mem.eql(u8, name, "svg")) {
-            return true;
+                // close the tag
+                try writer.writeAll("</");
+                try writer.writeAll(tag);
+                try writer.writeAll(">");
+            },
+            .text => {
+                const v = try parser.nodeValue(next.?) orelse continue;
+                try writer.writeAll(v);
+            },
+            .cdata_section => {
+                const v = try parser.nodeValue(next.?) orelse continue;
+                try writer.writeAll("<![CDATA[");
+                try writer.writeAll(v);
+                try writer.writeAll("]]>");
+            },
+            .comment => {
+                const v = try parser.nodeValue(next.?) orelse continue;
+                try writer.writeAll("<!--");
+                try writer.writeAll(v);
+                try writer.writeAll("-->");
+            },
+            // TODO handle processing instruction dump
+            .processing_instruction => continue,
+            // document fragment is outside of the main document DOM, so we
+            // don't output it.
+            .document_fragment => continue,
+            // document will never be called, but required for completeness.
+            .document => continue,
+            // done globally instead, but required for completeness.
+            .document_type => continue,
+            // deprecated
+            .attribute => continue,
+            .entity_reference => continue,
+            .entity => continue,
+            .notation => continue,
        }
    }
-    return false;
 }

 // area, base, br, col, embed, hr, img, input, link, meta, source, track, wbr
 // https://html.spec.whatwg.org/#void-elements
 fn isVoid(elem: *parser.Element) !bool {
-    const tag = try parser.elementTag(elem);
+    const tag = try parser.elementHTMLGetTagType(@as(*parser.ElementHTML, @ptrCast(elem)));
    return switch (tag) {
        .area, .base, .br, .col, .embed, .hr, .img, .input, .link => true,
        .meta, .source, .track, .wbr => true,
@@ -236,104 +115,18 @@ fn isVoid(elem: *parser.Element) !bool {
    };
 }

-fn writeEscapedTextNode(writer: *std.Io.Writer, value: []const u8) !void {
-    var v = value;
-    while (v.len > 0) {
-        const index = std.mem.indexOfAnyPos(u8, v, 0, &.{ '&', '<', '>', 194 }) orelse {
-            return writer.writeAll(v);
-        };
-        try writer.writeAll(v[0..index]);
-        switch (v[index]) {
-            '&' => try writer.writeAll("&amp;"),
-            '<' => try writer.writeAll("&lt;"),
-            '>' => try writer.writeAll("&gt;"),
-            194 => {
-                // non breaking space
-                if (v.len > index + 1 and v[index + 1] == 160) {
-                    try writer.writeAll("&nbsp;");
-                    v = v[index + 2 ..];
-                    continue;
-                }
-                try writer.writeByte(194);
-            },
-            else => unreachable,
-        }
-        v = v[index + 1 ..];
-    }
-}
-
-fn writeEscapedAttributeValue(writer: *std.Io.Writer, value: []const u8) !void {
-    var v = value;
-    while (v.len > 0) {
-        const index = std.mem.indexOfAnyPos(u8, v, 0, &.{ '&', '<', '>', '"' }) orelse {
-            return writer.writeAll(v);
-        };
-        try writer.writeAll(v[0..index]);
-        switch (v[index]) {
-            '&' => try writer.writeAll("&amp;"),
-            '<' => try writer.writeAll("&lt;"),
-            '>' => try writer.writeAll("&gt;"),
-            '"' => try writer.writeAll("&quot;"),
-            else => unreachable,
-        }
-        v = v[index + 1 ..];
-    }
-}
-
-const testing = std.testing;
 test "dump.writeHTML" {
-    parser.init();
-    defer parser.deinit();
+    const out = try std.fs.openFileAbsolute("/dev/null", .{ .mode = .write_only });
+    defer out.close();

-    try testWriteHTML(
-        "<div id=\"content\">Over 9000!</div>",
-        "<div id=\"content\">Over 9000!</div>",
-    );
+    const file = try std.fs.cwd().openFile("test.html", .{});
+    defer file.close();

-    try testWriteHTML(
-        "<root><!-- a comment --></root>",
-        "<root><!-- a comment --></root>",
-    );
-
-    try testWriteHTML(
-        "<p>&lt; &gt; &amp;</p>",
-        "<p>&lt; &gt; &amp;</p>",
-    );
-
-    try testWriteHTML(
-        "<p id=\"&quot;&gt;&lt;&amp;&quot;''\">wat?</p>",
-        "<p id='\">&lt;&amp;&quot;&#39;&apos;'>wat?</p>",
-    );
-
-    try testWriteFullHTML(
-        \\<!DOCTYPE html>
-        \\<html><head><title>It's over what?</title><meta name="a" value="b">
-        \\</head><body>9000</body></html>
-        \\
-    , "<html><title>It's over what?</title><meta name=a value=\"b\">\n<body>9000");
-
-    try testWriteHTML(
-        "<p>hi</p><script>alert(power > 9000)</script>",
-        "<p>hi</p><script>alert(power > 9000)</script>",
-    );
-}
-
-fn testWriteHTML(comptime expected_body: []const u8, src: []const u8) !void {
-    const expected =
-        "<!DOCTYPE html>\n<html><head></head><body>" ++
-        expected_body ++
-        "</body></html>\n";
-    return testWriteFullHTML(expected, src);
-}
-
-fn testWriteFullHTML(comptime expected: []const u8, src: []const u8) !void {
-    var aw = std.Io.Writer.Allocating.init(testing.allocator);
-    defer aw.deinit();
-
-    const doc_html = try parser.documentHTMLParseFromStr(src);
+    const doc_html = try parser.documentHTMLParse(file.reader(), "UTF-8");
+    // ignore close error
    defer parser.documentHTMLClose(doc_html) catch {};

    const doc = parser.documentHTMLToDocument(doc_html);
-    try writeHTML(doc, .{}, &aw.writer);
-    try testing.expectEqualStrings(expected, aw.written());
+
+    try writeHTML(doc, out);
 }
--- a/src/browser/encoding/TextDecoder.zig
+++ b/src/browser/encoding/TextDecoder.zig
@@ -1,102 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const Page = @import("../page.zig").Page;
-
-// https://encoding.spec.whatwg.org/#interface-textdecoder
-const TextDecoder = @This();
-
-const SupportedLabels = enum {
-    utf8,
-    @"utf-8",
-    @"unicode-1-1-utf-8",
-};
-
-const Options = struct {
-    fatal: bool = false,
-    ignoreBOM: bool = false,
-};
-
-fatal: bool,
-ignore_bom: bool,
-stream: std.ArrayList(u8),
-
-pub fn constructor(label_: ?[]const u8, opts_: ?Options) !TextDecoder {
-    if (label_) |l| {
-        _ = std.meta.stringToEnum(SupportedLabels, l) orelse {
-            log.warn(.web_api, "not implemented", .{ .feature = "TextDecoder label", .label = l });
-            return error.NotImplemented;
-        };
-    }
-    const opts = opts_ orelse Options{};
-    return .{
-        .stream = .empty,
-        .fatal = opts.fatal,
-        .ignore_bom = opts.ignoreBOM,
-    };
-}
-
-pub fn get_encoding(_: *const TextDecoder) []const u8 {
-    return "utf-8";
-}
-
-pub fn get_ignoreBOM(self: *const TextDecoder) bool {
-    return self.ignore_bom;
-}
-
-pub fn get_fatal(self: *const TextDecoder) bool {
-    return self.fatal;
-}
-
-const DecodeOptions = struct {
-    stream: bool = false,
-};
-pub fn _decode(self: *TextDecoder, str_: ?[]const u8, opts_: ?DecodeOptions, page: *Page) ![]const u8 {
-    var str = str_ orelse return "";
-    const opts: DecodeOptions = opts_ orelse .{};
-
-    if (self.stream.items.len > 0) {
-        try self.stream.appendSlice(page.arena, str);
-        str = self.stream.items;
-    }
-
-    if (self.fatal and !std.unicode.utf8ValidateSlice(str)) {
-        if (opts.stream) {
-            if (self.stream.items.len == 0) {
-                try self.stream.appendSlice(page.arena, str);
-            }
-            return "";
-        }
-        return error.InvalidUtf8;
-    }
-
-    self.stream.clearRetainingCapacity();
-    if (self.ignore_bom == false and std.mem.startsWith(u8, str, &.{ 0xEF, 0xBB, 0xBF })) {
-        return str[3..];
-    }
-
-    return str;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: Encoding.TextDecoder" {
-    try testing.htmlRunner("encoding/decoder.html");
-}
--- a/src/browser/encoding/TextEncoder.zig
+++ b/src/browser/encoding/TextEncoder.zig
@@ -1,48 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-
-// https://encoding.spec.whatwg.org/#interface-textencoder
-const TextEncoder = @This();
-
-pub fn constructor() !TextEncoder {
-    return .{};
-}
-
-pub fn get_encoding(_: *const TextEncoder) []const u8 {
-    return "utf-8";
-}
-
-pub fn _encode(_: *const TextEncoder, v: []const u8) !js.TypedArray(u8) {
-    // Ensure the input is a valid utf-8
-    // It seems chrome accepts invalid utf-8 sequence.
-    //
-    if (!std.unicode.utf8ValidateSlice(v)) {
-        return error.InvalidUtf8;
-    }
-
-    return .{ .values = v };
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: Encoding.TextEncoder" {
-    try testing.htmlRunner("encoding/encoder.html");
-}
--- a/src/browser/events/custom_event.zig
+++ b/src/browser/events/custom_event.zig
@@ -1,86 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const Event = @import("event.zig").Event;
-
-const netsurf = @import("../netsurf.zig");
-
-// https://dom.spec.whatwg.org/#interface-customevent
-pub const CustomEvent = struct {
-    pub const prototype = *Event;
-    pub const union_make_copy = true;
-
-    proto: parser.Event,
-    detail: ?js.Object,
-
-    const CustomEventInit = struct {
-        bubbles: bool = false,
-        cancelable: bool = false,
-        composed: bool = false,
-        detail: ?js.Object = null,
-    };
-
-    pub fn constructor(event_type: []const u8, opts_: ?CustomEventInit) !CustomEvent {
-        const opts = opts_ orelse CustomEventInit{};
-
-        const event = try parser.eventCreate();
-        defer parser.eventDestroy(event);
-        try parser.eventInit(event, event_type, .{
-            .bubbles = opts.bubbles,
-            .cancelable = opts.cancelable,
-            .composed = opts.composed,
-        });
-
-        return .{
-            .proto = event.*,
-            .detail = if (opts.detail) |d| try d.persist() else null,
-        };
-    }
-
-    pub fn get_detail(self: *CustomEvent) ?js.Object {
-        return self.detail;
-    }
-
-    // Initializes an already created `CustomEvent`.
-    // https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/initCustomEvent
-    pub fn _initCustomEvent(
-        self: *CustomEvent,
-        event_type: []const u8,
-        can_bubble: bool,
-        cancelable: bool,
-        maybe_detail: ?js.Object,
-    ) !void {
-        // This function can only be called after the constructor has called.
-        // So we assume proto is initialized already by constructor.
-        self.proto.type = try netsurf.strFromData(event_type);
-        self.proto.bubble = can_bubble;
-        self.proto.cancelable = cancelable;
-        self.proto.is_initialised = true;
-        // Detail is stored separately.
-        if (maybe_detail) |detail| {
-            self.detail = try detail.persist();
-        }
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: Events.Custom" {
-    try testing.htmlRunner("events/custom.html");
-}
--- a/src/browser/events/event.zig
+++ b/src/browser/events/event.zig
@@ -1,440 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const Allocator = std.mem.Allocator;
-
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const generate = @import("../js/generate.zig");
-
-const Page = @import("../page.zig").Page;
-const Node = @import("../dom/node.zig").Node;
-const DOMException = @import("../dom/exceptions.zig").DOMException;
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-const EventTargetUnion = @import("../dom/event_target.zig").Union;
-const AbortSignal = @import("../html/AbortController.zig").AbortSignal;
-
-const CustomEvent = @import("custom_event.zig").CustomEvent;
-const ProgressEvent = @import("../xhr/progress_event.zig").ProgressEvent;
-const MouseEvent = @import("mouse_event.zig").MouseEvent;
-const KeyboardEvent = @import("keyboard_event.zig").KeyboardEvent;
-const ErrorEvent = @import("../html/error_event.zig").ErrorEvent;
-const MessageEvent = @import("../dom/MessageChannel.zig").MessageEvent;
-const PopStateEvent = @import("../html/History.zig").PopStateEvent;
-const NavigationCurrentEntryChangeEvent = @import("../navigation/navigation.zig").NavigationCurrentEntryChangeEvent;
-
-// Event interfaces
-pub const Interfaces = .{
-    Event,
-    CustomEvent,
-    ProgressEvent,
-    MouseEvent,
-    KeyboardEvent,
-    ErrorEvent,
-    MessageEvent,
-    PopStateEvent,
-    NavigationCurrentEntryChangeEvent,
-};
-
-pub const Union = generate.Union(Interfaces);
-
-// https://dom.spec.whatwg.org/#event
-pub const Event = struct {
-    pub const Self = parser.Event;
-    pub const Exception = DOMException;
-
-    pub const EventInit = parser.EventInit;
-
-    // JS
-    // --
-
-    pub const _CAPTURING_PHASE = 1;
-    pub const _AT_TARGET = 2;
-    pub const _BUBBLING_PHASE = 3;
-
-    pub fn toInterface(evt: *parser.Event) Union {
-        return switch (parser.eventGetInternalType(evt)) {
-            .event, .abort_signal, .xhr_event => .{ .Event = evt },
-            .custom_event => .{ .CustomEvent = @as(*CustomEvent, @ptrCast(evt)).* },
-            .progress_event => .{ .ProgressEvent = @as(*ProgressEvent, @ptrCast(evt)).* },
-            .mouse_event => .{ .MouseEvent = @as(*parser.MouseEvent, @ptrCast(evt)) },
-            .error_event => .{ .ErrorEvent = @as(*ErrorEvent, @ptrCast(evt)).* },
-            .message_event => .{ .MessageEvent = @as(*MessageEvent, @ptrCast(evt)).* },
-            .keyboard_event => .{ .KeyboardEvent = @as(*parser.KeyboardEvent, @ptrCast(evt)) },
-            .pop_state => .{ .PopStateEvent = @as(*PopStateEvent, @ptrCast(evt)).* },
-            .navigation_current_entry_change_event => .{
-                .NavigationCurrentEntryChangeEvent = @as(*NavigationCurrentEntryChangeEvent, @ptrCast(evt)).*,
-            },
-        };
-    }
-
-    pub fn constructor(event_type: []const u8, opts: ?EventInit) !*parser.Event {
-        const event = try parser.eventCreate();
-        try parser.eventInit(event, event_type, opts orelse EventInit{});
-        return event;
-    }
-
-    // Getters
-
-    pub fn get_type(self: *parser.Event) []const u8 {
-        return parser.eventType(self);
-    }
-
-    pub fn get_target(self: *parser.Event, page: *Page) !?EventTargetUnion {
-        const et = parser.eventTarget(self);
-        if (et == null) return null;
-        return try EventTarget.toInterface(et.?, page);
-    }
-
-    pub fn get_currentTarget(self: *parser.Event, page: *Page) !?EventTargetUnion {
-        const et = parser.eventCurrentTarget(self);
-        if (et == null) return null;
-        return try EventTarget.toInterface(et.?, page);
-    }
-
-    pub fn get_eventPhase(self: *parser.Event) u8 {
-        return parser.eventPhase(self);
-    }
-
-    pub fn get_bubbles(self: *parser.Event) bool {
-        return parser.eventBubbles(self);
-    }
-
-    pub fn get_cancelable(self: *parser.Event) bool {
-        return parser.eventCancelable(self);
-    }
-
-    pub fn get_defaultPrevented(self: *parser.Event) bool {
-        return parser.eventDefaultPrevented(self);
-    }
-
-    pub fn get_isTrusted(self: *parser.Event) bool {
-        return parser.eventIsTrusted(self);
-    }
-
-    // Even though this is supposed to to provide microsecond resolution, browser
-    // return coarser values to protect against fingerprinting. libdom returns
-    // seconds, which is good enough.
-    pub fn get_timeStamp(self: *parser.Event) u64 {
-        return parser.eventTimestamp(self);
-    }
-
-    // Methods
-
-    pub fn _initEvent(
-        self: *parser.Event,
-        eventType: []const u8,
-        bubbles: ?bool,
-        cancelable: ?bool,
-    ) !void {
-        const opts = EventInit{
-            .bubbles = bubbles orelse false,
-            .cancelable = cancelable orelse false,
-        };
-        return try parser.eventInit(self, eventType, opts);
-    }
-
-    pub fn _stopPropagation(self: *parser.Event) !void {
-        return parser.eventStopPropagation(self);
-    }
-
-    pub fn _stopImmediatePropagation(self: *parser.Event) !void {
-        return parser.eventStopImmediatePropagation(self);
-    }
-
-    pub fn _preventDefault(self: *parser.Event) !void {
-        return parser.eventPreventDefault(self);
-    }
-
-    pub fn _composedPath(self: *parser.Event, page: *Page) ![]const EventTargetUnion {
-        const et_ = parser.eventTarget(self);
-        const et = et_ orelse return &.{};
-
-        var node: ?*parser.Node = switch (parser.eventTargetInternalType(et)) {
-            .libdom_node => @as(*parser.Node, @ptrCast(et)),
-            .plain => parser.eventTargetToNode(et),
-            else => {
-                // Window, XHR, MessagePort, etc...no path beyond the event itself
-                return &.{try EventTarget.toInterface(et, page)};
-            },
-        };
-
-        const arena = page.call_arena;
-        var path: std.ArrayListUnmanaged(EventTargetUnion) = .empty;
-        while (node) |n| {
-            try path.append(arena, .{
-                .node = try Node.toInterface(n),
-            });
-
-            node = parser.nodeParentNode(n);
-            if (node == null and parser.nodeType(n) == .document_fragment) {
-                // we have a non-continuous hook from a shadowroot to its host (
-                // it's parent element). libdom doesn't really support ShdowRoots
-                // and, for the most part, that works out well since it naturally
-                // provides isolation. But events don't follow the same
-                // shadowroot isolation as most other things, so, if this is
-                // a parent-less document fragment, we need to check if it has
-                // a host.
-                if (parser.documentFragmentGetHost(@ptrCast(n))) |host| {
-                    node = host;
-
-                    // If a document fragment has a host, then that host
-                    // _has_ to have a state and that state _has_ to have
-                    // a shadow_root field. All of this is set in Element._attachShadow
-                    if (page.getNodeState(host).?.shadow_root.?.mode == .closed) {
-                        // if the shadow root is closed, then the composedPath
-                        // starts at the host element.
-                        path.clearRetainingCapacity();
-                    }
-                } else {
-                    // Our document fragement has no parent and no host, we
-                    // can break out of the loop.
-                    break;
-                }
-            }
-        }
-
-        if (path.getLastOrNull()) |last| {
-            // the Window isn't part of the DOM hierarchy, but for events, it
-            // is, so we need to glue it on.
-            if (last.node == .HTMLDocument and last.node.HTMLDocument == page.window.document) {
-                try path.append(arena, .{ .node = .{ .Window = &page.window } });
-            }
-        }
-        return path.items;
-    }
-};
-
-pub const EventHandler = struct {
-    once: bool,
-    capture: bool,
-    callback: js.Function,
-    node: parser.EventNode,
-    listener: *parser.EventListener,
-
-    pub const Listener = union(enum) {
-        function: js.Function,
-        object: js.Object,
-
-        pub fn callback(self: Listener, target: *parser.EventTarget) !?js.Function {
-            return switch (self) {
-                .function => |func| try func.withThis(target),
-                .object => |obj| blk: {
-                    const func = (try obj.getFunction("handleEvent")) orelse return null;
-                    break :blk try func.withThis(try obj.persist());
-                },
-            };
-        }
-    };
-
-    pub const Opts = union(enum) {
-        flags: Flags,
-        capture: bool,
-
-        const Flags = struct {
-            once: ?bool,
-            capture: ?bool,
-            // We ignore this property. It seems to be largely used to help the
-            // browser make certain performance tweaks (i.e. the browser knows
-            // that the listener won't call preventDefault() and thus can safely
-            // run the default as needed).
-            passive: ?bool,
-            signal: ?*AbortSignal, // currently does nothing
-        };
-    };
-
-    pub fn register(
-        allocator: Allocator,
-        target: *parser.EventTarget,
-        typ: []const u8,
-        listener: Listener,
-        opts_: ?Opts,
-    ) !?*EventHandler {
-        var once = false;
-        var capture = false;
-        var signal: ?*AbortSignal = null;
-
-        if (opts_) |opts| {
-            switch (opts) {
-                .capture => |c| capture = c,
-                .flags => |f| {
-                    once = f.once orelse false;
-                    signal = f.signal orelse null;
-                    capture = f.capture orelse false;
-                },
-            }
-        }
-        const callback = (try listener.callback(target)) orelse return null;
-
-        if (signal) |s| {
-            const signal_target = parser.toEventTarget(AbortSignal, s);
-
-            const scb = try allocator.create(SignalCallback);
-            scb.* = .{
-                .target = target,
-                .capture = capture,
-                .callback_id = callback.id,
-                .typ = try allocator.dupe(u8, typ),
-                .signal_target = signal_target,
-                .signal_listener = undefined,
-                .node = .{ .func = SignalCallback.handle },
-            };
-
-            scb.signal_listener = try parser.eventTargetAddEventListener(
-                signal_target,
-                "abort",
-                &scb.node,
-                false,
-            );
-        }
-
-        // check if event target has already this listener
-        if (try parser.eventTargetHasListener(target, typ, capture, callback.id) != null) {
-            return null;
-        }
-
-        const eh = try allocator.create(EventHandler);
-        eh.* = .{
-            .once = once,
-            .capture = capture,
-            .callback = callback,
-            .node = .{
-                .id = callback.id,
-                .func = handle,
-            },
-            .listener = undefined,
-        };
-
-        eh.listener = try parser.eventTargetAddEventListener(
-            target,
-            typ,
-            &eh.node,
-            capture,
-        );
-        return eh;
-    }
-
-    fn handle(node: *parser.EventNode, event: *parser.Event) void {
-        const ievent = Event.toInterface(event);
-        const self: *EventHandler = @fieldParentPtr("node", node);
-        var result: js.Function.Result = undefined;
-        self.callback.tryCall(void, .{ievent}, &result) catch {
-            log.debug(.user_script, "callback error", .{
-                .err = result.exception,
-                .stack = result.stack,
-                .source = "event handler",
-            });
-        };
-
-        if (self.once) {
-            const target = parser.eventTarget(event).?;
-            const typ = parser.eventType(event);
-            parser.eventTargetRemoveEventListener(
-                target,
-                typ,
-                self.listener,
-                self.capture,
-            ) catch {};
-        }
-    }
-};
-
-const SignalCallback = struct {
-    typ: []const u8,
-    capture: bool,
-    callback_id: usize,
-    node: parser.EventNode,
-    target: *parser.EventTarget,
-    signal_target: *parser.EventTarget,
-    signal_listener: *parser.EventListener,
-
-    fn handle(node: *parser.EventNode, _: *parser.Event) void {
-        const self: *SignalCallback = @fieldParentPtr("node", node);
-        self._handle() catch |err| {
-            log.err(.app, "event signal handler", .{ .err = err });
-        };
-    }
-
-    fn _handle(self: *SignalCallback) !void {
-        const lst = try parser.eventTargetHasListener(
-            self.target,
-            self.typ,
-            self.capture,
-            self.callback_id,
-        );
-        if (lst == null) {
-            return;
-        }
-
-        try parser.eventTargetRemoveEventListener(
-            self.target,
-            self.typ,
-            lst.?,
-            self.capture,
-        );
-
-        // remove the abort signal listener itself
-        try parser.eventTargetRemoveEventListener(
-            self.signal_target,
-            "abort",
-            self.signal_listener,
-            false,
-        );
-    }
-};
-
-pub fn DirectEventHandler(
-    comptime TargetT: type,
-    target: *TargetT,
-    event_type: []const u8,
-    maybe_listener: ?EventHandler.Listener,
-    cb: *?js.Function,
-    page_arena: std.mem.Allocator,
-) !void {
-    const event_target = parser.toEventTarget(TargetT, target);
-
-    // Check if we have a listener set.
-    if (cb.*) |callback| {
-        const listener = try parser.eventTargetHasListener(event_target, event_type, false, callback.id);
-        std.debug.assert(listener != null);
-        try parser.eventTargetRemoveEventListener(event_target, event_type, listener.?, false);
-    }
-
-    if (maybe_listener) |listener| {
-        switch (listener) {
-            // If an object is given as listener, do nothing.
-            .object => {},
-            .function => |callback| {
-                _ = try EventHandler.register(page_arena, event_target, event_type, listener, null) orelse unreachable;
-                cb.* = callback;
-
-                return;
-            },
-        }
-    }
-
-    // Just unset the listener.
-    cb.* = null;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: Event" {
-    try testing.htmlRunner("events/event.html");
-}
--- a/src/browser/events/keyboard_event.zig
+++ b/src/browser/events/keyboard_event.zig
@@ -1,159 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-const builtin = @import("builtin");
-
-const parser = @import("../netsurf.zig");
-const Event = @import("event.zig").Event;
-
-// TODO: We currently don't have a UIEvent interface so we skip it in the prototype chain.
-// https://developer.mozilla.org/en-US/docs/Web/API/UIEvent
-const UIEvent = Event;
-
-// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent
-pub const KeyboardEvent = struct {
-    pub const Self = parser.KeyboardEvent;
-    pub const prototype = *UIEvent;
-
-    pub const ConstructorOptions = struct {
-        key: []const u8 = "",
-        code: []const u8 = "",
-        location: parser.KeyboardEventOpts.LocationCode = .standard,
-        repeat: bool = false,
-        isComposing: bool = false,
-        // Currently not supported but we take as argument.
-        charCode: u32 = 0,
-        // Currently not supported but we take as argument.
-        keyCode: u32 = 0,
-        // Currently not supported but we take as argument.
-        which: u32 = 0,
-        ctrlKey: bool = false,
-        shiftKey: bool = false,
-        altKey: bool = false,
-        metaKey: bool = false,
-    };
-
-    pub fn constructor(event_type: []const u8, maybe_options: ?ConstructorOptions) !*parser.KeyboardEvent {
-        const options: ConstructorOptions = maybe_options orelse .{};
-
-        const event = try parser.keyboardEventCreate();
-        parser.eventSetInternalType(@ptrCast(event), .keyboard_event);
-
-        try parser.keyboardEventInit(
-            event,
-            event_type,
-            .{
-                .key = options.key,
-                .code = options.code,
-                .location = options.location,
-                .repeat = options.repeat,
-                .is_composing = options.isComposing,
-                .ctrl_key = options.ctrlKey,
-                .shift_key = options.shiftKey,
-                .alt_key = options.altKey,
-                .meta_key = options.metaKey,
-            },
-        );
-
-        return event;
-    }
-
-    // Returns the modifier state for given modifier key.
-    pub fn _getModifierState(self: *Self, key: []const u8) bool {
-        // Chrome and Firefox do case-sensitive match, here we prefer the same.
-        if (std.mem.eql(u8, key, "Alt")) {
-            return get_altKey(self);
-        }
-
-        if (std.mem.eql(u8, key, "AltGraph")) {
-            return (get_altKey(self) and get_ctrlKey(self));
-        }
-
-        if (std.mem.eql(u8, key, "Control")) {
-            return get_ctrlKey(self);
-        }
-
-        if (std.mem.eql(u8, key, "Shift")) {
-            return get_shiftKey(self);
-        }
-
-        if (std.mem.eql(u8, key, "Meta") or std.mem.eql(u8, key, "OS")) {
-            return get_metaKey(self);
-        }
-
-        // Special case for IE.
-        if (comptime builtin.os.tag == .windows) {
-            if (std.mem.eql(u8, key, "Win")) {
-                return get_metaKey(self);
-            }
-        }
-
-        // getModifierState() also accepts a deprecated virtual modifier named "Accel".
-        // event.getModifierState("Accel") returns true when at least one of
-        // KeyboardEvent.ctrlKey or KeyboardEvent.metaKey is true.
-        //
-        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState#accel_virtual_modifier
-        if (std.mem.eql(u8, key, "Accel")) {
-            return (get_ctrlKey(self) or get_metaKey(self));
-        }
-
-        // TODO: Add support for "CapsLock", "ScrollLock".
-        return false;
-    }
-
-    // Getters.
-
-    pub fn get_altKey(self: *Self) bool {
-        return parser.keyboardEventKeyIsSet(self, .alt);
-    }
-
-    pub fn get_ctrlKey(self: *Self) bool {
-        return parser.keyboardEventKeyIsSet(self, .ctrl);
-    }
-
-    pub fn get_metaKey(self: *Self) bool {
-        return parser.keyboardEventKeyIsSet(self, .meta);
-    }
-
-    pub fn get_shiftKey(self: *Self) bool {
-        return parser.keyboardEventKeyIsSet(self, .shift);
-    }
-
-    pub fn get_isComposing(self: *Self) bool {
-        return self.is_composing;
-    }
-
-    pub fn get_location(self: *Self) u32 {
-        return self.location;
-    }
-
-    pub fn get_key(self: *Self) ![]const u8 {
-        return parser.keyboardEventGetKey(self);
-    }
-
-    pub fn get_repeat(self: *Self) bool {
-        return self.repeat;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: Events.Keyboard" {
-    try testing.htmlRunner("events/keyboard.html");
-}
--- a/src/browser/events/mouse_event.zig
+++ b/src/browser/events/mouse_event.zig
@@ -1,111 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const parser = @import("../netsurf.zig");
-const Event = @import("event.zig").Event;
-
-// TODO: We currently don't have a UIEvent interface so we skip it in the prototype chain.
-// https://developer.mozilla.org/en-US/docs/Web/API/UIEvent
-const UIEvent = Event;
-
-// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
-pub const MouseEvent = struct {
-    pub const Self = parser.MouseEvent;
-    pub const prototype = *UIEvent;
-
-    const MouseButton = enum(u16) {
-        main_button = 0,
-        auxillary_button = 1,
-        secondary_button = 2,
-        fourth_button = 3,
-        fifth_button = 4,
-    };
-
-    const MouseEventInit = struct {
-        screenX: i32 = 0,
-        screenY: i32 = 0,
-        clientX: i32 = 0,
-        clientY: i32 = 0,
-        ctrlKey: bool = false,
-        shiftKey: bool = false,
-        altKey: bool = false,
-        metaKey: bool = false,
-        button: MouseButton = .main_button,
-    };
-
-    pub fn constructor(event_type: []const u8, opts_: ?MouseEventInit) !*parser.MouseEvent {
-        const opts = opts_ orelse MouseEventInit{};
-
-        const mouse_event = try parser.mouseEventCreate();
-        parser.eventSetInternalType(@ptrCast(mouse_event), .mouse_event);
-
-        try parser.mouseEventInit(mouse_event, event_type, .{
-            .x = opts.clientX,
-            .y = opts.clientY,
-            .ctrl = opts.ctrlKey,
-            .shift = opts.shiftKey,
-            .alt = opts.altKey,
-            .meta = opts.metaKey,
-            .button = @intFromEnum(opts.button),
-        });
-
-        if (!std.mem.eql(u8, event_type, "click")) {
-            log.warn(.browser, "unsupported mouse event", .{ .event = event_type });
-        }
-
-        return mouse_event;
-    }
-
-    pub fn get_button(self: *parser.MouseEvent) u16 {
-        return self.button;
-    }
-
-    // These is just an alias for clientX.
-    pub fn get_x(self: *parser.MouseEvent) i32 {
-        return self.cx;
-    }
-
-    // These is just an alias for clientY.
-    pub fn get_y(self: *parser.MouseEvent) i32 {
-        return self.cy;
-    }
-
-    pub fn get_clientX(self: *parser.MouseEvent) i32 {
-        return self.cx;
-    }
-
-    pub fn get_clientY(self: *parser.MouseEvent) i32 {
-        return self.cy;
-    }
-
-    pub fn get_screenX(self: *parser.MouseEvent) i32 {
-        return self.sx;
-    }
-
-    pub fn get_screenY(self: *parser.MouseEvent) i32 {
-        return self.sy;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: Events.Mouse" {
-    try testing.htmlRunner("events/mouse.html");
-}
--- a/src/browser/fetch/Headers.zig
+++ b/src/browser/fetch/Headers.zig
@@ -1,225 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-const URL = @import("../../url.zig").URL;
-const Page = @import("../page.zig").Page;
-
-const iterator = @import("../iterator/iterator.zig");
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Headers
-const Headers = @This();
-
-// Case-Insensitive String HashMap.
-// This allows us to avoid having to allocate lowercase keys all the time.
-const HeaderHashMap = std.HashMapUnmanaged([]const u8, []const u8, struct {
-    pub fn hash(_: @This(), s: []const u8) u64 {
-        var buf: [64]u8 = undefined;
-        var hasher = std.hash.Wyhash.init(s.len);
-
-        var key = s;
-        while (key.len >= 64) {
-            const lower = std.ascii.lowerString(buf[0..], key[0..64]);
-            hasher.update(lower);
-            key = key[64..];
-        }
-
-        if (key.len > 0) {
-            const lower = std.ascii.lowerString(buf[0..key.len], key);
-            hasher.update(lower);
-        }
-
-        return hasher.final();
-    }
-
-    pub fn eql(_: @This(), a: []const u8, b: []const u8) bool {
-        return std.ascii.eqlIgnoreCase(a, b);
-    }
-}, 80);
-
-headers: HeaderHashMap = .empty,
-
-// They can either be:
-//
-// 1. An array of string pairs.
-// 2. An object with string keys to string values.
-// 3. Another Headers object.
-pub const HeadersInit = union(enum) {
-    // List of Pairs of []const u8
-    strings: []const [2][]const u8,
-    // Headers
-    headers: *Headers,
-    // Mappings
-    object: js.Object,
-};
-
-pub fn constructor(_init: ?HeadersInit, page: *Page) !Headers {
-    const arena = page.arena;
-    var headers: HeaderHashMap = .empty;
-
-    if (_init) |init| {
-        switch (init) {
-            .strings => |kvs| {
-                for (kvs) |pair| {
-                    const key = try arena.dupe(u8, pair[0]);
-                    const value = try arena.dupe(u8, pair[1]);
-
-                    try headers.put(arena, key, value);
-                }
-            },
-            .headers => |hdrs| {
-                var iter = hdrs.headers.iterator();
-                while (iter.next()) |entry| {
-                    try headers.put(arena, entry.key_ptr.*, entry.value_ptr.*);
-                }
-            },
-            .object => |obj| {
-                var iter = obj.nameIterator();
-                while (try iter.next()) |name_value| {
-                    const name = try name_value.toString(arena);
-                    const value = try obj.get(name);
-                    const value_string = try value.toString(arena);
-
-                    try headers.put(arena, name, value_string);
-                }
-            },
-        }
-    }
-
-    return .{
-        .headers = headers,
-    };
-}
-
-pub fn append(self: *Headers, name: []const u8, value: []const u8, allocator: std.mem.Allocator) !void {
-    const key = try allocator.dupe(u8, name);
-    const gop = try self.headers.getOrPut(allocator, key);
-
-    if (gop.found_existing) {
-        // If we found it, append the value.
-        const new_value = try std.fmt.allocPrint(allocator, "{s}, {s}", .{ gop.value_ptr.*, value });
-        gop.value_ptr.* = new_value;
-    } else {
-        // Otherwise, we should just put it in.
-        gop.value_ptr.* = try allocator.dupe(u8, value);
-    }
-}
-
-pub fn _append(self: *Headers, name: []const u8, value: []const u8, page: *Page) !void {
-    const arena = page.arena;
-    try self.append(name, value, arena);
-}
-
-pub fn _delete(self: *Headers, name: []const u8) void {
-    _ = self.headers.remove(name);
-}
-
-pub const HeadersEntryIterator = struct {
-    slot: [2][]const u8,
-    iter: HeaderHashMap.Iterator,
-
-    // TODO: these SHOULD be in lexigraphical order but I'm not sure how actually
-    // important that is.
-    pub fn _next(self: *HeadersEntryIterator) ?[2][]const u8 {
-        if (self.iter.next()) |entry| {
-            self.slot[0] = entry.key_ptr.*;
-            self.slot[1] = entry.value_ptr.*;
-            return self.slot;
-        } else {
-            return null;
-        }
-    }
-};
-
-pub fn _entries(self: *const Headers) HeadersEntryIterable {
-    return .{
-        .inner = .{
-            .slot = undefined,
-            .iter = self.headers.iterator(),
-        },
-    };
-}
-
-pub fn _forEach(self: *Headers, callback_fn: js.Function, this_arg: ?js.Object) !void {
-    var iter = self.headers.iterator();
-
-    const cb = if (this_arg) |this| try callback_fn.withThis(this) else callback_fn;
-
-    while (iter.next()) |entry| {
-        try cb.call(void, .{ entry.key_ptr.*, entry.value_ptr.*, self });
-    }
-}
-
-pub fn _get(self: *const Headers, name: []const u8) ?[]const u8 {
-    return self.headers.get(name);
-}
-
-pub fn _has(self: *const Headers, name: []const u8) bool {
-    return self.headers.contains(name);
-}
-
-pub const HeadersKeyIterator = struct {
-    iter: HeaderHashMap.KeyIterator,
-
-    pub fn _next(self: *HeadersKeyIterator) ?[]const u8 {
-        if (self.iter.next()) |key| {
-            return key.*;
-        } else {
-            return null;
-        }
-    }
-};
-
-pub fn _keys(self: *const Headers) HeadersKeyIterable {
-    return .{ .inner = .{ .iter = self.headers.keyIterator() } };
-}
-
-pub fn _set(self: *Headers, name: []const u8, value: []const u8, page: *Page) !void {
-    const arena = page.arena;
-
-    const key = try arena.dupe(u8, name);
-    const gop = try self.headers.getOrPut(arena, key);
-    gop.value_ptr.* = try arena.dupe(u8, value);
-}
-
-pub const HeadersValueIterator = struct {
-    iter: HeaderHashMap.ValueIterator,
-
-    pub fn _next(self: *HeadersValueIterator) ?[]const u8 {
-        if (self.iter.next()) |value| {
-            return value.*;
-        } else {
-            return null;
-        }
-    }
-};
-
-pub fn _values(self: *const Headers) HeadersValueIterable {
-    return .{ .inner = .{ .iter = self.headers.valueIterator() } };
-}
-
-pub const HeadersKeyIterable = iterator.Iterable(HeadersKeyIterator, "HeadersKeyIterator");
-pub const HeadersValueIterable = iterator.Iterable(HeadersValueIterator, "HeadersValueIterator");
-pub const HeadersEntryIterable = iterator.Iterable(HeadersEntryIterator, "HeadersEntryIterator");
-
-const testing = @import("../../testing.zig");
-test "fetch: Headers" {
-    try testing.htmlRunner("fetch/headers.html");
-}
--- a/src/browser/fetch/Request.zig
+++ b/src/browser/fetch/Request.zig
@@ -1,283 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-
-const URL = @import("../../url.zig").URL;
-const Page = @import("../page.zig").Page;
-
-const Response = @import("./Response.zig");
-const Http = @import("../../http/Http.zig");
-const ReadableStream = @import("../streams/ReadableStream.zig");
-
-const Headers = @import("Headers.zig");
-const HeadersInit = @import("Headers.zig").HeadersInit;
-
-pub const RequestInput = union(enum) {
-    string: []const u8,
-    request: *Request,
-};
-
-pub const RequestCache = enum {
-    default,
-    @"no-store",
-    reload,
-    @"no-cache",
-    @"force-cache",
-    @"only-if-cached",
-
-    pub fn fromString(str: []const u8) ?RequestCache {
-        for (std.enums.values(RequestCache)) |cache| {
-            if (std.ascii.eqlIgnoreCase(str, @tagName(cache))) {
-                return cache;
-            }
-        } else {
-            return null;
-        }
-    }
-
-    pub fn toString(self: RequestCache) []const u8 {
-        return @tagName(self);
-    }
-};
-
-pub const RequestCredentials = enum {
-    omit,
-    @"same-origin",
-    include,
-
-    pub fn fromString(str: []const u8) ?RequestCredentials {
-        for (std.enums.values(RequestCredentials)) |cache| {
-            if (std.ascii.eqlIgnoreCase(str, @tagName(cache))) {
-                return cache;
-            }
-        } else {
-            return null;
-        }
-    }
-
-    pub fn toString(self: RequestCredentials) []const u8 {
-        return @tagName(self);
-    }
-};
-
-pub const RequestMode = enum {
-    cors,
-    @"no-cors",
-    @"same-origin",
-    navigate,
-
-    pub fn fromString(str: []const u8) ?RequestMode {
-        for (std.enums.values(RequestMode)) |cache| {
-            if (std.ascii.eqlIgnoreCase(str, @tagName(cache))) {
-                return cache;
-            }
-        } else {
-            return null;
-        }
-    }
-
-    pub fn toString(self: RequestMode) []const u8 {
-        return @tagName(self);
-    }
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/RequestInit
-pub const RequestInit = struct {
-    body: ?[]const u8 = null,
-    cache: ?[]const u8 = null,
-    credentials: ?[]const u8 = null,
-    headers: ?HeadersInit = null,
-    integrity: ?[]const u8 = null,
-    method: ?[]const u8 = null,
-    mode: ?[]const u8 = null,
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Request/Request
-const Request = @This();
-
-method: Http.Method,
-url: [:0]const u8,
-cache: RequestCache,
-credentials: RequestCredentials,
-// no-cors is default is not built with constructor.
-mode: RequestMode = .@"no-cors",
-headers: Headers,
-body: ?[]const u8,
-body_used: bool = false,
-integrity: []const u8,
-
-pub fn constructor(input: RequestInput, _options: ?RequestInit, page: *Page) !Request {
-    const arena = page.arena;
-    const options: RequestInit = _options orelse .{};
-
-    const url: [:0]const u8 = blk: switch (input) {
-        .string => |str| {
-            break :blk try URL.stitch(arena, str, page.url.raw, .{ .null_terminated = true });
-        },
-        .request => |req| {
-            break :blk try arena.dupeZ(u8, req.url);
-        },
-    };
-
-    const cache = (if (options.cache) |cache| RequestCache.fromString(cache) else null) orelse RequestCache.default;
-    const credentials = (if (options.credentials) |creds| RequestCredentials.fromString(creds) else null) orelse RequestCredentials.@"same-origin";
-    const integrity = if (options.integrity) |integ| try arena.dupe(u8, integ) else "";
-    const headers: Headers = if (options.headers) |hdrs| try Headers.constructor(hdrs, page) else .{};
-    const mode = (if (options.mode) |mode| RequestMode.fromString(mode) else null) orelse RequestMode.cors;
-
-    const method: Http.Method = blk: {
-        if (options.method) |given_method| {
-            for (std.enums.values(Http.Method)) |method| {
-                if (std.ascii.eqlIgnoreCase(given_method, @tagName(method))) {
-                    break :blk method;
-                }
-            } else {
-                return error.TypeError;
-            }
-        } else {
-            break :blk Http.Method.GET;
-        }
-    };
-
-    // Can't have a body on .GET or .HEAD.
-    const body: ?[]const u8 = blk: {
-        if (method == .GET or method == .HEAD) {
-            break :blk null;
-        } else break :blk if (options.body) |body| try arena.dupe(u8, body) else null;
-    };
-
-    return .{
-        .method = method,
-        .url = url,
-        .cache = cache,
-        .credentials = credentials,
-        .mode = mode,
-        .headers = headers,
-        .body = body,
-        .integrity = integrity,
-    };
-}
-
-pub fn get_body(self: *const Request, page: *Page) !?*ReadableStream {
-    if (self.body) |body| {
-        const stream = try ReadableStream.constructor(null, null, page);
-        try stream.queue.append(page.arena, .{ .string = body });
-        return stream;
-    } else return null;
-}
-
-pub fn get_bodyUsed(self: *const Request) bool {
-    return self.body_used;
-}
-
-pub fn get_cache(self: *const Request) RequestCache {
-    return self.cache;
-}
-
-pub fn get_credentials(self: *const Request) RequestCredentials {
-    return self.credentials;
-}
-
-pub fn get_headers(self: *Request) *Headers {
-    return &self.headers;
-}
-
-pub fn get_integrity(self: *const Request) []const u8 {
-    return self.integrity;
-}
-
-// TODO: If we ever support the Navigation API, we need isHistoryNavigation
-// https://developer.mozilla.org/en-US/docs/Web/API/Request/isHistoryNavigation
-
-pub fn get_method(self: *const Request) []const u8 {
-    return @tagName(self.method);
-}
-
-pub fn get_mode(self: *const Request) RequestMode {
-    return self.mode;
-}
-
-pub fn get_url(self: *const Request) []const u8 {
-    return self.url;
-}
-
-pub fn _clone(self: *Request) !Request {
-    // Not allowed to clone if the body was used.
-    if (self.body_used) {
-        return error.TypeError;
-    }
-
-    // OK to just return the same fields BECAUSE
-    // all of these fields are read-only and can't be modified.
-    return Request{
-        .body = self.body,
-        .body_used = self.body_used,
-        .cache = self.cache,
-        .credentials = self.credentials,
-        .headers = self.headers,
-        .method = self.method,
-        .integrity = self.integrity,
-        .url = self.url,
-    };
-}
-
-pub fn _bytes(self: *Response, page: *Page) !js.Promise {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-    self.body_used = true;
-    return page.js.resolvePromise(self.body);
-}
-
-pub fn _json(self: *Response, page: *Page) !js.Promise {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-    self.body_used = true;
-
-    if (self.body) |body| {
-        const p = std.json.parseFromSliceLeaky(
-            std.json.Value,
-            page.call_arena,
-            body,
-            .{},
-        ) catch |e| {
-            log.info(.browser, "invalid json", .{ .err = e, .source = "Request" });
-            return error.SyntaxError;
-        };
-
-        return page.js.resolvePromise(p);
-    }
-    return page.js.resolvePromise(null);
-}
-
-pub fn _text(self: *Response, page: *Page) !js.Promise {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-    self.body_used = true;
-    return page.js.resolvePromise(self.body);
-}
-
-const testing = @import("../../testing.zig");
-test "fetch: Request" {
-    try testing.htmlRunner("fetch/request.html");
-}
--- a/src/browser/fetch/Response.zig
+++ b/src/browser/fetch/Response.zig
@@ -1,209 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-
-const HttpClient = @import("../../http/Client.zig");
-const Http = @import("../../http/Http.zig");
-const URL = @import("../../url.zig").URL;
-
-const ReadableStream = @import("../streams/ReadableStream.zig");
-const Headers = @import("Headers.zig");
-const HeadersInit = @import("Headers.zig").HeadersInit;
-
-const Mime = @import("../mime.zig").Mime;
-const Page = @import("../page.zig").Page;
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Response
-const Response = @This();
-
-status: u16 = 200,
-status_text: []const u8 = "",
-headers: Headers,
-mime: ?Mime = null,
-url: []const u8 = "",
-body: ?[]const u8 = null,
-body_used: bool = false,
-redirected: bool = false,
-type: ResponseType = .basic,
-
-const ResponseBody = union(enum) {
-    string: []const u8,
-};
-
-const ResponseOptions = struct {
-    status: u16 = 200,
-    statusText: ?[]const u8 = null,
-    headers: ?HeadersInit = null,
-};
-
-pub const ResponseType = enum {
-    basic,
-    cors,
-    @"error",
-    @"opaque",
-    opaqueredirect,
-
-    pub fn fromString(str: []const u8) ?ResponseType {
-        for (std.enums.values(ResponseType)) |cache| {
-            if (std.ascii.eqlIgnoreCase(str, @tagName(cache))) {
-                return cache;
-            }
-        } else {
-            return null;
-        }
-    }
-
-    pub fn toString(self: ResponseType) []const u8 {
-        return @tagName(self);
-    }
-};
-
-pub fn constructor(_input: ?ResponseBody, _options: ?ResponseOptions, page: *Page) !Response {
-    const arena = page.arena;
-
-    const options: ResponseOptions = _options orelse .{};
-
-    const body = blk: {
-        if (_input) |input| {
-            switch (input) {
-                .string => |str| {
-                    break :blk try arena.dupe(u8, str);
-                },
-            }
-        } else {
-            break :blk null;
-        }
-    };
-
-    const headers: Headers = if (options.headers) |hdrs| try Headers.constructor(hdrs, page) else .{};
-    const status_text = if (options.statusText) |st| try arena.dupe(u8, st) else "";
-
-    return .{
-        .body = body,
-        .headers = headers,
-        .status = options.status,
-        .status_text = status_text,
-    };
-}
-
-pub fn get_body(self: *const Response, page: *Page) !*ReadableStream {
-    const stream = try ReadableStream.constructor(null, null, page);
-    if (self.body) |body| {
-        try stream.queue.append(page.arena, .{ .string = body });
-    }
-    return stream;
-}
-
-pub fn get_bodyUsed(self: *const Response) bool {
-    return self.body_used;
-}
-
-pub fn get_headers(self: *Response) *Headers {
-    return &self.headers;
-}
-
-pub fn get_ok(self: *const Response) bool {
-    return self.status >= 200 and self.status <= 299;
-}
-
-pub fn get_redirected(self: *const Response) bool {
-    return self.redirected;
-}
-
-pub fn get_status(self: *const Response) u16 {
-    return self.status;
-}
-
-pub fn get_statusText(self: *const Response) []const u8 {
-    return self.status_text;
-}
-
-pub fn get_type(self: *const Response) ResponseType {
-    return self.type;
-}
-
-pub fn get_url(self: *const Response) []const u8 {
-    return self.url;
-}
-
-pub fn _clone(self: *const Response) !Response {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-
-    // OK to just return the same fields BECAUSE
-    // all of these fields are read-only and can't be modified.
-    return Response{
-        .body = self.body,
-        .body_used = self.body_used,
-        .mime = self.mime,
-        .headers = self.headers,
-        .redirected = self.redirected,
-        .status = self.status,
-        .url = self.url,
-        .type = self.type,
-    };
-}
-
-pub fn _bytes(self: *Response, page: *Page) !js.Promise {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-
-    self.body_used = true;
-    return page.js.resolvePromise(self.body);
-}
-
-pub fn _json(self: *Response, page: *Page) !js.Promise {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-
-    if (self.body) |body| {
-        self.body_used = true;
-        const p = std.json.parseFromSliceLeaky(
-            std.json.Value,
-            page.call_arena,
-            body,
-            .{},
-        ) catch |e| {
-            log.info(.browser, "invalid json", .{ .err = e, .source = "Response" });
-            return error.SyntaxError;
-        };
-
-        return page.js.resolvePromise(p);
-    }
-    return page.js.resolvePromise(null);
-}
-
-pub fn _text(self: *Response, page: *Page) !js.Promise {
-    if (self.body_used) {
-        return error.TypeError;
-    }
-    self.body_used = true;
-
-    return page.js.resolvePromise(self.body);
-}
-
-const testing = @import("../../testing.zig");
-test "fetch: Response" {
-    try testing.htmlRunner("fetch/response.html");
-}
--- a/src/browser/fetch/fetch.zig
+++ b/src/browser/fetch/fetch.zig
@@ -1,243 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const js = @import("../js/js.zig");
-const Page = @import("../page.zig").Page;
-
-const Http = @import("../../http/Http.zig");
-const HttpClient = @import("../../http/Client.zig");
-const Mime = @import("../mime.zig").Mime;
-
-const Headers = @import("Headers.zig");
-
-const RequestInput = @import("Request.zig").RequestInput;
-const RequestInit = @import("Request.zig").RequestInit;
-const Request = @import("Request.zig");
-const Response = @import("Response.zig");
-
-pub const Interfaces = .{
-    @import("Headers.zig"),
-    @import("Headers.zig").HeadersEntryIterable,
-    @import("Headers.zig").HeadersKeyIterable,
-    @import("Headers.zig").HeadersValueIterable,
-    @import("Request.zig"),
-    @import("Response.zig"),
-};
-
-pub const FetchContext = struct {
-    page: *Page,
-    arena: std.mem.Allocator,
-    promise_resolver: js.PersistentPromiseResolver,
-
-    method: Http.Method,
-    url: []const u8,
-    body: std.ArrayListUnmanaged(u8) = .empty,
-    headers: std.ArrayListUnmanaged([]const u8) = .empty,
-    status: u16 = 0,
-    mime: ?Mime = null,
-    mode: Request.RequestMode,
-    transfer: ?*HttpClient.Transfer = null,
-
-    /// This effectively takes ownership of the FetchContext.
-    ///
-    /// We just return the underlying slices used for `headers`
-    /// and for `body` here to avoid an allocation.
-    pub fn toResponse(self: *const FetchContext) !Response {
-        var headers: Headers = .{};
-
-        // seems to be the highest priority
-        const same_origin = try self.page.isSameOrigin(self.url);
-
-        // If the mode is "no-cors", we need to return this opaque/stripped Response.
-        // https://developer.mozilla.org/en-US/docs/Web/API/Response/type
-        if (!same_origin and self.mode == .@"no-cors") {
-            return Response{
-                .status = 0,
-                .headers = headers,
-                .mime = self.mime,
-                .body = null,
-                .url = self.url,
-                .type = .@"opaque",
-            };
-        }
-
-        // convert into Headers
-        for (self.headers.items) |hdr| {
-            var iter = std.mem.splitScalar(u8, hdr, ':');
-            const name = iter.next() orelse "";
-            const value = iter.next() orelse "";
-            try headers.append(name, value, self.arena);
-        }
-
-        const resp_type: Response.ResponseType = blk: {
-            if (same_origin or std.mem.startsWith(u8, self.url, "data:")) {
-                break :blk .basic;
-            }
-
-            break :blk switch (self.mode) {
-                .cors => .cors,
-                .@"same-origin", .navigate => .basic,
-                .@"no-cors" => unreachable,
-            };
-        };
-
-        return Response{
-            .status = self.status,
-            .headers = headers,
-            .mime = self.mime,
-            .body = self.body.items,
-            .url = self.url,
-            .type = resp_type,
-        };
-    }
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch
-pub fn fetch(input: RequestInput, options: ?RequestInit, page: *Page) !js.Promise {
-    const arena = page.arena;
-
-    const req = try Request.constructor(input, options, page);
-    var headers = try page.http_client.newHeaders();
-
-    // Copy our headers into the HTTP headers.
-    var header_iter = req.headers.headers.iterator();
-    while (header_iter.next()) |entry| {
-        const combined = try std.fmt.allocPrintSentinel(
-            page.arena,
-            "{s}: {s}",
-            .{ entry.key_ptr.*, entry.value_ptr.* },
-            0,
-        );
-        try headers.add(combined.ptr);
-    }
-
-    try page.requestCookie(.{}).headersForRequest(arena, req.url, &headers);
-
-    const resolver = try page.js.createPromiseResolver(.page);
-
-    const fetch_ctx = try arena.create(FetchContext);
-    fetch_ctx.* = .{
-        .page = page,
-        .arena = arena,
-        .promise_resolver = resolver,
-        .method = req.method,
-        .url = req.url,
-        .mode = req.mode,
-    };
-
-    try page.http_client.request(.{
-        .ctx = @ptrCast(fetch_ctx),
-        .url = req.url,
-        .method = req.method,
-        .headers = headers,
-        .body = req.body,
-        .cookie_jar = page.cookie_jar,
-        .resource_type = .fetch,
-
-        .start_callback = struct {
-            fn startCallback(transfer: *HttpClient.Transfer) !void {
-                const self: *FetchContext = @ptrCast(@alignCast(transfer.ctx));
-                log.debug(.fetch, "request start", .{ .method = self.method, .url = self.url, .source = "fetch" });
-
-                self.transfer = transfer;
-            }
-        }.startCallback,
-        .header_callback = struct {
-            fn headerCallback(transfer: *HttpClient.Transfer) !void {
-                const self: *FetchContext = @ptrCast(@alignCast(transfer.ctx));
-
-                const header = &transfer.response_header.?;
-
-                log.debug(.fetch, "request header", .{
-                    .source = "fetch",
-                    .method = self.method,
-                    .url = self.url,
-                    .status = header.status,
-                });
-
-                if (header.contentType()) |ct| {
-                    self.mime = Mime.parse(ct) catch {
-                        return error.MimeParsing;
-                    };
-                }
-
-                if (transfer.getContentLength()) |cl| {
-                    try self.body.ensureTotalCapacity(self.arena, cl);
-                }
-
-                var it = transfer.responseHeaderIterator();
-                while (it.next()) |hdr| {
-                    const joined = try std.fmt.allocPrint(self.arena, "{s}: {s}", .{ hdr.name, hdr.value });
-                    try self.headers.append(self.arena, joined);
-                }
-
-                self.status = header.status;
-            }
-        }.headerCallback,
-        .data_callback = struct {
-            fn dataCallback(transfer: *HttpClient.Transfer, data: []const u8) !void {
-                const self: *FetchContext = @ptrCast(@alignCast(transfer.ctx));
-                try self.body.appendSlice(self.arena, data);
-            }
-        }.dataCallback,
-        .done_callback = struct {
-            fn doneCallback(ctx: *anyopaque) !void {
-                const self: *FetchContext = @ptrCast(@alignCast(ctx));
-                self.transfer = null;
-
-                log.info(.fetch, "request complete", .{
-                    .source = "fetch",
-                    .method = self.method,
-                    .url = self.url,
-                    .status = self.status,
-                });
-
-                const response = try self.toResponse();
-                try self.promise_resolver.resolve(response);
-            }
-        }.doneCallback,
-        .error_callback = struct {
-            fn errorCallback(ctx: *anyopaque, err: anyerror) void {
-                const self: *FetchContext = @ptrCast(@alignCast(ctx));
-                self.transfer = null;
-
-                log.err(.fetch, "error", .{
-                    .url = self.url,
-                    .err = err,
-                    .source = "fetch error",
-                });
-
-                // We throw an Abort error when the page is getting closed so,
-                // in this case, we don't need to reject the promise.
-                if (err != error.Abort) {
-                    self.promise_resolver.reject(@errorName(err)) catch unreachable;
-                }
-            }
-        }.errorCallback,
-    });
-
-    return resolver.promise();
-}
-
-const testing = @import("../../testing.zig");
-test "fetch: fetch" {
-    try testing.htmlRunner("fetch/fetch.html");
-}
--- a/src/browser/html/AbortController.zig
+++ b/src/browser/html/AbortController.zig
@@ -1,143 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-
-pub const Interfaces = .{
-    AbortController,
-    AbortSignal,
-};
-
-const AbortController = @This();
-
-signal: *AbortSignal,
-
-pub fn constructor(page: *Page) !AbortController {
-    // Why do we allocate this rather than storing directly in the struct?
-    // https://github.com/lightpanda-io/project/discussions/165
-    const signal = try page.arena.create(AbortSignal);
-    signal.* = .init;
-
-    return .{
-        .signal = signal,
-    };
-}
-
-pub fn get_signal(self: *AbortController) *AbortSignal {
-    return self.signal;
-}
-
-pub fn _abort(self: *AbortController, reason_: ?[]const u8) !void {
-    return self.signal.abort(reason_);
-}
-
-pub const AbortSignal = struct {
-    const DEFAULT_REASON = "AbortError";
-
-    pub const prototype = *EventTarget;
-    proto: parser.EventTargetTBase = .{ .internal_target_type = .abort_signal },
-
-    aborted: bool,
-    reason: ?[]const u8,
-
-    pub const init: AbortSignal = .{
-        .reason = null,
-        .aborted = false,
-    };
-
-    pub fn static_abort(reason_: ?[]const u8) AbortSignal {
-        return .{
-            .aborted = true,
-            .reason = reason_ orelse DEFAULT_REASON,
-        };
-    }
-
-    pub fn static_timeout(delay: u32, page: *Page) !*AbortSignal {
-        const callback = try page.arena.create(TimeoutCallback);
-        callback.* = .{
-            .signal = .init,
-        };
-
-        try page.scheduler.add(callback, TimeoutCallback.run, delay, .{ .name = "abort_signal" });
-        return &callback.signal;
-    }
-
-    pub fn get_aborted(self: *const AbortSignal) bool {
-        return self.aborted;
-    }
-
-    fn abort(self: *AbortSignal, reason_: ?[]const u8) !void {
-        self.aborted = true;
-        self.reason = reason_ orelse DEFAULT_REASON;
-
-        const abort_event = try parser.eventCreate();
-        parser.eventSetInternalType(abort_event, .abort_signal);
-
-        defer parser.eventDestroy(abort_event);
-        try parser.eventInit(abort_event, "abort", .{});
-        _ = try parser.eventTargetDispatchEvent(
-            parser.toEventTarget(AbortSignal, self),
-            abort_event,
-        );
-    }
-
-    const Reason = union(enum) {
-        reason: []const u8,
-        undefined: void,
-    };
-    pub fn get_reason(self: *const AbortSignal) Reason {
-        if (self.reason) |r| {
-            return .{ .reason = r };
-        }
-        return .{ .undefined = {} };
-    }
-
-    const ThrowIfAborted = union(enum) {
-        exception: js.Exception,
-        undefined: void,
-    };
-    pub fn _throwIfAborted(self: *const AbortSignal, page: *Page) ThrowIfAborted {
-        if (self.aborted) {
-            const ex = page.js.throw(self.reason orelse DEFAULT_REASON);
-            return .{ .exception = ex };
-        }
-        return .{ .undefined = {} };
-    }
-};
-
-const TimeoutCallback = struct {
-    signal: AbortSignal,
-
-    fn run(ctx: *anyopaque) ?u32 {
-        const self: *TimeoutCallback = @ptrCast(@alignCast(ctx));
-        self.signal.abort("TimeoutError") catch |err| {
-            log.warn(.app, "abort signal timeout", .{ .err = err });
-        };
-        return null;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.AbortController" {
-    try testing.htmlRunner("html/abort_controller.html");
-}
--- a/src/browser/html/DataSet.zig
+++ b/src/browser/html/DataSet.zig
@@ -1,82 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-const std = @import("std");
-const parser = @import("../netsurf.zig");
-const js = @import("../js/js.zig");
-
-const Page = @import("../page.zig").Page;
-
-const Allocator = std.mem.Allocator;
-
-const DataSet = @This();
-
-element: *parser.Element,
-
-pub fn named_get(self: *const DataSet, name: []const u8, _: *bool, page: *Page) !js.UndefinedOr([]const u8) {
-    const normalized_name = try normalize(page.call_arena, name);
-    if (try parser.elementGetAttribute(self.element, normalized_name)) |value| {
-        return .{ .value = value };
-    }
-    return .undefined;
-}
-
-pub fn named_set(self: *DataSet, name: []const u8, value: []const u8, _: *bool, page: *Page) !void {
-    const normalized_name = try normalize(page.call_arena, name);
-    try parser.elementSetAttribute(self.element, normalized_name, value);
-}
-
-pub fn named_delete(self: *DataSet, name: []const u8, _: *bool, page: *Page) !void {
-    const normalized_name = try normalize(page.call_arena, name);
-    try parser.elementRemoveAttribute(self.element, normalized_name);
-}
-
-fn normalize(allocator: Allocator, name: []const u8) ![]const u8 {
-    var upper_count: usize = 0;
-    for (name) |c| {
-        if (std.ascii.isUpper(c)) {
-            upper_count += 1;
-        }
-    }
-    // for every upper-case letter, we'll probably need a dash before it
-    // and we need the 'data-' prefix
-    var normalized = try allocator.alloc(u8, name.len + upper_count + 5);
-
-    @memcpy(normalized[0..5], "data-");
-    if (upper_count == 0) {
-        @memcpy(normalized[5..], name);
-        return normalized;
-    }
-
-    var pos: usize = 5;
-    for (name) |c| {
-        if (std.ascii.isUpper(c)) {
-            normalized[pos] = '-';
-            pos += 1;
-            normalized[pos] = c + 32;
-        } else {
-            normalized[pos] = c;
-        }
-        pos += 1;
-    }
-    return normalized;
-}
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.DataSet" {
-    try testing.htmlRunner("html/dataset.html");
-}
--- a/src/browser/html/History.zig
+++ b/src/browser/html/History.zig
@@ -1,183 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const js = @import("../js/js.zig");
-const Page = @import("../page.zig").Page;
-const Window = @import("window.zig").Window;
-
-// https://html.spec.whatwg.org/multipage/nav-history-apis.html#the-history-interface
-const History = @This();
-
-const ScrollRestorationMode = enum {
-    pub const ENUM_JS_USE_TAG = true;
-
-    auto,
-    manual,
-};
-
-scroll_restoration: ScrollRestorationMode = .auto,
-
-pub fn get_length(_: *History, page: *Page) u32 {
-    return @intCast(page.session.navigation.entries.items.len);
-}
-
-pub fn get_scrollRestoration(self: *History) ScrollRestorationMode {
-    return self.scroll_restoration;
-}
-
-pub fn set_scrollRestoration(self: *History, mode: ScrollRestorationMode) void {
-    self.scroll_restoration = mode;
-}
-
-pub fn get_state(_: *History, page: *Page) !?js.Value {
-    if (page.session.navigation.currentEntry().state) |state| {
-        const value = try js.Value.fromJson(page.js, state);
-        return value;
-    } else {
-        return null;
-    }
-}
-
-pub fn _pushState(_: *const History, state: js.Object, _: ?[]const u8, _url: ?[]const u8, page: *Page) !void {
-    const arena = page.session.arena;
-    const url = if (_url) |u| try arena.dupe(u8, u) else try arena.dupe(u8, page.url.raw);
-
-    const json = state.toJson(arena) catch return error.DataClone;
-    _ = try page.session.navigation.pushEntry(url, json, page, true);
-}
-
-pub fn _replaceState(_: *const History, state: js.Object, _: ?[]const u8, _url: ?[]const u8, page: *Page) !void {
-    const arena = page.session.arena;
-
-    const entry = page.session.navigation.currentEntry();
-    const json = try state.toJson(arena);
-    const url = if (_url) |u| try arena.dupe(u8, u) else try arena.dupe(u8, page.url.raw);
-
-    entry.state = json;
-    entry.url = url;
-}
-
-pub fn go(_: *const History, delta: i32, page: *Page) !void {
-    // 0 behaves the same as no argument, both reloading the page.
-
-    const current = page.session.navigation.index;
-    const index_s: i64 = @intCast(@as(i64, @intCast(current)) + @as(i64, @intCast(delta)));
-    if (index_s < 0 or index_s > page.session.navigation.entries.items.len - 1) {
-        return;
-    }
-
-    const index = @as(usize, @intCast(index_s));
-    const entry = page.session.navigation.entries.items[index];
-
-    if (entry.url) |url| {
-        if (try page.isSameOrigin(url)) {
-            PopStateEvent.dispatch(entry.state, page);
-        }
-    }
-
-    _ = try page.session.navigation.navigate(entry.url, .{ .traverse = index }, page);
-}
-
-pub fn _go(self: *History, _delta: ?i32, page: *Page) !void {
-    try self.go(_delta orelse 0, page);
-}
-
-pub fn _back(self: *History, page: *Page) !void {
-    try self.go(-1, page);
-}
-
-pub fn _forward(self: *History, page: *Page) !void {
-    try self.go(1, page);
-}
-
-const parser = @import("../netsurf.zig");
-const Event = @import("../events/event.zig").Event;
-
-pub const PopStateEvent = struct {
-    pub const prototype = *Event;
-    pub const union_make_copy = true;
-
-    pub const EventInit = struct {
-        state: ?[]const u8 = null,
-    };
-
-    proto: parser.Event,
-    state: ?[]const u8,
-
-    pub fn constructor(event_type: []const u8, opts: ?EventInit) !PopStateEvent {
-        const event = try parser.eventCreate();
-        defer parser.eventDestroy(event);
-        try parser.eventInit(event, event_type, .{});
-        parser.eventSetInternalType(event, .pop_state);
-
-        const o = opts orelse EventInit{};
-
-        return .{
-            .proto = event.*,
-            .state = o.state,
-        };
-    }
-
-    // `hasUAVisualTransition` is not implemented. It isn't baseline so this is okay.
-
-    pub fn get_state(self: *const PopStateEvent, page: *Page) !?js.Value {
-        if (self.state) |state| {
-            const value = try js.Value.fromJson(page.js, state);
-            return value;
-        } else {
-            return null;
-        }
-    }
-
-    pub fn dispatch(state: ?[]const u8, page: *Page) void {
-        log.debug(.script_event, "dispatch popstate event", .{
-            .type = "popstate",
-            .source = "history",
-        });
-
-        var evt = PopStateEvent.constructor("popstate", .{ .state = state }) catch |err| {
-            log.err(.app, "event constructor error", .{
-                .err = err,
-                .type = "popstate",
-                .source = "history",
-            });
-
-            return;
-        };
-
-        _ = parser.eventTargetDispatchEvent(
-            parser.toEventTarget(Window, &page.window),
-            &evt.proto,
-        ) catch |err| {
-            log.err(.app, "dispatch popstate event error", .{
-                .err = err,
-                .type = "popstate",
-                .source = "history",
-            });
-        };
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.History" {
-    try testing.htmlRunner("html/history/history.html");
-    try testing.htmlRunner("html/history/history2.html");
-}
--- a/src/browser/html/document.zig
+++ b/src/browser/html/document.zig
@@ -1,322 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const Window = @import("window.zig").Window;
-const Element = @import("../dom/element.zig").Element;
-const ElementUnion = @import("../dom/element.zig").Union;
-const Document = @import("../dom/document.zig").Document;
-const NodeList = @import("../dom/nodelist.zig").NodeList;
-const Location = @import("location.zig").Location;
-
-const collection = @import("../dom/html_collection.zig");
-const Walker = @import("../dom/walker.zig").WalkerDepthFirst;
-const Cookie = @import("../storage/cookie.zig").Cookie;
-
-// WEB IDL https://html.spec.whatwg.org/#the-document-object
-pub const HTMLDocument = struct {
-    pub const Self = parser.DocumentHTML;
-    pub const prototype = *Document;
-    pub const subtype = .node;
-
-    // JS funcs
-    // --------
-
-    pub fn get_domain(self: *parser.DocumentHTML, page: *Page) ![]const u8 {
-        // libdom's document_html get_domain always returns null, this is
-        // the way MDN recommends getting the domain anyways, since document.domain
-        // is deprecated.
-        const location = try parser.documentHTMLGetLocation(Location, self) orelse return "";
-        return location.get_host(page);
-    }
-
-    pub fn set_domain(_: *parser.DocumentHTML, _: []const u8) ![]const u8 {
-        return error.NotImplemented;
-    }
-
-    pub fn get_referrer(self: *parser.DocumentHTML) ![]const u8 {
-        return try parser.documentHTMLGetReferrer(self);
-    }
-
-    pub fn set_referrer(_: *parser.DocumentHTML, _: []const u8) ![]const u8 {
-        return error.NotImplemented;
-    }
-
-    pub fn get_body(self: *parser.DocumentHTML) !?*parser.Body {
-        return try parser.documentHTMLBody(self);
-    }
-
-    pub fn set_body(self: *parser.DocumentHTML, elt: ?*parser.ElementHTML) !?*parser.Body {
-        try parser.documentHTMLSetBody(self, elt);
-        return try get_body(self);
-    }
-
-    pub fn get_head(self: *parser.DocumentHTML) !?*parser.Head {
-        const root = parser.documentHTMLToNode(self);
-        const walker = Walker{};
-        var next: ?*parser.Node = null;
-        while (true) {
-            next = try walker.get_next(root, next) orelse return null;
-            if (std.ascii.eqlIgnoreCase("head", try parser.nodeName(next.?))) {
-                return @as(*parser.Head, @ptrCast(next.?));
-            }
-        }
-    }
-
-    pub fn get_cookie(_: *parser.DocumentHTML, page: *Page) ![]const u8 {
-        var buf: std.ArrayListUnmanaged(u8) = .{};
-        try page.cookie_jar.forRequest(&page.url.uri, buf.writer(page.arena), .{
-            .is_http = false,
-            .is_navigation = true,
-        });
-        return buf.items;
-    }
-
-    pub fn set_cookie(_: *parser.DocumentHTML, cookie_str: []const u8, page: *Page) ![]const u8 {
-        // we use the cookie jar's allocator to parse the cookie because it
-        // outlives the page's arena.
-        const c = try Cookie.parse(page.cookie_jar.allocator, &page.url.uri, cookie_str);
-        errdefer c.deinit();
-        if (c.http_only) {
-            c.deinit();
-            return ""; // HttpOnly cookies cannot be set from JS
-        }
-        try page.cookie_jar.add(c, std.time.timestamp());
-        return cookie_str;
-    }
-
-    pub fn get_title(self: *parser.DocumentHTML) ![]const u8 {
-        return try parser.documentHTMLGetTitle(self);
-    }
-
-    pub fn set_title(self: *parser.DocumentHTML, v: []const u8) ![]const u8 {
-        try parser.documentHTMLSetTitle(self, v);
-        return v;
-    }
-
-    pub fn _getElementsByName(self: *parser.DocumentHTML, name: []const u8, page: *Page) !NodeList {
-        var list: NodeList = .{};
-
-        if (name.len == 0) {
-            return list;
-        }
-
-        const root = parser.documentHTMLToNode(self);
-        var c = try collection.HTMLCollectionByName(root, name, .{
-            .include_root = false,
-        });
-
-        const ln = try c.get_length();
-        try list.ensureTotalCapacity(page.arena, ln);
-
-        var i: u32 = 0;
-        while (i < ln) : (i += 1) {
-            const n = try c.item(i) orelse break;
-            list.appendAssumeCapacity(n);
-        }
-
-        return list;
-    }
-
-    pub fn get_images(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionByTagName(parser.documentHTMLToNode(self), "img", .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_embeds(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionByTagName(parser.documentHTMLToNode(self), "embed", .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_plugins(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return get_embeds(self);
-    }
-
-    pub fn get_forms(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionByTagName(parser.documentHTMLToNode(self), "form", .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_scripts(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionByTagName(parser.documentHTMLToNode(self), "script", .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_applets(_: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionEmpty();
-    }
-
-    pub fn get_links(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionByLinks(parser.documentHTMLToNode(self), .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_anchors(self: *parser.DocumentHTML) collection.HTMLCollection {
-        return collection.HTMLCollectionByAnchors(parser.documentHTMLToNode(self), .{
-            .include_root = false,
-        });
-    }
-
-    pub fn get_all(self: *parser.DocumentHTML) collection.HTMLAllCollection {
-        return collection.HTMLAllCollection.init(parser.documentHTMLToNode(self));
-    }
-
-    pub fn get_currentScript(self: *parser.DocumentHTML) !?*parser.Script {
-        return try parser.documentHTMLGetCurrentScript(self);
-    }
-
-    pub fn get_location(self: *parser.DocumentHTML) !?*Location {
-        return try parser.documentHTMLGetLocation(Location, self);
-    }
-
-    pub fn set_location(_: *const parser.DocumentHTML, url: []const u8, page: *Page) !void {
-        return page.navigateFromWebAPI(url, .{ .reason = .script }, .{ .push = null });
-    }
-
-    pub fn get_designMode(_: *parser.DocumentHTML) []const u8 {
-        return "off";
-    }
-
-    pub fn set_designMode(_: *parser.DocumentHTML, _: []const u8) []const u8 {
-        return "off";
-    }
-
-    pub fn get_defaultView(_: *parser.DocumentHTML, page: *Page) *Window {
-        return &page.window;
-    }
-
-    pub fn get_readyState(self: *parser.DocumentHTML, page: *Page) ![]const u8 {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        return @tagName(state.ready_state);
-    }
-
-    // noop legacy functions
-    // https://html.spec.whatwg.org/#Document-partial
-    pub fn _clear(_: *parser.DocumentHTML) void {}
-    pub fn _captureEvents(_: *parser.DocumentHTML) void {}
-    pub fn _releaseEvents(_: *parser.DocumentHTML) void {}
-
-    pub fn get_fgColor(_: *parser.DocumentHTML) []const u8 {
-        return "";
-    }
-    pub fn set_fgColor(_: *parser.DocumentHTML, _: []const u8) []const u8 {
-        return "";
-    }
-    pub fn get_linkColor(_: *parser.DocumentHTML) []const u8 {
-        return "";
-    }
-    pub fn set_linkColor(_: *parser.DocumentHTML, _: []const u8) []const u8 {
-        return "";
-    }
-    pub fn get_vlinkColor(_: *parser.DocumentHTML) []const u8 {
-        return "";
-    }
-    pub fn set_vlinkColor(_: *parser.DocumentHTML, _: []const u8) []const u8 {
-        return "";
-    }
-    pub fn get_alinkColor(_: *parser.DocumentHTML) []const u8 {
-        return "";
-    }
-    pub fn set_alinkColor(_: *parser.DocumentHTML, _: []const u8) []const u8 {
-        return "";
-    }
-    pub fn get_bgColor(_: *parser.DocumentHTML) []const u8 {
-        return "";
-    }
-    pub fn set_bgColor(_: *parser.DocumentHTML, _: []const u8) []const u8 {
-        return "";
-    }
-
-    // Returns the topmost Element at the specified coordinates (relative to the viewport).
-    // Since LightPanda requires the client to know what they are clicking on we do not return the underlying element at this moment
-    // This can currenty only happen if the first pixel is clicked without having rendered any element. This will change when css properties are supported.
-    // This returns an ElementUnion instead of a *Parser.Element in case the element somehow hasn't passed through the js runtime yet.
-    // While x and y should be f32, here we take i32 since that's what our
-    // "renderer" uses. By specifying i32 here, rather than f32 and doing the
-    // conversion ourself, we rely on v8's type conversion which is both more
-    // flexible (e.g. handles NaN) and will be more consistent with a browser.
-    pub fn _elementFromPoint(_: *parser.DocumentHTML, x: i32, y: i32, page: *Page) !?ElementUnion {
-        const element = page.renderer.getElementAtPosition(x, y) orelse return null;
-        // TODO if pointer-events set to none the underlying element should be returned (parser.documentGetDocumentElement(self.document);?)
-        return try Element.toInterface(element);
-    }
-
-    // Returns an array of all elements at the specified coordinates (relative to the viewport). The elements are ordered from the topmost to the bottommost box of the viewport.
-    // While x and y should be f32, here we take i32 since that's what our
-    // "renderer" uses. By specifying i32 here, rather than f32 and doing the
-    // conversion ourself, we rely on v8's type conversion which is both more
-    // flexible (e.g. handles NaN) and will be more consistent with a browser.
-    pub fn _elementsFromPoint(_: *parser.DocumentHTML, x: i32, y: i32, page: *Page) ![]ElementUnion {
-        const element = page.renderer.getElementAtPosition(x, y) orelse return &.{};
-        // TODO if pointer-events set to none the underlying element should be returned (parser.documentGetDocumentElement(self.document);?)
-
-        var list: std.ArrayListUnmanaged(ElementUnion) = .empty;
-        try list.ensureTotalCapacity(page.call_arena, 3);
-        list.appendAssumeCapacity(try Element.toInterface(element));
-
-        // Since we are using a flat renderer there is no hierarchy of elements. What we do know is that the element is part of the main document.
-        // Thus we can add the HtmlHtmlElement and it's child HTMLBodyElement to the returned list.
-        // TBD Should we instead return every parent that is an element? Note that a child does not physically need to be overlapping the parent.
-        // Should we do a render pass on demand?
-        const doc_elem = try parser.documentGetDocumentElement(parser.documentHTMLToDocument(page.window.document)) orelse {
-            return list.items;
-        };
-        if (try parser.documentHTMLBody(page.window.document)) |body| {
-            list.appendAssumeCapacity(try Element.toInterface(parser.bodyToElement(body)));
-        }
-        list.appendAssumeCapacity(try Element.toInterface(doc_elem));
-        return list.items;
-    }
-
-    pub fn documentIsLoaded(self: *parser.DocumentHTML, page: *Page) !void {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        state.ready_state = .interactive;
-
-        log.debug(.script_event, "dispatch event", .{
-            .type = "DOMContentLoaded",
-            .source = "document",
-        });
-
-        const evt = try parser.eventCreate();
-        defer parser.eventDestroy(evt);
-        try parser.eventInit(evt, "DOMContentLoaded", .{ .bubbles = true, .cancelable = true });
-        _ = try parser.eventTargetDispatchEvent(parser.toEventTarget(parser.DocumentHTML, self), evt);
-
-        try page.window.dispatchForDocumentTarget(evt);
-    }
-
-    pub fn documentIsComplete(self: *parser.DocumentHTML, page: *Page) !void {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
-        state.ready_state = .complete;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.Document" {
-    try testing.htmlRunner("html/document.html");
-}
--- a/src/browser/html/elements.zig
+++ b/src/browser/html/elements.zig
--- a/src/browser/html/error_event.zig
+++ b/src/browser/html/error_event.zig
@@ -1,86 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-
-// https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
-pub const ErrorEvent = struct {
-    pub const prototype = *parser.Event;
-    pub const union_make_copy = true;
-
-    proto: parser.Event,
-    message: []const u8,
-    filename: []const u8,
-    lineno: i32,
-    colno: i32,
-    @"error": ?js.Object,
-
-    const ErrorEventInit = struct {
-        message: []const u8 = "",
-        filename: []const u8 = "",
-        lineno: i32 = 0,
-        colno: i32 = 0,
-        @"error": ?js.Object = null,
-    };
-
-    pub fn constructor(event_type: []const u8, opts: ?ErrorEventInit) !ErrorEvent {
-        const event = try parser.eventCreate();
-        defer parser.eventDestroy(event);
-        try parser.eventInit(event, event_type, .{});
-        parser.eventSetInternalType(event, .event);
-
-        const o = opts orelse ErrorEventInit{};
-
-        return .{
-            .proto = event.*,
-            .message = o.message,
-            .filename = o.filename,
-            .lineno = o.lineno,
-            .colno = o.colno,
-            .@"error" = if (o.@"error") |e| try e.persist() else null,
-        };
-    }
-
-    pub fn get_message(self: *const ErrorEvent) []const u8 {
-        return self.message;
-    }
-
-    pub fn get_filename(self: *const ErrorEvent) []const u8 {
-        return self.filename;
-    }
-
-    pub fn get_lineno(self: *const ErrorEvent) i32 {
-        return self.lineno;
-    }
-
-    pub fn get_colno(self: *const ErrorEvent) i32 {
-        return self.colno;
-    }
-
-    pub fn get_error(self: *const ErrorEvent) js.UndefinedOr(js.Object) {
-        if (self.@"error") |e| {
-            return .{ .value = e };
-        }
-        return .undefined;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.ErrorEvent" {
-    try testing.htmlRunner("html/error_event.html");
-}
--- a/src/browser/html/form.zig
+++ b/src/browser/html/form.zig
@@ -1,37 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-const HTMLElement = @import("elements.zig").HTMLElement;
-
-pub const HTMLFormElement = struct {
-    pub const Self = parser.Form;
-    pub const prototype = *HTMLElement;
-    pub const subtype = .node;
-
-    pub fn _submit(self: *parser.Form, page: *Page) !void {
-        return page.submitForm(self, null);
-    }
-
-    pub fn _reset(self: *parser.Form) !void {
-        try parser.formElementReset(self);
-    }
-};
--- a/src/browser/html/html.zig
+++ b/src/browser/html/html.zig
@@ -1,43 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const HTMLDocument = @import("document.zig").HTMLDocument;
-const HTMLElem = @import("elements.zig");
-const SVGElem = @import("svg_elements.zig");
-const Window = @import("window.zig").Window;
-const Navigator = @import("navigator.zig").Navigator;
-const History = @import("History.zig");
-const Location = @import("location.zig").Location;
-const MediaQueryList = @import("media_query_list.zig").MediaQueryList;
-
-pub const Interfaces = .{
-    HTMLDocument,
-    HTMLElem.HTMLElement,
-    HTMLElem.HTMLMediaElement,
-    HTMLElem.Interfaces,
-    SVGElem.SVGElement,
-    Window,
-    Navigator,
-    History,
-    Location,
-    MediaQueryList,
-    @import("DataSet.zig"),
-    @import("screen.zig").Interfaces,
-    @import("error_event.zig").ErrorEvent,
-    @import("AbortController.zig").Interfaces,
-};
--- a/src/browser/html/iframe.zig
+++ b/src/browser/html/iframe.zig
@@ -1,28 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-const HTMLElement = @import("elements.zig").HTMLElement;
-
-// https://html.spec.whatwg.org/multipage/iframe-embed-object.html#htmliframeelement
-pub const HTMLIFrameElement = struct {
-    pub const Self = parser.IFrame;
-    pub const prototype = *HTMLElement;
-    pub const subtype = .node;
-};
--- a/src/browser/html/location.zig
+++ b/src/browser/html/location.zig
@@ -1,96 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const Uri = @import("std").Uri;
-
-const Page = @import("../page.zig").Page;
-const URL = @import("../url/url.zig").URL;
-
-// https://html.spec.whatwg.org/multipage/nav-history-apis.html#the-location-interface
-pub const Location = struct {
-    url: URL,
-
-    /// Browsers give such initial values when user not navigated yet:
-    /// Chrome  -> chrome://new-tab-page/
-    /// Firefox -> about:newtab
-    /// Safari  -> favorites://
-    pub const default = Location{
-        .url = .initWithoutSearchParams(Uri.parse("about:blank") catch unreachable),
-    };
-
-    pub fn get_href(self: *Location, page: *Page) ![]const u8 {
-        return self.url.get_href(page);
-    }
-
-    pub fn set_href(_: *const Location, href: []const u8, page: *Page) !void {
-        return page.navigateFromWebAPI(href, .{ .reason = .script }, .{ .push = null });
-    }
-
-    pub fn get_protocol(self: *Location) []const u8 {
-        return self.url.get_protocol();
-    }
-
-    pub fn get_host(self: *Location, page: *Page) ![]const u8 {
-        return self.url.get_host(page);
-    }
-
-    pub fn get_hostname(self: *Location) []const u8 {
-        return self.url.get_hostname();
-    }
-
-    pub fn get_port(self: *Location, page: *Page) ![]const u8 {
-        return self.url.get_port(page);
-    }
-
-    pub fn get_pathname(self: *Location) []const u8 {
-        return self.url.get_pathname();
-    }
-
-    pub fn get_search(self: *Location, page: *Page) ![]const u8 {
-        return self.url.get_search(page);
-    }
-
-    pub fn get_hash(self: *Location, page: *Page) ![]const u8 {
-        return self.url.get_hash(page);
-    }
-
-    pub fn get_origin(self: *Location, page: *Page) ![]const u8 {
-        return self.url.get_origin(page);
-    }
-
-    pub fn _assign(_: *const Location, url: []const u8, page: *Page) !void {
-        return page.navigateFromWebAPI(url, .{ .reason = .script }, .{ .push = null });
-    }
-
-    pub fn _replace(_: *const Location, url: []const u8, page: *Page) !void {
-        return page.navigateFromWebAPI(url, .{ .reason = .script }, .replace);
-    }
-
-    pub fn _reload(_: *const Location, page: *Page) !void {
-        return page.navigateFromWebAPI(page.url.raw, .{ .reason = .script }, .reload);
-    }
-
-    pub fn _toString(self: *Location, page: *Page) ![]const u8 {
-        return try self.get_href(page);
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.Location" {
-    try testing.htmlRunner("html/location.html");
-}
--- a/src/browser/html/media_query_list.zig
+++ b/src/browser/html/media_query_list.zig
@@ -1,45 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const js = @import("../js/js.zig");
-const parser = @import("../netsurf.zig");
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-
-// https://drafts.csswg.org/cssom-view/#the-mediaquerylist-interface
-pub const MediaQueryList = struct {
-    pub const prototype = *EventTarget;
-
-    // Extend libdom event target for pure zig struct.
-    // This is not safe as it relies on a structure layout that isn't guaranteed
-    base: parser.EventTargetTBase = parser.EventTargetTBase{ .internal_target_type = .media_query_list },
-
-    matches: bool,
-    media: []const u8,
-
-    pub fn get_matches(self: *const MediaQueryList) bool {
-        return self.matches;
-    }
-
-    pub fn get_media(self: *const MediaQueryList) []const u8 {
-        return self.media;
-    }
-
-    pub fn _addListener(_: *const MediaQueryList, _: js.Function) void {}
-
-    pub fn _removeListener(_: *const MediaQueryList, _: js.Function) void {}
-};
--- a/src/browser/html/navigator.zig
+++ b/src/browser/html/navigator.zig
@@ -1,86 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const builtin = @import("builtin");
-
-// https://html.spec.whatwg.org/multipage/system-state.html#navigator
-pub const Navigator = struct {
-    agent: []const u8 = "Lightpanda/1.0",
-    version: []const u8 = "1.0",
-    vendor: []const u8 = "",
-    platform: []const u8 = std.fmt.comptimePrint("{any} {any}", .{ builtin.os.tag, builtin.cpu.arch }),
-
-    language: []const u8 = "en-US",
-
-    pub fn get_userAgent(self: *Navigator) []const u8 {
-        return self.agent;
-    }
-    pub fn get_appCodeName(_: *Navigator) []const u8 {
-        return "Mozilla";
-    }
-    pub fn get_appName(_: *Navigator) []const u8 {
-        return "Netscape";
-    }
-    pub fn get_appVersion(self: *Navigator) []const u8 {
-        return self.version;
-    }
-    pub fn get_platform(self: *Navigator) []const u8 {
-        return self.platform;
-    }
-    pub fn get_product(_: *Navigator) []const u8 {
-        return "Gecko";
-    }
-    pub fn get_productSub(_: *Navigator) []const u8 {
-        return "20030107";
-    }
-    pub fn get_vendor(self: *Navigator) []const u8 {
-        return self.vendor;
-    }
-    pub fn get_vendorSub(_: *Navigator) []const u8 {
-        return "";
-    }
-    pub fn get_language(self: *Navigator) []const u8 {
-        return self.language;
-    }
-    // TODO wait for arrays.
-    //pub fn get_languages(self: *Navigator) [][]const u8 {
-    //    return .{self.language};
-    //}
-    pub fn get_online(_: *Navigator) bool {
-        return true;
-    }
-    pub fn _registerProtocolHandler(_: *Navigator, scheme: []const u8, url: []const u8) void {
-        _ = scheme;
-        _ = url;
-    }
-    pub fn _unregisterProtocolHandler(_: *Navigator, scheme: []const u8, url: []const u8) void {
-        _ = scheme;
-        _ = url;
-    }
-
-    pub fn get_cookieEnabled(_: *Navigator) bool {
-        return true;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.Navigator" {
-    try testing.htmlRunner("html/navigator.html");
-}
--- a/src/browser/html/screen.zig
+++ b/src/browser/html/screen.zig
@@ -1,103 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-
-pub const Interfaces = .{
-    Screen,
-    ScreenOrientation,
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/Screen
-pub const Screen = struct {
-    pub const prototype = *EventTarget;
-
-    proto: parser.EventTargetTBase = .{ .internal_target_type = .screen },
-
-    height: u32 = 1080,
-    width: u32 = 1920,
-    // https://developer.mozilla.org/en-US/docs/Web/API/Screen/colorDepth
-    color_depth: u32 = 8,
-    // https://developer.mozilla.org/en-US/docs/Web/API/Screen/pixelDepth
-    pixel_depth: u32 = 8,
-    orientation: ScreenOrientation = .{ .type = .landscape_primary },
-
-    pub fn get_availHeight(self: *const Screen) u32 {
-        return self.height;
-    }
-
-    pub fn get_availWidth(self: *const Screen) u32 {
-        return self.width;
-    }
-
-    pub fn get_height(self: *const Screen) u32 {
-        return self.height;
-    }
-
-    pub fn get_width(self: *const Screen) u32 {
-        return self.width;
-    }
-
-    pub fn get_pixelDepth(self: *const Screen) u32 {
-        return self.pixel_depth;
-    }
-
-    pub fn get_orientation(self: *const Screen) ScreenOrientation {
-        return self.orientation;
-    }
-};
-
-const ScreenOrientationType = enum {
-    portrait_primary,
-    portrait_secondary,
-    landscape_primary,
-    landscape_secondary,
-
-    pub fn toString(self: ScreenOrientationType) []const u8 {
-        return switch (self) {
-            .portrait_primary => "portrait-primary",
-            .portrait_secondary => "portrait-secondary",
-            .landscape_primary => "landscape-primary",
-            .landscape_secondary => "landscape-secondary",
-        };
-    }
-};
-
-pub const ScreenOrientation = struct {
-    pub const prototype = *EventTarget;
-
-    angle: u32 = 0,
-    type: ScreenOrientationType,
-    proto: parser.EventTargetTBase = .{ .internal_target_type = .screen_orientation },
-
-    pub fn get_angle(self: *const ScreenOrientation) u32 {
-        return self.angle;
-    }
-
-    pub fn get_type(self: *const ScreenOrientation) []const u8 {
-        return self.type.toString();
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.Screen" {
-    try testing.htmlRunner("html/screen.html");
-}
--- a/src/browser/html/select.zig
+++ b/src/browser/html/select.zig
@@ -1,204 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-const std = @import("std");
-
-const parser = @import("../netsurf.zig");
-const collection = @import("../dom/html_collection.zig");
-
-const Page = @import("../page.zig").Page;
-const HTMLElement = @import("elements.zig").HTMLElement;
-
-pub const Interfaces = .{
-    HTMLSelectElement,
-    HTMLOptionElement,
-    HTMLOptionsCollection,
-};
-
-pub const HTMLSelectElement = struct {
-    pub const Self = parser.Select;
-    pub const prototype = *HTMLElement;
-    pub const subtype = .node;
-
-    pub fn get_length(select: *parser.Select) !u32 {
-        return parser.selectGetLength(select);
-    }
-
-    pub fn get_form(select: *parser.Select) !?*parser.Form {
-        return parser.selectGetForm(select);
-    }
-
-    pub fn get_name(select: *parser.Select) ![]const u8 {
-        return parser.selectGetName(select);
-    }
-    pub fn set_name(select: *parser.Select, name: []const u8) !void {
-        return parser.selectSetName(select, name);
-    }
-
-    pub fn get_disabled(select: *parser.Select) !bool {
-        return parser.selectGetDisabled(select);
-    }
-    pub fn set_disabled(select: *parser.Select, disabled: bool) !void {
-        return parser.selectSetDisabled(select, disabled);
-    }
-
-    pub fn get_multiple(select: *parser.Select) !bool {
-        return parser.selectGetMultiple(select);
-    }
-    pub fn set_multiple(select: *parser.Select, multiple: bool) !void {
-        return parser.selectSetMultiple(select, multiple);
-    }
-
-    pub fn get_selectedIndex(select: *parser.Select, page: *Page) !i32 {
-        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(select)));
-        const selected_index = try parser.selectGetSelectedIndex(select);
-
-        // See the explicit_index_set field documentation
-        if (!state.explicit_index_set) {
-            if (selected_index == -1) {
-                if (try parser.selectGetMultiple(select) == false) {
-                    if (try get_length(select) > 0) {
-                        return 0;
-                    }
-                }
-            }
-        }
-        return selected_index;
-    }
-
-    // Libdom's dom_html_select_select_set_selected_index will crash if index
-    // is out of range, and it doesn't properly unset options
-    pub fn set_selectedIndex(select: *parser.Select, index: i32, page: *Page) !void {
-        var state = try page.getOrCreateNodeState(@ptrCast(@alignCast(select)));
-        state.explicit_index_set = true;
-
-        const options = try parser.selectGetOptions(select);
-        const len = try parser.optionCollectionGetLength(options);
-        for (0..len) |i| {
-            const option = try parser.optionCollectionItem(options, @intCast(i));
-            try parser.optionSetSelected(option, false);
-        }
-        if (index >= 0 and index < try get_length(select)) {
-            const option = try parser.optionCollectionItem(options, @intCast(index));
-            try parser.optionSetSelected(option, true);
-        }
-    }
-
-    pub fn get_options(select: *parser.Select) HTMLOptionsCollection {
-        return .{
-            .select = select,
-            .proto = collection.HTMLCollectionChildren(@ptrCast(@alignCast(select)), .{
-                .mutable = true,
-                .include_root = false,
-            }),
-        };
-    }
-};
-
-pub const HTMLOptionElement = struct {
-    pub const Self = parser.Option;
-    pub const prototype = *HTMLElement;
-    pub const subtype = .node;
-
-    pub fn get_value(self: *parser.Option) ![]const u8 {
-        return parser.optionGetValue(self);
-    }
-    pub fn set_value(self: *parser.Option, value: []const u8) !void {
-        return parser.optionSetValue(self, value);
-    }
-
-    pub fn get_label(self: *parser.Option) ![]const u8 {
-        return parser.optionGetLabel(self);
-    }
-    pub fn set_label(self: *parser.Option, label: []const u8) !void {
-        return parser.optionSetLabel(self, label);
-    }
-
-    pub fn get_selected(self: *parser.Option) !bool {
-        return parser.optionGetSelected(self);
-    }
-    pub fn set_selected(self: *parser.Option, value: bool) !void {
-        return parser.optionSetSelected(self, value);
-    }
-
-    pub fn get_disabled(self: *parser.Option) !bool {
-        return parser.optionGetDisabled(self);
-    }
-    pub fn set_disabled(self: *parser.Option, value: bool) !void {
-        return parser.optionSetDisabled(self, value);
-    }
-
-    pub fn get_text(self: *parser.Option) ![]const u8 {
-        return parser.optionGetText(self);
-    }
-
-    pub fn get_form(self: *parser.Option) !?*parser.Form {
-        return parser.optionGetForm(self);
-    }
-};
-
-pub const HTMLOptionsCollection = struct {
-    pub const prototype = *collection.HTMLCollection;
-
-    proto: collection.HTMLCollection,
-    select: *parser.Select,
-
-    pub fn get_selectedIndex(self: *HTMLOptionsCollection, page: *Page) !i32 {
-        return HTMLSelectElement.get_selectedIndex(self.select, page);
-    }
-
-    pub fn set_selectedIndex(self: *HTMLOptionsCollection, index: i32, page: *Page) !void {
-        return HTMLSelectElement.set_selectedIndex(self.select, index, page);
-    }
-
-    const BeforeOpts = union(enum) {
-        index: u32,
-        option: *parser.Option,
-    };
-    pub fn _add(self: *HTMLOptionsCollection, option: *parser.Option, before_: ?BeforeOpts) !void {
-        const Node = @import("../dom/node.zig").Node;
-        const before = before_ orelse {
-            return self.appendOption(option);
-        };
-
-        const insert_before: *parser.Node = switch (before) {
-            .option => |o| @ptrCast(@alignCast(o)),
-            .index => |i| (try self.proto.item(i)) orelse return self.appendOption(option),
-        };
-        return Node.before(insert_before, &.{
-            .{ .node = @ptrCast(@alignCast(option)) },
-        });
-    }
-
-    pub fn _remove(self: *HTMLOptionsCollection, index: u32) !void {
-        const Node = @import("../dom/node.zig").Node;
-        const option = (try self.proto.item(index)) orelse return;
-        _ = try Node._removeChild(@ptrCast(@alignCast(self.select)), option);
-    }
-
-    fn appendOption(self: *HTMLOptionsCollection, option: *parser.Option) !void {
-        const Node = @import("../dom/node.zig").Node;
-        return Node.append(@ptrCast(@alignCast(self.select)), &.{
-            .{ .node = @ptrCast(@alignCast(option)) },
-        });
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.Select" {
-    try testing.htmlRunner("html/select.html");
-}
--- a/src/browser/html/svg_elements.zig
+++ b/src/browser/html/svg_elements.zig
@@ -1,36 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const Element = @import("../dom/element.zig").Element;
-
-// Support for SVGElements is very limited, this is a dummy implementation.
-// This is here no to be able to support `element instanceof SVGElement;` in JavaScript.
-// https://developer.mozilla.org/en-US/docs/Web/API/SVGElement
-pub const SVGElement = struct {
-    // Currently the prototype chain is not implemented (will not be returned by toInterface())
-    // For that we need parser.SvgElement and the derived types with tags in the v-table.
-    pub const prototype = *Element;
-    // While this is a Node, could consider not exposing the subtype untill we have
-    // a Self type to cast to.
-    pub const subtype = .node;
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: HTML.SVGElement" {
-    try testing.htmlRunner("html/svg.html");
-}
--- a/src/browser/html/window.zig
+++ b/src/browser/html/window.zig
@@ -1,491 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const js = @import("../js/js.zig");
-const log = @import("../../log.zig");
-const parser = @import("../netsurf.zig");
-const Page = @import("../page.zig").Page;
-
-const Navigator = @import("navigator.zig").Navigator;
-const History = @import("History.zig");
-const Navigation = @import("../navigation/Navigation.zig");
-const Location = @import("location.zig").Location;
-const Crypto = @import("../crypto/crypto.zig").Crypto;
-const Console = @import("../console/console.zig").Console;
-const EventTarget = @import("../dom/event_target.zig").EventTarget;
-const MediaQueryList = @import("media_query_list.zig").MediaQueryList;
-const Performance = @import("../dom/performance.zig").Performance;
-const CSSStyleDeclaration = @import("../cssom/CSSStyleDeclaration.zig");
-const Screen = @import("screen.zig").Screen;
-const domcss = @import("../dom/css.zig");
-const Css = @import("../css/css.zig").Css;
-const EventHandler = @import("../events/event.zig").EventHandler;
-
-const Request = @import("../fetch/Request.zig");
-const fetchFn = @import("../fetch/fetch.zig").fetch;
-
-const storage = @import("../storage/storage.zig");
-
-const DirectEventHandler = @import("../events/event.zig").DirectEventHandler;
-
-// https://dom.spec.whatwg.org/#interface-window-extensions
-// https://html.spec.whatwg.org/multipage/nav-history-apis.html#window
-pub const Window = struct {
-    pub const prototype = *EventTarget;
-
-    // Extend libdom event target for pure zig struct.
-    base: parser.EventTargetTBase = parser.EventTargetTBase{ .internal_target_type = .window },
-
-    document: *parser.DocumentHTML,
-    target: []const u8 = "",
-    location: Location = .default,
-    storage_shelf: ?*storage.Shelf = null,
-
-    // counter for having unique timer ids
-    timer_id: u30 = 0,
-    timers: std.AutoHashMapUnmanaged(u32, void) = .{},
-
-    crypto: Crypto = .{},
-    console: Console = .{},
-    navigator: Navigator = .{},
-    performance: Performance,
-    screen: Screen = .{},
-    css: Css = .{},
-    scroll_x: u32 = 0,
-    scroll_y: u32 = 0,
-    onload_callback: ?js.Function = null,
-    onpopstate_callback: ?js.Function = null,
-
-    pub fn create(target: ?[]const u8, navigator: ?Navigator) !Window {
-        var fbs = std.io.fixedBufferStream("");
-        const html_doc = try parser.documentHTMLParse(fbs.reader(), "utf-8");
-        const doc = parser.documentHTMLToDocument(html_doc);
-        try parser.documentSetDocumentURI(doc, "about:blank");
-
-        return .{
-            .document = html_doc,
-            .target = target orelse "",
-            .navigator = navigator orelse .{},
-            .performance = Performance.init(),
-        };
-    }
-
-    pub fn replaceLocation(self: *Window, loc: Location) !void {
-        self.location = loc;
-        try parser.documentHTMLSetLocation(Location, self.document, &self.location);
-    }
-
-    pub fn replaceDocument(self: *Window, doc: *parser.DocumentHTML) !void {
-        self.performance.reset(); // When to reset see: https://developer.mozilla.org/en-US/docs/Web/API/Performance/timeOrigin
-        self.document = doc;
-        try parser.documentHTMLSetLocation(Location, doc, &self.location);
-    }
-
-    pub fn setStorageShelf(self: *Window, shelf: *storage.Shelf) void {
-        self.storage_shelf = shelf;
-    }
-
-    pub fn _fetch(_: *Window, input: Request.RequestInput, options: ?Request.RequestInit, page: *Page) !js.Promise {
-        return fetchFn(input, options, page);
-    }
-
-    /// Returns `onload_callback`.
-    pub fn get_onload(self: *const Window) ?js.Function {
-        return self.onload_callback;
-    }
-
-    /// Sets `onload_callback`.
-    pub fn set_onload(self: *Window, maybe_listener: ?EventHandler.Listener, page: *Page) !void {
-        try DirectEventHandler(Window, self, "load", maybe_listener, &self.onload_callback, page.arena);
-    }
-
-    /// Returns `onpopstate_callback`.
-    pub fn get_onpopstate(self: *const Window) ?js.Function {
-        return self.onpopstate_callback;
-    }
-
-    /// Sets `onpopstate_callback`.
-    pub fn set_onpopstate(self: *Window, maybe_listener: ?EventHandler.Listener, page: *Page) !void {
-        try DirectEventHandler(Window, self, "popstate", maybe_listener, &self.onpopstate_callback, page.arena);
-    }
-
-    pub fn get_location(self: *Window) *Location {
-        return &self.location;
-    }
-
-    pub fn set_location(_: *const Window, url: []const u8, page: *Page) !void {
-        return page.navigateFromWebAPI(url, .{ .reason = .script }, .{ .push = null });
-    }
-
-    // frames return the window itself, but accessing it via a pseudo
-    // array returns the Window object corresponding to the given frame or
-    // iframe.
-    // https://developer.mozilla.org/en-US/docs/Web/API/Window/frames
-    pub fn get_frames(self: *Window) *Window {
-        return self;
-    }
-
-    pub fn indexed_get(self: *Window, index: u32, has_value: *bool, page: *Page) !*Window {
-        const frames = try domcss.querySelectorAll(
-            page.call_arena,
-            parser.documentHTMLToNode(self.document),
-            "iframe",
-        );
-
-        if (index >= frames.nodes.items.len) {
-            has_value.* = false;
-            return undefined;
-        }
-
-        has_value.* = true;
-        // TODO return the correct frame's window
-        // frames.nodes.items[indexed]
-        return error.TODO;
-    }
-
-    // Retrieve the numbre of frames/iframes from the DOM dynamically.
-    pub fn get_length(self: *const Window, page: *Page) !u32 {
-        const frames = try domcss.querySelectorAll(
-            page.call_arena,
-            parser.documentHTMLToNode(self.document),
-            "iframe",
-        );
-
-        return frames.get_length();
-    }
-
-    pub fn get_document(self: *Window) ?*parser.DocumentHTML {
-        return self.document;
-    }
-
-    pub fn get_history(_: *Window, page: *Page) *History {
-        return &page.session.history;
-    }
-
-    pub fn get_navigation(_: *Window, page: *Page) *Navigation {
-        return &page.session.navigation;
-    }
-
-    //  The interior height of the window in pixels, including the height of the horizontal scroll bar, if present.
-    pub fn get_innerHeight(_: *Window, page: *Page) u32 {
-        // We do not have scrollbars or padding so this is the same as Element.clientHeight
-        return page.renderer.height();
-    }
-
-    // The interior width of the window in pixels. That includes the width of the vertical scroll bar, if one is present.
-    pub fn get_innerWidth(_: *Window, page: *Page) u32 {
-        // We do not have scrollbars or padding so this is the same as Element.clientWidth
-        return page.renderer.width();
-    }
-
-    pub fn get_name(self: *Window) []const u8 {
-        return self.target;
-    }
-
-    pub fn get_localStorage(self: *Window) !*storage.Bottle {
-        if (self.storage_shelf == null) return parser.DOMError.NotSupported;
-        return &self.storage_shelf.?.bucket.local;
-    }
-
-    pub fn get_sessionStorage(self: *Window) !*storage.Bottle {
-        if (self.storage_shelf == null) return parser.DOMError.NotSupported;
-        return &self.storage_shelf.?.bucket.session;
-    }
-
-    pub fn get_CSS(self: *Window) *Css {
-        return &self.css;
-    }
-
-    pub fn _requestAnimationFrame(self: *Window, cbk: js.Function, page: *Page) !u32 {
-        return self.createTimeout(cbk, 5, page, .{
-            .animation_frame = true,
-            .name = "animationFrame",
-            .low_priority = true,
-        });
-    }
-
-    pub fn _cancelAnimationFrame(self: *Window, id: u32) !void {
-        _ = self.timers.remove(id);
-    }
-
-    pub fn _setTimeout(self: *Window, cbk: js.Function, delay: ?u32, params: []js.Object, page: *Page) !u32 {
-        return self.createTimeout(cbk, delay, page, .{ .args = params, .name = "setTimeout" });
-    }
-
-    pub fn _setInterval(self: *Window, cbk: js.Function, delay: ?u32, params: []js.Object, page: *Page) !u32 {
-        return self.createTimeout(cbk, delay, page, .{ .repeat = true, .args = params, .name = "setInterval" });
-    }
-
-    pub fn _clearTimeout(self: *Window, id: u32) !void {
-        _ = self.timers.remove(id);
-    }
-
-    pub fn _clearInterval(self: *Window, id: u32) !void {
-        _ = self.timers.remove(id);
-    }
-
-    pub fn _queueMicrotask(self: *Window, cbk: js.Function, page: *Page) !u32 {
-        return self.createTimeout(cbk, 0, page, .{ .name = "queueMicrotask" });
-    }
-
-    pub fn _setImmediate(self: *Window, cbk: js.Function, page: *Page) !u32 {
-        return self.createTimeout(cbk, 0, page, .{ .name = "setImmediate" });
-    }
-
-    pub fn _clearImmediate(self: *Window, id: u32) void {
-        _ = self.timers.remove(id);
-    }
-
-    pub fn _matchMedia(_: *const Window, media: js.String) !MediaQueryList {
-        return .{
-            .matches = false, // TODO?
-            .media = media.string,
-        };
-    }
-
-    pub fn _btoa(_: *const Window, value: []const u8, page: *Page) ![]const u8 {
-        const Encoder = std.base64.standard.Encoder;
-        const out = try page.call_arena.alloc(u8, Encoder.calcSize(value.len));
-        return Encoder.encode(out, value);
-    }
-
-    pub fn _atob(_: *const Window, value: []const u8, page: *Page) ![]const u8 {
-        const Decoder = std.base64.standard.Decoder;
-        const size = Decoder.calcSizeForSlice(value) catch return error.InvalidCharacterError;
-
-        const out = try page.call_arena.alloc(u8, size);
-        Decoder.decode(out, value) catch return error.InvalidCharacterError;
-        return out;
-    }
-
-    const CreateTimeoutOpts = struct {
-        name: []const u8,
-        args: []js.Object = &.{},
-        repeat: bool = false,
-        animation_frame: bool = false,
-        low_priority: bool = false,
-    };
-    fn createTimeout(self: *Window, cbk: js.Function, delay_: ?u32, page: *Page, opts: CreateTimeoutOpts) !u32 {
-        const delay = delay_ orelse 0;
-        if (self.timers.count() > 512) {
-            return error.TooManyTimeout;
-        }
-        const timer_id = self.timer_id +% 1;
-        self.timer_id = timer_id;
-
-        const arena = page.arena;
-
-        const gop = try self.timers.getOrPut(arena, timer_id);
-        if (gop.found_existing) {
-            // this can only happen if we've created 2^31 timeouts.
-            return error.TooManyTimeout;
-        } else {
-            gop.value_ptr.* = {};
-        }
-        errdefer _ = self.timers.remove(timer_id);
-
-        const args = opts.args;
-        var persisted_args: []js.Object = &.{};
-        if (args.len > 0) {
-            persisted_args = try page.arena.alloc(js.Object, args.len);
-            for (args, persisted_args) |a, *ca| {
-                ca.* = try a.persist();
-            }
-        }
-
-        const callback = try arena.create(TimerCallback);
-        callback.* = .{
-            .cbk = cbk,
-            .window = self,
-            .timer_id = timer_id,
-            .args = persisted_args,
-            .animation_frame = opts.animation_frame,
-            // setting a repeat time of 0 is illegal, doing + 1 is a simple way to avoid that
-            .repeat = if (opts.repeat) delay + 1 else null,
-        };
-
-        try page.scheduler.add(callback, TimerCallback.run, delay, .{
-            .name = opts.name,
-            .low_priority = opts.low_priority,
-        });
-
-        return timer_id;
-    }
-
-    // TODO: getComputedStyle should return a read-only CSSStyleDeclaration.
-    // We currently don't have a read-only one, so we return a new instance on
-    // each call.
-    pub fn _getComputedStyle(_: *const Window, element: *parser.Element, pseudo_element: ?[]const u8) !CSSStyleDeclaration {
-        _ = element;
-        _ = pseudo_element;
-        return .empty;
-    }
-
-    const ScrollToOpts = union(enum) {
-        x: i32,
-        opts: Opts,
-
-        const Opts = struct {
-            top: i32,
-            left: i32,
-            behavior: []const u8 = "",
-        };
-    };
-    pub fn _scrollTo(self: *Window, opts: ScrollToOpts, y: ?i32) !void {
-        switch (opts) {
-            .x => |x| {
-                self.scroll_x = @intCast(@max(x, 0));
-                self.scroll_y = @intCast(@max(0, y orelse 0));
-            },
-            .opts => |o| {
-                self.scroll_y = @intCast(@max(0, o.top));
-                self.scroll_x = @intCast(@max(0, o.left));
-            },
-        }
-
-        {
-            const scroll_event = try parser.eventCreate();
-            defer parser.eventDestroy(scroll_event);
-
-            try parser.eventInit(scroll_event, "scroll", .{});
-            _ = try parser.eventTargetDispatchEvent(
-                parser.toEventTarget(Window, self),
-                scroll_event,
-            );
-        }
-
-        {
-            const scroll_end = try parser.eventCreate();
-            defer parser.eventDestroy(scroll_end);
-
-            try parser.eventInit(scroll_end, "scrollend", .{});
-            _ = try parser.eventTargetDispatchEvent(
-                parser.toEventTarget(parser.DocumentHTML, self.document),
-                scroll_end,
-            );
-        }
-    }
-    pub fn _scroll(self: *Window, opts: ScrollToOpts, y: ?i32) !void {
-        // just an alias for scrollTo
-        return self._scrollTo(opts, y);
-    }
-
-    pub fn get_scrollX(self: *const Window) u32 {
-        return self.scroll_x;
-    }
-
-    pub fn get_scrollY(self: *const Window) u32 {
-        return self.scroll_y;
-    }
-
-    pub fn get_pageXOffset(self: *const Window) u32 {
-        // just an alias for scrollX
-        return self.get_scrollX();
-    }
-
-    pub fn get_pageYOffset(self: *const Window) u32 {
-        // just an alias for scrollY
-        return self.get_scrollY();
-    }
-
-    // libdom's document doesn't have a parent, which is correct, but
-    // breaks the event bubbling that happens for many events from
-    // document -> window.
-    // We need to force dispatch this event on the window, with the
-    // document target.
-    // In theory, we should do this for a lot of events and might need
-    // to come up with a good way to solve this more generically. But
-    // this specific event, and maybe a few others in the near future,
-    // are blockers.
-    // Worth noting that NetSurf itself appears to do something similar:
-    // https://github.com/netsurf-browser/netsurf/blob/a32e1a03e1c91ee9f0aa211937dbae7a96831149/content/handlers/html/html.c#L380
-    pub fn dispatchForDocumentTarget(self: *Window, evt: *parser.Event) !void {
-        // we assume that this evt has already been dispatched on the document
-        // and thus the target has already been set to the document.
-        return self.base.redispatchEvent(evt);
-    }
-
-    pub fn postAttach(self: *Window, js_this: js.This) !void {
-        try js_this.set("top", self, .{});
-        try js_this.set("self", self, .{});
-        try js_this.set("parent", self, .{});
-        try js_this.set("window", self, .{});
-        try js_this.set("crypto", &self.crypto, .{});
-        try js_this.set("screen", &self.screen, .{});
-        try js_this.set("console", &self.console, .{});
-        try js_this.set("navigator", &self.navigator, .{});
-        try js_this.set("performance", &self.performance, .{});
-    }
-};
-
-const TimerCallback = struct {
-    // the id of our timer (windows.timers key)
-    timer_id: u31,
-
-    // if false, we'll remove the timer_id from the window.timers lookup on run
-    repeat: ?u32,
-
-    // The JavaScript callback to execute
-    cbk: js.Function,
-
-    animation_frame: bool = false,
-
-    window: *Window,
-
-    args: []js.Object = &.{},
-
-    fn run(ctx: *anyopaque) ?u32 {
-        const self: *TimerCallback = @ptrCast(@alignCast(ctx));
-        if (self.repeat != null) {
-            if (self.window.timers.contains(self.timer_id) == false) {
-                // it was called
-                return null;
-            }
-        } else if (self.window.timers.remove(self.timer_id) == false) {
-            // it was cancelled
-            return null;
-        }
-
-        var result: js.Function.Result = undefined;
-
-        var call: anyerror!void = undefined;
-        if (self.animation_frame) {
-            call = self.cbk.tryCall(void, .{self.window.performance._now()}, &result);
-        } else {
-            call = self.cbk.tryCall(void, self.args, &result);
-        }
-
-        call catch {
-            log.warn(.user_script, "callback error", .{
-                .err = result.exception,
-                .stack = result.stack,
-                .source = "window timeout",
-            });
-        };
-
-        return self.repeat;
-    }
-};
-
-const testing = @import("../../testing.zig");
-test "Browser: Window" {
-    try testing.htmlRunner("window/window.html");
-    try testing.htmlRunner("window/frames.html");
-}
--- a/src/browser/iterator/iterator.zig
+++ b/src/browser/iterator/iterator.zig
@@ -1,226 +0,0 @@
-pub const Interfaces = .{
-    U32Iterator,
-};
-
-pub const U32Iterator = struct {
-    length: u32,
-    index: u32 = 0,
-
-    pub const Return = struct {
-        value: u32,
-        done: bool,
-    };
-
-    pub fn _next(self: *U32Iterator) Return {
-        const i = self.index;
-        if (i >= self.length) {
-            return .{
-                .value = 0,
-                .done = true,
-            };
-        }
-
-        self.index = i + 1;
-        return .{
-            .value = i,
-            .done = false,
-        };
-    }
-
-    // Iterators should be iterable. There's a [JS] example on MDN that
-    // suggests this is the correct approach:
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterator_protocol
-    pub fn _symbol_iterator(self: *U32Iterator) *U32Iterator {
-        return self;
-    }
-};
-
-// A wrapper around an iterator that emits an Iterable result
-// An iterable has a next() which emits a {done: bool, value: T} result
-pub fn Iterable(comptime T: type, comptime JsName: []const u8) type {
-    // The inner iterator's return type.
-    // Maybe an error union.
-    // Definitely an optional
-    const RawValue = @typeInfo(@TypeOf(T._next)).@"fn".return_type.?;
-    const CanError = @typeInfo(RawValue) == .error_union;
-
-    const Value = blk: {
-        // Unwrap the RawValue
-        var V = RawValue;
-        if (CanError) {
-            V = @typeInfo(V).error_union.payload;
-        }
-        break :blk @typeInfo(V).optional.child;
-    };
-
-    const Result = struct {
-        done: bool,
-        // todo, technically, we should return undefined when done = true
-        // or even omit the value;
-        value: ?Value,
-    };
-
-    const ReturnType = if (CanError) T.Error!Result else Result;
-
-    return struct {
-        // the inner value iterator
-        inner: T,
-
-        // Generics don't generate clean names. Can't just take the resulting
-        // type name and use that as a the JS class name. So we always ask for
-        // an explicit JS class name
-        pub const js_name = JsName;
-
-        const Self = @This();
-
-        pub fn init(inner: T) Self {
-            return .{ .inner = inner };
-        }
-
-        pub fn _next(self: *Self) ReturnType {
-            const value = if (comptime CanError) try self.inner._next() else self.inner._next();
-            return .{ .done = value == null, .value = value };
-        }
-
-        pub fn _symbol_iterator(self: *Self) *Self {
-            return self;
-        }
-    };
-}
-
-// A wrapper around an iterator that emits integer/index keyed entries.
-pub fn NumericEntries(comptime T: type, comptime JsName: []const u8) type {
-    // The inner iterator's return type.
-    // Maybe an error union.
-    // Definitely an optional
-    const RawValue = @typeInfo(@TypeOf(T._next)).@"fn".return_type.?;
-    const CanError = @typeInfo(RawValue) == .error_union;
-
-    const Value = blk: {
-        // Unwrap the RawValue
-        var V = RawValue;
-        if (CanError) {
-            V = @typeInfo(V).error_union.payload;
-        }
-        break :blk @typeInfo(V).optional.child;
-    };
-
-    const ReturnType = if (CanError) T.Error!?struct { u32, Value } else ?struct { u32, Value };
-
-    // Avoid ambiguity. We want to expose a NumericEntries(T).Iterable, so we
-    // need a declartion inside here for an "Iterable", but that will conflict
-    // with the above Iterable generic function we have.
-    const BaseIterable = Iterable;
-
-    return struct {
-        // the inner value iterator
-        inner: T,
-        index: u32,
-
-        const Self = @This();
-
-        // Generics don't generate clean names. Can't just take the resulting
-        // type name and use that as a the JS class name. So we always ask for
-        // an explicit JS class name
-        pub const js_name = JsName;
-
-        // re-exposed for when/if we compose this type into an Iterable
-        pub const Error = T.Error;
-
-        // This iterator as an iterable
-        pub const Iterable = BaseIterable(Self, JsName ++ "Iterable");
-
-        pub fn init(inner: T) Self {
-            return .{ .inner = inner, .index = 0 };
-        }
-
-        pub fn _next(self: *Self) ReturnType {
-            const value_ = if (comptime CanError) try self.inner._next() else self.inner._next();
-            const value = value_ orelse return null;
-
-            const index = self.index;
-            self.index = index + 1;
-            return .{ index, value };
-        }
-
-        // make the iterator, iterable
-        pub fn _symbol_iterator(self: *Self) Self.Iterable {
-            return Self.Iterable.init(self.*);
-        }
-    };
-}
-
-const testing = @import("../../testing.zig");
-test "U32Iterator" {
-    {
-        var it = U32Iterator{ .length = 0 };
-        try testing.expectEqual(.{ .value = 0, .done = true }, it._next());
-        try testing.expectEqual(.{ .value = 0, .done = true }, it._next());
-    }
-
-    {
-        var it = U32Iterator{ .length = 3 };
-        try testing.expectEqual(.{ .value = 0, .done = false }, it._next());
-        try testing.expectEqual(.{ .value = 1, .done = false }, it._next());
-        try testing.expectEqual(.{ .value = 2, .done = false }, it._next());
-        try testing.expectEqual(.{ .value = 0, .done = true }, it._next());
-        try testing.expectEqual(.{ .value = 0, .done = true }, it._next());
-    }
-}
-
-test "NumericEntries" {
-    const it = DummyIterator{};
-    var entries = NumericEntries(DummyIterator, "DummyIterator").init(it);
-
-    const v1 = entries._next().?;
-    try testing.expectEqual(0, v1.@"0");
-    try testing.expectEqual("it's", v1.@"1");
-
-    const v2 = entries._next().?;
-    try testing.expectEqual(1, v2.@"0");
-    try testing.expectEqual("over", v2.@"1");
-
-    const v3 = entries._next().?;
-    try testing.expectEqual(2, v3.@"0");
-    try testing.expectEqual("9000!!", v3.@"1");
-
-    try testing.expectEqual(null, entries._next());
-    try testing.expectEqual(null, entries._next());
-    try testing.expectEqual(null, entries._next());
-}
-
-test "Iterable" {
-    const it = DummyIterator{};
-    var entries = Iterable(DummyIterator, "DummyIterator").init(it);
-
-    const v1 = entries._next();
-    try testing.expectEqual(false, v1.done);
-    try testing.expectEqual("it's", v1.value.?);
-
-    const v2 = entries._next();
-    try testing.expectEqual(false, v2.done);
-    try testing.expectEqual("over", v2.value.?);
-
-    const v3 = entries._next();
-    try testing.expectEqual(false, v3.done);
-    try testing.expectEqual("9000!!", v3.value.?);
-
-    try testing.expectEqual(true, entries._next().done);
-    try testing.expectEqual(true, entries._next().done);
-    try testing.expectEqual(true, entries._next().done);
-}
-
-const DummyIterator = struct {
-    index: u32 = 0,
-
-    pub fn _next(self: *DummyIterator) ?[]const u8 {
-        const index = self.index;
-        self.index = index + 1;
-        return switch (index) {
-            0 => "it's",
-            1 => "over",
-            2 => "9000!!",
-            else => null,
-        };
-    }
-};
--- a/src/browser/js/Caller.zig
+++ b/src/browser/js/Caller.zig
@@ -1,561 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const log = @import("../../log.zig");
-const Page = @import("../page.zig").Page;
-
-const types = @import("types.zig");
-const Context = @import("Context.zig");
-
-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
-
-const CALL_ARENA_RETAIN = 1024 * 16;
-
-// Responsible for calling Zig functions from JS invocations. This could
-// probably just contained in ExecutionWorld, but having this specific logic, which
-// is somewhat repetitive between constructors, functions, getters, etc contained
-// here does feel like it makes it cleaner.
-const Caller = @This();
-context: *Context,
-v8_context: v8.Context,
-isolate: v8.Isolate,
-call_arena: Allocator,
-
-// info is a v8.PropertyCallbackInfo or a v8.FunctionCallback
-// All we really want from it is the isolate.
-// executor = Isolate -> getCurrentContext -> getEmbedderData()
-pub fn init(info: anytype) Caller {
-    const isolate = info.getIsolate();
-    const v8_context = isolate.getCurrentContext();
-    const context: *Context = @ptrFromInt(v8_context.getEmbedderData(1).castTo(v8.BigInt).getUint64());
-
-    context.call_depth += 1;
-    return .{
-        .context = context,
-        .isolate = isolate,
-        .v8_context = v8_context,
-        .call_arena = context.call_arena,
-    };
-}
-
-pub fn deinit(self: *Caller) void {
-    const context = self.context;
-    const call_depth = context.call_depth - 1;
-
-    // Because of callbacks, calls can be nested. Because of this, we
-    // can't clear the call_arena after _every_ call. Imagine we have
-    //    arr.forEach((i) => { console.log(i); }
-    //
-    // First we call forEach. Inside of our forEach call,
-    // we call console.log. If we reset the call_arena after this call,
-    // it'll reset it for the `forEach` call after, which might still
-    // need the data.
-    //
-    // Therefore, we keep a call_depth, and only reset the call_arena
-    // when a top-level (call_depth == 0) function ends.
-    if (call_depth == 0) {
-        const arena: *ArenaAllocator = @ptrCast(@alignCast(context.call_arena.ptr));
-        _ = arena.reset(.{ .retain_with_limit = CALL_ARENA_RETAIN });
-    }
-
-    // Set this _after_ we've executed the above code, so that if the
-    // above code executes any callbacks, they aren't being executed
-    // at scope 0, which would be wrong.
-    context.call_depth = call_depth;
-}
-
-pub fn constructor(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, info: v8.FunctionCallbackInfo) !void {
-    const args = try self.getArgs(Struct, named_function, 0, info);
-    const res = @call(.auto, Struct.constructor, args);
-
-    const ReturnType = @typeInfo(@TypeOf(Struct.constructor)).@"fn".return_type orelse {
-        @compileError(@typeName(Struct) ++ " has a constructor without a return type");
-    };
-
-    const this = info.getThis();
-    if (@typeInfo(ReturnType) == .error_union) {
-        const non_error_res = res catch |err| return err;
-        _ = try self.context.mapZigInstanceToJs(this, non_error_res);
-    } else {
-        _ = try self.context.mapZigInstanceToJs(this, res);
-    }
-    info.getReturnValue().set(this);
-}
-
-pub fn method(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, info: v8.FunctionCallbackInfo) !void {
-    if (comptime isSelfReceiver(Struct, named_function) == false) {
-        return self.function(Struct, named_function, info);
-    }
-
-    const context = self.context;
-    const func = @field(Struct, named_function.name);
-    var args = try self.getArgs(Struct, named_function, 1, info);
-    const zig_instance = try context.typeTaggedAnyOpaque(named_function, *types.Receiver(Struct), info.getThis());
-
-    // inject 'self' as the first parameter
-    @field(args, "0") = zig_instance;
-
-    const res = @call(.auto, func, args);
-    info.getReturnValue().set(try context.zigValueToJs(res));
-}
-
-pub fn function(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, info: v8.FunctionCallbackInfo) !void {
-    const context = self.context;
-    const func = @field(Struct, named_function.name);
-    const args = try self.getArgs(Struct, named_function, 0, info);
-    const res = @call(.auto, func, args);
-    info.getReturnValue().set(try context.zigValueToJs(res));
-}
-
-pub fn getIndex(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, idx: u32, info: v8.PropertyCallbackInfo) !u8 {
-    const context = self.context;
-    const func = @field(Struct, named_function.name);
-    const IndexedGet = @TypeOf(func);
-    if (@typeInfo(IndexedGet).@"fn".return_type == null) {
-        @compileError(named_function.full_name ++ " must have a return type");
-    }
-
-    var has_value = true;
-
-    var args: ParamterTypes(IndexedGet) = undefined;
-    const arg_fields = @typeInfo(@TypeOf(args)).@"struct".fields;
-    switch (arg_fields.len) {
-        0, 1, 2 => @compileError(named_function.full_name ++ " must take at least a u32 and *bool parameter"),
-        3, 4 => {
-            const zig_instance = try context.typeTaggedAnyOpaque(named_function, *types.Receiver(Struct), info.getThis());
-            comptime assertSelfReceiver(Struct, named_function);
-            @field(args, "0") = zig_instance;
-            @field(args, "1") = idx;
-            @field(args, "2") = &has_value;
-            if (comptime arg_fields.len == 4) {
-                comptime assertIsPageArg(Struct, named_function, 3);
-                @field(args, "3") = context.page;
-            }
-        },
-        else => @compileError(named_function.full_name ++ " has too many parmaters"),
-    }
-
-    const res = @call(.auto, func, args);
-    if (has_value == false) {
-        return v8.Intercepted.No;
-    }
-    info.getReturnValue().set(try context.zigValueToJs(res));
-    return v8.Intercepted.Yes;
-}
-
-pub fn getNamedIndex(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, name: v8.Name, info: v8.PropertyCallbackInfo) !u8 {
-    const context = self.context;
-    const func = @field(Struct, named_function.name);
-    comptime assertSelfReceiver(Struct, named_function);
-
-    var has_value = true;
-    var args = try self.getArgs(Struct, named_function, 3, info);
-    const zig_instance = try context.typeTaggedAnyOpaque(named_function, *types.Receiver(Struct), info.getThis());
-    @field(args, "0") = zig_instance;
-    @field(args, "1") = try self.nameToString(name);
-    @field(args, "2") = &has_value;
-
-    const res = @call(.auto, func, args);
-    if (has_value == false) {
-        return v8.Intercepted.No;
-    }
-    info.getReturnValue().set(try self.context.zigValueToJs(res));
-    return v8.Intercepted.Yes;
-}
-
-pub fn setNamedIndex(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, name: v8.Name, js_value: v8.Value, info: v8.PropertyCallbackInfo) !u8 {
-    const context = self.context;
-    const func = @field(Struct, named_function.name);
-    comptime assertSelfReceiver(Struct, named_function);
-
-    var has_value = true;
-    var args = try self.getArgs(Struct, named_function, 4, info);
-    const zig_instance = try context.typeTaggedAnyOpaque(named_function, *types.Receiver(Struct), info.getThis());
-    @field(args, "0") = zig_instance;
-    @field(args, "1") = try self.nameToString(name);
-    @field(args, "2") = try context.jsValueToZig(named_function, @TypeOf(@field(args, "2")), js_value);
-    @field(args, "3") = &has_value;
-
-    const res = @call(.auto, func, args);
-    return namedSetOrDeleteCall(res, has_value);
-}
-
-pub fn deleteNamedIndex(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, name: v8.Name, info: v8.PropertyCallbackInfo) !u8 {
-    const context = self.context;
-    const func = @field(Struct, named_function.name);
-    comptime assertSelfReceiver(Struct, named_function);
-
-    var has_value = true;
-    var args = try self.getArgs(Struct, named_function, 3, info);
-    const zig_instance = try context.typeTaggedAnyOpaque(named_function, *types.Receiver(Struct), info.getThis());
-    @field(args, "0") = zig_instance;
-    @field(args, "1") = try self.nameToString(name);
-    @field(args, "2") = &has_value;
-
-    const res = @call(.auto, func, args);
-    return namedSetOrDeleteCall(res, has_value);
-}
-
-fn namedSetOrDeleteCall(res: anytype, has_value: bool) !u8 {
-    if (@typeInfo(@TypeOf(res)) == .error_union) {
-        _ = try res;
-    }
-    if (has_value == false) {
-        return v8.Intercepted.No;
-    }
-    return v8.Intercepted.Yes;
-}
-
-fn nameToString(self: *Caller, name: v8.Name) ![]const u8 {
-    return self.context.valueToString(.{ .handle = name.handle }, .{});
-}
-
-fn isSelfReceiver(comptime Struct: type, comptime named_function: NamedFunction) bool {
-    return checkSelfReceiver(Struct, named_function, false);
-}
-fn assertSelfReceiver(comptime Struct: type, comptime named_function: NamedFunction) void {
-    _ = checkSelfReceiver(Struct, named_function, true);
-}
-fn checkSelfReceiver(comptime Struct: type, comptime named_function: NamedFunction, comptime fail: bool) bool {
-    const func = @field(Struct, named_function.name);
-    const params = @typeInfo(@TypeOf(func)).@"fn".params;
-    if (params.len == 0) {
-        if (fail) {
-            @compileError(named_function.full_name ++ " must have a self parameter");
-        }
-        return false;
-    }
-
-    const R = types.Receiver(Struct);
-    const first_param = params[0].type.?;
-    if (first_param != *R and first_param != *const R) {
-        if (fail) {
-            @compileError(std.fmt.comptimePrint("The first parameter to {s} must be a *{s} or *const {s}. Got: {s}", .{
-                named_function.full_name,
-                @typeName(R),
-                @typeName(R),
-                @typeName(first_param),
-            }));
-        }
-        return false;
-    }
-    return true;
-}
-
-fn assertIsPageArg(comptime Struct: type, comptime named_function: NamedFunction, index: comptime_int) void {
-    const F = @TypeOf(@field(Struct, named_function.name));
-    const param = @typeInfo(F).@"fn".params[index].type.?;
-    if (isPage(param)) {
-        return;
-    }
-    @compileError(std.fmt.comptimePrint("The {d} parameter to {s} must be a *Page or *const Page. Got: {s}", .{ index, named_function.full_name, @typeName(param) }));
-}
-
-pub fn handleError(self: *Caller, comptime Struct: type, comptime named_function: NamedFunction, err: anyerror, info: anytype) void {
-    const isolate = self.isolate;
-
-    if (comptime @import("builtin").mode == .Debug and @hasDecl(@TypeOf(info), "length")) {
-        if (log.enabled(.js, .warn)) {
-            self.logFunctionCallError(err, named_function.full_name, info);
-        }
-    }
-
-    var js_err: ?v8.Value = switch (err) {
-        error.InvalidArgument => createTypeException(isolate, "invalid argument"),
-        error.OutOfMemory => js._createException(isolate, "out of memory"),
-        error.IllegalConstructor => js._createException(isolate, "Illegal Contructor"),
-        else => blk: {
-            const func = @field(Struct, named_function.name);
-            const return_type = @typeInfo(@TypeOf(func)).@"fn".return_type orelse {
-                // void return type;
-                break :blk null;
-            };
-
-            if (@typeInfo(return_type) != .error_union) {
-                // type defines a custom exception, but this function should
-                // not fail. We failed somewhere inside of js.zig and
-                // should return the error as-is, since it isn't related
-                // to our Struct
-                break :blk null;
-            }
-
-            const function_error_set = @typeInfo(return_type).error_union.error_set;
-
-            const E = comptime getCustomException(Struct) orelse break :blk null;
-            if (function_error_set == E or isErrorSetException(E, err)) {
-                const custom_exception = E.init(self.call_arena, err, named_function.js_name) catch |init_err| {
-                    switch (init_err) {
-                        // if a custom exceptions' init wants to return a
-                        // different error, we need to think about how to
-                        // handle that failure.
-                        error.OutOfMemory => break :blk js._createException(isolate, "out of memory"),
-                    }
-                };
-                // ughh..how to handle an error here?
-                break :blk self.context.zigValueToJs(custom_exception) catch js._createException(isolate, "internal error");
-            }
-            // this error isn't part of a custom exception
-            break :blk null;
-        },
-    };
-
-    if (js_err == null) {
-        js_err = js._createException(isolate, @errorName(err));
-    }
-    const js_exception = isolate.throwException(js_err.?);
-    info.getReturnValue().setValueHandle(js_exception.handle);
-}
-
-// walk the prototype chain to see if a type declares a custom Exception
-fn getCustomException(comptime Struct: type) ?type {
-    var S = Struct;
-    while (true) {
-        if (@hasDecl(S, "Exception")) {
-            return S.Exception;
-        }
-        if (@hasDecl(S, "prototype") == false) {
-            return null;
-        }
-        // long ago, we validated that every prototype declaration
-        // is a pointer.
-        S = @typeInfo(S.prototype).pointer.child;
-    }
-}
-
-// Does the error we want to return belong to the custom exeception's ErrorSet
-fn isErrorSetException(comptime E: type, err: anytype) bool {
-    const Entry = std.meta.Tuple(&.{ []const u8, void });
-
-    const error_set = @typeInfo(E.ErrorSet).error_set.?;
-    const entries = comptime blk: {
-        var kv: [error_set.len]Entry = undefined;
-        for (error_set, 0..) |e, i| {
-            kv[i] = .{ e.name, {} };
-        }
-        break :blk kv;
-    };
-    const lookup = std.StaticStringMap(void).initComptime(entries);
-    return lookup.has(@errorName(err));
-}
-
-// If we call a method in javascript: cat.lives('nine');
-//
-// Then we'd expect a Zig function with 2 parameters: a self and the string.
-// In this case, offset == 1. Offset is always 1 for setters or methods.
-//
-// Offset is always 0 for constructors.
-//
-// For constructors, setters and methods, we can further increase offset + 1
-// if the first parameter is an instance of Page.
-//
-// Finally, if the JS function is called with _more_ parameters and
-// the last parameter in Zig is an array, we'll try to slurp the additional
-// parameters into the array.
-fn getArgs(self: *const Caller, comptime Struct: type, comptime named_function: NamedFunction, comptime offset: usize, info: anytype) !ParamterTypes(@TypeOf(@field(Struct, named_function.name))) {
-    const context = self.context;
-    const F = @TypeOf(@field(Struct, named_function.name));
-    var args: ParamterTypes(F) = undefined;
-
-    const params = @typeInfo(F).@"fn".params[offset..];
-    // Except for the constructor, the first parameter is always `self`
-    // This isn't something we'll bind from JS, so skip it.
-    const params_to_map = blk: {
-        if (params.len == 0) {
-            return args;
-        }
-
-        // If the last parameter is the Page, set it, and exclude it
-        // from our params slice, because we don't want to bind it to
-        // a JS argument
-        if (comptime isPage(params[params.len - 1].type.?)) {
-            @field(args, tupleFieldName(params.len - 1 + offset)) = self.context.page;
-            break :blk params[0 .. params.len - 1];
-        }
-
-        // If the last parameter is a special JsThis, set it, and exclude it
-        // from our params slice, because we don't want to bind it to
-        // a JS argument
-        if (comptime params[params.len - 1].type.? == js.This) {
-            @field(args, tupleFieldName(params.len - 1 + offset)) = .{ .obj = .{
-                .context = context,
-                .js_obj = info.getThis(),
-            } };
-
-            // AND the 2nd last parameter is state
-            if (params.len > 1 and comptime isPage(params[params.len - 2].type.?)) {
-                @field(args, tupleFieldName(params.len - 2 + offset)) = self.context.page;
-                break :blk params[0 .. params.len - 2];
-            }
-
-            break :blk params[0 .. params.len - 1];
-        }
-
-        // we have neither a Page nor a JsObject. All params must be
-        // bound to a JavaScript value.
-        break :blk params;
-    };
-
-    if (params_to_map.len == 0) {
-        return args;
-    }
-
-    const js_parameter_count = info.length();
-    const last_js_parameter = params_to_map.len - 1;
-    var is_variadic = false;
-
-    {
-        // This is going to get complicated. If the last Zig parameter
-        // is a slice AND the corresponding javascript parameter is
-        // NOT an an array, then we'll treat it as a variadic.
-
-        const last_parameter_type = params_to_map[params_to_map.len - 1].type.?;
-        const last_parameter_type_info = @typeInfo(last_parameter_type);
-        if (last_parameter_type_info == .pointer and last_parameter_type_info.pointer.size == .slice) {
-            const slice_type = last_parameter_type_info.pointer.child;
-            const corresponding_js_value = info.getArg(@as(u32, @intCast(last_js_parameter)));
-            if (corresponding_js_value.isArray() == false and corresponding_js_value.isTypedArray() == false and slice_type != u8) {
-                is_variadic = true;
-                if (js_parameter_count == 0) {
-                    @field(args, tupleFieldName(params_to_map.len + offset - 1)) = &.{};
-                } else if (js_parameter_count >= params_to_map.len) {
-                    const arr = try self.call_arena.alloc(last_parameter_type_info.pointer.child, js_parameter_count - params_to_map.len + 1);
-                    for (arr, last_js_parameter..) |*a, i| {
-                        const js_value = info.getArg(@as(u32, @intCast(i)));
-                        a.* = try context.jsValueToZig(named_function, slice_type, js_value);
-                    }
-                    @field(args, tupleFieldName(params_to_map.len + offset - 1)) = arr;
-                } else {
-                    @field(args, tupleFieldName(params_to_map.len + offset - 1)) = &.{};
-                }
-            }
-        }
-    }
-
-    inline for (params_to_map, 0..) |param, i| {
-        const field_index = comptime i + offset;
-        if (comptime i == params_to_map.len - 1) {
-            if (is_variadic) {
-                break;
-            }
-        }
-
-        if (comptime isPage(param.type.?)) {
-            @compileError("Page must be the last parameter (or 2nd last if there's a JsThis): " ++ named_function.full_name);
-        } else if (comptime param.type.? == js.This) {
-            @compileError("JsThis must be the last parameter: " ++ named_function.full_name);
-        } else if (i >= js_parameter_count) {
-            if (@typeInfo(param.type.?) != .optional) {
-                return error.InvalidArgument;
-            }
-            @field(args, tupleFieldName(field_index)) = null;
-        } else {
-            const js_value = info.getArg(@as(u32, @intCast(i)));
-            @field(args, tupleFieldName(field_index)) = context.jsValueToZig(named_function, param.type.?, js_value) catch {
-                return error.InvalidArgument;
-            };
-        }
-    }
-
-    return args;
-}
-
-// This is extracted to speed up compilation. When left inlined in handleError,
-// this can add as much as 10 seconds of compilation time.
-fn logFunctionCallError(self: *Caller, err: anyerror, function_name: []const u8, info: v8.FunctionCallbackInfo) void {
-    const args_dump = self.serializeFunctionArgs(info) catch "failed to serialize args";
-    log.info(.js, "function call error", .{
-        .name = function_name,
-        .err = err,
-        .args = args_dump,
-        .stack = self.context.stackTrace() catch |err1| @errorName(err1),
-    });
-}
-
-fn serializeFunctionArgs(self: *Caller, info: v8.FunctionCallbackInfo) ![]const u8 {
-    const separator = log.separator();
-    const js_parameter_count = info.length();
-
-    const context = self.context;
-    var arr: std.ArrayListUnmanaged(u8) = .{};
-    for (0..js_parameter_count) |i| {
-        const js_value = info.getArg(@intCast(i));
-        const value_string = try context.valueToDetailString(js_value);
-        const value_type = try context.jsStringToZig(try js_value.typeOf(self.isolate), .{});
-        try std.fmt.format(arr.writer(context.call_arena), "{s}{d}: {s} ({s})", .{
-            separator,
-            i + 1,
-            value_string,
-            value_type,
-        });
-    }
-    return arr.items;
-}
-
-// We want the function name, or more precisely, the "Struct.function" for
-// displaying helpful @compileError.
-// However, there's no way to get the name from a std.Builtin.Fn, so we create
-// a NamedFunction as part of our binding, and pass it around incase we need
-// to display an error
-pub const NamedFunction = struct {
-    name: []const u8,
-    js_name: []const u8,
-    full_name: []const u8,
-
-    pub fn init(comptime Struct: type, comptime name: []const u8) NamedFunction {
-        return .{
-            .name = name,
-            .js_name = if (name[0] == '_') name[1..] else name,
-            .full_name = @typeName(Struct) ++ "." ++ name,
-        };
-    }
-};
-
-// Takes a function, and returns a tuple for its argument. Used when we
-// @call a function
-fn ParamterTypes(comptime F: type) type {
-    const params = @typeInfo(F).@"fn".params;
-    var fields: [params.len]std.builtin.Type.StructField = undefined;
-
-    inline for (params, 0..) |param, i| {
-        fields[i] = .{
-            .name = tupleFieldName(i),
-            .type = param.type.?,
-            .default_value_ptr = null,
-            .is_comptime = false,
-            .alignment = @alignOf(param.type.?),
-        };
-    }
-
-    return @Type(.{ .@"struct" = .{
-        .layout = .auto,
-        .decls = &.{},
-        .fields = &fields,
-        .is_tuple = true,
-    } });
-}
-
-fn tupleFieldName(comptime i: usize) [:0]const u8 {
-    return switch (i) {
-        0 => "0",
-        1 => "1",
-        2 => "2",
-        3 => "3",
-        4 => "4",
-        5 => "5",
-        6 => "6",
-        7 => "7",
-        8 => "8",
-        9 => "9",
-        else => std.fmt.comptimePrint("{d}", .{i}),
-    };
-}
-
-fn isPage(comptime T: type) bool {
-    return T == *Page or T == *const Page;
-}
-
-fn createTypeException(isolate: v8.Isolate, msg: []const u8) v8.Value {
-    return v8.Exception.initTypeError(v8.String.initUtf8(isolate, msg));
-}
--- a/src/browser/js/Context.zig
+++ b/src/browser/js/Context.zig
--- a/src/browser/js/Env.zig
+++ b/src/browser/js/Env.zig
@@ -1,539 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const log = @import("../../log.zig");
-
-const types = @import("types.zig");
-const Types = types.Types;
-const Caller = @import("Caller.zig");
-const Context = @import("Context.zig");
-const Platform = @import("Platform.zig");
-const Inspector = @import("Inspector.zig");
-const ExecutionWorld = @import("ExecutionWorld.zig");
-const NamedFunction = Caller.NamedFunction;
-
-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
-
-// The Env maps to a V8 isolate, which represents a isolated sandbox for
-// executing JavaScript. The Env is where we'll define our V8 <-> Zig bindings,
-// and it's where we'll start ExecutionWorlds, which actually execute JavaScript.
-// The `S` parameter is arbitrary state. When we start an ExecutionWorld, an instance
-// of S must be given. This instance is available to any Zig binding.
-// The `types` parameter is a tuple of Zig structures we want to bind to V8.
-const Env = @This();
-
-allocator: Allocator,
-
-platform: *const Platform,
-
-// the global isolate
-isolate: v8.Isolate,
-
-// just kept around because we need to free it on deinit
-isolate_params: *v8.CreateParams,
-
-// Given a type, we can lookup its index in TYPE_LOOKUP and then have
-// access to its TunctionTemplate (the thing we need to create an instance
-// of it)
-// I.e.:
-// const index = @field(TYPE_LOOKUP, @typeName(type_name))
-// const template = templates[index];
-templates: [Types.len]v8.FunctionTemplate,
-
-// Given a type index (retrieved via the TYPE_LOOKUP), we can retrieve
-// the index of its prototype. Types without a prototype have their own
-// index.
-prototype_lookup: [Types.len]u16,
-
-meta_lookup: [Types.len]types.Meta,
-
-context_id: usize,
-
-const Opts = struct {};
-
-pub fn init(allocator: Allocator, platform: *const Platform, _: Opts) !*Env {
-    // var params = v8.initCreateParams();
-    var params = try allocator.create(v8.CreateParams);
-    errdefer allocator.destroy(params);
-
-    v8.c.v8__Isolate__CreateParams__CONSTRUCT(params);
-
-    params.array_buffer_allocator = v8.createDefaultArrayBufferAllocator();
-    errdefer v8.destroyArrayBufferAllocator(params.array_buffer_allocator.?);
-
-    var isolate = v8.Isolate.init(params);
-    errdefer isolate.deinit();
-
-    // This is the callback that runs whenever a module is dynamically imported.
-    isolate.setHostImportModuleDynamicallyCallback(Context.dynamicModuleCallback);
-    isolate.setPromiseRejectCallback(promiseRejectCallback);
-    isolate.setMicrotasksPolicy(v8.c.kExplicit);
-
-    isolate.enter();
-    errdefer isolate.exit();
-
-    isolate.setHostInitializeImportMetaObjectCallback(Context.metaObjectCallback);
-
-    var temp_scope: v8.HandleScope = undefined;
-    v8.HandleScope.init(&temp_scope, isolate);
-    defer temp_scope.deinit();
-
-    const env = try allocator.create(Env);
-    errdefer allocator.destroy(env);
-
-    env.* = .{
-        .context_id = 0,
-        .platform = platform,
-        .isolate = isolate,
-        .templates = undefined,
-        .allocator = allocator,
-        .isolate_params = params,
-        .meta_lookup = undefined,
-        .prototype_lookup = undefined,
-    };
-
-    // Populate our templates lookup. generateClass creates the
-    // v8.FunctionTemplate, which we store in our env.templates.
-    // The ordering doesn't matter. What matters is that, given a type
-    // we can get its index via: @field(types.LOOKUP, type_name)
-    const templates = &env.templates;
-    inline for (Types, 0..) |s, i| {
-        @setEvalBranchQuota(10_000);
-        templates[i] = v8.Persistent(v8.FunctionTemplate).init(isolate, generateClass(s.defaultValue().?, isolate)).castToFunctionTemplate();
-    }
-
-    // Above, we've created all our our FunctionTemplates. Now that we
-    // have them all, we can hook up the prototypes.
-    const meta_lookup = &env.meta_lookup;
-    inline for (Types, 0..) |s, i| {
-        const Struct = s.defaultValue().?;
-        if (@hasDecl(Struct, "prototype")) {
-            const TI = @typeInfo(Struct.prototype);
-            const proto_name = @typeName(types.Receiver(TI.pointer.child));
-            if (@hasField(types.Lookup, proto_name) == false) {
-                @compileError(std.fmt.comptimePrint("Prototype '{s}' for '{s}' is undefined", .{ proto_name, @typeName(Struct) }));
-            }
-            // Hey, look! This is our first real usage of the types.LOOKUP.
-            // Just like we said above, given a type, we can get its
-            // template index.
-
-            const proto_index = @field(types.LOOKUP, proto_name);
-            templates[i].inherit(templates[proto_index]);
-        }
-
-        // while we're here, let's populate our meta lookup
-        const subtype: ?types.Sub = if (@hasDecl(Struct, "subtype")) Struct.subtype else null;
-
-        const proto_offset = comptime blk: {
-            if (!@hasField(Struct, "proto")) {
-                break :blk 0;
-            }
-            const proto_info = std.meta.fieldInfo(Struct, .proto);
-            if (@typeInfo(proto_info.type) == .pointer) {
-                // we store the offset as a negative, to so that,
-                // when we reverse this, we know that it's
-                // behind a pointer that we need to resolve.
-                break :blk -@offsetOf(Struct, "proto");
-            }
-            break :blk @offsetOf(Struct, "proto");
-        };
-
-        meta_lookup[i] = .{
-            .index = i,
-            .subtype = subtype,
-            .proto_offset = proto_offset,
-        };
-    }
-
-    return env;
-}
-
-pub fn deinit(self: *Env) void {
-    self.isolate.exit();
-    self.isolate.deinit();
-    v8.destroyArrayBufferAllocator(self.isolate_params.array_buffer_allocator.?);
-    self.allocator.destroy(self.isolate_params);
-    self.allocator.destroy(self);
-}
-
-pub fn newInspector(self: *Env, arena: Allocator, ctx: anytype) !Inspector {
-    return Inspector.init(arena, self.isolate, ctx);
-}
-
-pub fn runMicrotasks(self: *const Env) void {
-    self.isolate.performMicrotasksCheckpoint();
-}
-
-pub fn pumpMessageLoop(self: *const Env) bool {
-    return self.platform.inner.pumpMessageLoop(self.isolate, false);
-}
-
-pub fn runIdleTasks(self: *const Env) void {
-    return self.platform.inner.runIdleTasks(self.isolate, 1);
-}
-
-pub fn newExecutionWorld(self: *Env) !ExecutionWorld {
-    return .{
-        .env = self,
-        .context = null,
-        .context_arena = ArenaAllocator.init(self.allocator),
-    };
-}
-
-// V8 doesn't immediately free memory associated with
-// a Context, it's managed by the garbage collector. We use the
-// `lowMemoryNotification` call on the isolate to encourage v8 to free
-// any contexts which have been freed.
-pub fn lowMemoryNotification(self: *Env) void {
-    var handle_scope: v8.HandleScope = undefined;
-    v8.HandleScope.init(&handle_scope, self.isolate);
-    defer handle_scope.deinit();
-    self.isolate.lowMemoryNotification();
-}
-
-pub fn dumpMemoryStats(self: *Env) void {
-    const stats = self.isolate.getHeapStatistics();
-    std.debug.print(
-        \\ Total Heap Size: {d}
-        \\ Total Heap Size Executable: {d}
-        \\ Total Physical Size: {d}
-        \\ Total Available Size: {d}
-        \\ Used Heap Size: {d}
-        \\ Heap Size Limit: {d}
-        \\ Malloced Memory: {d}
-        \\ External Memory: {d}
-        \\ Peak Malloced Memory: {d}
-        \\ Number Of Native Contexts: {d}
-        \\ Number Of Detached Contexts: {d}
-        \\ Total Global Handles Size: {d}
-        \\ Used Global Handles Size: {d}
-        \\ Zap Garbage: {any}
-        \\
-    , .{ stats.total_heap_size, stats.total_heap_size_executable, stats.total_physical_size, stats.total_available_size, stats.used_heap_size, stats.heap_size_limit, stats.malloced_memory, stats.external_memory, stats.peak_malloced_memory, stats.number_of_native_contexts, stats.number_of_detached_contexts, stats.total_global_handles_size, stats.used_global_handles_size, stats.does_zap_garbage });
-}
-
-fn promiseRejectCallback(v8_msg: v8.C_PromiseRejectMessage) callconv(.c) void {
-    const msg = v8.PromiseRejectMessage.initFromC(v8_msg);
-    const isolate = msg.getPromise().toObject().getIsolate();
-    const context = Context.fromIsolate(isolate);
-
-    const value =
-        if (msg.getValue()) |v8_value| context.valueToString(v8_value, .{}) catch |err| @errorName(err) else "no value";
-
-    log.debug(.js, "unhandled rejection", .{ .value = value });
-}
-
-// Give it a Zig struct, get back a v8.FunctionTemplate.
-// The FunctionTemplate is a bit like a struct container - it's where
-// we'll attach functions/getters/setters and where we'll "inherit" a
-// prototype type (if there is any)
-fn generateClass(comptime Struct: type, isolate: v8.Isolate) v8.FunctionTemplate {
-    const template = generateConstructor(Struct, isolate);
-    attachClass(Struct, isolate, template);
-    return template;
-}
-
-// Normally this is called from generateClass. Where generateClass creates
-// the constructor (hence, the FunctionTemplate), attachClass adds all
-// of its functions, getters, setters, ...
-// But it's extracted from generateClass because we also have 1 global
-// object (i.e. the Window), which gets attached not only to the Window
-// constructor/FunctionTemplate as normal, but also through the default
-// FunctionTemplate of the isolate (in createContext)
-pub fn attachClass(comptime Struct: type, isolate: v8.Isolate, template: v8.FunctionTemplate) void {
-    const template_proto = template.getPrototypeTemplate();
-    inline for (@typeInfo(Struct).@"struct".decls) |declaration| {
-        const name = declaration.name;
-        if (comptime name[0] == '_') {
-            switch (@typeInfo(@TypeOf(@field(Struct, name)))) {
-                .@"fn" => generateMethod(Struct, name, isolate, template_proto),
-                else => |ti| if (!comptime js.isComplexAttributeType(ti)) {
-                    generateAttribute(Struct, name, isolate, template, template_proto);
-                },
-            }
-        } else if (comptime std.mem.startsWith(u8, name, "get_")) {
-            generateProperty(Struct, name[4..], isolate, template_proto);
-        } else if (comptime std.mem.startsWith(u8, name, "static_")) {
-            generateFunction(Struct, name[7..], isolate, template);
-        }
-    }
-
-    if (@hasDecl(Struct, "get_symbol_toStringTag") == false) {
-        // If this WAS defined, then we would have created it in generateProperty.
-        // But if it isn't, we create a default one
-        const string_tag_callback = v8.FunctionTemplate.initCallback(isolate, struct {
-            fn stringTag(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-                const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-                const class_name = v8.String.initUtf8(info.getIsolate(), comptime js.classNameForStruct(Struct));
-                info.getReturnValue().set(class_name);
-            }
-        }.stringTag);
-        const key = v8.Symbol.getToStringTag(isolate).toName();
-        template_proto.setAccessorGetter(key, string_tag_callback);
-    }
-
-    generateIndexer(Struct, template_proto);
-    generateNamedIndexer(Struct, template.getInstanceTemplate());
-    generateUndetectable(Struct, template.getInstanceTemplate());
-}
-
-// Even if a struct doesn't have a `constructor` function, we still
-// `generateConstructor`, because this is how we create our
-// FunctionTemplate. Such classes exist, but they can't be instantiated
-// via `new ClassName()` - but they could, for example, be created in
-// Zig and returned from a function call, which is why we need the
-// FunctionTemplate.
-fn generateConstructor(comptime Struct: type, isolate: v8.Isolate) v8.FunctionTemplate {
-    const template = v8.FunctionTemplate.initCallback(isolate, struct {
-        fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-            const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-            var caller = Caller.init(info);
-            defer caller.deinit();
-            // See comment above. We generateConstructor on all types
-            // in order to create the FunctionTemplate, but there might
-            // not be an actual "constructor" function. So if someone
-            // does `new ClassName()` where ClassName doesn't have
-            // a constructor function, we'll return an error.
-            if (@hasDecl(Struct, "constructor") == false) {
-                const iso = caller.isolate;
-                log.warn(.js, "Illegal constructor call", .{ .name = @typeName(Struct) });
-                const js_exception = iso.throwException(js._createException(iso, "Illegal Constructor"));
-                info.getReturnValue().set(js_exception);
-                return;
-            }
-
-            // Safe to call now, because if Struct.constructor didn't
-            // exist, the above if block would have returned.
-            const named_function = comptime NamedFunction.init(Struct, "constructor");
-            caller.constructor(Struct, named_function, info) catch |err| {
-                caller.handleError(Struct, named_function, err, info);
-            };
-        }
-    }.callback);
-
-    if (comptime types.isEmpty(types.Receiver(Struct)) == false) {
-        // If the struct is empty, we won't store a Zig reference inside
-        // the JS object, so we don't need to set the internal field count
-        template.getInstanceTemplate().setInternalFieldCount(1);
-    }
-
-    const class_name = v8.String.initUtf8(isolate, comptime js.classNameForStruct(Struct));
-    template.setClassName(class_name);
-    return template;
-}
-
-fn generateMethod(comptime Struct: type, comptime name: []const u8, isolate: v8.Isolate, template_proto: v8.ObjectTemplate) void {
-    var js_name: v8.Name = undefined;
-    if (comptime std.mem.eql(u8, name, "_symbol_iterator")) {
-        js_name = v8.Symbol.getIterator(isolate).toName();
-    } else {
-        js_name = v8.String.initUtf8(isolate, name[1..]).toName();
-    }
-    const function_template = v8.FunctionTemplate.initCallback(isolate, struct {
-        fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-            const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-            var caller = Caller.init(info);
-            defer caller.deinit();
-
-            const named_function = comptime NamedFunction.init(Struct, name);
-            caller.method(Struct, named_function, info) catch |err| {
-                caller.handleError(Struct, named_function, err, info);
-            };
-        }
-    }.callback);
-    template_proto.set(js_name, function_template, v8.PropertyAttribute.None);
-}
-
-fn generateFunction(comptime Struct: type, comptime name: []const u8, isolate: v8.Isolate, template: v8.FunctionTemplate) void {
-    const js_name = v8.String.initUtf8(isolate, name).toName();
-    const function_template = v8.FunctionTemplate.initCallback(isolate, struct {
-        fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-            const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-            var caller = Caller.init(info);
-            defer caller.deinit();
-
-            const named_function = comptime NamedFunction.init(Struct, "static_" ++ name);
-            caller.function(Struct, named_function, info) catch |err| {
-                caller.handleError(Struct, named_function, err, info);
-            };
-        }
-    }.callback);
-    template.set(js_name, function_template, v8.PropertyAttribute.None);
-}
-
-fn generateAttribute(comptime Struct: type, comptime name: []const u8, isolate: v8.Isolate, template: v8.FunctionTemplate, template_proto: v8.ObjectTemplate) void {
-    const zig_value = @field(Struct, name);
-    const js_value = js.simpleZigValueToJs(isolate, zig_value, true);
-
-    const js_name = v8.String.initUtf8(isolate, name[1..]).toName();
-
-    // apply it both to the type itself
-    template.set(js_name, js_value, v8.PropertyAttribute.ReadOnly + v8.PropertyAttribute.DontDelete);
-
-    // and to instances of the type
-    template_proto.set(js_name, js_value, v8.PropertyAttribute.ReadOnly + v8.PropertyAttribute.DontDelete);
-}
-
-fn generateProperty(comptime Struct: type, comptime name: []const u8, isolate: v8.Isolate, template_proto: v8.ObjectTemplate) void {
-    var js_name: v8.Name = undefined;
-    if (comptime std.mem.eql(u8, name, "symbol_toStringTag")) {
-        js_name = v8.Symbol.getToStringTag(isolate).toName();
-    } else {
-        js_name = v8.String.initUtf8(isolate, name).toName();
-    }
-
-    const getter_callback = v8.FunctionTemplate.initCallback(isolate, struct {
-        fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-            const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-            var caller = Caller.init(info);
-            defer caller.deinit();
-
-            const named_function = comptime NamedFunction.init(Struct, "get_" ++ name);
-            caller.method(Struct, named_function, info) catch |err| {
-                caller.handleError(Struct, named_function, err, info);
-            };
-        }
-    }.callback);
-
-    const setter_name = "set_" ++ name;
-    if (@hasDecl(Struct, setter_name) == false) {
-        template_proto.setAccessorGetter(js_name, getter_callback);
-        return;
-    }
-
-    const setter_callback = v8.FunctionTemplate.initCallback(isolate, struct {
-        fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-            const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-            std.debug.assert(info.length() == 1);
-
-            var caller = Caller.init(info);
-            defer caller.deinit();
-
-            const named_function = comptime NamedFunction.init(Struct, "set_" ++ name);
-            caller.method(Struct, named_function, info) catch |err| {
-                caller.handleError(Struct, named_function, err, info);
-            };
-        }
-    }.callback);
-
-    template_proto.setAccessorGetterAndSetter(js_name, getter_callback, setter_callback);
-}
-
-fn generateIndexer(comptime Struct: type, template_proto: v8.ObjectTemplate) void {
-    if (@hasDecl(Struct, "indexed_get") == false) {
-        return;
-    }
-    const configuration = v8.IndexedPropertyHandlerConfiguration{
-        .getter = struct {
-            fn callback(idx: u32, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
-                const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
-                var caller = Caller.init(info);
-                defer caller.deinit();
-
-                const named_function = comptime NamedFunction.init(Struct, "indexed_get");
-                return caller.getIndex(Struct, named_function, idx, info) catch |err| blk: {
-                    caller.handleError(Struct, named_function, err, info);
-                    break :blk v8.Intercepted.No;
-                };
-            }
-        }.callback,
-    };
-
-    // If you're trying to implement setter, read:
-    // https://groups.google.com/g/v8-users/c/8tahYBsHpgY/m/IteS7Wn2AAAJ
-    // The issue I had was
-    // (a) where to attache it: does it go on the instance_template
-    //     instead of the prototype?
-    // (b) defining the getter or query to respond with the
-    //     PropertyAttribute to indicate if the property can be set
-    template_proto.setIndexedProperty(configuration, null);
-}
-
-fn generateNamedIndexer(comptime Struct: type, template_proto: v8.ObjectTemplate) void {
-    if (@hasDecl(Struct, "named_get") == false) {
-        return;
-    }
-
-    var configuration = v8.NamedPropertyHandlerConfiguration{
-        .getter = struct {
-            fn callback(c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
-                const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
-                var caller = Caller.init(info);
-                defer caller.deinit();
-
-                const named_function = comptime NamedFunction.init(Struct, "named_get");
-                return caller.getNamedIndex(Struct, named_function, .{ .handle = c_name.? }, info) catch |err| blk: {
-                    caller.handleError(Struct, named_function, err, info);
-                    break :blk v8.Intercepted.No;
-                };
-            }
-        }.callback,
-
-        // This is really cool. Without this, we'd intercept _all_ properties
-        // even those explicitly set. So, node.length for example would get routed
-        // to our `named_get`, rather than a `get_length`. This might be
-        // useful if we run into a type that we can't model properly in Zig.
-        .flags = v8.PropertyHandlerFlags.OnlyInterceptStrings | v8.PropertyHandlerFlags.NonMasking,
-    };
-
-    if (@hasDecl(Struct, "named_set")) {
-        configuration.setter = struct {
-            fn callback(c_name: ?*const v8.C_Name, c_value: ?*const v8.C_Value, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
-                const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
-                var caller = Caller.init(info);
-                defer caller.deinit();
-
-                const named_function = comptime NamedFunction.init(Struct, "named_set");
-                return caller.setNamedIndex(Struct, named_function, .{ .handle = c_name.? }, .{ .handle = c_value.? }, info) catch |err| blk: {
-                    caller.handleError(Struct, named_function, err, info);
-                    break :blk v8.Intercepted.No;
-                };
-            }
-        }.callback;
-    }
-
-    if (@hasDecl(Struct, "named_delete")) {
-        configuration.deleter = struct {
-            fn callback(c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
-                const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
-                var caller = Caller.init(info);
-                defer caller.deinit();
-
-                const named_function = comptime NamedFunction.init(Struct, "named_delete");
-                return caller.deleteNamedIndex(Struct, named_function, .{ .handle = c_name.? }, info) catch |err| blk: {
-                    caller.handleError(Struct, named_function, err, info);
-                    break :blk v8.Intercepted.No;
-                };
-            }
-        }.callback;
-    }
-    template_proto.setNamedProperty(configuration, null);
-}
-
-fn generateUndetectable(comptime Struct: type, template: v8.ObjectTemplate) void {
-    const has_js_call_as_function = @hasDecl(Struct, "jsCallAsFunction");
-
-    if (has_js_call_as_function) {
-        template.setCallAsFunctionHandler(struct {
-            fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
-                const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
-                var caller = Caller.init(info);
-                defer caller.deinit();
-
-                const named_function = comptime NamedFunction.init(Struct, "jsCallAsFunction");
-                caller.method(Struct, named_function, info) catch |err| {
-                    caller.handleError(Struct, named_function, err, info);
-                };
-            }
-        }.callback);
-    }
-
-    if (@hasDecl(Struct, "mark_as_undetectable") and Struct.mark_as_undetectable) {
-        if (!has_js_call_as_function) {
-            @compileError(@typeName(Struct) ++ ": mark_as_undetectable required jsCallAsFunction to be defined. This is a hard-coded requirement in V8, because mark_as_undetectable only exists for HTMLAllCollection which is also callable.");
-        }
-        template.markAsUndetectable();
-    }
-}
--- a/src/browser/js/ExecutionWorld.zig
+++ b/src/browser/js/ExecutionWorld.zig
@@ -1,251 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const log = @import("../../log.zig");
-const Page = @import("../page.zig").Page;
-const ScriptManager = @import("../ScriptManager.zig");
-
-const types = @import("types.zig");
-const Types = types.Types;
-const Env = @import("Env.zig");
-const Context = @import("Context.zig");
-
-const ArenaAllocator = std.heap.ArenaAllocator;
-
-const CONTEXT_ARENA_RETAIN = 1024 * 64;
-
-// ExecutionWorld closely models a JS World.
-// https://chromium.googlesource.com/chromium/src/+/master/third_party/blink/renderer/bindings/core/v8/V8BindingDesign.md#World
-// https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/ExecutionWorld
-const ExecutionWorld = @This();
-env: *Env,
-
-// Arena whose lifetime is for a single page load. Where
-// the call_arena lives for a single function call, the context_arena
-// lives for the lifetime of the entire page. The allocator will be
-// owned by the Context, but the arena itself is owned by the ExecutionWorld
-// so that we can re-use it from context to context.
-context_arena: ArenaAllocator,
-
-// Currently a context maps to a Browser's Page. Here though, it's only a
-// mechanism to organization page-specific memory. The ExecutionWorld
-// does all the work, but having all page-specific data structures
-// grouped together helps keep things clean.
-context: ?Context = null,
-
-// no init, must be initialized via env.newExecutionWorld()
-
-pub fn deinit(self: *ExecutionWorld) void {
-    if (self.context != null) {
-        self.removeContext();
-    }
-
-    self.context_arena.deinit();
-}
-
-// Only the top Context in the Main ExecutionWorld should hold a handle_scope.
-// A v8.HandleScope is like an arena. Once created, any "Local" that
-// v8 creates will be released (or at least, releasable by the v8 GC)
-// when the handle_scope is freed.
-// We also maintain our own "context_arena" which allows us to have
-// all page related memory easily managed.
-pub fn createContext(self: *ExecutionWorld, page: *Page, enter: bool, global_callback: ?js.GlobalMissingCallback) !*Context {
-    std.debug.assert(self.context == null);
-
-    const env = self.env;
-    const isolate = env.isolate;
-    const Global = @TypeOf(page.window);
-    const templates = &self.env.templates;
-
-    var v8_context: v8.Context = blk: {
-        var temp_scope: v8.HandleScope = undefined;
-        v8.HandleScope.init(&temp_scope, isolate);
-        defer temp_scope.deinit();
-
-        const js_global = v8.FunctionTemplate.initDefault(isolate);
-        Env.attachClass(Global, isolate, js_global);
-
-        const global_template = js_global.getInstanceTemplate();
-        global_template.setInternalFieldCount(1);
-
-        // Configure the missing property callback on the global
-        // object.
-        if (global_callback != null) {
-            const configuration = v8.NamedPropertyHandlerConfiguration{
-                .getter = struct {
-                    fn callback(c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
-                        const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
-                        const context = Context.fromIsolate(info.getIsolate());
-
-                        const property = context.valueToString(.{ .handle = c_name.? }, .{}) catch "???";
-                        if (context.global_callback.?.missing(property, context)) {
-                            return v8.Intercepted.Yes;
-                        }
-                        return v8.Intercepted.No;
-                    }
-                }.callback,
-                .flags = v8.PropertyHandlerFlags.NonMasking | v8.PropertyHandlerFlags.OnlyInterceptStrings,
-            };
-            global_template.setNamedProperty(configuration, null);
-        }
-
-        // All the FunctionTemplates that we created and setup in Env.init
-        // are now going to get associated with our global instance.
-        inline for (Types, 0..) |s, i| {
-            const Struct = s.defaultValue().?;
-            const class_name = v8.String.initUtf8(isolate, comptime js.classNameForStruct(Struct));
-            global_template.set(class_name.toName(), templates[i], v8.PropertyAttribute.None);
-        }
-
-        // The global object (Window) has already been hooked into the v8
-        // engine when the Env was initialized - like every other type.
-        // But the V8 global is its own FunctionTemplate instance so even
-        // though it's also a Window, we need to set the prototype for this
-        // specific instance of the the Window.
-        if (@hasDecl(Global, "prototype")) {
-            const proto_type = types.Receiver(@typeInfo(Global.prototype).pointer.child);
-            const proto_name = @typeName(proto_type);
-            const proto_index = @field(types.LOOKUP, proto_name);
-            js_global.inherit(templates[proto_index]);
-        }
-
-        const context_local = v8.Context.init(isolate, global_template, null);
-        const v8_context = v8.Persistent(v8.Context).init(isolate, context_local).castToContext();
-        v8_context.enter();
-        errdefer if (enter) v8_context.exit();
-        defer if (!enter) v8_context.exit();
-
-        // This shouldn't be necessary, but it is:
-        // https://groups.google.com/g/v8-users/c/qAQQBmbi--8
-        // TODO: see if newer V8 engines have a way around this.
-        inline for (Types, 0..) |s, i| {
-            const Struct = s.defaultValue().?;
-
-            if (@hasDecl(Struct, "prototype")) {
-                const proto_type = types.Receiver(@typeInfo(Struct.prototype).pointer.child);
-                const proto_name = @typeName(proto_type);
-                if (@hasField(types.Lookup, proto_name) == false) {
-                    @compileError("Type '" ++ @typeName(Struct) ++ "' defines an unknown prototype: " ++ proto_name);
-                }
-
-                const proto_index = @field(types.LOOKUP, proto_name);
-                const proto_obj = templates[proto_index].getFunction(v8_context).toObject();
-
-                const self_obj = templates[i].getFunction(v8_context).toObject();
-                _ = self_obj.setPrototype(v8_context, proto_obj);
-            }
-        }
-        break :blk v8_context;
-    };
-
-    // For a Page we only create one HandleScope, it is stored in the main World (enter==true). A page can have multple contexts, 1 for each World.
-    // The main Context that enters and holds the HandleScope should therefore always be created first. Following other worlds for this page
-    // like isolated Worlds, will thereby place their objects on the main page's HandleScope. Note: In the furure the number of context will multiply multiple frames support
-    var handle_scope: ?v8.HandleScope = null;
-    if (enter) {
-        handle_scope = @as(v8.HandleScope, undefined);
-        v8.HandleScope.init(&handle_scope.?, isolate);
-    }
-    errdefer if (enter) handle_scope.?.deinit();
-
-    {
-        // If we want to overwrite the built-in console, we have to
-        // delete the built-in one.
-        const js_obj = v8_context.getGlobal();
-        const console_key = v8.String.initUtf8(isolate, "console");
-        if (js_obj.deleteValue(v8_context, console_key) == false) {
-            return error.ConsoleDeleteError;
-        }
-    }
-    const context_id = env.context_id;
-    env.context_id = context_id + 1;
-
-    self.context = Context{
-        .page = page,
-        .id = context_id,
-        .isolate = isolate,
-        .v8_context = v8_context,
-        .templates = &env.templates,
-        .meta_lookup = &env.meta_lookup,
-        .handle_scope = handle_scope,
-        .script_manager = &page.script_manager,
-        .call_arena = page.call_arena,
-        .arena = self.context_arena.allocator(),
-        .global_callback = global_callback,
-    };
-
-    var context = &self.context.?;
-    {
-        // Store a pointer to our context inside the v8 context so that, given
-        // a v8 context, we can get our context out
-        const data = isolate.initBigIntU64(@intCast(@intFromPtr(context)));
-        v8_context.setEmbedderData(1, data);
-    }
-
-    // Custom exception
-    // NOTE: there is no way in v8 to subclass the Error built-in type
-    // TODO: this is an horrible hack
-    inline for (Types) |s| {
-        const Struct = s.defaultValue().?;
-        if (@hasDecl(Struct, "ErrorSet")) {
-            const script = comptime js.classNameForStruct(Struct) ++ ".prototype.__proto__ = Error.prototype";
-            _ = try context.exec(script, "errorSubclass");
-        }
-    }
-
-    // Primitive attributes are set directly on the FunctionTemplate
-    // when we setup the environment. But we cannot set more complex
-    // types (v8 will crash).
-    //
-    // Plus, just to create more complex types, we always need a
-    // context, i.e. an Array has to have a Context to exist.
-    //
-    // As far as I can tell, getting the FunctionTemplate's object
-    // and setting values directly on it, for each context, is the
-    // way to do this.
-    inline for (Types, 0..) |s, i| {
-        const Struct = s.defaultValue().?;
-        inline for (@typeInfo(Struct).@"struct".decls) |declaration| {
-            const name = declaration.name;
-            if (comptime name[0] == '_') {
-                const value = @field(Struct, name);
-
-                if (comptime js.isComplexAttributeType(@typeInfo(@TypeOf(value)))) {
-                    const js_obj = templates[i].getFunction(v8_context).toObject();
-                    const js_name = v8.String.initUtf8(isolate, name[1..]).toName();
-                    const js_val = try context.zigValueToJs(value);
-                    if (!js_obj.setValue(v8_context, js_name, js_val)) {
-                        log.fatal(.app, "set class attribute", .{
-                            .@"struct" = @typeName(Struct),
-                            .name = name,
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    try context.setupGlobal();
-    return context;
-}
-
-pub fn removeContext(self: *ExecutionWorld) void {
-    // Force running the micro task to drain the queue before reseting the
-    // context arena.
-    // Tasks in the queue are relying to the arena memory could be present in
-    // the queue. Running them later could lead to invalid memory accesses.
-    self.env.runMicrotasks();
-
-    self.context.?.deinit();
-    self.context = null;
-    _ = self.context_arena.reset(.{ .retain_with_limit = CONTEXT_ARENA_RETAIN });
-}
-
-pub fn terminateExecution(self: *const ExecutionWorld) void {
-    self.env.isolate.terminateExecution();
-}
-
-pub fn resumeExecution(self: *const ExecutionWorld) void {
-    self.env.isolate.cancelTerminateExecution();
-}
--- a/src/browser/js/Function.zig
+++ b/src/browser/js/Function.zig
@@ -1,144 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const Caller = @import("Caller.zig");
-const Context = @import("Context.zig");
-const PersistentFunction = v8.Persistent(v8.Function);
-
-const Allocator = std.mem.Allocator;
-
-const Function = @This();
-
-id: usize,
-context: *js.Context,
-this: ?v8.Object = null,
-func: PersistentFunction,
-
-pub const Result = struct {
-    stack: ?[]const u8,
-    exception: []const u8,
-};
-
-pub fn getName(self: *const Function, allocator: Allocator) ![]const u8 {
-    const name = self.func.castToFunction().getName();
-    return self.context.valueToString(name, .{ .allocator = allocator });
-}
-
-pub fn setName(self: *const Function, name: []const u8) void {
-    const v8_name = v8.String.initUtf8(self.context.isolate, name);
-    self.func.castToFunction().setName(v8_name);
-}
-
-pub fn withThis(self: *const Function, value: anytype) !Function {
-    const this_obj = if (@TypeOf(value) == js.Object)
-        value.js_obj
-    else
-        (try self.context.zigValueToJs(value)).castTo(v8.Object);
-
-    return .{
-        .id = self.id,
-        .this = this_obj,
-        .func = self.func,
-        .context = self.context,
-    };
-}
-
-pub fn newInstance(self: *const Function, result: *Result) !js.Object {
-    const context = self.context;
-
-    var try_catch: js.TryCatch = undefined;
-    try_catch.init(context);
-    defer try_catch.deinit();
-
-    // This creates a new instance using this Function as a constructor.
-    // This returns a generic Object
-    const js_obj = self.func.castToFunction().initInstance(context.v8_context, &.{}) orelse {
-        if (try_catch.hasCaught()) {
-            const allocator = context.call_arena;
-            result.stack = try_catch.stack(allocator) catch null;
-            result.exception = (try_catch.exception(allocator) catch "???") orelse "???";
-        } else {
-            result.stack = null;
-            result.exception = "???";
-        }
-        return error.JsConstructorFailed;
-    };
-
-    return .{
-        .context = context,
-        .js_obj = js_obj,
-    };
-}
-
-pub fn call(self: *const Function, comptime T: type, args: anytype) !T {
-    return self.callWithThis(T, self.getThis(), args);
-}
-
-pub fn tryCall(self: *const Function, comptime T: type, args: anytype, result: *Result) !T {
-    return self.tryCallWithThis(T, self.getThis(), args, result);
-}
-
-pub fn tryCallWithThis(self: *const Function, comptime T: type, this: anytype, args: anytype, result: *Result) !T {
-    var try_catch: js.TryCatch = undefined;
-    try_catch.init(self.context);
-    defer try_catch.deinit();
-
-    return self.callWithThis(T, this, args) catch |err| {
-        if (try_catch.hasCaught()) {
-            const allocator = self.context.call_arena;
-            result.stack = try_catch.stack(allocator) catch null;
-            result.exception = (try_catch.exception(allocator) catch @errorName(err)) orelse @errorName(err);
-        } else {
-            result.stack = null;
-            result.exception = @errorName(err);
-        }
-        return err;
-    };
-}
-
-pub fn callWithThis(self: *const Function, comptime T: type, this: anytype, args: anytype) !T {
-    const context = self.context;
-
-    const js_this = try context.valueToExistingObject(this);
-
-    const aargs = if (comptime @typeInfo(@TypeOf(args)) == .null) struct {}{} else args;
-
-    const js_args: []const v8.Value = switch (@typeInfo(@TypeOf(aargs))) {
-        .@"struct" => |s| blk: {
-            const fields = s.fields;
-            var js_args: [fields.len]v8.Value = undefined;
-            inline for (fields, 0..) |f, i| {
-                js_args[i] = try context.zigValueToJs(@field(aargs, f.name));
-            }
-            const cargs: [fields.len]v8.Value = js_args;
-            break :blk &cargs;
-        },
-        .pointer => blk: {
-            var values = try context.call_arena.alloc(v8.Value, args.len);
-            for (args, 0..) |a, i| {
-                values[i] = try context.zigValueToJs(a);
-            }
-            break :blk values;
-        },
-        else => @compileError("JS Function called with invalid paremter type"),
-    };
-
-    const result = self.func.castToFunction().call(context.v8_context, js_this, js_args);
-    if (result == null) {
-        return error.JSExecCallback;
-    }
-
-    if (@typeInfo(T) == .void) return {};
-    const named_function = comptime Caller.NamedFunction.init(T, "callResult");
-    return context.jsValueToZig(named_function, T, result.?);
-}
-
-fn getThis(self: *const Function) v8.Object {
-    return self.this orelse self.context.v8_context.getGlobal();
-}
-
-pub fn src(self: *const Function) ![]const u8 {
-    const value = self.func.castToFunction().toValue();
-    return self.context.valueToString(value, .{});
-}
--- a/src/browser/js/Inspector.zig
+++ b/src/browser/js/Inspector.zig
@@ -1,125 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const Context = @import("Context.zig");
-
-const Allocator = std.mem.Allocator;
-
-const Inspector = @This();
-
-pub const RemoteObject = v8.RemoteObject;
-
-isolate: v8.Isolate,
-inner: *v8.Inspector,
-session: v8.InspectorSession,
-
-// We expect allocator to be an arena
-pub fn init(allocator: Allocator, isolate: v8.Isolate, ctx: anytype) !Inspector {
-    const ContextT = @TypeOf(ctx);
-
-    const InspectorContainer = switch (@typeInfo(ContextT)) {
-        .@"struct" => ContextT,
-        .pointer => |ptr| ptr.child,
-        .void => NoopInspector,
-        else => @compileError("invalid context type"),
-    };
-
-    // If necessary, turn a void context into something we can safely ptrCast
-    const safe_context: *anyopaque = if (ContextT == void) @ptrCast(@constCast(&{})) else ctx;
-
-    const channel = v8.InspectorChannel.init(safe_context, InspectorContainer.onInspectorResponse, InspectorContainer.onInspectorEvent, isolate);
-
-    const client = v8.InspectorClient.init();
-
-    const inner = try allocator.create(v8.Inspector);
-    v8.Inspector.init(inner, client, channel, isolate);
-    return .{ .inner = inner, .isolate = isolate, .session = inner.connect() };
-}
-
-pub fn deinit(self: *const Inspector) void {
-    self.session.deinit();
-    self.inner.deinit();
-}
-
-pub fn send(self: *const Inspector, msg: []const u8) void {
-    // Can't assume the main Context exists (with its HandleScope)
-    // available when doing this. Pages (and thus the HandleScope)
-    // comes and goes, but CDP can keep sending messages.
-    const isolate = self.isolate;
-    var temp_scope: v8.HandleScope = undefined;
-    v8.HandleScope.init(&temp_scope, isolate);
-    defer temp_scope.deinit();
-
-    self.session.dispatchProtocolMessage(isolate, msg);
-}
-
-// From CDP docs
-// https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ExecutionContextDescription
-// ----
-// - name: Human readable name describing given context.
-// - origin: Execution context origin (ie. URL who initialised the request)
-// - auxData: Embedder-specific auxiliary data likely matching
-// {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}
-// - is_default_context: Whether the execution context is default, should match the auxData
-pub fn contextCreated(
-    self: *const Inspector,
-    context: *const Context,
-    name: []const u8,
-    origin: []const u8,
-    aux_data: ?[]const u8,
-    is_default_context: bool,
-) void {
-    self.inner.contextCreated(context.v8_context, name, origin, aux_data, is_default_context);
-}
-
-// Retrieves the RemoteObject for a given value.
-// The value is loaded through the ExecutionWorld's mapZigInstanceToJs function,
-// just like a method return value. Therefore, if we've mapped this
-// value before, we'll get the existing JS PersistedObject and if not
-// we'll create it and track it for cleanup when the context ends.
-pub fn getRemoteObject(
-    self: *const Inspector,
-    context: *Context,
-    group: []const u8,
-    value: anytype,
-) !RemoteObject {
-    const js_value = try context.zigValueToJs(value);
-
-    // We do not want to expose this as a parameter for now
-    const generate_preview = false;
-    return self.session.wrapObject(
-        context.isolate,
-        context.v8_context,
-        js_value,
-        group,
-        generate_preview,
-    );
-}
-
-// Gets a value by object ID regardless of which context it is in.
-pub fn getNodePtr(self: *const Inspector, allocator: Allocator, object_id: []const u8) !?*anyopaque {
-    const unwrapped = try self.session.unwrapObject(allocator, object_id);
-    // The values context and groupId are not used here
-    const toa = getTaggedAnyOpaque(unwrapped.value) orelse return null;
-    if (toa.subtype == null or toa.subtype != .node) return error.ObjectIdIsNotANode;
-    return toa.ptr;
-}
-
-const NoopInspector = struct {
-    pub fn onInspectorResponse(_: *anyopaque, _: u32, _: []const u8) void {}
-    pub fn onInspectorEvent(_: *anyopaque, _: []const u8) void {}
-};
-
-pub fn getTaggedAnyOpaque(value: v8.Value) ?*js.TaggedAnyOpaque {
-    if (value.isObject() == false) {
-        return null;
-    }
-    const obj = value.castTo(v8.Object);
-    if (obj.internalFieldCount() == 0) {
-        return null;
-    }
-
-    const external_data = obj.getInternalField(0).castTo(v8.External).get().?;
-    return @ptrCast(@alignCast(external_data));
-}
--- a/src/browser/js/Object.zig
+++ b/src/browser/js/Object.zig
@@ -1,149 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const Caller = @import("Caller.zig");
-const Context = @import("Context.zig");
-const PersistentObject = v8.Persistent(v8.Object);
-
-const Allocator = std.mem.Allocator;
-
-const Object = @This();
-js_obj: v8.Object,
-context: *js.Context,
-
-pub const SetOpts = packed struct(u32) {
-    READ_ONLY: bool = false,
-    DONT_ENUM: bool = false,
-    DONT_DELETE: bool = false,
-    _: u29 = 0,
-};
-pub fn setIndex(self: Object, index: u32, value: anytype, opts: SetOpts) !void {
-    @setEvalBranchQuota(10000);
-    const key = switch (index) {
-        inline 0...20 => |i| std.fmt.comptimePrint("{d}", .{i}),
-        else => try std.fmt.allocPrint(self.context.arena, "{d}", .{index}),
-    };
-    return self.set(key, value, opts);
-}
-
-pub fn set(self: Object, key: []const u8, value: anytype, opts: SetOpts) error{ FailedToSet, OutOfMemory }!void {
-    const context = self.context;
-
-    const js_key = v8.String.initUtf8(context.isolate, key);
-    const js_value = try context.zigValueToJs(value);
-
-    const res = self.js_obj.defineOwnProperty(context.v8_context, js_key.toName(), js_value, @bitCast(opts)) orelse false;
-    if (!res) {
-        return error.FailedToSet;
-    }
-}
-
-pub fn get(self: Object, key: []const u8) !js.Value {
-    const context = self.context;
-    const js_key = v8.String.initUtf8(context.isolate, key);
-    const js_val = try self.js_obj.getValue(context.v8_context, js_key);
-    return context.createValue(js_val);
-}
-
-pub fn isTruthy(self: Object) bool {
-    const js_value = self.js_obj.toValue();
-    return js_value.toBool(self.context.isolate);
-}
-
-pub fn toString(self: Object) ![]const u8 {
-    const js_value = self.js_obj.toValue();
-    return self.context.valueToString(js_value, .{});
-}
-
-pub fn toDetailString(self: Object) ![]const u8 {
-    const js_value = self.js_obj.toValue();
-    return self.context.valueToDetailString(js_value);
-}
-
-pub fn format(self: Object, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-    return writer.writeAll(try self.toString());
-}
-
-pub fn toJson(self: Object, allocator: Allocator) ![]u8 {
-    const json_string = try v8.Json.stringify(self.context.v8_context, self.js_obj.toValue(), null);
-    const str = try self.context.jsStringToZig(json_string, .{ .allocator = allocator });
-    return str;
-}
-
-pub fn persist(self: Object) !Object {
-    var context = self.context;
-    const js_obj = self.js_obj;
-
-    const persisted = PersistentObject.init(context.isolate, js_obj);
-    try context.js_object_list.append(context.arena, persisted);
-
-    return .{
-        .context = context,
-        .js_obj = persisted.castToObject(),
-    };
-}
-
-pub fn getFunction(self: Object, name: []const u8) !?js.Function {
-    if (self.isNullOrUndefined()) {
-        return null;
-    }
-    const context = self.context;
-
-    const js_name = v8.String.initUtf8(context.isolate, name);
-
-    const js_value = try self.js_obj.getValue(context.v8_context, js_name.toName());
-    if (!js_value.isFunction()) {
-        return null;
-    }
-    return try context.createFunction(js_value);
-}
-
-pub fn isNull(self: Object) bool {
-    return self.js_obj.toValue().isNull();
-}
-
-pub fn isUndefined(self: Object) bool {
-    return self.js_obj.toValue().isUndefined();
-}
-
-pub fn triState(self: Object, comptime Struct: type, comptime name: []const u8, comptime T: type) !TriState(T) {
-    if (self.isNull()) {
-        return .{ .null = {} };
-    }
-    if (self.isUndefined()) {
-        return .{ .undefined = {} };
-    }
-    return .{ .value = try self.toZig(Struct, name, T) };
-}
-
-pub fn isNullOrUndefined(self: Object) bool {
-    return self.js_obj.toValue().isNullOrUndefined();
-}
-
-pub fn nameIterator(self: Object) js.ValueIterator {
-    const context = self.context;
-    const js_obj = self.js_obj;
-
-    const array = js_obj.getPropertyNames(context.v8_context);
-    const count = array.length();
-
-    return .{
-        .count = count,
-        .context = context,
-        .js_obj = array.castTo(v8.Object),
-    };
-}
-
-pub fn toZig(self: Object, comptime Struct: type, comptime name: []const u8, comptime T: type) !T {
-    const named_function = comptime Caller.NamedFunction.init(Struct, name);
-    return self.context.jsValueToZig(named_function, T, self.js_obj.toValue());
-}
-
-pub fn TriState(comptime T: type) type {
-    return union(enum) {
-        null: void,
-        undefined: void,
-        value: T,
-    };
-}
--- a/src/browser/js/Platform.zig
+++ b/src/browser/js/Platform.zig
@@ -1,21 +0,0 @@
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const Platform = @This();
-inner: v8.Platform,
-
-pub fn init() !Platform {
-    if (v8.initV8ICU() == false) {
-        return error.FailedToInitializeICU;
-    }
-    const platform = v8.Platform.initDefault(0, true);
-    v8.initV8Platform(platform);
-    v8.initV8();
-    return .{ .inner = platform };
-}
-
-pub fn deinit(self: Platform) void {
-    _ = v8.deinitV8();
-    v8.deinitV8Platform();
-    self.inner.deinit();
-}
--- a/src/browser/js/This.zig
+++ b/src/browser/js/This.zig
@@ -1,25 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const Allocator = std.mem.Allocator;
-
-// This only exists so that we know whether a function wants the opaque
-// JS argument (js.Object), or if it wants the receiver as an opaque
-// value.
-// js.Object is normally used when a method wants an opaque JS object
-// that it'll pass into a callback.
-// This is used when the function wants to do advanced manipulation
-// of the v8.Object bound to the instance. For example, postAttach is an
-// example of using This.
-
-const This = @This();
-obj: js.Object,
-
-pub fn setIndex(self: This, index: u32, value: anytype, opts: js.Object.SetOpts) !void {
-    return self.obj.setIndex(index, value, opts);
-}
-
-pub fn set(self: This, key: []const u8, value: anytype, opts: js.Object.SetOpts) !void {
-    return self.obj.set(key, value, opts);
-}
--- a/src/browser/js/TryCatch.zig
+++ b/src/browser/js/TryCatch.zig
@@ -1,64 +0,0 @@
-const std = @import("std");
-const js = @import("js.zig");
-const v8 = js.v8;
-
-const Allocator = std.mem.Allocator;
-
-const TryCatch = @This();
-
-inner: v8.TryCatch,
-context: *const js.Context,
-
-pub fn init(self: *TryCatch, context: *const js.Context) void {
-    self.context = context;
-    self.inner.init(context.isolate);
-}
-
-pub fn hasCaught(self: TryCatch) bool {
-    return self.inner.hasCaught();
-}
-
-// the caller needs to deinit the string returned
-pub fn exception(self: TryCatch, allocator: Allocator) !?[]const u8 {
-    const msg = self.inner.getException() orelse return null;
-    return try self.context.valueToString(msg, .{ .allocator = allocator });
-}
-
-// the caller needs to deinit the string returned
-pub fn stack(self: TryCatch, allocator: Allocator) !?[]const u8 {
-    const context = self.context;
-    const s = self.inner.getStackTrace(context.v8_context) orelse return null;
-    return try context.valueToString(s, .{ .allocator = allocator });
-}
-
-// the caller needs to deinit the string returned
-pub fn sourceLine(self: TryCatch, allocator: Allocator) !?[]const u8 {
-    const context = self.context;
-    const msg = self.inner.getMessage() orelse return null;
-    const sl = msg.getSourceLine(context.v8_context) orelse return null;
-    return try context.jsStringToZig(sl, .{ .allocator = allocator });
-}
-
-pub fn sourceLineNumber(self: TryCatch) ?u32 {
-    const context = self.context;
-    const msg = self.inner.getMessage() orelse return null;
-    return msg.getLineNumber(context.v8_context);
-}
-
-// a shorthand method to return either the entire stack message
-// or just the exception message
-// - in Debug mode return the stack if available
-// - otherwise return the exception if available
-// the caller needs to deinit the string returned
-pub fn err(self: TryCatch, allocator: Allocator) !?[]const u8 {
-    if (comptime @import("builtin").mode == .Debug) {
-        if (try self.stack(allocator)) |msg| {
-            return msg;
-        }
-    }
-    return try self.exception(allocator);
-}
-
-pub fn deinit(self: *TryCatch) void {
-    self.inner.deinit();
-}
--- a/src/browser/js/generate.zig
+++ b/src/browser/js/generate.zig
@@ -1,231 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-// ----
-const Type = std.builtin.Type;
-
-// Union
-// -----
-
-// Generate a flatten tagged Union from a Tuple
-pub fn Union(comptime interfaces: anytype) type {
-    // @setEvalBranchQuota(10000);
-    const tuple = Tuple(interfaces){};
-    const fields = std.meta.fields(@TypeOf(tuple));
-
-    const tag_type = switch (fields.len) {
-        0 => unreachable,
-        1 => u0,
-        2 => u1,
-        3...4 => u2,
-        5...8 => u3,
-        9...16 => u4,
-        17...32 => u5,
-        33...64 => u6,
-        65...128 => u7,
-        129...256 => u8,
-        else => @compileError("Too many interfaces to generate union"),
-    };
-
-    // second iteration to generate tags
-    var enum_fields: [fields.len]Type.EnumField = undefined;
-    for (fields, 0..) |field, index| {
-        const member = @field(tuple, field.name);
-        const full_name = @typeName(member);
-        const separator = std.mem.lastIndexOfScalar(u8, full_name, '.') orelse unreachable;
-        const name = full_name[separator + 1 ..];
-        enum_fields[index] = .{
-            .name = name ++ "",
-            .value = index,
-        };
-    }
-
-    const enum_info = Type.Enum{
-        .tag_type = tag_type,
-        .fields = &enum_fields,
-        .decls = &.{},
-        .is_exhaustive = true,
-    };
-    const enum_T = @Type(.{ .@"enum" = enum_info });
-
-    // third iteration to generate union type
-    var union_fields: [fields.len]Type.UnionField = undefined;
-    for (fields, enum_fields, 0..) |field, e, index| {
-        var FT = @field(tuple, field.name);
-        if (@hasDecl(FT, "Self")) {
-            FT = *(@field(FT, "Self"));
-        } else if (!@hasDecl(FT, "union_make_copy")) {
-            FT = *FT;
-        }
-        union_fields[index] = .{
-            .type = FT,
-            .name = e.name,
-            .alignment = @alignOf(FT),
-        };
-    }
-
-    return @Type(.{ .@"union" = .{
-        .layout = .auto,
-        .tag_type = enum_T,
-        .fields = &union_fields,
-        .decls = &.{},
-    } });
-}
-
-// Tuple
-// -----
-
-// Flattens and depuplicates a list of nested tuples. For example
-// input: {A, B, {C, B, D}, {A, E}}
-// output {A, B, C, D, E}
-pub fn Tuple(comptime args: anytype) type {
-    @setEvalBranchQuota(100000);
-
-    const count = countInterfaces(args, 0);
-    var interfaces: [count]type = undefined;
-    _ = flattenInterfaces(args, &interfaces, 0);
-
-    const unfiltered_count, const filter_set = filterMap(count, interfaces);
-
-    var field_index: usize = 0;
-    var fields: [unfiltered_count]Type.StructField = undefined;
-
-    for (filter_set, 0..) |filter, i| {
-        if (filter) {
-            continue;
-        }
-        fields[field_index] = .{
-            .name = std.fmt.comptimePrint("{d}", .{field_index}),
-            .type = type,
-            // has to be true in order to properly capture the default value
-            .is_comptime = true,
-            .alignment = @alignOf(type),
-            .default_value_ptr = @ptrCast(&interfaces[i]),
-        };
-        field_index += 1;
-    }
-
-    return @Type(.{ .@"struct" = .{
-        .layout = .auto,
-        .fields = &fields,
-        .decls = &.{},
-        .is_tuple = true,
-    } });
-}
-
-fn countInterfaces(args: anytype, count: usize) usize {
-    var new_count = count;
-    for (@typeInfo(@TypeOf(args)).@"struct".fields) |f| {
-        const member = @field(args, f.name);
-        if (@TypeOf(member) == type) {
-            new_count += 1;
-        } else {
-            new_count = countInterfaces(member, new_count);
-        }
-    }
-    return new_count;
-}
-
-fn flattenInterfaces(args: anytype, interfaces: []type, index: usize) usize {
-    var new_index = index;
-    for (@typeInfo(@TypeOf(args)).@"struct".fields) |f| {
-        const member = @field(args, f.name);
-        if (@TypeOf(member) == type) {
-            interfaces[new_index] = member;
-            new_index += 1;
-        } else {
-            new_index = flattenInterfaces(member, interfaces, new_index);
-        }
-    }
-    return new_index;
-}
-
-fn filterMap(comptime count: usize, interfaces: [count]type) struct { usize, [count]bool } {
-    var map: [count]bool = undefined;
-    var unfiltered_count: usize = 0;
-    outer: for (interfaces, 0..) |iface, i| {
-        for (interfaces[i + 1 ..]) |check| {
-            if (iface == check) {
-                map[i] = true;
-                continue :outer;
-            }
-        }
-        map[i] = false;
-        unfiltered_count += 1;
-    }
-    return .{ unfiltered_count, map };
-}
-
-test "generate: Union" {
-    const Astruct = struct {
-        pub const Self = Other;
-        const Other = struct {};
-    };
-
-    const Bstruct = struct {
-        value: u8 = 0,
-    };
-
-    const Cstruct = struct {
-        value: u8 = 0,
-    };
-
-    const value = Union(.{ Astruct, Bstruct, .{Cstruct} });
-    const ti = @typeInfo(value).@"union";
-    try std.testing.expectEqual(3, ti.fields.len);
-    try std.testing.expectEqualStrings("*browser.js.generate.test.generate: Union.Astruct.Other", @typeName(ti.fields[0].type));
-    try std.testing.expectEqualStrings(ti.fields[0].name, "Astruct");
-    try std.testing.expectEqual(*Bstruct, ti.fields[1].type);
-    try std.testing.expectEqualStrings(ti.fields[1].name, "Bstruct");
-    try std.testing.expectEqual(*Cstruct, ti.fields[2].type);
-    try std.testing.expectEqualStrings(ti.fields[2].name, "Cstruct");
-}
-
-test "generate: Tuple" {
-    const Astruct = struct {};
-
-    const Bstruct = struct {
-        value: u8 = 0,
-    };
-
-    const Cstruct = struct {
-        value: u8 = 0,
-    };
-
-    {
-        const tuple = Tuple(.{ Astruct, Bstruct }){};
-        const ti = @typeInfo(@TypeOf(tuple)).@"struct";
-        try std.testing.expectEqual(true, ti.is_tuple);
-        try std.testing.expectEqual(2, ti.fields.len);
-        try std.testing.expectEqual(Astruct, tuple.@"0");
-        try std.testing.expectEqual(Bstruct, tuple.@"1");
-    }
-
-    {
-        // dedupe
-        const tuple = Tuple(.{ Cstruct, Astruct, .{Astruct}, Bstruct, .{ Astruct, .{ Astruct, Bstruct } } }){};
-        const ti = @typeInfo(@TypeOf(tuple)).@"struct";
-        try std.testing.expectEqual(true, ti.is_tuple);
-        try std.testing.expectEqual(3, ti.fields.len);
-        try std.testing.expectEqual(Cstruct, tuple.@"0");
-        try std.testing.expectEqual(Astruct, tuple.@"1");
-        try std.testing.expectEqual(Bstruct, tuple.@"2");
-    }
-}
--- a/src/browser/js/js.zig
+++ b/src/browser/js/js.zig
@@ -1,504 +0,0 @@
-// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-pub const v8 = @import("v8");
-
-const types = @import("types.zig");
-const log = @import("../../log.zig");
-const Page = @import("../page.zig").Page;
-
-const Allocator = std.mem.Allocator;
-
-pub const Env = @import("Env.zig");
-pub const ExecutionWorld = @import("ExecutionWorld.zig");
-pub const Context = @import("Context.zig");
-pub const Inspector = @import("Inspector.zig");
-
-// TODO: Is "This" really necessary?
-pub const This = @import("This.zig");
-pub const Object = @import("Object.zig");
-pub const TryCatch = @import("TryCatch.zig");
-pub const Function = @import("Function.zig");
-
-const Caller = @import("Caller.zig");
-const NamedFunction = Context.NamedFunction;
-
-// If a function returns a []i32, should that map to a plain-old
-// JavaScript array, or a Int32Array? It's ambiguous. By default, we'll
-// map arrays/slices to the JavaScript arrays. If you want a TypedArray
-// wrap it in this.
-// Also, this type has nothing to do with the Env. But we place it here
-// for consistency. Want a callback? Env.Callback. Want a JsObject?
-// Env.JsObject. Want a TypedArray? Env.TypedArray.
-pub fn TypedArray(comptime T: type) type {
-    return struct {
-        pub const _TYPED_ARRAY_ID_KLUDGE = true;
-
-        values: []const T,
-
-        pub fn dupe(self: TypedArray(T), allocator: Allocator) !TypedArray(T) {
-            return .{ .values = try allocator.dupe(T, self.values) };
-        }
-    };
-}
-
-pub const PromiseResolver = struct {
-    context: *Context,
-    resolver: v8.PromiseResolver,
-
-    pub fn promise(self: PromiseResolver) Promise {
-        return self.resolver.getPromise();
-    }
-
-    pub fn resolve(self: PromiseResolver, value: anytype) !void {
-        const context = self.context;
-        const js_value = try context.zigValueToJs(value);
-
-        // resolver.resolve will return null if the promise isn't pending
-        const ok = self.resolver.resolve(context.v8_context, js_value) orelse return;
-        if (!ok) {
-            return error.FailedToResolvePromise;
-        }
-    }
-
-    pub fn reject(self: PromiseResolver, value: anytype) !void {
-        const context = self.context;
-        const js_value = try context.zigValueToJs(value);
-
-        // resolver.reject will return null if the promise isn't pending
-        const ok = self.resolver.reject(context.v8_context, js_value) orelse return;
-        if (!ok) {
-            return error.FailedToRejectPromise;
-        }
-    }
-};
-
-pub const PersistentPromiseResolver = struct {
-    context: *Context,
-    resolver: v8.Persistent(v8.PromiseResolver),
-
-    pub fn deinit(self: *PersistentPromiseResolver) void {
-        self.resolver.deinit();
-    }
-
-    pub fn promise(self: PersistentPromiseResolver) Promise {
-        return self.resolver.castToPromiseResolver().getPromise();
-    }
-
-    pub fn resolve(self: PersistentPromiseResolver, value: anytype) !void {
-        const context = self.context;
-        const js_value = try context.zigValueToJs(value);
-
-        // resolver.resolve will return null if the promise isn't pending
-        const ok = self.resolver.castToPromiseResolver().resolve(context.v8_context, js_value) orelse return;
-        if (!ok) {
-            return error.FailedToResolvePromise;
-        }
-    }
-
-    pub fn reject(self: PersistentPromiseResolver, value: anytype) !void {
-        const context = self.context;
-        const js_value = try context.zigValueToJs(value);
-
-        // resolver.reject will return null if the promise isn't pending
-        const ok = self.resolver.castToPromiseResolver().reject(context.v8_context, js_value) orelse return;
-        if (!ok) {
-            return error.FailedToRejectPromise;
-        }
-    }
-};
-
-pub const Promise = v8.Promise;
-
-// When doing jsValueToZig, string ([]const u8) are managed by the
-// call_arena. That means that if the API wants to persist the string
-// (which is relatively common), it needs to dupe it again.
-// If the parameter is an Env.String rather than a []const u8, then
-// the page's arena will be used (rather than the call arena).
-pub const String = struct {
-    string: []const u8,
-};
-
-pub const Exception = struct {
-    inner: v8.Value,
-    context: *const Context,
-
-    // the caller needs to deinit the string returned
-    pub fn exception(self: Exception, allocator: Allocator) ![]const u8 {
-        return self.context.valueToString(self.inner, .{ .allocator = allocator });
-    }
-};
-
-pub const Value = struct {
-    value: v8.Value,
-    context: *const Context,
-
-    // the caller needs to deinit the string returned
-    pub fn toString(self: Value, allocator: Allocator) ![]const u8 {
-        return self.context.valueToString(self.value, .{ .allocator = allocator });
-    }
-
-    pub fn fromJson(ctx: *Context, json: []const u8) !Value {
-        const json_string = v8.String.initUtf8(ctx.isolate, json);
-        const value = try v8.Json.parse(ctx.v8_context, json_string);
-        return Value{ .context = ctx, .value = value };
-    }
-};
-
-pub const ValueIterator = struct {
-    count: u32,
-    idx: u32 = 0,
-    js_obj: v8.Object,
-    context: *const Context,
-
-    pub fn next(self: *ValueIterator) !?Value {
-        const idx = self.idx;
-        if (idx == self.count) {
-            return null;
-        }
-        self.idx += 1;
-
-        const context = self.context;
-        const js_val = try self.js_obj.getAtIndex(context.v8_context, idx);
-        return context.createValue(js_val);
-    }
-};
-
-pub fn UndefinedOr(comptime T: type) type {
-    return union(enum) {
-        undefined: void,
-        value: T,
-    };
-}
-
-// An interface for types that want to have their jsScopeEnd function be
-// called when the call context ends
-const CallScopeEndCallback = struct {
-    ptr: *anyopaque,
-    callScopeEndFn: *const fn (ptr: *anyopaque) void,
-
-    fn init(ptr: anytype) CallScopeEndCallback {
-        const T = @TypeOf(ptr);
-        const ptr_info = @typeInfo(T);
-
-        const gen = struct {
-            pub fn callScopeEnd(pointer: *anyopaque) void {
-                const self: T = @ptrCast(@alignCast(pointer));
-                return ptr_info.pointer.child.jsCallScopeEnd(self);
-            }
-        };
-
-        return .{
-            .ptr = ptr,
-            .callScopeEndFn = gen.callScopeEnd,
-        };
-    }
-
-    pub fn callScopeEnd(self: CallScopeEndCallback) void {
-        self.callScopeEndFn(self.ptr);
-    }
-};
-
-// Callback called on global's property missing.
-// Return true to intercept the execution or false to let the call
-// continue the chain.
-pub const GlobalMissingCallback = struct {
-    ptr: *anyopaque,
-    missingFn: *const fn (ptr: *anyopaque, name: []const u8, ctx: *Context) bool,
-
-    pub fn init(ptr: anytype) GlobalMissingCallback {
-        const T = @TypeOf(ptr);
-        const ptr_info = @typeInfo(T);
-
-        const gen = struct {
-            pub fn missing(pointer: *anyopaque, name: []const u8, ctx: *Context) bool {
-                const self: T = @ptrCast(@alignCast(pointer));
-                return ptr_info.pointer.child.missing(self, name, ctx);
-            }
-        };
-
-        return .{
-            .ptr = ptr,
-            .missingFn = gen.missing,
-        };
-    }
-
-    pub fn missing(self: GlobalMissingCallback, name: []const u8, ctx: *Context) bool {
-        return self.missingFn(self.ptr, name, ctx);
-    }
-};
-
-// Attributes that return a primitive type are setup directly on the
-// FunctionTemplate when the Env is setup. More complex types need a v8.Context
-// and cannot be set directly on the FunctionTemplate.
-// We default to saying types are primitives because that's mostly what
-// we have. If we add a new complex type that isn't explictly handled here,
-// we'll get a compiler error in simpleZigValueToJs, and can then explicitly
-// add the type here.
-pub fn isComplexAttributeType(ti: std.builtin.Type) bool {
-    return switch (ti) {
-        .array => true,
-        else => false,
-    };
-}
-
-// These are simple types that we can convert to JS with only an isolate. This
-// is separated from the Caller's zigValueToJs to make it available when we
-// don't have a caller (i.e., when setting static attributes on types)
-pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bool) if (fail) v8.Value else ?v8.Value {
-    switch (@typeInfo(@TypeOf(value))) {
-        .void => return v8.initUndefined(isolate).toValue(),
-        .null => return v8.initNull(isolate).toValue(),
-        .bool => return v8.getValue(if (value) v8.initTrue(isolate) else v8.initFalse(isolate)),
-        .int => |n| switch (n.signedness) {
-            .signed => {
-                if (value >= -2_147_483_648 and value <= 2_147_483_647) {
-                    return v8.Integer.initI32(isolate, @intCast(value)).toValue();
-                }
-                if (comptime n.bits <= 64) {
-                    return v8.getValue(v8.BigInt.initI64(isolate, @intCast(value)));
-                }
-                @compileError(@typeName(value) ++ " is not supported");
-            },
-            .unsigned => {
-                if (value <= 4_294_967_295) {
-                    return v8.Integer.initU32(isolate, @intCast(value)).toValue();
-                }
-                if (comptime n.bits <= 64) {
-                    return v8.getValue(v8.BigInt.initU64(isolate, @intCast(value)));
-                }
-                @compileError(@typeName(value) ++ " is not supported");
-            },
-        },
-        .comptime_int => {
-            if (value >= 0) {
-                if (value <= 4_294_967_295) {
-                    return v8.Integer.initU32(isolate, @intCast(value)).toValue();
-                }
-                return v8.BigInt.initU64(isolate, @intCast(value)).toValue();
-            }
-            if (value >= -2_147_483_648) {
-                return v8.Integer.initI32(isolate, @intCast(value)).toValue();
-            }
-            return v8.BigInt.initI64(isolate, @intCast(value)).toValue();
-        },
-        .comptime_float => return v8.Number.init(isolate, value).toValue(),
-        .float => |f| switch (f.bits) {
-            64 => return v8.Number.init(isolate, value).toValue(),
-            32 => return v8.Number.init(isolate, @floatCast(value)).toValue(),
-            else => @compileError(@typeName(value) ++ " is not supported"),
-        },
-        .pointer => |ptr| {
-            if (ptr.size == .slice and ptr.child == u8) {
-                return v8.String.initUtf8(isolate, value).toValue();
-            }
-            if (ptr.size == .one) {
-                const one_info = @typeInfo(ptr.child);
-                if (one_info == .array and one_info.array.child == u8) {
-                    return v8.String.initUtf8(isolate, value).toValue();
-                }
-            }
-        },
-        .array => return simpleZigValueToJs(isolate, &value, fail),
-        .optional => {
-            if (value) |v| {
-                return simpleZigValueToJs(isolate, v, fail);
-            }
-            return v8.initNull(isolate).toValue();
-        },
-        .@"struct" => {
-            const T = @TypeOf(value);
-            if (@hasDecl(T, "_TYPED_ARRAY_ID_KLUDGE")) {
-                const values = value.values;
-                const value_type = @typeInfo(@TypeOf(values)).pointer.child;
-                const len = values.len;
-                const bits = switch (@typeInfo(value_type)) {
-                    .int => |n| n.bits,
-                    .float => |f| f.bits,
-                    else => @compileError("Invalid TypeArray type: " ++ @typeName(value_type)),
-                };
-
-                var array_buffer: v8.ArrayBuffer = undefined;
-                if (len == 0) {
-                    array_buffer = v8.ArrayBuffer.init(isolate, 0);
-                } else {
-                    const buffer_len = len * bits / 8;
-                    const backing_store = v8.BackingStore.init(isolate, buffer_len);
-                    const data: [*]u8 = @ptrCast(@alignCast(backing_store.getData()));
-                    @memcpy(data[0..buffer_len], @as([]const u8, @ptrCast(values))[0..buffer_len]);
-                    array_buffer = v8.ArrayBuffer.initWithBackingStore(isolate, &backing_store.toSharedPtr());
-                }
-
-                switch (@typeInfo(value_type)) {
-                    .int => |n| switch (n.signedness) {
-                        .unsigned => switch (n.bits) {
-                            8 => return v8.Uint8Array.init(array_buffer, 0, len).toValue(),
-                            16 => return v8.Uint16Array.init(array_buffer, 0, len).toValue(),
-                            32 => return v8.Uint32Array.init(array_buffer, 0, len).toValue(),
-                            64 => return v8.BigUint64Array.init(array_buffer, 0, len).toValue(),
-                            else => {},
-                        },
-                        .signed => switch (n.bits) {
-                            8 => return v8.Int8Array.init(array_buffer, 0, len).toValue(),
-                            16 => return v8.Int16Array.init(array_buffer, 0, len).toValue(),
-                            32 => return v8.Int32Array.init(array_buffer, 0, len).toValue(),
-                            64 => return v8.BigInt64Array.init(array_buffer, 0, len).toValue(),
-                            else => {},
-                        },
-                    },
-                    .float => |f| switch (f.bits) {
-                        32 => return v8.Float32Array.init(array_buffer, 0, len).toValue(),
-                        64 => return v8.Float64Array.init(array_buffer, 0, len).toValue(),
-                        else => {},
-                    },
-                    else => {},
-                }
-                // We normally don't fail in this function unless fail == true
-                // but this can never be valid.
-                @compileError("Invalid TypeArray type: " ++ @typeName(value_type));
-            }
-        },
-        .@"union" => return simpleZigValueToJs(isolate, std.meta.activeTag(value), fail),
-        .@"enum" => {
-            const T = @TypeOf(value);
-            if (@hasDecl(T, "toString")) {
-                // This should be deprecated in favor of the ENUM_JS_USE_TAG.
-                return simpleZigValueToJs(isolate, value.toString(), fail);
-            }
-
-            if (@hasDecl(T, "ENUM_JS_USE_TAG")) {
-                return simpleZigValueToJs(isolate, @tagName(value), fail);
-            }
-        },
-        else => {},
-    }
-    if (fail) {
-        @compileError("Unsupported Zig type " ++ @typeName(@TypeOf(value)));
-    }
-    return null;
-}
-
-pub fn _createException(isolate: v8.Isolate, msg: []const u8) v8.Value {
-    return v8.Exception.initError(v8.String.initUtf8(isolate, msg));
-}
-
-pub fn classNameForStruct(comptime Struct: type) []const u8 {
-    if (@hasDecl(Struct, "js_name")) {
-        return Struct.js_name;
-    }
-    @setEvalBranchQuota(10_000);
-    const full_name = @typeName(Struct);
-    const last = std.mem.lastIndexOfScalar(u8, full_name, '.') orelse return full_name;
-    return full_name[last + 1 ..];
-}
-
-// When we return a Zig object to V8, we put it on the heap and pass it into
-// v8 as an *anyopaque (i.e. void *). When V8 gives us back the value, say, as a
-// function parameter, we know what type it _should_ be. Above, in Caller.method
-// (for example), we know all the parameter types. So if a Zig function takes
-// a single parameter (its receiver), we know what that type is.
-//
-// In a simple/perfect world, we could use this knowledge to cast the *anyopaque
-// to the parameter type:
-//   const arg: @typeInfo(@TypeOf(function)).@"fn".params[0] = @ptrCast(v8_data);
-//
-// But there are 2 reasons we can't do that.
-//
-// == Reason 1 ==
-// The JS code might pass the wrong type:
-//
-//   var cat = new Cat();
-//   cat.setOwner(new Cat());
-//
-// The zig _setOwner method expects the 2nd parameter to be an *Owner, but
-// the JS code passed a *Cat.
-//
-// To solve this issue, we tag every returned value so that we can check what
-// type it is. In the above case, we'd expect an *Owner, but the tag would tell
-// us that we got a *Cat. We use the type index in our Types lookup as the tag.
-//
-// == Reason 2 ==
-// Because of prototype inheritance, even "correct" code can be a challenge. For
-// example, say the above JavaScript is fixed:
-//
-//   var cat = new Cat();
-//   cat.setOwner(new Owner("Leto"));
-//
-// The issue is that setOwner might not expect an *Owner, but rather a
-// *Person, which is the prototype for Owner. Now our Zig code is expecting
-// a *Person, but it was (correctly) given an *Owner.
-// For this reason, we also store the prototype's type index.
-//
-// One of the prototype mechanisms that we support is via composition. Owner
-// can have a "proto: *Person" field. For this reason, we also store the offset
-// of the proto field, so that, given an intFromPtr(*Owner) we can access its
-// proto field.
-//
-// The other prototype mechanism that we support is for netsurf, where we just
-// cast one type to another. In this case, we'll store an offset of -1 (as a
-// sentinel to indicate that we should just cast directly).
-pub const TaggedAnyOpaque = struct {
-    // The type of object this is. The type is captured as an index, which
-    // corresponds to both a field in TYPE_LOOKUP and the index of
-    // PROTOTYPE_TABLE
-    index: u16,
-
-    // Ptr to the Zig instance. Between the context where it's called (i.e.
-    // we have the comptime parameter info for all functions), and the index field
-    // we can figure out what type this is.
-    ptr: *anyopaque,
-
-    // When we're asked to describe an object via the Inspector, we _must_ include
-    // the proper subtype (and description) fields in the returned JSON.
-    // V8 will give us a Value and ask us for the subtype. From the v8.Value we
-    // can get a v8.Object, and from the v8.Object, we can get out TaggedAnyOpaque
-    // which is where we store the subtype.
-    subtype: ?types.Sub,
-};
-
-// These are here, and not in Inspector.zig, because Inspector.zig isn't always
-// included (e.g. in the wpt build).
-
-// This is called from V8. Whenever the v8 inspector has to describe a value
-// it'll call this function to gets its [optional] subtype - which, from V8's
-// point of view, is an arbitrary string.
-pub export fn v8_inspector__Client__IMPL__valueSubtype(
-    _: *v8.c.InspectorClientImpl,
-    c_value: *const v8.C_Value,
-) callconv(.c) [*c]const u8 {
-    const external_entry = Inspector.getTaggedAnyOpaque(.{ .handle = c_value }) orelse return null;
-    return if (external_entry.subtype) |st| @tagName(st) else null;
-}
-
-// Same as valueSubType above, but for the optional description field.
-// From what I can tell, some drivers _need_ the description field to be
-// present, even if it's empty. So if we have a subType for the value, we'll
-// put an empty description.
-pub export fn v8_inspector__Client__IMPL__descriptionForValueSubtype(
-    _: *v8.c.InspectorClientImpl,
-    v8_context: *const v8.C_Context,
-    c_value: *const v8.C_Value,
-) callconv(.c) [*c]const u8 {
-    _ = v8_context;
-
-    // We _must_ include a non-null description in order for the subtype value
-    // to be included. Besides that, I don't know if the value has any meaning
-    const external_entry = Inspector.getTaggedAnyOpaque(.{ .handle = c_value }) orelse return null;
-    return if (external_entry.subtype == null) null else "";
-}
--- a/Show More
+++ b/Show More