@ai-ecoverse/slicc-kernel 1.110.7 → 1.111.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.7" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.111.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,594 +11780,208 @@ 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));
+  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);
   }
-  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();
+  write(at, bytes) {
+    for (let done4 = 0; done4 < bytes.length; ) {
+      const pos = at + done4;
+      const page = Math.floor(pos / PAGE);
+      const from = pos - page * PAGE;
+      const n = Math.min(PAGE - from, bytes.length - done4);
+      let target = this.pages.get(page);
+      if (!target) {
+        target = this.take(0);
+        this.pages.set(page, target);
+      }
+      target.set(bytes.subarray(done4, done4 + n), from);
+      this.dirty.add(page);
+      done4 += n;
     }
-    return bytes.length;
+    this.length = Math.max(this.length, at + 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();
+  truncate(size) {
+    if (size < this.stored) {
+      this.stored = size;
+      this.shrink = Math.min(this.shrink ?? size, size);
     }
-    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;
+    if (size < this.length) {
+      const edge = Math.floor(size / PAGE);
+      for (const page of [...this.pages.keys()]) {
+        if (page > edge || page === edge && size === edge * PAGE) this.drop(page);
+      }
+      this.pages.get(edge)?.fill(0, size - edge * PAGE);
+    }
+    this.length = size;
   }
-  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);
+  plan() {
+    const runs = [];
+    const sorted = [...this.dirty].sort((a, b) => a - b);
+    for (let i = 0; i < sorted.length; ) {
+      let j = i + 1;
+      const first = sorted[i];
+      while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
+        j++;
+      }
+      const start2 = first * PAGE;
+      const end = Math.min(this.length, (first + (j - i)) * PAGE);
+      const bytes = new Uint8Array(end - start2);
+      for (let k = i; k < j; k++) {
+        const page = this.pages.get(sorted[k]);
+        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
       }
+      runs.push({ offset: start2, bytes });
+      i = j;
+    }
+    const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
+    return {
+      ...this.shrink !== void 0 ? { shrink: this.shrink } : {},
+      runs,
+      ...this.length > written2 ? { extend: this.length } : {}
     };
-    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();
+  flushed() {
+    this.dirty.clear();
+    this.shrink = void 0;
+    this.stored = this.length;
+    this.evict();
   }
-  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;
+  pin() {
+    this.pinned = 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);
-    }
+  reset(size) {
+    if (this.pinned) return;
+    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
+    if (this.changed) return;
+    this.length = size;
+    this.stored = size;
   }
