@bytecodealliance/preview2-shim 0.0.17 → 0.0.19

package/types/interfaces/wasi-io-streams.d.ts

@@ -1,4 +1,13 @@
 export namespace WasiIoStreams {
+  /**
+   * Returns a string that's suitable to assist humans in debugging this
+   * error.
+   * 
+   * The returned string will change across platforms and hosts which
+   * means that parsing it, for example, would be a
+   * platform-compatibility hazard.
+   */
+  export { Error };
   /**
    * Perform a non-blocking read from the stream.
    * 
@@ -7,8 +16,8 @@ export namespace WasiIoStreams {
    * reads are expected to produce data. The returned list will contain up to
    * `len` bytes; it may return fewer than requested, but not more. An
    * empty list and `stream-status:open` indicates no more data is
-   * available at this time, and that the pollable given by
-   * `subscribe-to-input-stream` will be ready when more data is available.
+   * available at this time, and that the pollable given by `subscribe`
+   * will be ready when more data is available.
    * 
    * Once a stream has reached the end, subsequent calls to `read` or
    * `skip` will always report `stream-status:ended` rather than producing more
@@ -23,12 +32,11 @@ export namespace WasiIoStreams {
    * as a return value by the callee. The callee may return a list of bytes
    * less than `len` in size while more bytes are available for reading.
    */
-  export function read(this_: InputStream, len: bigint): [Uint8Array, StreamStatus];
+  export { InputStream };
   /**
    * Read bytes from a stream, after blocking until at least one byte can
    * be read. Except for blocking, identical to `read`.
    */
-  export function blockingRead(this_: InputStream, len: bigint): [Uint8Array, StreamStatus];
   /**
    * Skip bytes from a stream.
    * 
@@ -43,12 +51,10 @@ export namespace WasiIoStreams {
    * `stream-status` indicating whether the end of the stream was
    * reached. The returned value will be at most `len`; it may be less.
    */
-  export function skip(this_: InputStream, len: bigint): [bigint, StreamStatus];
   /**
    * Skip bytes from a stream, after blocking until at least one byte
    * can be skipped. Except for blocking behavior, identical to `skip`.
    */
-  export function blockingSkip(this_: InputStream, len: bigint): [bigint, StreamStatus];
   /**
    * Create a `pollable` which will resolve once either the specified stream
    * has bytes available to read or the other end of the stream has been
@@ -57,16 +63,6 @@ export namespace WasiIoStreams {
    * Implementations may trap if the `input-stream` is dropped before
    * all derived `pollable`s created with this function are dropped.
    */
-  export function subscribeToInputStream(this_: InputStream): Pollable;
-  /**
-   * Dispose of the specified `input-stream`, after which it may no longer
-   * be used.
-   * Implementations may trap if this `input-stream` is dropped while child
-   * `pollable` resources are still alive.
-   * After this `input-stream` is dropped, implementations may report any
-   * corresponding `output-stream` has `stream-state.closed`.
-   */
-  export function dropInputStream(this_: InputStream): void;
   /**
    * Check readiness for writing. This function never blocks.
    * 
@@ -74,11 +70,11 @@ export namespace WasiIoStreams {
    * or an error. Calling `write` with more bytes than this function has
    * permitted will trap.
    * 
-   * When this function returns 0 bytes, the `subscribe-to-output-stream`
-   * pollable will become ready when this function will report at least
-   * 1 byte, or an error.
+   * When this function returns 0 bytes, the `subscribe` pollable will
+   * become ready when this function will report at least 1 byte, or an
+   * error.
    */
-  export function checkWrite(this_: OutputStream): bigint;
+  export { OutputStream };
   /**
    * Perform a write. This function never blocks.
    * 
@@ -88,34 +84,32 @@ export namespace WasiIoStreams {
    * returns Err(closed) without writing if the stream has closed since
    * the last call to check-write provided a permit.
    */
-  export function write(this_: OutputStream, contents: Uint8Array): void;
   /**
    * Perform a write of up to 4096 bytes, and then flush the stream. Block
    * until all of these operations are complete, or an error occurs.
    * 
    * This is a convenience wrapper around the use of `check-write`,
-   * `subscribe-to-output-stream`, `write`, and `flush`, and is implemented
-   * with the following pseudo-code:
+   * `subscribe`, `write`, and `flush`, and is implemented with the
+   * following pseudo-code:
    * 
    * ```text
-   * let pollable = subscribe-to-output-stream(this);
+   * let pollable = this.subscribe();
    * while !contents.is_empty() {
      * // Wait for the stream to become writable
-     * poll-oneoff(pollable);
-     * let Ok(n) = check-write(this); // eliding error handling
+     * poll-one(pollable);
+     * let Ok(n) = this.check-write(); // eliding error handling
      * let len = min(n, contents.len());
      * let (chunk, rest) = contents.split_at(len);
-     * write(this, chunk);            // eliding error handling
+     * this.write(chunk  );            // eliding error handling
      * contents = rest;
      * }
-     * flush(this);
+     * this.flush();
      * // Wait for completion of `flush`
-     * poll-oneoff(pollable);
+     * poll-one(pollable);
      * // Check for any errors that arose during `flush`
-     * let _ = check-write(this);       // eliding error handling
+     * let _ = this.check-write();         // eliding error handling
      * ```
      */
-    export function blockingWriteAndFlush(this_: OutputStream, contents: Uint8Array): void;
     /**
      * Request to flush buffered output. This function never blocks.
      * 
@@ -125,15 +119,13 @@ export namespace WasiIoStreams {
      * 
      * Upon calling this function, the `output-stream` will not accept any
      * writes (`check-write` will return `ok(0)`) until the flush has
-     * completed. The `subscribe-to-output-stream` pollable will become ready
-     * when the flush has completed and the stream can accept more writes.
+     * completed. The `subscribe` pollable will become ready when the
+     * flush has completed and the stream can accept more writes.
      */
-    export function flush(this_: OutputStream): void;
     /**
      * Request to flush buffered output, and block until flush completes
      * and stream is ready for writing again.
      */
-    export function blockingFlush(this_: OutputStream): void;
     /**
      * Create a `pollable` which will resolve once the output-stream
      * is ready for more writing, or an error has occured. When this
@@ -146,7 +138,6 @@ export namespace WasiIoStreams {
      * Implementations may trap if the `output-stream` is dropped before
      * all derived `pollable`s created with this function are dropped.
      */
-    export function subscribeToOutputStream(this_: OutputStream): Pollable;
     /**
      * Write zeroes to a stream.
      * 
@@ -155,120 +146,109 @@ export namespace WasiIoStreams {
      * passing a list of bytes, you simply pass the number of zero-bytes
      * that should be written.
      */
-    export function writeZeroes(this_: OutputStream, len: bigint): void;
     /**
-     * Read from one stream and write to another.
+     * Perform a write of up to 4096 zeroes, and then flush the stream.
+     * Block until all of these operations are complete, or an error
+     * occurs.
      * 
-     * This function returns the number of bytes transferred; it may be less
-     * than `len`.
+     * This is a convenience wrapper around the use of `check-write`,
+     * `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+     * the following pseudo-code:
      * 
-     * Unlike other I/O functions, this function blocks until all the data
-     * read from the input stream has been written to the output stream.
-     */
-    export function splice(this_: OutputStream, src: InputStream, len: bigint): [bigint, StreamStatus];
+     * ```text
+     * let pollable = this.subscribe();
+     * while num_zeroes != 0 {
+       * // Wait for the stream to become writable
+       * poll-one(pollable);
+       * let Ok(n) = this.check-write(); // eliding error handling
+       * let len = min(n, num_zeroes);
+       * this.write-zeroes(len);         // eliding error handling
+       * num_zeroes -= len;
+       * }
+       * this.flush();
+       * // Wait for completion of `flush`
+       * poll-one(pollable);
+       * // Check for any errors that arose during `flush`
+       * let _ = this.check-write();         // eliding error handling
+       * ```
+       */
+      /**
+       * Read from one stream and write to another.
+       * 
+       * This function returns the number of bytes transferred; it may be less
+       * than `len`.
+       * 
+       * Unlike other I/O functions, this function blocks until all the data
+       * read from the input stream has been written to the output stream.
+       */
+      /**
+       * Read from one stream and write to another, with blocking.
+       * 
+       * This is similar to `splice`, except that it blocks until at least
+       * one byte can be read.
+       */
+      /**
+       * Forward the entire contents of an input stream to an output stream.
+       * 
+       * This function repeatedly reads from the input stream and writes
+       * the data to the output stream, until the end of the input stream
+       * is reached, or an error is encountered.
+       * 
+       * Unlike other I/O functions, this function blocks until the end
+       * of the input stream is seen and all the data has been written to
+       * the output stream.
+       * 
+       * This function returns the number of bytes transferred, and the status of
+       * the output stream.
+       */
+    }
+    import type { Pollable } from '../interfaces/wasi-io-poll';
+    export { Pollable };
     /**
-     * Read from one stream and write to another, with blocking.
-     * 
-     * This is similar to `splice`, except that it blocks until at least
-     * one byte can be read.
+     * An error for input-stream and output-stream operations.
      */
