@ai-ecoverse/slicc-kernel 1.110.8 → 1.111.0

package/dist/node.js

@@ -1858,6 +1858,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();
@@ -1883,6 +1884,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);
   }
@@ -1936,7 +1949,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;
@@ -1950,6 +1965,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");
@@ -6494,7 +6510,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.110.8" : "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
@@ -11860,391 +11876,115 @@ 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);
-
-// 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;
+// 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;
   }
-  bind(addr) {
-    if (this.local) throw new KernelError("EINVAL");
-    this.local = this.net.bindDgram(this, addr);
+  get dirtyBytes() {
+    return this.dirty.size * PAGE;
   }
-  bound() {
-    this.local ??= this.net.bindDgram(this, { family: "inet", host: "0.0.0.0", port: 0 });
-    return this.local;
+  get changed() {
+    return this.dirty.size > 0 || this.shrink !== void 0 || this.length !== this.stored;
   }
-  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));
+  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)]);
   }
-  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);
+  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;
   }
-  route(host) {
-    const where = this.net.destination(host);
-    if (where === "loopback" || where === "uplink") return where;
-    throw new KernelError("ENETUNREACH");
+  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);
+    }
   }
-  takeError() {
-    const pending = this.pending;
-    this.pending = void 0;
-    return pending;
+  read(at, length2) {
+    const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length2) - at));
+    this.readInto(at, out);
+    return out;
   }
-  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();
+  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 bytes.length;
+    return Math.max(0, end - at);
   }
-  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();
+  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;
-  }
-  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;
+    this.length = Math.max(this.length, at + bytes.length);
   }
-  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);
+  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);
       }
-    };
-    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);
-  }
-  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;
+      this.pages.get(edge)?.fill(0, size - edge * PAGE);
+    }
+    this.length = size;
   }
   plan() {
     const runs = [];
@@ -14867,6 +14607,20 @@ 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);
+
 // src/kernel/net/resolver.ts
 var RESOLVE_TTL_MAX = 60;
 var RESOLVE_TIMEOUT_MS = 1e4;
@@ -15852,63 +15606,476 @@ function socketNames(deps) {
   };
 }
 
-// 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.setUint16(1, got.port);
-  view2.setUint8(3, host.length);
-  out.set(host, 4);
-  out.set(got.bytes, 4 + host.length);
-  return out;
-}
-
-// src/kernel/socket-syscalls.ts
-var SOCKET_OPS = [
-  "sock-open",
-  "sock-pair",
-  "sock-bind",
-  "sock-listen",
-  "sock-accept",
-  "sock-connect",
-  "sock-shutdown",
-  "sock-name",
-  "sock-getopt",
-  "sock-setopt",
+// 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;
+      }
+    }
+    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/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) | (got.unix ? 2 : 0));
+  view2.setUint16(1, got.port);
+  view2.setUint8(3, host.length);
+  out.set(host, 4);
+  out.set(got.bytes, 4 + host.length);
+  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",
+  "sock-pair",
+  "sock-bind",
+  "sock-listen",
+  "sock-accept",
+  "sock-connect",
+  "sock-shutdown",
+  "sock-name",
+  "sock-getopt",
+  "sock-setopt",
   "sock-resolve",
   "sock-sendto",
   "sock-recvfrom"
 ];
 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)]);
@@ -15934,7 +16101,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));
@@ -15956,6 +16123,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?.();
@@ -15967,8 +16138,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);
@@ -15985,6 +16171,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));
@@ -15995,6 +16182,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"));
@@ -17812,8 +18017,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 } : {},
@@ -18249,7 +18454,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,