@ai-ecoverse/slicc-kernel 1.182.0 → 1.183.0

package/dist/index.js

@@ -326,11 +326,120 @@ function clipboardAnswerer(port, hook) {
   };
 }
 
-// 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 fresh2(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 = fresh2(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 fresh3(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 };
@@ -369,7 +478,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 };
@@ -404,7 +513,7 @@ function embedderAnswerer(port, hookFor) {
         post({ id, done: true });
         return;
       }
-      const bytes = fresh2(got.value);
+      const bytes = fresh3(got.value);
       post({ id, chunk: bytes }, [bytes.buffer]);
     } catch (err) {
       fail(id, err);
@@ -591,6 +700,9 @@ function integrityAnswerer(port, lookup) {
   };
 }
 
+// src/fs/owners.ts
+var ROOT_OWNER = Object.freeze({ uid: 0, gid: 0 });
+
 // src/kernel/embedder.ts
 var EMBEDDER_HEADER_MAX = 64 * 1024;
 var EMBEDDER_WINDOW = 1024 * 1024;
@@ -610,6 +722,147 @@ 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 signalName(sig) {
+  const name = Object.entries(SIG).find(([, n]) => n === sig)?.[0];
+  return name === void 0 ? void 0 : `SIG${name}`;
+}
+function quiet2(p) {
+  p.catch(() => void 0);
+  return p;
+}
+function signalField(sig) {
+  const name = signalName(sig);
+  return name ? { signal: name } : {};
+}
+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 encoder3 = 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/loopback-names.ts
 var HOST_LOOPBACK = "host.slicc.internal";
 var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
@@ -928,69 +1181,6 @@ function transferOf(reply) {
   return [reply.bytes.buffer];
 }
 
-// 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 signalName(sig) {
-  const name = Object.entries(SIG).find(([, n]) => n === sig)?.[0];
-  return name === void 0 ? void 0 : `SIG${name}`;
-}
-function quiet(p) {
-  p.catch(() => void 0);
-  return p;
-}
-function signalField(sig) {
-  const name = signalName(sig);
-  return name ? { signal: name } : {};
-}
-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/sealed-relay.ts
 function textOf(err) {
   return err instanceof Error ? err.message : String(err);
@@ -1410,13 +1600,13 @@ function unsendableHeaders(url, names, hint) {
 function refuseUnsendable(url, out, hint) {
   if (!platformFilters()) return;
   const kept = new Request(PROBE, { headers: out }).headers;
-  const refused2 = [];
+  const refused3 = [];
   for (const name of new Set(out.keys())) {
     if (kept.has(name)) continue;
     if (TRANSPORT_OWN.has(name)) out.delete(name);
-    else refused2.push(name);
+    else refused3.push(name);
   }
-  if (refused2.length > 0) throw unsendableHeaders(url, refused2, hint);
+  if (refused3.length > 0) throw unsendableHeaders(url, refused3, hint);
 }
 function streamOf(body) {
   const it = body[Symbol.asyncIterator]();
@@ -1748,7 +1938,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 {
@@ -1839,7 +2029,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 = () => {
@@ -1890,7 +2080,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 } : {},
@@ -1958,7 +2148,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 17];
+var PROTOCOL = [1, 18];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -1985,8 +2175,8 @@ var KernelCallError = class extends Error {
     this.code = code;
   }
 };
-var encoder3 = new TextEncoder();
-var bytesOf2 = (data) => typeof data === "string" ? encoder3.encode(data) : data;
+var encoder4 = new TextEncoder();
+var bytesOf2 = (data) => typeof data === "string" ? encoder4.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -2072,8 +2262,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);
@@ -2278,7 +2470,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 } : {} };
@@ -2408,9 +2600,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(
@@ -2424,9 +2621,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;
   }
