kit

wasm_host.c (39783B)

---

 #include <kit/wasm.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 typedef struct KitWasmMemoryRecord {
   uint8_t* data;
   uint64_t pages;
   uint64_t max_pages;
   uint32_t flags;
 } KitWasmMemoryRecord;
 
 #define KIT_WASM_HOST_MAX_FDS 64u
 
 typedef struct KitWasmOpenFd {
   uint32_t used;
   uint32_t is_dir;
   KitFileData data;
   const KitFileIO* io;
   uint64_t pos;
   void*  dir_handle;
   char*  host_path;
   size_t host_path_size; /* 0=borrowed (KIT_WASM_FS_FILE), >0=heap-owned */
 } KitWasmOpenFd;
 
 struct KitWasmHost {
   KitWasmHostConfig config;
 };
 
 typedef struct KitWasmRuntimeInstance {
   KitWasmHost* host;
   const KitWasmMemoryLayout* memory_layouts;
   uint64_t allocation_bytes;
   uint64_t instance_bytes;
   uint64_t total_memory_bytes;
   uint8_t** memories;
   uint64_t* memory_bytes;
   uint32_t nmemories;
   int exit_called;
   int exit_code;
   KitWasmOpenFd fds[KIT_WASM_HOST_MAX_FDS];
   uint8_t instance[];
 } KitWasmRuntimeInstance;
 
 enum {
   WASI_ESUCCESS = 0,
   WASI_EACCES = 2,
   WASI_EBADF = 8,
   WASI_EISDIR = 31,
   WASI_EINVAL = 28,
   WASI_EIO = 29,
   WASI_ENOMEM = 34,
   WASI_ENOENT = 44,
   WASI_ENOSYS = 52,
   WASI_ENOTDIR = 54,
   WASI_ENOTCAPABLE = 76,
 };
 
 static KitWasmRuntimeInstance* wasm_wrap_from_instance(KitWasmInstance* inst) {
   return (KitWasmRuntimeInstance*)((uint8_t*)inst -
                                    offsetof(KitWasmRuntimeInstance, instance));
 }
 
 static KitWasmInstance* wasm_instance_from_wrap(KitWasmRuntimeInstance* w) {
   return (KitWasmInstance*)w->instance;
 }
 
 static size_t wasm_cstrlen(const char* s) {
   size_t n = 0;
   if (!s) return 0;
   while (s[n]) ++n;
   return n;
 }
 
 static int wasm_streq(const char* a, const char* b) {
   size_t i = 0;
   if (!a || !b) return 0;
   while (a[i] && b[i]) {
     if (a[i] != b[i]) return 0;
     ++i;
   }
   return a[i] == b[i];
 }
 
 static KitStatus wasm_u64_to_size(uint64_t n, size_t* out) {
   if (n > (uint64_t)SIZE_MAX) return KIT_INVALID;
   *out = (size_t)n;
   return KIT_OK;
 }
 
 static KitStatus wasm_page_bytes(uint64_t pages, uint64_t* out) {
   if (pages > UINT64_MAX / (uint64_t)KIT_WASM_PAGE_SIZE) return KIT_INVALID;
   *out = pages * (uint64_t)KIT_WASM_PAGE_SIZE;
   return KIT_OK;
 }
 
 static uint32_t wasm_preopen_count(const KitWasmHost* host) {
   return host ? host->config.nmounts : 0u;
 }
 
 static const KitWasmFsMount* wasm_preopen_for_fd(KitWasmRuntimeInstance* w,
                                                  uint32_t fd) {
   uint32_t index;
   if (!w || !w->host || fd < 3u) return NULL;
   index = fd - 3u;
   if (index >= w->host->config.nmounts) return NULL;
   return &w->host->config.mounts[index];
 }
 
 static size_t wasm_guest_parent_len(const char* path) {
   size_t i;
   size_t last = 0;
   if (!path || path[0] != '/') return 0;
   for (i = 1; path[i]; ++i) {
     if (path[i] == '/') last = i;
   }
   return last ? last : 1u;
 }
 
 static const char* wasm_guest_basename(const char* path) {
   size_t i;
   size_t last = 0;
   if (!path) return NULL;
   for (i = 0; path[i]; ++i) {
     if (path[i] == '/') last = i + 1u;
   }
   return path + last;
 }
 
 static int wasm_bytes_eq_cstr(const uint8_t* a, uint32_t alen,
                               const char* b) {
   uint32_t i;
   if (!a || !b) return 0;
   for (i = 0; i < alen; ++i) {
     if (b[i] == '\0' || a[i] != (uint8_t)b[i]) return 0;
   }
   return b[alen] == '\0';
 }
 
 static KitWasmMemoryRecord* wasm_memory0(KitWasmRuntimeInstance* w) {
   if (!w || w->nmemories == 0 || !w->memory_layouts) return NULL;
   if (w->memory_layouts[0].offset > w->instance_bytes) return NULL;
   if (w->instance_bytes - w->memory_layouts[0].offset <
       sizeof(KitWasmMemoryRecord))
     return NULL;
   return (KitWasmMemoryRecord*)(w->instance + w->memory_layouts[0].offset);
 }
 
 static int wasm_mem_ptr(KitWasmInstance* inst, uint32_t addr, uint32_t n,
                         uint8_t** out) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   KitWasmMemoryRecord* mem = wasm_memory0(w);
   uint64_t end;
   uint64_t size;
   if (!out || !mem || !mem->data) return 0;
   if (addr > UINT32_MAX - n) return 0;
   end = (uint64_t)addr + (uint64_t)n;
   if (wasm_page_bytes(mem->pages, &size) != KIT_OK) return 0;
   if (end > size) return 0;
   *out = mem->data + addr;
   return 1;
 }
 
 static int wasm_read_u32(KitWasmInstance* inst, uint32_t addr, uint32_t* out) {
   uint8_t* p;
   if (!wasm_mem_ptr(inst, addr, 4u, &p)) return 0;
   *out = ((uint32_t)p[0]) | ((uint32_t)p[1] << 8) |
          ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
   return 1;
 }
 
 static int wasm_write_u32(KitWasmInstance* inst, uint32_t addr, uint32_t v) {
   uint8_t* p;
   if (!wasm_mem_ptr(inst, addr, 4u, &p)) return 0;
   p[0] = (uint8_t)(v & 0xffu);
   p[1] = (uint8_t)((v >> 8) & 0xffu);
   p[2] = (uint8_t)((v >> 16) & 0xffu);
   p[3] = (uint8_t)((v >> 24) & 0xffu);
   return 1;
 }
 
 static int wasm_write_u64(KitWasmInstance* inst, uint32_t addr, uint64_t v) {
   uint8_t* p;
   if (!wasm_mem_ptr(inst, addr, 8u, &p)) return 0;
   p[0] = (uint8_t)(v & 0xffu);
   p[1] = (uint8_t)((v >> 8) & 0xffu);
   p[2] = (uint8_t)((v >> 16) & 0xffu);
   p[3] = (uint8_t)((v >> 24) & 0xffu);
   p[4] = (uint8_t)((v >> 32) & 0xffu);
   p[5] = (uint8_t)((v >> 40) & 0xffu);
   p[6] = (uint8_t)((v >> 48) & 0xffu);
   p[7] = (uint8_t)((v >> 56) & 0xffu);
   return 1;
 }
 
 static void wasm_put_u64_le(uint8_t* buf, uint32_t off, uint64_t v) {
   buf[off+0] = (uint8_t)(v);       buf[off+1] = (uint8_t)(v >> 8);
   buf[off+2] = (uint8_t)(v >> 16); buf[off+3] = (uint8_t)(v >> 24);
   buf[off+4] = (uint8_t)(v >> 32); buf[off+5] = (uint8_t)(v >> 40);
   buf[off+6] = (uint8_t)(v >> 48); buf[off+7] = (uint8_t)(v >> 56);
 }
 
 static void wasm_put_u32_le(uint8_t* buf, uint32_t off, uint32_t v) {
   buf[off+0] = (uint8_t)(v);       buf[off+1] = (uint8_t)(v >> 8);
   buf[off+2] = (uint8_t)(v >> 16); buf[off+3] = (uint8_t)(v >> 24);
 }
 
 /* wasi_filestat_t: dev(u64@0) ino(u64@8) filetype(u8@16)+7pad nlink(u64@24)
  * size(u64@32) atim(u64@40) mtim(u64@48) ctim(u64@56) — 64 bytes total */
 static int wasm_write_filestat(KitWasmInstance* inst, uint32_t ptr,
                                uint8_t filetype, uint64_t size,
                                uint64_t mtime_ns) {
   uint8_t* p;
   if (!wasm_mem_ptr(inst, ptr, 64u, &p)) return 0;
   memset(p, 0, 64u);
   p[16] = filetype;
   wasm_put_u64_le(p, 32u, size);
   wasm_put_u64_le(p, 40u, mtime_ns);
   wasm_put_u64_le(p, 48u, mtime_ns);
   wasm_put_u64_le(p, 56u, mtime_ns);
   return 1;
 }
 
 static int wasm_status_errno(KitStatus st) {
   switch (st) {
     case KIT_OK:
       return WASI_ESUCCESS;
     case KIT_NOMEM:
       return WASI_ENOMEM;
     case KIT_NOT_FOUND:
       return WASI_ENOENT;
     case KIT_IO:
       return WASI_EIO;
     case KIT_UNSUPPORTED:
       return WASI_ENOSYS;
     case KIT_INVALID:
     case KIT_MALFORMED:
     case KIT_AMBIGUOUS:
     case KIT_ERR:
     default:
       return WASI_EINVAL;
   }
 }
 
 static int wasm_sig(const KitWasmImportType* t, const KitWasmValType* params,
                     uint32_t nparams, const KitWasmValType* results,
                     uint32_t nresults) {
   uint32_t i;
   if (!t || t->nparams != nparams || t->nresults != nresults) return 0;
   for (i = 0; i < nparams; ++i)
     if (!t->params || t->params[i] != params[i]) return 0;
   for (i = 0; i < nresults; ++i)
     if (!t->results || t->results[i] != results[i]) return 0;
   return 1;
 }
 
 static void wasi_proc_exit(KitWasmInstance* inst, int32_t code) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   w->exit_called = 1;
   w->exit_code = code;
 }
 
 static int32_t wasi_fd_write(KitWasmInstance* inst, int32_t fd_i,
                              int32_t iovs_i, int32_t iovs_len_i,
                              int32_t nwritten_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   uint32_t iovs = (uint32_t)iovs_i;
   uint32_t iovs_len = (uint32_t)iovs_len_i;
   uint32_t nwritten = (uint32_t)nwritten_i;
   uint32_t total = 0;
   uint32_t i;
   if (fd != 1u && fd != 2u) return WASI_EBADF;
   for (i = 0; i < iovs_len; ++i) {
     uint32_t ptr;
     uint32_t len;
     uint8_t* data;
     uint32_t off;
     uint32_t rec;
     size_t wrote = 0;
     KitStatus st;
     if (i > UINT32_MAX / 8u) return WASI_EINVAL;
     off = i * 8u;
     if (iovs > UINT32_MAX - off) return WASI_EINVAL;
     rec = iovs + off;
     if (!wasm_read_u32(inst, rec, &ptr) ||
         !wasm_read_u32(inst, rec + 4u, &len) ||
         !wasm_mem_ptr(inst, ptr, len, &data))
       return WASI_EINVAL;
     if (w->host->config.write) {
       st = w->host->config.write(w->host->config.user, fd, data, len, &wrote);
       if (st != KIT_OK) return wasm_status_errno(st);
       if (wrote > len) wrote = len;
     } else {
       wrote = len;
     }
     if (total > UINT32_MAX - (uint32_t)wrote) return WASI_EINVAL;
     total += (uint32_t)wrote;
     if (wrote < len) break;
   }
   if (!wasm_write_u32(inst, nwritten, total)) return WASI_EINVAL;
   return WASI_ESUCCESS;
 }
 
 static int wasm_strings_size(const char* const* items, uint32_t n,
                              uint32_t* bytes_out) {
   uint64_t total = 0;
   uint32_t i;
   for (i = 0; i < n; ++i) {
     total += (uint64_t)wasm_cstrlen(items ? items[i] : NULL) + 1u;
     if (total > UINT32_MAX) return 0;
   }
   *bytes_out = (uint32_t)total;
   return 1;
 }
 
 static int32_t wasi_environ_sizes_get(KitWasmInstance* inst, int32_t count_i,
                                       int32_t size_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t bytes;
   if (!wasm_strings_size(w->host->config.env, w->host->config.nenv, &bytes))
     return WASI_EINVAL;
   if (!wasm_write_u32(inst, (uint32_t)count_i, w->host->config.nenv) ||
       !wasm_write_u32(inst, (uint32_t)size_i, bytes))
     return WASI_EINVAL;
   return WASI_ESUCCESS;
 }
 
 static int wasm_write_strings(KitWasmInstance* inst, const char* const* items,
                               uint32_t nitems, uint32_t ptrs_addr,
                               uint32_t buf_addr) {
   uint32_t total;
   uint8_t* ptrs;
   uint8_t* buf;
   uint32_t off = 0;
   uint32_t i;
   if (!wasm_strings_size(items, nitems, &total)) return 0;
   if (nitems > UINT32_MAX / 4u) return 0;
   if (!wasm_mem_ptr(inst, ptrs_addr, nitems * 4u, &ptrs) ||
       !wasm_mem_ptr(inst, buf_addr, total, &buf))
     return 0;
   (void)ptrs;
   for (i = 0; i < nitems; ++i) {
     const char* s = items ? items[i] : NULL;
     size_t len = wasm_cstrlen(s);
     if (len > (size_t)(UINT32_MAX - off - 1u)) return 0;
     if (!wasm_write_u32(inst, ptrs_addr + i * 4u, buf_addr + off)) return 0;
     if (len) memcpy(buf + off, s, len);
     buf[off + (uint32_t)len] = 0;
     off += (uint32_t)len + 1u;
   }
   return 1;
 }
 
 static int32_t wasi_environ_get(KitWasmInstance* inst, int32_t env_i,
                                 int32_t buf_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   return wasm_write_strings(inst, w->host->config.env, w->host->config.nenv,
                             (uint32_t)env_i,
                             (uint32_t)buf_i)
              ? WASI_ESUCCESS
              : WASI_EINVAL;
 }
 
 static int32_t wasi_args_sizes_get(KitWasmInstance* inst, int32_t count_i,
                                    int32_t size_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t bytes;
   if (!wasm_strings_size(w->host->config.args, w->host->config.nargs, &bytes))
     return WASI_EINVAL;
   if (!wasm_write_u32(inst, (uint32_t)count_i, w->host->config.nargs) ||
       !wasm_write_u32(inst, (uint32_t)size_i, bytes))
     return WASI_EINVAL;
   return WASI_ESUCCESS;
 }
 
 static int32_t wasi_args_get(KitWasmInstance* inst, int32_t args_i,
                              int32_t buf_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   return wasm_write_strings(inst, w->host->config.args, w->host->config.nargs,
                             (uint32_t)args_i,
                             (uint32_t)buf_i)
              ? WASI_ESUCCESS
              : WASI_EINVAL;
 }
 
 static int32_t wasi_random_get(KitWasmInstance* inst, int32_t ptr_i,
                                int32_t len_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint8_t* dst;
   KitStatus st;
   if (!w->host->config.random) return WASI_ENOSYS;
   if (!wasm_mem_ptr(inst, (uint32_t)ptr_i, (uint32_t)len_i, &dst))
     return WASI_EINVAL;
   st = w->host->config.random(w->host->config.user, dst, (size_t)len_i);
   return wasm_status_errno(st);
 }
 
 static int32_t wasi_clock_time_get(KitWasmInstance* inst, int32_t clock_id_i,
                                    int64_t precision_i, int32_t time_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint64_t ns = 0;
   KitStatus st;
   (void)precision_i;
   if (!w->host->config.clock) return WASI_ENOSYS;
   st = w->host->config.clock(w->host->config.user, (uint32_t)clock_id_i, &ns);
   if (st != KIT_OK) return wasm_status_errno(st);
   return wasm_write_u64(inst, (uint32_t)time_i, ns) ? WASI_ESUCCESS
                                                     : WASI_EINVAL;
 }
 
 static int32_t wasi_fd_prestat_get(KitWasmInstance* inst, int32_t fd_i,
                                    int32_t prestat_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   const KitWasmFsMount* m = wasm_preopen_for_fd(w, (uint32_t)fd_i);
   uint8_t* p;
   uint32_t len;
   if (!m) return WASI_EBADF;
   len = (m->flags & KIT_WASM_FS_FILE)
             ? (uint32_t)wasm_guest_parent_len(m->guest_path)
             : (uint32_t)wasm_cstrlen(m->guest_path);
   if (!wasm_mem_ptr(inst, (uint32_t)prestat_i, 8u, &p)) return WASI_EINVAL;
   p[0] = 0;
   p[1] = 0;
   p[2] = 0;
   p[3] = 0;
   p[4] = (uint8_t)(len & 0xffu);
   p[5] = (uint8_t)((len >> 8) & 0xffu);
   p[6] = (uint8_t)((len >> 16) & 0xffu);
   p[7] = (uint8_t)((len >> 24) & 0xffu);
   return WASI_ESUCCESS;
 }
 
 static int32_t wasi_fd_prestat_dir_name(KitWasmInstance* inst, int32_t fd_i,
                                         int32_t path_i, int32_t path_len_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   const KitWasmFsMount* m = wasm_preopen_for_fd(w, (uint32_t)fd_i);
   uint8_t* dst;
   size_t len;
   if (!m) return WASI_EBADF;
   len = (m->flags & KIT_WASM_FS_FILE) ? wasm_guest_parent_len(m->guest_path)
                                       : wasm_cstrlen(m->guest_path);
   if ((uint32_t)path_len_i < len) return WASI_EINVAL;
   if (!wasm_mem_ptr(inst, (uint32_t)path_i, (uint32_t)len, &dst))
     return WASI_EINVAL;
   if (len) memcpy(dst, m->guest_path, len);
   return WASI_ESUCCESS;
 }
 
 static int wasm_guest_path_safe(const uint8_t* path, uint32_t len) {
   uint32_t i = 0;
   if (!path || len == 0 || path[0] == '/') return 0;
   while (i < len) {
     uint32_t start = i;
     while (i < len && path[i] != '/') {
       if (path[i] == '\\') return 0;
       ++i;
     }
     if (i == start) return 0;
     if (i - start == 2u && path[start] == '.' && path[start + 1u] == '.')
       return 0;
     if (i < len) ++i;
   }
   return 1;
 }
 
 static KitStatus wasm_join_path(KitHeap* heap, const char* base,
                                 const uint8_t* rel, uint32_t rel_len,
                                 char** out, size_t* out_size) {
   size_t base_len = wasm_cstrlen(base);
   size_t need;
   char* p;
   int slash;
   if (!base || !rel || !out || !out_size) return KIT_INVALID;
   slash = base_len && base[base_len - 1u] != '/' && base[base_len - 1u] != '\\';
   if (base_len > SIZE_MAX - (size_t)rel_len - (slash ? 2u : 1u))
     return KIT_INVALID;
   need = base_len + (slash ? 1u : 0u) + (size_t)rel_len + 1u;
   p = (char*)heap->alloc(heap, need, 1u);
   if (!p) return KIT_NOMEM;
   if (base_len) memcpy(p, base, base_len);
   if (slash) p[base_len++] = '/';
   if (rel_len) memcpy(p + base_len, rel, rel_len);
   p[base_len + (size_t)rel_len] = 0;
   *out = p;
   *out_size = need;
   return KIT_OK;
 }
 
 static int wasm_find_free_fd(KitWasmRuntimeInstance* w, uint32_t* out) {
   uint32_t start = 3u + wasm_preopen_count(w->host);
   uint32_t fd;
   if (start >= KIT_WASM_HOST_MAX_FDS) return 0;
   for (fd = start; fd < KIT_WASM_HOST_MAX_FDS; ++fd) {
     if (!w->fds[fd].used) {
       *out = fd;
       return 1;
     }
   }
   return 0;
 }
 
 static void wasm_fd_close_slot(KitWasmRuntimeInstance* w, uint32_t fd) {
   KitHeap* heap = w->host->config.heap;
   if (!w->fds[fd].used) return;
   if (w->fds[fd].is_dir) {
     if (w->fds[fd].dir_handle && w->host->config.close_dir)
       w->host->config.close_dir(w->host->config.user, w->fds[fd].dir_handle);
   } else {
     if (w->fds[fd].io && w->fds[fd].io->release)
       w->fds[fd].io->release(w->fds[fd].io->user, &w->fds[fd].data);
   }
   if (w->fds[fd].host_path_size > 0)
     heap->free(heap, w->fds[fd].host_path, w->fds[fd].host_path_size);
   memset(&w->fds[fd], 0, sizeof w->fds[fd]);
 }
 
 static int32_t wasi_path_open(KitWasmInstance* inst, int32_t dirfd_i,
                               int32_t dirflags_i, int32_t path_i,
                               int32_t path_len_i, int32_t oflags_i,
                               int64_t rights_base_i,
                               int64_t rights_inheriting_i,
                               int32_t fdflags_i, int32_t opened_fd_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   const KitWasmFsMount* m = wasm_preopen_for_fd(w, (uint32_t)dirfd_i);
   uint8_t* guest_path;
   char* host_path = NULL;
   size_t host_path_size = 0;
   uint32_t fd;
   KitStatus st;
   int open_as_dir;
   (void)dirflags_i;
   (void)rights_base_i;
   (void)rights_inheriting_i;
   (void)fdflags_i;
   if (!m) return WASI_EBADF;
   if (!(m->flags & KIT_WASM_FS_READ)) return WASI_EACCES;
   /* OFLAGS_DIRECTORY=4; CREAT/EXCL/TRUNC not supported */
   if (oflags_i & ~4) return WASI_ENOSYS;
   open_as_dir = (oflags_i & 4) != 0;
   if (!open_as_dir &&
       (!w->host->config.file_io || !w->host->config.file_io->read_all))
     return WASI_ENOSYS;
   if (!wasm_mem_ptr(inst, (uint32_t)path_i, (uint32_t)path_len_i,
                     &guest_path))
     return WASI_EINVAL;
   if (!wasm_guest_path_safe(guest_path, (uint32_t)path_len_i))
     return WASI_ENOTCAPABLE;
   if (m->flags & KIT_WASM_FS_FILE) {
     const char* base = wasm_guest_basename(m->guest_path);
     if (!base || !*base ||
         !wasm_bytes_eq_cstr(guest_path, (uint32_t)path_len_i, base))
       return WASI_ENOENT;
     host_path = (char*)m->host_path; /* borrowed */
   } else {
     st = wasm_join_path(w->host->config.heap, m->host_path, guest_path,
                         (uint32_t)path_len_i, &host_path, &host_path_size);
     if (st != KIT_OK) return wasm_status_errno(st);
   }
   if (open_as_dir) {
     void* dir_handle = NULL;
     if (!w->host->config.open_dir) {
       if (host_path_size > 0)
         w->host->config.heap->free(w->host->config.heap, host_path,
                                    host_path_size);
       return WASI_ENOSYS;
     }
     st = w->host->config.open_dir(w->host->config.user, host_path,
                                    &dir_handle);
     if (st != KIT_OK) {
       if (host_path_size > 0)
         w->host->config.heap->free(w->host->config.heap, host_path,
                                    host_path_size);
       return wasm_status_errno(st);
     }
     if (!wasm_find_free_fd(w, &fd)) {
       if (w->host->config.close_dir)
         w->host->config.close_dir(w->host->config.user, dir_handle);
       if (host_path_size > 0)
         w->host->config.heap->free(w->host->config.heap, host_path,
                                    host_path_size);
       return WASI_ENOMEM;
     }
     w->fds[fd].used = 1;
     w->fds[fd].is_dir = 1;
     w->fds[fd].dir_handle = dir_handle;
     w->fds[fd].host_path = host_path;
     w->fds[fd].host_path_size = host_path_size;
     if (!wasm_write_u32(inst, (uint32_t)opened_fd_i, fd)) return WASI_EINVAL;
     return WASI_ESUCCESS;
   } else {
     KitFileData data;
     memset(&data, 0, sizeof data);
     st = w->host->config.file_io->read_all(w->host->config.file_io->user,
                                            host_path, &data);
     if (st != KIT_OK) {
       if (host_path_size > 0)
         w->host->config.heap->free(w->host->config.heap, host_path,
                                    host_path_size);
       return wasm_status_errno(st);
     }
     if (!wasm_find_free_fd(w, &fd)) {
       if (w->host->config.file_io->release)
         w->host->config.file_io->release(w->host->config.file_io->user, &data);
       if (host_path_size > 0)
         w->host->config.heap->free(w->host->config.heap, host_path,
                                    host_path_size);
       return WASI_ENOMEM;
     }
     w->fds[fd].used = 1;
     w->fds[fd].data = data;
     w->fds[fd].io = w->host->config.file_io;
     w->fds[fd].pos = 0;
     w->fds[fd].host_path = host_path;
     w->fds[fd].host_path_size = host_path_size;
     if (!wasm_write_u32(inst, (uint32_t)opened_fd_i, fd)) return WASI_EINVAL;
     return WASI_ESUCCESS;
   }
 }
 
 static int32_t wasi_fd_read(KitWasmInstance* inst, int32_t fd_i,
                             int32_t iovs_i, int32_t iovs_len_i,
                             int32_t nread_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   uint32_t iovs = (uint32_t)iovs_i;
   uint32_t iovs_len = (uint32_t)iovs_len_i;
   uint32_t total = 0;
   uint32_t i;
   if (fd >= KIT_WASM_HOST_MAX_FDS || !w->fds[fd].used) return WASI_EBADF;
   if (w->fds[fd].is_dir) return WASI_EISDIR;
   for (i = 0; i < iovs_len; ++i) {
     uint32_t ptr;
     uint32_t len;
     uint8_t* dst;
     uint32_t off;
     uint32_t rec;
     uint64_t remain64;
     uint32_t ncopy;
     if (i > UINT32_MAX / 8u) return WASI_EINVAL;
     off = i * 8u;
     if (iovs > UINT32_MAX - off) return WASI_EINVAL;
     rec = iovs + off;
     if (!wasm_read_u32(inst, rec, &ptr) ||
         !wasm_read_u32(inst, rec + 4u, &len) ||
         !wasm_mem_ptr(inst, ptr, len, &dst))
       return WASI_EINVAL;
     if (w->fds[fd].pos >= (uint64_t)w->fds[fd].data.size) break;
     remain64 = (uint64_t)w->fds[fd].data.size - w->fds[fd].pos;
     ncopy = len;
     if ((uint64_t)ncopy > remain64) ncopy = (uint32_t)remain64;
     if (ncopy)
       memcpy(dst, w->fds[fd].data.data + (size_t)w->fds[fd].pos, ncopy);
     w->fds[fd].pos += ncopy;
     if (total > UINT32_MAX - ncopy) return WASI_EINVAL;
     total += ncopy;
     if (ncopy < len) break;
   }
   if (!wasm_write_u32(inst, (uint32_t)nread_i, total)) return WASI_EINVAL;
   return WASI_ESUCCESS;
 }
 
 static int32_t wasi_fd_close(KitWasmInstance* inst, int32_t fd_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   if (fd >= KIT_WASM_HOST_MAX_FDS || !w->fds[fd].used) return WASI_EBADF;
   wasm_fd_close_slot(w, fd);
   return WASI_ESUCCESS;
 }
 
 static int32_t wasi_fd_seek(KitWasmInstance* inst, int32_t fd_i,
                             int64_t offset, int32_t whence_i,
                             int32_t newoffset_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   int64_t base;
   int64_t newpos;
   if (fd >= KIT_WASM_HOST_MAX_FDS || !w->fds[fd].used) return WASI_EBADF;
   if (w->fds[fd].is_dir) return WASI_EISDIR;
   switch (whence_i) {
     case 0: base = 0; break;
     case 1: base = (int64_t)w->fds[fd].pos; break;
     case 2: base = (int64_t)(uint64_t)w->fds[fd].data.size; break;
     default: return WASI_EINVAL;
   }
   if (offset < 0 && (uint64_t)(-offset) > (uint64_t)base) return WASI_EINVAL;
   newpos = base + offset;
   if (newpos < 0) return WASI_EINVAL;
   if ((uint64_t)newpos > (uint64_t)w->fds[fd].data.size)
     newpos = (int64_t)(uint64_t)w->fds[fd].data.size;
   w->fds[fd].pos = (uint64_t)newpos;
   return wasm_write_u64(inst, (uint32_t)newoffset_i, (uint64_t)newpos)
              ? WASI_ESUCCESS
              : WASI_EINVAL;
 }
 
 static int32_t wasi_fd_tell(KitWasmInstance* inst, int32_t fd_i,
                             int32_t offset_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   if (fd >= KIT_WASM_HOST_MAX_FDS || !w->fds[fd].used) return WASI_EBADF;
   if (w->fds[fd].is_dir) return WASI_EISDIR;
   return wasm_write_u64(inst, (uint32_t)offset_i, w->fds[fd].pos)
              ? WASI_ESUCCESS
              : WASI_EINVAL;
 }
 
 static int32_t wasi_fd_filestat_get(KitWasmInstance* inst, int32_t fd_i,
                                     int32_t filestat_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   uint32_t npreopen = wasm_preopen_count(w->host);
   uint64_t size = 0, mtime_ns = 0;
   uint8_t ft;
   if (fd <= 2u)
     return wasm_write_filestat(inst, (uint32_t)filestat_i,
                                KIT_WASM_FILETYPE_CHARACTER_DEVICE, 0u, 0u)
                ? WASI_ESUCCESS
                : WASI_EINVAL;
   if (fd >= 3u && fd < 3u + npreopen) {
     const KitWasmFsMount* m = wasm_preopen_for_fd(w, fd);
     ft = (m && (m->flags & KIT_WASM_FS_FILE)) ? KIT_WASM_FILETYPE_REGULAR_FILE
                                               : KIT_WASM_FILETYPE_DIRECTORY;
     return wasm_write_filestat(inst, (uint32_t)filestat_i, ft, 0u, 0u)
                ? WASI_ESUCCESS
                : WASI_EINVAL;
   }
   if (fd >= KIT_WASM_HOST_MAX_FDS || !w->fds[fd].used) return WASI_EBADF;
   ft = w->fds[fd].is_dir ? KIT_WASM_FILETYPE_DIRECTORY
                          : KIT_WASM_FILETYPE_REGULAR_FILE;
   if (w->host->config.stat_path && w->fds[fd].host_path) {
     w->host->config.stat_path(w->host->config.user, w->fds[fd].host_path,
                               &size, &mtime_ns, &ft);
   } else if (!w->fds[fd].is_dir) {
     size = (uint64_t)w->fds[fd].data.size;
   }
   return wasm_write_filestat(inst, (uint32_t)filestat_i, ft, size, mtime_ns)
              ? WASI_ESUCCESS
              : WASI_EINVAL;
 }
 
 static int32_t wasi_path_filestat_get(KitWasmInstance* inst, int32_t dirfd_i,
                                       int32_t flags_i, int32_t path_i,
                                       int32_t path_len_i,
                                       int32_t filestat_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   const KitWasmFsMount* m = wasm_preopen_for_fd(w, (uint32_t)dirfd_i);
   uint8_t* guest_path;
   char* host_path = NULL;
   size_t host_path_size = 0;
   uint64_t size = 0, mtime_ns = 0;
   uint8_t ft = KIT_WASM_FILETYPE_UNKNOWN;
   KitStatus st;
   (void)flags_i;
   if (!m) return WASI_EBADF;
   if (!w->host->config.stat_path) return WASI_ENOSYS;
   if (!wasm_mem_ptr(inst, (uint32_t)path_i, (uint32_t)path_len_i, &guest_path))
     return WASI_EINVAL;
   if (!wasm_guest_path_safe(guest_path, (uint32_t)path_len_i))
     return WASI_ENOTCAPABLE;
   if (m->flags & KIT_WASM_FS_FILE) {
     const char* base = wasm_guest_basename(m->guest_path);
     if (!base || !*base ||
         !wasm_bytes_eq_cstr(guest_path, (uint32_t)path_len_i, base))
       return WASI_ENOENT;
     host_path = (char*)m->host_path;
   } else {
     st = wasm_join_path(w->host->config.heap, m->host_path, guest_path,
                         (uint32_t)path_len_i, &host_path, &host_path_size);
     if (st != KIT_OK) return wasm_status_errno(st);
   }
   st = w->host->config.stat_path(w->host->config.user, host_path,
                                   &size, &mtime_ns, &ft);
   if (host_path_size > 0)
     w->host->config.heap->free(w->host->config.heap, host_path, host_path_size);
   if (st != KIT_OK) return wasm_status_errno(st);
   return wasm_write_filestat(inst, (uint32_t)filestat_i, ft, size, mtime_ns)
              ? WASI_ESUCCESS
              : WASI_EINVAL;
 }
 
 /* wasi_dirent_t: d_next(u64@0) ino(u64@8) namlen(u32@16) type(u8@20) 3pad
  * then namlen bytes of name (no NUL). Cookie = zero-based entry index. */
 static int32_t wasi_fd_readdir(KitWasmInstance* inst, int32_t fd_i,
                                int32_t buf_i, int32_t buf_len_i,
                                int64_t cookie_i, int32_t bufused_i) {
   KitWasmRuntimeInstance* w = wasm_wrap_from_instance(inst);
   uint32_t fd = (uint32_t)fd_i;
   uint32_t buf_len = (uint32_t)buf_len_i;
   uint64_t cookie = (uint64_t)cookie_i;
   uint8_t* buf;
   uint32_t written = 0;
   if (fd >= KIT_WASM_HOST_MAX_FDS || !w->fds[fd].used) return WASI_EBADF;
   if (!w->fds[fd].is_dir) return WASI_ENOTDIR;
   if (!w->host->config.read_dir_entry) return WASI_ENOSYS;
   if (!wasm_mem_ptr(inst, (uint32_t)buf_i, buf_len, &buf)) return WASI_EINVAL;
   while (written < buf_len) {
     KitWasmDirEntry entry;
     uint8_t hdr[24];
     uint32_t remain = buf_len - written;
     uint32_t to_write;
     KitStatus st = w->host->config.read_dir_entry(
         w->host->config.user, w->fds[fd].dir_handle, cookie, &entry);
     if (st == KIT_NOT_FOUND) break;
     if (st != KIT_OK) return wasm_status_errno(st);
     memset(hdr, 0, 24u);
     wasm_put_u64_le(hdr, 0u, cookie + 1u);
     wasm_put_u64_le(hdr, 8u, entry.ino);
     wasm_put_u32_le(hdr, 16u, entry.name_len);
     hdr[20] = entry.filetype;
     to_write = (remain < 24u) ? remain : 24u;
     memcpy(buf + written, hdr, to_write);
     written += to_write;
     remain -= to_write;
     if (remain > 0u && entry.name_len > 0u && entry.name) {
       to_write = (remain < entry.name_len) ? remain : entry.name_len;
       memcpy(buf + written, entry.name, to_write);
       written += to_write;
     }
     ++cookie;
   }
   return wasm_write_u32(inst, (uint32_t)bufused_i, written) ? WASI_ESUCCESS
                                                             : WASI_EINVAL;
 }
 
 static void* wasm_wasi_resolve(void* user, const char* module,
                                const char* field,
                                const KitWasmImportType* type) {
   KitWasmHost* host = (KitWasmHost*)user;
   KitWasmValType r_i32[1] = {KIT_WASM_VAL_I32};
   KitWasmValType p_proc_exit[1] = {KIT_WASM_VAL_I32};
   KitWasmValType p2_i32[2] = {KIT_WASM_VAL_I32, KIT_WASM_VAL_I32};
   KitWasmValType p4_i32[4] = {KIT_WASM_VAL_I32, KIT_WASM_VAL_I32,
                               KIT_WASM_VAL_I32, KIT_WASM_VAL_I32};
   KitWasmValType p5_i32[5] = {KIT_WASM_VAL_I32, KIT_WASM_VAL_I32,
                               KIT_WASM_VAL_I32, KIT_WASM_VAL_I32,
                               KIT_WASM_VAL_I32};
   KitWasmValType p_clock[3] = {KIT_WASM_VAL_I32, KIT_WASM_VAL_I64,
                                KIT_WASM_VAL_I32};
   KitWasmValType p_path_open[9] = {
       KIT_WASM_VAL_I32, KIT_WASM_VAL_I32, KIT_WASM_VAL_I32,
       KIT_WASM_VAL_I32, KIT_WASM_VAL_I32, KIT_WASM_VAL_I64,
       KIT_WASM_VAL_I64, KIT_WASM_VAL_I32, KIT_WASM_VAL_I32};
   KitWasmValType p_fd_seek[4] = {KIT_WASM_VAL_I32, KIT_WASM_VAL_I64,
                                  KIT_WASM_VAL_I32, KIT_WASM_VAL_I32};
   KitWasmValType p_fd_readdir[5] = {KIT_WASM_VAL_I32, KIT_WASM_VAL_I32,
                                     KIT_WASM_VAL_I32, KIT_WASM_VAL_I64,
                                     KIT_WASM_VAL_I32};
   if (!host || !(host->config.flags & KIT_WASM_HOST_WASI_PREVIEW1))
     return NULL;
   if (!wasm_streq(module, "wasi_snapshot_preview1")) return NULL;
   if (wasm_streq(field, "proc_exit") &&
       wasm_sig(type, p_proc_exit, 1u, NULL, 0u))
     return (void*)(uintptr_t)wasi_proc_exit;
   if (wasm_streq(field, "fd_write") &&
       wasm_sig(type, p4_i32, 4u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_write;
   if (wasm_streq(field, "environ_sizes_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_environ_sizes_get;
   if (wasm_streq(field, "environ_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_environ_get;
   if (wasm_streq(field, "args_sizes_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_args_sizes_get;
   if (wasm_streq(field, "args_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_args_get;
   if (wasm_streq(field, "random_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_random_get;
   if (wasm_streq(field, "clock_time_get") &&
       wasm_sig(type, p_clock, 3u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_clock_time_get;
   if (wasm_streq(field, "fd_prestat_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_prestat_get;
   if (wasm_streq(field, "fd_prestat_dir_name") &&
       wasm_sig(type, p4_i32, 4u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_prestat_dir_name;
   if (wasm_streq(field, "path_open") &&
       wasm_sig(type, p_path_open, 9u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_path_open;
   if (wasm_streq(field, "fd_read") &&
       wasm_sig(type, p4_i32, 4u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_read;
   if (wasm_streq(field, "fd_close") &&
       wasm_sig(type, p_proc_exit, 1u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_close;
   if (wasm_streq(field, "fd_seek") &&
       wasm_sig(type, p_fd_seek, 4u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_seek;
   if (wasm_streq(field, "fd_tell") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_tell;
   if (wasm_streq(field, "fd_filestat_get") &&
       wasm_sig(type, p2_i32, 2u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_filestat_get;
   if (wasm_streq(field, "path_filestat_get") &&
       wasm_sig(type, p5_i32, 5u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_path_filestat_get;
   if (wasm_streq(field, "fd_readdir") &&
       wasm_sig(type, p_fd_readdir, 5u, r_i32, 1u))
     return (void*)(uintptr_t)wasi_fd_readdir;
   return NULL;
 }
 
 KIT_API KitStatus kit_wasm_host_new(const KitWasmHostConfig* config,
                                     KitWasmHost** out) {
   KitWasmHost* host;
   uint32_t i;
   if (!out || !config || !config->heap) return KIT_INVALID;
   *out = NULL;
   if (config->nmounts && !config->mounts) return KIT_INVALID;
   if (config->nmounts > KIT_WASM_HOST_MAX_FDS - 3u) return KIT_INVALID;
   for (i = 0; i < config->nmounts; ++i) {
     const KitWasmFsMount* m = &config->mounts[i];
     if (!m->host_path || !m->guest_path || m->guest_path[0] != '/')
       return KIT_INVALID;
     if ((m->flags & KIT_WASM_FS_FILE) &&
         (!*wasm_guest_basename(m->guest_path)))
       return KIT_INVALID;
   }
   host = (KitWasmHost*)config->heap->alloc(config->heap, sizeof(*host),
                                            _Alignof(KitWasmHost));
   if (!host) return KIT_NOMEM;
   host->config = *config;
   *out = host;
   return KIT_OK;
 }
 
 KIT_API void kit_wasm_host_free(KitWasmHost* host) {
   KitHeap* heap;
   if (!host) return;
   heap = host->config.heap;
   heap->free(heap, host, sizeof(*host));
 }
 
 KIT_API KitStatus kit_wasm_instance_new(KitWasmHost* host, KitJit* jit,
                                         KitWasmInstance** out) {
   KitWasmRuntimeLayout layout;
   KitWasmRuntimeInstance* w;
   KitHeap* heap;
   uint64_t instance_bytes;
   uint64_t allocation_bytes;
   size_t allocation_size;
   uint64_t total_memory = 0;
   KitStatus st;
   uint32_t i;
   if (!out || !host || !host->config.heap || !jit) return KIT_INVALID;
   *out = NULL;
   heap = host->config.heap;
   st = kit_wasm_get_runtime_layout(jit, &layout);
   if (st != KIT_OK) return st;
   if (layout.nmemories > host->config.max_memories) return KIT_INVALID;
   instance_bytes = layout.instance_size ? layout.instance_size : 1u;
   if (instance_bytes > host->config.max_instance_bytes) return KIT_INVALID;
   if (instance_bytes > UINT64_MAX - offsetof(KitWasmRuntimeInstance, instance))
     return KIT_INVALID;
   allocation_bytes =
       (uint64_t)offsetof(KitWasmRuntimeInstance, instance) + instance_bytes;
   st = wasm_u64_to_size(allocation_bytes, &allocation_size);
   if (st != KIT_OK) return st;
   w = (KitWasmRuntimeInstance*)heap->alloc(heap, allocation_size,
                                           _Alignof(KitWasmRuntimeInstance));
   if (!w) return KIT_NOMEM;
   memset(w, 0, allocation_size);
   w->host = host;
   w->memory_layouts = layout.memories;
   w->allocation_bytes = allocation_bytes;
   w->instance_bytes = instance_bytes;
   w->nmemories = layout.nmemories;
   if (layout.nmemories) {
     size_t ptr_bytes;
     size_t bytes_bytes;
     if ((uint64_t)layout.nmemories > (uint64_t)SIZE_MAX / sizeof(uint8_t*) ||
         (uint64_t)layout.nmemories > (uint64_t)SIZE_MAX / sizeof(uint64_t)) {
       heap->free(heap, w, allocation_size);
       return KIT_INVALID;
     }
     ptr_bytes = (size_t)layout.nmemories * sizeof(uint8_t*);
     bytes_bytes = (size_t)layout.nmemories * sizeof(uint64_t);
     w->memories = (uint8_t**)heap->alloc(heap, ptr_bytes, _Alignof(uint8_t*));
     w->memory_bytes =
         (uint64_t*)heap->alloc(heap, bytes_bytes, _Alignof(uint64_t));
     if (!w->memories || !w->memory_bytes) {
       if (w->memory_bytes) heap->free(heap, w->memory_bytes, bytes_bytes);
       if (w->memories) heap->free(heap, w->memories, ptr_bytes);
       heap->free(heap, w, allocation_size);
       return KIT_NOMEM;
     }
     memset(w->memories, 0, ptr_bytes);
     memset(w->memory_bytes, 0, bytes_bytes);
   }
   for (i = 0; i < layout.nmemories; ++i) {
     const KitWasmMemoryLayout* ml = &layout.memories[i];
     KitWasmMemoryRecord* rec;
     uint64_t mem_bytes;
     size_t mem_size;
     if (ml->max_pages < ml->min_pages) {
       kit_wasm_instance_free(wasm_instance_from_wrap(w));
       return KIT_MALFORMED;
     }
     if (ml->offset > instance_bytes ||
         instance_bytes - ml->offset < sizeof(KitWasmMemoryRecord)) {
       kit_wasm_instance_free(wasm_instance_from_wrap(w));
       return KIT_MALFORMED;
     }
     st = wasm_page_bytes(ml->max_pages, &mem_bytes);
     if (st != KIT_OK) {
       kit_wasm_instance_free(wasm_instance_from_wrap(w));
       return st;
     }
     if (mem_bytes > host->config.max_total_memory_bytes ||
         total_memory > host->config.max_total_memory_bytes - mem_bytes) {
       kit_wasm_instance_free(wasm_instance_from_wrap(w));
       return KIT_INVALID;
     }
     total_memory += mem_bytes;
     st = wasm_u64_to_size(mem_bytes, &mem_size);
     if (st != KIT_OK) {
       kit_wasm_instance_free(wasm_instance_from_wrap(w));
       return st;
     }
     if (mem_size) {
       w->memories[i] = (uint8_t*)heap->alloc(heap, mem_size, 1u);
       if (!w->memories[i]) {
         kit_wasm_instance_free(wasm_instance_from_wrap(w));
         return KIT_NOMEM;
       }
       memset(w->memories[i], 0, mem_size);
     }
     w->memory_bytes[i] = mem_bytes;
     rec = (KitWasmMemoryRecord*)(w->instance + ml->offset);
     rec->data = w->memories[i];
   }
   w->total_memory_bytes = total_memory;
   *out = wasm_instance_from_wrap(w);
   return KIT_OK;
 }
 
 KIT_API void kit_wasm_instance_free(KitWasmInstance* inst) {
   KitWasmRuntimeInstance* w;
   KitHeap* heap;
   uint32_t i;
   size_t allocation_size;
   if (!inst) return;
   w = wasm_wrap_from_instance(inst);
   heap = w->host->config.heap;
   for (i = 0; i < KIT_WASM_HOST_MAX_FDS; ++i)
     wasm_fd_close_slot(w, i);
   for (i = 0; i < w->nmemories; ++i) {
     size_t mem_size;
     if (w->memories && w->memories[i] &&
         wasm_u64_to_size(w->memory_bytes[i], &mem_size) == KIT_OK)
       heap->free(heap, w->memories[i], mem_size);
   }
   if (w->memories)
     heap->free(heap, w->memories, (size_t)w->nmemories * sizeof(uint8_t*));
   if (w->memory_bytes)
     heap->free(heap, w->memory_bytes,
                (size_t)w->nmemories * sizeof(uint64_t));
   allocation_size = (size_t)w->allocation_bytes;
   heap->free(heap, w, allocation_size);
 }
 
 KIT_API KitStatus kit_wasm_host_bind_imports(KitWasmHost* host,
                                              KitCompiler* compiler,
                                              KitJit* jit,
                                              KitWasmInstance* inst) {
   if (!host || !compiler || !jit || !inst) return KIT_INVALID;
   return kit_wasm_bind_host_imports(compiler, jit, inst, NULL, 0,
                                     wasm_wasi_resolve, host);
 }
 
 KIT_API int kit_wasm_instance_exit_code(KitWasmInstance* inst, int* code_out) {
   KitWasmRuntimeInstance* w;
   if (!inst) return 0;
   w = wasm_wrap_from_instance(inst);
   if (!w->exit_called) return 0;
   if (code_out) *code_out = w->exit_code;
   return 1;
 }