@webiny/api-websockets-standalone 0.0.0-unstable.0156a4c312

package/delivery/sendToLocalSockets.js

@@ -0,0 +1,24 @@
+const sendToLocalSockets = async (params)=>{
+    const { connectionManager, adapter, logger, connectionIds, data } = params;
+    const payload = JSON.stringify(data);
+    const missing = [];
+    for (const connectionId of connectionIds){
+        const socket = connectionManager.getSocket(connectionId);
+        if (void 0 === socket) {
+            missing.push(connectionId);
+            continue;
+        }
+        try {
+            await adapter.send(socket, payload);
+        } catch (error) {
+            logger.error({
+                error,
+                connectionId
+            }, "[websockets] could not send to a connection");
+        }
+    }
+    return missing;
+};
+export { sendToLocalSockets };
+
+//# sourceMappingURL=sendToLocalSockets.js.map

package/delivery/sendToLocalSockets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery/sendToLocalSockets.js","sources":["../../src/delivery/sendToLocalSockets.ts"],"sourcesContent":["import type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { Logger } from \"@webiny/api-core/features/logger/abstractions.js\";\nimport type { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\nimport type { WebsocketsServerAdapter } from \"~/adapter/abstractions.js\";\n\nexport interface ISendToLocalSocketsParams {\n    connectionManager: WebsocketsConnectionManager.Interface<unknown>;\n    adapter: WebsocketsServerAdapter.Interface<unknown>;\n    logger: Logger.Interface;\n    connectionIds: string[];\n    data: GenericRecord;\n}\n\n/*\n * Sends `data` on each socket this process holds and returns the ids it holds no socket for. A failed\n * send is logged and the others go on.\n */\nexport const sendToLocalSockets = async (params: ISendToLocalSocketsParams): Promise<string[]> => {\n    const { connectionManager, adapter, logger, connectionIds, data } = params;\n    const payload = JSON.stringify(data);\n    const missing: string[] = [];\n    for (const connectionId of connectionIds) {\n        const socket = connectionManager.getSocket(connectionId);\n        if (socket === undefined) {\n            missing.push(connectionId);\n            continue;\n        }\n        try {\n            await adapter.send(socket, payload);\n        } catch (error) {\n            logger.error({ error, connectionId }, \"[websockets] could not send to a connection\");\n        }\n    }\n    return missing;\n};\n"],"names":["sendToLocalSockets","params","connectionManager","adapter","logger","connectionIds","data","payload","JSON","missing","connectionId","socket","undefined","error"],"mappings":"AAiBO,MAAMA,qBAAqB,OAAOC;IACrC,MAAM,EAAEC,iBAAiB,EAAEC,OAAO,EAAEC,MAAM,EAAEC,aAAa,EAAEC,IAAI,EAAE,GAAGL;IACpE,MAAMM,UAAUC,KAAK,SAAS,CAACF;IAC/B,MAAMG,UAAoB,EAAE;IAC5B,KAAK,MAAMC,gBAAgBL,cAAe;QACtC,MAAMM,SAAST,kBAAkB,SAAS,CAACQ;QAC3C,IAAIC,AAAWC,WAAXD,QAAsB;YACtBF,QAAQ,IAAI,CAACC;YACb;QACJ;QACA,IAAI;YACA,MAAMP,QAAQ,IAAI,CAACQ,QAAQJ;QAC/B,EAAE,OAAOM,OAAO;YACZT,OAAO,KAAK,CAAC;gBAAES;gBAAOH;YAAa,GAAG;QAC1C;IACJ;IACA,OAAOD;AACX"}

package/heartbeat/HeartbeatManager.d.ts

