@bytecodealliance/preview2-shim 0.17.8 → 0.17.9

package/lib/io/worker-socket-udp.js

@@ -1,27 +1,27 @@
-import { createSocket } from 'node:dgram';
+import { createSocket } from "node:dgram";
 import {
-    createFuture,
-    futureDispose,
-    futureTakeValue,
-    pollStateReady,
-    verifyPollsDroppedForDrop,
-} from './worker-thread.js';
+  createFuture,
+  futureDispose,
+  futureTakeValue,
+  pollStateReady,
+  verifyPollsDroppedForDrop,
+} from "./worker-thread.js";
 import {
-    convertSocketError,
-    convertSocketErrorCode,
-    getDefaultReceiveBufferSize,
-    getDefaultSendBufferSize,
-    ipSocketAddress,
-    isIPv4MappedAddress,
-    isWildcardAddress,
-    noLookup,
-    serializeIpAddress,
-    SOCKET_STATE_BIND,
-    SOCKET_STATE_BOUND,
-    SOCKET_STATE_CLOSED,
-    SOCKET_STATE_CONNECTION,
-    SOCKET_STATE_INIT,
-} from './worker-sockets.js';
+  convertSocketError,
+  convertSocketErrorCode,
+  getDefaultReceiveBufferSize,
+  getDefaultSendBufferSize,
+  ipSocketAddress,
+  isIPv4MappedAddress,
+  isWildcardAddress,
+  noLookup,
+  serializeIpAddress,
+  SOCKET_STATE_BIND,
+  SOCKET_STATE_BOUND,
+  SOCKET_STATE_CLOSED,
+  SOCKET_STATE_CONNECTION,
+  SOCKET_STATE_INIT,
+} from "./worker-sockets.js";
 
 // Experimental support for batched UDP sends. Set this to true to enable.
 // This is not enabled by default because we need to figure out how to know
@@ -61,7 +61,7 @@ const UDP_BATCH_SENDS = false;
  */
 
 let udpSocketCnt = 0,
