@ai-ecoverse/slicc-kernel 1.41.0 → 1.41.2

package/dist/node-process-worker.js

@@ -166,7 +166,7 @@ var init_pages = __esm({
         }
         const last = runs[runs.length - 1];
         if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
-        return runs.map(([start, n]) => [start, Math.min(n, this.stored - start)]);
+        return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
       }
       partial(at, length) {
         if (length === 0) return [];
@@ -174,16 +174,16 @@ var init_pages = __esm({
         const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length - 1) / PAGE)]);
         const runs = [];
         for (const page of edges) {
-          const start = page * PAGE;
-          const covered = at <= start && at + length >= start + PAGE;
-          if (covered || this.pages.has(page) || start >= this.stored) continue;
-          runs.push([start, Math.min(PAGE, this.stored - start)]);
+          const start2 = page * PAGE;
+          const covered = at <= start2 && at + length >= start2 + PAGE;
+          if (covered || this.pages.has(page) || start2 >= this.stored) continue;
+          runs.push([start2, Math.min(PAGE, this.stored - start2)]);
         }
         return runs;
       }
-      fill(start, bytes) {
+      fill(start2, bytes) {
         for (let at = 0; at < bytes.length; at += PAGE) {
-          const page = (start + at) / PAGE;
+          const page = (start2 + at) / PAGE;
           if (this.pages.has(page)) continue;
           const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
           const fresh = this.take(part.length);
@@ -249,14 +249,14 @@ var init_pages = __esm({
           while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
             j++;
           }
-          const start = first * PAGE;
+          const start2 = first * PAGE;
           const end = Math.min(this.length, (first + (j - i)) * PAGE);
-          const bytes = new Uint8Array(end - start);
+          const bytes = new Uint8Array(end - start2);
           for (let k = i; k < j; k++) {
             const page = this.pages.get(sorted[k]);
-            bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start)), (k - i) * PAGE);
+            bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
           }
-          runs.push({ offset: start, bytes });
+          runs.push({ offset: start2, bytes });
           i = j;
         }
         const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
