@webqit/webflo 0.20.11-next.0 → 0.20.11

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "0.20.11-next.0",
+  "version": "0.20.11",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/runtime-pi/WebfloRuntime.js

@@ -2,6 +2,10 @@ import { WebfloRouter } from './webflo-routing/WebfloRouter.js';
 import { response as responseShim, headers as headersShim } from './webflo-fetch/index.js';
 import { LiveResponse } from './webflo-fetch/LiveResponse.js';
 import { AppBootstrap } from './AppBootstrap.js';
+import { HttpEvent } from './webflo-routing/HttpEvent.js';
+import { HttpThread } from './webflo-routing/HttpThread.js';
+import { HttpSession } from './webflo-routing/HttpSession.js';
+import { HttpUser } from './webflo-routing/HttpUser.js';
 import { _wq } from '../util.js';
 
 export class WebfloRuntime {
@@ -11,6 +15,14 @@ export class WebfloRuntime {
 
     static get Router() { return WebfloRouter; }
 
+	static get HttpEvent() { return HttpEvent; }
+
+	static get HttpThread() { return HttpThread; }
+
+	static get HttpSession() { return HttpSession; }
+
+	static get HttpUser() { return HttpUser; }
+
     static create(bootstrap) { return new this(bootstrap); }
 
     #bootstrap;
@@ -72,34 +84,33 @@ export class WebfloRuntime {
         return new Request(href, init);
     }
 
-    createHttpCookies({ request, ...rest }) {
-        return this.constructor.HttpCookies.create({ request, ...rest });
+    createHttpThread({ store, threadID, ...rest }) {
+        return this.constructor.HttpThread.create({ store, threadID, ...rest });
     }
 
-    createHttpSession({ store, request, ...rest }) {
-        return this.constructor.HttpSession.create({ store, request, ...rest });
+    createHttpCookies({ request, thread, ...rest }) {
+        return this.constructor.HttpCookies.create({ request, thread, ...rest });
     }
 
-    createHttpUser({ store, request, session, client, ...rest }) {
-        return this.constructor.HttpUser.create({ store, request, session, client, ...rest });
+    createHttpSession({ store, request, thread, ...rest }) {
+        return this.constructor.HttpSession.create({ store, request, thread, ...rest });
     }
 
-    createHttpEvent({ request, cookies, session, user, client, detail, signal, state, ...rest }) {
-        return this.constructor.HttpEvent.create(null, { request, cookies, session, user, client, detail, signal, state, ...rest });
+    createHttpUser({ store, request, thread, client, ...rest }) {
+        return this.constructor.HttpUser.create({ store, request, thread, client, ...rest });
+    }
+
+    createHttpEvent({ request, thread, cookies, session, user, client, detail, signal, state, ...rest }) {
+        return this.constructor.HttpEvent.create(null, { request, thread, cookies, session, user, client, detail, signal, state, ...rest });
     }
 
     async dispatchNavigationEvent({ httpEvent, crossLayerFetch, clientPortB }) {
         const { flags: FLAGS, logger: LOGGER } = this.cx;
-        // Resolve rid before dispatching
-        if (httpEvent.request.method === 'GET' && httpEvent.url.query['_rid']) {
-            const requestMeta = _wq(httpEvent.request, 'meta');
-            requestMeta.set('redirectID', httpEvent.url.query['_rid']);
-            requestMeta.set('carries', [].concat(await httpEvent.session.get(`carry-store:${requestMeta.get('redirectID')}`) || []));
-            await httpEvent.session.delete(`carry-store:${requestMeta.get('redirectID')}`);
-        }
+
         // Dispatch event
         const router = new this.constructor.Router(this, httpEvent.url.pathname);
-        await router.route(['SETUP'], httpEvent.extend(false));
+        await router.route(['SETUP'], httpEvent);
+
         // Do proper routing for respone
         const response = await new Promise(async (resolve) => {
             let autoLiveResponse, response;
@@ -113,6 +124,7 @@ export class WebfloRuntime {
                 return await router.route(routeMethods, httpEvent, crossLayerFetch, remoteFetch);
             };
             const fullRoutingPipeline = this.bootstrap.middlewares.concat(route);
+
             try {
                 response = await fullRoutingPipeline.reverse().reduce((next, fn) => {
                     return () => fn.call(this.cx, httpEvent, next);
@@ -121,14 +133,17 @@ export class WebfloRuntime {
                 console.error(e);
                 response = new Response(null, { status: 500, statusText: e.message });
             }
+
             if (!/Response/.test(LiveResponse.test(response))) {
-                const isLifecyleComplete = httpEvent.lifeCycleComplete();
+                const isLifecyleComplete = httpEvent.lifeCycleComplete() ?? true;
                 response = LiveResponse.test(response) !== 'Default' || !isLifecyleComplete
                     ? await LiveResponse.from(response, { done: isLifecyleComplete })
                     : responseShim.from.value(response);
             }
+
             // Any "carry" data?
             await this.handleCarries(httpEvent, response);
+
             // Resolve now...
             if (autoLiveResponse) {
                 await autoLiveResponse.replaceWith(response, { done: true });
@@ -148,7 +163,7 @@ export class WebfloRuntime {
 
         // Send the X-Background-Messaging-Port header
         // This server's event lifecycle management
-        if (!httpEvent.lifeCycleComplete()) {
+        if (!(httpEvent.lifeCycleComplete() ?? true)) {
             if (this.isClientSide) {
                 const responseMeta = _wq(response, 'meta');
                 responseMeta.set('background_port', clientPortB);
@@ -191,44 +206,17 @@ export class WebfloRuntime {
     }
 
     async handleCarries(httpEvent, response) {
-        const requestMeta = _wq(httpEvent.request, 'meta');
-        const responseMeta = _wq(response, 'meta');
-        if (response.headers.get('Location')) {
-            // Don't emit the supposedly incoming "carries"
-            // Save back to URL
-            if (requestMeta.get('carries')?.length) {
-                await httpEvent.session.set(`carry-store:${requestMeta.get('redirectID')}`, requestMeta.get('carries'));
-                requestMeta.set('carries', []);
-            }
-            // Stash current byte of "carry"
-            if (responseMeta.has('carry')) {
-                const $url = new URL(response.headers.get('Location'), httpEvent.request.url);
-                if ($url.searchParams.has('_rid')) {
-                    // If the URL already has a rid, append the new one
-                    const existingRedirectID = $url.searchParams.get('_rid');
-                    const existingData = await httpEvent.session.get(`carry-store:${existingRedirectID}`);
-                    const combinedData = [].concat(responseMeta.get('carry'), existingData || []);
-                    // Save the combined data back to the session
-                    await httpEvent.session.set(`carry-store:${existingRedirectID}`, combinedData);
-                } else {
-                    // If not, create a new rid
-                    const redirectID = (0 | Math.random() * 9e6).toString(36);
-                    $url.searchParams.set('_rid', redirectID);
-                    await httpEvent.session.set(`carry-store:${redirectID}`, [].concat(responseMeta.get('carry')));
-                }
-            }
-        } else {
+        if (!response.headers.get('Location')) {
+            const status = await httpEvent.thread.consume('status');
+            await httpEvent.thread.clear();
+            if (!status) return;
             // Fire redirect message?
-            const flashResponses = requestMeta.get('carries')?.filter((c) => ['message', 'error', 'success', 'alert', 'info', 'tip', 'warning'].includes(c.type));
-            if (flashResponses?.length) {
-                httpEvent.waitUntil(new Promise((resolve) => {
-                    httpEvent.client.wqLifecycle.open.then(() => {
-                        httpEvent.client.postMessage(flashResponses, { wqEventOptions: { type: 'flash' } });
-                        resolve();
-                    }, { once: true });
-                }));
-            }
-            requestMeta.set('carries', []);
+            httpEvent.waitUntil(new Promise((resolve) => {
+                httpEvent.client.wqLifecycle.open.then(async () => {
+                    httpEvent.client.postMessage(status, { wqEventOptions: { type: 'alert' } });
+                    resolve();
+                }, { once: true });
+            }));
         }
     }
 

package/src/runtime-pi/webflo-client/ClientSideCookies.js

@@ -1,9 +1,10 @@
 import { HttpCookies } from '../webflo-routing/HttpCookies.js';
 
 export class ClientSideCookies extends HttpCookies {
-    static create({ request }) {
+    static create({ request, thread }) {
         return new this({
             request,
+            thread,
             entries: document.cookie.split(';').map((c) => c.split('=').map((s) => s.trim()))
         });
     }

package/src/runtime-pi/webflo-client/WebfloClient.js

@@ -7,9 +7,6 @@ import { response as responseShim } from '../webflo-fetch/index.js';
 import { LiveResponse } from '../webflo-fetch/LiveResponse.js';
 import { WQStarPort } from '../webflo-messaging/WQStarPort.js';
 import { ClientSideCookies } from './ClientSideCookies.js';
-import { HttpSession } from '../webflo-routing/HttpSession.js';
-import { HttpEvent } from '../webflo-routing/HttpEvent.js';
-import { HttpUser } from '../webflo-routing/HttpUser.js';
 import { Url } from '../webflo-url/Url.js';
 import { _wq } from '../../util.js';
 import '../webflo-fetch/index.js';
@@ -17,14 +14,8 @@ import '../webflo-url/index.js';
 
 export class WebfloClient extends WebfloRuntime {
 
-    static get HttpEvent() { return HttpEvent; }
-
     static get HttpCookies() { return ClientSideCookies; }
 
-    static get HttpSession() { return HttpSession; }
-
-    static get HttpUser() { return HttpUser; }
-
     #host;
     get host() { return this.#host; }
 
@@ -68,19 +59,23 @@ export class WebfloClient extends WebfloRuntime {
         // Bind prompt handlers
         const promptsHandler = (e) => {
             const message = e.data?.message
-                ? e.data.message + (e.data.details ? `\r\n${e.data.details}` : '')
+                ? e.data.message
                 : e.data;
             const execPromp = () => {
+                if (e.defaultPrevented) return;
                 if (e.type === 'confirm') {
                     e.wqRespondWith(confirm(message));
                 } else if (e.type === 'prompt') {
                     e.wqRespondWith(prompt(message));
+                } else if (e.type === 'alert') {
+                    alert(message);
                 }
             };
             window.queueMicrotask(execPromp);
         };
         this.background.addEventListener('confirm', promptsHandler, { signal: instanceController.signal });
         this.background.addEventListener('prompt', promptsHandler, { signal: instanceController.signal });
+        this.background.addEventListener('alert', promptsHandler, { signal: instanceController.signal });
         await this.setupCapabilities();
         this.control();
         await this.hydrate();
@@ -242,7 +237,8 @@ export class WebfloClient extends WebfloRuntime {
     #prevEvent;
     createHttpEvent(init, singleton = true) {
         if (singleton && this.#prevEvent) {
-            this.#prevEvent.abort();
+            // TODO
+            //this.#prevEvent.abort();
         }
         const httpEvent = super.createHttpEvent(init);
         this.$instanceController.signal.addEventListener('abort', () => httpEvent.abort(), { once: true });
@@ -266,20 +262,30 @@ export class WebfloClient extends WebfloRuntime {
         }
         // Create and route request
         scopeObj.request = this.createRequest(scopeObj.url, scopeObj.init);
+        scopeObj.thread = this.createHttpThread({
+            store: this.createStorage('thread'),
+            threadId: scopeObj.url.searchParams.get('_thread'),
+            realm: 1
+        });
         scopeObj.cookies = this.createHttpCookies({
-            request: scopeObj.request
+            request: scopeObj.request,
+            thread: scopeObj.thread,
+            realm: 1
         });
         scopeObj.session = this.createHttpSession({
-			store: this.createStorage('session'),
-			request: scopeObj.request
-		});
+            store: this.createStorage('session'),
+            request: scopeObj.request,
+            thread: scopeObj.thread,
+            realm: 1
+        });
         const wqMessageChannel = new WQMessageChannel;
         scopeObj.clientRequestRealtime = wqMessageChannel.port1;
         scopeObj.user = this.createHttpUser({
             store: this.createStorage('user'),
             request: scopeObj.request,
+            thread: scopeObj.thread,
             client: scopeObj.clientRequestRealtime,
-            session: scopeObj.session,
+            realm: 1
         });
         if (window.webqit?.oohtml?.configs) {
             const { BINDINGS_API: { api: bindingsConfig } = {}, } = window.webqit.oohtml.configs;
@@ -287,6 +293,7 @@ export class WebfloClient extends WebfloRuntime {
         }
         scopeObj.httpEvent = this.createHttpEvent({
             request: scopeObj.request,
+            thread: scopeObj.thread,
             client: scopeObj.clientRequestRealtime,
             cookies: scopeObj.cookies,
             session: scopeObj.session,
@@ -294,6 +301,7 @@ export class WebfloClient extends WebfloRuntime {
             detail: scopeObj.detail,
             signal: init.signal,
             state: scopeObj.UIState,
+            realm: 1
         }, true);
         // Set pre-request states
         Observer.set(this.navigator, {
@@ -434,15 +442,18 @@ export class WebfloClient extends WebfloRuntime {
     async transitionUI(updateCallback) {
         if (document.startViewTransition && this.withViewTransitions) {
             const synthesizeWhile = window.webqit?.realdom?.synthesizeWhile || ((callback) => callback());
-            await synthesizeWhile(async () => {
-                Observer.set(this.transition, 'phase', 1);
-                const viewTransition = document.startViewTransition(updateCallback);
-                try { await viewTransition.updateCallbackDone; } catch (e) { console.log(e); }
-                Observer.set(this.transition, 'phase', 2);
-                try { await viewTransition.ready; } catch (e) { console.log(e); }
-                Observer.set(this.transition, 'phase', 3);
-                try { await viewTransition.finished; } catch (e) { console.log(e); }
-                Observer.set(this.transition, 'phase', 0);
+            return new Promise(async (resolve) => {
+                await synthesizeWhile(async () => {
+                    Observer.set(this.transition, 'phase', 1);
+                    const viewTransition = document.startViewTransition(updateCallback);
+                    try { await viewTransition.updateCallbackDone; } catch (e) { console.log(e); }
+                    Observer.set(this.transition, 'phase', 2);
+                    try { await viewTransition.ready; } catch (e) { console.log(e); }
+                    Observer.set(this.transition, 'phase', 3);
+                    try { await viewTransition.finished; } catch (e) { console.log(e); }
+                    Observer.set(this.transition, 'phase', 0);
+                    resolve();
+                });
             });
         } else await updateCallback();
     }

package/src/runtime-pi/webflo-client/WebfloRootClient2.js

@@ -48,7 +48,7 @@ export class WebfloRootClient2 extends WebfloRootClient1 {
 			const init = {
 				method: formData && 'POST' || 'GET',
 				body: formData,
-				signal
+				//signal TODO: auto-aborts on a redirect response which thus fails to parse
 			};
 			this.updateCurrentEntry({
 				state: {

package/src/runtime-pi/webflo-fetch/index.js

@@ -140,40 +140,6 @@ export const response = {
             return instance;
         }
     },
-    redirect: {
-        value: function (url, status = 302) {
-            if (typeof url !== 'string' && !(url instanceof URL)) {
-                throw new Error('Redirect URL must be a string or URL!');
-            }
-            if (typeof status !== 'number') {
-                throw new Error('Redirect code must be a number!');
-            }
-            return new Response(null, { status, headers: { Location: url } });
-        }
-    },
-    redirectWith: {
-        value: function (url, ...args) {
-            if (typeof url !== 'string' && !(url instanceof URL)) {
-                throw new Error('Redirect URL must be a string or URL!');
-            }
-            let status = 302;
-            if (!_isObject(args[0])) {
-                status = args.shift();
-            }
-            if (typeof status !== 'number') {
-                throw new Error('Redirect code must be a number!');
-            }
-            if (args.some((arg) => !_isObject(arg))) {
-                throw new Error('Redirect arguments must be objects!');
-            }
-            const responseInstance = new Response(null, { status, headers: { Location: url } });
-            if (args.length) {
-                const responseMeta = _wq(responseInstance, 'meta');
-                responseMeta.set('carry', args);
-            }
-            return responseInstance;
-        }
-    },
     prototype: {
         status: {
             get: function () {
@@ -393,6 +359,7 @@ export function renderHttpMessageInit(httpMessageInit) {
 }
 
 export async function parseHttpMessage(httpMessage) {
+    if (!httpMessage.body) return null;
     let result;
     const contentType = httpMessage.headers.get('Content-Type') || '';
     if (contentType === 'application/x-www-form-urlencoded' || contentType.startsWith('multipart/form-data')) {

package/src/runtime-pi/webflo-routing/HttpCookies.js

@@ -1,5 +1,5 @@
-import { _isObject } from '@webqit/util/js/index.js';
 import { _even } from '@webqit/util/obj/index.js';
+import { _isObject } from '@webqit/util/js/index.js';
 import { renderCookieObjToString } from '../webflo-fetch/index.js';
 import { HttpState } from './HttpState.js';
 
@@ -7,9 +7,9 @@ export class HttpCookies extends HttpState {
 
     #originals;
 
-    constructor({ request, entries = [] }) {
+    constructor({ request, thread = null, entries = [] }) {
         entries = [...entries].map(([key, value]) => [key, !_isObject(value) ? { name: key, value } : value]);
-        super({ store: new Map(entries), request, session: null });
+        super({ store: new Map(entries), request, thread });
         this.#originals = new Map(entries);
     }
 

package/src/runtime-pi/webflo-routing/HttpEvent.js

@@ -26,10 +26,14 @@ export class HttpEvent {
         });
     }
 
+    get signal() { return this.#abortController.signal; }
+
     get url() { return this.#url; }
 
     get request() { return this.#init.request; }
 
+    get thread() { return this.#init.thread; }
+
     get client() { return this.#init.client; }
 
     get cookies() { return this.#init.cookies; }
@@ -40,8 +44,6 @@ export class HttpEvent {
 
     get detail() { return this.#init.detail; }
 
-    get signal() { return this.#abortController.signal; }
-
     get state() { return { ...(this.#init.state || {}) }; }
 
     #lifecyclePromises = new Set;
@@ -58,6 +60,9 @@ export class HttpEvent {
         if (this.#lifecyclePromises.dirty && !this.#lifecyclePromises.size) {
             throw new Error('Event lifecycle already complete.');
         }
+        if (this.#parentEvent) {
+            this.#parentEvent.waitUntil(promise);
+        }
         promise = Promise.resolve(promise);
         this.#lifecyclePromises.add(promise);
         this.#lifecyclePromises.dirty = true;
@@ -78,8 +83,11 @@ export class HttpEvent {
         if (returningThePromise) {
             return this.#lifeCycleResolutionPromise;
         }
-        return this.#lifecyclePromises.dirty // IMPORTANT
-            && !this.#lifecyclePromises.size;
+        if (this.#lifecyclePromises.dirty === undefined) {
+            // Hasn't been initialized yet
+            return null;
+        }
+        return !this.#lifecyclePromises.size;
     }
 
     async waitUntil(promise) {
@@ -97,13 +105,49 @@ export class HttpEvent {
         await this.#internalLiveResponse.replaceWith(data, ...args);
     }
 
+    async redirect(url, status = 302) {
+        if (typeof url !== 'string' && !(url instanceof URL)) {
+            throw new Error('Redirect URL must be a string or URL!');
+        }
+        let options = {};
+        if (_isObject(status)) {
+            ({ status = 302, ...options } = status);
+        }
+        if (typeof status !== 'number') {
+            throw new Error('Redirect code must be a number!');
+        }
+        return await this.respondWith(null, { status, ...options, headers: { Location: url } });
+    }
+
+    async redirectWith(url, data, status = 302) {
+        if (typeof url !== 'string' && !(url instanceof URL)) {
+            throw new Error('Redirect URL must be a string or URL!');
+        }
+        let options = {};
+        if (_isObject(status)) {
+            ({ status = 302, ...options } = status);
+        }
+        if (typeof status !== 'number') {
+            throw new Error('Redirect code must be a number!');
+        }
+        //-----
+        const urlRewrite = new URL(url, this.request.url);
+        const newThread = this.thread.extend(urlRewrite.searchParams.get('_thread'));
+        urlRewrite.searchParams.set('_thread', newThread.threadID);
+        await newThread.append('back', this.request.url.replace(urlRewrite.origin, ''));
+        for (const [key, value] of Object.entries(data)) {
+            await newThread.append(key, value);
+        }
+        //-----
+        return await this.respondWith(null, { status, ...options, headers: { Location: urlRewrite.href } });
+    }
+
     clone(init = {}) {
         return this.constructor.create(this.#parentEvent, { ...this.#init, ...init });
     }
 
     extend(init = {}) {
         const instance = this.constructor.create(this/*Main difference from clone*/, { ...this.#init, ...(init || {}) });
-        if (init !== false) this.#extendLifecycle(instance.lifeCycleComplete(true));
         return instance;
     }
 

package/src/runtime-pi/webflo-routing/HttpSession.js

@@ -1,11 +1,11 @@
 import { HttpState } from './HttpState.js';
 
 export class HttpSession extends HttpState {
-    static create({ store, request }) {
+    static create({ store, request, thread }) {
         return new this({
             store,
             request,
-            session: true
+            thread
         });
     }
 }

package/src/runtime-pi/webflo-routing/HttpState.js

@@ -2,16 +2,16 @@ import { _isObject } from '@webqit/util/js/index.js';
 import { _even } from '@webqit/util/obj/index.js';
 
 export class HttpState {
-    
+
     #store;
     #request;
-    #session;
+    #thread;
     #modified = false;
 
-    constructor({ store, request, session = null }) {
+    constructor({ store, request, thread }) {
         this.#store = store || new Map;
         this.#request = request;
-        this.#session = session === true ? this : session;
+        this.#thread = thread === true ? this : thread;
     }
 
     async has(key) { return await this.#store.has(key); }
@@ -59,7 +59,7 @@ export class HttpState {
 
     async forEach(callback) { (await this.entries()).forEach(([key, value], i) => callback(value, key, i)); }
 
-    [ Symbol.iterator ]() { return this.entries().then((entries) => entries[ Symbol.iterator ]()); }
+    [Symbol.iterator]() { return this.entries().then((entries) => entries[Symbol.iterator]()); }
 
     get size() { return this.#store.sizs; }
 
@@ -97,9 +97,15 @@ export class HttpState {
                 handler = { callback: handler };
             } else if (typeof handler === 'string') {
                 handler = { url: handler };
-            } else if (typeof handler?.callback !== 'function' && typeof handler?.url !== 'string') {
+            } else if (!(_isObject(handler) && (handler = { ...handler })) 
+                || typeof handler.callback !== 'function' && typeof handler.url !== 'string') {
                 throw new Error(`Handler must be either an URL or a function or an object specifying either an URL (handler.url) or a function (handler.callback)`);
             }
+            if (_isObject(handler.with)) {
+                handler.with = { ...handler.with };
+            } else if (handler.with) {
+                throw new Error(`The "with" parameter must be a valid JSON object`);
+            }
             $handlers.push(handler);
         }
         this.#handlers.set(attr, $handlers);
@@ -115,7 +121,7 @@ export class HttpState {
                 if (!handlers) {
                     throw new Error(`No handler defined for the user attribute: ${attr}`);
                 }
-                for (let i = 0; i < handlers.length; i ++) {
+                for (let i = 0; i < handlers.length; i++) {
                     const handler = handlers[i];
                     if (handler.callback) {
                         const returnValue = await handler.callback(this, attr);
@@ -129,20 +135,19 @@ export class HttpState {
                         continue main;
                     }
                     const urlRewrite = new URL(handler.url, this.#request.url);
-                    if (!urlRewrite.searchParams.has('success-redirect')) {
-                        urlRewrite.searchParams.set('success-redirect', this.#request.url.replace(urlRewrite.origin, ''));
-                    }
-                    if (handler.message) {
-                        if (!this.#session) {
-                            throw new Error('Storage type does not support redirect messages');
+                    const newThread = this.#thread.extend(urlRewrite.searchParams.get('_thread'));
+                    urlRewrite.searchParams.set('_thread', newThread.threadID);
+                    await newThread.append('back', this.#request.url.replace(urlRewrite.origin, ''));
+                    if (handler.with) {
+                        for (const [key, value] of Object.entries(handler.with)) {
+                            await newThread.append(key, value);
                         }
-                        const messageID = (0 | Math.random() * 9e6).toString(36);
-                        urlRewrite.searchParams.set('redirect-message', messageID);
-                        await this.#session.set(`redirect-message:${messageID}`, { status: { type: handler.type || 'info', message: handler.message }});
                     }
-                    return new Response(null, { status: 302, headers: {
-                        Location: urlRewrite
-                    }});
+                    return new Response(null, {
+                        status: 302, headers: {
+                            Location: urlRewrite
+                        }
+                    });
                 }
             }
             entries.push(await this.get(attr));

package/src/runtime-pi/webflo-routing/HttpThread.js

@@ -0,0 +1,81 @@
+export class HttpThread {
+
+    static create({ store, threadID, realm }) {
+        if (!threadID || !(new RegExp(`^wq\\.${realm}\\.`)).test(threadID)) {
+            threadID = `wq.${realm}.${crypto.randomUUID()}`;
+        }
+        return new this({ store, threadID, realm });
+    }
+
+    #store;
+    #threadID;
+    #realm;
+
+    get threadID() { return this.#threadID; }
+
+    constructor({ store, threadID, realm }) {
+        this.#store = store || new Map;
+        this.#threadID = threadID;
+        this.#realm = realm;
+    }
+
+    extend(_threadID = null) {
+        return this.constructor.create({
+            store: this.#store,
+            threadID: _threadID,
+            realm: this.#realm
+        });
+    }
+
+    async keys() {
+        const thread = await this.#store.get(this.#threadID) || {};
+        return Object.keys(thread);
+    }
+
+    async has(key, filter = null) {
+        if (filter === true || !filter) return (await this.keys()).includes(key);
+        const thread = await this.#store.get(this.#threadID) || {};
+        const values = [].concat(thread[key] ?? []);
+        return values.findIndex(filter) !== -1;
+    }
+
+    async append(key, value) {
+        const thread = await this.#store.get(this.#threadID) || {};
+        thread[key] = [].concat(thread[key] ?? []);
+        thread[key].push(value);
+        await this.#store.set(this.#threadID, thread);
+        return this;
+    }
+
+    async consume(key, filter = null) {
+        const thread = await this.#store.get(this.#threadID) || {};
+        const values = [].concat(thread[key] ?? []);
+
+        let value;
+        if (filter === true) {
+            delete thread[key];
+            value = values;
+        } else if (filter) {
+            const i = values.findIndex(filter);
+            if (i !== -1) {
+                value = values.splice(i, 1)[0];
+            }
+        } else { value = values.pop(); }
+
+        if (!values.length) {
+            delete thread[key];
+        }
+        if (!Object.keys(thread).length) {
+            await this.#store.delete(this.#threadID);
+        } else {
+            await this.#store.set(this.#threadID, thread);
+        }
+
+        return value;
+    }
+
+    async clear() {
+        await this.#store.delete(this.#threadID);
+        return this;
+    }
+}

package/src/runtime-pi/webflo-routing/HttpUser.js

@@ -2,17 +2,17 @@ import { HttpState } from './HttpState.js';
 
 export class HttpUser extends HttpState {
 
-    static create({ store, request, client, session }) {
-        return new this({ store, request, client, session });
+    static create({ store, request, thread, client }) {
+        return new this({ store, request, thread, client });
     }
 
     #client;
 
-    constructor({ store, request, client, session }) {
+    constructor({ store, request, thread, client }) {
         super({
             store,
             request,
-            session
+            thread
         });
         this.#client = client;
     }

package/src/runtime-pi/webflo-routing/WebfloRouter.js

@@ -15,6 +15,13 @@ export class WebfloRouter {
 
     async route(method, event, _default = null, remoteFetch = null) {
         const $this = this;
+        const callWebfloDefault = async (thisContext, thisTick) => {
+            let returnValue;
+            if (_default) {
+                returnValue = await _default.call(thisContext, thisTick.event, remoteFetch);
+            }
+            return returnValue;
+        };
         // ----------------
         // The loop
         // ----------------
@@ -33,10 +40,7 @@ export class WebfloRouter {
                         return next(thisTick);
                     }
                     // Exports not found and directory not found
-                    if (_default) {
-                        return await _default.call(thisContext, thisTick.event, remoteFetch);
-                    }
-                    return;
+                    return callWebfloDefault(thisContext, thisTick);
                 }
                 // -------------
                 // Broadcast any hints exported by handler
@@ -190,15 +194,7 @@ export class WebfloRouter {
                     }
                 });
             }
-            let returnValue;
-            if (_default) {
-                returnValue = await _default.call(thisContext, thisTick.event, remoteFetch);
-            }
-            try {
-                // IMPORTANT: Explicitly terminate the event lifecycle if nothing extends it
-                await thisTick.event.waitUntil();
-            } catch(e) {}
-            return returnValue;
+            return callWebfloDefault(thisContext, thisTick);
         };
 
         return next({

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

@@ -2,10 +2,11 @@ import { headers as headersShim } from '../webflo-fetch/index.js';
 import { HttpCookies } from '../webflo-routing/HttpCookies.js';
 
 export class ServerSideCookies extends HttpCookies {
-    static create({ request }) {
+    static create({ request, thread }) {
         const cookies = headersShim.get.value.call(request.headers, 'Cookie', true);
         return new this({
             request,
+            thread,
             entries: cookies.map((c) => [c.name, c])
         });
     }

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

@@ -3,10 +3,11 @@ import { headers as headersShim } from '../webflo-fetch/index.js';
 
 export class ServerSideSession extends HttpSession {
 
-    static create({ store, request, sessionID, ttl }) {
+    static create({ store, request, thread, sessionID, ttl }) {
         return new this({
             store,
             request,
+            thread,
             sessionID,
             ttl
         });
@@ -16,14 +17,14 @@ export class ServerSideSession extends HttpSession {
     get sessionID() { return this.#sessionID; }
     #ttl;
     
-    constructor({ store, request, sessionID, ttl }) {
+    constructor({ store, request, thread, sessionID, ttl }) {
         if (!sessionID) {
             throw new Error(`sessionID is required`);
         }
         super({
             store,
             request,
-            session: true
+            thread,
         });
         this.#sessionID = sessionID;
         this.#ttl = ttl;

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

@@ -20,8 +20,6 @@ import { WebfloRuntime } from '../WebfloRuntime.js';
 import { WQSockPort } from '../webflo-messaging/WQSockPort.js';
 import { ServerSideCookies } from './ServerSideCookies.js';
 import { ServerSideSession } from './ServerSideSession.js';
-import { HttpEvent } from '../webflo-routing/HttpEvent.js';
-import { HttpUser } from '../webflo-routing/HttpUser.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';
@@ -31,14 +29,10 @@ import '../webflo-url/index.js';
 
 export class WebfloServer extends WebfloRuntime {
 
-    static get HttpEvent() { return HttpEvent; }
-
     static get HttpCookies() { return ServerSideCookies; }
 
     static get HttpSession() { return ServerSideSession; }
 
-    static get HttpUser() { return HttpUser; }
-
     static create(bootstrap) {
         return new this(bootstrap);
     }
@@ -648,33 +642,45 @@ export class WebfloServer extends WebfloRuntime {
         // Request processing
         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.cookies = this.createHttpCookies({
-            request: scopeObj.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),
+            threadID: scopeObj.url.searchParams.get('_thread'),
+            realm: 3
+        });
+        scopeObj.cookies = this.createHttpCookies({
+            request: scopeObj.request,
+            thread: scopeObj.thread,
+            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,
-            ttl: scopeObj.sessionTTL
+            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,
-            session: scopeObj.session,
+            realm: 3
         });
         scopeObj.httpEvent = this.createHttpEvent({
             request: scopeObj.request,
+            thread: scopeObj.thread,
             client: scopeObj.clientRequestRealtime,
             cookies: scopeObj.cookies,
             session: scopeObj.session,
             user: scopeObj.user,
             detail: scopeObj.detail,
+            realm: 3
         });
         // Dispatch for response
         scopeObj.response = await this.dispatchNavigationEvent({

package/src/runtime-pi/webflo-worker/WebfloWorker.js

@@ -4,22 +4,13 @@ import { response as responseShim } from '../webflo-fetch/index.js';
 import { WQBroadcastChannel } from '../webflo-messaging/WQBroadcastChannel.js';
 import { WorkerSideWorkport } from './WorkerSideWorkport.js';
 import { WorkerSideCookies } from './WorkerSideCookies.js';
-import { HttpSession } from '../webflo-routing/HttpSession.js';
-import { HttpEvent } from '../webflo-routing/HttpEvent.js';
-import { HttpUser } from '../webflo-routing/HttpUser.js';
 import '../webflo-fetch/index.js';
 import '../webflo-url/index.js';
 
 export class WebfloWorker extends WebfloRuntime {
 
-	static get HttpEvent() { return HttpEvent; }
-
 	static get HttpCookies() { return WorkerSideCookies; }
 
-	static get HttpSession() { return HttpSession; }
-
-	static get HttpUser() { return HttpUser; }
-
 	static get Workport() { return WorkerSideWorkport; }
 
 	async initialize() {
@@ -106,28 +97,40 @@ export class WebfloWorker extends WebfloRuntime {
 		}
 		// Create and route request
 		scopeObj.request =  this.createRequest(scopeObj.url, scopeObj.init);
+		scopeObj.thread = this.createHttpThread({
+            store: this.createStorage('thread'),
+            threadId: scopeObj.url.searchParams.get('_thread'),
+            realm: 2
+        });
 		scopeObj.cookies = this.createHttpCookies({
-			request: scopeObj.request
+			request: scopeObj.request,
+			thread: scopeObj.thread,
+			realm: 2
 		});
 		scopeObj.session = this.createHttpSession({
 			store: this.createStorage('session'),
-			request: scopeObj.request
+			request: scopeObj.request,
+			thread: scopeObj.thread,
+			realm: 2
 		});
 		const requestID = crypto.randomUUID();
 		scopeObj.clientRequestRealtime = new WQBroadcastChannel(requestID);
 		scopeObj.user = this.createHttpUser({
 			store: this.createStorage('user'),
 			request: scopeObj.request,
+			thread: scopeObj.thread,
 			client: scopeObj.clientRequestRealtime,
-			session: scopeObj.session,
+			realm: 2
 		});
 		scopeObj.httpEvent = this.createHttpEvent({
 			request: scopeObj.request,
+			thread: scopeObj.thread,
 			client: scopeObj.clientRequestRealtime,
 			cookies: scopeObj.cookies,
 			session: scopeObj.session,
 			user: scopeObj.user,
 			detail: scopeObj.detail,
+			realm: 2
 		});
 		// Dispatch for response
 		scopeObj.response = await this.dispatchNavigationEvent({

package/src/runtime-pi/webflo-worker/WorkerSideCookies.js

@@ -2,9 +2,10 @@ import { HttpCookies } from '../webflo-routing/HttpCookies.js';
 import { headers as headersShim } from '../webflo-fetch/index.js';
 
 export class WorkerSideCookies extends HttpCookies {
-    static create({ request }) {
+    static create({ request, thread }) {
         return new this({
             request,
+            thread,
             entries: headersShim.get.value.call(request.headers, 'Cookie', true).map((c) => [c.name, c])
         });
     }