* Updates stats information from the fuzzer.

* Emits the given stat to the output stream.

* Stores the artifact in the set.

* Returns the slice of the buffer that has been written but not read yet. * This will share memory with the underlying buffer and is NOT safe to

* Gets all inputs from the set.

* Returns the number of unread bytes in the buffer.

* Prepends the list of statements to the provided expression and returns it.

* Gets the underlying buffer size.

* Advances the read pointer by the given amount.

* Attaches an ipc reader/writer to the streams.

* Runs the mutation on the buffer, returning a new buffer. If the * mutation can't be run right now, this will return null.

* Instruments the provided code with branch analysis instructions.

* Kills the underlying process and returns a promise that's resolved * when the process exits. The process will be forcefully terminated * if it

* Adds a new literal that can be used for mutations.

* Emits the fatal error to the output stream.

* Wraps the node as a block statement if it isn't already on.

* Returns a relative time in microseconds.

* Returns whether this input resulted in more interesting behavior * that the other one. This is mostly ported from go-fuzz * @see https://git.i

* Hooks the transformation function into Node's require(). Returns a * function that can be used to unhook it.

* Prepends the list of statements to the provided block and returns it. If * the block to be prepended to is already a BlockExpression, we'll just *

* Stores the work summary and the coverage file.

* Stops the server.

* Boots the cluster.

* Deserializes the input string to a qualified Input object

* Creates a new Worker instance and returns a promise that resolves * when it has signaled it's ready.

* Creates an ES node that calls an expression on the runtime.

* Detaches the instrumenter from intercepting new code.

* Detects and returns all literals in files required synchronously within * the given function.

* Evens off the statement count in the coverage into count "buckets" and * returns the sum of all buckets.

* Returns all inputs stored in the corpus.

* Grows the underlying buffer to ensure there's space to write the * provided message.

* Installs the runtime global.

* Walks and instruments the AST tree.

* Returns if we're interested in getting a full summary report for the * the given hash.

* Attempts to load a corpus from its serialized version.

* Hooks into events on the worker and reboots it if it dies.

* Peeks at the next byte in the buffer, advancing the read pointer.

* Returns an input, weighting by its score.

* Sends new work to the working process.

* Does a quick smoke test to see if the module looks like it's set up * correctly to fuzz, throwing an error if it isn't.

* Sends new work to the working process.

* Serializes an input into a string.

* Returns the number of items in our store.

* Serializes the corpus and saves it on the disk.

* Store the error that occurred as a result of the input.

* Returns that a timeout occurred as a result of the provided input.

* Hooks the instrumenter into the require() statement.

* Shuts down the reporter.