@underpostnet/cyberia 3.3.73 → 3.3.77

package/src/client/public/cyberia-docs/STATS-PROGRESSION.md

@@ -0,0 +1,217 @@
+# Cyberia stats and entity progression
+
+The Go server owns effective stats, XP, and level changes.
+The engine owns authored content, configuration, validation, and persistence.
+The client displays server state. The CLI validates content and generates shared contracts.
+
+## Canonical contract
+
+`src/client/components/cyberia/SharedDefaultsCyberia.js` defines the stat order, descriptions, modifier bounds, defaults, effective floors, and what one point is worth. The generated contract carries the scales to the server, so the simulation and the documentation read one table.
+
+| Index | Stat | One point | Effective floor |
+| --- | --- | --- | ---: |
+| 0 | `effect` | Removes one life point per hit | 1 |
+| 1 | `resistance` | Adds one point of maximum life and a tenth of a point to each regeneration | 0 |
+| 2 | `agility` | Adds one percent of base movement speed | -90 |
+| 3 | `range` | Adds fifty milliseconds of summon lifetime | 0 |
+| 4 | `intelligence` | Adds five percentage points of summon chance | 0 |
+| 5 | `utility` | Removes one percent of base cooldown and adds one percentage point of regeneration chance | 0 |
+
+Chances are fractions of one. A tap regenerates with `lifeRegenChance` (default 0.15) plus utility; a skill summons with its `skillRules` chance (projectile 0.75, doppelganger 0.6) plus intelligence. No chance the stats raise passes `maxChance` (default 0.95), so nothing becomes a certainty. Regeneration heals the entity's own base amount plus a tenth of a point per resistance point, never past its maximum.
+
+Each OL modifier is an integer from `-100` through `+100`. Zero is neutral.
+Missing stat keys resolve to zero. Unknown keys, fractions, numeric strings, null values, and values outside the bounds fail validation.
+An OL cannot store XP or level in `data.stats`.
+
+The editor marks negative values as penalties and positive values as bonuses.
+The randomizer validates its bounds and uses the full signed range by default.
+
+## Semantic bounds and balancing
+
+`STAT_TYPE_BOUNDS` in the same module declares the inclusive range each stat may take per item type. A weapon deals its effect and can cost resistance; a skin and a breastplate defend; a skill reaches; world content carries nothing. A type or stat absent there keeps the contract range.
+
+| Type | effect | resistance | agility | range | intelligence | utility |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| `weapon` | 5..20 | -10..2 | -5..5 | 0..10 | 0..5 | 0..10 |
+| `skin` | 1 | 0..20 | -5..10 | 0 | 0..2 | 0..5 |
+| `breastplate` | 0 | 5..30 | -15..0 | 0 | 0..3 | 0..5 |
+| `skill` | 0..15 | 0..5 | 0..5 | 5..30 | 0..10 | 0..10 |
+| `resource` | 0 | 0..10 | 0 | 0 | 0 | 0 |
+| world content | 0 | 0 | 0 | 0 | 0 | 0 |
+
+`src/projects/cyberia/stat-balance.js` applies one policy to every object layer the `ol` command writes: import, batch import, generation, atlas rebuilds, and the minify refresh. `--normalize-stats` clamps the stats the content carries into its type's range. `--random-stats` draws every stat inside the range instead. `--min-stat` and `--max-stat` narrow the range; a request that leaves no overlap pins the stat to the semantic edge nearest it. The policy is a pure function of the content and the flags, so a run is deterministic and normalizing is idempotent.
+
+## Aggregation and levels
+
+```text
+BaseStat(level) = baseStats[stat] + (level - 1) * perLevelStats[stat]
+EffectiveStat = max(floor, BaseStat(level) + ActiveOLStat + TemporaryStat)
+TotalXPForLevel(level) = xpPerLevel * (level - 1)^2
+```
+
+Each active OL with positive quantity contributes once. Stack quantity does not multiply its modifier.
+The server applies floors after the full sum. Effective values can exceed the OL bounds.
+Equipment rules still control item types, active slots, and required skins.
+
+Players, bots, NPCs, and resources share `EntityProgression`, the base curve, and stat aggregation.
+Bots, NPCs, and resources have frozen progression. Their content `level` selects the base stats.
+An absent content level uses `defaultBotLevel`. New players start at level 1 with zero XP.
+Terrain and other passive objects carry no progression state.
+
+Summoned entities inherit the caster's base and signed contributions, then add their own contributions.
+The server applies floors after inheritance. A caster cycle stops traversal.
+Temporary modifiers have an ID and expiry time. Setting the same ID replaces that modifier.
+The lifecycle phase removes expired modifiers and updates maximum life.
+
+The agility floor retains at least 10% of configured movement speed.
+The existing minimum action cooldown still applies. Resistance keeps maximum life and regeneration nonnegative.
+Increasing maximum life does not grant an instant heal.
+
+## Server configuration
+
+`src/api/cyberia-server-defaults/cyberia-server-defaults.js` owns progression defaults and configuration limits.
+Instance content can override `progressionRules`. Partial curves inherit missing defaults.
+The engine resolves and validates the complete configuration before transport.
+
+| Setting | Default |
+| --- | ---: |
+| `maxLevel` | 100 |
+| `xpPerLevel` | 100 |
+| `defaultBotLevel` | 1 |
+| `killXp` | 25 |
+| `objectiveXp` | 10 |
+| `questXp` | 100 |
+| `minAwardIntervalMs` | 500 |
+| `repeatWindowMs` | 60000 |
+| `maxRepeatAwards` | 4 |
+| `maxAwardsPerWindow` | 30 |
+
+The default base array is `[5, 10, 0, 0, 0, 0]`.
+The default growth array is `[2, 5, 1, 10, 1, 1]`.
+The first total XP thresholds are `0`, `100`, `400`, and `900`.
+One reward can advance several levels. XP stops at the maximum level threshold.
+
+Authored levels must be integers from 1 through 65535 and cannot exceed the instance maximum.
+Base and growth fields must be integers from 0 through 100.
+The CLI prints the current defaults with `node bin/cyberia.js stats progression`.
+
+Configuration participates in the instance version hash.
+The server validates stat bounds, curves, and authored levels before a full reload mutates state.
+An invalid reload retains its pending version so a corrected payload can retry.
+On a curve change, player XP selects the level under the new curve. The new maximum clamps XP.
+
+## XP rules
+
+Only resolved simulation events can award XP:
+
+- A player or bot defeat can award kill XP.
+- A resource defeat can award objective XP.
+- A completed quest can award quest XP once per quest code and session.
+
+A combat contributor must supply at least 10% of recorded positive damage.
+Self kills, summoned targets, item drops, providers, ghosts, and frozen players cannot produce eligible defeat rewards.
+Bots and NPCs cannot gain XP.
+
+Low-value outcomes share an award interval and a window limit.
+Repeated rewards for the same event kind and target divide by `1`, `2`, `3`, then `4`.
+Further repeats in that window award zero. Lower-level targets reduce the reward again.
+Integer division rounds down. Zero rewards do not consume an award slot.
+
+Unique quest completion bypasses the low-value interval and window limit.
+This permits a final kill and its quest completion to award XP in the same tick.
+Quest completion still rejects repeats.
+
+Raw taps, idle duration, inventory changes, and currency transfers award no XP.
+Player skills and tap regeneration share the server action cooldown. Movement input remains independent.
+
+## API and Object Layer specification
+
+An Object Layer record stores its contract marker outside hashed metadata. The model stamps it on every write:
+
+```json
+{
+  "statContractVersion": 2,
+  "data": {
+    "stats": {
+      "effect": -100,
+      "resistance": 100,
+      "agility": 0,
+      "range": 0,
+      "intelligence": 0,
+      "utility": 0
+    }
+  }
+}
+```
+
+This fragment omits the existing required item, ledger, and asset fields.
+The OL API, import path, generator, and boot assembler use the shared validator.
+Mongo schema validation also enforces integer bounds. API updates run validators.
+
+Entity content stores optional `level` beside `entityType` and `objectLayerItemIds`.
+The map editor preserves this field and accepts an optional level. An empty input uses the instance default.
+`InstanceConfig.progressionRules` carries the resolved server rules over gRPC and REST. Protobuf field 24 is reserved.
+
+The game link uses JSON envelopes over WebSocket. AOI stat arrays use canonical order.
+
+| Snapshot scope | Fields |
+| --- | --- |
+| Living entities | `level`, `effectiveStats[6]`, `statsSum` |
+| Viewing player only | `xp`, `levelXp`, `nextLevelXp`, `baseStats[6]`, `layerStats[6]`, `temporaryStats[6]` |
+
+`xp` is total XP. `levelXp` and `nextLevelXp` are the thresholds that bound the current level, so the client draws in-level progress without the curve. At maximum level, all three equal the final threshold.
+`statsSum` is an uncapped display summary, not an equipment budget.
+Passive objects omit `level` and `effectiveStats`. Other players do not receive private XP or base-stat breakdowns.
+The instance-map REST API serves authored topology and capabilities. It does not calculate simulation stats.
+
+An XP award sends a `combat_text` message of kind `xp` to the earner only. Damage and regen kinds stay broadcast to the area of interest.
+
+The overhead HUD of every living entity shows its level, its stats sum, and an XP bar under the HP bar. The bar fills with the viewing player's in-level progress and stays empty for other entities.
+The Stats tab draws one shared stat panel per block. Every entity gets its effective stats; the viewing player also gets OL, base, and temporary values.
+The level-up effect observes authoritative level increments for an entity already in view.
+First exposure, repeated snapshots, and level decreases produce no effect. Reconnect resets effects.
+The server broadcasts the `level-up` audio event to every viewer in reach when a player's level rises, and the `death` audio event on every defeat.
+
+## Progression lifetime
+
+The guest runtime assigns a new UUID for each WebSocket session.
+Progression survives death, respawn, portal travel, and world reload within that session.
+A disconnect or server restart ends that progression state.
+
+Persistent account progression requires an authenticated, stable account binding and an engine-owned persistence contract.
+The simulation server exposes no XP mutation API and stores no progression.
+
+## Generation and verification
+
+Generate contracts after a shared stat or progression-default change:
+
+```sh
+node bin/cyberia.js stat-contract
+node bin/cyberia.js stat-contract --check
+```
+
+The generator writes the Go contract, C header, and REST test fixtures. Do not edit these outputs by hand.
+Regenerate protobuf output with the existing protobuf toolchain when `gen/proto/cyberia.proto` changes.
+
+Inspect and validate content with:
+
+```sh
+node bin/cyberia.js stats progression
+node bin/cyberia.js stats validate /tmp/object-layers.json
+node bin/cyberia.js stats random --min=-100 --max=100
+```
+
+Focused engine tests:
+
+```sh
+node node_modules/vitest/vitest.mjs run test/integration/app/cyberia/cyberia-stats.test.js
+```
+
+Run `go test ./...` from `cyberia-server`. The REST and WebSocket tests need local loopback socket access.
+The tests cover signed bounds, floors, inheritance, expiry, thresholds, static levels, repeat limits, tap spam, and reload rejection.
+Generated REST fixtures and protobuf round trips check the engine/server contract.
+
+Run the native client tests, including the level-up effect, with `cyberia-client/tests/run.sh`.
+
+Build the client with its existing `Web.mk` target and Emscripten SDK.
+The SDK needs Python 3.10 or later and a writable cache.

