@underpostnet/cyberia 3.3.73 → 3.3.77

package/src/projects/cyberia/seed-audio.js

@@ -0,0 +1,139 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getFallbackMapCodes } from '../../api/cyberia-instance/cyberia-fallback-world.js';
+import {
+  DEFAULT_AUDIO_BANK,
+  DEFAULT_AUDIO_SETTINGS,
+  DEFAULT_MAP_MUSIC,
+  buildAudioEventBindings,
+} from '../../api/cyberia-server-defaults/cyberia-server-defaults.js';
+import { CyberiaAudioService } from '../../api/cyberia-audio/cyberia-audio.service.js';
+import { CyberiaMapAudioConfService } from '../../api/cyberia-map-audio-conf/cyberia-map-audio-conf.service.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
+
+/**
+ * Resolves the canonical audio defaults against a list of map codes.
+ *
+ * The vocabulary, the bank and the bindings are owned by cyberia-server-defaults; this only states
+ * them per map. Every map of a world carries the same bed and the same bindings, so a world sounds
+ * like itself wherever the player stands, and what changes a place is the event that fires there.
+ *
+ * @param {string[]} mapCodes - Map codes the world declares.
+ * @returns {{assets: string[], settings: object, events: object[], maps: object[]}}
+ */
+const audioConfigForMaps = (mapCodes) => ({
+  // The codes the world needs imported; the client fetches every one of them by code.
+  assets: DEFAULT_AUDIO_BANK.map(({ code }) => code),
+  settings: DEFAULT_AUDIO_SETTINGS,
+  events: buildAudioEventBindings(),
+  maps: mapCodes.map((mapCode) => ({ mapCode, defaultMusic: DEFAULT_MAP_MUSIC })),
+});
+
+/** The canonical audio configuration of the fallback world. */
+const fallbackAudioConfig = () => audioConfigForMaps(getFallbackMapCodes());
+
+// The renderer lives in cyberia-audio, a sibling repository this one does not contain (see
+// .gitignore, alongside cyberia-server and cyberia-client). Named once so the runtime and the
+// suites that need real bytes ask the same question of the same path.
+const AUDIO_RENDERER_URL = new URL('../../../cyberia-audio/src/dispatcher.js', import.meta.url);
+
+/** Whether the cyberia-audio renderer is present beside this repository. */
+const hasAudioRenderer = () => fs.existsSync(AUDIO_RENDERER_URL);
+
+/**
+ * Loads the cyberia-audio dispatcher, or says plainly what is missing.
+ *
+ * A bare dynamic import fails here with a resolver message that names neither the project nor
+ * what to do about it, and a fresh checkout hits that before anything else.
+ *
+ * @returns {Promise<{dispatch: Function}>}
+ */
+async function loadAudioRenderer() {
+  if (!hasAudioRenderer()) {
+    throw new Error(
+      `cyberia-audio renderer not found at ${fileURLToPath(AUDIO_RENDERER_URL)}. It is a sibling ` +
+        'repository, not part of engine — clone it beside this one to record the audio bank.',
+    );
+  }
+  return await import(AUDIO_RENDERER_URL.href);
+}
+
+/**
+ * Records the fallback audio the world needs, as `<code>.wav` + `<code>.json` pairs.
+ *
+ * Recording is where the bytes are produced and nowhere else: the client ships no audio and
+ * fetches every asset from engine-cyberia by code, so there is no bundle to build alongside these.
+ *
+ * @param {{recordsPath: string}} params - Output directory for the recorded pairs.
+ * @returns {Promise<object>} The fallback audio configuration these recordings satisfy.
+ */
+async function prepareFallbackAudio({ recordsPath }) {
+  const { dispatch } = await loadAudioRenderer();
+  const config = fallbackAudioConfig();
+  await fs.ensureDir(recordsPath);
+  for (const { code, bus, options } of DEFAULT_AUDIO_BANK) {
+    const output = path.resolve(recordsPath, `${code}.wav`);
+    await dispatch(bus, code, { sampleRate: 22050, ...options }, { play: false, record: true, path: output });
+  }
+  return config;
+}
+
+/**
+ * Imports the bank and writes one complete audio configuration per map.
+ *
+ * @param {object} config - As {@link audioConfigForMaps} resolves it.
+ * @param {{recordsPath: string}} params - Directory holding the recorded pairs.
+ * @param {{host: string, path: string}} options - Provider context.
+ * @returns {Promise<{assets: object[], maps: object[]}>}
+ */
+async function seedMapAudio(config, { recordsPath }, options) {
+  const assets = await CyberiaAudioService.importRecords({ recordsPath, codes: config.assets }, options);
+  if (assets.length !== config.assets.length) throw new Error('Seeding audio requires every WAV and manifest pair');
+  const maps = [];
+  for (const map of config.maps) {
+    // The seed states the whole configuration, so re-running it converges: a binding whose logic
+    // event this bank no longer declares is dropped rather than left behind pointing at an asset
+    // the client can no longer resolve.
+    maps.push(
+      await CyberiaMapAudioConfService.assign(
+        { ...map, settings: config.settings, events: config.events, replaceEvents: true },
+        options,
+      ),
+    );
+  }
+  return { assets, maps };
+}
+
+const seedFallbackAudio = ({ recordsPath }, options) =>
+  seedMapAudio(fallbackAudioConfig(), { recordsPath }, options);
+
+/**
+ * Scores one instance's maps with the canonical bank.
+ *
+ * Every map the instance declares is scored with the same bank, bed and bindings the fallback
+ * world uses, so any world sounds the way that one does.
+ *
+ * @param {{instanceCode: string, recordsPath: string}} params - Target instance and records directory.
+ * @param {{host: string, path: string}} options - Provider context.
+ * @returns {Promise<{assets: object[], maps: object[]}>}
+ * @throws {Error} When the instance does not exist or declares no maps.
+ */
+async function seedInstanceAudio({ instanceCode, recordsPath }, options) {
+  const CyberiaInstance = DataBaseProviderService.getModel('CyberiaInstance', options);
+  const instance = await CyberiaInstance.findOne({ code: instanceCode }).select('cyberiaMapCodes').lean();
+  if (!instance) throw new Error(`cyberia-instance not found for code="${instanceCode}"`);
+  const mapCodes = instance.cyberiaMapCodes ?? [];
+  if (mapCodes.length === 0) throw new Error(`cyberia-instance "${instanceCode}" declares no maps`);
+  return seedMapAudio(audioConfigForMaps(mapCodes), { recordsPath }, options);
+}
+
+export {
+  audioConfigForMaps,
+  fallbackAudioConfig,
+  hasAudioRenderer,
+  loadAudioRenderer,
+  prepareFallbackAudio,
+  seedFallbackAudio,
+  seedInstanceAudio,
+};

