subprojects: Prepare for release

subprojects: Bump outdated
android: Bump frida-java-bridge in system-server
2026-11-09 10:09:38 -10:00 · 2025-07-21 15:06:16 +02:00 · 2025-07-21 15:04:37 +02:00 · 2025-07-21 14:51:52 +02:00 · 2025-07-18 10:32:18 +02:00 · 2025-07-18 10:28:26 +02:00
320 changed files with 294260 additions and 8310 deletions
@@ -0,0 +1 @@
+github: frida
@@ -16,13 +16,13 @@ jobs:
    strategy:
      matrix:
        include:
-          - { id: windows-x86_64, runner: '"windows-latest"'                    }
-          - { id: windows-x86,    runner: '"windows-latest"'                    }
-          - { id: macos-x86_64,   runner: '"macos-11"'                          }
-          - { id: macos-arm64,    runner: '"macos-latest"'                      }
-          - { id: linux-x86_64,   runner: '"ubuntu-latest"'                     }
-          - { id: linux-x86,      runner: '"ubuntu-latest"'                     }
-          - { id: freebsd-arm64,  runner: '["self-hosted", "freebsd", "arm64"]' }
+          - { id: windows-arm64,  runner: '"windows-11-arm"', sys: CLANGARM64, pkg: 'mingw-w64-clang-aarch64-clang' }
+          - { id: windows-x86_64, runner: '"windows-latest"', sys: MINGW64,    pkg: 'mingw-w64-x86_64-gcc'          }
+          - { id: windows-x86,    runner: '"windows-latest"', sys: MINGW32,    pkg: 'mingw-w64-i686-gcc'            }
+          - { id: macos-x86_64,   runner: '"macos-latest"'                                                          }
+          - { id: macos-arm64,    runner: '"macos-latest"'                                                          }
+          - { id: linux-x86_64,   runner: '"ubuntu-latest"'                                                         }
+          - { id: linux-x86,      runner: '"ubuntu-latest"'                                                         }
      fail-fast: false
    runs-on: ${{ fromJSON(matrix.runner) }}
    steps:
@@ -30,6 +30,18 @@ jobs:
        uses: actions/checkout@v4
        with:
          submodules: recursive
+      - name: Install MinGW toolchain for cgo support
+        if: ${{ startsWith(matrix.id, 'windows-') }}
+        id: msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.sys }}
+          install: ${{ matrix.pkg }}
+      - name: Install Go toolchain
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'src/compiler/go.mod'
+          cache-dependency-path: 'src/compiler/go.mod'
      - name: Set up Apple certificates
        if: ${{ startsWith(matrix.id, 'macos-') }}
        uses: ./.github/actions/setup-apple-certificates
@@ -42,22 +54,35 @@ jobs:
        run: sudo security authorizationdb write system.privilege.taskport allow
      - name: Install gcc-multilib
        if: matrix.id == 'linux-x86'
-        run: sudo apt-get install gcc-multilib lib32stdc++-11-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get install gcc-multilib lib32stdc++-13-dev
      - name: Build
        if: ${{ startsWith(matrix.id, 'windows-') }}
        run: |
-          .\configure ${{ env.FRIDA_CORE_OPTIONS }}
+          .\configure `
+              --host=${{ matrix.id }} `
+              --enable-compiler-backend `
+              ${{ env.FRIDA_CORE_OPTIONS }}
          .\make
+        env:
+          MSYS2_LOCATION: ${{ steps.msys2.outputs.msys2-location }}
      - name: Build
        if: ${{ !startsWith(matrix.id, 'windows-') && matrix.id != 'linux-x86' }}
        run: |
-          ./configure ${{ env.FRIDA_CORE_OPTIONS }}
+          ./configure \
+              --enable-compiler-backend \
+              ${{ env.FRIDA_CORE_OPTIONS }}
          make
      - name: Build
        if: matrix.id == 'linux-x86'
        run: |
          CC="gcc -m32" CXX="g++ -m32" STRIP="strip" \
-              ./configure --build=linux-x86 --host=linux-x86 ${{ env.FRIDA_CORE_OPTIONS }}
+              ./configure \
+                --build=linux-x86 \
+                --host=linux-x86 \
+                --enable-compiler-backend \
+                ${{ env.FRIDA_CORE_OPTIONS }}
          make
      - name: Upload devkit
        if: ${{ !startsWith(matrix.id, 'linux-') }}
@@ -66,7 +91,7 @@ jobs:
          name: core-devkit-${{ matrix.id }}
          path: build/src/devkit/
      - name: Test
-        if: matrix.id != 'macos-arm64'
+        if: ${{ matrix.id != 'windows-arm64' && !startsWith(matrix.id, 'macos-') }}
        run: make test

  cross:
@@ -87,10 +112,20 @@ jobs:
        with:
          submodules: recursive
      - name: Install toolchain
-        run: sudo apt-get install ${{ matrix.pkg }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install ${{ matrix.pkg }}
+      - name: Install Go toolchain
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'src/compiler/go.mod'
+          cache-dependency-path: 'src/compiler/go.mod'
      - name: Build
        run: |
-          ./configure ${{ matrix.opts }} ${{ env.FRIDA_CORE_OPTIONS }}
+          ./configure \
+              ${{ matrix.opts }} \
+              ${{ !contains(matrix.id, 'mips') && '--enable-compiler-backend' || '' }} \
+              ${{ env.FRIDA_CORE_OPTIONS }}
          make
      - name: Upload devkit
        if: ${{ !startsWith(matrix.id, 'linux-') }}
@@ -111,9 +146,17 @@ jobs:
        uses: actions/checkout@v4
        with:
          submodules: recursive
+      - name: Install Go toolchain
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'src/compiler/go.mod'
+          cache-dependency-path: 'src/compiler/go.mod'
      - name: Build
        run: |
-          ./configure --host=$XTOOLS_HOST ${{ env.FRIDA_CORE_OPTIONS }}
+          ./configure \
+              --host=$XTOOLS_HOST \
+              ${{ !startsWith(matrix.arch, 'mips') && '--enable-compiler-backend' || '' }} \
+              ${{ env.FRIDA_CORE_OPTIONS }}
          make
      - name: Upload devkit
        uses: actions/upload-artifact@v4
@@ -124,6 +167,131 @@ jobs:
        if: matrix.arch == 'x86' || matrix.arch == 'x86_64'
        run: make test

+  emulator:
+    strategy:
+      matrix:
+        arch: [armbe8, arm64be]
+      fail-fast: false
+    runs-on: ubuntu-latest
+    container: ghcr.io/frida/x-tools-linux-${{ matrix.arch }}:latest
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build
+        run: |
+          ./configure --host=$XTOOLS_HOST --without-prebuilds=sdk:host --enable-tests
+          make
+      - name: Run custom container
+        uses: addnab/docker-run-action@v3
+        with:
+          image: docker:stable
+          options: -v ${{ github.workspace }}:/workspace:delegated
+          run: |
+            cat <<EOF > /workspace/initscript
+            #!/bin/sh
+            dmesg -n1
+            mount -t proc none /proc
+            mount -t sysfs none /sys
+            mount -t tmpfs none /tmp
+            mount -t devtmpfs none /dev
+            mount -t 9p -o rw,sync,dirsync,relatime,trans=virtio,msize=131072,version=9p2000.L host0 /workspace
+            ip link set lo up
+            ip addr add 192.168.76.20/24 dev eth0
+            ip link set eth0 up
+            ip route add default via 192.168.76.2 dev eth0
+            export LD_LIBRARY_PATH=/lib:/lib64:/libilp32
+            /sbin/entropy
+            cat /etc/motd
+            export PS1='\u@frida:\w\$ '
+            /root/frida-tests
+            status=\$?
+            echo "exit status: \$status"
+            if [ \$status -eq 0 ]; then
+              echo EXIT_OK
+            elif [ \$status -gt 128 ]; then
+              signal=\$((\$status - 128))
+              echo "EXIT_FAIL (terminated by signal \$signal)"
+            else
+              echo "EXIT_FAIL (exit code \$status)"
+            fi
+            EOF
+
+            cat <<EOF > /workspace/launch.sh
+            #!/bin/sh
+            LOGFILE=/workspace/qemu.log
+            : > "\$LOGFILE"
+            timeout 120 qemu-system-aarch64 \
+                -M virt \
+                -machine virtualization=true \
+                -machine type=virt \
+                -cpu cortex-a72 \
+                -smp 4 \
+                -kernel /root/Image.gz \
+                -initrd /root/initramfs.img \
+                -append 'earlyprintk=serial,ttyAMA0 console=ttyAMA0 coredump_filter=0x3f' \
+                -m 4096M \
+                -net nic,id=eth \
+                -net user,id=mynet,net=192.168.76.0/24 \
+                -virtfs local,path=/workspace/,mount_tag=host0,security_model=passthrough,id=host0 \
+                -nographic \
+                -no-reboot \
+                >> "\$LOGFILE" 2>&1 &
+            QEMU_PID=\$!
+            echo "QEMU started with PID \$QEMU_PID"
+            tail -n 0 -f "\$LOGFILE" | while read line; do
+              echo "\$line"
+              echo "\$line" | grep "EXIT_OK" >/dev/null 2>&1
+              if [ \$? -eq 0 ]; then
+                echo "Success signal received from guest. Killing QEMU..."
+                kill -9 "\$QEMU_PID"
+                cat -n "\$LOGFILE"
+                exit 0
+              fi
+              echo "\$line" | grep "EXIT_FAIL" >/dev/null 2>&1
+              if [ \$? -eq 0 ]; then
+                echo "Failure signal received from guest. Killing QEMU..."
+                kill -9 "\$QEMU_PID"
+                cat -n "\$LOGFILE"
+                exit 1
+              fi
+              if ! kill -0 "\$QEMU_PID" 2>/dev/null; then
+                echo "QEMU process has exited."
+                cat -n "\$LOGFILE"
+                exit 1
+              fi
+            done
+            EOF
+
+            cat <<EOF > /workspace/Dockerfile.ci
+            FROM ghcr.io/frida/x-tools-linux-be-target:latest
+
+            ENV DEBIAN_FRONTEND=noninteractive
+            RUN apt-get update && \
+                apt-get install -y \
+                cpio
+
+            RUN mkdir /tmp/initramfs
+            WORKDIR /tmp/initramfs
+            RUN cpio --extract < /root/initramfs.img
+
+            RUN mkdir /tmp/initramfs/workspace
+
+            COPY initscript /tmp/initramfs/init
+            RUN chmod +x /tmp/initramfs/init
+
+            COPY build/tests /tmp/initramfs/root/
+            RUN find . | cpio -o --format=newc -R root:root > /root/initramfs.img
+
+            COPY launch.sh /root/launch.sh
+            RUN chmod +x /root/launch.sh
+            ENTRYPOINT ["/root/launch.sh"]
+            EOF
+
+            docker build -t ci-image -f /workspace/Dockerfile.ci /workspace
+            docker run --rm -v /workspace:/workspace ci-image
+
  mobile:
    strategy:
      matrix:
@@ -140,6 +308,11 @@ jobs:
        uses: actions/checkout@v4
        with:
          submodules: recursive
+      - name: Install Go toolchain
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'src/compiler/go.mod'
+          cache-dependency-path: 'src/compiler/go.mod'
      - name: Set up Apple certificates
        if: startsWith(matrix.id, 'ios-')
        uses: ./.github/actions/setup-apple-certificates
@@ -147,9 +320,20 @@ jobs:
          certificates-p12: ${{ secrets.APPLE_CERTIFICATES_P12 }}
          certificates-password: ${{ secrets.APPLE_CERTIFICATES_PASSWORD }}
          keychain-password: ${{ secrets.APPLE_KEYCHAIN_PASSWORD }}
+      - uses: nttld/setup-ndk@v1
+        if: startsWith(matrix.id, 'android-')
+        id: setup-ndk
+        with:
+          ndk-version: r25c
+      - name: Add NDK to env
+        if: startsWith(matrix.id, 'android-')
+        run: echo ANDROID_NDK_ROOT=${{ steps.setup-ndk.outputs.ndk-path }} >> $GITHUB_ENV
      - name: Build
        run: |
-          ./configure --host=${{ matrix.id }} ${{ env.FRIDA_CORE_OPTIONS }}
+          ./configure \
+              --host=${{ matrix.id }} \
+              --enable-compiler-backend \
+              ${{ env.FRIDA_CORE_OPTIONS }}
          make
      - name: Upload devkit
        uses: actions/upload-artifact@v4
@@ -177,6 +361,7 @@ jobs:
          tar -C /tmp/pkg -czf /tmp/runner.tar.gz .
      - name: Test on Corellium iOS device
        if: matrix.id == 'ios-arm64'
+        continue-on-error: true
        uses: frida/corellium-action@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
@@ -192,6 +377,7 @@ jobs:
            ./frida-tests
      - name: Test on Corellium Android device
        if: matrix.id == 'android-arm64'
+        continue-on-error: true
        uses: frida/corellium-action@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
@@ -228,3 +414,69 @@ jobs:
          cp -a tests/frida-tests tests/labrats lib/agent/frida-agent.so /tmp/pkg/
          tar -C /tmp/pkg -cf /tmp/runner.tar .
          /opt/sabrelite/run.sh /tmp/runner.tar /opt/frida/frida-tests
+
+  # This job is used to check that the Linux helpers are built correctly for all
+  # supported architectures. We do this because the binary artifacts are checked
+  # in, and we want to ensure that they are up-to-date with respect to the source
+  # for all architectures.
+  check-linux-helpers:
+    strategy:
+      matrix:
+        arch: [x86, x86_64, arm, armbe8, arm64, arm64be, arm64beilp32, mips, mipsel, mips64, mips64el]
+      fail-fast: false
+    runs-on: ubuntu-latest
+    container: ghcr.io/frida/core-linux-helpers-${{ matrix.arch }}:latest
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build
+        run: |
+          ./src/linux/helpers/rebuild.sh ${{ matrix.arch }}
+      - name: Check for unexpected changes
+        run: |
+          git config --global --add safe.directory "$(realpath .)"
+          status_output=$(git status --porcelain tests/labrats/{resident-agent,simple-agent}-linux-${{ matrix.arch }}.so tests/labrats/{forker,sleeper,spawner}-linux-${{ matrix.arch }})
+          if [ -n "$status_output" ]; then
+            echo "Unexpected changes detected:"
+            echo "$status_output"
+            echo "Diff:"
+            git diff
+            exit 1
+          else
+            echo "No unexpected changes detected."
+          fi
+
+  # This job is used to check that the Linux labrats are built correctly for all
+  # supported architectures. We do this because the binary artifacts are checked
+  # in, and we want to ensure that they are up-to-date with respect to the source
+  # for all architectures.
+  check-labrats:
+    strategy:
+      matrix:
+        arch: [x86, x86_64, arm, armbe8, arm64, arm64be, arm64beilp32, mips, mipsel, mips64, mips64el]
+      fail-fast: false
+    runs-on: ubuntu-latest
+    container: ghcr.io/frida/core-linux-helpers-${{ matrix.arch }}:latest
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build
+        run: |
+          ./tests/labrats/rebuild.sh ${{ matrix.arch }}
+      - name: Check for unexpected changes
+        run: |
+          git config --global --add safe.directory "$(realpath .)"
+          status_output=$(git status --porcelain src/linux/helpers/{bootstrapper,loader}-${{ matrix.arch }}.bin)
+          if [ -n "$status_output" ]; then
+            echo "Unexpected changes detected:"
+            echo "$status_output"
+            echo "Diff:"
+            git diff
+            exit 1
+          else
+            echo "No unexpected changes detected."
+          fi
@@ -3,9 +3,16 @@
 /src/barebone/helpers/memory-scanner/target/
 /src/barebone/helpers/target/
 /src/barebone/node_modules/
+/src/barebone/script-runtime.js
 /src/compiler/node_modules/
+/src/darwin/agent/osanalytics/node_modules/
+/src/darwin/agent/osanalytics/osanalytics.js
+/src/darwin/agent/reportcrash/node_modules/
+/src/darwin/agent/reportcrash/reportcrash.js
 /src/droidy/helper/build/
 /src/fruity/helpers/build/
+/src/linux/agent/system-server/node_modules/
+/src/linux/agent/system-server/system-server.js
 /src/linux/helpers/build/
 /src/linux/helpers/ext/
 /subprojects/*
@@ -4,6 +4,7 @@ import base64
 from collections import OrderedDict
 from dataclasses import dataclass, field
 import itertools
+import locale
 import os
 from pathlib import Path
 import pickle
@@ -14,7 +15,7 @@ import subprocess
 import sys
 import tempfile
 import traceback
-from typing import Any, Literal, Mapping, Optional, Sequence
+from typing import Any, Literal, Mapping, Optional, Sequence, Tuple


 REPO_ROOT = Path(__file__).resolve().parent.parent
@@ -140,16 +141,19 @@ def setup(role: Role,
            compat = set()
        else:
            summary = "enabled by user"
+        missing: list[MissingFeature] = []

        if "native" in compat:
            have_toolchain = True
+            other_label: Optional[str] = None
            other_triplet: Optional[str] = None
            extra_environ: dict[str, str] = {}

            if host_os == "windows" and host_arch == "x86_64" and host_config == "mingw":
-                other_triplet = "i686-w64-mingw32"
-                have_toolchain = shutil.which(other_triplet + "-gcc") is not None
+                other_label = "x86"
+                have_toolchain, other_triplet = detect_mingw_toolchain_for("x86")
            elif host_os == "linux" and host_arch == "x86_64" and host_config is None:
+                other_label = "x86"
                other_triplet = "i686-linux-gnu"
                have_toolchain = shutil.which(other_triplet + "-gcc") is not None
                if not have_toolchain:
@@ -173,7 +177,7 @@ def setup(role: Role,
            if not have_toolchain:
                if not auto_detect:
                    raise ToolchainNotFoundError(f"unable to locate toolchain for {other_triplet}")
-                summary = "disabled due to missing toolchain for {other_triplet}"
+                missing.append(MissingFeature(other_label, other_triplet))

            if host_os == "windows" and host_arch == "x86_64" and have_toolchain:
                group = OutputGroup("x86", other_triplet, extra_environ)
@@ -269,6 +273,28 @@ def setup(role: Role,
                    ]

        if "emulated" in compat:
+            if host_os == "windows" and host_arch == "arm64":
+                for kind, emulated_arch in [("modern", "x86_64"), ("legacy", "x86")]:
+                    if host_config == "mingw":
+                        found, emulated_triplet = detect_mingw_toolchain_for(emulated_arch)
+                        if not found:
+                            if not auto_detect:
+                                raise ToolchainNotFoundError(f"unable to locate toolchain for {emulated_triplet}")
+                            missing.append(MissingFeature(emulated_arch, emulated_triplet))
+                            continue
+                    else:
+                        emulated_triplet = None
+                    outputs[OutputGroup(emulated_arch, emulated_triplet, extra_environ)] = [
+                        Output(identifier=f"helper_emulated_{kind}",
+                               name=HELPER_FILE_WINDOWS.name.replace(".exe", f"-{emulated_arch}.exe"),
+                               file=HELPER_FILE_WINDOWS,
+                               target=HELPER_TARGET),
+                        Output(identifier=f"agent_emulated_{kind}",
+                               name=AGENT_FILE_WINDOWS.name.replace(".dll", f"-{emulated_arch}.dll"),
+                               file=AGENT_FILE_WINDOWS,
+                               target=AGENT_TARGET),
+                    ]
+
            if host_os == "android" and host_arch in {"x86_64", "x86"}:
                outputs[OutputGroup("arm")] = [
                    Output(identifier="agent_emulated_legacy",
@@ -290,6 +316,8 @@ def setup(role: Role,
        state = State(role, builddir, top_builddir, frida_version, host_os, host_config, allowed_prebuilds, outputs)
        serialized_state = base64.b64encode(pickle.dumps(state)).decode('ascii')

+        if missing:
+            summary = ", ".join([f"{m.label} disabled due to missing toolchain for {m.triplet}" for m in missing])
        variable_names, output_names = zip(*[(output.identifier, output.name) \
                for output in itertools.chain.from_iterable(outputs.values())])
        print("ok")
@@ -349,6 +377,12 @@ class Output:
    target: str


+@dataclass
+class MissingFeature:
+    label: str
+    triplet: str
+
+
 def compile(privdir: Path, state: State):
    releng_location = query_releng_location(state.role)
    subprojects = detect_relevant_subprojects(releng_location)
@@ -367,7 +401,7 @@ def compile(privdir: Path, state: State):
                **kwargs,
                "stdout": subprocess.PIPE,
                "stderr": subprocess.STDOUT,
-                "encoding": "utf-8",
+                "encoding": locale.getpreferredencoding(),
            }
        else:
            silenced_kwargs = kwargs
@@ -401,6 +435,7 @@ def compile(privdir: Path, state: State):
                      environ={**build_env, **group.extra_environ},
                      allowed_prebuilds=state.allowed_prebuilds,
                      extra_meson_options=[
+                          "-Dcompiler_backend=disabled",
                          "-Dhelper_modern=",
                          "-Dhelper_legacy=",
                          "-Dagent_modern=",
@@ -432,7 +467,7 @@ def compile(privdir: Path, state: State):
                path = Path(raw_path)
                if not path.is_absolute():
                    path = Path(os.path.relpath(workdir / path, top_builddir))
-                input_entries.append(quote(path.as_posix()))
+                input_entries.append(escape_depfile_path(path.as_posix()))
            depfile_lines.append(f"{output_relpath}: {' '.join(input_entries)}")

    (state.builddir / DEPFILE_FILENAME).write_text("\n".join(depfile_lines), encoding="utf-8")
@@ -465,6 +500,8 @@ def option_should_be_forwarded(k: "OptionKey",

    if k.is_project():
        if is_for_us:
+            if k.name == "compiler_backend":
+                return False
            tokens = k.name.split("_")
            if tokens[0] in {"helper", "agent"} and tokens[-1] in {"modern", "legacy"}:
                return False
@@ -480,6 +517,10 @@ def option_should_be_forwarded(k: "OptionKey",
            return False
        if not str(v.value):
            return False
+        if not is_for_child and role == "subproject" and k.subproject in {"", our_project_id}:
+            if not coredata.BUILTIN_OPTIONS[k.as_root()].yielding:
+                return k.subproject == our_project_id
+            return True

    if k.module == "python":
        if k.name == "install_env" and v.value == "prefix":
@@ -519,10 +560,8 @@ def scrub_windows_devenv_dirs_from_path(raw_path: str, env: Mapping[str, str]) -
    return ";".join(clean_entries)


-def quote(path: str) -> str:
-    if " " not in path:
-        return path
-    return "\"" + path.replace ("\"", "\\\"") + "\""
+def escape_depfile_path(path: str) -> str:
+    return path.replace(" ", "\\ ")


 def query_releng_location(role: Role) -> Path:
@@ -568,10 +607,10 @@ def grab_subprojects_from_parent(subprojects: dict[str, Path], releng_location:
            continue

        try:
-            subp_here.symlink_to(location, target_is_directory=True)
+            subp_here.symlink_to(Path("..") / ".." / name, target_is_directory=True)
            continue
        except OSError as e:
-            if not getattr(e, "winerror") == 1314:
+            if not getattr(e, "winerror", None) == 1314:
                raise e

        subprocess.run(["git", "worktree", "add", subp_here],
@@ -587,6 +626,12 @@ def configure_import_path(releng_location: Path):
    sys.path.insert(0, str(releng_location.parent))


+def detect_mingw_toolchain_for(arch: str) -> Tuple[bool, Optional[str]]:
+    triplet = MINGW_ARCHS.get(arch, arch) + "-w64-mingw32"
+    found = shutil.which(triplet + "-gcc") is not None
+    return (found, triplet)
+
+
 STATE_FILENAME = "state.dat"
 DEPFILE_FILENAME = "compat.deps"

@@ -614,6 +659,11 @@ MSVS_ENVVARS = {
    "LIB",
 }

+MINGW_ARCHS = {
+    "x86": "i686",
+    "arm64": "aarch64",
+}
+

 if __name__ == "__main__":
    main(sys.argv)
@@ -1,6 +1,8 @@
 helper_modern = get_option('helper_modern')
 helper_legacy = get_option('helper_legacy')
 helper_compat = ''
+helper_emulated_modern = get_option('helper_emulated_modern')
+helper_emulated_legacy = get_option('helper_emulated_legacy')
 helper_depends = []

 agent_modern = get_option('agent_modern')
@@ -18,6 +20,7 @@ server_depends = []

 no_overridden_compat_bits = \
    helper_modern == 'auto' and helper_legacy == 'auto' \
+    and helper_emulated_modern == 'auto' and helper_emulated_legacy == 'auto' \
    and agent_modern == 'auto' and agent_legacy == 'auto' \
    and agent_emulated_modern == 'auto' and agent_emulated_legacy == 'auto'

@@ -147,7 +147,7 @@ namespace Frida.Inject {
 		public extern void init ();
 	}

-	public class Application : Object {
+	public sealed class Application : Object {
 		public string? device_id {
 			get;
 			construct;
@@ -388,7 +388,7 @@ namespace Frida.Inject {
 				return false;
 			}

-			script_runner.on_stdin (line);
+			script_runner.on_stdin (line, null);

 			return true;
 		}
@@ -414,14 +414,19 @@ namespace Frida.Inject {

 			buf[n] = 0;

-			script_runner.on_stdin ((string) buf);
+			if (script_runner.terminal_mode == TerminalMode.BINARY) {
+				var bytes = new Bytes (buf[:n]);
+				script_runner.on_stdin ("", bytes);
+			} else {
+				script_runner.on_stdin ((string) buf, null);
+			}

 			return true;
 		}
 #endif
 	}

-	private class ScriptRunner : Object, RpcPeer {
+	private sealed class ScriptRunner : Object, RpcPeer {
 		public TerminalMode terminal_mode {
 			get;
 			private set;
@@ -549,7 +554,7 @@ namespace Frida.Inject {
 			var stage = new Json.Node.alloc ().init_string ("early");

 			try {
-				yield rpc_client.call ("init", new Json.Node[] { stage, parameters }, io_cancellable);
+				yield rpc_client.call ("init", new Json.Node[] { stage, parameters }, null, io_cancellable);
 			} catch (GLib.Error e) {
 			}
 		}
@@ -591,7 +596,7 @@ namespace Frida.Inject {
 		private async TerminalMode query_terminal_mode () {
 			Json.Node mode_value;
 			try {
-				mode_value = yield rpc_client.call ("getFridaTerminalMode", new Json.Node[] {}, io_cancellable);
+				mode_value = yield rpc_client.call ("getFridaTerminalMode", new Json.Node[] {}, null, io_cancellable);
 			} catch (GLib.Error e) {
 				return COOKED;
 			}
@@ -599,7 +604,14 @@ namespace Frida.Inject {
 			if (mode_value.get_value_type () != typeof (string))
 				return COOKED;

-			return (mode_value.get_string () == "raw") ? TerminalMode.RAW : TerminalMode.COOKED;
+			switch (mode_value.get_string ()) {
+				case "raw":
+					return TerminalMode.RAW;
+				case "binary":
+					return TerminalMode.BINARY;
+				default:
+					return TerminalMode.COOKED;
+			}
 		}

 		private void apply_terminal_mode (TerminalMode mode) throws Error {
@@ -632,10 +644,10 @@ namespace Frida.Inject {
 		}
 #endif

-		public void on_stdin (string data) {
-			var data_value = new Json.Node.alloc ().init_string (data);
+		public void on_stdin (string str, Bytes? data) {
+			var str_value = new Json.Node.alloc ().init_string (str);

-			rpc_client.call.begin ("onFridaStdin", new Json.Node[] { data_value }, io_cancellable);
+			rpc_client.call.begin ("onFridaStdin", new Json.Node[] { str_value }, data, io_cancellable);
 		}

 		private void on_script_file_changed (File file, File? other_file, FileMonitorEvent event_type) {
@@ -675,7 +687,7 @@ namespace Frida.Inject {
 					handled = try_handle_log_message (message);
 					break;
 				case "send":
-					handled = try_handle_stdout_message (message);
+					handled = try_handle_stdout_message (message, data);
 					break;
 				default:
 					handled = false;
@@ -722,20 +734,19 @@ namespace Frida.Inject {
 		 *
 		 * {"type":"send","payload":["frida:stdout","DATA"]}
 		 */
-		private bool try_handle_stdout_message (Json.Object message) {
+		private bool try_handle_stdout_message (Json.Object message, Bytes? data) {
 			var payload = message.get_member ("payload");
 			if (payload.get_node_type () != Json.NodeType.ARRAY)
 				return false;

 			var tuple = payload.get_array ();
-			if (tuple.get_length () != 2)
+			var tuple_len = tuple.get_length ();
+			if (tuple_len == 0)
 				return false;

-			var first_element = tuple.get_element (0);
-			if (first_element.get_value_type () != typeof (string))
+			var type = tuple.get_element (0).get_string ();
+			if (type == null)
 				return false;
-
-			var type = first_element.get_string ();
 			switch (type) {
 				case "frida:stdout":
 				case "frida:stderr":
@@ -744,31 +755,49 @@ namespace Frida.Inject {
 					return false;
 			}

-			var second_element = tuple.get_element (1);
-			if (second_element.get_value_type () != typeof (string))
-				return false;
-			var str = second_element.get_string ();
-
-			switch (type) {
-				case "frida:stdout":
-					stdout.write (str.data);
-					stdout.flush ();
-					return true;
-				case "frida:stderr":
-					stderr.write (str.data);
-					return true;
-				default:
+			if (tuple_len >= 2) {
+				var str = tuple.get_element (1).get_string ();
+				if (str == null)
 					return false;
+
+				switch (type) {
+					case "frida:stdout":
+						stdout.write (str.data);
+						stdout.flush ();
+						break;
+					case "frida:stderr":
+						stderr.write (str.data);
+						break;
+					default:
+						return false;
+				}
 			}
+
+			if (data != null) {
+				switch (type) {
+					case "frida:stdout":
+						stdout.write (data.get_data ());
+						stdout.flush ();
+						break;
+					case "frida:stderr":
+						stderr.write (data.get_data ());
+						break;
+					default:
+						return false;
+				}
+			}
+
+			return true;
 		}

-		private async void post_rpc_message (string json, Cancellable? cancellable) throws Error, IOError {
-			script.post (json, null);
+		private async void post_rpc_message (string json, Bytes? data, Cancellable? cancellable) throws Error, IOError {
+			script.post (json, data);
 		}
 	}

 	private enum TerminalMode {
 		COOKED,
-		RAW
+		RAW,
+		BINARY
 	}
 }
@@ -11,7 +11,7 @@ namespace Frida.Agent {
 		PROCESS_TRANSITION
 	}

-	private class Runner : Object, ProcessInvader, AgentSessionProvider, ExitHandler, ForkHandler, SpawnHandler {
+	private sealed class Runner : Object, ProcessInvader, AgentSessionProvider, ExitHandler, ForkHandler, SpawnHandler {
 		public static Runner shared_instance = null;
 		public static Mutex shared_mutex;
 		private static string? cached_agent_path = null;
@@ -1400,12 +1400,12 @@ namespace Frida.Agent {
 				if (nb_api.unload_library == null)
 					parameters.append ("|eternal|sticky");
 				/*
-				 * Disable ExitMonitor to work around a bug in Android's libndk_translation.so on Android 11.
-				 * We need to avoid modifying libc.so ranges that the translator potentially depends on, to
-				 * avoid blowing up when Interceptor's CPU cache flush results in the translated code being
-				 * discarded, which seems like an edge-case the translator doesn't handle.
+				 * Disable Exceptor and ExitMonitor to work around a bug in Android's libndk_translation.so
+				 * on Android 11. We need to avoid modifying libc.so ranges that the translator potentially
+				 * depends on, to avoid blowing up when Interceptor's CPU cache flush results in the translated
+				 * code being discarded, which seems like an edge-case the translator doesn't handle.
 				 */
-				parameters.append ("|exit-monitor:off");
+				parameters.append ("|exceptor:off|exit-monitor:off");

 				emulated_bridge_state = new BridgeState (parameters.str);

@@ -1509,13 +1509,14 @@ namespace Frida.Agent {
 			}

 			public static NativeBridgeApi open () throws Error {
-				string? nb_mod = null;
-				string? vm_mod = null;
-				Gum.Process.enumerate_modules ((details) => {
-					if (/\/lib(64)?\/libnativebridge.so$/.match (details.path))
-						nb_mod = details.path;
-					else if (/^lib(art|dvm).so$/.match (details.name) && !/\/system\/fake-libs/.match (details.path))
-						vm_mod = details.path;
+				Gum.Module? nb_mod = null;
+				Gum.Module? vm_mod = null;
+				Gum.Process.enumerate_modules (module => {
+					unowned string path = module.path;
+					if (/\/lib(64)?\/libnativebridge.so$/.match (path))
+						nb_mod = module;
+					else if (/^lib(art|dvm).so$/.match (module.name) && !/\/system\/fake-libs/.match (path))
+						vm_mod = module;
 					bool carry_on = nb_mod == null || vm_mod == null;
 					return carry_on;
 				});
@@ -1530,29 +1531,27 @@ namespace Frida.Agent {
 				NBUnloadLibraryFunc? unload;
 				NBGetTrampolineFunc get_trampoline;

-				load = (NBLoadLibraryFunc) Gum.Module.find_export_by_name (nb_mod, "NativeBridgeLoadLibrary");;
+				load = (NBLoadLibraryFunc) nb_mod.find_export_by_name ("NativeBridgeLoadLibrary");;
 				if (load != null) {
 					flavor = MODERN;
-					load_ext = (NBLoadLibraryExtFunc) Gum.Module.find_export_by_name (nb_mod, "NativeBridgeLoadLibraryExt");
+					load_ext = (NBLoadLibraryExtFunc) nb_mod.find_export_by_name ("NativeBridgeLoadLibraryExt");
 					// XXX: NativeBridgeUnloadLibrary() is only a stub as of Android 11 w/ libndk_translation.so
 					unload = null;
-					get_trampoline = (NBGetTrampolineFunc) Gum.Module.find_export_by_name (nb_mod,
-						"NativeBridgeGetTrampoline");
+					get_trampoline = (NBGetTrampolineFunc) nb_mod.find_export_by_name ("NativeBridgeGetTrampoline");
 				} else {
 					flavor = LEGACY;
-					load = (NBLoadLibraryFunc) Gum.Module.find_export_by_name (nb_mod,
-						"_ZN7android23NativeBridgeLoadLibraryEPKci");
-					load_ext = (NBLoadLibraryExtFunc) Gum.Module.find_export_by_name (nb_mod,
+					load = (NBLoadLibraryFunc) nb_mod.find_export_by_name ("_ZN7android23NativeBridgeLoadLibraryEPKci");
+					load_ext = (NBLoadLibraryExtFunc) nb_mod.find_export_by_name (
 						"_ZN7android26NativeBridgeLoadLibraryExtEPKciPNS_25native_bridge_namespace_tE");
 					// XXX: Unload implementation seems to be unreliable.
 					unload = null;
-					get_trampoline = (NBGetTrampolineFunc) Gum.Module.find_export_by_name (nb_mod,
+					get_trampoline = (NBGetTrampolineFunc) nb_mod.find_export_by_name (
 						"_ZN7android25NativeBridgeGetTrampolineEPvPKcS2_j");
 				}
 				if (load == null || get_trampoline == null)
 					throw new Error.NOT_SUPPORTED ("NativeBridge API is not available on this system");

-				var get_vms = (JNIGetCreatedJavaVMsFunc) Gum.Module.find_export_by_name (vm_mod, "JNI_GetCreatedJavaVMs");
+				var get_vms = (JNIGetCreatedJavaVMsFunc) vm_mod.find_export_by_name ("JNI_GetCreatedJavaVMs");
 				if (get_vms == null)
 					throw new Error.NOT_SUPPORTED ("Unable to locate Java VM");

@@ -1622,7 +1621,7 @@ namespace Frida.Agent {
 	}
 #endif

-	private class LiveAgentSession : BaseAgentSession {
+	private sealed class LiveAgentSession : BaseAgentSession {
 		public uint registration_id {
 			get;
 			set;
@@ -0,0 +1,8 @@
+{
+  global:
+    frida_agent_main;
+    JNI_OnLoad;
+
+  local:
+    *;
+};
@@ -1,7 +1,6 @@
 {
  global:
    frida_agent_main;
-    JNI_OnLoad;

  local:
    *;
@@ -28,7 +28,7 @@ if host_os_family == 'windows'
 elif host_os_family == 'darwin'
  extra_link_args += '-Wl,-exported_symbol,_frida_agent_main'
 else
-  symscript = 'frida-agent.version'
+  symscript = (host_os == 'android') ? 'frida-agent-android.version' : 'frida-agent.version'
  extra_link_args += '-Wl,--version-script,' + meson.current_source_dir() / symscript
  extra_link_depends += symscript
 endif
@@ -0,0 +1,12 @@
+#include "frida-base.h"
+
+GBytes *
+frida_make_bytes_with_owner (GType t_type,
+                             GBoxedCopyFunc t_dup_func,
+                             GDestroyNotify t_destroy_func,
+                             void * data,
+                             gsize size,
+                             gpointer owner)
+{
+  return g_bytes_new_with_free_func (data, size, t_destroy_func, owner);
+}
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class BufferBuilder : Object {
+	public sealed class BufferBuilder : Object {
 		public ByteOrder byte_order {
 			get;
 			construct;
@@ -307,7 +307,7 @@ namespace Frida {
 		NUL
 	}

-	public class Buffer : Object {
+	public sealed class Buffer : Object {
 		public Bytes bytes {
 			get;
 			construct;
@@ -356,10 +356,20 @@ namespace Frida {
 			return *((int8 *) get_pointer (offset, sizeof (int8)));
 		}

+		public unowned Buffer write_int8 (size_t offset, int8 val) {
+			*((int8 *) get_pointer (offset, sizeof (int8))) = val;
+			return this;
+		}
+
 		public uint8 read_uint8 (size_t offset) {
 			return *get_pointer (offset, sizeof (uint8));
 		}

+		public unowned Buffer write_uint8 (size_t offset, uint8 val) {
+			*((uint8 *) get_pointer (offset, sizeof (uint8))) = val;
+			return this;
+		}
+
 		public int16 read_int16 (size_t offset) {
 			int16 val = *((int16 *) get_pointer (offset, sizeof (int16)));
 			return (byte_order == BIG_ENDIAN)
@@ -367,6 +377,14 @@ namespace Frida {
 				: int16.from_little_endian (val);
 		}

+		public unowned Buffer write_int16 (size_t offset, int16 val) {
+			int16 target_val = (byte_order == BIG_ENDIAN)
+				? val.to_big_endian ()
+				: val.to_little_endian ();
+			*((int16 *) get_pointer (offset, sizeof (int16))) = target_val;
+			return this;
+		}
+
 		public uint16 read_uint16 (size_t offset) {
 			uint16 val = *((uint16 *) get_pointer (offset, sizeof (uint16)));
 			return (byte_order == BIG_ENDIAN)
@@ -374,6 +392,14 @@ namespace Frida {
 				: uint16.from_little_endian (val);
 		}

+		public unowned Buffer write_uint16 (size_t offset, uint16 val) {
+			uint16 target_val = (byte_order == BIG_ENDIAN)
+				? val.to_big_endian ()
+				: val.to_little_endian ();
+			*((uint16 *) get_pointer (offset, sizeof (uint16))) = target_val;
+			return this;
+		}
+
 		public int32 read_int32 (size_t offset) {
 			int32 val = *((int32 *) get_pointer (offset, sizeof (int32)));
 			return (byte_order == BIG_ENDIAN)
@@ -381,6 +407,14 @@ namespace Frida {
 				: int32.from_little_endian (val);
 		}

+		public unowned Buffer write_int32 (size_t offset, int32 val) {
+			int32 target_val = (byte_order == BIG_ENDIAN)
+				? val.to_big_endian ()
+				: val.to_little_endian ();
+			*((int32 *) get_pointer (offset, sizeof (int32))) = target_val;
+			return this;
+		}
+
 		public uint32 read_uint32 (size_t offset) {
 			uint32 val = *((uint32 *) get_pointer (offset, sizeof (uint32)));
 			return (byte_order == BIG_ENDIAN)
@@ -403,6 +437,14 @@ namespace Frida {
 				: int64.from_little_endian (val);
 		}

+		public unowned Buffer write_int64 (size_t offset, int64 val) {
+			int64 target_val = (byte_order == BIG_ENDIAN)
+				? val.to_big_endian ()
+				: val.to_little_endian ();
+			*((int64 *) get_pointer (offset, sizeof (int64))) = target_val;
+			return this;
+		}
+
 		public uint64 read_uint64 (size_t offset) {
 			uint64 val = *((uint64 *) get_pointer (offset, sizeof (uint64)));
 			return (byte_order == BIG_ENDIAN)
@@ -428,21 +470,35 @@ namespace Frida {
 			return *((double *) &bits);
 		}

-		public string read_string (size_t offset) {
+		public string read_string (size_t offset) throws Error {
+			string * start = (string *) get_pointer (offset, sizeof (char));
 			size_t max_length = size - offset;
-			string * val = (string *) get_pointer (offset, sizeof (char));
-			string * end = memchr (val, 0, max_length);
-			assert (end != null);
-			size_t size = end - val;
-			return val->substring (0, (long) size);
+			string * end = memchr (start, 0, max_length);
+			if (end == null)
+				throw new Error.PROTOCOL ("Missing null character");
+			size_t size = end - start;
+			string val = start->substring (0, (long) size);
+			if (!val.validate ())
+				throw new Error.PROTOCOL ("Invalid UTF-8 string");
+			return val;
 		}

 		[CCode (cname = "memchr", cheader_filename = "string.h")]
 		private extern static string * memchr (string * s, int c, size_t n);

-		public string read_fixed_string (size_t offset, size_t size) {
-			string * val = (string *) get_pointer (offset, size);
-			return val->substring (0, (long) size);
+		public string read_fixed_string (size_t offset, size_t size) throws Error {
+			string * start = (string *) get_pointer (offset, size);
+			size_t max_length = size_t.min (size, this.size - offset);
+			string * end = memchr (start, 0, max_length);
+			size_t n;
+			if (end != null)
+				n = end - start;
+			else
+				n = size;
+			string val = start->substring (0, (long) n);
+			if (!val.validate ())
+				throw new Error.PROTOCOL ("Invalid UTF-8 string");
+			return val;
 		}

 		public unowned Buffer write_string (size_t offset, string val) {
@@ -451,6 +507,18 @@ namespace Frida {
 			return this;
 		}

+		public Bytes read_bytes (size_t offset, size_t size) {
+			var data = new uint8[size + 1];
+			Memory.copy (data, get_pointer (offset, size), size);
+			return new Bytes.take ((owned) data);
+		}
+
+		public unowned Buffer write_bytes (size_t offset, Bytes bytes) {
+			size_t size = bytes.get_size ();
+			Memory.copy (get_pointer (offset, size), bytes.get_data (), size);
+			return this;
+		}
+
 		private uint8 * get_pointer (size_t offset, size_t n) {
 			size_t minimum_size = offset + n;
 			assert (size >= minimum_size);
@@ -458,4 +526,137 @@ namespace Frida {
 			return data + offset;
 		}
 	}
+
+	public sealed class BufferReader {
+		public size_t offset {
+			get {
+				return _offset;
+			}
+		}
+
+		public size_t available {
+			get {
+				return buffer.bytes.get_size () - _offset;
+			}
+		}
+
+		private Buffer buffer;
+		private size_t _offset = 0;
+
+		public BufferReader (Buffer buf) {
+			buffer = buf;
+		}
+
+		public uint64 read_pointer (size_t offset) throws Error {
+			var pointer_size = buffer.pointer_size;
+			check_available (pointer_size);
+			var ptr = buffer.read_pointer (_offset);
+			_offset += pointer_size;
+			return ptr;
+		}
+
+		public int8 read_int8 () throws Error {
+			check_available (sizeof (int8));
+			var val = buffer.read_int8 (_offset);
+			_offset += sizeof (int8);
+			return val;
+		}
+
+		public uint8 read_uint8 () throws Error {
+			check_available (sizeof (uint8));
+			var val = buffer.read_uint8 (_offset);
+			_offset += sizeof (uint8);
+			return val;
+		}
+
+		public int16 read_int16 () throws Error {
+			check_available (sizeof (int16));
+			var val = buffer.read_int16 (_offset);
+			_offset += sizeof (int16);
+			return val;
+		}
+
+		public uint16 read_uint16 () throws Error {
+			check_available (sizeof (uint16));
+			var val = buffer.read_uint16 (_offset);
+			_offset += sizeof (uint16);
+			return val;
+		}
+
+		public int32 read_int32 () throws Error {
+			check_available (sizeof (int32));
+			var val = buffer.read_int32 (_offset);
+			_offset += sizeof (int32);
+			return val;
+		}
+
+		public uint32 read_uint32 () throws Error {
+			check_available (sizeof (uint32));
+			var val = buffer.read_uint32 (_offset);
+			_offset += sizeof (uint32);
+			return val;
+		}
+
+		public int64 read_int64 () throws Error {
+			check_available (sizeof (int64));
+			var val = buffer.read_int64 (_offset);
+			_offset += sizeof (int64);
+			return val;
+		}
+
+		public uint64 read_uint64 () throws Error {
+			check_available (sizeof (uint64));
+			var val = buffer.read_uint64 (_offset);
+			_offset += sizeof (uint64);
+			return val;
+		}
+
+		public float read_float () throws Error {
+			check_available (sizeof (float));
+			var val = buffer.read_float (_offset);
+			_offset += sizeof (float);
+			return val;
+		}
+
+		public double read_double () throws Error {
+			check_available (sizeof (double));
+			var val = buffer.read_double (_offset);
+			_offset += sizeof (double);
+			return val;
+		}
+
+		public string read_string () throws Error {
+			check_available (1);
+			var val = buffer.read_string (_offset);
+			_offset += val.length + 1;
+			return val;
+		}
+
+		public string read_fixed_string (size_t size) throws Error {
+			check_available (size);
+			var val = buffer.read_fixed_string (_offset, size);
+			_offset += size;
+			return val;
+		}
+
+		public Bytes read_bytes (size_t size) throws Error {
+			check_available (size);
+			var val = buffer.bytes[_offset:_offset + size];
+			_offset += size;
+			return val;
+		}
+
+		public unowned BufferReader skip (size_t n) throws Error {
+			check_available (n);
+			_offset += n;
+			return this;
+		}
+
+		private void check_available (size_t n) throws Error {
+			if (available < n)
+				throw new Error.PROTOCOL ("Malformed buffer: truncated");
+		}
+	}
+
+	public extern Bytes make_bytes_with_owner<T> (void * data, size_t size, owned T? owner = null);
 }
@@ -0,0 +1,243 @@
+namespace Frida {
+	public sealed class ChannelRegistry : Object {
+		public signal void channel_closed (ChannelId id);
+
+		private Gee.Map<ChannelId?, weak IOStream> channels =
+			new Gee.HashMap<ChannelId?, weak IOStream> (ChannelId.hash, ChannelId.equal);
+
+		~ChannelRegistry () {
+			clear ();
+		}
+
+		public void clear () {
+			foreach (IOStream stream in channels.values.to_array ()) {
+				var channel_stream = stream as ChannelStream;
+				if (channel_stream != null)
+					channel_stream.abandon ();
+			}
+			channels.clear ();
+		}
+
+		public void register (ChannelId id, IOStream stream) {
+			stream.set_data ("channel-registry-entry", new Entry (this, id));
+			lock (channels)
+				channels[id] = stream;
+		}
+
+		public IOStream link (ChannelId id) throws Error {
+			IOStream? stream;
+			lock (channels)
+				stream = channels[id];
+			if (stream == null)
+				throw new Error.INVALID_ARGUMENT ("Invalid channel ID");
+			return stream;
+		}
+
+		public void unlink (ChannelId id) {
+			lock (channels) {
+				if (!channels.unset (id))
+					return;
+			}
+
+			channel_closed (id);
+		}
+
+		private class Entry {
+			public ChannelRegistry parent;
+			public ChannelId id;
+
+			public Entry (ChannelRegistry parent, ChannelId id) {
+				this.parent = parent;
+				this.id = id;
+			}
+
+			~Entry () {
+				parent.unlink (id);
+			}
+		}
+	}
+
+	public sealed class ChannelEndpoint : Object, Channel {
+		private IOStream? stream;
+
+		private ByteArray write_queue = new ByteArray ();
+		private bool writing = false;
+
+		private Cancellable io_cancellable = new Cancellable ();
+
+		public ChannelEndpoint (IOStream stream) {
+			this.stream = stream;
+
+			read_loop.begin ();
+		}
+
+		public async void close (Cancellable? cancellable) throws Error, IOError {
+			io_cancellable.cancel ();
+		}
+
+		public async void input (uint8[] data, Cancellable? cancellable) throws Error, IOError {
+			if (io_cancellable.is_cancelled ())
+				throw new Error.INVALID_OPERATION ("Channel is closed");
+
+			write_queue.append (data);
+
+			if (!writing) {
+				writing = true;
+
+				var source = new IdleSource ();
+				source.set_callback (() => {
+					process_write_queue.begin ();
+					return false;
+				});
+				source.attach (MainContext.get_thread_default ());
+			}
+		}
+
+		private async void read_loop () {
+			var input = stream.get_input_stream ();
+			var buffer = new uint8[64 * 1024];
+
+			while (true) {
+				ssize_t n;
+				try {
+					n = yield input.read_async (buffer, Priority.DEFAULT, io_cancellable);
+				} catch (GLib.Error e) {
+					break;
+				}
+
+				output (buffer[:n]);
+
+				if (n == 0)
+					break;
+			}
+
+			stream.close_async.begin ();
+			stream = null;
+		}
+
+		private async void process_write_queue () {
+			if (stream != null) {
+				var output = stream.get_output_stream ();
+
+				while (write_queue.len > 0) {
+					uint8[] batch = write_queue.steal ();
+
+					size_t bytes_written;
+					try {
+						yield output.write_all_async (batch, Priority.DEFAULT, io_cancellable, out bytes_written);
+					} catch (GLib.Error e) {
+						break;
+					}
+				}
+			}
+
+			writing = false;
+		}
+	}
+
+	public sealed class ChannelStream : VirtualStream {
+		public Channel channel {
+			get;
+			construct;
+		}
+
+		private ByteArray recv_queue = new ByteArray ();
+		private ByteArray send_queue = new ByteArray ();
+
+		public ChannelStream (Channel channel) {
+			Object (channel: channel);
+		}
+
+		construct {
+			channel.output.connect (on_output);
+		}
+
+		public void abandon () {
+			with_state_lock (() => {
+				state = CLOSED;
+				update_pending_io ();
+			});
+		}
+
+		protected override IOCondition query_events () {
+			IOCondition new_events = 0;
+
+			if (recv_queue.len != 0 || state == CLOSED)
+				new_events |= IN;
+
+			if (state == OPEN)
+				new_events |= OUT;
+
+			return new_events;
+		}
+
+		protected override void handle_close () {
+			channel.close.begin (null);
+		}
+
+		public override ssize_t read (uint8[] buffer) throws IOError {
+			ssize_t n = 0;
+			with_state_lock (() => {
+				n = ssize_t.min (recv_queue.len, buffer.length);
+				if (n > 0) {
+					Memory.copy (buffer, recv_queue.data, n);
+					recv_queue.remove_range (0, (uint) n);
+
+					update_pending_io ();
+				} else {
+					if (state == OPEN)
+						n = -1;
+				}
+			});
+
+			if (n == -1)
+				throw new IOError.WOULD_BLOCK ("Resource temporarily unavailable");
+
+			return n;
+		}
+
+		public override ssize_t write (uint8[] buffer) throws IOError {
+			with_state_lock (() => {
+				send_queue.append (buffer);
+			});
+
+			if (main_context.is_owner ()) {
+				process_send_queue ();
+			} else {
+				var source = new IdleSource ();
+				source.set_callback (() => {
+					process_send_queue ();
+					return Source.REMOVE;
+				});
+				source.attach (main_context);
+			}
+
+			return buffer.length;
+		}
+
+		private void process_send_queue () {
+			uint8[]? chunk = null;
+			with_state_lock (() => {
+				size_t n = send_queue.len;
+				if (n == 0)
+					return;
+				chunk = send_queue.data[0:n];
+				send_queue.remove_range (0, (uint) n);
+			});
+			if (chunk == null)
+				return;
+
+			channel.input.begin (chunk, io_cancellable);
+		}
+
+		private void on_output (uint8[] data) {
+			with_state_lock (() => {
+				if (data.length != 0)
+					recv_queue.append (data);
+				else
+					state = CLOSED;
+				update_pending_io ();
+			});
+		}
+	}
+}
@@ -0,0 +1,34 @@
+namespace Frida {
+	public sealed class CFArray<T> {
+		private CoreFoundation.Array handle;
+
+		public static CFArray<T> wrap<T> (void * handle) {
+			return new CFArray<T> ((CoreFoundation.Array) handle);
+		}
+
+		private CFArray (CoreFoundation.Array handle) {
+			this.handle = handle;
+		}
+
+		public Iterator<T> iterator () {
+			return new Iterator<T> (handle);
+		}
+
+		public class Iterator<T> {
+			public CoreFoundation.Array handle;
+			private CoreFoundation.Index i = 0;
+			private CoreFoundation.Index length;
+
+			internal Iterator (CoreFoundation.Array arr) {
+				handle = arr;
+				length = arr.length;
+			}
+
+			public unowned T? next_value () {
+				if (i == length)
+					return null;
+				return handle[i++];
+			}
+		}
+	}
+}
@@ -60,7 +60,7 @@ namespace Frida {
 		return yield connection.get_proxy (null, ObjectPath.HOST_SESSION, DBusProxyFlags.NONE, cancellable);
 	}

-	private class DummyInputStream : InputStream {
+	private sealed class DummyInputStream : InputStream {
 		private bool done = false;
 		private Mutex mutex;
 		private Cond cond;
@@ -0,0 +1,51 @@
+#include "frida-darwin.h"
+
+gpointer
+_frida_dispatch_retain (gpointer object)
+{
+  dispatch_retain (object);
+  return object;
+}
+
+void
+_frida_xpc_connection_set_event_handler (xpc_connection_t connection, FridaXpcHandler handler, gpointer user_data)
+{
+  xpc_connection_set_event_handler (connection, ^(xpc_object_t object)
+      {
+        handler (object, user_data);
+      });
+}
+
+void
+_frida_xpc_connection_send_message_with_reply (xpc_connection_t connection, xpc_object_t message, dispatch_queue_t replyq,
+    FridaXpcHandler handler, gpointer user_data, GDestroyNotify notify)
+{
+  xpc_connection_send_message_with_reply (connection, message, replyq, ^(xpc_object_t object)
+      {
+        handler (object, user_data);
+        if (notify != NULL)
+          notify (user_data);
+      });
+}
+
+gchar *
+_frida_xpc_object_to_string (xpc_object_t object)
+{
+  gchar * result;
+  char * str;
+
+  str = xpc_copy_description (object);
+  result = g_strdup (str);
+  free (str);
+
+  return result;
+}
+
+gboolean
+_frida_xpc_dictionary_apply (xpc_object_t dict, FridaXpcDictionaryApplier applier, gpointer user_data)
+{
+  return xpc_dictionary_apply (dict, ^bool (const char * key, xpc_object_t val)
+      {
+        return applier (key, val, user_data);
+      });
+}
@@ -0,0 +1,22 @@
+#ifndef __FRIDA_DARWIN_H__
+#define __FRIDA_DARWIN_H__
+
+#ifdef HAVE_MACOS
+
+#include <glib.h>
+#include <xpc/xpc.h>
+
+typedef void (* FridaXpcHandler) (xpc_object_t object, gpointer user_data);
+typedef gboolean (* FridaXpcDictionaryApplier) (const gchar * key, xpc_object_t val, gpointer user_data);
+
+gpointer _frida_dispatch_retain (gpointer object);
+
+void _frida_xpc_connection_set_event_handler (xpc_connection_t connection, FridaXpcHandler handler, gpointer user_data);
+void _frida_xpc_connection_send_message_with_reply (xpc_connection_t connection, xpc_object_t message, dispatch_queue_t replyq,
+    FridaXpcHandler handler, gpointer user_data, GDestroyNotify notify);
+gchar * _frida_xpc_object_to_string (xpc_object_t object);
+gboolean _frida_xpc_dictionary_apply (xpc_object_t dict, FridaXpcDictionaryApplier applier, gpointer user_data);
+
+#endif
+
+#endif
@@ -0,0 +1,114 @@
+namespace Frida.FS {
+	public void mkdirp (File dir, Cancellable? cancellable = null) throws Error {
+		try {
+			dir.make_directory_with_parents (cancellable);
+		} catch (GLib.Error e) {
+			if (!(e is IOError.EXISTS))
+				throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+	}
+
+	public void rmtree (File dir, Cancellable? cancellable = null) throws Error {
+		rmtree_worker (dir, 0, cancellable);
+	}
+
+	private void rmtree_worker (File dir, uint depth, Cancellable? cancellable = null) throws Error {
+		FileEnumerator enumerator;
+		try {
+			enumerator = dir.enumerate_children (FileAttribute.STANDARD_NAME, NOFOLLOW_SYMLINKS, cancellable);
+		} catch (GLib.Error e) {
+			if (depth == 0 && e is IOError.NOT_FOUND)
+				return;
+			throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+
+		try {
+			FileInfo? info;
+			File? child;
+			while (enumerator.iterate (out info, out child, cancellable) && info != null) {
+				if (info == null)
+					continue;
+				if (info.get_file_type () == DIRECTORY)
+					rmtree (child, cancellable);
+				else
+					child.delete (cancellable);
+			}
+
+			dir.delete (cancellable);
+		} catch (GLib.Error e) {
+			if (!(e is IOError.EXISTS))
+				throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+	}
+
+	public async void rmtree_async (File dir, Cancellable? cancellable = null) throws Error, IOError {
+		yield rmtree_async_worker (dir, 0, cancellable);
+	}
+
+	private async void rmtree_async_worker (File dir, uint depth, Cancellable? cancellable = null) throws Error, IOError {
+		int io_priority = Priority.DEFAULT;
+
+		FileEnumerator enumerator;
+		try {
+			enumerator = yield dir.enumerate_children_async (FileAttribute.STANDARD_NAME, NOFOLLOW_SYMLINKS, io_priority,
+				cancellable);
+		} catch (GLib.Error e) {
+			if (depth == 0 && e is IOError.NOT_FOUND)
+				return;
+			throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+
+		try {
+			while (true) {
+				var batch = yield enumerator.next_files_async (1000, io_priority, cancellable);
+				if (batch.is_empty ())
+					break;
+				foreach (FileInfo info in batch) {
+					File child = dir.get_child (info.get_name ());
+					if (info.get_file_type () == DIRECTORY)
+						yield rmtree_async_worker (child, depth + 1, cancellable);
+					else
+						yield child.delete_async (io_priority, cancellable);
+				}
+			}
+
+			yield dir.delete_async (io_priority, cancellable);
+		} catch (GLib.Error e) {
+			throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+	}
+
+	public async string read_all_text (File f, Cancellable? cancellable) throws Error, IOError {
+		Bytes b = yield read_all_bytes (f, cancellable);
+		string text = (string) b.get_data ();
+		if (!text.validate ())
+			throw new Error.PROTOCOL ("Unable to read '%s': invalid UTF-8", f.get_parse_name ());
+		return text;
+	}
+
+	public async void write_all_text (File f, string t, Cancellable? cancellable) throws Error, IOError {
+		yield write_all_bytes (f, new Bytes (t.data), cancellable);
+	}
+
+	public async Bytes read_all_bytes (File f, Cancellable? cancellable) throws Error, IOError {
+		try {
+			return yield f.load_bytes_async (cancellable, null);
+		} catch (GLib.Error e) {
+			if (e is IOError.CANCELLED)
+				throw (IOError) e;
+			if (e is IOError.NOT_FOUND)
+				throw new Error.INVALID_ARGUMENT ("%s", e.message);
+			throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+	}
+
+	public async void write_all_bytes (File f, Bytes b, Cancellable? cancellable) throws Error, IOError {
+		try {
+			yield f.replace_contents_bytes_async (b, null, false, FileCreateFlags.NONE, cancellable, null);
+		} catch (GLib.Error e) {
+			if (e is IOError.CANCELLED)
+				throw (IOError) e;
+			throw new Error.PERMISSION_DENIED ("%s", e.message);
+		}
+	}
+}
@@ -1,6 +1,7 @@
-#ifndef __FRIDA_SYSCALL_H__
-#define __FRIDA_SYSCALL_H__
+#ifndef __FRIDA_LINUX_SYSCALL_H__
+#define __FRIDA_LINUX_SYSCALL_H__

+#include <linux/unistd.h>
 #include <sys/syscall.h>

 #undef SYS_process_vm_readv
@@ -14,7 +14,7 @@ namespace Frida {
 	[CCode (cheader_filename = "sys/mman.h", cname = "MAP_ANONYMOUS")]
 	public const int MAP_ANONYMOUS;

-	[CCode (cheader_filename = "linux/frida-syscall.h", cprefix = "SYS_", has_type_id = false)]
+	[CCode (cheader_filename = "linux-syscall.h", cprefix = "SYS_", has_type_id = false)]
 	public enum SysCall {
 		memfd_create,
 		pidfd_getfd,
@@ -0,0 +1,107 @@
+namespace Frida {
+	private uint linux_major = 0;
+	private uint linux_minor = 0;
+
+	public bool check_kernel_version (uint major, uint minor) {
+		if (linux_major == 0) {
+			var name = Posix.utsname ();
+			name.release.scanf ("%u.%u", out linux_major, out linux_minor);
+		}
+
+		return (linux_major == major && linux_minor >= minor) || linux_major > major;
+	}
+
+	public class FileDescriptor : Object, FileDescriptorBased {
+		public int handle;
+
+		public FileDescriptor (int handle) {
+			this.handle = handle;
+		}
+
+		~FileDescriptor () {
+			if (handle != -1)
+				Posix.close (handle);
+		}
+
+		public int steal () {
+			int result = handle;
+			handle = -1;
+			return result;
+		}
+
+		public int get_fd () {
+			return handle;
+		}
+	}
+
+	public sealed class PidFileDescriptor : FileDescriptor {
+		private uint pid;
+
+		private PidFileDescriptor (int fd, uint pid) {
+			base (fd);
+			this.pid = pid;
+		}
+
+		public static bool is_supported () {
+			return check_kernel_version (5, 3);
+		}
+
+		public static bool getfd_is_supported () {
+			return check_kernel_version (5, 6);
+		}
+
+		public static PidFileDescriptor from_pid (uint pid) throws Error {
+			int fd = pidfd_open (pid, 0);
+			if (fd == -1)
+				throw_pidfd_error (pid, errno);
+			return new PidFileDescriptor (fd, pid);
+		}
+
+		public FileDescriptor getfd (int targetfd) throws Error {
+			int fd = pidfd_getfd (handle, targetfd, 0);
+			if (fd == -1)
+				throw_pidfd_error (pid, errno);
+			return new FileDescriptor (fd);
+		}
+
+		private static int pidfd_open (uint pid, uint flags) {
+			return Linux.syscall (SysCall.pidfd_open, pid, flags);
+		}
+
+		private static int pidfd_getfd (int pidfd, int targetfd, uint flags) {
+			return Linux.syscall (SysCall.pidfd_getfd, pidfd, targetfd, flags);
+		}
+
+		[NoReturn]
+		private static void throw_pidfd_error (uint pid, int err) throws Error {
+			switch (err) {
+				case Posix.ESRCH:
+					throw new Error.PROCESS_NOT_FOUND ("Process not found");
+				case Posix.EPERM:
+					throw new Error.PERMISSION_DENIED ("Unable to use pidfd for pid %u: %s", pid, strerror (err));
+				default:
+					throw new Error.NOT_SUPPORTED ("Unable to use pidfd for pid %u: %s", pid, strerror (err));
+			}
+		}
+	}
+
+	namespace MemoryFileDescriptor {
+		public bool is_supported () {
+			return check_kernel_version (3, 17);
+		}
+
+		public static FileDescriptor from_bytes (string name, Bytes bytes) {
+			assert (is_supported ());
+
+			var fd = new FileDescriptor (memfd_create (name, 0));
+			unowned uint8[] data = bytes.get_data ();
+			ssize_t n = Posix.write (fd.handle, data, data.length);
+			assert (n == data.length);
+			return fd;
+		}
+
+		private int memfd_create (string name, uint flags) {
+			return Linux.syscall (SysCall.memfd_create, name, flags);
+		}
+	}
+}
@@ -1,17 +1,44 @@
 base_sources = [
  'session.vala',
  'session-glue.c',
+  'channel.vala',
+  'service.vala',
+  'stream.vala',
  'rpc.vala',
  'p2p.vala',
  'p2p-glue.c',
  'dbus.vala',
  'promise.vala',
+  'fs.vala',
  'socket.vala',
  'socket-glue.c',
  'buffer.vala',
+  'buffer-glue.c',
+  'value.vala',
 ]

 extra_vala_args = []
+
+if host_os == 'macos'
+  base_sources += [
+    'xpc.vala',
+    'frida-darwin.c',
+  ]
+endif
+
+if host_os_family == 'darwin'
+  base_sources += 'corefoundation.vala'
+endif
+
+if host_os_family == 'linux'
+  base_sources += 'linux.vala'
+  extra_vala_args += [
+    '--pkg=linux',
+    '--pkg=linux-system',
+    '--pkg=posix',
+  ]
+endif
+
 extra_deps = []
 if host_os_family != 'windows'
  extra_vala_args += '--pkg=gio-unix-2.0'
@@ -22,21 +49,37 @@ base_vala_args = [gum_vala_args, '--pkg=gio-2.0', '--pkg=json-glib-1.0']
 if nice_dep.found()
  base_vala_args += '--pkg=nice'
 endif
+if host_os_family == 'darwin'
+  base_vala_args += [
+    '--pkg=corefoundation',
+    '--pkg=darwin-gcd',
+    '--pkg=darwin-xpc',
+  ]
+endif
+if host_os_family == 'linux'
+  base_vala_args += [
+    '--vapidir=' + meson.current_source_dir(),
+    '--pkg=gio-unix-2.0',
+  ]
+endif
+
+base_gir_name = f'FridaBase-@[email protected]'

 base = static_library('frida-base-' + api_version, base_sources,
  c_args: frida_component_cflags,
  vala_args: [base_vala_args, '--pkg=libsoup-3.0'] + extra_vala_args,
  vala_header: 'frida-base.h',
+  vala_gir: base_gir_name,
  vala_vapi: f'frida-base-@[email protected]',
  dependencies: [glib_dep, gobject_dep, gio_dep, libsoup_dep, nice_dep, usrsctp_dep, gee_dep, json_glib_dep, gum_dep, openssl_dep] + extra_deps,
  install: true,
-  install_dir: [true, header_install_dir, true],
+  install_dir: [true, header_install_dir, true, false],
 )

 base_dep = declare_dependency(
  include_directories: include_directories('.'),
  link_with: base,
-  dependencies: [nice_dep, json_glib_dep, gum_dep],
+  dependencies: [nice_dep, json_glib_dep, gum_dep] + extra_deps,
 )

 base_build_dir = meson.current_build_dir()
@@ -169,7 +169,7 @@ namespace Frida {
 		}
 	}

-	public class PeerSocket : Object, DatagramBased {
+	public sealed class PeerSocket : Object, DatagramBased {
 		public Nice.Agent agent {
 			get;
 			construct;
@@ -452,6 +452,8 @@ namespace Frida {
 				if ((_pending_io & c) != 0)
 					source.set_ready_time (0);
 			}
+
+			notify_property ("pending-io");
 		}

 		private void prepare_for_io (int64 timeout, Cancellable? cancellable, out int64 deadline) throws IOError {
@@ -563,7 +565,7 @@ namespace Frida {
 		}
 	}

-	public class SctpConnection : IOStream {
+	public sealed class SctpConnection : VirtualStream {
 		public DatagramBased transport_socket {
 			get;
 			construct;
@@ -584,55 +586,14 @@ namespace Frida {
 			construct;
 		}

-		public State state {
-			get {
-				return _state;
-			}
-		}
-
-		public override InputStream input_stream {
-			get {
-				return _input_stream;
-			}
-		}
-
-		public override OutputStream output_stream {
-			get {
-				return _output_stream;
-			}
-		}
-
-		public IOCondition pending_io {
-			get {
-				lock (state)
-					return sctp_events;
-			}
-		}
-
-		private State _state = CREATED;
-		private SctpInputStream _input_stream;
-		private SctpOutputStream _output_stream;
-
 		private DatagramBasedSource transport_source;
 		private uint8[] transport_buffer = new uint8[65536];

 		private void * sctp_socket;
-		private IOCondition sctp_events = 0;
 		private SctpTimerSource sctp_source;
 		private uint16 stream_id;
 		private ByteArray dcep_message = new ByteArray ();

-		private Gee.Map<unowned Source, IOCondition> sources = new Gee.HashMap<unowned Source, IOCondition> ();
-
-		private Cancellable io_cancellable = new Cancellable ();
-
-		public enum State {
-			CREATED,
-			OPENING,
-			OPENED,
-			CLOSED
-		}
-
 		public SctpConnection (DatagramBased transport_socket, PeerSetup setup, uint16 port, size_t max_message_size) {
 			Object (
 				transport_socket: transport_socket,
@@ -649,14 +610,9 @@ namespace Frida {
 		protected extern static void _initialize_sctp_backend ();

 		construct {
-			_input_stream = new SctpInputStream (this);
-			_output_stream = new SctpOutputStream (this);
-
 			sctp_socket = _create_sctp_socket ();
 			_connect_sctp_socket (sctp_socket, port);

-			var main_context = MainContext.get_thread_default ();
-
 			transport_source = transport_socket.create_source (IOCondition.IN, io_cancellable);
 			transport_source.set_callback (on_transport_socket_readable);
 			transport_source.attach (main_context);
@@ -669,17 +625,22 @@ namespace Frida {

 		protected extern void _connect_sctp_socket (void * sock, uint16 port);

-		public override bool close (GLib.Cancellable? cancellable) throws IOError {
-			do_close ();
-			return true;
+		protected override VirtualStream.State query_initial_state () {
+			return CREATED;
 		}

-		public override async bool close_async (int io_priority, GLib.Cancellable? cancellable) throws IOError {
-			do_close ();
-			return true;
+		protected override IOCondition query_events () {
+			return _query_sctp_socket_events (sctp_socket);
 		}

-		private void do_close () {
+		protected override void update_pending_io () {
+			base.update_pending_io ();
+			sctp_source.invalidate ();
+		}
+
+		protected extern static IOCondition _query_sctp_socket_events (void * sock);
+
+		protected override void handle_close () {
 			sctp_source.destroy ();
 			transport_source.destroy ();

@@ -689,13 +650,17 @@ namespace Frida {

 		public extern static void _close (void * sock);

-		public void shutdown (SctpShutdownType type) throws IOError {
-			_shutdown (sctp_socket, type);
+		public override void shutdown_read () throws IOError {
+			_shutdown (sctp_socket, READ);
+		}
+
+		public override void shutdown_write () throws IOError {
+			_shutdown (sctp_socket, WRITE);
 		}

 		public extern static void _shutdown (void * sock, SctpShutdownType type) throws IOError;

-		public ssize_t recv (uint8[] buffer) throws IOError {
+		public override ssize_t read (uint8[] buffer) throws IOError {
 			ssize_t n = -1;

 			try {
@@ -711,18 +676,18 @@ namespace Frida {
 						handle_dcep_message (stream_id, dcep_message.steal ());
 					}
 					throw new IOError.WOULD_BLOCK ("Resource temporarily unavailable");
-				} else if (protocol_id == NONE || _state != OPENED) {
+				} else if (protocol_id == NONE || state != OPEN) {
 					throw new IOError.WOULD_BLOCK ("Resource temporarily unavailable");
 				}
 			} finally {
-				update_sctp_events ();
+				update_pending_io ();
 			}

 			return n;
 		}

-		public ssize_t send (uint8[] buffer) throws IOError {
-			if (_state != OPENED)
+		public override ssize_t write (uint8[] buffer) throws IOError {
+			if (state != OPEN)
 				throw new IOError.WOULD_BLOCK ("Resource temporarily unavailable");

 			ssize_t n = ssize_t.min (buffer.length, (ssize_t) max_message_size);
@@ -730,20 +695,10 @@ namespace Frida {
 			try {
 				return _send (sctp_socket, stream_id, WEBRTC_BINARY, buffer[0:n]);
 			} finally {
-				update_sctp_events ();
+				update_pending_io ();
 			}
 		}

-		public void register_source (Source source, IOCondition condition) {
-			lock (state)
-				sources[source] = condition | IOCondition.ERR | IOCondition.HUP;
-		}
-
-		public void unregister_source (Source source) {
-			lock (state)
-				sources.unset (source);
-		}
-
 		private bool on_transport_socket_readable (DatagramBased datagram_based, IOCondition condition) {
 			var v = InputVector ();
 			v.buffer = transport_buffer;
@@ -774,31 +729,18 @@ namespace Frida {
 		protected extern void _handle_transport_packet (uint8[] data);

 		protected int _emit_transport_packet (uint8[] data) {
-			var v = OutputVector ();
-			v.buffer = data;
-			v.size = data.length;
-
-			OutputVector[] vectors = { v };
-
-			var m = OutputMessage ();
-			m.vectors = vectors;
-			m.num_vectors = vectors.length;
-
-			OutputMessage[] messages = { m };
-
 			try {
-				transport_socket.send_messages (messages, 0, 0, io_cancellable);
+				Udp.send (data, transport_socket, io_cancellable);
+				return 0;
 			} catch (GLib.Error e) {
 				return -1;
 			}
-
-			return 0;
 		}

 		protected void _on_sctp_socket_events_changed () {
-			update_sctp_events ();
+			update_pending_io ();

-			if (_state == CREATED && setup == ACTIVE && (sctp_events & IOCondition.OUT) != 0) {
+			if (state == CREATED && setup == ACTIVE && (pending_io & IOCondition.OUT) != 0) {
 				stream_id = 1;

 				uint8[] open_message = {
@@ -812,31 +754,12 @@ namespace Frida {
 				};
 				try {
 					_send (sctp_socket, stream_id, WEBRTC_DCEP, open_message);
-					_state = OPENING;
+					state = OPENING;
 				} catch (IOError e) {
 				}
 			}
 		}

-		private void update_sctp_events () {
-			IOCondition new_events = _query_sctp_socket_events (sctp_socket);
-
-			lock (state) {
-				sctp_events = new_events;
-
-				foreach (var entry in sources.entries) {
-					unowned Source source = entry.key;
-					IOCondition c = entry.value;
-					if ((new_events & c) != 0)
-						source.set_ready_time (0);
-				}
-
-				sctp_source.invalidate ();
-			}
-		}
-
-		protected extern static IOCondition _query_sctp_socket_events (void * sock);
-
 		protected extern static ssize_t _recv (void * sock, uint8[] buffer, out uint16 stream_id,
 			out PayloadProtocolId protocol_id, out SctpMessageFlags message_flags) throws IOError;

@@ -848,7 +771,7 @@ namespace Frida {

 			switch (type) {
 				case DATA_CHANNEL_OPEN: {
-					if (_state != CREATED || setup == ACTIVE)
+					if (state != CREATED || setup == ACTIVE)
 						return;

 					this.stream_id = stream_id;
@@ -856,15 +779,15 @@ namespace Frida {
 					uint8[] reply = { DcepMessageType.DATA_CHANNEL_ACK };
 					_send (sctp_socket, stream_id, WEBRTC_DCEP, reply);

-					_state = OPENED;
+					state = OPEN;

 					break;
 				}
 				case DATA_CHANNEL_ACK:
-					if (_state != OPENING)
+					if (state != OPENING)
 						return;

-					_state = OPENED;
+					state = OPEN;

 					break;
 			}
@@ -899,140 +822,6 @@ namespace Frida {
 		DATA_CHANNEL_ACK = 0x02
 	}

-	private class SctpInputStream : InputStream, PollableInputStream {
-		public weak SctpConnection connection {
-			get;
-			construct;
-		}
-
-		public SctpInputStream (SctpConnection connection) {
-			Object (connection: connection);
-		}
-
-		public override bool close (Cancellable? cancellable) throws IOError {
-			connection.shutdown (READ);
-			return true;
-		}
-
-		public override async bool close_async (int io_priority, Cancellable? cancellable) throws GLib.IOError {
-			return close (cancellable);
-		}
-
-		public override ssize_t read (uint8[] buffer, Cancellable? cancellable) throws IOError {
-			assert_not_reached ();
-		}
-
-		public bool can_poll () {
-			return true;
-		}
-
-		public bool is_readable () {
-			return (connection.pending_io & IOCondition.IN) != 0;
-		}
-
-		public PollableSource create_source (Cancellable? cancellable) {
-			return new PollableSource.full (this, new SctpIOSource (connection, IOCondition.IN), cancellable);
-		}
-
-		public ssize_t read_nonblocking_fn (uint8[] buffer) throws GLib.Error {
-			return connection.recv (buffer);
-		}
-	}
-
-	private class SctpOutputStream : OutputStream, PollableOutputStream {
-		public weak SctpConnection connection {
-			get;
-			construct;
-		}
-
-		public SctpOutputStream (SctpConnection connection) {
-			Object (connection: connection);
-		}
-
-		public override bool close (Cancellable? cancellable) throws IOError {
-			connection.shutdown (WRITE);
-			return true;
-		}
-
-		public override async bool close_async (int io_priority, Cancellable? cancellable) throws GLib.IOError {
-			return close (cancellable);
-		}
-
-		public override bool flush (GLib.Cancellable? cancellable) throws GLib.Error {
-			return true;
-		}
-
-		public override async bool flush_async (int io_priority, GLib.Cancellable? cancellable) throws GLib.Error {
-			return true;
-		}
-
-		public override ssize_t write (uint8[] buffer, Cancellable? cancellable) throws IOError {
-			assert_not_reached ();
-		}
-
-		public bool can_poll () {
-			return true;
-		}
-
-		public bool is_writable () {
-			return (connection.pending_io & IOCondition.OUT) != 0;
-		}
-
-		public PollableSource create_source (Cancellable? cancellable) {
-			return new PollableSource.full (this, new SctpIOSource (connection, IOCondition.OUT), cancellable);
-		}
-
-		public ssize_t write_nonblocking_fn (uint8[]? buffer) throws GLib.Error {
-			return connection.send (buffer);
-		}
-
-		public PollableReturn writev_nonblocking_fn (OutputVector[] vectors, out size_t bytes_written) throws GLib.Error {
-			assert_not_reached ();
-		}
-	}
-
-	private class SctpIOSource : Source {
-		public SctpConnection connection;
-		public IOCondition condition;
-
-		public SctpIOSource (SctpConnection connection, IOCondition condition) {
-			this.connection = connection;
-			this.condition = condition;
-
-			connection.register_source (this, condition);
-		}
-
-		~SctpIOSource () {
-			connection.unregister_source (this);
-		}
-
-		protected override bool prepare (out int timeout) {
-			timeout = -1;
-			return (connection.pending_io & condition) != 0;
-		}
-
-		protected override bool check () {
-			return (connection.pending_io & condition) != 0;
-		}
-
-		protected override bool dispatch (SourceFunc? callback) {
-			set_ready_time (-1);
-
-			if (callback == null)
-				return Source.REMOVE;
-
-			return callback ();
-		}
-
-		protected static bool closure_callback (Closure closure) {
-			var return_value = Value (typeof (bool));
-
-			closure.invoke (ref return_value, {});
-
-			return return_value.get_boolean ();
-		}
-	}
-
 	private class SctpTimerSource : Source {
 		private static int64 last_process_time = -1;

@@ -1,5 +1,5 @@
 namespace Frida {
-	public class Promise<T> {
+	public sealed class Promise<T> {
 		private Impl<T> impl;

 		public Future<T> future {
@@ -46,7 +46,8 @@ namespace Frida {
 			}
 			private GLib.Error? _error;

-			private Gee.ArrayQueue<CompletionFuncEntry> on_complete;
+			private Gee.ArrayQueue<CompletionFuncEntry>? on_complete;
+			private Gee.ArrayQueue<ThenHandlerEntry<T>>? on_then;

 			public async T wait_async (Cancellable? cancellable) throws Frida.Error, IOError {
 				if (_ready)
@@ -74,7 +75,21 @@ namespace Frida {
 				return get_result ();
 			}

-			private T get_result () throws Frida.Error, IOError {
+			public void then (owned FutureCompletionHandler<T> handler) {
+				if (_ready) {
+					schedule (() => {
+						handler (this);
+						return Source.REMOVE;
+					});
+					return;
+				}
+
+				if (on_then == null)
+					on_then = new Gee.ArrayQueue<ThenHandlerEntry<T>> ();
+				on_then.offer (new ThenHandlerEntry<T> ((owned) handler));
+			}
+
+			public T get_result () throws Frida.Error, IOError {
 				if (error != null) {
 					if (error is Frida.Error)
 						throw (Frida.Error) error;
@@ -111,19 +126,32 @@ namespace Frida {
 			internal void transition_to_ready () {
 				_ready = true;

-				if (on_complete != null && !on_complete.is_empty) {
-					var source = new IdleSource ();
-					source.set_priority (Priority.HIGH);
-					source.set_callback (() => {
-						CompletionFuncEntry? entry;
-						while ((entry = on_complete.poll ()) != null)
-							entry.func ();
-						on_complete = null;
-						return false;
+				if (on_complete != null || on_then != null) {
+					schedule (() => {
+						if (on_complete != null) {
+							CompletionFuncEntry? entry;
+							while ((entry = on_complete.poll ()) != null)
+								entry.func ();
+							on_complete = null;
+						}
+
+						if (on_then != null) {
+							ThenHandlerEntry? entry;
+							while ((entry = on_then.poll ()) != null)
+								entry.handler (this);
+							on_then = null;
+						}
+
+						return Source.REMOVE;
 					});
-					source.attach (MainContext.get_thread_default ());
 				}
 			}
+
+			private static void schedule (owned SourceFunc function) {
+				var source = new IdleSource ();
+				source.set_callback ((owned) function);
+				source.attach (MainContext.get_thread_default ());
+			}
 		}

 		private class CompletionFuncEntry {
@@ -133,6 +161,14 @@ namespace Frida {
 				this.func = (owned) func;
 			}
 		}
+
+		private class ThenHandlerEntry<T> {
+			public FutureCompletionHandler<T> handler;
+
+			public ThenHandlerEntry (owned FutureCompletionHandler<T> handler) {
+				this.handler = (owned) handler;
+			}
+		}
 	}

 	public interface Future<T> : Object {
@@ -140,5 +176,9 @@ namespace Frida {
 		public abstract T? value { get; }
 		public abstract GLib.Error? error { get; }
 		public abstract async T wait_async (Cancellable? cancellable) throws Frida.Error, IOError;
+		public abstract void then (owned FutureCompletionHandler<T> handler);
+		public abstract T get_result () throws Frida.Error, IOError;
 	}
+
+	public delegate void FutureCompletionHandler<T> (Future<T> future);
 }
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class RpcClient : Object {
+	public sealed class RpcClient : Object {
 		public weak RpcPeer peer {
 			get;
 			construct;
@@ -11,7 +11,7 @@ namespace Frida {
 			Object (peer: peer);
 		}

-		public async Json.Node call (string method, Json.Node[] args, Cancellable? cancellable) throws Error, IOError {
+		public async Json.Node call (string method, Json.Node[] args, Bytes? data, Cancellable? cancellable) throws Error, IOError {
 			string request_id = Uuid.string_random ();

 			var request = new Json.Builder ();
@@ -39,7 +39,7 @@ namespace Frida {
 			pending_responses[request_id] = pending;

 			try {
-				yield peer.post_rpc_message (raw_request, cancellable);
+				yield peer.post_rpc_message (raw_request, data, cancellable);
 			} catch (Error e) {
 				if (pending_responses.unset (request_id))
 					pending.complete_with_error (e);
@@ -158,6 +158,6 @@ namespace Frida {
 	}

 	public interface RpcPeer : Object {
-		public abstract async void post_rpc_message (string json, Cancellable? cancellable) throws Error, IOError;
+		public abstract async void post_rpc_message (string json, Bytes? data, Cancellable? cancellable) throws Error, IOError;
 	}
 }
@@ -0,0 +1,48 @@
+namespace Frida {
+	public sealed class ServiceSessionRegistry : Object {
+		public signal void session_closed (ServiceSessionId id);
+
+		private Gee.Map<ServiceSessionId?, ServiceSession> sessions =
+			new Gee.HashMap<ServiceSessionId?, ServiceSession> (ServiceSessionId.hash, ServiceSessionId.equal);
+
+		~ServiceSessionRegistry () {
+			clear ();
+		}
+
+		public void clear () {
+			foreach (var session in sessions.values.to_array ())
+				session.close ();
+			sessions.clear ();
+		}
+
+		public void register (ServiceSessionId id, ServiceSession session) {
+			sessions[id] = session;
+
+			ServiceSessionId? boxed_id = id;
+			session.set_data ("service-session-id", boxed_id);
+
+			session.close.connect (on_session_close);
+		}
+
+		public ServiceSession link (ServiceSessionId id) throws Error {
+			var session = sessions[id];
+			if (session == null)
+				throw new Error.INVALID_ARGUMENT ("Invalid session ID");
+			return session;
+		}
+
+		public void unlink (ServiceSessionId id) {
+			ServiceSession? session;
+			if (sessions.unset (id, out session)) {
+				session.close.disconnect (on_session_close);
+
+				session_closed (id);
+			}
+		}
+
+		private void on_session_close (ServiceSession session) {
+			ServiceSessionId? id = session.get_data ("service-session-id");
+			unlink (id);
+		}
+	}
+}
@@ -1,5 +1,5 @@
 namespace Frida {
-	[DBus (name = "re.frida.HostSession16")]
+	[DBus (name = "re.frida.HostSession17")]
 	public interface HostSession : Object {
 		public abstract async void ping (uint interval_seconds, Cancellable? cancellable) throws GLib.Error;

@@ -27,6 +27,10 @@ namespace Frida {
 		public abstract async InjectorPayloadId inject_library_blob (uint pid, uint8[] blob, string entrypoint, string data,
 			Cancellable? cancellable) throws GLib.Error;

+		public abstract async ChannelId open_channel (string address, Cancellable? cancellable) throws GLib.Error;
+
+		public abstract async ServiceSessionId open_service (string address, Cancellable? cancellable) throws GLib.Error;
+
 		public signal void spawn_added (HostSpawnInfo info);
 		public signal void spawn_removed (HostSpawnInfo info);
 		public signal void child_added (HostChildInfo info);
@@ -34,10 +38,12 @@ namespace Frida {
 		public signal void process_crashed (CrashInfo crash);
 		public signal void output (uint pid, int fd, uint8[] data);
 		public signal void agent_session_detached (AgentSessionId id, SessionDetachReason reason, CrashInfo crash);
+		public signal void channel_closed (ChannelId id);
+		public signal void service_session_closed (ServiceSessionId id);
 		public signal void uninjected (InjectorPayloadId id);
 	}

-	[DBus (name = "re.frida.AgentSessionProvider16")]
+	[DBus (name = "re.frida.AgentSessionProvider17")]
 	public interface AgentSessionProvider : Object {
 		public abstract async void open (AgentSessionId id, HashTable<string, Variant> options,
 			Cancellable? cancellable) throws GLib.Error;
@@ -52,7 +58,7 @@ namespace Frida {
 		public signal void child_gating_changed (uint subscriber_count);
 	}

-	[DBus (name = "re.frida.AgentSession16")]
+	[DBus (name = "re.frida.AgentSession17")]
 	public interface AgentSession : Object {
 		public abstract async void close (Cancellable? cancellable) throws GLib.Error;

@@ -94,7 +100,7 @@ namespace Frida {
 		public signal void candidate_gathering_done ();
 	}

-	[DBus (name = "re.frida.AgentController16")]
+	[DBus (name = "re.frida.AgentController17")]
 	public interface AgentController : Object {
 #if !WINDOWS
 		public abstract async HostChildId prepare_to_fork (uint parent_pid, Cancellable? cancellable, out uint parent_injectee_id,
@@ -115,7 +121,7 @@ namespace Frida {
 			Cancellable? cancellable) throws GLib.Error;
 	}

-	[DBus (name = "re.frida.AgentMessageSink16")]
+	[DBus (name = "re.frida.AgentMessageSink17")]
 	public interface AgentMessageSink : Object {
 		public abstract async void post_messages (AgentMessage[] messages, uint batch_id,
 			Cancellable? cancellable) throws GLib.Error;
@@ -145,7 +151,7 @@ namespace Frida {
 		DEBUGGER
 	}

-	public class AgentMessageTransmitter : Object {
+	public sealed class AgentMessageTransmitter : Object {
 		public signal void closed ();
 		public signal void new_candidates (string[] candidate_sdps);
 		public signal void candidate_gathering_done ();
@@ -743,13 +749,30 @@ namespace Frida {
 		}
 	}

-	[DBus (name = "re.frida.TransportBroker16")]
+	[DBus (name = "re.frida.Channel17")]
+	public interface Channel : Object {
+		public abstract async void close (Cancellable? cancellable) throws GLib.Error;
+		public abstract async void input (uint8[] data, Cancellable? cancellable) throws GLib.Error;
+		public signal void output (uint8[] data);
+	}
+
+	[DBus (name = "re.frida.ServiceSession17")]
+	public interface ServiceSession : Object {
+		public signal void close ();
+		public signal void message (Variant message);
+
+		public abstract async void activate (Cancellable? cancellable) throws GLib.Error;
+		public abstract async void cancel (Cancellable? cancellable) throws GLib.Error;
+		public abstract async Variant request (Variant parameters, Cancellable? cancellable) throws GLib.Error;
+	}
+
+	[DBus (name = "re.frida.TransportBroker17")]
 	public interface TransportBroker : Object {
 		public abstract async void open_tcp_transport (AgentSessionId id, Cancellable? cancellable, out uint16 port,
 			out string token) throws GLib.Error;
 	}

-	[DBus (name = "re.frida.PortalSession16")]
+	[DBus (name = "re.frida.PortalSession17")]
 	public interface PortalSession : Object {
 		public abstract async void join (HostApplicationInfo app, SpawnStartState current_state,
 			AgentSessionId[] interrupted_sessions, HashTable<string, Variant> options, Cancellable? cancellable,
@@ -758,19 +781,19 @@ namespace Frida {
 		public signal void kill ();
 	}

-	[DBus (name = "re.frida.BusSession16")]
+	[DBus (name = "re.frida.BusSession17")]
 	public interface BusSession : Object {
 		public abstract async void attach (Cancellable? cancellable) throws GLib.Error;
 		public abstract async void post (string json, bool has_data, uint8[] data, Cancellable? cancellable) throws GLib.Error;
 		public signal void message (string json, bool has_data, uint8[] data);
 	}

-	[DBus (name = "re.frida.AuthenticationService16")]
+	[DBus (name = "re.frida.AuthenticationService17")]
 	public interface AuthenticationService : Object {
 		public abstract async string authenticate (string token, Cancellable? cancellable) throws GLib.Error;
 	}

-	public class StaticAuthenticationService : Object, AuthenticationService {
+	public sealed class StaticAuthenticationService : Object, AuthenticationService {
 		public string token_hash {
 			get;
 			construct;
@@ -795,13 +818,13 @@ namespace Frida {
 		}
 	}

-	public class NullAuthenticationService : Object, AuthenticationService {
+	public sealed class NullAuthenticationService : Object, AuthenticationService {
 		public async string authenticate (string token, Cancellable? cancellable) throws Error, IOError {
 			throw new Error.INVALID_OPERATION ("Authentication not expected");
 		}
 	}

-	public class UnauthorizedHostSession : Object, HostSession {
+	public sealed class UnauthorizedHostSession : Object, HostSession {
 		public async void ping (uint interval_seconds, Cancellable? cancellable) throws Error, IOError {
 			throw_not_authorized ();
 		}
@@ -875,9 +898,17 @@ namespace Frida {
 				Cancellable? cancellable) throws Error, IOError {
 			throw_not_authorized ();
 		}
+
+		public async ChannelId open_channel (string address, Cancellable? cancellable) throws Error, IOError {
+			throw_not_authorized ();
+		}
+
+		public async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
+			throw_not_authorized ();
+		}
 	}

-	public class UnauthorizedPortalSession : Object, PortalSession {
+	public sealed class UnauthorizedPortalSession : Object, PortalSession {
 		public async void join (HostApplicationInfo app, SpawnStartState current_state,
 				AgentSessionId[] interrupted_sessions, HashTable<string, Variant> options,
 				Cancellable? cancellable, out SpawnStartState next_state) throws Error, IOError {
@@ -885,7 +916,7 @@ namespace Frida {
 		}
 	}

-	public class UnauthorizedBusSession : Object, BusSession {
+	public sealed class UnauthorizedBusSession : Object, BusSession {
 		public async void attach (Cancellable? cancellable) throws Error, IOError {
 			throw_not_authorized ();
 		}
@@ -1083,7 +1114,7 @@ namespace Frida {
 		}
 	}

-	public class FrontmostQueryOptions : Object {
+	public sealed class FrontmostQueryOptions : Object {
 		public Scope scope {
 			get;
 			set;
@@ -1113,7 +1144,7 @@ namespace Frida {
 		}
 	}

-	public class ApplicationQueryOptions : Object {
+	public sealed class ApplicationQueryOptions : Object {
 		public Scope scope {
 			get;
 			set;
@@ -1171,7 +1202,7 @@ namespace Frida {
 		}
 	}

-	public class ProcessQueryOptions : Object {
+	public sealed class ProcessQueryOptions : Object {
 		public Scope scope {
 			get;
 			set;
@@ -1313,7 +1344,7 @@ namespace Frida {
 		}
 	}

-	public class SessionOptions : Object {
+	public sealed class SessionOptions : Object {
 		public Realm realm {
 			get;
 			set;
@@ -1502,6 +1533,46 @@ namespace Frida {
 		}
 	}

+	public struct ChannelId {
+		public string handle;
+
+		public ChannelId (string handle) {
+			this.handle = handle;
+		}
+
+		public ChannelId.generate () {
+			this.handle = Uuid.string_random ().replace ("-", "");
+		}
+
+		public static uint hash (ChannelId? id) {
+			return id.handle.hash ();
+		}
+
+		public static bool equal (ChannelId? a, ChannelId? b) {
+			return a.handle == b.handle;
+		}
+	}
+
+	public struct ServiceSessionId {
+		public string handle;
+
+		public ServiceSessionId (string handle) {
+			this.handle = handle;
+		}
+
+		public ServiceSessionId.generate () {
+			this.handle = Uuid.string_random ().replace ("-", "");
+		}
+
+		public static uint hash (ServiceSessionId? id) {
+			return id.handle.hash ();
+		}
+
+		public static bool equal (ServiceSessionId? a, ServiceSessionId? b) {
+			return a.handle == b.handle;
+		}
+	}
+
 	public struct AgentScriptId {
 		public uint handle;

@@ -1518,7 +1589,7 @@ namespace Frida {
 		}
 	}

-	public class ScriptOptions : Object {
+	public sealed class ScriptOptions : Object {
 		public string? name {
 			get;
 			set;
@@ -1608,7 +1679,7 @@ namespace Frida {
 		SHARED_MEMORY
 	}

-	public class SnapshotOptions : Object {
+	public sealed class SnapshotOptions : Object {
 		public string? warmup_script {
 			get;
 			set;
@@ -1683,7 +1754,7 @@ namespace Frida {
 		}
 	}

-	public class PortalOptions : Object {
+	public sealed class PortalOptions : Object {
 		public TlsCertificate? certificate {
 			get;
 			set;
@@ -1746,7 +1817,7 @@ namespace Frida {
 		}
 	}

-	public class PeerOptions : Object {
+	public sealed class PeerOptions : Object {
 		public string? stun_server {
 			get;
 			set;
@@ -1807,7 +1878,7 @@ namespace Frida {
 		}
 	}

-	public class Relay : Object {
+	public sealed class Relay : Object {
 		public string address {
 			get;
 			construct;
@@ -2048,7 +2119,8 @@ namespace Frida {
 		public const string AGENT_SESSION = "/re/frida/AgentSession";
 		public const string AGENT_CONTROLLER = "/re/frida/AgentController";
 		public const string AGENT_MESSAGE_SINK = "/re/frida/AgentMessageSink";
-		public const string CHILD_SESSION = "/re/frida/ChildSession";
+		public const string CHANNEL = "/re/frida/Channel";
+		public const string SERVICE = "/re/frida/Service";
 		public const string TRANSPORT_BROKER = "/re/frida/TransportBroker";
 		public const string PORTAL_SESSION = "/re/frida/PortalSession";
 		public const string BUS_SESSION = "/re/frida/BusSession";
@@ -2061,6 +2133,14 @@ namespace Frida {
 		public static string for_agent_message_sink (AgentSessionId id) {
 			return AGENT_MESSAGE_SINK + "/" + id.handle;
 		}
+
+		public static string for_channel (ChannelId id) {
+			return CHANNEL + "/" + id.handle;
+		}
+
+		public static string for_service_session (ServiceSessionId id) {
+			return SERVICE + "/" + id.handle;
+		}
 	}

 	namespace Marshal {
@@ -2079,6 +2159,17 @@ namespace Frida {
 	}

 	namespace Numeric {
+		public uint int64_hash (int64? val) {
+			uint64 v = (uint64) val.abs ();
+			return (uint) ((v >> 32) ^ (v & 0xffffffffU));
+		}
+
+		public bool int64_equal (int64? val_a, int64? val_b) {
+			int64 a = val_a;
+			int64 b = val_b;
+			return a == b;
+		}
+
 		public uint uint64_hash (uint64? val) {
 			uint64 v = val;
 			return (uint) ((v >> 32) ^ (v & 0xffffffffU));
@@ -0,0 +1,336 @@
+namespace Frida {
+	public abstract class VirtualStream : IOStream {
+		public override InputStream input_stream {
+			get {
+				return _input_stream;
+			}
+		}
+
+		public override OutputStream output_stream {
+			get {
+				return _output_stream;
+			}
+		}
+
+		public IOCondition pending_io {
+			get {
+				lock (state)
+					return _pending_io;
+			}
+		}
+
+		protected State state = OPEN;
+
+		private VirtualInputStream _input_stream;
+		private VirtualOutputStream _output_stream;
+
+		private IOCondition _pending_io;
+
+		private Gee.Map<unowned Source, IOCondition> sources = new Gee.HashMap<unowned Source, IOCondition> ();
+
+		protected Cancellable io_cancellable = new Cancellable ();
+
+		protected MainContext main_context;
+
+		protected enum State {
+			CREATED,
+			OPENING,
+			OPEN,
+			CLOSED
+		}
+
+		protected delegate void WorkFunc ();
+
+		construct {
+			_input_stream = new VirtualInputStream (this);
+			_output_stream = new VirtualOutputStream (this);
+
+			main_context = MainContext.ref_thread_default ();
+
+			state = query_initial_state ();
+			_pending_io = query_events ();
+		}
+
+		public override void dispose () {
+			_output_stream.detach ();
+			_input_stream.detach ();
+
+			io_cancellable.cancel ();
+
+			base.dispose ();
+		}
+
+		protected virtual State query_initial_state () {
+			return OPEN;
+		}
+
+		protected abstract IOCondition query_events ();
+
+		public override bool close (GLib.Cancellable? cancellable) throws IOError {
+			_close ();
+			return true;
+		}
+
+		public override async bool close_async (int io_priority, GLib.Cancellable? cancellable) throws IOError {
+			_close ();
+			return true;
+		}
+
+		private void _close () {
+			if (main_context.is_owner ()) {
+				do_close ();
+			} else {
+				var source = new IdleSource ();
+				source.set_callback (() => {
+					do_close ();
+					return Source.REMOVE;
+				});
+				source.attach (main_context);
+			}
+		}
+
+		private void do_close () {
+			if (state == CLOSED)
+				return;
+
+			handle_close ();
+		}
+
+		protected abstract void handle_close ();
+
+		public virtual void shutdown_read () throws IOError {
+		}
+
+		public virtual void shutdown_write () throws IOError {
+		}
+
+		public abstract ssize_t read (uint8[] buffer) throws IOError;
+
+		public abstract ssize_t write (uint8[] buffer) throws IOError;
+
+		protected void with_state_lock (WorkFunc func) {
+			lock (state)
+				func ();
+		}
+
+		public void register_source (Source source, IOCondition condition) {
+			lock (state)
+				sources[source] = condition | IOCondition.ERR | IOCondition.HUP;
+		}
+
+		public void unregister_source (Source source) {
+			lock (state)
+				sources.unset (source);
+		}
+
+		protected virtual void update_pending_io () {
+			lock (state) {
+				_pending_io = query_events ();
+
+				foreach (var entry in sources.entries) {
+					unowned Source source = entry.key;
+					IOCondition c = entry.value;
+					if ((_pending_io & c) != 0)
+						source.set_ready_time (0);
+				}
+			}
+
+			notify_property ("pending-io");
+		}
+	}
+
+	private sealed class VirtualInputStream : InputStream, PollableInputStream {
+		private weak VirtualStream stream;
+
+		public VirtualInputStream (VirtualStream stream) {
+			Object ();
+			this.stream = stream;
+		}
+
+		internal void detach () {
+			stream = null;
+		}
+
+		public override bool close (Cancellable? cancellable) throws IOError {
+			if (stream != null)
+				stream.shutdown_read ();
+			return true;
+		}
+
+		public override async bool close_async (int io_priority, Cancellable? cancellable) throws GLib.IOError {
+			return close (cancellable);
+		}
+
+		public override ssize_t read (uint8[] buffer, Cancellable? cancellable) throws IOError {
+			if (stream == null)
+				return 0;
+
+			if (!is_readable ()) {
+				bool done = false;
+				var mutex = Mutex ();
+				var cond = Cond ();
+
+				ulong io_handler = stream.notify["pending-io"].connect ((obj, pspec) => {
+					if (is_readable ()) {
+						mutex.lock ();
+						done = true;
+						cond.signal ();
+						mutex.unlock ();
+					}
+				});
+				ulong cancellation_handler = 0;
+				if (cancellable != null) {
+					cancellation_handler = cancellable.connect (() => {
+						mutex.lock ();
+						done = true;
+						cond.signal ();
+						mutex.unlock ();
+					});
+				}
+
+				if (!is_readable ()) {
+					mutex.lock ();
+					while (!done)
+						cond.wait (mutex);
+					mutex.unlock ();
+				}
+
+				if (cancellation_handler != 0)
+					cancellable.disconnect (cancellation_handler);
+				stream.disconnect (io_handler);
+
+				cancellable.set_error_if_cancelled ();
+			}
+
+			return stream.read (buffer);
+		}
+
+		public bool can_poll () {
+			return true;
+		}
+
+		public bool is_readable () {
+			if (stream == null)
+				return true;
+			return (stream.pending_io & IOCondition.IN) != 0;
+		}
+
+		public PollableSource create_source (Cancellable? cancellable) {
+			return new PollableSource.full (this, new VirtualIOSource (stream, IOCondition.IN), cancellable);
+		}
+
+		public ssize_t read_nonblocking_fn (uint8[] buffer) throws GLib.Error {
+			if (stream == null)
+				return 0;
+			return stream.read (buffer);
+		}
+	}
+
+	private sealed class VirtualOutputStream : OutputStream, PollableOutputStream {
+		private weak VirtualStream? stream;
+
+		public VirtualOutputStream (VirtualStream stream) {
+			Object ();
+			this.stream = stream;
+		}
+
+		internal void detach () {
+			stream = null;
+		}
+
+		public override bool close (Cancellable? cancellable) throws IOError {
+			if (stream != null)
+				stream.shutdown_write ();
+			return true;
+		}
+
+		public override async bool close_async (int io_priority, Cancellable? cancellable) throws GLib.IOError {
+			return close (cancellable);
+		}
+
+		public override bool flush (GLib.Cancellable? cancellable) throws GLib.Error {
+			return true;
+		}
+
+		public override async bool flush_async (int io_priority, GLib.Cancellable? cancellable) throws GLib.Error {
+			return true;
+		}
+
+		public override ssize_t write (uint8[] buffer, Cancellable? cancellable) throws IOError {
+			return stream.write (buffer);
+		}
+
+		public bool can_poll () {
+			return true;
+		}
+
+		public bool is_writable () {
+			if (stream == null)
+				return false;
+			return (stream.pending_io & IOCondition.OUT) != 0;
+		}
+
+		public PollableSource create_source (Cancellable? cancellable) {
+			return new PollableSource.full (this, new VirtualIOSource (stream, IOCondition.OUT), cancellable);
+		}
+
+		public ssize_t write_nonblocking_fn (uint8[]? buffer) throws GLib.Error {
+			if (stream == null)
+				throw new IOError.CLOSED ("Virtual is closed");
+			return stream.write (buffer);
+		}
+
+		public PollableReturn writev_nonblocking_fn (OutputVector[] vectors, out size_t bytes_written) throws GLib.Error {
+			assert_not_reached ();
+		}
+	}
+
+	private class VirtualIOSource : Source {
+		public VirtualStream? stream;
+		public IOCondition condition;
+
+		public VirtualIOSource (VirtualStream stream, IOCondition condition) {
+			this.stream = stream;
+			this.condition = condition;
+
+			if (stream != null)
+				stream.register_source (this, condition);
+		}
+
+		~VirtualIOSource () {
+			if (stream != null)
+				stream.unregister_source (this);
+		}
+
+		protected override bool prepare (out int timeout) {
+			timeout = -1;
+			return is_ready ();
+		}
+
+		protected override bool check () {
+			return is_ready ();
+		}
+
+		private bool is_ready () {
+			IOCondition pending_io = (stream != null) ? stream.pending_io : IOCondition.IN;
+			return (pending_io & condition) != 0;
+		}
+
+		protected override bool dispatch (SourceFunc? callback) {
+			set_ready_time (-1);
+
+			if (callback == null)
+				return Source.REMOVE;
+
+			return callback ();
+		}
+
+		protected static bool closure_callback (Closure closure) {
+			var return_value = Value (typeof (bool));
+
+			closure.invoke (ref return_value, {});
+
+			return return_value.get_boolean ();
+		}
+	}
+}
@@ -0,0 +1,391 @@
+namespace Frida {
+	public interface ObjectBuilder : Object {
+		public abstract unowned ObjectBuilder begin_dictionary ();
+		public abstract unowned ObjectBuilder set_member_name (string name);
+		public abstract unowned ObjectBuilder end_dictionary ();
+
+		public abstract unowned ObjectBuilder begin_array ();
+		public abstract unowned ObjectBuilder end_array ();
+
+		public abstract unowned ObjectBuilder add_null_value ();
+		public abstract unowned ObjectBuilder add_bool_value (bool val);
+		public abstract unowned ObjectBuilder add_int64_value (int64 val);
+		public abstract unowned ObjectBuilder add_uint64_value (uint64 val);
+		public abstract unowned ObjectBuilder add_data_value (Bytes val);
+		public abstract unowned ObjectBuilder add_string_value (string val);
+		public abstract unowned ObjectBuilder add_uuid_value (uint8[] val);
+		public abstract unowned ObjectBuilder add_raw_value (Bytes val);
+
+		public abstract Bytes build ();
+	}
+
+	public interface ObjectReader : Object {
+		public abstract bool has_member (string name) throws Error;
+		public abstract unowned ObjectReader read_member (string name) throws Error;
+		public abstract unowned ObjectReader end_member ();
+
+		public abstract uint count_elements () throws Error;
+		public abstract unowned ObjectReader read_element (uint index) throws Error;
+		public abstract unowned ObjectReader end_element () throws Error;
+
+		public abstract bool get_bool_value () throws Error;
+		public abstract uint8 get_uint8_value () throws Error;
+		public abstract uint16 get_uint16_value () throws Error;
+		public abstract int64 get_int64_value () throws Error;
+		public abstract uint64 get_uint64_value () throws Error;
+		public abstract Bytes get_data_value () throws Error;
+		public abstract unowned string get_string_value () throws Error;
+		public abstract unowned string get_uuid_value () throws Error;
+	}
+
+	public sealed class VariantReader : Object, ObjectReader {
+		public Variant root_object {
+			get {
+				return scopes.peek_head ().val;
+			}
+		}
+
+		public Variant current_object {
+			get {
+				return scopes.peek_tail ().val;
+			}
+		}
+
+		private Gee.Deque<Scope> scopes = new Gee.ArrayQueue<Scope> ();
+
+		public VariantReader (Variant v) {
+			push_scope (v);
+		}
+
+		public bool has_member (string name) throws Error {
+			var scope = peek_scope ();
+			if (scope.dict == null)
+				throw new Error.PROTOCOL ("Dictionary expected, but at %s", scope.val.print (true));
+			return scope.dict.contains (name);
+		}
+
+		public unowned ObjectReader read_member (string name) throws Error {
+			var scope = peek_scope ();
+			if (scope.dict == null)
+				throw new Error.PROTOCOL ("Dictionary expected, but at %s", scope.val.print (true));
+
+			Variant? v = scope.dict.lookup_value (name, null);
+			if (v == null)
+				throw new Error.PROTOCOL ("Key '%s' not found in dictionary: %s", name, scope.val.print (true));
+
+			push_scope (v);
+
+			return this;
+		}
+
+		public unowned ObjectReader end_member () {
+			pop_scope ();
+
+			return this;
+		}
+
+		public uint count_elements () throws Error {
+			var scope = peek_scope ();
+			scope.check_array ();
+			return (uint) scope.val.n_children ();
+		}
+
+		public unowned ObjectReader read_element (uint index) throws Error {
+			var scope = peek_scope ();
+			scope.check_array ();
+			push_scope (scope.val.get_child_value (index).get_variant ());
+
+			return this;
+		}
+
+		public unowned ObjectReader end_element () throws Error {
+			pop_scope ();
+
+			return this;
+		}
+
+		public bool get_bool_value () throws Error {
+			return peek_scope ().get_value (VariantType.BOOLEAN).get_boolean ();
+		}
+
+		public uint8 get_uint8_value () throws Error {
+			return peek_scope ().get_value (VariantType.BYTE).get_byte ();
+		}
+
+		public uint16 get_uint16_value () throws Error {
+			return peek_scope ().get_value (VariantType.UINT16).get_uint16 ();
+		}
+
+		public int64 get_int64_value () throws Error {
+			return peek_scope ().get_value (VariantType.INT64).get_int64 ();
+		}
+
+		public uint64 get_uint64_value () throws Error {
+			return peek_scope ().get_value (VariantType.UINT64).get_uint64 ();
+		}
+
+		public Bytes get_data_value () throws Error {
+			return peek_scope ().get_value (new VariantType.array (VariantType.BYTE)).get_data_as_bytes ();
+		}
+
+		public unowned string get_string_value () throws Error {
+			return peek_scope ().get_value (VariantType.STRING).get_string ();
+		}
+
+		public unowned string get_uuid_value () throws Error {
+			return peek_scope ().get_value (VariantType.STRING).get_string (); // TODO: Use a tuple to avoid ambiguity.
+		}
+
+		private void push_scope (Variant v) {
+			scopes.offer_tail (new Scope (v));
+		}
+
+		private Scope peek_scope () {
+			return scopes.peek_tail ();
+		}
+
+		private Scope pop_scope () {
+			return scopes.poll_tail ();
+		}
+
+		private class Scope {
+			public Variant val;
+			public VariantDict? dict;
+			public bool is_array = false;
+
+			public Scope (Variant v) {
+				val = v;
+
+				VariantType t = v.get_type ();
+				if (t.equal (VariantType.VARDICT))
+					dict = new VariantDict (v);
+				else if (t.is_subtype_of (VariantType.ARRAY))
+					is_array = true;
+			}
+
+			public Variant get_value (VariantType expected_type) throws Error {
+				if (!val.get_type ().equal (expected_type)) {
+					throw new Error.PROTOCOL ("Expected type '%s', got '%s'",
+						(string) expected_type.peek_string (),
+						(string) val.get_type ().peek_string ());
+				}
+
+				return val;
+			}
+
+			public void check_array () throws Error {
+				if (!is_array)
+					throw new Error.PROTOCOL ("Array expected, but at %s", val.print (true));
+			}
+		}
+	}
+
+	public sealed class JsonObjectBuilder : Object, ObjectBuilder {
+		private Json.Builder builder = new Json.Builder ();
+		private Gee.Map<string, Bytes> raw_values = new Gee.HashMap<string, Bytes> ();
+
+		public unowned ObjectBuilder begin_dictionary () {
+			builder.begin_object ();
+			return this;
+		}
+
+		public unowned ObjectBuilder set_member_name (string name) {
+			builder.set_member_name (name);
+			return this;
+		}
+
+		public unowned ObjectBuilder end_dictionary () {
+			builder.end_object ();
+			return this;
+		}
+
+		public unowned ObjectBuilder begin_array () {
+			builder.begin_array ();
+			return this;
+		}
+
+		public unowned ObjectBuilder end_array () {
+			builder.end_array ();
+			return this;
+		}
+
+		public unowned ObjectBuilder add_null_value () {
+			builder.add_null_value ();
+			return this;
+		}
+
+		public unowned ObjectBuilder add_bool_value (bool val) {
+			builder.add_boolean_value (val);
+			return this;
+		}
+
+		public unowned ObjectBuilder add_int64_value (int64 val) {
+			builder.add_int_value (val);
+			return this;
+		}
+
+		public unowned ObjectBuilder add_uint64_value (uint64 val) {
+			builder.add_int_value ((int64) val);
+			return this;
+		}
+
+		public unowned ObjectBuilder add_data_value (Bytes val) {
+			builder.add_string_value (Base64.encode (val.get_data ()));
+			return this;
+		}
+
+		public unowned ObjectBuilder add_string_value (string val) {
+			builder.add_string_value (val);
+			return this;
+		}
+
+		public unowned ObjectBuilder add_uuid_value (uint8[] val) {
+			assert_not_reached ();
+		}
+
+		public unowned ObjectBuilder add_raw_value (Bytes val) {
+			string uuid = Uuid.string_random ();
+			builder.add_string_value (uuid);
+			raw_values[uuid] = val;
+			return this;
+		}
+
+		public Bytes build () {
+			string json = Json.to_string (builder.get_root (), false);
+
+			foreach (var e in raw_values.entries) {
+				unowned string uuid = e.key;
+				Bytes val = e.value;
+
+				unowned string raw_str = (string) val.get_data ();
+				string str = raw_str[:(long) val.get_size ()];
+
+				json = json.replace ("\"" + uuid + "\"", str);
+			}
+
+			return new Bytes (json.data);
+		}
+	}
+
+	public sealed class JsonObjectReader : Object, ObjectReader {
+		private Json.Reader reader;
+
+		public JsonObjectReader (string json) throws Error {
+			try {
+				reader = new Json.Reader (Json.from_string (json));
+			} catch (GLib.Error e) {
+				throw new Error.INVALID_ARGUMENT ("%s", e.message);
+			}
+		}
+
+		public bool has_member (string name) throws Error {
+			bool result = reader.read_member (name);
+			reader.end_member ();
+			return result;
+		}
+
+		public unowned ObjectReader read_member (string name) throws Error {
+			if (!reader.read_member (name))
+				throw_dict_access_error ();
+			return this;
+		}
+
+		public unowned ObjectReader end_member () {
+			reader.end_member ();
+			return this;
+		}
+
+		[NoReturn]
+		private void throw_dict_access_error () throws Error {
+			GLib.Error e = reader.get_error ();
+			reader.end_member ();
+			throw new Error.PROTOCOL ("%s", e.message);
+		}
+
+		public uint count_elements () throws Error {
+			int n = reader.count_elements ();
+			if (n == -1)
+				throw_array_access_error ();
+			return n;
+		}
+
+		public unowned ObjectReader read_element (uint index) throws Error {
+			if (!reader.read_element (index)) {
+				GLib.Error e = reader.get_error ();
+				reader.end_element ();
+				throw new Error.PROTOCOL ("%s", e.message);
+			}
+			return this;
+		}
+
+		public unowned ObjectReader end_element () throws Error {
+			reader.end_element ();
+			return this;
+		}
+
+		[NoReturn]
+		private void throw_array_access_error () throws Error {
+			GLib.Error e = reader.get_error ();
+			reader.end_element ();
+			throw new Error.PROTOCOL ("%s", e.message);
+		}
+
+		public bool get_bool_value () throws Error {
+			bool v = reader.get_boolean_value ();
+			if (!v)
+				maybe_throw_value_access_error ();
+			return v;
+		}
+
+		public uint8 get_uint8_value () throws Error {
+			int64 v = get_int64_value ();
+			if (v < 0 || v > uint8.MAX)
+				throw new Error.PROTOCOL ("Invalid uint8");
+			return (uint8) v;
+		}
+
+		public uint16 get_uint16_value () throws Error {
+			int64 v = get_int64_value ();
+			if (v < 0 || v > uint16.MAX)
+				throw new Error.PROTOCOL ("Invalid uint16");
+			return (uint16) v;
+		}
+
+		public int64 get_int64_value () throws Error {
+			int64 v = reader.get_int_value ();
+			if (v == 0)
+				maybe_throw_value_access_error ();
+			return v;
+		}
+
+		public uint64 get_uint64_value () throws Error {
+			int64 v = get_int64_value ();
+			if (v < 0)
+				throw new Error.PROTOCOL ("Invalid uint64");
+			return v;
+		}
+
+		public Bytes get_data_value () throws Error {
+			return new Bytes (Base64.decode (get_string_value ()));
+		}
+
+		public unowned string get_string_value () throws Error {
+			unowned string? v = reader.get_string_value ();
+			if (v == null)
+				maybe_throw_value_access_error ();
+			return v;
+		}
+
+		public unowned string get_uuid_value () throws Error {
+			return get_string_value ();
+		}
+
+		private void maybe_throw_value_access_error () throws Error {
+			GLib.Error? e = reader.get_error ();
+			if (e == null)
+				return;
+			reader.end_member ();
+			throw new Error.PROTOCOL ("%s", e.message);
+		}
+	}
+}
@@ -0,0 +1,291 @@
+namespace Frida {
+	public sealed class XpcClient : Object {
+		public signal void message (Darwin.Xpc.Object obj);
+
+		public State state {
+			get {
+				return _state;
+			}
+		}
+
+		public Darwin.Xpc.Connection connection {
+			get;
+			construct;
+		}
+
+		public Darwin.GCD.DispatchQueue queue {
+			get;
+			construct;
+		}
+
+		private State _state;
+		private string? close_reason;
+		private MainContext main_context;
+
+		public enum State {
+			OPEN,
+			CLOSING,
+			CLOSED,
+		}
+
+		public static XpcClient make_for_mach_service (string name, Darwin.GCD.DispatchQueue queue) {
+			return new XpcClient (Darwin.Xpc.Connection.create_mach_service (name, queue, 0), queue);
+		}
+
+		public XpcClient (Darwin.Xpc.Connection connection, Darwin.GCD.DispatchQueue queue) {
+			Object (connection: connection, queue: queue);
+		}
+
+		construct {
+			main_context = MainContext.ref_thread_default ();
+
+			connection.set_event_handler (on_event);
+			connection.activate ();
+		}
+
+		public override void dispose () {
+			if (close_reason != null) {
+				change_state (CLOSED);
+			} else {
+				change_state (CLOSING);
+				this.ref ();
+				connection.cancel ();
+			}
+
+			base.dispose ();
+		}
+
+		public async Darwin.Xpc.Object request (Darwin.Xpc.Object message, Cancellable? cancellable) throws Error, IOError {
+			Darwin.Xpc.Object? reply = null;
+			connection.send_message_with_reply (message, queue, r => {
+				schedule_on_frida_thread (() => {
+					reply = r;
+					request.callback ();
+					return Source.REMOVE;
+				});
+			});
+
+			var cancel_source = new CancellableSource (cancellable);
+			cancel_source.set_callback (() => {
+				connection.cancel ();
+				return Source.REMOVE;
+			});
+			cancel_source.attach (main_context);
+
+			yield;
+
+			cancel_source.destroy ();
+
+			if (reply.type == Darwin.Xpc.Error.TYPE) {
+				var e = (Darwin.Xpc.Error) reply;
+				throw new Error.NOT_SUPPORTED ("%s", e.get_string (Darwin.Xpc.Error.KEY_DESCRIPTION));
+			}
+
+			return reply;
+		}
+
+		public void post (Darwin.Xpc.Object message) throws Error, IOError {
+			connection.send_message (message);
+		}
+
+		private void change_state (State new_state) {
+			_state = new_state;
+			notify_property ("state");
+		}
+
+		private void on_event (Darwin.Xpc.Object obj) {
+			schedule_on_frida_thread (() => {
+				if (obj.type == Darwin.Xpc.Error.TYPE) {
+					var e = (Darwin.Xpc.Error) obj;
+					close_reason = e.get_string (Darwin.Xpc.Error.KEY_DESCRIPTION);
+					switch (state) {
+						case OPEN:
+							change_state (CLOSED);
+							break;
+						case CLOSING:
+							change_state (CLOSED);
+							unref ();
+							break;
+						case CLOSED:
+							assert_not_reached ();
+					}
+				} else {
+					message (obj);
+				}
+				return Source.REMOVE;
+			});
+		}
+
+		private void schedule_on_frida_thread (owned SourceFunc function) {
+			var source = new IdleSource ();
+			source.set_callback ((owned) function);
+			source.attach (main_context);
+		}
+	}
+
+	public sealed class XpcObjectReader {
+		public Darwin.Xpc.Object root_object {
+			get {
+				return scopes.peek_head ().object;
+			}
+		}
+
+		public Darwin.Xpc.Object current_object {
+			get {
+				return scopes.peek_tail ().object;
+			}
+		}
+
+		public delegate int TranslateErrorFunc (string domain, int code, string description);
+
+		private Gee.Deque<Scope> scopes = new Gee.ArrayQueue<Scope> ();
+
+		public XpcObjectReader (Darwin.Xpc.Object obj) {
+			push_scope (obj);
+		}
+
+		public bool has_member (string name) throws Error {
+			return peek_scope ().get_dictionary ().get_value (name) != null;
+		}
+
+		public bool try_read_member (string name) throws Error {
+			var scope = peek_scope ();
+			var dict = scope.get_dictionary ();
+			var val = dict.get_value (name);
+			if (val == null)
+				return false;
+
+			push_scope (val);
+
+			return true;
+		}
+
+		public unowned XpcObjectReader read_member (string name) throws Error {
+			var scope = peek_scope ();
+			var dict = scope.get_dictionary ();
+			var val = dict.get_value (name);
+			if (val == null)
+				throw new Error.PROTOCOL ("Key '%s' not found in dictionary: %s", name, scope.object.to_string ());
+
+			push_scope (val);
+
+			return this;
+		}
+
+		public unowned XpcObjectReader end_member () {
+			pop_scope ();
+
+			return this;
+		}
+
+		public size_t count_elements () throws Error {
+			return peek_scope ().get_array ().count;
+		}
+
+		public unowned XpcObjectReader read_element (size_t index) throws Error {
+			push_scope (peek_scope ().get_array ().get_value (index));
+
+			return this;
+		}
+
+		public unowned XpcObjectReader end_element () throws Error {
+			pop_scope ();
+
+			return this;
+		}
+
+		public bool get_bool_value () throws Error {
+			return peek_scope ().get_object<Darwin.Xpc.Bool> (Darwin.Xpc.Bool.TYPE).get_value ();
+		}
+
+		public int64 get_int64_value () throws Error {
+			return peek_scope ().get_object<Darwin.Xpc.Int64> (Darwin.Xpc.Int64.TYPE).get_value ();
+		}
+
+		public uint64 get_uint64_value () throws Error {
+			return peek_scope ().get_object<Darwin.Xpc.UInt64> (Darwin.Xpc.UInt64.TYPE).get_value ();
+		}
+
+		public unowned uint8[] get_data_value () throws Error {
+			var data = peek_scope ().get_object<Darwin.Xpc.Data> (Darwin.Xpc.Data.TYPE);
+			unowned uint8[] buf = (uint8[]) data.get_bytes_ptr ();
+			buf.length = (int) data.get_length ();
+			return buf;
+		}
+
+		public unowned string get_string_value () throws Error {
+			return peek_scope ().get_object<Darwin.Xpc.String> (Darwin.Xpc.String.TYPE).get_string_ptr ();
+		}
+
+		public unowned uint8[] get_uuid_value () throws Error {
+			return peek_scope ().get_object<Darwin.Xpc.Uuid> (Darwin.Xpc.Uuid.TYPE).get_bytes ()[:16];
+		}
+
+		public unowned string get_error_description () throws Error {
+			var error = peek_scope ().get_object<Darwin.Xpc.Error> (Darwin.Xpc.Error.TYPE);
+			return error.get_string (Darwin.Xpc.Error.KEY_DESCRIPTION);
+		}
+
+		public void check_nserror (TranslateErrorFunc translate_error) throws Error {
+			if (!has_member ("error"))
+				return;
+
+			read_member ("error");
+
+			unowned string domain = read_member ("domain").get_string_value ();
+			end_member ();
+
+			var code = (int) read_member ("code").get_int64_value ();
+			end_member ();
+
+			string description = read_member ("userInfo").read_member ("NSLocalizedDescription").get_string_value ();
+			if (description.has_suffix ("."))
+				description = description[:description.length - 1];
+
+			throw (Error) new GLib.Error.literal (
+				Quark.from_string ("frida-error-quark"),
+				translate_error (domain, code, description),
+				description);
+		}
+
+		public unowned Darwin.Xpc.Object get_object_value (Darwin.Xpc.Type expected_type) throws Error {
+			return peek_scope ().get_object<Darwin.Xpc.Object> (expected_type);
+		}
+
+		private void push_scope (Darwin.Xpc.Object obj) {
+			scopes.offer_tail (new Scope (obj));
+		}
+
+		private Scope peek_scope () {
+			return scopes.peek_tail ();
+		}
+
+		private Scope pop_scope () {
+			return scopes.poll_tail ();
+		}
+
+		private class Scope {
+			public Darwin.Xpc.Object object;
+			private unowned Darwin.Xpc.Type type;
+
+			public Scope (Darwin.Xpc.Object obj) {
+				object = obj;
+				type = obj.type;
+			}
+
+			public unowned T get_object<T> (Darwin.Xpc.Type expected_type) throws Error {
+				if (type != expected_type)
+					throw new Error.PROTOCOL ("Expected type '%s', got '%s'", expected_type.name, type.name);
+				return object;
+			}
+
+			public unowned Darwin.Xpc.Array get_array () throws Error {
+				return get_object<Darwin.Xpc.Array> (Darwin.Xpc.Array.TYPE);
+			}
+
+			public unowned Darwin.Xpc.Dictionary get_dictionary () throws Error {
+				return get_object<Darwin.Xpc.Dictionary> (Darwin.Xpc.Dictionary.TYPE);
+			}
+		}
+	}
+}
@@ -1,6 +1,8 @@
 #include "frida-gadget.h"

 #import <Foundation/Foundation.h>
+#include <gum/gumdarwin.h>
+#include <mach-o/loader.h>
 #include <objc/runtime.h>
 #include <pthread.h>

@@ -51,3 +53,53 @@ frida_gadget_environment_set_thread_name (const gchar * name)
  /* For now only implemented on i/macOS as Fruity.Injector relies on it there. */
  pthread_setname_np (name);
 }
+
+void
+frida_gadget_environment_detect_darwin_location_fields (GumAddress our_address, gchar ** executable_name, gchar ** our_path,
+    GumMemoryRange ** our_range)
+{
+  mach_port_t task;
+  GumDarwinModuleResolver * resolver;
+  GPtrArray * modules;
+  guint i;
+
+  task = mach_task_self ();
+
+  resolver = gum_darwin_module_resolver_new (task, NULL);
+  if (resolver == NULL)
+    return;
+
+  gum_darwin_module_resolver_fetch_modules (resolver, &modules, NULL);
+
+  for (i = 0; i != modules->len; i++)
+  {
+    GumModule * module;
+    const GumMemoryRange * range;
+
+    module = g_ptr_array_index (modules, i);
+    range = gum_module_get_range (module);
+
+    if (*executable_name == NULL)
+    {
+      gum_mach_header_t * header = GSIZE_TO_POINTER (range->base_address);
+      if (header->filetype == MH_EXECUTE)
+        *executable_name = g_strdup (gum_module_get_name (module));
+    }
+
+    if (our_address >= range->base_address && our_address < range->base_address + range->size)
+    {
+      if (*our_path == NULL)
+        *our_path = g_strdup (gum_module_get_path (module));
+
+      if (*our_range == NULL)
+        *our_range = gum_memory_range_copy (range);
+    }
+
+    if (*executable_name != NULL && *our_path != NULL && *our_range != NULL)
+      break;
+  }
+
+  g_ptr_array_unref (modules);
+
+  g_object_unref (resolver);
+}
@@ -1,5 +1,5 @@
 namespace Frida.Gadget {
-	private class Config : Object, Json.Serializable {
+	private sealed class Config : Object, Json.Serializable {
 		public Object interaction {
 			get;
 			set;
@@ -24,12 +24,6 @@ namespace Frida.Gadget {
 			default = Gum.CodeSigningPolicy.OPTIONAL;
 		}

-		private ObjectClass klass = (ObjectClass) typeof (Config).class_ref ();
-
-		public Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
-			return default_serialize_property (property_name, value, pspec);
-		}
-
 		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 			if (property_name == "interaction" && property_node.get_node_type () == Json.NodeType.OBJECT) {
 				var interaction_node = property_node.get_object ();
@@ -77,23 +71,9 @@ namespace Frida.Gadget {
 			value = Value (pspec.value_type);
 			return false;
 		}
-
-		public unowned ParamSpec? find_property (string name) {
-			return klass.find_property (name);
-		}
-
-		public new Value get_property (ParamSpec pspec) {
-			var val = Value (pspec.value_type);
-			base.get_property (pspec.name, ref val);
-			return val;
-		}
-
-		public new void set_property (ParamSpec pspec, Value value) {
-			base.set_property (pspec.name, value);
-		}
 	}

-	private class ScriptInteraction : Object, Json.Serializable {
+	private sealed class ScriptInteraction : Object, Json.Serializable {
 		public string path {
 			get;
 			set;
@@ -112,12 +92,6 @@ namespace Frida.Gadget {
 			default = Script.ChangeBehavior.IGNORE;
 		}

-		private ObjectClass klass = (ObjectClass) typeof (ScriptInteraction).class_ref ();
-
-		public Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
-			return default_serialize_property (property_name, value, pspec);
-		}
-
 		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 			if (property_name == "parameters" && property_node.get_node_type () == Json.NodeType.OBJECT) {
 				var v = Value (typeof (Json.Node));
@@ -129,23 +103,9 @@ namespace Frida.Gadget {
 			value = Value (pspec.value_type);
 			return false;
 		}
-
-		public unowned ParamSpec? find_property (string name) {
-			return klass.find_property (name);
-		}
-
-		public new Value get_property (ParamSpec pspec) {
-			var val = Value (pspec.value_type);
-			base.get_property (pspec.name, ref val);
-			return val;
-		}
-
-		public new void set_property (ParamSpec pspec, Value value) {
-			base.set_property (pspec.name, value);
-		}
 	}

-	private class ScriptDirectoryInteraction : Object {
+	private sealed class ScriptDirectoryInteraction : Object {
 		public string path {
 			get;
 			set;
@@ -164,7 +124,7 @@ namespace Frida.Gadget {
 		}
 	}

-	private class ScriptConfig : Object, Json.Serializable {
+	private sealed class ScriptConfig : Object, Json.Serializable {
 		public ProcessFilter? filter {
 			get;
 			set;
@@ -183,12 +143,6 @@ namespace Frida.Gadget {
 			default = Script.ChangeBehavior.IGNORE;
 		}

-		private ObjectClass klass = (ObjectClass) typeof (ScriptConfig).class_ref ();
-
-		public Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
-			return default_serialize_property (property_name, value, pspec);
-		}
-
 		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 			if (property_name == "parameters" && property_node.get_node_type () == Json.NodeType.OBJECT) {
 				var v = Value (typeof (Json.Node));
@@ -200,23 +154,9 @@ namespace Frida.Gadget {
 			value = Value (pspec.value_type);
 			return false;
 		}
-
-		public unowned ParamSpec? find_property (string name) {
-			return klass.find_property (name);
-		}
-
-		public new Value get_property (ParamSpec pspec) {
-			var val = Value (pspec.value_type);
-			base.get_property (pspec.name, ref val);
-			return val;
-		}
-
-		public new void set_property (ParamSpec pspec, Value value) {
-			base.set_property (pspec.name, value);
-		}
 	}

-	private class ProcessFilter : Object {
+	private sealed class ProcessFilter : Object {
 		public string[] executables {
 			get;
 			set;
@@ -258,7 +198,7 @@ namespace Frida.Gadget {
 		}
 	}

-	private class ListenInteraction : SocketInteraction {
+	private sealed class ListenInteraction : SocketInteraction {
 		public PortConflictBehavior on_port_conflict {
 			get;
 			set;
@@ -287,7 +227,7 @@ namespace Frida.Gadget {
 		}
 	}

-	private class ConnectInteraction : SocketInteraction, Json.Serializable {
+	private sealed class ConnectInteraction : SocketInteraction, Json.Serializable {
 		public string[]? acl {
 			get;
 			set;
@@ -299,8 +239,6 @@ namespace Frida.Gadget {
 			default = make_empty_json_object ();
 		}

-		private ObjectClass klass = (ObjectClass) typeof (ConnectInteraction).class_ref ();
-
 		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 			if (property_name == "parameters" && property_node.get_node_type () == Json.NodeType.OBJECT) {
 				var v = Value (typeof (Json.Node));
@@ -312,23 +250,9 @@ namespace Frida.Gadget {
 			value = Value (pspec.value_type);
 			return false;
 		}
-
-		public unowned ParamSpec? find_property (string name) {
-			return klass.find_property (name);
-		}
-
-		public new Value get_property (ParamSpec pspec) {
-			var val = Value (pspec.value_type);
-			base.get_property (pspec.name, ref val);
-			return val;
-		}
-
-		public new void set_property (ParamSpec pspec, Value value) {
-			base.set_property (pspec.name, value);
-		}
 	}

-	private class Location : Object {
+	private sealed class Location : Object {
 		public string executable_name {
 			get;
 			construct;
@@ -751,7 +675,7 @@ namespace Frida.Gadget {

 		string config_data;
 		try {
-			FileUtils.get_contents (config_path, out config_data);
+			load_asset_text (config_path, out config_data);
 		} catch (FileError e) {
 			if (e is FileError.NOENT)
 				return new Config ();
@@ -759,7 +683,7 @@ namespace Frida.Gadget {
 		}

 		try {
-			return Json.gobject_from_data (typeof (Config), config_data) as Config;
+			return (Config) Json.gobject_from_data (typeof (Config), config_data);
 		} catch (GLib.Error e) {
 			throw new Error.INVALID_ARGUMENT ("Invalid config: %s", e.message);
 		}
@@ -767,7 +691,7 @@ namespace Frida.Gadget {

 	private Config parse_config (string config_data) throws Error {
 		try {
-			return Json.gobject_from_data (typeof (Config), config_data) as Config;
+			return (Config) Json.gobject_from_data (typeof (Config), config_data);
 		} catch (GLib.Error e) {
 			throw new Error.INVALID_ARGUMENT ("Invalid config: %s", e.message);
 		}
@@ -775,21 +699,20 @@ namespace Frida.Gadget {

 	private Location detect_location (Gum.MemoryRange? mapped_range) {
 		string? executable_name = null;
-		string? executable_path = null;
-		Gum.MemoryRange? executable_range = null;
 		string? our_path = null;
 		Gum.MemoryRange? our_range = mapped_range;

 		Gum.Address our_address = Gum.Address.from_pointer (Gum.strip_code_pointer ((void *) detect_location));

+#if DARWIN
+		Environment.detect_darwin_location_fields (our_address, ref executable_name, ref our_path, ref our_range);
+#else
 		var index = 0;
 		Gum.Process.enumerate_modules ((details) => {
 			var range = details.range;

 			if (index == 0) {
 				executable_name = details.name;
-				executable_path = details.path;
-				executable_range = details.range;
 			}

 			if (mapped_range != null)
@@ -805,6 +728,7 @@ namespace Frida.Gadget {

 			return true;
 		});
+#endif

 		assert (our_range != null);

@@ -988,7 +912,7 @@ namespace Frida.Gadget {
 		}
 	}

-	private class ScriptRunner : BaseController {
+	private sealed class ScriptRunner : BaseController {
 		private ScriptEngine engine;
 		private Script script;

@@ -1036,7 +960,7 @@ namespace Frida.Gadget {
 		}
 	}

-	private class ScriptDirectoryRunner : BaseController {
+	private sealed class ScriptDirectoryRunner : BaseController {
 		public string directory_path {
 			get;
 			construct;
@@ -1226,7 +1150,7 @@ namespace Frida.Gadget {
 		private ScriptConfig load_config (string path) throws Error {
 			string data;
 			try {
-				FileUtils.get_contents (path, out data);
+				load_asset_text (path, out data);
 			} catch (FileError e) {
 				if (e is FileError.NOENT)
 					return new ScriptConfig ();
@@ -1234,15 +1158,21 @@ namespace Frida.Gadget {
 			}

 			try {
-				return Json.gobject_from_data (typeof (ScriptConfig), data) as ScriptConfig;
+				return (ScriptConfig) Json.gobject_from_data (typeof (ScriptConfig), data);
 			} catch (GLib.Error e) {
 				throw new Error.INVALID_ARGUMENT ("Invalid config: %s", e.message);
 			}
 		}
 	}

-	private class Script : Object, RpcPeer {
-		private const uint8 QUICKJS_BYTECODE_MAGIC = 0x02;
+	private sealed class Script : Object, RpcPeer {
+		private const uint8 QUICKJS_BYTECODE_MAGIC =
+#if BIG_ENDIAN
+			0x42
+#else
+			0x02
+#endif
+			;

 		public enum ChangeBehavior {
 			IGNORE,
@@ -1349,9 +1279,9 @@ namespace Frida.Gadget {
 			try {
 				var path = this.path;

-				uint8[] contents;
+				Bytes contents;
 				try {
-					FileUtils.get_data (path, out contents);
+					load_asset_bytes (path, out contents);
 				} catch (FileError e) {
 					throw new Error.INVALID_ARGUMENT ("%s", e.message);
 				}
@@ -1360,11 +1290,10 @@ namespace Frida.Gadget {
 				options.name = Path.get_basename (path).split (".", 2)[0];

 				ScriptEngine.ScriptInstance instance;
-				if (contents.length > 0 && contents[0] == QUICKJS_BYTECODE_MAGIC) {
-					instance = yield engine.create_script (null, new Bytes (contents), options);
-				} else {
-					instance = yield engine.create_script ((string) contents, null, options);
-				}
+				if (contents.length > 0 && contents[0] == QUICKJS_BYTECODE_MAGIC)
+					instance = yield engine.create_script (null, contents, options);
+				else
+					instance = yield engine.create_script ((string) contents.get_data (), null, options);

 				if (id.handle != 0)
 					yield engine.destroy_script (id);
@@ -1381,7 +1310,7 @@ namespace Frida.Gadget {
 			var stage = new Json.Node.alloc ().init_string ((peek_state () == State.CREATED) ? "early" : "late");

 			try {
-				yield rpc_client.call ("init", new Json.Node[] { stage, parameters }, null);
+				yield rpc_client.call ("init", new Json.Node[] { stage, parameters }, null, null);
 			} catch (GLib.Error e) {
 			}
 		}
@@ -1449,12 +1378,12 @@ namespace Frida.Gadget {
 			return true;
 		}

-		private async void post_rpc_message (string json, Cancellable? cancellable) throws Error, IOError {
-			engine.post_to_script (id, json);
+		private async void post_rpc_message (string json, Bytes? data, Cancellable? cancellable) throws Error, IOError {
+			engine.post_to_script (id, json, data);
 		}
 	}

-	private class ControlServer : BaseController {
+	private sealed class ControlServer : BaseController {
 		public EndpointParameters endpoint_params {
 			get;
 			construct;
@@ -1497,7 +1426,8 @@ namespace Frida.Gadget {
 			var endpoint_params = new EndpointParameters (interaction.address, interaction.port,
 				parse_certificate (interaction.certificate, location), interaction.origin, auth_service, asset_root);

-			service = new WebService (endpoint_params, CONTROL, interaction.on_port_conflict);
+			service = new WebService (endpoint_params, WebServiceFlavor.CONTROL, interaction.on_port_conflict,
+				new TunnelInterfaceObserver ());
 			service.incoming.connect (on_incoming_connection);
 			yield service.start (io_cancellable);
 		}
@@ -1927,6 +1857,14 @@ namespace Frida.Gadget {
 				throw new Error.NOT_SUPPORTED ("Unable to inject libraries when embedded");
 			}

+			public async ChannelId open_channel (string address, Cancellable? cancellable) throws Error, IOError {
+				throw new Error.NOT_SUPPORTED ("Unable to open channels when embedded");
+			}
+
+			public async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
+				throw new Error.NOT_SUPPORTED ("Unable to open services when embedded");
+			}
+
 			private void validate_pid (uint pid) throws Error {
 				if (pid != this_process.pid)
 					throw new Error.NOT_SUPPORTED ("Unable to act on other processes when embedded");
@@ -1958,7 +1896,7 @@ namespace Frida.Gadget {
 		}
 	}

-	private class ClusterClient : BaseController {
+	private sealed class ClusterClient : BaseController {
 		public SocketConnectable connectable {
 			get;
 			construct;
@@ -2075,6 +2013,60 @@ namespace Frida.Gadget {
 	}
 #endif

+	private void load_asset_text (string filename, out string text) throws FileError {
+		Bytes raw_contents;
+		load_asset_bytes (filename, out raw_contents);
+
+		unowned string str = (string) raw_contents.get_data ();
+		if (!str.validate ())
+			throw new FileError.FAILED ("%s: invalid UTF-8", filename);
+
+		text = str;
+	}
+
+	private void load_asset_bytes (string filename, out Bytes bytes) throws FileError {
+#if ANDROID
+		if (maybe_load_asset_bytes_from_apk (filename, out bytes))
+			return;
+#endif
+
+		uint8[] data;
+		FileUtils.get_data (filename, out data);
+		bytes = new Bytes.take ((owned) data);
+	}
+
+#if ANDROID
+	private bool maybe_load_asset_bytes_from_apk (string filename, out Bytes contents) throws FileError {
+		contents = null;
+
+		var tokens = filename.split ("!", 2);
+		if (tokens.length != 2 || !tokens[0].has_suffix (".apk"))
+			return false;
+		unowned string apk_path = tokens[0];
+		unowned string file_path = tokens[1];
+
+		var reader = Minizip.Reader.create ();
+		try {
+			if (reader.open_file (apk_path) != OK)
+				throw new FileError.FAILED ("Unable to open APK");
+
+			if (reader.locate_entry (file_path[1:], true) != OK)
+				throw new FileError.FAILED ("Unable to locate %s inside APK", file_path);
+
+			var size = reader.entry_save_buffer_length ();
+			var data = new uint8[size + 1];
+			if (reader.entry_save_buffer (data[:size]) != OK)
+				throw new FileError.FAILED ("Unable to extract %s from APK", file_path);
+
+			contents = new Bytes.take ((owned) data);
+			return true;
+		} finally {
+			reader.close ();
+			Minizip.Reader.destroy (ref reader);
+		}
+	}
+#endif
+
 	private Json.Node make_empty_json_object () {
 		return new Json.Node.alloc ().init_object (new Json.Object ());
 	}
@@ -2108,6 +2100,10 @@ namespace Frida.Gadget {
 		private extern bool has_objc_class (string name);

 		private extern void set_thread_name (string name);
+#if DARWIN
+		private extern void detect_darwin_location_fields (Gum.Address our_address, ref string? executable_name,
+			ref string? our_path, ref Gum.MemoryRange? our_range);
+#endif
 	}

 	private extern void log_info (string message);
@@ -29,6 +29,11 @@ if host_os_family == 'darwin'
  extra_link_args += '-Wl,-framework,Foundation'
 endif

+if host_os == 'android'
+  extra_vala_args += '--pkg=minizip'
+  platform_deps += minizip_dep
+endif
+
 if host_os_family == 'windows'
  if host_toolchain != 'microsoft'
    symfile = 'frida-gadget.symbols'
@@ -60,7 +65,7 @@ raw_gadget = shared_library('frida-gadget-raw', gadget_sources,
  link_depends: extra_link_depends,
  vs_module_defs: 'frida-gadget.def',
  override_options: ['b_asneeded=true'],
-  dependencies: [gio_dep, gee_dep, json_glib_dep, gum_dep, gumjs_dep, base_dep, tls_provider_dep, payload_dep] + platform_deps,
+  dependencies: [gio_dep, gee_dep, json_glib_dep, gum_dep, gumjs_dep, base_dep, netif_dep, tls_provider_dep, payload_dep] + platform_deps,
 )

 operations = [
@@ -2,6 +2,7 @@ if host_os == 'android'
  subdir('selinux')
 endif
 subdir('base')
+subdir('netif')
 subdir('pipe')
 subdir('payload')
 if have_local_backend
@@ -0,0 +1,28 @@
+netif_sources = [
+  'tunnel-interface-observer.vala',
+]
+
+extra_vala_args = []
+extra_link_args = []
+
+if host_os in ['ios', 'tvos']
+  extra_vala_args += [
+    '--pkg=corefoundation',
+    '--pkg=darwin-gcd',
+    '--pkg=darwin-systemconfiguration',
+  ]
+  extra_link_args += '-Wl,-framework,SystemConfiguration'
+endif
+
+netif = static_library('frida-netif', netif_sources,
+  c_args: frida_component_cflags,
+  vala_args: [base_vala_args, extra_vala_args],
+  dependencies: [base_dep, gee_dep],
+)
+
+netif_dep = declare_dependency(
+  include_directories: include_directories('.'),
+  link_args: extra_link_args,
+  link_with: netif,
+  dependencies: base_dep,
+)
@@ -0,0 +1,99 @@
+public sealed class Frida.TunnelInterfaceObserver : Object, DynamicInterfaceObserver {
+#if IOS || TVOS
+	private Gee.Map<string, DynamicInterface> interfaces = new Gee.HashMap<string, DynamicInterface> ();
+
+	private Darwin.SystemConfiguration.DynamicStore? store;
+	private Darwin.GCD.DispatchQueue event_queue =
+		new Darwin.GCD.DispatchQueue ("re.frida.endpoint-enumerator", Darwin.GCD.DispatchQueueAttr.SERIAL);
+
+	private MainContext? main_context;
+
+	public override void dispose () {
+		if (store != null) {
+			store.set_dispatch_queue (null);
+			store = null;
+			ref ();
+			event_queue.dispatch_async (do_dispose);
+		}
+
+		base.dispose ();
+	}
+
+	private void do_dispose () {
+		unref ();
+	}
+
+	public void start () {
+		main_context = MainContext.ref_thread_default ();
+
+		Darwin.SystemConfiguration.DynamicStoreContext context = { 0, };
+		context.info = this;
+		store = new Darwin.SystemConfiguration.DynamicStore (null, CoreFoundation.String.make ("Frida"),
+			on_interfaces_changed_wrapper, context);
+
+		var pattern = CoreFoundation.String.make ("State:/Network/Interface/utun.*/IPv6");
+		var patterns = new CoreFoundation.Array (null, ((CoreFoundation.Type[]) &pattern)[:1]);
+		store.set_notification_keys (null, patterns);
+
+		store.set_dispatch_queue (event_queue);
+
+		var initial_keys = store.copy_key_list (pattern);
+		if (initial_keys != null)
+			handle_interface_changes (initial_keys);
+	}
+
+	private static void on_interfaces_changed_wrapper (Darwin.SystemConfiguration.DynamicStore store,
+			CoreFoundation.Array changed_keys, void * info) {
+		unowned TunnelInterfaceObserver enumerator = (TunnelInterfaceObserver) info;
+		enumerator.on_interfaces_changed (changed_keys);
+	}
+
+	private void on_interfaces_changed (CoreFoundation.Array changed_keys) {
+		schedule_on_frida_thread (() => {
+			if (store != null)
+				handle_interface_changes (changed_keys);
+			return Source.REMOVE;
+		});
+	}
+
+	private void handle_interface_changes (CoreFoundation.Array changed_keys) {
+		var addresses_str = CoreFoundation.String.make ("Addresses");
+
+		foreach (var key in CFArray.wrap<CoreFoundation.String> (changed_keys)) {
+			string name = key.to_string ().split ("/")[3];
+
+			var val = (CoreFoundation.Dictionary) store.copy_value (key);
+			if (val != null) {
+				InetAddress? address = null;
+				foreach (var raw_address in CFArray.wrap<CoreFoundation.String> (val[addresses_str])) {
+					var str = raw_address.to_string ();
+					bool is_reserved_ipv6_range = str.has_prefix ("fc") || str.has_prefix ("fd");
+					bool is_tunnel = is_reserved_ipv6_range && str.has_suffix ("::1");
+					if (is_tunnel) {
+						address = new InetAddress.from_string (str);
+						break;
+					}
+				}
+				if (address != null && !interfaces.has_key (name)) {
+					var iface = new DynamicInterface (name, address);
+					interfaces[name] = iface;
+					interface_attached (iface);
+				}
+			} else {
+				DynamicInterface iface;
+				if (interfaces.unset (name, out iface))
+					interface_detached (iface);
+			}
+		}
+	}
+
+	private void schedule_on_frida_thread (owned SourceFunc function) {
+		var source = new IdleSource ();
+		source.set_callback ((owned) function);
+		source.attach (main_context);
+	}
+#else
+	public void start () {
+	}
+#endif
+}
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class ThreadIgnoreScope {
+	public sealed class ThreadIgnoreScope {
 		public enum Kind {
 			APPLICATION_THREAD,
 			FRIDA_THREAD
@@ -43,7 +43,7 @@ namespace Frida {
 	}

 #if ANDROID
-	public class ThreadCountCloaker : Object {
+	public sealed class ThreadCountCloaker : Object {
 		private ReadFunc * read_slot;
 		private static ReadFunc old_read_impl;

@@ -53,15 +53,18 @@ namespace Frida {
 		private delegate ssize_t ReadFunc (int fd, void * buf, size_t count);

 		construct {
-			Gum.Module.enumerate_imports ("libart.so", imp => {
-				if (imp.name == "read") {
-					read_slot = (ReadFunc *) imp.slot;
-					return false;
-				}
-				return true;
-			});
-			if (read_slot != null)
-				old_read_impl = update_read_slot (on_read);
+			var art = Gum.Process.find_module_by_name ("libart.so");
+			if (art != null) {
+				art.enumerate_imports (imp => {
+					if (imp.name == "read") {
+						read_slot = (ReadFunc *) imp.slot;
+						return false;
+					}
+					return true;
+				});
+				if (read_slot != null)
+					old_read_impl = update_read_slot (on_read);
+			}
 		}

 		~ThreadCountCloaker () {
@@ -153,12 +156,12 @@ namespace Frida {
 		}
 	}
 #else
-	public class ThreadCountCloaker : Object {
+	public sealed class ThreadCountCloaker : Object {
 	}
 #endif

 #if LINUX
-	public class ThreadListCloaker : Object, DirListFilter {
+	public sealed class ThreadListCloaker : Object, DirListFilter {
 		private string our_dir_by_pid;
 		private DirListCloaker cloaker;

@@ -177,7 +180,7 @@ namespace Frida {
 		}
 	}

-	public class FDListCloaker : Object, DirListFilter {
+	public sealed class FDListCloaker : Object, DirListFilter {
 		private string our_dir_by_pid;
 		private DirListCloaker cloaker;

@@ -196,7 +199,7 @@ namespace Frida {
 		}
 	}

-	private class DirListCloaker : Object {
+	private sealed class DirListCloaker : Object {
 		public weak DirListFilter filter {
 			get;
 			construct;
@@ -212,34 +215,34 @@ namespace Frida {
 		construct {
 			var interceptor = Gum.Interceptor.obtain ();

-			unowned string libc = Gum.Process.query_libc_name ();
+			var libc = Gum.Process.get_libc_module ();

 			var open_listener = new OpenDirListener (this);
 			listeners.add (open_listener);
-			interceptor.attach ((void *) Gum.Module.find_export_by_name (libc, "opendir"), open_listener);
+			interceptor.attach ((void *) libc.find_export_by_name ("opendir"), open_listener);

 			var close_listener = new CloseDirListener (this);
 			listeners.add (close_listener);
-			interceptor.attach ((void *) Gum.Module.find_export_by_name (libc, "closedir"), close_listener);
+			interceptor.attach ((void *) libc.find_export_by_name ("closedir"), close_listener);

-			var readdir_impl = Gum.Module.find_export_by_name (libc, "readdir");
+			var readdir_impl = libc.find_export_by_name ("readdir");
 			var readdir_listener = new ReadDirListener (this, LEGACY);
 			listeners.add (readdir_listener);
 			interceptor.attach ((void *) readdir_impl, readdir_listener);

-			var readdir64_impl = Gum.Module.find_export_by_name (libc, "readdir64");
+			var readdir64_impl = libc.find_export_by_name ("readdir64");
 			if (readdir64_impl != 0 && readdir64_impl != readdir_impl) {
 				var listener = new ReadDirListener (this, MODERN);
 				listeners.add (listener);
 				interceptor.attach ((void *) readdir64_impl, listener);
 			}

-			var readdir_r_impl = Gum.Module.find_export_by_name (libc, "readdir_r");
+			var readdir_r_impl = libc.find_export_by_name ("readdir_r");
 			var readdir_r_listener = new ReadDirRListener (this, LEGACY);
 			listeners.add (readdir_r_listener);
 			interceptor.attach ((void *) readdir_r_impl, readdir_r_listener);

-			var readdir64_r_impl = Gum.Module.find_export_by_name (libc, "readdir64_r");
+			var readdir64_r_impl = libc.find_export_by_name ("readdir64_r");
 			if (readdir64_r_impl != 0 && readdir64_r_impl != readdir_r_impl) {
 				var listener = new ReadDirRListener (this, MODERN);
 				listeners.add (listener);
@@ -464,10 +467,10 @@ namespace Frida {
 		public abstract bool matches_file (string name);
 	}
 #else
-	public class ThreadListCloaker : Object {
+	public sealed class ThreadListCloaker : Object {
 	}

-	public class FDListCloaker : Object {
+	public sealed class FDListCloaker : Object {
 	}
 #endif
 }
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class ExitMonitor : Object, Gum.InvocationListener {
+	public sealed class ExitMonitor : Object, Gum.InvocationListener {
 		public weak ExitHandler handler {
 			get;
 			construct;
@@ -32,16 +32,17 @@ namespace Frida {
 			unowned Gum.InvocationListener listener = this;

 #if WINDOWS
-			interceptor.attach ((void *) Gum.Module.find_export_by_name ("kernel32.dll", "ExitProcess"), listener);
+			interceptor.attach ((void *) Gum.Process.find_module_by_name ("kernel32.dll").find_export_by_name ("ExitProcess"),
+				listener);
 #else
-			unowned string libc = Gum.Process.query_libc_name ();
+			var libc = Gum.Process.get_libc_module ();
 			const string[] apis = {
 				"exit",
 				"_exit",
 				"abort",
 			};
 			foreach (var symbol in apis) {
-				interceptor.attach ((void *) Gum.Module.find_export_by_name (libc, symbol), listener);
+				interceptor.attach ((void *) libc.find_export_by_name (symbol), listener);
 			}
 #endif
 		}
@@ -1,6 +1,6 @@
 namespace Frida {
 #if WINDOWS
-	public class FileDescriptorGuard : Object {
+	public sealed class FileDescriptorGuard : Object {
 		public Gum.MemoryRange agent_range {
 			get;
 			construct;
@@ -11,7 +11,7 @@ namespace Frida {
 		}
 	}
 #else
-	public class FileDescriptorGuard : Object {
+	public sealed class FileDescriptorGuard : Object {
 		public Gum.MemoryRange agent_range {
 			get;
 			construct;
@@ -26,7 +26,7 @@ namespace Frida {
 		construct {
 			var interceptor = Gum.Interceptor.obtain ();

-			var close = Gum.Module.find_export_by_name (Gum.Process.query_libc_name (), "close");
+			var close = Gum.Process.get_libc_module ().find_export_by_name ("close");
 			close_listener = new CloseListener (this);
 			interceptor.attach ((void *) close, close_listener);
 		}
@@ -1,6 +1,6 @@
 namespace Frida {
 #if WINDOWS
-	public class FileDescriptorTablePadder {
+	public sealed class FileDescriptorTablePadder {
 		public static FileDescriptorTablePadder obtain () {
 			return new FileDescriptorTablePadder ();
 		}
@@ -9,7 +9,7 @@ namespace Frida {
 		}
 	}
 #else
-	public class FileDescriptorTablePadder {
+	public sealed class FileDescriptorTablePadder {
 		private const int MIN_TABLE_SIZE = 32;

 		private static unowned FileDescriptorTablePadder shared_instance = null;
@@ -1,6 +1,6 @@
 namespace Frida {
 #if WINDOWS
-	public class ForkMonitor : Object {
+	public sealed class ForkMonitor : Object {
 		public weak ForkHandler handler {
 			get;
 			construct;
@@ -11,7 +11,7 @@ namespace Frida {
 		}
 	}
 #else
-	public class ForkMonitor : Object, Gum.InvocationListener {
+	public sealed class ForkMonitor : Object, Gum.InvocationListener {
 		public weak ForkHandler handler {
 			get;
 			construct;
@@ -45,9 +45,9 @@ namespace Frida {
 		}

 		static construct {
-			unowned string libc = Gum.Process.query_libc_name ();
-			fork_impl = (void *) Gum.Module.find_export_by_name (libc, "fork");
-			vfork_impl = (void *) Gum.Module.find_export_by_name (libc, "vfork");
+			var libc = Gum.Process.get_libc_module ();
+			fork_impl = (void *) libc.find_export_by_name ("fork");
+			vfork_impl = (void *) libc.find_export_by_name ("vfork");
 		}

 		construct {
@@ -61,15 +61,21 @@ namespace Frida {
 					string cmdline;
 					FileUtils.get_contents ("/proc/self/cmdline", out cmdline);
 					if (cmdline == "zygote" || cmdline == "zygote64" || cmdline == "usap32" || cmdline == "usap64") {
-						var set_argv0 = (void *) Gum.Module.find_export_by_name ("libandroid_runtime.so", "_Z27android_os_Process_setArgV0P7_JNIEnvP8_jobjectP8_jstring");
-						if (set_argv0 != null) {
-							interceptor.attach (set_argv0, listener, (void *) HookId.SET_ARGV0);
-							child_recovery_behavior = DEFERRED_UNTIL_SET_ARGV0;
+						var runtime = Gum.Process.find_module_by_name ("libandroid_runtime.so");
+						if (runtime != null) {
+							var set_argv0 = (void *) runtime.find_export_by_name ("_Z27android_os_Process_setArgV0P7_JNIEnvP8_jobjectP8_jstring");
+							if (set_argv0 != null) {
+								interceptor.attach (set_argv0, listener, (void *) HookId.SET_ARGV0);
+								child_recovery_behavior = DEFERRED_UNTIL_SET_ARGV0;
+							}
 						}

-						var setcontext = (void *) Gum.Module.find_export_by_name ("libselinux.so", "selinux_android_setcontext");
-						if (setcontext != null)
-							interceptor.attach (setcontext, listener, (void *) HookId.SET_CTX);
+						var selinux = Gum.Process.find_module_by_name ("libselinux.so");
+						if (selinux != null) {
+							var setcontext = (void *) selinux.find_export_by_name ("selinux_android_setcontext");
+							if (setcontext != null)
+								interceptor.attach (setcontext, listener, (void *) HookId.SET_CTX);
+						}
 					}
 				} catch (FileError e) {
 				}
@@ -25,6 +25,24 @@ frida_run_atexit_handlers (void)
 {
 }

+# ifdef HAVE_ASAN
+
+__attribute__ ((constructor)) static void
+frida_init_memory (void)
+{
+  asm volatile ("");
+}
+
+#  ifndef HAVE_DARWIN
+__attribute__ ((destructor)) static void
+frida_deinit_memory (void)
+{
+  asm volatile ("");
+}
+#  endif
+
+# endif
+
 #else

 #define FRIDA_SHIM_LOCK() gum_spinlock_acquire (&frida_shim_lock)
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class PortalClient : Object, AgentSessionProvider {
+	public sealed class PortalClient : Object, AgentSessionProvider {
 		public signal void resume ();
 		public signal void kill ();

@@ -1,5 +1,5 @@
 namespace Frida {
-	public class ScriptEngine : Object {
+	public sealed class ScriptEngine : Object {
 		public signal void message_from_script (AgentScriptId script_id, string json, Bytes? data);
 		public signal void message_from_debugger (AgentScriptId script_id, string message);

@@ -223,7 +223,7 @@ namespace Frida {
 			source.attach (Gum.ScriptBackend.get_scheduler ().get_js_context ());
 		}

-		public class ScriptInstance : Object, RpcPeer {
+		public sealed class ScriptInstance : Object, RpcPeer {
 			public signal void closed ();
 			public signal void message (string json, Bytes? data);
 			public signal void debug_message (string message);
@@ -420,7 +420,7 @@ namespace Frida {
 					var reason_value = new Json.Node.alloc ().init_string (reason.to_nick ());

 					try {
-						yield rpc_client.call ("dispose", new Json.Node[] { reason_value }, null);
+						yield rpc_client.call ("dispose", new Json.Node[] { reason_value }, null, null);
 					} catch (GLib.Error e) {
 					}

@@ -467,10 +467,10 @@ namespace Frida {
 				this.debug_message (message);
 			}

-			private async void post_rpc_message (string json, Cancellable? cancellable) throws Error, IOError {
+			private async void post_rpc_message (string json, Bytes? data, Cancellable? cancellable) throws Error, IOError {
 				if (script == null)
 					throw new Error.INVALID_OPERATION ("Script is destroyed");
-				script.post (json);
+				script.post (json, data);
 			}
 		}
 	}
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class SpawnMonitor : Object, Gum.InvocationListener {
+	public sealed class SpawnMonitor : Object, Gum.InvocationListener {
 		public weak SpawnHandler handler {
 			get;
 			construct;
@@ -38,21 +38,24 @@ namespace Frida {
 			var interceptor = Gum.Interceptor.obtain ();

 #if WINDOWS
-			var create_process_internal = Gum.Module.find_export_by_name ("kernelbase.dll", "CreateProcessInternalW");
-			if (create_process_internal == 0)
-				create_process_internal = Gum.Module.find_export_by_name ("kernel32.dll", "CreateProcessInternalW");
+			var kernelbase = Gum.Process.find_module_by_name ("kernelbase.dll");
+			var create_process_internal = (kernelbase != null) ? kernelbase.find_export_by_name ("CreateProcessInternalW") : 0;
+			if (create_process_internal == 0) {
+				create_process_internal = Gum.Process.find_module_by_name ("kernel32.dll")
+					.find_export_by_name ("CreateProcessInternalW");
+			}
 			assert (create_process_internal != 0);
 			interceptor.attach ((void *) create_process_internal, this);
 #else
-			unowned string libc = Gum.Process.query_libc_name ();
+			var libc = Gum.Process.get_libc_module ();
 #if DARWIN
-			posix_spawn = (PosixSpawnFunc) Gum.Module.find_export_by_name (libc, "posix_spawn");
-			posix_spawnattr_init = (PosixSpawnAttrInitFunc) Gum.Module.find_export_by_name (libc, "posix_spawnattr_init");
-			posix_spawnattr_destroy = (PosixSpawnAttrDestroyFunc) Gum.Module.find_export_by_name (libc, "posix_spawnattr_destroy");
-			posix_spawnattr_getflags = (PosixSpawnAttrSetFlagsFunc) Gum.Module.find_export_by_name (libc, "posix_spawnattr_getflags");
-			posix_spawnattr_setflags = (PosixSpawnAttrSetFlagsFunc) Gum.Module.find_export_by_name (libc, "posix_spawnattr_setflags");
+			posix_spawn = (PosixSpawnFunc) libc.find_export_by_name ("posix_spawn");
+			posix_spawnattr_init = (PosixSpawnAttrInitFunc) libc.find_export_by_name ("posix_spawnattr_init");
+			posix_spawnattr_destroy = (PosixSpawnAttrDestroyFunc) libc.find_export_by_name ("posix_spawnattr_destroy");
+			posix_spawnattr_getflags = (PosixSpawnAttrSetFlagsFunc) libc.find_export_by_name ("posix_spawnattr_getflags");
+			posix_spawnattr_setflags = (PosixSpawnAttrSetFlagsFunc) libc.find_export_by_name ("posix_spawnattr_setflags");

-			execve = (void *) Gum.Module.find_export_by_name (libc, "execve");
+			execve = (void *) libc.find_export_by_name ("execve");

 			interceptor.attach ((void *) posix_spawn, this);

@@ -60,10 +63,10 @@ namespace Frida {
 #else
 			Gum.Address execve = 0;
 #if ANDROID
-			execve = Gum.Module.find_symbol_by_name (libc, "__execve");
+			execve = libc.find_symbol_by_name ("__execve");
 #endif
 			if (execve == 0)
-				execve = Gum.Module.find_export_by_name (libc, "execve");
+				execve = libc.find_export_by_name ("execve");
 			interceptor.attach ((void *) execve, this);
 #endif
 #endif
@@ -1,6 +1,6 @@
 namespace Frida {
 #if DARWIN
-	public class ThreadSuspendMonitor : Object {
+	public sealed class ThreadSuspendMonitor : Object {
 		public weak ProcessInvader invader {
 			get;
 			construct;
@@ -26,9 +26,10 @@ namespace Frida {
 		construct {
 			var interceptor = Gum.Interceptor.obtain ();

-			task_threads = (TaskThreadsFunc) Gum.Module.find_export_by_name (LIBSYSTEM_KERNEL, "task_threads");
-			thread_suspend = (ThreadSuspendFunc) Gum.Module.find_export_by_name (LIBSYSTEM_KERNEL, "thread_suspend");
-			thread_resume = (ThreadResumeFunc) Gum.Module.find_export_by_name (LIBSYSTEM_KERNEL, "thread_resume");
+			var kernel = Gum.Process.find_module_by_name (LIBSYSTEM_KERNEL);
+			task_threads = (TaskThreadsFunc) kernel.find_export_by_name ("task_threads");
+			thread_suspend = (ThreadSuspendFunc) kernel.find_export_by_name ("thread_suspend");
+			thread_resume = (ThreadResumeFunc) kernel.find_export_by_name ("thread_resume");

 			interceptor.replace ((void *) task_threads, (void *) replacement_task_threads, this);
 			interceptor.replace ((void *) thread_suspend, (void *) replacement_thread_suspend, this);
@@ -130,7 +131,7 @@ namespace Frida {
 		}
 	}
 #else
-	public class ThreadSuspendMonitor : Object {
+	public sealed class ThreadSuspendMonitor : Object {
 		public weak ProcessInvader invader {
 			get;
 			construct;
@@ -55,6 +55,7 @@ struct _FridaUnwindHookState
  gpointer set_info_original;
  void (* set_info) (gpointer cursor, gint is_return_address);
  gpointer (* get_reg) (gpointer cursor, gint reg);
+  GumInterceptor * interceptor;
 };

 #if __has_feature (ptrauth_calls)
@@ -97,7 +98,6 @@ _frida_unwind_sitter_hook_libunwind (void)
 #if GLIB_SIZEOF_VOID_P == 8
  gpointer * set_info_slot;
  gpointer get_reg_impl;
-  GumInterceptor * interceptor;

  if (state != NULL)
    return;
@@ -121,8 +121,9 @@ _frida_unwind_sitter_hook_libunwind (void)
  state->set_info = FRIDA_RESIGN_PTR (state->set_info_original);
  state->get_reg = FRIDA_RESIGN_PTR (get_reg_impl);

-  interceptor = gum_interceptor_obtain ();
-  if (gum_interceptor_replace (interceptor, state->set_info_original, frida_unwind_cursor_set_info_replacement, NULL, NULL)
+  state->interceptor = gum_interceptor_obtain ();
+
+  if (gum_interceptor_replace (state->interceptor, state->set_info_original, frida_unwind_cursor_set_info_replacement, NULL, NULL)
      != GUM_REPLACE_OK)
    goto unsupported_version;

@@ -137,13 +138,12 @@ unsupported_version:
 void
 _frida_unwind_sitter_unhook_libunwind (void)
 {
-  GumInterceptor * interceptor;
-
  if (state == NULL)
    return;

-  interceptor = gum_interceptor_obtain ();
-  gum_interceptor_revert (interceptor, state->set_info_original);
+  gum_interceptor_revert (state->interceptor, state->set_info_original);
+
+  g_object_unref (state->interceptor);

  g_slice_free (FridaUnwindHookState, state);
  state = NULL;
@@ -300,6 +300,7 @@ static gpointer
 frida_find_vtable (void)
 {
  GumAddress result = 0;
+  GumModule * libunwind;
  GumAddress export;
  uint64_t address;
  G_GNUC_UNUSED cs_err err;
@@ -309,11 +310,15 @@ frida_find_vtable (void)
  size_t size;
  const size_t max_size = 2048;

-  export = gum_module_find_export_by_name (FRIDA_LIBUNWIND_PATH, "unw_init_local");
+  libunwind = gum_process_find_module_by_name (FRIDA_LIBUNWIND_PATH);
+  if (libunwind == NULL)
+    goto beach;
+
+  export = gum_module_find_export_by_name (libunwind, "unw_init_local");
  if (export == 0)
-    export = gum_module_find_export_by_name (FRIDA_LIBUNWIND_PATH, "_Unwind_RaiseException");
+    export = gum_module_find_export_by_name (libunwind, "_Unwind_RaiseException");
  if (export == 0)
-    return NULL;
+    goto beach;
  export = gum_strip_code_address (export);
  address = export;

@@ -340,7 +345,7 @@ frida_find_vtable (void)
    GumMemoryRange bss_range;

    bss_range.base_address = 0;
-    gum_module_enumerate_sections (FRIDA_LIBUNWIND_PATH, (GumFoundSectionFunc) frida_find_bss_range, &bss_range);
+    gum_module_enumerate_sections (libunwind, (GumFoundSectionFunc) frida_find_bss_range, &bss_range);

    while (cs_disasm_iter (capstone, &code, &size, &address, insn))
    {
@@ -404,6 +409,9 @@ frida_find_vtable (void)
    cs_free (insn, 1);
  cs_close (&capstone);

+beach:
+  g_clear_object (&libunwind);
+
  return GSIZE_TO_POINTER (result);
 }

@@ -1,6 +1,6 @@
 namespace Frida {
 #if DARWIN
-	public class UnwindSitter : Object {
+	public sealed class UnwindSitter : Object {
 		public weak ProcessInvader invader {
 			get;
 			construct;
@@ -21,7 +21,7 @@ namespace Frida {
 			var interceptor = Gum.Interceptor.obtain ();

 			dyld_find_unwind_sections = (DyldFindUnwindSectionsFunc)
-				Gum.Module.find_export_by_name (LIBDYLD, "_dyld_find_unwind_sections");
+				Gum.Process.find_module_by_name (LIBDYLD).find_export_by_name ("_dyld_find_unwind_sections");

 			interceptor.replace ((void *) dyld_find_unwind_sections, (void *) replacement_dyld_find_unwind_sections, this);

@@ -62,7 +62,7 @@ namespace Frida {
 		public extern static void _unhook_libunwind ();
 	}
 #else
-	public class UnwindSitter : Object {
+	public sealed class UnwindSitter : Object {
 		public weak ProcessInvader invader {
 			get;
 			construct;
@@ -1,7 +1,7 @@
-#include "pipe-glue.h"
-
 #include "frida-tvos.h"

+#include "pipe-glue.h"
+
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class PipeTransport : Object {
+	public sealed class PipeTransport : Object {
 		public string local_address {
 			get;
 			construct;
@@ -42,7 +42,7 @@ namespace Frida {
 	}

 #if WINDOWS
-	public class WindowsPipe : IOStream {
+	public sealed class WindowsPipe : IOStream {
 		public string address {
 			get;
 			construct;
@@ -6,13 +6,17 @@ project('frida-core', 'vala', 'c', 'cpp',
  default_options: ['c_std=gnu99,c99', 'cpp_std=c++17'],
 )

+fs = import('fs')
+
 if not meson.get_compiler('vala').version().endswith('-frida')
  error('''Incompatible Vala compiler detected.

 Frida currently relies on features not yet upstream. Grab the Frida-optimized
-Vala compiler from:
+Vala sources from:

-    https://github.com/frida/vala''')
+    https://github.com/frida/vala
+
+and compile them with Meson.''')
 endif

 c_languages = ['c', 'cpp']
@@ -20,7 +24,7 @@ cc = meson.get_compiler('c')
 cpp = meson.get_compiler('cpp')

 releng = meson.global_source_root() / 'releng'
-if not import('fs').exists(releng)
+if not fs.exists(releng)
  releng = meson.project_source_root() / 'releng'
 endif

@@ -92,11 +96,12 @@ else
  host_arch = host_machine.cpu_family()
  host_abi = host_arch
 endif
-gumjs_archs = {
-  'x86': 'ia32',
-  'x86_64': 'x64',
-}
-host_arch_gumjs = gumjs_archs.get(host_arch, host_arch)
+if cc.sizeof('void *') == 8
+  host_cpu_mode = '64'
+else
+  host_cpu_mode = '32'
+endif
+host_docks_mobile_devices = host_os in ['windows', 'macos', 'linux'] and host_cpu_mode == '64'

 if host_os_family == 'darwin'
  c_languages += ['objc', 'objcpp']
@@ -156,10 +161,12 @@ if host_os_family == 'darwin'
  endif
 endif

-if cc.sizeof('void *') == 8
-  host_cpu_mode = '64'
-else
-  host_cpu_mode = '32'
+if host_machine.endian() == 'big'
+  if host_abi in ['arm', 'armhf']
+    host_abi = 'armbe8'
+  elif host_abi == 'arm64'
+    host_abi = 'arm64be'
+  endif
 endif

 if host_os_family == 'darwin' and host_arch == 'arm64'
@@ -264,12 +271,14 @@ if host_os == 'linux'
 #endif
 '''
  if cc.compiles(glibc_src, name: 'compiling for glibc')
-    cdata.set('HAVE_GLIBC', 1)
+    libc = 'glibc'
  elif cc.compiles(uclibc_src, name: 'compiling for uClibc')
-    cdata.set('HAVE_UCLIBC', 1)
+    libc = 'uclibc'
  else
-    cdata.set('HAVE_MUSL', 1)
+    libc = 'musl'
  endif
+  cdata.set('HAVE_' + libc.to_upper(), 1)
+  vala_flags += '--define=' + libc.to_upper()
 endif

 if get_option('b_sanitize') == 'address'
@@ -347,15 +356,112 @@ else
  gio_unix_dep = dependency('gio-unix-2.0')
 endif

+if host_os == 'android'
+  minizip_dep = dependency('minizip', required: false, default_options: [
+    'zlib=enabled',
+    'lzma=disabled',
+  ])
+endif
+
+if host_toolchain == 'microsoft'
+  lib = find_program('lib')
+  ar = ''
+  nm = ''
+  ranlib = ''
+  strip = ''
+else
+  lib = ''
+  ar = find_program('ar')
+  nm = find_program('nm')
+  ranlib = find_program('ranlib')
+  strip = find_program('strip')
+endif
+if host_os_family != 'windows'
+  if host_os_family == 'darwin'
+    readelf = ''
+    otool = find_program('otool')
+    libtool = find_program('libtool')
+  else
+    readelf = find_program('readelf')
+    otool = ''
+    libtool = ''
+  endif
+else
+  readelf = ''
+  otool = ''
+  libtool = ''
+endif
+if host_os_family == 'darwin'
+  install_name_tool = find_program('install_name_tool')
+  lipo = find_program('lipo')
+  codesign = find_program('codesign')
+else
+  install_name_tool = ''
+  lipo = ''
+  codesign = ''
+endif
+
 have_local_backend = get_option('local_backend').allowed()
-have_fruity_backend = get_option('fruity_backend').allowed()
-have_droidy_backend = get_option('droidy_backend').allowed()
-have_socket_backend = get_option('socket_backend').allowed()
-have_barebone_backend = quickjs_dep.found()
-have_compiler_backend = get_option('compiler_backend') \
-    .disable_if(not have_local_backend, error_message: 'compiler backend requires the local backend for script execution') \
-    .disable_auto_if(host_os == 'watchos') \
+have_fruity_backend = get_option('fruity_backend') \
+    .disable_auto_if(not host_docks_mobile_devices) \
    .allowed()
+have_droidy_backend = get_option('droidy_backend') \
+    .disable_auto_if(not host_docks_mobile_devices) \
+    .allowed()
+have_socket_backend = get_option('socket_backend').allowed()
+have_barebone_backend = get_option('barebone_backend') \
+    .disable_if(not quickjs_dep.found()) \
+    .disable_auto_if(not host_docks_mobile_devices) \
+    .allowed()
+compiler_backend_opt = get_option('compiler_backend') \
+    .disable_auto_if(host_os == 'watchos')
+have_compiler_backend = false
+if compiler_backend_opt.allowed()
+  go = find_program('go', native: true, required: false)
+  if go.found()
+    message('Detecting cgo availability')
+    detect_output = run_command(
+      [
+        python,
+        files('tools' / 'cgo' / 'detect.py'),
+        go,
+        host_os,
+        host_abi,
+        shlib_suffix,
+        cc.get_id(),
+        '>>>', cc.cmd_array(), '<<<',
+        '>>>', ar, '<<<',
+        '>>>', nm, '<<<',
+        '>>>', ranlib, '<<<',
+      ],
+      capture: true,
+      check: true
+    ).stdout()
+    lines = detect_output.split('\n')
+    status = lines[0]
+    if status == 'ok'
+      have_compiler_backend = true
+      tokens = lines[1].split(' ')
+      go_mode = tokens[0]
+      go_config = tokens[1]
+      compiler_backend_static_compilation = go_mode == 'c-archive'
+      if compiler_backend_static_compilation
+        vala_flags += '--define=COMPILER_BACKEND_STATIC_COMPILATION'
+      endif
+    else
+      error_message = lines[1]
+      if compiler_backend_opt.enabled()
+        error(error_message)
+      else
+        warning(f'Building without Compiler backend: @error_message@')
+      endif
+    endif
+  elif compiler_backend_opt.enabled()
+    error('Need Go >= 1.24 to build the Compiler backend powered by ESBuild and typescript-go')
+  else
+    warning('Building without Compiler backend: Go >= 1.24 not found')
+  endif
+endif

 build_gadget = get_option('gadget') \
    .disable_auto_if(meson.is_subproject()) \
@@ -394,7 +500,7 @@ foreach b : [['local', have_local_backend],
  endif
 endforeach

-if have_barebone_backend or have_compiler_backend
+if host_os_family == 'darwin' or host_os == 'android' or have_barebone_backend or have_compiler_backend
  node = find_program('node', version: '>=18.0.0', native: true, required: false)
  if not node.found()
    error('Need Node.js >= 18.0.0 to process JavaScript code at build time')
@@ -411,9 +517,8 @@ if gi_dep.found()
 else
  girdir = get_option('prefix') / get_option('datadir') / 'gir-1.0'
 endif
-uninstalled_girdir = meson.current_build_dir() / 'src'

-vapidir = get_option('datadir') / 'vala' / 'vapi'
+vapidir = get_option('prefix') / get_option('datadir') / 'vala' / 'vapi'

 gum_vala_args = [
  '--pkg=frida-gum-1.0',
@@ -425,18 +530,49 @@ gumjs_inspector_vala_args = ['--pkg=frida-gumjs-inspector-1.0', gum_vala_args]
 have_v8 = gumjs_dep.get_variable('gumjs_v8') == 'enabled'
 if have_v8
  vala_flags += ['--define=HAVE_V8']
-  v8_mksnapshot = find_program('v8-mksnapshot-@0@-@1@'.format(host_os, host_abi), required: false)
-  if not v8_mksnapshot.found()
-    v8_mksnapshot = ''
-  endif
-else
-  v8_mksnapshot = ''
 endif

 backend_deps_private = []
 backend_reqs_private = []
 backend_libs_private = []

+openssl_options = [
+  'cli=disabled',
+]
+if host_os_family == 'windows' and cc.get_argument_syntax() != 'msvc'
+  openssl_options += 'asm=disabled'
+endif
+openssl_dep = dependency('openssl',
+  required: have_fruity_backend or get_option('connectivity').enabled(),
+  modules: cc.get_argument_syntax() == 'msvc' ? ['OpenSSL::SSL'] : [],
+  default_options: openssl_options,
+)
+
+if have_fruity_backend
+  foreach dep : ['libnghttp2', 'libngtcp2', 'libngtcp2_crypto_quictls', 'libusb-1.0']
+    backend_deps_private += dependency(dep)
+    backend_reqs_private += dep
+  endforeach
+
+  lwip_options = [
+    'ipv4=disabled',
+    'ipv6=enabled',
+    'dns=disabled',
+    'arp=disabled',
+    'ethernet=enabled',
+    'tcp_mss=4036',
+    'tcp_snd_buf=65535',
+    'tcp_wnd=65535',
+  ]
+  if optimize_for_prod
+    lwip_options += 'lwip_debug=disabled'
+  else
+    lwip_options += 'lwip_debug=enabled'
+  endif
+  backend_deps_private += dependency('lwip', default_options: lwip_options)
+  backend_reqs_private += 'lwip'
+endif
+
 if quickjs_dep.found()
  backend_deps_private += quickjs_dep
  backend_reqs_private += 'quickjs'
@@ -456,8 +592,19 @@ else
  termux_elf_cleaner = []
 endif

-tls_provider_dep = dependency('gioopenssl', required: get_option('connectivity'))
+tls_provider_dep = dependency('gioopenssl', required: get_option('connectivity'), default_options: [
+  'gnutls=disabled',
+  'openssl=enabled',
+  'libproxy=disabled',
+  'gnome_proxy=disabled',
+  'tests=false',
+])
+tls_provider_vala_args = []
 if tls_provider_dep.found()
+  tls_provider_vala_args += [
+    '--pkg=gioopenssl',
+    '--vapidir=' + tls_provider_dep.get_variable('vapidir'),
+  ]
  cdata.set('HAVE_GIOOPENSSL', 1)
  vala_flags += ['--define=HAVE_GIOOPENSSL']
  backend_deps_private += tls_provider_dep
@@ -473,7 +620,6 @@ nice_dep = dependency('nice', required: get_option('connectivity'), default_opti
  'introspection=disabled',
 ])
 if nice_dep.found()
-  openssl_dep = dependency('openssl')
  usrsctp_dep = dependency('usrsctp', default_options: [
    'sctp_inet=false',
    'sctp_inet6=false',
@@ -489,7 +635,6 @@ if nice_dep.found()
    cdata.set('HAVE_SCONN_LEN', 1)
  endif
 else
-  openssl_dep = []
  usrsctp_dep = []
 endif

@@ -506,42 +651,6 @@ if host_os in ['ios', 'tvos']
  backend_libs_private += ['-Wl,-framework,CoreGraphics', '-Wl,-framework,UIKit']
 endif

-if host_toolchain == 'microsoft'
-  lib = find_program('lib')
-  ar = ''
-  nm = ''
-  strip = ''
-else
-  lib = ''
-  ar = find_program('ar')
-  nm = find_program('nm')
-  strip = find_program('strip')
-endif
-if host_os_family != 'windows'
-  if host_os_family == 'darwin'
-    readelf = ''
-    otool = find_program('otool')
-    libtool = find_program('libtool')
-  else
-    readelf = find_program('readelf')
-    otool = ''
-    libtool = ''
-  endif
-else
-  readelf = ''
-  otool = ''
-  libtool = ''
-endif
-if host_os_family == 'darwin'
-  install_name_tool = find_program('install_name_tool')
-  lipo = find_program('lipo')
-  codesign = find_program('codesign')
-else
-  install_name_tool = ''
-  lipo = ''
-  codesign = ''
-endif
-
 if get_option('devkits').length() != 0
  if get_option('default_library') != 'static'
    error('Devkits can only be generated from static libraries')
@@ -549,6 +658,7 @@ if get_option('devkits').length() != 0
  mkdevkit = [python, releng / 'mkdevkit.py']
  uninstalled_dir = meson.global_build_root() / 'meson-uninstalled'
  devkit_options = [
+    '--dep-symbol-scope', get_option('devkit_symbol_scope'),
    '--cc', '>>>', cc.cmd_array(), '<<<',
    '--c-args', '>>>', get_option('c_args'), '<<<',
    '--pkg-config', '>>>', find_program('pkg-config'), '<<<',
@@ -599,6 +709,8 @@ post_process = [
  '@INPUT0@',
 ]

+compile_js_agent = files('tools' / 'compile-js-agent.py')
+
 mapper_opt = get_option('mapper')
 if mapper_opt.auto()
  have_mapper = host_os_family == 'darwin'
@@ -627,25 +739,29 @@ if cc.get_id() == 'gcc' and cc.compiles('#if __GNUC__ >= 5\n#error NOTNEEDED\n#e
  add_project_arguments('-w', language: 'c')
 endif

+vapidir = meson.current_source_dir() / 'vapi'
 vala_flags += [
-  '--vapidir=' + meson.current_source_dir() / 'vapi',
+  '--vapidir=' + vapidir,
  '--pkg', 'config',
 ]

-vala_flags += ['--define=' + host_os_family.to_upper()]
+vala_flags += '--define=' + host_os_family.to_upper()
 if host_os != host_os_family
-  vala_flags += ['--define=' + host_os.to_upper()]
+  vala_flags += '--define=' + host_os.to_upper()
 endif
-vala_flags += ['--define=' + host_arch.to_upper()]
+vala_flags += '--define=' + host_arch.to_upper()
 if host_abi != host_arch
-  vala_flags += ['--define=' + host_abi.to_upper()]
+  vala_flags += '--define=' + host_abi.to_upper()
 endif
+vala_flags += '--define=' + host_machine.endian().to_upper() + '_ENDIAN'
 add_project_arguments(vala_flags, language: 'vala')
+add_project_arguments('-I' + vapidir, language: 'c')

 native_vala_flags = [
  '--vapidir=' + meson.current_source_dir() / 'vapi',
 ]
 add_project_arguments(native_vala_flags, language: 'vala', native: true)
+add_project_arguments('-I' + vapidir, language: 'c', native: true)

 subdir('compat')
 subdir('tools')
@@ -664,9 +780,30 @@ if build_tests
  subdir('tests')
 endif

+summary(
+  {
+    'local': have_local_backend,
+    'fruity': have_fruity_backend,
+    'droidy': have_droidy_backend,
+    'socket': have_socket_backend,
+    'barebone': have_barebone_backend,
+    'compiler': have_compiler_backend,
+  },
+  section: 'Backends',
+  bool_yn: true,
+)
 summary(
  {
    'compat': compat_summary,
+    'assets': get_option('assets'),
+    'mapper': have_mapper,
+    'connectivity': tls_provider_dep.found(),
+    'gadget': build_gadget,
+    'server': build_server,
+    'portal': build_portal,
+    'inject': build_inject,
+    'tests': build_tests,
  },
  section: 'Features',
+  bool_yn: true,
 )
@@ -37,13 +37,7 @@ option('barebone_backend',
 option('compiler_backend',
  type: 'feature',
  value: 'auto',
-  description: 'Include frida-compile backend powered by GumJS',
-)
-
-option('compiler_snapshot',
-  type: 'feature',
-  value: 'auto',
-  description: 'Speed up compiler startup by using a snapshot'
+  description: 'Include frida-compile backend powered by ESBuild and typescript-go',
 )

 option('assets',
@@ -68,13 +62,25 @@ option('compat',
 option('helper_modern',
  type: 'string',
  value: 'auto',
-  description: 'Prebuilt frida-helper to embed for use on modern systems'
+  description: 'Prebuilt frida-helper to embed for supporting modern targets'
 )

 option('helper_legacy',
  type: 'string',
  value: 'auto',
-  description: 'Prebuilt frida-helper to embed for use on legacy systems'
+  description: 'Prebuilt frida-helper to embed for supporting legacy targets'
+)
+
+option('helper_emulated_modern',
+  type: 'string',
+  value: 'auto',
+  description: 'Prebuilt frida-helper to embed for supporting modern emulated targets'
+)
+
+option('helper_emulated_legacy',
+  type: 'string',
+  value: 'auto',
+  description: 'Prebuilt frida-helper to embed for supporting legacy emulated targets'
 )

 option('agent_modern',
@@ -101,16 +107,6 @@ option('agent_emulated_legacy',
  description: 'Prebuilt agent to embed for use on legacy emulated targets'
 )

-option('agent_dbghelp_prefix',
-  type: 'string',
-  description: 'Location of DbgHelp binaries to embed alongside agent (Windows only)'
-)
-
-option('agent_symsrv_prefix',
-  type: 'string',
-  description: 'Location of SymSrv binaries to embed alongside agent (Windows only)'
-)
-
 option('gadget',
  type: 'feature',
  value: 'auto',
@@ -137,7 +133,7 @@ option('inject',

 option('connectivity',
  type: 'feature',
-  value: 'auto',
+  value: 'enabled',
  description: 'Internet connectivity features (TLS and ICE support)'
 )

@@ -154,6 +150,15 @@ option('devkits',
  description: 'Devkits to build'
 )

+option('devkit_symbol_scope',
+  type: 'combo',
+  choices: ['prefixed', 'original'],
+  value: 'prefixed',
+  description : 'How devkit generation treats third-party symbols:\n'
+                + ' - prefixed: add the \'_frida_\' prefix\n'
+                + ' - original: keep symbols exactly as upstream\n'
+)
+
 option('tests',
  type: 'feature',
  value: 'auto',
@@ -20,7 +20,7 @@ if tls_provider_dep.found()
 endif

 raw_portal = executable('frida-portal-raw', portal_sources,
-  vala_args: [core_vala_args, '--pkg=posix'],
+  vala_args: [core_vala_args, tls_provider_vala_args, '--pkg=posix'],
  link_args: extra_link_args,
  link_depends: extra_link_depends,
  dependencies: [core_dep] + extra_deps,
@@ -142,7 +142,7 @@ namespace Frida.Portal {
 		return application.run ();
 	}

-	private class Application : Object {
+	private sealed class Application : Object {
 		public signal void ready (bool success);

 		public PortalService service {
@@ -3,6 +3,7 @@ namespace Frida.Server {

 	private const string DEFAULT_DIRECTORY = "re.frida.server";
 	private static bool output_version = false;
+	private static string? device_id = null;
 	private static string? listen_address = null;
 	private static string? certpath = null;
 	private static string? origin = null;
@@ -30,6 +31,7 @@ namespace Frida.Server {

 	const OptionEntry[] option_entries = {
 		{ "version", 0, 0, OptionArg.NONE, ref output_version, "Output version information and exit", null },
+		{ "device", 0, 0, OptionArg.STRING, ref device_id, "Serve device with the given ID", "ID" },
 		{ "listen", 'l', 0, OptionArg.STRING, ref listen_address, "Listen on ADDRESS", "ADDRESS" },
 		{ "certificate", 0, 0, OptionArg.FILENAME, ref certpath, "Enable TLS using CERTIFICATE", "CERTIFICATE" },
 		{ "origin", 0, 0, OptionArg.STRING, ref origin, "Only accept requests with “Origin” header matching ORIGIN " +
@@ -178,7 +180,7 @@ namespace Frida.Server {

 #if DARWIN
 		var worker = new Thread<int> ("frida-server-main-loop", () => {
-			var exit_code = run_application (endpoint_params, options, on_ready);
+			var exit_code = run_application (device_id, endpoint_params, options, on_ready);

 			_stop_run_loop ();

@@ -190,15 +192,16 @@ namespace Frida.Server {

 		return exit_code;
 #else
-		return run_application (endpoint_params, options, on_ready);
+		return run_application (device_id, endpoint_params, options, on_ready);
 #endif
 	}

-	private static int run_application (EndpointParameters endpoint_params, ControlServiceOptions options, ReadyHandler on_ready) {
+	private static int run_application (string? device_id, EndpointParameters endpoint_params, ControlServiceOptions options,
+			ReadyHandler on_ready) {
 		TemporaryDirectory.always_use ((directory != null) ? directory : DEFAULT_DIRECTORY);
 		TemporaryDirectory.use_sysroot (options.sysroot);

-		application = new Application (new ControlService (endpoint_params, options));
+		application = new Application (device_id, endpoint_params, options);

 		Posix.signal (Posix.Signal.INT, (sig) => {
 			application.stop ();
@@ -232,22 +235,39 @@ namespace Frida.Server {
 	}
 #endif

-	private class Application : Object {
+	private sealed class Application : Object {
 		public signal void ready (bool success);

-		public ControlService service {
+		public string? device_id {
 			get;
 			construct;
 		}

+		public EndpointParameters endpoint_params {
+			get;
+			construct;
+		}
+
+		public ControlServiceOptions options {
+			get;
+			construct;
+		}
+
+		private DeviceManager? manager;
+		private ControlService? service;
+
 		private Cancellable io_cancellable = new Cancellable ();

 		private MainLoop loop = new MainLoop ();
 		private int exit_code;
 		private bool stopping;

-		public Application (ControlService service) {
-			Object (service: service);
+		public Application (string? device_id, EndpointParameters endpoint_params, ControlServiceOptions options) {
+			Object (
+				device_id: device_id,
+				endpoint_params: endpoint_params,
+				options: options
+			);
 		}

 		public int run () {
@@ -265,6 +285,17 @@ namespace Frida.Server {

 		private async void start () {
 			try {
+				if (device_id != null && device_id != "local") {
+					manager = new DeviceManager.with_nonlocal_backends_only ();
+
+					var device = yield manager.get_device_by_id (device_id, 0, io_cancellable);
+					device.lost.connect (on_device_lost);
+
+					service = yield new ControlService.with_device (device, endpoint_params, options);
+				} else {
+					service = new ControlService (endpoint_params, options);
+				}
+
 				yield service.start (io_cancellable);
 			} catch (GLib.Error e) {
 				if (e is IOError.CANCELLED)
@@ -297,7 +328,15 @@ namespace Frida.Server {
 			io_cancellable.cancel ();

 			try {
-				yield service.stop ();
+				if (service != null) {
+					yield service.stop ();
+					service = null;
+				}
+
+				if (manager != null) {
+					yield manager.close ();
+					manager = null;
+				}
 			} catch (GLib.Error e) {
 			}

@@ -306,6 +345,10 @@ namespace Frida.Server {
 				return false;
 			});
 		}
+
+		private void on_device_lost () {
+			stop ();
+		}
 	}

 	private TlsCertificate? parse_certificate (string? path) throws GLib.Error {
@@ -1,5 +1,5 @@
 namespace Frida {
-	public class AgentContainer : Object, AgentSessionProvider {
+	public sealed class AgentContainer : Object, AgentSessionProvider {
 		public DBusConnection connection {
 			get;
 			private set;
@@ -1,42 +1,71 @@
+from __future__ import annotations
 import argparse
-import os
+from dataclasses import dataclass
+from io import StringIO
 from pathlib import Path
 import re
-import sys
+from typing import List, Set
+import xml.etree.ElementTree as ET

+CORE_NAMESPACE = "http://www.gtk.org/introspection/core/1.0"
+C_NAMESPACE = "http://www.gtk.org/introspection/c/1.0"
+GLIB_NAMESPACE = "http://www.gtk.org/introspection/glib/1.0"
+GIR_NAMESPACES = {
+    "": CORE_NAMESPACE,
+    "c": C_NAMESPACE,
+    "glib": GLIB_NAMESPACE,
+}
+
+CORE_TAG_IMPLEMENTS = f"{{{CORE_NAMESPACE}}}implements"
+CORE_TAG_FIELD = f"{{{CORE_NAMESPACE}}}field"
+CORE_TAG_CONSTRUCTOR = f"{{{CORE_NAMESPACE}}}constructor"
+CORE_TAG_METHOD = f"{{{CORE_NAMESPACE}}}method"
+
+OBJECT_TYPE_PATTERN = re.compile(r"\bpublic\s+(sealed )?(class|interface)\s+(\w+)\b")

 def main():
    parser = argparse.ArgumentParser(description="Generate refined Frida API definitions")
    parser.add_argument('--output', dest='output_type', choices=['bundle', 'header', 'gir', 'vapi', 'vapi-stamp'], default='bundle')
+    parser.add_argument('frida_version', metavar='frida-version', type=str)
+    parser.add_argument('frida_major_version', metavar='frida-major-version', type=str)
+    parser.add_argument('frida_minor_version', metavar='frida-minor-version', type=str)
+    parser.add_argument('frida_micro_version', metavar='frida-micro-version', type=str)
+    parser.add_argument('frida_nano_version', metavar='frida-nano-version', type=str)
    parser.add_argument('api_version', metavar='api-version', type=str)
+    parser.add_argument('core_header', metavar='/path/to/frida-core.h', type=argparse.FileType('r', encoding='utf-8'))
    parser.add_argument('core_gir', metavar='/path/to/Frida-x.y.gir', type=argparse.FileType('r', encoding='utf-8'))
    parser.add_argument('core_vapi', metavar='/path/to/frida-core.vapi', type=argparse.FileType('r', encoding='utf-8'))
-    parser.add_argument('core_header', metavar='/path/to/frida-core.h', type=argparse.FileType('r', encoding='utf-8'))
-    parser.add_argument('base_vapi', metavar='/path/to/frida-base.vapi', type=argparse.FileType('r', encoding='utf-8'))
    parser.add_argument('base_header', metavar='/path/to/frida-base.h', type=argparse.FileType('r', encoding='utf-8'))
+    parser.add_argument('base_gir', metavar='/path/to/FridaBase-x.y.gir', type=argparse.FileType('r', encoding='utf-8'))
+    parser.add_argument('base_vapi', metavar='/path/to/frida-base.vapi', type=argparse.FileType('r', encoding='utf-8'))
    parser.add_argument('output_dir', metavar='/output/dir')

    args = parser.parse_args()

    output_type = args.output_type
+    frida_version = args.frida_version
+    frida_version_components = (
+        args.frida_major_version,
+        args.frida_minor_version,
+        args.frida_micro_version,
+        args.frida_nano_version,
+    )
    api_version = args.api_version
+    core_header = args.core_header.read()
    core_gir = args.core_gir.read()
    core_vapi = args.core_vapi.read()
-    core_header = args.core_header.read()
-    base_vapi = args.base_vapi.read()
    base_header = args.base_header.read()
+    base_gir = args.base_gir.read()
+    base_vapi = args.base_vapi.read()
    output_dir = Path(args.output_dir)

-    if output_type == 'gir':
-        (output_dir / f"Frida-{api_version}.gir").write_text(core_gir, encoding='utf-8')
-        return
-
    if output_type == 'vapi-stamp':
        (output_dir / f"frida-core-{api_version}.vapi.stamp").write_bytes(b"")
        return

    toplevel_names = [
        "frida.vala",
+        "package-manager.vala",
        "control-service.vala",
        "portal-service.vala",
        "file-monitor.vala",
@@ -45,33 +74,58 @@ def main():
    toplevel_sources = []
    src_dir = Path(__file__).parent.parent.resolve()
    for name in toplevel_names:
-        with open(src_dir / name, 'r', encoding='utf-8') as f:
-            toplevel_sources.append(f.read())
+        toplevel_sources.append((src_dir / name).read_text(encoding='utf-8'))
    toplevel_code = "\n".join(toplevel_sources)

    enable_header = False
+    enable_gir = False
    enable_vapi = False
    if output_type == 'bundle':
        enable_header = True
+        enable_gir = True
        enable_vapi = True
    elif output_type == 'header':
        enable_header = True
+    elif output_type == 'gir':
+        enable_gir = True
    elif output_type == 'vapi':
        enable_vapi = True

-    api = parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, base_header)
+    api = parse_api(frida_version, frida_version_components, api_version, toplevel_code, core_header, core_vapi, base_header, base_vapi)

    if enable_header:
        emit_header(api, output_dir)

+    if enable_gir:
+        emit_gir(api, core_gir, base_gir, output_dir)
+
    if enable_vapi:
        emit_vapi(api, output_dir)

 def emit_header(api, output_dir):
-    with open(output_dir / 'frida-core.h', 'w', encoding='utf-8') as output_header_file:
+    with OutputFile(output_dir / 'frida-core.h') as output_header_file:
        output_header_file.write("#ifndef __FRIDA_CORE_H__\n#define __FRIDA_CORE_H__\n\n")

-        output_header_file.write("#include <glib.h>\n#include <glib-object.h>\n#include <gio/gio.h>\n#include <json-glib/json-glib.h>\n")
+        output_header_file.write("#include <glib.h>\n#include <glib-object.h>\n#include <gio/gio.h>\n#include <json-glib/json-glib.h>\n\n")
+
+        output_header_file.write(f"#define FRIDA_VERSION \"{api.frida_version}\"\n\n")
+
+        for name, value in zip(['MAJOR', 'MINOR', 'MICRO', 'NANO'], api.frida_version_components):
+            output_header_file.write(f"#define FRIDA_{name}_VERSION {value}\n")
+
+        output_header_file.write("""
+#define FRIDA_CHECK_VERSION(maj, min, mic) \\
+    (FRIDA_CURRENT_VERSION >= FRIDA_VERSION_ENCODE ((maj), (min), (mic)))
+
+#define FRIDA_CURRENT_VERSION \\
+    FRIDA_VERSION_ENCODE (    \\
+        FRIDA_MAJOR_VERSION,  \\
+        FRIDA_MINOR_VERSION,  \\
+        FRIDA_MICRO_VERSION)
+
+#define FRIDA_VERSION_ENCODE(maj, min, mic) \\
+    (((maj) * 1000000U) + ((min) * 1000U) + (mic))
+""")

        output_header_file.write("\nG_BEGIN_DECLS\n")

@@ -79,7 +133,6 @@ def emit_header(api, output_dir):
            output_header_file.write("\ntypedef struct _%s %s;" % (object_type.c_name, object_type.c_name))
            if object_type.c_iface_definition is not None:
                output_header_file.write("\ntypedef struct _%sIface %sIface;" % (object_type.c_name, object_type.c_name))
-        output_header_file.write("\ntypedef struct _FridaHostSession FridaHostSession;")

        for enum in api.enum_types:
            output_header_file.write("\n\n" + enum.c_definition)
@@ -150,8 +203,64 @@ def emit_header(api, output_dir):

        output_header_file.write("\n\n#endif\n")

+def emit_gir(api: ApiSpec, core_gir: str, base_gir: str, output_dir: Path) -> str:
+    ET.register_namespace("", CORE_NAMESPACE)
+    ET.register_namespace("c", C_NAMESPACE)
+    ET.register_namespace("glib", GLIB_NAMESPACE)
+
+    core_tree = ET.ElementTree(ET.fromstring(core_gir))
+    base_tree = ET.ElementTree(ET.fromstring(base_gir))
+
+    core_root = core_tree.getroot()
+    base_root = base_tree.getroot()
+
+    merged_root = ET.Element(core_root.tag, core_root.attrib)
+
+    for elem in core_root.findall("include", GIR_NAMESPACES):
+        name = elem.get("name")
+        if name in {"GLib", "GObject", "Gio"}:
+            merged_root.append(elem)
+
+    for tag in ["package", "c:include"]:
+        for elem in core_root.findall(tag, GIR_NAMESPACES):
+            merged_root.append(elem)
+
+    core_namespace = core_root.find("namespace", GIR_NAMESPACES)
+    merged_namespace = ET.SubElement(merged_root, core_namespace.tag, core_namespace.attrib)
+
+    object_type_names = {obj.name for obj in api.object_types}
+    enum_type_names = {enum.name for enum in api.enum_types}
+    error_type_names = {error.name for error in api.error_types}
+
+    def merge_and_transform_elements(tag_name: str, spec_set: Set[str]):
+        core_elements = filter_elements(core_root.findall(f".//{tag_name}", GIR_NAMESPACES), spec_set)
+        base_elements = filter_elements(base_root.findall(f".//{tag_name}", GIR_NAMESPACES), spec_set)
+        for elem in core_elements + base_elements:
+            if tag_name == "class":
+                for child in list(elem):
+                    if (child.tag == CORE_TAG_IMPLEMENTS and child.get("name") == "FridaBase.AgentMessageSink") \
+                            or child.tag == CORE_TAG_FIELD \
+                            or child.get("name").startswith("_"):
+                        elem.remove(child)
+            merged_namespace.append(elem)
+
+    merge_and_transform_elements("class", object_type_names)
+    merge_and_transform_elements("interface", object_type_names)
+    merge_and_transform_elements("enumeration", enum_type_names | error_type_names)
+
+    ET.indent(merged_root, space="  ")
+    result = ET.tostring(merged_root,
+                         encoding="unicode",
+                         xml_declaration=True)
+    result = result.replace("FridaBase.", "Frida.")
+    with OutputFile(output_dir / f"Frida-{api.version}.gir") as output_gir:
+        output_gir.write(result)
+
+def filter_elements(elements: List[ET.Element], spec_set: Set[str]):
+    return [elem for elem in elements if elem.get("name") in spec_set]
+
 def emit_vapi(api, output_dir):
-    with open(output_dir / "frida-core-{0}.vapi".format(api.version), "w", encoding='utf-8') as output_vapi_file:
+    with OutputFile(output_dir / f"frida-core-{api.version}.vapi") as output_vapi_file:
        output_vapi_file.write("[CCode (cheader_filename = \"frida-core.h\", cprefix = \"Frida\", lower_case_cprefix = \"frida_\")]")
        output_vapi_file.write("\nnamespace Frida {")
        output_vapi_file.write("\n\tpublic static void init ();")
@@ -189,12 +298,12 @@ def emit_vapi(api, output_dir):

        output_vapi_file.write("\n}\n")

-    with open(output_dir / "frida-core-{0}.deps".format(api.version), "w", encoding='utf-8') as output_deps_file:
+    with OutputFile(output_dir / f"frida-core-{api.version}.deps") as output_deps_file:
        output_deps_file.write("glib-2.0\n")
        output_deps_file.write("gobject-2.0\n")
        output_deps_file.write("gio-2.0\n")

-def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, base_header):
+def parse_api(frida_version, frida_version_components, api_version, toplevel_code, core_header, core_vapi, base_header, base_vapi):
    all_headers = core_header + "\n" + base_header

    all_enum_names = [m.group(1) for m in re.finditer(r"^\t+public\s+enum\s+(\w+)\s+", toplevel_code + "\n" + base_vapi, re.MULTILINE)]
@@ -217,12 +326,18 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
        "StaticAuthenticationService": "AuthenticationService",
    }
    internal_type_prefixes = [
+        "AgentMessageKind",
        "Fruity",
        "HostSession",
        "MessageType",
+        "PeerSetup",
+        "PortConflictBehavior",
        "ResultCode",
        "SpawnStartState",
        "State",
+        "StringTerminator",
+        "UnloadPolicy",
+        "WebService",
        "Winjector"
    ]
    seen_enum_names = set()
@@ -287,8 +402,7 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
            method_cname_lc = object_type.c_name_lc + '_' + method_name
            if method_cname_lc not in seen_cfunctions:
                seen_cfunctions.add(method_cname_lc)
-                if method_name not in ('construct', 'construct_with_host_session', 'get_main_context', 'get_provider', 'get_session') \
-                        and not (object_type.name in ("Session", "Script") and method_name == 'get_id'):
+                if method_name != 'construct':
                    if (object_type.c_name + '*') in m.group(0):
                        if method_name == 'new' or method_name.startswith('new_'):
                            object_type.c_constructors.append(method_cprototype)
@@ -305,7 +419,7 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
            if delegate_cname not in seen_cdelegates:
                seen_cdelegates.add(delegate_cname)
                object_type.c_delegate_typedefs.append(beautify_cprototype(d.group(0)))
-        if object_type.kind == 'interface' and object_type.name != "Injector":
+        if object_type.kind == 'interface':
            for m in re.finditer("^(struct _" + object_type.c_name + "Iface {[^}]+};)$", all_headers, re.MULTILINE):
                object_type.c_iface_definition = beautify_cinterface(m.group(1))

@@ -327,8 +441,10 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
                if stripped_line == "}":
                    ignoring = False
            else:
-                if stripped_line.startswith("public abstract") or stripped_line.startswith("public class Promise") \
-                        or stripped_line.startswith("public interface Future"):
+                if stripped_line.startswith("public abstract") \
+                        or stripped_line.startswith("public class Promise") \
+                        or stripped_line.startswith("public interface Future") \
+                        or stripped_line.startswith("public class CF"):
                    ignoring = True
                elif stripped_line.startswith("public enum") or stripped_line.startswith("public errordomain"):
                    name = re.match(r"^public (?:enum|errordomain) (\w+) ", stripped_line).group(1)
@@ -340,8 +456,8 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
                        current_enum.vapi_declaration = stripped_line
                    else:
                        ignoring = True
-                elif stripped_line.startswith("public class") or stripped_line.startswith("public interface"):
-                    name = re.match(r"^public (class|interface) (\w+) ", stripped_line).group(2)
+                elif (match := OBJECT_TYPE_PATTERN.match(stripped_line)) is not None:
+                    name = match.group(3)
                    if name not in object_type_by_name:
                        ignoring = True
                    else:
@@ -360,8 +476,7 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
                current_object_type.vapi_signals.append(stripped_line)
            elif "{ get" in stripped_line:
                name = re.match(r".+?(\w+)\s+{", stripped_line).group(1)
-                if name not in ('main_context', 'provider', 'session'):
-                    current_object_type.vapi_properties.append(stripped_line)
+                current_object_type.vapi_properties.append(stripped_line)
            else:
                m = re.match(r".+?(\w+)\s+\(", stripped_line)
                if m is not None:
@@ -381,7 +496,7 @@ def parse_api(api_version, toplevel_code, core_vapi, core_header, base_vapi, bas
        m = re.search(r"^[\w\*]+ frida_{}.+?;".format(f.name), all_headers, re.MULTILINE | re.DOTALL)
        f.c_prototype = beautify_cprototype(m.group(0))

-    return ApiSpec(api_version, object_types, functions, enum_types, error_types)
+    return ApiSpec(frida_version, frida_version_components, api_version, object_types, functions, enum_types, error_types)

 def function_is_public(name):
    return not name.startswith("_") and \
@@ -395,22 +510,25 @@ def function_is_public(name):
                "parse_control_address",
                "parse_cluster_address",
                "parse_socket_address",
-                "negotiate_connection"
+                "negotiate_connection",
+                "check_kernel_version",
            ]

-def parse_vala_object_types(source):
-    return [ApiObjectType(m.group(2), m.group(1)) for m in re.finditer(r"^\t+public\s+(class|interface)\s+(\w+)\s+", source, re.MULTILINE)]
+def parse_vala_object_types(source) -> List[ApiObjectType]:
+    return [ApiObjectType(m.group(3), m.group(2)) for m in OBJECT_TYPE_PATTERN.finditer(source, re.MULTILINE)]

-def parse_vapi_functions(vapi):
+def parse_vapi_functions(vapi) -> List[ApiFunction]:
    return [ApiFunction(m.group(1), m.group(0)) for m in re.finditer(r"^\tpublic static .+ (\w+) \(.+;", vapi, re.MULTILINE)]

+@dataclass
 class ApiSpec:
-    def __init__(self, version, object_types, functions, enum_types, error_types):
-        self.version = version
-        self.object_types = object_types
-        self.functions = functions
-        self.enum_types = enum_types
-        self.error_types = error_types
+    frida_version: str
+    frida_version_components: List[int]
+    version: str
+    object_types: List[ApiObjectType]
+    functions: List[ApiFunction]
+    enum_types: List[ApiEnum]
+    error_types: List[ApiEnum]

 class ApiEnum:
    def __init__(self, name):
@@ -512,6 +630,23 @@ def fuzzysort(items, keys):
    result.extend(remaining)
    return result

+class OutputFile:
+    def __init__(self, output_path):
+        self._output_path = output_path
+        self._io = StringIO()
+
+    def __enter__(self):
+        return self._io
+
+    def __exit__(self, *exc):
+        result = self._io.getvalue()
+        if self._output_path.exists():
+            existing_contents = self._output_path.read_text(encoding='utf-8')
+            if existing_contents == result:
+                return False
+        self._output_path.write_text(result, encoding='utf-8')
+        return False
+

 if __name__ == '__main__':
    main()
@@ -1,55 +1,50 @@
+fs = import('fs')
+
 generate_api = [python, files('generate.py')]

 generate_api_args = [
+  frida_version,
+  frida_major_version.to_string(),
+  frida_minor_version.to_string(),
+  frida_micro_version.to_string(),
+  frida_nano_version.to_string(),
  api_version,
+  core_build_dir / 'frida-core.h',
  core_build_dir / core_gir_name,
  core_build_dir / 'frida-core.vapi',
-  core_build_dir / 'frida-core.h',
-  base_build_dir / f'frida-base-@[email protected]',
  base_build_dir / 'frida-base.h',
+  base_build_dir / base_gir_name,
+  base_build_dir / f'frida-base-@[email protected]',
  meson.current_build_dir(),
 ]

-core_public_h = custom_target('frida-core-header',
-  input: [core, base],
-  output: ['frida-core.h'],
-  command: [
-    generate_api,
-    '--output=header',
-    generate_api_args,
-  ],
-  install: true,
-  install_dir: header_install_dir,
-)
-
-core_public_gir = custom_target('frida-core-gir',
-  input: [core, base],
-  output: [core_gir_name],
-  command: [
-    generate_api,
-    '--output=gir',
-    generate_api_args,
-  ],
-  install: true,
-  install_dir: girdir,
-)
-
-core_public_vapi = custom_target('frida-core-vapi',
+core_api = custom_target('frida-core-api',
  input: [core, base],
  output: [
+    'frida-core.h',
+    core_gir_name,
    f'frida-core-@[email protected]',
    f'frida-core-@[email protected]',
  ],
  command: [
    generate_api,
-    '--output=vapi',
+    '--output=bundle',
    generate_api_args,
  ],
  install: true,
-  install_dir: vapidir,
+  install_dir: [header_install_dir, girdir, vapidir, vapidir],
 )

-core_public_vapi_stamp =  custom_target('frida-core-vapi-stamp',
+core_public_h = core_api[0]
+core_public_gir = core_api[1]
+core_public_vapi = [core_api[2], core_api[3]]
+
+install_glib_girs = not gi_dep.found() and not fs.exists(girdir / 'GLib-2.0.gir')
+glib_gir = fs.copyfile('GLib-2.0.gir', install: install_glib_girs, install_dir: girdir)
+gobject_gir = fs.copyfile('GObject-2.0.gir', install: install_glib_girs, install_dir: girdir)
+gio_gir = fs.copyfile('Gio-2.0.gir', install: install_glib_girs, install_dir: girdir)
+
+core_public_vapi_stamp = custom_target('frida-core-vapi-stamp',
  input: core_public_vapi,
  output: f'frida-core-@[email protected]',
  command: [
@@ -76,8 +71,6 @@ core_public_lib = custom_target('frida-core-library',
  install_dir: get_option('libdir'),
 )

-fs = import('fs')
-
 core_public_extra_headers = []
 if host_os == 'android'
  core_public_extra_headers += fs.copyfile(frida_selinux_h)
@@ -88,19 +81,28 @@ if build_machine.system() == 'windows'
 else
  uninstalled_incdir = meson.current_build_dir()
 endif
+uninstalled_girdir = uninstalled_incdir
 uninstalled_vapidir = uninstalled_incdir

+uninstalled_variables = {
+  'frida_includedir': uninstalled_incdir,
+  'frida_girdir': uninstalled_girdir,
+  'frida_vapidir': uninstalled_vapidir,
+}
+
+installed_variables = {
+  'frida_includedir': '${includedir}',
+  'frida_girdir': girdir,
+  'frida_vapidir': vapidir,
+}
+
 core_public_dep = declare_dependency(
-  sources: [core_public_h, core_public_gir, core_public_vapi_stamp, core_public_extra_headers],
+  sources: [core_public_h, core_public_gir, glib_gir, gobject_gir, gio_gir, core_public_vapi_stamp, core_public_extra_headers],
  include_directories: include_directories('.'),
  link_args: backend_libs_private,
  link_with: core_public_lib,
  dependencies: core_deps,
-  variables: {
-    'frida_includedir': uninstalled_incdir,
-    'frida_girdir': uninstalled_girdir,
-    'frida_vapidir': uninstalled_vapidir,
-  },
+  variables: uninstalled_variables,
 )

 pkg = import('pkgconfig')
@@ -115,16 +117,8 @@ pkg.generate(
  libraries: core_public_lib,
  libraries_private: backend_libs_private,
  extra_cflags: ['-I${frida_includedir}'],
-  variables: {
-    'frida_includedir': '${includedir}',
-    'frida_girdir': girdir,
-    'frida_vapidir': vapidir,
-  },
-  uninstalled_variables: {
-    'frida_includedir': uninstalled_incdir,
-    'frida_girdir': uninstalled_girdir,
-    'frida_vapidir': uninstalled_vapidir,
-  },
+  variables: installed_variables,
+  uninstalled_variables: uninstalled_variables,
 )

 meson.override_dependency(f'frida-core-@api_version@', core_public_dep)
@@ -14,59 +14,79 @@ namespace Frida.Barebone {
 			get;
 		}

+		public abstract size_t size {
+			get;
+		}
+
 		public abstract async void deallocate (Cancellable? cancellable) throws Error, IOError;
 	}

-	public class SimpleAllocator : Object, Allocator {
+	public sealed class NullAllocator : Object, Allocator {
 		public size_t page_size {
-			get { return _page_size; }
+			get {
+				return _page_size;
+			}
+		}
+
+		private size_t _page_size;
+
+		public NullAllocator (size_t page_size) {
+			this._page_size = page_size;
+		}
+
+		public async Allocation allocate (size_t size, size_t alignment, Cancellable? cancellable) throws Error, IOError {
+			throw new Error.NOT_SUPPORTED ("To enable this feature, specify an allocator in your FRIDA_BAREBONE_CONFIG");
+		}
+	}
+
+	public sealed class PhysicalAllocator : Object, Allocator {
+		public size_t page_size {
+			get {
+				return _page_size;
+			}
 		}

 		private Machine machine;
 		private size_t _page_size;
-		private uint64 base_pa;

 		private uint64 cursor;

-		public SimpleAllocator (Machine machine, size_t page_size, uint64 base_pa) {
+		public PhysicalAllocator (Machine machine, size_t page_size, PhysicalAllocatorConfig config) {
 			this.machine = machine;
 			this._page_size = page_size;
-			this.base_pa = base_pa;
-			this.cursor = base_pa;
+			this.cursor = config.physical_base;
 		}

 		public async Allocation allocate (size_t size, size_t alignment, Cancellable? cancellable) throws Error, IOError {
-			if (base_pa == 0) {
-				uint64 example_base;
-				if ("corellium" in machine.gdb.features)
-					example_base = 0x0800000000 + ((2048 - 3) * 1024 * 1024);
-				else
-					example_base = 0x0040000000 + (128 * 1024 * 1024);
-				throw new Error.NOT_SUPPORTED ("To enable this feature, set FRIDA_BAREBONE_HEAP_BASE to the physical " +
-					"base address to use, e.g. 0x%" + uint64.FORMAT_MODIFIER + "x", example_base);
-			}
-
 			uint64 address_pa = cursor;

-			size_t vm_size = round_size_up (size, page_size);
+			size_t vm_size = round_size_up (size, _page_size);
 			cursor += vm_size;

-			uint num_pages = (uint) (vm_size / page_size);
+			uint num_pages = (uint) (vm_size / _page_size);

 			Allocation page_allocation = yield machine.allocate_pages (address_pa, num_pages, cancellable);

-			return new SimpleAllocation (page_allocation);
+			return new PhysicalAllocation (page_allocation);
 		}

-		private class SimpleAllocation : Object, Allocation {
+		private class PhysicalAllocation : Object, Allocation {
 			public uint64 virtual_address {
-				get { return page_allocation.virtual_address; }
+				get {
+					return page_allocation.virtual_address;
+				}
+			}
+
+			public size_t size {
+				get {
+					return page_allocation.size;
+				}
 			}

 			private Allocation page_allocation;

-			public SimpleAllocation (Allocation page_allocation) {
-				this.page_allocation = page_allocation;
+			public PhysicalAllocation (Allocation allocation) {
+				page_allocation = allocation;
 			}

 			public async void deallocate (Cancellable? cancellable) throws Error, IOError {
@@ -75,4 +95,60 @@ namespace Frida.Barebone {
 			}
 		}
 	}
+
+	public sealed class TargetFunctionsAllocator : Object, Allocator {
+		public size_t page_size {
+			get {
+				return _page_size;
+			}
+		}
+
+		private Machine machine;
+		private size_t _page_size;
+		private TargetFunctionsAllocatorConfig config;
+
+		public TargetFunctionsAllocator (Machine machine, size_t page_size, TargetFunctionsAllocatorConfig config) {
+			this.machine = machine;
+			this._page_size = page_size;
+			this.config = config;
+		}
+
+		public async Allocation allocate (size_t size, size_t alignment, Cancellable? cancellable) throws Error, IOError {
+			uint64 address = yield machine.invoke (config.alloc_function, { size }, cancellable);
+
+			// TODO: Handle alignment.
+
+			return new TargetAllocation (address, size, machine, config);
+		}
+
+		private class TargetAllocation : Object, Allocation {
+			public uint64 virtual_address {
+				get {
+					return _virtual_address;
+				}
+			}
+
+			public size_t size {
+				get {
+					return _size;
+				}
+			}
+
+			private uint64 _virtual_address;
+			public size_t _size;
+			private Machine machine;
+			private TargetFunctionsAllocatorConfig config;
+
+			public TargetAllocation (uint64 address, size_t size, Machine m, TargetFunctionsAllocatorConfig c) {
+				_virtual_address = address;
+				_size = size;
+				machine = m;
+				config = c;
+			}
+
+			public async void deallocate (Cancellable? cancellable) throws Error, IOError {
+				yield machine.invoke (config.free_function, { _virtual_address, size }, cancellable);
+			}
+		}
+	}
 }
@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class ArmMachine : Object, Machine {
+	public sealed class ArmMachine : Object, Machine {
 		public override GDB.Client gdb {
 			get;
 			set;
@@ -36,6 +36,11 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

+		public async void protect_pages (uint64 virtual_address, size_t size, Gum.PageProtection prot,
+				Cancellable? cancellable) throws Error, IOError {
+			throw_not_supported ();
+		}
+
 		public async Gee.List<uint64?> scan_ranges (Gee.List<Gum.MemoryRange?> ranges, MatchPattern pattern, uint max_matches,
 				Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
@@ -45,8 +50,7 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

-		public async uint64 invoke (uint64 impl, uint64[] args, uint64 landing_zone, Cancellable? cancellable)
-				throws Error, IOError {
+		public async uint64 invoke (uint64 impl, uint64[] args, Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
 		}

@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class Arm64Machine : Object, Machine {
+	public sealed class Arm64Machine : Object, Machine {
 		public override GDB.Client gdb {
 			get;
 			set;
@@ -25,6 +25,13 @@ namespace Frida.Barebone {
 		private const uint64 INT6_MASK = 0x3fULL;
 		private const uint64 INT48_MASK = 0xffffffffffffULL;

+		private const uint64 TABLE_PXN_BIT = 1ULL << 59;
+
+		private const uint64 UXN_BIT = 1ULL << 54;
+		private const uint64 PXN_BIT = 1ULL << 53;
+		private const uint64 AP1_BIT = 1ULL << 7;
+		private const uint64 AP0_BIT = 1ULL << 6;
+
 		public Arm64Machine (GDB.Client gdb) {
 			Object (gdb: gdb);
 		}
@@ -55,7 +62,7 @@ namespace Frida.Barebone {

 			yield set_addressing_mode (gdb, PHYSICAL, cancellable);
 			try {
-				yield collect_ranges_in_table (p.tt1, p.first_level, p.upper_bits, p.granule, result, cancellable);
+				yield collect_ranges_in_table (p.tt1, p.first_level, p.upper_bits, p, result, cancellable);
 			} finally {
 				set_addressing_mode.begin (gdb, VIRTUAL, null);
 			}
@@ -63,30 +70,30 @@ namespace Frida.Barebone {
 			return result;
 		}

-		private async void collect_ranges_in_table (uint64 table_address, uint level, uint64 upper_bits, Granule granule,
+		private async void collect_ranges_in_table (uint64 table_address, uint level, uint64 upper_bits, MMUParameters p,
 				Gee.List<RangeDetails> ranges, Cancellable? cancellable) throws Error, IOError {
-			uint max_entries = compute_max_entries (level, granule);
+			uint max_entries = compute_max_entries (level, p);
 			Buffer entries = yield gdb.read_buffer (table_address, max_entries * Descriptor.SIZE, cancellable);
-			uint shift = address_shift_at_level (level, granule);
+			uint shift = address_shift_at_level (level, p.granule);
 			for (uint i = 0; i != max_entries; i++) {
 				uint64 raw_descriptor = entries.read_uint64 (i * Descriptor.SIZE);

-				Descriptor desc = Descriptor.parse (raw_descriptor, level, granule);
+				Descriptor desc = Descriptor.parse (raw_descriptor, level, p.granule);
 				if (desc.kind == INVALID)
 					continue;

 				uint64 address = upper_bits | ((uint64) i << shift);

 				if (desc.kind == BLOCK) {
-					size_t size = 1 << num_block_bits_at_level (level, granule);
-					Gum.PageProtection prot = protection_from_flags (desc.flags);
+					size_t size = 1 << num_block_bits_at_level (level, p.granule);
+					Gum.PageProtection prot = protection_from_flags (desc.flags, p);

 					ranges.add (new RangeDetails (address, desc.target_address, size, prot, MappingType.UNKNOWN));

 					continue;
 				}

-				yield collect_ranges_in_table (desc.target_address, level + 1, address, granule, ranges, cancellable);
+				yield collect_ranges_in_table (desc.target_address, level + 1, address, p, ranges, cancellable);
 			}
 		}

@@ -152,9 +159,10 @@ namespace Frida.Barebone {
 			yield set_addressing_mode (gdb, PHYSICAL, cancellable);
 			try {
 				Allocation? allocation = yield maybe_insert_descriptor_in_table (physical_address, num_pages, p.tt1,
-					p.first_level, p.upper_bits, p.granule, cancellable);
+					p.first_level, p.upper_bits, p, cancellable);
 				if (allocation == null)
 					throw new Error.NOT_SUPPORTED ("Unable to insert page table mapping; please file a bug");
+
 				return allocation;
 			} finally {
 				set_addressing_mode.begin (gdb, VIRTUAL, null);
@@ -162,10 +170,10 @@ namespace Frida.Barebone {
 		}

 		private async Allocation? maybe_insert_descriptor_in_table (uint64 physical_address, uint num_pages,
-				uint64 table_address, uint level, uint64 upper_bits, Granule granule, Cancellable? cancellable)
+				uint64 table_address, uint level, uint64 upper_bits, MMUParameters p, Cancellable? cancellable)
 				throws Error, IOError {
-			uint max_entries = compute_max_entries (level, granule);
-			uint shift = address_shift_at_level (level, granule);
+			uint max_entries = compute_max_entries (level, p);
+			uint shift = address_shift_at_level (level, p.granule);

 			uint64 first_available_va = 0;
 			uint64 first_available_slot = 0;
@@ -184,13 +192,15 @@ namespace Frida.Barebone {
 					uint table_index = chunk_offset + i;
 					uint64 address = upper_bits | ((uint64) table_index << shift);

-					Descriptor desc = Descriptor.parse (raw_descriptor, level, granule);
+					Descriptor desc = Descriptor.parse (raw_descriptor, level, p.granule);

 					if (level < 3) {
 						if (desc.kind != TABLE)
 							continue;
+						if ((desc.flags & DescriptorFlags.PXNTABLE) != 0)
+							continue;
 						Allocation? allocation = yield maybe_insert_descriptor_in_table (physical_address,
-							num_pages, desc.target_address, level + 1, address, granule, cancellable);
+							num_pages, desc.target_address, level + 1, address, p, cancellable);
 						if (allocation != null)
 							return allocation;
 						continue;
@@ -215,17 +225,197 @@ namespace Frida.Barebone {
 			if (num_available_slots != num_pages)
 				return null;

+			Gum.PageProtection page_prot = Gum.PageProtection.READ | Gum.PageProtection.WRITE;
+			if (!p.sprr_enabled)
+				page_prot |= Gum.PageProtection.EXECUTE;
+
 			var builder = gdb.make_buffer_builder ();
 			for (uint i = 0; i != num_available_slots; i++) {
-				uint64 cur_physical_address = physical_address + (i * granule);
-				uint64 new_descriptor = cur_physical_address | 0x40000000000403ULL;
+				uint64 cur_physical_address = physical_address + (i * p.granule);
+				uint64 base_descriptor = cur_physical_address | 0x403ULL;
+
+				uint64 new_descriptor = apply_protection_bits (base_descriptor, page_prot, p);
+
 				builder.append_uint64 (new_descriptor);
 			}
 			Bytes new_descriptors = builder.build ();
 			Bytes old_descriptors = yield gdb.read_byte_array (first_available_slot, new_descriptors.get_size (), cancellable);
 			yield gdb.write_byte_array (first_available_slot, new_descriptors, cancellable);

-			return new DescriptorAllocation (first_available_va, first_available_slot, old_descriptors, gdb);
+			size_t size = num_pages * p.granule;
+			return new DescriptorAllocation (first_available_va, size, first_available_slot, old_descriptors, gdb);
+		}
+
+		public async void protect_pages (uint64 virtual_address, size_t size, Gum.PageProtection prot, Cancellable? cancellable)
+				throws Error, IOError {
+			MMUParameters p = yield MMUParameters.load (gdb, cancellable);
+
+			yield set_addressing_mode (gdb, PHYSICAL, cancellable);
+			try {
+				uint64 page_mask = p.granule - 1;
+				uint64 aligned_va = virtual_address & ~page_mask;
+				uint64 aligned_end = (virtual_address + size + page_mask) & ~page_mask;
+				uint num_pages = (uint) ((aligned_end - aligned_va) / p.granule);
+
+				yield perform_protect_pages (aligned_va, num_pages, prot, p, cancellable);
+			} finally {
+				set_addressing_mode.begin (gdb, VIRTUAL, null);
+			}
+		}
+
+		private async void perform_protect_pages (uint64 start_va, uint num_pages, Gum.PageProtection prot, MMUParameters p,
+				Cancellable? cancellable) throws Error, IOError {
+			var table_cache = new TableWalkCache ();
+			uint pages_processed = 0;
+
+			var processed_tables = new Gee.HashSet<uint64?> (Numeric.uint64_hash, Numeric.uint64_equal);
+			bool need_exec = (prot & Gum.PageProtection.EXECUTE) != 0;
+
+			while (pages_processed != num_pages) {
+				uint64 current_va = start_va + (uint64) pages_processed * p.granule;
+
+				uint64 table_pa = yield find_level3_table (current_va, p, table_cache, cancellable);
+
+				if (need_exec && !processed_tables.contains (table_pa)) {
+					yield clear_pxn_table_bits_for_va (current_va, p, table_cache, cancellable);
+					processed_tables.add (table_pa);
+				}
+
+				uint level3_shift = address_shift_at_level (3, p.granule);
+				uint64 level3_mask = (1ULL << level3_shift) - 1;
+				uint64 table_base_va = current_va & ~level3_mask;
+				uint64 table_end_va = table_base_va + (1ULL << level3_shift);
+				uint64 remaining_va = start_va + num_pages * p.granule;
+				uint64 batch_end_va = uint64.min (remaining_va, table_end_va);
+				uint batch_size = (uint) ((batch_end_va - current_va) / p.granule);
+
+				yield protect_pages_in_table (current_va, batch_size, prot, table_pa, p, cancellable);
+
+				pages_processed += batch_size;
+			}
+		}
+
+		private async void protect_pages_in_table (uint64 current_va, uint batch_size, Gum.PageProtection prot,
+				uint64 table_pa, MMUParameters p, Cancellable? cancellable) throws Error, IOError {
+			uint index_bits = num_address_bits_at_level (3, p);
+			uint index_shift = inpage_bits_for_granule (p.granule);
+			uint index_mask = (1U << index_bits) - 1;
+
+			uint64 first_index = (current_va >> index_shift) & index_mask;
+			uint64 first_slot_pa = table_pa + (first_index * Descriptor.SIZE);
+
+			Buffer descriptors = yield gdb.read_buffer (first_slot_pa, batch_size * Descriptor.SIZE, cancellable);
+
+			bool any_changed = false;
+			for (uint i = 0; i != batch_size; i++) {
+				uint64 raw_desc = descriptors.read_uint64 (i * Descriptor.SIZE);
+				uint64 new_desc = apply_protection_bits (raw_desc, prot, p);
+
+				if (new_desc != raw_desc) {
+					descriptors.write_uint64 (i * Descriptor.SIZE, new_desc);
+					any_changed = true;
+				}
+			}
+
+			if (any_changed)
+				yield gdb.write_byte_array (first_slot_pa, descriptors.bytes, cancellable);
+		}
+
+		private async uint64 find_level3_table (uint64 va, MMUParameters p, TableWalkCache cache, Cancellable? cancellable)
+				throws Error, IOError {
+			TableWalkResult? cached = cache.lookup (va, p);
+			if (cached != null)
+				return yield walk_to_level3 (va, cached.table_pa, cached.level, p, cache, cancellable);
+
+			return yield walk_to_level3 (va, p.tt1, p.first_level, p, cache, cancellable);
+		}
+
+		private async uint64 walk_to_level3 (uint64 va, uint64 start_table_pa, uint start_level, MMUParameters p,
+				TableWalkCache cache, Cancellable? cancellable) throws Error, IOError {
+			uint64 table_pa = start_table_pa;
+			uint level = start_level;
+
+			while (level != 3) {
+				cache.store (va, level, table_pa, p);
+
+				uint shift = address_shift_at_level (level, p.granule);
+				uint entries = compute_max_entries (level, p);
+				uint index = (uint) ((va >> shift) & (entries - 1));
+				uint64 slot_pa = table_pa + ((uint64) index * Descriptor.SIZE);
+
+				Buffer d_buf = yield gdb.read_buffer (slot_pa, Descriptor.SIZE, cancellable);
+				uint64 raw = d_buf.read_uint64 (0);
+				Descriptor desc = Descriptor.parse (raw, level, p.granule);
+
+				if (desc.kind != TABLE)
+					throw new Error.NOT_SUPPORTED ("Walk failed at level %u", level);
+
+				table_pa = desc.target_address;
+				level++;
+			}
+
+			return table_pa;
+		}
+
+		private async void clear_pxn_table_bits_for_va (uint64 va, MMUParameters p, TableWalkCache cache, Cancellable? cancellable)
+				throws Error, IOError {
+			uint64 table_pa = p.tt1;
+			for (uint level = p.first_level; level != 3; level++) {
+				uint entries = compute_max_entries (level, p);
+				uint shift = address_shift_at_level (level, p.granule);
+				uint index = (uint) ((va >> shift) & (entries - 1));
+				uint64 slot_pa = table_pa + (index * Descriptor.SIZE);
+
+				Buffer d_buf = yield gdb.read_buffer (slot_pa, Descriptor.SIZE, cancellable);
+				uint64 raw_desc = d_buf.read_uint64 (0);
+				Descriptor desc = Descriptor.parse (raw_desc, level, p.granule);
+				if (desc.kind != TABLE)
+					break;
+
+				if ((raw_desc & TABLE_PXN_BIT) != 0) {
+					uint64 new_desc = raw_desc & ~TABLE_PXN_BIT;
+					d_buf.write_uint64 (0, new_desc);
+					yield gdb.write_byte_array (slot_pa, d_buf.bytes, cancellable);
+				}
+
+				table_pa = desc.target_address;
+			}
+		}
+
+		private class TableWalkCache {
+			private Gee.Map<uint64?, TableWalkResult> cache =
+				new Gee.HashMap<uint64?, TableWalkResult> (Numeric.uint64_hash, Numeric.uint64_equal);
+
+			public TableWalkResult? lookup (uint64 va, MMUParameters p) {
+				for (int level = 2; level >= (int) p.first_level; level--) {
+					uint64 cache_key = compute_cache_key (va, (uint) level, p);
+					TableWalkResult? result = cache[cache_key];
+					if (result != null)
+						return result;
+				}
+				return null;
+			}
+
+			public void store (uint64 va, uint level, uint64 table_pa, MMUParameters p) {
+				if (level >= 3)
+					return;
+
+				uint64 cache_key = compute_cache_key (va, level, p);
+				cache[cache_key] = new TableWalkResult () {
+					table_pa = table_pa,
+					level = level
+				};
+			}
+
+			private uint64 compute_cache_key (uint64 va, uint level, MMUParameters p) {
+				uint shift = address_shift_at_level (level + 1, p.granule);
+				return (va >> shift) << shift;
+			}
+		}
+
+		private class TableWalkResult {
+			public uint64 table_pa;
+			public uint level;
 		}

 		public async Gee.List<uint64?> scan_ranges (Gee.List<Gum.MemoryRange?> ranges, MatchPattern pattern, uint max_matches,
@@ -354,14 +544,17 @@ namespace Frida.Barebone {
 				case ABS64:
 					relocated.write_uint64 ((size_t) r.address, base_va + r.symbol.address + r.addend);
 					break;
+				case PREL32:
+					var diff = (int64) (base_va + r.symbol.address + r.addend) - (int64) (base_va + r.address);
+					relocated.write_int32 ((size_t) r.address, (int32) diff);
+					break;
 				default:
 					throw new Error.NOT_SUPPORTED ("Unsupported relocation type: %s",
 						Marshal.enum_to_nick<Gum.ElfArm64Relocation> (type));
 			}
 		}

-		public async uint64 invoke (uint64 impl, uint64[] args, uint64 landing_zone, Cancellable? cancellable)
-				throws Error, IOError {
+		public async uint64 invoke (uint64 impl, uint64[] args, Cancellable? cancellable) throws Error, IOError {
 			if (args.length > 8)
 				throw new Error.NOT_SUPPORTED ("Unsupported number of arguments; please open a PR");

@@ -377,6 +570,7 @@ namespace Frida.Barebone {

 			regs["pc"] = impl;

+			uint64 landing_zone = saved_regs["pc"].get_uint64 ();
 			regs["x30"] = landing_zone;

 			uint64 sp = saved_regs["sp"].get_uint64 ();
@@ -406,6 +600,35 @@ namespace Frida.Barebone {
 			return retval;
 		}

+		public async void execute (uint64 start, uint64 end, Cancellable? cancellable) throws Error, IOError {
+			bool was_running = gdb.state != STOPPED;
+			if (was_running)
+				yield gdb.stop (cancellable);
+
+			GDB.Thread thread = gdb.exception.thread;
+			Gee.Map<string, Variant> saved_regs = yield thread.read_registers (cancellable);
+
+			var regs = new Gee.HashMap<string, Variant> ();
+			regs.set_all (saved_regs);
+
+			regs["pc"] = start;
+
+			yield thread.write_registers (regs, cancellable);
+
+			GDB.Breakpoint bp = yield gdb.add_breakpoint (SOFT, end, 4, cancellable);
+			GDB.Exception ex = null;
+			do {
+				ex = yield gdb.continue_until_exception (cancellable);
+			} while (ex.breakpoint != bp || ex.thread.id != thread.id);
+			// TODO: Improve GDB.Client to guarantee a single GDB.Thread instance per ID.
+			yield bp.remove (cancellable);
+
+			yield thread.write_registers (saved_regs, cancellable);
+
+			if (was_running)
+				yield gdb.continue (cancellable);
+		}
+
 		public async CallFrame load_call_frame (GDB.Thread thread, uint arity, Cancellable? cancellable) throws Error, IOError {
 			var regs = yield thread.read_registers (cancellable);

@@ -689,6 +912,10 @@ namespace Frida.Barebone {
 			public uint first_level;
 			public uint64 upper_bits;
 			public uint64 tt1;
+			public uint t1sz;
+
+			public bool sprr_enabled;
+			public uint64 sprr_perm;

 			public static async MMUParameters load (GDB.Client gdb, Cancellable? cancellable) throws Error, IOError {
 				GDB.Exception? exception = gdb.exception;
@@ -716,6 +943,10 @@ namespace Frida.Barebone {
 					parameters.upper_bits |= 1ULL << (63 - i);

 				parameters.tt1 = regs.ttbr1 & INT48_MASK;
+				parameters.t1sz = t1sz;
+
+				parameters.sprr_enabled = (regs.sprr_config & 1) != 0;
+				parameters.sprr_perm = regs.sprr_perm;

 				return parameters;
 			}
@@ -724,6 +955,8 @@ namespace Frida.Barebone {
 		private class MMURegisters {
 			public uint64 tcr;
 			public uint64 ttbr1;
+			public uint64 sprr_config;
+			public uint64 sprr_perm;

 			public static async MMURegisters read (GDB.Thread thread, Cancellable? cancellable) throws Error, IOError {
 				var regs = new MMURegisters ();
@@ -741,10 +974,19 @@ namespace Frida.Barebone {
 							regs.tcr = val;
 						else if (name == "ttbr1_el1")
 							regs.ttbr1 = val;
+						else if (name == "sprr_config_el1")
+							regs.sprr_config = val;
+						else if (name == "sprr_el1br1_el1")
+							regs.sprr_perm = val;
 					}
 				} else {
 					regs.tcr = yield thread.read_register ("tcr_el1", cancellable);
 					regs.ttbr1 = yield thread.read_register ("ttbr1_el1", cancellable);
+					try {
+						regs.sprr_config = yield thread.read_register ("sprr_config_el1", cancellable);
+						regs.sprr_perm = yield thread.read_register ("sprr_el1br1_el1", cancellable);
+					} catch (Error e) {
+					}
 				}

 				return regs;
@@ -850,16 +1092,27 @@ namespace Frida.Barebone {

 		private class DescriptorAllocation : Object, Allocation {
 			public uint64 virtual_address {
-				get { return base_va; }
+				get {
+					return base_va;
+				}
+			}
+
+			public size_t size {
+				get {
+					return _size;
+				}
 			}

 			private uint64 base_va;
+			private size_t _size;
 			private uint64 first_slot;
 			private Bytes? old_descriptors;
 			private GDB.Client gdb;

-			public DescriptorAllocation (uint64 base_va, uint64 first_slot, Bytes old_descriptors, GDB.Client gdb) {
+			public DescriptorAllocation (uint64 base_va, size_t size, uint64 first_slot, Bytes old_descriptors,
+					GDB.Client gdb) {
 				this.base_va = base_va;
+				this._size = size;
 				this.first_slot = first_slot;
 				this.old_descriptors = old_descriptors;
 				this.gdb = gdb;
@@ -908,11 +1161,23 @@ namespace Frida.Barebone {
 			assert_not_reached ();
 		}

-		private static uint compute_max_entries (uint level, Granule granule) {
-			return 1 << num_address_bits_at_level (level, granule);
+		private static uint compute_max_entries (uint level, MMUParameters p) {
+			return 1 << num_address_bits_at_level (level, p);
 		}

-		private static uint num_address_bits_at_level (uint level, Granule granule) {
+		private static uint num_address_bits_at_level (uint level, MMUParameters p) {
+			if (level == p.first_level) {
+				uint available_address_bits = 64 - p.t1sz - inpage_bits_for_granule (p.granule);
+				uint consumed_by_lower_levels = 0;
+				for (uint l = level + 1; l <= 3; l++)
+					consumed_by_lower_levels += unclipped_address_bits_at_level (l, p.granule);
+				return available_address_bits - consumed_by_lower_levels;
+			} else {
+				return unclipped_address_bits_at_level (level, p.granule);
+			}
+		}
+
+		private static uint unclipped_address_bits_at_level (uint level, Granule granule) {
 			switch (granule) {
 				case 4K:
 					return 9;
@@ -932,7 +1197,7 @@ namespace Frida.Barebone {
 		private static uint address_shift_at_level (uint level, Granule granule) {
 			uint shift = inpage_bits_for_granule (granule);
 			for (int l = 2; l != (int) level - 1; l--)
-				shift += num_address_bits_at_level (l, granule);
+				shift += unclipped_address_bits_at_level (l, granule);
 			return shift;
 		}

@@ -949,7 +1214,45 @@ namespace Frida.Barebone {
 			}
 		}

-		private static Gum.PageProtection protection_from_flags (DescriptorFlags flags) {
+		private static Gum.PageProtection protection_from_flags (DescriptorFlags flags, MMUParameters p) {
+			if (p.sprr_enabled) {
+				uint idx = 0;
+				if ((flags & DescriptorFlags.AP_READ_ONLY) != 0)
+					idx |= 1 << 3;
+				if ((flags & DescriptorFlags.AP_ALLOW_APPLICATION) != 0)
+					idx |= 1 << 2;
+				if ((flags & DescriptorFlags.UXN) != 0)
+					idx |= 1 << 1;
+				if ((flags & DescriptorFlags.PXN) != 0)
+					idx |= 1 << 0;
+
+				uint perm = (uint) ((p.sprr_perm >> (idx * 4)) & 0xf);
+
+				Gum.PageProtection prot;
+				switch (perm & 3) {
+					case 0:
+						prot = 0;
+						break;
+					case 1:
+						prot = READ | EXECUTE;
+						if ((perm >> 2) == 2)
+							prot = EXECUTE;
+						break;
+					case 2:
+						prot = READ;
+						break;
+					case 3:
+						prot = READ | WRITE;
+						if ((perm >> 2) == 1)
+							prot = 0;
+						break;
+					default:
+						assert_not_reached ();
+				}
+
+				return prot;
+			}
+
 			Gum.PageProtection prot = READ;
 			if ((flags & DescriptorFlags.PXN) == 0)
 				prot |= EXECUTE;
@@ -958,6 +1261,93 @@ namespace Frida.Barebone {
 			return prot;
 		}

+		private static uint64 apply_protection_bits (uint64 descriptor, Gum.PageProtection prot, MMUParameters p) throws Error {
+			uint64 result = descriptor;
+
+			if (p.sprr_enabled) {
+				uint target_sprr_index = find_sprr_index_for_permissions (prot, p);
+				result = apply_sprr_index_to_descriptor (result, target_sprr_index);
+			} else {
+				result = apply_non_sprr_protection_bits (result, prot);
+			}
+
+			return result;
+		}
+
+		private static uint64 apply_non_sprr_protection_bits (uint64 descriptor, Gum.PageProtection prot) {
+			uint64 result = descriptor;
+
+			bool want_exec = (prot & Gum.PageProtection.EXECUTE) != 0;
+			bool want_write = (prot & Gum.PageProtection.WRITE) != 0;
+
+			if (want_exec)
+				result &= ~(UXN_BIT | PXN_BIT);
+			else
+				result |= (UXN_BIT | PXN_BIT);
+
+			if (want_write) {
+				result &= ~(AP1_BIT | AP0_BIT);
+			} else {
+				result |= AP1_BIT;
+				result &= ~AP0_BIT;
+			}
+
+			return result;
+		}
+
+		private static uint find_sprr_index_for_permissions (Gum.PageProtection prot, MMUParameters p) throws Error {
+			bool want_read = (prot & Gum.PageProtection.READ) != 0;
+			bool want_write = (prot & Gum.PageProtection.WRITE) != 0;
+			bool want_exec = (prot & Gum.PageProtection.EXECUTE) != 0;
+
+			for (uint i = 0; i != 16; i++) {
+				uint perm = (uint) ((p.sprr_perm >> (i * 4)) & 0xf);
+
+				bool slot_allows_read = false;
+				bool slot_allows_write = false;
+				bool slot_allows_exec = false;
+
+				switch (perm & 3) {
+					case 0:
+						break;
+					case 1:
+						slot_allows_exec = true;
+						if ((perm >> 2) != 2)
+							slot_allows_read = true;
+						break;
+					case 2:
+						slot_allows_read = true;
+						break;
+					case 3:
+						slot_allows_read = true;
+						slot_allows_write = ((perm >> 2) != 1);
+						break;
+				}
+
+				if (slot_allows_read == want_read && slot_allows_write == want_write && slot_allows_exec == want_exec)
+					return i;
+			}
+
+			throw new Error.INVALID_ARGUMENT ("No suitable SPRR slot found for protection 0x%x", prot);
+		}
+
+		private static uint64 apply_sprr_index_to_descriptor (uint64 descriptor, uint sprr_index) {
+			uint64 result = descriptor;
+
+			result &= ~(AP1_BIT | AP0_BIT | UXN_BIT | PXN_BIT);
+
+			if ((sprr_index & 0x8) != 0)
+				result |= AP1_BIT;
+			if ((sprr_index & 0x4) != 0)
+				result |= AP0_BIT;
+			if ((sprr_index & 0x2) != 0)
+				result |= UXN_BIT;
+			if ((sprr_index & 0x1) != 0)
+				result |= PXN_BIT;
+
+			return result;
+		}
+
 		private static Gum.PageProtection protection_from_corellium_pt_details (string details) {
 			Gum.PageProtection prot = READ;
 			if (!("pXN" in details))
@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class UnknownMachine : Object, Machine {
+	public sealed class UnknownMachine : Object, Machine {
 		public GDB.Client gdb {
 			get;
 			set;
@@ -31,6 +31,11 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

+		public async void protect_pages (uint64 virtual_address, size_t size, Gum.PageProtection prot,
+				Cancellable? cancellable) throws Error, IOError {
+			throw_not_supported ();
+		}
+
 		public async Gee.List<uint64?> scan_ranges (Gee.List<Gum.MemoryRange?> ranges, MatchPattern pattern,
 				uint max_matches, Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
@@ -40,8 +45,7 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

-		public async uint64 invoke (uint64 impl, uint64[] args, uint64 landing_zone, Cancellable? cancellable)
-				throws Error, IOError {
+		public async uint64 invoke (uint64 impl, uint64[] args, Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
 		}

@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class IA32Machine : Object, Machine {
+	public sealed class IA32Machine : Object, Machine {
 		public override GDB.Client gdb {
 			get;
 			set;
@@ -32,6 +32,11 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

+		public async void protect_pages (uint64 virtual_address, size_t size, Gum.PageProtection prot,
+				Cancellable? cancellable) throws Error, IOError {
+			throw_not_supported ();
+		}
+
 		public async Gee.List<uint64?> scan_ranges (Gee.List<Gum.MemoryRange?> ranges, MatchPattern pattern, uint max_matches,
 				Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
@@ -41,8 +46,7 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

-		public async uint64 invoke (uint64 impl, uint64[] args, uint64 landing_zone, Cancellable? cancellable)
-				throws Error, IOError {
+		public async uint64 invoke (uint64 impl, uint64[] args, Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
 		}

@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class X64Machine : Object, Machine {
+	public sealed class X64Machine : Object, Machine {
 		public override GDB.Client gdb {
 			get;
 			set;
@@ -34,6 +34,11 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

+		public async void protect_pages (uint64 virtual_address, size_t size, Gum.PageProtection prot,
+				Cancellable? cancellable) throws Error, IOError {
+			throw_not_supported ();
+		}
+
 		public async Gee.List<uint64?> scan_ranges (Gee.List<Gum.MemoryRange?> ranges, MatchPattern pattern, uint max_matches,
 				Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
@@ -43,8 +48,7 @@ namespace Frida.Barebone {
 			throw_not_supported ();
 		}

-		public async uint64 invoke (uint64 impl, uint64[] args, uint64 landing_zone, Cancellable? cancellable)
-				throws Error, IOError {
+		public async uint64 invoke (uint64 impl, uint64[] args, Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
 		}

@@ -1,27 +1,9 @@
 namespace Frida {
-	public class BareboneHostSessionBackend : Object, HostSessionBackend {
+	public sealed class BareboneHostSessionBackend : Object, HostSessionBackend {
 		private BareboneHostSessionProvider? provider;

-		private const uint16 DEFAULT_PORT = 3333;
-
 		public async void start (Cancellable? cancellable) throws IOError {
-			SocketConnectable? connectable = null;
-			unowned string? address = Environment.get_variable ("FRIDA_BAREBONE_ADDRESS");
-			if (address != null) {
-				try {
-					connectable = NetworkAddress.parse (address, DEFAULT_PORT);
-				} catch (GLib.Error e) {
-				}
-			}
-			if (connectable == null)
-				connectable = new InetSocketAddress (new InetAddress.loopback (SocketFamily.IPV4), DEFAULT_PORT);
-
-			uint64 heap_base_pa = 0;
-			unowned string? heap_base_preference = Environment.get_variable ("FRIDA_BAREBONE_HEAP_BASE");
-			if (heap_base_preference != null)
-				heap_base_pa = uint64.parse (heap_base_preference, 16);
-
-			provider = new BareboneHostSessionProvider (connectable, heap_base_pa);
+			provider = new BareboneHostSessionProvider ();
 			provider_available (provider);
 		}

@@ -30,7 +12,7 @@ namespace Frida {
 		}
 	}

-	public class BareboneHostSessionProvider : Object, HostSessionProvider {
+	public sealed class BareboneHostSessionProvider : Object, HostSessionProvider {
 		public string id {
 			get { return "barebone"; }
 		}
@@ -49,22 +31,8 @@ namespace Frida {
 			}
 		}

-		public SocketConnectable connectable {
-			get;
-			construct;
-		}
-
-		public uint64 heap_base_pa {
-			get;
-			construct;
-		}
-
 		private BareboneHostSession? host_session;

-		public BareboneHostSessionProvider (SocketConnectable connectable, uint64 heap_base_pa) {
-			Object (connectable: connectable, heap_base_pa: heap_base_pa);
-		}
-
 		public async void close (Cancellable? cancellable) throws IOError {
 			if (host_session != null) {
 				yield host_session.close (cancellable);
@@ -76,6 +44,27 @@ namespace Frida {
 			if (host_session != null)
 				throw new Error.INVALID_OPERATION ("Already created");

+			Barebone.Config config;
+			unowned string? config_path = Environment.get_variable ("FRIDA_BAREBONE_CONFIG");
+			if (config_path != null) {
+				try {
+					var config_data = yield FS.read_all_text (File.new_for_path (config_path), cancellable);
+					config = (Barebone.Config) Json.gobject_from_data (typeof (Barebone.Config), config_data);
+				} catch (GLib.Error e) {
+					throw new Error.INVALID_ARGUMENT ("Unable to load %s: %s", config_path, e.message);
+				}
+			} else {
+				config = new Barebone.Config ();
+			}
+
+			SocketConnectable connectable;
+			try {
+				Barebone.ConnectionConfig c = config.connection;
+				connectable = NetworkAddress.parse (c.host, c.port);
+			} catch (GLib.Error e) {
+				throw new Error.INVALID_ARGUMENT ("Unable to load %s: %s", config_path, e.message);
+			}
+
 			IOStream stream;
 			try {
 				var client = new SocketClient ();
@@ -111,8 +100,19 @@ namespace Frida {

 			var page_size = yield machine.query_page_size (cancellable);

-			// TODO: Locate and use kernel's allocator when possible.
-			Barebone.Allocator allocator = new Barebone.SimpleAllocator (machine, page_size, heap_base_pa);
+			Barebone.Allocator allocator;
+			Barebone.AllocatorConfig ac = config.allocator;
+			if (ac is Barebone.NoAllocatorConfig) {
+				allocator = new Barebone.NullAllocator (page_size);
+			} else if (ac is Barebone.PhysicalAllocatorConfig) {
+				allocator = new Barebone.PhysicalAllocator (machine, page_size,
+					(Barebone.PhysicalAllocatorConfig) ac);
+			} else if (ac is Barebone.TargetFunctionsAllocatorConfig) {
+				allocator = new Barebone.TargetFunctionsAllocator (machine, page_size,
+					(Barebone.TargetFunctionsAllocatorConfig) ac);
+			} else {
+				assert_not_reached ();
+			}

 			var interceptor = new Barebone.Interceptor (machine, allocator);

@@ -141,12 +141,35 @@ namespace Frida {
 			return yield this.host_session.link_agent_session (id, sink, cancellable);
 		}

+		public void unlink_agent_session (HostSession host_session, AgentSessionId id) {
+			if (host_session != this.host_session)
+				return;
+
+			this.host_session.unlink_agent_session (id);
+		}
+
+		public async IOStream link_channel (HostSession host_session, ChannelId id, Cancellable? cancellable)
+				throws Error, IOError {
+			throw new Error.NOT_SUPPORTED ("Channels are not supported by this backend");
+		}
+
+		public void unlink_channel (HostSession host_session, ChannelId id) {
+		}
+
+		public async ServiceSession link_service_session (HostSession host_session, ServiceSessionId id, Cancellable? cancellable)
+				throws Error, IOError {
+			throw new Error.NOT_SUPPORTED ("Services are not supported by this backend");
+		}
+
+		public void unlink_service_session (HostSession host_session, ServiceSessionId id) {
+		}
+
 		private void on_agent_session_detached (AgentSessionId id, SessionDetachReason reason, CrashInfo crash) {
 			agent_session_detached (id, reason, crash);
 		}
 	}

-	public class BareboneHostSession : Object, HostSession {
+	public sealed class BareboneHostSession : Object, HostSession {
 		public Barebone.Services services {
 			get;
 			construct;
@@ -260,6 +283,14 @@ namespace Frida {
 			return session;
 		}

+		public void unlink_agent_session (AgentSessionId id) {
+			BareboneAgentSession? session = agent_sessions[id];
+			if (session == null)
+				return;
+
+			session.message_sink = null;
+		}
+
 		public async InjectorPayloadId inject_library_file (uint pid, string path, string entrypoint, string data,
 				Cancellable? cancellable) throws Error, IOError {
 			throw_not_supported ();
@@ -270,6 +301,14 @@ namespace Frida {
 			throw_not_supported ();
 		}

+		public async ChannelId open_channel (string address, Cancellable? cancellable) throws Error, IOError {
+			throw new Error.NOT_SUPPORTED ("Channels are not supported by this backend");
+		}
+
+		public async ServiceSessionId open_service (string address, Cancellable? cancellable) throws Error, IOError {
+			throw new Error.NOT_SUPPORTED ("Services are not supported by this backend");
+		}
+
 		private void on_agent_session_closed (BareboneAgentSession session) {
 			AgentSessionId id = session.id;

@@ -282,7 +321,7 @@ namespace Frida {
 		}
 	}

-	private class BareboneAgentSession : Object, AgentSession {
+	private sealed class BareboneAgentSession : Object, AgentSession {
 		public signal void closed ();

 		public AgentSessionId id {
@@ -426,7 +465,8 @@ namespace Frida {

 		public async void load_script (AgentScriptId script_id, Cancellable? cancellable) throws Error, IOError {
 			check_open ();
-			get_script (script_id).load ();
+			var script = get_script (script_id);
+			yield script.load (cancellable);
 		}

 		public async void eternalize_script (AgentScriptId script_id, Cancellable? cancellable) throws Error, IOError {
@@ -525,7 +565,7 @@ namespace Frida {
 	}

 	namespace Barebone {
-		public class Services : Object {
+		public sealed class Services : Object {
 			public Machine machine {
 				get;
 				construct;
@@ -0,0 +1,63 @@
+[CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
+namespace Frida.Barebone {
+	private sealed class CModule : Object {
+		public signal void console_output (string message);
+
+		public Gee.List<Export> exports {
+			get;
+			default = new Gee.ArrayList<Export> ();
+		}
+
+		public class Export {
+			public string name;
+			public uint64 address;
+
+			internal Export (string name, uint64 address) {
+				this.name = name;
+				this.address = address;
+			}
+		}
+
+		private Gum.ElfModule elf;
+		private Allocation allocation;
+		private Callback console_log_callback;
+
+		public async CModule.from_blob (Bytes blob, Machine machine, Allocator allocator, Cancellable? cancellable)
+				throws Error, IOError {
+			try {
+				elf = new Gum.ElfModule.from_blob (blob);
+			} catch (Gum.Error e) {
+				throw new Error.NOT_SUPPORTED ("%s", e.message);
+			}
+
+			allocation = yield inject_elf (elf, machine, allocator, cancellable);
+
+			uint64 base_va = allocation.virtual_address;
+			uint64 console_log_trap = 0;
+			elf.enumerate_symbols (e => {
+				if (e.name == "")
+					return true;
+
+				if (e.name[0] == '_') {
+					if (e.name == "_console_log")
+						console_log_trap = base_va + e.address;
+					return true;
+				}
+
+				exports.add (new Export (e.name, base_va + e.address));
+
+				return true;
+			});
+
+			if (console_log_trap != 0) {
+				var handler = new ConsoleLogHandler (machine.gdb);
+				handler.output.connect (on_console_output);
+				console_log_callback = yield new Callback (console_log_trap, handler, machine, cancellable);
+			}
+		}
+
+		private void on_console_output (string message) {
+			console_output (message);
+		}
+	}
+}
@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class Callback : Object {
+	public sealed class Callback : Object {
 		private uint64 code;
 		private CallbackHandler handler;
 		private Machine machine;
@@ -0,0 +1,185 @@
+[CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
+namespace Frida.Barebone {
+	/**
+	 * Barebone backend configuration. This is specified via the FRIDA_BAREBONE_CONFIG environment
+	 * variable, which should point to the filesystem path of a JSON-encoded configuration file.
+	 *
+	 * Example JSON configurations:
+	 *
+	 * 1. Using all defaults:
+	 * {
+	 *   "connection": {
+	 *     "host": "127.0.0.1",
+	 *     "port": 3333
+	 *   },
+	 *   "allocator": {
+	 *     "mode": "none"
+	 *   }
+	 * }
+	 *
+	 * 2. Using a physical memory allocator:
+	 *  {
+	 *    "connection": {
+	 *      "host": "127.0.0.1",
+	 *      "port": 9000
+	 *    },
+	 *    "allocator": {
+	 *      "mode": "physical",
+	 *      "physical_base": "0x8ec9b4000"
+	 *    }
+	 *  }
+	 *
+	 * 3. Using target-specific allocation functions:
+	 *  {
+	 *    "connection": {
+	 *      "host": "127.0.0.1",
+	 *      "port": 9000
+	 *    },
+	 *    "allocator": {
+	 *      "mode": "target-functions",
+	 *      "alloc_function": "0xfffffff007a3c278",
+	 *      "free_function": "0xfffffff007a3c338"
+	 *    }
+	 *  }
+	 */
+	public sealed class Config : Object, Json.Serializable {
+		public ConnectionConfig connection {
+			get;
+			set;
+			default = new ConnectionConfig ();
+		}
+
+		public AllocatorConfig allocator {
+			get;
+			set;
+			default = new NoAllocatorConfig ();
+		}
+
+		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
+			if (property_name == "allocator" && property_node.get_node_type () == Json.NodeType.OBJECT) {
+				var obj_node = property_node.get_object ();
+				string? mode = obj_node.get_string_member ("mode");
+
+				Type t = 0;
+				switch (mode) {
+				case "none":
+					t = typeof (NoAllocatorConfig);
+					break;
+				case "physical":
+					t = typeof (PhysicalAllocatorConfig);
+					break;
+				case "target-functions":
+					t = typeof (TargetFunctionsAllocatorConfig);
+					break;
+				default:
+					break;
+				}
+
+				if (t != 0) {
+					var obj = (AllocatorConfig) Json.gobject_deserialize (t, property_node);
+					if (obj != null && obj.is_valid) {
+						var v = Value (t);
+						v.set_object (obj);
+						value = v;
+						return true;
+					}
+				}
+			}
+
+			value = Value (pspec.value_type);
+			return false;
+		}
+	}
+
+	public sealed class ConnectionConfig : Object {
+		public string host {
+			get;
+			set;
+			default = "127.0.0.1";
+		}
+
+		public uint16 port {
+			get;
+			set;
+			default = 3333;
+		}
+	}
+
+	public abstract class AllocatorConfig : Object {
+		public abstract bool is_valid {
+			get;
+		}
+	}
+
+	public sealed class NoAllocatorConfig : AllocatorConfig {
+		public override bool is_valid {
+			get {
+				return true;
+			}
+		}
+	}
+
+	public sealed class PhysicalAllocatorConfig : AllocatorConfig, Json.Serializable {
+		public override bool is_valid {
+			get {
+				return true;
+			}
+		}
+
+		public uint64 physical_base {
+			get;
+			set;
+		}
+
+		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
+			if (try_deserialize_address ("physical_base", property_node, out value))
+				return true;
+
+			value = Value (pspec.value_type);
+			return false;
+		}
+	}
+
+	public sealed class TargetFunctionsAllocatorConfig : AllocatorConfig, Json.Serializable {
+		public override bool is_valid {
+			get {
+				return alloc_function != 0 && free_function != 0;
+			}
+		}
+
+		public uint64 alloc_function {
+			get;
+			set;
+		}
+
+		public uint64 free_function {
+			get;
+			set;
+		}
+
+		public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
+			if (try_deserialize_address ("alloc_function", property_node, out value))
+				return true;
+
+			if (try_deserialize_address ("free_function", property_node, out value))
+				return true;
+
+			value = Value (pspec.value_type);
+			return false;
+		}
+	}
+
+	private bool try_deserialize_address (string name, Json.Node node, out Value val) {
+		val = Value (typeof (uint64));
+
+		if (node.get_value_type () != typeof (string))
+			return false;
+
+		uint64 v;
+		if (!uint64.try_parse (node.get_string (), out v, null, 16))
+			return false;
+
+		val = v;
+		return true;
+	}
+}
@@ -0,0 +1,31 @@
+[CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
+namespace Frida.Barebone {
+	private class ConsoleLogHandler : Object, CallbackHandler {
+		public signal void output (string message);
+
+		public uint arity {
+			get { return 2; }
+		}
+
+		private GDB.Client gdb;
+
+		public ConsoleLogHandler (GDB.Client gdb) {
+			this.gdb = gdb;
+		}
+
+		public async uint64 handle_invocation (uint64[] args, CallFrame frame, Cancellable? cancellable)
+				throws Error, IOError {
+			var message = args[0];
+			var len = (long) args[1];
+
+			Bytes str_bytes = yield gdb.read_byte_array (message, len, cancellable);
+			unowned uint8[] str_data = str_bytes.get_data ();
+			unowned string str_raw = (string) str_data;
+			string str = str_raw.substring (0, len);
+
+			output (str);
+
+			return 0;
+		}
+	}
+}
@@ -0,0 +1,27 @@
+[CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
+namespace Frida.Barebone {
+	public async Allocation inject_elf (Gum.ElfModule elf, Machine machine, Allocator allocator, Cancellable? cancellable)
+			throws Error, IOError {
+		size_t vm_size = (size_t) elf.mapped_size;
+
+		size_t page_size = yield machine.query_page_size (cancellable);
+		uint num_pages = (uint) (vm_size / page_size);
+		if (vm_size % page_size != 0)
+			num_pages++;
+
+		var allocation = yield allocator.allocate (num_pages * page_size, page_size, cancellable);
+		try {
+			uint64 base_va = allocation.virtual_address;
+
+			Bytes relocated_image = machine.relocate (elf, base_va);
+			yield machine.gdb.write_byte_array (base_va, relocated_image, cancellable);
+
+			yield machine.protect_pages (base_va, vm_size, READ | EXECUTE, cancellable);
+		} catch (GLib.Error e) {
+			yield allocation.deallocate (cancellable);
+			throw_api_error (e);
+		}
+
+		return allocation;
+	}
+}
@@ -1,36 +0,0 @@
-from pathlib import Path
-import shutil
-import subprocess
-import sys
-
-
-def main(argv):
-    output_dir, priv_dir, input_dir, npm = [Path(d).resolve() for d in argv[1:]]
-
-    try:
-        generate_runtime(output_dir, priv_dir, input_dir, npm)
-    except Exception as e:
-        print(e, file=sys.stderr)
-        sys.exit(1)
-
-
-def generate_runtime(output_dir, priv_dir, input_dir, npm):
-    priv_dir.mkdir(exist_ok=True)
-
-    shutil.copy(input_dir / "package.json", priv_dir)
-    shutil.copy(input_dir / "package-lock.json", priv_dir)
-
-    runtime_reldir = Path("script-runtime")
-    runtime_srcdir = input_dir / runtime_reldir
-    runtime_intdir = priv_dir / runtime_reldir
-    if runtime_intdir.exists():
-        shutil.rmtree(runtime_intdir)
-    shutil.copytree(runtime_srcdir, runtime_intdir)
-
-    subprocess.run([npm, "install"], capture_output=True, cwd=priv_dir, check=True)
-
-    shutil.copy(priv_dir / "script-runtime.js", output_dir)
-
-
-if __name__ == "__main__":
-    main(sys.argv)
@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	public class Interceptor : Object {
+	public sealed class Interceptor : Object {
 		public Machine machine {
 			get;
 			construct;
@@ -22,6 +22,9 @@ namespace Frida.Barebone {
 		public abstract async Allocation allocate_pages (uint64 physical_address, uint num_pages, Cancellable? cancellable)
 			throws Error, IOError;

+		public abstract async void protect_pages (uint64 virtual_address, size_t size, Gum.PageProtection prot,
+			Cancellable? cancellable) throws Error, IOError;
+
 		public abstract async Gee.List<uint64?> scan_ranges (Gee.List<Gum.MemoryRange?> ranges, MatchPattern pattern,
 			uint max_matches, Cancellable? cancellable) throws Error, IOError;

@@ -65,8 +68,7 @@ namespace Frida.Barebone {

 		public abstract void apply_relocation (Gum.ElfRelocationDetails r, uint64 base_va, Buffer relocated) throws Error;

-		public abstract async uint64 invoke (uint64 impl, uint64[] args, uint64 landing_zone, Cancellable? cancellable)
-			throws Error, IOError;
+		public abstract async uint64 invoke (uint64 impl, uint64[] args, Cancellable? cancellable) throws Error, IOError;

 		public abstract async CallFrame load_call_frame (GDB.Thread thread, uint arity, Cancellable? cancellable)
 			throws Error, IOError;
@@ -1,12 +1,16 @@
 backend_sources += files(
  'barebone-host-session.vala',
+  'config.vala',
  'script.vala',
  'machine.vala',
  'allocator.vala',
  'callback.vala',
  'memory-scanner.vala',
  'interceptor.vala',
+  'c-module.vala',
  'rust-module.vala',
+  'console.vala',
+  'elf.vala',
  'arch-x86' / 'machine.vala',
  'arch-x86_64' / 'machine.vala',
  'arch-arm' / 'machine.vala',
@@ -29,11 +33,11 @@ barebone_script_runtime = custom_target('frida-barebone-script-runtime',
  ],
  command: [
    python,
-    files('generate-script-runtime.py'),
-    meson.current_build_dir(),
+    compile_js_agent,
+    '@OUTPUT@',
    '@PRIVATE_DIR@',
-    meson.current_source_dir(),
    npm,
+    '@INPUT@',
  ],
 )
 backend_sources += custom_target('frida-data-barebone',
@@ -1,494 +1,503 @@
 {
-  "name": "frida-barebone-runtime",
+  "name": "frida-barebone-script-runtime",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
-      "name": "frida-barebone-runtime",
+      "name": "frida-barebone-script-runtime",
      "version": "1.0.0",
      "devDependencies": {
-        "@types/frida-gum": "^18.3.2",
-        "frida-compile": "^16.2.1"
+        "@types/frida-gum": "^19.0.0",
+        "esbuild": "^0.25.5",
+        "typescript": "^5.8.3"
      }
    },
-    "node_modules/@frida/assert": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/assert/-/assert-3.0.2.tgz",
-      "integrity": "sha512-JXJq5SbXGrM5EkjrZKfRmB29zOoEOix02NC6A5TSJ+C1GE/X051EinJJsuOO2pEOx7KZwpvAHvS0WXW0+levKg==",
-      "dev": true
-    },
-    "node_modules/@frida/base64-js": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/@frida/base64-js/-/base64-js-2.0.3.tgz",
-      "integrity": "sha512-2w0F+1TynOTCZ/v7du9LdHPWwq0lJhazjo2fF9upMyQmA1zHetT14fLuQ1v/6T0qPgyeEGkiSrybstU8EsgeUA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/@frida/buffer": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/@frida/buffer/-/buffer-7.0.4.tgz",
-      "integrity": "sha512-RxQ1lZRRiCJj7nhcCiD8xeJx0NsLpGGnjqsmTg7jShGmbnVFMN5W7+J+3gqdPSQhc/IxNBIWc6zRXVp4+qnYHg==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.5.tgz",
+      "integrity": "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==",
+      "cpu": [
+        "ppc64"
      ],
-      "dependencies": {
-        "base64-js": "^1.5.1",
-        "ieee754": "^1.2.1"
-      }
-    },
-    "node_modules/@frida/crosspath": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/crosspath/-/crosspath-3.0.0.tgz",
-      "integrity": "sha512-bNdO1spIPD2P40XtK89N49oZpJhstdlnkJZcD4yJ17jrdkm9Ctu0sd9MIEX6Z8Tm8ydhVJBAOMEKl9/R27onAQ==",
      "dev": true,
-      "dependencies": {
-        "@types/node": "^17.0.36"
-      },
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
      "engines": {
-        "node": ">=14.9.0"
+        "node": ">=18"
      }
    },
-    "node_modules/@frida/diagnostics_channel": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/diagnostics_channel/-/diagnostics_channel-1.0.0.tgz",
-      "integrity": "sha512-mYX1jp/5Bpk24tHArJNx65iCk7qSuV8YJkdU0gFNVtJUXxfV8BG5WuPa4mL+ynxsbWWpsg/cwKZbLAepYKTdQQ==",
-      "dev": true
-    },
-    "node_modules/@frida/events": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/@frida/events/-/events-4.0.4.tgz",
-      "integrity": "sha512-qJVQ6VWHf9sjUKuiJzoCAC00frbpcwxeYfvQ+PP9LU/d70j+QvjWgYe98Qa3ekLaBU6r/AvWm8ThKCDUCLWrQQ==",
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.5.tgz",
+      "integrity": "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==",
+      "cpu": [
+        "arm"
+      ],
      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
      "engines": {
-        "node": ">=0.8.x"
+        "node": ">=18"
      }
    },
-    "node_modules/@frida/http": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/http/-/http-4.0.2.tgz",
-      "integrity": "sha512-cvkc7ex7GmVXVOWqtjXKBWUUbYEBgpNRKZbEEoMeI8KiIs8zejKwg+N7rx7296Ao+EP3+xcUr4wBVr3xLaUVfQ==",
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.5.tgz",
+      "integrity": "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==",
+      "cpu": [
+        "arm64"
+      ],
      "dev": true,
-      "dependencies": {
-        "http-parser-js": "^0.5.3"
-      }
-    },
-    "node_modules/@frida/http-parser-js": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/http-parser-js/-/http-parser-js-1.0.0.tgz",
-      "integrity": "sha512-2nMrNXt/OeTlWbqnE8AH4Sfz4I2+BGoN206dzKEyC/g2svtn83Xu+zuv/V3TkwrA27s26Mcy84ZwsXeNlqNxUQ==",
-      "dev": true
-    },
-    "node_modules/@frida/https": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/https/-/https-1.0.0.tgz",
-      "integrity": "sha512-OiqQ6qsALcWOktRLq07oJ0i6sH8eX6MXb/MdZS1qVKDRf6wchH4Pjn6fiLB+pt/OlYbggk+DOfpHwSdjTwuHMQ==",
-      "dev": true
-    },
-    "node_modules/@frida/ieee754": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/ieee754/-/ieee754-2.0.2.tgz",
-      "integrity": "sha512-wlcUebnne4ENN7GDr5pTH598ZDLMVOsh0FjenxeVOe6u7ewZkz9gGRnLnZKJAm9kl5G6XhdxhI0cSXVQK/rQUw==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/@frida/net": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/net/-/net-4.0.2.tgz",
-      "integrity": "sha512-qQRe7hQ+ZfCcG/SE3P1TRqQ9bmuK/T7wPCYaT4z56rBPWAxsaQbQHpX4fR6OrFaSDr7X0xJLsTbdIp9hGhhLZg==",
-      "dev": true
-    },
-    "node_modules/@frida/os": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/os/-/os-1.0.2.tgz",
-      "integrity": "sha512-3ISAiGNiyIya3QN2EHBCz1wqP0enTdSxP99wUeroeh8+AQRmgoOr/5TRnrVry8pe378anay3fmV/tdUMMSkehQ==",
-      "dev": true
-    },
-    "node_modules/@frida/path": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/@frida/path/-/path-2.0.3.tgz",
-      "integrity": "sha512-2RQy36QatoC846fzBhBhV8sXMsSOBGoYvwTHeaE1zUdz7F4RNScP4QEekTTooBYWYX/XjiF36KQpYAzc9OYFtg==",
-      "dev": true
-    },
-    "node_modules/@frida/process": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@frida/process/-/process-1.2.1.tgz",
-      "integrity": "sha512-nvCu22DstFW2ttGFtOKekHM7vnjbZm+XgtvavOt427GNT6uV7k0JYK9tnMbcLMRWv57DG6udAmuJlWs8Paq1ag==",
-      "dev": true
-    },
-    "node_modules/@frida/punycode": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/punycode/-/punycode-3.0.0.tgz",
-      "integrity": "sha512-XVSDY2KamDs1D5/fTVgHcOSNxdU4kTboxzqJMBbTjcQC7XScIT9c0EfbwKCq7Kci6gWQdsHSCr7lU+9Oc4KAdg==",
-      "dev": true
-    },
-    "node_modules/@frida/querystring": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/querystring/-/querystring-1.0.0.tgz",
-      "integrity": "sha512-15m1fOZPmoO/vWlgPJrG/J9/BJDz6a2/JpVGpS8ynNzo+fBhTznaStX5nHxUs24mVTqh/OqLo0EiYJM5WWHXxg==",
-      "dev": true
-    },
-    "node_modules/@frida/readable-stream": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/@frida/readable-stream/-/readable-stream-4.1.3.tgz",
-      "integrity": "sha512-ntGUFmi+CryRGRJIK13a/VST2Ad19uivbln8Xd92vKPAARq+6vMIASDyZIqyl5BLRccfiyCHdYgrgQ6RI5rUig==",
-      "dev": true
-    },
-    "node_modules/@frida/reserved-words": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/reserved-words/-/reserved-words-1.0.0.tgz",
-      "integrity": "sha512-2yG/XxJlsGlk/mm6eZTb4OAaQEhkTI2qaFfZFtAsrA/XuCpuMWkS4y/guyBlsRu4hAuhK2HPmNM8+OLLK1zM9Q==",
-      "dev": true
-    },
-    "node_modules/@frida/stream": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/stream/-/stream-1.0.2.tgz",
-      "integrity": "sha512-4OuaC1ztmEKgTq3WeBhsy8Oq+AwW9n9cYnvLklcC9jwD93AEwgbWpecLlxJCVuALvTMdhKPg0nQVfyGYP/i9Bw==",
-      "dev": true,
-      "dependencies": {
-        "@frida/readable-stream": "^4.1.3"
-      }
-    },
-    "node_modules/@frida/string_decoder": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/string_decoder/-/string_decoder-2.0.0.tgz",
-      "integrity": "sha512-in371tYZMHQiW9HF5MS3JDw6Ao6tyBoq34UWy2rzOswYyMG1rpizh85ofi/yVkxDiaqybEZefxzkVittpPGT6g==",
-      "dev": true
-    },
-    "node_modules/@frida/terser": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/terser/-/terser-1.0.0.tgz",
-      "integrity": "sha512-59h9WuNzD1Rx/zwoWqQ/FW/4Y/Q3R91Eng2hEwdHapqiTDvtKbZ08F6CynCR7ZVinrh4tLYsF46AtVPTz1ys9g==",
-      "dev": true,
-      "dependencies": {
-        "@jridgewell/source-map": "^0.3.2",
-        "acorn": "^8.5.0",
-        "commander": "^2.20.0",
-        "source-map-support": "~0.5.20"
-      },
-      "bin": {
-        "terser": "bin/terser"
-      },
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
      "engines": {
-        "node": ">=10"
+        "node": ">=18"
      }
    },
-    "node_modules/@frida/terser/node_modules/commander": {
-      "version": "2.20.3",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
-      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
-      "dev": true
-    },
-    "node_modules/@frida/timers": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/timers/-/timers-3.0.0.tgz",
-      "integrity": "sha512-3b+0igv10aT8TMxefrTAd06rActqbxJLY2Xkkq9vYcPBffB/yHszl0NYIp/5ko8WC3ecDYPU6bQiY6fjs72zTA==",
-      "dev": true
-    },
-    "node_modules/@frida/tty": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/tty/-/tty-1.0.0.tgz",
-      "integrity": "sha512-p/kjLnKYxEAB1MdYP8+5rKv9CsHzyA+0jg9BcGETzjQVKHHcroHDULRxDYUh+DC7qs6cpX8QdDQh9E+a6ydgsQ==",
-      "dev": true
-    },
-    "node_modules/@frida/url": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@frida/url/-/url-1.0.2.tgz",
-      "integrity": "sha512-ZKunbKJHMr8w2Eb/5K1avy0MzK1B998S17wYXNv3RmzBGxMm8S5T0F3qEpRxkU7/72P8m4izyQU87fWl+FjQsQ==",
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.5.tgz",
+      "integrity": "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==",
+      "cpu": [
+        "x64"
+      ],
      "dev": true,
-      "dependencies": {
-        "@frida/punycode": "^3.0.0",
-        "@frida/querystring": "^1.0.0"
-      }
-    },
-    "node_modules/@frida/util": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@frida/util/-/util-1.0.3.tgz",
-      "integrity": "sha512-htcG3uDiRXv89ERVNNYhfase39kJ2X75ZARfrYcYEtJLFEsSk0nemM1YnEIR4CjrHvdvkWHrwgKkS+acOyoNEg==",
-      "dev": true
-    },
-    "node_modules/@frida/vm": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@frida/vm/-/vm-2.0.0.tgz",
-      "integrity": "sha512-7fsjLWscZT5odNIBtg6qbLNI+vAk1xmii6H5W2kaYkMYt0vRohQEcDSUWacA+eaWlu5SvMjZI82Yibj/3G9pJw==",
-      "dev": true
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.3",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz",
-      "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==",
-      "dev": true,
-      "dependencies": {
-        "@jridgewell/set-array": "^1.0.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      },
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
      "engines": {
-        "node": ">=6.0.0"
+        "node": ">=18"
      }
    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
-      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.5.tgz",
+      "integrity": "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==",
+      "cpu": [
+        "arm64"
+      ],
      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
      "engines": {
-        "node": ">=6.0.0"
+        "node": ">=18"
      }
    },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
-      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.5.tgz",
+      "integrity": "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==",
+      "cpu": [
+        "x64"
+      ],
      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
      "engines": {
-        "node": ">=6.0.0"
+        "node": ">=18"
      }
    },
-    "node_modules/@jridgewell/source-map": {
-      "version": "0.3.3",
-      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.3.tgz",
-      "integrity": "sha512-b+fsZXeLYi9fEULmfBrhxn4IrPlINf8fiNarzTof004v3lFdntdwa9PF7vFJqm3mg7s+ScJMxXaE3Acp1irZcg==",
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.5.tgz",
+      "integrity": "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==",
+      "cpu": [
+        "arm64"
+      ],
      "dev": true,
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
      }
    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.15",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
-      "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==",
-      "dev": true
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.18",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz",
-      "integrity": "sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==",
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.5.tgz",
+      "integrity": "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==",
+      "cpu": [
+        "x64"
+      ],
      "dev": true,
-      "dependencies": {
-        "@jridgewell/resolve-uri": "3.1.0",
-        "@jridgewell/sourcemap-codec": "1.4.14"
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
      }
    },
-    "node_modules/@jridgewell/trace-mapping/node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
-      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==",
-      "dev": true
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.5.tgz",
+      "integrity": "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.5.tgz",
+      "integrity": "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.5.tgz",
+      "integrity": "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.5.tgz",
+      "integrity": "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.5.tgz",
+      "integrity": "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.5.tgz",
+      "integrity": "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.5.tgz",
+      "integrity": "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.5.tgz",
+      "integrity": "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.5.tgz",
+      "integrity": "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.5.tgz",
+      "integrity": "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.5.tgz",
+      "integrity": "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.5.tgz",
+      "integrity": "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.5.tgz",
+      "integrity": "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.5.tgz",
+      "integrity": "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.5.tgz",
+      "integrity": "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.5.tgz",
+      "integrity": "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.5.tgz",
+      "integrity": "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
    },
    "node_modules/@types/frida-gum": {
-      "version": "18.3.2",
-      "resolved": "https://registry.npmjs.org/@types/frida-gum/-/frida-gum-18.3.2.tgz",
-      "integrity": "sha512-bso8bJRxrhchNRrOMmT18st/THIdjzxFdcMtJ/gGSYSknJeerQ8ArBwBtlWt/f3pqVVs1Mz1Fg6lvUdjXswa+g==",
-      "dev": true
-    },
-    "node_modules/@types/node": {
-      "version": "17.0.45",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.45.tgz",
-      "integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==",
-      "dev": true
-    },
-    "node_modules/acorn": {
-      "version": "8.8.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
-      "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==",
+      "version": "19.0.0",
+      "resolved": "https://registry.npmjs.org/@types/frida-gum/-/frida-gum-19.0.0.tgz",
+      "integrity": "sha512-qViK1KwvPEAkajwSUv0wpZvZLiX8xO4JFFCh8dfYZfzSyOEfoE0KliCP/nJSKIKG6N3hXnPowrvPufjs5fLKAA==",
      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.5.tgz",
+      "integrity": "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
      "bin": {
-        "acorn": "bin/acorn"
+        "esbuild": "bin/esbuild"
      },
      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/base64-js": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/buffer-from": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
-      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
-      "dev": true
-    },
-    "node_modules/commander": {
-      "version": "9.5.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
-      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
-      "dev": true,
-      "engines": {
-        "node": "^12.20.0 || >=14"
-      }
-    },
-    "node_modules/frida-compile": {
-      "version": "16.2.1",
-      "resolved": "https://registry.npmjs.org/frida-compile/-/frida-compile-16.2.1.tgz",
-      "integrity": "sha512-be/U5h8l0cb0b+fWeZclhfw1s2xER8fPOjnTU4rZF8oh5GkB0BeAEaApwfGrdmeZkVNdUhDLXud7DqEljHRWmA==",
-      "dev": true,
-      "dependencies": {
-        "@frida/assert": "^3.0.1",
-        "@frida/base64-js": "^2.0.3",
-        "@frida/buffer": "^7.0.4",
-        "@frida/crosspath": "^3.0.0",
-        "@frida/diagnostics_channel": "^1.0.0",
-        "@frida/events": "^4.0.4",
-        "@frida/http": "^4.0.2",
-        "@frida/http-parser-js": "^1.0.0",
-        "@frida/https": "^1.0.0",
-        "@frida/ieee754": "^2.0.2",
-        "@frida/net": "^4.0.1",
-        "@frida/os": "^1.0.0",
-        "@frida/path": "^2.0.3",
-        "@frida/process": "^1.2.1",
-        "@frida/punycode": "^3.0.0",
-        "@frida/querystring": "^1.0.0",
-        "@frida/readable-stream": "^4.1.3",
-        "@frida/reserved-words": "^1.0.0",
-        "@frida/stream": "^1.0.2",
-        "@frida/string_decoder": "^2.0.0",
-        "@frida/terser": "^1.0.0",
-        "@frida/timers": "^3.0.0",
-        "@frida/tty": "^1.0.0",
-        "@frida/url": "^1.0.2",
-        "@frida/util": "^1.0.3",
-        "@frida/vm": "^2.0.0",
-        "commander": "^9.4.0",
-        "frida-fs": "^5.2.3",
-        "typed-emitter": "^2.1.0"
+        "node": ">=18"
      },
-      "bin": {
-        "frida-compile": "dist/cli.js"
-      }
-    },
-    "node_modules/frida-fs": {
-      "version": "5.2.3",
-      "resolved": "https://registry.npmjs.org/frida-fs/-/frida-fs-5.2.3.tgz",
-      "integrity": "sha512-jJhtNI86UqDkOtB72XR7Ia9KHudQUxIFIbZadS9kxrDU6Io1jLhoMNp++iW7n7MaDgFQLRR8VgNj9VViGzaydA==",
-      "dev": true
-    },
-    "node_modules/http-parser-js": {
-      "version": "0.5.8",
-      "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz",
-      "integrity": "sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==",
-      "dev": true
-    },
-    "node_modules/ieee754": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
-      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/rxjs": {
-      "version": "7.8.1",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz",
-      "integrity": "sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==",
-      "dev": true,
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "node_modules/source-map": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/source-map-support": {
-      "version": "0.5.21",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
-      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
-      "dev": true,
-      "dependencies": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.0"
-      }
-    },
-    "node_modules/tslib": {
-      "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.5.2.tgz",
-      "integrity": "sha512-5svOrSA2w3iGFDs1HibEVBGbDrAY82bFQ3HZ3ixB+88nsbsWQoKqDRb5UBYAUPEzbBn6dAp5gRNXglySbx1MlA==",
-      "dev": true,
-      "optional": true
-    },
-    "node_modules/typed-emitter": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/typed-emitter/-/typed-emitter-2.1.0.tgz",
-      "integrity": "sha512-g/KzbYKbH5C2vPkaXGu8DJlHrGKHLsM25Zg9WuC9pMGfuvT+X25tZQWo5fK1BjBm8+UrVE9LDCvaY0CQk+fXDA==",
-      "dev": true,
      "optionalDependencies": {
-        "rxjs": "*"
+        "@esbuild/aix-ppc64": "0.25.5",
+        "@esbuild/android-arm": "0.25.5",
+        "@esbuild/android-arm64": "0.25.5",
+        "@esbuild/android-x64": "0.25.5",
+        "@esbuild/darwin-arm64": "0.25.5",
+        "@esbuild/darwin-x64": "0.25.5",
+        "@esbuild/freebsd-arm64": "0.25.5",
+        "@esbuild/freebsd-x64": "0.25.5",
+        "@esbuild/linux-arm": "0.25.5",
+        "@esbuild/linux-arm64": "0.25.5",
+        "@esbuild/linux-ia32": "0.25.5",
+        "@esbuild/linux-loong64": "0.25.5",
+        "@esbuild/linux-mips64el": "0.25.5",
+        "@esbuild/linux-ppc64": "0.25.5",
+        "@esbuild/linux-riscv64": "0.25.5",
+        "@esbuild/linux-s390x": "0.25.5",
+        "@esbuild/linux-x64": "0.25.5",
+        "@esbuild/netbsd-arm64": "0.25.5",
+        "@esbuild/netbsd-x64": "0.25.5",
+        "@esbuild/openbsd-arm64": "0.25.5",
+        "@esbuild/openbsd-x64": "0.25.5",
+        "@esbuild/sunos-x64": "0.25.5",
+        "@esbuild/win32-arm64": "0.25.5",
+        "@esbuild/win32-ia32": "0.25.5",
+        "@esbuild/win32-x64": "0.25.5"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
      }
    }
  }
@@ -2,12 +2,15 @@
  "name": "frida-barebone-script-runtime",
  "version": "1.0.0",
  "description": "Script runtime used by Frida's Barebone backend",
+  "type": "module",
  "scripts": {
-    "prepare": "npm run build",
-    "build": "frida-compile script-runtime/entrypoint.ts -o script-runtime.js -c"
+    "build": "esbuild script-runtime/entrypoint.ts --outfile=script-runtime.js --bundle --platform=node --target=es2022 --minify",
+    "check": "tsc",
+    "watch": "tsc -w"
  },
  "devDependencies": {
-    "@types/frida-gum": "^18.3.2",
-    "frida-compile": "^16.2.1"
+    "@types/frida-gum": "^19.0.0",
+    "esbuild": "^0.25.5",
+    "typescript": "^5.8.3"
  }
 }
@@ -1,6 +1,6 @@
 [CCode (gir_namespace = "FridaBarebone", gir_version = "1.0")]
 namespace Frida.Barebone {
-	private class RustModule : Object {
+	private sealed class RustModule : Object {
 		public signal void console_output (string message);

 		public Gee.List<Export> exports {
@@ -84,23 +84,11 @@ namespace Frida.Barebone {
 				throw new Error.NOT_SUPPORTED ("%s", e.message);
 			}

-			size_t vm_size = (size_t) elf.mapped_size;
+			allocation = yield inject_elf (elf, machine, allocator, cancellable);

-			size_t page_size = yield machine.query_page_size (cancellable);
-			uint num_pages = (uint) (vm_size / page_size);
-			if (vm_size % page_size != 0)
-				num_pages++;
-
-			var gdb = machine.gdb;
-
-			allocation = yield allocator.allocate (num_pages * page_size, page_size, cancellable);
 			uint64 base_va = allocation.virtual_address;
-
-			Bytes relocated_image = machine.relocate (elf, base_va);
-			yield gdb.write_byte_array (base_va, relocated_image, cancellable);
-
 			uint64 console_log_trap = 0;
-			elf.enumerate_dynamic_symbols (e => {
+			elf.enumerate_symbols (e => {
 				if (e.name == "")
 					return true;

@@ -116,38 +104,14 @@ namespace Frida.Barebone {
 			});

 			if (console_log_trap != 0) {
-				console_log_callback = yield new Callback (console_log_trap, new ConsoleLogHandler (this, gdb),
-					machine, cancellable);
+				var handler = new ConsoleLogHandler (machine.gdb);
+				handler.output.connect (on_console_output);
+				console_log_callback = yield new Callback (console_log_trap, handler, machine, cancellable);
 			}
 		}

-		private class ConsoleLogHandler : Object, CallbackHandler {
-			public uint arity {
-				get { return 2; }
-			}
-
-			private weak RustModule parent;
-			private GDB.Client gdb;
-
-			public ConsoleLogHandler (RustModule parent, GDB.Client gdb) {
-				this.parent = parent;
-				this.gdb = gdb;
-			}
-
-			public async uint64 handle_invocation (uint64[] args, CallFrame frame, Cancellable? cancellable)
-					throws Error, IOError {
-				var message = args[0];
-				var len = (long) args[1];
-
-				Bytes str_bytes = yield gdb.read_byte_array (message, len, cancellable);
-				unowned uint8[] str_data = str_bytes.get_data ();
-				unowned string str_raw = (string) str_data;
-				string str = str_raw.substring (0, len);
-
-				parent.console_output (str);
-
-				return 0;
-			}
+		private void on_console_output (string message) {
+			console_output (message);
 		}

 		private const string CRATE_NAME = "rustmodule";
@@ -201,14 +165,17 @@ namespace Frida.Barebone {
 							.resolve_relative_path (CRATE_NAME);
 					}

-					yield write_text_file (workdir, "module.lds", make_linker_script (symbols), cancellable);
+					yield write_text_file (workdir, "module.lds", make_linker_script (code, symbols), cancellable);
 				} catch (GLib.Error e) {
 					throw new Error.PERMISSION_DENIED ("%s", e.message);
 				}
 			}

 			~CompilationAssets () {
-				rmtree (workdir);
+				try {
+					FS.rmtree (workdir);
+				} catch (Error e) {
+				}
 			}

 			private static string make_main_rs (string code, Machine machine) {
@@ -267,8 +234,8 @@ namespace Frida.Barebone {
 				return rs.str;
 			}

-			private static string make_linker_script (Gee.Map<string, uint64?> symbols) {
-				var script = new StringBuilder.sized (256);
+			private static string make_linker_script (string code, Gee.Map<string, uint64?> symbols) {
+				var script = new StringBuilder.sized (512);

 				foreach (var e in symbols.entries) {
 					unowned string name = e.key;
@@ -279,15 +246,16 @@ namespace Frida.Barebone {
 						.append_printf ("0x%" + uint64.FORMAT_MODIFIER + "x;\n", address);
 				}

-				script.append (prettify_text_asset (BASE_LINKER_SCRIPT));
-
-				return script.str;
-			}
-
-			private const string BASE_LINKER_SCRIPT = """
+				script.append ("""
 				SECTIONS {
 					.text : {
 						*(.text*);
+				""");
+
+				foreach (string name in extract_extern_c_symbols (code))
+					script.append_printf ("		KEEP(*(.text.%s))\n", name);
+
+				script.append ("""
 						_console_log = .;
 						. += 8;
 					}
@@ -304,7 +272,25 @@ namespace Frida.Barebone {
 						*(.bss*)
 					}
 				}
-			""";
+				""");
+
+				return prettify_text_asset (script.str);
+			}
+
+			private static Gee.List<string> extract_extern_c_symbols (string code) {
+				var names = new Gee.ArrayList<string> ();
+
+				var export_pattern = /\#\[\s*no_mangle\s*\]\s*pub\s+(?:unsafe\s+)?extern\s*"C"\s+fn\s+([A-Za-z_]\w*)\s*\(/;
+
+				try {
+					MatchInfo info;
+					for (export_pattern.match (code, 0, out info); info.matches (); info.next ())
+						names.add (info.fetch (1));
+				} catch (RegexError e) {
+				}
+
+				return names;
+			}

 			private const string BUILTINS = """
 				#![no_main]
@@ -428,23 +414,4 @@ namespace Frida.Barebone {
 		yield file.replace_contents_async (content.data, null, false, FileCreateFlags.NONE, cancellable, null);
 		return file;
 	}
-
-	private void rmtree (File dir) {
-		try {
-			var enumerator = dir.enumerate_children (FileAttribute.STANDARD_NAME, NOFOLLOW_SYMLINKS);
-			FileInfo? info;
-			File? child;
-			while (enumerator.iterate (out info, out child) && info != null) {
-				if (info == null)
-					continue;
-				if (info.get_file_type () == DIRECTORY)
-					rmtree (child);
-				else
-					child.delete ();
-			}
-
-			dir.delete ();
-		} catch (GLib.Error e) {
-		}
-	}
 }
@@ -210,24 +210,6 @@ Object.defineProperties(globalThis, {
            }
        }
    },
-    ObjC: {
-        enumerable: true,
-        value: {
-            available: false
-        }
-    },
-    Swift: {
-        enumerable: true,
-        value: {
-            available: false
-        }
-    },
-    Java: {
-        enumerable: true,
-        value: {
-            available: false
-        }
-    },
    console: {
        enumerable: true,
        value: new Console()
@@ -278,6 +260,8 @@ Object.defineProperties(Process, {
                    base: NULL,
                    size: 0x1000,
                    path: "/kernel",
+                    ensureInitialized() {
+                    },
                    enumerateImports() {
                        return [];
                    },
@@ -290,11 +274,23 @@ Object.defineProperties(Process, {
                    enumerateRanges() {
                        return [];
                    },
+                    enumerateSections() {
+                        return [];
+                    },
+                    enumerateDependencies() {
+                        return [];
+                    },
                    findExportByName() {
                        return null;
                    },
-                    getExportByName(exportName) {
-                        throw new Error(`unable to find export '${exportName}'`);
+                    getExportByName(name) {
+                        throw new Error(`unable to find export '${name}'`);
+                    },
+                    findSymbolByName() {
+                        return null;
+                    },
+                    getSymbolByName(name) {
+                        throw new Error(`unable to find symbol '${name}'`);
                    }
                }
            ];
@@ -308,6 +304,13 @@ Object.defineProperties(Process, {
 });

 const marshalers: { [type: string]: Marshaler } = {
+    void: {
+        fromNative(v) {
+        },
+        toNative(v) {
+            throw new Error("invalid operation");
+        }
+    },
    pointer: {
        fromNative(v) {
            return new BNativePointer(v);
@@ -342,6 +345,17 @@ const marshalers: { [type: string]: Marshaler } = {
            return BigInt(v);
        }
    },
+    size_t: {
+        fromNative(v) {
+            return new BUInt64(v);
+        },
+        toNative(v) {
+            if (typeof v === "number") {
+                return BigInt(v);
+            }
+            return v.$v;
+        }
+    },
 };

 function getMarshalerFor(t: NativeFunctionReturnType | NativeFunctionArgumentType): Marshaler {
@@ -1,5 +1,5 @@
 namespace Frida {
-	private class BareboneScript : Object {
+	private sealed class BareboneScript : Object {
 		public signal void message (string json, Bytes? data);

 		public AgentScriptId id {
@@ -42,8 +42,6 @@ namespace Frida {

 		private Gee.Queue<QuickJS.Value?> tick_callbacks = new Gee.ArrayQueue<QuickJS.Value?> ();

-		private Barebone.Allocation? cached_landing_zone; // TODO: Deallocate on teardown.
-
 		private Gee.Set<Barebone.Callback> native_callbacks = new Gee.HashSet<Barebone.Callback> ();

 		private static QuickJS.ClassID cpu_context_class;
@@ -56,6 +54,9 @@ namespace Frida {
 		private static QuickJS.ClassExoticMethods invocation_args_exotic_methods;
 		private static QuickJS.ClassID invocation_retval_class;

+		private static QuickJS.ClassID c_module_class;
+		private Gee.Set<Barebone.CModule> c_modules = new Gee.HashSet<Barebone.CModule> ();
+
 		private static QuickJS.ClassID rust_module_class;
 		private Gee.Set<Barebone.RustModule> rust_modules = new Gee.HashSet<Barebone.RustModule> ();

@@ -72,7 +73,7 @@ namespace Frida {
 		private QuickJS.Value int64_func = QuickJS.Undefined;
 		private QuickJS.Value uint64_func = QuickJS.Undefined;

-		private Gee.ArrayList<QuickJS.Value?> entrypoints = new Gee.ArrayList<QuickJS.Value?> ();
+		private Gee.Queue<Entrypoint> entrypoints = new Gee.ArrayQueue<Entrypoint> ();
 		private Gee.Map<string, Asset> assets = new Gee.HashMap<string, Asset> ();

 		private Cancellable io_cancellable = new Cancellable ();
@@ -155,6 +156,7 @@ namespace Frida {

 			var memory_obj = ctx.make_object ();
 			add_cfunc (memory_obj, "alloc", on_memory_alloc, 1);
+			add_cfunc (memory_obj, "protect", on_memory_protect, 3);
 			add_cfunc (memory_obj, "scan", on_memory_scan, 4);
 			add_cfunc (memory_obj, "scanSync", on_memory_scan_sync, 3);
 			global.set_property_str (ctx, "Memory", memory_obj);
@@ -206,6 +208,17 @@ namespace Frida {
 			ir.class_name = "InvocationReturnValue";
 			rt.make_class (QuickJS.make_class_id (ref invocation_retval_class), ir);

+			QuickJS.ClassDef cm;
+			cm.class_name = "CModule";
+			cm.finalizer = on_c_module_finalize;
+			rt.make_class (QuickJS.make_class_id (ref c_module_class), cm);
+			var cm_proto = ctx.make_object ();
+			add_cfunc (cm_proto, "dispose", on_c_module_dispose, 0);
+			ctx.set_class_proto (c_module_class, cm_proto);
+			var cm_ctor = ctx.make_cfunction2 (on_c_module_construct, cm.class_name, 1, constructor, 0);
+			cm_ctor.set_constructor (ctx, cm_proto);
+			global.set_property_str (ctx, "CModule", cm_ctor);
+
 			QuickJS.ClassDef rm;
 			rm.class_name = "RustModule";
 			rm.finalizer = on_rust_module_finalize;
@@ -328,6 +341,8 @@ namespace Frida {
 			foreach (var val in values)
 				ctx.free_value (val);

+			entrypoints.clear ();
+
 			QuickJS.Atom atoms[] = {
 				address_key,
 				base_key,
@@ -376,51 +391,70 @@ namespace Frida {
 			yield;
 		}

-		public void load () {
-			foreach (QuickJS.Value? entrypoint in entrypoints) {
-				var result = ctx.eval_function (entrypoint);
-				if (result.is_exception ())
+		public async void load (Cancellable? cancellable) throws IOError {
+			Entrypoint? entrypoint;
+			while ((entrypoint = entrypoints.poll ()) != null) {
+				var result = ctx.eval_function (ctx.dup_value (entrypoint.callable));
+				if (result.is_exception ()) {
 					catch_and_emit ();
-				ctx.free_value (result);
-
-				if (runtime_obj.is_undefined ()) {
-					runtime_obj = global.get_property_str (ctx, "$rt");
-					if (!runtime_obj.is_undefined ()) {
-						dispatch_exception_func = runtime_obj.get_property_str (ctx, "dispatchException");
-						assert (!dispatch_exception_func.is_undefined ());
-
-						dispatch_message_func = runtime_obj.get_property_str (ctx, "dispatchMessage");
-						assert (!dispatch_message_func.is_undefined ());
-
-						var native_pointer_instance = global.get_property_str (ctx, "NULL");
-						assert (!native_pointer_instance.is_undefined ());
-						var native_pointer_proto = native_pointer_instance.get_prototype (ctx);
-
-						var ir_proto = ctx.make_object_proto (native_pointer_proto);
-						add_cfunc (ir_proto, "replace", on_invocation_retval_replace, 1);
-						ctx.set_class_proto (invocation_retval_class, ir_proto);
-
-						ctx.free_value (native_pointer_proto);
-						ctx.free_value (native_pointer_instance);
-
-						ptr_func = global.get_property_str (ctx, "ptr");
-						assert (!ptr_func.is_undefined ());
-
-						int64_func = global.get_property_str (ctx, "int64");
-						assert (!int64_func.is_undefined ());
-
-						uint64_func = global.get_property_str (ctx, "uint64");
-						assert (!uint64_func.is_undefined ());
-					}
+					continue;
 				}
+
+				if (entrypoint.kind == ESM) {
+					var op = new PromiseWaitOperation (this, result);
+					var r = yield op.perform (cancellable);
+					if (!r.error.is_null ())
+						on_unhandled_exception (r.error);
+				} else {
+					ctx.free_value (result);
+				}
+
+				maybe_bind_runtime ();
 			}

 			perform_pending_io ();
 		}

+		private void maybe_bind_runtime () {
+			if (!runtime_obj.is_undefined ())
+				return;
+
+			runtime_obj = global.get_property_str (ctx, "$rt");
+			if (runtime_obj.is_undefined ())
+				return;
+
+			dispatch_exception_func = runtime_obj.get_property_str (ctx, "dispatchException");
+			assert (!dispatch_exception_func.is_undefined ());
+
+			dispatch_message_func = runtime_obj.get_property_str (ctx, "dispatchMessage");
+			assert (!dispatch_message_func.is_undefined ());
+
+			var native_pointer_instance = global.get_property_str (ctx, "NULL");
+			assert (!native_pointer_instance.is_undefined ());
+			var native_pointer_proto = native_pointer_instance.get_prototype (ctx);
+
+			var ir_proto = ctx.make_object_proto (native_pointer_proto);
+			add_cfunc (ir_proto, "replace", on_invocation_retval_replace, 1);
+			ctx.set_class_proto (invocation_retval_class, ir_proto);
+
+			ctx.free_value (native_pointer_proto);
+			ctx.free_value (native_pointer_instance);
+
+			ptr_func = global.get_property_str (ctx, "ptr");
+			assert (!ptr_func.is_undefined ());
+
+			int64_func = global.get_property_str (ctx, "int64");
+			assert (!int64_func.is_undefined ());
+
+			uint64_func = global.get_property_str (ctx, "uint64");
+			assert (!uint64_func.is_undefined ());
+		}
+
 		public void post (string json, Bytes? data) {
 			var json_val = ctx.make_string (json);
-			invoke_void (dispatch_message_func, { json_val }, runtime_obj);
+			var data_val = (data != null) ? ctx.make_array_buffer (data.get_data ()) : QuickJS.Null;
+			invoke_void (dispatch_message_func, { json_val, data_val }, runtime_obj);
+			ctx.free_value (data_val);
 			ctx.free_value (json_val);

 			perform_pending_io ();
@@ -493,7 +527,7 @@ namespace Frida {
 						throw_malformed_package ();

 					var val = compile_module (entrypoint);
-					entrypoints.add (val);
+					entrypoints.offer (new Entrypoint (this, val, ESM));

 					string rest = raw_assets[assets_offset:];
 					if (rest.has_prefix (delimiter_marker))
@@ -505,7 +539,7 @@ namespace Frida {
 				}
 			} else {
 				var val = compile_script (source, name);
-				entrypoints.add (val);
+				entrypoints.offer (new Entrypoint (this, val, PLAIN));
 			}
 		}

@@ -651,11 +685,7 @@ namespace Frida {

 		private async void do_invoke (uint64 impl, uint64[] args, Promise<uint64?> promise) {
 			try {
-				if (cached_landing_zone == null)
-					cached_landing_zone = yield services.allocator.allocate (4, 1, io_cancellable);
-
-				uint64 retval = yield services.machine.invoke (impl, args, cached_landing_zone.virtual_address,
-					io_cancellable);
+				uint64 retval = yield services.machine.invoke (impl, args, io_cancellable);

 				promise.resolve (retval);
 			} catch (GLib.Error e) {
@@ -706,6 +736,111 @@ namespace Frida {
 			}
 		}

+		private class Entrypoint {
+			private weak BareboneScript script;
+			public QuickJS.Value callable;
+			public Kind kind;
+
+			public enum Kind {
+				PLAIN,
+				ESM
+			}
+
+			public Entrypoint (BareboneScript script, QuickJS.Value callable, Kind kind) {
+				this.script = script;
+				this.callable = callable;
+				this.kind = kind;
+			}
+
+			~Entrypoint () {
+				script.ctx.free_value (callable);
+			}
+		}
+
+		private class PromiseWaitOperation {
+			private BareboneScript script;
+			private QuickJS.Value promise;
+
+			private enum Magic {
+				ON_SUCCESS,
+				ON_FAILURE,
+			}
+
+			public PromiseWaitOperation (BareboneScript script, QuickJS.Value promise) {
+				this.script = script;
+				this.promise = promise;
+			}
+
+			~PromiseWaitOperation () {
+				script.ctx.free_value (promise);
+			}
+
+			public async Result perform (Cancellable? cancellable) throws IOError {
+				var res = new Result (script, perform.callback);
+
+				unowned QuickJS.Context ctx = script.ctx;
+
+				var data = ctx.make_object ();
+				data.set_opaque (res);
+
+				var on_success = ctx.make_cfunction_data (on_settled, 1, Magic.ON_SUCCESS, { data });
+				var on_failure = ctx.make_cfunction_data (on_settled, 1, Magic.ON_FAILURE, { data });
+
+				var then_func = promise.get_property_str (ctx, "then");
+				var catch_func = promise.get_property_str (ctx, "catch");
+
+				ctx.free_value (then_func.call (ctx, promise, { on_success }));
+				ctx.free_value (catch_func.call (ctx, promise, { on_failure }));
+
+				ctx.free_value (catch_func);
+				ctx.free_value (then_func);
+
+				ctx.free_value (on_failure);
+				ctx.free_value (on_success);
+
+				script.perform_pending_io ();
+				yield;
+
+				return res;
+			}
+
+			private static QuickJS.Value on_settled (QuickJS.Context ctx, QuickJS.Value this_val, QuickJS.Value[] argv, int magic,
+					QuickJS.Value[] data) {
+				QuickJS.ClassID cid;
+				unowned Result res = (Result) data[0].get_any_opaque (out cid);
+
+				if (magic == Magic.ON_SUCCESS)
+					res.val = ctx.dup_value (argv[0]);
+				else
+					res.error = ctx.dup_value (argv[0]);
+
+				var source = new IdleSource ();
+				source.set_callback ((owned) res.on_complete);
+				source.attach (MainContext.get_thread_default ());
+
+				return QuickJS.Undefined;
+			}
+
+			public class Result {
+				public BareboneScript script;
+				public SourceFunc on_complete;
+
+				public QuickJS.Value val = QuickJS.Null;
+				public QuickJS.Value error = QuickJS.Null;
+
+				public Result (BareboneScript script, owned SourceFunc on_complete) {
+					this.script = script;
+					this.on_complete = (owned) on_complete;
+				}
+
+				~Result () {
+					unowned QuickJS.Context ctx = script.ctx;
+					ctx.free_value (val);
+					ctx.free_value (error);
+				}
+			}
+		}
+
 		private class NativeCallbackHandler : Object, Barebone.CallbackHandler {
 			public uint arity {
 				get { return _arity; }
@@ -998,6 +1133,41 @@ namespace Frida {
 			}
 		}

+		private static QuickJS.Value on_memory_protect (QuickJS.Context ctx, QuickJS.Value this_val, QuickJS.Value[] argv) {
+			BareboneScript * script = ctx.get_opaque ();
+
+			uint64 address;
+			if (!script->unparse_native_pointer (argv[0], out address))
+				return QuickJS.Exception;
+
+			uint size;
+			if (!script->unparse_uint (argv[1], out size))
+				return QuickJS.Exception;
+
+			Gum.PageProtection prot;
+			if (!script->unparse_page_protection (argv[2], out prot))
+				return QuickJS.Exception;
+
+			var promise = new Promise<bool?> ();
+			script->do_memory_protect.begin (address, size, prot, promise);
+
+			bool? result = script->process_events_until_ready (promise);
+			if (result == null)
+				return QuickJS.Exception;
+
+			return ctx.make_bool (result);
+		}
+
+		private async void do_memory_protect (uint64 address, size_t size, Gum.PageProtection prot, Promise<bool?> promise) {
+			try {
+				yield services.machine.protect_pages (address, size, prot, io_cancellable);
+
+				promise.resolve (true);
+			} catch (GLib.Error e) {
+				promise.resolve (false);
+			}
+		}
+
 		private static QuickJS.Value on_memory_scan (QuickJS.Context ctx, QuickJS.Value this_val, QuickJS.Value[] argv) {
 			BareboneScript * script = ctx.get_opaque ();

@@ -1665,6 +1835,67 @@ namespace Frida {
 			return QuickJS.Undefined;
 		}

+		private static QuickJS.Value on_c_module_construct (QuickJS.Context ctx, QuickJS.Value new_target,
+				QuickJS.Value[] argv) {
+			BareboneScript * script = ctx.get_opaque ();
+
+			Bytes blob;
+			if (!script->unparse_bytes (argv[0], out blob))
+				return QuickJS.Exception;
+
+			var promise = new Promise<Barebone.CModule> ();
+			script->load_c_module.begin (blob, promise);
+
+			Barebone.CModule? mod = script->process_events_until_ready (promise);
+			if (mod == null)
+				return QuickJS.Exception;
+
+			var proto = new_target.get_property (ctx, script->prototype_key);
+			var wrapper = ctx.make_object_with_proto_and_class (proto, c_module_class);
+			ctx.free_value (proto);
+
+			wrapper.set_opaque (mod);
+			script->c_modules.add (mod);
+
+			foreach (var e in mod.exports)
+				wrapper.set_property_str (ctx, e.name, script->make_native_pointer (e.address));
+
+			mod.console_output.connect (script->on_console_output);
+
+			return wrapper;
+		}
+
+		private async void load_c_module (Bytes blob, Promise<Barebone.CModule> promise) {
+			try {
+				var mod = yield new Barebone.CModule.from_blob (blob, services.machine, services.allocator, io_cancellable);
+
+				promise.resolve (mod);
+			} catch (GLib.Error e) {
+				promise.reject (e);
+			}
+		}
+
+		private static void on_c_module_finalize (QuickJS.Runtime rt, QuickJS.Value val) {
+			Barebone.CModule * mod = val.get_opaque (c_module_class);
+			if (mod == null)
+				return;
+
+			BareboneScript * script = rt.get_opaque ();
+			script->c_modules.remove (mod);
+		}
+
+		private static QuickJS.Value on_c_module_dispose (QuickJS.Context ctx, QuickJS.Value this_val, QuickJS.Value[] argv) {
+			Barebone.CModule * mod = this_val.get_opaque (c_module_class);
+
+			if (mod != null) {
+				this_val.set_opaque (null);
+				BareboneScript * script = ctx.get_opaque ();
+				script->c_modules.remove (mod);
+			}
+
+			return QuickJS.Undefined;
+		}
+
 		private static QuickJS.Value on_rust_module_construct (QuickJS.Context ctx, QuickJS.Value new_target,
 				QuickJS.Value[] argv) {
 			BareboneScript * script = ctx.get_opaque ();
@@ -1734,7 +1965,7 @@ namespace Frida {
 			foreach (var e in mod.exports)
 				wrapper.set_property_str (ctx, e.name, script->make_native_pointer (e.address));

-			mod.console_output.connect (script->on_rust_module_console_output);
+			mod.console_output.connect (script->on_console_output);

 			return wrapper;
 		}
@@ -1772,7 +2003,7 @@ namespace Frida {
 			return QuickJS.Undefined;
 		}

-		private void on_rust_module_console_output (string message) {
+		private void on_console_output (string message) {
 			var builder = new Json.Builder ();
 			builder
 				.begin_object ()
@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "Node16",
+    "strict": true,
+    "noEmit": true
+  },
+  "include": ["script-runtime/**/*.ts"]
+}
@@ -1,469 +0,0 @@
-import * as crosspath from "@frida/crosspath";
-import type * as backend from "frida-compile";
-import {
-    makeDefaultCompilerOptions,
-    build as _build,
-    watch as _watch,
-    queryDefaultAssets as _queryDefaultAssets,
-} from "frida-compile";
-import ts from "frida-compile/ext/typescript.js";
-import fridaFs from "frida-fs";
-import fs from "fs";
-
-const { DiagnosticCategory, FileWatcherEventKind } = ts;
-
-const { S_IFDIR } = fs.constants;
-
-export const compilerRoot = "/frida-compile";
-export const compilerNodeModules = compilerRoot + "/node_modules";
-
-export const agentDirectories = new Set<string>(__agentDirectories__);
-export const agentFiles = new Map<string, string>(__agentFiles__);
-const cachedSourceFiles = new Map<string, ts.SourceFile>();
-
-declare const __agentDirectories__: string[];
-declare const __agentFiles__: [string, string][];
-
-const pendingDiagnostics: ts.Diagnostic[] = [];
-
-const fileWatchers = new Map<WatcherId, WatcherCallback>();
-let nextWatcherId: WatcherId = 1;
-
-populateSourceFileCache();
-
-function populateSourceFileCache() {
-    const config = makeDefaultCompilerOptions();
-    for (const [name, contents] of agentFiles) {
-        if (name.endsWith(".d.ts")) {
-            const sf = ts.createSourceFile(name, contents, config.target!);
-            ts.prebindSourceFile(sf, config);
-            cachedSourceFiles.set(name, sf);
-        }
-    }
-}
-
-export function init(): void {
-    function onChange(message: WatchChangeMessage): void {
-        const callback = fileWatchers.get(message.id);
-        callback?.(fileWatcherEventKindFromFileState(message.state));
-
-        recv("watch:change", onChange);
-    }
-    recv("watch:change", onChange);
-
-    const origCreateCompilerHostFromProgramHost = (ts as any).createCompilerHostFromProgramHost;
-    (ts as any).createCompilerHostFromProgramHost = (...args: any[]): ts.CompilerHost => {
-        const host = origCreateCompilerHostFromProgramHost(...args);
-        patchCompilerHost(host);
-        return host;
-    };
-}
-
-export function build(projectRoot: string, entrypoint: string, sourceMaps: backend.SourceMaps, compression: backend.Compression): string {
-    const system = new FridaSystem(projectRoot);
-    const assets = _queryDefaultAssets(projectRoot, system);
-
-    try {
-        return _build({
-            projectRoot,
-            entrypoint,
-            assets,
-            system,
-            sourceMaps,
-            compression,
-            onDiagnostic,
-            onCompilerHostCreated: patchCompilerHost,
-        });
-    } finally {
-        flushDiagnostics();
-    }
-}
-
-export function watch(projectRoot: string, entrypoint: string, sourceMaps: backend.SourceMaps, compression: backend.Compression): void {
-    const system = new FridaSystem(projectRoot);
-    const assets = _queryDefaultAssets(projectRoot, system);
-    _watch({
-        projectRoot,
-        entrypoint,
-        assets,
-        system,
-        sourceMaps,
-        compression,
-        onDiagnostic,
-    })
-        .on("compilationStarting", () => {
-            send(["watch:compilation-starting"]);
-        })
-        .on("compilationFinished", () => {
-            send(["watch:compilation-finished"]);
-        })
-        .on("bundleUpdated", bundle => {
-            send(["watch:bundle-updated", bundle]);
-        });
-}
-
-function patchCompilerHost(host: ts.CompilerHost) {
-    const origGetSourceFile = host.getSourceFile;
-    host.getSourceFile = (fileName, ...args) => {
-        const compilerPath = nativePathToCompilerPath(fileName);
-        if (compilerPath !== null) {
-            const sf = cachedSourceFiles.get(compilerPath);
-            if (sf !== undefined) {
-                return sf;
-            }
-        } else {
-            const startPos = fileName.indexOf("/node_modules/@types/");
-            if (startPos !== -1) {
-                const builtinsPath = fileName.substring(startPos);
-                const sf = cachedSourceFiles.get(builtinsPath);
-                if (sf !== undefined) {
-                    let allowCache = true;
-
-                    if (builtinsPath.startsWith("/node_modules/@types/frida-gum/")) {
-                        try {
-                            const hashOnDisk = Checksum.compute("sha256", File.readAllText(fileName));
-                            const hashInCache = Checksum.compute("sha256", agentFiles.get(sf.fileName)!);
-                            allowCache = hashOnDisk === hashInCache;
-                        } catch (e) {
-                        }
-                    }
-
-                    if (allowCache) {
-                        return sf;
-                    }
-                }
-            }
-        }
-
-        return origGetSourceFile(fileName, ...args);
-    };
-}
-
-export { _build, _watch, _queryDefaultAssets };
-
-type DiagnosticFile = [path: string, line: number, character: number];
-
-function onDiagnostic(diagnostic: ts.Diagnostic): void {
-    pendingDiagnostics.push(diagnostic);
-    if (pendingDiagnostics.length === 1) {
-        Script.nextTick(flushDiagnostics);
-    }
-}
-
-function flushDiagnostics(): void {
-    const pending = pendingDiagnostics.splice(0, pendingDiagnostics.length);
-    if (pending.length === 0) {
-        return;
-    }
-
-    send([
-        "diagnostics",
-        pending.map(({
-            category,
-            code,
-            file: tsFile,
-            start,
-            messageText
-        }) => {
-            let file: DiagnosticFile | null = null;
-            if (tsFile !== undefined) {
-                const { line, character } = ts.getLineAndCharacterOfPosition(tsFile, start!);
-                file = [tsFile.fileName, line, character];
-            }
-            return [
-                diagnosticCategoryToString(category),
-                code,
-                file,
-                ts.flattenDiagnosticMessageText(messageText, "\n")
-            ];
-        }),
-    ]);
-}
-
-function diagnosticCategoryToString(category: ts.DiagnosticCategory): string {
-    switch (category) {
-        case DiagnosticCategory.Warning:
-            return "warning";
-        case DiagnosticCategory.Error:
-            return "error";
-        case DiagnosticCategory.Suggestion:
-            return "suggestion";
-        case DiagnosticCategory.Message:
-            return "message";
-    }
-}
-
-class FridaSystem implements ts.System {
-    args = [];
-    newLine = "\n";
-    useCaseSensitiveFileNames = true;
-
-    #projectRoot: string;
-    #projectNodeModules: string;
-
-    constructor(projectRoot: string) {
-        this.#projectRoot = crosspath.ensurePosix(projectRoot);
-        this.#projectNodeModules = crosspath.join(this.#projectRoot, "node_modules");
-    }
-
-    write(s: string): void {
-    }
-
-    writeOutputIsTTY(): boolean {
-        return true;
-    }
-
-    readFile(path: string, encoding?: string): string | undefined {
-        let result: string | undefined;
-        if (path.startsWith(this.#projectRoot)) {
-            try {
-                result = File.readAllText(path);
-            } catch (e) {
-            }
-        }
-
-        if (result === undefined) {
-            const agentZipPath = this.#nativePathToAgentZipPath(path);
-            if (agentZipPath !== null) {
-                result = agentFiles.get(agentZipPath);
-            }
-        }
-
-        return result;
-    }
-
-    getFileSize(path: string): number {
-        throw new Error("not implemented");
-    }
-
-    writeFile(path: string, data: string, writeByteOrderMark?: boolean): void {
-        File.writeAllText(path, data);
-    }
-
-    watchFile(path: string, callback: ts.FileWatcherCallback, pollingInterval?: number, options?: ts.WatchOptions): ts.FileWatcher {
-        if (path.startsWith(compilerRoot)) {
-            return makeDummyWatcher();
-        }
-
-        return makeFileWatcher(path, "file", pollingInterval ?? 0, kind => {
-            callback(path, kind);
-        });
-    }
-
-    watchDirectory(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean, options?: ts.WatchOptions): ts.FileWatcher {
-        if (path.startsWith(compilerRoot)) {
-            return makeDummyWatcher();
-        }
-
-        return makeFileWatcher(path, "directory", 0, kind => {
-            callback(path);
-        });
-    }
-
-    resolvePath(path: string): string {
-        return path;
-    }
-
-    fileExists(path: string): boolean {
-        if (path.startsWith(this.#projectRoot)) {
-            try {
-                const st = fs.statSync(path);
-                return !st.isDirectory();
-            } catch (e) {
-            }
-        }
-
-        const agentZipPath = this.#nativePathToAgentZipPath(path);
-        if (agentZipPath === null) {
-            return false;
-        }
-        return agentFiles.has(agentZipPath);
-    }
-
-    directoryExists(path: string): boolean {
-        if (path === compilerNodeModules) {
-            return true;
-        }
-
-        if (path.startsWith(this.#projectRoot)) {
-            try {
-                const st = fs.statSync(path);
-                return st.isDirectory();
-            } catch (e) {
-            }
-        }
-
-        const agentZipPath = this.#nativePathToAgentZipPath(path);
-        if (agentZipPath === null) {
-            return false;
-        }
-        return agentDirectories.has(agentZipPath);
-    }
-
-    createDirectory(path: string): void {
-        throw new Error("not implemented");
-    }
-
-    getExecutingFilePath(): string {
-        return [compilerRoot, "ext", "typescript.js"].join("/");
-    }
-
-    getCurrentDirectory(): string {
-        return this.#projectRoot;
-    }
-
-    getDirectories(path: string): string[] {
-        const result = new Set<string>();
-
-        if (path.startsWith(this.#projectRoot)) {
-            try {
-                for (const entry of fridaFs.list(path).filter(entry => entry.type === S_IFDIR)) {
-                    result.add(entry.name);
-                }
-            } catch (e) {
-            }
-        }
-
-        const agentZipPath = this.#nativePathToAgentZipPath(path);
-        if (agentZipPath !== null) {
-            for (const dir of agentDirectories) {
-                const slashIndex = dir.lastIndexOf("/");
-                const parent = dir.substring(0, slashIndex);
-                if (parent === agentZipPath) {
-                    const basename = dir.substring(slashIndex + 1);
-                    result.add(basename);
-                }
-            }
-        }
-
-        return Array.from(result);
-    }
-
-    readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[] {
-        return [];
-    }
-
-    getModifiedTime(path: string): Date | undefined {
-        return undefined;
-    }
-
-    setModifiedTime(path: string, time: Date): void {
-    }
-
-    deleteFile(path: string): void {
-    }
-
-    createHash(data: string): string {
-        return this.createSHA256Hash(data);
-    }
-
-    createSHA256Hash(data: string): string {
-        return Checksum.compute("sha256", data);
-    }
-
-    getMemoryUsage(): number {
-        return Frida.heapSize;
-    }
-
-    exit(exitCode?: number): void {
-    }
-
-    realpath(path: string): string {
-        return path;
-    }
-
-    getEnvironmentVariable(name: string): string {
-        return "";
-    }
-
-    setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any {
-        return setTimeout(callback);
-    }
-
-    clearTimeout(timeoutId: any): void {
-        return clearTimeout(timeoutId);
-    }
-
-    clearScreen(): void {
-    }
-
-    base64decode(input: string): string {
-        throw new Error("not implemented");
-    }
-
-    base64encode(input: string): string {
-        throw new Error("not implemented");
-    }
-
-    #nativePathToAgentZipPath(path: string): string | null {
-        const compilerPath = nativePathToCompilerPath(path);
-        if (compilerPath !== null) {
-            return compilerPath;
-        }
-
-        if (path.startsWith(this.#projectNodeModules)) {
-            return "/node_modules" + path.substring(this.#projectNodeModules.length);
-        }
-
-        return null;
-    }
-}
-
-function nativePathToCompilerPath(path: string): string | null {
-    if (!path.startsWith(compilerRoot)) {
-        return null;
-    }
-
-    const subPath = path.substring(compilerRoot.length);
-    if (subPath.startsWith("/node_modules")) {
-        return subPath;
-    }
-
-    return "/node_modules/frida-compile" + subPath;
-}
-
-type WatcherId = number;
-type WatcherCallback = (eventKind: ts.FileWatcherEventKind) => void;
-type FileState = "pristine" | "modified" | "deleted";
-
-interface WatchChangeMessage {
-    id: WatcherId;
-    state: FileState;
-}
-
-function makeFileWatcher(path: string, type: "file" | "directory", pollingInterval: number, callback: WatcherCallback): ts.FileWatcher {
-    if (nextWatcherId === 0xffffffff) {
-        nextWatcherId = 1;
-    }
-    let id: WatcherId = nextWatcherId++;
-    while (fileWatchers.has(id)) {
-        id = nextWatcherId++;
-    }
-
-    fileWatchers.set(id, callback);
-
-    send(["watch:add", id, path, type, pollingInterval ?? 0]);
-
-    return {
-        close() {
-            send(["watch:remove", id]);
-
-            fileWatchers.delete(id);
-        }
-    };
-}
-
-function makeDummyWatcher(): ts.FileWatcher {
-    return {
-        close() {
-        }
-    };
-}
-
-function fileWatcherEventKindFromFileState(state: FileState): ts.FileWatcherEventKind {
-    switch (state) {
-        case "pristine": return FileWatcherEventKind.Created;
-        case "modified": return FileWatcherEventKind.Changed;
-        case "deleted": return FileWatcherEventKind.Deleted;
-    }
-}
@@ -1,5 +0,0 @@
-const { init, build, watch } = FridaCompilerAgentCore;
-
-init();
-
-rpc.exports = { build, watch };
@@ -1,222 +0,0 @@
-const {
-  compilerRoot,
-  compilerNodeModules,
-  agentDirectories,
-  agentFiles,
-  _build,
-  _queryDefaultAssets,
-} = FridaCompilerAgentCore;
-
-const projectRoot = '/agent';
-const projectNodeModules = '/agent/node_modules';
-const entrypoint = 'index.ts';
-const sourceMaps = 'included';
-const compression = 'none';
-
-const hashes = new Map();
-let nextHashId = 1;
-
-function main() {
-  const system = new StubSystem();
-  const assets = _queryDefaultAssets(projectRoot, system);
-  _build({
-    projectRoot,
-    entrypoint,
-    assets,
-    system,
-    sourceMaps,
-    compression,
-    onDiagnostic,
-  });
-}
-
-function onDiagnostic(diagnostic) {
-  throwNotImplemented('diagnostic', ts.flattenDiagnosticMessageText(diagnostic, '\n'));
-}
-
-class StubSystem {
-  args = [];
-  newLine = '\n';
-  useCaseSensitiveFileNames = true;
-
-  write(s) {
-  }
-
-  writeOutputIsTTY() {
-    return true;
-  }
-
-  readFile(path, encoding) {
-    if (path === '/agent/tsconfig.json')
-      return '{}';
-
-    if (path === '/agent/index.ts')
-      return 'Interceptor.attach(ptr(1234), { onEnter(args) {} });'
-
-    const agentZipPath = this.#nativePathToAgentZipPath(path);
-    if (agentZipPath !== null) {
-      return agentFiles.get(agentZipPath);
-    }
-
-    throwNotImplemented('readFile', path);
-  }
-
-  getFileSize(path) {
-    throwNotImplemented('getFileSize');
-  }
-
-  writeFile(path, data, writeByteOrderMark) {
-    throwNotImplemented('writeFile');
-  }
-
-  watchFile(path, callback, pollingInterval, options) {
-    throwNotImplemented('watchFile');
-  }
-
-  watchDirectory(path, callback, recursive, options) {
-    throwNotImplemented('watchDirectory');
-  }
-
-  resolvePath(path) {
-    throwNotImplemented('resolvePath');
-  }
-
-  fileExists(path) {
-    if (path === '/package.json' || path === '/agent/package.json')
-      return false;
-
-    const agentZipPath = this.#nativePathToAgentZipPath(path);
-    if (agentZipPath !== null)
-      return agentFiles.has(agentZipPath);
-
-    throwNotImplemented('fileExists', path);
-  }
-
-  directoryExists(path) {
-    if (path === '/' || path === projectRoot || path === compilerNodeModules)
-      return true;
-
-    const agentZipPath = this.#nativePathToAgentZipPath(path);
-    if (agentZipPath !== null)
-      return agentDirectories.has(agentZipPath);
-
-    if (path === '/node_modules/@types' || path === '/node_modules')
-      return false;
-
-    throwNotImplemented('directoryExists', path);
-  }
-
-  createDirectory(path) {
-    throwNotImplemented('createDirectory');
-  }
-
-  getExecutingFilePath() {
-    return [compilerRoot, 'ext', 'typescript.js'].join('/');
-  }
-
-  getCurrentDirectory() {
-    return '/';
-  }
-
-  getDirectories(path) {
-    const agentZipPath = this.#nativePathToAgentZipPath(path);
-    if (agentZipPath !== null) {
-      const result = [];
-      for (const dir of agentDirectories) {
-        const slashIndex = dir.lastIndexOf('/');
-        const parent = dir.substring(0, slashIndex);
-        if (parent === agentZipPath) {
-          const basename = dir.substring(slashIndex + 1);
-          result.push(basename);
-        }
-      }
-      return result;
-    }
-
-    throwNotImplemented('getDirectories', path);
-  }
-
-  readDirectory(path, extensions, exclude, include, depth) {
-    if (!extensions.includes('.ts'))
-      throwNotImplemented('readDirectory', path, extensions);
-    return ['index.ts'];
-  }
-
-  getModifiedTime(path) {
-  }
-
-  setModifiedTime(path, time) {
-  }
-
-  deleteFile(path) {
-  }
-
-  createHash(data) {
-    let hash = hashes.get(data);
-    if (hash === undefined) {
-      hash = 'hash' + nextHashId++;
-      hashes.set(data, hash);
-    }
-    return hash;
-  }
-
-  createSHA256Hash(data) {
-    throwNotImplemented('createSHA256Hash');
-  }
-
-  getMemoryUsage() {
-    throwNotImplemented('getMemoryUsage');
-  }
-
-  exit(exitCode) {
-  }
-
-  realpath(path) {
-    return path;
-  }
-
-  getEnvironmentVariable(name) {
-    return '';
-  }
-
-  setTimeout(callback, ms, ...args) {
-    throwNotImplemented('setTimeout');
-  }
-
-  clearTimeout(timeoutId) {
-    throwNotImplemented('clearTimeout');
-  }
-
-  clearScreen() {
-  }
-
-  base64decode(input) {
-    throwNotImplemented('base64decode');
-  }
-
-  base64encode(input) {
-    throwNotImplemented('base64encode');
-  }
-
-  #nativePathToAgentZipPath(path) {
-    if (path.startsWith(compilerRoot)) {
-      const subPath = path.substring(compilerRoot.length);
-      if (subPath.startsWith('/node_modules')) {
-        return subPath;
-      }
-      return '/node_modules/frida-compile' + subPath;
-    }
-
-    if (path.startsWith(projectNodeModules)) {
-      return '/node_modules' + path.substring(projectNodeModules.length);
-    }
-
-    return null;
-  }
-}
-
-function throwNotImplemented(operation, ...details) {
-  throw new Error('not implemented: ' + operation + ((details.length > 0) ? ` (${details.join(' ')})` : ''));
-}
-
-main();
@@ -0,0 +1,28 @@
+#ifdef _MSC_VER
+
+#include <glib.h>
+
+#ifdef HAVE_ARM64
+# define FRIDA_CGO_INIT_FUNC _st0_arm64_windows_lib
+#elif GLIB_SIZEOF_VOID_P == 8
+# define FRIDA_CGO_INIT_FUNC _st0_amd64_windows_lib
+#else
+# define FRIDA_CGO_INIT_FUNC st0_386_windows_lib
+#endif
+
+extern void FRIDA_CGO_INIT_FUNC ();
+
+void
+_frida_compiler_backend_init_go_runtime (void)
+{
+  FRIDA_CGO_INIT_FUNC ();
+}
+
+#else
+
+void
+_frida_compiler_backend_init_go_runtime (void)
+{
+}
+
+#endif
@@ -0,0 +1,816 @@
+package main
+
+/*
+#include <stdint.h>
+
+typedef enum {
+  FRIDA_OUTPUT_UNESCAPED,
+  FRIDA_OUTPUT_HEX_BYTES,
+  FRIDA_OUTPUT_C_STRING,
+} FridaOutputFormat;
+
+typedef enum {
+  FRIDA_BUNDLE_ESM,
+  FRIDA_BUNDLE_IIFE,
+} FridaBundleFormat;
+
+typedef void (* FridaBuildCompleteFunc) (char * bundle, char * error_message, void * user_data);
+typedef void (* FridaWatchReadyFunc) (uintptr_t session_handle, char * error_message, void * user_data);
+typedef void (* FridaStartingFunc) (void * user_data);
+typedef void (* FridaFinishedFunc) (void * user_data);
+typedef void (* FridaOutputFunc) (char * bundle, void * user_data);
+typedef void (* FridaDiagnosticFunc) (char * category, int code, char * path, int line, int character, char * text,
+    void * user_data);
+typedef void (* FridaDestroyFunc) (void * user_data);
+
+static inline void
+invoke_build_complete_func (FridaBuildCompleteFunc fn,
+                            char * bundle,
+                            char * error_message,
+                            void * user_data)
+{
+  fn (bundle, error_message, user_data);
+}
+
+static inline void
+invoke_watch_ready_func (FridaWatchReadyFunc fn,
+                         uintptr_t session_handle,
+                         char * error_message,
+                         void * user_data)
+{
+  fn (session_handle, error_message, user_data);
+}
+
+static inline void
+invoke_starting_func (FridaStartingFunc fn,
+                      void * user_data)
+{
+  fn (user_data);
+}
+
+static inline void
+invoke_finished_func (FridaFinishedFunc fn,
+                      void * user_data)
+{
+  fn (user_data);
+}
+
+static inline void
+invoke_output_func (FridaOutputFunc fn,
+                    char * bundle,
+                    void * user_data)
+{
+  fn (bundle, user_data);
+}
+
+static inline void
+invoke_diagnostic_func (FridaDiagnosticFunc fn,
+                        char * category,
+                        int code,
+                        char * path,
+                        int line,
+                        int character,
+                        char * text,
+                        void * user_data)
+{
+  fn (category, code, path, line, character, text, user_data);
+}
+
+static inline void
+invoke_destroy_func (FridaDestroyFunc fn,
+                     void * user_data)
+{
+  fn (user_data);
+}
+*/
+import "C"
+
+import (
+	"fmt"
+	"path"
+	"path/filepath"
+	"runtime/cgo"
+	"strings"
+	"sync"
+	"unsafe"
+
+	esbuild "github.com/evanw/esbuild/pkg/api"
+	tsscanner "github.com/frida/typescript-go/pkg/scanner"
+)
+
+type BuildOptions struct {
+	ProjectRoot      string
+	Entrypoint       string
+	OutputFormat     OutputFormat
+	BundleFormat     BundleFormat
+	DisableTypeCheck bool
+	SourceMap        bool
+	Compress         bool
+}
+
+type OutputFormat C.FridaOutputFormat
+
+const (
+	OutputFormatUnescaped OutputFormat = OutputFormat(C.FRIDA_OUTPUT_UNESCAPED)
+	OutputFormatHexBytes  OutputFormat = OutputFormat(C.FRIDA_OUTPUT_HEX_BYTES)
+	OutputFormatCString   OutputFormat = OutputFormat(C.FRIDA_OUTPUT_C_STRING)
+)
+
+type BundleFormat C.FridaBundleFormat
+
+const (
+	BundleFormatESM  BundleFormat = BundleFormat(C.FRIDA_BUNDLE_ESM)
+	BundleFormatIIFE BundleFormat = BundleFormat(C.FRIDA_BUNDLE_IIFE)
+)
+
+type Diagnostic struct {
+	category        string
+	code            int
+	path            string
+	line, character int
+	text            string
+}
+
+type BuildEventCallbacks struct {
+	OnStart        BuildStartCallback
+	OnEnd          BuildEndCallback
+	OnOutput       BuildOutputCallback
+	OnDiagnostic   BuildDiagnosticCallback
+	OnConfigChange ConfigChangeCallback
+}
+
+type BuildStartCallback func()
+type BuildEndCallback func()
+type BuildOutputCallback func(bundle string)
+type BuildDiagnosticCallback func(d Diagnostic)
+
+//export _frida_compiler_backend_build
+func _frida_compiler_backend_build(cProjectRoot, cEntrypoint *C.char, outputFormat C.FridaOutputFormat, bundleFormat C.FridaBundleFormat,
+	disableTypeCheck, sourceMap, compress uintptr,
+	onCompleteFn C.FridaBuildCompleteFunc, onCompleteData unsafe.Pointer, onCompleteDataDestroy C.FridaDestroyFunc,
+	onDiagnosticFn C.FridaDiagnosticFunc, onDiagnosticData unsafe.Pointer) {
+	options := BuildOptions{
+		ProjectRoot:      C.GoString(cProjectRoot),
+		Entrypoint:       C.GoString(cEntrypoint),
+		OutputFormat:     OutputFormat(outputFormat),
+		BundleFormat:     BundleFormat(bundleFormat),
+		DisableTypeCheck: disableTypeCheck != 0,
+		SourceMap:        sourceMap != 0,
+		Compress:         compress != 0,
+	}
+	onComplete := NewCDelegate(onCompleteFn, onCompleteData, onCompleteDataDestroy)
+	onDiagnostic := NewCDelegate(onDiagnosticFn, onDiagnosticData, nil)
+
+	go func() {
+		defer onComplete.Dispose()
+		defer onDiagnostic.Dispose()
+
+		onDiagnostic := makeCBuildDiagnosticCallback(onDiagnostic)
+
+		bundle, err := build(options, onDiagnostic)
+
+		var cBundle, cErrorMessage *C.char
+		if err == nil {
+			cBundle = C.CString(bundle)
+		} else {
+			cErrorMessage = C.CString(err.Error())
+		}
+		C.invoke_build_complete_func(onComplete.Func, cBundle, cErrorMessage, onComplete.Data)
+	}()
+}
+
+//export _frida_compiler_backend_watch
+func _frida_compiler_backend_watch(cProjectRoot, cEntrypoint *C.char, outputFormat C.FridaOutputFormat, bundleFormat C.FridaBundleFormat,
+	disableTypeCheck, sourceMap, compress uintptr,
+	onReadyFn C.FridaWatchReadyFunc, onReadyData unsafe.Pointer, onReadyDataDestroy C.FridaDestroyFunc,
+	onStartingFn C.FridaStartingFunc, onStartingData unsafe.Pointer,
+	onFinishedFn C.FridaFinishedFunc, onFinishedData unsafe.Pointer,
+	onOutputFn C.FridaOutputFunc, onOutputData unsafe.Pointer,
+	onDiagnosticFn C.FridaDiagnosticFunc, onDiagnosticData unsafe.Pointer) {
+	options := BuildOptions{
+		ProjectRoot:      C.GoString(cProjectRoot),
+		Entrypoint:       C.GoString(cEntrypoint),
+		OutputFormat:     OutputFormat(outputFormat),
+		BundleFormat:     BundleFormat(bundleFormat),
+		DisableTypeCheck: disableTypeCheck != 0,
+		SourceMap:        sourceMap != 0,
+		Compress:         compress != 0,
+	}
+	onReady := NewCDelegate(onReadyFn, onReadyData, onReadyDataDestroy)
+	onStarting := NewCDelegate(onStartingFn, onStartingData, nil)
+	onFinished := NewCDelegate(onFinishedFn, onFinishedData, nil)
+	onOutput := NewCDelegate(onOutputFn, onOutputData, nil)
+	onDiagnostic := NewCDelegate(onDiagnosticFn, onDiagnosticData, nil)
+
+	go func() {
+		defer onReady.Dispose()
+
+		onDispose := func() {
+			onStarting.Dispose()
+			onFinished.Dispose()
+			onOutput.Dispose()
+			onDiagnostic.Dispose()
+		}
+
+		callbacks := BuildEventCallbacks{
+			OnStart: func() {
+				C.invoke_starting_func(onStarting.Func, onStarting.Data)
+			},
+			OnEnd: func() {
+				C.invoke_starting_func(onFinished.Func, onFinished.Data)
+			},
+			OnOutput: func(bundle string) {
+				C.invoke_output_func(onOutput.Func, C.CString(bundle), onOutput.Data)
+			},
+			OnDiagnostic: makeCBuildDiagnosticCallback(onDiagnostic),
+		}
+
+		session, err := NewWatchSession(options, onDispose, callbacks)
+
+		var cSession C.uintptr_t
+		var cErrorMessage *C.char
+		if err == nil {
+			cSession = C.uintptr_t(cgo.NewHandle(session))
+		} else {
+			cErrorMessage = C.CString(err.Error())
+		}
+		C.invoke_watch_ready_func(onReady.Func, cSession, cErrorMessage, onReady.Data)
+	}()
+}
+
+//export _frida_compiler_backend_watch_session_dispose
+func _frida_compiler_backend_watch_session_dispose(h uintptr) {
+	handle := cgo.Handle(h)
+	session := handle.Value().(*WatchSession)
+	session.Dispose()
+	handle.Delete()
+}
+
+func makeCBuildDiagnosticCallback(onDiagnostic *CDelegate[C.FridaDiagnosticFunc]) BuildDiagnosticCallback {
+	return func(d Diagnostic) {
+		var cPath *C.char
+		if d.path != "" {
+			cPath = C.CString(d.path)
+		}
+
+		C.invoke_diagnostic_func(onDiagnostic.Func, C.CString(d.category), C.int(d.code), cPath, C.int(d.line),
+			C.int(d.character), C.CString(d.text), onDiagnostic.Data)
+	}
+}
+
+func build(options BuildOptions, onDiagnostic BuildDiagnosticCallback) (bundle string, err error) {
+	callbacks := BuildEventCallbacks{
+		OnOutput: func(b string) {
+			bundle = b
+		},
+		OnDiagnostic: onDiagnostic,
+	}
+
+	ctx, err := makeContext(options, callbacks)
+	if err != nil {
+		return
+	}
+	defer ctx.Dispose()
+
+	result := ctx.Rebuild()
+
+	if len(result.Errors) != 0 {
+		err = fmt.Errorf("Compilation failed")
+	}
+	return
+}
+
+type WatchSession struct {
+	mu        sync.Mutex
+	options   BuildOptions
+	callbacks BuildEventCallbacks
+	ctx       esbuild.BuildContext
+	onDispose SessionDisposeHandler
+}
+
+type SessionDisposeHandler func()
+
+func NewWatchSession(opts BuildOptions, onDispose SessionDisposeHandler, callbacks BuildEventCallbacks) (session *WatchSession, err error) {
+	cbs := BuildEventCallbacks{
+		OnStart:      callbacks.OnStart,
+		OnEnd:        callbacks.OnEnd,
+		OnOutput:     callbacks.OnOutput,
+		OnDiagnostic: callbacks.OnDiagnostic,
+		OnConfigChange: func() {
+			if callbacks.OnConfigChange != nil {
+				callbacks.OnConfigChange()
+			}
+			session.onConfigChange()
+		},
+	}
+
+	ctx, err := makeContext(opts, cbs)
+	if err != nil {
+		return
+	}
+
+	ctx.Watch(esbuild.WatchOptions{})
+
+	session = &WatchSession{
+		options:   opts,
+		callbacks: cbs,
+		ctx:       ctx,
+		onDispose: onDispose,
+	}
+	return
+}
+
+func (s *WatchSession) Dispose() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.ctx != nil {
+		s.ctx.Dispose()
+		s.ctx = nil
+	}
+
+	s.onDispose()
+}
+
+func (s *WatchSession) onConfigChange() {
+	go func() {
+		s.mu.Lock()
+		defer s.mu.Unlock()
+
+		if s.ctx != nil {
+			s.ctx.Dispose()
+			s.ctx = nil
+		}
+
+		ctx, err := makeContext(s.options, s.callbacks)
+		if err != nil {
+			return
+		}
+		s.ctx = ctx
+
+		ctx.Watch(esbuild.WatchOptions{})
+	}()
+}
+
+func makeContext(options BuildOptions, callbacks BuildEventCallbacks) (ctx esbuild.BuildContext, err error) {
+	var e error
+
+	var projectRoot string
+	if projectRoot, e = filepath.EvalSymlinks(options.ProjectRoot); e != nil {
+		err = fmt.Errorf("Failed to resolve project root: %w", e)
+		return
+	}
+
+	var entrypoint string
+	if filepath.IsAbs(options.Entrypoint) {
+		entrypoint = options.Entrypoint
+	} else {
+		entrypoint = filepath.Join(projectRoot, options.Entrypoint)
+	}
+	if entrypoint, e = filepath.EvalSymlinks(entrypoint); e != nil {
+		err = fmt.Errorf("Failed to resolve entrypoint: %w", e)
+		return
+	}
+	rel, e := filepath.Rel(projectRoot, entrypoint)
+	if e != nil {
+		err = fmt.Errorf("Could not compute entrypoint path relative to project root: %w", e)
+		return
+	}
+	if strings.HasPrefix(rel, "..") {
+		err = fmt.Errorf("Entrypoint must be inside the project root")
+		return
+	}
+
+	isTS := strings.HasSuffix(entrypoint, ".ts")
+
+	var tsconfigCache *TSConfigCache
+	var tsconfigText string
+	var tsCompiler *TSCompiler
+
+	if isTS {
+		tsconfigCache = NewTSConfigCache(projectRoot, options.SourceMap, callbacks.OnConfigChange)
+
+		tsCompiler = NewTSCompiler(projectRoot, entrypoint, tsconfigCache.GetCompilerOptions)
+
+		_, tsconfigText, err = tsconfigCache.GetCompilerOptions(tsCompiler)
+		if err != nil {
+			err = fmt.Errorf("Failed to load tsconfig options: %w", err)
+			return
+		}
+	}
+
+	sourcemapOption := esbuild.SourceMapNone
+	if options.SourceMap {
+		if options.BundleFormat == BundleFormatESM {
+			sourcemapOption = esbuild.SourceMapExternal
+		} else {
+			sourcemapOption = esbuild.SourceMapInline
+		}
+	}
+
+	minifyWhitespace := false
+	minifyIdentifiers := false
+	minifySyntax := false
+	if options.Compress {
+		minifyWhitespace = true
+		minifyIdentifiers = true
+		minifySyntax = true
+	}
+
+	var format esbuild.Format
+	if options.BundleFormat == BundleFormatESM {
+		format = esbuild.FormatESModule
+	} else {
+		format = esbuild.FormatIIFE
+	}
+
+	plugins := []esbuild.Plugin{
+		makeBuildObserverPlugin(projectRoot, entrypoint, options, callbacks),
+	}
+
+	if isTS && !options.DisableTypeCheck {
+		plugins = append(plugins, makeTypeScriptPlugin(tsCompiler))
+	}
+
+	plugins = append(plugins, makeFridaShimsPlugin())
+
+	buildOpts := esbuild.BuildOptions{
+		Sourcemap:         sourcemapOption,
+		SourcesContent:    esbuild.SourcesContentExclude,
+		Target:            esbuild.ES2022,
+		MinifyWhitespace:  minifyWhitespace,
+		MinifyIdentifiers: minifyIdentifiers,
+		MinifySyntax:      minifySyntax,
+		LegalComments:     esbuild.LegalCommentsNone,
+		Bundle:            true,
+		Outdir:            projectRoot,
+		AbsWorkingDir:     projectRoot,
+		Platform:          esbuild.PlatformNode,
+		Format:            format,
+		Inject:            []string{"frida-builtins:///node-globals.js"},
+		EntryPoints:       []string{entrypoint},
+		Write:             false,
+		Plugins:           plugins,
+	}
+
+	if isTS {
+		buildOpts.TsconfigRaw = tsconfigText
+	}
+
+	if buildCtx, ctxErr := esbuild.Context(buildOpts); ctxErr == nil {
+		ctx = buildCtx
+	} else {
+		for _, e := range ctxErr.Errors {
+			emitDiagnostic("error", e, callbacks.OnDiagnostic)
+		}
+		err = fmt.Errorf("Failed to create ESBuild context")
+	}
+	return
+}
+
+func emitDiagnostic(category string, message esbuild.Message, onDiagnostic BuildDiagnosticCallback) {
+	d := Diagnostic{
+		category: category,
+		code:     -1,
+		text:     message.Text,
+	}
+
+	l := message.Location
+	if l != nil {
+		d.path = l.File
+		d.line = l.Line
+		d.character = l.Column
+	}
+
+	if message.PluginName == "frida-custom-ts" && len(message.Notes) == 2 {
+		d.category = message.Notes[0].Text
+		fmt.Sscan(message.Notes[1].Text, &d.code)
+	}
+
+	onDiagnostic(d)
+}
+
+func changeToJS(p string) string {
+	ext := path.Ext(p)
+	base := p[:len(p)-len(ext)]
+	return base + ".js"
+}
+
+func makeBuildObserverPlugin(projectRoot, entrypoint string, options BuildOptions, callbacks BuildEventCallbacks) esbuild.Plugin {
+	return esbuild.Plugin{
+		Name: "frida-build-observer",
+		Setup: func(build esbuild.PluginBuild) {
+			if callbacks.OnStart != nil {
+				build.OnStart(func() (esbuild.OnStartResult, error) {
+					callbacks.OnStart()
+					return esbuild.OnStartResult{}, nil
+				})
+			}
+
+			build.OnEnd(func(result *esbuild.BuildResult) (esbuild.OnEndResult, error) {
+				if len(result.Errors) == 0 {
+					var output string
+					if options.BundleFormat == BundleFormatESM {
+						output = makeESMBundle(result.OutputFiles, projectRoot, entrypoint)
+					} else {
+						output = string(result.OutputFiles[0].Contents)
+					}
+
+					switch options.OutputFormat {
+					case OutputFormatHexBytes:
+						output = encodeStringToHexBytes(output)
+					case OutputFormatCString:
+						output = encodeStringToCString(output)
+					}
+
+					callbacks.OnOutput(output)
+				} else {
+					for _, e := range result.Errors {
+						emitDiagnostic("error", e, callbacks.OnDiagnostic)
+					}
+					for _, e := range result.Warnings {
+						emitDiagnostic("warning", e, callbacks.OnDiagnostic)
+					}
+				}
+
+				if callbacks.OnEnd != nil {
+					callbacks.OnEnd()
+				}
+
+				return esbuild.OnEndResult{}, nil
+			})
+		},
+	}
+}
+
+func makeESMBundle(files []esbuild.OutputFile, projectRoot, entrypoint string) string {
+	entrypointJS, entrypointMap := outputForEntrypoint(projectRoot, entrypoint)
+	relEntryp, err := filepath.Rel(projectRoot, entrypoint)
+	if err != nil {
+		panic(fmt.Sprintf("Cannot compute entrypoint relative path: %v", err))
+	}
+	entrySubDir := filepath.Dir(relEntryp)
+
+	entryIndexJS := -1
+	entryIndexMap := -1
+	for i, of := range files {
+		if of.Path == entrypointJS {
+			entryIndexJS = i
+		}
+		if of.Path == entrypointMap {
+			entryIndexMap = i
+		}
+	}
+	if entryIndexJS < 0 {
+		panic(fmt.Sprintf("Entrypoint JS %q not found in files", entrypointJS))
+	}
+
+	orderedFiles := make([]esbuild.OutputFile, 0, len(files))
+	orderedFiles = append(orderedFiles, files[entryIndexJS])
+	if entryIndexMap >= 0 {
+		orderedFiles = append(orderedFiles, files[entryIndexMap])
+	}
+
+	for i, of := range files {
+		if i == entryIndexJS || i == entryIndexMap {
+			continue
+		}
+		orderedFiles = append(orderedFiles, of)
+	}
+
+	var sb strings.Builder
+
+	sb.WriteString("📦\n")
+	for _, of := range orderedFiles {
+		size := len(of.Contents)
+		relPath, _ := filepath.Rel(projectRoot, of.Path)
+		withSub := filepath.Join(entrySubDir, relPath)
+		sb.WriteString(fmt.Sprintf("%d /%s\n", size, filepath.ToSlash(withSub)))
+	}
+
+	sb.WriteString("✄\n")
+	for i, of := range orderedFiles {
+		sb.Write(of.Contents)
+		if i < len(orderedFiles)-1 {
+			sb.WriteString("\n✄\n")
+		}
+	}
+
+	return sb.String()
+}
+
+func outputForEntrypoint(projectRoot, entrypoint string) (jsOut, mapOut string) {
+	jsOut = filepath.Join(projectRoot, changeToJS(filepath.Base(entrypoint)))
+	mapOut = jsOut + ".map"
+	return
+}
+
+func encodeStringToHexBytes(s string) string {
+	n := len(s)
+	if n == 0 {
+		return ""
+	}
+
+	totalLen := n*4 + (n-1)*2 + 1
+	buf := make([]byte, 0, totalLen)
+
+	hexDigits := "0123456789abcdef"
+	for i := 0; i < n; i++ {
+		b := s[i]
+		buf = append(buf, '0', 'x')
+		buf = append(buf,
+			hexDigits[b>>4],
+			hexDigits[b&0xF],
+		)
+
+		if i < n-1 {
+			if (i+1)%12 == 0 {
+				buf = append(buf, ',', '\n')
+			} else {
+				buf = append(buf, ',', ' ')
+			}
+		}
+	}
+
+	buf = append(buf, '\n')
+
+	return string(buf)
+}
+
+func encodeStringToCString(s string) string {
+	n := len(s)
+	if n == 0 {
+		return `""`
+	}
+
+	hexDigits := "0123456789abcdef"
+	var bldr strings.Builder
+
+	openLiteral := func() {
+		bldr.WriteByte('"')
+	}
+	closeLiteral := func() {
+		bldr.WriteByte('"')
+	}
+
+	inLiteral := false
+
+	for i := 0; i < n; i++ {
+		c := s[i]
+
+		if !inLiteral {
+			openLiteral()
+			inLiteral = true
+		}
+
+		if c == '\n' {
+			bldr.WriteByte('\\')
+			bldr.WriteByte('n')
+			closeLiteral()
+			inLiteral = false
+
+			if i < n-1 {
+				bldr.WriteByte('\n')
+				openLiteral()
+				inLiteral = true
+			}
+			continue
+		}
+
+		switch c {
+		case '"':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('"')
+		case '\\':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('\\')
+
+		case '\a':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('a')
+		case '\b':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('b')
+		case '\t':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('t')
+		case '\v':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('v')
+		case '\f':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('f')
+		case '\r':
+			bldr.WriteByte('\\')
+			bldr.WriteByte('r')
+
+		default:
+			isPrintableExceptQuoteAndBackslash := c >= 0x20 && c <= 0x7E
+			if isPrintableExceptQuoteAndBackslash {
+				bldr.WriteByte(c)
+			} else {
+				bldr.WriteByte('\\')
+				bldr.WriteByte('x')
+				bldr.WriteByte(hexDigits[c>>4])
+				bldr.WriteByte(hexDigits[c&0xF])
+			}
+		}
+	}
+
+	if inLiteral {
+		closeLiteral()
+	}
+
+	bldr.WriteByte('\n')
+
+	return bldr.String()
+}
+
+func makeTypeScriptPlugin(compiler *TSCompiler) esbuild.Plugin {
+	return esbuild.Plugin{
+		Name: "frida-custom-ts",
+		Setup: func(build esbuild.PluginBuild) {
+			build.OnStart(func() (esbuild.OnStartResult, error) {
+				compiler.EnsureProgramUpToDate()
+				return esbuild.OnStartResult{}, nil
+			})
+
+			build.OnEnd(func(result *esbuild.BuildResult) (esbuild.OnEndResult, error) {
+				if len(result.Errors) == 0 {
+					compiler.CommitPendingInputs()
+				} else {
+					compiler.DropPendingInputs()
+				}
+				return esbuild.OnEndResult{}, nil
+			})
+
+			build.OnLoad(esbuild.OnLoadOptions{Filter: "\\.ts$"}, func(args esbuild.OnLoadArgs) (esbuild.OnLoadResult, error) {
+				compiledJS, tsDiagnostics, err := compiler.Compile(args.Path)
+
+				result := esbuild.OnLoadResult{
+					WatchFiles: compiler.WatchFiles(),
+					WatchDirs:  compiler.WatchDirs(),
+				}
+
+				var esbuildMessages []esbuild.Message
+				for _, d := range tsDiagnostics {
+					f := d.File()
+					pos := d.Pos()
+					line, column := tsscanner.GetLineAndCharacterOfPosition(f, pos)
+
+					esbuildMessages = append(esbuildMessages, esbuild.Message{
+						Text: d.Message(),
+						Location: &esbuild.Location{
+							File:     f.FileName(),
+							Line:     line,
+							Column:   column,
+							Length:   d.Len(),
+							LineText: f.Text()[pos:d.End()],
+						},
+						Notes: []esbuild.Note{
+							{Text: d.Category().Name()},
+							{Text: fmt.Sprintf("%d", d.Code())},
+						},
+					})
+				}
+
+				if err != nil {
+					mainErr := esbuild.Message{Text: err.Error()}
+					result.Errors = append([]esbuild.Message{mainErr}, esbuildMessages...)
+					return result, nil
+				}
+
+				if len(esbuildMessages) > 0 {
+					result.Errors = esbuildMessages
+					return result, nil
+				}
+
+				result.Contents = &compiledJS
+				result.Loader = esbuild.LoaderJS
+				return result, nil
+			})
+		},
+	}
+}
+
+type CDelegate[F any] struct {
+	Func        F
+	null        F
+	Data        unsafe.Pointer
+	dataDestroy C.FridaDestroyFunc
+}
+
+func NewCDelegate[F any](function F, data unsafe.Pointer, dataDestroy C.FridaDestroyFunc) *CDelegate[F] {
+	return &CDelegate[F]{Func: function, Data: data, dataDestroy: dataDestroy}
+}
+
+func (d *CDelegate[F]) Dispose() {
+	if d.dataDestroy != nil {
+		C.invoke_destroy_func(d.dataDestroy, d.Data)
+	}
+	d.Func = d.null
+	d.Data = nil
+	d.dataDestroy = nil
+}
+
+func main() {}
@@ -0,0 +1,7 @@
+{
+  global:
+    _frida_compiler_backend_*;
+
+  local:
+    *;
+};
@@ -0,0 +1,375 @@
+import base64
+import json
+import os
+import shutil
+import struct
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+
+def main(argv):
+    go_config = json.loads(base64.b64decode(argv[1]).decode("utf-8"))
+    output_dir, priv_dir, go, npm, *inputs = [Path(d).resolve() for d in argv[2:]]
+
+    try:
+        build_backend(go_config, inputs, output_dir, priv_dir, go, npm)
+    except subprocess.CalledProcessError as e:
+        print(e, file=sys.stderr)
+        print(
+            "Output:\n\t| " + "\n\t| ".join(e.output.strip().split("\n")),
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    except Exception as e:
+        print(e, file=sys.stderr)
+        sys.exit(1)
+
+
+def build_backend(
+    config: dict,
+    inputs: List[Path],
+    output_dir: Path,
+    priv_dir: Path,
+    go: Path,
+    npm: Path,
+):
+    base_dir = min(inputs, key=lambda p: len(p.parts)).parent
+    for f in inputs:
+        dest = priv_dir / f.relative_to(base_dir)
+        dest.parent.mkdir(exist_ok=True)
+        shutil.copy(f, dest)
+
+    go_sources = [str(f.relative_to(base_dir)) for f in inputs if f.suffix == ".go"]
+
+    def run(*args):
+        return subprocess.run(
+            args,
+            cwd=priv_dir,
+            env=config["env"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            encoding="utf-8",
+            check=True,
+        )
+
+    run(npm, "install")
+    # run(npm, "link", "/home/oleavr/src/frida-fs")
+
+    mode = config["mode"]
+
+    backend_stem = "frida-compiler-backend"
+    if mode == "c-shared":
+        backend_stem += "-raw"
+
+    backend_a = priv_dir / f"{backend_stem}.a"
+    backend_shlib = priv_dir / (f"{backend_stem}" + config["shlib_suffix"])
+    backend_h = priv_dir / f"{backend_stem}.h"
+
+    extra_go_args = config["extra_go_args"].copy()
+
+    if mode == "c-shared":
+        version_script = priv_dir / "backend.version"
+        extra_go_args.append(f"-ldflags=-linkmode=external -extldflags=-Wl,--version-script={version_script}")
+
+    run(
+        go,
+        "build",
+        f"-buildmode={mode}",
+        "-o",
+        backend_a.name if mode == "c-archive" else backend_shlib.name,
+        "-buildvcs=false",
+        *extra_go_args,
+        *go_sources,
+    )
+
+    if mode == "c-archive":
+        symbols_to_scramble = detect_conflictful_symbols_in_archive(backend_a, config["nm"])
+        scramble_symbols_in_archive(backend_a, symbols_to_scramble, config["ranlib"])
+
+        if (mingw := config.get("mingw")) is not None and (abi := config["abi"]) in {
+            "x86",
+            "x86_64",
+        }:
+            prefix = Path(mingw["prefix"])
+            ar = config["ar"]
+
+            libmingwex_a = prefix / "lib" / "libmingwex.a"
+            if not libmingwex_a.exists():
+                libmingwex_a = prefix / mingw["triplet"] / "lib" / "libmingwex.a"
+
+            libgcc_objects = [
+                "_chkstk_ms.o",
+            ]
+            run(*ar, "x", mingw["libcc"], *libgcc_objects)
+
+            gwex_objflavor = "64" if abi == "x86_64" else "32"
+            gwex_objects = [
+                f"lib{gwex_objflavor}_libmingwex_a-{name}.o"
+                for name in [
+                    "dmisc",
+                    "gdtoa",
+                    "gmisc",
+                    "mingw_fprintf",
+                    "mingw_pformat",
+                    "misc",
+                ]
+            ]
+            run(*ar, "x", libmingwex_a, *gwex_objects)
+
+            extra_objects = []
+            if abi == "x86_64":
+                run(*ar, "x", backend_a.name, "go.o")
+                sort_pdata_in_object(Path(priv_dir) / "go.o")
+                extra_objects.append("go.o")
+
+            run(*ar, "rs", backend_a.name, *libgcc_objects, *gwex_objects, *extra_objects)
+
+        shutil.copy(priv_dir / backend_a.name, output_dir / backend_a.name)
+    else:
+        shutil.copy(priv_dir / backend_shlib.name, output_dir / backend_shlib.name)
+
+    shutil.copy(priv_dir / backend_h.name, output_dir / backend_h.name)
+
+
+def detect_conflictful_symbols_in_archive(
+    archive: Path, nm_cmd_array: List[str]
+) -> List[str]:
+    result = []
+    for line in subprocess.run(
+        [*nm_cmd_array, str(archive)], capture_output=True, encoding="utf-8", check=True
+    ).stdout.splitlines():
+        tokens = line.lstrip().split(" ")
+        if len(tokens) >= 3 and tokens[1] in {"S", "T"}:
+            symbol = tokens[2]
+            if all(sub not in symbol for sub in ("/", ".", ":", "frida")):
+                result.append(symbol)
+    return result
+
+
+def scramble_symbols_in_archive(
+    archive: Path, symbols: List[str], ranlib_cmd_array: List[str]
+):
+    data = archive.read_bytes()
+
+    for old_sym in symbols:
+        new_sym = roll_first_alpha(old_sym)
+        data = data.replace(old_sym.encode("ascii"), new_sym.encode("ascii"))
+
+    archive.write_bytes(data)
+
+    subprocess.run([*ranlib_cmd_array, str(archive)], check=True)
+
+
+def roll_first_alpha(s: str) -> str:
+    chars = list(s)
+    for i, c in enumerate(chars):
+        if c.isalpha():
+            if c == "z":
+                chars[i] = "a"
+            elif c == "Z":
+                chars[i] = "A"
+            else:
+                chars[i] = chr(ord(c) + 1)
+            break
+    return "".join(chars)
+
+
+# Work around the Go toolchain's almost-MSVC-compatible object files
+# until our patch is merged upstream:
+# https://go-review.googlesource.com/c/go/+/678795
+def sort_pdata_in_object(object_file: Path):
+    data = bytearray(object_file.read_bytes())
+
+    # --- Parse COFF File Header (IMAGE_FILE_HEADER) ---
+    # Format: WORD Machine; WORD NumberOfSections;
+    #         DWORD TimeDateStamp; DWORD PointerToSymbolTable;
+    #         DWORD NumberOfSymbols; WORD SizeOfOptionalHeader;
+    #         WORD Characteristics;
+    IMAGE_FILE_HEADER_FMT = "<HHLLLHH"
+    IMAGE_FILE_HEADER_SIZE = struct.calcsize(IMAGE_FILE_HEADER_FMT)
+
+    if len(data) < IMAGE_FILE_HEADER_SIZE:
+        print("Error: File too small to be a valid COFF object", file=sys.stderr)
+        return
+
+    (
+        machine,
+        number_of_sections,
+        time_date_stamp,
+        pointer_to_symbol_table,
+        number_of_symbols,
+        size_of_optional_header,
+        characteristics,
+    ) = struct.unpack(IMAGE_FILE_HEADER_FMT, data[0:IMAGE_FILE_HEADER_SIZE])
+
+    # --- Parse Section Headers to find .pdata ---
+    # Each IMAGE_SECTION_HEADER is 40 bytes: Name[8], Misc(VirtualSize), VirtualAddress,
+    # SizeOfRawData, PointerToRawData, PointerToRelocations, PointerToLinenumbers,
+    # NumberOfRelocations, NumberOfLinenumbers, Characteristics
+    SECTION_HEADER_FMT = "<8sLLLLLLHHI"
+    SECTION_HEADER_SIZE = struct.calcsize(SECTION_HEADER_FMT)
+    section_table_offset = IMAGE_FILE_HEADER_SIZE + size_of_optional_header
+
+    pdata_section_index = None
+    pdata_pointer_to_raw = None
+    pdata_size_of_raw = None
+    pdata_pointer_to_relocs = None
+    pdata_number_of_relocs = None
+
+    # Keep all section headers for rewriting relocation entries later if needed
+    section_headers = []
+
+    for i in range(number_of_sections):
+        offset = section_table_offset + i * SECTION_HEADER_SIZE
+        section_data = data[offset : offset + SECTION_HEADER_SIZE]
+        (
+            name,
+            virtual_size,
+            virtual_address,
+            size_of_raw_data,
+            pointer_to_raw_data,
+            pointer_to_relocations,
+            pointer_to_linenumbers,
+            number_of_relocations,
+            number_of_linenumbers,
+            sec_characteristics,
+        ) = struct.unpack(SECTION_HEADER_FMT, section_data)
+
+        section_name = name.rstrip(b"\x00").decode("utf-8")
+        section_headers.append(
+            {
+                "name": section_name,
+                "offset": offset,
+                "virtual_size": virtual_size,
+                "virtual_address": virtual_address,
+                "size_of_raw_data": size_of_raw_data,
+                "pointer_to_raw_data": pointer_to_raw_data,
+                "pointer_to_relocations": pointer_to_relocations,
+                "number_of_relocations": number_of_relocations,
+            }
+        )
+
+        if section_name == ".pdata":
+            pdata_section_index = i
+            pdata_pointer_to_raw = pointer_to_raw_data
+            pdata_size_of_raw = size_of_raw_data
+            pdata_pointer_to_relocs = pointer_to_relocations
+            pdata_number_of_relocs = number_of_relocations
+
+    if pdata_section_index is None:
+        print("Error: No .pdata section found in the object file", file=sys.stderr)
+        return
+
+    # --- Parse Symbol Table ---
+    # Each IMAGE_SYMBOL is 18 bytes: Name[8], Value (4 bytes), SectionNumber (2 bytes),
+    # Type (2 bytes), StorageClass (1 byte), NumberOfAuxSymbols (1 byte)
+    SYMBOL_TABLE_ENTRY_SIZE = 18
+    symbols = []
+    for sym_index in range(number_of_symbols):
+        sym_offset = pointer_to_symbol_table + sym_index * SYMBOL_TABLE_ENTRY_SIZE
+        entry = data[sym_offset : sym_offset + SYMBOL_TABLE_ENTRY_SIZE]
+        if len(entry) < SYMBOL_TABLE_ENTRY_SIZE:
+            print("Error: Truncated symbol table entry", file=sys.stderr)
+            return
+        # Unpack: Name (8s), Value (L), SectionNumber (h), Type (H), StorageClass (B), NumberOfAuxSymbols (B)
+        name_bytes, value, section_number, sym_type, storage_class, num_aux = (
+            struct.unpack("<8sLhHBB", entry)
+        )
+        # Decode name: if name_bytes[0:4] are zeros, use string from offset in string table
+        if name_bytes[:4] == b"\x00\x00\x00\x00":
+            str_table_offset = struct.unpack("<L", name_bytes[4:])[0]
+            # String table starts immediately after symbol table: size (4 bytes) + NUL-terminated strings
+            str_tab_start = (
+                pointer_to_symbol_table + number_of_symbols * SYMBOL_TABLE_ENTRY_SIZE
+            )
+            # Fetch the name from string table
+            str_offset = str_tab_start + str_table_offset
+            name_end = data.find(b"\x00", str_offset)
+            symbol_name = data[str_offset:name_end].decode("utf-8")
+        else:
+            symbol_name = name_bytes.partition(b"\x00")[0].decode("utf-8")
+
+        symbols.append(
+            {"name": symbol_name, "value": value, "section_number": section_number}
+        )
+
+    # --- Read original .pdata section raw data ---
+    pdata_data = data[pdata_pointer_to_raw : pdata_pointer_to_raw + pdata_size_of_raw]
+    if len(pdata_data) % 12 != 0:
+        print("Error: .pdata size is not a multiple of 12 bytes", file=sys.stderr)
+        return
+    num_entries = len(pdata_data) // 12
+
+    # --- Read relocation entries for .pdata ---
+    # Each IMAGE_RELOCATION is 10 bytes: VirtualAddress (4), SymbolTableIndex (4), Type (2)
+    RELOC_ENTRY_SIZE = 10
+    reloc_entries = []
+    reloc_table_start = pdata_pointer_to_relocs
+    for rindex in range(pdata_number_of_relocs):
+        reloff = reloc_table_start + rindex * RELOC_ENTRY_SIZE
+        entry = data[reloff : reloff + RELOC_ENTRY_SIZE]
+        if len(entry) < RELOC_ENTRY_SIZE:
+            print("Error: Truncated relocation entry", file=sys.stderr)
+            return
+        va, sym_index, rtype = struct.unpack("<LLH", entry)
+        reloc_entries.append(
+            {"virtual_address": va, "symbol_index": sym_index, "type": rtype}
+        )
+
+    # There should be 3 relocations per .pdata entry
+    if len(reloc_entries) != num_entries * 3:
+        print(
+            "Warning: Expected {} relocations but found {}".format(
+                num_entries * 3, len(reloc_entries)
+            ),
+            file=sys.stderr,
+        )
+
+    # --- Associate each entry with its relocations and sorting key ---
+    entries = []
+    for i in range(num_entries):
+        entry_bytes = pdata_data[i * 12 : (i + 1) * 12]
+        entry_relocs = reloc_entries[i * 3 : i * 3 + 3]
+
+        # Sorting key: use symbol.Value of first relocation"s symbol index
+        sym_idx = entry_relocs[0]["symbol_index"]
+        if sym_idx < 0 or sym_idx >= number_of_symbols:
+            key = 0
+        else:
+            key = symbols[sym_idx]["value"]
+
+        entries.append({"entry_bytes": entry_bytes, "relocs": entry_relocs, "key": key})
+
+    # --- Sort entries by computed key ---
+    entries.sort(key=lambda x: x["key"])
+
+    # --- Build new .pdata data buffer ---
+    sorted_pdata = bytearray()
+    for e in entries:
+        sorted_pdata.extend(e["entry_bytes"])
+
+    # --- Build new relocation table buffer ---
+    new_reloc_buf = bytearray()
+    for new_i, e in enumerate(entries):
+        for reloc in e["relocs"]:
+            field_offset = reloc["virtual_address"] % 12
+            new_va = new_i * 12 + field_offset
+            packed = struct.pack("<LLH", new_va, reloc["symbol_index"], reloc["type"])
+            new_reloc_buf.extend(packed)
+
+    # --- Write back sorted .pdata and new relocations into data buffer ---
+    # Replace .pdata raw data
+    data[pdata_pointer_to_raw : pdata_pointer_to_raw + pdata_size_of_raw] = sorted_pdata
+    # Replace relocation entries
+    data[pdata_pointer_to_relocs : pdata_pointer_to_relocs + len(new_reloc_buf)] = (
+        new_reloc_buf
+    )
+
+    # --- Emit the fixed object file ---
+    object_file.write_bytes(data)
+
+
+if __name__ == "__main__":
+    main(sys.argv)
@@ -1,3 +1,2 @@
 [resource-compiler]
 namespace = Frida.Data.Compiler
-compress = *.js:text:7; *.bin:generic:7
@@ -1,3 +0,0 @@
-[resource-compiler]
-namespace = Frida.Data.Compiler
-compress = *.js:text:11; *.bin:generic:11
@@ -1,63 +1,56 @@
 namespace Frida {
-	public class Compiler : Object {
+	public sealed class Compiler : Object {
 		public signal void starting ();
 		public signal void finished ();
 		public signal void output (string bundle);
 		public signal void diagnostics (Variant diagnostics);

-		public DeviceManager manager {
-			get;
-			construct;
+		private size_t watch_session_handle = 0;
+		private Gee.Queue<Diagnostic> pending_diagnostics = new Gee.ArrayQueue<Diagnostic> ();
+
+		private MainContext main_context;
+
+		// TODO: Remove the DeviceManager parameter.
+		public Compiler (DeviceManager? manager = null) {
+			Object ();
 		}

-#if HAVE_COMPILER_BACKEND
-		private Promise<Agent>? load_request;
-		private Gee.Map<uint, MonitorEntry> monitors = new Gee.HashMap<uint, MonitorEntry> ();
-		private Gee.Set<MonitorEntry> dirty_monitors = new Gee.HashSet<MonitorEntry> ();
-		private TimeoutSource? monitor_flush_timer;
-
-		private Cancellable io_cancellable = new Cancellable ();
-#endif
-
-		public Compiler (DeviceManager manager) {
-			Object (manager: manager);
+		static construct {
+			CompilerBackend.init ();
 		}

-#if HAVE_COMPILER_BACKEND
-		public override void dispose () {
-			if (load_request != null)
-				close.begin ();
-
-			base.dispose ();
+		construct {
+			main_context = Frida.get_main_context ();
 		}

-		private async void close () {
-			try {
-				var agent = yield get_agent (null);
-				yield agent.close (null);
-			} catch (GLib.Error e) {
-			}
-			load_request = null;
-
-			if (monitor_flush_timer != null) {
-				monitor_flush_timer.destroy ();
-				monitor_flush_timer = null;
-			}
-
-			foreach (var entry in monitors.values)
-				detach_monitor_entry (entry);
-			monitors.clear ();
+		~Compiler () {
+			cancel_watch ();
 		}
-#endif

 		public async string build (string entrypoint, BuildOptions? options = null, Cancellable? cancellable = null)
 				throws Error, IOError {
-#if HAVE_COMPILER_BACKEND
-			var agent = yield get_agent (cancellable);
+			CompilerBackend.check_available ();
+
+			BuildOptions opts = (options != null) ? options : new BuildOptions ();
+			string project_root = compute_project_root (entrypoint, opts);

 			starting ();
 			try {
-				string bundle = yield agent.build (entrypoint, options, cancellable);
+				string? bundle = null;
+				string? error_message = null;
+				CompilerBackend.BuildCompleteFunc on_complete = (b, e) => {
+					bundle = b;
+					error_message = e;
+					schedule_on_frida_thread (build.callback);
+				};
+
+				CompilerBackend.build (project_root, entrypoint, opts.output_format, opts.bundle_format,
+					(size_t) (opts.type_check == NONE), (size_t) (opts.source_maps == INCLUDED),
+					(size_t) (opts.compression == TERSER), (owned) on_complete, on_diagnostic);
+				yield;
+
+				if (error_message != null)
+					throw new Error.INVALID_ARGUMENT ("%s", error_message);

 				output (bundle);

@@ -65,9 +58,6 @@ namespace Frida {
 			} finally {
 				finished ();
 			}
-#else
-			throw_not_supported ();
-#endif
 		}

 		public string build_sync (string entrypoint, BuildOptions? options = null, Cancellable? cancellable = null)
@@ -89,13 +79,38 @@ namespace Frida {

 		public async void watch (string entrypoint, WatchOptions? options = null, Cancellable? cancellable = null)
 				throws Error, IOError {
-#if HAVE_COMPILER_BACKEND
-			var agent = yield get_agent (cancellable);
+			CompilerBackend.check_available ();

-			yield agent.watch (entrypoint, options, cancellable);
-#else
-			throw_not_supported ();
-#endif
+			WatchOptions opts = (options != null) ? options : new WatchOptions ();
+			string project_root = compute_project_root (entrypoint, opts);
+
+			cancel_watch ();
+
+			size_t session_handle = 0;
+			string? error_message = null;
+			CompilerBackend.WatchReadyFunc on_ready = (h, e) => {
+				session_handle = h;
+				error_message = e;
+				schedule_on_frida_thread (watch.callback);
+			};
+
+			CompilerBackend.watch (project_root, entrypoint, opts.output_format, opts.bundle_format,
+				(size_t) (opts.type_check == NONE), (size_t) (opts.source_maps == INCLUDED),
+				(size_t) (opts.compression == TERSER), (owned) on_ready, on_starting, on_finished,
+				on_output, on_diagnostic);
+			yield;
+
+			if (error_message != null)
+				throw new Error.INVALID_ARGUMENT ("%s", error_message);
+
+			watch_session_handle = session_handle;
+		}
+
+		private void cancel_watch () {
+			if (watch_session_handle != 0) {
+				CompilerBackend.WatchSession.dispose (watch_session_handle);
+				watch_session_handle = 0;
+			}
 		}

 		public void watch_sync (string entrypoint, WatchOptions? options = null, Cancellable? cancellable = null)
@@ -115,343 +130,238 @@ namespace Frida {
 			}
 		}

-#if HAVE_COMPILER_BACKEND
-		private void on_watch_add (uint id, string path, string type, int64 polling_interval) {
-			var file = File.parse_name (path);
+		private void on_starting () {
+			schedule_on_frida_thread (() => {
+				starting ();
+				return Source.REMOVE;
+			});
+		}

-			GLib.FileMonitor monitor;
-			try {
-				if (type == "file")
-					monitor = file.monitor_file (FileMonitorFlags.SEND_MOVED, io_cancellable);
-				else if (type == "directory")
-					monitor = file.monitor_directory (FileMonitorFlags.NONE, io_cancellable);
-				else
-					assert_not_reached ();
-			} catch (GLib.Error e) {
-				return;
+		private void on_finished () {
+			schedule_on_frida_thread (() => {
+				finished ();
+				return Source.REMOVE;
+			});
+		}
+
+		private void on_output (owned string bundle) {
+			schedule_on_frida_thread (() => {
+				output (bundle);
+				return Source.REMOVE;
+			});
+		}
+
+		private void on_diagnostic (owned string category, int code, owned string? path, int line, int character,
+				owned string text) {
+			var diag = new Diagnostic () {
+				category = category,
+				code = code,
+				path = path,
+				line = line,
+				character = character,
+				text = text,
+			};
+
+			bool schedule_emit = false;
+			lock (pending_diagnostics) {
+				schedule_emit = pending_diagnostics.is_empty;
+				pending_diagnostics.add (diag);
 			}

-			if (polling_interval != 0)
-				monitor.rate_limit = (int) polling_interval;
-
-			var entry = new MonitorEntry (id, monitor);
-			entry.file_changed.connect (on_file_changed);
-			monitors[id] = entry;
-		}
-
-		private void on_watch_remove (uint id) {
-			MonitorEntry? entry;
-			if (monitors.unset (id, out entry))
-				detach_monitor_entry (entry);
-		}
-
-		private void detach_monitor_entry (MonitorEntry entry) {
-			dirty_monitors.remove (entry);
-
-			entry.file_changed.disconnect (on_file_changed);
-			entry.destroy ();
-		}
-
-		private void on_file_changed (MonitorEntry entry) {
-			dirty_monitors.add (entry);
-
-			if (monitor_flush_timer == null) {
-				var source = new TimeoutSource (50);
-				source.set_callback (on_monitor_flush_tick);
-				source.attach (MainContext.get_thread_default ());
-				monitor_flush_timer = source;
+			if (schedule_emit) {
+				schedule_on_frida_thread (() => {
+					emit_pending_diagnostics ();
+					return Source.REMOVE;
+				});
 			}
 		}

-		private bool on_monitor_flush_tick () {
-			var settled = new Gee.ArrayList<MonitorEntry> ();
-			var now = get_monotonic_time ();
-			settled.add_all_iterator (dirty_monitors.filter (m => now - m.last_change >= 50000));
-
-			Agent agent = load_request.future.value;
-			foreach (var entry in settled) {
-				agent.notify_file_changed (entry.id, entry.state, io_cancellable);
-				dirty_monitors.remove (entry);
+		private void emit_pending_diagnostics () {
+			var batch = new Gee.ArrayList<Diagnostic> ();
+			lock (pending_diagnostics) {
+				batch.add_all (pending_diagnostics);
+				pending_diagnostics.clear ();
 			}

-			if (!dirty_monitors.is_empty)
-				return Source.CONTINUE;
+			var builder = new VariantBuilder (new VariantType.array (VariantType.VARDICT));

-			monitor_flush_timer = null;
-			return Source.REMOVE;
-		}
-
-		private async Agent get_agent (Cancellable? cancellable) throws Error, IOError {
-			Future<Agent> future;
-			if (load_request != null) {
-				future = load_request.future;
-			} else {
-				load_request = new Promise<Agent> ();
-				future = load_request.future;
-
-				load_agent.begin ();
+			foreach (var d in batch) {
+				builder.open (VariantType.VARDICT);
+				builder.add ("{sv}", "category", new Variant.string (d.category));
+				builder.add ("{sv}", "code", new Variant.int64 (d.code));
+				if (d.path != null) {
+					var b = new VariantBuilder (VariantType.VARDICT);
+					b.add ("{sv}", "path", new Variant.string (d.path));
+					b.add ("{sv}", "line", new Variant.int64 (d.line));
+					b.add ("{sv}", "character", new Variant.int64 (d.character));
+					builder.add ("{sv}", "file", b.end ());
+				}
+				builder.add ("{sv}", "text", new Variant.string (d.text));
+				builder.close ();
 			}

-			return yield future.wait_async (cancellable);
+			diagnostics (builder.end ());
 		}

-		private async void load_agent () {
-			try {
-				var device = yield manager.get_device_by_type (LOCAL, 0, io_cancellable);
-				var session = yield device.get_host_session (io_cancellable);
-				var agent = new Agent (this, (BaseDBusHostSession) session);
-
-				load_request.resolve (agent);
-			} catch (GLib.Error e) {
-				if ((e is Error || e is IOError.CANCELLED))
-					e = new Error.NOT_SUPPORTED ("%s", e.message);
-
-				load_request.reject (e);
-				load_request = null;
-			}
-		}
-#else
-		[NoReturn]
-		private void throw_not_supported () throws Error {
-			throw new Error.NOT_SUPPORTED ("Compiler backend disabled at build-time");
-		}
-#endif
-
 		private T create<T> () {
 			return Object.new (typeof (T), parent: this);
 		}

+		protected void schedule_on_frida_thread (owned SourceFunc function) {
+			var source = new IdleSource ();
+			source.set_callback ((owned) function);
+			source.attach (main_context);
+		}
+
+		private class Diagnostic {
+			public string category;
+			public int code;
+			public string? path;
+			public int line;
+			public int character;
+			public string text;
+		}
+
 		private abstract class CompilerTask<T> : AsyncTask<T> {
 			public weak Compiler parent {
 				get;
 				construct;
 			}
 		}
+	}

+	namespace CompilerBackend {
+		private void init () {
 #if HAVE_COMPILER_BACKEND
-		private class Agent : InternalAgent {
-			public weak Compiler parent {
-				get;
-				construct;
-			}
-
-			private Promise<string> source_request = new Promise<string> ();
-			private Promise<Bytes?> snapshot_request = new Promise<Bytes?> ();
-
-			public Agent (Compiler parent, BaseDBusHostSession host_session) {
-				Object (
-					parent: parent,
-					host_session: host_session,
-#if HAVE_V8
-					script_runtime: ScriptRuntime.V8
+#if COMPILER_BACKEND_STATIC_COMPILATION
+			_init_go_runtime ();
+			build = (BuildFunc) _build;
+			watch = (WatchFunc) _watch;
+			WatchSession.dispose = (WatchSession.DisposeFunc) WatchSession._dispose;
 #else
-					script_runtime: ScriptRuntime.DEFAULT
-#endif
-				);
-			}
+			unowned uint8[] backend_so = Frida.Data.Compiler.get_frida_compiler_backend_so_blob ().data;

-			construct {
-				load_resources ();
-			}
+			FileDescriptor fd;
+			if (MemoryFileDescriptor.is_supported ()) {
+				fd = MemoryFileDescriptor.from_bytes ("frida-compiler-backend.so", new Bytes.static (backend_so));
+			} else {
+				string name_used;
+				try {
+					fd = new FileDescriptor (FileUtils.open_tmp ("frida-compiler-backend-XXXXXX.so", out name_used));
+					FileUtils.unlink (name_used);

-			private void load_resources () {
-				new Thread<void> ("compiler-agent-loader", () => {
-					var agent_js_blob = Data.Compiler.get_agent_js_blob ();
-					Bytes agent_js_bytes = decompress (agent_js_blob.data, agent_js_blob.uncompressed_size);
-					source_request.resolve ((string) agent_js_bytes.get_data ());
+					var output = new UnixOutputStream (fd.handle, false);
+					output.write_all (backend_so, null);

-					var snapshot_blob = Data.Compiler.get_snapshot_bin_blob ();
-					Bytes snapshot = decompress (snapshot_blob.data, snapshot_blob.uncompressed_size);
-					snapshot_request.resolve ((snapshot.get_size () != 0) ? snapshot : null);
-				});
-			}
-
-			public async string build (string entrypoint, BuildOptions? options, Cancellable? cancellable)
-					throws Error, IOError {
-				BuildOptions opts = (options != null) ? options : new BuildOptions ();
-
-				Json.Node bundle = yield call ("build", new Json.Node[] {
-						new Json.Node.alloc ().init_string (compute_project_root (entrypoint, opts)),
-						new Json.Node.alloc ().init_string (entrypoint),
-						new Json.Node.alloc ().init_string (opts.source_maps.to_nick ()),
-						new Json.Node.alloc ().init_string (opts.compression.to_nick ()),
-					}, cancellable);
-				return bundle.get_string ();
-			}
-
-			public async void watch (string entrypoint, WatchOptions? options, Cancellable? cancellable)
-					throws Error, IOError {
-				WatchOptions opts = (options != null) ? options : new WatchOptions ();
-
-				yield call ("watch", new Json.Node[] {
-						new Json.Node.alloc ().init_string (compute_project_root (entrypoint, opts)),
-						new Json.Node.alloc ().init_string (entrypoint),
-						new Json.Node.alloc ().init_string (opts.source_maps.to_nick ()),
-						new Json.Node.alloc ().init_string (opts.compression.to_nick ()),
-					}, cancellable);
-			}
-
-			private static string compute_project_root (string entrypoint, CompilerOptions options) {
-				string? project_root = options.project_root;
-
-				if (project_root != null)
-					return project_root;
-
-				if (Path.is_absolute (entrypoint))
-					return Path.get_dirname (entrypoint);
-
-				return Environment.get_current_dir ();
-			}
-
-			public void notify_file_changed (uint id, FileState state, Cancellable? cancellable) {
-				var notification = new Json.Builder ();
-				notification
-					.begin_object ()
-						.set_member_name ("type")
-						.add_string_value ("watch:change")
-						.set_member_name ("id")
-						.add_int_value (id)
-						.set_member_name ("state")
-						.add_string_value (Marshal.enum_to_nick<FileState> (state))
-					.end_object ();
-				post.begin (notification.get_root (), cancellable);
-			}
-
-			protected override async uint get_target_pid (Cancellable? cancellable) throws Error, IOError {
-				return 0;
-			}
-
-			protected override async string? load_source (Cancellable? cancellable) throws Error, IOError {
-				return yield source_request.future.wait_async (cancellable);
-			}
-
-			protected override async Bytes? load_snapshot (Cancellable? cancellable, out SnapshotTransport transport)
-					throws Error, IOError {
-				transport = SHARED_MEMORY;
-				return yield snapshot_request.future.wait_async (cancellable);
-			}
-
-			protected override void on_event (string type, Json.Array event) {
-				if (type == "diagnostics") {
-					on_build_diagnostics (event.get_array_element (1));
-				} else if (type == "watch:compilation-starting") {
-					parent.starting ();
-				} else if (type == "watch:compilation-finished") {
-					parent.finished ();
-				} else if (type == "watch:bundle-updated") {
-					on_watch_bundle_updated (event.get_string_element (1));
-				} else if (type == "watch:add") {
-					parent.on_watch_add ((uint) event.get_int_element (1), event.get_string_element (2),
-						event.get_string_element (3), event.get_int_element (4));
-				} else if (type == "watch:remove") {
-					parent.on_watch_remove ((uint) event.get_int_element (1));
-				} else {
+					Posix.lseek (fd.handle, 0, Posix.SEEK_SET);
+				} catch (GLib.Error e) {
 					assert_not_reached ();
 				}
 			}

-			private void on_build_diagnostics (Json.Array diagnostics) {
-				uint n = diagnostics.get_length ();
-
-				var builder = new VariantBuilder (new VariantType.array (VariantType.VARDICT));
-				for (uint i = 0; i != n; i++) {
-					var diag = diagnostics.get_array_element (i);
-					builder.open (VariantType.VARDICT);
-					builder.add ("{sv}", "category", new Variant.string (diag.get_string_element (0)));
-					builder.add ("{sv}", "code", new Variant.int64 (diag.get_int_element (1)));
-					if (!diag.get_null_element (2)) {
-						var file = diag.get_array_element (2);
-						var b = new VariantBuilder (VariantType.VARDICT);
-						b.add ("{sv}", "path", new Variant.string (file.get_string_element (0)));
-						b.add ("{sv}", "line", new Variant.int64 (file.get_int_element (1)));
-						b.add ("{sv}", "character", new Variant.int64 (file.get_int_element (2)));
-						builder.add ("{sv}", "file", b.end ());
-					}
-					builder.add ("{sv}", "text", new Variant.string (diag.get_string_element (3)));
-					builder.close ();
-				}
-
-				parent.diagnostics (builder.end ());
-			}
-
-			private void on_watch_bundle_updated (string bundle) {
-				parent.output (bundle);
-			}
-
-			private static Bytes decompress (uint8[] data, uint uncompressed_size) {
-				var decoder = new Brotli.Decoder ();
-				decoder.set_parameter (LARGE_WINDOW, 1);
-
-				uint8[] uncompressed_data = new uint8[uncompressed_size + 1];
-				size_t available_in = data.length;
-				size_t available_out = uncompressed_size;
-				uint8 * next_in = data;
-				uint8 * next_out = uncompressed_data;
-				decoder.decompress_stream (&available_in, &next_in, &available_out, &next_out);
-				uncompressed_data.length = (int) (next_out - (uint8 *) uncompressed_data);
-
-				return new Bytes.take ((owned) uncompressed_data);
+			Module backend;
+			try {
+				backend = new Module ("/proc/self/fd/%d".printf (fd.handle), LOCAL);
+			} catch (ModuleError e) {
+				assert_not_reached ();
 			}
+			build = resolve_symbol (backend, "_frida_compiler_backend_build");
+			watch = resolve_symbol (backend, "_frida_compiler_backend_watch");
+			WatchSession.dispose = resolve_symbol (backend, "_frida_compiler_backend_watch_session_dispose");
+#endif
+#endif
 		}

-		private class MonitorEntry : Object {
-			public signal void file_changed ();
-
-			public uint id;
-			public GLib.FileMonitor monitor;
-
-			public FileState state = PRISTINE;
-			public int64 last_change = -1;
-
-			public MonitorEntry (uint id, GLib.FileMonitor monitor) {
-				this.id = id;
-				this.monitor = monitor;
-
-				monitor.changed.connect (on_file_changed);
-			}
-
-			public void destroy () {
-				monitor.changed.disconnect (on_file_changed);
-				monitor.cancel ();
-			}
-
-			private void on_file_changed (File file, File? other_file, FileMonitorEvent event) {
-				switch (event) {
-					case CREATED:
-						state = PRISTINE;
-						break;
-					case CHANGED:
-						if (state != PRISTINE)
-							state = MODIFIED;
-						break;
-					case DELETED:
-					case MOVED:
-						state = DELETED;
-						break;
-					default:
-						return;
-				}
-
-				last_change = get_monotonic_time ();
-
-				file_changed ();
-			}
+		private void check_available () throws Error {
+			if (build == null)
+				throw new Error.NOT_SUPPORTED ("Compiler backend disabled at build-time");
 		}

-		private enum FileState {
-			PRISTINE,
-			MODIFIED,
-			DELETED,
+		private BuildFunc? build;
+		private WatchFunc? watch;
+
+		[CCode (has_target = false)]
+		private delegate void BuildFunc (string project_root, string entrypoint, OutputFormat output_format,
+			BundleFormat bundle_format, size_t disable_type_check, size_t source_map, size_t compress,
+			owned BuildCompleteFunc on_complete, DiagnosticFunc on_diagnostic);
+
+		[CCode (has_target = false)]
+		private delegate void WatchFunc (string project_root, string entrypoint, OutputFormat output_format,
+			BundleFormat bundle_format, size_t disable_type_check, size_t source_map, size_t compress,
+			owned WatchReadyFunc on_ready, StartingFunc on_starting, FinishedFunc on_finished, OutputFunc on_output,
+			DiagnosticFunc on_diagnostic);
+
+#if COMPILER_BACKEND_STATIC_COMPILATION
+		private extern void _init_go_runtime ();
+		private extern void _build ();
+		private extern void _watch ();
+#endif
+
+		namespace WatchSession {
+			[CCode (has_target = false)]
+			private delegate void DisposeFunc (size_t handle);
+
+			private DisposeFunc? dispose;
+
+#if COMPILER_BACKEND_STATIC_COMPILATION
+			private extern void _dispose ();
+#endif
+		}
+
+		private delegate void BuildCompleteFunc (owned string? bundle, owned string? error_message);
+		private delegate void WatchReadyFunc (size_t session_handle, owned string? error_message);
+		private delegate void StartingFunc ();
+		private delegate void FinishedFunc ();
+		private delegate void OutputFunc (owned string bundle);
+		private delegate void DiagnosticFunc (owned string category, int code, owned string? path, int line, int character,
+			owned string text);
+
+#if HAVE_COMPILER_BACKEND && !COMPILER_BACKEND_STATIC_COMPILATION
+		private static T resolve_symbol<T> (Module m, string name) {
+			void * address;
+			if (!m.symbol (name, out address))
+				assert_not_reached ();
+			return (T) address;
 		}
 #endif
 	}

+	private string compute_project_root (string entrypoint, CompilerOptions options) {
+		string? project_root = options.project_root;
+
+		if (project_root != null)
+			return project_root;
+
+		if (Path.is_absolute (entrypoint))
+			return Path.get_dirname (entrypoint);
+
+		return Environment.get_current_dir ();
+	}
+
 	public class CompilerOptions : Object {
 		public string? project_root {
 			get;
 			set;
 		}

+		public OutputFormat output_format {
+			get;
+			set;
+			default = UNESCAPED;
+		}
+
+		public BundleFormat bundle_format {
+			get;
+			set;
+			default = ESM;
+		}
+
+		public TypeCheckMode type_check {
+			get;
+			set;
+			default = FULL;
+		}
+
 		public SourceMaps source_maps {
 			get;
 			set;
@@ -465,10 +375,50 @@ namespace Frida {
 		}
 	}

-	public class BuildOptions : CompilerOptions {
+	public sealed class BuildOptions : CompilerOptions {
 	}

-	public class WatchOptions : CompilerOptions {
+	public sealed class WatchOptions : CompilerOptions {
+	}
+
+	public enum OutputFormat {
+		UNESCAPED,
+		HEX_BYTES,
+		C_STRING;
+
+		public static OutputFormat from_nick (string nick) throws Error {
+			return Marshal.enum_from_nick<OutputFormat> (nick);
+		}
+
+		public string to_nick () {
+			return Marshal.enum_to_nick<OutputFormat> (this);
+		}
+	}
+
+	public enum BundleFormat {
+		ESM,
+		IIFE;
+
+		public static BundleFormat from_nick (string nick) throws Error {
+			return Marshal.enum_from_nick<BundleFormat> (nick);
+		}
+
+		public string to_nick () {
+			return Marshal.enum_to_nick<BundleFormat> (this);
+		}
+	}
+
+	public enum TypeCheckMode {
+		FULL,
+		NONE;
+
+		public static TypeCheckMode from_nick (string nick) throws Error {
+			return Marshal.enum_from_nick<TypeCheckMode> (nick);
+		}
+
+		public string to_nick () {
+			return Marshal.enum_to_nick<TypeCheckMode> (this);
+		}
 	}

 	public enum SourceMaps {
@@ -1,91 +0,0 @@
-from pathlib import Path
-import shutil
-import subprocess
-import sys
-
-
-INPUTS = [
-    "agent-entrypoint.js",
-    "agent-core.ts",
-    "agent-warmup.js",
-    "package.json",
-    "package-lock.json",
-    "tsconfig.json",
-    "rollup.config.agent-core.ts",
-    "rollup.config.typescript.ts",
-]
-
-
-def main(argv):
-    output_dir, priv_dir, input_dir, npm, v8_mksnapshot = [Path(d).resolve() if d else None for d in argv[1:6]]
-    host_os_family, host_arch, host_cpu_mode = argv[6:9]
-
-    try:
-        generate_agent(output_dir, priv_dir, input_dir, npm, v8_mksnapshot, host_os_family, host_arch, host_cpu_mode)
-    except subprocess.CalledProcessError as e:
-        print(e, file=sys.stderr)
-        print("Output:\n\t| " + "\n\t| ".join(e.output.strip().split("\n")), file=sys.stderr)
-        sys.exit(2)
-    except Exception as e:
-        print(e, file=sys.stderr)
-        sys.exit(1)
-
-
-def generate_agent(output_dir, priv_dir, input_dir, npm, v8_mksnapshot, host_os_family, host_arch, host_cpu_mode):
-    entrypoint = input_dir / "agent-entrypoint.js"
-    priv_dir.mkdir(exist_ok=True)
-    for name in INPUTS:
-        if name == "agent-entrypoint.js":
-            continue
-        shutil.copy(input_dir / name, priv_dir / name)
-
-    run_kwargs = {
-        "cwd": priv_dir,
-        "stdout": subprocess.PIPE,
-        "stderr": subprocess.STDOUT,
-        "encoding": "utf-8",
-        "check": True,
-    }
-
-    subprocess.run([npm, "install"], **run_kwargs)
-    #subprocess.run([npm, "link", "/Users/oleavr/src/frida-compile"], **run_kwargs)
-
-    components = ["typescript", "agent-core"]
-    for component in components:
-        subprocess.run([
-                           npm, "run", "build:" + component,
-                           "--",
-                           "--environment", f"FRIDA_HOST_OS_FAMILY:{host_os_family},FRIDA_HOST_ARCH:{host_arch},FRIDA_HOST_CPU_MODE:{host_cpu_mode}",
-                           "--silent",
-                       ],
-                       **run_kwargs)
-    chunks = []
-    for component in components:
-        script = (priv_dir / f"{component}.js").read_text(encoding="utf-8")
-        chunks.append(script)
-    components_source = "\n".join(chunks)
-
-    agent = output_dir / "agent.js"
-    snapshot = output_dir / "snapshot.bin"
-
-    if v8_mksnapshot is not None:
-        shutil.copy(entrypoint, agent)
-        (priv_dir / "embed.js").write_text(components_source, encoding="utf-8")
-        subprocess.run([
-                           v8_mksnapshot,
-                           "--turbo-instruction-scheduling",
-                           f"--startup-blob={snapshot}",
-                           "embed.js",
-                           input_dir / "agent-warmup.js",
-                       ],
-                       **run_kwargs)
-    else:
-        agent.write_text("\n".join([
-            components_source,
-            entrypoint.read_text(encoding="utf-8"),
-        ]), encoding="utf-8")
-        snapshot.write_bytes(b"")
-
-
-if __name__ == "__main__":
-    main(sys.argv)
@@ -0,0 +1,14 @@
+module github.com/frida/frida-core-compiler
+
+go 1.24.3
+
+require (
+	github.com/evanw/esbuild v0.25.5
+	github.com/frida/typescript-go v0.0.0-20250601212135-a4721f45f19c
+)
+
+require (
+	github.com/dlclark/regexp2 v1.11.5 // indirect
+	github.com/go-json-experiment/json v0.0.0-20250517221953-25912455fbc8 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+)
@@ -0,0 +1,17 @@
+github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
+github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/evanw/esbuild v0.25.5 h1:E+JpeY5S/1LFmnX1vtuZqUKT7qDVcfXdhzMhM3uIKFs=
+github.com/evanw/esbuild v0.25.5/go.mod h1:D2vIQZqV/vIf/VRHtViaUtViZmG7o+kKmlBfVQuRi48=
+github.com/frida/typescript-go v0.0.0-20250601212135-a4721f45f19c h1:IWBI9AwSFLWymI4enx1jrAw0E4H2E+qHwsihv+AxSoE=
+github.com/frida/typescript-go v0.0.0-20250601212135-a4721f45f19c/go.mod h1:L4RMzD/pFBl7CqIf9XTrX41RO2xcok3OOVVcowv0H4k=
+github.com/go-json-experiment/json v0.0.0-20250517221953-25912455fbc8 h1:o8UqXPI6SVwQt04RGsqKp3qqmbOfTNMqDrWsc4O47kk=
+github.com/go-json-experiment/json v0.0.0-20250517221953-25912455fbc8/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
@@ -1,67 +1,65 @@
 compiler_sources = files(
  'compiler.vala',
+  'backend-glue.c',
 )

 if have_compiler_backend
-  if get_option('compiler_snapshot').auto()
-    # Generating our snapshot with V8's CPU simulator takes a very long time.
-    use_snapshot = meson.can_run_host_binaries()
-  else
-    use_snapshot = get_option('compiler_snapshot').enabled()
-  endif
-  compiler_mksnapshot = use_snapshot ? v8_mksnapshot : ''
-
-  compiler_agent = custom_target('frida-compiler-agent',
+  compiler_backend = custom_target('frida-compiler-backend',
    input: [
-      'agent-entrypoint.js',
-      'agent-core.ts',
-      'agent-warmup.js',
+      'go.mod',
+      'go.sum',
+      'backend.go',
+      'backend.version',
+      'tscompiler.go',
+      'tsconfig.go',
+      'shims.go',
      'package.json',
      'package-lock.json',
-      'tsconfig.json',
-      'rollup.config.agent-core.ts',
-      'rollup.config.typescript.ts',
    ],
    output: [
-      'agent.js',
-      'snapshot.bin',
+      'frida-compiler-backend' + (compiler_backend_static_compilation ? '.a' : ('-raw' + shlib_suffix)),
+      'frida-compiler-backend.h',
    ],
    command: [
      python,
-      files('generate-agent.py'),
+      files('build-backend.py'),
+      go_config,
      meson.current_build_dir(),
      '@PRIVATE_DIR@',
-      meson.current_source_dir(),
+      go,
      npm,
-      compiler_mksnapshot,
-      host_os_family,
-      host_arch_gumjs,
-      host_cpu_mode,
+      '@INPUT@',
    ],
  )
-  compiler_data = custom_target('frida-data-compiler',
-    input: [
-      'compiler.resources.' + frida_profile,
-      compiler_agent,
-    ],
-    output: [
-      'frida-data-compiler.vapi',
-      'frida-data-compiler.h',
-      'frida-data-compiler.c',
-      'frida-data-compiler-blob' + resource_blob_extension,
-      'frida-data-compiler-agent.js.br',
-      'frida-data-compiler-snapshot.bin.br',
-    ],
-    command: [
-      resource_compiler_cmd_array,
-      '-c', '@INPUT0@',
-      '-o', meson.current_build_dir() / 'frida-data-compiler',
-      '@INPUT1@',
-      '@INPUT2@',
-    ],
-  )
-  compiler_sources += compiler_data
+  if compiler_backend_static_compilation
+    backend_libs += compiler_backend[0]
+  else
+    filename = 'frida-compiler-backend' + shlib_suffix
+    identity = (host_os_family == 'darwin') ? 'FridaCompilerBackend' : filename
+    compiler_backend_shlib = custom_target('frida-compiler-backend-shlib',
+      input: compiler_backend[0],
+      output: filename,
+      command: post_process + ['shared-library', identity, 'elf-cleaner:off'],
+    )

-  backend_vala_args_private += '--pkg=libbrotlidec'
-  backend_deps_private += brotlidec_dep
+    compiler_data = custom_target('frida-data-compiler',
+      input: [
+        'compiler.resources',
+        compiler_backend_shlib,
+      ],
+      output: [
+        'frida-data-compiler.vapi',
+        'frida-data-compiler.h',
+        'frida-data-compiler.c',
+        'frida-data-compiler-blob' + resource_blob_extension,
+      ],
+      command: [
+        resource_compiler_cmd_array,
+        '-c', '@INPUT0@',
+        '-o', meson.current_build_dir() / 'frida-data-compiler',
+        '@INPUT1@',
+      ],
+    )
+    backend_sources += compiler_data
+  endif
 endif