package/src/client/public/cyberia-docs/WHITE-PAPER.md

@@ -18,7 +18,7 @@ _Stackable Rendering Layers as a Unified Tokenized Reality_
 
 ---
 
-**Version:** 3.3.73 | **Status:** Draft | **Authors:** Underpost Engineering
+**Version:** 3.3.77 | **Status:** Draft | **Authors:** Underpost Engineering
 
 ---
 
@@ -208,18 +208,26 @@ The `ObjectLayerToken` contract maps each `tokenId` → canonical `cid` on-chain
 
 ### 4.4 Canonical Stats Schema
 
-Stats govern mechanical behavior across all game systems (combat, movement, skills, drops):
+Each Object Layer contributes six signed integer modifiers in `[-100, +100]`. Zero is neutral.
+The canonical source is `SharedDefaultsCyberia.js`.
 
-```
-Stats {
-  effect:       int  // damage output / skill power
-  resistance:   int  // damage reduction
-  agility:      int  // movement speed modifier
-  range:        int  // attack / interaction range
-  intelligence: int  // skill cooldown / mana modifier
-  utility:      int  // general-purpose utility bonus
-}
-```
+| Stat           | Runtime meaning                                                       |
+| -------------- | --------------------------------------------------------------------- |
+| `effect`       | Life removed by an impact                                             |
+| `resistance`   | Maximum life bonus and life restored by regeneration                  |
+| `agility`      | Movement speed percentage modifier                                    |
+| `range`        | Summoned entity lifetime in milliseconds                              |
+| `intelligence` | Summon success chance modifier                                        |
+| `utility`      | Action cooldown percentage reduction and regeneration chance modifier |
+
+The server adds base stats at the entity level, active OL contributions, and temporary modifiers.
+It applies playable floors after this sum. Players, bots, NPCs, and resources use the same calculation.
+Bots and NPCs use assigned levels with frozen XP.
+
+XP belongs to entity progression. Resolved kills, resource defeats, and quest completions can award XP.
+Cooldowns, contribution checks, repeat limits, and rate limits restrict rewards. Raw taps and idle time award no XP.
+
+The current guest runtime keeps progression for one connected session.
 
 ### 4.5 Item Type Registry
 

