cyberia 3.2.12 → 3.2.70

package/src/{server → client-builder}/ssr.js

@@ -1,6 +1,6 @@
 /**
  * Module for managing server side rendering
- * @module src/server/ssr.js
+ * @module src/client-builder/ssr.js
  * @namespace ServerSideRendering
  */
 
@@ -10,19 +10,19 @@ import vm from 'node:vm';
 import Underpost from '../index.js';
 
 import { srcFormatted, JSONweb } from './client-formatted.js';
-import { loggerFactory } from './logger.js';
-import { getRootDirectory } from './process.js';
+import { loggerFactory } from '../server/logger.js';
+import { getRootDirectory } from '../server/process.js';
 
 const logger = loggerFactory(import.meta);
 
 /**
  * Creates a server-side rendering component function from a given file path.
  * It reads the component file, formats it, and executes it in a sandboxed Node.js VM context to extract the component.
- * @param {string} [componentPath='./src/client/ssr/Render.js'] - The path to the SSR component file.
+ * @param {string} [componentPath='./src/client/ssr/RootDocument.js'] - The path to the SSR component file.
  * @returns {Promise<Function>} A promise that resolves to the SSR component function.
  * @memberof ServerSideRendering
  */
-const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
+const ssrFactory = async (componentPath = `./src/client/ssr/RootDocument.js`) => {
   const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
   vm.createContext(context);
   vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);

package/src/client.build.js

@@ -6,7 +6,7 @@
 import { loggerFactory } from './server/logger.js';
 import { Config } from './server/conf.js';
 import { ProcessController } from './server/process.js';
-import { clientLiveBuild } from './server/client-build-live.js';
+import { clientLiveBuild } from './client-builder/client-build-live.js';
 
 await Config.build();
 
@@ -15,5 +15,3 @@ const logger = loggerFactory(import.meta);
 await logger.setUpInfo();
 
 await clientLiveBuild();
-
-// ProcessController.init(logger);

package/src/client.dev.js

@@ -6,7 +6,7 @@
 import { loggerFactory } from './server/logger.js';
 import { ProcessController } from './server/process.js';
 import { Config, buildClientStaticConf } from './server/conf.js';
-import { createClientDevServer } from './server/client-dev-server.js';
+import { createClientDevServer } from './client-builder/client-dev-server.js';
 
 const logger = loggerFactory(import.meta);
 

package/src/db/mongo/MongoBootstrap.js

