@webqit/webflo 0.11.61 → 0.20.2-next.0

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

@@ -0,0 +1,49 @@
+import { _isTypeObject } from '@webqit/util/js/index.js';
+import { createFormDataFromJson } from './formdata.js';
+import { dataType } from './util.js';
+
+export function renderHttpMessageInit(httpMessageInit) {
+    // JSONfy headers
+    const headers = (httpMessageInit.headers instanceof Headers) ? [...httpMessageInit.headers.entries()].reduce((_headers, [name, value]) => {
+        return { ..._headers, [name/* lower-cased */]: _headers[name] ? [].concat(_headers[name], value) : value };
+    }, {}) : Object.keys(httpMessageInit.headers || {}).reduce((_headers, name) => {
+        return { ..._headers, [name.toLowerCase()]: httpMessageInit.headers[name] };
+    }, {});
+    // Process body
+    let body = httpMessageInit.body, type = dataType(httpMessageInit.body);
+    if (['Blob', 'File'].includes(type)) {
+        !headers['content-type'] && (headers['content-type'] = body.type);
+        !headers['content-length'] && (headers['content-length'] = body.size);
+    } else if (['Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer'].includes(type)) {
+        !headers['content-length'] && (headers['content-length'] = body.byteLength);
+    } else if (type === 'json' && _isTypeObject(body)/*JSON object*/) {
+        if (!headers['content-type']) {
+            const [_body, isJsonfiable] = createFormDataFromJson(body, true/*jsonfy*/, true/*getIsJsonfiable*/);
+            if (isJsonfiable) {
+                body = JSON.stringify(body, (k, v) => v instanceof Error ? { ...v, message: v.message } : v);
+                headers['content-type'] = 'application/json';
+                headers['content-length'] = (new Blob([body])).size;
+            } else {
+                body = _body;
+                type = 'FormData';
+            }
+        }
+    } else if (type === 'json'/*JSON string*/ && !headers['content-length']) {
+        (headers['content-length'] = (body + '').length);
+    }
+    return { body, headers, $type: type };
+}
+
+export async function parseHttpMessage(httpMessage) {
+    let result;
+    const contentType = httpMessage.headers.get('Content-Type') || '';
+    if (contentType === 'application/x-www-form-urlencoded' || contentType.startsWith('multipart/form-data')) {
+        const formData = await httpMessage.formData();
+        result = await formData?.json();
+    } else if (contentType.startsWith('application/json')/*can include charset*/) {
+        result = await httpMessage.json();
+    } else /*if (contentType === 'text/plain')*/ {
+        result = httpMessage.body;
+    }
+    return result;
+}

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

@@ -0,0 +1,62 @@
+import { _wq } from '../../util.js';
+import { renderHttpMessageInit } from './message.js';
+
+const prototypeOriginals = { clone: Request.prototype.clone };
+const prototypeExtensions = {
+    carries: { get: function () { return new Set(_wq(this, 'meta').get('carries') || []); } },
+    clone: {
+        value: function (init = {}) {
+            const clone = prototypeOriginals.clone.call(this, init);
+            const requestMeta = _wq(this, 'meta');
+            _wq(clone).set('meta', requestMeta);
+            return clone;
+        }
+    },
+    parse: { value: function () { return parseHttpMessage(this); } },
+};
+
+const staticExtensions = {
+    from: {
+        value: function (url, init = {}) {
+            if (url instanceof Request) return url;
+            let $$type, $$body = init.body;
+            if ('body' in init) {
+                const { body, headers, $type } = renderHttpMessageInit(init);
+                init = { ...init, body, headers };
+                $$type = $type;
+            }
+            const instance = new Request(url, init);
+            const responseMeta = _wq(instance, 'meta');
+            responseMeta.set('body', $$body);
+            responseMeta.set('type', $$type);
+            return instance;
+        }
+    },
+    copy: {
+        value: async function (request, init = {}) {
+            const requestInit = [
+                'method', 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity',
+            ].reduce(($init, prop) => (
+                { ...$init, [prop]: prop in init ? init[prop] : (prop === 'headers' ? new Headers(request[prop]) : request[prop]) }
+            ), {});
+            if (!['GET', 'HEAD'].includes(init.method?.toUpperCase() || request.method)) {
+                if ('body' in init) {
+                    requestInit.body = init.body
+                    if (!('headers' in init)) {
+                        requestInit.headers.delete('Content-Type');
+                        requestInit.headers.delete('Content-Length');
+                    }
+                } else {
+                    requestInit.body = await request.clone().arrayBuffer();
+                }
+            }
+            if (requestInit.mode === 'navigate') {
+                requestInit.mode = 'cors';
+            }
+            return { url: request.url, ...requestInit };
+        }
+    }
+};
+
+Object.defineProperties(Request.prototype, prototypeExtensions);
+Object.defineProperties(Request, staticExtensions);

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

