cyberia 3.2.9 → 3.2.22

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.router.js

@@ -4,39 +4,44 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const AtlasSpriteSheetRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(
-    `/generate/:id`,
-    authMiddleware,
-    async (req, res) => await AtlasSpriteSheetController.generate(req, res, options),
-  );
-  router.delete(
-    `/object-layer/:id`,
-    authMiddleware,
-    async (req, res) => await AtlasSpriteSheetController.deleteByObjectLayerId(req, res, options),
-  );
-  router.post(`/:id`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
-  router.get(`/blob/:itemKey`, async (req, res) => await AtlasSpriteSheetController.blob(req, res, options));
-  // Metadata endpoints: returns itemKey, atlasWidth, atlasHeight, cellPixelDim, frames (no fileId).
-  // Client fetches /metadata/:itemKey once, caches it, then fetches /blob/:itemKey for the PNG.
-  router.get(`/metadata/:itemKey`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
-  router.get(`/metadata`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
-  router.get(
-    `/:id`,
-    // authMiddleware,
-    async (req, res) => await AtlasSpriteSheetController.get(req, res, options),
-  );
-  router.get(`/`, async (req, res) => await AtlasSpriteSheetController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
-  router.put(`/`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
-  router.delete(`/:id`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
-  router.delete(`/`, authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
-  return router;
-};
+class AtlasSpriteSheetRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(
+      `/generate/:id`,
+      options.authMiddleware,
+      async (req, res) => await AtlasSpriteSheetController.generate(req, res, options),
+    );
+    router.delete(
+      `/object-layer/:id`,
+      options.authMiddleware,
+      async (req, res) => await AtlasSpriteSheetController.deleteByObjectLayerId(req, res, options),
+    );
+    router.post(`/:id`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.post(req, res, options));
+    router.get(`/blob/:itemKey`, async (req, res) => await AtlasSpriteSheetController.blob(req, res, options));
+    // Metadata endpoints: returns itemKey, atlasWidth, atlasHeight, cellPixelDim, frames (no fileId).
+    // Client fetches /metadata/:itemKey once, caches it, then fetches /blob/:itemKey for the PNG.
+    router.get(`/metadata/:itemKey`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
+    router.get(`/metadata`, async (req, res) => await AtlasSpriteSheetController.getMetadata(req, res, options));
+    router.get(
+      `/:id`,
+      // options.authMiddleware,
+      async (req, res) => await AtlasSpriteSheetController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await AtlasSpriteSheetController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.put(req, res, options));
+    router.delete(`/:id`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, async (req, res) => await AtlasSpriteSheetController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = AtlasSpriteSheetRouter;
+const ApiRouter = (options) => AtlasSpriteSheetRouter.router(options);
 
 export { ApiRouter, AtlasSpriteSheetRouter };

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
 import { AtlasSpriteSheetGenerator } from '../../server/atlas-sprite-sheet-generator.js';
@@ -55,9 +55,9 @@ class AtlasSpriteSheetService {
   static blob = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     const itemKey = req.params.itemKey;
     const atlasDoc = await AtlasSpriteSheet.findOne({ 'metadata.itemKey': itemKey }).lean();
@@ -70,12 +70,12 @@ class AtlasSpriteSheetService {
   };
   static generate = async (req, res, options, generateOptions = {}) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
 
     let objectLayer = req.objectLayer;
 
@@ -195,12 +195,12 @@ class AtlasSpriteSheetService {
   };
   static deleteByObjectLayerId = async (req, res, options) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
 
     const objectLayer = await ObjectLayer.findById(req.params.id);
     if (!objectLayer) {
@@ -255,13 +255,13 @@ class AtlasSpriteSheetService {
   static post = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     return await new AtlasSpriteSheet(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     if (req.params.id)
       return await AtlasSpriteSheet.findById(req.params.id)
         .select(AtlasSpriteSheetDto.select.get())
@@ -287,10 +287,10 @@ class AtlasSpriteSheetService {
   // Client fetches this once per itemKey, caches it, then fetches the PNG blob.
   static getMetadata = async (req, res, options) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
-    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    const ObjectLayer = DataBaseProviderService.getModel("ObjectLayer", options);
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
 
     if (req.params.itemKey) {
       const doc = await AtlasSpriteSheet.findOne({ 'metadata.itemKey': req.params.itemKey })
@@ -329,15 +329,15 @@ class AtlasSpriteSheetService {
   static put = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     return await AtlasSpriteSheet.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
+      DataBaseProviderService.getModel("AtlasSpriteSheet", options);
     /** @type {import('../file/file.model.js').FileModel} */
-    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    const File = DataBaseProviderService.getModel("File", options);
 
     if (req.params.id) {
       const atlasDoc = await AtlasSpriteSheet.findById(req.params.id);

package/src/api/core/core.router.js

@@ -5,20 +5,25 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const CoreRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-  router.post(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-  router.get(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-  router.get(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-  router.put(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-  router.put(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-  router.delete(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-  router.delete(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-  return router;
-};
+class CoreRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
+    router.get(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
+    router.get(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
+    router.put(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
+    router.put(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
+    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
+    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CoreRouter;
+const ApiRouter = (options) => CoreRouter.router(options);
 
 export { ApiRouter, CoreRouter };

package/src/api/core/core.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { shellExec } from '../../server/process.js';
 
@@ -7,22 +7,22 @@ const logger = loggerFactory(import.meta);
 class CoreService {
   static post = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await new Core(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await Core.findById(req.params.id);
   };
   static put = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await Core.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
+    const Core = DataBaseProviderService.getModel("Core", options);
     return await Core.findByIdAndDelete(req.params.id);
   };
 }

package/src/api/crypto/crypto.router.js

@@ -1,20 +1,26 @@
 import { loggerFactory } from '../../server/logger.js';
 import { CryptoController } from './crypto.controller.js';
 import express from 'express';
+
 const logger = loggerFactory(import.meta);
 
-const CryptoRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
-  router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
-  router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
-  router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
-  router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
-  return router;
-};
+class CryptoRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
+    router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
+    router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
+    router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
+    router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CryptoRouter;
+const ApiRouter = (options) => CryptoRouter.router(options);
 
 export { ApiRouter, CryptoRouter };

package/src/api/crypto/crypto.service.js

@@ -1,14 +1,14 @@
 import { loggerFactory } from '../../server/logger.js';
 import crypto from 'crypto';
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 const logger = loggerFactory(import.meta);
 
 class CryptoService {
   static post = async (req, res, options) => {
     /** @type {import('./crypto.model.js').CryptoModel} */
-    const Crypto = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Crypto;
+    const Crypto = DataBaseProviderService.getModel("Crypto", options);
     /** @type {import('../user/user.model.js').UserModel} */
-    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+    const User = DataBaseProviderService.getModel("User", options);
 
     switch (req.params.id) {
       case 'verify': {

package/src/api/cyberia-action/cyberia-action.model.js

@@ -1,5 +1,5 @@
 import { Schema, model } from 'mongoose';
-import { CYBERIA_ACTION_TYPES } from '../../client/components/cyberia-portal/CommonCyberiaPortal.js';
+import { CYBERIA_ACTION_TYPES } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
 
 // https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
 

package/src/api/cyberia-action/cyberia-action.router.js

@@ -4,24 +4,28 @@ import express from 'express';
 
 const logger = loggerFactory(import.meta);
 
-const CyberiaActionRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, async (req, res) => await CyberiaActionController.post(req, res, options));
-  router.post(`/`, async (req, res) => await CyberiaActionController.post(req, res, options));
-  router.get(
-    `/:id`,
-    // authMiddleware,
-    async (req, res) => await CyberiaActionController.get(req, res, options),
-  );
-  router.get(`/`, async (req, res) => await CyberiaActionController.get(req, res, options));
-  router.put(`/:id`, async (req, res) => await CyberiaActionController.put(req, res, options));
-  router.put(`/`, async (req, res) => await CyberiaActionController.put(req, res, options));
-  router.delete(`/:id`, async (req, res) => await CyberiaActionController.delete(req, res, options));
-  router.delete(`/`, async (req, res) => await CyberiaActionController.delete(req, res, options));
-  return router;
-};
+class CyberiaActionRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, async (req, res) => await CyberiaActionController.post(req, res, options));
+    router.post(`/`, async (req, res) => await CyberiaActionController.post(req, res, options));
+    router.get(`/:id`,
+      // options.authMiddleware,
+      async (req, res) => await CyberiaActionController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await CyberiaActionController.get(req, res, options));
+    router.put(`/:id`, async (req, res) => await CyberiaActionController.put(req, res, options));
+    router.put(`/`, async (req, res) => await CyberiaActionController.put(req, res, options));
+    router.delete(`/:id`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+    router.delete(`/`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CyberiaActionRouter;
+const ApiRouter = (options) => CyberiaActionRouter.router(options);
 
 export { ApiRouter, CyberiaActionRouter };

package/src/api/cyberia-action/cyberia-action.service.js

@@ -1,4 +1,4 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
 
@@ -7,12 +7,12 @@ const logger = loggerFactory(import.meta);
 class CyberiaActionService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     return await new CyberiaAction(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     if (req.params.id) return await CyberiaAction.findById(req.params.id);
 
     // Parse query parameters using DataQuery helper
@@ -28,12 +28,12 @@ class CyberiaActionService {
   };
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     return await CyberiaAction.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
-    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
     if (req.params.id) return await CyberiaAction.findByIdAndDelete(req.params.id);
     else return await CyberiaAction.deleteMany();
   };

package/src/api/cyberia-client-hints/cyberia-client-hints.controller.js

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaClientHintsService } from './cyberia-client-hints.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaClientHintsController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static get = async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaClientHintsService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static put = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static delete = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+}
+
+export { CyberiaClientHintsController };

package/src/api/cyberia-client-hints/cyberia-client-hints.model.js

@@ -0,0 +1,99 @@
+/**
+ * Mongoose model for `CyberiaClientHints`.
+ *
+ * Dedicated collection for per-instance presentation overrides.
+ *
+ * Ownership:
+ *   - Read by:  cyberia-client (via /api/cyberia-client-hints/:code), CMS UIs.
+ *   - Written by: CMS / editor flows. The Cyberia simulation server
+ *                 never reads or writes this collection.
+ *   - Cacheable: yes — the service layer keeps an in-memory TTL cache.
+ *
+ * Schema scope: purely visual fields. Anything that influences simulation
+ * belongs in `CyberiaInstanceConf`.
+ *
+ * @module src/api/cyberia-client-hints/cyberia-client-hints.model.js
+ */
+
+import { Schema, model } from 'mongoose';
+
+const ColorRgbaSchema = new Schema(
+    {
+        r: { type: Number, default: 0 },
+        g: { type: Number, default: 0 },
+        b: { type: Number, default: 0 },
+        a: { type: Number, default: 255 },
+    },
+    { _id: false },
+);
+
+const PaletteEntrySchema = new Schema(
+    {
+        key: { type: String, required: true },
+        r: { type: Number, default: 0 },
+        g: { type: Number, default: 0 },
+        b: { type: Number, default: 0 },
+        a: { type: Number, default: 255 },
+    },
+    { _id: false },
+);
+
+const StatusIconHintSchema = new Schema(
+    {
+        id: { type: Number, required: true },
+        iconId: { type: String, default: '' },
+        bounce: { type: Boolean, default: false },
+        borderColor: { type: ColorRgbaSchema, default: () => ({ r: 100, g: 100, b: 100, a: 200 }) },
+    },
+    { _id: false },
+);
+
+const EntityColorKeySchema = new Schema(
+    {
+        entityType: { type: String, required: true },
+        colorKey: { type: String, required: true },
+    },
+    { _id: false },
+);
+
+const CyberiaClientHintsSchema = new Schema(
+    {
+        // Instance code this hint set is scoped to. Matches CyberiaInstance.code
+        // and CyberiaInstanceConf.instanceCode. Indexed and unique to make the
+        // service-layer cache a 1-to-1 keyed lookup.
+        code: { type: String, required: true, unique: true, index: true },
+
+        // Optional palette overrides. Keys not present here fall back to the
+        // client's compile-time defaults.
+        palette: { type: [PaletteEntrySchema], default: [] },
+
+        // Optional per-entity-type color-key overrides.
+        entityColorKeys: { type: [EntityColorKeySchema], default: [] },
+
+        // Optional status-icon visual overrides (id → iconId + borderColor).
+        statusIcons: { type: [StatusIconHintSchema], default: [] },
+
+        // Camera, viewport, and cell-sizing tunings — null/undefined means
+        // "use the SharedDefaultsCyberia.RENDER_DEFAULTS value".
+        cellSize: { type: Number, default: null },
+        defaultObjWidth: { type: Number, default: null },
+        defaultObjHeight: { type: Number, default: null },
+        cameraSmoothing: { type: Number, default: null },
+        cameraZoom: { type: Number, default: null },
+        defaultWidthScreenFactor: { type: Number, default: null },
+        defaultHeightScreenFactor: { type: Number, default: null },
+        interpolationMs: { type: Number, default: null },
+        devUi: { type: Boolean, default: null },
+    },
+    { timestamps: true },
+);
+
+const CyberiaClientHintsModel = model('CyberiaClientHints', CyberiaClientHintsSchema);
+
+const ProviderSchema = CyberiaClientHintsSchema;
+
+export {
+    CyberiaClientHintsSchema,
+    CyberiaClientHintsModel,
+    ProviderSchema,
+};