cyberia 3.2.9 → 3.2.12

package/src/db/mongo/MongooseDB.js

@@ -1,6 +1,6 @@
 import mongoose from 'mongoose';
-import { loggerFactory } from '../../server/logger.js';
 import { getCapVariableName } from '../../client/components/core/CommonJs.js';
+import { loggerFactory } from '../../server/logger.js';
 
 /**
  * Module for connecting to and loading models for a MongoDB database using Mongoose.
@@ -10,6 +10,32 @@ import { getCapVariableName } from '../../client/components/core/CommonJs.js';
 
 const logger = loggerFactory(import.meta);
 
+const MONGODB_SERVICE_NAME = 'mongodb-service';
+const MONGODB_STATEFULSET_NAME = 'mongodb';
+const MONGODB_DEFAULT_AUTH_SOURCE = 'admin';
+const MONGODB_DEFAULT_REPLICA_SET = 'rs0';
+const MONGODB_DEFAULT_REPLICA_COUNT = 3;
+
+/**
+ * Resolves MongoDB replica hosts from explicit input or StatefulSet defaults.
+ * @param {{hostList?: string, replicaCount?: number}} [options] - Host resolution options.
+ * @returns {Array<string>} Normalized host:port entries.
+ */
+const resolveMongoReplicaHosts = ({ hostList = '', replicaCount = MONGODB_DEFAULT_REPLICA_COUNT }) => {
+  if (hostList) {
+    return hostList
+      .split(',')
+      .map((host) => host.trim())
+      .filter(Boolean)
+      .map((host) => (host.includes(':') ? host : `${host}:27017`));
+  }
+
+  return Array.from(
+    { length: replicaCount },
+    (_, index) => `${MONGODB_STATEFULSET_NAME}-${index}.${MONGODB_SERVICE_NAME}:27017`,
+  );
+};
+
 /**
  * @class
  * @alias MongooseDBService
@@ -23,35 +49,109 @@ const logger = loggerFactory(import.meta);
  * 3. No built-in defaults — both `host` and `name` are required from the caller or environment.
  */
 class MongooseDBService {
+  /**
+   * Normalizes Mongo host inputs into plain host:port entries.
+   * @param {Array<string>|string} hosts - Host input as list or comma-separated string.
+   * @returns {Array<string>} Normalized host:port entries.
+   */
+  normalizeHosts(hosts) {
+    const hostEntries = Array.isArray(hosts) ? hosts : `${hosts || ''}`.split(',');
+
+    return hostEntries
+      .map((entry) => `${entry || ''}`.trim())
+      .filter(Boolean)
+      .map((entry) => entry.replace(/^mongodb:\/\//, '').replace(/\/.*$/, ''));
+  }
+
+  /**
+   * Normalizes connection config from object or legacy host/name signature.
+   * @param {object|string} configOrHost - Connection config object or host string.
+   * @param {string} [name] - Legacy DB name when using host string input.
+   * @returns {{authSource: string, dbName: string, directConnection: boolean, hosts: Array<string>, password: string, replicaSet: string, user: string}} Normalized config.
+   */
+  normalizeConfig(configOrHost, name) {
+    const config =
+      typeof configOrHost === 'object' && configOrHost !== null ? { ...configOrHost } : { host: configOrHost, name };
+
+    const rawHosts = config.host || process.env.DB_HOST;
+    const hosts = this.normalizeHosts(rawHosts);
+    const dbName = config.name || process.env.DB_NAME;
+
+    if (!hosts.length || !dbName) {
+      const missing = [!hosts.length && 'host (db.host|DB_HOST)', !dbName && 'name (db.name|DB_NAME)']
+        .filter(Boolean)
+        .join(', ');
+      throw new Error(`MongooseDBService.connect: missing required parameter(s): ${missing}`);
+    }
+
+    const user = config.user || process.env.DB_USER || '';
+    const password = config.password || process.env.DB_PASSWORD || '';
+    const directConnection = hosts.length === 1;
+    const replicaSet = directConnection
+      ? ''
+      : config.replicaSet || process.env.DB_REPLICA_SET || MONGODB_DEFAULT_REPLICA_SET;
+    const authSource = config.authSource || process.env.DB_AUTH_SOURCE || (user ? MONGODB_DEFAULT_AUTH_SOURCE : '');
+
+    return {
+      authSource,
+      dbName,
+      directConnection,
+      hosts,
+      password,
+      replicaSet,
+      user,
+    };
+  }
+
+  /**
+   * Builds a MongoDB URI from normalized config options.
+   * @param {object|string} configOrHost - Connection config object or host string.
+   * @param {string} [name] - Legacy DB name when using host string input.
+   * @returns {string} MongoDB connection URI.
+   */
+  buildUri(configOrHost, name) {
+    const config = this.normalizeConfig(configOrHost, name);
+    const credentials =
+      config.user && config.password
+        ? `${encodeURIComponent(config.user)}:${encodeURIComponent(config.password)}@`
+        : '';
+    const query = new URLSearchParams();
+
+    if (config.directConnection) query.set('directConnection', 'true');
+    else if (config.replicaSet) query.set('replicaSet', config.replicaSet);
+    if (config.authSource) query.set('authSource', config.authSource);
+
+    return `mongodb://${credentials}${config.hosts.join(',')}/${config.dbName}${query.size ? `?${query.toString()}` : ''}`;
+  }
+
   /**
    * Establishes a Mongoose connection to the specified MongoDB instance.
    *
    * @async
-   * @param {string} host - The MongoDB host URI (e.g., `'mongodb://localhost:27017'`).
-   *   Falls back to `process.env.DB_HOST` when not provided.
-   * @param {string} name - The database name.
-   *   Falls back to `process.env.DB_NAME` when not provided.
+   * @param {object|string} configOrHost - Either a db config object or a legacy host string.
+   * @param {string} [configOrHost.host] - Legacy single host or comma-separated host list.
+   * @param {string} [configOrHost.name] - The database name.
+   * @param {string} [configOrHost.replicaSet] - The MongoDB replica set name.
+   * @param {string} [configOrHost.authSource] - The authentication database.
+   * @param {string} [configOrHost.user] - The MongoDB username.
+   * @param {string} [configOrHost.password] - The MongoDB password.
+   * @param {string} [name] - Legacy database name when a host string is passed.
    * @returns {Promise<mongoose.Connection>} A promise that resolves to the established Mongoose connection object.
    * @throws {Error} If neither the argument nor the corresponding environment variable supplies a value.
    */
-  async connect(host, name) {
-    host = host || process.env.DB_HOST;
-    name = name || process.env.DB_NAME;
-
-    if (!host || !name) {
-      const missing = [!host && 'host (DB_HOST)', !name && 'name (DB_NAME)'].filter(Boolean).join(', ');
-      throw new Error(`MongooseDBService.connect: missing required parameter(s): ${missing}`);
-    }
-
-    const uri = `${host}/${name}`;
-    // logger.info('MongooseDB connect', { host, name, uri });
+  async connect(configOrHost, name) {
+    const uri = this.buildUri(configOrHost, name);
+    if (process.env.NODE_ENV === 'development') logger.info(`Connecting to MongoDB with URI`, uri);
     return await mongoose
       .createConnection(uri, {
+        autoIndex: process.env.NODE_ENV !== 'production',
+        heartbeatFrequencyMS: 10000,
+        maxPoolSize: 20,
+        minPoolSize: 2,
+        retryReads: true,
+        retryWrites: true,
         serverSelectionTimeoutMS: 5000,
-        // readPreference: 'primary',
-        // directConnection: true,
-        // useNewUrlParser: true,
-        // useUnifiedTopology: true,
+        socketTimeoutMS: 45000,
       })
       .asPromise();
   }
@@ -87,4 +187,12 @@ class MongooseDBService {
  */
 const MongooseDB = new MongooseDBService();
 
-export { MongooseDB, MongooseDBService as MongooseDBClass };
+export {
+  MongooseDB,
+  MongooseDBService as MongooseDBClass,
+  MONGODB_DEFAULT_REPLICA_COUNT,
+  MONGODB_DEFAULT_REPLICA_SET,
+  MONGODB_SERVICE_NAME,
+  MONGODB_STATEFULSET_NAME,
+  resolveMongoReplicaHosts,
+};

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

@@ -13,13 +13,15 @@ import * as protoLoader from '@grpc/proto-loader';
 import crypto from 'crypto';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import {
   CYBERIA_INSTANCE_CONF_DEFAULTS as FALLBACK_CONFIG_DEFAULTS,
   ENTITY_TYPE_DEFAULTS,
-  STATUS_ICONS,
-} from '../../api/cyberia-instance-conf/cyberia-instance-conf.defaults.js';
+  // 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.
+} from '../../api/cyberia-server-defaults/cyberia-server-defaults.js';
 import { generateFallbackWorld } from '../../api/cyberia-instance/cyberia-fallback-world.js';
 
 const logger = loggerFactory(import.meta);
@@ -27,7 +29,7 @@ const logger = loggerFactory(import.meta);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const PROTO_PATH = path.resolve(__dirname, '../../../cyberia-server/proto/cyberia.proto');
+const PROTO_PATH = path.resolve(__dirname, '../../../cyberia-server/gen/proto/cyberia.proto');
 
 const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
   keepCase: false,
@@ -44,11 +46,11 @@ const proto = grpc.loadPackageDefinition(packageDefinition).cyberia;
 // ═══════════════════════════════════════════════════════════════════
 
 function getModels(dbKey) {
-  const bucket = DataBaseProvider.instance[dbKey];
-  if (!bucket || !bucket.mongoose || !bucket.mongoose.models) {
-    throw new Error(`DataBaseProvider not loaded for key "${dbKey}"`);
+  const bucket = DataBaseProviderService.getProvider(dbKey, 'mongoose');
+  if (!bucket || !bucket.models) {
+    throw new Error(`DataBaseProviderService not loaded for key "${dbKey}"`);
   }
-  return bucket.mongoose.models;
+  return bucket.models;
 }
 
 function countSharedItemIds(source = [], target = []) {
@@ -72,7 +74,6 @@ function normalizeEntityDefault(entityDefault = {}, canonical = {}) {
     liveItemIds: [...(entityDefault.liveItemIds ?? canonical.liveItemIds ?? [])],
     deadItemIds: [...(entityDefault.deadItemIds ?? canonical.deadItemIds ?? [])],
     dropItemIds: [...(entityDefault.dropItemIds ?? canonical.dropItemIds ?? [])],
-    colorKey: entityDefault.colorKey ?? canonical.colorKey ?? '',
     defaultObjectLayers: defaultObjectLayers.map((ol) => ({
       itemId: ol.itemId || '',
       active: !!ol.active,
@@ -96,10 +97,6 @@ function selectCanonicalEntityDefaultIndex(entityDefault, canonicalDefaults, use
       if (firstSameTypeIndex === -1) {
         firstSameTypeIndex = index;
       }
-      if (entityDefault.colorKey && canonical.colorKey === entityDefault.colorKey) {
-        return index;
-      }
-
       const liveOverlap = countSharedItemIds(entityDefault.liveItemIds, canonical.liveItemIds);
       if (
         liveOverlap > 0 &&
@@ -264,36 +261,24 @@ function toInstanceConfig(gc) {
   const fb = FALLBACK_CONFIG_DEFAULTS;
   if (!gc) return buildFallbackConfig();
 
-  // Per-key merge: start with canonical defaults, overlay any DB-defined colours.
-  const dbColorMap = new Map((gc.colors || []).map((c) => [c.key, c]));
-  const colors = fb.colors.map((c) => {
-    const ov = dbColorMap.get(c.key);
-    return ov ? { key: c.key, r: ov.r ?? c.r, g: ov.g ?? c.g, b: ov.b ?? c.b, a: ov.a ?? c.a } : { ...c };
-  });
-  // Append any DB colours whose keys are absent from the canonical defaults.
-  for (const [key, c] of dbColorMap) {
-    if (!colors.some((fc) => fc.key === key)) {
-      colors.push({ key, r: c.r ?? 0, g: c.g ?? 0, b: c.b ?? 0, a: c.a ?? 255 });
-    }
-  }
+  // STRICT BOUNDARY — this function produces the *simulation* config for
+  // cyberia-server only. Every presentation concern is excluded:
+  //
+  //   - palette (colors), camera tunings, screen factors, devUi,
+  //     interpolationMs, status-icon visuals, entityDefaults[].colorKey,
+  //     cellSize, defaultObj* — all of these reach the client through
+  //     /api/cyberia-client-hints, never through gRPC.
+  //
+  // The Go simulation does not need any of them to advance world state;
+  // the C/WASM cyberia-client owns its own render policy. See
+  // src/client/components/cyberia/SharedDefaultsCyberia.js.
 
-  // Merge entity defaults while preserving duplicate builds (for example,
-  // multiple resource or portal variants sharing the same entityType).
   const gcDefaults = gc.entityDefaults && gc.entityDefaults.length > 0 ? gc.entityDefaults : [];
   const entityDefaults = mergeEntityDefaults(gcDefaults);
 
   return {
-    cellSize: gc.cellSize ?? fb.cellSize,
-    fps: gc.fps ?? fb.fps,
-    interpolationMs: gc.interpolationMs ?? fb.interpolationMs,
-    defaultObjWidth: gc.defaultObjWidth ?? fb.defaultObjWidth,
-    defaultObjHeight: gc.defaultObjHeight ?? fb.defaultObjHeight,
-    cameraSmoothing: gc.cameraSmoothing ?? fb.cameraSmoothing,
-    cameraZoom: gc.cameraZoom ?? fb.cameraZoom,
-    defaultWidthScreenFactor: gc.defaultWidthScreenFactor ?? fb.defaultWidthScreenFactor,
-    defaultHeightScreenFactor: gc.defaultHeightScreenFactor ?? fb.defaultHeightScreenFactor,
-    devUi: gc.devUi ?? fb.devUi,
-    colors,
+    tickRate: gc.tickRate ?? fb.tickRate,
+    snapshotRate: gc.snapshotRate ?? fb.snapshotRate,
     aoiRadius: gc.aoiRadius ?? fb.aoiRadius,
     portalHoldTimeMs: gc.portalHoldTimeMs ?? fb.portalHoldTimeMs,
     portalSpawnRadius: gc.portalSpawnRadius ?? fb.portalSpawnRadius,
@@ -352,23 +337,6 @@ function toInstanceConfig(gc) {
       onePerType: gc.equipmentRules?.onePerType ?? fb.equipmentRules.onePerType,
       requireSkin: gc.equipmentRules?.requireSkin ?? fb.equipmentRules.requireSkin,
     },
-    // Status icon mapping — u8 ID → icon filename stem + border colour.
-    // Border colours come from the frozen STATUS_ICONS constant (canonical
-    // source of truth).  DB entries may override iconId but borderColor is
-    // always canonical — the DB schema defaults are generic grey, not the
-    // actual per-status colours.
-    statusIcons: STATUS_ICONS.map((canon) => {
-      const dbEntry = (gc.statusIcons || []).find((s) => s.id === canon.id);
-      const bc = canon.borderColor || {};
-      return {
-        id: canon.id,
-        iconId: (dbEntry && dbEntry.iconId) || canon.iconId || '',
-        borderColorR: bc.r ?? 100,
-        borderColorG: bc.g ?? 100,
-        borderColorB: bc.b ?? 100,
-        borderColorA: bc.a ?? 200,
-      };
-    }),
   };
 }
 
@@ -598,8 +566,8 @@ class GrpcServer {
 
   /**
    * @param {Object} opts
-   * @param {string} opts.host  - DataBaseProvider host key
-   * @param {string} opts.path  - DataBaseProvider path key
+   * @param {string} opts.host  - DataBaseProviderService host key
+   * @param {string} opts.path  - DataBaseProviderService path key
    * @param {number} [opts.port=50051]
    */
   static async start({ host, path: dbPath, port = 50051 } = {}) {

package/src/index.js

@@ -44,7 +44,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v3.2.9';
+  static version = 'v3.2.12';
 
   /**
    * Required Node.js major version

package/src/runtime/cyberia-client/Dockerfile

@@ -53,19 +53,37 @@ RUN ./emsdk install ${EMSDK_VERSION} && \
     ./emsdk activate ${EMSDK_VERSION}
 
 WORKDIR /cyberia-client
-COPY cyberia-client/ .
+# Build context is the cyberia-client project repo root (the workflow
+# in .github/workflows/docker-image.cyberia-client.ci.yml sets
+# context: . from the cyberia-client checkout). The legacy
+# engine-context layout (COPY cyberia-client/ .) is no longer used.
+COPY . .
 
-RUN make -f Web.mk all BUILD_MODE=${BUILD_MODE} OUTPUT_DIR=bin/
+# `make clean` first so stale bin/ or build/ artefacts copied in from a
+# developer's local checkout (or a previous Docker layer cache hit)
+# can't shadow a fresh BUILD_MODE rebuild — e.g. mixing a DEBUG-mode
+# index.wasm with a RELEASE-mode index.js once produced the
+# "corrupted heap memory area" panic that masked the real Closure bug.
+RUN make -f Web.mk clean && make -f Web.mk all BUILD_MODE=${BUILD_MODE} OUTPUT_DIR=bin/
 
 # --- Runtime Image
 FROM rockylinux/rockylinux:9 AS runtime
 
+# Runtime needs:
+#   - python3 (serves the built /bin/ static files via server.py)
+#   - nodejs + the underpost CLI globally, for the container-status
+#     lifecycle hooks invoked from conf.instances.json before / after
+#     launching server.py. Installing it at build time avoids the slow
+#     `npm install -g` startup the K8S cmd would otherwise repeat.
+ARG UNDERPOST_VERSION=3.2.9
 RUN dnf -y update && \
     dnf -y install epel-release && \
     dnf -y install --allowerasing curl git python3 && \
     curl -fsSL https://rpm.nodesource.com/setup_24.x | bash - && \
     dnf install -y nodejs && \
-    dnf clean all
+    npm install -g underpost@${UNDERPOST_VERSION} && \
+    dnf clean all && \
+    npm cache clean --force
 
 WORKDIR /home/dd/engine/cyberia-client
 
@@ -77,4 +95,7 @@ ENV CYBERIA_MODE=production
 
 EXPOSE 8081 8082
 
+# Default CMD when the image is run directly (not via K8S cmd).
+# In K8S deploys conf.instances.json supplies its own cmd that wraps
+# container-status hooks + this same server.py invocation.
 CMD ["sh", "-c", "exec python3 server.py ${CYBERIA_PORT} bin ${CYBERIA_MODE}"]

package/src/runtime/cyberia-client/Dockerfile.dev

@@ -0,0 +1,82 @@
+# cyberia-client DEV runtime image.
+#
+# Differences vs the production Dockerfile in this same directory:
+#   - Builds the C/WASM bundle with BUILD_MODE=DEBUG (raylib + emcc keep
+#     symbols, asserts, and DWARF info; the bundle is larger but
+#     debuggable in the browser devtools).
+#   - Default CYBERIA_MODE is `development` instead of `production`.
+#   - Default CYBERIA_PORT is `8082` (debug port) instead of `8081`.
+#   - Keeps `vim-minimal`, `lsof`, `strace`, `procps-ng` in the runtime
+#     image so the operator can attach and inspect a misbehaving pod.
+#   - Does NOT clean the npm cache.
+#
+# Selected automatically by `node bin run instance-build-manifest`
+# whenever the `--dev` flag is set; the production Dockerfile in the
+# same directory is used otherwise.
+
+ARG BUILD_MODE=DEBUG
+
+# --- Build Image
+FROM rockylinux/rockylinux:9 AS builder
+ARG BUILD_MODE=DEBUG
+
+RUN dnf -y update && \
+    dnf -y install epel-release && \
+    dnf -y install --allowerasing \
+    git curl wget openssl-devel libnsl perl gnupg2 bzip2 && \
+    dnf clean all
+
+RUN dnf groupinstall -y "Development Tools" && \
+    dnf install -y \
+        cmake unzip python3 python3.11 \
+        alsa-lib-devel mesa-libGL-devel mesa-libGLU-devel \
+        libX11-devel libXrandr-devel libXi-devel libXcursor-devel \
+        libXinerama-devel libXfixes-devel \
+        freeglut-devel glfw-devel libatomic.x86_64 && \
+    dnf clean all && \
+    alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 2 && \
+    alternatives --set python3 /usr/bin/python3.11
+
+ENV EMSDK=/opt/emsdk
+ENV PATH="${EMSDK}:${EMSDK}/upstream/emscripten:${PATH}"
+
+ARG EMSDK_VERSION=5.0.6
+WORKDIR /opt
+RUN git clone https://github.com/emscripten-core/emsdk.git ${EMSDK}
+WORKDIR ${EMSDK}
+RUN ./emsdk install ${EMSDK_VERSION} && \
+    ./emsdk activate ${EMSDK_VERSION}
+
+WORKDIR /cyberia-client
+# Build context is the cyberia-client project repo root (see the
+# production Dockerfile in this directory for the rationale).
+COPY . .
+
+# Dev build: BUILD_MODE=DEBUG keeps symbols, asserts, source maps.
+RUN make -f Web.mk all BUILD_MODE=${BUILD_MODE} OUTPUT_DIR=bin/
+
+# --- Runtime Image
+FROM rockylinux/rockylinux:9 AS runtime
+
+ARG UNDERPOST_VERSION=3.2.9
+RUN dnf -y update && \
+    dnf -y install epel-release && \
+    dnf -y install --allowerasing \
+        curl git python3 \
+        procps-ng strace lsof vim-minimal && \
+    curl -fsSL https://rpm.nodesource.com/setup_24.x | bash - && \
+    dnf install -y nodejs && \
+    npm install -g underpost@${UNDERPOST_VERSION} && \
+    dnf clean all
+
+WORKDIR /home/dd/engine/cyberia-client
+
+COPY --from=builder /cyberia-client/server.py ./server.py
+COPY --from=builder /cyberia-client/bin       ./bin/
+
+ENV CYBERIA_PORT=8082
+ENV CYBERIA_MODE=development
+
+EXPOSE 8081 8082
+
+CMD ["sh", "-c", "exec python3 server.py ${CYBERIA_PORT} bin ${CYBERIA_MODE}"]

package/src/runtime/cyberia-server/Dockerfile

@@ -11,27 +11,52 @@ RUN dnf -y update && \
 
 WORKDIR /build
 
-# Cache dependency downloads independently of source changes
-COPY cyberia-server/go.mod cyberia-server/go.sum ./
+# Build context is the cyberia-server project repo root (the workflow
+# in .github/workflows/docker-image.cyberia-server.ci.yml sets
+# context: . from the cyberia-server checkout). The legacy
+# engine-context layout (COPY cyberia-server/ .) is no longer used.
+COPY go.mod go.sum ./
 RUN go mod download
 
-COPY cyberia-server/ ./
+COPY . ./
 RUN chmod +x build.sh && ./build.sh
 
 # --- Runtime Image
 FROM rockylinux/rockylinux:9 AS runtime
 
+# Runtime needs:
+#   - the compiled Go binary (cyberia-server itself)
+#   - nodejs + the underpost CLI globally, for the container-status
+#     lifecycle hooks (`underpost config set container-status ...`) that
+#     the conf.instances.json cmd invokes before / after launching the
+#     server binary. Installing it at build time avoids the slow
+#     `npm install -g` startup the K8S cmd would otherwise have to do
+#     on every pod boot.
+ARG UNDERPOST_VERSION=3.2.9
 RUN dnf -y update && \
     dnf -y install epel-release && \
     dnf -y install --allowerasing curl git && \
     curl -fsSL https://rpm.nodesource.com/setup_24.x | bash - && \
     dnf install -y nodejs && \
-    dnf clean all
+    npm install -g underpost@${UNDERPOST_VERSION} && \
+    dnf clean all && \
+    npm cache clean --force
 
 WORKDIR /home/dd/engine/cyberia-server
 
 COPY --from=builder /build/server ./server
 
+# Static SSR dashboard rendered by `node bin/cyberia run-workflow
+# build-server-dashboard --output-path <project-root>/public/index.html`
+# from inside the engine repo checkout. The Go server's findPublicDir()
+# hard-requires public/index.html at boot and log.Fatalf's without it.
+# CI writes the dashboard into ./public/ at the cyberia-server repo root
+# before docker build picks it up here.
+COPY public/ ./public/
+
 EXPOSE 8081
 
+# Default entrypoint when the image is run directly (not via K8S cmd).
+# In K8S deploys conf.instances.json supplies its own cmd that wraps env
+# sourcing + container-status hooks + this same binary.
 ENTRYPOINT ["/home/dd/engine/cyberia-server/server"]

package/src/runtime/cyberia-server/Dockerfile.dev

@@ -0,0 +1,71 @@
+# cyberia-server DEV runtime image.
+#
+# Differences vs the production Dockerfile in this same directory:
+#   - Builds the Go binary WITHOUT `-trimpath -ldflags="-s -w"` so symbols
+#     and source paths survive into the binary for stack traces and pprof.
+#   - Keeps -race (CGO-free race detector is not available; we still pass
+#     `-gcflags="all=-N -l"` to disable inlining + optimisations so the
+#     dlv debugger and live profilers can attach predictably).
+#   - Keeps `git`, `procps-ng`, `strace`, `lsof`, `vim`, `curl` in the
+#     runtime image so the operator can attach and inspect a misbehaving
+#     pod without re-baking the image. Production keeps the runtime
+#     layer minimal.
+#   - Does NOT strip the npm cache after `npm install -g underpost@…` so
+#     `npm upgrade -g underpost` works in a running container.
+#
+# Selected automatically by `node bin run instance-build-manifest`
+# whenever the `--dev` flag is set; the production Dockerfile in the
+# same directory is used otherwise.
+
+# --- Build Image
+FROM rockylinux/rockylinux:9 AS builder
+
+RUN dnf -y update && \
+    dnf -y install epel-release && \
+    dnf -y install --allowerasing \
+    git \
+    make \
+    golang && \
+    dnf clean all
+
+WORKDIR /build
+
+# Build context is the cyberia-server project repo root (see the
+# production Dockerfile in this directory for the rationale).
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . ./
+# Dev build: keep source paths, disable inlining + optimisations.
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
+      go build -gcflags="all=-N -l" -o server ./cmd/cyberia-server/ && \
+    echo "DEV build complete: $(pwd)/server"
+
+# --- Runtime Image
+FROM rockylinux/rockylinux:9 AS runtime
+
+ARG UNDERPOST_VERSION=3.2.9
+RUN dnf -y update && \
+    dnf -y install epel-release && \
+    dnf -y install --allowerasing \
+        curl git \
+        procps-ng strace lsof vim-minimal && \
+    curl -fsSL https://rpm.nodesource.com/setup_24.x | bash - && \
+    dnf install -y nodejs && \
+    npm install -g underpost@${UNDERPOST_VERSION} && \
+    dnf clean all
+
+WORKDIR /home/dd/engine/cyberia-server
+
+COPY --from=builder /build/server ./server
+
+# Static SSR dashboard — required by the Go server's findPublicDir() at boot.
+# See the production Dockerfile in this directory for the full rationale.
+# The same `node bin/cyberia run-workflow build-server-dashboard --dev
+# --output-path <project-root>/public/index.html` command is executed by
+# the CI workflow before docker build.
+COPY public/ ./public/
+
+EXPOSE 8081
+
+ENTRYPOINT ["/home/dd/engine/cyberia-server/server"]

package/src/runtime/express/Express.js

@@ -15,7 +15,7 @@ import { createServer } from 'http';
 import { loggerFactory, loggerMiddleware } from '../../server/logger.js';
 import { getCapVariableName, newInstance } from '../../client/components/core/CommonJs.js';
 import { MailerProvider } from '../../mailer/MailerProvider.js';
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { createPeerServer } from '../../server/peer.js';
 import { createValkeyConnection } from '../../server/valkey.js';
 import { applySecurity, authMiddlewareFactory } from '../../server/auth.js';
@@ -192,7 +192,7 @@ class ExpressService {
       }
 
       // Database and Valkey connections
-      if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
+      if (db && apis) await DataBaseProviderService.load({ apis, host, path, db });
 
       if (valkey) await createValkeyConnection({ host, path }, valkey);