underpost 3.1.2 → 3.2.0

package/src/server/client-formatted.js

@@ -1,87 +1,139 @@
 /**
- * Module for formatting client-side code
+ * Module for formatting client-side code using esbuild for import rewriting and minification.
  * @module src/server/client-formatted.js
  * @namespace clientFormatted
  */
 
 'use strict';
 
+import * as esbuild from 'esbuild';
+import fs from 'fs-extra';
+import * as path from 'path';
+
+/**
+ * Escapes a string for safe use inside a RegExp.
+ * @param {string} s - The string to escape.
+ * @returns {string} The escaped string.
+ * @memberof clientFormatted
+ */
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
 /**
- * Formats a source code string by removing 'html`' and 'css`' tags from template literals.
+ * Formats a source code string by removing 'html`' and 'css`' tagged template prefixes.
+ * Used for SSR VM execution where the full esbuild pipeline is not needed.
  * @param {string} src - The source code string.
  * @returns {string} The formatted source code.
  * @memberof clientFormatted
  */
-const srcFormatted = (src) =>
-  src
-    .replaceAll(' html`', '`')
-    .replaceAll(' css`', '`')
-    .replaceAll('{html`', '{`')
-    .replaceAll('{css`', '{`')
-    .replaceAll('(html`', '(`')
-    .replaceAll('(css`', '(`')
-    .replaceAll('[html`', '[`')
-    .replaceAll('[css`', '[`');
+const srcFormatted = (src) => src.replace(/(?<=[\s({[,;=+!?:^])(html|css)`/g, '`');
 
 /**
  * Converts a JavaScript object into a string that can be embedded in client-side code
  * and parsed back into an object (e.g., 'JSON.parse(`{...}`)').
+ * Escapes backticks and template expression markers for safe template literal embedding.
  * @param {*} data - The data to be stringified.
  * @returns {string} A string representing the code to parse the JSON data.
  * @memberof clientFormatted
  */
-const JSONweb = (data) => 'JSON.parse(`' + JSON.stringify(data) + '`)';
+const JSONweb = (data) => {
+  const json = JSON.stringify(data).replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+  return 'JSON.parse(`' + json + '`)';
+};
 
 /**
- * Formats a component's source code by rewriting its import paths to be absolute for browser consumption.
- * @param {string} src - The source code of the component.
- * @param {string} module - The name of the module/component.
- * @param {Array<object>} dists - An array of distribution objects with import names.
- * @param {string} proxyPath - The proxy path for the application.
- * @param {string} [componentBasePath=''] - The base path for components.
- * @param {string} [baseHost=''] - The base host URL.
- * @returns {string} The formatted source code with updated import paths.
+ * Creates an esbuild plugin that rewrites import paths for browser consumption.
+ * Handles dist library imports, relative imports, and marks all remaining imports as external.
+ * @param {object} options
+ * @param {Array<object>} [options.dists=[]] - Distribution objects with import_name and import_name_build.
+ * @param {string} options.proxyPath - The proxy path for the application.
+ * @param {string} [options.basePath=''] - The base path for the module type (e.g., 'components', 'services').
+ * @param {string} [options.module=''] - The module/component name for relative import resolution.
+ * @param {string} [options.baseHost=''] - The base host URL.
+ * @returns {import('esbuild').Plugin}
  * @memberof clientFormatted
  */
-const componentFormatted = (src, module, dists, proxyPath, componentBasePath = '', baseHost = '') => {
-  dists.map(
-    (dist) =>
-      (src = src.replaceAll(
-        `from '${dist.import_name}'`,
-        `from '${baseHost}${proxyPath !== '/' ? `${proxyPath}` : ''}${dist.import_name_build}'`,
-      )),
-  );
-  return src
-    .replaceAll(
-      `from '../`,
-      `from '${baseHost}${proxyPath !== '/' ? `${proxyPath}/` : '/'}${
-        componentBasePath === '' ? `` : `${componentBasePath}/`
-      }`,
-    )
-    .replaceAll(
-      `from './`,
-      `from '${baseHost}${proxyPath !== '/' ? `${proxyPath}/` : '/'}${
-        componentBasePath === '' ? `` : `${componentBasePath}/`
-      }${module}/`,
-    );
-};
+const importRewritePlugin = ({ dists = [], proxyPath, basePath = '', module = '', baseHost = '' }) => ({
+  name: 'import-rewrite',
+  setup(build) {
+    const prefix = `${baseHost}${proxyPath !== '/' ? `${proxyPath}/` : '/'}`;
+
+    // Rewrite dist library imports (e.g., '@neodrag/vanilla' → '/proxyPath/dist/@neodrag-vanilla/index.js')
+    if (dists) {
+      for (const dist of dists) {
+        if (!dist.import_name) continue;
+        const filter = new RegExp(`^${escapeRegExp(dist.import_name)}$`);
+        build.onResolve({ filter }, () => ({
+          path: `${baseHost}${proxyPath !== '/' ? proxyPath : ''}${dist.import_name_build}`,
+          external: true,
+        }));
+      }
+    }
+
+    // Rewrite relative imports to absolute paths based on proxy path and module
+    build.onResolve({ filter: /^\.\.?\// }, (args) => {
+      const basePrefix = `${prefix}${basePath ? `${basePath}/` : ''}`;
+      if (args.path.startsWith('./')) {
+        return {
+          path: `${basePrefix}${module ? `${module}/` : ''}${args.path.slice(2)}`,
+          external: true,
+        };
+      }
+      if (args.path.startsWith('../')) {
+        return {
+          path: `${basePrefix}${args.path.slice(3)}`,
+          external: true,
+        };
+      }
+    });
+
+    // Mark any remaining imports as external
+    build.onResolve({ filter: /.*/ }, (args) => {
+      if (args.kind === 'entry-point') return;
+      return { path: args.path, external: true };
+    });
+  },
+});
 
 /**
- * Formats a view's source code by rewriting its import paths.
- * @param {string} src - The source code of the view.
- * @param {Array<object>} dists - An array of distribution objects with import names.
- * @param {string} proxyPath - The proxy path for the application.
- * @param {string} [baseHost=''] - The base host URL.
- * @returns {string} The formatted source code with updated import paths.
+ * Transforms a JavaScript source file using esbuild with import path rewriting,
+ * tagged template stripping, and optional minification.
+ * Replaces the previous srcFormatted + componentFormatted/viewFormatted + UglifyJS pipeline.
+ * @param {string} srcPath - Path to the source file.
+ * @param {object} options
+ * @param {Array<object>} [options.dists=[]] - Distribution objects with import names.
+ * @param {string} options.proxyPath - The proxy path for the application.
+ * @param {string} [options.basePath=''] - Base path for the module type (e.g., 'components', 'services').
+ * @param {string} [options.module=''] - Module name for relative import resolution.
+ * @param {string} [options.baseHost=''] - Base host URL.
+ * @param {boolean} [options.minify=false] - Whether to minify the output.
+ * @returns {Promise<string>} The transformed source code.
  * @memberof clientFormatted
  */
-const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
-  dists.map(
-    (dist) =>
-      (src = src.replaceAll(dist.import_name, `${proxyPath !== '/' ? `${proxyPath}` : ''}${dist.import_name_build}`)),
-  );
-  const componentFromFormatted = `from '${baseHost}${proxyPath !== '/' ? `${proxyPath}/` : '/'}`;
-  return src.replaceAll(`from './`, componentFromFormatted).replaceAll(`from '../`, componentFromFormatted);
+const transformClientJs = async (
+  srcPath,
+  { dists = [], proxyPath, basePath = '', module = '', baseHost = '', minify: shouldMinify = false } = {},
+) => {
+  const src = fs.readFileSync(srcPath, 'utf8');
+  const stripped = srcFormatted(src);
+
+  const result = await esbuild.build({
+    stdin: {
+      contents: stripped,
+      loader: 'js',
+      resolveDir: path.dirname(path.resolve(srcPath)),
+      sourcefile: srcPath,
+    },
+    bundle: true,
+    write: false,
+    format: 'esm',
+    platform: 'browser',
+    target: 'esnext',
+    minify: shouldMinify,
+    logLevel: 'warning',
+    plugins: [importRewritePlugin({ dists, proxyPath, basePath, module, baseHost })],
+  });
+
+  return result.outputFiles[0].text;
 };
 
-export { srcFormatted, JSONweb, componentFormatted, viewFormatted };
+export { srcFormatted, JSONweb, transformClientJs };

package/src/server/conf.js

@@ -1275,18 +1275,6 @@ const awaitDeployMonitor = async (init = false, deltaMs = 1000) => {
   if (Underpost.env.get('await-deploy')) return await awaitDeployMonitor();
 };
 
-/**
- * @method getCronBackUpFolder
- * @description Gets the cron back up folder.
- * @param {string} host - The host.
- * @param {string} path - The path.
- * @returns {string} - The cron back up folder.
- * @memberof ServerConfBuilder
- */
-const getCronBackUpFolder = (host = '', path = '') => {
-  return `${host}${path.replace(/\\/g, '/').replace(`/`, '-')}`;
-};
-
 /**
  * @method mergeFile
  * @description Merges the file.
@@ -1499,8 +1487,25 @@ const buildCliDoc = (program, oldVersion, newVersion) => {
   md = md.replaceAll(oldVersion, newVersion);
   fs.writeFileSync(`./src/client/public/nexodev/docs/references/Command Line Interface.md`, md, 'utf8');
   fs.writeFileSync(`./CLI-HELP.md`, md, 'utf8');
-  const readme = fs.readFileSync(`./README.md`, 'utf8');
-  fs.writeFileSync('./README.md', readme.replaceAll(oldVersion, newVersion), 'utf8');
+
+  // Update README.md: replace version and CLI index section between comment tags
+  let readme = fs.readFileSync(`./README.md`, 'utf8');
+  readme = readme.replaceAll(oldVersion, newVersion);
+  const cliStartTag = '<!-- cli-index-start -->';
+  const cliEndTag = '<!-- cli-index-end -->';
+  const startIdx = readme.indexOf(cliStartTag);
+  const endIdx = readme.indexOf(cliEndTag);
+  if (startIdx !== -1 && endIdx !== -1) {
+    readme =
+      readme.substring(0, startIdx) +
+      cliStartTag +
+      '\n' +
+      baseOptions +
+      '\n' +
+      cliEndTag +
+      readme.substring(endIdx + cliEndTag.length);
+  }
+  fs.writeFileSync('./README.md', readme, 'utf8');
 };
 
 /**
@@ -1743,7 +1748,6 @@ export {
   getDataDeploy,
   validateTemplatePath,
   buildReplicaId,
-  getCronBackUpFolder,
   mergeFile,
   getPathsSSR,
   buildKindPorts,

package/src/server/ipfs-client.js

@@ -244,7 +244,11 @@ const unpinCid = async (cid) => {
     });
     if (!clusterRes.ok) {
       const text = await clusterRes.text();
-      logger.warn(`IPFS Cluster unpin failed (${clusterRes.status}): ${text}`);
+      if (clusterRes.status === 404) {
+        logger.info(`IPFS Cluster unpin – CID already not pinned: ${cid}`);
+      } else {
+        logger.warn(`IPFS Cluster unpin failed (${clusterRes.status}): ${text}`);
+      }
     } else {
       logger.info(`IPFS Cluster unpin OK – CID: ${cid}`);
     }
@@ -428,6 +432,25 @@ const IpfsClient = {
   listClusterPins,
   listKuboPins,
   removeMfsPath,
+  /**
+   * Check whether a single CID is currently pinned on the local Kubo node.
+   * Uses the pin/ls?arg=<cid> endpoint which returns only that one pin
+   * (much cheaper than fetching the full list).
+   *
+   * @param {string} cid - IPFS Content Identifier to check.
+   * @returns {Promise<boolean>} true when the CID is pinned.
+   */
+  isCidPinned: async (cid) => {
+    const kuboUrl = getIpfsApiUrl();
+    try {
+      const res = await fetch(`${kuboUrl}/api/v0/pin/ls?arg=${encodeURIComponent(cid)}&type=all`, { method: 'POST' });
+      if (!res.ok) return false;
+      const json = await res.json();
+      return !!(json.Keys && json.Keys[cid]);
+    } catch {
+      return false;
+    }
+  },
 };
 
 export { IpfsClient };

package/src/server/peer.js

@@ -44,6 +44,14 @@ const logger = loggerFactory(import.meta);
  */
 const createPeerServer = async ({ port, origins, path }) => {
   logger.info('origins', origins);
+
+  // In development, allow the local client origin (peer runs on port+1 relative to the client)
+  if (process.env.NODE_ENV === 'development') {
+    const clientPort = port - 1;
+    const devOrigin = `http://localhost:${clientPort}`;
+    if (!origins.includes(devOrigin)) origins.push(devOrigin);
+  }
+
   /** @type {import('peer').IConfig} */
   const options = {
     port,

package/src/server/runtime.js

@@ -11,6 +11,7 @@ import * as promClient from 'prom-client';
 import { loggerFactory } from './logger.js';
 import { newInstance } from '../client/components/core/CommonJs.js';
 import { Lampp } from '../runtime/lampp/Lampp.js';
+import { WpService } from '../runtime/wp/Wp.js';
 import { getInstanceContext, readConfJson } from './conf.js';
 
 import ExpressService from '../runtime/express/Express.js';
@@ -71,6 +72,9 @@ const buildRuntime = async () => {
         valkey,
         apiBaseHost,
         useLocalSsl,
+        grpc,
+        repository,
+        wp,
       } = confServer[host][path];
 
       // Calculate context data
@@ -116,6 +120,7 @@ const buildRuntime = async () => {
             peer,
             valkey,
             apiBaseHost,
+            grpc,
             redirectTarget,
             rootHostPath,
             confSSR,
@@ -129,7 +134,7 @@ const buildRuntime = async () => {
 
         case 'lampp':
           {
-            const { disabled } = await Lampp.createApp({
+            const { disabled } = Lampp.createApp({
               port,
               host,
               path,
@@ -143,6 +148,25 @@ const buildRuntime = async () => {
             await Underpost.start.listenPortController(Underpost.start.listenServerFactory(), port, runningData);
           }
           break;
+
+        case 'wp':
+          {
+            const { disabled } = WpService.createApp({
+              port,
+              host,
+              pathRoute: path,
+              repository,
+              db,
+              wp,
+              redirect,
+              redirectTarget,
+              resetRouter: currentPort === initPort,
+            });
+            if (disabled) continue;
+            await Underpost.start.listenPortController(Underpost.start.listenServerFactory(), port, runningData);
+          }
+          break;
+
         default:
           break;
       }

package/src/server/start.js

@@ -9,6 +9,7 @@ import { awaitDeployMonitor } from './conf.js';
 import { actionInitLog, loggerFactory } from './logger.js';
 import { shellCd, shellExec } from './process.js';
 import Underpost from '../index.js';
+import isInsideContainer from 'is-inside-container';
 const logger = loggerFactory(import.meta);
 
 /**
@@ -147,18 +148,25 @@ class UnderpostStartUp {
      * @param {string} deployId - The ID of the deployment.
      * @param {string} env - The environment of the deployment.
      * @param {Object} options - Options for the build.
+     * @param {boolean} options.skipPullBase - Whether to skip pulling the base code and use the current workspace code directly.
      * @param {boolean} options.underpostQuicklyInstall - Whether to use underpost quickly install.
      * @memberof UnderpostStartUp
      */
-    async build(deployId = 'dd-default', env = 'development', options = { underpostQuicklyInstall: false }) {
+    async build(
+      deployId = 'dd-default',
+      env = 'development',
+      options = { underpostQuicklyInstall: false, skipPullBase: false },
+    ) {
       const buildBasePath = `/home/dd`;
       const repoName = `engine-${deployId.split('-')[1]}`;
-      shellExec(`cd ${buildBasePath} && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
-      shellExec(`mkdir -p ${buildBasePath}/engine`);
-      shellExec(`cd ${buildBasePath} && sudo cp -a ./${repoName}/. ./engine`);
-      shellExec(`cd ${buildBasePath} && sudo rm -rf ./${repoName}`);
-      shellExec(`cd ${buildBasePath}/engine && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}-private`);
-      shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      if (!options.skipPullBase) {
+        shellExec(`cd ${buildBasePath} && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
+        shellExec(`mkdir -p ${buildBasePath}/engine`);
+        shellExec(`cd ${buildBasePath} && sudo cp -a ./${repoName}/. ./engine`);
+        shellExec(`cd ${buildBasePath} && sudo rm -rf ./${repoName}`);
+        shellExec(`cd ${buildBasePath}/engine && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}-private`);
+        shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      }
       shellCd(`${buildBasePath}/engine`);
       shellExec(options?.underpostQuicklyInstall ? `underpost install` : `npm install`);
       shellExec(`node bin env ${deployId} ${env}`);
@@ -167,7 +175,7 @@ class UnderpostStartUp {
         for (const itcScript of itcScripts)
           if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
       }
-      await Underpost.repo.client(deployId);
+      shellExec(`node bin client ${deployId}`);
     },
     /**
      * Runs a deployment.
@@ -191,6 +199,11 @@ class UnderpostStartUp {
       shellExec(`npm ${runCmd} ${deployId}`, { async: true });
       await awaitDeployMonitor(true);
       Underpost.env.set('container-status', `${deployId}-${env}-running-deployment`);
+      if (env === 'production' && isInsideContainer()) {
+        Underpost.env.clean();
+        shellExec(`sudo rm -rf /home/dd/engine/engine-private`);
+        if (fs.existsSync('/etc/config/.env.production')) fs.removeSync('/etc/config/.env.production');
+      }
     },
   };
 }

package/src/ws/IoInterface.js

@@ -126,13 +126,4 @@ class IoChannel {
   }
 }
 
-/**
- * Backward compatibility function to create a new channel instance.
- * @memberof SocketIoInterface
- * @function IoCreateChannel
- * @param {ChannelInterface} IoInterface - The interface object defining the channel's behavior.
- * @returns {IoChannel} An instance of the IoChannel class.
- */
-const IoCreateChannel = (IoInterface) => new IoChannel(IoInterface);
-
-export { IoChannel, IoCreateChannel };
+export { IoChannel };

package/src/ws/IoServer.js

@@ -1,7 +1,6 @@
 /**
  * Module for creating and managing WebSocket servers.
- * @module src/ws/IoServer
- * @namespace SocketIoServer
+ * @module ws/IoServer
  */
 
 'use strict';
@@ -9,33 +8,27 @@
 import { Server } from 'socket.io';
 import { loggerFactory } from '../server/logger.js';
 import Underpost from '../index.js';
-import http from 'http';
 
 const logger = loggerFactory(import.meta);
 
 /**
- * @class IoServerClass
- * @alias IoServerClass
- * @memberof SocketIoServer
- * @classdesc Provides a static factory method to create and configure a Socket.IO server,
- * encapsulating WebSocket server initialization logic and CORS configuration.
+ * @class IoServer
+ * @classdesc Factory for creating and configuring Socket.IO server instances
+ * with CORS configuration and HTTP server attachment.
  */
-class IoServerClass {
+class IoServer {
   /**
    * Creates a new WebSocket server instance attached to an HTTP server.
    *
    * @static
-   * @param {http.Server} httpServer - The HTTP server instance to attach the WebSocket server to.
-   * @param {Object} options - Configuration options for the WebSocket server.
-   * @param {string[]} options.origins - List of allowed origins for Cross-Origin Resource Sharing (CORS).
-   * @param {string} options.path - The base path for the API. The WebSocket path ('/socket.io') will be appended to this.
-   * @param {function(import('socket.io').Socket): void} ConnectionHandler - The connection handler function to be executed on a new connection.
-   * @returns {Object} An object containing the final options and the server instance.
-   * @returns {import('socket.io').ServerOptions} return.options - The final options object used to create the WebSocket server.
-   * @returns {import('socket.io').Server} return.ioServer - The created and listening WebSocket server instance.
-   * @returns {object} return.meta - The module's import meta object (`import.meta`).
+   * @param {import('http').Server} httpServer - The HTTP server instance to attach to.
+   * @param {Object} options - Configuration options.
+   * @param {string[]} options.origins - Allowed CORS origins.
+   * @param {string} options.path - Base API path. Socket.IO path is appended automatically.
+   * @param {function(import('socket.io').Socket): void} connectionHandler - Handler for new connections.
+   * @returns {{ options: import('socket.io').ServerOptions, ioServer: import('socket.io').Server, meta: ImportMeta }}
    */
-  static create(httpServer, options = {}, ConnectionHandler = () => {}) {
+  static create(httpServer, options = {}, connectionHandler = () => {}) {
     logger.info('origins', options.origins);
     const wsOptions = {
       cors: {
@@ -55,12 +48,11 @@ class IoServerClass {
         ],
         credentials: true,
       },
-      // Ensure the path ends correctly, appending '/socket.io/'
       path: options.path !== '/' ? `${options.path}/socket.io/` : '/socket.io/',
     };
 
     const ioServerInstance = Underpost.start.listenServerFactory(() =>
-      new Server(httpServer, wsOptions).on('connection', ConnectionHandler),
+      new Server(httpServer, wsOptions).on('connection', connectionHandler),
     );
 
     logger.info('Socket.IO Server created and listening', { path: wsOptions.path });
@@ -73,15 +65,4 @@ class IoServerClass {
   }
 }
 
-/**
- * Backward compatibility export for the server creation function.
- * @memberof SocketIoServer
- * @function IoServer
- * @param {http.Server} httpServer - The HTTP server instance.
- * @param {Object} options - Configuration options.
- * @param {function(import('socket.io').Socket): void} ConnectionHandler - The connection handler function.
- * @returns {Object} The server configuration object.
- */
-const IoServer = IoServerClass.create;
-
-export { IoServerClass, IoServer };
+export { IoServer };

package/src/ws/core/channels/core.ws.chat.js

@@ -1,23 +1,68 @@
-import { loggerFactory } from '../../../server/logger.js';
-import { IoCreateChannel } from '../../IoInterface.js';
-import { CoreWsEmit } from '../core.ws.emit.js';
-
-const channel = 'chat';
-const logger = loggerFactory(import.meta);
-
-const CoreWsChatController = {
-  channel,
-  controller: function (socket, client, payload, wsManagementId) {
-    for (const socketId of Object.keys(client)) {
-      if (socketId !== socket.id) {
-        CoreWsEmit(channel, client[socketId], { id: socket.id, ...payload });
+/**
+ * Chat WebSocket channel — broadcasts messages to all connected sockets except the sender.
+ * @module ws/core/channels/core.ws.chat
+ */
+
+import { IoChannel } from '../../IoInterface.js';
+import { CoreWsEmitter } from '../core.ws.emit.js';
+
+/**
+ * @class CoreWsChatChannel
+ * @classdesc Manages the chat WebSocket channel with per-instance state.
+ * Broadcasts incoming messages to all other connected sockets.
+ */
+class CoreWsChatChannel {
+  /** @type {Object.<string, Object>} Per-instance state keyed by wsManagementId. */
+  static #state = {};
+
+  /** @type {IoChannel} */
+  static #io = new IoChannel({
+    channel: 'chat',
+    controller(socket, client, payload, wsManagementId) {
+      for (const socketId of Object.keys(client)) {
+        if (socketId !== socket.id) {
+          CoreWsEmitter.emit('chat', client[socketId], { id: socket.id, ...payload });
+        }
       }
-    }
-  },
-  connection: function (socket, client, wsManagementId) {},
-  disconnect: function (socket, client, reason, wsManagementId) {},
-};
+    },
+  });
+
+  /** @returns {Object.<string, import('socket.io').Socket>} Connected sockets map. */
+  static get client() {
+    return this.#io.client;
+  }
+
+  /** @returns {string} Channel name. */
+  static get channel() {
+    return this.#io.channel;
+  }
+
+  /**
+   * Initializes state for a server instance.
+   * @param {string} wsManagementId - Unique server context ID.
+   */
+  static init(wsManagementId) {
+    this.#state[wsManagementId] = {};
+  }
+
+  /**
+   * Registers a socket connection.
+   * @param {import('socket.io').Socket} socket
+   * @param {string} wsManagementId
+   */
+  static connection(socket, wsManagementId) {
+    return this.#io.connection(socket, wsManagementId);
+  }
 
-const CoreWsChatChannel = IoCreateChannel(CoreWsChatController);
+  /**
+   * Handles socket disconnection.
+   * @param {import('socket.io').Socket} socket
+   * @param {string} reason
+   * @param {string} wsManagementId
+   */
+  static disconnect(socket, reason, wsManagementId) {
+    return this.#io.disconnect(socket, reason, wsManagementId);
+  }
+}
 
-export { CoreWsChatChannel, CoreWsChatController };
+export { CoreWsChatChannel };