diff --git a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_emscripten.cpp b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_emscripten.cpp
index 1f71de0743277..29f77b86eb554 100644
--- a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_emscripten.cpp
+++ b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_emscripten.cpp
@@ -14,17 +14,23 @@
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
+#include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_common.h"
 #include "sanitizer_stoptheworld.h"
 
+#include <fcntl.h>
 #include <signal.h>
 #include <time.h>
+#include <unistd.h>
+#include <math.h>
 
 #if SANITIZER_EMSCRIPTEN
 
+#include <sys/stat.h>
+#include <sys/types.h>
+
 #include <emscripten.h>
 #include <emscripten/stack.h>
-#include <sys/types.h>
 
 #include "emscripten_internal.h"
 
@@ -128,6 +134,82 @@ u64 MonotonicNanoTime() {
 
 void GetMemoryProfile(fill_profile_f cb, uptr *stats) {}
 
+int internal_madvise(uptr addr, uptr length, int advice) {
+  return 0; // madvise is currently ignored
+}
+
+uptr internal_close(fd_t fd) {
+  return close(fd);
+}
+
+uptr internal_open(const char *filename, int flags) {
+  return open(filename, flags);
+}
+
+uptr internal_open(const char *filename, int flags, u32 mode) {
+  return open(filename, flags, mode);
+}
+
+uptr internal_read(fd_t fd, void *buf, uptr count) {
+  return read(fd, buf, count);
+}
+
+uptr internal_write(fd_t fd, const void *buf, uptr count) {
+  return write(fd, buf, count);
+}
+
+uptr internal_stat(const char *path, void *buf) {
+  return stat(path, (struct stat *)buf);
+}
+
+uptr internal_fstat(fd_t fd, void *buf) {
+  return fstat(fd, (struct stat *)buf);
+}
+
+uptr internal_filesize(fd_t fd) {
+  struct stat st;
+  if (internal_fstat(fd, &st))
+    return -1;
+  return (uptr)st.st_size;
+}
+
+uptr internal_dup(int oldfd) {
+  return dup(oldfd);
+}
+
+uptr internal_getpid() {
+  return 42;
+}
+
+uptr internal_sched_yield() {
+  return sched_yield();
+}
+
+void internal_sigfillset(__sanitizer_sigset_t *set) {
+  sigfillset(set);
+}
+
+uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
+                          __sanitizer_sigset_t *oldset) {
+  return sigprocmask(how, set, oldset);
+}
+
+void internal_usleep(u64 useconds) {
+  usleep(useconds);
+}
+
+void internal__exit(int exitcode) {
+  _exit(exitcode);
+}
+
+tid_t GetTid() {
+  return gettid();
+}
+
+uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
+  return clock_gettime(clk_id, (struct timespec *)tp);
+}
+
 } // namespace __sanitizer
 
 #endif
diff --git a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp
index 0a77861b1af11..538f0570e131b 100644
--- a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp
+++ b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp
@@ -115,15 +115,8 @@ extern struct ps_strings *__ps_strings;
 #  endif
 
 #  if SANITIZER_EMSCRIPTEN
-#    define weak __attribute__(__weak__)
-#    define hidden __attribute__((__visibility__("hidden")))
-#    include <syscall.h>
-#    undef weak
-#    undef hidden
-#    include <emscripten/threading.h>
-#    include <math.h>
-#    include <wasi/api.h>
-#    include <wasi/wasi-helpers.h>
+#    include <math.h>  // For INFINITY
+#    include <emscripten/threading.h>  // For emscripten_futex_wait
 #  endif
 
 extern char **environ;
@@ -254,8 +247,8 @@ ScopedBlockSignals::~ScopedBlockSignals() { SetSigProcMask(&saved_, nullptr); }
 #  endif
 
 // --------------- sanitizer_libc.h
-#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
-#    if !SANITIZER_S390 && !SANITIZER_EMSCRIPTEN
+#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
+#    if !SANITIZER_S390
 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                    u64 offset) {
 #      if SANITIZER_FREEBSD
@@ -270,25 +263,23 @@ uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                           (OFF_T)(offset / 4096));
 #      endif
 }
-#    endif  // !SANITIZER_S390 && !SANITIZER_EMSCRIPTEN
+#    endif  // !SANITIZER_S390
 
-#    if !SANITIZER_EMSCRIPTEN
 uptr internal_munmap(void *addr, uptr length) {
   return internal_syscall(SYSCALL(munmap), (uptr)addr, length);
 }
 
