@ai-ecoverse/slicc-kernel 1.48.3 → 1.49.0

package/dist/process-worker.js

@@ -1991,12 +1991,12 @@ var init_kernel_streams = __esm({
       usePipes(pipefs) {
         const createPipe = pipefs.createPipe.bind(pipefs);
         pipefs.createPipe = () => {
-          const [read, write] = this.call(() => this.sys.pipe());
+          const [read2, write2] = this.call(() => this.sys.pipe());
           let fds;
           try {
             fds = createPipe();
           } catch (e) {
-            for (const kfd of [read, write]) {
+            for (const kfd of [read2, write2]) {
               try {
                 this.sys.close(kfd);
               } catch {
@@ -2004,8 +2004,8 @@ var init_kernel_streams = __esm({
             }
             throw e;
           }
-          this.attach(this.Fs.getStream(fds.readable_fd), read, false);
-          this.attach(this.Fs.getStream(fds.writable_fd), write, false);
+          this.attach(this.Fs.getStream(fds.readable_fd), read2, false);
+          this.attach(this.Fs.getStream(fds.writable_fd), write2, false);
           return fds;
         };
       }
@@ -2394,12 +2394,12 @@ function readInto(sys, kfd, target, at) {
   }
   return done;
 }
-function positioned(original, write, deps) {
+function positioned(original, write2, deps) {
   return (fd, iov, iovcnt, ...rest2) => {
     const stream = deps.fs()?.getStream(Number(fd));
     const memory = deps.memory();
     const kfd = stream?.sliccKernelFile ? stream.sliccKernelFd : void 0;
-    if (kfd === void 0 || !memory || !(write ? deps.sys.pwrite : deps.sys.pread)) {
+    if (kfd === void 0 || !memory || !(write2 ? deps.sys.pwrite : deps.sys.pread)) {
       return original(fd, iov, iovcnt, ...rest2);
     }
     const at = offsetOf(rest2);
@@ -2411,7 +2411,7 @@ function positioned(original, write, deps) {
         const ptr = view.getUint32(Number(iov) + i * 8, true);
         const len = view.getUint32(Number(iov) + i * 8 + 4, true);
         const part = new Uint8Array(memory.buffer, ptr, len);
-        const moved = write ? deps.sys.pwrite?.(kfd, part.slice(), at + done) ?? 0 : readInto(deps.sys, kfd, part, at + done);
+        const moved = write2 ? deps.sys.pwrite?.(kfd, part.slice(), at + done) ?? 0 : readInto(deps.sys, kfd, part, at + done);
         done += moved;
         if (moved < len) break;
       }
@@ -2424,13 +2424,13 @@ function positioned(original, write, deps) {
 }
 function positionalIo(imports, deps) {
   for (const namespace of namespaces(imports)) {
-    for (const [name, write] of [
+    for (const [name, write2] of [
       ["fd_pread", false],
       ["fd_pwrite", true]
     ]) {
       const key = keyOf(namespace, name, deps.glue);
       if (key !== void 0) {
-        namespace[key] = positioned(namespace[key], write, deps);
+        namespace[key] = positioned(namespace[key], write2, deps);
       }
     }
   }
@@ -2558,10 +2558,10 @@ function useZeroDevices(Fs) {
       }
     ]
   ];
-  for (const [path, minor, write] of devices) {
+  for (const [path, minor, write2] of devices) {
     if (analyzePath.call(Fs, path).exists) continue;
     const dev = makedev.call(Fs, 1, minor);
-    registerDevice.call(Fs, dev, { read: zeros, write, llseek: () => 0 });
+    registerDevice.call(Fs, dev, { read: zeros, write: write2, llseek: () => 0 });
     mkdev.call(Fs, path, CHAR_DEVICE, dev);
   }
 }
@@ -2957,38 +2957,38 @@ function drain(Fs, stream) {
   }
   return out;
 }
-function kernelSelect(Fs, transport, read, write, timeoutMs) {
+function kernelSelect(Fs, transport, read2, write2, timeoutMs) {
   const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
-  const kr = read.map(kernel);
-  const kw = write.map(kernel);
+  const kr = read2.map(kernel);
+  const kw = write2.map(kernel);
   const r = transport.call({ op: "fd-select", read: kr, write: kw, timeoutMs }, Infinity, "select");
   if (!r.ok) return -wasiErrno(r.errno);
   const got = r.kind === "json" ? r.json : { read: [], write: [] };
   return {
-    read: read.filter((_, i) => got.read.includes(kr[i])),
-    write: write.filter((_, i) => got.write.includes(kw[i]))
+    read: read2.filter((_, i) => got.read.includes(kr[i])),
+    write: write2.filter((_, i) => got.write.includes(kw[i]))
   };
 }
-function ownReady(Fs, read, write) {
+function ownReady(Fs, read2, write2) {
   const flags = (fd) => {
     const stream = Fs.getStream(fd);
     if (!stream) return POLLNVAL;
     return stream.stream_ops.poll ? stream.stream_ops.poll(stream) : POLLIN2 | POLLOUT2;
   };
   return {
-    read: read.filter((fd) => flags(fd) & (POLLIN2 | POLLHUP2 | POLLERR2 | POLLNVAL)),
-    write: write.filter((fd) => flags(fd) & (POLLOUT2 | POLLERR2 | POLLNVAL))
+    read: read2.filter((fd) => flags(fd) & (POLLIN2 | POLLHUP2 | POLLERR2 | POLLNVAL)),
+    write: write2.filter((fd) => flags(fd) & (POLLOUT2 | POLLERR2 | POLLNVAL))
   };
 }
-function anySelect(Fs, transport, read, write, timeoutMs) {
+function anySelect(Fs, transport, read2, write2, timeoutMs) {
   const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
   const own = (fd) => kernel(fd) === void 0;
-  if (![...read, ...write].some(own)) return kernelSelect(Fs, transport, read, write, timeoutMs);
+  if (![...read2, ...write2].some(own)) return kernelSelect(Fs, transport, read2, write2, timeoutMs);
   const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
-  const kernelRead = read.filter((fd) => !own(fd));
-  const kernelWrite = write.filter((fd) => !own(fd));
+  const kernelRead = read2.filter((fd) => !own(fd));
+  const kernelWrite = write2.filter((fd) => !own(fd));
   for (; ; ) {
-    const local = ownReady(Fs, read.filter(own), write.filter(own));
+    const local = ownReady(Fs, read2.filter(own), write2.filter(own));
     const pending = local.read.length > 0 || local.write.length > 0;
     const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
     const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
@@ -3095,7 +3095,7 @@ function createProcessKernel(deps) {
       if (!r.ok) return -wasiErrno(r.errno);
       return r.kind === "json" ? r.json : -wasiErrno("EIO");
     },
-    select: (read, write, timeoutMs) => anySelect(Fs, transport, read, write, timeoutMs),
+    select: (read2, write2, timeoutMs) => anySelect(Fs, transport, read2, write2, timeoutMs),
     execWait,
     execve(file, argv, env, cwd) {
       const pid = spawnChild(file, argv, env, cwd, [0, 1, 2], void 0, true);
@@ -5393,17 +5393,17 @@ function writeEvents(mem, ptr, events) {
 }
 function classify(fds, subs) {
   const events = [];
-  const read = [];
-  const write = [];
+  const read2 = [];
+  const write2 = [];
   for (const s of subs) {
     if (s.type === EVENTTYPE.CLOCK) continue;
     const e = fds.find(s.fd);
     if (!e) events.push({ userdata: s.userdata, error: E.BADF, type: s.type });
     else if (e.type !== "kernel")
       events.push({ userdata: s.userdata, error: E.SUCCESS, type: s.type });
-    else (s.type === EVENTTYPE.FD_READ ? read : write).push(s.fd);
+    else (s.type === EVENTTYPE.FD_READ ? read2 : write2).push(s.fd);
   }
-  return { events, read, write };
+  return { events, read: read2, write: write2 };
 }
 function readyEvents(subs, ready) {
   return subs.filter(
@@ -5419,11 +5419,11 @@ function pollOneoff(deps, inPtr, outPtr, nsubs, neventsPtr) {
   if (nsubs === 0) return E.INVAL;
   const { mem, kernel } = deps;
   const subs = readSubscriptions(mem, inPtr, nsubs, deps.now);
-  const { events, read, write } = classify(deps.fds, subs);
+  const { events, read: read2, write: write2 } = classify(deps.fds, subs);
   let interrupted = false;
   const earliest = subs.reduce((min, s) => Math.min(min, s.deadline), Infinity);
   const expired = () => performance.now() + CLOCK_SLACK_MS >= earliest;
-  if (read.length > 0 || write.length > 0 || events.length === 0) {
+  if (read2.length > 0 || write2.length > 0 || events.length === 0) {
     do {
       let timeoutMs = -1;
       if (events.length > 0) timeoutMs = 0;
@@ -5431,7 +5431,7 @@ function pollOneoff(deps, inPtr, outPtr, nsubs, neventsPtr) {
         timeoutMs = Math.max(0, Math.ceil(earliest - performance.now()));
       let ready;
       try {
-        ready = kernel.call({ op: "fd-select", read, write, timeoutMs });
+        ready = kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs });
       } catch (e) {
         if (!deps.interruptWakes || e.code !== "EINTR") throw e;
         interrupted = true;
@@ -6669,10 +6669,10 @@ function processes(host, call2, inThread) {
   const slot = (n, how, mine, theirs) => {
     if (how === "inherit") return { fd: n };
     if (how === "null") return { none: true };
-    const [read, write] = call2({ op: "fd-pipe" });
-    mine[n] = n === 0 ? write : read;
-    theirs.push(n === 0 ? read : write);
-    return { fd: n === 0 ? read : write };
+    const [read2, write2] = call2({ op: "fd-pipe" });
+    mine[n] = n === 0 ? write2 : read2;
+    theirs.push(n === 0 ? read2 : write2);
+    return { fd: n === 0 ? read2 : write2 };
   };
   return {
     spawn(o) {
@@ -7056,6 +7056,289 @@ var init_wasix_fork = __esm({
   }
 });
 
+// src/process/wasi/wasix-ffi.ts
+function read(view, at, type) {
+  if (type === "i32") return view.getInt32(at, true);
+  if (type === "i64") return view.getBigInt64(at, true);
+  if (type === "f32") return view.getFloat32(at, true);
+  return view.getFloat64(at, true);
+}
+function write(view, at, type, value2) {
+  if (type === "i32") view.setInt32(at, Number(value2), true);
+  else if (type === "i64") view.setBigInt64(at, BigInt(value2), true);
+  else if (type === "f32") view.setFloat32(at, Number(value2), true);
+  else view.setFloat64(at, Number(value2), true);
+}
+function scalars(types) {
+  if (types.includes("other")) throw new WasiError("EINVAL");
+  return types;
+}
+function callDynamic(ctx, id, values, valuesLen, results, resultsLen, strict) {
+  const table = ctx.table();
+  if (!table) throw new WasiError("ENOTSUP");
+  const fn = id < table.length ? table.get(id) : null;
+  const sig = fn ? ctx.types.of(fn) : void 0;
+  if (!fn || !sig) throw new WasiError("EINVAL");
+  const params = scalars(sig.params);
+  const outs = scalars(sig.results);
+  const view = ctx.mem.view();
+  const end = values + valuesLen;
+  let at = values;
+  const args = params.map((type) => {
+    if (at + SIZE2[type] > end) {
+      if (strict) throw new WasiError("EINVAL");
+      return type === "i64" ? 0n : 0;
+    }
+    const v = read(view, at, type);
+    at += SIZE2[type];
+    return v;
+  });
+  if (strict && at !== end) throw new WasiError("EINVAL");
+  const returned = fn(...args);
+  const got = outs.length === 1 ? [returned] : returned ?? [];
+  const after = ctx.mem.view();
+  const stop = results + resultsLen;
+  let out = results;
+  outs.forEach((type, i) => {
+    if (out + SIZE2[type] > stop) {
+      if (strict) throw new WasiError("EINVAL");
+      return;
+    }
+    write(after, out, type, got[i]);
+    out += SIZE2[type];
+  });
+  if (strict && out !== stop) throw new WasiError("EINVAL");
+}
+var SIZE2;
+var init_wasix_ffi = __esm({
+  "src/process/wasi/wasix-ffi.ts"() {
+    "use strict";
+    init_wasi_files();
+    SIZE2 = { i32: 4, i64: 8, f32: 4, f64: 8 };
+  }
+});
+
+// src/process/wasi/wasm-functypes.ts
+function readTypes(r, s) {
+  for (let i = r.u32(); i > 0; i--) {
+    r.byte();
+    const params = [];
+    for (let n = r.u32(); n > 0; n--) params.push(r.valtype());
+    const results = [];
+    for (let n = r.u32(); n > 0; n--) results.push(r.valtype());
+    s.info.sigs.push({ params, results });
+  }
+}
+function readImports(r, s) {
+  for (let i = r.u32(); i > 0; i--) {
+    r.name();
+    const field2 = r.name();
+    const kind = r.byte();
+    if (kind === 0) s.info.funcs.push(r.u32());
+    else if (kind === 1) {
+      r.valtype();
+      r.limits();
+    } else if (kind === 2) r.limits();
+    else if (kind === 3) {
+      r.valtype();
+      r.byte();
+      s.globals.push(field2);
+    } else {
+      r.byte();
+      r.u32();
+    }
+  }
+}
+function readFunctions(r, s) {
+  for (let i = r.u32(); i > 0; i--) s.info.funcs.push(r.u32());
+}
+function constExpr(r, s) {
+  let value2 = 0;
+  let tableBase = false;
+  let known = true;
+  for (; ; ) {
+    const op = r.byte();
+    if (op === 11) return known ? { value: value2, tableBase } : void 0;
+    if (op === 65) value2 += r.s32();
+    else if (op === 35) {
+      const g = s.globals[r.u32()];
+      if (g === TABLE_BASE) tableBase = true;
+      else if (typeof g === "number") value2 += g;
+      else known = false;
+    } else if (op === 210) {
+      value2 = r.u32();
+    } else if (op in SKIP) {
+      SKIP[op]?.(r);
+      known = false;
+    } else if (op !== 106) {
+      r.at = r.bytes.length;
+      return void 0;
+    }
+  }
+}
+function readGlobals(r, s) {
+  for (let i = r.u32(); i > 0; i--) {
+    r.valtype();
+    r.byte();
+    const init = constExpr(r, s);
+    s.globals.push(init && !init.tableBase ? init.value : void 0);
+  }
+}
+function readExports(r, s) {
+  for (let i = r.u32(); i > 0; i--) {
+    const name = r.name();
+    const kind = r.byte();
+    const index2 = r.u32();
+    if (kind === 0) s.info.exports[name] = index2;
+  }
+}
+function readElems(r, s) {
+  for (let i = r.u32(); i > 0; i--) {
+    const flags = r.u32();
+    const active = (flags & 1) === 0;
+    const table = flags & 2 ? active ? r.u32() : 0 : 0;
+    const offset = active ? constExpr(r, s) : void 0;
+    if (flags & 3) r.valtype();
+    const funcs = [];
+    for (let n = r.u32(); n > 0; n--) {
+      if (flags & 4) {
+        const ref = constExpr(r, s);
+        funcs.push(ref ? ref.value : -1);
+      } else funcs.push(r.u32());
+    }
+    if (offset && table === 0) {
+      s.info.elems.push({ offset: offset.value, tableBase: offset.tableBase, funcs });
+    }
+  }
+}
+function funcTypeInfo(bytes) {
+  const r = new Reader(bytes);
+  const s = { info: { sigs: [], funcs: [], exports: {}, elems: [] }, globals: [] };
+  while (r.at < bytes.length) {
+    const id = r.byte();
+    const end = r.u32() + r.at;
+    SECTIONS[id]?.(r, s);
+    r.at = end;
+  }
+  return s.info;
+}
+var VALTYPES, TABLE_BASE, Reader, SKIP, SECTIONS, FuncTypes;
+var init_wasm_functypes = __esm({
+  "src/process/wasi/wasm-functypes.ts"() {
+    "use strict";
+    VALTYPES = {
+      127: "i32",
+      126: "i64",
+      125: "f32",
+      124: "f64"
+    };
+    TABLE_BASE = "__table_base";
+    Reader = class {
+      at = 8;
+      bytes;
+      constructor(bytes) {
+        this.bytes = bytes;
+      }
+      byte() {
+        return this.bytes[this.at++] ?? 0;
+      }
+      u32() {
+        let result = 0;
+        let shift = 0;
+        for (; ; ) {
+          const b = this.byte();
+          result |= (b & 127) << shift;
+          if (!(b & 128)) return result >>> 0;
+          shift += 7;
+        }
+      }
+      s32() {
+        let result = 0;
+        let shift = 0;
+        let b;
+        do {
+          b = this.byte();
+          result |= (b & 127) << shift;
+          shift += 7;
+        } while (b & 128);
+        return shift < 32 && b & 64 ? result | -1 << shift : result;
+      }
+      name() {
+        const len = this.u32();
+        const s = new TextDecoder().decode(this.bytes.subarray(this.at, this.at + len));
+        this.at += len;
+        return s;
+      }
+      valtype() {
+        const code2 = this.byte();
+        if (code2 === 99 || code2 === 100) this.s32();
+        return VALTYPES[code2] ?? "other";
+      }
+      limits() {
+        const flags = this.byte();
+        this.u32();
+        if (flags & 1) this.u32();
+      }
+    };
+    SKIP = {
+      66: (r) => r.s32(),
+      67: (r) => {
+        r.at += 4;
+      },
+      68: (r) => {
+        r.at += 8;
+      },
+      208: (r) => r.valtype()
+    };
+    SECTIONS = {
+      1: readTypes,
+      2: readImports,
+      3: readFunctions,
+      6: readGlobals,
+      7: readExports,
+      9: readElems
+    };
+    FuncTypes = class {
+      known = /* @__PURE__ */ new WeakMap();
+      pending = [];
+      register(read2, instance, table, tableBase) {
+        this.pending.push(() => {
+          const bytes = read2();
+          if (bytes) this.add(funcTypeInfo(bytes), instance, table, tableBase);
+        });
+      }
+      add(info, instance, table, tableBase) {
+        const sig = (func) => info.sigs[info.funcs[func] ?? -1];
+        for (const [name, func] of Object.entries(info.exports)) {
+          const fn = instance.exports[name];
+          const type = sig(func);
+          if (typeof fn === "function" && type) this.known.set(fn, type);
+        }
+        if (!table) return;
+        for (const seg of info.elems) {
+          const start2 = seg.offset + (seg.tableBase ? tableBase : 0);
+          seg.funcs.forEach((func, i) => {
+            const type = sig(func);
+            const fn = start2 + i < table.length ? table.get(start2 + i) : null;
+            if (fn && type) this.known.set(fn, type);
+          });
+        }
+      }
+      set(fn, sig) {
+        this.known.set(fn, sig);
+      }
+      of(fn) {
+        const known = this.known.get(fn);
+        if (known || this.pending.length === 0) return known;
+        const pending = this.pending;
+        this.pending = [];
+        for (const run of pending) run();
+        return this.known.get(fn);
+      }
+    };
+  }
+});
+
 // src/process/wasi/wasix-linker.ts
 function expandOrigin(entry, dir) {
   return entry.replace(/\$(?:ORIGIN\b|\{ORIGIN\})/g, dir);
@@ -7074,13 +7357,14 @@ function call(instance, name) {
   const fn = instance.exports[name];
   if (typeof fn === "function") fn();
 }
-var TABLE_BASE, PAGE2, STACK_SIZE, LIBRARY_DIRS, DlError, WasixLinker;
+var TABLE_BASE2, PAGE2, STACK_SIZE, LIBRARY_DIRS, DlError, WasixLinker;
 var init_wasix_linker = __esm({
   "src/process/wasi/wasix-linker.ts"() {
     "use strict";
     init_dylink();
     init_wasi_files();
-    TABLE_BASE = 1;
+    init_wasm_functypes();
+    TABLE_BASE2 = 1;
     PAGE2 = 65536;
     STACK_SIZE = 8 * 1024 * 1024;
     LIBRARY_DIRS = ["/lib", "/usr/lib", "/usr/local/lib"];
@@ -7101,6 +7385,8 @@ var init_wasix_linker = __esm({
       slots = /* @__PURE__ */ new Map();
       nextHandle = 1;
       publisher;
+      closures;
+      types = new FuncTypes();
       memory;
       host;
       constructor(memory, mainInfo, host, thread = false) {
@@ -7112,7 +7398,7 @@ var init_wasix_linker = __esm({
         if (!thread) growTo(memory, this.stackHigh);
         this.table = new WebAssembly.Table({
           element: "anyfunc",
-          initial: TABLE_BASE + mainInfo.tableSize
+          initial: TABLE_BASE2 + mainInfo.tableSize
         });
         this.stackPointer = new WebAssembly.Global(
           { value: "i32", mutable: true },
@@ -7132,7 +7418,7 @@ var init_wasix_linker = __esm({
           __indirect_function_table: this.table,
           __stack_pointer: this.stackPointer,
           __memory_base: i32(this.memoryBase),
-          __table_base: i32(TABLE_BASE),
+          __table_base: i32(TABLE_BASE2),
           __c_longjmp: this.cLongjmp,
           __cpp_exception: this.cppException
         };
@@ -7184,7 +7470,22 @@ var init_wasix_linker = __esm({
         for (const [path, linked] of this.byPath) out[path] = linked.module;
         return out;
       }
+      allocateClosure() {
+        const index2 = this.closures.allocate(
+          this.table.length
+        );
+        growTable(this.table, index2 + 1);
+        return index2;
+      }
+      freeClosure(index2) {
+        this.closures?.free(index2);
+        this.table.set(index2, null);
+      }
       replay(record) {
+        if (record.kind === "closure") {
+          growTable(this.table, record.index + 1);
+          return;
+        }
         if (record.kind === "load") {
           if (this.modules.has(record.handle)) return;
           this.instantiate(record.path, this.moduleAt(record.path), record, false);
@@ -7299,6 +7600,7 @@ var init_wasix_linker = __esm({
           "GOT.func": gotFunc
         };
         linked.instance = new WebAssembly.Instance(module, imports);
+        this.types.register(() => this.host.read(path), linked.instance, this.table, at.tableBase);
         this.modules.set(at.handle, linked);
         this.byPath.set(path, linked);
         for (const resolve of pending) resolve();
@@ -7676,9 +7978,11 @@ var init_wasix_host = __esm({
     init_wasi_files();
     init_wasi_host();
     init_wasi_threads();
+    init_wasix_ffi();
     init_wasix_linker();
     init_wasix_process();
     init_wasix_sockets();
+    init_wasm_functypes();
     FDFLAGSEXT_CLOEXEC = 1;
     SPAWN_OP_SIZE = 56;
     SPAWN_OPS = ["close", "dup2", "open", "chdir", "fchdir"];
@@ -7690,6 +7994,8 @@ var init_wasix_host = __esm({
       process;
       threads;
       linker;
+      types = new FuncTypes();
+      table;
       signals;
       host;
       driver;
@@ -7771,6 +8077,18 @@ var init_wasix_host = __esm({
           ...this.processImports(),
           ...this.threadImports(),
           ...this.dlImports(),
+          closure_allocate: (out) => {
+            if (!this.linker) throw new WasiError("ENOTSUP");
+            this.mem.view().setUint32(out, this.linker.allocateClosure(), true);
+          },
+          closure_free: (index2) => {
+            if (!this.linker) throw new WasiError("ENOTSUP");
+            this.linker.freeClosure(index2);
+          },
+          call_dynamic: (...a) => void callDynamic(
+            { mem: this.mem, table: () => this.table, types: this.types },
+            ...a
+          ),
           ...wasixSocketImports(this.host, this.host.imports())
         });
       }
@@ -8092,12 +8410,12 @@ function nameFrame(line, module, name) {
   const found = name(Number(m[4]));
   return found === void 0 ? line : `${m[1]}${found} (${m[2]})`;
 }
-function sidecarNames(read, path) {
+function sidecarNames(read2, path) {
   let names;
   return (index2) => {
     if (!names) {
       try {
-        names = parseFunctionNames(read(path));
+        names = parseFunctionNames(read2(path));
       } catch {
         names = /* @__PURE__ */ new Map();
       }
@@ -8267,7 +8585,8 @@ async function instantiate(host, module, memory, threads, {
   stats,
   signals,
   program,
-  foreign
+  foreign,
+  path
 } = {}) {
   const driver = new AsyncifyDriver(host.mem);
   const wasixHost = WebAssembly.Module.imports(module).some((i) => i.module === WASIX) ? new WasixHost(host, driver, module) : void 0;
@@ -8293,7 +8612,10 @@ async function instantiate(host, module, memory, threads, {
   ) : void 0;
   if (sync) {
     ({ preview1, wasix } = sync.guard(preview1, wasix));
-    if (wasixHost) wasixHost.linker = sync.linker;
+    if (wasixHost) {
+      wasixHost.linker = sync.linker;
+      wasixHost.types = sync.linker.types;
+    }
     if (threads) {
       sync.linker.cache = threads.received;
       threads.modules = () => sync.linker.compiled();
@@ -8324,6 +8646,14 @@ async function instantiate(host, module, memory, threads, {
   stats?.phase("instantiate");
   const exports = instance.exports;
   host.mem.bind(memory ?? exports.memory);
+  if (wasixHost) {
+    const table = sync?.linker.table ?? exportedTable(instance);
+    wasixHost.table = table;
+    if (path !== void 0) {
+      const read2 = linkerHost(host, () => ({})).read;
+      wasixHost.types.register(() => read2(path), instance, table, sync ? TABLE_BASE2 : 0);
+    }
+  }
   if (sync) {
     sync.linker.bindMain(instance, !thread);
     if (thread) sync.catchUp();
@@ -8331,6 +8661,10 @@ async function instantiate(host, module, memory, threads, {
   }
   return { instance, driver };
 }
+function exportedTable(instance) {
+  const table = instance.exports.__indirect_function_table;
+  return table instanceof WebAssembly.Table ? table : void 0;
+}
 function linkerHost(host, imports) {
   return {
     read: (path) => {
@@ -8410,6 +8744,7 @@ async function runWasiProcess(init, port2) {
     stats,
     signals,
     foreign: init.program.foreign,
+    path: init.program.path,
     ...program ? { program } : {}
   });
   restoreExportedMemory(instance, memory, init);
@@ -8494,6 +8829,7 @@ async function runWasiThread(init, port2) {
   const { instance } = await instantiate(host, init.program.module, thread.memory, threads, {
     thread: true,
     foreign: init.program.foreign,
+    path: init.program.path,
     ...program ? { program } : {}
   });
   signals.bind(instance.exports);
@@ -8573,6 +8909,14 @@ var init_wasi_runtime = __esm({
         this.call = call2;
         this.ids = ids;
         linker.publisher = (record) => this.publish(record);
+        linker.closures = {
+          allocate: (floor) => {
+            const index2 = this.call({ op: "dl-closure", floor });
+            this.catchUp();
+            return index2;
+          },
+          free: (index2) => void this.call({ op: "dl-closure-free", index: index2 })
+        };
       }
       publish(record) {
         const since = this.call({ op: "dl-log", append: record, from: this.count });
@@ -8931,10 +9275,10 @@ async function slots(kernel, o, mine, theirs) {
     else if (how === "null") stdio.push({ none: true });
     else if (typeof how === "number") stdio.push({ fd: how });
     else {
-      const [read, write] = await kernel.json({ op: "fd-pipe" });
-      mine[n] = n === 0 ? write : read;
-      theirs.push(n === 0 ? read : write);
-      stdio.push({ fd: n === 0 ? read : write });
+      const [read2, write2] = await kernel.json({ op: "fd-pipe" });
+      mine[n] = n === 0 ? write2 : read2;
+      theirs.push(n === 0 ? read2 : write2);
+      stdio.push({ fd: n === 0 ? read2 : write2 });
     }
   }
   return stdio;
@@ -9354,8 +9698,8 @@ function checkOpen(abs, o, existing) {
   if (existing?.isDirectory) throw new JsCallError("EISDIR", abs);
 }
 function flagsOf(o) {
-  const write = o.write || o.append || o.truncate;
-  const access = write ? o.read ? O_RDWR6 : O_WRONLY6 : 0;
+  const write2 = o.write || o.append || o.truncate;
+  const access = write2 ? o.read ? O_RDWR6 : O_WRONLY6 : 0;
   return access | (o.append ? O_APPEND3 : 0);
 }
 function openRequest(abs, o) {
@@ -9540,14 +9884,14 @@ function syncOps(kernel, shared) {
     infos.set(fd, got);
     return got;
   };
-  const read = (fd, max = CHUNK2) => {
+  const read2 = (fd, max = CHUNK2) => {
     index(max, "read");
     const emulated = readDevice(info(fd), max, shared.random);
     if (emulated) return emulated;
     const r = kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
     return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
   };
-  const write = (fd, data) => {
+  const write2 = (fd, data) => {
     const bytes = typeof data === "string" ? encoder2.encode(data) : data;
     const i = info(fd);
     if (writeDevice(i)) return;
@@ -9594,8 +9938,8 @@ function syncOps(kernel, shared) {
     return handle.file;
   };
   return {
-    read,
-    write,
+    read: read2,
+    write: write2,
     close(fd) {
       handles.get(fd)?.();
       handles.delete(fd);
@@ -10029,7 +10373,7 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const read = async (fd, max = CHUNK2, signal) => {
+  const read2 = async (fd, max = CHUNK2, signal) => {
     index(max, "read");
     const emulated = readDevice(await info(fd), max, random);
     if (emulated) return emulated;
@@ -10049,7 +10393,7 @@ function createContext(o) {
       }
     }
   };
-  const write = (fd, data) => {
+  const write2 = (fd, data) => {
     const bytes = typeof data === "string" ? encoder3.encode(data) : data;
     let settle;
     const settled = new Promise((resolve2) => settle = resolve2);
@@ -10063,7 +10407,7 @@ function createContext(o) {
       }
     })();
   };
-  const writable2 = (fd) => new WritableStream({ write: (chunk) => write(fd, chunk) });
+  const writable2 = (fd) => new WritableStream({ write: (chunk) => write2(fd, chunk) });
   const statOf = async (op, path) => {
     const abs = resolve(path);
     await kernel.call({ op: "fd-path-flush", path: abs });
@@ -10099,7 +10443,7 @@ function createContext(o) {
     handles
   });
   const terminal = ttyOps(kernel);
-  const io = { read, send: writeAll, close: (fd) => ctx.close(fd) };
+  const io = { read: read2, send: writeAll, close: (fd) => ctx.close(fd) };
   const children = childOps(kernel, io, { env: o.env, cwd: o.cwd, signal: signalNumber });
   const strays = o.strays ?? { exception: /* @__PURE__ */ new Set(), rejection: /* @__PURE__ */ new Set() };
   const ctx = {
@@ -10113,7 +10457,7 @@ function createContext(o) {
     stdin: new ReadableStream(
       {
         async pull(controller) {
-          const chunk = await read(0);
+          const chunk = await read2(0);
           if (chunk.length === 0) controller.close();
           else controller.enqueue(chunk);
         }
@@ -10122,8 +10466,8 @@ function createContext(o) {
     ),
     stdout: writable2(1),
     stderr: writable2(2),
-    read,
-    write,
+    read: read2,
+    write: write2,
     async close(fd) {
       handles.get(fd)?.();
       handles.delete(fd);