firefly-compiler 0.4.36 → 0.4.46

package/webserver/WebServer.ff

@@ -1,685 +1,685 @@
-capability WebServer(
-    intenalSystem: NodeSystem
-    internalHost: String
-    internalPort: Int
-    mutable internalJsWebSockets: JsValue
-    mutable internalJsWildcard: JsValue
-    mutable internalJsHosts: Array[JsValue]
-    mutable internalJsApp: JsValue
-)
-
-class WebRequest[T](
-    internalJsApp: JsValue
-    internalJsContext: JsValue
-    internalMethod: String
-    internalPath: String
-    internalQuery: String
-    internalHeaders: StringMap[String]
-    internalJsResponse: JsValue
-    internalResponse: T
-    internalResponseHeaders: StringMap[String]
-    internalResponseChunks: Array[JsValue]
-    mutable internalResponseStatus: String
-    mutable internalCloseConnection: Bool
-    mutable internalResolveFlush: JsValue
-    mutable internalContentSize: Int
-    mutable internalResponded: Bool
-)
-
-capability WebResponse {}
-
-data MultipartField {}
-
-capability WebSocketConnection {}
-
-new(
-    system: NodeSystem
-    host: String
-    port: Int
-): WebServer {
-    WebServer(system, host, port, system.js().null(), system.js().null(), [].toArray(), system.js().null())
-}
-
-extend self: WebServer {
-    
-    enableWebSockets(
-        maxPayloadBytes: Int = 16384
-        maxBackpressureBytes: Int = 65536
-        closeDueToMaxBackpressureBytes: Bool = False
-        maxLifetime: Option[Duration] = None
-        idleTimeout: Option[Duration] = None
-    ) {
-        self.internalJsWebSockets = self.intenalSystem.js().object()
-        self.internalJsWebSockets.set("maxPayloadLength", maxPayloadBytes)
-        self.internalJsWebSockets.set("maxBackpressureBytes", maxBackpressureBytes)
-        self.internalJsWebSockets.set("closeOnBackpressureLimit", closeDueToMaxBackpressureBytes)
-        maxLifetime.each {self.internalJsWebSockets.set("maxLifetime", (_.seconds / 60).round().toInt())}
-        idleTimeout.each {self.internalJsWebSockets.set("idleTimeout", _.seconds.round().toInt())}
-    }
-    
-    addHost(
-        hostname: String
-        key: Option[Path] = None
-        certificate: Option[Path] = None
-        certificateAuthority: Option[Path] = None
-        passphrase: Option[String] = None
-        dhParameters: Option[Path] = None
-        ciphers: Option[String] = None
-        preferLowMemoryUsage: Bool = False
-    ) {
-        let object = self.intenalSystem.js().object().with("hostname", hostname)
-        key.each {object.set("key_file_name", _.absolute())}
-        certificate.each {object.set("cert_file_name", _.absolute())}
-        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
-        passphrase.each {object.set("passphrase", _)}
-        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
-        ciphers.each {object.set("ssl_ciphers", _)}
-        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
-        self.internalJsHosts.push(object)
-    }
-
-    setWildcard(
-        key: Option[Path] = None
-        certificate: Option[Path] = None
-        certificateAuthority: Option[Path] = None
-        passphrase: Option[String] = None
-        dhParameters: Option[Path] = None
-        ciphers: Option[String] = None
-        preferLowMemoryUsage: Bool = False
-    ) {
-        let object = self.intenalSystem.js().object()
-        key.each {object.set("key_file_name", _.absolute())}
-        certificate.each {object.set("cert_file_name", _.absolute())}
-        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
-        passphrase.each {object.set("passphrase", _)}
-        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
-        ciphers.each {object.set("ssl_ciphers", _)}
-        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
-        self.internalJsWildcard = object
-    }
-    
-    listen(handler: WebRequest[WebResponse] => Unit)
-        target node async """
-            import * as uws from 'uWebSockets.js'
-            ff_core_Task.Task_throwIfAborted($task);
-            await new Promise((resolveServer, rejectServer) => {
-                self_.internalJsApp_ = self_.internalJsWilcard_ ? uws.SSLApp(self_.internalJsWilcard_) 
-                    : self_.internalJsHosts_.array.some(h => h.key_file_name) ? uws.SSLApp() : uws.App();
-                self_.internalJsHosts_.array.forEach(h => self_.internalJsApp_.addServerName(h.hostname, h));
-                const handleRequest = (res, req, context) => {
-                    let abortedByUws = false;
-                    const method = req.getMethod();
-                    const path = req.getUrl();
-                    const query = req.getQuery() || '';
-                    const headers = new Map();
-                    req.forEach((key, value) => headers.set(key, value));
-                    const chunks = internalArray_();
-                    const task = ff_core_Task.Task_spawn($task, async task => {
-                        try {
-                            ff_core_Task.Task_throwIfAborted(task);
-                            const webRequest = WebRequest(
-                                self_.internalJsApp_, context, 
-                                method, path, query, headers, 
-                                res, null, 
-                                new Map(), internalArray_(), 
-                                "200 OK", false, null, -1, false
-                            );
-                            await handler_(webRequest, task);
-                            ff_core_Task.Task_throwIfAborted(task);
-                            if(context == null && !webRequest.internalResponded_ && webRequest.internalContentSize_ >= 0) {
-                                await WebRequest_flush$(webRequest, task);
-                                ff_core_Task.Task_throwIfAborted(task);
-                            }
-                            if(context == null && !webRequest.internalResponded_) await new Promise((resolve, reject) => {
-                                res.cork(() => {
-                                    try {
-                                        ff_core_Task.Task_throwIfAborted(task);
-                                        if(!webRequest.internalResolveFlush_) {
-                                            res.writeStatus(webRequest.internalResponseStatus_);
-                                            webRequest.internalResponseHeaders_.forEach((value, key) => res.writeHeader(key, value));
-                                        }
-                                        const chunk = internalChunksToChunk_(webRequest.internalResponseChunks_);
-                                        res.end(chunk, webRequest.internalCloseConnection_);
-                                        resolve();
-                                    } catch(e) {
-                                        reject(e);
-                                    }
-                                });
-                            });
-                        } catch(e) {
-                            if(!abortedByUws) console.error(e);
-                            if(!abortedByUws && context == null) res.cork(() => {
-                                if(!abortedByUws) res.writeStatus("500 Internal Server Error");
-                                if(!abortedByUws) res.end();
-                            });
-                        }
-                    });
-                    res.onAborted(() => {
-                        abortedByUws = true; 
-                        ff_core_Task.Task_abort(task);
-                    });
-                }
-                self_.internalJsApp_.any('/*', handleRequest);
-                if(self_.internalJsWebSockets_) self_.internalJsApp_.ws("/*", {
-                    ...self_.internalJsWebSockets_,
-                    upgrade: handleRequest,
-                    open: ws => ws.getUserData().onOpen(ws),
-                    message: (ws, m, b) => ws.getUserData().onMessage(m, b),
-                    close: ws => ws.getUserData().onClose(),
-                });
-                self_.internalJsApp_.listen(self_.internalHost_, self_.internalPort_, listenSocket => {
-                    if(listenSocket) {
-                        const abort = () => {
-                            $task.controller.signal.removeEventListener('abort', abort);
-                            uws.us_listen_socket_close(listenSocket);
-                            self_.internalJsApp_.close();
-                        }
-                        $task.controller.signal.addEventListener('abort', abort);
-                    } else {
-                        rejectServer();
-                    }
-                });
-            });
-        """
-    
-    publishBuffer(topic: String, message: Buffer) // Should this be corked?
-        target js async """
-            if(self_.internalJsApp_) self_.internalJsApp_.publish(topic_, message_.buffer, true);
-        """
-    
-    publishText(topic: String, message: String) // Should this be corked?
-        target js async """
-            if(self_.internalJsApp_) self_.internalJsApp_.publish(topic_, message_, false);
-        """
-    
-}
-
-extend self[T]: WebRequest[T] {
-
-    readMethod(): String {
-        self.internalMethod
-    }
-
-    readPath(): String {
-        self.internalPath
-    }
-
-    readRawQueryString(): String {
-        self.internalQuery
-    }
-
-    readQuery(name: String): Option[String]
-        target node sync """
-            if(self_.internalQuery_.length === 0) return ff_core_Option.None();
-            const ps = self_.internalQuery_.split('&');
-            const n = name_ + '=';
-            const r = ps.find(p => p === name_ || p.startsWith(n));
-            if(r == null) return ff_core_Option.None();
-            return ff_core_Option.Some(decodeURIComponent(r.slice(name_.length + 1)));
-        """
-    
-    readHeader(lowerCaseName: String): Option[String] {
-        self.internalHeaders.get(lowerCaseName)
-    }
-    
-    eachHeader(body: (String, String) => Unit) {
-        self.internalHeaders.each {body(_, _)}
-    }
-    
-}
-
-extend self[T]: WebRequest[T] {
-    
-    writeStatus(codeAndMessage: String) {
-        self.internalResponseStatus = codeAndMessage
-    }
-    
-    writeHeader(name: String, value: String) {
-        self.internalResponseHeaders.set(name, value)
-    }
-    
-    writeContentSize(contentSize: Int) {
-        if(contentSize >= 0) {
-            self.internalContentSize = contentSize
-        }
-    }
-
-    writeText(data: String) {
-        self.internalResponseChunks.push(internalTextChunk(data))
-    }
-
-    writeLine(data: String) {
-        self.writeText(data + "\n")
-    }
-
-    writeBuffer(data: Buffer) {
-        self.internalResponseChunks.push(internalBufferChunk(data))
-    }
-    
-    writeStream(data: Stream[Buffer]) {
-        data.each {self.writeBuffer(_)}
-    }
-
-}
-
-extend self[T]: WebRequest[T] {
-
-    publishBuffer(topic: String, message: Buffer) // Should this be corked?
-        target js sync """
-            self_.internalJsApp_.publish(topic_, message_.buffer, true);
-        """
-    
-    publishText(topic: String, message: String) // Should this be corked?
-        target js sync """
-            self_.internalJsApp_.publish(topic_, message_, false);
-        """
-    
-}
-
-extend self[T]: WebRequest[T] {
-    
-    closeConnection() {
-        self.internalCloseConnection = True
-    }
-    
-    readRemoteAddress(): String
-        target js sync """
-            return new TextDecoder().decode(self_.internalJsResponse_.getRemoteAddressAsText())
-        """
-
-    readProxiedRemoteAddress(): String
-        target js sync """
-            return new TextDecoder().decode(self_.internalJsResponse_.getProxiedRemoteAddressAsText())
-        """
-
-}
-
-extend self: WebRequest[WebResponse] {
-
-    flush()
-        target js async """
-            if(!self_.internalResolveFlush_) {
-                self_.internalResolveFlush_ = () => {};
-                self_.internalJsResponse_.cork(() => {
-                    self_.internalJsResponse_.writeStatus(self_.internalResponseStatus_);
-                    self_.internalResponseHeaders_.forEach((value, key) =>
-                        self_.internalJsResponse_.writeHeader(key, value)
-                    );
-                    self_.internalJsResponse_.onWritable(() => {
-                        self_.internalResolveFlush_();
-                        return true;
-                    });
-                });
-            }
-            while(self_.internalResponseChunks_.array.length !== 0) {
-                await new Promise((resolve, reject) => {
-                    self_.internalJsResponse_.cork(() => {
-                        let backpressure = false;
-                        let i = 0;
-                        for(i = 0; i < self_.internalResponseChunks_.array.length && !backpressure; i++) {
-                            let chunk = self_.internalResponseChunks_.array[i];
-                            if(chunk && (chunk.byteLength || chunk.length)) {
-                                if(typeof chunk !== 'string') {
-                                    chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-                                } else if(self_.internalContentSize_ >= 0) {
-                                    chunk = new TextEncoder().encode(chunk);
-                                }
-                                if(self_.internalContentSize_ >= 0) {
-                                    const lastOffset = self_.internalJsResponse_.getWriteOffset();
-                                    const [ok, responded] = self_.internalJsResponse_.tryEnd(chunk, self_.internalContentSize_);
-                                    if(responded) self_.internalResponded_ = true;
-                                    if(!ok) {
-                                        const written = self_.internalJsResponse_.getWriteOffset() - lastOffset;
-                                        backpressure = true;
-                                        self_.internalResponseChunks_.array[i] = 
-                                            new Uint8Array(chunk.buffer, chunk.byteOffset + written, chunk.byteLength - written);
-                                        i -= 1;
-                                    }
-                                } else {
-                                    backpressure = !self_.internalJsResponse_.write(chunk);
-                                }
-                            }
-                        }
-                        if(i > 0) self_.internalResponseChunks_.array.splice(0, i);
-                        if(!backpressure) {
-                            resolve();
-                        } else {
-                            self_.internalResolveFlush_ = resolve;
-                        }
-                    });
-                });
-            }
-        """
-
-    flushText(data: String) {
-        self.writeText(data)
-        self.flush()
-    }
-
-    flushBuffer(data: Buffer) {
-        self.writeBuffer(data)
-        self.flush()
-    }
-
-    flushStream(data: Stream[Buffer]) {
-        data.each {self.flushBuffer(_)}
-    }
-
-}
-
-extend self: WebRequest[WebResponse] {
-    
-    readText(encoding: String = "utf8"): String {
-        self.readStream(1073741823).toString(encoding)
-    }
-    
-    readBuffer(): Buffer {
-        self.readStream(1073741823).toBuffer()
-    }
-    
-    readStream(maxPendingBytes: Int = 65536): Stream[Buffer]
-        target js async """
-            const front = [];
-            const back = [];
-            let pendingBytes = 0
-            let closed = false;
-            let callResolve = null;
-            let callReject = null;
-            self_.internalJsResponse_.onData((chunk, isLast) => {
-                if(closed) return;
-                if(isLast) closed = true; 
-                else chunk = cunk.slice();
-                pendingBytes += chunk.byteLength;
-                back.push(new DataView(chunk));
-                if(pendingBytes >= maxPendingBytes_) self_.internalJsResponse_.pause();
-                if(callResolve) callResolve();
-            });
-            const abort = () => {
-                $task.controller.signal.removeEventListener('abort', abort);
-                if(callReject) callReject();
-            }
-            $task.controller.signal.addEventListener('abort', abort);
-            return ff_core_Stream.Stream(
-                async () => {
-                    while(true) {
-                        ff_core_Task.Task_throwIfAborted($task);
-                        if(front.length === 0) {
-                            while(back.length !== 0) front.push(back.pop());
-                        }
-                        if(front.length !== 0) {
-                            const chunk = front.pop();
-                            const paused = pendingBytes >= maxPendingBytes_;
-                            pendingBytes -= chunk.byteLength;
-                            if(!closed && paused && pendingBytes < maxPendingBytes_) self_.internalJsResponse_.unpause();
-                            return ff_core_Option.Some(chunk);
-                        } else if(closed) {
-                            return ff_core_Option.None();
-                        } else {
-                            await new Promise((resolve, reject) => {
-                                callResolve = resolve;
-                                callReject = reject;
-                            });
-                            callResolve = null;
-                            callReject = null;
-                        }
-                    }
-                },
-                async () => {
-                    closed = true;
-                    ff_core_Task.Task_throwIfAborted($task);
-                    if(callResolve) callResolve();
-                }
-            )
-        """
-    
-}
-
-extend self[T]: WebRequest[T] {
-    
-    needsWebSocket(): Bool
-        target js sync """
-            return self_.internalJsContext_ != null;
-        """
-    
-}
-
-extend self: WebRequest[WebResponse] {
-    
-    openWebSocket(): WebSocketConnection
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task);
-            const userData = {};
-            const wrapper = {front: [], back: [], listeners: [], task: $task};
-            const promise = new Promise((resolve, reject) => {
-                const abort = () => {wrapper.webSocket = null; reject()};
-                userData.onOpen = ws => {wrapper.webSocket = ws; resolve(wrapper)};
-                userData.onClose = () => {
-                    $task.controller.signal.removeEventListener('abort', abort);
-                    abort();
-                    for(let i = 0; i < wrapper.listeners.length; i++) wrapper.listeners[i]();
-                    wrapper.listeners.length = 0;
-                };
-                userData.onMessage = (message, isBinary) => {
-                    wrapper.back.push(isBinary ? new DataView(message) : new TextDecoder().decode(message));
-                    for(let i = 0; i < wrapper.listeners.length; i++) wrapper.listeners[i]();
-                    wrapper.listeners.length = 0;
-                };
-                $task.controller.signal.addEventListener('abort', abort);
-            });
-            self_.internalJsResponse_.cork(() => {
-                ff_core_Task.Task_throwIfAborted($task);
-                self_.internalJsResponse_.upgrade(
-                    userData, 
-                    self_.internalHeaders_.get('sec-websocket-key'),
-                    self_.internalHeaders_.get('sec-websocket-protocol'),
-                    self_.internalHeaders_.get('sec-websocket-extensions'),
-                    self_.internalJsContext_
-                )
-            });
-            return await promise;
-        """
-
-}
-
-extend self: WebSocketConnection {
-    
-    readText(encoding: String = "utf8"): Option[String] {
-        self.readAny {_} {_.toString(encoding)}
-    }
-
-    readBuffer(): Option[Buffer] {
-        self.readAny {_.toBuffer()} {_}
-    }
-    
-    readAny[T](fromText: String => T, fromBuffer: Buffer => T): Option[T]
-        target node async """
-            ff_core_Task.Task_throwIfAborted($task);
-            while(self_.front.length === 0) {
-                while(self_.back.length !== 0) {
-                    self_.front.push(self_.back.pop());
-                }
-                if(self_.front.length !== 0) break;
-                if(self_.webSocket == null) return ff_core_Option.None();
-                let abort = null;
-                try {
-                    await new Promise((resolve, reject) => {
-                        self_.listeners.push(resolve);
-                        if($task !== self_.task) {
-                            abort = () => {
-                                self_.listeners = self_.listeners.filter(l => l != resolve);
-                                reject();
-                            };
-                            $task.controller.signal.addEventListener('abort', abort);
-                        }
-                    });
-                } finally {
-                    if($task !== self_.task) {
-                        $task.controller.signal.removeEventListener('abort', abort);
-                    }
-                }
-            }
-            const data = self_.front.pop();
-            if(typeof data === 'string') return ff_core_Option.Some(await fromText_(data));
-            return ff_core_Option.Some(await fromBuffer_(data));
-        """
-        
-    readStream(): Stream[Buffer] {
-        Stream {self.readBuffer()} {self.close()}
-    }
-    
-    writeBuffer(message: Buffer)
-        target node async """
-            await internalSend_$(self_, () => self_.webSocket.send(message_.buffer, true) !== 2, $task);
-        """
-    
-    writeText(message: String)
-        target node async """
-            await internalSend_$(self_, () => self_.webSocket.send(message_, false) !== 2, $task);
-        """
-    
-    publishBuffer(topic: String, message: Buffer)
-        target node async """
-            await internalSend_$(self_, () => self_.webSocket.publish(topic_, message_.buffer, true), $task);
-        """
-    
-    publishText(topic: String, message: String)
-        target node async """
-            await internalSend_$(self_, () => self_.webSocket.publish(topic_, message_, false), $task);
-        """
-
-    subscribe(topic: String)
-        target node async """
-            if(self_.webSocket == null) throw new Error("WebSocket is closed");
-            self_.webSocket.subscribe(topic_);
-        """
-
-    unsubscribe(topic: String)
-        target node async """
-            if(self_.webSocket == null) throw new Error("WebSocket is closed");
-            self_.webSocket.unsubscribe(topic_);
-        """
-
-    isSubscribedTo(topic: String): Bool
-        target node async """
-            if(self_.webSocket == null) throw new Error("WebSocket is closed");
-            return self_.webSocket.isSubscribed(topic_);
-        """
-        
-    subscriptions(): Array[String]
-        target node async """
-            if(self_.webSocket == null) throw new Error("WebSocket is closed");
-            return self_.webSocket.getTopics();
-        """
-
-    close(): Unit
-        target node async """
-            if(self_.webSocket != null) {
-                self_.webSocket.close();
-                self_.webSocket = null;
-            }
-        """
-
-}
-
-internalSend[T](self: WebSocketConnection, send: () => Bool): JsValue
-    target node async """
-        let abort = null;
-        try {
-            await new Promise((resolve, reject) => {
-                if(self_.webSocket == null) new Error("WebSocket is closed");
-                else self_.webSocket.cork(() => {
-                    if($task !== self_.task) {
-                        abort = () => {
-                            self_.listeners = self_.listeners.filter(l => l != resolve);
-                            reject();
-                        };
-                        $task.controller.signal.addEventListener('abort', abort);
-                    }
-                    if(self_.webSocket == null) {
-                        reject(new Error("WebSocket is closed"));
-                    } else if(!send_()) {
-                        reject(new Error("Dropped message due to backpressure"));
-                    } else {
-                        resolve();
-                    }
-                })
-            });
-        } finally {
-            if($task !== self_.task) {
-                $task.controller.signal.removeEventListener('abort', abort);
-            }
-        }
-    """
-
-internalArray[T](): Array[T] {
-    Array.new()
-}
-
-internalTextChunk(data: String): JsValue
-    target js sync """
-        return data_;
-    """
-    
-internalBufferChunk(data: Buffer): JsValue
-    target js sync """
-        return data_;
-    """
-
-internalChunksToChunk(chunks: Array[JsValue]): JsValue
-    target js sync """
-        const chunks = chunks_.array;
-        if(chunks.length === 0) return;
-        const firstIsString = typeof chunks[0] === 'string';
-        if(firstIsString && chunks.length === 1) return chunks[0];
-        if(firstIsString && chunks.every(c => typeof c === 'string')) {
-            let result = chunks[0];
-            for(let i = 1; i < chunks.length; i++) {
-                result += chunks[i];
-            }
-            return result;
-        }
-        let totalLength = 0;
-        for(let i = 0; i < chunks.length; i++) {
-            if(typeof chunks[i] === 'string') chunks[i] = new TextEncoder().encode(chunks[i]);
-            totalLength += chunks[i].byteLength;
-        }
-        const result = new Uint8Array(totalLength);
-        let offset = 0;
-        for(let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i];
-            const uint8Array = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-            result.set(uint8Array, offset);
-            offset += chunk.byteLength;
-        }
-        return result;
-    """
-
-parseMultipartFields(data: Buffer, contentType: String): Option[Array[MultipartField]]
-    target js sync """
-        const parts = getParts(data_, contentType_);
-        return parts == null ? ff_core_Option.None() : ff_core_Option.Some(parts);
-    """
-
-extend self: MultipartField {
-    
-    data(): Buffer
-        target js sync """
-            return new DataView(self_.data);
-        """
-
-    name(): String
-        target js sync """
-            return self_.name;
-        """
-
-    type(): Option[String]
-        target js sync """
-            return self_.type == null ? ff_core_Option.None() : ff_core_Option.Some(self_.type);
-        """
-
-    filename(): Option[String]
-        target js sync """
-            return self_.filename == null ? ff_core_Option.None() : ff_core_Option.Some(self_.filename);
-        """
-
-}
+capability WebServer(
+    intenalSystem: NodeSystem
+    internalHost: String
+    internalPort: Int
+    mutable internalJsWebSockets: JsValue
+    mutable internalJsWildcard: JsValue
+    mutable internalJsHosts: Array[JsValue]
+    mutable internalJsApp: JsValue
+)
+
+class WebRequest[T](
+    internalJsApp: JsValue
+    internalJsContext: JsValue
+    internalMethod: String
+    internalPath: String
+    internalQuery: String
+    internalHeaders: StringMap[String]
+    internalJsResponse: JsValue
+    internalResponse: T
+    internalResponseHeaders: StringMap[String]
+    internalResponseChunks: Array[JsValue]
+    mutable internalResponseStatus: String
+    mutable internalCloseConnection: Bool
+    mutable internalResolveFlush: JsValue
+    mutable internalContentSize: Int
+    mutable internalResponded: Bool
+)
+
+capability WebResponse {}
+
+data MultipartField {}
+
+capability WebSocketConnection {}
+
+new(
+    system: NodeSystem
+    host: String
+    port: Int
+): WebServer {
+    WebServer(system, host, port, system.js().null(), system.js().null(), [].toArray(), system.js().null())
+}
+
+extend self: WebServer {
+    
+    enableWebSockets(
+        maxPayloadBytes: Int = 16384
+        maxBackpressureBytes: Int = 65536
+        closeDueToMaxBackpressureBytes: Bool = False
+        maxLifetime: Option[Duration] = None
+        idleTimeout: Option[Duration] = None
+    ) {
+        self.internalJsWebSockets = self.intenalSystem.js().object()
+        self.internalJsWebSockets.set("maxPayloadLength", maxPayloadBytes)
+        self.internalJsWebSockets.set("maxBackpressureBytes", maxBackpressureBytes)
+        self.internalJsWebSockets.set("closeOnBackpressureLimit", closeDueToMaxBackpressureBytes)
+        maxLifetime.each {self.internalJsWebSockets.set("maxLifetime", (_.seconds / 60).round().toInt())}
+        idleTimeout.each {self.internalJsWebSockets.set("idleTimeout", _.seconds.round().toInt())}
+    }
+    
+    addHost(
+        hostname: String
+        key: Option[Path] = None
+        certificate: Option[Path] = None
+        certificateAuthority: Option[Path] = None
+        passphrase: Option[String] = None
+        dhParameters: Option[Path] = None
+        ciphers: Option[String] = None
+        preferLowMemoryUsage: Bool = False
+    ) {
+        let object = self.intenalSystem.js().object().with("hostname", hostname)
+        key.each {object.set("key_file_name", _.absolute())}
+        certificate.each {object.set("cert_file_name", _.absolute())}
+        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
+        passphrase.each {object.set("passphrase", _)}
+        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
+        ciphers.each {object.set("ssl_ciphers", _)}
+        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
+        self.internalJsHosts.push(object)
+    }
+
+    setWildcard(
+        key: Option[Path] = None
+        certificate: Option[Path] = None
+        certificateAuthority: Option[Path] = None
+        passphrase: Option[String] = None
+        dhParameters: Option[Path] = None
+        ciphers: Option[String] = None
+        preferLowMemoryUsage: Bool = False
+    ) {
+        let object = self.intenalSystem.js().object()
+        key.each {object.set("key_file_name", _.absolute())}
+        certificate.each {object.set("cert_file_name", _.absolute())}
+        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
+        passphrase.each {object.set("passphrase", _)}
+        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
+        ciphers.each {object.set("ssl_ciphers", _)}
+        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
+        self.internalJsWildcard = object
+    }
+    
+    listen(handler: WebRequest[WebResponse] => Unit)
+        target node async """
+            import * as uws from 'uWebSockets.js'
+            ff_core_Task.Task_throwIfAborted($task);
+            await new Promise((resolveServer, rejectServer) => {
+                self_.internalJsApp_ = self_.internalJsWilcard_ ? uws.SSLApp(self_.internalJsWilcard_) 
+                    : self_.internalJsHosts_.array.some(h => h.key_file_name) ? uws.SSLApp() : uws.App();
+                self_.internalJsHosts_.array.forEach(h => self_.internalJsApp_.addServerName(h.hostname, h));
+                const handleRequest = (res, req, context) => {
+                    let abortedByUws = false;
+                    const method = req.getMethod();
+                    const path = req.getUrl();
+                    const query = req.getQuery() || '';
+                    const headers = new Map();
+                    req.forEach((key, value) => headers.set(key, value));
+                    const chunks = internalArray_();
+                    const task = ff_core_Task.Task_spawn($task, async task => {
+                        try {
+                            ff_core_Task.Task_throwIfAborted(task);
+                            const webRequest = WebRequest(
+                                self_.internalJsApp_, context, 
+                                method, path, query, headers, 
+                                res, null, 
+                                new Map(), internalArray_(), 
+                                "200 OK", false, null, -1, false
+                            );
+                            await handler_(webRequest, task);
+                            ff_core_Task.Task_throwIfAborted(task);
+                            if(context == null && !webRequest.internalResponded_ && webRequest.internalContentSize_ >= 0) {
+                                await WebRequest_flush$(webRequest, task);
+                                ff_core_Task.Task_throwIfAborted(task);
+                            }
+                            if(context == null && !webRequest.internalResponded_) await new Promise((resolve, reject) => {
+                                res.cork(() => {
+                                    try {
+                                        ff_core_Task.Task_throwIfAborted(task);
+                                        if(!webRequest.internalResolveFlush_) {
+                                            res.writeStatus(webRequest.internalResponseStatus_);
+                                            webRequest.internalResponseHeaders_.forEach((value, key) => res.writeHeader(key, value));
+                                        }
+                                        const chunk = internalChunksToChunk_(webRequest.internalResponseChunks_);
+                                        res.end(chunk, webRequest.internalCloseConnection_);
+                                        resolve();
+                                    } catch(e) {
+                                        reject(e);
+                                    }
+                                });
+                            });
+                        } catch(e) {
+                            if(!abortedByUws) console.error(e);
+                            if(!abortedByUws && context == null) res.cork(() => {
+                                if(!abortedByUws) res.writeStatus("500 Internal Server Error");
+                                if(!abortedByUws) res.end();
+                            });
+                        }
+                    });
+                    res.onAborted(() => {
+                        abortedByUws = true; 
+                        ff_core_Task.Task_abort(task);
+                    });
+                }
+                self_.internalJsApp_.any('/*', handleRequest);
+                if(self_.internalJsWebSockets_) self_.internalJsApp_.ws("/*", {
+                    ...self_.internalJsWebSockets_,
+                    upgrade: handleRequest,
+                    open: ws => ws.getUserData().onOpen(ws),
+                    message: (ws, m, b) => ws.getUserData().onMessage(m, b),
+                    close: ws => ws.getUserData().onClose(),
+                });
+                self_.internalJsApp_.listen(self_.internalHost_, self_.internalPort_, listenSocket => {
+                    if(listenSocket) {
+                        const abort = () => {
+                            $task.controller.signal.removeEventListener('abort', abort);
+                            uws.us_listen_socket_close(listenSocket);
+                            self_.internalJsApp_.close();
+                        }
+                        $task.controller.signal.addEventListener('abort', abort);
+                    } else {
+                        rejectServer();
+                    }
+                });
+            });
+        """
+    
+    publishBuffer(topic: String, message: Buffer) // Should this be corked?
+        target js async """
+            if(self_.internalJsApp_) self_.internalJsApp_.publish(topic_, message_.buffer, true);
+        """
+    
+    publishText(topic: String, message: String) // Should this be corked?
+        target js async """
+            if(self_.internalJsApp_) self_.internalJsApp_.publish(topic_, message_, false);
+        """
+    
+}
+
+extend self[T]: WebRequest[T] {
+
+    readMethod(): String {
+        self.internalMethod
+    }
+
+    readPath(): String {
+        self.internalPath
+    }
+
+    readRawQueryString(): String {
+        self.internalQuery
+    }
+
+    readQuery(name: String): Option[String]
+        target node sync """
+            if(self_.internalQuery_.length === 0) return ff_core_Option.None();
+            const ps = self_.internalQuery_.split('&');
+            const n = name_ + '=';
+            const r = ps.find(p => p === name_ || p.startsWith(n));
+            if(r == null) return ff_core_Option.None();
+            return ff_core_Option.Some(decodeURIComponent(r.slice(name_.length + 1)));
+        """
+    
+    readHeader(lowerCaseName: String): Option[String] {
+        self.internalHeaders.get(lowerCaseName)
+    }
+    
+    eachHeader(body: (String, String) => Unit) {
+        self.internalHeaders.each {body(_, _)}
+    }
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    writeStatus(codeAndMessage: String) {
+        self.internalResponseStatus = codeAndMessage
+    }
+    
+    writeHeader(name: String, value: String) {
+        self.internalResponseHeaders.set(name, value)
+    }
+    
+    writeContentSize(contentSize: Int) {
+        if(contentSize >= 0) {
+            self.internalContentSize = contentSize
+        }
+    }
+
+    writeText(data: String) {
+        self.internalResponseChunks.push(internalTextChunk(data))
+    }
+
+    writeLine(data: String) {
+        self.writeText(data + "\n")
+    }
+
+    writeBuffer(data: Buffer) {
+        self.internalResponseChunks.push(internalBufferChunk(data))
+    }
+    
+    writeStream(data: Stream[Buffer]) {
+        data.each {self.writeBuffer(_)}
+    }
+
+}
+
+extend self[T]: WebRequest[T] {
+
+    publishBuffer(topic: String, message: Buffer) // Should this be corked?
+        target js sync """
+            self_.internalJsApp_.publish(topic_, message_.buffer, true);
+        """
+    
+    publishText(topic: String, message: String) // Should this be corked?
+        target js sync """
+            self_.internalJsApp_.publish(topic_, message_, false);
+        """
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    closeConnection() {
+        self.internalCloseConnection = True
+    }
+    
+    readRemoteAddress(): String
+        target js sync """
+            return new TextDecoder().decode(self_.internalJsResponse_.getRemoteAddressAsText())
+        """
+
+    readProxiedRemoteAddress(): String
+        target js sync """
+            return new TextDecoder().decode(self_.internalJsResponse_.getProxiedRemoteAddressAsText())
+        """
+
+}
+
+extend self: WebRequest[WebResponse] {
+
+    flush()
+        target js async """
+            if(!self_.internalResolveFlush_) {
+                self_.internalResolveFlush_ = () => {};
+                self_.internalJsResponse_.cork(() => {
+                    self_.internalJsResponse_.writeStatus(self_.internalResponseStatus_);
+                    self_.internalResponseHeaders_.forEach((value, key) =>
+                        self_.internalJsResponse_.writeHeader(key, value)
+                    );
+                    self_.internalJsResponse_.onWritable(() => {
+                        self_.internalResolveFlush_();
+                        return true;
+                    });
+                });
+            }
+            while(self_.internalResponseChunks_.array.length !== 0) {
+                await new Promise((resolve, reject) => {
+                    self_.internalJsResponse_.cork(() => {
+                        let backpressure = false;
+                        let i = 0;
+                        for(i = 0; i < self_.internalResponseChunks_.array.length && !backpressure; i++) {
+                            let chunk = self_.internalResponseChunks_.array[i];
+                            if(chunk && (chunk.byteLength || chunk.length)) {
+                                if(typeof chunk !== 'string') {
+                                    chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+                                } else if(self_.internalContentSize_ >= 0) {
+                                    chunk = new TextEncoder().encode(chunk);
+                                }
+                                if(self_.internalContentSize_ >= 0) {
+                                    const lastOffset = self_.internalJsResponse_.getWriteOffset();
+                                    const [ok, responded] = self_.internalJsResponse_.tryEnd(chunk, self_.internalContentSize_);
+                                    if(responded) self_.internalResponded_ = true;
+                                    if(!ok) {
+                                        const written = self_.internalJsResponse_.getWriteOffset() - lastOffset;
+                                        backpressure = true;
+                                        self_.internalResponseChunks_.array[i] = 
+                                            new Uint8Array(chunk.buffer, chunk.byteOffset + written, chunk.byteLength - written);
+                                        i -= 1;
+                                    }
+                                } else {
+                                    backpressure = !self_.internalJsResponse_.write(chunk);
+                                }
+                            }
+                        }
+                        if(i > 0) self_.internalResponseChunks_.array.splice(0, i);
+                        if(!backpressure) {
+                            resolve();
+                        } else {
+                            self_.internalResolveFlush_ = resolve;
+                        }
+                    });
+                });
+            }
+        """
+
+    flushText(data: String) {
+        self.writeText(data)
+        self.flush()
+    }
+
+    flushBuffer(data: Buffer) {
+        self.writeBuffer(data)
+        self.flush()
+    }
+
+    flushStream(data: Stream[Buffer]) {
+        data.each {self.flushBuffer(_)}
+    }
+
+}
+
+extend self: WebRequest[WebResponse] {
+    
+    readText(encoding: String = "utf8"): String {
+        self.readStream(1073741823).toString(encoding)
+    }
+    
+    readBuffer(): Buffer {
+        self.readStream(1073741823).toBuffer()
+    }
+    
+    readStream(maxPendingBytes: Int = 65536): Stream[Buffer]
+        target js async """
+            const front = [];
+            const back = [];
+            let pendingBytes = 0
+            let closed = false;
+            let callResolve = null;
+            let callReject = null;
+            self_.internalJsResponse_.onData((chunk, isLast) => {
+                if(closed) return;
+                if(isLast) closed = true; 
+                else chunk = cunk.slice();
+                pendingBytes += chunk.byteLength;
+                back.push(new DataView(chunk));
+                if(pendingBytes >= maxPendingBytes_) self_.internalJsResponse_.pause();
+                if(callResolve) callResolve();
+            });
+            const abort = () => {
+                $task.controller.signal.removeEventListener('abort', abort);
+                if(callReject) callReject();
+            }
+            $task.controller.signal.addEventListener('abort', abort);
+            return ff_core_Stream.Stream(
+                async () => {
+                    while(true) {
+                        ff_core_Task.Task_throwIfAborted($task);
+                        if(front.length === 0) {
+                            while(back.length !== 0) front.push(back.pop());
+                        }
+                        if(front.length !== 0) {
+                            const chunk = front.pop();
+                            const paused = pendingBytes >= maxPendingBytes_;
+                            pendingBytes -= chunk.byteLength;
+                            if(!closed && paused && pendingBytes < maxPendingBytes_) self_.internalJsResponse_.unpause();
+                            return ff_core_Option.Some(chunk);
+                        } else if(closed) {
+                            return ff_core_Option.None();
+                        } else {
+                            await new Promise((resolve, reject) => {
+                                callResolve = resolve;
+                                callReject = reject;
+                            });
+                            callResolve = null;
+                            callReject = null;
+                        }
+                    }
+                },
+                async () => {
+                    closed = true;
+                    ff_core_Task.Task_throwIfAborted($task);
+                    if(callResolve) callResolve();
+                }
+            )
+        """
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    needsWebSocket(): Bool
+        target js sync """
+            return self_.internalJsContext_ != null;
+        """
+    
+}
+
+extend self: WebRequest[WebResponse] {
+    
+    openWebSocket(): WebSocketConnection
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task);
+            const userData = {};
+            const wrapper = {front: [], back: [], listeners: [], task: $task};
+            const promise = new Promise((resolve, reject) => {
+                const abort = () => {wrapper.webSocket = null; reject()};
+                userData.onOpen = ws => {wrapper.webSocket = ws; resolve(wrapper)};
+                userData.onClose = () => {
+                    $task.controller.signal.removeEventListener('abort', abort);
+                    abort();
+                    for(let i = 0; i < wrapper.listeners.length; i++) wrapper.listeners[i]();
+                    wrapper.listeners.length = 0;
+                };
+                userData.onMessage = (message, isBinary) => {
+                    wrapper.back.push(isBinary ? new DataView(message) : new TextDecoder().decode(message));
+                    for(let i = 0; i < wrapper.listeners.length; i++) wrapper.listeners[i]();
+                    wrapper.listeners.length = 0;
+                };
+                $task.controller.signal.addEventListener('abort', abort);
+            });
+            self_.internalJsResponse_.cork(() => {
+                ff_core_Task.Task_throwIfAborted($task);
+                self_.internalJsResponse_.upgrade(
+                    userData, 
+                    self_.internalHeaders_.get('sec-websocket-key'),
+                    self_.internalHeaders_.get('sec-websocket-protocol'),
+                    self_.internalHeaders_.get('sec-websocket-extensions'),
+                    self_.internalJsContext_
+                )
+            });
+            return await promise;
+        """
+
+}
+
+extend self: WebSocketConnection {
+    
+    readText(encoding: String = "utf8"): Option[String] {
+        self.readAny {_} {_.toString(encoding)}
+    }
+
+    readBuffer(): Option[Buffer] {
+        self.readAny {_.toBuffer()} {_}
+    }
+    
+    readAny[T](fromText: String => T, fromBuffer: Buffer => T): Option[T]
+        target node async """
+            ff_core_Task.Task_throwIfAborted($task);
+            while(self_.front.length === 0) {
+                while(self_.back.length !== 0) {
+                    self_.front.push(self_.back.pop());
+                }
+                if(self_.front.length !== 0) break;
+                if(self_.webSocket == null) return ff_core_Option.None();
+                let abort = null;
+                try {
+                    await new Promise((resolve, reject) => {
+                        self_.listeners.push(resolve);
+                        if($task !== self_.task) {
+                            abort = () => {
+                                self_.listeners = self_.listeners.filter(l => l != resolve);
+                                reject();
+                            };
+                            $task.controller.signal.addEventListener('abort', abort);
+                        }
+                    });
+                } finally {
+                    if($task !== self_.task) {
+                        $task.controller.signal.removeEventListener('abort', abort);
+                    }
+                }
+            }
+            const data = self_.front.pop();
+            if(typeof data === 'string') return ff_core_Option.Some(await fromText_(data));
+            return ff_core_Option.Some(await fromBuffer_(data));
+        """
+        
+    readStream(): Stream[Buffer] {
+        Stream {self.readBuffer()} {self.close()}
+    }
+    
+    writeBuffer(message: Buffer)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.send(message_.buffer, true) !== 2, $task);
+        """
+    
+    writeText(message: String)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.send(message_, false) !== 2, $task);
+        """
+    
+    publishBuffer(topic: String, message: Buffer)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.publish(topic_, message_.buffer, true), $task);
+        """
+    
+    publishText(topic: String, message: String)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.publish(topic_, message_, false), $task);
+        """
+
+    subscribe(topic: String)
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            self_.webSocket.subscribe(topic_);
+        """
+
+    unsubscribe(topic: String)
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            self_.webSocket.unsubscribe(topic_);
+        """
+
+    isSubscribedTo(topic: String): Bool
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            return self_.webSocket.isSubscribed(topic_);
+        """
+        
+    subscriptions(): Array[String]
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            return self_.webSocket.getTopics();
+        """
+
+    close(): Unit
+        target node async """
+            if(self_.webSocket != null) {
+                self_.webSocket.close();
+                self_.webSocket = null;
+            }
+        """
+
+}
+
+internalSend[T](self: WebSocketConnection, send: () => Bool): JsValue
+    target node async """
+        let abort = null;
+        try {
+            await new Promise((resolve, reject) => {
+                if(self_.webSocket == null) new Error("WebSocket is closed");
+                else self_.webSocket.cork(() => {
+                    if($task !== self_.task) {
+                        abort = () => {
+                            self_.listeners = self_.listeners.filter(l => l != resolve);
+                            reject();
+                        };
+                        $task.controller.signal.addEventListener('abort', abort);
+                    }
+                    if(self_.webSocket == null) {
+                        reject(new Error("WebSocket is closed"));
+                    } else if(!send_()) {
+                        reject(new Error("Dropped message due to backpressure"));
+                    } else {
+                        resolve();
+                    }
+                })
+            });
+        } finally {
+            if($task !== self_.task) {
+                $task.controller.signal.removeEventListener('abort', abort);
+            }
+        }
+    """
+
+internalArray[T](): Array[T] {
+    Array.new()
+}
+
+internalTextChunk(data: String): JsValue
+    target js sync """
+        return data_;
+    """
+    
+internalBufferChunk(data: Buffer): JsValue
+    target js sync """
+        return data_;
+    """
+
+internalChunksToChunk(chunks: Array[JsValue]): JsValue
+    target js sync """
+        const chunks = chunks_.array;
+        if(chunks.length === 0) return;
+        const firstIsString = typeof chunks[0] === 'string';
+        if(firstIsString && chunks.length === 1) return chunks[0];
+        if(firstIsString && chunks.every(c => typeof c === 'string')) {
+            let result = chunks[0];
+            for(let i = 1; i < chunks.length; i++) {
+                result += chunks[i];
+            }
+            return result;
+        }
+        let totalLength = 0;
+        for(let i = 0; i < chunks.length; i++) {
+            if(typeof chunks[i] === 'string') chunks[i] = new TextEncoder().encode(chunks[i]);
+            totalLength += chunks[i].byteLength;
+        }
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for(let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const uint8Array = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+            result.set(uint8Array, offset);
+            offset += chunk.byteLength;
+        }
+        return result;
+    """
+
+parseMultipartFields(data: Buffer, contentType: String): Option[Array[MultipartField]]
+    target js sync """
+        const parts = getParts(data_, contentType_);
+        return parts == null ? ff_core_Option.None() : ff_core_Option.Some(parts);
+    """
+
+extend self: MultipartField {
+    
+    data(): Buffer
+        target js sync """
+            return new DataView(self_.data);
+        """
+
+    name(): String
+        target js sync """
+            return self_.name;
+        """
+
+    type(): Option[String]
+        target js sync """
+            return self_.type == null ? ff_core_Option.None() : ff_core_Option.Some(self_.type);
+        """
+
+    filename(): Option[String]
+        target js sync """
+            return self_.filename == null ? ff_core_Option.None() : ff_core_Option.Some(self_.filename);
+        """
+
+}