package/src/projects/cyberia/semantic-layer-generator-skin.js

@@ -28,6 +28,7 @@
  * @namespace SemanticLayerGeneratorSkin
  */
 import { readFileSync } from 'fs';
+import { STAT_DEFAULTS } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import crypto from 'crypto';
@@ -1070,14 +1071,7 @@ function generateSkinMultiFrame(options, _descriptor) {
         description: `Procedurally generated character skin (seed: ${seed})`,
         activable: true,
       },
-      stats: {
-        effect: 0,
-        resistance: 0,
-        agility: 0,
-        range: 0,
-        intelligence: 0,
-        utility: 0,
-      },
+      stats: { ...STAT_DEFAULTS },
       ledger: { type: 'OFF_CHAIN' },
       seed: localSeedToUUIDv4(`${seed}:${itemId}`),
     },

package/src/projects/cyberia/semantic-layer-generator.js

@@ -17,6 +17,7 @@
  */
 
 import crypto from 'crypto';
+import { generateRandomStats } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
 
 import { createRng, seedToInt, createNoise2D, generateShape, listShapes } from './shape-generator.js';
 import { loggerFactory } from '../../server/ops/logger.js';
@@ -703,14 +704,7 @@ export function generateMultiFrame(options) {
         description: `Procedurally generated ${descriptor.semanticTags.join(', ')} (seed: ${seed})`,
         activable: true,
       },
