@cosmonic-labs/openapi2mcp 0.10.0 → 0.10.2

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-io-error.d.ts

@@ -0,0 +1,18 @@
+/** @module Interface wasi:io/error@0.2.3 **/
+
+export class Error {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns a string that is suitable to assist humans in debugging
+  * this error.
+  * 
+  * WARNING: The returned string should not be consumed mechanically!
+  * It may change across platforms, hosts, or other implementation
+  * details. Parsing this string is a major platform-compatibility
+  * hazard.
+  */
+  toDebugString(): string;
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-io-poll.d.ts

@@ -0,0 +1,44 @@
+/** @module Interface wasi:io/poll@0.2.3 **/
+/**
+ * Poll for completion on a set of pollables.
+ * 
+ * This function takes a list of pollables, which identify I/O sources of
+ * interest, and waits until one or more of the events is ready for I/O.
+ * 
+ * The result `list<u32>` contains one or more indices of handles in the
+ * argument list that is ready for I/O.
+ * 
+ * This function traps if either:
+ * - the list is empty, or:
+ * - the list contains more elements than can be indexed with a `u32` value.
+ * 
+ * A timeout can be implemented by adding a pollable from the
+ * wasi-clocks API to the list.
+ * 
+ * This function does not return a `result`; polling in itself does not
+ * do any I/O so it doesn't fail. If any of the I/O sources identified by
+ * the pollables has an error, it is indicated by marking the source as
+ * being ready for I/O.
+ */
+export function poll(in_: Array<Pollable>): Uint32Array;
+
+export class Pollable {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Return the readiness of a pollable. This function never blocks.
+  * 
+  * Returns `true` when the pollable is ready, and `false` otherwise.
+  */
+  ready(): boolean;
+  /**
+  * `block` returns immediately if the pollable is ready, and otherwise
+  * blocks until ready.
+  * 
+  * This function is equivalent to calling `poll.poll` on a list
+  * containing only this pollable.
+  */
+  block(): void;
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-io-streams.d.ts

@@ -0,0 +1,243 @@
+/** @module Interface wasi:io/streams@0.2.3 **/
+export type Error = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+/**
+ * An error for input-stream and output-stream operations.
+ */
+export type StreamError = StreamErrorLastOperationFailed | StreamErrorClosed;
+/**
+ * The last operation (a write or flush) failed before completion.
+ * 
+ * More information is available in the `error` payload.
+ * 
+ * After this, the stream will be closed. All future operations return
+ * `stream-error::closed`.
+ */
+export interface StreamErrorLastOperationFailed {
+  tag: 'last-operation-failed',
+  val: Error,
+}
+/**
+ * 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 interface StreamErrorClosed {
+  tag: 'closed',
+}
+
+export class InputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Perform a non-blocking read from the stream.
+  * 
+  * When the source of a `read` is binary data, the bytes from the source
+  * are returned verbatim. When the source of a `read` is known to the
+  * implementation to be text, bytes containing the UTF-8 encoding of the
+  * text are returned.
+  * 
+  * This function returns a list of bytes containing the read data,
+  * when successful. The returned list will contain up to `len` bytes;
+  * it may return fewer than requested, but not more. The list is
+  * empty when no bytes are available for reading at this time. The
+  * pollable given by `subscribe` will be ready when more bytes are
+  * available.
+  * 
+  * This function fails with a `stream-error` when the operation
+  * encounters an error, giving `last-operation-failed`, or when the
+  * stream is closed, giving `closed`.
+  * 
+  * When the caller gives a `len` of 0, it represents a request to
+  * read 0 bytes. If the stream is still open, this call should
+  * succeed and return an empty list, or otherwise fail with `closed`.
+  * 
+  * The `len` parameter is a `u64`, which could represent a list of u8 which
+  * is not possible to allocate in wasm32, or not desirable to allocate as
+  * 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.
+  */
+  read(len: bigint): Uint8Array;
+  /**
+  * Read bytes from a stream, after blocking until at least one byte can
+  * be read. Except for blocking, behavior is identical to `read`.
+  */
+  blockingRead(len: bigint): Uint8Array;
+  /**
+  * Skip bytes from a stream. Returns number of bytes skipped.
+  * 
+  * Behaves identical to `read`, except instead of returning a list
+  * of bytes, returns the number of bytes consumed from the stream.
+  */
+  skip(len: bigint): bigint;
+  /**
+  * Skip bytes from a stream, after blocking until at least one byte
+  * can be skipped. Except for blocking behavior, identical to `skip`.
+  */
+  blockingSkip(len: bigint): bigint;
+  /**
+  * 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
+  * closed.
+  * The created `pollable` is a child resource of the `input-stream`.
+  * Implementations may trap if the `input-stream` is dropped before
+  * all derived `pollable`s created with this function are dropped.
+  */
+  subscribe(): Pollable;
+}
+
+export class OutputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Check readiness for writing. This function never blocks.
+  * 
+  * Returns the number of bytes permitted for the next call to `write`,
+  * or an error. Calling `write` with more bytes than this function has
+  * permitted will trap.
+  * 
+  * When this function returns 0 bytes, the `subscribe` pollable will
+  * become ready when this function will report at least 1 byte, or an
+  * error.
+  */
+  checkWrite(): bigint;
+  /**
+  * Perform a write. This function never blocks.
+  * 
+  * When the destination of a `write` is binary data, the bytes from
+  * `contents` are written verbatim. When the destination of a `write` is
+  * known to the implementation to be text, the bytes of `contents` are
+  * transcoded from UTF-8 into the encoding of the destination and then
+  * written.
+  * 
+  * Precondition: check-write gave permit of Ok(n) and contents has a
+  * length of less than or equal to n. Otherwise, this function will trap.
+  * 
+  * returns Err(closed) without writing if the stream has closed since
+  * the last call to check-write provided a permit.
+  */
+  write(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`, `write`, and `flush`, and is implemented with the
+  * following pseudo-code:
+  * 
+  * ```text
+  * let pollable = this.subscribe();
+  * while !contents.is_empty() {
+    *     // Wait for the stream to become writable
+    *     pollable.block();
+    *     let Ok(n) = this.check-write(); // eliding error handling
+    *     let len = min(n, contents.len());
+    *     let (chunk, rest) = contents.split_at(len);
+    *     this.write(chunk  );            // eliding error handling
+    *     contents = rest;
+    * }
+    * this.flush();
+    * // Wait for completion of `flush`
+    * pollable.block();
+    * // Check for any errors that arose during `flush`
+    * let _ = this.check-write();         // eliding error handling
+    * ```
+    */
+    blockingWriteAndFlush(contents: Uint8Array): void;
+    /**
+    * Request to flush buffered output. This function never blocks.
+    * 
+    * This tells the output-stream that the caller intends any buffered
+    * output to be flushed. the output which is expected to be flushed
+    * is all that has been passed to `write` prior to this call.
+    * 
+    * 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` pollable will become ready when the
+    * flush has completed and the stream can accept more writes.
+    */
+    flush(): void;
+    /**
+    * Request to flush buffered output, and block until flush completes
+    * and stream is ready for writing again.
+    */
+    blockingFlush(): void;
+    /**
+    * Create a `pollable` which will resolve once the output-stream
+    * is ready for more writing, or an error has occurred. When this
+    * pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+    * error.
+    * 
+    * If the stream is closed, this pollable is always ready immediately.
+    * 
+    * The created `pollable` is a child resource of the `output-stream`.
+    * Implementations may trap if the `output-stream` is dropped before
+    * all derived `pollable`s created with this function are dropped.
+    */
+    subscribe(): Pollable;
+    /**
+    * Write zeroes to a stream.
+    * 
+    * This should be used precisely like `write` with the exact same
+    * preconditions (must use check-write first), but instead of
+    * passing a list of bytes, you simply pass the number of zero-bytes
+    * that should be written.
+    */
+    writeZeroes(len: bigint): void;
+    /**
+    * 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 is a convenience wrapper around the use of `check-write`,
+    * `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+    * the following pseudo-code:
+    * 
+    * ```text
+    * let pollable = this.subscribe();
+    * while num_zeroes != 0 {
+      *     // Wait for the stream to become writable
+      *     pollable.block();
+      *     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`
+      * pollable.block();
+      * // Check for any errors that arose during `flush`
+      * let _ = this.check-write();         // eliding error handling
+      * ```
+      */
+      blockingWriteZeroesAndFlush(len: bigint): void;
+      /**
+      * Read from one stream and write to another.
+      * 
+      * The behavior of splice is equivalent to:
+      * 1. calling `check-write` on the `output-stream`
+      * 2. calling `read` on the `input-stream` with the smaller of the
+      * `check-write` permitted length and the `len` provided to `splice`
+      * 3. calling `write` on the `output-stream` with that read data.
+      * 
+      * Any error reported by the call to `check-write`, `read`, or
+      * `write` ends the splice and reports that error.
+      * 
+      * This function returns the number of bytes transferred; it may be less
+      * than `len`.
+      */
+      splice(src: InputStream, len: bigint): bigint;
+      /**
+      * Read from one stream and write to another, with blocking.
+      * 
+      * This is similar to `splice`, except that it blocks until the
+      * `output-stream` is ready for writing, and the `input-stream`
+      * is ready for reading, before performing the `splice`.
+      */
+      blockingSplice(src: InputStream, len: bigint): bigint;
+    }
+    

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-random-insecure-seed.d.ts

@@ -0,0 +1,21 @@
+/** @module Interface wasi:random/insecure-seed@0.2.3 **/
+/**
+ * Return a 128-bit value that may contain a pseudo-random value.
+ * 
+ * The returned value is not required to be computed from a CSPRNG, and may
+ * even be entirely deterministic. Host implementations are encouraged to
+ * provide pseudo-random values to any program exposed to
+ * attacker-controlled content, to enable DoS protection built into many
+ * languages' hash-map implementations.
+ * 
+ * This function is intended to only be called once, by a source language
+ * to initialize Denial Of Service (DoS) protection in its hash-map
+ * implementation.
+ * 
+ * # Expected future evolution
+ * 
+ * This will likely be changed to a value import, to prevent it from being
+ * called multiple times and potentially used for purposes other than DoS
+ * protection.
+ */
+export function insecureSeed(): [bigint, bigint];

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-random-insecure.d.ts

@@ -0,0 +1,19 @@
+/** @module Interface wasi:random/insecure@0.2.3 **/
+/**
+ * Return `len` insecure pseudo-random bytes.
+ * 
+ * This function is not cryptographically secure. Do not use it for
+ * anything related to security.
+ * 
+ * There are no requirements on the values of the returned bytes, however
+ * implementations are encouraged to return evenly distributed values with
+ * a long period.
+ */
+export function getInsecureRandomBytes(len: bigint): Uint8Array;
+/**
+ * Return an insecure pseudo-random `u64` value.
+ * 
+ * This function returns the same type of pseudo-random data as
+ * `get-insecure-random-bytes`, represented as a `u64`.
+ */
+export function getInsecureRandomU64(): bigint;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-random-random.d.ts

@@ -0,0 +1,23 @@
+/** @module Interface wasi:random/random@0.2.3 **/
+/**
+ * Return `len` cryptographically-secure random or pseudo-random bytes.
+ * 
+ * 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 data. Deterministic environments
+ * must omit this function, rather than implementing it with deterministic
+ * data.
+ */
+export function getRandomBytes(len: bigint): Uint8Array;
+/**
+ * Return a cryptographically-secure random or pseudo-random `u64` value.
+ * 
+ * This function returns the same type of data as `get-random-bytes`,
+ * represented as a `u64`.
+ */
+export function getRandomU64(): bigint;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-sockets-instance-network.d.ts

@@ -0,0 +1,6 @@
+/** @module Interface wasi:sockets/instance-network@0.2.3 **/
+/**
+ * Get a handle to the default network.
+ */
+export function instanceNetwork(): Network;
+export type Network = import('./wasi-sockets-network.js').Network;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-sockets-ip-name-lookup.d.ts

@@ -0,0 +1,58 @@
+/** @module Interface wasi:sockets/ip-name-lookup@0.2.3 **/
+/**
+ * Resolve an internet host name to a list of IP addresses.
+ * 
+ * Unicode domain names are automatically converted to ASCII using IDNA encoding.
+ * If the input is an IP address string, the address is parsed and returned
+ * as-is without making any external requests.
+ * 
+ * See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+ * 
+ * This function never blocks. It either immediately fails or immediately
+ * returns successfully with a `resolve-address-stream` that can be used
+ * to (asynchronously) fetch the results.
+ * 
+ * # Typical errors
+ * - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+ * 
+ * # References:
+ * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+ * - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+ * - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+ * - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+ */
+export function resolveAddresses(network: Network, name: string): ResolveAddressStream;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+export type Network = import('./wasi-sockets-network.js').Network;
+export type ErrorCode = import('./wasi-sockets-network.js').ErrorCode;
+export type IpAddress = import('./wasi-sockets-network.js').IpAddress;
+
+export class ResolveAddressStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns the next address from the resolver.
+  * 
+  * 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`.
+  * 
+  * This function never returns IPv4-mapped IPv6 addresses.
+  * 
+  * # Typical errors
+  * - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+  * - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
+  * - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
+  * - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+  */
+  resolveNextAddress(): IpAddress | undefined;
+  /**
+  * Create a `pollable` which will resolve once the stream is ready for I/O.
+  * 
+  * Note: this function is here for WASI 0.2 only.
+  * It's planned to be removed when `future` is natively supported in Preview3.
+  */
+  subscribe(): Pollable;
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-sockets-network.d.ts

@@ -0,0 +1,164 @@
+/** @module Interface wasi:sockets/network@0.2.3 **/
+/**
+ * Error codes.
+ * 
+ * In theory, every API can return any error code.
+ * In practice, API's typically only return the errors documented per API
+ * combined with a couple of errors that are always possible:
+ * - `unknown`
+ * - `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
+ * 
+ * ## `"unknown"`
+ * 
+ * Unknown error
+ * ## `"access-denied"`
+ * 
+ * Access denied.
+ * 
+ * POSIX equivalent: EACCES, EPERM
+ * ## `"not-supported"`
+ * 
+ * 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.
+ * 
+ * POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+ * ## `"timeout"`
+ * 
+ * The operation timed out before it could finish completely.
+ * ## `"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:
+ * - has not been started yet, or:
+ * - was already finished by a previous `finish-*` call.
+ * 
+ * Note: this is scheduled to be removed when `future`s are natively supported.
+ * ## `"would-block"`
+ * 
+ * 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.
+ * ## `"invalid-state"`
+ * 
+ * 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.
+ * ## `"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 or because there are no ephemeral ports available.
+ * ## `"remote-unreachable"`
+ * 
+ * The remote address is not reachable
+ * ## `"connection-refused"`
+ * 
+ * The TCP connection was forcefully rejected
+ * ## `"connection-reset"`
+ * 
+ * The TCP connection was reset.
+ * ## `"connection-aborted"`
+ * 
+ * A TCP connection was aborted.
+ * ## `"datagram-too-large"`
+ * 
+ * The size of a datagram sent to a UDP socket exceeded the maximum
+ * supported size.
+ * ## `"name-unresolvable"`
+ * 
+ * Name does not exist or has no suitable associated IP addresses.
+ * ## `"temporary-resolver-failure"`
+ * 
+ * A temporary failure in name resolution occurred.
+ * ## `"permanent-resolver-failure"`
+ * 
+ * A permanent failure in name resolution occurred.
+ */
+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
+ * 
+ * ## `"ipv4"`
+ * 
+ * Similar to `AF_INET` in POSIX.
+ * ## `"ipv6"`
+ * 
+ * Similar to `AF_INET6` in POSIX.
+ */
+export type IpAddressFamily = 'ipv4' | 'ipv6';
+export type Ipv4Address = [number, number, number, number];
+export type Ipv6Address = [number, number, number, number, number, number, number, number];
+export type IpAddress = IpAddressIpv4 | IpAddressIpv6;
+export interface IpAddressIpv4 {
+  tag: 'ipv4',
+  val: Ipv4Address,
+}
+export interface IpAddressIpv6 {
+  tag: 'ipv6',
+  val: Ipv6Address,
+}
+export interface Ipv4SocketAddress {
+  /**
+   * sin_port
+   */
+  port: number,
+  /**
+   * sin_addr
+   */
+  address: Ipv4Address,
+}
+export interface Ipv6SocketAddress {
+  /**
+   * sin6_port
+   */
+  port: number,
+  /**
+   * sin6_flowinfo
+   */
+  flowInfo: number,
+  /**
+   * sin6_addr
+   */
+  address: Ipv6Address,
+  /**
+   * sin6_scope_id
+   */
+  scopeId: number,
+}
+export type IpSocketAddress = IpSocketAddressIpv4 | IpSocketAddressIpv6;
+export interface IpSocketAddressIpv4 {
+  tag: 'ipv4',
+  val: Ipv4SocketAddress,
+}
+export interface IpSocketAddressIpv6 {
+  tag: 'ipv6',
+  val: Ipv6SocketAddress,
+}
+
+export class Network {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-sockets-tcp-create-socket.d.ts

@@ -0,0 +1,28 @@
+/** @module Interface wasi:sockets/tcp-create-socket@0.2.3 **/
+/**
+ * Create a new TCP socket.
+ * 
+ * Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+ * On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+ * 
+ * This function does not require a network capability handle. This is considered to be safe because
+ * at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect`
+ * is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+ * 
+ * All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+ * 
+ * # Typical errors
+ * - `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>
+ * - <https://man7.org/linux/man-pages/man2/socket.2.html>
+ * - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+ * - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+ */
+export function createTcpSocket(addressFamily: IpAddressFamily): TcpSocket;
+export type Network = import('./wasi-sockets-network.js').Network;
+export type ErrorCode = import('./wasi-sockets-network.js').ErrorCode;
+export type IpAddressFamily = import('./wasi-sockets-network.js').IpAddressFamily;
+export type TcpSocket = import('./wasi-sockets-tcp.js').TcpSocket;