cyberia 3.1.3 → 3.2.5

package/src/client/components/cyberia/ObjectLayerEngineModal.js

@@ -185,11 +185,11 @@ const ObjectLayerEngineModal = {
       return null;
     }
   },
-  Render: async (options = { idModal: '', Elements: {} }) => {
+  Render: async (options = { idModal: '', appStore: {} }) => {
     // Clear all cached data at the start of each render to prevent contamination
     ObjectLayerEngineModal.clearData();
 
-    const { Elements } = options;
+    const { appStore } = options;
 
     const directionCodes = ['08', '18', '02', '12', '04', '14', '06', '16'];
     const directionCodeLabels = {
@@ -352,8 +352,19 @@ const ObjectLayerEngineModal = {
       }
     }
 
-    const cells = 26;
-    const pixelSize = parseInt(320 / cells);
+    let cellsW = 26;
+    let cellsH = 26;
+    if (loadedData && loadedData.objectLayerRenderFramesId && loadedData.objectLayerRenderFramesId.frames) {
+      const frames = loadedData.objectLayerRenderFramesId.frames;
+      for (const direction of Object.keys(frames)) {
+        if (frames[direction] && frames[direction].length > 0 && frames[direction][0].length > 0) {
+          cellsH = frames[direction][0].length;
+          cellsW = frames[direction][0][0].length;
+          break;
+        }
+      }
+    }
+    const pixelSize = parseInt(320 / Math.max(cellsW, cellsH));
     const idSectionA = 'template-section-a';
     const idSectionB = 'template-section-b';
 
@@ -838,7 +849,7 @@ const ObjectLayerEngineModal = {
           ObjectLayerEngineModal.existingObjectLayerId ? '(UPDATE MODE)' : '(CREATE MODE)',
         );
 
-        if (Elements.Data.user.main.model.user.role === 'guest') {
+        if (appStore.Data.user.main.model.user.role === 'guest') {
           NotificationManager.Push({
             html: 'Guests cannot save object layers. Please log in.',
             status: 'warning',
@@ -1098,7 +1109,7 @@ const ObjectLayerEngineModal = {
       <div class="in section-mp section-mp-border frame-editor-container">
         <div class="in sub-title-modal"><i class="fa-solid fa-table-cells-large"></i> Frame editor</div>
 
-        <object-layer-engine id="ole" width="${cells}" height="${cells}" pixel-size="${pixelSize}">
+        <object-layer-engine id="ole" width="${cellsW}" height="${cellsH}" pixel-size="${pixelSize}">
         </object-layer-engine>
         <object-layer-png-loader id="loader" editor-selector="#ole"></object-layer-png-loader>
       </div>

package/src/client/components/cyberia/ObjectLayerEngineViewer.js

@@ -54,14 +54,14 @@ const ObjectLayerEngineViewer = {
     return directionCodeMap[key] || null;
   },
 
-  Render: async function ({ Elements }) {
+  Render: async function ({ appStore }) {
     const id = 'object-layer-engine-viewer';
 
     // Reset currentObjectId when modal is rendered to ensure Reload triggers properly
     this.Data.currentObjectId = undefined;
 
     Modal.Data[`modal-${id}`].onReloadModalListener[id] = async () => {
-      ObjectLayerEngineViewer.Reload({ Elements });
+      ObjectLayerEngineViewer.Reload({ appStore });
     };
 
     // Listen for query parameter changes for smooth navigation
@@ -77,7 +77,7 @@ const ObjectLayerEngineViewer = {
 
         // Only reload if object id actually changed (normalize undefined to null for comparison)
         if (objectId !== this.Data.currentObjectId) {
-          await this.Reload({ Elements });
+          await this.Reload({ appStore });
         }
       },
     });
@@ -93,7 +93,7 @@ const ObjectLayerEngineViewer = {
     `;
   },
 
-  renderEmpty: async function ({ Elements }) {
+  renderEmpty: async function ({ appStore }) {
     const id = 'object-layer-engine-viewer';
     const idModal = 'modal-object-layer-engine-viewer';
 
@@ -128,13 +128,13 @@ const ObjectLayerEngineViewer = {
     htmls(
       `#${id}`,
       await ObjectLayerManagement.RenderTable({
-        Elements,
+        appStore,
         idModal,
       }),
     );
   },
 
-  loadObjectLayer: async function (objectLayerId, Elements, options = {}) {
+  loadObjectLayer: async function (objectLayerId, appStore, options = {}) {
     const { skipWebp = false } = options;
     const id = 'object-layer-engine-viewer';
 
@@ -181,7 +181,7 @@ const ObjectLayerEngineViewer = {
       this.Data.currentMode = 'idle';
 
       // Render the viewer UI
-      await this.renderViewer({ Elements });
+      await this.renderViewer({ appStore });
 
       // Generate WebP
       if (!skipWebp) {
@@ -208,7 +208,7 @@ const ObjectLayerEngineViewer = {
     }
   },
 
-  renderViewer: async function ({ Elements }) {
+  renderViewer: async function ({ appStore }) {
     const id = 'object-layer-engine-viewer';
     const { objectLayer, frameCounts } = this.Data;
 
@@ -994,7 +994,7 @@ const ObjectLayerEngineViewer = {
     );
     ThemeEvents[id]();
     // Attach event listeners
-    this.attachEventListeners({ Elements });
+    this.attachEventListeners({ appStore });
 
     // If we already have a webp loaded, display it without re-generating
     if (this.Data.webp) {
@@ -1012,19 +1012,33 @@ const ObjectLayerEngineViewer = {
     const { frameCount, frameDuration, currentDirection, currentMode, numericCode } = webpMetadata;
 
     const container = s('#webp-canvas-container');
-    if (container) {
-      // Clear container
-      container.innerHTML = '';
+    if (!container) return;
 
-      // Create and append image
-      const img = document.createElement('img');
-      img.src = webp;
-      img.alt = 'WebP Animation';
-      container.appendChild(img);
+    // Remove one-time placeholder without destroying the rest of the container
+    // (clearing innerHTML would also destroy #webp-loading-overlay, breaking showLoading)
+    const placeholder = container.querySelector('.webp-placeholder');
+    if (placeholder) placeholder.remove();
 
-      // Create and append info badge
-      const infoBadge = document.createElement('div');
-      infoBadge.className = 'webp-info-badge';
+    // Reuse the existing <img> element or create one — never nuke the container
+    let img = container.querySelector('img');
+    if (!img) {
+      img = document.createElement('img');
+      img.alt = 'WebP Animation';
+      // Insert before the loading overlay so the overlay stays on top
+      const overlay = container.querySelector('#webp-loading-overlay');
+      container.insertBefore(img, overlay || null);
+    }
+    img.src = webp;
+
+    // Update info badge in-place or create it once
+    const displayArea = s('.webp-display-area');
+    if (displayArea) {
+      let infoBadge = displayArea.querySelector('.webp-info-badge');
+      if (!infoBadge) {
+        infoBadge = document.createElement('div');
+        infoBadge.className = 'webp-info-badge';
+        displayArea.appendChild(infoBadge);
+      }
       infoBadge.innerHTML = html`
         <span class="info-label" style="margin-left: 8px;">Frames:</span>
         <span>${frameCount}</span><br />
@@ -1037,13 +1051,6 @@ const ObjectLayerEngineViewer = {
         <span class="info-label" style="margin-left: 8px;">Code:</span>
         <span>${numericCode}</span>
       `;
-      const displayArea = s('.webp-display-area');
-      if (displayArea) {
-        // Remove old badge if exists
-        const oldBadge = s('.webp-info-badge');
-        if (oldBadge) oldBadge.remove();
-        displayArea.appendChild(infoBadge);
-      }
     }
   },
 
@@ -1114,7 +1121,7 @@ const ObjectLayerEngineViewer = {
     }
   },
 
-  deleteObjectLayer: async function ({ Elements } = {}) {
+  deleteObjectLayer: async function ({ appStore } = {}) {
     const objectLayerId = this.Data.objectLayer?._id;
     if (!objectLayerId) return;
 
@@ -1169,7 +1176,7 @@ const ObjectLayerEngineViewer = {
     }
   },
 
-  attachEventListeners: function ({ Elements }) {
+  attachEventListeners: function ({ appStore }) {
     // Direction buttons
     const directionButtons = document.querySelectorAll('[data-direction]');
     directionButtons.forEach((btn) => {
@@ -1178,8 +1185,8 @@ const ObjectLayerEngineViewer = {
         const direction = e.currentTarget.getAttribute('data-direction');
         if (direction !== this.Data.currentDirection) {
           this.Data.currentDirection = direction;
-          await this.renderViewer({ Elements });
-          // attachEventListeners is already called inside renderViewer
+          // Update button active states without re-rendering the full viewer (prevents flicker)
+          this._updateControlsState();
           await this.generateWebp();
         }
       });
@@ -1193,8 +1200,8 @@ const ObjectLayerEngineViewer = {
         const mode = e.currentTarget.getAttribute('data-mode');
         if (mode !== this.Data.currentMode) {
           this.Data.currentMode = mode;
-          await this.renderViewer({ Elements });
-          // attachEventListeners is already called inside renderViewer
+          // Update button active states without re-rendering the full viewer (prevents flicker)
+          this._updateControlsState();
           await this.generateWebp();
         }
       });
@@ -1230,7 +1237,7 @@ const ObjectLayerEngineViewer = {
         // listener → Reload → renderEmpty chain which can silently
         // fail when the URL was already clean or currentObjectId
         // was already null
-        await this.renderEmpty({ Elements });
+        await this.renderEmpty({ appStore });
       });
     }
 
@@ -1246,21 +1253,21 @@ const ObjectLayerEngineViewer = {
     const deleteBtn = s('#delete-object-layer-btn');
     if (deleteBtn) {
       deleteBtn.addEventListener('click', async () => {
-        await this.deleteObjectLayer({ Elements });
+        await this.deleteObjectLayer({ appStore });
       });
     }
 
     // Atlas buttons
     if (s('#generate-atlas-btn')) {
       EventsUI.onClick('#generate-atlas-btn', async () => {
-        await this.generateAtlas({ Elements });
+        await this.generateAtlas({ appStore });
       });
     }
 
     const removeAtlasBtn = s('#remove-atlas-btn');
     if (removeAtlasBtn) {
       removeAtlasBtn.addEventListener('click', async () => {
-        await this.removeAtlas({ Elements });
+        await this.removeAtlas({ appStore });
       });
     }
 
@@ -1306,10 +1313,10 @@ const ObjectLayerEngineViewer = {
     }
   },
 
-  generateAtlas: async function ({ Elements } = {}) {
+  generateAtlas: async function ({ appStore } = {}) {
     const objectLayerId = this.Data.objectLayer._id;
     this.Data.isGeneratingAtlas = true;
-    await this.renderViewer({ Elements });
+    await this.renderViewer({ appStore });
 
     try {
       const { status, data, message } = await AtlasSpriteSheetService.generateAtlas({ id: objectLayerId });
@@ -1321,7 +1328,7 @@ const ObjectLayerEngineViewer = {
         });
         // Reset generating flag before reload so renderViewer shows updated content
         this.Data.isGeneratingAtlas = false;
-        await this.Reload({ Elements, force: true, skipWebp: true });
+        await this.Reload({ appStore, force: true, skipWebp: true });
         return;
       } else {
         throw new Error(message || 'Failed to generate atlas');
@@ -1335,12 +1342,12 @@ const ObjectLayerEngineViewer = {
     } finally {
       if (this.Data.isGeneratingAtlas) {
         this.Data.isGeneratingAtlas = false;
-        await this.renderViewer({ Elements });
+        await this.renderViewer({ appStore });
       }
     }
   },
 
-  removeAtlas: async function ({ Elements } = {}) {
+  removeAtlas: async function ({ appStore } = {}) {
     const confirmResult = await Modal.RenderConfirm({
       id: 'remove-atlas-confirm',
       html: async () => html`
@@ -1356,7 +1363,7 @@ const ObjectLayerEngineViewer = {
 
     const objectLayerId = this.Data.objectLayer._id;
     this.Data.isGeneratingAtlas = true;
-    await this.renderViewer({ Elements });
+    await this.renderViewer({ appStore });
 
     try {
       const { status, message } = await AtlasSpriteSheetService.deleteByObjectLayerId({ id: objectLayerId });
@@ -1368,7 +1375,7 @@ const ObjectLayerEngineViewer = {
         });
         // Reset generating flag before reload so renderViewer shows updated content
         this.Data.isGeneratingAtlas = false;
-        await this.Reload({ Elements, force: true, skipWebp: true });
+        await this.Reload({ appStore, force: true, skipWebp: true });
         return;
       } else {
         throw new Error(message || 'Failed to remove atlas');
@@ -1382,7 +1389,7 @@ const ObjectLayerEngineViewer = {
     } finally {
       if (this.Data.isGeneratingAtlas) {
         this.Data.isGeneratingAtlas = false;
-        await this.renderViewer({ Elements });
+        await this.renderViewer({ appStore });
       }
     }
   },
@@ -1462,6 +1469,41 @@ const ObjectLayerEngineViewer = {
     }
   },
 
+  /**
+   * Updates direction/mode button active states and disabled flags in-place,
+   * without re-rendering the viewer. Prevents layout flicker when switching
+   * direction or mode while the WebP canvas and surrounding structure stay intact.
+   */
+  _updateControlsState: function () {
+    const { currentDirection, currentMode, frameCounts } = this.Data;
+    const hasFrames = (direction, mode) => {
+      const code = this.getDirectionCode(direction, mode);
+      return !!(code && frameCounts && frameCounts[code] && frameCounts[code] > 0);
+    };
+    const getFrameCount = (direction, mode) => {
+      const code = this.getDirectionCode(direction, mode);
+      return code ? (frameCounts && frameCounts[code]) || 0 : 0;
+    };
+
+    document.querySelectorAll('[data-direction]').forEach((btn) => {
+      const d = btn.getAttribute('data-direction');
+      btn.classList.toggle('active', d === currentDirection);
+      const hasFr = hasFrames(d, currentMode);
+      btn.disabled = !hasFr;
+      const countEl = btn.querySelector('.frame-count');
+      if (countEl) countEl.textContent = hasFr ? `(${getFrameCount(d, currentMode)})` : '';
+    });
+
+    document.querySelectorAll('[data-mode]').forEach((btn) => {
+      const m = btn.getAttribute('data-mode');
+      btn.classList.toggle('active', m === currentMode);
+      const hasFr = hasFrames(currentDirection, m);
+      btn.disabled = !hasFr;
+      const countEl = btn.querySelector('.frame-count');
+      if (countEl) countEl.textContent = hasFr ? `(${getFrameCount(currentDirection, m)})` : '';
+    });
+  },
+
   showLoading: function (show, message = 'Generating WebP...') {
     const overlay = s('#webp-loading-overlay');
     if (overlay) {
@@ -1477,11 +1519,7 @@ const ObjectLayerEngineViewer = {
       downloadBtn.disabled = show;
     }
 
-    // Remove old info badge if exists
-    const oldBadge = s('.webp-info-badge');
-    if (oldBadge && show) {
-      oldBadge.remove();
-    }
+    // Keep existing info badge visible during loading (removes the layout-shift flicker)
   },
 
   downloadWebp: function () {
@@ -1528,7 +1566,7 @@ const ObjectLayerEngineViewer = {
   },
 
   Reload: async function (options = {}) {
-    const { Elements, force = false, skipWebp = false } = options;
+    const { appStore, force = false, skipWebp = false } = options;
     const queryParams = getQueryParams();
     const objectId = queryParams.id || null;
 
@@ -1541,9 +1579,9 @@ const ObjectLayerEngineViewer = {
       this.Data.currentObjectId = objectId;
 
       if (objectId) {
-        await this.loadObjectLayer(objectId, Elements, { skipWebp });
+        await this.loadObjectLayer(objectId, appStore, { skipWebp });
       } else {
-        await this.renderEmpty({ Elements });
+        await this.renderEmpty({ appStore });
       }
     } else if (!objectId && (this.Data.currentObjectId === null || force)) {
       // Special case: if we're already in empty state but DOM might have been reset
@@ -1555,7 +1593,7 @@ const ObjectLayerEngineViewer = {
 
       if (!gridDomExists) {
         // DOM was reset (e.g., modal HTML reloaded), re-render the table
-        await this.renderEmpty({ Elements });
+        await this.renderEmpty({ appStore });
       }
     }
   },

package/src/client/components/cyberia-portal/AppStoreCyberiaPortal.js

@@ -0,0 +1,5 @@
+import { AppStore } from '../core/AppStore.js';
+
+const AppStoreCyberiaPortal = AppStore.create();
+
+export { AppStoreCyberiaPortal };

package/src/client/components/cyberia-portal/CommonCyberiaPortal.js

@@ -1,37 +1,223 @@
-const ModelElement = {
-  user: () => {
-    return {
-      user: {
-        _id: '',
-      },
-    };
-  },
-};
-
-const BaseElement = () => {
-  return {
-    user: {
-      main: {
-        model: {
-          ...ModelElement.user(),
-        },
-      },
-    },
-    chat: {},
-    mailer: {},
-  };
-};
-
-const CyberiaPortalParams = {
-  EVENT_CALLBACK_TIME: 45,
-};
-
 const CyberiaDependencies = {
   'maxrects-packer': '^2.7.3',
   pngjs: '^7.0.0',
   jimp: '^1.6.0',
-  sharp: '^0.32.5',
+  sharp: '^0.34.5',
   ethers: '~6.16.0',
 };
 
-export { BaseElement, ModelElement, CyberiaPortalParams, CyberiaDependencies };
+const DefaultCyberiaItems = [
+  { item: { id: 'coin', type: 'coin' } },
+  // { item: { id: 'red-power', type: 'skill' } },
+  // { item: { id: 'heal', type: 'skill' } },
+  // { item: { id: 'hatchet-skill', type: 'skill' } },
+  // { item: { id: 'green-power', type: 'skill' } },
+  // { item: { id: 'blood', type: 'skill' } },
+  { item: { id: 'atlas_pistol_mk2', type: 'weapon' } },
+  { item: { id: 'atlas_pistol_mk2_bullet', type: 'skill' } },
+  // { item: { id: 'tim-knife', type: 'weapon' } },
+  { item: { id: 'hatchet', type: 'weapon' } },
+  { item: { id: 'wason', type: 'skin' } },
+  { item: { id: 'scp-2040', type: 'skin' } },
+  { item: { id: 'purple', type: 'skin' } },
+  { item: { id: 'punk', type: 'skin' } },
+  // { item: { id: 'marciano', type: 'skin' } },
+  { item: { id: 'lain', type: 'skin' } },
+  { item: { id: 'kaneki', type: 'skin' } },
+  { item: { id: 'junko', type: 'skin' } },
+  { item: { id: 'ghost', type: 'skin' } },
+  { item: { id: 'eiri', type: 'skin' } },
+  { item: { id: 'anon', type: 'skin' } },
+  { item: { id: 'alex', type: 'skin' } },
+  { item: { id: 'agent', type: 'skin' } },
+  { item: { id: 'grass', type: 'floor' } },
+];
+
+const DefaultSkillConfig = [
+  // { triggerItemId: 'anon', logicEventIds: ['doppelganger'] },
+  {
+    triggerItemId: 'atlas_pistol_mk2',
+    logicEventIds: ['atlas_pistol_mk2_logic'],
+  },
+  { triggerItemId: 'coin', logicEventIds: ['coin_drop_or_transaction'] },
+  // { triggerItemId: 'purple', logicEventIds: ['doppelganger'] },
+  // { triggerItemId: 'atlas_pistol_mk2_bullet', logicEventIds: ['doppelganger'] },
+];
+
+/**
+ * Default dialogue seeds for every non-commented entry in DefaultCyberiaItems.
+ * Each item maps to an array of dialogue records following the CyberiaDialogue
+ * model schema: { itemId, order, speaker, text, mood }.
+ *
+ * Used by the seed/migration script to populate the database on first boot.
+ * The C client fetches these at runtime via GET /api/cyberia-dialogue?...
+ */
+const DefaultCyberiaDialogues = [
+  {
+    itemId: 'coin',
+    order: 0,
+    speaker: 'Coin',
+    text: 'A standard unit of exchange in the cyberia network.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'atlas_pistol_mk2',
+    order: 0,
+    speaker: 'Atlas Pistol MK2',
+    text: 'Military-grade sidearm. Fires energy projectiles.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'atlas_pistol_mk2_bullet',
+    order: 0,
+    speaker: 'MK2 Bullet',
+    text: 'High-velocity energy round. Dissipates on impact.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'hatchet',
+    order: 0,
+    speaker: 'Hatchet',
+    text: 'A crude but reliable melee tool. Good for close quarters.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'wason',
+    order: 0,
+    speaker: 'Wason',
+    text: 'They say I am just a wandering merchant... but I have seen things.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'wason',
+    order: 1,
+    speaker: 'Wason',
+    text: 'The network was not always like this. There was a time before the portals.',
+    mood: 'sad',
+  },
+  {
+    itemId: 'scp-2040',
+    order: 0,
+    speaker: 'SCP-2040',
+    text: 'CONTAINMENT PROTOCOL ACTIVE. Do not make direct eye contact.',
+    mood: 'angry',
+  },
+  {
+    itemId: 'scp-2040',
+    order: 1,
+    speaker: 'SCP-2040',
+    text: 'I remember everything. Every iteration. Every reset.',
+    mood: 'sad',
+  },
+  {
+    itemId: 'purple',
+    order: 0,
+    speaker: 'Purple',
+    text: 'The void between nodes is not empty — it is alive.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'punk',
+    order: 0,
+    speaker: 'Punk',
+    text: 'Rules are just code someone else wrote. I write my own.',
+    mood: 'happy',
+  },
+  {
+    itemId: 'lain',
+    order: 0,
+    speaker: 'Lain',
+    text: 'No matter where you go, everyone is connected.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'lain',
+    order: 1,
+    speaker: 'Lain',
+    text: 'If you are not remembered, then you never existed.',
+    mood: 'sad',
+  },
+  {
+    itemId: 'lain',
+    order: 2,
+    speaker: 'Lain',
+    text: 'The wired is not a separate world. It is layered over this one.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'kaneki',
+    order: 0,
+    speaker: 'Kaneki',
+    text: 'I am not the protagonist of a novel. I am just... me.',
+    mood: 'sad',
+  },
+  { itemId: 'kaneki', order: 1, speaker: 'Kaneki', text: 'What is 1000 minus 7?', mood: 'angry' },
+  { itemId: 'junko', order: 0, speaker: 'Junko', text: 'Despair is the seed from which hope blooms!', mood: 'happy' },
+  {
+    itemId: 'junko',
+    order: 1,
+    speaker: 'Junko',
+    text: 'How boring... nothing ever surprises me anymore.',
+    mood: 'sad',
+  },
+  { itemId: 'ghost', order: 0, speaker: 'Ghost', text: '...', mood: 'neutral' },
+  {
+    itemId: 'eiri',
+    order: 0,
+    speaker: 'Eiri',
+    text: 'I am the god of the wired. I designed the protocol.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'eiri',
+    order: 1,
+    speaker: 'Eiri',
+    text: 'Flesh is just hardware. Consciousness is the only software that matters.',
+    mood: 'neutral',
+  },
+  { itemId: 'anon', order: 0, speaker: '???', text: 'You should not be here. Turn back.', mood: 'angry' },
+  {
+    itemId: 'anon',
+    order: 1,
+    speaker: '???',
+    text: 'Or stay. It does not matter. Nothing leaves this place.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'alex',
+    order: 0,
+    speaker: 'Alex',
+    text: 'I have been mapping the portal network. Something does not add up.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'alex',
+    order: 1,
+    speaker: 'Alex',
+    text: 'There are nodes that exist in the registry but have no physical anchor.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'agent',
+    order: 0,
+    speaker: 'Agent',
+    text: 'Civilian, this area is restricted. State your business.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'agent',
+    order: 1,
+    speaker: 'Agent',
+    text: 'Hmm. Proceed, but know that you are being watched.',
+    mood: 'neutral',
+  },
+  {
+    itemId: 'grass',
+    order: 0,
+    speaker: 'Grass',
+    text: 'A patch of synthetic grass. It sways gently despite no wind.',
+    mood: 'neutral',
+  },
+];
+
+export { CyberiaDependencies, DefaultCyberiaItems, DefaultSkillConfig, DefaultCyberiaDialogues };

package/src/client/components/cyberia-portal/LogInCyberiaPortal.js

@@ -1,19 +1,19 @@
 import { Auth } from '../core/Auth.js';
 import { LogIn } from '../core/LogIn.js';
 import { s } from '../core/VanillaJs.js';
-import { ElementsCyberiaPortal } from './ElementsCyberiaPortal.js';
+import { AppStoreCyberiaPortal } from './AppStoreCyberiaPortal.js';
 import { ObjectLayerManagement } from '../../services/object-layer/object-layer.management.js';
 
 const LogInCyberiaPortal = async function () {
   LogIn.Event['LogInCyberiaPortal'] = async (options) => {
     const { token, user } = options;
 
-    ElementsCyberiaPortal.Data.user.main.model.user = user;
+    AppStoreCyberiaPortal.Data.user.main.model.user = user;
 
     await ObjectLayerManagement.Reload('viewer');
   };
   const { user } = await Auth.sessionIn();
-  ElementsCyberiaPortal.Data.user.main.model.user = user;
+  AppStoreCyberiaPortal.Data.user.main.model.user = user;
 };
 
 export { LogInCyberiaPortal };