@@ -0,0 +1,110 @@
+
+import { _isObject } from '@webqit/util/js/index.js';
+import { parseHttpMessage, renderHttpMessageInit } from './message.js';
+import { WQBroadcastChannel } from '../webflo-messaging/WQBroadcastChannel.js';
+import { WQSockPort } from '../webflo-messaging/WQSockPort.js';
+import { _wq } from '../../util.js';
+
+export function responseRealtimeConnect(url) {
+    const [proto, portID] = url.split(':');
+    if (proto === 'br') {
+        return new WQBroadcastChannel(portID);
+    }
+    if (proto !== 'ws') {
+        throw new Error(`Unknown background messaging protocol: ${proto}`);
+    }
+    return new WQSockPort(portID);
+}
+
+export function responseRealtime() {
+    const responseMeta = _wq(this, 'meta');
+    if (!responseMeta.has('wqRealtime')) {
+        const value = this.headers.get('X-Background-Messaging-Port')?.trim();
+        if (value) {
+            responseMeta.set('wqRealtime', responseRealtimeConnect(value));
+        }
+    }
+    return responseMeta.get('wqRealtime');
+}
+
+const staticOriginals = { json: Response.json };
+const staticExtensions = {
+    from: {
+        value: function (body, init = {}) {
+            if (body instanceof Response) return body;
+            let $type, $body = body;
+            if (body || body === 0) {
+                let headers;
+                ({ body, headers, $type } = renderHttpMessageInit({ body, headers: init.headers }));
+                init = { ...init, headers };
+            }
+            const instance = new Response(body, init);
+            const responseMeta = _wq(instance, 'meta');
+            responseMeta.set('body', $body);
+            responseMeta.set('type', $type);
+            return instance;
+        }
+    },
+    json: {
+        value: function (data, options = {}) {
+            const instance = staticOriginals.json(data, options);
+            const responseMeta = _wq(instance, 'meta');
+            responseMeta.set('body', data);
+            responseMeta.set('type', 'json');
+            return instance;
+        }
+    },
+    redirectWith: {
+        value: function (url, { status = 302, request = null, response = null }) {
+            if (typeof status !== 'string') {
+                throw new Error('Redirect code must be an object!');
+            }
+            if (request && !_isObject(request) || response && !_isObject(response)) {
+                throw new Error('Carries (redirect requests and responses) must be an object!');
+            }
+            const responseInstance = this.redirect(url, status);
+            if (request || response) {
+                const responseMeta = _wq(responseInstance, 'meta');
+                responseMeta.set('carry', { request, response });
+            }
+            return responseInstance;
+        }
+    }
+};
+
+const prototypeOriginals = {
+    clone: Response.prototype.clone,
+    status: Object.getOwnPropertyDescriptor(Response.prototype, 'status'),
+};
+const prototypeExtensions = {
+    status: { get: function () { return _wq(this, 'meta').get('status') || prototypeOriginals.status.get.call(this); } },
+    carry: { get: function () { return _wq(this, 'meta').get('carry'); } },
+    clone: {
+        value: function (init = {}) {
+            const clone = prototypeOriginals.clone.call(this, init);
+            const responseMeta = _wq(this, 'meta');
+            _wq(clone).set('meta', responseMeta);
+            return clone;
+        }
+    },
+    isLive: {
+        value: function () {
+            let liveLevel = (this.headers.get('X-Background-Messaging-Port')?.trim() || _wq(this, 'meta').has('wqRealtime')) && 1 || 0;
+            liveLevel += this.headers.get('X-Live-Response-Message-ID')?.trim() && 1 || 0;
+            return liveLevel;
+        }
+    },
+    wqRealtime: {
+        get: function () {
+            return responseRealtime.call(this);
+        }
+    },
+    parse: {
+        value: async function () {
+            return await parseHttpMessage(this);
+        }
+    }
+};
+
+Object.defineProperties(Response.prototype, prototypeExtensions);
+Object.defineProperties(Response, staticExtensions);

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