-      stats: {
-        effect: hashMod(seed + ':effect', 11),
-        resistance: hashMod(seed + ':resistance', 11),
-        agility: hashMod(seed + ':agility', 11),
-        range: hashMod(seed + ':range', 11),
-        intelligence: hashMod(seed + ':intelligence', 11),
-        utility: hashMod(seed + ':utility', 11),
-      },
+      stats: generateRandomStats(undefined, undefined, createRng(seedToInt(seed + ':stats'))),
       ledger: { type: 'OFF_CHAIN' },
       seed: seedToUUIDv4(seed + ':' + itemId),
     },
@@ -726,16 +720,6 @@ export function generateMultiFrame(options) {
   };
 }
 
-/**
- * Deterministic modulo hash for stat generation.
- * @param {string} str
- * @param {number} mod
- * @returns {number}
- */
-function hashMod(str, mod) {
-  return ((hashString(str) % mod) + mod) % mod;
-}
-
 /* ═══════════════════════════════════════════════════════════════════════════
  *  EXPORTS
  * ═══════════════════════════════════════════════════════════════════════════ */

package/src/projects/cyberia/stat-balance.js

@@ -0,0 +1,81 @@
+import {
+  STAT_MODIFIER_MAX,
+  STAT_MODIFIER_MIN,
+  STAT_TYPES,
+  statBoundsForType,
+  validateStatModifier,
+  validateStats,
+} from '../../client/components/cyberia/SharedDefaultsCyberia.js';
+
+/**
+ * Stat balancing for every object layer the content pipeline writes.
+ *
+ * One policy resolves the bounds each stat may take, then either clamps the stats the content
+ * carries or draws new ones inside those bounds. The same policy answers every write path, so a
+ * run with a given policy over given content is deterministic.
+ *
+ * @typedef {Object} StatPolicy
+ * @property {boolean} [normalize=false] - Bound each stat by the item type's semantic range.
+ * @property {boolean} [random=false] - Replace every stat with a value drawn inside its bounds.
+ * @property {number} [min] - Narrow every bound from below.
+ * @property {number} [max] - Narrow every bound from above.
+ */
+
+/** Whether a policy changes anything at all. */
+export const statPolicyActive = ({ normalize = false, random = false } = {}) => normalize || random;
+
+/**
+ * The inclusive `[min, max]` each stat may take under a policy for one item type.
+ *
+ * The semantic range wins: `min` and `max` narrow it, and a request that leaves no overlap pins
+ * the stat to the semantic edge nearest the request. Without `normalize` the contract range is
+ * the whole range.
+ *
+ * @param {string} itemType
+ * @param {StatPolicy} policy
+ * @returns {Record<string,[number,number]>}
+ */
+export function resolveStatBounds(itemType, { normalize = false, min, max } = {}) {
+  if (min !== undefined) validateStatModifier(min);
+  if (max !== undefined) validateStatModifier(max);
+  if (min !== undefined && max !== undefined && min > max)
+    throw new RangeError('Stat minimum must not exceed maximum.');
+  const semantic = normalize
+    ? statBoundsForType(itemType)
+    : Object.fromEntries(STAT_TYPES.map((key) => [key, [STAT_MODIFIER_MIN, STAT_MODIFIER_MAX]]));
+  return Object.fromEntries(
+    STAT_TYPES.map((key) => {
+      const [lo, hi] = semantic[key];
+      const low = Math.max(lo, min ?? lo);
+      const high = Math.min(hi, max ?? hi);
+      if (low <= high) return [key, [low, high]];
+      // No overlap: the semantic edge the request points at.
+      const pinned = (min ?? lo) > hi ? hi : lo;
+      return [key, [pinned, pinned]];
+    }),
+  );
+}
+
+/**
+ * Applies a policy to one item's stats.
+ *
+ * @param {Object} params
+ * @param {Object} params.stats - Stats as the content carries them.
+ * @param {string} params.itemType
+ * @param {StatPolicy} [params.policy]
+ * @param {() => number} [params.random=Math.random] - Source in [0, 1) for a random draw.
+ * @returns {Record<string,number>} The balanced stats, in canonical order.
+ */
+export function balanceStats({ stats, itemType, policy = {}, random = Math.random }) {
+  const current = validateStats(stats);
+  const bounds = resolveStatBounds(itemType, policy);
+  return Object.fromEntries(
+    STAT_TYPES.map((key) => {
+      const [lo, hi] = bounds[key];
+      if (!policy.random) return [key, Math.min(hi, Math.max(lo, current[key]))];
+      const value = random();
+      if (!Number.isFinite(value) || value < 0 || value >= 1) throw new RangeError('Random source must return [0, 1).');
+      return [key, Math.floor(value * (hi - lo + 1)) + lo];
+    }),
+  );
+}