-    export function blockingSplice(this_: OutputStream, src: InputStream, len: bigint): [bigint, StreamStatus];
+    export type StreamError = StreamErrorLastOperationFailed | StreamErrorClosed;
     /**
-     * Forward the entire contents of an input stream to an output stream.
-     * 
-     * This function repeatedly reads from the input stream and writes
-     * the data to the output stream, until the end of the input stream
-     * is reached, or an error is encountered.
+     * The last operation (a write or flush) failed before completion.
      * 
-     * Unlike other I/O functions, this function blocks until the end
-     * of the input stream is seen and all the data has been written to
-     * the output stream.
-     * 
-     * This function returns the number of bytes transferred, and the status of
-     * the output stream.
+     * More information is available in the `error` payload.
      */
-    export function forward(this_: OutputStream, src: InputStream): [bigint, StreamStatus];
+    export interface StreamErrorLastOperationFailed {
+      tag: 'last-operation-failed',
+      val: Error,
+    }
     /**
-     * Dispose of the specified `output-stream`, after which it may no longer
-     * be used.
-     * Implementations may trap if this `output-stream` is dropped while
-     * child `pollable` resources are still alive.
-     * After this `output-stream` is dropped, implementations may report any
-     * corresponding `input-stream` has `stream-state.closed`.
+     * The stream is closed: no more input will be accepted by the
+     * stream. A closed output-stream will return this error on all
+     * future operations.
      */