-    datagramStreamCnt = 0;
+  datagramStreamCnt = 0;
 
 /**
  * @type {Map<number, UdpSocketRecord>}
@@ -78,32 +78,32 @@ export const datagramStreams = new Map();
  * @returns {number}
  */
 export function createUdpSocket({ family, unicastHopLimit }) {
-    const udpSocket = createSocket({
-        type: family === 'ipv6' ? 'udp6' : 'udp4',
-        reuseAddr: false,
-        ipv6Only: family === 'ipv6',
-        lookup: noLookup,
-    });
-    udpSockets.set(++udpSocketCnt, {
-        state: SOCKET_STATE_INIT,
-        remoteAddress: null,
-        remotePort: null,
-        sendBufferSize: null,
-        receiveBufferSize: null,
-        unicastHopLimit,
-        udpSocket,
-        future: null,
-        serializedLocalAddress: null,
-        pollState: {
-            ready: true,
-            listener: null,
-            polls: [],
-            parentStream: null,
-        },
-        incomingDatagramStream: null,
-        outgoingDatagramStream: null,
-    });
-    return udpSocketCnt;
+  const udpSocket = createSocket({
+    type: family === "ipv6" ? "udp6" : "udp4",
+    reuseAddr: false,
+    ipv6Only: family === "ipv6",
+    lookup: noLookup,
+  });
+  udpSockets.set(++udpSocketCnt, {
+    state: SOCKET_STATE_INIT,
+    remoteAddress: null,
+    remotePort: null,
+    sendBufferSize: null,
+    receiveBufferSize: null,
+    unicastHopLimit,
+    udpSocket,
+    future: null,
+    serializedLocalAddress: null,
+    pollState: {
+      ready: true,
+      listener: null,
+      polls: [],
+      parentStream: null,
+    },
+    incomingDatagramStream: null,
+    outgoingDatagramStream: null,
+  });
+  return udpSocketCnt;
 }
 
 /**
@@ -111,45 +111,45 @@ export function createUdpSocket({ family, unicastHopLimit }) {
  * @returns {DatagramStreamRecord}
  */
 function createIncomingDatagramStream(socket) {
-    const id = ++datagramStreamCnt;
-    const pollState = {
-        ready: false,
-        listener: null,
-        polls: [],
-        parentStream: null,
-    };
-    const datagramStream = {
-        id,
-        active: true,
-        error: null,
-        socket,
-        queue: [],
-        cleanup,
-        pollState,
-    };
-    const { udpSocket } = socket;
-    datagramStreams.set(id, datagramStream);
-    function cleanup() {
-        udpSocket.off('message', onMessage);
-        udpSocket.off('error', onError);
-    }
-    function onMessage(data, rinfo) {
-        const family = rinfo.family.toLowerCase();
-        datagramStream.queue.push({
-            data,
-            remoteAddress: ipSocketAddress(family, rinfo.address, rinfo.port),
-        });
-        if (!pollState.ready) {
-            pollStateReady(pollState);
-        }
-    }
-    function onError(err) {
-        datagramStream.error = err;
-        pollStateReady(datagramStream.pollState);
-    }
-    udpSocket.on('message', onMessage);
-    udpSocket.once('error', onError);
-    return datagramStream;
+  const id = ++datagramStreamCnt;
+  const pollState = {
+    ready: false,
+    listener: null,
+    polls: [],
+    parentStream: null,
+  };
+  const datagramStream = {
+    id,
+    active: true,
+    error: null,
+    socket,
+    queue: [],
+    cleanup,
+    pollState,
+  };
+  const { udpSocket } = socket;
+  datagramStreams.set(id, datagramStream);
+  function cleanup() {
+    udpSocket.off("message", onMessage);
+    udpSocket.off("error", onError);
+  }
+  function onMessage(data, rinfo) {
+    const family = rinfo.family.toLowerCase();
+    datagramStream.queue.push({
+      data,
+      remoteAddress: ipSocketAddress(family, rinfo.address, rinfo.port),
+    });
+    if (!pollState.ready) {
+      pollStateReady(pollState);
+    }
+  }
+  function onError(err) {
+    datagramStream.error = err;
+    pollStateReady(datagramStream.pollState);
+  }
+  udpSocket.on("message", onMessage);
+  udpSocket.once("error", onError);
+  return datagramStream;
 }
 
 /**
@@ -157,92 +157,92 @@ function createIncomingDatagramStream(socket) {
  * @returns {DatagramStreamRecord}
  */
 function createOutgoingDatagramStream(socket) {
-    const id = ++datagramStreamCnt;
-    const datagramStream = {
-        id,
-        active: true,
-        error: null,
-        socket,
-        cleanup,
-        pollState: {
-            ready: true,
-            listener: null,
-            polls: [],
-            parentStream: null,
-        },
-    };
-    const { udpSocket } = socket;
-    datagramStreams.set(id, datagramStream);
-    udpSocket.on('error', onError);
-    function onError(err) {
-        datagramStream.error = err;
-        pollStateReady(datagramStream.pollState);
-    }
-    function cleanup() {
-        udpSocket.off('error', onError);
-    }
-    return datagramStream;
+  const id = ++datagramStreamCnt;
+  const datagramStream = {
+    id,
+    active: true,
+    error: null,
+    socket,
+    cleanup,
+    pollState: {
+      ready: true,
+      listener: null,
+      polls: [],
+      parentStream: null,
+    },
+  };
+  const { udpSocket } = socket;
+  datagramStreams.set(id, datagramStream);
+  udpSocket.on("error", onError);
+  function onError(err) {
+    datagramStream.error = err;
+    pollStateReady(datagramStream.pollState);
+  }
+  function cleanup() {
+    udpSocket.off("error", onError);
+  }
+  return datagramStream;
 }
 
 export function socketUdpBindStart(id, localAddress, family) {
-    const socket = udpSockets.get(id);
-
-    if (family !== localAddress.tag || isIPv4MappedAddress(localAddress)) {
-        throw 'invalid-argument';
-    }
-
-    const serializedLocalAddress = serializeIpAddress(localAddress);
-
-    if (socket.state !== SOCKET_STATE_INIT) {
-        throw 'invalid-state';
-    }
-    socket.state = SOCKET_STATE_BIND;
-    const { udpSocket } = socket;
-    socket.future = createFuture(
-        new Promise((resolve, reject) => {
-            function bindOk() {
-                resolve();
-                udpSocket.off('error', bindErr);
-            }
-            function bindErr(err) {
-                reject(convertSocketError(err));
-                udpSocket.off('listening', bindOk);
-            }
-            udpSocket.once('listening', bindOk);
-            udpSocket.once('error', bindErr);
-            udpSocket.bind(localAddress.val.port, serializedLocalAddress);
-        }),
-        socket.pollState
-    );
+  const socket = udpSockets.get(id);
+
+  if (family !== localAddress.tag || isIPv4MappedAddress(localAddress)) {
+    throw "invalid-argument";
+  }
+
+  const serializedLocalAddress = serializeIpAddress(localAddress);
+
+  if (socket.state !== SOCKET_STATE_INIT) {
+    throw "invalid-state";
+  }
+  socket.state = SOCKET_STATE_BIND;
+  const { udpSocket } = socket;
+  socket.future = createFuture(
+    new Promise((resolve, reject) => {
+      function bindOk() {
+        resolve();
+        udpSocket.off("error", bindErr);
+      }
+      function bindErr(err) {
+        reject(convertSocketError(err));
+        udpSocket.off("listening", bindOk);
+      }
+      udpSocket.once("listening", bindOk);
+      udpSocket.once("error", bindErr);
+      udpSocket.bind(localAddress.val.port, serializedLocalAddress);
+    }),
+    socket.pollState,
+  );
 }
 
 export function socketUdpBindFinish(id) {
-    const socket = udpSockets.get(id);
-    if (socket.state !== SOCKET_STATE_BIND) {
-        throw 'not-in-progress';
-    }
-    if (!socket.pollState.ready) {
-        throw 'would-block';
+  const socket = udpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_BIND) {
+    throw "not-in-progress";
+  }
+  if (!socket.pollState.ready) {
+    throw "would-block";
+  }
+  const { tag, val } = futureTakeValue(socket.future).val;
+  futureDispose(socket.future, false);
+  socket.future = null;
+  if (tag === "err") {
+    socket.state = SOCKET_STATE_CLOSED;
+    throw val;
+  } else {
+    // once bound, we can now set the options
+    // since Node.js doesn't support setting them until bound
+    socket.udpSocket.setTTL(socket.unicastHopLimit);
+    if (socket.sendBufferSize) {
+      socket.udpSocket.setRecvBufferSize(socket.sendBufferSize);
     }
-    const { tag, val } = futureTakeValue(socket.future).val;
-    futureDispose(socket.future, false);
-    socket.future = null;
-    if (tag === 'err') {
-        socket.state = SOCKET_STATE_CLOSED;
-        throw val;
-    } else {
-        // once bound, we can now set the options
-        // since Node.js doesn't support setting them until bound
-        socket.udpSocket.setTTL(socket.unicastHopLimit);
-        if (socket.sendBufferSize) {
-            socket.udpSocket.setRecvBufferSize(socket.sendBufferSize);
-        }
-        if (socket.receieveBufferSize) {
-            socket.udpSocket.setSendBufferSize(socket.receiveBufferSize);
-        }
-        socket.state = SOCKET_STATE_BOUND;
-        return val;
+    if (socket.receieveBufferSize) {
+      socket.udpSocket.setSendBufferSize(socket.receiveBufferSize);
     }
+    socket.state = SOCKET_STATE_BOUND;
+    return val;
+  }
 }
 
 /**
@@ -250,14 +250,14 @@ export function socketUdpBindFinish(id) {
  * @returns {IpSocketAddress}
  */
 export function socketUdpGetLocalAddress(id) {
-    const { udpSocket } = udpSockets.get(id);
-    let address, family, port;
-    try {
-        ({ address, family, port } = udpSocket.address());
-    } catch (err) {
-        throw convertSocketError(err);
-    }
-    return ipSocketAddress(family.toLowerCase(), address, port);
+  const { udpSocket } = udpSockets.get(id);
+  let address, family, port;
+  try {
+    ({ address, family, port } = udpSocket.address());
+  } catch (err) {
+    throw convertSocketError(err);
+  }
+  return ipSocketAddress(family.toLowerCase(), address, port);
 }
 
 /**
@@ -265,377 +265,323 @@ export function socketUdpGetLocalAddress(id) {
  * @returns {IpSocketAddress}
  */
 export function socketUdpGetRemoteAddress(id) {
-    const { udpSocket } = udpSockets.get(id);
-    let address, family, port;
-    try {
-        ({ address, family, port } = udpSocket.remoteAddress());
-    } catch (err) {
-        throw convertSocketError(err);
-    }
-    return ipSocketAddress(family.toLowerCase(), address, port);
+  const { udpSocket } = udpSockets.get(id);
+  let address, family, port;
+  try {
+    ({ address, family, port } = udpSocket.remoteAddress());
+  } catch (err) {
+    throw convertSocketError(err);
+  }
+  return ipSocketAddress(family.toLowerCase(), address, port);
 }
 
 export function socketUdpStream(id, remoteAddress) {
-    const socket = udpSockets.get(id);
-    const { udpSocket } = socket;
-
-    if (
-        socket.state !== SOCKET_STATE_BOUND &&
-        socket.state !== SOCKET_STATE_CONNECTION
-    ) {
-        throw 'invalid-state';
-    }
-
-    if (socket.state === SOCKET_STATE_INIT && !remoteAddress) {
-        throw 'invalid-state';
-    }
-
-    if (
-        remoteAddress &&
-        (remoteAddress.val.port === 0 ||
-            isWildcardAddress(remoteAddress) ||
-            (remoteAddress.tag === 'ipv6' &&
-                isIPv4MappedAddress(remoteAddress)))
-    ) {
-        throw 'invalid-argument';
-    }
-
-    if (socket.state === SOCKET_STATE_CONNECTION) {
-        socketDatagramStreamClear(socket.incomingDatagramStream);
-        socketDatagramStreamClear(socket.outgoingDatagramStream);
-        try {
-            udpSocket.disconnect();
-        } catch (e) {
-            throw convertSocketErrorCode(e);
+  const socket = udpSockets.get(id);
+  const { udpSocket } = socket;
+
+  if (socket.state !== SOCKET_STATE_BOUND && socket.state !== SOCKET_STATE_CONNECTION) {
+    throw "invalid-state";
+  }
+
+  if (socket.state === SOCKET_STATE_INIT && !remoteAddress) {
+    throw "invalid-state";
+  }
+
+  if (
+    remoteAddress &&
+    (remoteAddress.val.port === 0 ||
+      isWildcardAddress(remoteAddress) ||
+      (remoteAddress.tag === "ipv6" && isIPv4MappedAddress(remoteAddress)))
+  ) {
+    throw "invalid-argument";
+  }
+
+  if (socket.state === SOCKET_STATE_CONNECTION) {
+    socketDatagramStreamClear(socket.incomingDatagramStream);
+    socketDatagramStreamClear(socket.outgoingDatagramStream);
+    try {
+      udpSocket.disconnect();
+    } catch (e) {
+      throw convertSocketErrorCode(e);
+    }
+  }
+
+  if (remoteAddress) {
+    const serializedRemoteAddress = serializeIpAddress(remoteAddress);
+    socket.remoteAddress = serializedRemoteAddress;
+    socket.remotePort = remoteAddress.val.port;
+    return new Promise((resolve, reject) => {
+      function connectOk() {
+        if (socket.state === SOCKET_STATE_INIT) {
+          socket.udpSocket.setTTL(socket.unicastHopLimit);
+          socket.udpSocket.setRecvBufferSize(socket.sendBufferSize);
+          socket.udpSocket.setSendBufferSize(socket.receiveBufferSize);
         }
-    }
-
-    if (remoteAddress) {
-        const serializedRemoteAddress = serializeIpAddress(remoteAddress);
-        socket.remoteAddress = serializedRemoteAddress;
-        socket.remotePort = remoteAddress.val.port;
-        return new Promise((resolve, reject) => {
-            function connectOk() {
-                if (socket.state === SOCKET_STATE_INIT) {
-                    socket.udpSocket.setTTL(socket.unicastHopLimit);
-                    socket.udpSocket.setRecvBufferSize(socket.sendBufferSize);
-                    socket.udpSocket.setSendBufferSize(
-                        socket.receiveBufferSize
-                    );
-                }
-                udpSocket.off('error', connectErr);
-                socket.state = SOCKET_STATE_CONNECTION;
-                resolve([
-                    (socket.incomingDatagramStream =
-                        createIncomingDatagramStream(socket)).id,
-                    (socket.outgoingDatagramStream =
-                        createOutgoingDatagramStream(socket)).id,
-                ]);
-            }
-            function connectErr(err) {
-                udpSocket.off('connect', connectOk);
-                reject(convertSocketError(err));
-            }
-            udpSocket.once('connect', connectOk);
-            udpSocket.once('error', connectErr);
-            udpSocket.connect(remoteAddress.val.port, serializedRemoteAddress);
-        });
-    } else {
-        socket.state = SOCKET_STATE_BOUND;
-        socket.remoteAddress = null;
-        socket.remotePort = null;
-        return [
-            (socket.incomingDatagramStream =
-                createIncomingDatagramStream(socket)).id,
-            (socket.outgoingDatagramStream =
-                createOutgoingDatagramStream(socket)).id,
-        ];
-    }
+        udpSocket.off("error", connectErr);
+        socket.state = SOCKET_STATE_CONNECTION;
+        resolve([
+          (socket.incomingDatagramStream = createIncomingDatagramStream(socket)).id,
+          (socket.outgoingDatagramStream = createOutgoingDatagramStream(socket)).id,
+        ]);
+      }
+      function connectErr(err) {
+        udpSocket.off("connect", connectOk);
+        reject(convertSocketError(err));
+      }
+      udpSocket.once("connect", connectOk);
+      udpSocket.once("error", connectErr);
+      udpSocket.connect(remoteAddress.val.port, serializedRemoteAddress);
+    });
+  } else {
+    socket.state = SOCKET_STATE_BOUND;
+    socket.remoteAddress = null;
+    socket.remotePort = null;
+    return [
+      (socket.incomingDatagramStream = createIncomingDatagramStream(socket)).id,
+      (socket.outgoingDatagramStream = createOutgoingDatagramStream(socket)).id,
+    ];
+  }
 }
 
 export function socketUdpSetReceiveBufferSize(id, bufferSize) {
-    const socket = udpSockets.get(id);
-    bufferSize = Number(bufferSize);
-    if (
-        socket.state !== SOCKET_STATE_INIT &&
-        socket.state !== SOCKET_STATE_BIND
-    ) {
-        try {
-            socket.udpSocket.setRecvBufferSize(bufferSize);
-        } catch (err) {
-            throw convertSocketError(err);
-        }
+  const socket = udpSockets.get(id);
+  bufferSize = Number(bufferSize);
+  if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BIND) {
+    try {
+      socket.udpSocket.setRecvBufferSize(bufferSize);
+    } catch (err) {
+      throw convertSocketError(err);
     }
-    socket.receiveBufferSize = bufferSize;
+  }
+  socket.receiveBufferSize = bufferSize;
 }
 
 export function socketUdpSetSendBufferSize(id, bufferSize) {
-    const socket = udpSockets.get(id);
-    bufferSize = Number(bufferSize);
-    if (
-        socket.state !== SOCKET_STATE_INIT &&
-        socket.state !== SOCKET_STATE_BIND
-    ) {
-        try {
-            socket.udpSocket.setSendBufferSize(bufferSize);
-        } catch (err) {
-            throw convertSocketError(err);
-        }
+  const socket = udpSockets.get(id);
+  bufferSize = Number(bufferSize);
+  if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BIND) {
+    try {
+      socket.udpSocket.setSendBufferSize(bufferSize);
+    } catch (err) {
+      throw convertSocketError(err);
     }
-    socket.sendBufferSize = bufferSize;
+  }
+  socket.sendBufferSize = bufferSize;
 }
 
 export function socketUdpSetUnicastHopLimit(id, hopLimit) {
-    const socket = udpSockets.get(id);
-    if (
-        socket.state !== SOCKET_STATE_INIT &&
-        socket.state !== SOCKET_STATE_BIND
-    ) {
-        try {
-            socket.udpSocket.setTTL(hopLimit);
-        } catch (err) {
-            throw convertSocketError(err);
-        }
+  const socket = udpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BIND) {
+    try {
+      socket.udpSocket.setTTL(hopLimit);
+    } catch (err) {
+      throw convertSocketError(err);
     }
-    socket.unicastHopLimit = hopLimit;
+  }
+  socket.unicastHopLimit = hopLimit;
 }
 
 export async function socketUdpGetReceiveBufferSize(id) {
-    const socket = udpSockets.get(id);
-    if (socket.receiveBufferSize) {
-        return BigInt(socket.receiveBufferSize);
-    }
-    if (
-        socket.state !== SOCKET_STATE_INIT &&
-        socket.state !== SOCKET_STATE_BIND
-    ) {
-        try {
-            return BigInt(
-                (socket.receiveBufferSize =
-                    socket.udpSocket.getRecvBufferSize())
-            );
-        } catch (err) {
-            throw convertSocketError(err);
-        }
-    } else {
-        return BigInt(
-            (socket.receiveBufferSize = await getDefaultReceiveBufferSize())
-        );
+  const socket = udpSockets.get(id);
+  if (socket.receiveBufferSize) {
+    return BigInt(socket.receiveBufferSize);
+  }
+  if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BIND) {
+    try {
+      return BigInt((socket.receiveBufferSize = socket.udpSocket.getRecvBufferSize()));
+    } catch (err) {
+      throw convertSocketError(err);
     }
+  } else {
+    return BigInt((socket.receiveBufferSize = await getDefaultReceiveBufferSize()));
+  }
 }
 
 export async function socketUdpGetSendBufferSize(id) {
-    const socket = udpSockets.get(id);
-    if (socket.sendBufferSize) {
-        return BigInt(socket.sendBufferSize);
-    }
-    if (
-        socket.state !== SOCKET_STATE_INIT &&
-        socket.state !== SOCKET_STATE_BIND
-    ) {
-        try {
-            return BigInt(
-                (socket.sendBufferSize = socket.udpSocket.getSendBufferSize())
-            );
-        } catch (err) {
-            throw convertSocketError(err);
-        }
-    } else {
-        return BigInt(
-            (socket.sendBufferSize = await getDefaultSendBufferSize())
-        );
+  const socket = udpSockets.get(id);
+  if (socket.sendBufferSize) {
+    return BigInt(socket.sendBufferSize);
+  }
+  if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BIND) {
+    try {
+      return BigInt((socket.sendBufferSize = socket.udpSocket.getSendBufferSize()));
+    } catch (err) {
+      throw convertSocketError(err);
     }
+  } else {
+    return BigInt((socket.sendBufferSize = await getDefaultSendBufferSize()));
+  }
 }
 
 export function socketUdpGetUnicastHopLimit(id) {
-    const { unicastHopLimit } = udpSockets.get(id);
-    return unicastHopLimit;
+  const { unicastHopLimit } = udpSockets.get(id);
+  return unicastHopLimit;
 }
 
 export function socketUdpDispose(id) {
-    const { udpSocket } = udpSockets.get(id);
-    return new Promise((resolve) => {
-        udpSocket.close(() => {
-            udpSockets.delete(id);
-            resolve(0);
-        });
+  const { udpSocket } = udpSockets.get(id);
+  return new Promise((resolve) => {
+    udpSocket.close(() => {
+      udpSockets.delete(id);
+      resolve(0);
     });
+  });
 }
 
 export function socketIncomingDatagramStreamReceive(id, maxResults) {
-    const datagramStream = datagramStreams.get(id);
-    if (!datagramStream.active) {
-        throw new Error(
-            'wasi-io trap: attempt to receive on inactive incoming datagram stream'
-        );
-    }
-    if (maxResults === 0n || datagramStream.queue.length === 0) {
-        return [];
-    }
-    if (datagramStream.error) {
-        throw convertSocketError(datagramStream.error);
-    }
-    return datagramStream.queue.splice(0, Number(maxResults));
+  const datagramStream = datagramStreams.get(id);
+  if (!datagramStream.active) {
+    throw new Error("wasi-io trap: attempt to receive on inactive incoming datagram stream");
+  }
+  if (maxResults === 0n || datagramStream.queue.length === 0) {
+    return [];
+  }
+  if (datagramStream.error) {
+    throw convertSocketError(datagramStream.error);
+  }
+  return datagramStream.queue.splice(0, Number(maxResults));
 }
 
 export async function socketOutgoingDatagramStreamSend(id, datagrams) {
-    const { active, socket } = datagramStreams.get(id);
-    if (!active) {
-        throw new Error(
-            'wasi-io trap: writing to inactive outgoing datagram stream'
-        );
-    }
-
-    const { udpSocket } = socket;
-    let sendQueue = [],
-        sendQueueAddress,
-        sendQueuePort;
-    let datagramsSent = 0;
-    for (const { data, remoteAddress } of datagrams) {
-        const address = remoteAddress
-            ? serializeIpAddress(remoteAddress)
-            : socket.remoteAddress;
-        const port = remoteAddress?.val.port ?? socket.remotePort;
-        let sendLastBatch = !UDP_BATCH_SENDS;
-        if (sendQueue.length > 0) {
-            if (sendQueueAddress === address && sendQueuePort === port) {
-                sendQueue.push(data);
-            } else {
-                sendLastBatch = true;
-            }
-        } else {
-            sendQueueAddress = address;
-            sendQueuePort = port;
-            sendQueue.push(data);
+  const { active, socket } = datagramStreams.get(id);
+  if (!active) {
+    throw new Error("wasi-io trap: writing to inactive outgoing datagram stream");
+  }
+
+  const { udpSocket } = socket;
+  let sendQueue = [],
+    sendQueueAddress,
+    sendQueuePort;
+  let datagramsSent = 0;
+  for (const { data, remoteAddress } of datagrams) {
+    const address = remoteAddress ? serializeIpAddress(remoteAddress) : socket.remoteAddress;
+    const port = remoteAddress?.val.port ?? socket.remotePort;
+    let sendLastBatch = !UDP_BATCH_SENDS;
+    if (sendQueue.length > 0) {
+      if (sendQueueAddress === address && sendQueuePort === port) {
+        sendQueue.push(data);
+      } else {
+        sendLastBatch = true;
+      }
+    } else {
+      sendQueueAddress = address;
+      sendQueuePort = port;
+      sendQueue.push(data);
+    }
+    if (sendLastBatch) {
+      const err = await doSendBatch();
+      if (err) {
+        return BigInt(datagramsSent);
+      }
+      if (UDP_BATCH_SENDS) {
+        sendQueue = [data];
+        sendQueuePort = port;
+        sendQueueAddress = address;
+      } else {
+        sendQueue = [];
+        sendQueuePort = port;
+        sendQueueAddress = address;
+      }
+    }
+  }
+  if (sendQueue.length) {
+    const err = await doSendBatch();
+    if (err) {
+      return BigInt(datagramsSent);
+    }
+  }
+
+  if (datagramsSent !== datagrams.length) {
+    throw new Error("wasi-io trap: expected to have sent all the datagrams");
+  }
+  return BigInt(datagramsSent);
+
+  function doSendBatch() {
+    return new Promise((resolve, reject) => {
+      if (socket.remoteAddress) {
+        if (sendQueueAddress !== socket.remoteAddress || sendQueuePort !== socket.remotePort) {
+          return void reject("invalid-argument");
         }
-        if (sendLastBatch) {
-            const err = await doSendBatch();
-            if (err) {
-                return BigInt(datagramsSent);
-            }
-            if (UDP_BATCH_SENDS) {
-                sendQueue = [data];
-                sendQueuePort = port;
-                sendQueueAddress = address;
-            } else {
-                sendQueue = [];
-                sendQueuePort = port;
-                sendQueueAddress = address;
-            }
+        udpSocket.send(sendQueue, handler);
+      } else {
+        if (!sendQueueAddress) {
+          return void reject("invalid-argument");
         }
-    }
-    if (sendQueue.length) {
-        const err = await doSendBatch();
+        udpSocket.send(sendQueue, sendQueuePort, sendQueueAddress, handler);
+      }
+      function handler(err, _sentBytes) {
         if (err) {
-            return BigInt(datagramsSent);
+          // TODO: update datagramsSent properly on error for multiple sends
+          //       to enable send batching. Perhaps a Node.js PR could
+          //       still set the second sendBytes arg?
+          if (datagramsSent > 0) {
+            resolve(datagramsSent);
+          } else {
+            reject(convertSocketError(err));
+          }
+          return;
         }
-    }
-
-    if (datagramsSent !== datagrams.length) {
-        throw new Error(
-            'wasi-io trap: expected to have sent all the datagrams'
-        );
-    }
-    return BigInt(datagramsSent);
-
-    function doSendBatch() {
-        return new Promise((resolve, reject) => {
-            if (socket.remoteAddress) {
-                if (
-                    sendQueueAddress !== socket.remoteAddress ||
-                    sendQueuePort !== socket.remotePort
-                ) {
-                    return void reject('invalid-argument');
-                }
-                udpSocket.send(sendQueue, handler);
-            } else {
-                if (!sendQueueAddress) {
-                    return void reject('invalid-argument');
-                }
-                udpSocket.send(
-                    sendQueue,
-                    sendQueuePort,
-                    sendQueueAddress,
-                    handler
-                );
-            }
-            function handler(err, _sentBytes) {
-                if (err) {
-                    // TODO: update datagramsSent properly on error for multiple sends
-                    //       to enable send batching. Perhaps a Node.js PR could
-                    //       still set the second sendBytes arg?
-                    if (datagramsSent > 0) {
-                        resolve(datagramsSent);
-                    } else {
-                        reject(convertSocketError(err));
-                    }
-                    return;
-                }
-                datagramsSent += sendQueue.length;
-                resolve(false);
-            }
-        });
-    }
+        datagramsSent += sendQueue.length;
+        resolve(false);
+      }
+    });
+  }
 }
 
 function checkSend(socket) {
-    try {
-        return Math.floor(
-            (socket.udpSocket.getSendBufferSize() -
-                socket.udpSocket.getSendQueueSize()) /
-                1500
-        );
-    } catch (err) {
-        throw convertSocketError(err);
-    }
+  try {
+    return Math.floor(
+      (socket.udpSocket.getSendBufferSize() - socket.udpSocket.getSendQueueSize()) / 1500,
+    );
+  } catch (err) {
+    throw convertSocketError(err);
+  }
 }
 
 function pollSend(socket) {
-    socket.pollState.ready = false;
-    // The only way we have of dealing with getting a backpressure
-    // ready signal in Node.js is to just poll on the queue reducing.
-    // Ideally this should implement backoff on the poll interval,
-    // but that work should be done alongside careful benchmarking
-    // in due course.
-    setTimeout(() => {
-        const remaining = checkSend(socket);
-        if (remaining > 0) {
-            pollStateReady(socket.pollState);
-        } else {
-            pollSend(socket);
-        }
-    });
+  socket.pollState.ready = false;
+  // The only way we have of dealing with getting a backpressure
+  // ready signal in Node.js is to just poll on the queue reducing.
+  // Ideally this should implement backoff on the poll interval,
+  // but that work should be done alongside careful benchmarking
+  // in due course.
+  setTimeout(() => {
+    const remaining = checkSend(socket);
+    if (remaining > 0) {
+      pollStateReady(socket.pollState);
+    } else {
+      pollSend(socket);
+    }
+  });
 }
 
 export function socketOutgoingDatagramStreamCheckSend(id) {
-    const { active, socket } = datagramStreams.get(id);
-    if (!active) {
-        throw new Error(
-            'wasi-io trap: check send on inactive outgoing datagram stream'
-        );
-    }
-    const remaining = checkSend(socket);
-    if (remaining <= 0) {
-        pollSend(socket);
-    }
-    return BigInt(remaining);
+  const { active, socket } = datagramStreams.get(id);
+  if (!active) {
+    throw new Error("wasi-io trap: check send on inactive outgoing datagram stream");
+  }
+  const remaining = checkSend(socket);
+  if (remaining <= 0) {
+    pollSend(socket);
+  }
+  return BigInt(remaining);
 }
 
 function socketDatagramStreamClear(datagramStream) {
-    datagramStream.active = false;
-    if (datagramStream.cleanup) {
-        datagramStream.cleanup();
-        datagramStream.cleanup = null;
-    }
+  datagramStream.active = false;
+  if (datagramStream.cleanup) {
+    datagramStream.cleanup();
+    datagramStream.cleanup = null;
+  }
 }
 
 export function socketDatagramStreamDispose(id) {
-    const datagramStream = datagramStreams.get(id);
-    datagramStream.active = false;
-    if (datagramStream.cleanup) {
-        datagramStream.cleanup();
-        datagramStream.cleanup = null;
-    }
-    verifyPollsDroppedForDrop(datagramStream.pollState, 'datagram stream');
-    datagramStreams.delete(id);
+  const datagramStream = datagramStreams.get(id);
+  datagramStream.active = false;
+  if (datagramStream.cleanup) {
+    datagramStream.cleanup();
+    datagramStream.cleanup = null;
+  }
+  verifyPollsDroppedForDrop(datagramStream.pollState, "datagram stream");
+  datagramStreams.delete(id);
 }