package/src/client/services/cyberia-audio/cyberia-audio.service.js

@@ -0,0 +1,99 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory, buildQueryUrl } from '../core/core.service.js';
+const logger = loggerFactory(import.meta);
+logger.info('Load service');
+const endpoint = 'cyberia-audio';
+class CyberiaAudioService {
+  static post = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  static put = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'PUT',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  static get = (options = {}) => {
+    const { id, page, limit, filterModel, sortModel, sort, asc, order } = options;
+    const url = buildQueryUrl(getApiBaseUrl({ id, endpoint }), {
+      page,
+      limit,
+      filterModel,
+      sortModel,
+      sort,
+      asc,
+      order,
+    });
+    return new Promise((resolve, reject) =>
+      fetch(url.toString(), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  };
+  static delete = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'DELETE',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+}
+export { CyberiaAudioService };

package/src/client/services/cyberia-entity-type-default/cyberia-entity-type-default.service.js

@@ -95,5 +95,43 @@ class CyberiaEntityTypeDefaultService {
           return reject(error);
         }),
     );
+  /** Points one instance's conf at every default the given maps place. */
+  static syncInstance = (options = { instanceCode: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: `sync-instance/${options.instanceCode}`, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => await res.json())
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  /** States the complete set of instances that reference this default. */
+  static setInstances = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: `${options.id}/instances`, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => await res.json())
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
 }
 export { CyberiaEntityTypeDefaultService };

