@webqit/webflo 0.20.26 → 0.20.28

package/src/runtime-pi/webflo-server/WebfloServer.js

@@ -3,42 +3,43 @@ import Url from 'url';
 import Path from 'path';
 import Http from 'http';
 import Https from 'https';
-import { WebSocketServer } from 'ws';
 import Mime from 'mime-types';
 import crypto from 'crypto';
-import 'dotenv/config';
 import $glob from 'fast-glob';
 import EsBuild from 'esbuild';
 import { Readable } from 'stream';
+import { WebSocketServer } from 'ws';
 import { spawn } from 'child_process';
-import { _from as _arrFrom, _any } from '@webqit/util/arr/index.js';
-import { _isEmpty, _isObject } from '@webqit/util/js/index.js';
-import { _each } from '@webqit/util/obj/index.js';
-import { WebfloHMR, openBrowser } from './webflo-devmode.js';
-import { Clients } from './messaging/Clients.js';
-import { WebfloRuntime } from '../WebfloRuntime.js';
-import { WQSockPort } from '../webflo-messaging/WQSockPort.js';
-import { ServerSideCookies } from './ServerSideCookies.js';
-import { ServerSideSession } from './ServerSideSession.js';
-import { response as responseShim, headers as headersShim } from '../webflo-fetch/index.js';
-import { UseLiveTransform } from '../../build-pi/esbuild-plugin-uselive-transform.js';
 import { createWindow } from '@webqit/oohtml-ssr';
