cyberia 3.2.5 → 3.2.9

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

@@ -10,6 +10,7 @@
 
 import * as grpc from '@grpc/grpc-js';
 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';
@@ -50,6 +51,101 @@ function getModels(dbKey) {
   return bucket.mongoose.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 {
+    entityType: entityDefault.entityType ?? canonical.entityType ?? '',
+    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,
+      quantity: ol.quantity || 0,
+    })),
+  };
+}
+
+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;
+      }
+      if (entityDefault.colorKey && canonical.colorKey === entityDefault.colorKey) {
+        return 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;
+      }
+    }
+
+    if (bestLiveOverlapIndex !== -1) {
+      return bestLiveOverlapIndex;
+    }
+    return firstSameTypeIndex;
+  };
+
+  const unusedCandidateIndexes = canonicalDefaults.map((_, index) => index).filter((index) => !usedIndexes.has(index));
+
+  const preferredIndex = pickBestIndex(unusedCandidateIndexes);
+  if (preferredIndex !== -1) {
+    return preferredIndex;
+  }
+  return pickBestIndex(canonicalDefaults.map((_, index) => index));
+}
+
+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;
+    }
+
+    mergedDefaults[canonicalIndex] = normalizeEntityDefault(entityDefault, ENTITY_TYPE_DEFAULTS[canonicalIndex]);
+    usedCanonicalIndexes.add(canonicalIndex);
+  }
+
+  return mergedDefaults;
+}
+
 // ── Mongoose doc → protobuf message converters ───────────────────
 
 function toObjectLayerMsg(doc) {
@@ -58,13 +154,6 @@ function toObjectLayerMsg(doc) {
   const stats = d.stats || {};
   const ledger = d.ledger || {};
   const render = d.render || {};
-  const rf = doc.objectLayerRenderFramesId;
-  let frameDuration = 250;
-  let isStateless = false;
-  if (rf && typeof rf === 'object') {
-    if (rf.frame_duration != null) frameDuration = rf.frame_duration;
-    if (rf.is_stateless != null) isStateless = rf.is_stateless;
-  }
   return {
     mongoId: String(doc._id),
     stats: {
@@ -92,12 +181,24 @@ function toObjectLayerMsg(doc) {
     },
     sha256: doc.sha256 || '',
     cid: doc.cid || '',
-    frameDuration,
-    isStateless,
   };
 }
 
+/**
+ * Parse a CSS rgba() colour string into {r, g, b, a} integer components.
+ * Returns {r:0, g:0, b:0, a:0} (transparent) when the string is absent or malformed.
+ */
+function parseRgba(str) {
+  if (!str) return { r: 0, g: 0, b: 0, a: 0 };
+  const m = str.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/);
+  if (!m) return { r: 0, g: 0, b: 0, a: 0 };
+  // CSS alpha is 0-1 (float); proto uses 0-255 (int).
+  const cssAlpha = m[4] !== undefined ? parseFloat(m[4]) : 1;
+  return { r: Number(m[1]), g: Number(m[2]), b: Number(m[3]), a: Math.round(cssAlpha * 255) };
+}
+
 function toEntityMsg(ent) {
+  const rgba = parseRgba(ent.color);
   return {
     entityType: ent.entityType || 'floor',
     initCellX: ent.initCellX || 0,
@@ -111,6 +212,10 @@ function toEntityMsg(ent) {
     maxLife: ent.maxLife || 0,
     lifeRegen: ent.lifeRegen || 0,
     portalSubtype: ent.portalSubtype || '',
+    colorR: rgba.r,
+    colorG: rgba.g,
+    colorB: rgba.b,
+    colorA: rgba.a,
   };
 }
 
@@ -159,36 +264,23 @@ function toInstanceConfig(gc) {
   const fb = FALLBACK_CONFIG_DEFAULTS;
   if (!gc) return buildFallbackConfig();
 
-  const colors =
-    gc.colors && gc.colors.length > 0
-      ? gc.colors.map((c) => ({
-          key: c.key || '',
-          r: c.r ?? 0,
-          g: c.g ?? 0,
-          b: c.b ?? 0,
-          a: c.a ?? 255,
-        }))
-      : fb.colors.map((c) => ({ ...c }));
-
-  // Merge entity defaults: use canonical ENTITY_TYPE_DEFAULTS as base, overlay with
-  // any instance-specific overrides stored in gc.entityDefaults.
-  const gcDefaults = gc.entityDefaults && gc.entityDefaults.length > 0 ? gc.entityDefaults : [];
-  const gcDefaultsMap = Object.fromEntries(gcDefaults.map((d) => [d.entityType, d]));
-  const entityDefaults = ENTITY_TYPE_DEFAULTS.map((canonical) => {
-    const override = gcDefaultsMap[canonical.entityType] ?? {};
-    const dols = override.defaultObjectLayers ?? canonical.defaultObjectLayers ?? [];
-    return {
-      entityType: canonical.entityType,
-      liveItemIds: override.liveItemIds ?? canonical.liveItemIds,
-      deadItemIds: override.deadItemIds ?? canonical.deadItemIds,
-      colorKey: override.colorKey ?? canonical.colorKey,
-      defaultObjectLayers: dols.map((ol) => ({
-        itemId: ol.itemId || '',
-        active: !!ol.active,
-        quantity: ol.quantity || 0,
-      })),
-    };
+  // 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 });
+    }
+  }
+
+  // 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,
@@ -233,9 +325,14 @@ function toInstanceConfig(gc) {
     lifeRegenChance: gc.lifeRegenChance ?? fb.lifeRegenChance,
     maxChance: gc.maxChance ?? fb.maxChance,
     entityDefaults,
-    skillConfig: (gc.skillConfig || []).map((sc) => ({
+    skillConfig: (gc.skillConfig && gc.skillConfig.length > 0 ? gc.skillConfig : fb.skillConfig).map((sc) => ({
       triggerItemId: sc.triggerItemId || '',
-      logicEventIds: sc.logicEventIds || [],
+      skills: (sc.skills || []).map((sk) => ({
+        logicEventId: sk.logicEventId || '',
+        name: sk.name || '',
+        description: sk.description || '',
+        summonedEntityItemId: sk.summonedEntityItemId || '',
+      })),
     })),
     skillRules: {
       projectileSpawnChance: gc.skillRules?.projectileSpawnChance ?? fb.skillRules.projectileSpawnChance,
@@ -302,10 +399,7 @@ function buildHandlers(dbKey) {
         if (call.request.itemTypeFilter) {
           filter['data.item.type'] = call.request.itemTypeFilter;
         }
-        const cursor = models.ObjectLayer.find(filter)
-          .populate('objectLayerRenderFramesId', { _id: 1, frame_duration: 1, is_stateless: 1 })
-          .lean()
-          .cursor();
+        const cursor = models.ObjectLayer.find(filter).lean().cursor();
         for await (const doc of cursor) {
           call.write(toObjectLayerMsg(doc));
         }
@@ -319,9 +413,7 @@ function buildHandlers(dbKey) {
     async getObjectLayer(call, callback) {
       try {
         const models = getModels(dbKey);
-        const doc = await models.ObjectLayer.findOne({ 'data.item.id': call.request.itemId })
-          .populate('objectLayerRenderFramesId', { _id: 1, frame_duration: 1, is_stateless: 1 })
-          .lean();
+        const doc = await models.ObjectLayer.findOne({ 'data.item.id': call.request.itemId }).lean();
         if (!doc)
           return callback({ code: grpc.status.NOT_FOUND, message: `ObjectLayer "${call.request.itemId}" not found` });
         callback(null, toObjectLayerMsg(doc));
@@ -344,7 +436,7 @@ function buildHandlers(dbKey) {
           models.GlobalMapCodeRegistry.findOneAndUpdate(
             { mapCode },
             { instanceCode, status: 'active' },
-            { upsert: true, new: true, timestamps: true },
+            { upsert: true, returnDocument: 'after', timestamps: true },
           ).catch((err) => logger.warn('getMapData registry update failed:', err.message));
         }
 
@@ -380,15 +472,14 @@ function buildHandlers(dbKey) {
           for (const d of fallbackConf.entityDefaults || []) {
             for (const id of d.liveItemIds || []) fallbackItemIds.add(id);
             for (const id of d.deadItemIds || []) fallbackItemIds.add(id);
+            for (const id of d.dropItemIds || []) fallbackItemIds.add(id);
             for (const ol of d.defaultObjectLayers || []) {
               if (ol.itemId) fallbackItemIds.add(ol.itemId);
             }
           }
 
           const fallbackOlDocs = fallbackItemIds.size
-            ? await models.ObjectLayer.find({ 'data.item.id': { $in: [...fallbackItemIds] } })
-                .populate('objectLayerRenderFramesId', { _id: 1, frame_duration: 1, is_stateless: 1 })
-                .lean()
+            ? await models.ObjectLayer.find({ 'data.item.id': { $in: [...fallbackItemIds] } }).lean()
             : [];
 
           callback(null, {
@@ -415,12 +506,27 @@ function buildHandlers(dbKey) {
             })),
             objectLayers: fallbackOlDocs.map(toObjectLayerMsg),
             config: toInstanceConfig(fallbackConf),
+            version: 'fallback',
           });
           return;
         }
 
         // ── Instance found — load maps + entity OLs + config default OLs ──────
-        const conf = inst.conf || {};
+        // `populate('conf')` returns null when the ObjectId ref is missing or
+        // orphaned (e.g. after a --conf import that preserved a stale _id).
+        // Fall back to a direct instanceCode lookup so aoiRadius and all other
+        // tuning fields are always read from the database, never silently
+        // replaced by FALLBACK_CONFIG_DEFAULTS.
+        let conf = inst.conf;
+        if (!conf) {
+          conf = await models.CyberiaInstanceConf.findOne({ instanceCode }).lean();
+          if (conf) {
+            logger.warn(
+              `getFullInstance: conf ref missing on instance "${instanceCode}" — resolved by instanceCode lookup`,
+            );
+          }
+        }
+        conf = conf || {};
         const mapCodes = inst.cyberiaMapCodes || [];
         const mapDocs = mapCodes.length ? await models.CyberiaMap.find({ code: { $in: mapCodes } }).lean() : [];
 
@@ -432,29 +538,35 @@ function buildHandlers(dbKey) {
           }
         }
 
-        // Also include "system" item IDs from the instance config so the
-        // Go server has their OL data cached without extra round trips:
-        // Include OL item IDs from entityDefaults so the Go server has all
-        // default atlas data cached at startup without needing extra round trips.
-        for (const d of conf.entityDefaults || []) {
+        // 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.
+        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);
+          for (const id of d.dropItemIds || []) itemIds.add(id);
           for (const ol of d.defaultObjectLayers || []) {
             if (ol.itemId) itemIds.add(ol.itemId);
           }
         }
 
         const olDocs = itemIds.size
-          ? await models.ObjectLayer.find({ 'data.item.id': { $in: [...itemIds] } })
-              .populate('objectLayerRenderFramesId', { _id: 1, frame_duration: 1, is_stateless: 1 })
-              .lean()
+          ? await models.ObjectLayer.find({ 'data.item.id': { $in: [...itemIds] } }).lean()
           : [];
 
+        // Opaque version string from updatedAt timestamps — the Go server
+        // compares this to skip full world rebuilds when nothing changed.
+        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));
+        const version = crypto.createHash('sha256').update(versionParts.join('|')).digest('hex');
+
         callback(null, {
           instance: toInstanceMsg(inst),
           maps: mapDocs.map(toMapMsg),
           objectLayers: olDocs.map(toObjectLayerMsg),
           config: toInstanceConfig(conf),
+          version,
         });
       } catch (err) {
         logger.error('getFullInstance:', err);
@@ -481,8 +593,8 @@ function buildHandlers(dbKey) {
 // Server lifecycle
 // ═══════════════════════════════════════════════════════════════════
 
-const GrpcServer = {
-  _server: null,
+class GrpcServer {
+  static _server = null;
 
   /**
    * @param {Object} opts
@@ -490,7 +602,7 @@ const GrpcServer = {
    * @param {string} opts.path  - DataBaseProvider path key
    * @param {number} [opts.port=50051]
    */
-  async start({ host, path: dbPath, port = 50051 } = {}) {
+  static async start({ host, path: dbPath, port = 50051 } = {}) {
     const dbKey = `${host}${dbPath}`;
     const server = new grpc.Server({
       'grpc.max_send_message_length': 64 * 1024 * 1024,
@@ -513,9 +625,9 @@ const GrpcServer = {
         resolve(server);
       });
     });
-  },
+  }
 
-  async stop() {
+  static async stop() {
     if (!GrpcServer._server) return;
     return new Promise((resolve) => {
       GrpcServer._server.tryShutdown(() => {
@@ -524,7 +636,7 @@ const GrpcServer = {
         resolve();
       });
     });
-  },
-};
+  }
+}
 
 export { GrpcServer };

package/src/index.js

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

package/src/runtime/cyberia-client/Dockerfile

@@ -0,0 +1,80 @@
+# BUILD_MODE: RELEASE | DEBUG
+ARG BUILD_MODE=RELEASE
+
+# --- Build Image
+FROM rockylinux/rockylinux:9 AS builder
+# Re-declare ARG after FROM so it is in scope for RUN
+ARG BUILD_MODE=RELEASE
+
+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
+
+# System packages (raylib gfx + build dependencies)
+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}"
+
+# Pin emsdk version for reproducible builds
+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
+COPY cyberia-client/ .
+
+RUN make -f Web.mk all BUILD_MODE=${BUILD_MODE} OUTPUT_DIR=bin/
+
+# --- Runtime Image
+FROM rockylinux/rockylinux:9 AS runtime
+
+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
+
+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=8081
+ENV CYBERIA_MODE=production
+
+EXPOSE 8081 8082
+
+CMD ["sh", "-c", "exec python3 server.py ${CYBERIA_PORT} bin ${CYBERIA_MODE}"]

package/src/runtime/cyberia-server/Dockerfile

@@ -0,0 +1,37 @@
+# --- 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
+
+# Cache dependency downloads independently of source changes
+COPY cyberia-server/go.mod cyberia-server/go.sum ./
+RUN go mod download
+
+COPY cyberia-server/ ./
+RUN chmod +x build.sh && ./build.sh
+
+# --- Runtime Image
+FROM rockylinux/rockylinux:9 AS runtime
+
+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
+
+WORKDIR /home/dd/engine/cyberia-server
+
+COPY --from=builder /build/server ./server
+
+EXPOSE 8081
+
+ENTRYPOINT ["/home/dd/engine/cyberia-server/server"]

package/src/runtime/express/Dockerfile

@@ -30,11 +30,11 @@ RUN dnf clean all
 RUN node --version
 RUN npm --version
 
-# Create non-root user for secure container execution (cron jobs, init containers)
-# Deployment containers override to root via securityContext when npm install -g is needed
-RUN useradd -m -u 1000 -s /bin/bash dd
+# Install underpost ci/cd cli
+RUN npm install -g underpost
+RUN underpost --version
 
-# Set working directory
+# Create working directory
 WORKDIR /home/dd
 
 # Expose necessary ports

package/src/runtime/lampp/Dockerfile

@@ -1,6 +1,6 @@
 FROM rockylinux:9
 
-# Update and install required packages
+# System packages 
 RUN dnf -y update && \
     dnf -y install epel-release && \
     dnf -y install --allowerasing \
@@ -20,13 +20,14 @@ RUN dnf -y update && \
     perl && \
     dnf clean all
 
-# --- Download and install XAMPP (PHP 8.2)
+
+# Download and install XAMPP (PHP 8.2)
 RUN curl -L -o /tmp/xampp-linux-installer.run "https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/8.2.12/xampp-linux-x64-8.2.12-0-installer.run" && \
     chmod +x /tmp/xampp-linux-installer.run && \
     bash -c "/tmp/xampp-linux-installer.run --mode unattended" && \
     ln -sf /opt/lampp/lampp /usr/bin/lampp
 
-# --- Create /xampp/htdocs (static root) and set permissions
+# Create /xampp/htdocs (static root) and set permissions
 RUN mkdir -p /opt/lampp/htdocs && \
     chown -R root:root /opt/lampp/htdocs && \
     chmod -R a+rX /opt/lampp/htdocs
@@ -47,11 +48,11 @@ RUN dnf clean all
 RUN node --version
 RUN npm --version
 
-# Create non-root user for secure container execution (cron jobs, init containers)
-# Deployment containers override to root via securityContext when npm install -g is needed
-RUN useradd -m -u 1000 -s /bin/bash dd
+# Install underpost CLI 
+RUN npm install -g underpost
+RUN underpost --version
 
-# Set working directory
+# Runtime root expected by startup/build scripts.
 WORKDIR /home/dd
 
 EXPOSE 22

package/src/runtime/wp/Dockerfile

@@ -1,13 +1,12 @@
 FROM rockylinux:9
 
-# Update and install required packages
+# System packages 
 RUN dnf -y update && \
     dnf -y install epel-release && \
     dnf -y install --allowerasing \
     bzip2 \
     sudo \
     curl \
-    unzip \
     net-tools \
     openssh-server \
     nano \
@@ -21,13 +20,13 @@ RUN dnf -y update && \
     perl && \
     dnf clean all
 
-# --- Download and install XAMPP (PHP 8.2)
+# Download and install XAMPP (PHP 8.2)
 RUN curl -L -o /tmp/xampp-linux-installer.run "https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/8.2.12/xampp-linux-x64-8.2.12-0-installer.run" && \
     chmod +x /tmp/xampp-linux-installer.run && \
     bash -c "/tmp/xampp-linux-installer.run --mode unattended" && \
     ln -sf /opt/lampp/lampp /usr/bin/lampp
 
-# --- Create /xampp/htdocs (static root) and set permissions
+# Create /xampp/htdocs (static root) and set permissions
 RUN mkdir -p /opt/lampp/htdocs && \
     chown -R root:root /opt/lampp/htdocs && \
     chmod -R a+rX /opt/lampp/htdocs
@@ -39,25 +38,20 @@ RUN echo 'export PATH="/opt/lampp/bin:/usr/local/bin:${PATH}"' > /etc/profile.d/
 # Provide a no-op sendmail so WP plugins don't error on mail calls
 RUN printf '#!/bin/sh\ncat > /dev/null\n' > /usr/sbin/sendmail && chmod +x /usr/sbin/sendmail
 
+# Install Node.js (includes npm)
+RUN curl -fsSL https://rpm.nodesource.com/setup_24.x | bash - && \
+    dnf install -y nodejs && \
+    dnf clean all
+
 # Install WP-CLI
 RUN curl -sL https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar -o /usr/local/bin/wp && \
     chmod +x /usr/local/bin/wp && \
     wp --info --allow-root
 
-# Install Node.js
-RUN curl -fsSL https://rpm.nodesource.com/setup_24.x | bash -
-RUN dnf install nodejs -y
-RUN dnf clean all
-
-# Verify Node.js and npm versions
-RUN node --version
-RUN npm --version
-
-# Create non-root user for secure container execution (cron jobs, init containers)
-# Deployment containers override to root via securityContext when npm install -g is needed
-RUN useradd -m -u 1000 -s /bin/bash dd
+# Install underpost CLI 
+RUN npm install -g underpost
 
-# Set working directory
+# Runtime root expected by startup/build scripts.
 WORKDIR /home/dd
 
 EXPOSE 22

package/src/server/atlas-sprite-sheet-generator.js

@@ -133,6 +133,7 @@ export class AtlasSpriteSheetGenerator {
    */
   static async generateAtlas(objectLayerRenderFrames, itemKey, cellPixelDim = 20, maxAtlasDim = null) {
     const { frames, colors } = objectLayerRenderFrames;
+    const frameDuration = Number(objectLayerRenderFrames?.frame_duration);
 
     // Direction order for consistent packing
     const directionOrder = [
@@ -255,13 +256,13 @@ export class AtlasSpriteSheetGenerator {
         frameMetadata[direction] = [];
       }
 
-      frameMetadata[direction].push({
+      frameMetadata[direction][frameIndex] = {
         x,
         y,
         width: image.bitmap.width,
         height: image.bitmap.height,
         frameIndex,
-      });
+      };
     }
 
     // Convert to PNG buffer
@@ -272,6 +273,7 @@ export class AtlasSpriteSheetGenerator {
       atlasWidth,
       atlasHeight,
       cellPixelDim,
+      frame_duration: Number.isFinite(frameDuration) ? frameDuration : 100,
       frames: frameMetadata,
     };