-#      if SANITIZER_LINUX
+#    if SANITIZER_LINUX
 uptr internal_mremap(void *old_address, uptr old_size, uptr new_size, int flags,
                      void *new_address) {
   return internal_syscall(SYSCALL(mremap), (uptr)old_address, old_size,
                           new_size, flags, (uptr)new_address);
 }
-#      endif
+#    endif
 
 int internal_mprotect(void *addr, uptr length, int prot) {
   return internal_syscall(SYSCALL(mprotect), (uptr)addr, length, prot);
 }
-#    endif
 
 int internal_madvise(uptr addr, uptr length, int advice) {
   return internal_syscall(SYSCALL(madvise), addr, length, advice);
@@ -299,17 +290,10 @@ uptr internal_close_range(fd_t lowfd, fd_t highfd, int flags) {
   return internal_syscall(SYSCALL(close_range), lowfd, highfd, flags);
 }
 #    endif
-
-uptr internal_close(fd_t fd) {
-#    if SANITIZER_EMSCRIPTEN
-  return __wasi_fd_close(fd);
-#    else
-  return internal_syscall(SYSCALL(close), fd);
-#    endif
-}
+uptr internal_close(fd_t fd) { return internal_syscall(SYSCALL(close), fd); }
 
 uptr internal_open(const char *filename, int flags) {
-#    if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags);
 #    else
   return internal_syscall(SYSCALL(open), (uptr)filename, flags);
@@ -317,7 +301,7 @@ uptr internal_open(const char *filename, int flags) {
 }
 
 uptr internal_open(const char *filename, int flags, u32 mode) {
-#    if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags,
                           mode);
 #    else
@@ -326,35 +310,17 @@ uptr internal_open(const char *filename, int flags, u32 mode) {
 }
 
 uptr internal_read(fd_t fd, void *buf, uptr count) {
-#    if SANITIZER_EMSCRIPTEN
-  __wasi_iovec_t iov = {(uint8_t *)buf, count};
-  size_t num;
-  if (__wasi_syscall_ret(__wasi_fd_read(fd, &iov, 1, &num))) {
-    return -1;
-  }
-  return num;
-#    else
   sptr res;
   HANDLE_EINTR(res,
                (sptr)internal_syscall(SYSCALL(read), fd, (uptr)buf, count));
   return res;
-#    endif
 }
 
 uptr internal_write(fd_t fd, const void *buf, uptr count) {
-#    if SANITIZER_EMSCRIPTEN
-  __wasi_ciovec_t iov = {(const uint8_t *)buf, count};
-  size_t num;
-  if (__wasi_syscall_ret(__wasi_fd_write(fd, &iov, 1, &num))) {
-    return -1;
-  }
-  return num;
-#    else
   sptr res;
   HANDLE_EINTR(res,
                (sptr)internal_syscall(SYSCALL(write), fd, (uptr)buf, count));
   return res;
-#    endif
 }
 
 uptr internal_ftruncate(fd_t fd, uptr size) {
@@ -577,7 +543,7 @@ uptr internal_filesize(fd_t fd) {
 uptr internal_dup(int oldfd) { return internal_syscall(SYSCALL(dup), oldfd); }
 
 uptr internal_dup2(int oldfd, int newfd) {
-#    if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0);
 #    else
   return internal_syscall(SYSCALL(dup2), oldfd, newfd);
@@ -585,7 +551,7 @@ uptr internal_dup2(int oldfd, int newfd) {
 }
 
 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
-#    if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(readlinkat), AT_FDCWD, (uptr)path, (uptr)buf,
                           bufsize);
 #    else
@@ -594,7 +560,7 @@ uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
 }
 
 uptr internal_unlink(const char *path) {
-#    if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
 #    else
   return internal_syscall(SYSCALL(unlink), (uptr)path);
@@ -605,7 +571,7 @@ uptr internal_rename(const char *oldpath, const char *newpath) {
 #    if (defined(__riscv) || defined(__loongarch__)) && defined(__linux__)
   return internal_syscall(SYSCALL(renameat2), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath, 0);
-#    elif SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#    elif SANITIZER_LINUX
   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath);
 #    else
@@ -613,46 +579,32 @@ uptr internal_rename(const char *oldpath, const char *newpath) {
 #    endif
 }
 
-uptr internal_sched_yield() {
-#    if SANITIZER_EMSCRIPTEN
-  return 0;
-#    else
-  return internal_syscall(SYSCALL(sched_yield));
-#    endif
-}
+uptr internal_sched_yield() { return internal_syscall(SYSCALL(sched_yield)); }
 
 void internal_usleep(u64 useconds) {
-#    if SANITIZER_EMSCRIPTEN
-  usleep(useconds);
-#    else
   struct timespec ts;
   ts.tv_sec = useconds / 1000000;
   ts.tv_nsec = (useconds % 1000000) * 1000;
   internal_syscall(SYSCALL(nanosleep), &ts, &ts);
-#    endif
 }
 
-#    if !SANITIZER_EMSCRIPTEN
 uptr internal_execve(const char *filename, char *const argv[],
                      char *const envp[]) {
   return internal_syscall(SYSCALL(execve), (uptr)filename, (uptr)argv,
                           (uptr)envp);
 }
-#    endif  // !SANITIZER_EMSCRIPTEN
-#  endif    // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 
-#  if !SANITIZER_NETBSD
+#  if !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 void internal__exit(int exitcode) {
-#    if SANITIZER_EMSCRIPTEN
-  __wasi_proc_exit(exitcode);
-#    elif SANITIZER_FREEBSD || SANITIZER_SOLARIS
+#    if SANITIZER_FREEBSD || SANITIZER_SOLARIS
   internal_syscall(SYSCALL(exit), exitcode);
 #    else
   internal_syscall(SYSCALL(exit_group), exitcode);
 #    endif
   Die();  // Unreachable.
 }
-#  endif  // !SANITIZER_NETBSD
+#  endif  // !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 
 // ----------------- sanitizer_common.h
 bool FileExists(const char *filename) {
@@ -672,7 +624,7 @@ bool DirExists(const char *path) {
   return S_ISDIR(st.st_mode);
 }
 
-#  if !SANITIZER_NETBSD
+#  if !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 tid_t GetTid() {
 #    if SANITIZER_FREEBSD
   long Tid;
@@ -680,8 +632,6 @@ tid_t GetTid() {
   return Tid;
 #    elif SANITIZER_SOLARIS
   return thr_self();
-#    elif SANITIZER_EMSCRIPTEN
-  return (tid_t)pthread_self();
 #    else
   return internal_syscall(SYSCALL(gettid));
 #    endif
@@ -722,16 +672,6 @@ u64 NanoTime() {
 }
 #  endif
 
-#  if SANITIZER_EMSCRIPTEN
-extern "C" {
-int __clock_gettime(__sanitizer_clockid_t clk_id, void *tp);
-}
-
-uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
-  return __clock_gettime(clk_id, tp);
-}
-#  endif
-
 // Like getenv, but reads env directly from /proc (on Linux) or parses the
 // 'environ' array (on some others) and does not use libc. This function
 // should be called first inside __asan_init.
@@ -916,14 +856,12 @@ struct linux_dirent {
 };
 #  endif
 
-#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
-#    if !SANITIZER_EMSCRIPTEN
+#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 // Syscall wrappers.
 uptr internal_ptrace(int request, int pid, void *addr, void *data) {
   return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr,
                           (uptr)data);
 }
-#    endif
 
 uptr internal_waitpid(int pid, int *status, int options) {
   return internal_syscall(SYSCALL(wait4), pid, (uptr)status, options,
@@ -953,14 +891,7 @@ uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {
 }
 
 uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
-#    if SANITIZER_EMSCRIPTEN
-  __wasi_filesize_t result;
-  return __wasi_syscall_ret(__wasi_fd_seek(fd, offset, whence, &result))
-             ? -1
-             : result;
-#    else
   return internal_syscall(SYSCALL(lseek), fd, offset, whence);
-#    endif
 }
 
 #    if SANITIZER_LINUX
@@ -976,32 +907,25 @@ uptr internal_arch_prctl(int option, uptr arg2) {
 #      endif
 #    endif
 
-#    if !SANITIZER_EMSCRIPTEN
 uptr internal_sigaltstack(const void *ss, void *oss) {
   return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss);
 }
-#    endif
 
 extern "C" pid_t __fork(void);
 
 int internal_fork() {
-#    if SANITIZER_EMSCRIPTEN
-  Report("fork not supported on emscripten\n");
-  return -1;
-#    else
-#      if SANITIZER_LINUX
-#        if SANITIZER_S390
+#    if SANITIZER_LINUX
+#      if SANITIZER_S390
   return internal_syscall(SYSCALL(clone), 0, SIGCHLD);
-#        elif SANITIZER_SPARC
+#      elif SANITIZER_SPARC
   // The clone syscall interface on SPARC differs massively from the rest,
   // so fall back to __fork.
   return __fork();
-#        else
-  return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
-#        endif
 #      else
-  return internal_syscall(SYSCALL(fork));
+  return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
 #      endif
+#    else
+  return internal_syscall(SYSCALL(fork));
 #    endif
 }
 
@@ -1093,8 +1017,6 @@ uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
                           __sanitizer_sigset_t *oldset) {
 #    if SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(sigprocmask), how, set, oldset);
-#    elif SANITIZER_EMSCRIPTEN
-  return 0;
 #    else
   __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
   __sanitizer_kernel_sigset_t *k_oldset = (__sanitizer_kernel_sigset_t *)oldset;
@@ -1146,7 +1068,7 @@ bool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
   return sigismember(rset, signum);
 }
 #    endif
-#  endif  // !SANITIZER_SOLARIS
+#  endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 
 #  if !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 // ThreadLister implementation.
diff --git a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h
index 15a72d2d714d1..3cc84b995c62f 100644
--- a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h
+++ b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h
@@ -308,7 +308,7 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_SENDMMSG SI_LINUX
 #define SANITIZER_INTERCEPT_SYSMSG SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_GETPEERNAME SI_POSIX
-#define SANITIZER_INTERCEPT_IOCTL SI_POSIX && !SI_EMSCRIPTEN
+#define SANITIZER_INTERCEPT_IOCTL SI_POSIX_NOT_EMSCRIPTEN
 #define SANITIZER_INTERCEPT_INET_ATON SI_POSIX
 #define SANITIZER_INTERCEPT_SYSINFO SI_LINUX
 #define SANITIZER_INTERCEPT_READDIR SI_POSIX
diff --git a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
index cb60606f9cbd3..aa05c4f577791 100644
--- a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
+++ b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
@@ -38,6 +38,11 @@
 #define SANITIZER_HAS_STATFS64 1
 #endif
 
+#if SANITIZER_EMSCRIPTEN
+#include <signal.h> // For sigset_t
+#include <time.h>   // For clock_t and clockid_t
+#endif
+
 #if defined(__sparc__)
 // FIXME: This can't be included from tsan which does not support sparc yet.
 #include "sanitizer_glibc_version.h"
@@ -534,16 +539,19 @@ extern unsigned struct_sock_fprog_sz;
 #endif
 
 #if SANITIZER_EMSCRIPTEN
-typedef int __sanitizer_clock_t;
+typedef clock_t __sanitizer_clock_t;
 #elif defined(__x86_64__) && !defined(_LP64)
 typedef long long __sanitizer_clock_t;
 #else
 typedef long __sanitizer_clock_t;
 #endif
 
-#if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
+#if SANITIZER_LINUX
 typedef int __sanitizer_clockid_t;
 typedef unsigned long long __sanitizer_eventfd_t;
+#elif SANITIZER_EMSCRIPTEN
+typedef clockid_t __sanitizer_clockid_t;
+// eventfd is Unix-specific.
 #endif
 
 #if SANITIZER_LINUX
@@ -596,7 +604,7 @@ struct __sanitizer_sigset_t {
   uptr val[128 / sizeof(uptr)];
 };
 #elif SANITIZER_EMSCRIPTEN
-typedef unsigned long __sanitizer_sigset_t;
+typedef sigset_t __sanitizer_sigset_t;
 #endif
 
 struct __sanitizer_siginfo_pad {
diff --git a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc
index ae2cea517c1f9..2780f885d5ab8 100644
--- a/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc
+++ b/system/lib/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc
@@ -10,10 +10,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// NetBSD uses libc calls directly
-#if !SANITIZER_NETBSD
+// NetBSD and Emscripten uses libc calls directly
+#if !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 
-#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_SOLARIS || SANITIZER_EMSCRIPTEN
+#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_SOLARIS
 # define SYSCALL(name) SYS_ ## name
 #else
 # define SYSCALL(name) __NR_ ## name
diff --git a/tools/system_libs.py b/tools/system_libs.py
index 711dc4d5844ea..883c734e84942 100644
--- a/tools/system_libs.py
+++ b/tools/system_libs.py
@@ -2125,9 +2125,7 @@ class libubsan_minimal_rt(CompilerRTLibrary, MTLibrary):
 
 class libsanitizer_common_rt(CompilerRTLibrary, MTLibrary):
   name = 'libsanitizer_common_rt'
-  # TODO(sbc): We should not need musl-internal headers here.
-  includes = ['system/lib/libc/musl/src/internal',
-              'system/lib/compiler-rt/lib',
+  includes = ['system/lib/compiler-rt/lib',
               'system/lib/libc']
   never_force = True
   cflags = [