@@ -2438,11 +2635,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()));
@@ -2495,7 +2695,7 @@ function fsError2(code, message = code) {
 // src/mount/hostfs.ts
 var HOSTFS_IO = 16 * 1024 * 1024;
 var codeOf = (err) => err?.code;
-var errorOf2 = (err) => ({
+var errorOf3 = (err) => ({
   code: typeof codeOf(err) === "string" ? codeOf(err) : "EIO",
   message: err?.message ?? String(err)
 });
@@ -2545,7 +2745,7 @@ function serveHostfsPort(port, transport) {
         );
         send({ id, end: true });
       } catch (err) {
-        send({ id, error: errorOf2(err) });
+        send({ id, error: errorOf3(err) });
       } finally {
         watches.delete(id);
       }
@@ -2573,7 +2773,7 @@ function serveHostfsPort(port, transport) {
       if (op !== "call") throw fsError2("EINVAL", `unknown hostfs port op ${op}`);
       send({ id, result: await answer(data.name, data.body) });
     } catch (err) {
-      send({ id, error: errorOf2(err) });
+      send({ id, error: errorOf3(err) });
     }
   };
   const stop = () => {
@@ -2651,6 +2851,7 @@ async function initCall(options, transport) {
     ...hooks.fetch ? { sealedFetch: true } : {},
     ...options.clipboard ? { clipboard: true } : {},
     ...options.requests ? { requests: kindsOf(options.requests) } : {},
+    ...options.devices ? { devices: true } : {},
     ...options.approve ? { approve: true } : {},
     ...options.protect ? { protect: protectInit(options.protect) } : {},
     ...options.processMounts !== void 0 ? {
@@ -2826,24 +3027,44 @@ function checkOptions(options) {
   }
   if (options.timeZone !== void 0) systemTimeZone(options.timeZone);
   if (options.protect) protectInit(options.protect);
+  if (options.devices) devicesHook(options.devices);
   integrityOptions(options.protect?.integrity);
   facadesInit(options.facades);
   sealedHooks(options.sealed);
 }
 function connector(call, bound) {
   return async (connectOptions = {}) => {
-    const { requests, ...rest } = connectOptions;
-    if (requests === void 0 || requests === "attach")
-      return await call({
-        op: "connect",
-        ...rest,
-        ...requests ? { requests } : {}
-      });
-    const made = await call({ op: "connect", ...rest, requests: kindsOf(requests) });
-    bound.set(made.client, requests);
+    const { requests, devices, ...rest } = connectOptions;
+    const hook = devices !== void 0 && devices !== "attach" ? devicesHook(devices) : void 0;
+    const made = await call({
+      op: "connect",
+      ...rest,
+      ...requests === "attach" ? { requests } : requests ? { requests: kindsOf(requests) } : {},
+      ...devices === "attach" ? { devices } : hook ? { devices: true } : {}
+    });
+    if (!("client" in made)) return made;
+    if (requests && requests !== "attach") bound.requests.set(made.client, requests);
+    if (hook) bound.devices.set(made.client, hook);
+    bound.ports.set(made.port, made.client);
     return made.port;
   };
 }
+function clientApi(call, bound) {
+  return { connect: connector(call, bound), devices: kernelDevices(call, bound) };
+}
+function kernelDevices(call, bound) {
+  return {
+    async add({ client, ...spec }) {
+      const id = client === void 0 ? 0 : bound.ports.get(client);
+      if (id === void 0)
+        throw Object.assign(new Error("EINVAL: client is not a port from connect({ devices })"), {
+          code: "EINVAL"
+        });
+      const node = await call({ op: "devices-add", spec, client: id });
+      return { remove: async () => void await call({ op: "devices-remove", node }) };
+    }
+  };
+}
 function hookRelays(worker, options, bound) {
   const hooks = sealedHooks(options.sealed);
   const sealed = sealedAnswerer(worker, hooks.request, hooks.fetch);
@@ -2851,10 +3072,15 @@ function hookRelays(worker, options, bound) {
   const integrity = integrityAnswerer(worker, options.protect?.integrity?.lookup);
   const requests = embedderAnswerer(
     worker,
-    (client) => client === 0 ? options.requests : bound.get(client)
+    (client) => client === 0 ? options.requests : bound.requests.get(client)
+  );
+  const pageDevices = options.devices ? devicesHook(options.devices) : void 0;
+  const devices = devicesAnswerer(
+    worker,
+    (client) => client === 0 ? pageDevices : bound.devices.get(client)
   );
   return {
-    handle: (data) => sealed.handle(data) || clipboard.handle(data) || requests.handle(data) || integrity(data),
+    handle: (data) => sealed.handle(data) || clipboard.handle(data) || requests.handle(data) || devices.handle(data) || integrity(data),
     close: () => sealed.close()
   };
 }
@@ -2875,7 +3101,7 @@ async function sudoRunOn2(request, replay, { stdout, stderr, tag }) {
   );
   done.catch(started.reject);
   const pid = await started.promise;
-  return { pid, pgid: pid, ended: quiet(done.then(endedOf2)) };
+  return { pid, pgid: pid, ended: quiet2(done.then(endedOf2)) };
 }
 function endedOf2(r) {
   if (typeof r === "number") return { status: r };
@@ -2916,7 +3142,7 @@ async function createKernel(options = {}) {
   );
   const cdp = cdpBridge(options.cdp);
   const facades = facadeBridge(options.facades);
-  const bound = /* @__PURE__ */ new Map();
+  const bound = { requests: /* @__PURE__ */ new Map(), devices: /* @__PURE__ */ new Map(), ports: /* @__PURE__ */ new WeakMap() };
   const sealed = hookRelays(worker, options, bound);
   const approvals = approver(options.approve, worker);
   const fail = (error) => {
@@ -3010,8 +3236,8 @@ async function createKernel(options = {}) {
     const send = (action) => void call({ op: "terminal", terminal: id, ...action }).catch(() => void 0);
     return {
       pid,
-      exited: quiet(done.then((r) => endedOf2(r).status)),
-      ended: quiet(done.then(endedOf2)),
+      exited: quiet2(done.then((r) => endedOf2(r).status)),
+      ended: quiet2(done.then(endedOf2)),
       get onData() {
         return listener;
       },
@@ -3043,7 +3269,7 @@ async function createKernel(options = {}) {
     },
     openTerminal,
     sudoRun: (replay, sudoOptions = {}) => sudoRunOn2(request, replay, sudoOptions),
-    connect: connector(call, bound),
+    ...clientApi(call, bound),
     ...accounts(call, options.users === void 0 ? DEFAULT_USERS : options.users),
     setRoutes: async (routes) => void await call({ op: "routes", routes }),
     chmod: async (path, mode) => void await call({ op: "chmod", path, mode }),