-    export function dropOutputStream(this_: OutputStream): void;
-  }
-  import type { Pollable } from '../interfaces/wasi-poll-poll';
-  export { Pollable };
-  /**
-   * Streams provide a sequence of data and then end; once they end, they
-   * no longer provide any further data.
-   * 
-   * For example, a stream reading from a file ends when the stream reaches
-   * the end of the file. For another example, a stream reading from a
-   * socket ends when the socket is closed.
-   * # Variants
-   * 
-   * ## `"open"`
-   * 
-   * The stream is open and may produce further data.
-   * ## `"ended"`
-   * 
-   * When reading, this indicates that the stream will not produce
-   * further data.
-   * When writing, this indicates that the stream will no longer be read.
-   * Further writes are still permitted.
-   */
-  export type StreamStatus = 'open' | 'ended';
-  /**
-   * An input bytestream. In the future, this will be replaced by handle
-   * types.
-   * 
-   * `input-stream`s are *non-blocking* to the extent practical on underlying
-   * platforms. I/O operations always return promptly; if fewer bytes are
-   * promptly available than requested, they return the number of bytes promptly
-   * available, which could even be zero. To wait for data to be available,
-   * use the `subscribe-to-input-stream` function to obtain a `pollable` which
-   * can be polled for using `wasi:poll/poll.poll_oneoff`.
-   * 
-   * And at present, it is a `u32` instead of being an actual handle, until
-   * the wit-bindgen implementation of handles and resources is ready.
-   * 
-   * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
-   */
-  export type InputStream = number;
-  /**
-   * An output bytestream. In the future, this will be replaced by handle
-   * types.
-   * 
-   * `output-stream`s are *non-blocking* to the extent practical on
-   * underlying platforms. Except where specified otherwise, I/O operations also
-   * always return promptly, after the number of bytes that can be written
-   * promptly, which could even be zero. To wait for the stream to be ready to
-   * accept data, the `subscribe-to-output-stream` function to obtain a
-   * `pollable` which can be polled for using `wasi:poll`.
-   * 
-   * And at present, it is a `u32` instead of being an actual handle, until
-   * the wit-bindgen implementation of handles and resources is ready.
-   * 
-   * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
-   */
-  export type OutputStream = number;
-  /**
-   * An error for output-stream operations.
-   * 
-   * Contrary to input-streams, a closed output-stream is reported using
-   * an error.
-   * # Variants
-   * 
-   * ## `"last-operation-failed"`
-   * 
-   * The last operation (a write or flush) failed before completion.
-   * ## `"closed"`
-   * 
-   * The stream is closed: no more input will be accepted by the
-   * stream. A closed output-stream will return this error on all
-   * future operations.
-   */
-  export type WriteError = 'last-operation-failed' | 'closed';
-  
+    export interface StreamErrorClosed {
+      tag: 'closed',
+    }
+    
+    export class OutputStream {
+      checkWrite(): bigint;
+      write(contents: Uint8Array): void;
+      blockingWriteAndFlush(contents: Uint8Array): void;
+      flush(): void;
+      blockingFlush(): void;
+      subscribe(): Pollable;
+      writeZeroes(len: bigint): void;
+      blockingWriteZeroesAndFlush(len: bigint): void;
+      splice(src: InputStream, len: bigint): bigint;
+      blockingSplice(src: InputStream, len: bigint): bigint;
+      forward(src: InputStream): bigint;
+    }
+    
+    export class Error {
+      toDebugString(): string;
+    }
+    
+    export class InputStream {
+      read(len: bigint): Uint8Array;
+      blockingRead(len: bigint): Uint8Array;
+      skip(len: bigint): bigint;
+      blockingSkip(len: bigint): bigint;
+      subscribe(): Pollable;
+    }
+    

