@bytecodealliance/preview2-shim 0.17.2 → 0.17.3

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,27 +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;
 }
 
 /**
@@ -106,43 +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;
 }
 
 /**
@@ -150,78 +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 { 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;
-  }
+    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);
+        }
+        if (socket.receieveBufferSize) {
+            socket.udpSocket.setSendBufferSize(socket.receiveBufferSize);
+        }
+        socket.state = SOCKET_STATE_BOUND;
+        return val;
+    }
 }
 
 /**
@@ -229,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);
 }
 
 /**
@@ -244,333 +265,377 @@ 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);
-    }
-  }
-
-  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);
+    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);
         }
-        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,
-    ];
-  }
+    }
+
+    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,
+        ];
+    }
 }
 
 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);
+    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())
+        );
     }
-  } 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);
+    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())
+        );
     }
-  } 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 { 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");
-        udpSocket.send(sendQueue, handler);
-      } else {
-        if (!sendQueueAddress)
-          return void reject("invalid-argument");
-        udpSocket.send(sendQueue, sendQueuePort, sendQueueAddress, handler);
-      }
-      function handler(err, _sentBytes) {
+    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) {
-          // 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;
+            return BigInt(datagramsSent);
         }
-        datagramsSent += sendQueue.length;
-        resolve(false);
-      }
-    });
-  }
+    }
+
+    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);
+            }
+        });
+    }
 }
 
 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);
 }