@@ -0,0 +1,28 @@
+import { _isString, _isObject, _isPlainObject, _isPlainArray, _isTypeObject, _isNumber, _isBoolean } from '@webqit/util/js/index.js';
+
+export function isTypeStream(obj) {
+    return obj instanceof ReadableStream || isTypeReadable(obj);
+}
+
+export function isTypeReadable(obj) {
+    return (
+        obj !== null &&
+        typeof obj === 'object' &&
+        typeof obj.read === 'function' &&       // streams have .read()
+        typeof obj.pipe === 'function' &&       // streams have .pipe()
+        typeof obj.on === 'function'            // streams have event listeners
+    );
+}
+
+export function dataType(value) {
+    if (_isString(value) || _isNumber(value) || _isBoolean(value)) return 'json';
+    if (!_isTypeObject(value)) return;
+    const toStringTag = value[Symbol.toStringTag];
+    const type = [
+        'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer', 'Blob', 'File', 'FormData', 'Stream', 'ReadableStream'
+    ].reduce((_toStringTag, type) => _toStringTag || (toStringTag === type ? type : null), null);
+    if (type) return type;
+    if ((_isObject(value) && _isPlainObject(value)) || (Array.isArray(value) && _isPlainArray(value)) || 'toString' in value) {
+        return 'json';
+    }
+}

package/src/runtime-pi/webflo-messaging/WQBroadcastChannel.js

@@ -0,0 +1,10 @@
+import { toWQPort} from './wq-message-port.js';
+
+export class WQBroadcastChannel extends BroadcastChannel {
+    constructor(channelName) {
+        super(channelName);
+        toWQPort(this);
+    }
+}
+
+globalThis.WQBroadcastChannel = WQBroadcastChannel;

package/src/runtime-pi/webflo-messaging/WQMessageChannel.js

