cyberia 3.2.22 → 3.2.70

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.22';
+  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);
 

package/src/projects/cyberia/catalog-cyberia.js

@@ -0,0 +1,81 @@
+/**
+ * Cyberia CLI content catalog.
+ *
+ * A per-deploy product catalog: pure data, loaded dynamically by deploy id via
+ * {@link module:src/server/catalog} so the base build and template assembly never
+ * statically depend on it. Exports the uniform product-catalog shape:
+ *
+ *   - `sourceMoves`       — public `[src, dest]` pairs moved into the engine tree before a build.
+ *   - `privateConfPaths`  — extra payloads synced into the deploy's private repo.
+ *   - `templatePaths`     — engine paths packaged into the standalone product CLI template.
+ *   - `stripPaths`        — paths removed from the base `pwa-microservices-template`.
+ *   - `moves`             — `[src, dest]` pairs moved into the template during assembly (like sourceMoves but into the template target).
+ *   - `copies`            — `[src, dest]` pairs copied into the template during assembly (like moves but copied instead of moved).
+ *   - `keywords`          — npm keywords for the standalone product CLI package.
+ *   - `description`       — npm description for the standalone product CLI package.
+ *
+ * @module src/projects/cyberia/catalog-cyberia.js
+ * @namespace CyberiaCatalog
+ */
+
+export default {
+  sourceMoves: [],
+  privateConfPaths: ['cyberia-instances/amethyst-strata-expansion'],
+  templatePaths: [
+    '/src/grpc/cyberia',
+    '/src/client/ssr/views/CyberiaServerMetrics.js',
+    '/test/cyberia-instance-conf-defaults.test.js',
+    '/test/shape-generator.test.js',
+    '/src/projects/cyberia',
+    '/src/runtime/cyberia-server',
+    '/src/runtime/cyberia-client',
+    '/src/runtime/engine-cyberia',
+    '/.github/workflows/hardhat.ci.yml',
+    '/src/client/public/cyberia-docs',
+    '/src/api/cyberia-server-defaults',
+    '/.github/workflows/docker-image.cyberia-client.ci.yml',
+    '/.github/workflows/docker-image.cyberia-client.dev.ci.yml',
+    '/.github/workflows/docker-image.cyberia-server.ci.yml',
+    '/.github/workflows/docker-image.cyberia-server.dev.ci.yml',
+    '/.github/workflows/cyberia-client.cd.yml',
+    '/.github/workflows/cyberia-server.cd.yml',
+  ],
+  stripPaths: [
+    './src/projects/cyberia',
+    './src/grpc/cyberia',
+    './src/runtime/cyberia-server',
+    './src/runtime/cyberia-client',
+    './src/runtime/engine-cyberia',
+    './test/cyberia-instance-conf-defaults.test.js',
+    './test/shape-generator.test.js',
+    './src/client/public/cyberia-docs',
+    'bin/cyberia.js',
+    './hardhat',
+  ],
+  moves: [],
+  copies: [
+    ['./src/runtime/engine-cyberia/docker-compose.yml', './docker-compose.yml'],
+    ['./src/runtime/engine-cyberia/compose.env', './.env.example'],
+    ['./src/runtime/engine-cyberia/.', './'],
+  ],
+  keywords: [
+    'cyberia',
+    'cyberia-cli',
+    'engine-cyberia',
+    'sidecar',
+    'data-layer',
+    'object-layer',
+    'atlas-sprite-sheet',
+    'ipfs',
+    'erc-1155',
+    'object-layer-token',
+    'hardhat',
+    'hyperledger-besu',
+    'blockchain',
+    'web3',
+    'underpost-platform',
+    'mmorpg',
+  ],
+  description:
+    'Cyberia CLI — toolchain for the Cyberia MMO data layer, content pipeline, persistence, gRPC services, and ERC-1155 lifecycle on Hyperledger Besu.',
+};