@ai-ecoverse/slicc-kernel 1.32.3 → 1.33.0

package/dist/process-worker.js

@@ -1319,7 +1319,7 @@ function sabViews(sab) {
     window: new Uint8Array(sab, SAB_HEADER_BYTES)
   };
 }
-var SAB_HEADER_I32, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
+var SAB_HEADER_I32, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
 var init_sync_sab_wire = __esm({
   "src/realm/sync-sab-wire.ts"() {
     "use strict";
@@ -1339,6 +1339,8 @@ var init_sync_sab_wire = __esm({
     SAB_I_TOTAL_HI = 11;
     SAB_I_OFFSET_HI = 12;
     SAB_I_KILLED = 13;
+    SAB_I_ASYNC = 14;
+    SAB_I_STOP = 15;
     U32 = 2 ** 32;
     SAB_STATE_IDLE = 0;
     SAB_STATE_PENDING = 1;
@@ -2905,8 +2907,8 @@ var init_process_http = __esm({
     "use strict";
     HttpError = class extends Error {
       code;
-      constructor(code2, message) {
-        super(message);
+      constructor(code2, message2) {
+        super(message2);
         this.code = code2;
       }
     };
@@ -3695,8 +3697,8 @@ async function runWasmProcess(init, port, deps = {}) {
   );
   const transport = signals.transport();
   const sys = kernelSys(transport);
-  const encoder2 = new TextEncoder();
-  const say = (fd) => (text) => sys.write(fd, encoder2.encode(`${text}
+  const encoder3 = new TextEncoder();
+  const say = (fd) => (text) => sys.write(fd, encoder3.encode(`${text}
 `));
   let ready;
   let failed2;
@@ -4874,11 +4876,11 @@ var init_wasi_memory = __esm({
         return at;
       }
       putStrings(list, ptrs, buf) {
-        const encoder2 = new TextEncoder();
+        const encoder3 = new TextEncoder();
         const v = this.view();
         let at = buf;
         list.forEach((s, i) => {
-          const b = encoder2.encode(s);
+          const b = encoder3.encode(s);
           v.setUint32(ptrs + i * 4, at, true);
           this.bytes(at, b.length).set(b);
           v.setUint8(at + b.length, 0);
@@ -4886,12 +4888,12 @@ var init_wasi_memory = __esm({
         });
       }
       putSizes(list, countPtr, sizePtr) {
-        const encoder2 = new TextEncoder();
+        const encoder3 = new TextEncoder();
         const v = this.view();
         v.setUint32(countPtr, list.length, true);
         v.setUint32(
           sizePtr,
-          list.reduce((n, s) => n + encoder2.encode(s).length + 1, 0),
+          list.reduce((n, s) => n + encoder3.encode(s).length + 1, 0),
           true
         );
       }
@@ -5572,8 +5574,11 @@ function base64(text) {
   }
   return btoa(binary);
 }
+function importSource(source) {
+  return import(`data:text/javascript;base64,${base64(source)}`);
+}
 async function loadImports(source) {
-  const loaded = await import(`data:text/javascript;base64,${base64(source)}`);
+  const loaded = await importSource(source);
   if (typeof loaded.createImports !== "function") {
     throw new Error("the imports module exports no createImports function");
   }
@@ -6401,12 +6406,12 @@ var init_wasix_linker = __esm({
       slot(fn, handle, name) {
         const known = this.slots.get(fn);
         if (known !== void 0) return known;
-        const index = this.table.length;
+        const index2 = this.table.length;
         this.table.grow(1);
-        this.table.set(index, fn);
-        this.slots.set(fn, index);
-        this.publisher?.({ kind: "slot", index, handle, name });
-        return index;
+        this.table.set(index2, fn);
+        this.slots.set(fn, index2);
+        this.publisher?.({ kind: "slot", index: index2, handle, name });
+        return index2;
       }
       allocate(size, alignment) {
         if (size === 0) return 0;
@@ -7113,9 +7118,9 @@ var init_wasix_host = __esm({
       }
       dlImports() {
         const { mem, host } = this;
-        const failed2 = (message, buf, len) => {
+        const failed2 = (message2, buf, len) => {
           if (len > 0) {
-            const bytes = new TextEncoder().encode(message).subarray(0, len - 1);
+            const bytes = new TextEncoder().encode(message2).subarray(0, len - 1);
             mem.bytes(buf, bytes.length).set(bytes);
             mem.view().setUint8(buf + bytes.length, 0);
           }
@@ -7267,10 +7272,10 @@ function parseFunctionNames(payload) {
     if (end > payload.length) throw new RangeError("truncated name section");
     if (id === 1) {
       for (let count = leb(); count > 0; count--) {
-        const index = leb();
+        const index2 = leb();
         const length = leb();
         if (at + length > end) throw new RangeError("truncated name section");
-        names.set(index, decoder3.decode(payload.subarray(at, at + length)));
+        names.set(index2, decoder3.decode(payload.subarray(at, at + length)));
         at += length;
       }
     }
@@ -7294,7 +7299,7 @@ function nameFrame(line, module, name) {
 }
 function sidecarNames(read, path) {
   let names;
-  return (index) => {
+  return (index2) => {
     if (!names) {
       try {
         names = parseFunctionNames(read(path));
@@ -7302,7 +7307,7 @@ function sidecarNames(read, path) {
         names = /* @__PURE__ */ new Map();
       }
     }
-    return names.get(index);
+    return names.get(index2);
   };
 }
 var UNNAMED_FRAME, WASM_MODULE;
@@ -7767,11 +7772,721 @@ var init_wasi_runtime = __esm({
   }
 });
 
+// src/process/js/async-sab.ts
+async function changed(header, index2, seen, waitAsync = defaultWaitAsync) {
+  const waited = waitAsync(header, index2, seen);
+  if (waited.async) await waited.value;
+}
+function createAsyncSabTransport(sab, port, waitAsync = defaultWaitAsync) {
+  const { header, window } = sabViews(sab);
+  let seq = 0;
+  let tail = Promise.resolve();
+  async function ready(id) {
+    for (; ; ) {
+      const published = Atomics.load(header, SAB_I_PUB);
+      if (Atomics.load(header, SAB_I_STATE) === SAB_STATE_READY && Atomics.load(header, SAB_I_SEQ) === id) {
+        return;
+      }
+      await changed(header, SAB_I_PUB, published, waitAsync);
+    }
+  }
+  async function once(req) {
+    const id = ++seq;
+    let out = null;
+    let status2 = 0;
+    let offset = 0;
+    Atomics.store(header, SAB_I_REQ, id);
+    try {
+      for (; ; ) {
+        Atomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
+        port.postMessage(
+          offset === 0 ? { type: SYNC_SAB_REQ_MSG, id, req } : { type: SYNC_SAB_NEXT_MSG, id, offset }
+        );
+        await ready(id);
+        const total = loadU53(header, SAB_I_TOTAL, SAB_I_TOTAL_HI);
+        const chunk = Atomics.load(header, SAB_I_CHUNK);
+        const at = loadU53(header, SAB_I_OFFSET, SAB_I_OFFSET_HI);
+        if (at !== offset || chunk < 0 || total < 0 || offset + chunk > total) {
+          return { ok: false, errno: "EIO", message: "sync-sab: torn reply" };
+        }
+        if (out === null) {
+          status2 = Atomics.load(header, SAB_I_STATUS);
+          out = new Uint8Array(total);
+        }
+        out.set(window.subarray(0, chunk), offset);
+        offset += chunk;
+        if (offset >= total) break;
+        if (chunk === 0) return { ok: false, errno: "EIO", message: "sync-sab: empty chunk" };
+      }
+    } finally {
+      Atomics.store(header, SAB_I_REQ, 0);
+      Atomics.store(header, SAB_I_STATE, SAB_STATE_IDLE);
+    }
+    return decodeSabResult(status2, out);
+  }
+  return {
+    call(req) {
+      const run = tail.then(() => once(req));
+      tail = run.catch(() => void 0);
+      return run;
+    }
+  };
+}
+var defaultWaitAsync;
+var init_async_sab = __esm({
+  "src/process/js/async-sab.ts"() {
+    "use strict";
+    init_sync_sab_wire();
+    defaultWaitAsync = (a, i, v) => Atomics.waitAsync(a, i, v);
+  }
+});
+
+// src/process/js/js-kernel.ts
+var JsCallError, JsKernel;
+var init_js_kernel = __esm({
+  "src/process/js/js-kernel.ts"() {
+    "use strict";
+    init_signals();
+    init_sync_sab_wire();
+    init_async_sab();
+    JsCallError = class extends Error {
+      code;
+      constructor(code2, what) {
+        super(`${what}: ${code2}`);
+        this.name = "JsCallError";
+        this.code = code2;
+      }
+    };
+    JsKernel = class {
+      header;
+      transport;
+      waitAsync;
+      onError;
+      handlers = /* @__PURE__ */ new Map();
+      ignored = 0;
+      changing = Promise.resolve();
+      pid = 0;
+      reported = { caught: 0, ignored: 0 };
+      watching = false;
+      constructor(o) {
+        this.header = new Int32Array(o.sab, 0, SAB_HEADER_I32);
+        this.transport = o.transport;
+        this.waitAsync = o.waitAsync;
+        this.onError = o.onError;
+      }
+      async raw(req) {
+        const result = await this.transport.call(req);
+        this.deliver();
+        return result;
+      }
+      async call(req) {
+        const result = await this.raw(req);
+        if (!result.ok) throw new JsCallError(result.errno, req.op);
+        return result;
+      }
+      async json(req) {
+        const result = await this.call(req);
+        return result.ok && result.kind === "json" ? result.json : void 0;
+      }
+      async bytes(req) {
+        const result = await this.call(req);
+        return result.ok && result.kind === "bytes" ? result.bytes : new Uint8Array(0);
+      }
+      async blocking(req) {
+        for (; ; ) {
+          const id = await this.json({ op: "async-submit", req });
+          const result = await this.settled(id);
+          if (result.ok) return result;
+          if (result.errno !== "EINTR") throw new JsCallError(result.errno, req.op);
+        }
+      }
+      async settled(id) {
+        for (; ; ) {
+          const seen = Atomics.load(this.header, SAB_I_ASYNC);
+          const taken = await this.raw({ op: "async-take", id });
+          if (taken.ok || taken.errno !== "EAGAIN") return taken;
+          await changed(this.header, SAB_I_ASYNC, seen, this.waitAsync);
+        }
+      }
+      deliver() {
+        const pending = Atomics.exchange(this.header, SAB_I_SIGNALS, 0);
+        for (const sig of signalsIn(pending)) {
+          const handler = this.handlers.get(sig);
+          if (!handler) {
+            if (!(this.ignored & sigbit(sig))) this.raise(sig);
+            continue;
+          }
+          try {
+            Promise.resolve(handler(sig)).catch(this.onError);
+          } catch (err) {
+            this.onError(err);
+          }
+        }
+      }
+      async watch() {
+        if (this.watching) return;
+        this.watching = true;
+        for (; ; ) {
+          await changed(this.header, SAB_I_SIGNALS, 0, this.waitAsync);
+          this.deliver();
+        }
+      }
+      async watchStops() {
+        for (; ; ) {
+          await changed(this.header, SAB_I_STOP, 0, this.waitAsync);
+          this.freeze();
+        }
+      }
+      freeze() {
+        while (Atomics.load(this.header, SAB_I_STOP) === 1) Atomics.wait(this.header, SAB_I_STOP, 1);
+      }
+      setHandler(sig, handler) {
+        if (sig === SIG.KILL || sig === SIG.STOP) {
+          return Promise.reject(new JsCallError("EINVAL", "signal"));
+        }
+        const run = this.changing.then(() => this.change(sig, handler));
+        this.changing = run.catch(() => void 0);
+        return run;
+      }
+      async change(sig, handler) {
+        const handlers = new Map(this.handlers);
+        handlers.delete(sig);
+        let ignored = this.ignored & ~sigbit(sig);
+        if (handler === "ignore") ignored |= sigbit(sig);
+        else if (handler !== "default") handlers.set(sig, handler);
+        await this.report(handlers, ignored, handler === "default" ? sigbit(sig) : 0);
+        this.handlers = handlers;
+        this.ignored = ignored;
+        if (handlers.size > 0) void this.watch();
+      }
+      raise(sig) {
+        this.call({ op: "proc-kill", pid: this.pid, sig }).catch(this.onError);
+      }
+      async report(handlers, ignored, defaults) {
+        let caught = 0;
+        for (const sig of handlers.keys()) caught |= sigbit(sig);
+        const same = caught === this.reported.caught && ignored === this.reported.ignored;
+        if (same && defaults === 0) return;
+        this.reported = { caught, ignored };
+        await this.call({ op: "sig-mask", caught, ignored, ...defaults ? { defaults } : {} });
+      }
+    };
+  }
+});
+
+// src/process/js/js-context.ts
+function identityOf(answer2, fallback) {
+  const id = answer2;
+  return {
+    pid: typeof id?.pid === "number" ? id.pid : fallback.pid,
+    ppid: typeof id?.ppid === "number" ? id.ppid : fallback.ppid ?? 1
+  };
+}
+function signalNumber(signal) {
+  if (typeof signal === "number") {
+    if (Number.isInteger(signal) && signal >= 1 && signal <= 31) return signal;
+    throw new JsCallError("EINVAL", `signal ${signal}`);
+  }
+  const n = SIG[signal.slice(3)];
+  if (n === void 0) throw new JsCallError("EINVAL", `signal ${signal}`);
+  return n;
+}
+function resolvePath(cwd, path) {
+  const parts = [];
+  for (const part of (path.startsWith("/") ? path : `${cwd}/${path}`).split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts.pop();
+    else parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+}
+function typeOf(info) {
+  if (info.meta && "dir" in info.meta) return "directory";
+  if (info.meta && "device" in info.meta) return "device";
+  if (info.tty || info.kind === "tty") return "tty";
+  if (info.kind === "socket") return "socket";
+  return info.kind === "file" ? "file" : "pipe";
+}
+function flagsOf(o) {
+  const write = o.write || o.append || o.truncate;
+  const access = write ? o.read ? O_RDWR6 : O_WRONLY5 : 0;
+  return access | (o.append ? O_APPEND3 : 0);
+}
+function createContext(o) {
+  const { kernel } = o;
+  const infos = /* @__PURE__ */ new Map();
+  const handles = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const random = o.random ?? ((bytes) => void crypto.getRandomValues(bytes));
+  const resolve = (path) => resolvePath(o.cwd, path);
+  const exit = (code2 = 0) => {
+    o.exit(code2);
+    throw new JsExit(code2);
+  };
+  const info = async (fd) => {
+    const known = infos.get(fd);
+    if (known) return known;
+    const got = await kernel.json({ op: "fd-info", fd });
+    infos.set(fd, got);
+    return got;
+  };
+  const device = (i) => i.meta && "device" in i.meta ? i.meta : void 0;
+  const read = async (fd, max = CHUNK) => {
+    index(max, "read");
+    const i = await info(fd);
+    if (typeOf(i) === "directory") throw new JsCallError("EISDIR", "read");
+    const dev = device(i);
+    if (dev) {
+      if (dev.access === "write") throw new JsCallError("EBADF", "read");
+      if (dev.device === "null") return new Uint8Array(0);
+      const out = new Uint8Array(Math.min(max, CHUNK));
+      if (dev.device === "urandom") random(out);
+      return out;
+    }
+    const r = await kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
+    return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+  };
+  const writeAll = async (fd, data) => {
+    const i = await info(fd);
+    if (typeOf(i) === "directory") throw new JsCallError("EISDIR", "write");
+    const dev = device(i);
+    if (dev) {
+      if (dev.access === "read") throw new JsCallError("EBADF", "write");
+      if (dev.device === "full") throw new JsCallError("ENOSPC", "write");
+      return;
+    }
+    let at = 0;
+    while (at < data.length) {
+      const body = data.subarray(at, at + MAX_IO);
+      try {
+        const r = await kernel.blocking({ op: "fd-write", fd, body });
+        at += r.ok && r.kind === "json" && typeof r.json === "number" ? r.json : body.length;
+      } catch (err) {
+        const broken = err instanceof JsCallError && err.code === "EPIPE";
+        if (broken && typeOf(i) !== "socket") {
+          await kernel.call({ op: "proc-kill", pid: o.pid, sig: SIG.PIPE });
+        }
+        throw err;
+      }
+    }
+  };
+  const write = (fd, data) => {
+    const bytes = typeof data === "string" ? encoder2.encode(data) : data;
+    let settle;
+    const settled = new Promise((resolve2) => settle = resolve2);
+    pending.add(settled);
+    return (async () => {
+      try {
+        await writeAll(fd, bytes);
+      } finally {
+        pending.delete(settled);
+        settle();
+      }
+    })();
+  };
+  const writable = (fd) => new WritableStream({ write: (chunk) => write(fd, chunk) });
+  const statOf = async (op, path) => {
+    const abs = resolve(path);
+    await kernel.call({ op: "fd-path-flush", path: abs });
+    const s = parseSyncFsStat(await kernel.json({ op, path: abs }));
+    if (!s) throw new JsCallError("EIO", op);
+    return s;
+  };
+  const open = async (path, options = {}) => {
+    const abs = resolve(path);
+    const exclusive = options.create === true && options.exclusive === true;
+    const existing = await statOf(exclusive ? "lstat" : "stat", abs).catch((err) => {
+      if (err instanceof JsCallError && err.code === "ENOENT") return void 0;
+      throw err;
+    });
+    if (existing && exclusive) throw new JsCallError("EEXIST", abs);
+    if (!existing && !options.create) throw new JsCallError("ENOENT", abs);
+    if (existing?.isDirectory) throw new JsCallError("EISDIR", abs);
+    const fd = await kernel.json({
+      op: "fd-open-vfs",
+      path: abs,
+      flags: flagsOf(options),
+      position: 0,
+      ...exclusive ? { exclusive: true } : options.create ? { create: true } : { existing: true },
+      ...options.truncate ? { truncate: true } : {}
+    });
+    try {
+      await kernel.call({ op: "fd-vfs-stat", fd });
+    } catch (err) {
+      await kernel.raw({ op: "fd-close", fd });
+      throw err;
+    }
+    infos.set(fd, { kind: "file" });
+    const handle = fileHandle(kernel, fd, abs, options.append === true, () => {
+      infos.delete(fd);
+      handles.delete(fd);
+    });
+    handles.set(fd, handle.invalidate);
+    return handle.file;
+  };
+  const fs = pathOps(kernel, resolve, statOf, open);
+  const ctx = {
+    argv: o.argv,
+    env: o.env,
+    pid: o.pid,
+    async ppid() {
+      return identityOf(await kernel.json({ op: "proc-identity" }), o).ppid;
+    },
+    cwd: o.cwd,
+    stdin: new ReadableStream(
+      {
+        async pull(controller) {
+          const chunk = await read(0);
+          if (chunk.length === 0) controller.close();
+          else controller.enqueue(chunk);
+        }
+      },
+      { highWaterMark: 0 }
+    ),
+    stdout: writable(1),
+    stderr: writable(2),
+    read,
+    write,
+    async close(fd) {
+      handles.get(fd)?.();
+      handles.delete(fd);
+      infos.delete(fd);
+      await kernel.call({ op: "fd-close", fd });
+    },
+    async fdStatus(fd) {
+      const type = typeOf(await info(fd));
+      return { type, tty: type === "tty", seekable: type === "file" };
+    },
+    isatty: async (fd) => typeOf(await info(fd)) === "tty",
+    open,
+    resolve,
+    fs,
+    signals: {
+      on: async (signal, handler) => kernel.setHandler(signalNumber(signal), handler),
+      ignore: async (signal) => kernel.setHandler(signalNumber(signal), "ignore"),
+      reset: async (signal) => kernel.setHandler(signalNumber(signal), "default")
+    },
+    exit
+  };
+  const drain2 = async () => {
+    for (; ; ) {
+      await Promise.all([...pending]);
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      if (pending.size === 0) return;
+    }
+  };
+  return { ctx, drain: drain2 };
+}
+function fileHandle(kernel, fd, path, append, forget) {
+  let open = true;
+  const live = () => {
+    if (!open) throw new JsCallError("EBADF", path);
+  };
+  const file = {
+    fd,
+    path,
+    async size() {
+      live();
+      const s = await kernel.json({ op: "fd-vfs-stat", fd });
+      return s.size;
+    },
+    async read(position, length) {
+      index(position, "read");
+      index(length, "read");
+      const parts = [];
+      let got = 0;
+      do {
+        live();
+        const max = Math.min(length - got, MAX_IO);
+        if (max <= 0) break;
+        const chunk = await kernel.bytes({ op: "fd-pread", fd, offset: position + got, max });
+        if (chunk.length === 0) break;
+        parts.push(chunk);
+        got += chunk.length;
+      } while (got < length);
+      if (parts.length === 1) return parts[0];
+      const out = new Uint8Array(got);
+      let at = 0;
+      for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+      }
+      return out;
+    },
+    async write(position, data) {
+      index(position, "write");
+      let at = 0;
+      do {
+        live();
+        if (at >= data.length) break;
+        const body = data.subarray(at, at + MAX_IO);
+        const n = await kernel.json(
+          append ? { op: "fd-write", fd, body } : { op: "fd-pwrite", fd, offset: position + at, body }
+        );
+        if (!(n > 0)) throw new JsCallError("EIO", "write");
+        at += n;
+      } while (at < data.length);
+      return at;
+    },
+    async truncate(size) {
+      live();
+      index(size, "truncate");
+      await kernel.call({ op: "fd-resize", fd, size });
+    },
+    async sync() {
+      live();
+      await kernel.call({ op: "fd-flush", fd });
+    },
+    async close() {
+      live();
+      open = false;
+      forget();
+      await kernel.call({ op: "fd-close", fd });
+    }
+  };
+  return {
+    file,
+    invalidate: () => {
+      open = false;
+    }
+  };
+}
+function index(n, what) {
+  if (!Number.isSafeInteger(n) || n < 0) throw new JsCallError("EINVAL", what);
+}
+function pathOps(kernel, resolve, statOf, open) {
+  return {
+    stat: (path) => statOf("stat", path),
+    lstat: (path) => statOf("lstat", path),
+    exists: async (path) => await kernel.json({ op: "exists", path: resolve(path) }) === true,
+    readdir: async (path) => await kernel.json({ op: "readdir", path: resolve(path) }),
+    mkdir: async (path) => void await kernel.call({ op: "mkdir", path: resolve(path) }),
+    rm: async (path) => void await kernel.call({ op: "rm", path: resolve(path) }),
+    unlink: async (path) => void await kernel.call({ op: "unlink", path: resolve(path) }),
+    rename: async (from, to) => void await kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
+    symlink: async (target, path) => void await kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
+    readlink: async (path) => String(await kernel.json({ op: "readlink", path: resolve(path) })),
+    async readFile(path) {
+      const abs = resolve(path);
+      await kernel.call({ op: "fd-path-flush", path: abs });
+      return kernel.bytes({ op: "read", path: abs });
+    },
+    async writeFile(path, data) {
+      const file = await open(path, { write: true, create: true, truncate: true });
+      try {
+        await file.write(0, typeof data === "string" ? encoder2.encode(data) : data);
+      } finally {
+        await file.close();
+      }
+    }
+  };
+}
+var JsExit, CHUNK, MAX_IO, O_WRONLY5, O_RDWR6, O_APPEND3, encoder2;
+var init_js_context = __esm({
+  "src/process/js/js-context.ts"() {
+    "use strict";
+    init_signals();
+    init_sync_fs_wire();
+    init_js_kernel();
+    JsExit = class extends Error {
+      status;
+      constructor(status2) {
+        super(`exit ${status2}`);
+        this.name = "JsExit";
+        this.status = status2;
+      }
+    };
+    CHUNK = 64 * 1024;
+    MAX_IO = 1024 * 1024;
+    O_WRONLY5 = 1;
+    O_RDWR6 = 2;
+    O_APPEND3 = 1024;
+    encoder2 = new TextEncoder();
+  }
+});
+
+// src/process/js/lockdown.ts
+function chain(target) {
+  const out = [];
+  for (let at = target; at && at !== Object.prototype; ) {
+    out.push(at);
+    at = Object.getPrototypeOf(at);
+  }
+  return out;
+}
+function hide(target, names) {
+  for (const name of names) {
+    const holders = chain(target);
+    for (const holder of holders) {
+      if (Object.getOwnPropertyDescriptor(holder, name)?.configurable) {
+        Reflect.deleteProperty(holder, name);
+      }
+    }
+    const kept = holders.slice(1).some((holder) => Object.hasOwn(holder, name));
+    const defined = Reflect.defineProperty(target, name, {
+      value: void 0,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    if (kept || !defined && Reflect.get(target, name) !== void 0) {
+      throw new Error(`slicc-kernel: cannot withhold ${name} from a JS program`);
+    }
+  }
+}
+function lockdown(scope2 = globalThis) {
+  hide(scope2, BLOCKED_GLOBALS);
+  const navigator = scope2.navigator;
+  if (navigator && typeof navigator === "object") hide(navigator, BLOCKED_NAVIGATOR);
+}
+var BLOCKED_GLOBALS, BLOCKED_NAVIGATOR;
+var init_lockdown = __esm({
+  "src/process/js/lockdown.ts"() {
+    "use strict";
+    BLOCKED_GLOBALS = [
+      "fetch",
+      "XMLHttpRequest",
+      "WebSocket",
+      "WebSocketStream",
+      "WebTransport",
+      "EventSource",
+      "importScripts",
+      "indexedDB",
+      "caches",
+      "cookieStore",
+      "Worker",
+      "SharedWorker",
+      "BroadcastChannel",
+      "postMessage",
+      "close"
+    ];
+    BLOCKED_NAVIGATOR = ["storage", "locks", "serviceWorker"];
+  }
+});
+
+// src/process/js/js-runtime.ts
+var js_runtime_exports = {};
+__export(js_runtime_exports, {
+  mainOf: () => mainOf,
+  runJsProcess: () => runJsProcess,
+  trapStrays: () => trapStrays
+});
+function trapStrays(scope2, fail) {
+  if (typeof scope2.process?.on === "function") {
+    scope2.process.on("unhandledRejection", fail);
+    scope2.process.on("uncaughtException", fail);
+    return;
+  }
+  scope2.addEventListener?.("unhandledrejection", (event) => {
+    event.preventDefault();
+    fail(event.reason);
+  });
+  scope2.addEventListener?.("error", (event) => {
+    event.preventDefault();
+    fail(event.error);
+  });
+}
+async function settledStrays() {
+  for (let turn = 0; turn < 2; turn++) await new Promise((resolve) => setTimeout(resolve, 0));
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function statusOf(value2) {
+  return typeof value2 === "number" && Number.isInteger(value2) ? value2 & 255 : 0;
+}
+function mainOf(module) {
+  const main = typeof module.default === "function" ? module.default : module.main;
+  return typeof main === "function" ? main : void 0;
+}
+async function runJsProcess(init, port, deps = {}) {
+  const transport = createAsyncSabTransport(init.sab, port, deps.waitAsync);
+  let resolveExit;
+  const exit = new Promise((resolve) => resolveExit = resolve);
+  let exitedWith;
+  const exited = (status3) => {
+    exitedWith ??= status3;
+    resolveExit(status3);
+  };
+  let failing;
+  const fail = (err) => {
+    if (err instanceof JsExit) return;
+    failing ??= say(message(err)).then(() => exited(1));
+  };
+  const kernel = new JsKernel({
+    sab: init.sab,
+    transport,
+    onError: fail,
+    waitAsync: deps.waitAsync
+  });
+  void kernel.watchStops();
+  const id = identityOf(await kernel.json({ op: "proc-identity" }), init);
+  kernel.pid = id.pid;
+  const { ctx, drain: drain2 } = createContext({
+    kernel,
+    argv: [init.argv0, ...init.args],
+    env: init.env,
+    pid: id.pid,
+    ppid: id.ppid,
+    cwd: init.cwd,
+    exit: (status3) => exited(statusOf(status3))
+  });
+  const say = (text) => ctx.write(2, `${init.argv0}: ${text}
+`).catch(() => void 0);
+  let main;
+  trapStrays(deps.scope ?? globalThis, fail);
+  try {
+    (deps.lockdown ?? lockdown)();
+    main = mainOf(await (deps.load ?? importSource)(init.program.glue));
+  } catch (err) {
+    await say(message(err));
+    return NOT_RUNNABLE;
+  }
+  if (!main) {
+    await say(`${init.program.path} exports no main function`);
+    return NOT_RUNNABLE;
+  }
+  const program = main;
+  const ran = Promise.resolve().then(() => program(ctx)).then(statusOf, async (err) => {
+    if (err instanceof JsExit) return err.status;
+    await say(message(err));
+    return 1;
+  });
+  const status2 = await Promise.race([ran, exit]);
+  await drain2();
+  await settledStrays();
+  await failing;
+  if (exitedWith !== void 0) return exitedWith;
+  return status2;
+}
+var NOT_RUNNABLE;
+var init_js_runtime = __esm({
+  "src/process/js/js-runtime.ts"() {
+    "use strict";
+    init_wasi_imports();
+    init_async_sab();
+    init_js_context();
+    init_js_kernel();
+    init_lockdown();
+    NOT_RUNNABLE = 126;
+  }
+});
+
 // src/process/process-entry.ts
 init_protocol();
 init_process_runtime();
 var loadWasi = () => Promise.resolve().then(() => (init_wasi_runtime(), wasi_runtime_exports));
-function processEntry(port, run = runWasmProcess, wasi = loadWasi) {
+var loadJs = () => Promise.resolve().then(() => (init_js_runtime(), js_runtime_exports));
+function started(init, port, run, wasi, js) {
+  if (init.program?.abi === "js") {
+    const jsInit = init;
+    return js().then((m) => m.runJsProcess(jsInit, port));
+  }
+  const wasmInit = init;
+  if (wasmInit.program?.abi === "wasi") return wasi().then((m) => m.runWasiProcess(wasmInit, port));
+  return run(wasmInit, port);
+}
+function processEntry(port, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
   const failed2 = (err) => port.postMessage({
     type: WASM_PROCESS_ERROR,
     message: err instanceof Error ? err.stack ?? err.message : String(err)
@@ -7783,9 +8498,7 @@ function processEntry(port, run = runWasmProcess, wasi = loadWasi) {
       return;
     }
     if (type !== WASM_PROCESS_INIT) return;
-    const init = data;
-    const started = init.program?.abi === "wasi" ? wasi().then((m) => m.runWasiProcess(init, port)) : run(init, port);
-    started.then(
+    started(data, port, run, wasi, js).then(
       (code2) => port.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
       failed2
     );
@@ -7794,6 +8507,7 @@ function processEntry(port, run = runWasmProcess, wasi = loadWasi) {
 
 // src/process-worker.ts
 var scope = globalThis;
-var onMessage = processEntry({ postMessage: (message) => scope.postMessage(message) });
+var post = scope.postMessage.bind(scope);
+var onMessage = processEntry({ postMessage: (message2) => post(message2) });
 scope.addEventListener("message", (event) => onMessage(event.data));
 //# sourceMappingURL=process-worker.js.map