package/src/projects/cyberia/stat-commands.js

@@ -0,0 +1,23 @@
+import { readFile } from 'node:fs/promises';
+import { generateRandomStats, validateStats } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
+import { PROGRESSION_RULES_DEFAULTS } from '../../api/cyberia-server-defaults/cyberia-server-defaults.js';
+import { generateStatContract } from './stat-contract-generator.js';
+
+export function registerStatCommands(program) {
+  const stats = program.command('stats').description('Validate signed stats and inspect progression rules.');
+  stats.command('random').option('--min <number>').option('--max <number>').action((options) => {
+    const min = options.min === undefined ? undefined : Number(options.min);
+    const max = options.max === undefined ? undefined : Number(options.max);
+    console.log(JSON.stringify(generateRandomStats(min, max), null, 2));
+  });
+  stats.command('validate <file>').action(async (file) => {
+    const input = JSON.parse(await readFile(file, 'utf8'));
+    const records = Array.isArray(input) ? input : [input];
+    for (const record of records) validateStats(record.data?.stats ?? record.stats ?? record);
+    console.log(JSON.stringify({ valid: true, records: records.length }));
+  });
+  stats.command('progression').action(() => console.log(JSON.stringify(PROGRESSION_RULES_DEFAULTS, null, 2)));
+  program.command('stat-contract').option('--check', 'Check generated Go and C files.').action(async (options) => {
+    console.log(JSON.stringify(await generateStatContract({ check: !!options.check })));
+  });
+}

package/src/projects/cyberia/stat-contract-generator.js