package/types/interfaces/wasi-random-random.d.ts

@@ -1,22 +1,24 @@
 export namespace WasiRandomRandom {
   /**
-   * Return `len` cryptographically-secure pseudo-random bytes.
+   * Return `len` cryptographically-secure random or pseudo-random bytes.
    * 
-   * This function must produce data from an adequately seeded
-   * cryptographically-secure pseudo-random number generator (CSPRNG), so it
-   * must not block, from the perspective of the calling program, and the
-   * returned data is always unpredictable.
+   * This function must produce data at least as cryptographically secure and
+   * fast as an adequately seeded cryptographically-secure pseudo-random
+   * number generator (CSPRNG). It must not block, from the perspective of
+   * the calling program, under any circumstances, including on the first
+   * request and on requests for numbers of bytes. The returned data must
+   * always be unpredictable.
    * 
-   * This function must always return fresh pseudo-random data. Deterministic
-   * environments must omit this function, rather than implementing it with
-   * deterministic data.
+   * This function must always return fresh data. Deterministic environments
+   * must omit this function, rather than implementing it with deterministic
+   * data.
    */
   export function getRandomBytes(len: bigint): Uint8Array;
   /**
-   * Return a cryptographically-secure pseudo-random `u64` value.
+   * Return a cryptographically-secure random or pseudo-random `u64` value.
    * 
-   * This function returns the same type of pseudo-random data as
-   * `get-random-bytes`, represented as a `u64`.
+   * This function returns the same type of data as `get-random-bytes`,
+   * represented as a `u64`.
    */
   export function getRandomU64(): bigint;
 }

package/types/interfaces/wasi-sockets-ip-name-lookup.d.ts

