cyberia 3.1.3 → 3.2.9

package/src/server/object-layer.js

@@ -34,7 +34,6 @@ const logger = loggerFactory(import.meta);
  * @property {Object<string, number[][][]>} frames - Map of direction names to arrays of frame matrices.
  * @property {Array<number[]>} colors - Global color palette shared across all frames.
  * @property {number} frame_duration - Duration of each frame in milliseconds.
- * @property {boolean} is_stateless - Whether the render layer is stateless (no animation state).
  * @memberof CyberiaObjectLayer
  */
 
@@ -414,21 +413,18 @@ export class ObjectLayerEngine {
     if (metadata && metadata.objectLayerRenderFramesData) {
       objectLayerRenderFramesData = {
         frame_duration: metadata.objectLayerRenderFramesData.frame_duration || 250,
-        is_stateless: metadata.objectLayerRenderFramesData.is_stateless || false,
         frames: {},
         colors: [],
       };
     } else if (metadata && metadata.data && metadata.data.render) {
       objectLayerRenderFramesData = {
         frame_duration: metadata.data.render.frame_duration || 250,
-        is_stateless: metadata.data.render.is_stateless || false,
         frames: {},
         colors: [],
       };
     } else {
       objectLayerRenderFramesData = {
         frame_duration: 250,
-        is_stateless: false,
         frames: {},
         colors: [],
       };
@@ -559,7 +555,7 @@ export class ObjectLayerEngine {
    * @param {string} params.itemId   - Unique item identifier.
    * @param {ObjectLayerRenderFramesData} params.objectLayerRenderFramesData
    *   - The render frames data containing `frames`, `colors`,
-   *     `frame_duration` and `is_stateless`.
+   *     and `frame_duration`.
    * @param {Object} [params.objectLayerData=null] - When provided, a
    *   `metadata.json` file is written alongside the frame PNGs.
    * @param {number} [params.cellPixelDim=20] - Pixel size per grid cell.
@@ -623,7 +619,6 @@ export class ObjectLayerEngine {
             data: objectLayerData.data,
             objectLayerRenderFramesData: {
               frame_duration: objectLayerRenderFramesData.frame_duration,
-              is_stateless: objectLayerRenderFramesData.is_stateless,
             },
             generated: true,
             generatorVersion: '1.0.0',
@@ -639,11 +634,12 @@ export class ObjectLayerEngine {
 
   /**
    * Creates new ObjectLayerRenderFrames and ObjectLayer documents in MongoDB from the
-   * provided data, computes an initial SHA-256, and optionally generates the atlas sprite sheet.
+   * provided data, with cut-over consistency: all CIDs (atlas PNG, atlas metadata, data JSON)
+   * are computed and pinned to IPFS BEFORE the ObjectLayer document is created or updated in
+   * MongoDB, so the object layer is never visible in queries with empty CIDs.
    *
-   * When `generateAtlas` is `true` (the default) the method delegates to
-   * `AtlasSpriteSheetService.generate` and then recomputes the definitive SHA-256
-   * (which now includes `data.render.cid`) and persists an IPFS CID.
+   * If an existing ObjectLayer with the same `data.item.id` is found, it is atomically
+   * replaced (findByIdAndUpdate) and the old ObjectLayerRenderFrames is cleaned up.
    *
    * @static
    * @param {Object} params - Parameters.
@@ -664,44 +660,95 @@ export class ObjectLayerEngine {
   }) {
     const { generateAtlas = true, atlasServiceContext = null } = createOptions;
 
-    // 1. Persist ObjectLayerRenderFrames
+    // 1. Persist ObjectLayerRenderFrames (not queried by the viewer table)
     const objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.create(objectLayerRenderFramesData);
 
-    // 2. Attach reference + compute temporary SHA-256
+    // 2. Set up references in memory
     objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
     if (!objectLayerData.data.render) objectLayerData.data.render = {};
-    objectLayerData.data.render.cid = objectLayerData.data.render.cid || '';
-    objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    objectLayerData.data.render.cid = '';
+    objectLayerData.data.render.metadataCid = '';
 
-    // 3. Upsert ObjectLayer (handle duplicate sha256 gracefully)
+    // 3. Stage atlas + IPFS CIDs BEFORE creating/updating the ObjectLayer
+    if (generateAtlas && atlasServiceContext) {
+      const {
+        req,
+        res,
+        options,
+        AtlasSpriteSheetService,
+        IpfsClient: ipfsClient,
+        createPinRecord,
+      } = atlasServiceContext;
+
+      try {
+        const stagingOL = {
+          data: objectLayerData.data,
+          objectLayerRenderFramesId: objectLayerRenderFramesDoc,
+        };
+        const result = await AtlasSpriteSheetService.generate(
+          { objectLayer: stagingOL, auth: req ? req.auth : undefined },
+          res,
+          options,
+          { skipObjectLayerSave: true },
+        );
+        objectLayerData.data.render.cid = result.atlasCid;
+        objectLayerData.data.render.metadataCid = result.atlasMetadataCid;
+        objectLayerData.atlasSpriteSheetId = result.atlasDoc._id;
+      } catch (atlasError) {
+        logger.error('Failed to generate atlas during staging:', atlasError);
+      }
+
+      // Compute final SHA-256 (includes render CIDs)
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+
+      // Pin data JSON to IPFS
+      if (ipfsClient) {
+        try {
+          const itemId = objectLayerData.data.item.id;
+          const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+          const ipfsResult = await ipfsClient.addJsonToIpfs(objectLayerData.data, `${itemId}_data.json`, mfsPath);
+          if (ipfsResult) {
+            objectLayerData.cid = ipfsResult.cid;
+            if (createPinRecord) {
+              await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
+            }
+          }
+        } catch (ipfsError) {
+          logger.warn('Failed to pin data JSON to IPFS:', ipfsError.message);
+        }
+      }
+    } else {
+      // No atlas generation - compute SHA-256 without render CIDs
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    }
+
+    // 4. Atomic create/upsert - ObjectLayer is fully populated with all CIDs
     let objectLayer;
-    const existingObjectLayer = await ObjectLayer.findOne({ sha256: objectLayerData.sha256 });
-    if (existingObjectLayer) {
-      logger.info(`ObjectLayer with sha256 ${objectLayerData.sha256} already exists, updating...`);
-      objectLayer = await ObjectLayer.findByIdAndUpdate(existingObjectLayer._id, objectLayerData, {
+    const existingByItemId = await ObjectLayer.findOne({ 'data.item.id': objectLayerData.data.item.id });
+    if (existingByItemId) {
+      const oldRenderFramesId = existingByItemId.objectLayerRenderFramesId;
+      logger.info(
+        `ObjectLayer for item "${objectLayerData.data.item.id}" exists (${existingByItemId._id}), replacing atomically...`,
+      );
+      objectLayer = await ObjectLayer.findByIdAndUpdate(existingByItemId._id, objectLayerData, {
         returnDocument: 'after',
       }).populate('objectLayerRenderFramesId');
+      if (oldRenderFramesId && !oldRenderFramesId.equals(objectLayerRenderFramesDoc._id)) {
+        await ObjectLayerRenderFrames.findByIdAndDelete(oldRenderFramesId);
+      }
     } else {
       objectLayer = await (await ObjectLayer.create(objectLayerData)).populate('objectLayerRenderFramesId');
       logger.info(`ObjectLayer created successfully with id: ${objectLayer._id}`);
     }
 
-    // 4. Optional atlas generation + final SHA-256 / IPFS CID
-    if (generateAtlas && atlasServiceContext) {
-      objectLayer = await ObjectLayerEngine._generateAtlasAndFinalize({
-        objectLayer,
-        ObjectLayer,
-        atlasServiceContext,
-        isNew: true,
-      });
-    }
-
     return { objectLayer, objectLayerRenderFramesDoc };
   }
 
   /**
    * Updates an existing ObjectLayer and its ObjectLayerRenderFrames from the provided data,
-   * recomputes SHA-256, and optionally regenerates the atlas sprite sheet.
+   * with cut-over consistency: a new ObjectLayerRenderFrames is created, then atlas and all
+   * CIDs are staged BEFORE the live ObjectLayer is touched. The live document is updated
+   * atomically via findByIdAndUpdate only after all CIDs are computed.
    *
    * @static
    * @param {Object} params - Parameters.
@@ -724,27 +771,75 @@ export class ObjectLayerEngine {
   }) {
     const { generateAtlas = true, atlasServiceContext = null } = updateOptions;
 
-    // 1. Update or create ObjectLayerRenderFrames
-    let objectLayerRenderFramesDoc;
+    // 1. Load existing ObjectLayer to get old references
     const existingObjectLayer = await ObjectLayer.findById(objectLayerId);
-    if (existingObjectLayer && existingObjectLayer.objectLayerRenderFramesId) {
-      objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.findByIdAndUpdate(
-        existingObjectLayer.objectLayerRenderFramesId,
-        objectLayerRenderFramesData,
-        { returnDocument: 'after' },
-      );
-      objectLayerData.objectLayerRenderFramesId = existingObjectLayer.objectLayerRenderFramesId;
-    } else {
-      objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.create(objectLayerRenderFramesData);
-      objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
+    if (!existingObjectLayer) {
+      throw new Error('ObjectLayer not found for update');
     }
+    const oldRenderFramesId = existingObjectLayer.objectLayerRenderFramesId;
+
+    // 2. Create NEW RenderFrames (avoid mutating old doc mid-update)
+    const objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.create(objectLayerRenderFramesData);
+    objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
 
-    // 2. Compute temporary SHA-256
+    // 3. Set up render CIDs
     if (!objectLayerData.data.render) objectLayerData.data.render = {};
-    objectLayerData.data.render.cid = objectLayerData.data.render.cid || '';
-    objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    objectLayerData.data.render.cid = '';
+    objectLayerData.data.render.metadataCid = '';
+
+    // 4. Stage atlas + IPFS CIDs BEFORE updating the ObjectLayer
+    if (generateAtlas && atlasServiceContext) {
+      const {
+        req,
+        res,
+        options,
+        AtlasSpriteSheetService,
+        IpfsClient: ipfsClient,
+        createPinRecord,
+      } = atlasServiceContext;
+
+      try {
+        const stagingOL = {
+          data: objectLayerData.data,
+          objectLayerRenderFramesId: objectLayerRenderFramesDoc,
+        };
+        const result = await AtlasSpriteSheetService.generate(
+          { objectLayer: stagingOL, auth: req ? req.auth : undefined },
+          res,
+          options,
+          { skipObjectLayerSave: true },
+        );
+        objectLayerData.data.render.cid = result.atlasCid;
+        objectLayerData.data.render.metadataCid = result.atlasMetadataCid;
+        objectLayerData.atlasSpriteSheetId = result.atlasDoc._id;
+      } catch (atlasError) {
+        logger.error('Failed to generate atlas during update staging:', atlasError);
+      }
+
+      // Compute final SHA-256 (includes render CIDs)
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
 
-    // 3. Persist ObjectLayer update
+      // Pin data JSON to IPFS
+      if (ipfsClient) {
+        try {
+          const itemId = objectLayerData.data.item.id;
+          const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+          const ipfsResult = await ipfsClient.addJsonToIpfs(objectLayerData.data, `${itemId}_data.json`, mfsPath);
+          if (ipfsResult) {
+            objectLayerData.cid = ipfsResult.cid;
+            if (createPinRecord) {
+              await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
+            }
+          }
+        } catch (ipfsError) {
+          logger.warn('Failed to pin data JSON to IPFS:', ipfsError.message);
+        }
+      }
+    } else {
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    }
+
+    // 5. Atomic update - ObjectLayer is fully populated with all CIDs
     let objectLayer;
     try {
       objectLayer = await ObjectLayer.findByIdAndUpdate(objectLayerId, objectLayerData, {
@@ -753,20 +848,15 @@ export class ObjectLayerEngine {
       if (!objectLayer) {
         throw new Error('ObjectLayer not found for update');
       }
-      logger.info(`ObjectLayer updated successfully with id: ${objectLayerId}`);
+      logger.info(`ObjectLayer updated atomically with id: ${objectLayerId}`);
     } catch (error) {
       logger.error('Error updating ObjectLayer:', error);
       throw error;
     }
 
-    // 4. Optional atlas generation + final SHA-256 / IPFS CID
-    if (generateAtlas && atlasServiceContext) {
-      objectLayer = await ObjectLayerEngine._generateAtlasAndFinalize({
-        objectLayer,
-        ObjectLayer,
-        atlasServiceContext,
-        isNew: false,
-      });
+    // 6. Clean up old RenderFrames
+    if (oldRenderFramesId && !oldRenderFramesId.equals(objectLayerRenderFramesDoc._id)) {
+      await ObjectLayerRenderFrames.findByIdAndDelete(oldRenderFramesId);
     }
 
     return { objectLayer, objectLayerRenderFramesDoc };
@@ -783,26 +873,22 @@ export class ObjectLayerEngine {
    * @param {Object} params.objectLayer - The mongoose ObjectLayer document (must be populated).
    * @param {Object} [params.ipfsClient=null] - The IpfsClient module; when `null`, IPFS pinning is skipped.
    * @param {function} [params.createPinRecord=null] - The `createPinRecord` helper; when `null`, pin records are skipped.
-   * @param {string} [params.userId] - Authenticated user ID for IPFS pin record creation.
    * @param {Object} [params.options] - Server options (host, path) forwarded to `createPinRecord`.
    * @returns {Promise<Object>} The saved ObjectLayer document.
    * @memberof CyberiaObjectLayer
    */
-  static async computeAndSaveFinalSha256({ objectLayer, ipfsClient = null, createPinRecord = null, userId, options }) {
+  static async computeAndSaveFinalSha256({ objectLayer, ipfsClient = null, createPinRecord = null, options }) {
     const finalSha256 = ObjectLayerEngine.computeSha256(objectLayer.data);
 
     if (ipfsClient) {
       try {
         const itemId = objectLayer.data.item.id;
-        const ipfsResult = await ipfsClient.addJsonToIpfs(
-          objectLayer.data,
-          `${itemId}_data.json`,
-          `/object-layer/${itemId}/${itemId}_data.json`,
-        );
+        const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+        const ipfsResult = await ipfsClient.addJsonToIpfs(objectLayer.data, `${itemId}_data.json`, mfsPath);
         if (ipfsResult) {
           objectLayer.cid = ipfsResult.cid;
-          if (userId && createPinRecord) {
-            await createPinRecord({ cid: ipfsResult.cid, userId, options });
+          if (createPinRecord) {
+            await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
           }
         }
       } catch (ipfsError) {
@@ -882,58 +968,8 @@ export class ObjectLayerEngine {
     );
     return { cid: `sha256:${sha256}`, sha256, source: 'sha256-fallback' };
   }
-
-  /**
-   * Internal helper that generates an atlas sprite sheet and then finalizes the SHA-256 / IPFS CID.
-   * @static
-   * @param {Object} params - Parameters.
-   * @param {Object} params.objectLayer - The mongoose ObjectLayer document.
-   * @param {Object} params.ObjectLayer - Mongoose ObjectLayer model (for re-reading).
-   * @param {Object} params.atlasServiceContext - Context with `{ req, res, options, AtlasSpriteSheetService, IpfsClient, createPinRecord }`.
-   * @param {boolean} params.isNew - Whether this is a newly created object layer (used for logging).
-   * @returns {Promise<Object>} The finalized ObjectLayer document.
-   * @memberof CyberiaObjectLayer
-   * @private
-   */
-  static async _generateAtlasAndFinalize({ objectLayer, ObjectLayer, atlasServiceContext, isNew }) {
-    const { req, res, options, AtlasSpriteSheetService, IpfsClient: ipfsClient, createPinRecord } = atlasServiceContext;
-
-    // Generate atlas sprite sheet
-    try {
-      await AtlasSpriteSheetService.generate(
-        { params: { id: objectLayer._id }, objectLayer, auth: req ? req.auth : undefined },
-        res,
-        options,
-      );
-    } catch (atlasError) {
-      logger.error(`Failed to auto-${isNew ? 'generate' : 'update'} atlas for ObjectLayer:`, atlasError);
-    }
-
-    // Re-read the objectLayer so data.render.cid is up-to-date
-    objectLayer = await ObjectLayer.findById(objectLayer._id).populate('objectLayerRenderFramesId');
-
-    // Compute definitive SHA-256 and IPFS CID
-    const userId = req && req.auth && req.auth.user ? req.auth.user._id : undefined;
-    objectLayer = await ObjectLayerEngine.computeAndSaveFinalSha256({
-      objectLayer,
-      ipfsClient: ipfsClient || null,
-      createPinRecord: createPinRecord || null,
-      userId,
-      options,
-    });
-
-    return objectLayer;
-  }
 }
 
-/**
- * Mapping of item type names to numerical IDs.
- * @constant
- * @type {{floor: number, skin: number, weapon: number, skill: number, coin: number}}
- * @memberof CyberiaObjectLayer
- */
-export const itemTypes = { floor: 0, skin: 1, weapon: 2, skill: 3, coin: 4 };
-
 // ──────────────────────────────────────────────────────────────────────────
 // Backward-compatible named exports matching the original destructured imports.
 // ──────────────────────────────────────────────────────────────────────────

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/process.js

@@ -4,35 +4,30 @@
  * @module src/server/process.js
  * @namespace Process
  */
-
 // https://nodejs.org/api/process
-
 import shell from 'shelljs';
 import { loggerFactory } from './logger.js';
 import clipboard from 'clipboardy';
 import Underpost from '../index.js';
 import { getNpmRootPath } from './conf.js';
-
 const logger = loggerFactory(import.meta);
-
 /**
  * Gets the current working directory, replacing backslashes with forward slashes for consistency.
  * @memberof Process
  * @returns {string} The root directory path.
  */
 const getRootDirectory = () => process.cwd().replace(/\\/g, '/');
-
 /**
  * Controls and manages process-level events and signals.
  * @namespace ProcessController
  */
-const ProcessController = {
+class ProcessController {
   /**
    * List of signals to listen for for graceful shutdown/handling.
    * @memberof ProcessController
    * @type {string[]}
    */
-  SIG: [
+  static SIG = [
     'SIGPIPE',
     'SIGHUP',
     'SIGTERM',
@@ -45,29 +40,26 @@ const ProcessController = {
     'SIGFPE',
     'SIGSEGV',
     'SIGILL',
-  ],
-
+  ];
   /**
    * Sets up listeners for various process signals defined in {@link ProcessController.SIG}.
    * Handles graceful exit on 'SIGINT' (Ctrl+C).
    * @memberof ProcessController
    * @returns {Array<process.Process>} An array of process listener handles.
    */
-  onSigListen: function () {
-    return this.SIG.map((sig) =>
+  static onSigListen() {
+    return ProcessController.SIG.map((sig) =>
       process.on(sig, (...args) => {
-        this.logger.info(`process on ${sig}`, args);
+        ProcessController.logger.info(`process on ${sig}`, args);
         switch (sig) {
           case 'SIGINT':
             return process.exit();
-
           default:
             break;
         }
       }),
     );
-  },
-
+  }
   /**
    * Initializes the ProcessController.
    * Sets up signal listeners, registers a listener for the 'exit' event, and cleans up temporary deployment environment variables.
@@ -75,16 +67,15 @@ const ProcessController = {
    * @param {Object} logger - The logger instance to use for internal logging.
    * @returns {void}
    */
-  init: function (logger) {
-    this.logger = logger;
+  static init(logger) {
+    ProcessController.logger = logger;
     process.on('exit', (...args) => {
-      this.logger.info(`process on exit`, args);
+      ProcessController.logger.info(`process on exit`, args);
     });
-    this.onSigListen();
+    ProcessController.onSigListen();
     Underpost.env.delete('await-deploy');
-  },
-};
-
+  }
+}
 /**
  * Executes a shell command using shelljs.
  * @memberof Process
@@ -105,7 +96,6 @@ const shellExec = (
   if (options.callback) return shell.exec(cmd, options, options.callback);
   return options.stdout ? shell.exec(cmd, options).stdout : shell.exec(cmd, options);
 };
-
 /**
  * Changes the current working directory using shelljs.
  * @memberof Process
@@ -118,7 +108,6 @@ const shellCd = (cd, options = { disableLog: false }) => {
   if (!options.disableLog) logger.info(`cd`, cd);
   return shell.cd(cd);
 };
-
 /**
  * Wraps a command to run it as a daemon process in a shell (keeping the process alive/terminal open).
  * @memberof Process
@@ -126,7 +115,6 @@ const shellCd = (cd, options = { disableLog: false }) => {
  * @returns {string} The shell command string for the daemon process.
  */
 const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
-
 /**
  * Retrieves the process ID (PID) of the most recently created gnome-terminal instance.
  * Note: This function is environment-specific (GNOME/Linux) and uses `pgrep -n`.
@@ -136,7 +124,6 @@ const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
 // list all terminals: pgrep gnome-terminal
 // list last terminal: pgrep -n gnome-terminal
 const getTerminalPid = () => JSON.parse(shellExec(`pgrep -n gnome-terminal`, { stdout: true, silent: true }));
-
 /**
  * Copies text content to the system clipboard using clipboardy.
  * Logs the copied content for confirmation.
@@ -148,5 +135,4 @@ function pbcopy(data) {
   clipboard.writeSync(data || '🦄');
   logger.info(`copied to clipboard`, clipboard.readSync());
 }
-
 export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, getTerminalPid, daemonProcess };

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;
       }