@@ -0,0 +1,101 @@
+import { buildBootContractArtifacts } from './boot-contract-fixtures.js';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolve, dirname } from 'node:path';
+import { STAT_TYPES, STAT_DEFINITIONS, STAT_MODIFIER_MIN, STAT_MODIFIER_MAX, STAT_EFFECTIVE_FLOORS, STAT_SCALES, STAT_REGEN_PER_RESISTANCE } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
+import { PROGRESSION_RULES_DEFAULTS, PROGRESSION_RULE_LIMITS } from '../../api/cyberia-server-defaults/cyberia-server-defaults.js';
+
+const field = (key) => key[0].toUpperCase() + key.slice(1);
+const values = (stats) => STAT_TYPES.map((key) => stats[key]).join(', ');
+
+export function buildStatContractArtifacts() {
+  const go = `// Code generated by Cyberia stat-contract. DO NOT EDIT.
+package game
+const StatCount = ${STAT_TYPES.length}
+const StatModifierMin = ${STAT_MODIFIER_MIN}
+const StatModifierMax = ${STAT_MODIFIER_MAX}
+func (r ProgressionRules) validScalarBounds() bool { return ${Object.entries(PROGRESSION_RULE_LIMITS).map(([key, [min, max]]) => `r.${field(key)} >= ${min} && r.${field(key)} <= ${max}`).join(' && ')} }
+var statNames = [StatCount]string{${STAT_TYPES.map(JSON.stringify).join(', ')}}
+var statEffectiveFloors = [StatCount]float64{${values(STAT_EFFECTIVE_FLOORS)}}
+// statScales is what one point of each stat is worth in the simulation.
+var statScales = ComputedStats{${STAT_TYPES.map((key) => `${field(key)}: ${STAT_SCALES[key]}`).join(', ')}}
+const statRegenPerResistance = ${STAT_REGEN_PER_RESISTANCE}
+type Stats struct {
+${STAT_TYPES.map((key) => `${field(key)} int \`json:"${key}"\``).join('\n')}
+}
+type ComputedStats struct {
+${STAT_TYPES.map((key) => `${field(key)} float64 \`json:"${key}"\``).join('\n')}
+}
+func (s Stats) computed() ComputedStats { return ComputedStats{${STAT_TYPES.map((key) => `${field(key)}: float64(s.${field(key)})`).join(', ')}} }
+func (s ComputedStats) Values() [StatCount]float64 { return [StatCount]float64{${STAT_TYPES.map((key) => `s.${field(key)}`).join(', ')}} }
+func statsFromValues(v [StatCount]float64) ComputedStats { return ComputedStats{${STAT_TYPES.map((key, i) => `${field(key)}: v[${i}]`).join(', ')}} }
+func defaultProgressionRules() ProgressionRules { return ProgressionRules{
+${Object.entries(PROGRESSION_RULES_DEFAULTS).map(([key, value]) => `${field(key)}: ${typeof value === 'object' ? `ComputedStats{${values(value)}}` : value},`).join('\n')}
+} }
+`;
+  const header = `/* Code generated by Cyberia stat-contract. DO NOT EDIT. */
+#ifndef CYBERIA_STAT_CONTRACT_H
+#define CYBERIA_STAT_CONTRACT_H
+#define CYBERIA_STAT_COUNT ${STAT_TYPES.length}
+static const char* const CYBERIA_STAT_NAMES[CYBERIA_STAT_COUNT] = {${STAT_TYPES.map(JSON.stringify).join(', ')}};
+typedef struct {
+${STAT_TYPES.map((key) => '    int ' + key + ';').join('\n')}
+} Stats;
+static inline void cyberia_stats_values(const Stats* stats, int values[CYBERIA_STAT_COUNT]) {
+${STAT_TYPES.map((key, i) => '    values[' + i + '] = stats->' + key + ';').join('\n')}
+}
+static inline Stats cyberia_stats_from_values(const int values[CYBERIA_STAT_COUNT]) {
+    return (Stats){${STAT_TYPES.map((key, i) => 'values[' + i + ']').join(', ')}};
+}
+static const char* const CYBERIA_STAT_ICONS[CYBERIA_STAT_COUNT] = {${STAT_TYPES.map((key) => JSON.stringify('stat-' + key)).join(', ')}};
+static const char* const CYBERIA_STAT_LABELS[CYBERIA_STAT_COUNT] = {${STAT_DEFINITIONS.map(({ title }) => JSON.stringify(title)).join(', ')}};
+#endif
+`;
+  const temporary = mkdtempSync(join(tmpdir(), 'cyberia-stat-contract-'));
+  let formatted;
+  try {
+    const source = join(temporary, 'contract.go');
+    writeFileSync(source, go);
+    execFileSync('gofmt', ['-w', source], { stdio: 'inherit', timeout: 30000 });
+    formatted = readFileSync(source, 'utf8');
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+  return {
+    'cyberia-server/game/stat_contract_generated.go': formatted,
+    'cyberia-client/src/domain/stat_contract_generated.h': header,
+  };
+}
+
+/**
+ * Whether cyberia-server and cyberia-client sit beside this repository.
+ *
+ * Both are gitignored siblings (see .gitignore, alongside cyberia-audio), so a checkout that
+ * publishes only this repo's tracked tree — the engine-cyberia npm mirrors, for one — never has
+ * them. {@link generateStatContract} writes into both; callers that only run in a full
+ * multi-repo checkout should skip rather than fail on a missing sibling.
+ *
+ * @param {string} [root] - Defaults to this repository's own root.
+ * @returns {boolean}
+ */
+export function hasCyberiaSiblings(root = fileURLToPath(new URL('../../../', import.meta.url))) {
+  return existsSync(resolve(root, 'cyberia-server')) && existsSync(resolve(root, 'cyberia-client'));
+}
+
+export async function generateStatContract({ root = fileURLToPath(new URL('../../../', import.meta.url)), check = false } = {}) {
+  const artifacts = { ...buildStatContractArtifacts(), ...buildBootContractArtifacts() };
+  for (const [path, content] of Object.entries(artifacts)) {
+    const target = resolve(root, path);
+    if (check) {
+      if (await readFile(target, 'utf8') !== content) throw new Error(`Regenerate ${path} with cyberia stat-contract.`);
+    } else {
+      await mkdir(dirname(target), { recursive: true });
+      await writeFile(target, content);
+    }
+  }
+  return Object.keys(artifacts);
+}

package/src/runtime/cyberia-client/Dockerfile

@@ -38,17 +38,21 @@ RUN set -eux; \
     underpost --version
 
 # Path + server layout is the contract with conf.instances.json mmo-client cmd,
-# which execs `python3 /home/dd/engine/cyberia-client/docker-driver.py <port>
-# /home/dd/engine/cyberia-client/bin` in both development and production.
+# which execs `python3 /home/dd/engine/cyberia-client/wasm-driver.py --port=<port>
+# --directory=/home/dd/engine/cyberia-client/bin --data-server-url=<url>` in both
+# development and production.
 # Keep this identical to Dockerfile.dev so prod and dev images are interchangeable.
 WORKDIR /home/dd/engine/cyberia-client
 