@@ -21,9 +21,9 @@ export namespace WasiSocketsIpNameLookup {
    * to `resolve-next-address` never returns `ok(none)`. This may change in the future.
    * 
    * # Typical errors
-   * - `invalid-name`:                 `name` is a syntactically invalid domain name.
-   * - `invalid-name`:                 `name` is an IP address.
-   * - `address-family-not-supported`: The specified `address-family` is not supported. (EAI_FAMILY)
+   * - `invalid-argument`:     `name` is a syntactically invalid domain name.
+   * - `invalid-argument`:     `name` is an IP address.
+   * - `not-supported`:        The specified `address-family` is not supported. (EAI_FAMILY)
    * 
    * # References:
    * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
@@ -38,7 +38,6 @@ export namespace WasiSocketsIpNameLookup {
    * This function should be called multiple times. On each call, it will
    * return the next address in connection order preference. If all
    * addresses have been exhausted, this function returns `none`.
-   * After which, you should release the stream with `drop-resolve-address-stream`.
    * 
    * This function never returns IPv4-mapped IPv6 addresses.
    * 
@@ -48,22 +47,15 @@ export namespace WasiSocketsIpNameLookup {
    * - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
    * - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
    */
-  export function resolveNextAddress(this_: ResolveAddressStream): IpAddress | undefined;
-  /**
-   * Dispose of the specified `resolve-address-stream`, after which it may no longer be used.
-   * 
-   * Note: this function is scheduled to be removed when Resources are natively supported in Wit.
-   */
-  export function dropResolveAddressStream(this_: ResolveAddressStream): void;
+  export { ResolveAddressStream };
   /**
    * Create a `pollable` which will resolve once the stream is ready for I/O.
    * 
    * Note: this function is here for WASI Preview2 only.
    * It's planned to be removed when `future` is natively supported in Preview3.
    */
-  export function subscribe(this_: ResolveAddressStream): Pollable;
 }
-import type { Pollable } from '../interfaces/wasi-poll-poll';
+import type { Pollable } from '../interfaces/wasi-io-poll';
 export { Pollable };
 import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };
@@ -73,4 +65,8 @@ import type { IpAddress } from '../interfaces/wasi-sockets-network';
 export { IpAddress };
 import type { IpAddressFamily } from '../interfaces/wasi-sockets-network';
 export { IpAddressFamily };
-export type ResolveAddressStream = number;
+
+export class ResolveAddressStream {
+  resolveNextAddress(): IpAddress | undefined;
+  subscribe(): Pollable;
+}

package/types/interfaces/wasi-sockets-network.d.ts

@@ -1,19 +1,5 @@
 export namespace WasiSocketsNetwork {
-  /**
-   * Dispose of the specified `network`, after which it may no longer be used.
-   * 
-   * Note: this function is scheduled to be removed when Resources are natively supported in Wit.
-   */
-  export function dropNetwork(this_: Network): void;
 }
-/**
- * An opaque resource that represents access to (a subset of) the network.
- * This enables context-based security for networking.
- * There is no need for this to map 1:1 to a physical network interface.
- * 
- * FYI, In the future this will be replaced by handle types.
- */
-export type Network = number;
 /**
  * Error codes.
  * 
@@ -24,6 +10,7 @@ export type Network = number;
  * - `access-denied`
  * - `not-supported`
  * - `out-of-memory`
+ * - `concurrency-conflict`
  * 
  * See each individual API for what the POSIX equivalents are. They sometimes differ per API.
  * # Variants
@@ -41,6 +28,11 @@ export type Network = number;
  * The operation is not supported.
  * 
  * POSIX equivalent: EOPNOTSUPP
+ * ## `"invalid-argument"`
+ * 
+ * One of the arguments is invalid.
+ * 
+ * POSIX equivalent: EINVAL
  * ## `"out-of-memory"`
  * 
  * Not enough memory to complete the operation.
@@ -52,6 +44,8 @@ export type Network = number;
  * ## `"concurrency-conflict"`
  * 
  * This operation is incompatible with another asynchronous operation that is already in progress.
+ * 
+ * POSIX equivalent: EALREADY
  * ## `"not-in-progress"`
  * 
  * Trying to finish an asynchronous operation that:
@@ -64,68 +58,32 @@ export type Network = number;
  * The operation has been aborted because it could not be completed immediately.
  * 
  * Note: this is scheduled to be removed when `future`s are natively supported.
- * ## `"address-family-not-supported"`
- * 
- * The specified address-family is not supported.
- * ## `"address-family-mismatch"`
- * 
- * An IPv4 address was passed to an IPv6 resource, or vice versa.
- * ## `"invalid-remote-address"`
- * 
- * The socket address is not a valid remote address. E.g. the IP address is set to INADDR_ANY, or the port is set to 0.
- * ## `"ipv4-only-operation"`
- * 
- * The operation is only supported on IPv4 resources.
- * ## `"ipv6-only-operation"`
+ * ## `"invalid-state"`
  * 
- * The operation is only supported on IPv6 resources.
+ * The operation is not valid in the socket's current state.
  * ## `"new-socket-limit"`
  * 
  * A new socket resource could not be created because of a system limit.
- * ## `"already-attached"`
- * 
- * The socket is already attached to another network.
- * ## `"already-bound"`
- * 
- * The socket is already bound.
- * ## `"already-connected"`
- * 
- * The socket is already in the Connection state.
- * ## `"not-bound"`
- * 
- * The socket is not bound to any local address.
- * ## `"not-connected"`
- * 
- * The socket is not in the Connection state.
  * ## `"address-not-bindable"`
  * 
  * A bind operation failed because the provided address is not an address that the `network` can bind to.
  * ## `"address-in-use"`
  * 
- * A bind operation failed because the provided address is already in use.
- * ## `"ephemeral-ports-exhausted"`
- * 
- * A bind operation failed because there are no ephemeral ports available.
+ * A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
  * ## `"remote-unreachable"`
  * 
  * The remote address is not reachable
- * ## `"already-listening"`
- * 
- * The socket is already in the Listener state.
- * ## `"not-listening"`
- * 
- * The socket is already in the Listener state.
  * ## `"connection-refused"`
  * 
  * The connection was forcefully rejected
  * ## `"connection-reset"`
  * 
  * The connection was reset.
- * ## `"datagram-too-large"`
+ * ## `"connection-aborted"`
  * 
- * ## `"invalid-name"`
+ * A connection was aborted.
+ * ## `"datagram-too-large"`
  * 
- * The provided name is a syntactically invalid domain name.
  * ## `"name-unresolvable"`
  * 
  * Name does not exist or has no suitable associated IP addresses.
@@ -136,7 +94,7 @@ export type Network = number;
  * 
  * A permanent failure in name resolution occurred.
  */
-export type ErrorCode = 'unknown' | 'access-denied' | 'not-supported' | 'out-of-memory' | 'timeout' | 'concurrency-conflict' | 'not-in-progress' | 'would-block' | 'address-family-not-supported' | 'address-family-mismatch' | 'invalid-remote-address' | 'ipv4-only-operation' | 'ipv6-only-operation' | 'new-socket-limit' | 'already-attached' | 'already-bound' | 'already-connected' | 'not-bound' | 'not-connected' | 'address-not-bindable' | 'address-in-use' | 'ephemeral-ports-exhausted' | 'remote-unreachable' | 'already-listening' | 'not-listening' | 'connection-refused' | 'connection-reset' | 'datagram-too-large' | 'invalid-name' | 'name-unresolvable' | 'temporary-resolver-failure' | 'permanent-resolver-failure';
+export type ErrorCode = 'unknown' | 'access-denied' | 'not-supported' | 'invalid-argument' | 'out-of-memory' | 'timeout' | 'concurrency-conflict' | 'not-in-progress' | 'would-block' | 'invalid-state' | 'new-socket-limit' | 'address-not-bindable' | 'address-in-use' | 'remote-unreachable' | 'connection-refused' | 'connection-reset' | 'connection-aborted' | 'datagram-too-large' | 'name-unresolvable' | 'temporary-resolver-failure' | 'permanent-resolver-failure';
 /**
  * # Variants
  * 

package/types/interfaces/wasi-sockets-tcp-create-socket.d.ts

@@ -11,9 +11,8 @@ export namespace WasiSocketsTcpCreateSocket {
    * All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
    * 
    * # Typical errors
-   * - `not-supported`:                The host does not support TCP sockets. (EOPNOTSUPP)
-   * - `address-family-not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT)
-   * - `new-socket-limit`:             The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+   * - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+   * - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
    * 
    * # References
    * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>