@@ -0,0 +1,13 @@
+import type { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import type { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+export declare class HeartbeatManager {
+    private readonly connectionManager;
+    private readonly adapter;
+    private readonly interval;
+    private readonly staleAfter;
+    private timer;
+    constructor(connectionManager: WebsocketsConnectionManager.Interface<unknown>, adapter: WebsocketsServerAdapter.Interface<unknown>, interval: number, staleAfter: number);
+    start(): void;
+    stop(): void;
+    evictStale(): Promise<void>;
+}

package/heartbeat/HeartbeatManager.js

@@ -0,0 +1,46 @@
+const STALE_CLOSE_CODE = 1001;
+const STALE_CLOSE_REASON = "Connection went stale.";
+class HeartbeatManager {
+    constructor(connectionManager, adapter, interval, staleAfter){
+        this.connectionManager = connectionManager;
+        this.adapter = adapter;
+        this.interval = interval;
+        this.staleAfter = staleAfter;
+    }
+    start() {
+        this.timer = setInterval(()=>{
+            this.evictStale();
+        }, this.interval);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = void 0;
+        }
+    }
+    async evictStale() {
+        const sockets = new Map();
+        for (const connectionId of this.connectionManager.getActiveConnectionIds()){
+            const socket = this.connectionManager.getSocket(connectionId);
+            sockets.set(connectionId, socket);
+        }
+        let evicted;
+        try {
+            evicted = await this.connectionManager.cleanup(this.staleAfter);
+        } catch (error) {
+            console.error("Failed to evict stale WebSocket connections:", error);
+            return;
+        }
+        for (const connectionId of evicted){
+            const socket = sockets.get(connectionId);
+            if (void 0 !== socket) try {
+                this.adapter.close(socket, STALE_CLOSE_CODE, STALE_CLOSE_REASON);
+            } catch (error) {
+                console.error(`Failed to close stale WebSocket "${connectionId}":`, error);
+            }
+        }
+    }
+}
+export { HeartbeatManager };
+
+//# sourceMappingURL=HeartbeatManager.js.map

package/heartbeat/HeartbeatManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat/HeartbeatManager.js","sources":["../../src/heartbeat/HeartbeatManager.ts"],"sourcesContent":["import type { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\nimport type { WebsocketsServerAdapter } from \"~/adapter/abstractions.js\";\n\nconst STALE_CLOSE_CODE = 1001;\nconst STALE_CLOSE_REASON = \"Connection went stale.\";\n\n/*\n * Evicts connections that have not been seen for `staleAfter` milliseconds: forgets them and closes\n * their sockets.\n *\n * `staleAfter` must sit well above the client's ping interval. The admin pings every 5 minutes and\n * browsers delay timers in hidden tabs by up to a minute, so a threshold equal to the ping interval\n * evicted healthy background tabs. Closing the socket is what lets the client notice and reconnect:\n * an evicted socket left open looks connected to the client but no longer receives anything.\n */\nexport class HeartbeatManager {\n    private timer: ReturnType<typeof setInterval> | undefined;\n\n    public constructor(\n        private readonly connectionManager: WebsocketsConnectionManager.Interface<unknown>,\n        private readonly adapter: WebsocketsServerAdapter.Interface<unknown>,\n        private readonly interval: number,\n        private readonly staleAfter: number\n    ) {}\n\n    public start(): void {\n        this.timer = setInterval(() => {\n            void this.evictStale();\n        }, this.interval);\n    }\n\n    public stop(): void {\n        if (this.timer) {\n            clearInterval(this.timer);\n            this.timer = undefined;\n        }\n    }\n\n    public async evictStale(): Promise<void> {\n        // Cleanup forgets the sockets it evicts, so take them before it runs.\n        const sockets = new Map<string, unknown>();\n        for (const connectionId of this.connectionManager.getActiveConnectionIds()) {\n            const socket = this.connectionManager.getSocket(connectionId);\n            sockets.set(connectionId, socket);\n        }\n\n        let evicted: string[];\n        try {\n            evicted = await this.connectionManager.cleanup(this.staleAfter);\n        } catch (error) {\n            console.error(\"Failed to evict stale WebSocket connections:\", error);\n            return;\n        }\n\n        for (const connectionId of evicted) {\n            const socket = sockets.get(connectionId);\n            if (socket === undefined) {\n                continue;\n            }\n            try {\n                this.adapter.close(socket, STALE_CLOSE_CODE, STALE_CLOSE_REASON);\n            } catch (error) {\n                console.error(`Failed to close stale WebSocket \"${connectionId}\":`, error);\n            }\n        }\n    }\n}\n"],"names":["STALE_CLOSE_CODE","STALE_CLOSE_REASON","HeartbeatManager","connectionManager","adapter","interval","staleAfter","setInterval","clearInterval","undefined","sockets","Map","connectionId","socket","evicted","error","console"],"mappings":"AAGA,MAAMA,mBAAmB;AACzB,MAAMC,qBAAqB;AAWpB,MAAMC;IAGT,YACqBC,iBAAiE,EACjEC,OAAmD,EACnDC,QAAgB,EAChBC,UAAkB,CACrC;aAJmBH,iBAAiB,GAAjBA;aACAC,OAAO,GAAPA;aACAC,QAAQ,GAARA;aACAC,UAAU,GAAVA;IAClB;IAEI,QAAc;QACjB,IAAI,CAAC,KAAK,GAAGC,YAAY;YAChB,IAAI,CAAC,UAAU;QACxB,GAAG,IAAI,CAAC,QAAQ;IACpB;IAEO,OAAa;QAChB,IAAI,IAAI,CAAC,KAAK,EAAE;YACZC,cAAc,IAAI,CAAC,KAAK;YACxB,IAAI,CAAC,KAAK,GAAGC;QACjB;IACJ;IAEA,MAAa,aAA4B;QAErC,MAAMC,UAAU,IAAIC;QACpB,KAAK,MAAMC,gBAAgB,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,GAAI;YACxE,MAAMC,SAAS,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAACD;YAChDF,QAAQ,GAAG,CAACE,cAAcC;QAC9B;QAEA,IAAIC;QACJ,IAAI;YACAA,UAAU,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU;QAClE,EAAE,OAAOC,OAAO;YACZC,QAAQ,KAAK,CAAC,gDAAgDD;YAC9D;QACJ;QAEA,KAAK,MAAMH,gBAAgBE,QAAS;YAChC,MAAMD,SAASH,QAAQ,GAAG,CAACE;YAC3B,IAAIC,AAAWJ,WAAXI,QAGJ,IAAI;gBACA,IAAI,CAAC,OAAO,CAAC,KAAK,CAACA,QAAQb,kBAAkBC;YACjD,EAAE,OAAOc,OAAO;gBACZC,QAAQ,KAAK,CAAC,CAAC,iCAAiC,EAAEJ,aAAa,EAAE,CAAC,EAAEG;YACxE;QACJ;IACJ;AACJ"}

package/index.d.ts

@@ -0,0 +1,12 @@
+export { createWebsocketsServer, attachWebsocketsServer } from "./server/WebsocketsServer.js";
+export type { IWebsocketsServer, WebsocketsConnectionAuthenticator } from "./server/types.js";
+export * from "./adapter/abstractions.js";
+export * from "./upgradeHandler/abstractions.js";
+export * from "./connectionManager/abstractions.js";
+export { WebsocketsMessageBus } from "./bus/abstractions.js";
+export { createBusMessageHandler } from "./bus/createBusMessageHandler.js";
+export { ServerConnectionManager } from "./connectionManager/ServerConnectionManager.js";
+export { NodeWsAdapter } from "./adapter/NodeWsAdapter.js";
+export { ServerWebsocketsTransport } from "./transport/ServerWebsocketsTransport.js";
+export { InProcessMessageBus } from "./bus/InProcessMessageBus.js";
+export { WebsocketsStandaloneFeature } from "./WebsocketsStandaloneFeature.js";

package/index.js