-COPY --from=builder /cyberia-client/docker-driver.py ./docker-driver.py
+COPY --from=builder /cyberia-client/wasm-driver.py ./wasm-driver.py
 COPY --from=builder /cyberia-client/bin              ./bin/
 
 ENV PYTHONUNBUFFERED=1
 ENV CYBERIA_PORT=8081
+# Mirrors the --data-server-url default in wasm-driver.py: the CMD below always passes the flag,
+# so leaving this unset would hand the client an empty origin rather than that default.
+ENV CYBERIA_DATA_SERVER_URL=https://cyberiaonline.com
 
 EXPOSE 8081
 
-CMD ["sh", "-c", "exec python3 docker-driver.py ${CYBERIA_PORT} bin"]
+CMD ["sh", "-c", "exec python3 wasm-driver.py --port=${CYBERIA_PORT} --directory=bin --data-server-url=${CYBERIA_DATA_SERVER_URL}"]

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

@@ -71,11 +71,14 @@ RUN set -eux; \
 
 WORKDIR /home/dd/engine/cyberia-client
 
-COPY --from=builder /cyberia-client/docker-driver.py ./docker-driver.py
+COPY --from=builder /cyberia-client/wasm-driver.py ./wasm-driver.py
 COPY --from=builder /cyberia-client/bin              ./bin/
 
 ENV CYBERIA_PORT=8082
+# Mirrors the --data-server-url default in wasm-driver.py: the CMD below always passes the flag,
+# so leaving this unset would hand the client an empty origin rather than that default.
+ENV CYBERIA_DATA_SERVER_URL=https://cyberiaonline.com
 
 EXPOSE 8081 8082
 