package/src/client/services/cyberia-instance/cyberia-instance.management.js

@@ -29,7 +29,7 @@ class CyberiaInstanceManagement {
             <i class="fa-solid fa-upload"></i>
           </div>`,
           class: `in fll section-mp management-table-btn-mini management-table-btn-load-instance-${idModal}-${cellRenderId} ${
-            !params.data._id ? 'hide' : ''
+            !params.data.code ? 'hide' : ''
           }`,
         })}`;
 
@@ -37,12 +37,13 @@ class CyberiaInstanceManagement {
           EventsUI.onClick(
             `.management-table-btn-load-instance-${idModal}-${cellRenderId}`,
             async () => {
-              if (!params.data._id) return;
-              const result = await CyberiaInstanceService.get({ id: params.data._id });
+              // Instances are addressed by code, the key the engine URL carries.
+              if (!params.data.code) return;
+              const result = await CyberiaInstanceService.get({ id: params.data.code });
               if (result.status === 'success' && result.data) {
                 if (loadInstanceCallback) await loadInstanceCallback(result.data);
                 NotificationManager.Push({
-                  html: `Instance "${result.data.name || result.data.code || params.data._id}" loaded`,
+                  html: `Instance "${result.data.name || result.data.code}" loaded`,
                   status: 'success',
                 });
               } else {

package/src/client/services/cyberia-instance/cyberia-instance.service.js

@@ -96,46 +96,6 @@ class CyberiaInstanceService {
           return reject(error);
         }),
     );
-  /** Fallback-world default items currently staged on the engine process. */
-  static getFallbackDefaultItems = () =>
-    new Promise((resolve, reject) =>
-      fetch(getApiBaseUrl({ id: 'fallback-world/default-items', endpoint }), {
-        method: 'GET',
-        headers: headersFactory(),
-        credentials: 'include',
-      })
-        .then(async (res) => res.json())
-        .then((res) => {
-          logger.info(res);
-          return resolve(res);
-        })
-        .catch((error) => {
-          logger.error(error);
-          return reject(error);
-        }),
-    );
-  /**
-   * Stage the fallback world's default items and reload a running cyberia-server
-   * (moderator/admin). The items ride along with the trigger — nothing is persisted.
-   */
-  static fallbackHotReload = (options = { body: {} }) =>
-    new Promise((resolve, reject) =>
-      fetch(getApiBaseUrl({ id: 'fallback-world/hot-reload', endpoint }), {
-        method: 'POST',
-        headers: headersFactory(),
-        credentials: 'include',
-        body: JSON.stringify(options.body ?? {}),
-      })
-        .then(async (res) => res.json())
-        .then((res) => {
-          logger.info(res);
-          return resolve(res);
-        })
-        .catch((error) => {
-          logger.error(error);
-          return reject(error);
-        }),
-    );
   static portalConnect = (options = { id: '' }) =>
     new Promise((resolve, reject) =>
       fetch(getApiBaseUrl({ id: `${options.id}/portal-connect`, endpoint }), {

package/src/client/services/cyberia-map/cyberia-map.management.js

@@ -29,7 +29,7 @@ class CyberiaMapManagement {
             <i class="fa-solid fa-upload"></i>
           </div>`,
           class: `in fll section-mp management-table-btn-mini management-table-btn-load-map-${idModal}-${cellRenderId} ${
-            !params.data._id ? 'hide' : ''
+            !params.data.code ? 'hide' : ''
           }`,
         })}`;
 
@@ -37,12 +37,13 @@ class CyberiaMapManagement {
           EventsUI.onClick(
             `.management-table-btn-load-map-${idModal}-${cellRenderId}`,
             async () => {
-              if (!params.data._id) return;
-              const result = await CyberiaMapService.get({ id: params.data._id });
+              // Maps are addressed by code, the key the engine URL carries.
+              if (!params.data.code) return;
+              const result = await CyberiaMapService.get({ id: params.data.code });
               if (result.status === 'success' && result.data) {
                 if (loadMapCallback) await loadMapCallback(result.data);
                 NotificationManager.Push({
-                  html: `Map "${result.data.name || result.data.code || params.data._id}" loaded`,
+                  html: `Map "${result.data.name || result.data.code}" loaded`,
                   status: 'success',
                 });
               } else {

package/src/client/services/cyberia-map-audio-conf/cyberia-map-audio-conf.service.js

@@ -0,0 +1,138 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory, buildQueryUrl } from '../core/core.service.js';
+const logger = loggerFactory(import.meta);
+logger.info('Load service');
+const endpoint = 'cyberia-map-audio-conf';
+class CyberiaMapAudioConfService {
+  static post = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  static put = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'PUT',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  static get = (options = {}) => {
+    const { id, page, limit, filterModel, sortModel, sort, asc, order } = options;
+    const url = buildQueryUrl(getApiBaseUrl({ id, endpoint }), {
+      page,
+      limit,
+      filterModel,
+      sortModel,
+      sort,
+      asc,
+      order,
+    });
+    return new Promise((resolve, reject) =>
+      fetch(url.toString(), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  };
+  static delete = (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'DELETE',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  static getByMapCode = (options = { mapCode: '' }) =>
+    new Promise((resolve, reject) =>
+      fetch(`${getApiBaseUrl({ endpoint })}/map-code/${options.mapCode}`, {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  static assign = (options = { mapCode: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(`${getApiBaseUrl({ endpoint })}/map-code/${options.mapCode}`, {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+}
+export { CyberiaMapAudioConfService };