get writable() {
        // Prevent multiple streaming operations from taking place
        const scope = this;
        if (this.#stream)
            throw new Error(
                'Websocket.writable -> You may only access and utilize one writable stream at any given time. Make sure you are not already streaming or piping a stream to this websocket.'
            );

        // Create a new writable stream object which will write with the _write method
        let is_first = true;
        this.#stream = new Writable({
            write: (chunk, encoding, callback) => {
                // Buffer the incoming chunk as a fragment
                const fragment = scope._buffer_fragment(chunk);

                // Check to see if we have a fragment to send post buffering
                if (fragment) {
                    // Write the current retrieved fragment
                    scope._write(is_first ? FRAGMENTS.FIRST : FRAGMENTS.MIDDLE, fragment, true, false, callback);

                    // Invert the is_first boolean after first fragment
                    if (is_first) is_first = false;
                } else {
                    // Trigger the callback even if don't have a fragment to continue consuming
                    callback();
                }
            },
        });

        // Create a callback for ending the writable usage
        const end_stream = () => {
            // Retrieve the last buffered fragment to write as last or only chunk
            const fragment = scope._buffer_fragment();

            if (is_first) {
                scope.#ws.send(fragment, true, false);
                scope.#ws.stream = undefined;
            } else {
                // Write the final empty chunk as last fragment and cleanup the writable
                scope._write(FRAGMENTS.LAST, fragment, true, false, () => (scope.#stream = undefined));
            }
        };

        // Bind listeners to end the fragmented write procedure
        this.#stream.on('finish', end_stream);

        // Return the writable stream
        return this.#stream;
    }
Returns a Writable stream associated with this response to be used for piping streams.
Note! You can only retrieve/use only one writable at any given time.

@returns {Writable}