-CMD ["sh", "-c", "exec python3 docker-driver.py ${CYBERIA_PORT} bin"]
+CMD ["sh", "-c", "exec python3 wasm-driver.py --port=${CYBERIA_PORT} --directory=bin --data-server-url=${CYBERIA_DATA_SERVER_URL}"]

package/src/runtime/cyberia-server/Dockerfile

@@ -1,5 +1,5 @@
 # --- Build Image ---
-FROM golang:1.24 AS builder
+FROM golang:1.25 AS builder
 
 WORKDIR /build
 
@@ -45,4 +45,11 @@ COPY public/ ./public/
 
 EXPOSE 8081
 
-ENTRYPOINT ["/home/dd/engine/cyberia-server/server"]
+# Both Data Server endpoints are flags, not environment reads (cmd/cyberia-server/main.go), and
+# the server refuses to start without them. Passing them here from the environment is what lets a
+# plain `docker run` or a Compose service that sets no command still start: a Kubernetes pod spec
+# supplies its own command and overrides this.
+ENV CYBERIA_DATA_SERVER_URL=http://engine-cyberia
+ENV CYBERIA_DATA_SERVER_GRPC=engine-cyberia-runtime:50051
+
+CMD ["sh", "-c", "exec /home/dd/engine/cyberia-server/server --data-server-url=${CYBERIA_DATA_SERVER_URL} --data-server-grpc=${CYBERIA_DATA_SERVER_GRPC}"]

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

@@ -59,4 +59,11 @@ COPY public/ ./public/
 
 EXPOSE 8081
 
-ENTRYPOINT ["/home/dd/engine/cyberia-server/server"]
+# Both Data Server endpoints are flags, not environment reads (cmd/cyberia-server/main.go), and
+# the server refuses to start without them. Passing them here from the environment is what lets a
+# plain `docker run` or a Compose service that sets no command still start: a Kubernetes pod spec
+# supplies its own command and overrides this.
+ENV CYBERIA_DATA_SERVER_URL=http://engine-cyberia
+ENV CYBERIA_DATA_SERVER_GRPC=engine-cyberia-runtime:50051
+
+CMD ["sh", "-c", "exec /home/dd/engine/cyberia-server/server --data-server-url=${CYBERIA_DATA_SERVER_URL} --data-server-grpc=${CYBERIA_DATA_SERVER_GRPC}"]

package/src/runtime/engine-cyberia/Dockerfile

@@ -6,7 +6,7 @@
 # Stage 1 — builder: clone the private deploy, build it, then scrub secrets.
 # ---------------------------------------------------------------------------
 FROM rockylinux/rockylinux:9 AS builder
-ARG UNDERPOST_VERSION=3.3.73
+ARG UNDERPOST_VERSION=3.3.77
 # Pin Node to an exact patch: dnf's nodejs:24 module lags (24.14.1) while
 # underpost's dependencies require >=24.15.0, so install the official binary.
 ARG NODE_VERSION=24.15.0

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

@@ -6,7 +6,7 @@
 # Stage 1 — builder: clone the private deploy, build it, then scrub secrets.
 # ---------------------------------------------------------------------------
 FROM rockylinux/rockylinux:9 AS builder
-ARG UNDERPOST_VERSION=3.3.73
+ARG UNDERPOST_VERSION=3.3.77
 # Pin Node to an exact patch: dnf's nodejs:24 module lags (24.14.1) while
 # underpost's dependencies require >=24.15.0, so install the official binary.
 ARG NODE_VERSION=24.15.0

package/src/runtime/engine-cyberia/Dockerfile.test

@@ -6,7 +6,7 @@
 # Stage 1 — builder: clone the private deploy, build it, then scrub secrets.
 # ---------------------------------------------------------------------------
 FROM rockylinux/rockylinux:9 AS builder
