@ai-ecoverse/slicc-kernel 1.110.8 → 1.112.0

package/dist/kernel-worker.js

@@ -4674,6 +4674,7 @@ var LOCAL_ONLY = new Routes();
 var LoopbackNet = class {
   bound = /* @__PURE__ */ new Map();
   dgrams = /* @__PURE__ */ new Map();
+  unixDgrams = /* @__PURE__ */ new Map();
   activators = /* @__PURE__ */ new Map();
   internal = /* @__PURE__ */ new Set();
   reserved = /* @__PURE__ */ new Set();
@@ -4699,6 +4700,18 @@ var LoopbackNet = class {
     this.dgrams.set(port, socket);
     return { ...addr, port };
   }
+  bindUnixDgram(socket, key) {
+    if (this.bound.has(key) || this.unixDgrams.has(key)) throw new KernelError("EADDRINUSE");
+    this.unixDgrams.set(key, socket);
+  }
+  releaseUnixDgram(key, socket) {
+    if (this.unixDgrams.get(key) === socket) this.unixDgrams.delete(key);
+  }
+  unixDgramAt(key) {
+    const socket = this.unixDgrams.get(key);
+    if (socket) return socket;
+    throw new KernelError(this.bound.has(key) ? "EPROTOTYPE" : "ECONNREFUSED");
+  }
   releaseDgram(addr, socket) {
     if (this.dgrams.get(addr.port) === socket) this.dgrams.delete(addr.port);
   }
@@ -4752,7 +4765,9 @@ var LoopbackNet = class {
     } else this.bindable(addr, kernel);
     const named = addr.family === "inet" && addr.port === 0 ? { ...addr, port: this.ephemeral() } : addr;
     const key = keyOf(named, name2);
-    if (this.bound.has(key) && !name2) throw new KernelError("EADDRINUSE");
+    if (this.bound.has(key) && !name2 || this.unixDgrams.has(key)) {
+      throw new KernelError("EADDRINUSE");
+    }
     this.bound.set(key, socket);
     socket.named = name2;
     return named;
@@ -4766,6 +4781,7 @@ var LoopbackNet = class {
       throw new KernelError("ENETUNREACH");
     }
     const key = keyOf(addr, name2);
+    if (this.unixDgrams.has(key)) throw new KernelError("EPROTOTYPE");
     if (!this.bound.has(key)) this.activators.get(key)?.();
     const socket = this.bound.get(key);
     if (!socket?.listening) throw new KernelError("ECONNREFUSED");
@@ -6176,7 +6192,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.110.8" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.112.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -11764,470 +11780,84 @@ var ProcessClocks = class {
   }
 };
 
