@ai-ecoverse/slicc-kernel 1.12.0 → 1.14.0

package/README.md

@@ -119,7 +119,7 @@ A WASI preview1 or WASIX program (Zig, Rust, Go, wasi-libc or wasix-libc C) has
 { "slicc": { "abi": "wasi", "commands": { "rg": { "wasm": "bin/rg.wasm" }, "rustc": { "script": "bin/rustc" } } } }
 ```
 
-Entries may also set `argv0`, `args` and `env`, and a package can set `slicc.env` for all of its commands. In `env`, `${package}` is the package directory, `${cwd}` the process's working directory, and `${NAME}` the caller's `NAME` when the program starts (a default naming an unset variable is left out); a relative path that exists in the package (`lib/python3.14`, `./`) becomes that absolute path. The caller's environment wins over these defaults; a `null` value removes the variable for the command, after the caller's environment is applied (a host-networked program can drop the kernel's proxy settings that way), and a command entry can set a variable its package's `slicc.env` removes. The first package to define a name wins. `sh` runs bash as `sh` unless a package provides its own. The installed commands appear as executables in a virtual `/usr/bin` and `/bin`, so `PATH` lookups, `command -v` and `ls /usr/bin` work without writing anything to OPFS. A process can also run a program by the path of its glue when the `.wasm` sits next to it, a wasm module by its own path (as a WASI program), and a script through its `#!` line (including `#!/usr/bin/env name`). Executing any other file fails with `ENOEXEC`, so bash runs it as a shell script, as POSIX shells do. The catalog is re-read at the start of every `run`, so packages installed in between are picked up.
+Entries may also set `argv0`, `args` and `env`, and a package can set `slicc.env` for all of its commands. In `env`, `${package}` is the package directory, `${cwd}` the process's working directory, and `${NAME}` the caller's `NAME` when the program starts (a default naming an unset variable is left out); a relative path that exists in the package (`lib/python3.14`, `./`) becomes that absolute path. The caller's environment wins over these defaults; a `null` value removes the variable for the command, after the caller's environment is applied (a host-networked program can drop the kernel's proxy settings that way), and a command entry can set a variable its package's `slicc.env` removes. The first package to define a name wins. `sh` runs bash as `sh` unless a package provides its own. The installed commands appear as executables in a virtual `/usr/bin` and `/bin`, so `PATH` lookups, `command -v` and `ls /usr/bin` work without writing anything to OPFS. A process can also run a program by the path of its glue when the `.wasm` sits next to it, a wasm module by its own path (as a WASI program), and a script through its `#!` line (including `#!/usr/bin/env name`). Executing any other file fails with `ENOEXEC`, so bash runs it as a shell script, as POSIX shells do. Commands also come from pnpm's global directory. Every process gets `PNPM_HOME=/home/.local/share/pnpm`, unless the embedder sets its own, and has `$PNPM_HOME/bin` on `PATH`. The kernel scans each of pnpm's global install groups (`$PNPM_HOME/global/*/<group>/node_modules`) after `/node_modules`, which wins when both provide a command. The catalog is re-read whenever anything under either changes, so `pnpm add -g @ai-ecoverse/wasi-ripgrep` makes `rg` work in the same shell, and `pnpm remove -g` removes it again.
 
 ### WASI programs
 
@@ -179,6 +179,27 @@ The proxy answers `200` with `Content-Type: application/vnd.slicc.raw-fetch`: a
 
 Directories are renamed with `FileSystemHandle.move()` where available, else by copy and delete.
 
+### Mounts
+
+`kernel.mount({ type, source, target, options })` mounts a file system on an existing directory. Every process sees it, Emscripten and WASI alike, and so does every attached client. `kernel.umount(target)` unmounts it, and fails with `EBUSY` while a process has a file open under it. `kernel.mounts()` lists the table, as does `/proc/mounts`. The Node entry and attached clients have the same three calls (client protocol 1.2).
+
+- **Built in:** `tmpfs`, which lives in memory until unmounted.
+- **Package drivers:** a package declares a type in `"slicc": { "filesystems": { "<type>": { "module": "<file>" } } }`, and the kernel starts that module in a worker of its own for each mount. The module is a single self-contained file: it can't import bare specifiers.
+  - Its default export receives `{ fetch }`, the kernel's network transport. It returns `{ handlers, capabilities }`.
+  - The handlers are path-based: `getattr`, `readdir`, `open`/`read`/`write`/`release` on handles, `mkdir`, `rmdir`, `unlink`, `rename`, and optionally `symlink`, `readlink`, `setattr` and `statfs`.
+  - An optional `mount({ source, options })` handler validates the source.
+  - Errors carry a POSIX `code`.
+  - `@ai-ecoverse/slicc-kernel/driver` exports the types and `fsError`.
+- **Capabilities:** `readonly`, `symlinks`, `chmod`, `maxIo` (the largest read or write per message), `maxFile`, `listingStats`, and `attrTtl`/`entryTtl` (in ms, default 1000).
+- **Caching:** the kernel caches attributes and listings for those TTLs, and a driver can push `invalidate` for changes made outside. File contents are read whole when a program opens a file and written back when it closes it, which gives close-to-open consistency as NFS has.
+- **Rules on a mount:**
+  - a rename across mounts is `EXDEV`, so `mv` copies;
+  - `df` reports each mount from its driver's `statfs`;
+  - each mount has its own device number;
+  - without `chmod` support, `chmod` succeeds and changes nothing;
+  - a file over `maxFile` is `EFBIG`, and `options.maxfile` (`"2G"`, or `"0"` for none) changes that limit for one mount;
+  - a driver that crashes or doesn't answer within 30 s makes its mount's calls fail with `EIO`, and the mount is listed as `failed`.
+
 ### `/proc`
 
 Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `/proc/self/` has the same files for the process that reads them. They come from the kernel's process table when they are opened, so a terminal sees the processes of every client; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so is each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times, load and `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) are placeholders. Only Emscripten processes see this `/proc`.

package/dist/driver-worker.js

@@ -0,0 +1,574 @@
+// src/kernel/net/remote-transport.ts
+var TransportError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+var RemoteTransport = class {
+  traits;
+  port;
+  waiting = /* @__PURE__ */ new Map();
+  nextId = 0;
+  failure;
+  constructor(port, traits) {
+    this.port = port;
+    this.traits = traits;
+  }
+  receive(reply) {
+    const waiter = this.waiting.get(reply.nid);
+    if (!waiter) return;
+    this.waiting.delete(reply.nid);
+    if (reply.net === "error") {
+      waiter.reject(new TransportError(reply.message, reply.status, reply.code));
+    } else waiter.resolve(reply);
+  }
+  fail(error) {
+    this.failure = error;
+    for (const waiter of this.waiting.values()) waiter.reject(error);
+    this.waiting.clear();
+  }
+  ask(call) {
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      this.waiting.set(call.nid, { resolve, reject });
+      this.port.postMessage(call);
+    });
+  }
+  cancel(nid) {
+    const waiter = this.waiting.get(nid);
+    this.waiting.delete(nid);
+    waiter?.reject(new TransportError("the request was cancelled"));
+    this.port.postMessage({ net: "cancel", nid });
+  }
+  async fetch(request) {
+    const nid = ++this.nextId;
+    const { signal } = request;
+    signal.throwIfAborted();
+    let finished = false;
+    const abort = () => {
+      finished = true;
+      this.cancel(nid);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      signal.removeEventListener("abort", abort);
+    };
+    let head;
+    try {
+      head = await this.ask({
+        net: "fetch",
+        nid,
+        url: request.url,
+        method: request.method,
+        headers: request.headers,
+        ...request.body ? { body: request.body } : {}
+      });
+    } catch (e) {
+      finish();
+      throw e;
+    }
+    const { status, statusText, headers } = head;
+    const read = async () => {
+      if (finished) return void 0;
+      const reply = await this.ask({ net: "read", nid }).catch((e) => {
+        finish();
+        throw e;
+      });
+      if (reply.net === "chunk") return reply.bytes;
+      finish();
+      return void 0;
+    };
+    const cancel = async () => {
+      if (finished) return;
+      finish();
+      this.cancel(nid);
+    };
+    return {
+      status,
+      statusText,
+      headers,
+      cancel,
+      body: {
+        [Symbol.asyncIterator]: () => ({
+          next: async () => {
+            const bytes = await read();
+            return bytes ? { value: bytes, done: false } : { value: void 0, done: true };
+          },
+          return: async () => {
+            await cancel();
+            return { value: void 0, done: true };
+          }
+        })
+      }
+    };
+  }
+};
+
+// src/client/protocol.ts
+var PROTOCOL = [1, 2];
+function locksOf(scope = globalThis) {
+  const locks = scope.navigator?.locks;
+  return typeof locks?.request === "function" ? locks : void 0;
+}
+function versionError(theirs) {
+  const major = Array.isArray(theirs) ? theirs[0] : void 0;
+  if (major === PROTOCOL[0]) return void 0;
+  const named = typeof major === "number" ? `${major}.x` : "without a version";
+  return `slicc-kernel client protocol ${named} is not supported: this side speaks ${PROTOCOL.join(".")}`;
+}
+
+// src/client/attach.ts
+var KernelGoneError = class extends Error {
+  constructor(message = "the slicc-kernel this client was attached to is gone") {
+    super(message);
+    this.name = "KernelGoneError";
+  }
+};
+var KernelCallError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "KernelCallError";
+    this.code = code;
+  }
+};
+var encoder = new TextEncoder();
+var bytesOf = (data) => typeof data === "string" ? encoder.encode(data) : data;
+var UNAVAILABLE = {
+  manualRedirects: false,
+  encodedBodies: false,
+  maxRequestBody: 0,
+  unavailable: true
+};
+async function holdLock(locks) {
+  if (!locks) return { release() {
+  } };
+  const name = `slicc-kernel-client:${crypto.randomUUID()}`;
+  const granted = Promise.withResolvers();
+  const held = Promise.withResolvers();
+  void locks.request(name, () => {
+    granted.resolve();
+    return held.promise;
+  });
+  await granted.promise;
+  return { name, release: () => held.resolve() };
+}
+function concat(chunks) {
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+  let at = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, at);
+    at += chunk.length;
+  }
+  return out;
+}
+var Channel = class {
+  greeted = Promise.withResolvers();
+  ended = Promise.withResolvers();
+  remote;
+  failure;
+  pending = /* @__PURE__ */ new Map();
+  watching = /* @__PURE__ */ new Map();
+  protocol = PROTOCOL;
+  nextId = 0;
+  port;
+  release;
+  constructor(port, release) {
+    this.port = port;
+    this.release = release;
+    this.greeted.promise.catch(() => void 0);
+    port.addEventListener("message", (event) => this.receive(event.data));
+    port.addEventListener("close", () => this.end(new KernelGoneError()));
+    port.start?.();
+  }
+  post(message) {
+    if (!this.failure) this.port.postMessage(message);
+  }
+  end(error) {
+    if (this.failure) return;
+    this.failure = error;
+    this.greeted.reject(error);
+    this.remote?.fail(error);
+    for (const call of this.pending.values()) call.reject(error);
+    this.pending.clear();
+    this.release();
+    this.port.close?.();
+    this.ended.resolve(error);
+  }
+  request(call, handlers = {}) {
+    const id = ++this.nextId;
+    const { failure } = this;
+    if (failure) return { id, done: Promise.reject(failure) };
+    const done = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, ...handlers });
+      this.port.postMessage({ ...call, id });
+    });
+    return { id, done };
+  }
+  call(call) {
+    return this.request(call).done;
+  }
+  receive(data) {
+    if (data.watch !== void 0) {
+      this.watching.get(data.watch)?.(data.change);
+      return;
+    }
+    if (data.bye !== void 0) {
+      this.end(new KernelGoneError(data.bye));
+      return;
+    }
+    if (data.hello) {
+      this.greeted.resolve(data.hello);
+      return;
+    }
+    if (data.net !== void 0) {
+      this.remote?.receive(data);
+      return;
+    }
+    const reply = data;
+    const call = this.pending.get(reply.id);
+    if (!call) return;
+    if (reply.fd !== void 0) {
+      call.output?.(reply.fd, reply.bytes);
+      return;
+    }
+    if (reply.started !== void 0) {
+      call.started?.(reply.started);
+      return;
+    }
+    this.pending.delete(reply.id);
+    if (reply.error !== void 0) call.reject(new KernelCallError(reply.error, reply.code));
+    else call.resolve(reply.result);
+  }
+};
+async function spawnOn(channel, argv, opts) {
+  const { onStdout, onStderr, stdin, group: _, ...rest } = opts;
+  const started = Promise.withResolvers();
+  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf(stdin) } : {} };
+  const { done } = channel.request(
+    { op: "spawn", argv, options },
+    {
+      output: (fd, bytes) => (fd === 1 ? onStdout : onStderr)?.(bytes),
+      started: started.resolve
+    }
+  );
+  done.catch(started.reject);
+  const pid = await started.promise;
+  return {
+    pid,
+    pgid: pid,
+    exited: done,
+    signal: async (name = "SIGTERM") => void await channel.call({ op: "kill", pid: -pid, signal: name })
+  };
+}
+async function runOn(channel, argv, opts) {
+  const { onStdout, onStderr, ...rest } = opts;
+  const chunks = { 1: [], 2: [] };
+  const live = { 1: new TextDecoder(), 2: new TextDecoder() };
+  const tee = (fd, on) => (bytes) => {
+    chunks[fd].push(bytes);
+    on?.(live[fd].decode(bytes, { stream: true }));
+  };
+  const child = await spawnOn(channel, argv, {
+    ...rest,
+    onStdout: tee(1, onStdout),
+    onStderr: tee(2, onStderr)
+  });
+  const status = await child.exited;
+  const text = (fd) => new TextDecoder().decode(concat(chunks[fd]));
+  return { pid: child.pid, status, stdout: text(1), stderr: text(2) };
+}
+async function terminalOn(channel, argv, opts) {
+  const { onData, ...options } = opts;
+  let listener = onData ?? null;
+  const backlog = [];
+  const started = Promise.withResolvers();
+  const { id, done } = channel.request(
+    { op: "open-terminal", argv, options },
+    {
+      output: (_fd, bytes) => listener ? listener(bytes) : backlog.push(bytes),
+      started: started.resolve
+    }
+  );
+  done.catch(started.reject);
+  const pid = await started.promise;
+  const send = (action) => void channel.call({ op: "terminal", terminal: id, ...action }).catch(() => void 0);
+  return {
+    pid,
+    exited: done,
+    get onData() {
+      return listener;
+    },
+    set onData(next) {
+      listener = next;
+      if (next) for (const bytes of backlog.splice(0)) next(bytes);
+    },
+    write: (data) => send({ action: "write", bytes: bytesOf(data) }),
+    resize: (cols, rows) => send({ action: "resize", cols, rows }),
+    signal: (name) => send({ action: "signal", signal: name }),
+    close: () => send({ action: "close" })
+  };
+}
+function fsOn(channel) {
+  const fs = (method, ...args) => channel.call({ op: "fs", method, args });
+  const done = async (method, ...args) => void await fs(method, ...args);
+  return {
+    readFile: (path) => fs("readFile", path),
+    readText: async (path) => new TextDecoder().decode(await fs("readFile", path)),
+    writeFile: (path, data) => done("writeFile", path, data),
+    stat: (path) => fs("stat", path),
+    lstat: (path) => fs("lstat", path),
+    readdir: (path) => fs("readdir", path),
+    mkdir: (path) => done("mkdir", path),
+    rm: (path, o = {}) => done("rm", path, o.force === true),
+    rename: (from, to) => done("rename", from, to),
+    realpath: (path) => fs("realpath", path),
+    symlink: (target, path) => done("symlink", target, path),
+    readlink: (path) => fs("readlink", path),
+    exists: (path) => fs("exists", path),
+    async watch(paths, options, onChange) {
+      if (channel.protocol[1] < 1) {
+        throw new KernelCallError(
+          `this kernel speaks protocol ${channel.protocol.join(".")}, which has no watch`,
+          "ENOSYS"
+        );
+      }
+      const { id, done: done2 } = channel.request({
+        op: "watch",
+        paths,
+        recursive: options.recursive === true
+      });
+      channel.watching.set(id, onChange);
+      try {
+        await done2;
+      } catch (error) {
+        channel.watching.delete(id);
+        throw error;
+      }
+      return {
+        close: () => {
+          if (!channel.watching.delete(id)) return;
+          void channel.call({ op: "unwatch", watch: id }).catch(() => void 0);
+        }
+      };
+    }
+  };
+}
+function since(channel, minor, what, run) {
+  if (channel.protocol[1] < minor) {
+    return Promise.reject(
+      new KernelCallError(
+        `this kernel speaks protocol ${channel.protocol.join(".")}, which has no ${what}`,
+        "ENOSYS"
+      )
+    );
+  }
+  return run();
+}
+async function greet(channel, lock, timeoutMs) {
+  channel.post({ hello: { protocol: PROTOCOL, ...lock ? { lock } : {} } });
+  const timer = setTimeout(
+    () => channel.end(
+      new KernelGoneError(`no slicc-kernel answered on this port within ${timeoutMs} ms`)
+    ),
+    timeoutMs
+  );
+  let hello;
+  try {
+    hello = await channel.greeted.promise;
+  } finally {
+    clearTimeout(timer);
+  }
+  const refused = hello.error ?? versionError(hello.protocol);
+  if (refused) {
+    const error = new Error(refused);
+    channel.end(error);
+    throw error;
+  }
+  return hello;
+}
+async function attachKernel(port, options = {}) {
+  const locks = options.locks === null ? void 0 : options.locks ?? locksOf();
+  const own = await holdLock(locks);
+  const channel = new Channel(port, own.release);
+  const hello = await greet(channel, own.name, options.timeoutMs ?? 1e4);
+  channel.protocol = hello.protocol;
+  if (hello.lock && locks) void locks.request(hello.lock, () => channel.end(new KernelGoneError()));
+  const transport = new RemoteTransport(
+    { postMessage: (call) => channel.post(call) },
+    hello.traits ?? UNAVAILABLE
+  );
+  channel.remote = transport;
+  return {
+    protocol: hello.protocol,
+    transport,
+    closed: channel.ended.promise,
+    spawn: (argv, opts = {}) => spawnOn(channel, argv, opts),
+    run: (argv, opts = {}) => runOn(channel, argv, opts),
+    openTerminal: (argv, opts = {}) => terminalOn(channel, argv, opts),
+    ps: () => channel.call({ op: "ps" }),
+    mount: (spec) => since(channel, 2, "mount", () => channel.call({ op: "mount", spec })),
+    umount: async (target) => void await since(channel, 2, "umount", () => channel.call({ op: "umount", target })),
+    mounts: () => since(channel, 2, "mounts", () => channel.call({ op: "mounts" })),
+    kill: async (pid, signal = "SIGTERM") => void await channel.call({ op: "kill", pid, signal }),
+    fetch: (req) => {
+      const { signal, ...rest } = req;
+      return transport.fetch({ ...rest, signal: signal ?? new AbortController().signal });
+    },
+    fs: fsOn(channel),
+    async close(o = {}) {
+      if (channel.failure) return;
+      await channel.call({ op: "detach", ...o.kill ? { kill: true } : {} }).catch(() => void 0);
+      channel.end(new KernelGoneError("this client is closed"));
+    }
+  };
+}
+
+// src/mount/protocol.ts
+var DRIVER_PROTOCOL = [1, 0];
+function driverVersionError(theirs) {
+  const major = Array.isArray(theirs) ? theirs[0] : void 0;
+  if (major === DRIVER_PROTOCOL[0]) return void 0;
+  const named = typeof major === "number" ? `${major}.x` : "without a version";
+  return `slicc-kernel driver protocol ${named} is not supported: this side speaks ${DRIVER_PROTOCOL.join(".")}`;
+}
+
+// src/mount/driver.ts
+function fsError(code, message = code) {
+  return Object.assign(new Error(message), { code });
+}
+async function dispatch(h, req) {
+  switch (req.op) {
+    case "getattr":
+      return h.getattr(req.path);
+    case "readdir":
+      return h.readdir(req.path);
+    case "open":
+      return h.open(req.path, {
+        write: req.write,
+        create: req.create,
+        truncate: req.truncate,
+        exclusive: req.exclusive
+      });
+    case "read":
+      return h.read(req.fh, req.offset, req.size);
+    case "write":
+      return h.write(req.fh, req.offset, req.bytes);
+    case "release":
+      return h.release(req.fh);
+    case "mkdir":
+      return h.mkdir(req.path);
+    case "rmdir":
+      return h.rmdir(req.path);
+    case "unlink":
+      return h.unlink(req.path);
+    case "rename":
+      return h.rename(req.from, req.to);
+    case "symlink":
+      if (!h.symlink) throw fsError("EPERM", "this file system has no symlinks");
+      return h.symlink(req.target, req.path);
+    case "readlink":
+      if (!h.readlink) throw fsError("EINVAL", `${req.path} is not a symlink`);
+      return h.readlink(req.path);
+    case "setattr":
+      return h.setattr?.(req.path, {
+        ...req.mode !== void 0 ? { mode: req.mode } : {},
+        ...req.mtime !== void 0 ? { mtime: req.mtime } : {}
+      });
+    case "statfs":
+      return h.statfs?.() ?? null;
+    default:
+      throw fsError("ENOSYS", `unknown driver op ${req.op}`);
+  }
+}
+function serveFilesystem(port, handlers, capabilities = {}) {
+  let open = false;
+  const reply = (message, transfer = []) => port.postMessage(message, transfer);
+  async function hello(message) {
+    const refused = driverVersionError(message.protocol);
+    if (refused) {
+      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused, errno: "EPROTO" } });
+      return;
+    }
+    try {
+      const refined = await handlers.mount?.(message.mount);
+      open = true;
+      reply({
+        hello: { protocol: DRIVER_PROTOCOL, capabilities: { ...capabilities, ...refined } }
+      });
+    } catch (err) {
+      const code = err?.code;
+      reply({
+        hello: {
+          protocol: DRIVER_PROTOCOL,
+          error: err instanceof Error ? err.message : String(err),
+          errno: typeof code === "string" ? code : "EIO"
+        }
+      });
+    }
+  }
+  port.addEventListener("message", (event) => {
+    const data = event.data;
+    if (data.hello) {
+      void hello(data.hello);
+      return;
+    }
+    if (!open) return;
+    dispatch(handlers, data).then(
+      (result) => {
+        if (result instanceof Uint8Array) {
+          const bytes = result.slice();
+          reply({ id: data.id, result: bytes }, [bytes.buffer]);
+        } else reply({ id: data.id, result: result ?? null });
+      },
+      (err) => {
+        const code = err?.code;
+        reply({
+          id: data.id,
+          errno: typeof code === "string" ? code : "EIO",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    );
+  });
+  port.start?.();
+  return { invalidate: (paths) => reply({ invalidate: paths }) };
+}
+
+// src/mount/host.ts
+async function hostDriver(start, load) {
+  try {
+    const factory = (await load(start.code)).default;
+    if (typeof factory !== "function") {
+      throw new Error("a slicc file system module must export a default function");
+    }
+    const client = await attachKernel(start.client, { locks: null });
+    const made = await factory({ fetch: (request) => client.fetch(request) });
+    serveFilesystem(start.driver, made.handlers, made.capabilities ?? {});
+  } catch (err) {
+    start.driver.postMessage({
+      hello: {
+        protocol: DRIVER_PROTOCOL,
+        error: `the driver did not start: ${err instanceof Error ? err.message : String(err)}`,
+        errno: "EIO"
+      }
+    });
+  }
+}
+
+// src/driver-worker.ts
+addEventListener(
+  "message",
+  (event) => void hostDriver(
+    event.data,
+    (code) => import(URL.createObjectURL(new Blob([code], { type: "text/javascript" })))
+  ),
+  { once: true }
+);
+//# sourceMappingURL=driver-worker.js.map