-  async read(max, signal) {
-    return (await this.receive(max, false, signal)).bytes;
+  refresh(size) {
+    if (this.pinned) return;
+    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
+    const resized2 = this.length !== this.stored || this.shrink !== void 0;
+    if (this.shrink === void 0) this.stored = size;
+    this.length = resized2 ? Math.max(this.length, this.stored) : size;
   }
-  async peek(max, signal) {
-    return (await this.receive(max, true, signal)).bytes;
+  evict() {
+    if (this.pinned) return;
+    let clean = (this.pages.size - this.dirty.size) * PAGE;
+    for (const page of this.pages.keys()) {
+      if (clean <= CLEAN_LIMIT) return;
+      if (this.dirty.has(page)) continue;
+      this.drop(page);
+      clean -= PAGE;
+    }
   }
-  write(bytes) {
-    return this.send(bytes);
+  take(used) {
+    const page = this.free.pop();
+    if (!page) return new Uint8Array(PAGE);
+    page.fill(0, used);
+    return page;
   }
-  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 } : {}
-    };
+  drop(page) {
+    const bytes = this.pages.get(page);
+    this.pages.delete(page);
+    this.dirty.delete(page);
+    if (this.free.length < CLEAN_LIMIT / PAGE) this.free.push(bytes);
   }
-  changed(signal) {
-    return this.changes.wait(signal);
+};
+
+// src/fs/ranged.ts
+var AsyncRangedFile = class {
+  pages;
+  io;
+  pinned = false;
+  version;
+  path;
+  constructor(io, path, size, version) {
+    this.io = io;
+    this.path = path;
+    this.version = version;
+    this.pages = new Pages(size);
   }
-  shutdown(how) {
-    if (!this.peer) throw new KernelError("ENOTCONN");
-    if (how < 0 || how > 2) throw new KernelError("EINVAL");
+  size() {
+    return this.pages.length;
   }
-  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);
-  }
-  write(at, bytes) {
-    for (let done4 = 0; done4 < bytes.length; ) {
-      const pos = at + done4;
-      const page = Math.floor(pos / PAGE);
-      const from = pos - page * PAGE;
-      const n = Math.min(PAGE - from, bytes.length - done4);
-      let target = this.pages.get(page);
-      if (!target) {
-        target = this.take(0);
-        this.pages.set(page, target);
-      }
-      target.set(bytes.subarray(done4, done4 + n), from);
-      this.dirty.add(page);
-      done4 += n;
-    }
-    this.length = Math.max(this.length, at + bytes.length);
-  }
-  truncate(size) {
-    if (size < this.stored) {
-      this.stored = size;
-      this.shrink = Math.min(this.shrink ?? size, size);
-    }
-    if (size < this.length) {
-      const edge = Math.floor(size / PAGE);
-      for (const page of [...this.pages.keys()]) {
-        if (page > edge || page === edge && size === edge * PAGE) this.drop(page);
-      }
-      this.pages.get(edge)?.fill(0, size - edge * PAGE);
-    }
-    this.length = size;
-  }
-  plan() {
-    const runs = [];
-    const sorted = [...this.dirty].sort((a, b) => a - b);
-    for (let i = 0; i < sorted.length; ) {
-      let j = i + 1;
-      const first = sorted[i];
-      while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
-        j++;
-      }
-      const start2 = first * PAGE;
-      const end = Math.min(this.length, (first + (j - i)) * PAGE);
-      const bytes = new Uint8Array(end - start2);
-      for (let k = i; k < j; k++) {
-        const page = this.pages.get(sorted[k]);
-        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
-      }
-      runs.push({ offset: start2, bytes });
-      i = j;
-    }
-    const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
-    return {
-      ...this.shrink !== void 0 ? { shrink: this.shrink } : {},
-      runs,
-      ...this.length > written2 ? { extend: this.length } : {}
-    };
-  }
-  flushed() {
-    this.dirty.clear();
-    this.shrink = void 0;
-    this.stored = this.length;
-    this.evict();
-  }
-  pin() {
-    this.pinned = true;
-  }
-  reset(size) {
-    if (this.pinned) return;
-    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
-    if (this.changed) return;
-    this.length = size;
-    this.stored = size;
-  }
-  refresh(size) {
-    if (this.pinned) return;
-    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
-    const resized2 = this.length !== this.stored || this.shrink !== void 0;
-    if (this.shrink === void 0) this.stored = size;
-    this.length = resized2 ? Math.max(this.length, this.stored) : size;
-  }
-  evict() {
-    if (this.pinned) return;
-    let clean = (this.pages.size - this.dirty.size) * PAGE;
-    for (const page of this.pages.keys()) {
-      if (clean <= CLEAN_LIMIT) return;
-      if (this.dirty.has(page)) continue;
-      this.drop(page);
-      clean -= PAGE;
-    }
-  }
-  take(used) {
-    const page = this.free.pop();
-    if (!page) return new Uint8Array(PAGE);
-    page.fill(0, used);
-    return page;
-  }
-  drop(page) {
-    const bytes = this.pages.get(page);
-    this.pages.delete(page);
-    this.dirty.delete(page);
-    if (this.free.length < CLEAN_LIMIT / PAGE) this.free.push(bytes);
-  }
-};
-
-// src/fs/ranged.ts
-var AsyncRangedFile = class {
-  pages;
-  io;
-  pinned = false;
-  version;
-  path;
-  constructor(io, path, size, version) {
-    this.io = io;
-    this.path = path;
-    this.version = version;
-    this.pages = new Pages(size);
-  }
-  size() {
-    return this.pages.length;
-  }
-  async fetch(runs) {
-    for (const [start2, n] of runs) {
-      this.pages.fill(start2, await this.io.pread(this.path, start2, n, this.version));
+  async fetch(runs) {
+    for (const [start2, n] of runs) {
+      this.pages.fill(start2, await this.io.pread(this.path, start2, n, this.version));
     }
   }
   async read(at, length2) {
@@ -14929,19 +14559,143 @@ var HttpHandles = class {
   }
 };
 
-// src/kernel/net/resolver.ts
-var RESOLVE_TTL_MAX = 60;
-var RESOLVE_TIMEOUT_MS = 1e4;
-var RESOLVE_CACHE_MAX = 256;
-var LOOPBACK_NAMES2 = /* @__PURE__ */ new Set(["localhost", "localhost.localdomain", "ip6-localhost", "::1"]);
-function loopbackName(name2, own) {
-  return LOOPBACK_NAMES2.has(name2) || name2.endsWith(".localhost") || own.includes(name2);
+// src/kernel/net/uplink.ts
+function carriesUdp(uplink) {
+  return uplink.traits.udp === true && typeof uplink.udp === "function";
 }
-function hostsEntry(name2, own = ownNames(DEFAULT_HOSTNAME)) {
-  if (own.includes(name2)) return HOSTNAME_ADDRESS;
-  if (LOOPBACK_NAMES2.has(name2) || name2.endsWith(".localhost")) return "127.0.0.1";
-  if (name2 === HOST_LOOPBACK) return HOST_LOOPBACK_ADDRESS.join(".");
-  return ipv4Bytes(name2) ? name2 : void 0;
+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;
+var RESOLVE_CACHE_MAX = 256;
+var LOOPBACK_NAMES2 = /* @__PURE__ */ new Set(["localhost", "localhost.localdomain", "ip6-localhost", "::1"]);
+function loopbackName(name2, own) {
+  return LOOPBACK_NAMES2.has(name2) || name2.endsWith(".localhost") || own.includes(name2);
+}
+function hostsEntry(name2, own = ownNames(DEFAULT_HOSTNAME)) {
+  if (own.includes(name2)) return HOSTNAME_ADDRESS;
+  if (LOOPBACK_NAMES2.has(name2) || name2.endsWith(".localhost")) return "127.0.0.1";
+  if (name2 === HOST_LOOPBACK) return HOST_LOOPBACK_ADDRESS.join(".");
+  return ipv4Bytes(name2) ? name2 : void 0;
 }
 var Resolver = class {
   uplink;
@@ -15652,274 +15406,536 @@ async function selectFds(fds, read, write, timeoutMs, interrupt) {
   } finally {
     interrupted3.done();
   }
-}
-async function waitReady(fds, read, write, deadline, interrupted3) {
-  for (; ; ) {
-    const now = ready(fds, read, write);
-    if (now.read.length > 0 || now.write.length > 0 || performance.now() >= deadline) return now;
-    const round = new AbortController();
-    const changes = [.../* @__PURE__ */ new Set([...read, ...write])].flatMap((fd) => {
-      const file = fds.get(fd).file;
-      return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
-    });
-    let cancel = () => {
+}
+async function waitReady(fds, read, write, deadline, interrupted3) {
+  for (; ; ) {
+    const now = ready(fds, read, write);
+    if (now.read.length > 0 || now.write.length > 0 || performance.now() >= deadline) return now;
+    const round = new AbortController();
+    const changes = [.../* @__PURE__ */ new Set([...read, ...write])].flatMap((fd) => {
+      const file = fds.get(fd).file;
+      return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
+    });
+    let cancel = () => {
+    };
+    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => cancel = timerAt(deadline, resolve2))];
+    try {
+      await Promise.race([...changes, ...expiry, interrupted3]);
+    } finally {
+      round.abort();
+      cancel();
+    }
+  }
+}
+
+// src/kernel/sem.ts
+var SEM_VALUE_MAX = 2147483647;
+var SEM_NAMES_MAX = 65536;
+var SEM_HANDLES_MAX = 65536;
+var NAME_MAX = 251;
+var SEM_OPS = [
+  "sem-open",
+  "sem-close",
+  "sem-unlink",
+  "sem-post",
+  "sem-wait",
+  "sem-getvalue"
+];
+var Semaphore = class {
+  value;
+  uid;
+  gid;
+  mode;
+  waiters = [];
+  constructor(value2, uid, gid, mode) {
+    this.value = value2;
+    this.uid = uid;
+    this.gid = gid;
+    this.mode = mode;
+  }
+  post() {
+    const next3 = this.waiters.shift();
+    if (next3) next3.grant();
+    else if (this.value >= SEM_VALUE_MAX) throw new KernelError("EOVERFLOW");
+    else this.value++;
+  }
+  take() {
+    if (this.value === 0) return false;
+    this.value--;
+    return true;
+  }
+  wait(signal, timeoutMs) {
+    if (this.take()) return Promise.resolve(true);
+    if (signal.aborted) return Promise.reject(new KernelError("EINTR"));
+    return new Promise((resolve2, reject) => {
+      const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : performance.now() + timeoutMs;
+      let cancel = () => {
+      };
+      const leave = () => {
+        const at = this.waiters.indexOf(waiter);
+        if (at >= 0) this.waiters.splice(at, 1);
+        cancel();
+        signal.removeEventListener("abort", abort);
+      };
+      const waiter = {
+        grant: () => {
+          leave();
+          resolve2(true);
+        }
+      };
+      const abort = () => {
+        leave();
+        reject(new KernelError("EINTR"));
+      };
+      const expire = () => {
+        leave();
+        resolve2(false);
+      };
+      this.waiters.push(waiter);
+      signal.addEventListener("abort", abort, { once: true });
+      if (deadline !== Number.POSITIVE_INFINITY) {
+        cancel = timerAt(deadline, expire);
+      }
+    });
+  }
+};
+var SemTable = class {
+  names = /* @__PURE__ */ new Map();
+  limit;
+  constructor(limit = SEM_NAMES_MAX) {
+    this.limit = limit;
+  }
+  open(name2, create, exclusive, make, check, adopt) {
+    const found = this.names.get(name2);
+    if (found) {
+      if (create && exclusive) throw new KernelError("EEXIST");
+      check(found);
+      return adopt(found);
+    }
+    if (!create) throw new KernelError("ENOENT");
+    if (this.names.size >= this.limit) throw new KernelError("ENOSPC");
+    const sem = make();
+    const handle = adopt(sem);
+    this.names.set(name2, sem);
+    return handle;
+  }
+  unlink(name2, check) {
+    const found = this.names.get(name2);
+    if (!found) throw new KernelError("ENOENT");
+    check(found);
+    this.names.delete(name2);
+  }
+};
+var SemHandles = class _SemHandles {
+  byHandle = /* @__PURE__ */ new Map();
+  next = 1;
+  limit;
+  constructor(limit = SEM_HANDLES_MAX) {
+    this.limit = limit;
+  }
+  add(sem) {
+    for (const [handle2, entry] of this.byHandle) {
+      if (entry.sem === sem) {
+        entry.opens++;
+        return handle2;
+      }
+    }
+    if (this.byHandle.size >= this.limit) throw new KernelError("EMFILE");
+    const handle = this.next++;
+    this.byHandle.set(handle, { sem, opens: 1 });
+    return handle;
+  }
+  get(handle) {
+    const entry = this.byHandle.get(handle);
+    if (!entry) throw new KernelError("EINVAL");
+    return entry.sem;
+  }
+  close(handle) {
+    const entry = this.byHandle.get(handle);
+    if (!entry) throw new KernelError("EINVAL");
+    if (--entry.opens === 0) this.byHandle.delete(handle);
+  }
+  fork() {
+    const child = new _SemHandles(this.limit);
+    child.next = this.next;
+    for (const [handle, entry] of this.byHandle) child.byHandle.set(handle, { ...entry });
+    return child;
+  }
+  clear() {
+    this.byHandle.clear();
+  }
+};
+function semName(raw) {
+  const name2 = raw.replace(/^\/+/, "");
+  if (name2 === "" || name2.includes("/") || name2 === "." || name2 === "..") {
+    throw new KernelError("EINVAL");
+  }
+  if (new TextEncoder().encode(name2).length > NAME_MAX) throw new KernelError("ENAMETOOLONG");
+  return name2;
+}
+var ok2 = (json5) => json5 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json5 };
+async function semSyscall(req, proc) {
+  const { table, handles, cred } = proc;
+  if (!table) throw new KernelError("ENOSYS");
+  const { denied: denied2 } = proc;
+  const shown = (name2) => `/dev/shm/sem.${name2}`;
+  const opens = (name2) => (sem) => {
+    const perm = { uid: sem.uid, gid: sem.gid, mode: sem.mode };
+    if (denied2 && !permits(cred, perm, R_OK | W_OK, false)) denied2("sem_open", shown(name2));
+  };
+  const unlinks = (name2) => (sem) => {
+    if (denied2 && cred.euid !== 0 && cred.euid !== sem.uid) denied2("sem_unlink", shown(name2));
+  };
+  switch (req.op) {
+    case "sem-open": {
+      if (req.value < 0 || req.value > SEM_VALUE_MAX) throw new KernelError("EINVAL");
+      const name2 = semName(req.name);
+      const mode = req.mode & 511 & ~proc.umask;
+      return ok2(
+        table.open(
+          name2,
+          req.create,
+          req.exclusive,
+          () => new Semaphore(req.value, cred.euid, cred.egid, mode),
+          opens(name2),
+          (sem) => handles.add(sem)
+        )
+      );
+    }
+    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 expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => cancel = timerAt(deadline, resolve2))];
+    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 {
-      await Promise.race([...changes, ...expiry, interrupted3]);
+      const socket = await this.uplinkSocket(uplink, familyOf(to.host));
+      await socket.send(bytes.slice(), to.host, to.port);
+    } catch (e) {
+      throw sendError(e);
     } finally {
-      round.abort();
-      cancel();
+      this.sending -= bytes.length;
+      this.changes.wake();
     }
+    return bytes.length;
   }
-}
-
-// src/kernel/sem.ts
-var SEM_VALUE_MAX = 2147483647;
-var SEM_NAMES_MAX = 65536;
-var SEM_HANDLES_MAX = 65536;
-var NAME_MAX = 251;
-var SEM_OPS = [
-  "sem-open",
-  "sem-close",
-  "sem-unlink",
-  "sem-post",
-  "sem-wait",
-  "sem-getvalue"
-];
-var Semaphore = class {
-  value;
-  uid;
-  gid;
-  mode;
-  waiters = [];
-  constructor(value2, uid, gid, mode) {
-    this.value = value2;
-    this.uid = uid;
-    this.gid = gid;
-    this.mode = mode;
+  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;
   }
-  post() {
-    const next3 = this.waiters.shift();
-    if (next3) next3.grant();
-    else if (this.value >= SEM_VALUE_MAX) throw new KernelError("EOVERFLOW");
-    else this.value++;
+  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();
   }
-  take() {
-    if (this.value === 0) return false;
-    this.value--;
+  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;
   }
-  wait(signal, timeoutMs) {
-    if (this.take()) return Promise.resolve(true);
-    if (signal.aborted) return Promise.reject(new KernelError("EINTR"));
-    return new Promise((resolve2, reject) => {
-      const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : performance.now() + timeoutMs;
-      let cancel = () => {
-      };
-      const leave = () => {
-        const at = this.waiters.indexOf(waiter);
-        if (at >= 0) this.waiters.splice(at, 1);
-        cancel();
-        signal.removeEventListener("abort", abort);
-      };
-      const waiter = {
-        grant: () => {
-          leave();
-          resolve2(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 abort = () => {
-        leave();
-        reject(new KernelError("EINTR"));
-      };
-      const expire = () => {
-        leave();
-        resolve2(false);
-      };
-      this.waiters.push(waiter);
-      signal.addEventListener("abort", abort, { once: true });
-      if (deadline !== Number.POSITIVE_INFINITY) {
-        cancel = timerAt(deadline, expire);
+        const size = Math.max(0, max);
+        return {
+          bytes: next3.bytes.slice(0, size),
+          from: next3.from,
+          truncated: next3.bytes.length > size
+        };
       }
-    });
-  }
-};
-var SemTable = class {
-  names = /* @__PURE__ */ new Map();
-  limit;
-  constructor(limit = SEM_NAMES_MAX) {
-    this.limit = limit;
-  }
-  open(name2, create, exclusive, make, check, adopt) {
-    const found = this.names.get(name2);
-    if (found) {
-      if (create && exclusive) throw new KernelError("EEXIST");
-      check(found);
-      return adopt(found);
+      await this.changes.wait(signal);
     }
-    if (!create) throw new KernelError("ENOENT");
-    if (this.names.size >= this.limit) throw new KernelError("ENOSPC");
-    const sem = make();
-    const handle = adopt(sem);
-    this.names.set(name2, sem);
-    return handle;
-  }
-  unlink(name2, check) {
-    const found = this.names.get(name2);
-    if (!found) throw new KernelError("ENOENT");
-    check(found);
-    this.names.delete(name2);
   }
-};
-var SemHandles = class _SemHandles {
-  byHandle = /* @__PURE__ */ new Map();
-  next = 1;
-  limit;
-  constructor(limit = SEM_HANDLES_MAX) {
-    this.limit = limit;
-  }
-  add(sem) {
-    for (const [handle2, entry] of this.byHandle) {
-      if (entry.sem === sem) {
-        entry.opens++;
-        return handle2;
-      }
-    }
-    if (this.byHandle.size >= this.limit) throw new KernelError("EMFILE");
-    const handle = this.next++;
-    this.byHandle.set(handle, { sem, opens: 1 });
-    return handle;
+  async read(max, signal) {
+    return (await this.receive(max, false, signal)).bytes;
   }
-  get(handle) {
-    const entry = this.byHandle.get(handle);
-    if (!entry) throw new KernelError("EINVAL");
-    return entry.sem;
+  async peek(max, signal) {
+    return (await this.receive(max, true, signal)).bytes;
   }
-  close(handle) {
-    const entry = this.byHandle.get(handle);
-    if (!entry) throw new KernelError("EINVAL");
-    if (--entry.opens === 0) this.byHandle.delete(handle);
+  write(bytes) {
+    return this.send(bytes);
   }
-  fork() {
-    const child = new _SemHandles(this.limit);
-    child.next = this.next;
-    for (const [handle, entry] of this.byHandle) child.byHandle.set(handle, { ...entry });
-    return child;
+  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 } : {}
+    };
   }
-  clear() {
-    this.byHandle.clear();
+  changed(signal) {
+    return this.changes.wait(signal);
   }
-};
-function semName(raw) {
-  const name2 = raw.replace(/^\/+/, "");
-  if (name2 === "" || name2.includes("/") || name2 === "." || name2 === "..") {
-    throw new KernelError("EINVAL");
+  shutdown(how) {
+    if (!this.peer) throw new KernelError("ENOTCONN");
+    if (how < 0 || how > 2) throw new KernelError("EINVAL");
   }
-  if (new TextEncoder().encode(name2).length > NAME_MAX) throw new KernelError("ENAMETOOLONG");
-  return name2;
-}
-var ok2 = (json5) => json5 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json5 };
-async function semSyscall(req, proc) {
-  const { table, handles, cred } = proc;
-  if (!table) throw new KernelError("ENOSYS");
-  const { denied: denied2 } = proc;
-  const shown = (name2) => `/dev/shm/sem.${name2}`;
-  const opens = (name2) => (sem) => {
-    const perm = { uid: sem.uid, gid: sem.gid, mode: sem.mode };
-    if (denied2 && !permits(cred, perm, R_OK | W_OK, false)) denied2("sem_open", shown(name2));
-  };
-  const unlinks = (name2) => (sem) => {
-    if (denied2 && cred.euid !== 0 && cred.euid !== sem.uid) denied2("sem_unlink", shown(name2));
-  };
-  switch (req.op) {
-    case "sem-open": {
-      if (req.value < 0 || req.value > SEM_VALUE_MAX) throw new KernelError("EINVAL");
-      const name2 = semName(req.name);
-      const mode = req.mode & 511 & ~proc.umask;
-      return ok2(
-        table.open(
-          name2,
-          req.create,
-          req.exclusive,
-          () => new Semaphore(req.value, cred.euid, cred.egid, mode),
-          opens(name2),
-          (sem) => handles.add(sem)
-        )
-      );
+  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-close":
-      handles.close(req.handle);
-      return ok2();
-    case "sem-unlink": {
-      const name2 = semName(req.name);
-      table.unlink(name2, unlinks(name2));
-      return ok2();
+    if (level === IPPROTO_IP && name2 >= IP_MULTICAST_FIRST && name2 <= IP_MULTICAST_LAST) {
+      throw new KernelError("ENOPROTOOPT");
     }
-    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();
+    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);
   }
-}
-
-// 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));
+  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 +15943,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 +16107,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 +16163,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 +16185,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 +16200,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 +16233,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 +16244,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 +18079,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 +18516,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,