@ai-ecoverse/slicc-kernel 1.34.0 → 1.35.1

package/dist/process-worker.js

@@ -594,6 +594,26 @@ function toMs(v) {
 }
 function createHelpers(Fs, ops) {
   const bridgeOf = (node) => node.mount.opts.bridge;
+  const dirty = /* @__PURE__ */ new Set();
+  function markDirty(node) {
+    node.live.dirty = true;
+    dirty.add(node);
+  }
+  function flushDirty() {
+    for (const node of [...dirty]) {
+      const s = node.live;
+      if (!s.dirty || s.orphan) {
+        dirty.delete(node);
+        continue;
+      }
+      if (!s.ranged && s.len > EARLY_WHOLE_FILE) continue;
+      try {
+        flushNode(node);
+        dirty.delete(node);
+      } catch {
+      }
+    }
+  }
   function call2(fn) {
     try {
       return fn();
@@ -688,7 +708,7 @@ function createHelpers(Fs, ops) {
     const ranged = s.openCount > 0 ? rangedOf(node) : void 0;
     if (ranged) {
       ranged.truncate(size);
-      s.dirty = true;
+      markDirty(node);
       return;
     }
     if (s.openCount > 0) {
@@ -697,7 +717,7 @@ function createHelpers(Fs, ops) {
       const buf = ensureCapacity(node, size);
       if (size > s.len) buf.fill(0, s.len, size);
       s.len = size;
-      s.dirty = true;
+      markDirty(node);
       return;
     }
     const path = liveNodePath(node);
@@ -727,6 +747,8 @@ function createHelpers(Fs, ops) {
     ensureCapacity,
     rangedOf,
     flushNode,
+    markDirty,
+    flushDirty,
     truncate
   };
 }
@@ -971,7 +993,7 @@ function createStreamOps(h) {
       if (ranged) {
         const bytes = new Uint8Array(buffer.buffer, buffer.byteOffset + offset, length);
         h.call(() => ranged.write(position, bytes));
-        s.dirty = true;
+        h.markDirty(node);
         return length;
       }
       ensureLoaded(node);
@@ -979,7 +1001,7 @@ function createStreamOps(h) {
       if (position > s.len) buf.fill(0, s.len, position);
       buf.set(new Uint8Array(buffer.buffer, buffer.byteOffset + offset, length), position);
       s.len = Math.max(s.len, end);
-      s.dirty = true;
+      h.markDirty(node);
       return length;
     },
     llseek(stream, offset, whence) {
@@ -1009,6 +1031,7 @@ function createLiveVfsPlugin(Fs) {
     mounts,
     node_ops: nodeOps,
     stream_ops: streamOps,
+    flushDirty: () => h.flushDirty(),
     mount(mount) {
       const st = h.call(() => mount.opts.bridge.stat(mount.opts.root));
       if (!st.isDirectory) throw new Fs.ErrnoError(wasiErrno("ENOTDIR"));
@@ -1173,7 +1196,7 @@ function guardRenames(Fs) {
     rename(from, to);
   };
 }
-var S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR, SEEK_END;
+var S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR, SEEK_END, EARLY_WHOLE_FILE;
 var init_live_vfs_fs = __esm({
   "src/realm/live-vfs-fs.ts"() {
     "use strict";
@@ -1188,6 +1211,7 @@ var init_live_vfs_fs = __esm({
     UMASK = 18;
     SEEK_CUR = 1;
     SEEK_END = 2;
+    EARLY_WHOLE_FILE = 64 * 1024;
   }
 });
 
@@ -1224,6 +1248,7 @@ function mountVfsIntoEmscripten(Fs, deps) {
   return {
     mounted,
     flush: () => flushLiveVfs(Fs, plugin),
+    flushDirty: () => plugin.flushDirty(),
     invalidate: () => invalidateLiveVfs(Fs, plugin)
   };
 }
@@ -1268,10 +1293,34 @@ function parseSyncFsStat(json) {
     ...typeof s.version === "string" ? { version: s.version } : {}
   };
 }
-var SYNC_FS_REQUEST_TIMEOUT_MS;
+var SYNC_FS_OPS, SYNC_FS_REQUEST_TIMEOUT_MS;
 var init_sync_fs_wire = __esm({
   "src/realm/sync-fs-wire.ts"() {
     "use strict";
+    SYNC_FS_OPS = [
+      "read",
+      "write",
+      "exists",
+      "stat",
+      "lstat",
+      "readdir",
+      "readdir-stat",
+      "mkdir",
+      "rm",
+      "rename",
+      "unlink",
+      "rmdir",
+      "symlink",
+      "readlink",
+      "chmod",
+      "utimes",
+      "lutimes",
+      "statfs",
+      "hold",
+      "pread",
+      "pwrite",
+      "truncate"
+    ];
     SYNC_FS_REQUEST_TIMEOUT_MS = 25e3;
   }
 });
@@ -1558,7 +1607,7 @@ function ptyStat(path) {
 function nonblocking(stream) {
   return (stream.flags & O_NONBLOCK) !== 0 ? { nonblock: true } : void 0;
 }
-var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
+var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, TTY_NAME, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
 var init_kernel_streams = __esm({
   "src/process/kernel-streams.ts"() {
     "use strict";
@@ -1573,6 +1622,7 @@ var init_kernel_streams = __esm({
     SOCKET_MODE = 49663;
     PTY_PATH = /^\/dev\/(?:ptmx|pts\/(\d+))$/;
     TTY_PATH = /^\/dev\/tty\d+$/;
+    TTY_NAME = /^tty\d+$/;
     O_CREAT = 64;
     O_EXCL = 128;
     O_NOCTTY = 256;
@@ -1646,6 +1696,36 @@ var init_kernel_streams = __esm({
         if (typeof this.Fs.stat !== "function") return;
         stream.stream_ops = { ...stream.stream_ops, getattr: () => this.Fs.stat?.(name) ?? {} };
       }
+      creatingTerminal = false;
+      useTerminalNodes() {
+        const fs = this.Fs;
+        const { lookupNode, readdir, getPath, mkdev, makedev } = fs;
+        const ttyNames = this.sys.ttyNames?.bind(this.sys);
+        if (!lookupNode || !readdir || !getPath || !mkdev || !makedev || !ttyNames) return;
+        fs.lookupNode = (parent, name) => {
+          try {
+            return lookupNode.call(fs, parent, name);
+          } catch (e) {
+            const path = `/dev/${name}`;
+            if (this.creatingTerminal || !TTY_NAME.test(name) || getPath.call(fs, parent) !== "/dev")
+              throw e;
+            if (!ttyNames().includes(path)) throw e;
+            this.creatingTerminal = true;
+            try {
+              mkdev.call(fs, path, makedev.call(fs, 6, 0));
+            } finally {
+              this.creatingTerminal = false;
+            }
+            return lookupNode.call(fs, parent, name);
+          }
+        };
+        fs.readdir = (path) => {
+          const names = readdir.call(fs, path);
+          if (path.replace(/\/+$/, "") !== "/dev") return names;
+          const missing = ttyNames().map((tty) => tty.slice("/dev/".length)).filter((name) => TTY_NAME.test(name) && !names.includes(name));
+          return [...names, ...missing];
+        };
+      }
       ttyNode(name) {
         const { analyzePath, mkdev, makedev } = this.Fs;
         if (!TTY_PATH.test(name) || !analyzePath || !mkdev || !makedev) return;
@@ -1707,8 +1787,13 @@ var init_kernel_streams = __esm({
       useControllingTerminal() {
         if (typeof this.Fs.open !== "function") return;
         this.usePtyPaths();
+        this.useTerminalNodes();
         const open = this.Fs.open.bind(this.Fs);
         this.Fs.open = (path, flags, mode) => {
+          const device = typeof path === "string" ? this.devicePath(path) : void 0;
+          if (device !== void 0 && TTY_PATH.test(device) && !this.terminalExists(device)) {
+            throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
+          }
           const pty = this.openPty(open, path, flags, mode);
           if (pty) return pty;
           const stream = open(path, flags, mode);
@@ -1781,6 +1866,23 @@ var init_kernel_streams = __esm({
         const exists = n === void 0 ? this.sys.openPty !== void 0 : this.sys.ptyNumbers?.().includes(Number(n)) ?? false;
         if (!exists) throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
       }
+      devicePath(path) {
+        const name = path.slice(path.lastIndexOf("/") + 1);
+        if (!TTY_NAME.test(name)) return void 0;
+        const { lookupPath, cwd } = this.Fs;
+        const absolute = path.startsWith("/") ? path : `${cwd?.call(this.Fs) ?? "/"}/${path}`;
+        const dir = absolute.slice(0, absolute.lastIndexOf("/")) || "/";
+        try {
+          const real = lookupPath?.call(this.Fs, dir, { follow: true }).path ?? dir;
+          return `${real === "/" ? "" : real}/${name}`;
+        } catch {
+          return absolute;
+        }
+      }
+      terminalExists(path) {
+        const { analyzePath } = this.Fs;
+        return analyzePath?.call(this.Fs, path).exists ?? true;
+      }
       openNamedTerminal(path) {
         const { openTty } = this.sys;
         if (!openTty) return void 0;
@@ -2095,6 +2197,37 @@ function pathOpensLinks(Fs) {
   if (!mayOpen || !isLink) return;
   fs.mayOpen = (node, flags) => flags & O_PATH && isLink.call(fs, node.mode) ? 0 : mayOpen.call(fs, node, flags);
 }
+function kernelUmask(imports, deps) {
+  let umask = deps.initial & 511;
+  for (const ns of namespaces(imports)) {
+    const { __syscall_openat: openat, __syscall_mkdirat: mkdirat } = ns;
+    const { __syscall_mknodat: mknodat, __syscall_umask: own } = ns;
+    if (typeof openat === "function") {
+      ns.__syscall_openat = (dirfd, path, flags, varargs) => {
+        const memory = deps.memory();
+        if (flags & O_CREAT2 && varargs && memory)
+          new Int32Array(memory.buffer)[varargs >> 2] &= ~umask;
+        return openat(dirfd, path, flags, varargs);
+      };
+    }
+    if (typeof mkdirat === "function") {
+      ns.__syscall_mkdirat = (dirfd, path, mode) => mkdirat(dirfd, path, mode & ~umask);
+    }
+    if (typeof mknodat === "function") {
+      ns.__syscall_mknodat = (dirfd, path, mode, dev) => mknodat(dirfd, path, mode & ~umask, dev);
+    }
+    if (typeof own === "function") {
+      own(umask);
+      ns.__syscall_umask = (mask) => {
+        const old = umask;
+        umask = mask & 511;
+        own(umask);
+        deps.set(umask);
+        return old;
+      };
+    }
+  }
+}
 function noFollowUtimes(imports, fs, glue) {
   for (const namespace of namespaces(imports)) {
     const key = Object.keys(namespace).find(
@@ -2760,7 +2893,6 @@ function createProcessKernel(deps) {
     if (!stream) return { none: true };
     promote?.(stream);
     if (stream.sliccKernelFd !== void 0) return { fd: stream.sliccKernelFd };
-    if (stream.path === "/dev/null") return { none: true };
     const device = deviceOfStream(stream);
     if (device) return device;
     return n === 0 ? { input: drain(Fs, stream) } : { capture: true };
@@ -2975,6 +3107,7 @@ var init_process_signals = __esm({
       depth = 0;
       reporting = false;
       unwinding = false;
+      quieted = 0;
       raw;
       header;
       hooks;
@@ -3019,7 +3152,16 @@ var init_process_signals = __esm({
         this.reported = { caught, ignored };
         this.raw.call({ op: "sig-mask", caught, ignored }, Number.POSITIVE_INFINITY, "sig-mask");
       }
+      quiet(fn) {
+        this.quieted++;
+        try {
+          return fn();
+        } finally {
+          this.quieted--;
+        }
+      }
       deliver() {
+        if (this.quieted > 0) return;
         const killed = Atomics.load(this.header, SAB_I_KILLED);
         if (killed !== 0 && !this.unwinding && this.hooks.killed) {
           this.unwinding = true;
@@ -3265,7 +3407,7 @@ function pidStatus(info) {
   const ids = `${UID}	${UID}	${UID}	${UID}`;
   return [
     `Name:	${commOf(info)}`,
-    "Umask:	0022",
+    `Umask:	${(info.umask ?? 18).toString(8).padStart(4, "0")}`,
     `State:	${state}`,
     `Tgid:	${info.pid}`,
     "Ngid:	0",
@@ -3608,9 +3750,15 @@ function kernelSys(transport) {
     kind(fd) {
       return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.kind;
     },
+    device(fd) {
+      return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`)).meta;
+    },
     size(fd) {
       return json(call2({ op: "fd-vfs-stat", fd }, `fd-vfs-stat ${fd}`)).size;
     },
+    ttyNames() {
+      return json(call2({ op: "fd-tty-names" }, "fd-tty-names"));
+    },
     openTty(name) {
       const req = name === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name };
       return json(call2(req, `fd-open-tty ${name ?? ""}`));
@@ -3683,6 +3831,8 @@ function wireKernelStdio(Fs, streams, sys) {
     const stream = Fs.getStream(fd);
     if (!stream) continue;
     const kind = sys?.kind?.(fd);
+    const device = kind === "device" ? sys?.device?.(fd) : void 0;
+    if (device && openDevice(Fs, fd, device)) continue;
     if (kind && PLACED.has(kind)) {
       const { flags } = stream;
       Fs.closeStream(fd);
@@ -3741,7 +3891,15 @@ async function runWasmProcess(init, port, deps = {}) {
       }
     }
   );
-  const transport = signals.transport();
+  const gated = signals.transport();
+  let early = () => {
+  };
+  const transport = {
+    call: (req, timeoutMs, label) => {
+      if (!FS_OPS.has(req.op)) early();
+      return gated.call(req, timeoutMs, label);
+    }
+  };
   const sys = kernelSys(transport);
   const encoder3 = new TextEncoder();
   const say = (fd) => (text) => sys.write(fd, encoder3.encode(`${text}
@@ -3780,6 +3938,11 @@ async function runWasmProcess(init, port, deps = {}) {
           }
         });
         liveParent(imports, () => identify(transport, init).ppid);
+        kernelUmask(imports, {
+          initial: init.umask ?? 18,
+          memory: () => memory,
+          set: (mask) => void transport.call({ op: "proc-umask", mask }, Number.POSITIVE_INFINITY, "umask")
+        });
         noFollowUtimes(
           imports,
           () => ownValue(module, "FS"),
@@ -3827,6 +3990,7 @@ async function runWasmProcess(init, port, deps = {}) {
     cwd: init.cwd,
     warn: deps.warn ?? say(2)
   });
+  early = () => signals.quiet(() => vfs.flushDirty());
   const sigpipe = () => running.sliccSigpipe?.() === 1;
   const restartable = () => signals.restartable();
   const streams = new KernelStreams(running.FS, sys, { sigpipe, restartable });
@@ -3920,7 +4084,7 @@ function runMain(running, init) {
     return status2;
   }
 }
-var O_RDONLY, O_WRONLY3, O_RDWR3, PLACED, GLUE_TRAILER, evaluateGlue, EVAL_BLOCKED;
+var FS_OPS, O_RDONLY, O_WRONLY3, O_RDWR3, PLACED, GLUE_TRAILER, evaluateGlue, EVAL_BLOCKED;
 var init_process_runtime = __esm({
   "src/process/process-runtime.ts"() {
     "use strict";
@@ -3928,6 +4092,7 @@ var init_process_runtime = __esm({
     init_signals();
     init_emscripten_vfs_hook();
     init_live_vfs_fs();
+    init_sync_fs_wire();
     init_sync_sab_bridge();
     init_sync_sab_wire();
     init_kernel_streams();
@@ -3940,6 +4105,7 @@ var init_process_runtime = __esm({
     init_procfs();
     init_realm_user();
     init_kernel_streams();
+    FS_OPS = new Set(SYNC_FS_OPS);
     O_RDONLY = 0;
     O_WRONLY3 = 1;
     O_RDWR3 = 2;
@@ -5077,8 +5243,9 @@ function filestatOf(path, s) {
 function kernelFiletype(kind) {
   switch (kind) {
     case "tty":
-    case "device":
       return { filetype: FILETYPE.CHARACTER_DEVICE, seeks: false };
+    case "device":
+      return { filetype: FILETYPE.CHARACTER_DEVICE, seeks: true };
     case "socket":
       return { filetype: FILETYPE.SOCKET_STREAM, seeks: false };
     case "file":
@@ -5116,7 +5283,7 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, NS_PER_MS, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, WasiHost;
+var WasiExit, NS_PER_MS, AT_SYMLINK_NOFOLLOW2, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, WasiHost;
 var init_wasi_host = __esm({
   "src/process/wasi/wasi-host.ts"() {
     "use strict";
@@ -5133,6 +5300,8 @@ var init_wasi_host = __esm({
       }
     };
     NS_PER_MS = 1000000n;
+    AT_SYMLINK_NOFOLLOW2 = 1;
+    DEFAULT_UMASK = 18;
     MONOTONIC_BASE = BigInt(Math.round(performance.timeOrigin)) * NS_PER_MS;
     MAX_READ = 1024 * 1024;
     SIGPIPE_EXIT = 141;
@@ -5173,6 +5342,43 @@ var init_wasi_host = __esm({
       get cwd() {
         return this.fds.cwd() ?? this.startCwd;
       }
+      created(path, mode) {
+        const umask = this.o.kernel.call({ op: "proc-umask" });
+        if (umask !== DEFAULT_UMASK) this.o.fs.chmod(path, mode & ~umask);
+      }
+      sliccFsImports() {
+        const { mem, fds } = this;
+        const at = (dirfd, p, l) => fds.resolve(dirfd, mem.string(p, l));
+        const pathOf = (fd) => {
+          const e = fds.get(fd);
+          if (e.type === "dir") return e.path;
+          if (e.type === "file") return e.file.path;
+          const path = e.type === "kernel" && fds.kind(fd, e) === "file" ? this.kernelStat(fd).path : void 0;
+          if (path === void 0) throw new WasiError("EBADF");
+          return path;
+        };
+        const target = (path, flags) => {
+          if (flags & AT_SYMLINK_NOFOLLOW2 && this.o.fs.lstat(path).isSymbolicLink) {
+            throw new WasiError("ENOTSUP");
+          }
+          return path;
+        };
+        const modeOf = (st) => (st.mode ?? 0) & 4095;
+        return wrap({
+          fd_chmod: (fd, mode) => void this.o.fs.chmod(pathOf(fd), mode & 4095),
+          path_chmod: (dirfd, p, l, mode, flags) => void this.o.fs.chmod(target(at(dirfd, p, l), flags), mode & 4095),
+          umask: (mask, out) => {
+            const old = this.o.kernel.call({ op: "proc-umask", mask });
+            mem.view().setUint32(out, old, true);
+          },
+          fd_mode: (fd, out) => void mem.view().setUint32(out, modeOf(this.o.fs.stat(pathOf(fd))), true),
+          path_mode: (dirfd, p, l, flags, out) => {
+            const path = at(dirfd, p, l);
+            const st = flags & AT_SYMLINK_NOFOLLOW2 ? this.o.fs.lstat(path) : this.o.fs.stat(path);
+            mem.view().setUint32(out, modeOf(st), true);
+          }
+        });
+      }
       sliccImports() {
         const { mem } = this;
         const path = (p, l) => {
@@ -5322,7 +5528,12 @@ var init_wasi_host = __esm({
         const { mem, fds, o } = this;
         const at = (dirfd, p, l) => fds.resolve(dirfd, mem.string(p, l));
         return {
-          path_open: (dirfd, _lookup, p, l, oflags, rights, _inheriting, fdflags, out) => void mem.view().setUint32(out, fds.open(at(dirfd, p, l), oflags, rights, fdflags), true),
+          path_open: (dirfd, _lookup, p, l, oflags, rights, _inheriting, fdflags, out) => {
+            const path = at(dirfd, p, l);
+            const fresh = (oflags & OFLAGS.CREAT) !== 0 && !o.fs.exists(path);
+            mem.view().setUint32(out, fds.open(path, oflags, rights, fdflags), true);
+            if (fresh) this.created(path, 438);
+          },
           path_filestat_get: (dirfd, lookup, p, l, out) => void this.writeFilestat(out, this.pathFilestat(at(dirfd, p, l), lookup)),
           path_filestat_set_times: (dirfd, lookup, p, l, atim, mtim, flags) => {
             const path = at(dirfd, p, l);
@@ -5333,6 +5544,7 @@ var init_wasi_host = __esm({
             const path = at(dirfd, p, l);
             if (o.fs.exists(path)) throw new WasiError("EEXIST");
             o.fs.mkdir(path);
+            this.created(path, 511);
           },
           path_remove_directory: (dirfd, p, l) => void o.fs.rmdir(at(dirfd, p, l)),
           path_unlink_file: (dirfd, p, l) => {
@@ -5482,7 +5694,9 @@ var init_wasi_host = __esm({
       seek(fd, offset, whence) {
         const e = this.fds.get(fd);
         if (e.type === "kernel") {
-          if (this.fds.kind(fd, e) !== "file") throw new WasiError("ESPIPE");
+          const kind = this.fds.kind(fd, e);
+          if (kind === "device") return 0;
+          if (kind !== "file") throw new WasiError("ESPIPE");
           return this.o.kernel.sys.seek(fd, offset, whence);
         }
         if (e.type === "device") return 0;
@@ -7426,14 +7640,15 @@ function unsupportedImport(module, memory, extended = false, foreign = {}) {
   }
   return void 0;
 }
-function linkImports(module, preview1, wasix, memory, threads, program = {}, foreign, slicc = {}) {
+function linkImports(module, preview1, wasix, memory, threads, program = {}, foreign, slicc = {}, sliccFs = {}) {
   for (const ns of Object.keys(program)) {
-    if (RESERVED2.has(ns) || ns === SLICC)
+    if (RESERVED2.has(ns) || ns === SLICC || ns === SLICC_FS)
       throw new Error(`the imports module may not define ${ns}`);
   }
   const imports = {
     ...program,
     [SLICC]: { ...slicc },
+    [SLICC_FS]: { ...sliccFs },
     [PREVIEW1]: preview1,
     ...wasix ? { [WASIX]: { ...wasix } } : {},
     ...threads ? { wasi: { "thread-spawn": (arg) => threads.spawn(arg) } } : {}
@@ -7560,7 +7775,18 @@ async function instantiate(host, module, memory, threads, {
     () => instance
   );
   const slicc = traced(stats, "slicc", host.sliccImports());
-  const hostImports = linkImports(module, preview1, wasix, memory, threads, extra, foreign, slicc);
+  const sliccFs = traced(stats, "slicc_fs", host.sliccFsImports());
+  const hostImports = linkImports(
+    module,
+    preview1,
+    wasix,
+    memory,
+    threads,
+    extra,
+    foreign,
+    slicc,
+    sliccFs
+  );
   const imports = sync ? merge(hostImports, sync.linker.mainImports(module)) : hostImports;
   instance = await WebAssembly.instantiate(module, imports);
   stats?.phase("instantiate");
@@ -7750,7 +7976,7 @@ async function runWasiThread(init, port) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, RESERVED2, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SLICC_FS, RESERVED2, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -7776,6 +8002,7 @@ var init_wasi_runtime = __esm({
     PREVIEW1 = "wasi_snapshot_preview1";
     WASIX = "wasix_32v1";
     SLICC = "slicc";
+    SLICC_FS = "slicc_fs";
     RESERVED2 = RESERVED_NAMESPACES;
     noErrno = (key) => `imports ${key}: its result cannot carry ENOSYS, and this host does not provide it`;
     FALLBACK_MAXIMUM_PAGES = 32768;