@@ -339,8 +339,8 @@ var init_ranged = __esm({
         return this.pages.length;
       }
       fetch(runs) {
-        for (const [start, n] of runs) {
-          this.pages.fill(start, this.io.pread(this.path, start, n, this.version));
+        for (const [start2, n] of runs) {
+          this.pages.fill(start2, this.io.pread(this.path, start2, n, this.version));
         }
       }
       read(at, length) {
@@ -594,7 +594,9 @@ function toMs(v) {
 }
 function createHelpers(Fs, ops) {
   const bridgeOf = (node) => node.mount.opts.bridge;
+  const fileIo = (node) => pinnedIo(bridgeOf(node), node.live.handle);
   const dirty = /* @__PURE__ */ new Set();
+  const handled = /* @__PURE__ */ new Set();
   function markDirty(node) {
     node.live.dirty = true;
     dirty.add(node);
@@ -657,7 +659,7 @@ function createHelpers(Fs, ops) {
   function ensureLoaded(node) {
     const s = node.live;
     if (s.loaded) return;
-    const bytes = call2(() => bridgeOf(node).readFile(liveNodePath(node)));
+    const bytes = call2(() => fileIo(node).readFile(liveNodePath(node)));
     s.data = bytes;
     s.len = bytes.length;
     s.loaded = true;
@@ -667,10 +669,11 @@ function createHelpers(Fs, ops) {
     if (s.ranged || !s.ranges) return s.ranged;
     const bridge = bridgeOf(node);
     const path = () => liveNodePath(node);
+    const file = () => fileIo(node);
     const io = {
-      pread: (_, at, n, version) => bridge.pread(path(), at, n, version),
-      pwrite: (_, at, bytes, transfer) => bridge.pwrite(path(), at, bytes, transfer),
-      truncate: (_, size) => bridge.truncate(path(), size)
+      pread: (_, at, n, version) => file().pread(path(), at, n, version),
+      pwrite: (_, at, bytes, transfer) => file().pwrite(path(), at, bytes, transfer),
+      truncate: (_, size) => file().truncate(path(), size)
     };
     const st = call2(() => bridge.stat(path()));
     s.ranged = new RangedFile(io, path(), st.size, st.version);
@@ -691,7 +694,7 @@ function createHelpers(Fs, ops) {
     if (s.ranged) call2(() => s.ranged?.flush());
     else {
       const bytes = s.data.slice(0, s.len);
-      call2(() => bridgeOf(node).writeFile(liveNodePath(node), bytes, true));
+      call2(() => fileIo(node).writeFile(liveNodePath(node), bytes, true));
     }
     s.dirty = false;
     s.stat = void 0;
@@ -738,6 +741,7 @@ function createHelpers(Fs, ops) {
   return {
     Fs,
     bridgeOf,
+    handled,
     call: call2,
     metadataCall,
     makeNode,
@@ -924,8 +928,12 @@ function createStreamOps(h) {
     }
   };
   const opened = (node, on) => {
+    const s = node.live;
     try {
-      bridgeOf(node).hold?.(liveNodePath(node), on, true);
+      const handle = bridgeOf(node).hold?.(liveNodePath(node), on, true, s.handle);
+      s.handle = on ? handle : void 0;
+      if (s.handle === void 0) h.handled.delete(node);
+      else h.handled.add(node);
     } catch {
     }
   };
@@ -1043,6 +1051,7 @@ function createLiveVfsPlugin(Fs) {
     mounts,
     node_ops: nodeOps,
     stream_ops: streamOps,
+    handled: h.handled,
     flushDirty: () => h.flushDirty(),
     mount(mount) {
       const st = h.call(() => mount.opts.bridge.stat(mount.opts.root));
@@ -1065,7 +1074,7 @@ function flushLiveVfs(Fs, plugin) {
         if (s.ranged) s.ranged.flush();
         else {
           const bytes = s.data.slice(0, s.len);
-          node.mount.opts.bridge.writeFile(liveNodePath(node), bytes, true);
+          pinnedIo(node.mount.opts.bridge, s.handle).writeFile(liveNodePath(node), bytes, true);
         }
         s.dirty = false;
       } catch (err) {
@@ -1143,6 +1152,7 @@ function liveRoot(Fs, bridge) {
   plugin.mounts.add(root.mount);
   invalidateLiveVfs(Fs, plugin);
   guardRenames(Fs);
+  guardKeptNodes(Fs, plugin.handled);
   guardStatfs(Fs);
   const memfs = root.memfs ?? root.node_ops;
   const live = plugin.node_ops;
@@ -1199,6 +1209,28 @@ function guardStatfs(Fs) {
     };
   };
 }
+function pinnedIo(bridge, handle) {
+  return handle !== void 0 && bridge.pinned ? bridge.pinned(handle) : bridge;
+}
+function guardKeptNodes(Fs, handled) {
+  const open = Fs.open?.bind(Fs);
+  const forget = Fs.hashRemoveNode?.bind(Fs);
+  if (!open || !forget || !Fs.lookupPath || !handled || Fs.sliccKept) return;
+  Fs.sliccKept = true;
+  const lookupPath = Fs.lookupPath.bind(Fs);
+  Fs.open = (path, flags, mode) => {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    if (![...handled].some((held) => held.name === name)) return open(path, flags, mode);
+    let node;
+    try {
+      node = lookupPath(path, { follow: true }).node;
+    } catch {
+    }
+    const handle = node?.live?.openCount ? node.live.handle : void 0;
+    if (node && handle !== void 0 && node.mount.opts.bridge.kept?.(handle)) forget(node);
+    return open(path, flags, mode);
+  };
+}
 function guardRenames(Fs) {
   const rename = Fs.rename?.bind(Fs);
   if (!rename || Fs.sliccRename) return;
@@ -1330,6 +1362,7 @@ var init_sync_fs_wire = __esm({
       "statfs",
       "hold",
       "create",
+      "kept",
       "pread",
       "pwrite",
       "truncate"
@@ -1501,11 +1534,26 @@ function createSyncFsSabBridge(transport, opts = {}) {
     if (r.ok && r.kind === "json") return r.json;
     throw errnoError("EIO", path);
   }
-  return {
-    readFile: (path) => bytes({ op: "read", path }, path),
+  const io = (id) => ({
+    readFile: (path) => bytes({ op: "read", path, ...id }, path),
     writeFile: (path, data, open) => {
-      run({ op: "write", path, body: data, ...open ? { mode: 1 } : {} }, path);
+      run({ op: "write", path, body: data, ...open ? { mode: 1 } : {}, ...id }, path);
+    },
+    pread: (path, offset, length, version) => bytes({ op: "pread", path, offset, length, ...version ? { version } : {}, ...id }, path),
+    pwrite: (path, offset, body, transfer) => {
+      const whole = body.byteOffset === 0 && body.byteLength === body.buffer.byteLength;
+      const owned = transfer && whole && body.buffer instanceof ArrayBuffer;
+      const transferred = owned ? [body.buffer] : [];
+      run({ op: "pwrite", path, offset, body, ...id }, path, transferred);
     },
+    truncate: (path, length) => {
+      run({ op: "truncate", path, length, ...id }, path);
+    }
+  });
+  return {
+    ...io({}),
+    pinned: (handle) => io({ handle }),
+    kept: (handle) => json({ op: "kept", path: "/", handle }, "/") === true,
     stat: (path) => {
       const s = parseSyncFsStat(json({ op: "stat", path }, path));
       if (!s) throw errnoError("EIO", path);
@@ -1574,19 +1622,13 @@ function createSyncFsSabBridge(transport, opts = {}) {
     create: (path) => {
       run({ op: "create", path }, path);
     },
-    hold: (path, held, open) => {
-      run({ op: "hold", path, mode: (held ? 1 : 0) | (open ? 2 : 0) }, path);
-    },
-    statfs: (path = "/") => parseSyncFsUsage(json({ op: "statfs", path }, path)),
-    pread: (path, offset, length, version) => bytes({ op: "pread", path, offset, length, ...version ? { version } : {} }, path),
-    pwrite: (path, offset, body, transfer) => {
-      const whole = body.byteOffset === 0 && body.byteLength === body.buffer.byteLength;
-      const owned = transfer && whole && body.buffer instanceof ArrayBuffer;
-      run({ op: "pwrite", path, offset, body }, path, owned ? [body.buffer] : []);
+    hold: (path, held, open, handle) => {
+      const mode = (held ? 1 : 0) | (open ? 2 : 0);
+      if (mode === 3) return json({ op: "hold", path, mode }, path);
+      run({ op: "hold", path, mode, ...handle !== void 0 ? { handle } : {} }, path);
+      return void 0;
     },
-    truncate: (path, length) => {
-      run({ op: "truncate", path, length }, path);
-    }
+    statfs: (path = "/") => parseSyncFsUsage(json({ op: "statfs", path }, path))
   };
 }
 var init_sync_sab_bridge = __esm({
@@ -1794,9 +1836,9 @@ var init_kernel_streams = __esm({
         for (const name of ["stat", "lstat"]) {
           const original = fs[name];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest) => {
+          fs[name] = (path, ...rest2) => {
             const getattr = this.descriptions.get(path);
-            return getattr ? getattr() : original.call(fs, path, ...rest);
+            return getattr ? getattr() : original.call(fs, path, ...rest2);
           };
         }
       }
@@ -1884,13 +1926,13 @@ var init_kernel_streams = __esm({
         for (const name of ["chown", "lchown", "chmod", "lchmod"]) {
           const original = fs[name];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest);
+          fs[name] = (path, ...rest2) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest2);
         }
         for (const name of ["stat", "lstat"]) {
           const original = fs[name];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest) => {
-            if (!isPtyPath(path)) return original.call(fs, path, ...rest);
+          fs[name] = (path, ...rest2) => {
+            if (!isPtyPath(path)) return original.call(fs, path, ...rest2);
             this.existingPty(path);
             return ptyStat(path);
           };
@@ -2165,7 +2207,7 @@ function cloexecPipe2(pipe2, deps) {
   };
 }
 function quietTarget(dup3, deps) {
-  return (fd = -1, newfd = -1, flags = 0, ...rest) => {
+  return (fd = -1, newfd = -1, flags = 0, ...rest2) => {
     const Fs = deps.fs();
     const target = fd === newfd || flags !== 0 ? void 0 : Fs?.getStream(newfd);
     if (target && Fs?.getStream(fd)) {
@@ -2174,7 +2216,7 @@ function quietTarget(dup3, deps) {
       } catch {
       }
     }
-    return dup3(fd, newfd, flags, ...rest);
+    return dup3(fd, newfd, flags, ...rest2);
   };
 }
 function cloexecByFlag(syscall, flagArg, deps) {
@@ -2329,8 +2371,8 @@ function syncFsync(imports, fs, glue) {
     };
   }
 }
-function offsetOf(rest) {
-  const at = rest.length >= 3 ? Number(rest[1]) * 2 ** 32 + (Number(rest[0]) >>> 0) : Number(BigInt.asIntN(64, BigInt(rest[0])));
+function offsetOf(rest2) {
+  const at = rest2.length >= 3 ? Number(rest2[1]) * 2 ** 32 + (Number(rest2[0]) >>> 0) : Number(BigInt.asIntN(64, BigInt(rest2[0])));
   return at >= 0 && Number.isSafeInteger(at) ? at : void 0;
 }
 function readInto(sys, kfd, target, at) {
@@ -2344,14 +2386,14 @@ function readInto(sys, kfd, target, at) {
   return done;
 }
 function positioned(original, write, deps) {
-  return (fd, iov, iovcnt, ...rest) => {
+  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)) {
-      return original(fd, iov, iovcnt, ...rest);
+      return original(fd, iov, iovcnt, ...rest2);
     }
-    const at = offsetOf(rest);
+    const at = offsetOf(rest2);
     if (at === void 0) return wasiErrno("EINVAL");
     const view = new DataView(memory.buffer);
     let done = 0;
@@ -2367,7 +2409,7 @@ function positioned(original, write, deps) {
     } catch (err) {
       return errnoOf(err);
     }
-    view.setUint32(Number(rest[rest.length - 1]), done, true);
+    view.setUint32(Number(rest2[rest2.length - 1]), done, true);
     return 0;
   };
 }
@@ -4357,6 +4399,8 @@ function cachingBridge(bridge, now = () => performance.now()) {
     utimes: (p, a, m) => mutating(() => bridge.utimes(p, a, m)),
     lutimes: (p, a, m) => mutating(() => bridge.lutimes(p, a, m)),
     ...bridge.hold ? { hold: bridge.hold.bind(bridge) } : {},
+    ...bridge.kept ? { kept: bridge.kept.bind(bridge) } : {},
+    ...bridge.pinned ? { pinned: (handle) => pinnedIo2(bridge, handle, mutating) } : {},
     ...bridge.create ? { create: (p) => mutating(() => bridge.create?.(p)) } : {},
     ...bridge.pread && bridge.pwrite && bridge.truncate ? {
       pread: bridge.pread.bind(bridge),
@@ -4366,6 +4410,17 @@ function cachingBridge(bridge, now = () => performance.now()) {
     invalidate
   };
 }
+function pinnedIo2(bridge, handle, mutating) {
+  const io = bridge.pinned(handle);
+  const { pread, pwrite, truncate } = io;
+  return {
+    readFile: (p) => io.readFile(p),
+    writeFile: (p, bytes, open) => mutating(() => io.writeFile(p, bytes, open)),
+    pread: (p, at, n, version) => pread(p, at, n, version),
+    pwrite: (p, at, bytes, transfer) => mutating(() => pwrite(p, at, bytes, transfer)),
+    truncate: (p, size) => mutating(() => truncate(p, size))
+  };
+}
 var WasiError, FileBuffer, LocalFile, MISS_TTL_MS;
 var init_wasi_files = __esm({
   "src/process/wasi/wasi-files.ts"() {
@@ -4391,6 +4446,7 @@ var init_wasi_files = __esm({
       where;
       ranged;
       maxFile;
+      handle;
       constructor(fs, path, empty, maxFile, size, version) {
         this.fs = fs;
         this.where = path;
@@ -4960,7 +5016,7 @@ var init_wasi_fds = __esm({
         this.letGo(buffer);
       }
       letGo(buffer) {
-        this.fs.hold?.(buffer.path, false, true);
+        this.fs.hold?.(buffer.path, false, true, buffer.handle);
       }
       kind(fd, e) {
         if (!e.kind) {
@@ -5047,6 +5103,10 @@ var init_wasi_fds = __esm({
       file(path, existing, oflags, rights, fdflags) {
         const { readable: readable2, writable: writable2 } = openAccess(existing, oflags, rights);
         let buffer = this.buffers.get(path);
+        if (buffer?.handle !== void 0 && this.fs.kept?.(buffer.handle)) {
+          this.buffers.delete(path);
+          buffer = void 0;
+        }
         if (buffer) {
           if (oflags & OFLAGS.TRUNC) buffer.truncate(0);
         } else {
@@ -5055,9 +5115,11 @@ var init_wasi_fds = __esm({
           if (existing?.ranged) this.fs.invalidate?.();
           const st = existing?.ranged || !existing ? this.fs.stat(path) : existing;
           const ranged = st.ranged ? st.size : void 0;
-          buffer = new FileBuffer(this.fs, path, empty, st.maxFile, ranged, st.version);
+          const handle = this.fs.hold?.(path, true, true);
+          const io = handle !== void 0 && this.fs.pinned ? this.fs.pinned(handle) : this.fs;
+          buffer = new FileBuffer(io, path, empty, st.maxFile, ranged, st.version);
+          buffer.handle = handle;
           this.buffers.set(path, buffer);
-          this.fs.hold?.(path, true, true);
         }
         buffer.opens++;
         return new LocalFile(buffer, readable2, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
@@ -5343,11 +5405,11 @@ function kernelFiletype(kind) {
       return { filetype: FILETYPE.UNKNOWN, seeks: false };
   }
 }
-function direntRecord(next, ino, name, filetype) {
+function direntRecord(next2, ino, name, filetype) {
   const nameBytes = new TextEncoder().encode(name);
   const record = new Uint8Array(SIZE.DIRENT + nameBytes.length);
   const v = new DataView(record.buffer);
-  v.setBigUint64(0, BigInt(next), true);
+  v.setBigUint64(0, BigInt(next2), true);
   v.setBigUint64(8, ino, true);
   v.setUint32(16, nameBytes.length, true);
   v.setUint8(20, filetype);
@@ -5861,19 +5923,19 @@ var init_wasi_host = __esm({
           return { filetype: FILETYPE.CHARACTER_DEVICE, size: 0n, ino: pathInode(path), mtimeNs: 0n };
         }
         this.fds.flushPath(path);
-        const follow = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
-        return filestatOf(path, follow ? this.o.fs.stat(path) : this.o.fs.lstat(path));
+        const follow2 = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
+        return filestatOf(path, follow2 ? this.o.fs.stat(path) : this.o.fs.lstat(path));
       }
-      setTimes(path, atim, mtim, flags, follow = true) {
+      setTimes(path, atim, mtim, flags, follow2 = true) {
         const now = Date.now();
         let current;
-        const statOf = follow ? this.o.fs.stat.bind(this.o.fs) : this.o.fs.lstat.bind(this.o.fs);
+        const statOf = follow2 ? this.o.fs.stat.bind(this.o.fs) : this.o.fs.lstat.bind(this.o.fs);
         const kept = (field2) => {
           current ??= statOf(path);
           return current[field2] ?? current.mtimeMs ?? now;
         };
         const pick = (set, setNow, value2, field2) => flags & setNow ? now : flags & set ? Number(value2 / NS_PER_MS) : kept(field2);
-        (follow ? this.o.fs.utimes : this.o.fs.lutimes).call(
+        (follow2 ? this.o.fs.utimes : this.o.fs.lutimes).call(
           this.o.fs,
           path,
           pick(FSTFLAGS.ATIM, FSTFLAGS.ATIM_NOW, atim, "atimeMs"),
@@ -6779,6 +6841,61 @@ var init_wasix_linker = __esm({
   }
 });
 
+// src/fs/physical-path.ts
+function start(path) {
+  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
+}
+function next(walk) {
+  while (walk.todo.length > 0) {
+    const part = walk.todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      walk.done.pop();
+      continue;
+    }
+    return part;
+  }
+  return void 0;
+}
+function lexical(path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
+  return `/${walk.done.join("/")}`;
+}
+function rest(walk, part) {
+  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
+}
+function follow(walk, target) {
+  if (++walk.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk.done.length = 0;
+  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+  return true;
+}
+function physicalPath(fs, path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) {
+    const at = `/${[...walk.done, part].join("/")}`;
+    let target;
+    try {
+      target = fs.lstat(at).isSymbolicLink ? fs.readlink(at) : void 0;
+    } catch {
+      return rest(walk, part);
+    }
+    if (target === void 0) walk.done.push(part);
+    else if (!follow(walk, target)) {
+      throw Object.assign(new Error("too many levels of symbolic links"), { code: "ELOOP" });
+    }
+  }
+  return `/${walk.done.join("/")}`;
+}
+var MAX_HOPS;
+var init_physical_path = __esm({
+  "src/fs/physical-path.ts"() {
+    "use strict";
+    MAX_HOPS = 40;
+  }
+});
+
 // src/process/wasi/wasix-process.ts
 function resolveFrom(cwd, path) {
   return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
@@ -6787,6 +6904,7 @@ var POSIX_TO_WASI_SIGNAL, O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUN
 var init_wasix_process = __esm({
   "src/process/wasi/wasix-process.ts"() {
     "use strict";
+    init_physical_path();
     init_wasi_abi();
     init_wasi_files();
     init_wasi_host();
@@ -6873,10 +6991,13 @@ var init_wasix_process = __esm({
           const kfd = this.openFor(op, cwd);
           opened.push(kfd);
           point(op.fd, kfd);
-        } else if (op.cmd === "chdir") return resolveFrom(cwd, op.path);
-        else return fds.dir(op.fd).path;
+        } else if (op.cmd === "chdir") return this.physicalFrom(cwd, op.path);
+        else return physicalPath(this.host.o.fs, fds.dir(op.fd).path);
         return cwd;
       }
+      physicalFrom(cwd, path) {
+        return physicalPath(this.host.o.fs, path.startsWith("/") ? path : `${cwd}/${path}`);
+      }
       openFor(op, cwd) {
         const path = resolveFrom(cwd, op.path);
         const create = (op.oflags & OFLAG_CREAT) !== 0;
@@ -7910,8 +8031,8 @@ function linkerHost(host, imports) {
       }
     },
     hostImports: () => {
-      const { env: _env, "GOT.mem": _mem, "GOT.func": _func, ...rest } = imports();
-      return rest;
+      const { env: _env, "GOT.mem": _mem, "GOT.func": _func, ...rest2 } = imports();
+      return rest2;
     }
   };
 }
@@ -8053,9 +8174,9 @@ async function runWasiThread(init, port2) {
     foreign: init.program.foreign,
     ...program ? { program } : {}
   });
-  const start = instance.exports.wasi_thread_start;
+  const start2 = instance.exports.wasi_thread_start;
   try {
-    start(thread.tid, thread.arg);
+    start2(thread.tid, thread.arg);
     threads.exited();
   } catch (e) {
     if (e instanceof ThreadExit) {