@volter/browser-wali 0.1.4 → 0.1.6

package/dist/loopback-host.js

@@ -1,3 +1,4 @@
+import { browserRegisteredServer } from "@volter/browser-runtime/browser-http.js";
 import { WaliWebSocketPeer } from "./websocket-peer.js";
 const MAX_ACTIVE_CONNECTIONS = 32;
 const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
@@ -10,18 +11,77 @@ export class BrowserWaliLoopbackHost {
     bridge;
     webSocketRegistry;
     nextConnection = 1;
+    tcpServers = new Map();
+    /** Per listening WALI port, a raw byte connection to it: what a socket client of another lane is given. */
+    rawOpeners = new Map();
+    listenObservers = new Set();
+    listenReleases = new Map();
     constructor(bridge, webSocketRegistry) {
         this.bridge = bridge;
         this.webSocketRegistry = webSocketRegistry;
     }
+    /** Raw TCP is opt-in per virtual port; other ports keep their HTTP bridge. */
+    listenTcp(port, accept) {
+        if (!validPort(port) || this.tcpServers.has(port) || this.bridge.getServerPorts().includes(port)) {
+            throw new Error(`Loopback port ${port} is invalid or already in use.`);
+        }
+        const server = { accept, sockets: new Set() };
+        this.tcpServers.set(port, server);
+        return () => {
+            if (this.tcpServers.get(port) !== server)
+                return;
+            this.tcpServers.delete(port);
+            for (const socket of [...server.sockets])
+                socket.close();
+        };
+    }
+    /**
+     * Called for every port a WALI program listens on, now and later; the
+     * function it returns runs when that listener closes. The host a page
+     * builds uses it to give the port to its other lanes' socket clients.
+     */
+    onListen(observer) {
+        this.listenObservers.add(observer);
+        for (const port of this.rawOpeners.keys())
+            this.notifyListen(port, observer);
+        return () => { this.listenObservers.delete(observer); };
+    }
+    /** A raw TCP connection to a WALI program's listening port: bytes both ways, as a socket client sees them. */
+    connectTcp(port) {
+        const open = this.rawOpeners.get(port);
+        if (!open)
+            throw Object.assign(new Error(`Nothing listens on loopback port ${port}.`), { code: "ECONNREFUSED" });
+        return open();
+    }
+    notifyListen(port, observer) {
+        try {
+            const release = observer(port);
+            if (release)
+                this.listenReleases.set(port, [...(this.listenReleases.get(port) ?? []), release]);
+        }
+        catch { /* an observer that cannot take the port leaves it HTTP-only */ }
+    }
+    releaseListen(port) {
+        this.rawOpeners.delete(port);
+        const releases = this.listenReleases.get(port) ?? [];
+        this.listenReleases.delete(port);
+        for (const release of releases) {
+            try {
+                release();
+            }
+            catch { /* already gone */ }
+        }
+    }
     attach(port) {
         const registered = new Set();
         const pending = new Map();
         const outgoing = new Map();
         const webSockets = new Map();
         const webSocketRegistrations = new Map();
+        const tcp = new Map();
+        const raws = new Map();
         let closed = false;
-        const activeConnections = () => pending.size + outgoing.size + webSockets.size;
+        const activeConnections = () => pending.size + outgoing.size + webSockets.size + tcp.size + raws.size;
         const send = (message) => {
             if (!closed)
                 port.postMessage(message);
@@ -29,6 +89,7 @@ export class BrowserWaliLoopbackHost {
         const unregister = (virtualPort) => {
             if (!registered.delete(virtualPort))
                 return;
+            this.releaseListen(virtualPort);
             webSocketRegistrations.get(virtualPort)?.();
             webSocketRegistrations.delete(virtualPort);
             for (const [connectionId, active] of webSockets) {
@@ -59,6 +120,184 @@ export class BrowserWaliLoopbackHost {
             send({ type: "incoming", connectionId, port: virtualPort, bytes: peer.handshake });
             return peer;
         };
+        // A client's connection as the program sees it: accepted at once
+        // (`incoming`, with no bytes, so a server that speaks first can), its
+        // writes following on it, and either side may end it.
+        const openRaw = (virtualPort) => {
+            if (closed)
+                throw new Error("WALI loopback host is closed.");
+            if (activeConnections() >= MAX_ACTIVE_CONNECTIONS)
+                throw new Error("WALI loopback concurrency exceeded.");
+            const connectionId = this.nextConnection++;
+            const dataListeners = new Set();
+            const closeListeners = new Set();
+            let ended = false;
+            const end = (notify) => {
+                if (ended)
+                    return;
+                ended = true;
+                raws.delete(connectionId);
+                if (notify)
+                    send({ type: "peer-close", connectionId });
+                for (const listener of closeListeners)
+                    listener();
+            };
+            raws.set(connectionId, {
+                receive: (bytes) => { for (const listener of dataListeners)
+                    listener(bytes); },
+                closed: () => end(false),
+            });
+            const socket = {
+                onData: (listener) => { dataListeners.add(listener); },
+                onClose: (listener) => { closeListeners.add(listener); },
+                write: (bytes) => { if (!ended)
+                    send({ type: "data", connectionId, bytes }); },
+                close: () => end(true),
+            };
+            send({ type: "incoming", connectionId, port: virtualPort, bytes: new Uint8Array(0) });
+            return socket;
+        };
+        // A request answered as it arrives: the head resolves the Response and
+        // the body streams, so an event stream (SSE) is read as it is written
+        // rather than held to the buffered door's 30-second answer. The WALI wire
+        // carries no credit to pause the program, so what it has written waits in
+        // this stream for its reader, and the whole answer is held to the same
+        // 32 MiB the buffered door and the outgoing stream are.
+        const streamingFetch = async (virtualPort, incoming) => {
+            const body = incoming.method === "GET" || incoming.method === "HEAD" ? undefined : new Uint8Array(await incoming.arrayBuffer());
+            const headers = {};
+            incoming.headers.forEach((value, name) => { if (name !== "content-length" && name !== "transfer-encoding" && name !== "connection")
+                headers[name] = value; });
+            const target = new URL(incoming.url);
+            const socket = openRaw(virtualPort);
+            return new Promise((resolve, reject) => {
+                let buffered = new Uint8Array(0);
+                let controller;
+                let framing;
+                let finished = false;
+                let streamed = 0;
+                const deliver = (bytes) => {
+                    streamed += bytes.byteLength;
+                    if (streamed > MAX_RESPONSE_BYTES) {
+                        finish(new Error("WALI loopback response exceeds 32 MiB."));
+                        return;
+                    }
+                    controller.enqueue(bytes);
+                };
+                const finish = (error) => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    if (!controller)
+                        reject(error ?? new Error("WALI server closed before returning an HTTP response."));
+                    else if (error)
+                        controller.error(error);
+                    else
+                        controller.close();
+                    socket.close();
+                };
+                const drain = () => {
+                    if (!controller || !framing)
+                        return;
+                    if (framing.kind === "close") {
+                        if (buffered.byteLength) {
+                            const bytes = buffered;
+                            buffered = new Uint8Array(0);
+                            deliver(bytes);
+                        }
+                        return;
+                    }
+                    if (framing.kind === "length") {
+                        const take = Math.min(framing.remaining, buffered.byteLength);
+                        if (take) {
+                            const bytes = buffered.slice(0, take);
+                            buffered = buffered.slice(take);
+                            framing.remaining -= take;
+                            deliver(bytes);
+                        }
+                        if (finished)
+                            return;
+                        if (framing.remaining === 0)
+                            finish();
+                        return;
+                    }
+                    for (;;) {
+                        const lineEnd = indexOf(buffered, [13, 10]);
+                        if (lineEnd < 0)
+                            return;
+                        const size = Number.parseInt(new TextDecoder().decode(buffered.subarray(0, lineEnd)).split(";")[0].trim(), 16);
+                        if (!Number.isSafeInteger(size) || size < 0) {
+                            finish(new Error("WALI server sent an invalid chunk."));
+                            return;
+                        }
+                        if (size === 0) {
+                            finish();
+                            return;
+                        }
+                        if (buffered.byteLength < lineEnd + 2 + size + 2)
+                            return;
+                        const bytes = buffered.slice(lineEnd + 2, lineEnd + 2 + size);
+                        buffered = buffered.slice(lineEnd + 2 + size + 2);
+                        deliver(bytes);
+                        if (finished)
+                            return;
+                    }
+                };
+                socket.onData((bytes) => {
+                    if (finished)
+                        return;
+                    const next = new Uint8Array(buffered.byteLength + bytes.byteLength);
+                    next.set(buffered);
+                    next.set(bytes, buffered.byteLength);
+                    buffered = next;
+                    if (!framing) {
+                        const boundary = indexOf(buffered, [13, 10, 13, 10]);
+                        if (boundary < 0) {
+                            if (buffered.byteLength > MAX_HEADER_BYTES)
+                                finish(new Error("WALI server response headers exceed 64 KiB."));
+                            return;
+                        }
+                        const lines = new TextDecoder().decode(buffered.subarray(0, boundary)).split("\r\n");
+                        buffered = buffered.slice(boundary + 4);
+                        const status = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/u.exec(lines.shift() ?? "");
+                        if (!status) {
+                            finish(new Error("WALI server sent an invalid HTTP status line."));
+                            return;
+                        }
+                        const responseHeaders = new Headers();
+                        for (const line of lines) {
+                            const separator = line.indexOf(":");
+                            if (separator > 0)
+                                responseHeaders.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+                        }
+                        const length = responseHeaders.get("content-length");
+                        framing = /\bchunked\b/iu.test(responseHeaders.get("transfer-encoding") ?? "") ? { kind: "chunked" }
+                            : length !== null ? { kind: "length", remaining: Number(length) } : { kind: "close" };
+                        const statusCode = Number(status[1]);
+                        const empty = incoming.method === "HEAD" || statusCode === 204 || statusCode === 304;
+                        for (const name of ["transfer-encoding", "connection", "keep-alive"])
+                            responseHeaders.delete(name);
+                        const stream = empty ? null : new ReadableStream({
+                            start: (started) => { controller = started; },
+                            cancel: () => { finished = true; socket.close(); },
+                        });
+                        resolve(new Response(stream, { status: statusCode, statusText: status[2] ?? "", headers: responseHeaders }));
+                        if (empty) {
+                            finished = true;
+                            socket.close();
+                            return;
+                        }
+                    }
+                    drain();
+                });
+                socket.onClose(() => { if (framing?.kind === "close" || !controller)
+                    finish();
+                else if (!finished)
+                    finish(new Error("WALI server closed mid-response.")); });
+                incoming.signal.addEventListener("abort", () => finish(incoming.signal.reason), { once: true });
+                socket.write(serializeRequest(incoming.method, `${target.pathname}${target.search}`, headers, body));
+            });
+        };
         const request = (virtualPort, method, url, headers, body) => {
             if (closed)
                 return Promise.reject(new Error("WALI loopback host is closed."));
@@ -97,21 +336,106 @@ export class BrowserWaliLoopbackHost {
                 return;
             outgoing.delete(connectionId);
             window.clearTimeout(active.timeout);
+            active.abort.abort();
             send({ type: "peer-close", connectionId });
         };
         const dispatchOutgoing = async (connectionId, peerClosed) => {
             const active = outgoing.get(connectionId);
             if (!active || active.handling)
                 return;
+            let parsed;
+            try {
+                parsed = parseRequest(active.chunks, active.byteLength, peerClosed);
+            }
+            catch {
+                finishOutgoing(connectionId);
+                return;
+            }
+            // Headers and body may arrive in different writes. An incomplete
+            // request still owns its socket and waits for the remaining bytes.
+            if (!parsed) {
+                if (peerClosed)
+                    finishOutgoing(connectionId);
+                return;
+            }
+            active.handling = true;
+            const body = parsed.body?.buffer.slice(parsed.body.byteOffset, parsed.body.byteOffset + parsed.body.byteLength);
+            // A streamed response is framed by the connection's close, so its head
+            // carries no length; the response deadline covers only the wait for it.
+            let streamed = 0;
+            const head = (statusCode, statusMessage, headers) => {
+                window.clearTimeout(active.timeout);
+                send({ type: "data", connectionId, bytes: serializeHead(statusCode, statusMessage, headers) });
+            };
+            const chunk = (bytes) => {
+                streamed += bytes.byteLength;
+                if (streamed > MAX_RESPONSE_BYTES)
+                    throw new Error("Browser loopback response exceeds 32 MiB.");
+                if (bytes.byteLength > 0)
+                    send({ type: "data", connectionId, bytes: Uint8Array.from(bytes) });
+            };
             try {
-                const parsed = parseRequest(active.chunks, active.byteLength, peerClosed);
-                if (!parsed) {
-                    if (peerClosed)
-                        finishOutgoing(connectionId);
+                // A server the page answers as Fetch (a Host Fetch service) streams
+                // its body as it is produced, and the client's close reaches its
+                // handler as an abort, as a Node guest's loopback fetch does.
+                const registered = browserRegisteredServer(this.bridge, active.port);
+                const fetchable = registered?.fetch;
+                const streaming = registered?.handleStreamingRequest;
+                // A streamed answer's timing is the client's, as on a real socket: its
+                // close aborts the handler, so no deadline is needed to reclaim the
+                // connection. A local model answers its head only after prefill.
+                if (fetchable || streaming || this.bridge.handleStreamingRequest)
+                    window.clearTimeout(active.timeout);
+                if (fetchable) {
+                    const response = await fetchable(new Request(`http://127.0.0.1:${active.port}${parsed.url}`, {
+                        method: parsed.method,
+                        headers: parsed.headers,
+                        ...(body && body.byteLength > 0 && parsed.method !== "GET" && parsed.method !== "HEAD" ? { body } : {}),
+                        signal: active.abort.signal,
+                    }));
+                    const reader = response.body?.getReader();
+                    try {
+                        if (!outgoing.has(connectionId))
+                            return;
+                        head(response.status, response.statusText, Object.fromEntries(response.headers));
+                        for (;;) {
+                            const next = reader ? await reader.read() : { done: true, value: undefined };
+                            if (next.done || !outgoing.has(connectionId))
+                                break;
+                            chunk(next.value);
+                        }
+                    }
+                    finally {
+                        await reader?.cancel().catch(() => undefined);
+                        reader?.releaseLock();
+                    }
+                    return;
+                }
+                // A worker's port streams through its registration's door, paced by
+                // nothing but the client, and the client's close cancels it.
+                if (streaming) {
+                    await streaming.call(registered, parsed.method, parsed.url, parsed.headers, body ? new Uint8Array(body) : undefined, (statusCode, statusMessage, headers) => { if (outgoing.has(connectionId))
+                        head(statusCode, statusMessage, headers); }, (bytes) => { if (outgoing.has(connectionId))
+                        chunk(bytes); }, () => undefined, { signal: active.abort.signal });
                     return;
                 }
-                active.handling = true;
-                const response = await this.bridge.handleRequest(active.port, parsed.method, parsed.url, parsed.headers, parsed.body?.buffer.slice(parsed.body.byteOffset, parsed.body.byteOffset + parsed.body.byteLength));
+                // A guest's server streams through the bridge's own door when it has one.
+                if (this.bridge.handleStreamingRequest) {
+                    let ended;
+                    const end = new Promise((resolve) => { ended = resolve; });
+                    const handled = await this.bridge.handleStreamingRequest(active.port, parsed.method, parsed.url, parsed.headers, body, {
+                        start: (statusCode, statusMessage, headers) => { if (outgoing.has(connectionId))
+                            head(statusCode, statusMessage, headers); },
+                        chunk: (bytes) => { if (outgoing.has(connectionId))
+                            chunk(bytes); },
+                        end: () => ended(),
+                    });
+                    if (handled) {
+                        await Promise.race([end, new Promise((resolve) => active.abort.signal.addEventListener("abort", () => resolve(), { once: true }))]);
+                        return;
+                    }
+                }
+                const response = await this.bridge.handleRequest(active.port, parsed.method, parsed.url, parsed.headers, body);
                 if (!outgoing.has(connectionId))
                     return;
                 const bytes = serializeResponse({
@@ -124,9 +448,10 @@ export class BrowserWaliLoopbackHost {
                     throw new Error("Browser loopback response exceeds 32 MiB.");
                 send({ type: "data", connectionId, bytes });
             }
-            catch {
+            catch (error) {
                 // The native client observes EOF when a browser-local peer rejects or
-                // cannot parse its request.
+                // cannot parse its request; the page's console keeps the cause.
+                console.warn(`WALI loopback request to port ${active.port} failed:`, error);
             }
             finally {
                 finishOutgoing(connectionId);
@@ -136,7 +461,7 @@ export class BrowserWaliLoopbackHost {
             const message = event.data;
             if (message.type === "listen") {
                 let result = 0;
-                if (!validPort(message.port) || this.bridge.getServerPorts().includes(message.port))
+                if (!validPort(message.port) || this.bridge.getServerPorts().includes(message.port) || this.tcpServers.has(message.port))
                     result = -98;
                 else {
                     try {
@@ -144,6 +469,7 @@ export class BrowserWaliLoopbackHost {
                             listening: true,
                             address: () => ({ port: message.port, address: "0.0.0.0", family: "IPv4" }),
                             handleRequest: (method, url, headers, body) => request(message.port, method, url, headers, body),
+                            fetch: (incoming) => streamingFetch(message.port, incoming),
                         };
                         this.bridge.registerServer(server, message.port);
                         if (this.webSocketRegistry) {
@@ -152,6 +478,9 @@ export class BrowserWaliLoopbackHost {
                             }));
                         }
                         registered.add(message.port);
+                        this.rawOpeners.set(message.port, () => openRaw(message.port));
+                        for (const observer of this.listenObservers)
+                            this.notifyListen(message.port, observer);
                     }
                     catch {
                         webSocketRegistrations.get(message.port)?.();
@@ -164,10 +493,70 @@ export class BrowserWaliLoopbackHost {
                 return;
             }
             if (message.type === "connect") {
+                const server = this.tcpServers.get(message.port);
+                if (server && Number.isSafeInteger(message.connectionId) && message.connectionId < 0
+                    && activeConnections() < MAX_ACTIVE_CONNECTIONS && !tcp.has(message.connectionId)
+                    && !outgoing.has(message.connectionId)) {
+                    const id = message.connectionId;
+                    const dataListeners = new Set();
+                    const closeListeners = new Set();
+                    let received = 0;
+                    let written = 0;
+                    let ended = false;
+                    const timer = window.setTimeout(() => socket.close(), RESPONSE_TIMEOUT_MS);
+                    const socket = {
+                        onData: (listener) => { dataListeners.add(listener); },
+                        onClose: (listener) => { closeListeners.add(listener); },
+                        write: (bytes) => {
+                            if (ended)
+                                return;
+                            written += bytes.byteLength;
+                            if (written > MAX_RESPONSE_BYTES) {
+                                socket.close();
+                                return;
+                            }
+                            send({ type: "data", connectionId: id, bytes });
+                        },
+                        close: () => {
+                            if (ended)
+                                return;
+                            ended = true;
+                            window.clearTimeout(timer);
+                            tcp.delete(id);
+                            server.sockets.delete(socket);
+                            send({ type: "peer-close", connectionId: id });
+                            for (const listener of closeListeners)
+                                listener();
+                        },
+                    };
+                    tcp.set(id, { socket, receive: (bytes) => {
+                            received += bytes.byteLength;
+                            if (received > MAX_REQUEST_BYTES) {
+                                socket.close();
+                                return;
+                            }
+                            try {
+                                for (const listener of dataListeners)
+                                    listener(bytes);
+                            }
+                            catch {
+                                socket.close();
+                            }
+                        } });
+                    server.sockets.add(socket);
+                    send({ type: "ack", requestId: message.requestId, result: 0 });
+                    try {
+                        server.accept(socket);
+                    }
+                    catch {
+                        socket.close();
+                    }
+                    return;
+                }
                 let result = 0;
                 if (!validPort(message.port) || !Number.isSafeInteger(message.connectionId)
                     || !this.bridge.getServerPorts().includes(message.port)
-                    || activeConnections() >= MAX_ACTIVE_CONNECTIONS || outgoing.has(message.connectionId)) {
+                    || activeConnections() >= MAX_ACTIVE_CONNECTIONS || outgoing.has(message.connectionId) || tcp.has(message.connectionId)) {
                     result = -111;
                 }
                 else {
@@ -178,6 +567,7 @@ export class BrowserWaliLoopbackHost {
                         byteLength: 0,
                         timeout,
                         handling: false,
+                        abort: new AbortController(),
                     });
                 }
                 send({ type: "ack", requestId: message.requestId, result });
@@ -187,6 +577,22 @@ export class BrowserWaliLoopbackHost {
                 unregister(message.port);
                 return;
             }
+            const raw = raws.get(message.connectionId);
+            if (raw) {
+                if (message.type === "outgoing")
+                    raw.receive(message.bytes);
+                else if (message.type === "closed")
+                    raw.closed();
+                return;
+            }
+            const stream = tcp.get(message.connectionId);
+            if (stream) {
+                if (message.type === "outgoing")
+                    stream.receive(message.bytes);
+                else if (message.type === "closed")
+                    stream.socket.close();
+                return;
+            }
             const response = pending.get(message.connectionId);
             const outbound = outgoing.get(message.connectionId);
             const webSocket = webSockets.get(message.connectionId)?.peer;
@@ -224,7 +630,11 @@ export class BrowserWaliLoopbackHost {
                         return;
                     }
                     if (outbound) {
-                        void dispatchOutgoing(message.connectionId, true);
+                        // A client that closes while its response streams has gone.
+                        if (outbound.handling)
+                            finishOutgoing(message.connectionId);
+                        else
+                            void dispatchOutgoing(message.connectionId, true);
                         return;
                     }
                     if (!response)
@@ -247,6 +657,10 @@ export class BrowserWaliLoopbackHost {
             if (closed)
                 return;
             closed = true;
+            for (const { socket } of [...tcp.values()])
+                socket.close();
+            for (const raw of [...raws.values()])
+                raw.closed();
             for (const virtualPort of [...registered])
                 unregister(virtualPort);
             for (const active of pending.values()) {
@@ -254,8 +668,10 @@ export class BrowserWaliLoopbackHost {
                 active.reject(new Error("WALI loopback server stopped."));
             }
             pending.clear();
-            for (const active of outgoing.values())
+            for (const active of outgoing.values()) {
                 window.clearTimeout(active.timeout);
+                active.abort.abort();
+            }
             outgoing.clear();
             for (const active of webSockets.values())
                 active.peer.terminate("WALI loopback host stopped.");
@@ -330,6 +746,24 @@ function parseRequest(chunks, byteLength, closed) {
         return;
     return { method: request[1], url, headers, body: bytes.slice(bodyStart) };
 }
+/** The head of a response whose body follows as it is produced, ended by the close. */
+function serializeHead(statusCode, statusMessage, raw) {
+    if (!Number.isInteger(statusCode) || statusCode < 100 || statusCode > 599) {
+        throw new Error("Invalid browser loopback response status.");
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(name))
+            continue;
+        headers[name.toLowerCase()] = (Array.isArray(value) ? value.join(", ") : value).replace(/[\u0000\r\n]/gu, "");
+    }
+    delete headers["transfer-encoding"];
+    delete headers["content-length"];
+    headers.connection = "close";
+    const reason = (statusMessage || "OK").replace(/[\u0000\r\n]/gu, "");
+    return new TextEncoder().encode(`HTTP/1.1 ${statusCode} ${reason}\r\n${Object.entries(headers)
+        .map(([name, value]) => `${name}: ${value}`).join("\r\n")}\r\n\r\n`);
+}
 function serializeResponse(response) {
     if (!Number.isInteger(response.statusCode) || response.statusCode < 100 || response.statusCode > 599) {
         throw new Error("Invalid browser loopback response status.");