@ai-ecoverse/slicc-kernel 1.181.0 → 1.183.0

package/dist/driver-worker.js

@@ -43,11 +43,120 @@ function serveCdpPort(port, hook, request, onDone) {
   };
 }
 
-// src/embedder-relay.ts
+// src/devices-relay.ts
+function quiet() {
+  return void 0;
+}
+function errorOf(err) {
+  const name = err?.name;
+  const message = err instanceof Error ? err.message : String(err);
+  return { name: typeof name === "string" ? name : "Error", message };
+}
 function fresh(bytes) {
   return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes : bytes.slice();
 }
-function errorOf(err) {
+function devicesAnswerer(port, hookFor) {
+  const locals = /* @__PURE__ */ new Map();
+  const post = (message, transfer = []) => port.postMessage({ devicesReply: message }, transfer);
+  const open = async (id, asked) => {
+    const local = { abort: new AbortController() };
+    locals.set(id, local);
+    try {
+      const hook = hookFor(asked.client);
+      if (!hook)
+        throw Object.assign(new Error("this page has no devices hook"), {
+          name: "NotSupportedError"
+        });
+      const streams = await hook.open({
+        path: asked.path,
+        flags: asked.flags,
+        stamp: asked.stamp,
+        signal: local.abort.signal
+      });
+      if (!locals.has(id)) {
+        await streams?.readable?.cancel("closed").catch(quiet);
+        await streams?.writable?.abort("closed").catch(quiet);
+        await Promise.resolve(streams?.control?.("close")).catch(quiet);
+        return;
+      }
+      local.streams = streams;
+      local.reader = streams.readable.getReader();
+      local.writer = streams.writable.getWriter();
+      post({ id, opened: true });
+    } catch (err) {
+      locals.delete(id);
+      post({ id, failed: errorOf(err) });
+    }
+  };
+  const pull = async (id, local) => {
+    try {
+      const got = await local.reader.read();
+      if (got.done) return post({ id, done: true });
+      const bytes = fresh(got.value);
+      post({ id, chunk: bytes }, [bytes.buffer]);
+    } catch (err) {
+      post({ id, readError: errorOf(err) });
+    }
+  };
+  const write = async (id, local, bytes, seq) => {
+    try {
+      await local.writer.write(bytes);
+      post({ id, wrote: seq });
+    } catch (err) {
+      post({ id, writeError: errorOf(err), seq });
+    }
+  };
+  const control = async (id, local, asked) => {
+    try {
+      await local.closing;
+      const value = await local.streams.control(asked.op, asked.args);
+      post({ id, answered: asked.seq, ...value !== void 0 ? { value } : {} });
+    } catch (err) {
+      post({ id, refused: asked.seq, error: errorOf(err) });
+    }
+    if (asked.op === "close") locals.delete(id);
+  };
+  const release = async (local, reason) => {
+    const { reader, writer } = local;
+    local.reader = void 0;
+    local.writer = void 0;
+    await reader?.cancel(reason).catch(quiet);
+    reader?.releaseLock();
+    await writer?.abort(reason).catch(quiet);
+    writer?.releaseLock();
+  };
+  const cancel = (id, local, reason) => {
+    local.abort.abort(new DOMException(reason, "AbortError"));
+    if (!local.streams) {
+      locals.delete(id);
+      return;
+    }
+    local.closing = Promise.resolve(local.closing).then(() => release(local, reason));
+  };
+  return {
+    handle(data) {
+      const message = data?.devices;
+      if (!message) return false;
+      if ("open" in message) {
+        void open(message.id, message.open);
+        return true;
+      }
+      const local = locals.get(message.id);
+      if (!local) return true;
+      if ("pull" in message) void pull(message.id, local);
+      else if ("write" in message) void write(message.id, local, message.write, message.seq);
+      else if ("control" in message) void control(message.id, local, message.control);
+      else cancel(message.id, local, message.cancel);
+      return true;
+    }
+  };
+}
+
+// src/embedder-relay.ts
+function fresh2(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes : bytes.slice();
+}
+function errorOf2(err) {
   const name = err?.name;
   const message = err instanceof Error ? err.message : String(err);
   return { name: typeof name === "string" ? name : "Error", message };
@@ -86,7 +195,7 @@ function embedderAnswerer(port, hookFor) {
   const post = (message, transfer = []) => port.postMessage({ embedderReply: message }, transfer);
   const fail = (id, err) => {
     running.delete(id);
-    post({ id, error: errorOf(err) });
+    post({ id, error: errorOf2(err) });
   };
   const start = async (ask) => {
     const state = { abort: new AbortController(), body: [], wakeBody: void 0 };
@@ -121,7 +230,7 @@ function embedderAnswerer(port, hookFor) {
         post({ id, done: true });
         return;
       }
-      const bytes = fresh(got.value);
+      const bytes = fresh2(got.value);
       post({ id, chunk: bytes }, [bytes.buffer]);
     } catch (err) {
       fail(id, err);
@@ -201,6 +310,9 @@ function serveFacadePort(port, hook, { name, stamp }, onDone) {
   };
 }
 
+// src/fs/owners.ts
+var ROOT_OWNER = Object.freeze({ uid: 0, gid: 0 });
+
 // src/kernel/pipe.ts
 var PIPE_CAPACITY = 64 * 1024;
 
@@ -223,6 +335,139 @@ function kindsOf(hook) {
   );
 }
 
+// src/kernel/serial-ioctl.ts
+var IOCTL = {
+  TCGETS: 21505,
+  TCSETS: 21506,
+  TCSETSW: 21507,
+  TCSETSF: 21508,
+  TCSBRK: 21513,
+  TCFLSH: 21515,
+  TIOCEXCL: 21516,
+  TIOCNXCL: 21517,
+  TIOCSCTTY: 21518,
+  TIOCGPGRP: 21519,
+  TIOCSPGRP: 21520,
+  TIOCOUTQ: 21521,
+  TIOCGWINSZ: 21523,
+  TIOCSWINSZ: 21524,
+  TIOCMGET: 21525,
+  TIOCMBIS: 21526,
+  TIOCMBIC: 21527,
+  TIOCMSET: 21528,
+  FIONREAD: 21531,
+  TIOCNOTTY: 21538,
+  TCSBRKP: 21541,
+  TIOCSBRK: 21543,
+  TIOCCBRK: 21544,
+  TCGETS2: 2150388778,
+  TCSETS2: 1076646955,
+  TCSETSW2: 1076646956,
+  TCSETSF2: 1076646957
+};
+var TERMIOS_GETS = /* @__PURE__ */ new Set([IOCTL.TCGETS, IOCTL.TCGETS2]);
+var TERMIOS_SETS = /* @__PURE__ */ new Set([
+  IOCTL.TCSETS,
+  IOCTL.TCSETSW,
+  IOCTL.TCSETSF,
+  IOCTL.TCSETS2,
+  IOCTL.TCSETSW2,
+  IOCTL.TCSETSF2
+]);
+var INT_OUT = /* @__PURE__ */ new Set([
+  IOCTL.TIOCMGET,
+  IOCTL.FIONREAD,
+  IOCTL.TIOCOUTQ
+]);
+var INT_IN = /* @__PURE__ */ new Set([
+  IOCTL.TIOCMBIS,
+  IOCTL.TIOCMBIC,
+  IOCTL.TIOCMSET
+]);
+var INT_ARG = /* @__PURE__ */ new Set([IOCTL.TCSBRK, IOCTL.TCSBRKP, IOCTL.TCFLSH]);
+var CSIZE = 48;
+var CSTOPB = 64;
+var PARENB = 256;
+var PARODD = 512;
+var CRTSCTS = 2147483648;
+function settingsOf(cflag, baudRate) {
+  return {
+    baudRate,
+    dataBits: 5 + ((cflag & CSIZE) >> 4),
+    parity: cflag & PARENB ? cflag & PARODD ? "odd" : "even" : "none",
+    stopBits: cflag & CSTOPB ? 2 : 1,
+    flowControl: cflag & CRTSCTS ? "hardware" : "none"
+  };
+}
+var SERIAL_CFLAG = 13 | 48 | 128 | 1024 | 2048;
+var SERIAL_LFLAG = 16 | 32 | 512 | 2048;
+
+// src/kernel/signals.ts
+var SIG = {
+  HUP: 1,
+  INT: 2,
+  QUIT: 3,
+  ILL: 4,
+  TRAP: 5,
+  ABRT: 6,
+  BUS: 7,
+  FPE: 8,
+  KILL: 9,
+  USR1: 10,
+  SEGV: 11,
+  USR2: 12,
+  PIPE: 13,
+  ALRM: 14,
+  TERM: 15,
+  STKFLT: 16,
+  CHLD: 17,
+  CONT: 18,
+  STOP: 19,
+  TSTP: 20,
+  TTIN: 21,
+  TTOU: 22,
+  URG: 23,
+  XCPU: 24,
+  XFSZ: 25,
+  VTALRM: 26,
+  PROF: 27,
+  WINCH: 28,
+  POLL: 29,
+  PWR: 30,
+  SYS: 31
+};
+var IGNORED_BY_DEFAULT = /* @__PURE__ */ new Set([SIG.CHLD, SIG.URG, SIG.WINCH]);
+var STOPPING = /* @__PURE__ */ new Set([SIG.STOP, SIG.TSTP, SIG.TTIN, SIG.TTOU]);
+function quiet2(p) {
+  p.catch(() => void 0);
+  return p;
+}
+var SIGNAL_BY_NAME = {
+  SIGINT: SIG.INT,
+  SIGTERM: SIG.TERM,
+  SIGKILL: SIG.KILL,
+  SIGSTOP: SIG.STOP,
+  SIGCONT: SIG.CONT
+};
+var SI = { USER: 0, QUEUE: -1, TIMER: -2, TKILL: -6, KERNEL: 128 };
+var KERNEL_SIGINFO = Object.freeze({
+  code: SI.KERNEL,
+  pid: 0,
+  uid: 0,
+  status: 0
+});
+
+// src/kernel/tty.ts
+var encoder = new TextEncoder();
+
+// src/kernel/devices.ts
+var HIGH_WATER = 64 * 1024;
+var DEFAULT_SETTINGS = settingsOf(SERIAL_CFLAG, 9600);
+function devicesHook(hook) {
+  if (typeof hook?.open !== "function") throw new TypeError("devices needs open");
+  return { open: (request) => hook.open(request) };
+}
+
 // src/kernel/net/transport.ts
 var FORBIDDEN_HEADER = "forbidden-header";
 
@@ -315,7 +560,7 @@ function honors(traits, redirect) {
   const raw = traits.manualRedirects === true && (hops === void 0 || hops === false);
   return redirect === "manual" && raw;
 }
-function refused(message) {
+function refused2(message) {
   return new TransportError(message, 502, void 0, "transport");
 }
 var RemoteTransport = class {
@@ -406,7 +651,7 @@ var RemoteTransport = class {
     const { signal, redirect } = request;
     signal.throwIfAborted();
     if (unfollowed(redirect) && !honors(this.traits, redirect)) {
-      throw refused(`this transport cannot honor redirect: ${redirect}`);
+      throw refused2(`this transport cannot honor redirect: ${redirect}`);
     }
     let finished = false;
     const abort = () => {
@@ -457,7 +702,7 @@ var RemoteTransport = class {
     };
     if (unfollowed(redirect) && (redirected || redirects?.length)) {
       await cancel();
-      throw refused(`this transport followed a redirect despite redirect: ${redirect}`);
+      throw refused2(`this transport followed a redirect despite redirect: ${redirect}`);
     }
     return {
       ...url !== void 0 ? { url } : {},
@@ -524,63 +769,8 @@ var RemoteTransport = class {
   }
 };
 
-// src/kernel/signals.ts
-var SIG = {
-  HUP: 1,
-  INT: 2,
-  QUIT: 3,
-  ILL: 4,
-  TRAP: 5,
-  ABRT: 6,
-  BUS: 7,
-  FPE: 8,
-  KILL: 9,
-  USR1: 10,
-  SEGV: 11,
-  USR2: 12,
-  PIPE: 13,
-  ALRM: 14,
-  TERM: 15,
-  STKFLT: 16,
-  CHLD: 17,
-  CONT: 18,
-  STOP: 19,
-  TSTP: 20,
-  TTIN: 21,
-  TTOU: 22,
-  URG: 23,
-  XCPU: 24,
-  XFSZ: 25,
-  VTALRM: 26,
-  PROF: 27,
-  WINCH: 28,
-  POLL: 29,
-  PWR: 30,
-  SYS: 31
-};
-var IGNORED_BY_DEFAULT = /* @__PURE__ */ new Set([SIG.CHLD, SIG.URG, SIG.WINCH]);
-var STOPPING = /* @__PURE__ */ new Set([SIG.STOP, SIG.TSTP, SIG.TTIN, SIG.TTOU]);
-function quiet(p) {
-  p.catch(() => void 0);
-  return p;
-}
-var SIGNAL_BY_NAME = {
-  SIGINT: SIG.INT,
-  SIGTERM: SIG.TERM,
-  SIGKILL: SIG.KILL,
-  SIGSTOP: SIG.STOP,
-  SIGCONT: SIG.CONT
-};
-var SI = { USER: 0, QUEUE: -1, TIMER: -2, TKILL: -6, KERNEL: 128 };
-var KERNEL_SIGINFO = Object.freeze({
-  code: SI.KERNEL,
-  pid: 0,
-  uid: 0,
-  status: 0
-});
-
 // src/bytes.ts
-function fresh2(bytes, start = 0, end = bytes.length) {
+function fresh3(bytes, start = 0, end = bytes.length) {
   return new Uint8Array(bytes.subarray(start, end));
 }
 
@@ -637,7 +827,7 @@ function dialStream(port, onClose) {
   const writable = new WritableStream({
     write(chunk) {
       if (closed) throw errorWithCode("EPIPE: the connection is closed");
-      const copy = fresh2(chunk);
+      const copy = fresh3(chunk);
       const acked = new Promise((resolve, reject) => acks.push({ resolve, reject }));
       port.postMessage(copy, [copy.buffer]);
       return acked;
@@ -658,7 +848,7 @@ function dialStream(port, onClose) {
 
 // src/client/loopback-fetch.ts
 var OWN_HEADERS = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding"]);
-var encoder = new TextEncoder();
+var encoder2 = new TextEncoder();
 var latin1 = new TextDecoder("latin1");
 var ByteSource = class {
   buffered = new Uint8Array(0);
@@ -676,7 +866,7 @@ var ByteSource = class {
     return true;
   }
   async until(marker) {
-    const needle = encoder.encode(marker);
+    const needle = encoder2.encode(marker);
     for (; ; ) {
       const at = indexOf(this.buffered, needle);
       if (at >= 0) return this.take(at + needle.length);
@@ -784,7 +974,7 @@ async function requestBytes(request) {
   });
   if (body) lines.push(`Content-Length: ${body.length}`);
   lines.push("Connection: close", "", "");
-  const head = encoder.encode(lines.join("\r\n"));
+  const head = encoder2.encode(lines.join("\r\n"));
   const out = new Uint8Array(head.length + (body?.length ?? 0));
   out.set(head);
   if (body) out.set(body, head.length);
@@ -824,7 +1014,7 @@ async function loopbackFetch(dial, input, options) {
 }
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 16];
+var PROTOCOL = [1, 18];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -851,8 +1041,8 @@ var KernelCallError = class extends Error {
     this.code = code;
   }
 };
-var encoder2 = new TextEncoder();
-var bytesOf2 = (data) => typeof data === "string" ? encoder2.encode(data) : data;
+var encoder3 = new TextEncoder();
+var bytesOf2 = (data) => typeof data === "string" ? encoder3.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -938,8 +1128,10 @@ var Channel = class {
     return this.request(call).done;
   }
   requests;
+  devices;
   receive(data) {
     if (this.requests?.handle(data)) return;
+    if (this.devices?.handle(data)) return;
     if (data.traits && data.id === void 0) {
       if (this.remote) this.remote.traits = data.traits;
       for (const listener of [...this.traitsListeners]) listener(data.traits);
@@ -1144,7 +1336,7 @@ async function sudoRunOn(channel, replay, { stdout, stderr, tag }) {
   return { pid, pgid: pid, ended: endedOf(done, () => endedBy) };
 }
 function endedOf(done, signal) {
-  return quiet(
+  return quiet2(
     done.then((status) => {
       const by = signal();
       return { status, ...by ? { signal: by } : {} };
@@ -1274,9 +1466,14 @@ function since(channel, minor, what, run) {
   }
   return run();
 }
-async function greet(channel, lock, timeoutMs, requests) {
+async function greet(channel, lock, timeoutMs, requests, devices) {
   channel.post({
-    hello: { protocol: PROTOCOL, ...lock ? { lock } : {}, ...requests ? { requests } : {} }
+    hello: {
+      protocol: PROTOCOL,
+      ...lock ? { lock } : {},
+      ...requests ? { requests } : {},
+      ...devices ? { devices: true } : {}
+    }
   });
   const timer = setTimeout(
     () => channel.end(
@@ -1290,9 +1487,9 @@ async function greet(channel, lock, timeoutMs, requests) {
   } finally {
     clearTimeout(timer);
   }
-  const refused2 = hello.error ?? versionError(hello.protocol);
-  if (refused2) {
-    const error = new Error(refused2);
+  const refused3 = hello.error ?? versionError(hello.protocol);
+  if (refused3) {
+    const error = new Error(refused3);
     channel.end(error);
     throw error;
   }
@@ -1304,11 +1501,14 @@ async function attachKernel(port, options = {}) {
   const channel = new Channel(port, own.release);
   const requests = options.requests;
   if (requests) channel.requests = embedderAnswerer(port, () => requests);
+  const devices = options.devices ? devicesHook(options.devices) : void 0;
+  if (devices) channel.devices = devicesAnswerer(port, () => devices);
   const hello = await greet(
     channel,
     own.name,
     options.timeoutMs ?? 1e4,
-    requests ? kindsOf(requests) : void 0
+    requests ? kindsOf(requests) : void 0,
+    devices !== void 0
   );
   channel.protocol = hello.protocol;
   if (hello.lock && locks) void locks.request(hello.lock, () => channel.end(new KernelGoneError()));
@@ -1374,7 +1574,7 @@ function ownerOf(req) {
 function withOwner(base, owner) {
   return owner ? { ...base, owner } : base;
 }
-function fsError(code, message = code) {
+function fsError2(code, message = code) {
   return Object.assign(new Error(message), { code });
 }
 var SET_ATTRS = ["mode", "mtime", "atime", "size", "uid", "gid"];
@@ -1418,32 +1618,32 @@ async function dispatch(h, req) {
     case "rename":
       return h.rename(req.from, req.to);
     case "link":
-      if (!h.link) throw fsError("EPERM", "this file system has no hard links");
+      if (!h.link) throw fsError2("EPERM", "this file system has no hard links");
       return h.link(req.from, req.to);
     case "mkfifo":
-      if (!h.mkfifo) throw fsError("EPERM", "this file system has no FIFOs");
+      if (!h.mkfifo) throw fsError2("EPERM", "this file system has no FIFOs");
       return ownerOf(req) ? h.mkfifo(req.path, ownerOf(req)) : h.mkfifo(req.path);
     case "symlink":
-      if (!h.symlink) throw fsError("EPERM", "this file system has no symlinks");
+      if (!h.symlink) throw fsError2("EPERM", "this file system has no symlinks");
       return ownerOf(req) ? h.symlink(req.target, req.path, ownerOf(req)) : h.symlink(req.target, req.path);
     case "readlink":
-      if (!h.readlink) throw fsError("EINVAL", `${req.path} is not a symlink`);
+      if (!h.readlink) throw fsError2("EINVAL", `${req.path} is not a symlink`);
       return h.readlink(req.path);
     case "setattr":
       return h.setattr?.(req.path, setAttrOf(req));
     case "statfs":
       return h.statfs?.() ?? null;
     default:
-      throw fsError("ENOSYS", `unknown driver op ${req.op}`);
+      throw fsError2("ENOSYS", `unknown driver op ${req.op}`);
   }
 }
 function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
   let open = false;
   const reply = (message, transfer = []) => port.postMessage(message, transfer);
   async function hello(message) {
-    const refused2 = driverVersionError(message.protocol);
-    if (refused2) {
-      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused2, errno: "EPROTO" } });
+    const refused3 = driverVersionError(message.protocol);
+    if (refused3) {
+      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused3, errno: "EPROTO" } });
       return;
     }
     try {
@@ -1474,7 +1674,7 @@ function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
       (result) => {
         if (result instanceof Uint8Array) {
           const whole = result.byteOffset === 0 && result.byteLength === result.buffer.byteLength;
-          const bytes = options.owned && whole ? result : fresh2(result);
+          const bytes = options.owned && whole ? result : fresh3(result);
           reply({ id: data.id, result: bytes }, [bytes.buffer]);
         } else reply({ id: data.id, result: result ?? null });
       },
@@ -1546,7 +1746,7 @@ var OPEN_SLOTS = [
   "Worker",
   "postMessage"
 ];
-function chain(target) {
+function chain2(target) {
   const out = [];
   for (let at = target; at && at !== Object.prototype; ) {
     out.push(at);
@@ -1556,7 +1756,7 @@ function chain(target) {
 }
 function hide(target, names) {
   for (const name of names) {
-    const holders = chain(target);
+    const holders = chain2(target);
     for (const holder of holders) Reflect.deleteProperty(holder, name);
     const kept = holders.slice(1).some((holder) => Object.hasOwn(holder, name));
     const defined = Reflect.defineProperty(target, name, {
@@ -1572,7 +1772,7 @@ function hide(target, names) {
 }
 function vacate(target, names) {
   for (const name of names) {
-    const holders = chain(target);
+    const holders = chain2(target);
     for (const holder of holders) Reflect.deleteProperty(holder, name);
     const kept = holders.slice(1).some((holder) => Object.hasOwn(holder, name));
     const opened = Reflect.defineProperty(target, name, {