-import { _wq } from '../../util.js';
-import '../webflo-fetch/index.js';
-import '../webflo-url/index.js';
-
-export class WebfloServer extends WebfloRuntime {
-
-    static get HttpCookies() { return ServerSideCookies; }
+import { RequestPlus } from '@webqit/fetch-plus';
+import { HttpThread111 } from '../webflo-routing/HttpThread111.js';
+import { HttpCookies101 } from '../webflo-routing/HttpCookies101.js';
+import { HttpSession001 } from '../webflo-routing/HttpSession001.js';
+import { HttpUser111 } from '../webflo-routing/HttpUser111.js';
+import { HttpEvent111 } from '../webflo-routing/HttpEvent111.js';
+import { WebfloRouter111 } from '../webflo-routing/WebfloRouter111.js';
+import { KeyvalsFactory001 } from '../webflo-routing/KeyvalsFactory001.js';
+import { WebfloTenancy001 } from '../webflo-messaging/WebfloTenancy001.js';
+import { UseLiveTransform } from '../../build-pi/esbuild-plugin-uselive-transform.js';
+import { WebfloHMR, openBrowser } from './webflo-devmode.js';
+import { InMemoryKV } from '@webqit/keyval/inmemory';
+import { URLPatternPlus } from '@webqit/url-plus';
+import { WebSocketPort } from '@webqit/port-plus';
+import { AppRuntime } from '../AppRuntime.js';
+import { _meta } from '../../util.js';
+import 'dotenv/config';
 
-    static get HttpSession() { return ServerSideSession; }
+export class WebfloServer extends AppRuntime {
 
     static create(bootstrap) {
         return new this(bootstrap);
     }
 
+    #keyvals;
+    get keyvals() { return this.#keyvals; }
+
     #servers = new Map;
-    #clients = new Clients;
+    #tenancy = new WebfloTenancy001({ handshake: 1, postAwaitsOpen: true, autoClose: false });
     #hmr;
 
     #renderFileCache = new Map;
@@ -61,6 +62,14 @@ export class WebfloServer extends WebfloRuntime {
             await this.buildRoutes({ server: true });
         }
 
+        // ----------
+        // The keyvals API
+        this.#keyvals = new KeyvalsFactory001({
+            localDir: this.env('KEYVALS_DIR'),
+            redisUrl: this.env('REDIS_URL'),
+            redisNamespace: APP_META.name
+        });
+
         // ----------
         // Call default-init
         const instanceController = await super.initialize();
@@ -72,11 +81,14 @@ export class WebfloServer extends WebfloRuntime {
         // ----------
         // Show proxies
         const { PROXY } = this.config;
+
         if (PROXY.entries.length) {
             // Show active proxies
             LOGGER.info(`> Reverse proxies active.`);
+
             for (const proxy of PROXY.entries) {
                 let desc = `> ${proxy.hostnames.join('|')} >>> ${proxy.port || proxy.path}`;
+
                 // Start a proxy recursively?
                 if (proxy.path && FLAGS['recursive']) {
                     desc += ` ✅`;
@@ -87,6 +99,7 @@ export class WebfloServer extends WebfloRuntime {
                         shell: true       // for Windows compatibility
                     });
                 }
+
                 LOGGER.info(desc);
             }
         }
@@ -95,6 +108,7 @@ export class WebfloServer extends WebfloRuntime {
         // Show server details
         if (this.#servers.size) {
             LOGGER.info(`> Server running! (${APP_META.title || ''}) ✅`);
+
             for (let [proto, def] of this.#servers) {
                 LOGGER.info(`> ${proto.toUpperCase()} / ${def.hostnames.concat('').join(`:${def.port} / `)}`);
             }
@@ -109,7 +123,9 @@ export class WebfloServer extends WebfloRuntime {
         const routeDirs = [...new Set([this.config.LAYOUT.CLIENT_DIR, this.config.LAYOUT.WORKER_DIR, this.config.LAYOUT.SERVER_DIR])];
         const entryPoints = await $glob(routeDirs.map((d) => `${d}/**/handler{${client ? ',.client' : ''}${worker ? ',.worker' : ''}${server ? ',.server' : ''}}.js`), { absolute: true })
             .then((files) => files.map((file) => file.replace(/\\/g, '/')));
+
         const initFiles = await $glob(`${process.cwd()}/init.server.js`);
+
         const bundlingConfig = {
             entryPoints: entryPoints.concat(initFiles),
             outdir: this.config.RUNTIME_DIR,
@@ -123,11 +139,13 @@ export class WebfloServer extends WebfloRuntime {
             plugins: [UseLiveTransform()],
             ...options,
         };
+
         return await EsBuild.build(bundlingConfig);
     }
 
     async enterDevMode() {
         const { appMeta, flags: FLAGS } = this.cx;
+
         this.#hmr = WebfloHMR.manage(this, {
             appMeta,
             buildScripts: {
@@ -137,8 +155,10 @@ export class WebfloServer extends WebfloRuntime {
             },
             buildSensitivity: parseInt(FLAGS['build-sensitivity'] || 0),
         });
+
         await this.#hmr.buildRoutes(true);
         await this.#hmr.bundleAssetsIfPending(true);
+
         if (FLAGS['open']) {
             for (let [proto, def] of this.#servers) {
                 const url = `${proto}://${def.hostnames.find((h) => h !== '*') || 'localhost'}:${def.port}`;
@@ -147,194 +167,41 @@ export class WebfloServer extends WebfloRuntime {
         }
     }
 
-    async initCreateStorage() {
-        if (this.bootstrap.init.createStorage
-            || !this.bootstrap.init.redis) {
-            return super.initCreateStorage();
-        }
-
-        // ns -> field -> { value, subscriptions: Set<fn> }
-        const local = new Map();
-        const fire = (state, value, key, namespace, scopeReference = false) => {
-            const returnValues = [];
-            for (const subscription of state.subscriptions) {
-                const { callback, options } = subscription;
-                
-                const scope = subscription.scopeReference === scopeReference ? 0 : scopeReference ? 1 : 2;
-                // For options.scope === 0, only include same-request cycle mutations
-                // For options.scope === 1, only include local mutations
-                // For options.scope === 2, include remote mutations
-                if ((options.scope || 0) !== scope) continue;
-                
-                returnValues.push(callback(value, scope));
-                if (options.once) state.subscriptions.delete(subscription);
-                const ns = local.get(namespace);
-                if (!state.subscriptions.size) ns.delete(key);
-                if (!ns.size) local.delete(namespace);
-            }
-            return Promise.all(returnValues);
-        };
-
-        // Initialize storage
-        const redis = this.bootstrap.init.redis;
-        this.bootstrap.init.createStorage = (namespace, ttl = null, scopeReference = {}) => {
-            const cleanups = [];
-            return {
-                async has(key) { return await redis.hexists(namespace, key); },
-                async get(key) {
-                    const jsonValue = await redis.hget(namespace, key);
-                    return jsonValue === null ? undefined : JSON.parse(jsonValue);
-                },
-                async set(key, value) {
-                    const jsonValue = JSON.stringify(value);
-                    const returnValue = await redis.hset(namespace, key, jsonValue);
-                    if (!this.ttlApplied && ttl) {
-                        await redis.expire(namespace, ttl);
-                        this.ttlApplied = true;
-                    }
-                    const state = local.get(namespace)?.get(key);
-                    if (state) {
-                        state.jsonValue = jsonValue;
-                        state.initialized = true;
-                        await fire(state, value, key, namespace, scopeReference);
-                    }
-                    return returnValue;
-                },
-                async delete(key) {
-                    const returnValue = await redis.hdel(namespace, key);
-                    const state = local.get(namespace)?.get(key);
-                    if (state) {
-                        state.jsonValue = null;
-                        state.initialized = true;
-                        await fire(state, undefined, key, namespace, scopeReference);
-                    }
-                    return returnValue;
-                },
-                async clear() {
-                    const returnValue = await redis.del(namespace);
-                    const nsLocal = local.get(namespace);
-                    if (nsLocal) {
-                        for (const [key, state] of nsLocal.entries()) {
-                            state.jsonValue = null;
-                            state.initialized = true;
-                            await fire(state, undefined, key, namespace, scopeReference);
-                        }
-                    }
-                    return returnValue;
-                },
-                async keys() { return await redis.hkeys(namespace); },
-                async values() { return (await redis.hvals(namespace) || []).map((value) => value === null ? undefined : JSON.parse(value)); },
-                async entries() { return Object.entries(await redis.hgetall(namespace) || {}).map(([key, value]) => [key, value === null ? undefined : JSON.parse(value)]); },
-                get size() { return redis.hlen(namespace); },
-                observe(key, callback, options = {}) {
-                    // Prepare local data structure
-                    let ns = local.get(namespace);
-                    if (!ns) {
-                        ns = new Map();
-                        local.set(namespace, ns);
-                    }
-
-                    let state = ns.get(key);
-                    if (!state) {
-                        state = { jsonValue: null, initialized: false, subscriptions: new Set() };
-                        ns.set(key, state);
-                        // Prime initial value only once
-                        redis.hget(namespace, key).then((jsonValue) => {
-                            if (state.initialized) return;
-                            state.jsonValue = jsonValue;
-                            state.initialized = true;
-                        });
-                    }
-
-                    const subscription = { callback, options, scopeReference };
-                    state.subscriptions.add(subscription);
-                    if (options.signal) {
-                        options.signal.addEventListener('abort', () => {
-                            state.subscriptions.delete(subscription);
-                            if (state.subscriptions.size === 0) ns.delete(key);
-                            if (ns.size === 0) local.delete(namespace);
-                        });
-                    }
-
-                    // Unsubscribe logic
-                    const cleanup = () => {
-                        state.subscriptions.delete(subscription);
-                        if (state.subscriptions.size === 0) ns.delete(key);
-                        if (ns.size === 0) local.delete(namespace);
-                    };
-                    cleanups.push(cleanup);
-                    return cleanup;
-                },
-                cleanup() {
-                    for (const cleanup of cleanups) cleanup();
-                    cleanups.length = 0;
-                },
-            };
-        };
-
-        // Watch for changes
-        const redisWatch = this.bootstrap.init.redisWatch;
-        if (redisWatch) {
-            // Subscribe to all events
-            redisWatch.psubscribe('__keyevent@0__:*');
-            redisWatch.on('pmessage', async (pattern, channel, redisKey) => {
-                const [, , event] = channel.split(':'); // -> "hset", "hdel", "expire", "del"
-                const namespace = redisKey;
-
-                const nsLocal = local.get(namespace);
-                if (!nsLocal) return;
-
-                const emitDiff = async () => {
-                    for (const [field, state] of nsLocal) {
-                        const jsonValue = await redis.hget(namespace, field);
-                        if (jsonValue !== state.jsonValue) {
-                            state.jsonValue = jsonValue;
-                            const value = jsonValue === null ? undefined : JSON.parse(jsonValue);
-                            fire(state, value, field, namespace);
-                        }
-                    }
-                }
-
-                // Field updates
-                if (event === 'hset') await emitDiff();
-                if (event === 'hdel') await emitDiff();
-
-                // Namespace removal (expire or del)
-                if (event === 'expire' || event === 'del') {
-                    for (const [key, state] of nsLocal) {
-                        if (state.jsonValue !== null) {
-                            state.jsonValue = null;
-                            fire(state, undefined, key, namespace);
-                        }
-                    }
-                    local.delete(namespace);
-                }
-            });
-        }
-    }
-
     control() {
-        const { flags: FLAGS } = this.cx;
+        const { flags: FLAGS, logger: LOGGER } = this.cx;
         const { SERVER, PROXY } = this.config;
         const instanceController = super.control();
 
         if (!FLAGS['test-only'] && !FLAGS['https-only'] && SERVER.port) {
-            const httpServer = Http.createServer((request, response) => this.handleNodeHttpRequest(request, response));
+            const httpServer = Http.createServer((request, response) => {
+                this.handleNodeHttpRequest(request, response).catch((e) => {
+                    LOGGER.error(e);
+                });
+            });
             httpServer.listen(FLAGS['port'] || SERVER.port);
+
             this.#servers.set('http', {
                 instance: httpServer,
                 hostnames: SERVER.hostnames,
                 port: FLAGS['port'] || SERVER.port,
             });
+
             // Handle WebSocket connections
             httpServer.on('upgrade', (request, socket, head) => {
-                this.handleNodeWsRequest(wss, request, socket, head);
+                this.handleNodeWsRequest(wss, request, socket, head).catch((e) => {
+                    LOGGER.error(e);
+                });
             });
         }
 
         if (!FLAGS['test-only'] && !FLAGS['http-only'] && SERVER.https.port) {
-            const httpsServer = Https.createServer((request, response) => this.handleNodeHttpRequest(request, response));
+            const httpsServer = Https.createServer((request, response) => {
+                this.handleNodeHttpRequest(request, response).catch((e) => {
+                    LOGGER.error(e);
+                });
+            });
             httpsServer.listen(SERVER.https.port);
+
             const addSSLContext = (SERVER) => {
                 if (!Fs.existsSync(SERVER.https.keyfile)) return;
                 const cert = {
@@ -344,32 +211,37 @@ export class WebfloServer extends WebfloRuntime {
                 SERVER.https.hostnames.forEach((hostname) => {
                     httpsServer.addContext(hostname, cert);
                 });
-            }
+            };
+
             this.#servers.set('https', {
                 instance: httpsServer,
                 hostnames: SERVER.https.hostnames,
                 port: SERVER.https.port,
             });
-            // -------
+
             addSSLContext(SERVER);
+
             for (const proxy of PROXY.entries) {
                 if (proxy.SERVER) {
                     addSSLContext(proxy.SERVER);
                 }
             }
+
             // Handle WebSocket connections
             httpsServer.on('upgrade', (request, socket, head) => {
-                this.handleNodeWsRequest(wss, request, socket, head);
+                this.handleNodeWsRequest(wss, request, socket, head).catch((e) => {
+                    LOGGER.error(e);
+                });
             });
         }
 
         const wss = new WebSocketServer({ noServer: true });
 
         process.on('uncaughtException', (err) => {
-            console.error('Uncaught Exception:', err);
+            LOGGER.error('Uncaught Exception:', err);
         });
         process.on('unhandledRejection', (reason, promise) => {
-            console.log('Unhandled Rejection', reason, promise);
+            LOGGER.log('Unhandled Rejection', reason, promise);
         });
 
         return instanceController;
@@ -377,32 +249,35 @@ export class WebfloServer extends WebfloRuntime {
 
     identifyIncoming(request, autoGenerateID = false) {
         const secret = this.env('SESSION_KEY');
-        let clientID = headersShim.get.value.call(request.headers, 'Cookie', true).find((c) => c.name === '__sessid')?.value;
-        if (clientID?.includes('.')) {
+        let tenantID = request.headers.get('Cookie', true).find((c) => c.name === '__sessid')?.value;
+        if (tenantID?.includes('.')) {
             if (secret) {
-                const [rand, signature] = clientID.split('.');
+                const [rand, signature] = tenantID.split('.');
                 const expectedSignature = crypto.createHmac('sha256', secret)
                     .update(rand)
                     .digest('hex');
                 if (signature !== expectedSignature) {
-                    clientID = null;
+                    tenantID = null;
                 }
             } else {
-                clientID = null;
+                tenantID = null;
             }
         }
-        if (!clientID && autoGenerateID) {
+        if (!tenantID) {
+            tenantID = request.headers.get('Authorization')?.replace(/\s+/, '_');
+        }
+        if (!tenantID && autoGenerateID) {
             if (secret) {
                 const rand = `${(0 | Math.random() * 9e6).toString(36)}`;
                 const signature = crypto.createHmac('sha256', secret)
                     .update(rand)
                     .digest('hex');
-                clientID = `${rand}.${signature}`
+                tenantID = `${rand}.${signature}`
             } else {
-                clientID = crypto.randomUUID();
+                tenantID = crypto.randomUUID();
             }
         }
-        return clientID;
+        return tenantID;
     }
 
     async preResolveIncoming({ type, nodeRequest, proxy, reject, handle }) {
@@ -459,7 +334,7 @@ export class WebfloServer extends WebfloRuntime {
         }
         if (REDIRECTS) {
             const rejection = REDIRECTS.entries.reduce((_rdr, entry) => {
-                return _rdr || ((_rdr = (new URLPattern(entry.from, url.origin)).exec(url.href)) && {
+                return _rdr || ((_rdr = new URLPatternPlus(entry.from, url.origin).exec(url.href)) && {
                     status: entry.code || 302,
                     statusText: entry.code === 301 ? 'Moved Permanently' : 'Found',
                     headers: { Location: _rdr.render(entry.to) }
@@ -469,10 +344,11 @@ export class WebfloServer extends WebfloRuntime {
                 return reject(rejection);
             }
         }
-        return handle(url);
+        return await handle(url);
     }
 
     async handleNodeWsRequest(wss, nodeRequest, socket, head) {
+        const { logger: LOGGER } = this.cx;
         const reject = (rejection) => {
             const status = rejection.status || 400;
             const statusText = rejection.statusText || 'Bad Request';
@@ -487,7 +363,7 @@ export class WebfloServer extends WebfloRuntime {
                 `\r\n` +
                 body + `\r\n`
             );
-            socket.destroy();
+            socket.end();
         };
         const proxy = async (destinationURL) => {
             const isSecure = destinationURL.protocol === 'wss:';
@@ -513,11 +389,11 @@ export class WebfloServer extends WebfloRuntime {
             });
             // Handle errors
             proxySocket.on('error', err => {
-                console.error('Proxy socket error:', err);
-                socket.destroy();
+                LOGGER.error('Proxy socket error:', err);
+                socket.end();
             });
             socket.on('error', () => {
-                proxySocket.destroy();
+                proxySocket.end();
             });
         };
         const handle = (requestURL) => {
@@ -527,24 +403,29 @@ export class WebfloServer extends WebfloRuntime {
                     this.#hmr.clients.add(ws);
                 });
             }
+
             if (requestURL.searchParams.get('rel') === 'background-messaging') {
-                const request = new Request(requestURL.href, { headers: nodeRequest.headers });
-                const clientID = this.identifyIncoming(request);
-                const client = clientID && this.#clients.getClient(clientID);
-                if (!client) {
-                    return reject({ body: `Lost or invalid clientID` });
+                const request = new RequestPlus(requestURL.href, { headers: nodeRequest.headers });
+                const tenantID = this.identifyIncoming(request);
+
+                const tenant = tenantID && this.#tenancy.getTenant(tenantID);
+                if (!tenant) {
+                    return reject({ body: `Lost or invalid tenantID` });
                 }
-                const clientRequestRealtime = client?.getRequestRealtime(requestURL.pathname.split('/').pop());
-                if (!clientRequestRealtime) {
+
+                const clientRequestPort = tenant?.getRequestPort(requestURL.pathname.split('/').pop());
+                if (!clientRequestPort) {
                     return reject({ body: `Lost or invalid portID` });
                 }
+
                 wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
                     wss.emit('connection', ws, nodeRequest);
-                    const wsw = new WQSockPort(ws);
-                    clientRequestRealtime.addPort(wsw);
+                    const wsw = new WebSocketPort(ws, { handshake: 1, postAwaitsOpen: true });
+                    clientRequestPort.addPort(wsw);
                 });
             }
         };
+
         return await this.preResolveIncoming({ type: 'ws', nodeRequest, proxy, reject, handle });
     }
 
@@ -556,8 +437,10 @@ export class WebfloServer extends WebfloRuntime {
                 if (existing) nodeResponse.setHeader(name, [].concat(existing).concat(value));
                 else nodeResponse.setHeader(name, value);
             }
-            nodeResponse.statusCode = responseShim.prototype.status.get.call(response);
+
+            nodeResponse.statusCode = response.status;
             nodeResponse.statusMessage = response.statusText;
+
             if (response.body instanceof Readable) {
                 response.body.pipe(nodeResponse);
             } else if (response.body instanceof ReadableStream) {
@@ -567,6 +450,7 @@ export class WebfloServer extends WebfloRuntime {
             } else {
                 nodeResponse.end();
             }
+
             // Logging
             const { logger: LOGGER } = this.cx;
             if (LOGGER && requestURL) {
@@ -574,10 +458,12 @@ export class WebfloServer extends WebfloRuntime {
                 LOGGER.log(log);
             }
         };
+
         // Reject with error status
         const reject = async (rejection) => {
             respondWith(new Response(null, rejection));
         };
+
         // Proxy request to a remote/local host
         const proxy = async (destinationURL) => {
             const requestInit = this.parseNodeRequest(nodeRequest);
@@ -586,6 +472,7 @@ export class WebfloServer extends WebfloRuntime {
             const response = await fetch(destinationURL, requestInit);
             respondWith(response, destinationURL);
         };
+
         // Handle
         const handle = async (requestURL) => {
             const requestInit = this.parseNodeRequest(nodeRequest);
@@ -596,6 +483,7 @@ export class WebfloServer extends WebfloRuntime {
             });
             respondWith(response, requestURL);
         };
+
         return await this.preResolveIncoming({ typr: 'http', nodeRequest, reject, proxy, handle });
     }
 
@@ -632,33 +520,35 @@ export class WebfloServer extends WebfloRuntime {
     writeRedirectHeaders(httpEvent, response) {
         const $sparoots = this.bootstrap.$sparoots;
         const xRedirectPolicy = httpEvent.request.headers.get('X-Redirect-Policy');
-        const xRedirectCode = httpEvent.request.headers.get('X-Redirect-Code') || 300;
         const destinationURL = new URL(response.headers.get('Location'), httpEvent.url.origin);
         const isSameOriginRedirect = destinationURL.origin === httpEvent.url.origin;
         let isSameSpaRedirect = true;
+
         if (isSameOriginRedirect && xRedirectPolicy === 'manual-when-cross-spa' && $sparoots.length) {
             // Longest-first sorting
             const sparoots = $sparoots.sort((a, b) => a.length > b.length ? -1 : 1);
             const matchRoot = path => sparoots.reduce((prev, root) => prev || (`${path}/`.startsWith(`${root}/`) && root), null);
             isSameSpaRedirect = matchRoot(destinationURL.pathname) === matchRoot(httpEvent.url.pathname);
         }
+
         if (xRedirectPolicy === 'manual' || (!isSameOriginRedirect && (xRedirectPolicy === 'manual-when-cross-origin' || xRedirectPolicy === 'manual-when-cross-spa')) || (!isSameSpaRedirect && xRedirectPolicy === 'manual-when-cross-spa')) {
-            response.headers.set('X-Redirect-Code', responseShim.prototype.status.get.call(response));
+            response.headers.set('X-Redirect-Code', response.status);
             response.headers.set('Access-Control-Allow-Origin', '*');
             response.headers.set('Cache-Control', 'no-store');
-            const responseMeta = _wq(response, 'meta');
-            responseMeta.set('status', xRedirectCode);
         }
     }
 
     async remoteFetch(request, ...args) {
         let href = request;
+
         if (request instanceof Request) {
             href = request.url;
         } else if (request instanceof URL) {
             href = request.href;
         }
+
         const _response = fetch(request, ...args);
+
         // Save a reference to this
         return _response.then(async response => {
             // Stop loading status
@@ -670,6 +560,7 @@ export class WebfloServer extends WebfloRuntime {
         const { flags: FLAGS } = this.cx;
         const { RUNTIME_LAYOUT, LAYOUT } = this.config;
         const scopeObj = {};
+
         if (FLAGS['dev']) {
             if (httpEvent.url.pathname === '/@hmr') {
                 const filename = httpEvent.url.searchParams.get('src')?.split('?')[0] || '';
@@ -690,22 +581,28 @@ export class WebfloServer extends WebfloRuntime {
         } else {
             scopeObj.filename = Path.join(LAYOUT.PUBLIC_DIR, httpEvent.url.pathname.split('?')[0]);
         }
+
         scopeObj.ext = Path.parse(scopeObj.filename).ext;
+
         const finalizeResponse = (response) => {
             // Qualify Service-Worker responses
             if (httpEvent.request.headers.get('Service-Worker') === 'script') {
                 response.headers.set('Service-Worker-Allowed', this.config.WORKER.scope || '/');
             }
-            const responseMeta = _wq(response, 'meta');
+
+            const responseMeta = _meta(response);
             responseMeta.set('filename', scopeObj.filename);
             responseMeta.set('static', true);
             responseMeta.set('index', scopeObj.index);
+
             return response;
         };
+
         // Pre-encoding support?
         if (scopeObj.preEncodingSupportLevel !== 0) {
             scopeObj.acceptEncs = [];
             scopeObj.supportedEncs = { gzip: '.gz', br: '.br' };
+
             if ((scopeObj.acceptEncs = (httpEvent.request.headers.get('Accept-Encoding') || '').split(',').map((e) => e.trim())).length
                 && (scopeObj.enc = scopeObj.acceptEncs.reduce((prev, _enc) => prev || (scopeObj.supportedEncs[_enc] && Fs.existsSync(scopeObj.filename + scopeObj.supportedEncs[_enc]) && _enc), null))) {
                 // Route to a pre-compressed version of the file
@@ -715,6 +612,7 @@ export class WebfloServer extends WebfloRuntime {
                 // TODO: Do dynamic encoding
             }
         }
+
         // if is a directory, search for index file matching the extention
         if (!scopeObj.ext && scopeObj.autoIndexFileSupport !== false && Fs.existsSync(scopeObj.filename) && (scopeObj.stats = Fs.lstatSync(scopeObj.filename)).isDirectory()) {
             scopeObj.ext = '.html';
@@ -722,6 +620,7 @@ export class WebfloServer extends WebfloRuntime {
             scopeObj.filename = Path.join(scopeObj.filename, scopeObj.index);
             scopeObj.stats = null;
         }
+
         // ------ If we get here, scopeObj.filename has been finalized ------
         // Do file stats
         if (!scopeObj.stats) {
@@ -730,9 +629,11 @@ export class WebfloServer extends WebfloRuntime {
                 throw e; // Re-throw other errors
             }
         }
+
         // ETag support
         scopeObj.stats.etag = `W/"${scopeObj.stats.size}-${scopeObj.stats.mtimeMs}"`;
         const ifNoneMatch = httpEvent.request.headers.get('If-None-Match');
+
         if (scopeObj.stats.etag && ifNoneMatch === scopeObj.stats.etag) {
             const response = new Response(null, { status: 304, statusText: 'Not Modified' });
             response.headers.set('ETag', scopeObj.stats.etag);
@@ -740,29 +641,37 @@ export class WebfloServer extends WebfloRuntime {
             response.headers.set('Cache-Control', 'public, max-age=31536000'); // 1 year
             return finalizeResponse(response);
         }
-        scopeObj.stats.mime = scopeObj.ext && Mime.lookup(scopeObj.ext)?.replace('application/javascript', 'text/javascript') || 'application/octet-stream';
+
+        scopeObj.stats.mime = scopeObj.ext && (Mime.lookup(scopeObj.ext) || null)?.replace('application/javascript', 'text/javascript') || 'application/octet-stream';
+
         // Range support
         const readStream = (params = {}) => Fs.createReadStream(scopeObj.filename, { ...params });
         scopeObj.response = this.createStreamingResponse(httpEvent, readStream, scopeObj.stats);
-        const statusCode = responseShim.prototype.status.get.call(scopeObj.response);
+        const statusCode = scopeObj.response.status;
         if (statusCode === 416) return finalizeResponse(scopeObj.response);
+
         // ------ If we get here, it means we're good ------
         if (scopeObj.enc) {
             scopeObj.response.headers.set('Content-Encoding', scopeObj.enc);
         }
+
         // 1. Strong cache validators
         scopeObj.response.headers.set('ETag', scopeObj.stats.etag);
         scopeObj.response.headers.set('Last-Modified', scopeObj.stats.mtime.toUTCString());
+
         // 2. Content presentation and policy
         scopeObj.response.headers.set('Content-Disposition', `inline; filename="${Path.basename(scopeObj.filename)}"`);
         scopeObj.response.headers.set('Referrer-Policy', 'no-referrer-when-downgrade');
+
         // 3. Cache-Control
         scopeObj.response.headers.set('Cache-Control', 'public, max-age=31536000'); // 1 year
         scopeObj.response.headers.set('Vary', 'Accept-Encoding'); // The header that talks to our support for "Accept-Encoding"
+
         // 4. Security headers
         scopeObj.response.headers.set('X-Content-Type-Options', 'nosniff');
         scopeObj.response.headers.set('Access-Control-Allow-Origin', '*');
         scopeObj.response.headers.set('X-Frame-Options', 'SAMEORIGIN');
+
         // 5. Partial content support
         scopeObj.response.headers.set('Accept-Ranges', 'bytes');
 
@@ -772,63 +681,110 @@ export class WebfloServer extends WebfloRuntime {
     async navigate(url, init = {}, detail = {}) {
         const { HEADERS } = this.config;
         const { flags: FLAGS } = this.cx;
-        const scopeObj = { url, init, detail };
+
+        // Scope object
+        const scopeObj = {
+            url,
+            init,
+            detail,
+            requestID: (0 | Math.random() * 9e6).toString(36),
+            sessionTTL: parseInt(this.env('SESSION_TTL')) || 2592000/*30days*/
+        };
         if (typeof scopeObj.url === 'string') {
             scopeObj.url = new URL(scopeObj.url, 'http://localhost');
         }
-        // Request processing
+
+        // Request
         scopeObj.autoHeaders = HEADERS.entries.filter((entry) => (new URLPattern(entry.url, url.origin)).exec(url.href)) || [];
-        scopeObj.request = this.createRequest(scopeObj.url.href, scopeObj.init, scopeObj.autoHeaders.filter((header) => header.type === 'request'));
-        scopeObj.clientID = this.identifyIncoming(scopeObj.request, true);
-        scopeObj.client = this.#clients.getClient(scopeObj.clientID, true);
-        scopeObj.clientPortID = crypto.randomUUID();
-        scopeObj.clientRequestRealtime = scopeObj.client.createRequestRealtime(scopeObj.clientPortID, scopeObj.request.url);
-        scopeObj.sessionTTL = this.env('SESSION_TTL') || 2592000/*30days*/;
-        scopeObj.thread = this.createHttpThread({
-            store: this.createStorage(`${scopeObj.url.host}/thread:${scopeObj.clientID}`, scopeObj.sessionTTL),
+        scopeObj.request = scopeObj.init instanceof Request && scopeObj.init.url === scopeObj.url.href
+            ? scopeObj.init
+            : this.createRequest(scopeObj.url.href, scopeObj.init, scopeObj.autoHeaders.filter((header) => header.type === 'request'));
+        RequestPlus.upgradeInPlace(scopeObj.request);
+        scopeObj.tenantID = this.identifyIncoming(scopeObj.request, true);
+
+        // Origins
+        const origins = [scopeObj.requestID];
+
+        // Thread
+        scopeObj.thread = HttpThread111.create({
+            context: {},
+            store: this.#keyvals.create({ path: ['thread', scopeObj.tenantID], origins }),
             threadID: scopeObj.url.searchParams.get('_thread'),
             realm: 3
         });
-        scopeObj.cookies = this.createHttpCookies({
-            request: scopeObj.request,
-            thread: scopeObj.thread,
+
+        // Cookies
+        const entries = scopeObj.request.headers.get('Cookie', true).map((c) => [c.name, c]);
+        const store = InMemoryKV.create({ path: ['cookies', scopeObj.tenantID] });
+        entries.forEach(([key, value]) => store.set(key, { value }));
+        const initial = Object.fromEntries(entries);
+        scopeObj.cookies = HttpCookies101.create({
+            context: { handlersRegistry: this.#keyvals.getHandlers('cookies', true) },
+            store,
+            initial,
             realm: 3
         });
-        scopeObj.session = this.createHttpSession({
-            store: this.createStorage(`${scopeObj.url.host}/session:${scopeObj.clientID}`, scopeObj.sessionTTL),
-            request: scopeObj.request,
-            thread: scopeObj.thread,
-            sessionID: scopeObj.clientID,
+
+        // Session
+        scopeObj.session = HttpSession001.create({
+            context: { handlersRegistry: this.#keyvals.getHandlers('session', true) },
+            store: this.#keyvals.create({ path: ['session', scopeObj.tenantID], ttl: scopeObj.sessionTTL, origins }),
+            sessionID: scopeObj.tenantID,
             ttl: scopeObj.sessionTTL,
             realm: 3
         });
-        scopeObj.user = this.createHttpUser({
-            store: this.createStorage(`${scopeObj.url.host}/user:${scopeObj.clientID}`, scopeObj.sessionTTL),
-            request: scopeObj.request,
-            thread: scopeObj.thread,
-            client: scopeObj.clientRequestRealtime,
+
+        // User
+        scopeObj.user = HttpUser111.create({
+            context: { handlersRegistry: this.#keyvals.getHandlers('user', true) },
+            store: this.#keyvals.create({ path: ['user', scopeObj.tenantID], ttl: scopeObj.sessionTTL, origins }),
             realm: 3
         });
-        scopeObj.httpEvent = this.createHttpEvent({
+
+        // Client
+        scopeObj.tenant = this.#tenancy.getTenant(scopeObj.tenantID, true);
+        scopeObj.clientRequestPort = scopeObj.tenant.createRequestPort(
+            crypto.randomUUID(),
+            scopeObj.request.url
+        );
+
+        // HttpEvent
+        scopeObj.httpEvent = HttpEvent111.create({
+            detail: scopeObj.detail,
+            signal: init.signal,
             request: scopeObj.request,
             thread: scopeObj.thread,
-            client: scopeObj.clientRequestRealtime,
             cookies: scopeObj.cookies,
             session: scopeObj.session,
             user: scopeObj.user,
-            detail: scopeObj.detail,
+            client: scopeObj.clientRequestPort,
             realm: 3
         });
+
         // Dispatch for response
         scopeObj.response = await this.dispatchNavigationEvent({
             httpEvent: scopeObj.httpEvent,
             crossLayerFetch: (event) => this.localFetch(event),
-            clientPortB: `ws:${scopeObj.httpEvent.client.portID}?rel=background-messaging`
+            clientPortB: `socket:///${scopeObj.httpEvent.client.portID}?rel=background-messaging`
         });
+
+        // Commit session - expires six months
+        if (!scopeObj.response.headers.get('Set-Cookie', true).find((c) => c.name === '__sessid')) {
+            scopeObj.response.headers.append('Set-Cookie', `__sessid=${scopeObj.tenantID}; Path=/; ${!FLAGS['dev'] ? 'Secure; ' : ''}HttpOnly; SameSite=Lax${scopeObj.sessionTTL ? `; Max-Age=${scopeObj.sessionTTL}` : ''}`);
+        }
+
+        // Commit cookies
+        for (const cookieStr of await scopeObj.cookies.render()) {
+            scopeObj.response.headers.append('Set-Cookie', cookieStr);
+        }
+        await scopeObj.cookies._commit();
+
         // Reponse handlers
         if (FLAGS['dev']) {
             scopeObj.response.headers.set('X-Webflo-Dev-Mode', 'true'); // Must come before satisfyRequestFormat() sp as to be rendered
         }
+
+        // Write headers / satisfy request format
         if (scopeObj.response.headers.get('Location')) {
             this.writeRedirectHeaders(scopeObj.httpEvent, scopeObj.response);
         } else {
@@ -838,74 +794,90 @@ export class WebfloServer extends WebfloRuntime {
                 scopeObj.response.headers.set('Cache-Control', 'no-store');
             }
         }
+
         return scopeObj.response;
     }
 
     async satisfyRequestFormat(httpEvent, response) {
-        const statusCode = responseShim.prototype.status.get.call(response);
+        const statusCode = response.status;
+
         if (statusCode === 206 || statusCode === 416) {
             // If the response is a partial content, we don't need to do anything else
             return response;
         }
+
         // Satisfy "Accept" header
-        const requestAccept = headersShim.get.value.call(httpEvent.request.headers, 'Accept', true);
+        const requestAccept = httpEvent.request.headers.get('Accept', true);
         const asHTML = requestAccept?.match('text/html');
         const asIs = requestAccept?.match(response.headers.get('Content-Type'));
-        const responseMeta = _wq(response, 'meta');
+        const responseMeta = _meta(response);
+
         if (requestAccept && asHTML > asIs && !responseMeta.get('static')) {
             response = await this.render(httpEvent, response);
-        } else if (requestAccept && response.headers.get('Content-Type') && !asIs) {
+        } else if (requestAccept && response.body && response.headers.get('Content-Type') && !asIs) {
             return new Response(response.body, { status: 406, statusText: 'Not Acceptable', headers: response.headers });
         }
+
         // ------- With "exception" responses out of the way,
         // let's set the header that talks to our support for "Accept"
         if (!responseMeta.get('static')) {
             response.headers.append('Vary', 'Accept');
         }
+
         // Satisfy "Range" header
-        const requestRange = headersShim.get.value.call(httpEvent.request.headers, 'Range', true);
-        if (requestRange.length && response.headers.get('Content-Length')) {
+        const requestRange = httpEvent.request.headers.get('Range', true);
+        if (requestRange.length && response.body && response.headers.get('Content-Length')) {
             const stats = {
                 size: parseInt(response.headers.get('Content-Length')),
                 mime: response.headers.get('Content-Type') || 'application/octet-stream',
             };
+
             const headersBefore = response.headers;
             response = this.createStreamingResponse(
                 httpEvent,
                 (params) => this.streamSlice(response.body, { ...params }),
                 stats
             );
+
             for (const [name, value] of headersBefore) {
                 if (/Content-Length|Content-Type/i.test(name)) continue;
                 response.headers.append(name, value);
             }
         }
+
         return response;
     }
 
     async render(httpEvent, response) {
         const { LAYOUT } = this.config;
         const scopeObj = {};
-        scopeObj.router = new this.constructor.Router(this, httpEvent.url.pathname);
+
+        scopeObj.router = new WebfloRouter111(this, httpEvent.url.pathname);
         scopeObj.rendering = await scopeObj.router.route('render', httpEvent, async (httpEvent) => {
             let renderFile, pathnameSplit = httpEvent.url.pathname.split('/');
+
             while ((renderFile = Path.join(LAYOUT.PUBLIC_DIR, './' + pathnameSplit.join('/'), 'index.html'))
                 && (this.#renderFileCache.get(renderFile) === false/* false on previous runs */ || !Fs.existsSync(renderFile))) {
                 this.#renderFileCache.set(renderFile, false);
                 pathnameSplit.pop();
             }
+
             const dirPublic = Url.pathToFileURL(Path.resolve(Path.join(LAYOUT.PUBLIC_DIR)));
             const instanceParams = /*QueryString.stringify*/({
                 //file: renderFile,
                 url: dirPublic.href,// httpEvent.url.href,
             });
+
             const { window, document } = createWindow(renderFile, instanceParams);
+
             //const { window, document } = await import('@webqit/oohtml-ssr/src/instance.js?' + instanceParams);
             await new Promise((res) => {
                 if (document.readyState === 'complete') return res(1);
                 document.addEventListener('load', res);
             });
-            const data = await responseShim.prototype.parse.value.call(response);
+
+            const data = await response.any({ to: 'json' });
+
             if (window.webqit?.oohtml?.config) {
                 // Await rendering engine
                 if (window.webqit?.$qCompilerWorker) {
@@ -915,14 +887,17 @@ export class WebfloServer extends WebfloRuntime {
                         setTimeout(() => res(1), 1000);
                     });
                 }
+
                 const {
                     HTML_IMPORTS: { attr: modulesContextAttrs } = {},
                     BINDINGS_API: { api: bindingsConfig } = {},
                 } = window.webqit.oohtml.config;
+
                 if (modulesContextAttrs) {
                     const newRoute = '/' + `app/${httpEvent.url.pathname}`.split('/').map(a => (a => a.startsWith('$') ? '-' : a)(a.trim())).filter(a => a).join('/');
                     document.body.setAttribute(modulesContextAttrs.importscontext, newRoute);
                 }
+
                 if (bindingsConfig) {
                     document[bindingsConfig.bind]({
                         state: {},
@@ -935,9 +910,11 @@ export class WebfloServer extends WebfloRuntime {
                         background: null
                     }, { diff: true });
                 }
+
                 await new Promise(res => setTimeout(res, 300));
             }
-            for (const name of ['X-Background-Messaging-Port', 'X-Live-Response-Message-ID', 'X-Webflo-Dev-Mode']) {
+
+            for (const name of ['X-Message-Port', 'X-Webflo-Dev-Mode']) {
                 document.querySelector(`meta[name="${name}"]`)?.remove();
                 if (!response.headers.get(name)) continue;
                 const metaElement = document.createElement('meta');
@@ -945,6 +922,7 @@ export class WebfloServer extends WebfloRuntime {
                 metaElement.setAttribute('content', response.headers.get(name));
                 document.head.prepend(metaElement);
             }
+
             // Append hydration data
             for (const [rel, content] of [['hydration', data]]) {
                 document.querySelector(`script[rel="${rel}"][type="application/json"]`)?.remove();
@@ -954,18 +932,23 @@ export class WebfloServer extends WebfloRuntime {
                 dataScript.textContent = JSON.stringify(content);
                 document.body.append(dataScript);
             }
+
             const rendering = window.toString();
             document.documentElement.remove();
             document.writeln('');
+
             try { window.close(); } catch (e) { }
+
             return rendering;
         });
+
         // Validate rendering
         if (typeof scopeObj.rendering !== 'string' && !(typeof scopeObj.rendering?.toString === 'function')) {
             throw new Error('render() must return a string response or an object that implements toString()..');
         }
+
         // Convert back to response
-        const statusCode = responseShim.prototype.status.get.call(response);
+        const statusCode = response.status;
         scopeObj.response = new Response(scopeObj.rendering, {
             headers: response.headers,
             status: statusCode,
@@ -973,32 +956,42 @@ export class WebfloServer extends WebfloRuntime {
         });
         scopeObj.response.headers.set('Content-Type', 'text/html');
         scopeObj.response.headers.set('Content-Length', (new Blob([scopeObj.rendering])).size);
+
         return scopeObj.response;
     }
 
     generateLog(request, response, isproxy = false) {
         const { logger: LOGGER } = this.cx;
         const log = [];
+
         // ---------------
         const style = LOGGER.style || { keyword: (str) => str, comment: (str) => str, url: (str) => str, val: (str) => str, err: (str) => str, };
-        const statusCode = responseShim.prototype.status.get.call(response);
+        const statusCode = response.status;
         const errorCode = statusCode >= 400 && statusCode < 500 ? statusCode : 0;
         const xRedirectCode = response.headers.get('X-Redirect-Code');
         const isRedirect = (xRedirectCode || statusCode + '').startsWith('3') && (xRedirectCode || statusCode) !== 304;
-        const _statusCode = xRedirectCode && `${xRedirectCode} (${statusCode})` || statusCode;
-        const responseMeta = _wq(response, 'meta');
+        const _statusCode = xRedirectCode && `${statusCode} (${xRedirectCode})` || statusCode;
+        const responseMeta = _meta(response);
         // ---------------
+
         log.push(`[${style.comment((new Date).toUTCString())}]`);
         log.push(style.keyword(request.method));
         if (isproxy) log.push(style.keyword('>>'));
         log.push(style.url(request.url));
+
         if (responseMeta.has('hint')) log.push(`(${style.comment(responseMeta.get('hint'))})`);
         const contentInfo = [response.headers.get('Content-Type'), response.headers.get('Content-Length') && this.formatBytes(response.headers.get('Content-Length'))].filter((x) => x);
+
         if (contentInfo.length) log.push(`(${style.comment(contentInfo.join('; '))})`);
         if (response.headers.get('Content-Encoding')) log.push(`(${style.comment(response.headers.get('Content-Encoding'))})`);
         if (errorCode) log.push(style.err(`${errorCode} ${response.statusText}`));
         else log.push(style.val(`${_statusCode} ${response.statusText}`));
+        if (response.headers.get('X-Message-Port')) {
+            log.push(style.keyword(`[${style.keyword('L')}]`));
+        }
+
         if (isRedirect) log.push(`- ${style.url(response.headers.get('Location'))}`);
+
         return log.join(' ');
     }