-ARG UNDERPOST_VERSION=3.3.73
+ARG UNDERPOST_VERSION=3.3.77
 # Pin Node to an exact patch: dnf's nodejs:24 module lags (24.14.1) while
 # underpost's dependencies require >=24.15.0, so install the official binary.
 ARG NODE_VERSION=24.15.0
@@ -72,7 +72,7 @@ RUN --mount=type=secret,id=github_token \
     # --- install deps + env, then replay build-safe itc provisioning ----------
     npm install; \
     node bin app load --env development --args deploy-id=dd-cyberia; \
-    node bin fs --pull --recursive --deploy-id dd-cyberia --storage-file-path './engine-private/conf/dd-cyberia/storage.engine-cyberia.json'; \
+    node bin fs --pull --tracked --deploy-id dd-cyberia --storage-id engine-cyberia; \
     ( cd /home/dd/engine/hardhat && npm install --include=dev ); \
     ( cd /home/dd/engine && underpost clone underpostnet/cyberia-server ); \
     \

package/src/runtime/engine-cyberia/compose.env

@@ -43,25 +43,37 @@ VALKEY_PORT=6379
 # cyberia-server-* -> stable engine gateway for HTTP and the raw engine runtime
 # for gRPC. The public engine-cyberia name belongs to nginx, avoiding ambiguous
 # Docker DNS while keeping one stable HTTP endpoint for every module.
-ENGINE_API_BASE_URL=http://engine-cyberia
-ENGINE_GRPC_ADDRESS=engine-cyberia-runtime:50051
+CYBERIA_DATA_SERVER_URL=http://engine-cyberia
+CYBERIA_DATA_SERVER_GRPC=engine-cyberia-runtime:50051
 
 # Client-visible Content Authority origin, forwarded to browser/Raylib clients
 # for every engine-cyberia content/asset/metadata request. Host-reachable
 # (Docker publishes the raw engine runtime on host :4005). Unlike the internal
-# ENGINE_API_BASE_URL, this value is consumed outside the Compose network:
+# CYBERIA_DATA_SERVER_URL, this value is consumed outside the Compose network:
 # the two responsibilities must never overwrite each other.
 ENGINE_PUBLIC_URL=http://localhost:4005
 ENGINE_GRPC_RELOAD_INTERVAL_SEC=300
 
-# --- Browser-facing client runtime config (injected by docker-driver.py) -----
+# Shared secret between the engine and every game server. It guards the server
+# registry report (server -> engine) and the hot-reload trigger (engine ->
+# server). Unset disables both: a server then stays out of the public list.
+CYBERIA_SERVER_API_KEY=change_me_dev_server_api_key
+
+# Public origin of the server gateway. Each server reports this origin plus its
+# own sub-path, which is the URL a client dials.
+CYBERIA_SERVER_PUBLIC_ORIGIN=http://localhost:8081
+
+# --- Browser-facing client runtime config (injected by wasm-driver.py) -----
 # The single WASM bundle resolves its instance from the URL sub-path and builds
 # its endpoints from these origins. HTTP client/API traffic uses nginx on :80;
 # WebSocket traffic uses the dedicated multi-path server gateway on :8081.
 #   http://localhost/          -> default, ws://localhost:8081/ws
 #   http://localhost/FOREST    -> FOREST,  ws://localhost:8081/FOREST/ws
 CYBERIA_WS_ORIGIN=ws://localhost:8081
-CYBERIA_ENGINE_API_ORIGIN=http://localhost
+# The browser's own route to the Data Server, through nginx on :80. Distinct from the internal
+# CYBERIA_DATA_SERVER_URL above: both name a Data Server origin, but from opposite sides of the
+# Compose network, and one file cannot hold two values under one name.
+CYBERIA_CLIENT_DATA_SERVER_URL=http://localhost
 CYBERIA_DEFAULT_INSTANCE=amethyst-strata-expansion
 
 # cyberia-server logging. This is the dev stack, so default to DEBUG. Set