-// src/kernel/net/uplink.ts
-function carriesUdp(uplink) {
-  return uplink.traits.udp === true && typeof uplink.udp === "function";
-}
-function answerOf(result) {
-  const answer = Array.isArray(result) ? { addresses: result } : result;
-  const addresses = Array.isArray(answer?.addresses) ? answer.addresses.filter((a) => typeof a === "string") : [];
-  return {
-    addresses,
-    ...typeof answer?.ttl === "number" && answer.ttl >= 0 ? { ttl: answer.ttl } : {}
-  };
-}
-var NEVER = new Routes(true);
-var RemoteUplink = class {
-  traits;
-  routes;
-  port;
-  waiting = /* @__PURE__ */ new Map();
-  nextId = 0;
-  constructor(port, traits, routes) {
-    this.port = port;
-    this.traits = traits;
-    this.routes = routes;
-  }
-  receive(reply) {
-    const waiter = this.waiting.get(reply.uid);
-    if (!waiter) return;
-    this.waiting.delete(reply.uid);
-    if (reply.uplink === "error") {
-      waiter.reject(Object.assign(new Error(reply.message), { code: reply.code }));
-    } else waiter.resolve(reply);
-  }
-  ask(call, signal, transfer) {
-    const waiter = Promise.withResolvers();
-    this.waiting.set(call.uid, waiter);
-    const abort = () => {
-      this.waiting.delete(call.uid);
-      this.port.postMessage({ uplink: "cancel", uid: call.uid });
-      waiter.reject(signal?.reason);
-    };
-    signal?.addEventListener("abort", abort, { once: true });
-    const settled = () => signal?.removeEventListener("abort", abort);
-    waiter.promise.then(settled, settled);
-    this.port.postMessage(call, transfer);
-    return waiter.promise;
+// src/fs/pages.ts
+var PAGE = 64 * 1024;
+var READAHEAD = 1024 * 1024;
+var CLEAN_LIMIT = 4 * 1024 * 1024;
+var WRITEBACK = 8 * 1024 * 1024;
+var RUN = 1024 * 1024;
+var Pages = class {
+  length;
+  stored;
+  shrink;
+  pages = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  free = [];
+  pinned = false;
+  constructor(size) {
+    this.length = size;
+    this.stored = size;
   }
-  async resolve(name2, family, signal) {
-    const reply = await this.ask(
-      { uplink: "resolve", uid: ++this.nextId, name: name2, family },
-      signal
-    );
-    return answerOf(reply);
+  get dirtyBytes() {
+    return this.dirty.size * PAGE;
   }
-  async dial(req) {
-    req.signal.throwIfAborted();
-    const { host, port } = req;
-    const opened2 = await this.ask(
-      { uplink: "dial", uid: ++this.nextId, host, port },
-      req.signal
-    );
-    const { cid, localAddr, remoteAddr } = opened2;
-    return {
-      localAddr,
-      remoteAddr,
-      read: async () => {
-        const got = await this.ask({
-          uplink: "read",
-          uid: ++this.nextId,
-          cid
-        });
-        return got.bytes;
-      },
-      write: async (bytes) => {
-        const copy = bytes.slice();
-        const call = { uplink: "write", uid: ++this.nextId, cid, bytes: copy };
-        const done4 = await this.ask(call, void 0, [
-          copy.buffer
-        ]);
-        return done4.n;
-      },
-      closeWrite: () => this.port.postMessage({ uplink: "close-write", cid }),
-      close: () => this.port.postMessage({ uplink: "close", cid })
-    };
+  get changed() {
+    return this.dirty.size > 0 || this.shrink !== void 0 || this.length !== this.stored;
   }
-  async udp(req) {
-    req.signal.throwIfAborted();
-    const opened2 = await this.ask(
-      { uplink: "udp-open", uid: ++this.nextId, family: req.family },
-      req.signal
-    );
-    const { cid, localAddr } = opened2;
-    const recv = () => this.ask({
-      uplink: "udp-recv",
-      uid: ++this.nextId,
-      cid
-    });
-    return {
-      localAddr,
-      send: async (bytes, host, port) => {
-        const copy = bytes.slice();
-        const call = {
-          uplink: "udp-send",
-          uid: ++this.nextId,
-          cid,
-          bytes: copy,
-          host,
-          port
-        };
-        await this.ask(call, void 0, [copy.buffer]);
-      },
-      messages: {
-        [Symbol.asyncIterator]: async function* () {
-          for (; ; ) {
-            const got = await recv();
-            if (!got.message) return;
-            yield got.message;
-          }
-        }
-      },
-      close: () => this.port.postMessage({ uplink: "udp-close", cid })
-    };
+  missing(at, length2) {
+    this.evict();
+    const end = Math.min(this.stored, at + length2, this.length);
+    const runs = [];
+    for (let page = Math.floor(at / PAGE); page * PAGE < end; page++) {
+      if (this.pages.has(page)) continue;
+      const last2 = runs[runs.length - 1];
+      if (last2 && last2[0] + last2[1] === page * PAGE) last2[1] += PAGE;
+      else runs.push([page * PAGE, PAGE]);
+    }
+    const last = runs[runs.length - 1];
+    if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
+    return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
   }
-};
-
-// src/kernel/dgram.ts
-var DGRAM_QUEUE_BYTES = 256 * 1024;
-var DGRAM_QUEUE_COUNT = 512;
-var DGRAM_SEND_ROOM = 256 * 1024;
-var MAX_DATAGRAM_V4 = 65507;
-var MAX_DATAGRAM_V6 = 65527;
-var SOL_SOCKET2 = 1;
-var IPPROTO_IP = 0;
-var SO_TYPE2 = 3;
-var SO_ERROR2 = 4;
-var SO_BROADCAST = 6;
-var SO_SNDBUF2 = 7;
-var SO_RCVBUF2 = 8;
-var SO_DOMAIN2 = 39;
-var SOCK_DGRAM = 2;
-var AF_INET2 = 2;
-var IP_MULTICAST_FIRST = 32;
-var IP_MULTICAST_LAST = 36;
-var SEND_ERRORS = ["ENETUNREACH", "EHOSTUNREACH", "EACCES", "EMSGSIZE"];
-var UNREACHABLE = ["EACCES", "ENETUNREACH", "EHOSTUNREACH"];
-function sendError(e) {
-  if (e instanceof KernelError) return e;
-  const code = e?.code;
-  return new KernelError(SEND_ERRORS.find((errno2) => errno2 === code) ?? "EHOSTUNREACH");
-}
-function sameAddr(a, b) {
-  return a.port === b.port && canonicalHost(a.host) === canonicalHost(b.host);
-}
-function familyOf(host) {
-  return host.includes(":") ? 6 : 4;
-}
-var KernelDgram = class {
-  local;
-  peer;
-  net;
-  queue = [];
-  queued = 0;
-  pending;
-  closed = false;
-  sending = 0;
-  changes = new Changes();
-  options = /* @__PURE__ */ new Map();
-  uplinks = /* @__PURE__ */ new Map();
-  stop = new AbortController();
-  constructor(net) {
-    this.net = net;
+  partial(at, length2) {
+    if (length2 === 0) return [];
+    this.evict();
+    const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
+    const runs = [];
+    for (const page of edges) {
+      const start2 = page * PAGE;
+      const covered = at <= start2 && at + length2 >= start2 + PAGE;
+      if (covered || this.pages.has(page) || start2 >= this.stored) continue;
+      runs.push([start2, Math.min(PAGE, this.stored - start2)]);
+    }
+    return runs;
   }
-  bind(addr) {
-    if (this.local) throw new KernelError("EINVAL");
-    this.local = this.net.bindDgram(this, addr);
+  fill(start2, bytes) {
+    for (let at = 0; at < bytes.length; at += PAGE) {
+      const page = (start2 + at) / PAGE;
+      if (this.pages.has(page)) continue;
+      const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
+      const fresh2 = this.take(part.length);
+      fresh2.set(part);
+      this.pages.set(page, fresh2);
+    }
   }
-  bound() {
-    this.local ??= this.net.bindDgram(this, { family: "inet", host: "0.0.0.0", port: 0 });
-    return this.local;
+  read(at, length2) {
+    const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length2) - at));
+    this.readInto(at, out);
+    return out;
   }
-  connectTo(addr) {
-    if (addr.family !== "inet") throw new KernelError("EAFNOSUPPORT");
-    this.route(addr.host);
-    this.bound();
-    this.peer = { family: "inet", host: canonicalHost(addr.host), port: addr.port };
-    this.pending = void 0;
-    this.drain((d) => sameAddr(d.from, addr));
-  }
-  drain(keep2) {
-    const kept = this.queue.filter(keep2);
-    this.queue.splice(0, this.queue.length, ...kept);
-    this.queued = kept.reduce((sum, d) => sum + d.bytes.length, 0);
-  }
-  route(host) {
-    const where = this.net.destination(host);
-    if (where === "loopback" || where === "uplink") return where;
-    throw new KernelError("ENETUNREACH");
-  }
-  takeError() {
-    const pending = this.pending;
-    this.pending = void 0;
-    return pending;
-  }
-  async send(bytes, to) {
-    if (this.closed) throw new KernelError("EBADF");
-    const pending = this.takeError();
-    if (pending) throw new KernelError(pending);
-    const target = to ?? this.peer;
-    if (!target) throw new KernelError("EDESTADDRREQ");
-    if (target.family !== "inet") throw new KernelError("EAFNOSUPPORT");
-    const max = familyOf(target.host) === 6 ? MAX_DATAGRAM_V6 : MAX_DATAGRAM_V4;
-    if (bytes.length > max) throw new KernelError("EMSGSIZE");
-    const where = this.route(target.host);
-    const local = this.bound();
-    if (where === "uplink") return this.sendUp(bytes, target);
-    const from = {
-      family: "inet",
-      host: local.host === "0.0.0.0" ? "127.0.0.1" : local.host,
-      port: local.port
-    };
-    const delivered = this.net.deliverDgram(target.port, { bytes: bytes.slice(), from });
-    if (!delivered && this.peer && sameAddr(this.peer, target)) {
-      this.pending = "ECONNREFUSED";
-      this.changes.wake();
-    }
-    return bytes.length;
-  }
-  async sendUp(bytes, to) {
-    const uplink = this.net.uplinkFor(to.host)?.uplink;
-    if (!uplink || !carriesUdp(uplink)) throw new KernelError("ENETUNREACH");
-    this.sending += bytes.length;
-    try {
-      const socket = await this.uplinkSocket(uplink, familyOf(to.host));
-      await socket.send(bytes.slice(), to.host, to.port);
-    } catch (e) {
-      throw sendError(e);
-    } finally {
-      this.sending -= bytes.length;
-      this.changes.wake();
-    }
-    return bytes.length;
-  }
-  uplinkSocket(uplink, family) {
-    const known = this.uplinks.get(family);
-    if (known !== void 0) return known;
-    const opening2 = Promise.resolve().then(() => {
-      if (!uplink.udp) throw new KernelError("ENETUNREACH");
-      return uplink.udp({ family, signal: this.stop.signal });
-    });
-    this.uplinks.set(family, opening2);
-    opening2.then(
-      (socket) => {
-        if (this.closed) {
-          socket.close();
-          return;
-        }
-        void this.pump(socket, family);
-      },
-      () => this.uplinks.delete(family)
-    );
-    return opening2;
-  }
-  async pump(socket, family) {
-    const iterate = async () => {
-      for await (const message3 of socket.messages) {
-        if (this.closed) return;
-        const from = { family: "inet", host: message3.host, port: message3.port };
-        if ("bytes" in message3) this.deliver({ bytes: message3.bytes, from });
-        else this.unreachable(message3.error, from);
-      }
-    };
-    await iterate().catch(() => void 0);
-    if (!this.closed) this.uplinks.delete(family);
-    socket.close();
-  }
-  unreachable(error, from) {
-    if (!this.peer || !sameAddr(this.peer, from)) return;
-    this.pending = UNREACHABLE.find((errno2) => errno2 === error) ?? "EHOSTUNREACH";
-    this.changes.wake();
-  }
-  deliver(datagram2) {
-    if (this.closed) return false;
-    if (this.peer && !sameAddr(this.peer, datagram2.from)) return true;
-    const full = this.queue.length >= DGRAM_QUEUE_COUNT || this.queued + datagram2.bytes.length > DGRAM_QUEUE_BYTES;
-    if (full) return true;
-    this.queue.push(datagram2);
-    this.queued += datagram2.bytes.length;
-    this.changes.wake();
-    return true;
-  }
-  async receive(max, peek, signal) {
-    for (; ; ) {
-      const pending = this.takeError();
-      if (pending) throw new KernelError(pending);
-      if (this.closed) throw new KernelError("EBADF");
-      const next3 = this.queue[0];
-      if (next3) {
-        if (!peek) {
-          this.queue.shift();
-          this.queued -= next3.bytes.length;
-          this.changes.wake();
-        }
-        const size = Math.max(0, max);
-        return {
-          bytes: next3.bytes.slice(0, size),
-          from: next3.from,
-          truncated: next3.bytes.length > size
-        };
-      }
-      await this.changes.wait(signal);
-    }
-  }
-  async read(max, signal) {
-    return (await this.receive(max, false, signal)).bytes;
-  }
-  async peek(max, signal) {
-    return (await this.receive(max, true, signal)).bytes;
-  }
-  write(bytes) {
-    return this.send(bytes);
-  }
-  poll() {
-    return {
-      readable: this.queue.length > 0 || this.pending !== void 0 || this.closed,
-      writable: this.sending < DGRAM_SEND_ROOM,
-      hangup: this.closed,
-      ...this.pending !== void 0 ? { error: true } : {}
-    };
-  }
-  changed(signal) {
-    return this.changes.wait(signal);
-  }
-  shutdown(how) {
-    if (!this.peer) throw new KernelError("ENOTCONN");
-    if (how < 0 || how > 2) throw new KernelError("EINVAL");
-  }
-  getOption(level, name2) {
-    if (level === SOL_SOCKET2) {
-      switch (name2) {
-        case SO_TYPE2:
-          return SOCK_DGRAM;
-        case SO_ERROR2: {
-          const pending = this.takeError();
-          return pending ? wasiErrno(pending) : 0;
-        }
-        case SO_DOMAIN2:
-          return AF_INET2;
-        case SO_BROADCAST:
-          return 0;
-        case SO_SNDBUF2:
-          return this.options.get(`${level}:${name2}`) ?? DGRAM_SEND_ROOM;
-        case SO_RCVBUF2:
-          return this.options.get(`${level}:${name2}`) ?? DGRAM_QUEUE_BYTES;
-      }
-    }
-    if (level === IPPROTO_IP && name2 >= IP_MULTICAST_FIRST && name2 <= IP_MULTICAST_LAST) {
-      throw new KernelError("ENOPROTOOPT");
-    }
-    return this.options.get(`${level}:${name2}`) ?? 0;
-  }
-  setOption(level, name2, value2) {
-    if (level === SOL_SOCKET2 && name2 === SO_BROADCAST && value2 !== 0) {
-      throw new KernelError("EOPNOTSUPP");
-    }
-    if (level === IPPROTO_IP && name2 >= IP_MULTICAST_FIRST && name2 <= IP_MULTICAST_LAST) {
-      throw new KernelError("ENOPROTOOPT");
-    }
-    this.options.set(`${level}:${name2}`, value2);
-  }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.stop.abort();
-    for (const opening2 of this.uplinks.values()) {
-      opening2.then(
-        (socket) => socket.close(),
-        () => void 0
-      );
-    }
-    this.uplinks.clear();
-    if (this.local) this.net.releaseDgram(this.local, this);
-    this.queue.length = 0;
-    this.queued = 0;
-    this.changes.wake();
-  }
-};
-
-// src/fs/pages.ts
-var PAGE = 64 * 1024;
-var READAHEAD = 1024 * 1024;
-var CLEAN_LIMIT = 4 * 1024 * 1024;
-var WRITEBACK = 8 * 1024 * 1024;
-var RUN = 1024 * 1024;
-var Pages = class {
-  length;
-  stored;
-  shrink;
-  pages = /* @__PURE__ */ new Map();
-  dirty = /* @__PURE__ */ new Set();
-  free = [];
-  pinned = false;
-  constructor(size) {
-    this.length = size;
-    this.stored = size;
-  }
-  get dirtyBytes() {
-    return this.dirty.size * PAGE;
-  }
-  get changed() {
-    return this.dirty.size > 0 || this.shrink !== void 0 || this.length !== this.stored;
-  }
-  missing(at, length2) {
-    this.evict();
-    const end = Math.min(this.stored, at + length2, this.length);
-    const runs = [];
-    for (let page = Math.floor(at / PAGE); page * PAGE < end; page++) {
-      if (this.pages.has(page)) continue;
-      const last2 = runs[runs.length - 1];
-      if (last2 && last2[0] + last2[1] === page * PAGE) last2[1] += PAGE;
-      else runs.push([page * PAGE, PAGE]);
-    }
-    const last = runs[runs.length - 1];
-    if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
-    return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
-  }
-  partial(at, length2) {
-    if (length2 === 0) return [];
-    this.evict();
-    const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
-    const runs = [];
-    for (const page of edges) {
-      const start2 = page * PAGE;
-      const covered = at <= start2 && at + length2 >= start2 + PAGE;
-      if (covered || this.pages.has(page) || start2 >= this.stored) continue;
-      runs.push([start2, Math.min(PAGE, this.stored - start2)]);
-    }
-    return runs;
-  }
-  fill(start2, bytes) {
-    for (let at = 0; at < bytes.length; at += PAGE) {
-      const page = (start2 + at) / PAGE;
-      if (this.pages.has(page)) continue;
-      const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
-      const fresh2 = this.take(part.length);
-      fresh2.set(part);
-      this.pages.set(page, fresh2);
-    }
-  }
-  read(at, length2) {
-    const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length2) - at));
-    this.readInto(at, out);
-    return out;
-  }
-  readInto(at, out) {
-    const end = Math.min(this.length, at + out.length);
-    for (let pos = at; pos < end; ) {
-      const page = Math.floor(pos / PAGE);
-      const from = pos - page * PAGE;
-      const n = Math.min(PAGE - from, end - pos);
-      const bytes = this.pages.get(page);
-      if (bytes) out.set(bytes.subarray(from, from + n), pos - at);
-      else out.fill(0, pos - at, pos - at + n);
-      pos += n;
-    }
-    return Math.max(0, end - at);
+  readInto(at, out) {
+    const end = Math.min(this.length, at + out.length);
+    for (let pos = at; pos < end; ) {
+      const page = Math.floor(pos / PAGE);
+      const from = pos - page * PAGE;
+      const n = Math.min(PAGE - from, end - pos);
+      const bytes = this.pages.get(page);
+      if (bytes) out.set(bytes.subarray(from, from + n), pos - at);
+      else out.fill(0, pos - at, pos - at + n);
+      pos += n;
+    }
+    return Math.max(0, end - at);
   }
   write(at, bytes) {
     for (let done4 = 0; done4 < bytes.length; ) {
@@ -14929,6 +14559,130 @@ var HttpHandles = class {
   }
 };
 
+// src/kernel/net/uplink.ts
+function carriesUdp(uplink) {
+  return uplink.traits.udp === true && typeof uplink.udp === "function";
+}
+function answerOf(result) {
+  const answer = Array.isArray(result) ? { addresses: result } : result;
+  const addresses = Array.isArray(answer?.addresses) ? answer.addresses.filter((a) => typeof a === "string") : [];
+  return {
+    addresses,
+    ...typeof answer?.ttl === "number" && answer.ttl >= 0 ? { ttl: answer.ttl } : {}
+  };
+}
+var NEVER = new Routes(true);
+var RemoteUplink = class {
+  traits;
+  routes;
+  port;
+  waiting = /* @__PURE__ */ new Map();
+  nextId = 0;
+  constructor(port, traits, routes) {
+    this.port = port;
+    this.traits = traits;
+    this.routes = routes;
+  }
+  receive(reply) {
+    const waiter = this.waiting.get(reply.uid);
+    if (!waiter) return;
+    this.waiting.delete(reply.uid);
+    if (reply.uplink === "error") {
+      waiter.reject(Object.assign(new Error(reply.message), { code: reply.code }));
+    } else waiter.resolve(reply);
+  }
+  ask(call, signal, transfer) {
+    const waiter = Promise.withResolvers();
+    this.waiting.set(call.uid, waiter);
+    const abort = () => {
+      this.waiting.delete(call.uid);
+      this.port.postMessage({ uplink: "cancel", uid: call.uid });
+      waiter.reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    const settled = () => signal?.removeEventListener("abort", abort);
+    waiter.promise.then(settled, settled);
+    this.port.postMessage(call, transfer);
+    return waiter.promise;
+  }
+  async resolve(name2, family, signal) {
+    const reply = await this.ask(
+      { uplink: "resolve", uid: ++this.nextId, name: name2, family },
+      signal
+    );
+    return answerOf(reply);
+  }
+  async dial(req) {
+    req.signal.throwIfAborted();
+    const { host, port } = req;
+    const opened2 = await this.ask(
+      { uplink: "dial", uid: ++this.nextId, host, port },
+      req.signal
+    );
+    const { cid, localAddr, remoteAddr } = opened2;
+    return {
+      localAddr,
+      remoteAddr,
+      read: async () => {
+        const got = await this.ask({
+          uplink: "read",
+          uid: ++this.nextId,
+          cid
+        });
+        return got.bytes;
+      },
+      write: async (bytes) => {
+        const copy = bytes.slice();
+        const call = { uplink: "write", uid: ++this.nextId, cid, bytes: copy };
+        const done4 = await this.ask(call, void 0, [
+          copy.buffer
+        ]);
+        return done4.n;
+      },
+      closeWrite: () => this.port.postMessage({ uplink: "close-write", cid }),
+      close: () => this.port.postMessage({ uplink: "close", cid })
+    };
+  }
+  async udp(req) {
+    req.signal.throwIfAborted();
+    const opened2 = await this.ask(
+      { uplink: "udp-open", uid: ++this.nextId, family: req.family },
+      req.signal
+    );
+    const { cid, localAddr } = opened2;
+    const recv = () => this.ask({
+      uplink: "udp-recv",
+      uid: ++this.nextId,
+      cid
+    });
+    return {
+      localAddr,
+      send: async (bytes, host, port) => {
+        const copy = bytes.slice();
+        const call = {
+          uplink: "udp-send",
+          uid: ++this.nextId,
+          cid,
+          bytes: copy,
+          host,
+          port
+        };
+        await this.ask(call, void 0, [copy.buffer]);
+      },
+      messages: {
+        [Symbol.asyncIterator]: async function* () {
+          for (; ; ) {
+            const got = await recv();
+            if (!got.message) return;
+            yield got.message;
+          }
+        }
+      },
+      close: () => this.port.postMessage({ uplink: "udp-close", cid })
+    };
+  }
+};
+
 // src/kernel/net/resolver.ts
 var RESOLVE_TTL_MAX = 60;
 var RESOLVE_TIMEOUT_MS = 1e4;
@@ -14952,6 +14706,7 @@ var Resolver = class {
   own;
   cache = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
+  hosts;
   constructor(options) {
     this.uplink = options.uplink;
     this.routes = options.routes;
@@ -14959,6 +14714,14 @@ var Resolver = class {
     this.timeoutMs = options.timeoutMs ?? RESOLVE_TIMEOUT_MS;
     this.log = options.log ?? ((message3) => console.warn(message3));
     this.own = ownNames(options.hostname ?? DEFAULT_HOSTNAME);
+    this.hosts = options.hosts;
+  }
+  async fromFile(key, family) {
+    const listed = (await this.hosts?.().catch(() => void 0))?.get(key);
+    if (!listed) return void 0;
+    const v4 = listed.filter((a) => ipv4Bytes(a) !== void 0);
+    const v6 = listed.filter((a) => ipv4Bytes(a) === void 0);
+    return family === 4 ? v4 : family === 6 ? v6 : [...v4, ...v6];
   }
   async resolve(name2, family, blocking) {
     const key = name2.toLowerCase().replace(/\.$/, "");
@@ -14967,6 +14730,8 @@ var Resolver = class {
       const v4 = family !== 6 && local ? [local] : [];
       return family === 4 ? v4 : [...v4, key];
     }
+    const listed = this.hosts ? await this.fromFile(key, family) : void 0;
+    if (listed?.length) return listed;
     if (local) {
       const six = loopbackName(key, this.own) ? ["::1"] : [];
       return family === 6 ? six : family === 4 ? [local] : [local, ...six];
@@ -15848,78 +15613,340 @@ async function semSyscall(req, proc) {
         )
       );
     }
-    case "sem-close":
-      handles.close(req.handle);
-      return ok2();
-    case "sem-unlink": {
-      const name2 = semName(req.name);
-      table.unlink(name2, unlinks(name2));
-      return ok2();
+    case "sem-close":
+      handles.close(req.handle);
+      return ok2();
+    case "sem-unlink": {
+      const name2 = semName(req.name);
+      table.unlink(name2, unlinks(name2));
+      return ok2();
+    }
+    case "sem-post":
+      handles.get(req.handle).post();
+      return ok2();
+    case "sem-getvalue":
+      return ok2(handles.get(req.handle).value);
+    case "sem-wait": {
+      const sem = handles.get(req.handle);
+      if (sem.take()) return ok2();
+      if (req.how === "try") throw new KernelError("EAGAIN");
+      if (req.how === "timed" && req.timeoutMs === 0) throw new KernelError("ETIMEDOUT");
+      const got = await sem.wait(proc.blocking(), req.how === "block" ? -1 : req.timeoutMs);
+      if (!got) throw new KernelError("ETIMEDOUT");
+      return ok2();
+    }
+  }
+}
+
+// src/kernel/socket-nodes.ts
+function filePath(addr) {
+  if (addr.family !== "unix" || addr.path === "" || addr.path.startsWith("\0")) return void 0;
+  return normalizePath(addr.path);
+}
+function nameOf(st) {
+  return { key: `${st.dev ?? 0}:${st.ino}`, typed: st.isSocket === true };
+}
+function codeOf3(err) {
+  return err?.code;
+}
+function socketNames(deps) {
+  const { fs } = deps;
+  return {
+    async make(path) {
+      const g = deps.guard();
+      if (g) await inParent(g, "bind", path);
+      const owner = deps.owner();
+      try {
+        await deps.create(path, owner);
+      } catch (err) {
+        if (codeOf3(err) === "EEXIST") throw new KernelError("EADDRINUSE");
+        throw err;
+      }
+      const remove = () => fs.rm(path, { file: true }).catch(() => void 0);
+      try {
+        if (!deps.owners && owner.mode !== void 0) await fs.chmod(path, owner.mode);
+        return { ...nameOf(await fs.lstat(path)), remove };
+      } catch (err) {
+        await remove();
+        throw err;
+      }
+    },
+    async find(path) {
+      const g = deps.guard();
+      if (g) await need(g, "connect", path, W_OK, { directory: false });
+      return nameOf(await fs.stat(path));
+    }
+  };
+}
+
+// src/kernel/dgram.ts
+var DGRAM_QUEUE_BYTES = 256 * 1024;
+var DGRAM_QUEUE_COUNT = 512;
+var DGRAM_SEND_ROOM = 256 * 1024;
+var MAX_DATAGRAM_V4 = 65507;
+var MAX_DATAGRAM_V6 = 65527;
+var SOL_SOCKET2 = 1;
+var IPPROTO_IP = 0;
+var SO_TYPE2 = 3;
+var SO_ERROR2 = 4;
+var SO_BROADCAST = 6;
+var SO_SNDBUF2 = 7;
+var SO_RCVBUF2 = 8;
+var SO_DOMAIN2 = 39;
+var SOCK_DGRAM = 2;
+var AF_INET2 = 2;
+var IP_MULTICAST_FIRST = 32;
+var IP_MULTICAST_LAST = 36;
+var SEND_ERRORS = ["ENETUNREACH", "EHOSTUNREACH", "EACCES", "EMSGSIZE"];
+var UNREACHABLE = ["EACCES", "ENETUNREACH", "EHOSTUNREACH"];
+function sendError(e) {
+  if (e instanceof KernelError) return e;
+  const code = e?.code;
+  return new KernelError(SEND_ERRORS.find((errno2) => errno2 === code) ?? "EHOSTUNREACH");
+}
+function sameAddr(a, b) {
+  return a.port === b.port && canonicalHost(a.host) === canonicalHost(b.host);
+}
+function familyOf(host) {
+  return host.includes(":") ? 6 : 4;
+}
+var KernelDgram = class {
+  local;
+  peer;
+  net;
+  queue = [];
+  queued = 0;
+  pending;
+  closed = false;
+  sending = 0;
+  changes = new Changes();
+  options = /* @__PURE__ */ new Map();
+  uplinks = /* @__PURE__ */ new Map();
+  stop = new AbortController();
+  constructor(net) {
+    this.net = net;
+  }
+  bind(addr) {
+    if (this.local) throw new KernelError("EINVAL");
+    this.local = this.net.bindDgram(this, addr);
+  }
+  bound() {
+    this.local ??= this.net.bindDgram(this, { family: "inet", host: "0.0.0.0", port: 0 });
+    return this.local;
+  }
+  connectTo(addr) {
+    if (addr.family !== "inet") throw new KernelError("EAFNOSUPPORT");
+    this.route(addr.host);
+    this.bound();
+    this.peer = { family: "inet", host: canonicalHost(addr.host), port: addr.port };
+    this.pending = void 0;
+    this.drain((d) => sameAddr(d.from, addr));
+  }
+  drain(keep2) {
+    const kept = this.queue.filter(keep2);
+    this.queue.splice(0, this.queue.length, ...kept);
+    this.queued = kept.reduce((sum, d) => sum + d.bytes.length, 0);
+  }
+  route(host) {
+    const where = this.net.destination(host);
+    if (where === "loopback" || where === "uplink") return where;
+    throw new KernelError("ENETUNREACH");
+  }
+  takeError() {
+    const pending = this.pending;
+    this.pending = void 0;
+    return pending;
+  }
+  async send(bytes, to) {
+    if (this.closed) throw new KernelError("EBADF");
+    const pending = this.takeError();
+    if (pending) throw new KernelError(pending);
+    const target = to ?? this.peer;
+    if (!target) throw new KernelError("EDESTADDRREQ");
+    if (target.family !== "inet") throw new KernelError("EAFNOSUPPORT");
+    const max = familyOf(target.host) === 6 ? MAX_DATAGRAM_V6 : MAX_DATAGRAM_V4;
+    if (bytes.length > max) throw new KernelError("EMSGSIZE");
+    const where = this.route(target.host);
+    const local = this.bound();
+    if (where === "uplink") return this.sendUp(bytes, target);
+    const from = {
+      family: "inet",
+      host: local.host === "0.0.0.0" ? "127.0.0.1" : local.host,
+      port: local.port
+    };
+    const delivered = this.net.deliverDgram(target.port, { bytes: bytes.slice(), from });
+    if (!delivered && this.peer && sameAddr(this.peer, target)) {
+      this.pending = "ECONNREFUSED";
+      this.changes.wake();
+    }
+    return bytes.length;
+  }
+  async sendUp(bytes, to) {
+    const uplink = this.net.uplinkFor(to.host)?.uplink;
+    if (!uplink || !carriesUdp(uplink)) throw new KernelError("ENETUNREACH");
+    this.sending += bytes.length;
+    try {
+      const socket = await this.uplinkSocket(uplink, familyOf(to.host));
+      await socket.send(bytes.slice(), to.host, to.port);
+    } catch (e) {
+      throw sendError(e);
+    } finally {
+      this.sending -= bytes.length;
+      this.changes.wake();
+    }
+    return bytes.length;
+  }
+  uplinkSocket(uplink, family) {
+    const known = this.uplinks.get(family);
+    if (known !== void 0) return known;
+    const opening2 = Promise.resolve().then(() => {
+      if (!uplink.udp) throw new KernelError("ENETUNREACH");
+      return uplink.udp({ family, signal: this.stop.signal });
+    });
+    this.uplinks.set(family, opening2);
+    opening2.then(
+      (socket) => {
+        if (this.closed) {
+          socket.close();
+          return;
+        }
+        void this.pump(socket, family);
+      },
+      () => this.uplinks.delete(family)
+    );
+    return opening2;
+  }
+  async pump(socket, family) {
+    const iterate = async () => {
+      for await (const message3 of socket.messages) {
+        if (this.closed) return;
+        const from = { family: "inet", host: message3.host, port: message3.port };
+        if ("bytes" in message3) this.deliver({ bytes: message3.bytes, from });
+        else this.unreachable(message3.error, from);
+      }
+    };
+    await iterate().catch(() => void 0);
+    if (!this.closed) this.uplinks.delete(family);
+    socket.close();
+  }
+  unreachable(error, from) {
+    if (!this.peer || !sameAddr(this.peer, from)) return;
+    this.pending = UNREACHABLE.find((errno2) => errno2 === error) ?? "EHOSTUNREACH";
+    this.changes.wake();
+  }
+  deliver(datagram2) {
+    if (this.closed) return false;
+    if (this.peer && !sameAddr(this.peer, datagram2.from)) return true;
+    const full = this.queue.length >= DGRAM_QUEUE_COUNT || this.queued + datagram2.bytes.length > DGRAM_QUEUE_BYTES;
+    if (full) return true;
+    this.queue.push(datagram2);
+    this.queued += datagram2.bytes.length;
+    this.changes.wake();
+    return true;
+  }
+  async receive(max, peek, signal) {
+    for (; ; ) {
+      const pending = this.takeError();
+      if (pending) throw new KernelError(pending);
+      if (this.closed) throw new KernelError("EBADF");
+      const next3 = this.queue[0];
+      if (next3) {
+        if (!peek) {
+          this.queue.shift();
+          this.queued -= next3.bytes.length;
+          this.changes.wake();
+        }
+        const size = Math.max(0, max);
+        return {
+          bytes: next3.bytes.slice(0, size),
+          from: next3.from,
+          truncated: next3.bytes.length > size
+        };
+      }
+      await this.changes.wait(signal);
+    }
+  }
+  async read(max, signal) {
+    return (await this.receive(max, false, signal)).bytes;
+  }
+  async peek(max, signal) {
+    return (await this.receive(max, true, signal)).bytes;
+  }
+  write(bytes) {
+    return this.send(bytes);
+  }
+  poll() {
+    return {
+      readable: this.queue.length > 0 || this.pending !== void 0 || this.closed,
+      writable: this.sending < DGRAM_SEND_ROOM,
+      hangup: this.closed,
+      ...this.pending !== void 0 ? { error: true } : {}
+    };
+  }
+  changed(signal) {
+    return this.changes.wait(signal);
+  }
+  shutdown(how) {
+    if (!this.peer) throw new KernelError("ENOTCONN");
+    if (how < 0 || how > 2) throw new KernelError("EINVAL");
+  }
+  getOption(level, name2) {
+    if (level === SOL_SOCKET2) {
+      switch (name2) {
+        case SO_TYPE2:
+          return SOCK_DGRAM;
+        case SO_ERROR2: {
+          const pending = this.takeError();
+          return pending ? wasiErrno(pending) : 0;
+        }
+        case SO_DOMAIN2:
+          return AF_INET2;
+        case SO_BROADCAST:
+          return 0;
+        case SO_SNDBUF2:
+          return this.options.get(`${level}:${name2}`) ?? DGRAM_SEND_ROOM;
+        case SO_RCVBUF2:
+          return this.options.get(`${level}:${name2}`) ?? DGRAM_QUEUE_BYTES;
+      }
     }
-    case "sem-post":
-      handles.get(req.handle).post();
-      return ok2();
-    case "sem-getvalue":
-      return ok2(handles.get(req.handle).value);
-    case "sem-wait": {
-      const sem = handles.get(req.handle);
-      if (sem.take()) return ok2();
-      if (req.how === "try") throw new KernelError("EAGAIN");
-      if (req.how === "timed" && req.timeoutMs === 0) throw new KernelError("ETIMEDOUT");
-      const got = await sem.wait(proc.blocking(), req.how === "block" ? -1 : req.timeoutMs);
-      if (!got) throw new KernelError("ETIMEDOUT");
-      return ok2();
+    if (level === IPPROTO_IP && name2 >= IP_MULTICAST_FIRST && name2 <= IP_MULTICAST_LAST) {
+      throw new KernelError("ENOPROTOOPT");
     }
+    return this.options.get(`${level}:${name2}`) ?? 0;
   }
-}
-
-// src/kernel/socket-nodes.ts
-function filePath(addr) {
-  if (addr.family !== "unix" || addr.path === "" || addr.path.startsWith("\0")) return void 0;
-  return normalizePath(addr.path);
-}
-function nameOf(st) {
-  return { key: `${st.dev ?? 0}:${st.ino}`, typed: st.isSocket === true };
-}
-function codeOf3(err) {
-  return err?.code;
-}
-function socketNames(deps) {
-  const { fs } = deps;
-  return {
-    async make(path) {
-      const g = deps.guard();
-      if (g) await inParent(g, "bind", path);
-      const owner = deps.owner();
-      try {
-        await deps.create(path, owner);
-      } catch (err) {
-        if (codeOf3(err) === "EEXIST") throw new KernelError("EADDRINUSE");
-        throw err;
-      }
-      const remove = () => fs.rm(path, { file: true }).catch(() => void 0);
-      try {
-        if (!deps.owners && owner.mode !== void 0) await fs.chmod(path, owner.mode);
-        return { ...nameOf(await fs.lstat(path)), remove };
-      } catch (err) {
-        await remove();
-        throw err;
-      }
-    },
-    async find(path) {
-      const g = deps.guard();
-      if (g) await need(g, "connect", path, W_OK, { directory: false });
-      return nameOf(await fs.stat(path));
+  setOption(level, name2, value2) {
+    if (level === SOL_SOCKET2 && name2 === SO_BROADCAST && value2 !== 0) {
+      throw new KernelError("EOPNOTSUPP");
     }
-  };
-}
+    if (level === IPPROTO_IP && name2 >= IP_MULTICAST_FIRST && name2 <= IP_MULTICAST_LAST) {
+      throw new KernelError("ENOPROTOOPT");
+    }
+    this.options.set(`${level}:${name2}`, value2);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.stop.abort();
+    for (const opening2 of this.uplinks.values()) {
+      opening2.then(
+        (socket) => socket.close(),
+        () => void 0
+      );
+    }
+    this.uplinks.clear();
+    if (this.local) this.net.releaseDgram(this.local, this);
+    this.queue.length = 0;
+    this.queued = 0;
+    this.changes.wake();
+  }
+};
 
 // src/kernel/net/datagram-wire.ts
 function encodeReceived(got) {
   const host = new TextEncoder().encode(got.host);
   const out = new Uint8Array(4 + host.length + got.bytes.length);
   const view2 = new DataView(out.buffer);
-  view2.setUint8(0, got.truncated ? 1 : 0);
+  view2.setUint8(0, (got.truncated ? 1 : 0) | (got.unix ? 2 : 0));
   view2.setUint16(1, got.port);
   view2.setUint8(3, host.length);
   out.set(host, 4);
@@ -15927,6 +15954,152 @@ function encodeReceived(got) {
   return out;
 }
 
+// src/kernel/unix-dgram.ts
+var SOL_SOCKET3 = 1;
+var SO_TYPE3 = 3;
+var SO_ERROR3 = 4;
+var SO_SNDBUF3 = 7;
+var SO_RCVBUF3 = 8;
+var SO_DOMAIN3 = 39;
+var SOCK_DGRAM2 = 2;
+var AF_UNIX2 = 1;
+var UNNAMED = { family: "unix", path: "" };
+var UnixDgram = class _UnixDgram {
+  local;
+  peer;
+  key;
+  peerCred;
+  target;
+  net;
+  queue = [];
+  queued = 0;
+  closed = false;
+  changes = new Changes();
+  options = /* @__PURE__ */ new Map();
+  constructor(net) {
+    this.net = net;
+  }
+  static pair(net, cred) {
+    const a = new _UnixDgram(net);
+    const b = new _UnixDgram(net);
+    a.target = b;
+    b.target = a;
+    a.peer = b.peer = UNNAMED;
+    a.peerCred = b.peerCred = cred;
+    return [a, b];
+  }
+  bind(addr, key) {
+    if (addr.family !== "unix") throw new KernelError("EINVAL");
+    if (this.local) throw new KernelError("EINVAL");
+    if (addr.path === "") throw new KernelError("EINVAL");
+    this.net.bindUnixDgram(this, key);
+    this.local = { family: "unix", path: addr.path };
+    this.key = key;
+  }
+  connectTo(addr, target) {
+    this.target = target;
+    this.peer = addr;
+    const kept = this.queue.filter((d) => d.sender === target);
+    this.queue.splice(0, this.queue.length, ...kept);
+    this.queued = kept.reduce((sum, d) => sum + d.bytes.length, 0);
+  }
+  destination() {
+    if (!this.target) throw new KernelError("EDESTADDRREQ");
+    return this.target;
+  }
+  room(bytes) {
+    return this.closed || this.queue.length < DGRAM_QUEUE_COUNT && this.queued + bytes <= DGRAM_QUEUE_BYTES;
+  }
+  async send(bytes, to, nonblock, signal) {
+    if (this.closed) throw new KernelError("EBADF");
+    if (bytes.length > DGRAM_QUEUE_BYTES) throw new KernelError("EMSGSIZE");
+    if (to.target && to.target !== this) throw new KernelError("EPERM");
+    while (!to.room(bytes.length)) {
+      if (nonblock) throw new KernelError("EAGAIN");
+      await to.changed(signal);
+    }
+    if (to.closed) throw new KernelError("ECONNREFUSED");
+    to.queue.push({ bytes: bytes.slice(), from: this.local ?? UNNAMED, sender: this });
+    to.queued += bytes.length;
+    to.changes.wake();
+    return bytes.length;
+  }
+  async receive(max, peek, signal) {
+    for (; ; ) {
+      if (this.closed) throw new KernelError("EBADF");
+      const next3 = this.queue[0];
+      if (next3) {
+        if (!peek) {
+          this.queue.shift();
+          this.queued -= next3.bytes.length;
+          this.changes.wake();
+        }
+        const size = Math.max(0, max);
+        return {
+          bytes: next3.bytes.slice(0, size),
+          from: next3.from,
+          truncated: next3.bytes.length > size
+        };
+      }
+      await this.changes.wait(signal);
+    }
+  }
+  async read(max, signal) {
+    return (await this.receive(max, false, signal)).bytes;
+  }
+  async peek(max, signal) {
+    return (await this.receive(max, true, signal)).bytes;
+  }
+  write(bytes, signal) {
+    return this.send(bytes, this.destination(), false, signal);
+  }
+  poll() {
+    const target = this.target;
+    return {
+      readable: this.queue.length > 0 || this.closed,
+      writable: !target || target.room(1),
+      hangup: this.closed
+    };
+  }
+  changed(signal) {
+    return this.changes.wait(signal);
+  }
+  shutdown(how) {
+    if (!this.peer) throw new KernelError("ENOTCONN");
+    if (how < 0 || how > 2) throw new KernelError("EINVAL");
+  }
+  getOption(level, name2) {
+    if (level === SOL_SOCKET3) {
+      switch (name2) {
+        case SO_TYPE3:
+          return SOCK_DGRAM2;
+        case SO_ERROR3:
+          return 0;
+        case SO_DOMAIN3:
+          return AF_UNIX2;
+        case SO_SNDBUF3:
+        case SO_RCVBUF3:
+          return this.options.get(`${level}:${name2}`) ?? DGRAM_QUEUE_BYTES;
+      }
+    }
+    return this.options.get(`${level}:${name2}`) ?? 0;
+  }
+  setOption(level, name2, value2) {
+    this.options.set(`${level}:${name2}`, value2);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.key !== void 0) this.net.releaseUnixDgram(this.key, this);
+    this.queue.length = 0;
+    this.queued = 0;
+    this.changes.wake();
+  }
+};
+function isDatagram(file) {
+  return file instanceof KernelDgram || file instanceof UnixDgram;
+}
+
 // src/kernel/socket-syscalls.ts
 var SOCKET_OPS = [
   "sock-open",
@@ -15945,32 +16118,37 @@ var SOCKET_OPS = [
 ];
 function socketAt(fds, fd) {
   const file = anySocketAt(fds, fd);
-  if (file instanceof KernelDgram) throw new KernelError("EOPNOTSUPP");
+  if (!(file instanceof KernelSocket)) throw new KernelError("EOPNOTSUPP");
   return file;
 }
 function anySocketAt(fds, fd) {
   const file = fds.get(fd).file;
-  if (!(file instanceof KernelSocket) && !(file instanceof KernelDgram)) {
+  if (!(file instanceof KernelSocket) && !(file instanceof KernelDgram) && !(file instanceof UnixDgram)) {
     throw new KernelError("ENOTSOCK");
   }
   return file;
 }
 function dgramAt(fds, fd) {
   const file = anySocketAt(fds, fd);
-  if (!(file instanceof KernelDgram)) throw new KernelError("EOPNOTSUPP");
+  if (file instanceof KernelSocket) throw new KernelError("EOPNOTSUPP");
   return file;
 }
+async function unixTarget(proc, addr) {
+  if (addr.family !== "unix") throw new KernelError("EAFNOSUPPORT");
+  const path = filePath(addr);
+  const name2 = path !== void 0 ? await proc.names?.find(path) : void 0;
+  return proc.net.unixDgramAt(keyOf(path !== void 0 ? { family: "unix", path } : addr, name2));
+}
 var ok3 = (json5) => json5 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json5 };
 async function socketSyscall(req, proc) {
   const { fds, net } = proc;
   switch (req.op) {
     case "sock-open": {
-      if (req.type === "dgram" && req.domain !== "inet") throw new KernelError("EPROTONOSUPPORT");
-      const file = req.type === "dgram" ? new KernelDgram(net) : net.socket(req.domain);
+      const file = req.type !== "dgram" ? net.socket(req.domain) : req.domain === "unix" ? new UnixDgram(net) : new KernelDgram(net);
       return ok3(fds.install(new OpenFile(file), 3));
     }
     case "sock-pair": {
-      const [a, b] = KernelSocket.pair(net, req.domain, proc.cred?.());
+      const [a, b] = req.type === "dgram" && req.domain === "unix" ? UnixDgram.pair(net, proc.cred?.()) : KernelSocket.pair(net, req.domain, proc.cred?.());
       const first = fds.install(new OpenFile(a), 3);
       try {
         return ok3([first, fds.install(new OpenFile(b), 3)]);
@@ -15996,7 +16174,7 @@ async function socketSyscall(req, proc) {
       const socket = anySocketAt(fds, req.fd);
       const addr = req.peer ? socket.peer : socket.local;
       if (req.peer && !addr) throw new KernelError("ENOTCONN");
-      return ok3(addr ?? unnamed(socket instanceof KernelDgram ? "inet" : socket.domain));
+      return ok3(addr ?? unnamed(socket instanceof KernelSocket ? socket.domain : domainOf(socket)));
     }
     case "sock-getopt":
       return ok3(anySocketAt(fds, req.fd).getOption(req.level, req.name));
@@ -16018,6 +16196,10 @@ async function connect(req, proc) {
     target.connectTo(req.addr);
     return ok3();
   }
+  if (target instanceof UnixDgram) {
+    target.connectTo(req.addr, await unixTarget(proc, req.addr));
+    return ok3();
+  }
   const path = filePath(req.addr);
   const name2 = path !== void 0 ? await proc.names?.find(path) : void 0;
   const stamp = proc.net.facadeAt(req.addr) && await proc.stamp?.();
@@ -16029,8 +16211,23 @@ async function connect(req, proc) {
   if (dialing !== void 0) await interruptible2(dialing, proc.blocking());
   return ok3();
 }
+async function bindUnixDgram(proc, socket, addr) {
+  const path = filePath(addr);
+  if (path === void 0 || !proc.names) {
+    socket.bind(addr, keyOf(addr));
+    return;
+  }
+  const name2 = await proc.names.make(path);
+  try {
+    socket.bind({ family: "unix", path }, keyOf({ family: "unix", path }, name2));
+  } catch (err) {
+    await name2.remove();
+    throw err;
+  }
+}
 async function bind(proc, fd, addr) {
   const socket = anySocketAt(proc.fds, fd);
+  if (socket instanceof UnixDgram) return bindUnixDgram(proc, socket, addr);
   const path = filePath(addr);
   if (!(socket instanceof KernelSocket) || path === void 0 || !proc.names) {
     socket.bind(addr);
@@ -16047,6 +16244,7 @@ async function bind(proc, fd, addr) {
 }
 async function datagram(req, proc) {
   const dgram = dgramAt(proc.fds, req.fd);
+  if (dgram instanceof UnixDgram) return unixDatagram(req, dgram, proc);
   if (req.op === "sock-sendto") {
     if (req.nonblock && !pollFile(dgram).writable) throw new KernelError("EAGAIN");
     return ok3(await dgram.send(req.body, req.addr));
@@ -16057,6 +16255,24 @@ async function datagram(req, proc) {
   const { bytes, from, truncated } = got;
   return { ok: true, kind: "bytes", bytes: encodeReceived({ bytes, truncated, ...from }) };
 }
+async function unixDatagram(req, dgram, proc) {
+  if (req.op === "sock-sendto") {
+    const to = req.addr ? await unixTarget(proc, req.addr) : dgram.destination();
+    return ok3(await dgram.send(req.body, to, req.nonblock, proc.blocking()));
+  }
+  const ready2 = pollFile(dgram).readable;
+  if (req.nonblock && !ready2) throw new KernelError("EAGAIN");
+  const got = await dgram.receive(req.max, req.peek, ready2 ? void 0 : proc.blocking());
+  const { bytes, from, truncated } = got;
+  return {
+    ok: true,
+    kind: "bytes",
+    bytes: encodeReceived({ bytes, truncated, host: from.path, port: 0, unix: true })
+  };
+}
+function domainOf(socket) {
+  return socket instanceof UnixDgram ? "unix" : "inet";
+}
 function interruptible2(dialing, signal) {
   return new Promise((resolve2, reject) => {
     const abort = () => reject(new KernelError("EINTR"));
@@ -17874,8 +18090,8 @@ var WasmProcess = class {
     const terminal = (file.tty ?? file.pty?.slave)?.name;
     return {
       tty: file.tty !== void 0,
-      kind: file instanceof KernelSocket || file instanceof KernelDgram ? "socket" : kernelFdKind(file),
-      ...file instanceof KernelDgram ? { dgram: true } : {},
+      kind: file instanceof KernelSocket || isDatagram(file) ? "socket" : kernelFdKind(file),
+      ...isDatagram(file) ? { dgram: true } : {},
       ...file.heldMeta ? { meta: file.heldMeta } : {},
       ...flags2 !== void 0 ? { flags: flags2 } : {},
       ...this.fds.closesOnExec(fd) ? { cloexec: true } : {},
@@ -18311,7 +18527,7 @@ function inheritedFds(fds) {
   return fds.numbers().filter((fd) => fd > 2 && !fds.get(fd).file.held).map((fd) => {
     const open = fds.get(fd);
     const flags2 = fds.statusFlags(fd);
-    const kind = open.file instanceof KernelSocket || open.file instanceof KernelDgram ? "socket" : kernelFdKind(open.file);
+    const kind = open.file instanceof KernelSocket || isDatagram(open.file) ? "socket" : kernelFdKind(open.file);
     const meta = open.file.heldMeta;
     return {
       fd,
@@ -18917,6 +19133,43 @@ var JobTable = class {
   }
 };
 
+// src/kernel/net/hosts-file.ts
+var HOSTS_PATH = "/etc/hosts";
+function parseHosts(text) {
+  const table = /* @__PURE__ */ new Map();
+  for (const raw of text.split("\n")) {
+    const [address, ...names] = raw.replace(/#.*/, "").trim().split(/\s+/);
+    if (!address || names.length === 0) continue;
+    if (ipv4Bytes(address) === void 0 && ipv6Groups(address) === void 0) continue;
+    for (const name2 of names) {
+      const key = name2.toLowerCase().replace(/\.$/, "");
+      const known = table.get(key) ?? [];
+      if (!known.includes(address)) known.push(address);
+      table.set(key, known);
+    }
+  }
+  return table;
+}
+function hostsReader(fs, path = HOSTS_PATH) {
+  let stamp = "";
+  let table;
+  return async () => {
+    const st = await fs.stat(path).catch(() => void 0);
+    if (!st?.isFile) {
+      stamp = "";
+      table = void 0;
+      return void 0;
+    }
+    const now = `${st.ino}:${st.size}:${st.mtime.getTime()}`;
+    if (now === stamp && table) return table;
+    const text = await fs.readFile(path).catch(() => void 0);
+    if (text === void 0) return void 0;
+    stamp = now;
+    table = parseHosts(text);
+    return table;
+  };
+}
+
 // src/kernel/net/redirect-hops.ts
 var HELD_MS = 3e4;
 var HELD_MAX = 64;
@@ -22289,7 +22542,12 @@ var Launcher = class {
     this.uplink = options.uplink;
     this.routes = new Routes(options.uplink?.traits.ipv6 === true);
     if (options.uplink?.routes) this.routes.set(options.uplink.routes);
-    this.resolver = new Resolver({ uplink: options.uplink, routes: this.routes, hostname });
+    this.resolver = new Resolver({
+      uplink: options.uplink,
+      routes: this.routes,
+      hostname,
+      hosts: hostsReader(this.base)
+    });
     if (options.uplink) this.net.useUplink({ uplink: options.uplink, routes: this.routes });
     enableNetwork(this.net, {
       transport: this.transport,