@@ -0,0 +1,26 @@
+import { toWQPort } from './wq-message-port.js';
+
+export class WQMessageChannel extends MessageChannel {
+
+    #port1;
+    get port1() {
+        if (!this.#port1) {
+            this.#port1 = super.port1;
+            this.#port1.start();
+            toWQPort(this.#port1);
+        }
+        return this.#port1;
+    }
+
+    #port2;
+    get port2() {
+        if (!this.#port2) {
+            this.#port2 = super.port2;
+            this.#port2.start();
+            toWQPort(this.#port2);
+        }
+        return this.#port2;
+    }
+}
+
+globalThis.WQMessageChannel = WQMessageChannel;

package/src/runtime-pi/webflo-messaging/WQMessageEvent.js

@@ -0,0 +1,87 @@
+import { _isTypeObject } from '@webqit/util/js/index.js';
+import { toWQPort, applyMutations } from './wq-message-port.js';
+import { _wq } from '../../util.js';
+
+export class WQMessageEvent extends Event {
+
+    #originalTarget;
+    get originalTarget() { return this.#originalTarget; }
+
+    #eventID;
+    get eventID() { return this.#eventID; }
+
+    #data;
+    get data() { return this.#data; }
+
+    #live;
+    get live() { return this.#live; }
+
+    #bubbles;
+    get bubbles() { return this.#bubbles; }
+
+    #forwarded;
+    get forwarded() { return this.#forwarded; }
+
+    #ports = [];
+    get ports() { return this.#ports; }
+
+    constructor(originalTarget, {
+        data = null,
+        wqEventOptions: { eventID, type = 'message', live = false, bubbles = false, forwarded = false } = {},
+        wqProcessingOptions: {} = {},
+        ports = []
+    } = {}) {
+        if (typeof eventID !== 'string') {
+            throw new TypeError('eventID must be a non-empty string');
+        }
+        if (type && typeof type !== 'string') {
+            throw new TypeError('Where specified, wqEventOptions.type must be a string');
+        }
+        super(type);
+        this.#originalTarget = originalTarget;
+        this.#eventID = eventID;
+        this.#data = data;
+        this.#live = live;
+        this.#bubbles = bubbles;
+        this.#forwarded = forwarded;
+        this.#ports = ports.map(toWQPort);
+        if (_isTypeObject(this.#data) && this.#live) {
+            // If the data is a live object, we can apply mutations to it
+            applyMutations.call(originalTarget, this.#data, this.#eventID);
+        }
+    }
+
+    #immediatePropagationStopped = false;
+    get immediatePropagationStopped() { return this.#immediatePropagationStopped; }
+
+    stopImmediatePropagation() {
+        this.#immediatePropagationStopped = true;
+        this.#propagationStopped = true;
+        super.stopImmediatePropagation();
+    }
+
+    #propagationStopped = false;
+    get propagationStopped() { return this.#propagationStopped; }
+
+    stopPropagation() {
+        this.#propagationStopped = true;
+        super.stopPropagation();
+    }
+
+    #defaultPrevented = false;
+    get defaultPrevented() { return this.#defaultPrevented; }
+
+    preventDefault() {
+        this.#defaultPrevented = true;
+        super.preventDefault();
+    }
+
+    wqRespondWith(data, transferOrOptions = []) {
+        for (const port of this.#ports) {
+            port.postMessage(data, transferOrOptions);
+        }
+        return !!this.#ports.length;
+    }
+}
+
+globalThis.WQMessageEvent = WQMessageEvent;

package/src/runtime-pi/webflo-messaging/WQMessagePort.js

@@ -0,0 +1,38 @@
+import { internalAddEventListener, postRequest, handleRequests, forwardPort, forwardEvent } from './wq-message-port.js';
+import { _wq } from '../../util.js';
+
+export const WQMessagePortInstanceTag = Symbol('WQMessagePortInstanceTag');
+
+export class WQMessagePort extends EventTarget {
+
+    [WQMessagePortInstanceTag] = true;
+
+    static [Symbol.hasInstance](instance) {
+        return !!instance?.[WQMessagePortInstanceTag];
+    }
+
+    addEventListener(...args) {
+        internalAddEventListener.call(this, args);
+        return super.addEventListener(...args);
+    }
+
+    dispatchEvent(event) {
+        const returnValue = super.dispatchEvent(event);
+        forwardEvent.call(this, event);
+        return returnValue;
+    }
+
+    postRequest(data, callback, options = {}) {
+        return postRequest.call(this, data, callback, options);
+    }
+    
+    handleRequests(type, listener, options = {}) {
+        return handleRequests.call(this, type, listener, options);
+    }
+
+    wqForwardPort(eventTypes, eventTarget, { resolveData = null, bidirectional = false, namespace1 = null, namespace2 = null } = {}) {
+        return forwardPort.call(this, eventTypes, eventTarget, { resolveData, bidirectional, namespace1, namespace2 });
+    }
+}
+
+globalThis.WQMessagePort = WQMessagePort;

package/src/runtime-pi/webflo-messaging/WQRelayPort.js

@@ -0,0 +1,47 @@
+import { forwardPort } from './wq-message-port.js';
+import { WQStarPort } from './WQStarPort.js';
+
+export class WQRelayPort extends WQStarPort {
+
+    #namespace;
+    get namespace() { return this.#namespace; }
+
+    constructor(namespace = null) {
+        super();
+        this.#namespace = namespace;
+    }
+
+    addPort(port, { resolveData = null } = {}) {
+        const $resolveData = (data, ...args) => {
+            if (resolveData) {
+                return resolveData(data, ...args);
+            }
+            return data;
+        };
+        // Setup
+        const superCleanup = super.addPort(port, { enableBubbling: false });
+        const forwardingCleanup = forwardPort.call(port, '*', this, { bidirectional: false, resolveData: $resolveData, namespace1: this.namespace, namespace2: this.namespace });
+        const messageType_ping = this.namespace && `${this.namespace}:message` || 'message';
+        this.postMessage(
+            $resolveData({
+                event: 'joins',
+            }, port, this),
+            { wqEventOptions: { type: messageType_ping }, wqProcessingOptions: { except: port } }
+        );
+        // Teardown
+        const leaves = () => {
+            forwardingCleanup();
+            this.postMessage(
+                $resolveData({
+                    event: 'leaves',
+                }, port, this),
+                { wqEventOptions: { type: messageType_ping }, wqProcessingOptions: { except: port } }
+            );
+        };
+        port.wqLifecycle.close.then(leaves);
+        return () => {
+            superCleanup(); // Cascade to super
+            leaves();
+        };
+    }
+}

package/src/runtime-pi/webflo-messaging/WQSockPort.js

@@ -0,0 +1,113 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import { toWQPort, portIsMessaging, forwardPort, preProcessPostMessage, portHooksCleanup } from './wq-message-port.js';
+import { WQMessageEvent } from './WQMessageEvent.js';
+import { WQMessagePort } from './WQMessagePort.js';
+import { _wq } from '../../util.js';
+
+export class WQSockPort extends WQMessagePort {
+
+    static WebSocket = typeof WebSocket !== 'undefined' ? WebSocket : null;
+
+    #socket;
+    #cleanups = [];
+
+    constructor(instanceOrConnectionID) {
+        super();
+        this.#socket = typeof instanceOrConnectionID === 'string' ? new this.constructor.WebSocket(`/${instanceOrConnectionID}`) : instanceOrConnectionID;
+        const meta = _wq(this, 'meta');
+        Object.defineProperty(this, 'wqLifecycle', {
+            value: {
+                open: new Promise((resolve) => {
+                    if (meta.get('open')) return resolve();
+                    meta.set('onlineCallback', resolve);
+                }),
+                close: new Promise((resolve) => {
+                    if (meta.get('close')) return resolve();
+                    meta.set('offlineCallback', resolve);
+                }),
+                messaging: new Promise((resolve) => {
+                    if (meta.get('messaging')) return resolve();
+                    meta.set('messagingCallback', resolve);
+                }),
+            },
+            configurable: true
+        });
+        const fireOpen = () => {
+            this.dispatchEvent(new Event('open'));
+            meta.get('onlineCallback')();
+        };
+        const fireClose = () => {
+            this.dispatchEvent(new Event('close'));
+            meta.get('offlineCallback')();
+        };
+        if (this.#socket.readyState === this.#socket.constructor.OPEN) {
+            fireOpen();
+        }
+        const fireError = () => {
+            this.dispatchEvent(new Event('error'));
+        };
+        // --------
+        const handleMessage = async (event) => {
+            let json;
+            try {
+                if (!(json = JSON.parse(event.data))
+                    || !json['.wq']
+                    || !('data' in json)
+                    || !['wqEventOptions', 'wqProcessingOptions'].every((k) => _isObject(json[k]))) {
+                    return;
+                }
+            } catch (e) {
+                // throw a better error
+            }
+            // Build event details...
+            const { data, wqEventOptions, wqProcessingOptions } = json;
+            const eventInit = { data, wqEventOptions, ports: [] };
+            if (wqProcessingOptions.dataOriginallyUndefined) {
+                eventInit.data = undefined;
+            }
+            for (let i = 0; i < (wqProcessingOptions.numPorts || 0); i++) {
+                const channel = new MessageChannel;
+                channel.port1.start();
+                toWQPort(channel.port1);
+                this.#cleanups.push(forwardPort.call(this, '*', channel.port1, { bidirectional: true, namespace1: `${wqEventOptions.eventID}:${i}` }));
+                eventInit.ports.push(channel.port2);
+            }
+            this.dispatchEvent(new WQMessageEvent(this, eventInit));
+        };
+        const handleClose = (e) => {
+            this.#socket.removeEventListener('message', handleMessage);
+            this.#socket.removeEventListener('open', fireOpen);
+            this.#socket.removeEventListener('error', fireError);
+            this.#socket.removeEventListener('close', handleClose);
+            for (const c of this.#cleanups) {
+                c();
+            }
+            portHooksCleanup.call(this);
+            fireClose();
+        };
+        this.#socket.addEventListener('message', handleMessage);
+        this.#socket.addEventListener('open', fireOpen);
+        this.#socket.addEventListener('error', fireError);
+        this.#socket.addEventListener('close', handleClose);
+    }
+
+    postMessage(data, transferOrOptions = []) {
+        const { transfer = [], wqEventOptions = {}, wqProcessingOptions: _, ...portOptions } = preProcessPostMessage.call(this, data, transferOrOptions);
+        const messagePorts = transfer.filter((t) => t instanceof MessagePort);
+        portIsMessaging.call(this);
+        this.#socket.send(JSON.stringify({
+            data: data === undefined ? null : data,
+            wqEventOptions,
+            wqProcessingOptions: { numPorts: messagePorts.length, dataOriginallyUndefined: data === undefined },
+            ['.wq']: true,
+        }), portOptions);
+        for (let i = 0; i < messagePorts.length; i++) {
+            toWQPort(messagePorts[i]);
+            this.#cleanups.push(forwardPort.call(this, '*', messagePorts[i], { bidirectional: true, namespace1: `${wqEventOptions.eventID}:${i}` }));
+        }
+    }
+
+    close() {
+        return this.#socket.close();
+    }
+}

package/src/runtime-pi/webflo-messaging/WQStarPort.js

@@ -0,0 +1,104 @@
+import { preProcessPostMessage, portIsMessaging, portHooksCleanup } from './wq-message-port.js';
+import { WQMessagePort } from './WQMessagePort.js';
+import { _wq } from '../../util.js';
+
+export class WQStarPort extends WQMessagePort {
+
+    #ports = new Set;
+
+    get length() { return this.#ports.size; }
+
+    [Symbol.iterator]() { return this.#ports[Symbol.iterator](); }
+
+    constructor() {
+        super();
+        this.#startWQLifecycle();
+    }
+
+    #startWQLifecycle() {
+        const meta = _wq(this, 'meta');
+        Object.defineProperty(this, 'wqLifecycle', {
+            value: {
+                open: new Promise((resolve) => {
+                    if (meta.get('open')) return resolve();
+                    meta.set('onlineCallback', resolve);
+                }),
+                close: new Promise((resolve) => {
+                    if (meta.get('close')) return resolve();
+                    meta.set('offlineCallback', resolve);
+                }),
+                messaging: new Promise((resolve) => {
+                    if (meta.get('messaging')) return resolve();
+                    meta.set('messagingCallback', resolve);
+                }),
+            },
+            configurable: true
+        });
+    }
+
+    addPort(port, { enableBubbling = true } = {}) {
+        if (!(port instanceof WQMessagePort)) {
+            throw new TypeError('Port must be a WQMessagePort instance.');
+        }
+        if (this.#ports.has(port)) return;
+        this.#ports.add(port);              // @ORDER: 1
+        const meta = _wq(this, 'meta');
+        const portMeta = _wq(port, 'meta');
+        if (enableBubbling) {
+            if (portMeta.get('parentNode')) {
+                throw new TypeError('Incoming port already has a parent node.');
+            }
+            portMeta.set('parentNode', this);   // @ORDER: 2
+        }
+        // Lifecycle management
+        port.wqLifecycle.open.then(() => {
+            if (meta.get('open')) return;
+            this.dispatchEvent(new Event('open'));
+            meta.get('onlineCallback')();
+        });
+        const cleanup = () => {
+            if (!this.#ports.has(port)) return;
+            this.#ports.delete(port);
+            if (enableBubbling) {
+                portMeta.set('parentNode', null);
+            }
+            if (this.#ports.size === 0) {
+                this.dispatchEvent(new Event('close'));
+                meta.get('offlineCallback')();
+                this.#startWQLifecycle();
+            }
+        };
+        port.wqLifecycle.close.then(cleanup);
+        return cleanup;
+    }
+
+    findPort(callback) {
+        for (const port of this.#ports) {
+            if (callback(port)) {
+                return port;
+            }
+        }
+    }
+
+    // --------
+
+    postMessage(data, transferOrOptions = []) {
+        portIsMessaging.call(this);
+        this.wqLifecycle.open.then(() => {
+            const { wqProcessingOptions, ...resstOptions } = preProcessPostMessage.call(this, data, transferOrOptions);
+            for (const port of this.#ports) {
+                if (port === wqProcessingOptions.except) continue;
+                port.postMessage(data, { wqProcessingOptions, ...resstOptions });
+            }
+        });
+    }
+
+    close(destroy = false) {
+        for (const port of this.#ports) {
+            port.close?.();
+        }
+        if (destroy) {
+            portHooksCleanup.call(this);
+        }
+    }
+}