@@ -0,0 +1,11 @@
+export * from "./adapter/abstractions.js";
+export * from "./upgradeHandler/abstractions.js";
+export * from "./connectionManager/abstractions.js";
+export { attachWebsocketsServer, createWebsocketsServer } from "./server/WebsocketsServer.js";
+export { WebsocketsMessageBus } from "./bus/abstractions.js";
+export { createBusMessageHandler } from "./bus/createBusMessageHandler.js";
+export { ServerConnectionManager } from "./connectionManager/ServerConnectionManager.js";
+export { NodeWsAdapter } from "./adapter/NodeWsAdapter.js";
+export { ServerWebsocketsTransport } from "./transport/ServerWebsocketsTransport.js";
+export { InProcessMessageBus } from "./bus/InProcessMessageBus.js";
+export { WebsocketsStandaloneFeature } from "./WebsocketsStandaloneFeature.js";

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@webiny/api-websockets-standalone",
+	"version": "0.0.0-unstable.0156a4c312",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "Standalone WebSocket server transport for @webiny/api-websockets",
+	"contributors": [
+		"Bruno Zorić <bruno@webiny.com>"
+	],
+	"exports": {
+		"./*": "./*",
+		".": "./index.js"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-core": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-websockets": "0.0.0-unstable.0156a4c312",
+		"@webiny/event-handler-standalone": "0.0.0-unstable.0156a4c312",
+		"@webiny/feature": "0.0.0-unstable.0156a4c312",
+		"@webiny/plugins": "0.0.0-unstable.0156a4c312",
+		"@webiny/utils": "0.0.0-unstable.0156a4c312",
+		"ws": "8.22.1",
+		"zod": "4.6.7"
+	},
+	"devDependencies": {
+		"@types/ws": "8.18.2",
+		"@webiny/build-tools": "0.0.0-unstable.0156a4c312",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "5.0.5"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/server/WebsocketsServer.d.ts

@@ -0,0 +1,55 @@
+import type { Server as HttpServer } from "node:http";
+import type { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+import type { WebsocketsUpgradeHandler } from "../upgradeHandler/abstractions.js";
+import type { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import type { CreateWebsocketsServerParams, AttachWebsocketsServerParams, IWebsocketsServer, WebsocketsConnectionAuthenticator } from "./types.js";
+interface WebsocketsServerParams {
+    httpServer: HttpServer;
+    ownsHttpServer: boolean;
+    adapter: WebsocketsServerAdapter.Interface<unknown>;
+    upgradeHandler: WebsocketsUpgradeHandler.Interface;
+    connectionManager?: WebsocketsConnectionManager.Interface<unknown>;
+    authenticate?: WebsocketsConnectionAuthenticator;
+    heartbeatInterval: number;
+    staleAfter: number;
+    debug: boolean;
+    port: number;
+    host: string;
+}
+declare class WebsocketsServer implements IWebsocketsServer {
+    private readonly httpServer;
+    private readonly ownsHttpServer;
+    private readonly adapter;
+    private readonly upgradeHandler;
+    private readonly connectionManager;
+    private readonly authenticate;
+    private readonly heartbeat;
+    private readonly debug;
+    private readonly requestedPort;
+    private readonly requestedHost;
+    private shuttingDown;
+    private endpoint;
+    private resolvedPort;
+    constructor(params: WebsocketsServerParams);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    port(): number;
+    private wireUpgradeHandler;
+    private wireConnectionHandler;
+    /**
+     * Authenticates the upgrade using the `?token`/`?tenant` query the app-websockets client sends,
+     * then registers the live socket in the shared connection manager under the resolved identity and
+     * tenant. Getting both right matters for targeted server→client sends: `SendToIdentity` finds
+     * connections by identity id in the registry, so a connection that's anonymous (or never made it
+     * into the registry) can't be reached. Everything here is guarded — if something goes wrong we
+     * don't crash the server or the upgrade, the connection just ends up unaddressable.
+     */
+    private registerConnection;
+    private removeConnection;
+    private resolvePortFromExistingServer;
+    private listen;
+    private closeHttpServer;
+}
+export { WebsocketsServer };
+export declare const createWebsocketsServer: (params: CreateWebsocketsServerParams) => IWebsocketsServer;
+export declare const attachWebsocketsServer: (params: AttachWebsocketsServerParams) => IWebsocketsServer;

package/server/WebsocketsServer.js

@@ -0,0 +1,211 @@
+import { createServer } from "node:http";
+import { mdbid } from "@webiny/utils";
+import { NodeWsAdapterImpl } from "../adapter/NodeWsAdapter.js";
+import { DefaultUpgradeHandlerImpl } from "../upgradeHandler/DefaultUpgradeHandler.js";
+import { HeartbeatManager } from "../heartbeat/HeartbeatManager.js";
+const ANONYMOUS_IDENTITY = {
+    id: "",
+    displayName: "",
+    type: ""
+};
+const DEFAULT_HEARTBEAT_INTERVAL = 60000;
+const DEFAULT_STALE_AFTER = 900000;
+const toHeaders = (raw)=>{
+    const headers = {};
+    for (const [key, value] of Object.entries(raw))if ("string" == typeof value) headers[key] = value;
+    return headers;
+};
+class WebsocketsServer {
+    constructor(params){
+        this.shuttingDown = false;
+        this.endpoint = "";
+        this.resolvedPort = 0;
+        this.httpServer = params.httpServer;
+        this.ownsHttpServer = params.ownsHttpServer;
+        this.adapter = params.adapter;
+        this.upgradeHandler = params.upgradeHandler;
+        this.connectionManager = params.connectionManager;
+        this.authenticate = params.authenticate;
+        this.debug = params.debug;
+        this.requestedPort = params.port;
+        this.requestedHost = params.host;
+        if (params.connectionManager) this.heartbeat = new HeartbeatManager(params.connectionManager, params.adapter, params.heartbeatInterval, params.staleAfter);
+    }
+    async start() {
+        this.adapter.start(this.httpServer);
+        this.wireUpgradeHandler();
+        this.wireConnectionHandler();
+        if (this.ownsHttpServer) await this.listen();
+        else this.resolvePortFromExistingServer();
+        this.heartbeat?.start();
+        if (this.debug) console.log(`[WebsocketsServer] started on ${this.endpoint}`);
+    }
+    async stop() {
+        this.shuttingDown = true;
+        this.heartbeat?.stop();
+        const activeIds = this.connectionManager?.getActiveConnectionIds() ?? [];
+        const removals = activeIds.map((connectionId)=>this.removeConnection(connectionId));
+        const closing = this.adapter.stop();
+        await Promise.all([
+            closing,
+            ...removals
+        ]);
+        if (this.ownsHttpServer) await this.closeHttpServer();
+        if (this.debug) console.log("[WebsocketsServer] stopped");
+    }
+    port() {
+        return this.resolvedPort;
+    }
+    wireUpgradeHandler() {
+        this.httpServer.on("upgrade", async (request, socket, head)=>{
+            if (this.shuttingDown) return void socket.destroy();
+            socket.on("error", (error)=>{
+                console.error("WebSocket upgrade socket error:", error.message);
+            });
+            try {
+                const decision = await this.upgradeHandler.shouldUpgrade(request);
+                if (!decision.allowed) {
+                    socket.write(`HTTP/1.1 ${decision.statusCode} ${decision.reason}\r\n\r\n`);
+                    socket.destroy();
+                    return;
+                }
+                this.adapter.handleUpgrade(request, socket, head);
+            } catch (error) {
+                console.error("WebSocket upgrade failed:", error);
+                socket.destroy();
+            }
+        });
+    }
+    wireConnectionHandler() {
+        this.adapter.onConnection((socket, request)=>{
+            if (this.shuttingDown) return;
+            const connectionId = mdbid();
+            const connectedAt = Date.now();
+            const host = request.headers.host || "localhost";
+            const headers = toHeaders(request.headers);
+            const registration = this.registerConnection({
+                connectionId,
+                socket,
+                request,
+                connectedAt,
+                host,
+                headers
+            });
+            this.adapter.onMessage(socket, (data)=>{
+                if (this.shuttingDown) return;
+                const metadata = this.connectionManager?.getMetadata(connectionId);
+                if (!metadata) return;
+                try {
+                    JSON.parse(data.toString());
+                } catch  {
+                    return;
+                }
+                this.connectionManager?.updateLastSeen(connectionId).catch((error)=>{
+                    console.error(`Failed to update last seen for WebSocket connection "${connectionId}":`, error);
+                });
+            });
+            this.adapter.onClose(socket, ()=>{
+                if (this.shuttingDown) return;
+                registration.then(()=>this.removeConnection(connectionId));
+            });
+            this.adapter.onError(socket, (error)=>{
+                console.error(`WebSocket error for connection "${connectionId}":`, error.message);
+            });
+        });
+    }
+    async registerConnection(params) {
+        const { connectionId, socket, request, connectedAt, host, headers } = params;
+        let identity = ANONYMOUS_IDENTITY;
+        let tenant = "";
+        try {
+            const url = new URL(request.url ?? "", `http://${host}`);
+            tenant = url.searchParams.get("tenant") ?? "";
+            const token = url.searchParams.get("token") ?? "";
+            if (this.authenticate && token) {
+                const authenticated = await this.authenticate(token);
+                if (authenticated?.id) identity = authenticated;
+            }
+            await this.connectionManager?.add({
+                connectionId,
+                socket,
+                endpoint: this.endpoint,
+                identity,
+                tenant,
+                connectedAt,
+                host,
+                headers
+            });
+        } catch (error) {
+            console.error(`Failed to register WebSocket connection "${connectionId}":`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    async removeConnection(connectionId) {
+        try {
+            await this.connectionManager?.remove(connectionId);
+        } catch (error) {
+            console.error(`Failed to remove WebSocket connection "${connectionId}":`, error);
+        }
+    }
+    resolvePortFromExistingServer() {
+        const address = this.httpServer.address();
+        if (address && "string" != typeof address) {
+            this.resolvedPort = address.port;
+            this.endpoint = `ws://127.0.0.1:${this.resolvedPort}`;
+        }
+    }
+    listen() {
+        return new Promise((resolve, reject)=>{
+            this.httpServer.listen(this.requestedPort, this.requestedHost, ()=>{
+                const address = this.httpServer.address();
+                if (!address || "string" == typeof address) return void reject(new Error("Unexpected server address format."));
+                this.resolvedPort = address.port;
+                this.endpoint = `ws://${this.requestedHost}:${this.resolvedPort}`;
+                resolve();
+            });
+        });
+    }
+    closeHttpServer() {
+        return new Promise((resolve, reject)=>{
+            this.httpServer.close((err)=>{
+                if (err) return void reject(err);
+                resolve();
+            });
+        });
+    }
+}
+const createWebsocketsServer = (params)=>{
+    const httpServer = createServer();
+    const server = new WebsocketsServer({
+        httpServer,
+        ownsHttpServer: true,
+        adapter: new NodeWsAdapterImpl(),
+        upgradeHandler: new DefaultUpgradeHandlerImpl(),
+        connectionManager: params.connectionManager,
+        authenticate: params.authenticate,
+        heartbeatInterval: params.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL,
+        staleAfter: params.staleAfter ?? DEFAULT_STALE_AFTER,
+        debug: params.debug ?? false,
+        port: params.port ?? 0,
+        host: params.host ?? "127.0.0.1"
+    });
+    return server;
+};
+const attachWebsocketsServer = (params)=>{
+    const server = new WebsocketsServer({
+        httpServer: params.server,
+        ownsHttpServer: false,
+        adapter: new NodeWsAdapterImpl(),
+        upgradeHandler: new DefaultUpgradeHandlerImpl(),
+        connectionManager: params.connectionManager,
+        authenticate: params.authenticate,
+        heartbeatInterval: params.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL,
+        staleAfter: params.staleAfter ?? DEFAULT_STALE_AFTER,
+        debug: params.debug ?? false,
+        port: 0,
+        host: "127.0.0.1"
+    });
+    return server;
+};
+export { WebsocketsServer, attachWebsocketsServer, createWebsocketsServer };
+
+//# sourceMappingURL=WebsocketsServer.js.map

package/server/WebsocketsServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server/WebsocketsServer.js","sources":["../../src/server/WebsocketsServer.ts"],"sourcesContent":["import { createServer } from \"node:http\";\nimport type { Server as HttpServer, IncomingMessage } from \"node:http\";\nimport type { Duplex } from \"node:stream\";\nimport { mdbid } from \"@webiny/utils\";\nimport type { WebsocketsServerAdapter } from \"~/adapter/abstractions.js\";\nimport type { WebsocketsUpgradeHandler } from \"~/upgradeHandler/abstractions.js\";\nimport type { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\nimport type { ConnectionRegistry } from \"@webiny/api-websockets/exports/api.js\";\nimport { NodeWsAdapterImpl } from \"~/adapter/NodeWsAdapter.js\";\nimport { DefaultUpgradeHandlerImpl } from \"~/upgradeHandler/DefaultUpgradeHandler.js\";\nimport { HeartbeatManager } from \"~/heartbeat/HeartbeatManager.js\";\nimport type {\n    CreateWebsocketsServerParams,\n    AttachWebsocketsServerParams,\n    IWebsocketsServer,\n    WebsocketsConnectionAuthenticator\n} from \"./types.js\";\n\nconst ANONYMOUS_IDENTITY: ConnectionRegistry.Identity = { id: \"\", displayName: \"\", type: \"\" };\n\nconst DEFAULT_HEARTBEAT_INTERVAL = 60_000;\n// Three admin ping intervals (5 minutes each): one late ping is not enough to evict a live tab.\nconst DEFAULT_STALE_AFTER = 15 * 60_000;\n\nconst toHeaders = (raw: IncomingMessage[\"headers\"]): Record<string, string> => {\n    const headers: Record<string, string> = {};\n    for (const [key, value] of Object.entries(raw)) {\n        if (typeof value === \"string\") {\n            headers[key] = value;\n        }\n    }\n    return headers;\n};\n\ninterface WebsocketsServerParams {\n    httpServer: HttpServer;\n    ownsHttpServer: boolean;\n    adapter: WebsocketsServerAdapter.Interface<unknown>;\n    upgradeHandler: WebsocketsUpgradeHandler.Interface;\n    connectionManager?: WebsocketsConnectionManager.Interface<unknown>;\n    authenticate?: WebsocketsConnectionAuthenticator;\n    heartbeatInterval: number;\n    staleAfter: number;\n    debug: boolean;\n    port: number;\n    host: string;\n}\n\nclass WebsocketsServer implements IWebsocketsServer {\n    private readonly httpServer: HttpServer;\n    private readonly ownsHttpServer: boolean;\n    private readonly adapter: WebsocketsServerAdapter.Interface<unknown>;\n    private readonly upgradeHandler: WebsocketsUpgradeHandler.Interface;\n    private readonly connectionManager: WebsocketsConnectionManager.Interface<unknown> | undefined;\n    private readonly authenticate: WebsocketsConnectionAuthenticator | undefined;\n    private readonly heartbeat: HeartbeatManager | undefined;\n    private readonly debug: boolean;\n    private readonly requestedPort: number;\n    private readonly requestedHost: string;\n\n    private shuttingDown: boolean = false;\n    private endpoint: string = \"\";\n    private resolvedPort: number = 0;\n\n    public constructor(params: WebsocketsServerParams) {\n        this.httpServer = params.httpServer;\n        this.ownsHttpServer = params.ownsHttpServer;\n        this.adapter = params.adapter;\n        this.upgradeHandler = params.upgradeHandler;\n        this.connectionManager = params.connectionManager;\n        this.authenticate = params.authenticate;\n        this.debug = params.debug;\n        this.requestedPort = params.port;\n        this.requestedHost = params.host;\n\n        if (params.connectionManager) {\n            this.heartbeat = new HeartbeatManager(\n                params.connectionManager,\n                params.adapter,\n                params.heartbeatInterval,\n                params.staleAfter\n            );\n        }\n    }\n\n    public async start(): Promise<void> {\n        this.adapter.start(this.httpServer);\n        this.wireUpgradeHandler();\n        this.wireConnectionHandler();\n\n        if (this.ownsHttpServer) {\n            await this.listen();\n        } else {\n            this.resolvePortFromExistingServer();\n        }\n\n        this.heartbeat?.start();\n\n        if (this.debug) {\n            console.log(`[WebsocketsServer] started on ${this.endpoint}`);\n        }\n    }\n\n    public async stop(): Promise<void> {\n        this.shuttingDown = true;\n        this.heartbeat?.stop();\n\n        /*\n         * Close the sockets and take this process's connections out of the registry at the same\n         * time, so both fit in the shutdown. Without the registry step, the rows stay until another\n         * process's heartbeat finds them stale, and sends to those users go nowhere until then.\n         */\n        const activeIds = this.connectionManager?.getActiveConnectionIds() ?? [];\n        const removals = activeIds.map(connectionId => this.removeConnection(connectionId));\n        const closing = this.adapter.stop();\n        await Promise.all([closing, ...removals]);\n\n        if (this.ownsHttpServer) {\n            await this.closeHttpServer();\n        }\n\n        if (this.debug) {\n            console.log(\"[WebsocketsServer] stopped\");\n        }\n    }\n\n    public port(): number {\n        return this.resolvedPort;\n    }\n\n    private wireUpgradeHandler(): void {\n        this.httpServer.on(\n            \"upgrade\",\n            async (request: IncomingMessage, socket: Duplex, head: Buffer) => {\n                if (this.shuttingDown) {\n                    socket.destroy();\n                    return;\n                }\n\n                /*\n                 * Node drops its own error listener before emitting `upgrade`, so an error on the\n                 * raw socket before `ws` takes it over would be unhandled and end the process.\n                 */\n                socket.on(\"error\", error => {\n                    console.error(\"WebSocket upgrade socket error:\", error.message);\n                });\n\n                try {\n                    const decision = await this.upgradeHandler.shouldUpgrade(request);\n                    if (!decision.allowed) {\n                        socket.write(`HTTP/1.1 ${decision.statusCode} ${decision.reason}\\r\\n\\r\\n`);\n                        socket.destroy();\n                        return;\n                    }\n\n                    this.adapter.handleUpgrade(request, socket, head);\n                } catch (error) {\n                    console.error(\"WebSocket upgrade failed:\", error);\n                    socket.destroy();\n                }\n            }\n        );\n    }\n\n    private wireConnectionHandler(): void {\n        this.adapter.onConnection((socket, request) => {\n            if (this.shuttingDown) {\n                return;\n            }\n\n            const connectionId = mdbid();\n            const connectedAt = Date.now();\n            const host = request.headers.host || \"localhost\";\n            const headers = toHeaders(request.headers);\n\n            // Register the connection under its real identity, decoded from the `?token` JWT. Both\n            // the authentication and the registry write are async, so we kick this off without\n            // awaiting it and wire the socket handlers below synchronously — that way we don't miss a\n            // close or message that arrives during the gap. If a message does arrive before\n            // registration finishes, the `getMetadata` guard below just drops it, which is fine since\n            // the client doesn't send anything meaningful right at connect time.\n            const registration = this.registerConnection({\n                connectionId,\n                socket,\n                request,\n                connectedAt,\n                host,\n                headers\n            });\n\n            this.adapter.onMessage(socket, data => {\n                if (this.shuttingDown) {\n                    return;\n                }\n\n                const metadata = this.connectionManager?.getMetadata(connectionId);\n                if (!metadata) {\n                    return;\n                }\n\n                try {\n                    JSON.parse(data.toString());\n                } catch {\n                    return;\n                }\n\n                this.connectionManager?.updateLastSeen(connectionId).catch(error => {\n                    console.error(\n                        `Failed to update last seen for WebSocket connection \"${connectionId}\":`,\n                        error\n                    );\n                });\n            });\n\n            this.adapter.onClose(socket, () => {\n                if (this.shuttingDown) {\n                    return;\n                }\n                /*\n                 * Wait for registration: a socket that closes while it is still authenticating\n                 * would otherwise be removed first and then registered, leaving a dead entry.\n                 */\n                void registration.then(() => this.removeConnection(connectionId));\n            });\n\n            this.adapter.onError(socket, error => {\n                console.error(`WebSocket error for connection \"${connectionId}\":`, error.message);\n            });\n        });\n    }\n\n    /**\n     * Authenticates the upgrade using the `?token`/`?tenant` query the app-websockets client sends,\n     * then registers the live socket in the shared connection manager under the resolved identity and\n     * tenant. Getting both right matters for targeted server→client sends: `SendToIdentity` finds\n     * connections by identity id in the registry, so a connection that's anonymous (or never made it\n     * into the registry) can't be reached. Everything here is guarded — if something goes wrong we\n     * don't crash the server or the upgrade, the connection just ends up unaddressable.\n     */\n    private async registerConnection(params: {\n        connectionId: string;\n        socket: unknown;\n        request: IncomingMessage;\n        connectedAt: number;\n        host: string;\n        headers: Record<string, string>;\n    }): Promise<void> {\n        const { connectionId, socket, request, connectedAt, host, headers } = params;\n\n        let identity: ConnectionRegistry.Identity = ANONYMOUS_IDENTITY;\n        let tenant = \"\";\n\n        try {\n            const url = new URL(request.url ?? \"\", `http://${host}`);\n            tenant = url.searchParams.get(\"tenant\") ?? \"\";\n            const token = url.searchParams.get(\"token\") ?? \"\";\n\n            if (this.authenticate && token) {\n                const authenticated = await this.authenticate(token);\n                if (authenticated?.id) {\n                    identity = authenticated;\n                }\n            }\n\n            await this.connectionManager?.add({\n                connectionId,\n                socket,\n                endpoint: this.endpoint,\n                identity,\n                tenant,\n                connectedAt,\n                host,\n                headers\n            });\n        } catch (error) {\n            console.error(\n                `Failed to register WebSocket connection \"${connectionId}\":`,\n                error instanceof Error ? error.message : String(error)\n            );\n        }\n    }\n\n    private async removeConnection(connectionId: string): Promise<void> {\n        try {\n            await this.connectionManager?.remove(connectionId);\n        } catch (error) {\n            console.error(`Failed to remove WebSocket connection \"${connectionId}\":`, error);\n        }\n    }\n\n    private resolvePortFromExistingServer(): void {\n        const address = this.httpServer.address();\n        if (address && typeof address !== \"string\") {\n            this.resolvedPort = address.port;\n            this.endpoint = `ws://127.0.0.1:${this.resolvedPort}`;\n        }\n    }\n\n    private listen(): Promise<void> {\n        return new Promise((resolve, reject) => {\n            this.httpServer.listen(this.requestedPort, this.requestedHost, () => {\n                const address = this.httpServer.address();\n                if (!address || typeof address === \"string\") {\n                    reject(new Error(\"Unexpected server address format.\"));\n                    return;\n                }\n                this.resolvedPort = address.port;\n                this.endpoint = `ws://${this.requestedHost}:${this.resolvedPort}`;\n                resolve();\n            });\n        });\n    }\n\n    private closeHttpServer(): Promise<void> {\n        return new Promise((resolve, reject) => {\n            this.httpServer.close(err => {\n                if (err) {\n                    reject(err);\n                    return;\n                }\n                resolve();\n            });\n        });\n    }\n}\n\nexport { WebsocketsServer };\n\nexport const createWebsocketsServer = (params: CreateWebsocketsServerParams): IWebsocketsServer => {\n    const httpServer = createServer();\n    const server = new WebsocketsServer({\n        httpServer,\n        ownsHttpServer: true,\n        adapter: new NodeWsAdapterImpl(),\n        upgradeHandler: new DefaultUpgradeHandlerImpl(),\n        connectionManager: params.connectionManager,\n        authenticate: params.authenticate,\n        heartbeatInterval: params.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL,\n        staleAfter: params.staleAfter ?? DEFAULT_STALE_AFTER,\n        debug: params.debug ?? false,\n        port: params.port ?? 0,\n        host: params.host ?? \"127.0.0.1\"\n    });\n    return server;\n};\n\nexport const attachWebsocketsServer = (params: AttachWebsocketsServerParams): IWebsocketsServer => {\n    const server = new WebsocketsServer({\n        httpServer: params.server,\n        ownsHttpServer: false,\n        adapter: new NodeWsAdapterImpl(),\n        upgradeHandler: new DefaultUpgradeHandlerImpl(),\n        connectionManager: params.connectionManager,\n        authenticate: params.authenticate,\n        heartbeatInterval: params.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL,\n        staleAfter: params.staleAfter ?? DEFAULT_STALE_AFTER,\n        debug: params.debug ?? false,\n        port: 0,\n        host: \"127.0.0.1\"\n    });\n    return server;\n};\n"],"names":["ANONYMOUS_IDENTITY","DEFAULT_HEARTBEAT_INTERVAL","DEFAULT_STALE_AFTER","toHeaders","raw","headers","key","value","Object","WebsocketsServer","params","HeartbeatManager","console","activeIds","removals","connectionId","closing","Promise","request","socket","head","error","decision","mdbid","connectedAt","Date","host","registration","data","metadata","JSON","identity","tenant","url","URL","token","authenticated","Error","String","address","resolve","reject","err","createWebsocketsServer","httpServer","createServer","server","NodeWsAdapterImpl","DefaultUpgradeHandlerImpl","attachWebsocketsServer"],"mappings":"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"}

package/server/types.d.ts

@@ -0,0 +1,44 @@
+import type { Server as HttpServer } from "node:http";
+import type { PluginsContainer } from "@webiny/plugins";
+import type { PluginCollection } from "@webiny/plugins/types.js";
+import type { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import type { ConnectionRegistry } from "@webiny/api-websockets/exports/api.js";
+/**
+ * Resolves a connection's identity from the `?token` JWT sent on the WebSocket upgrade — the SAME
+ * token→identity step the HTTP request stack runs (RequestIdentityLoader). Returns `null` for an
+ * absent/invalid/anonymous token, in which case the connection registers anonymously and won't
+ * receive targeted (`SendToIdentity`) messages.
+ *
+ * It's a plain callback rather than a resolved dependency for two reasons: this WebSocket server is a
+ * DI-agnostic class (the handler resolves what it needs and passes plain values in), and the auth it
+ * needs — `AuthenticationContext` — lives in the PER-REQUEST stack, not the root container, so a
+ * boot-time object like this couldn't resolve it directly anyway. The handler builds the callback
+ * (spinning up a request-scoped child container per token). So authenticate has to be a callback the
+ * handler supplies, regardless of DI.
+ */
+export type WebsocketsConnectionAuthenticator = (token: string) => Promise<ConnectionRegistry.Identity | null>;
+interface BaseServerParams {
+    plugins?: PluginsContainer | PluginCollection;
+    heartbeatInterval?: number;
+    /**
+     * How long a connection may go without a message before it is closed. Keep it well above the
+     * client's ping interval.
+     */
+    staleAfter?: number;
+    debug?: boolean;
+    connectionManager?: WebsocketsConnectionManager.Interface<unknown>;
+    authenticate?: WebsocketsConnectionAuthenticator;
+}
+export interface CreateWebsocketsServerParams extends BaseServerParams {
+    port?: number;
+    host?: string;
+}
+export interface AttachWebsocketsServerParams extends BaseServerParams {
+    server: HttpServer;
+}
+export interface IWebsocketsServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    port(): number;
+}
+export {};

package/transport/ServerWebsocketsTransport.d.ts

@@ -0,0 +1,21 @@
+import { WebsocketsTransport } from "@webiny/api-websockets/exports/api.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import { Logger } from "@webiny/api-core/features/logger/abstractions.js";
+import { ProcessOwner } from "@webiny/event-handler-standalone";
+import { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+import { WebsocketsMessageBus } from "../bus/abstractions.js";
+export declare class ServerWebsocketsTransportImpl implements WebsocketsTransport.Interface {
+    private readonly connectionManager;
+    private readonly adapter;
+    private readonly bus;
+    private readonly owner;
+    private readonly logger;
+    constructor(connectionManager: WebsocketsConnectionManager.Interface<unknown>, adapter: WebsocketsServerAdapter.Interface<unknown>, bus: WebsocketsMessageBus.Interface, owner: ProcessOwner.Interface, logger: Logger.Interface);
+    send<T extends GenericRecord = GenericRecord>(connections: WebsocketsTransport.SendConnection[], data: WebsocketsTransport.SendData<T>): Promise<void>;
+    disconnect(connections: WebsocketsTransport.DisconnectConnection[]): Promise<void>;
+    private forward;
+}
+export declare const ServerWebsocketsTransport: typeof ServerWebsocketsTransportImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-websockets/transport").IWebsocketsTransport>;
+};

package/transport/ServerWebsocketsTransport.js

@@ -0,0 +1,77 @@
+import { WebsocketsTransport } from "@webiny/api-websockets/exports/api.js";
+import { Logger } from "@webiny/api-core/features/logger/abstractions.js";
+import { ProcessOwner } from "@webiny/event-handler-standalone";
+import { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+import { WebsocketsMessageBus } from "../bus/abstractions.js";
+import { sendToLocalSockets } from "../delivery/sendToLocalSockets.js";
+import { disconnectLocalSockets } from "../delivery/disconnectLocalSockets.js";
+class ServerWebsocketsTransportImpl {
+    constructor(connectionManager, adapter, bus, owner, logger){
+        this.connectionManager = connectionManager;
+        this.adapter = adapter;
+        this.bus = bus;
+        this.owner = owner;
+        this.logger = logger;
+    }
+    async send(connections, data) {
+        const connectionIds = connections.map((connection)=>connection.connectionId);
+        const missing = await sendToLocalSockets({
+            connectionManager: this.connectionManager,
+            adapter: this.adapter,
+            logger: this.logger,
+            connectionIds,
+            data
+        });
+        await this.forward(missing, (ids)=>({
+                action: "send",
+                connectionIds: ids,
+                data
+            }));
+    }
+    async disconnect(connections) {
+        const connectionIds = connections.map((connection)=>connection.connectionId);
+        const missing = await disconnectLocalSockets({
+            connectionManager: this.connectionManager,
+            adapter: this.adapter,
+            logger: this.logger,
+            connectionIds
+        });
+        await this.forward(missing, (ids)=>({
+                action: "disconnect",
+                connectionIds: ids
+            }));
+    }
+    async forward(missing, toMessage) {
+        const byOwner = await this.connectionManager.groupByOwner(missing);
+        for (const [owner, connectionIds] of byOwner){
+            if (owner === this.owner.id) {
+                for (const connectionId of connectionIds)await this.connectionManager.remove(connectionId);
+                continue;
+            }
+            const message = toMessage(connectionIds);
+            try {
+                await this.bus.publish(owner, message);
+            } catch (error) {
+                this.logger.error({
+                    error,
+                    owner,
+                    connectionIds
+                }, "[websockets] could not publish to the process holding these connections");
+            }
+        }
+    }
+}
+const ServerWebsocketsTransport = WebsocketsTransport.createImplementation({
+    implementation: ServerWebsocketsTransportImpl,
+    dependencies: [
+        WebsocketsConnectionManager,
+        WebsocketsServerAdapter,
+        WebsocketsMessageBus,
+        ProcessOwner,
+        Logger
+    ]
+});
+export { ServerWebsocketsTransport, ServerWebsocketsTransportImpl };
+
+//# sourceMappingURL=ServerWebsocketsTransport.js.map

package/transport/ServerWebsocketsTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport/ServerWebsocketsTransport.js","sources":["../../src/transport/ServerWebsocketsTransport.ts"],"sourcesContent":["import { WebsocketsTransport } from \"@webiny/api-websockets/exports/api.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/abstractions.js\";\nimport { ProcessOwner } from \"@webiny/event-handler-standalone\";\nimport { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\nimport { WebsocketsServerAdapter } from \"~/adapter/abstractions.js\";\nimport { WebsocketsMessageBus } from \"~/bus/abstractions.js\";\nimport { sendToLocalSockets } from \"~/delivery/sendToLocalSockets.js\";\nimport { disconnectLocalSockets } from \"~/delivery/disconnectLocalSockets.js\";\n\ntype ToMessage = (connectionIds: string[]) => WebsocketsMessageBus.Message;\n\n/*\n * Sends to the sockets this process holds, and hands the rest to the process that holds them, through\n * the message bus. With one process there is no rest, apart from rows a previous run of the process\n * left behind.\n */\nexport class ServerWebsocketsTransportImpl implements WebsocketsTransport.Interface {\n    public constructor(\n        private readonly connectionManager: WebsocketsConnectionManager.Interface<unknown>,\n        private readonly adapter: WebsocketsServerAdapter.Interface<unknown>,\n        private readonly bus: WebsocketsMessageBus.Interface,\n        private readonly owner: ProcessOwner.Interface,\n        private readonly logger: Logger.Interface\n    ) {}\n\n    public async send<T extends GenericRecord = GenericRecord>(\n        connections: WebsocketsTransport.SendConnection[],\n        data: WebsocketsTransport.SendData<T>\n    ): Promise<void> {\n        const connectionIds = connections.map(connection => connection.connectionId);\n        const missing = await sendToLocalSockets({\n            connectionManager: this.connectionManager,\n            adapter: this.adapter,\n            logger: this.logger,\n            connectionIds,\n            data\n        });\n        await this.forward(missing, ids => {\n            return { action: \"send\", connectionIds: ids, data };\n        });\n    }\n\n    public async disconnect(\n        connections: WebsocketsTransport.DisconnectConnection[]\n    ): Promise<void> {\n        const connectionIds = connections.map(connection => connection.connectionId);\n        const missing = await disconnectLocalSockets({\n            connectionManager: this.connectionManager,\n            adapter: this.adapter,\n            logger: this.logger,\n            connectionIds\n        });\n        await this.forward(missing, ids => {\n            return { action: \"disconnect\", connectionIds: ids };\n        });\n    }\n\n    /*\n     * Connections this process has no socket for. Its own are gone, so they are removed; another\n     * process's are published to that process. A failed publish is logged, not thrown: the message\n     * is lost, as it would be if that process were restarting.\n     */\n    private async forward(missing: string[], toMessage: ToMessage): Promise<void> {\n        const byOwner = await this.connectionManager.groupByOwner(missing);\n        for (const [owner, connectionIds] of byOwner) {\n            if (owner === this.owner.id) {\n                for (const connectionId of connectionIds) {\n                    await this.connectionManager.remove(connectionId);\n                }\n                continue;\n            }\n            const message = toMessage(connectionIds);\n            try {\n                await this.bus.publish(owner, message);\n            } catch (error) {\n                this.logger.error(\n                    { error, owner, connectionIds },\n                    \"[websockets] could not publish to the process holding these connections\"\n                );\n            }\n        }\n    }\n}\n\nexport const ServerWebsocketsTransport = WebsocketsTransport.createImplementation({\n    implementation: ServerWebsocketsTransportImpl,\n    dependencies: [\n        WebsocketsConnectionManager,\n        WebsocketsServerAdapter,\n        WebsocketsMessageBus,\n        ProcessOwner,\n        Logger\n    ]\n});\n"],"names":["ServerWebsocketsTransportImpl","connectionManager","adapter","bus","owner","logger","connections","data","connectionIds","connection","missing","sendToLocalSockets","ids","disconnectLocalSockets","toMessage","byOwner","connectionId","message","error","ServerWebsocketsTransport","WebsocketsTransport","WebsocketsConnectionManager","WebsocketsServerAdapter","WebsocketsMessageBus","ProcessOwner","Logger"],"mappings":";;;;;;;;AAiBO,MAAMA;IACT,YACqBC,iBAAiE,EACjEC,OAAmD,EACnDC,GAAmC,EACnCC,KAA6B,EAC7BC,MAAwB,CAC3C;aALmBJ,iBAAiB,GAAjBA;aACAC,OAAO,GAAPA;aACAC,GAAG,GAAHA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;IAClB;IAEH,MAAa,KACTC,WAAiD,EACjDC,IAAqC,EACxB;QACb,MAAMC,gBAAgBF,YAAY,GAAG,CAACG,CAAAA,aAAcA,WAAW,YAAY;QAC3E,MAAMC,UAAU,MAAMC,mBAAmB;YACrC,mBAAmB,IAAI,CAAC,iBAAiB;YACzC,SAAS,IAAI,CAAC,OAAO;YACrB,QAAQ,IAAI,CAAC,MAAM;YACnBH;YACAD;QACJ;QACA,MAAM,IAAI,CAAC,OAAO,CAACG,SAASE,CAAAA,MACjB;gBAAE,QAAQ;gBAAQ,eAAeA;gBAAKL;YAAK;IAE1D;IAEA,MAAa,WACTD,WAAuD,EAC1C;QACb,MAAME,gBAAgBF,YAAY,GAAG,CAACG,CAAAA,aAAcA,WAAW,YAAY;QAC3E,MAAMC,UAAU,MAAMG,uBAAuB;YACzC,mBAAmB,IAAI,CAAC,iBAAiB;YACzC,SAAS,IAAI,CAAC,OAAO;YACrB,QAAQ,IAAI,CAAC,MAAM;YACnBL;QACJ;QACA,MAAM,IAAI,CAAC,OAAO,CAACE,SAASE,CAAAA,MACjB;gBAAE,QAAQ;gBAAc,eAAeA;YAAI;IAE1D;IAOA,MAAc,QAAQF,OAAiB,EAAEI,SAAoB,EAAiB;QAC1E,MAAMC,UAAU,MAAM,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAACL;QAC1D,KAAK,MAAM,CAACN,OAAOI,cAAc,IAAIO,QAAS;YAC1C,IAAIX,UAAU,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE;gBACzB,KAAK,MAAMY,gBAAgBR,cACvB,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAACQ;gBAExC;YACJ;YACA,MAAMC,UAAUH,UAAUN;YAC1B,IAAI;gBACA,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAACJ,OAAOa;YAClC,EAAE,OAAOC,OAAO;gBACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBAAEA;oBAAOd;oBAAOI;gBAAc,GAC9B;YAER;QACJ;IACJ;AACJ;AAEO,MAAMW,4BAA4BC,oBAAoB,oBAAoB,CAAC;IAC9E,gBAAgBpB;IAChB,cAAc;QACVqB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}