@@ -290,19 +290,16 @@ class MongoBootstrap {
    * @returns {Promise<number>} Number of pods that failed to become ready (0 = all good).
    */
   static async waitForPods(namespace, replicaCount) {
-    const { default: Underpost } = await import('../../index.js');
-    const results = await Promise.all(
-      Array.from({ length: replicaCount }, async (_, i) => {
-        const podName = `${MONGODB_STATEFULSET_NAME}-${i}`;
-        const ready = await Underpost.test.statusMonitor(podName, 'Running', 'pods', 1000, 60 * 10);
-        return { index: i, ready };
-      }),
-    );
-    const failed = results.filter((r) => !r.ready).map((r) => `${MONGODB_STATEFULSET_NAME}-${r.index}`);
-    if (failed.length > 0) {
-      logger.error('MongoDB pods did not become ready', { failed });
+    let failedCount = 0;
+    for (let i = 0; i < replicaCount; i++) {
+      const podName = `${MONGODB_STATEFULSET_NAME}-${i}`;
+      const result = shellExec(`kubectl wait --for=condition=Ready pod/${podName} -n ${namespace} --timeout=60s`);
+      if (result.code !== 0) {
+        logger.error(`Pod ${podName} did not become ready`);
+        failedCount++;
+      }
     }
-    return failed.length;
+    return failedCount;
   }
 
   /**
@@ -620,6 +617,9 @@ class MongoBootstrap {
       process.env.DB_PASSWORD ||
       readTrimmedFile('./engine-private/mongodb-password');
 
+    // Ensure the pod is ready before querying
+    shellExec(`kubectl wait --for=condition=Ready pod/${podName} -n ${namespace} --timeout=60s`);
+
     const evalExpr = 'rs.status().members.filter(m=>m.stateStr=="PRIMARY").map(m=>m.name)';
 
     const cli = disableAuth ? 'mongo' : 'mongosh';

package/src/db/mongo/MongooseDB.js

@@ -86,7 +86,8 @@ class MongooseDBService {
 
     const user = config.user || process.env.DB_USER || '';
     const password = config.password || process.env.DB_PASSWORD || '';
-    const directConnection = hosts.length === 1;
+    const hasExplicitReplicaSet = !!(config.replicaSet || process.env.DB_REPLICA_SET);
+    const directConnection = hosts.length === 1 && !hasExplicitReplicaSet;
     const replicaSet = directConnection
       ? ''
       : config.replicaSet || process.env.DB_REPLICA_SET || MONGODB_DEFAULT_REPLICA_SET;

package/src/grpc/cyberia/grpc-server.js

@@ -17,11 +17,12 @@ import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import {
   CYBERIA_INSTANCE_CONF_DEFAULTS as FALLBACK_CONFIG_DEFAULTS,
+  DEFAULT_PLAYER_SPAWN,
   ENTITY_TYPE_DEFAULTS,
-  // STATUS_ICONS deliberately not imported here — see toInstanceConfig.
-  // Server simulation only cares about the numeric u8 IDs (which travel on
-  // the AOI wire). Icon stems + border colours live in SharedDefaultsCyberia.
+  DefaultCyberiaActions,
+  DefaultCyberiaQuests,
 } from '../../api/cyberia-server-defaults/cyberia-server-defaults.js';
+import { DefaultCyberiaItems } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
 import { generateFallbackWorld } from '../../api/cyberia-instance/cyberia-fallback-world.js';
 
 const logger = loggerFactory(import.meta);
@@ -53,20 +54,6 @@ function getModels(dbKey) {
   return bucket.models;
 }
 
-function countSharedItemIds(source = [], target = []) {
-  if (!Array.isArray(source) || source.length === 0 || !Array.isArray(target) || target.length === 0) {
-    return 0;
-  }
-  const targetSet = new Set(target.filter(Boolean));
-  let count = 0;
-  for (const itemId of source) {
-    if (targetSet.has(itemId)) {
-      count += 1;
-    }
-  }
-  return count;
-}
-
 function normalizeEntityDefault(entityDefault = {}, canonical = {}) {
   const defaultObjectLayers = entityDefault.defaultObjectLayers ?? canonical.defaultObjectLayers ?? [];
   return {
@@ -79,68 +66,140 @@ function normalizeEntityDefault(entityDefault = {}, canonical = {}) {
       active: !!ol.active,
       quantity: ol.quantity || 0,
     })),
+    behavior: entityDefault.behavior ?? canonical.behavior ?? '',
   };
 }
 
-function selectCanonicalEntityDefaultIndex(entityDefault, canonicalDefaults, usedIndexes) {
-  const pickBestIndex = (candidateIndexes) => {
-    let firstSameTypeIndex = -1;
-    let bestLiveOverlapIndex = -1;
-    let bestLiveOverlap = 0;
-    let bestLiveItemCount = Number.POSITIVE_INFINITY;
-
-    for (const index of candidateIndexes) {
-      const canonical = canonicalDefaults[index];
-      if (canonical.entityType !== entityDefault.entityType) {
-        continue;
-      }
-      if (firstSameTypeIndex === -1) {
-        firstSameTypeIndex = index;
-      }
-      const liveOverlap = countSharedItemIds(entityDefault.liveItemIds, canonical.liveItemIds);
-      if (
-        liveOverlap > 0 &&
-        (bestLiveOverlapIndex === -1 ||
-          liveOverlap > bestLiveOverlap ||
-          (liveOverlap === bestLiveOverlap && (canonical.liveItemIds?.length ?? 0) < bestLiveItemCount))
-      ) {
-        bestLiveOverlapIndex = index;
-        bestLiveOverlap = liveOverlap;
-        bestLiveItemCount = canonical.liveItemIds?.length ?? 0;
+// Merge instance-level itemIds flagged `defaultPlayerInventory` into the player
+// entityDefault's defaultObjectLayers so cyberia-server seeds them into every new
+// player's inventory (see handlers.go player spawn). Items are added inactive —
+// present in the inventory, not auto-equipped — so they never violate the
+// one-active-per-type equipment rule.
+//
+// Also **removes** items that are flagged `defaultPlayerInventory: false` from
+// the player's defaultObjectLayers. This ensures the instance's explicit intent
+// is honoured even when the conf's entityDefaults (e.g. from a backup/import)
+// baked those items into the player layer list.
+function applyInstanceDefaultPlayerInventory(config, instanceItemIds = []) {
+  const entries = instanceItemIds || [];
+
+  // ── 1. Remove items explicitly flagged as NOT default player inventory ─────
+  const removeIds = new Set(
+    entries.filter((entry) => entry && entry.defaultPlayerInventory === false && entry.id).map((entry) => entry.id),
+  );
+  if (removeIds.size > 0) {
+    for (const ed of config.entityDefaults || []) {
+      if (ed.defaultObjectLayers) {
+        ed.defaultObjectLayers = ed.defaultObjectLayers.filter((ol) => !removeIds.has(ol.itemId));
       }
     }
+  }
 
-    if (bestLiveOverlapIndex !== -1) {
-      return bestLiveOverlapIndex;
-    }
-    return firstSameTypeIndex;
-  };
+  // ── 2. Add items flagged as default player inventory ──────────────────────
+  const addIds = entries.filter((entry) => entry && entry.defaultPlayerInventory && entry.id).map((entry) => entry.id);
+  if (addIds.length === 0) return config;
 
-  const unusedCandidateIndexes = canonicalDefaults.map((_, index) => index).filter((index) => !usedIndexes.has(index));
+  const playerDefault = (config.entityDefaults || []).find((d) => d.entityType === 'player');
+  if (!playerDefault) return config;
 
-  const preferredIndex = pickBestIndex(unusedCandidateIndexes);
-  if (preferredIndex !== -1) {
-    return preferredIndex;
+  playerDefault.defaultObjectLayers = playerDefault.defaultObjectLayers || [];
+  const existing = new Set(playerDefault.defaultObjectLayers.map((ol) => ol.itemId));
+  for (const id of addIds) {
+    if (existing.has(id)) continue;
+    playerDefault.defaultObjectLayers.push({ itemId: id, active: false, quantity: 1 });
+    existing.add(id);
   }
-  return pickBestIndex(canonicalDefaults.map((_, index) => index));
+  return config;
 }
 
-function mergeEntityDefaults(entityDefaults = []) {
-  const mergedDefaults = ENTITY_TYPE_DEFAULTS.map((canonical) => normalizeEntityDefault(canonical, canonical));
-  const usedCanonicalIndexes = new Set();
-
-  for (const entityDefault of entityDefaults) {
-    const canonicalIndex = selectCanonicalEntityDefaultIndex(entityDefault, ENTITY_TYPE_DEFAULTS, usedCanonicalIndexes);
-    if (canonicalIndex === -1) {
-      mergedDefaults.push(normalizeEntityDefault(entityDefault));
-      continue;
-    }
+// Map CyberiaSkill collection docs to the proto skillConfig shape. The skill
+// collection is the authoritative own-model source: it carries full skill
+// metadata (summonedEntityItemId, name, description) that the instance-conf
+// skillConfig schema deliberately does not store.
+function skillDocsToConfig(skillDocs = []) {
+  return skillDocs
+    .filter((d) => d && d.triggerItemId)
+    .map((d) => ({
+      triggerItemId: d.triggerItemId,
+      skills: (d.skills || []).map((sk) => ({
+        logicEventId: sk.logicEventId || '',
+        name: sk.name || '',
+        description: sk.description || '',
+        summonedEntityItemId: sk.summonedEntityItemId || '',
+      })),
+    }));
+}
+
+// Load authoritative skill configs from the CyberiaSkill collection. Returns []
+// when the model is not loaded (api not mounted) or the collection is empty, so
+// callers transparently keep the conf / fallback skillConfig.
+async function loadSkillConfigDocs(models) {
+  if (!models.CyberiaSkill) return [];
+  return await models.CyberiaSkill.find({}).lean();
+}
+
+// Map CyberiaEntityTypeDefault collection docs to the proto entityDefaults shape.
+// This collection is the authoritative own-model source for per-entity-type item
+// defaults (live/dead/drop + seed object layers). Resolution is by liveItemIds
+// membership, so every variant (e.g. each resource skin) must travel as its own
+// entry — never collapsed by entityType.
+function entityTypeDefaultDocsToConfig(docs = []) {
+  return docs
+    .filter((d) => d && d.entityType)
+    .map((d) => ({
+      entityType: d.entityType,
+      liveItemIds: [...(d.liveItemIds || [])],
+      deadItemIds: [...(d.deadItemIds || [])],
+      dropItemIds: [...(d.dropItemIds || [])],
+      defaultObjectLayers: (d.defaultObjectLayers || []).map((ol) => ({
+        itemId: ol.itemId,
+        active: !!ol.active,
+        quantity: ol.quantity || 0,
+      })),
+      behavior: d.behavior || '',
+    }));
+}
+
+// Load authoritative entity-type defaults from the CyberiaEntityTypeDefault
+// collection. Returns [] when the model is not mounted or empty, so callers
+// transparently keep the conf / canonical entityDefaults.
+async function loadEntityTypeDefaultDocs(models) {
+  if (!models.CyberiaEntityTypeDefault) return [];
+  return await models.CyberiaEntityTypeDefault.find({}).lean();
+}
+
+// Feed every live/dead/drop and default-object-layer item id from the collection
+// defaults into the atlas id set so the Go server resolves their sprites even
+// when the entity appears in no map (e.g. a new resource skin).
+function addEntityDefaultAtlasIds(entityDefaults, atlasItemIds) {
+  for (const d of entityDefaults || []) {
+    for (const id of d.liveItemIds || []) if (id) atlasItemIds.add(id);
+    for (const id of d.deadItemIds || []) if (id) atlasItemIds.add(id);
+    for (const id of d.dropItemIds || []) if (id) atlasItemIds.add(id);
+    for (const ol of d.defaultObjectLayers || []) if (ol.itemId) atlasItemIds.add(ol.itemId);
+  }
+}
 
-    mergedDefaults[canonicalIndex] = normalizeEntityDefault(entityDefault, ENTITY_TYPE_DEFAULTS[canonicalIndex]);
-    usedCanonicalIndexes.add(canonicalIndex);
+// Feed skill trigger items and every concrete summoned-entity id into the atlas
+// id set so the Go server resolves their sprites even when the entity appears in
+// no map. Runtime placeholders ('$active_skin', …) are excluded.
+function addSkillAtlasIds(skillDocs, atlasItemIds) {
+  for (const d of skillDocs || []) {
+    if (d.triggerItemId) atlasItemIds.add(d.triggerItemId);
+    for (const sk of d.skills || []) {
+      const id = sk.summonedEntityItemId;
+      if (id && !id.startsWith('$')) atlasItemIds.add(id);
+    }
   }
+}
 
-  return mergedDefaults;
+function mergeEntityDefaults(entityDefaults = []) {
+  const merged = entityDefaults.map((entityDefault) => normalizeEntityDefault(entityDefault));
+  const coveredTypes = new Set(merged.map((entityDefault) => entityDefault.entityType));
+  for (const canonical of ENTITY_TYPE_DEFAULTS) {
+    if (!coveredTypes.has(canonical.entityType)) merged.push(normalizeEntityDefault(canonical, canonical));
+  }
+  return merged;
 }
 
 // ── Mongoose doc → protobuf message converters ───────────────────
@@ -248,6 +307,52 @@ function toInstanceMsg(doc) {
     })),
     topologyMode: doc.topologyMode || 'hybrid',
     seed: doc.seed || '',
+    playerSpawn: {
+      sourceMapCode: doc.playerSpawn?.sourceMapCode || '',
+      sourceCellX: doc.playerSpawn?.sourceCellX || 0,
+      sourceCellY: doc.playerSpawn?.sourceCellY || 0,
+      random: !!doc.playerSpawn?.random,
+    },
+  };
+}
+
+// CyberiaAction → CyberiaActionMessage (proto camelCase fields).
+function toActionMsg(a) {
+  return {
+    code: a.code || '',
+    label: a.label || '',
+    sourceMapCode: a.sourceMapCode || '',
+    sourceCellX: a.sourceCellX || 0,
+    sourceCellY: a.sourceCellY || 0,
+    dialogCode: a.dialogCode || '',
+    questDialogueCodes: (a.questDialogueCodes || []).map((qd) => ({
+      questCode: qd.questCode || '',
+      dialogCode: qd.dialogCode || '',
+    })),
+  };
+}
+
+// CyberiaQuest → CyberiaQuestMessage.
+function toQuestMsg(q) {
+  return {
+    code: q.code || '',
+    title: q.title || '',
+    description: q.description || '',
+    unlocksQuestCodes: q.unlocksQuestCodes || [],
+    prerequisiteCodes: q.prerequisiteCodes || [],
+    sourceMapCode: q.sourceMapCode || '',
+    sourceCellX: q.sourceCellX || 0,
+    sourceCellY: q.sourceCellY || 0,
+    steps: (q.steps || []).map((s) => ({
+      id: s.id || '',
+      description: s.description || '',
+      objectives: (s.objectives || []).map((o) => ({
+        type: o.type || '',
+        itemId: o.itemId || '',
+        quantity: o.quantity || 1,
+      })),
+    })),
+    rewards: (q.rewards || []).map((r) => ({ itemId: r.itemId || '', quantity: r.quantity || 1 })),
   };
 }
 
@@ -445,11 +550,34 @@ function buildHandlers(dbKey) {
               if (ol.itemId) fallbackItemIds.add(ol.itemId);
             }
           }
+          // Include every canonical item so the Go server can resolve the type
+          // of anything a player may pick up or equip (quest rewards like
+          // hatchet, alt weapons, etc.) — required for the one-per-type
+          // equipment rule, which silently no-ops when item type is unknown.
+          for (const it of DefaultCyberiaItems || []) {
+            if (it?.item?.id) fallbackItemIds.add(it.item.id);
+          }
+
+          // Own-model skills (if seeded) override the fallback skillConfig; their
+          // summoned-entity atlases are resolved alongside the world's.
+          const fallbackSkillDocs = await loadSkillConfigDocs(models);
+          addSkillAtlasIds(fallbackSkillDocs, fallbackItemIds);
+
+          // Own-model entity defaults (if seeded) override the fallback
+          // entityDefaults; their live/dead/drop atlases resolve alongside.
+          const fallbackEntityDefaultDocs = await loadEntityTypeDefaultDocs(models);
+          const fallbackEntityDefaultsConfig = entityTypeDefaultDocsToConfig(fallbackEntityDefaultDocs);
+          addEntityDefaultAtlasIds(fallbackEntityDefaultsConfig, fallbackItemIds);
 
           const fallbackOlDocs = fallbackItemIds.size
             ? await models.ObjectLayer.find({ 'data.item.id': { $in: [...fallbackItemIds] } }).lean()
             : [];
 
+          const fallbackConfig = toInstanceConfig(fallbackConf);
+          if (fallbackEntityDefaultsConfig.length)
+            fallbackConfig.entityDefaults = mergeEntityDefaults(fallbackEntityDefaultsConfig);
+          if (fallbackSkillDocs.length) fallbackConfig.skillConfig = skillDocsToConfig(fallbackSkillDocs);
+
           callback(null, {
             instance: toInstanceMsg({
               _id: '',
@@ -461,6 +589,7 @@ function buildHandlers(dbKey) {
               portals: world.portals,
               topologyMode: 'procedural',
               seed: instanceCode,
+              playerSpawn: world.instance.playerSpawn,
             }),
             maps: world.maps.map((m) => ({
               mongoId: '',
@@ -473,8 +602,12 @@ function buildHandlers(dbKey) {
               entities: (m.entities || []).map(toEntityMsg),
             })),
             objectLayers: fallbackOlDocs.map(toObjectLayerMsg),
-            config: toInstanceConfig(fallbackConf),
+            config: fallbackConfig,
             version: 'fallback',
+            // Mission content for the procedural fallback comes straight from
+            // the canonical defaults — no DB, fully self-contained.
+            actions: DefaultCyberiaActions.map(toActionMsg),
+            quests: DefaultCyberiaQuests.map(toQuestMsg),
           });
           return;
         }
@@ -506,9 +639,23 @@ function buildHandlers(dbKey) {
           }
         }
 
-        // Include system OL items from BOTH canonical ENTITY_TYPE_DEFAULTS AND
-        // the DB conf so the Go server always caches all default atlases even if
-        // the DB doc has incomplete entityDefaults.
+        // Instance-level itemIds (e.g. default-player-inventory items) may not
+        // appear in any map entity — include them so their atlases resolve.
+        // Tolerate legacy flat-string entries alongside the { id, … } shape.
+        for (const entry of inst.itemIds || []) {
+          const id = typeof entry === 'string' ? entry : entry?.id;
+          if (id) itemIds.add(id);
+        }
+
+        // Authoritative per-entity-type defaults come from the
+        // CyberiaEntityTypeDefault collection (own model); empty collection leaves
+        // the conf/canonical defaults in place.
+        const entityDefaultDocs = await loadEntityTypeDefaultDocs(models);
+        const entityDefaultsConfig = entityTypeDefaultDocsToConfig(entityDefaultDocs);
+
+        // Include system OL items from canonical ENTITY_TYPE_DEFAULTS, the DB conf,
+        // AND the collection so the Go server always caches every default atlas
+        // even when an entity (e.g. a new resource skin) appears in no map.
         for (const d of [...ENTITY_TYPE_DEFAULTS, ...(conf.entityDefaults || [])]) {
           for (const id of d.liveItemIds || []) itemIds.add(id);
           for (const id of d.deadItemIds || []) itemIds.add(id);
@@ -517,6 +664,12 @@ function buildHandlers(dbKey) {
             if (ol.itemId) itemIds.add(ol.itemId);
           }
         }
+        addEntityDefaultAtlasIds(entityDefaultsConfig, itemIds);
+
+        // Authoritative skills come from the CyberiaSkill collection (own model);
+        // resolve their atlases before the OL query so summoned entities render.
+        const skillDocs = await loadSkillConfigDocs(models);
+        addSkillAtlasIds(skillDocs, itemIds);
 
         const olDocs = itemIds.size
           ? await models.ObjectLayer.find({ 'data.item.id': { $in: [...itemIds] } }).lean()
@@ -527,14 +680,46 @@ function buildHandlers(dbKey) {
         const versionParts = [String(inst.updatedAt || inst._id)];
         for (const m of mapDocs) versionParts.push(String(m.updatedAt || m._id));
         if (conf.updatedAt) versionParts.push(String(conf.updatedAt));
+        // Skill edits live in their own collection — fold them in so a skill
+        // change triggers a Go-side world rebuild instead of serving stale skills.
+        for (const sk of skillDocs) versionParts.push(String(sk.updatedAt || sk._id));
+        // Entity-type-default edits live in their own collection too — fold them
+        // in so adding/editing a default (e.g. a new resource) rebuilds the world.
+        for (const ed of entityDefaultDocs) versionParts.push(String(ed.updatedAt || ed._id));
         const version = crypto.createHash('sha256').update(versionParts.join('|')).digest('hex');
 
+        // Mission content for this instance: actions and quests bound to its
+        // maps (by sourceMapCode). Delivered with the world so the Go server
+        // never opens a separate REST channel, and never receives content from
+        // other instances' maps.
+        const actionDocs =
+          mapCodes.length && models.CyberiaAction
+            ? await models.CyberiaAction.find({ sourceMapCode: { $in: mapCodes } }).lean()
+            : [];
+        const questDocs =
+          mapCodes.length && models.CyberiaQuest
+            ? await models.CyberiaQuest.find({ sourceMapCode: { $in: mapCodes } }).lean()
+            : [];
+
+        const baseConfig = toInstanceConfig(conf);
+        // Own-model entity defaults win over the conf's entityDefaults (overlaid on
+        // canonical via mergeEntityDefaults), so every collection variant — e.g.
+        // each resource skin — reaches the Go runtime keyed by liveItemIds. Applied
+        // BEFORE default-player-inventory so the player layer additions survive.
+        if (entityDefaultsConfig.length) baseConfig.entityDefaults = mergeEntityDefaults(entityDefaultsConfig);
+        const config = applyInstanceDefaultPlayerInventory(baseConfig, inst.itemIds);
+        // Own-model skills win over the conf's stripped skillConfig (which lacks
+        // summonedEntityItemId); empty collection leaves the conf/fallback as-is.
+        if (skillDocs.length) config.skillConfig = skillDocsToConfig(skillDocs);
+
         callback(null, {
           instance: toInstanceMsg(inst),
           maps: mapDocs.map(toMapMsg),
           objectLayers: olDocs.map(toObjectLayerMsg),
-          config: toInstanceConfig(conf),
+          config,
           version,
+          actions: actionDocs.map(toActionMsg),
+          quests: questDocs.map(toQuestMsg),
         });
       } catch (err) {
         logger.error('getFullInstance:', err);

package/src/index.js

@@ -10,6 +10,7 @@ import UnderpostKickStart from './cli/kickstart.js';
 import UnderpostCluster from './cli/cluster.js';
 import UnderpostDB from './cli/db.js';
 import UnderpostDeploy from './cli/deploy.js';
+import UnderpostDockerCompose from './cli/docker-compose.js';
 import UnderpostKubectl from './cli/kubectl.js';
 import UnderpostRootEnv from './cli/env.js';
 import UnderpostFileStorage from './cli/fs.js';
@@ -44,7 +45,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v3.2.12';
+  static version = 'v3.2.70';
 
   /**
    * Required Node.js major version
@@ -146,6 +147,15 @@ class Underpost {
   static get deploy() {
     return UnderpostDeploy.API;
   }
+  /**
+   * Docker Compose pipeline cli API
+   * @static
+   * @type {UnderpostDockerCompose.API}
+   * @memberof Underpost
+   */
+  static get dockerCompose() {
+    return UnderpostDockerCompose.API;
+  }
   /**
    * File Storage cli API
    * @static
@@ -321,6 +331,7 @@ export {
   UnderpostCluster,
   UnderpostDB,
   UnderpostDeploy,
+  UnderpostDockerCompose,
   UnderpostKubectl,
   UnderpostRootEnv,
   UnderpostFileStorage,

package/src/mailer/EmailRender.js

@@ -1,4 +1,4 @@
-import { ssrFactory } from '../server/ssr.js';
+import { ssrFactory } from '../client-builder/ssr.js';
 
 /**
  * Module for handling the rendering and styling of HTML emails using SSR components.

package/src/{server → projects/cyberia}/atlas-sprite-sheet-generator.js

@@ -1,7 +1,7 @@
 /**
  * Atlas Sprite Sheet Generator for Cyberia Online.
  * Consolidates all object layer frames (8 directions, multiple modes) into a single PNG atlas.
- * @module src/server/atlas-sprite-sheet-generator.js
+ * @module src/projects/cyberia/atlas-sprite-sheet-generator.js
  * @namespace CyberiaAtlasSpriteSheetGenerator
  */
 
@@ -9,7 +9,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import sharp from 'sharp';
 import { Jimp, rgbaToInt } from 'jimp';
-import { loggerFactory } from './logger.js';
+import { loggerFactory } from '../../server/logger.js';
 
 const logger = loggerFactory(import.meta);
 

package/src/{server → projects/cyberia}/besu-genesis-generator.js

@@ -9,7 +9,7 @@
  * This eliminates hardcoded keys/hashes in manifests/besu/ and ensures every
  * new deployment gets a clean, unique chain identity.
  *
- * @module src/server/besu-genesis-generator.js
+ * @module src/projects/cyberia/besu-genesis-generator.js
  * @namespace BesuGenesisGenerator
  */
 
@@ -17,8 +17,8 @@ import crypto from 'crypto';
 import fs from 'fs-extra';
 import path from 'path';
 import { keccak256 as ethersKeccak256 } from 'ethers';
-import { loggerFactory } from '../server/logger.js';
-import { shellExec } from '../server/process.js';
+import { loggerFactory } from '../../server/logger.js';
+import { shellExec } from '../../server/process.js';
 
 const logger = loggerFactory(import.meta);