@underpostnet/cyberia 3.3.73 → 3.3.77

package/test/unit/zip-archive.test.js

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * @module zip-archive.test
+ * @description Covers the JSZip-backed archive helpers shared by the file-storage CLI and the
+ * client builder: local-file archiving, full and single-entry extraction, entry lookup by
+ * basename, and the guard that keeps an archive path from escaping the extraction root.
+ *
+ * Uses 'chai' for assertions.
+ */
+
+import { expect } from 'chai';
+import fs from 'fs-extra';
+import JSZip from 'jszip';
+import * as dir from 'path';
+import {
+  extractZipEntryTo,
+  extractZipTo,
+  findZipEntry,
+  isZipBuffer,
+  loadZip,
+  readZipEntry,
+  zipFromLocalFiles,
+} from '../../src/server/storage/zip.js';
+
+describe('zip archive helpers', () => {
+  let fixturePath;
+
+  beforeEach(() => {
+    fixturePath = fs.mkdtempSync('/tmp/engine-zip-archive-');
+    fs.mkdirSync(`${fixturePath}/src/nested`, { recursive: true });
+    fs.writeFileSync(`${fixturePath}/src/index.html`, '<h1>index</h1>'.repeat(200), 'utf8');
+    fs.writeFileSync(`${fixturePath}/src/nested/app.js`, 'console.log(1);'.repeat(200), 'utf8');
+    fs.writeFileSync(`${fixturePath}/src/run.sh`, '#!/bin/sh\necho run\n', 'utf8');
+    fs.chmodSync(`${fixturePath}/src/run.sh`, 0o755);
+  });
+
+  afterEach(() => {
+    fs.removeSync(fixturePath);
+  });
+
+  const buildFixtureArchive = () =>
+    zipFromLocalFiles([
+      { localPath: `${fixturePath}/src/index.html`, entryName: 'index.html' },
+      { localPath: `${fixturePath}/src/nested/app.js`, entryName: 'nested/app.js' },
+      { localPath: `${fixturePath}/src/run.sh`, entryName: 'run.sh' },
+    ]);
+
+  it('writes a deflated archive that keeps the requested entry names', async () => {
+    const archive = await buildFixtureArchive();
+    const rawBytes = ['src/index.html', 'src/nested/app.js', 'src/run.sh'].reduce(
+      (total, relativePath) => total + fs.statSync(`${fixturePath}/${relativePath}`).size,
+      0,
+    );
+
+    expect(isZipBuffer(archive)).to.equal(true);
+    expect(archive.length).to.be.below(rawBytes);
+    const entries = Object.values((await loadZip(archive)).files);
+    expect(entries.filter((entry) => entry.dir).map((entry) => entry.name)).to.deep.equal(['nested/']);
+    expect(
+      entries
+        .filter((entry) => !entry.dir)
+        .map((entry) => entry.name)
+        .sort(),
+    ).to.deep.equal(['index.html', 'nested/app.js', 'run.sh']);
+  });
+
+  it('round-trips an archive through extraction, preserving content and executable bits', async () => {
+    const outputPath = `${fixturePath}/out`;
+    await extractZipTo(await buildFixtureArchive(), outputPath);
+
+    expect(fs.readFileSync(`${outputPath}/nested/app.js`, 'utf8')).to.equal(
+      fs.readFileSync(`${fixturePath}/src/nested/app.js`, 'utf8'),
+    );
+    expect(fs.statSync(`${outputPath}/run.sh`).mode & 0o777).to.equal(0o755);
+  });
+
+  it('extracts from an archive path as well as from a buffer', async () => {
+    const archivePath = `${fixturePath}/build.zip`;
+    fs.writeFileSync(archivePath, await buildFixtureArchive());
+    await extractZipTo(archivePath, `${fixturePath}/from-path`);
+
+    expect(fs.existsSync(`${fixturePath}/from-path/nested/app.js`)).to.equal(true);
+  });
+
+  it('resolves an entry by exact name, by basename, and by single-entry fallback', async () => {
+    const nested = await loadZip(await buildFixtureArchive());
+    expect(findZipEntry(nested, 'nested/app.js').name).to.equal('nested/app.js');
+    expect(findZipEntry(nested, 'app.js').name).to.equal('nested/app.js');
+    expect(findZipEntry(nested, 'absent.js')).to.equal(null);
+
+    const single = await loadZip(
+      await zipFromLocalFiles([{ localPath: `${fixturePath}/src/index.html`, entryName: 'deep/path/index.html' }]),
+    );
+    expect(findZipEntry(single, 'absent.js').name).to.equal('deep/path/index.html');
+  });
+
+  it('reads a wrapped entry out of a single-file archive', async () => {
+    const inner = await buildFixtureArchive();
+    fs.writeFileSync(`${fixturePath}/inner.zip`, inner);
+    const wrapper = await zipFromLocalFiles([
+      { localPath: `${fixturePath}/inner.zip`, entryName: 'wrapped/inner.zip' },
+    ]);
+
+    expect(await readZipEntry(wrapper, 'inner.zip')).to.deep.equal(inner);
+  });
+
+  it('flattens a single extracted entry into the target directory', async () => {
+    const archive = await zipFromLocalFiles([
+      { localPath: `${fixturePath}/src/index.html`, entryName: 'deep/path/index.html' },
+    ]);
+    const targetDir = `${fixturePath}/pull`;
+    const written = await extractZipEntryTo(archive, 'index.html', targetDir);
+
+    expect(written).to.equal(dir.resolve(targetDir, 'index.html'));
+    expect(fs.readFileSync(written, 'utf8')).to.equal(fs.readFileSync(`${fixturePath}/src/index.html`, 'utf8'));
+  });
+
+  it('rejects a missing entry rather than writing an empty file', async () => {
+    const archive = await buildFixtureArchive();
+    let thrown;
+    await extractZipEntryTo(archive, 'index.html', `${fixturePath}/missing`).catch((error) => (thrown = error));
+    expect(thrown).to.equal(undefined);
+
+    await extractZipEntryTo(await buildFixtureArchive(), 'absent.js', `${fixturePath}/missing`).catch(
+      (error) => (thrown = error),
+    );
+    expect(thrown?.message).to.match(/Zip entry not found/);
+  });
+
+  it('blocks an archive entry that resolves outside the extraction root', async () => {
+    const escaping = new JSZip();
+    escaping.file('../escaped.txt', 'escaped');
+    const archive = await escaping.generateAsync({ type: 'nodebuffer' });
+
+    let thrown;
+    await extractZipTo(archive, `${fixturePath}/guarded`).catch((error) => (thrown = error));
+
+    expect(thrown?.message).to.match(/Blocked zip entry outside extraction directory/);
+    expect(fs.existsSync(`${fixturePath}/escaped.txt`)).to.equal(false);
+  });
+});

package/vitest.config.js

@@ -2,13 +2,16 @@ import { defineConfig } from 'vitest/config';
 import {
   UNDERPOST_TESTING,
   coverageIncludeFactory,
+  coverageReportKey,
   coverageThresholdFactory,
   testProjectsFactory,
+  vitestProjectSelector,
 } from './src/server/build/testing.js';
 
 const allureResultsDirectory = process.env[UNDERPOST_TESTING.allureResultsEnvKey];
 const coverageThreshold = coverageThresholdFactory(process.env);
 const coverageInclude = coverageIncludeFactory(process.argv);
+const coverageReportDirectory = coverageReportKey(vitestProjectSelector(process.argv));
 
 // Spread into every tier: a Vitest project inherits nothing from the root
 // `test` block, and only `coverage` and `reporters` are read from it.
@@ -33,9 +36,14 @@ export default defineConfig({
     coverage: {
       provider: 'v8',
       reportsDirectory: UNDERPOST_TESTING.coverageDirectory,
-      // `lcov` is what Coveralls ingests, `json` is what a merged multi-job
-      // report is assembled from, `text` is what a local run reads.
-      reporter: ['text', 'lcov', 'json'],
+      // `lcovonly` is what Coveralls ingests, `json` is what a merged multi-job
+      // report is assembled from, `text` is what a local run reads, and `html` is
+      // what a deploy publishes — under the selection's own directory, so the
+      // report a deploy declares is the run it names and never the last run made.
+      reporter: ['text', 'lcovonly', 'json', ['html', { subdir: coverageReportDirectory }]],
+      // The directory holds one report per selection, so a run must not empty it; the
+      // runner (`src/cli/test.js`) clears its own selection's report before it starts.
+      clean: false,
       // Written even when the run fails: the coverage workflows upload the report
       // from a job the threshold step is meant to fail, and without it the badge
       // freezes at the last passing build instead of moving with the tree.

package/src/api/cyberia-instance/cyberia-fallback-default-items.js

@@ -1,63 +0,0 @@
-/**
- * Fallback-world default items — process-local override store.
- *
- * The procedural fallback world is never persisted, so its default item set
- * has no collection to live in. This module holds the set the FallbackWorldEngine
- * view composed, in memory, for the lifetime of the engine process:
- *
- *   - written by  POST /api/cyberia-instance/fallback-world/hot-reload
- *   - read by     fetchFullInstance()'s fallback branch (instance-data.js) and
- *                 GET /api/cyberia-instance/fallback-world[/default-items]
- *
- * Deliberately NOT persisted: an engine restart drops back to the code defaults,
- * so a stale editor session can never become the permanent shape of the world.
- * This keeps the fallback path's "code defaults are authoritative" invariant —
- * the only thing an operator can layer on top is this explicit, volatile list.
- *
- * @module src/api/cyberia-instance/cyberia-fallback-default-items.js
- */
-
-/** @typedef {{ id: string, defaultPlayerInventory: boolean }} FallbackDefaultItem */
-
-/** @type {FallbackDefaultItem[]} */
-let defaultItems = [];
-
-/**
- * Coerce a caller-supplied list into the canonical `{ id, defaultPlayerInventory }`
- * shape. Accepts the legacy `string[]` form and drops blank/duplicate ids so the
- * world generator never sees a malformed entry.
- *
- * @param {Array<string|FallbackDefaultItem>} entries
- * @returns {FallbackDefaultItem[]}
- */
-function normalizeFallbackDefaultItems(entries) {
-  if (!Array.isArray(entries)) return [];
-  const seen = new Set();
-  const normalized = [];
-  for (const entry of entries) {
-    const raw = typeof entry === 'string' ? { id: entry } : entry;
-    const id = typeof raw?.id === 'string' ? raw.id.trim() : '';
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    normalized.push({ id, defaultPlayerInventory: !!raw.defaultPlayerInventory });
-  }
-  return normalized;
-}
-
-/**
- * Current override set. Returns a copy so callers cannot mutate the store.
- * @returns {FallbackDefaultItem[]}
- */
-const getFallbackDefaultItems = () => defaultItems.map((entry) => ({ ...entry }));
-
-/**
- * Replace the override set. An empty list clears it, restoring pure code defaults.
- * @param {Array<string|FallbackDefaultItem>} entries
- * @returns {FallbackDefaultItem[]} The stored set.
- */
-function setFallbackDefaultItems(entries) {
-  defaultItems = normalizeFallbackDefaultItems(entries);
-  return getFallbackDefaultItems();
-}
-
-export { getFallbackDefaultItems, setFallbackDefaultItems, normalizeFallbackDefaultItems };

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

@@ -1,368 +0,0 @@
-/**
- * Fallback World Engine — editor for the procedural fallback world's default items.
- *
- * The fallback world (src/api/cyberia-instance/cyberia-fallback-world.js) is
- * generated in memory and never persisted, so it has no CyberiaInstance document
- * to edit. This view is the trimmed-down counterpart of InstanceEngineCyberia:
- * only the default-items section plus a reload trigger.
- *
- * The composed item set is staged on the engine process and shipped with the
- * reload trigger — it is deliberately volatile (see cyberia-fallback-default-items.js),
- * so an engine restart returns the world to pure code defaults.
- */
-
-import { BtnIcon } from '../core/BtnIcon.js';
-import { Input } from '../core/Input.js';
-import { htmls, s } from '../core/VanillaJs.js';
-import { commonModeratorGuard } from '../core/CommonJs.js';
-import { NotificationManager } from '../core/NotificationManager.js';
-import { DropDown } from '../core/DropDown.js';
-import { CyberiaInstanceService } from '../../services/cyberia-instance/cyberia-instance.service.js';
-import { ObjectLayerService } from '../../services/object-layer/object-layer.service.js';
-import { DefaultCyberiaItems } from './SharedDefaultsCyberia.js';
-
-const dropdownValueKey = (value = '') => String(value).trim().replaceAll(' ', '-');
-const createDropdownOption = (value, onClick = () => {}, display = value, data = value) => ({
-  value,
-  display,
-  data,
-  onClick,
-});
-
-class FallbackWorldEngineCyberia {
-  static itemIdsDropdownId = 'fallback-world-engine-item-ids-dropdown';
-  static itemInventoryListId = 'fallback-world-engine-item-inventory-list';
-  // itemId → defaultPlayerInventory flag for the currently selected item ids.
-  static itemInventoryFlags = {};
-  // Ids the code defaults already ship in an entity's defaultObjectLayers.
-  // Selecting one and leaving it unchecked REMOVES it from those defaults, so
-  // the list flags them instead of letting a player lose their starting kit.
-  static entityDefaultItemIds = [];
-
-  // Current selection, read from the dropdown's `oncheckvalues` (always live —
-  // it is updated before `_renderSelectedBadges` runs, unlike `.value` which
-  // lags by one in the option-click path).
-  static getSelectedItemIds() {
-    const token = DropDown.Tokens[FallbackWorldEngineCyberia.itemIdsDropdownId];
-    if (!token) return [];
-    const fromChecks = Object.values(token.oncheckvalues || {})
-      .map((v) => v.data)
-      .filter(Boolean);
-    if (fromChecks.length > 0) return fromChecks;
-    return Array.isArray(token.value) ? token.value.filter(Boolean) : [];
-  }
-
-  /** Payload shape shared with CyberiaInstance.itemIds. */
-  static getItemIdsPayload() {
-    return FallbackWorldEngineCyberia.getSelectedItemIds().map((id) => ({
-      id,
-      defaultPlayerInventory: !!FallbackWorldEngineCyberia.itemInventoryFlags[id],
-    }));
-  }
-
-  // Render the per-item "Default Player Inventory" toggles for every selected
-  // item id. Kept in sync with the dropdown via a MutationObserver on its badge
-  // container (see render()).
-  static renderItemInventoryList(containerId = FallbackWorldEngineCyberia.itemInventoryListId) {
-    const container = s(`.${containerId}`);
-    if (!container) return;
-
-    const selected = FallbackWorldEngineCyberia.getSelectedItemIds();
-
-    // Drop flags for items no longer selected so the payload never carries them.
-    for (const key of Object.keys(FallbackWorldEngineCyberia.itemInventoryFlags)) {
-      if (!selected.includes(key)) delete FallbackWorldEngineCyberia.itemInventoryFlags[key];
-    }
-
-    if (selected.length === 0) {
-      htmls(
-        `.${containerId}`,
-        html`<div style="color:#888;font-size:12px;">
-          No item IDs selected — the fallback world runs on pure code defaults.
-        </div>`,
-      );
-      return;
-    }
-
-    let listHtml = '';
-    for (const itemId of selected) {
-      const isChecked = !!FallbackWorldEngineCyberia.itemInventoryFlags[itemId];
-      const checked = isChecked ? 'checked' : '';
-      const strips = !isChecked && FallbackWorldEngineCyberia.entityDefaultItemIds.includes(itemId);
-      listHtml += html`<div class="fl" style="border-bottom:1px solid #444;padding:4px 0;align-items:center;">
-        <div class="in fll" style="flex:1;font-size:12px;font-family:monospace;">
-          ${itemId}
-          ${strips
-            ? html`<span
-                style="color:#d90;font-size:11px;font-family:initial;margin-left:6px;"
-                title="This id is part of the code entity defaults. Left unchecked, it is removed from them."
-                ><i class="fa-solid fa-triangle-exclamation"></i> removes from entity defaults</span
-              >`
-            : ''}
-        </div>
-        <div class="in fll" style="display:flex;align-items:center;justify-content:flex-end;">
-          <label style="font-size:11px;cursor:pointer;display:flex;align-items:center;gap:5px;">
-            <input
-              type="checkbox"
-              class="fallback-world-engine-item-inv-checkbox"
-              data-item-id="${itemId}"
-              ${checked}
-              style="cursor:pointer;"
-            />
-            Default Player Inventory
-          </label>
-        </div>
-      </div>`;
-    }
-    htmls(`.${containerId}`, listHtml);
-
-    container.querySelectorAll('.fallback-world-engine-item-inv-checkbox').forEach((cb) => {
-      cb.onchange = () => {
-        FallbackWorldEngineCyberia.itemInventoryFlags[cb.dataset.itemId] = cb.checked;
-      };
-    });
-  }
-
-  static syncItemIdsDropdownSelection(itemIds = []) {
-    const dropdownId = FallbackWorldEngineCyberia.itemIdsDropdownId;
-    if (!DropDown.Tokens[dropdownId]) return;
-
-    // Accept both the `[{ id, defaultPlayerInventory }]` shape and a plain
-    // string[], matching what the fallback-world endpoint may return.
-    const normalized = (itemIds || [])
-      .map((entry) => (typeof entry === 'string' ? { id: entry, defaultPlayerInventory: false } : entry))
-      .filter((entry) => entry && entry.id);
-
-    DropDown.Tokens[dropdownId].value = [];
-    if (s(`.${dropdownId}`)) s(`.${dropdownId}`).value = [];
-    DropDown.Tokens[dropdownId].oncheckvalues = {};
-    htmls(`.dropdown-current-${dropdownId}`, '');
-    htmls(`.${dropdownId}-render-container`, '');
-
-    FallbackWorldEngineCyberia.itemInventoryFlags = {};
-    const ids = [];
-    for (const entry of normalized) {
-      const key = dropdownValueKey(entry.id);
-      DropDown.Tokens[dropdownId].oncheckvalues[key] = {
-        data: entry.id,
-        display: entry.id,
-        value: entry.id,
-      };
-      FallbackWorldEngineCyberia.itemInventoryFlags[entry.id] = !!entry.defaultPlayerInventory;
-      ids.push(entry.id);
-    }
-    DropDown.Tokens[dropdownId].value = [...ids];
-    if (s(`.${dropdownId}`)) s(`.${dropdownId}`).value = [...ids];
-    DropDown.Tokens[dropdownId]._renderSelectedBadges?.();
-    FallbackWorldEngineCyberia.renderItemInventoryList();
-  }
-
-  static async buildItemIdsDropdown() {
-    return await DropDown.instance({
-      id: FallbackWorldEngineCyberia.itemIdsDropdownId,
-      label: html`Object Layer Item IDs`,
-      data: [],
-      type: 'checkbox',
-      containerClass: 'inl',
-      excludeSelected: true,
-      serviceProvider: async (q) => {
-        const result = await ObjectLayerService.searchItemIds({ q });
-        if (result.status === 'success' && result.data?.itemIds) {
-          return result.data.itemIds.map((itemId) => createDropdownOption(itemId));
-        }
-        return [];
-      },
-    });
-  }
-
-  static async render(options = {}) {
-    const { appStore } = options;
-    const role = appStore?.Data?.user?.main?.model?.user?.role || 'guest';
-    const canMutate = commonModeratorGuard(role);
-    const idHotReloadUrl = 'fallback-world-engine-input-hot-reload-url';
-    const idItemIdsDropdown = FallbackWorldEngineCyberia.itemIdsDropdownId;
-    const idItemInventoryList = FallbackWorldEngineCyberia.itemInventoryListId;
-
-    setTimeout(async () => {
-      // Keep the per-item "Default Player Inventory" toggles in sync with the
-      // item-ids dropdown. Every add/remove/clear re-renders the dropdown badge
-      // container, so observing it is a reliable change hook (the dropdown
-      // exposes no onChange callback).
-      const itemBadgeContainer = s(`.dropdown-current-${idItemIdsDropdown}`);
-      if (itemBadgeContainer) {
-        const itemInventoryObserver = new MutationObserver(() => {
-          FallbackWorldEngineCyberia.renderItemInventoryList();
-        });
-        itemInventoryObserver.observe(itemBadgeContainer, { childList: true, subtree: true });
-      }
-
-      // Load whatever this engine process currently serves, so reopening the
-      // view shows the live set rather than an empty form.
-      try {
-        const result = await CyberiaInstanceService.getFallbackDefaultItems();
-        if (result?.status === 'success') {
-          FallbackWorldEngineCyberia.entityDefaultItemIds = result.data?.entityDefaultItemIds || [];
-          FallbackWorldEngineCyberia.syncItemIdsDropdownSelection(result.data?.itemIds || []);
-        }
-      } catch (error) {
-        NotificationManager.Push({ html: error.message, status: 'error' });
-      }
-      FallbackWorldEngineCyberia.renderItemInventoryList();
-
-      if (s(`.btn-fallback-world-engine-load-defaults`))
-        s(`.btn-fallback-world-engine-load-defaults`).onclick = () => {
-          // Seed from the canonical registry so an operator starts from the
-          // same list `import-default-items` creates ObjectLayers for. Ids the
-          // entity defaults already ship start checked: selecting them
-          // unchecked would strip them from those defaults, which is never what
-          // "load the defaults" is asking for.
-          const flags = Object.fromEntries(
-            FallbackWorldEngineCyberia.getItemIdsPayload().map((e) => [e.id, e.defaultPlayerInventory]),
-          );
-          FallbackWorldEngineCyberia.syncItemIdsDropdownSelection(
-            DefaultCyberiaItems.map((entry) => ({
-              id: entry.item.id,
-              defaultPlayerInventory:
-                flags[entry.item.id] ?? FallbackWorldEngineCyberia.entityDefaultItemIds.includes(entry.item.id),
-            })),
-          );
-        };
-
-      if (s(`.btn-fallback-world-engine-clear`))
-        s(`.btn-fallback-world-engine-clear`).onclick = () => {
-          FallbackWorldEngineCyberia.syncItemIdsDropdownSelection([]);
-        };
-
-      if (s(`.btn-fallback-world-engine-toggle-hot-reload`))
-        s(`.btn-fallback-world-engine-toggle-hot-reload`).onclick = () => {
-          const body = s(`.fallback-world-engine-hot-reload-body`);
-          const caret = s(`.fallback-world-engine-hot-reload-caret`);
-          if (body) body.classList.toggle('hide');
-          if (caret) {
-            caret.classList.toggle('fa-caret-right');
-            caret.classList.toggle('fa-caret-down');
-          }
-        };
-
-      const triggerHotReload = async (mode) => {
-        const buttons = [
-          s(`.btn-fallback-world-engine-hot-reload`),
-          s(`.btn-fallback-world-engine-hot-reload-incremental`),
-        ];
-        const statusSelector = `.fallback-world-engine-hot-reload-status`;
-        const serverUrl = s(`.${idHotReloadUrl}`)?.value?.trim();
-        if (!serverUrl) {
-          NotificationManager.Push({ html: 'Set the cyberia-server URL first.', status: 'warning' });
-          return;
-        }
-
-        for (const btn of buttons) if (btn) btn.disabled = true;
-        if (s(statusSelector))
-          htmls(statusSelector, html`<span style="color:#888;">Triggering ${mode} hot reload…</span>`);
-        try {
-          const result = await CyberiaInstanceService.fallbackHotReload({
-            body: { serverUrl, mode, itemIds: FallbackWorldEngineCyberia.getItemIdsPayload() },
-          });
-          if (result.status === 'error') {
-            NotificationManager.Push({ html: result.message, status: 'error' });
-            if (s(statusSelector)) htmls(statusSelector, html`<span style="color:#d66;">${result.message}</span>`);
-            return;
-          }
-          const { transport, durationMs, message, grpcError, itemIds } = result.data || {};
-          NotificationManager.Push({ html: `Hot reload via ${transport}: ${message}`, status: 'success' });
-          if (s(statusSelector))
-            htmls(
-              statusSelector,
-              html`<span style="color:#6b6;">
-                  via <b>${transport}</b> · ${durationMs}ms · ${(itemIds || []).length} default item(s) staged ·
-                  ${message} </span
-                >${grpcError ? html`<div style="color:#a80;">gRPC unavailable: ${grpcError}</div>` : ''}`,
-            );
-        } catch (error) {
-          NotificationManager.Push({ html: error.message, status: 'error' });
-          if (s(statusSelector)) htmls(statusSelector, html`<span style="color:#d66;">${error.message}</span>`);
-        } finally {
-          for (const btn of buttons) if (btn) btn.disabled = false;
-        }
-      };
-
-      if (s(`.btn-fallback-world-engine-hot-reload`))
-        s(`.btn-fallback-world-engine-hot-reload`).onclick = () => triggerHotReload('full');
-      if (s(`.btn-fallback-world-engine-hot-reload-incremental`))
-        s(`.btn-fallback-world-engine-hot-reload-incremental`).onclick = () => triggerHotReload('incremental');
-    });
-
-    return html`
-      <div class="in fallback-world-engine-container">
-        <div class="in section-mp" style="color:#888;font-size:12px;">
-          The fallback world is generated in memory and never persisted, so it has no instance document to edit. Items
-          selected here are staged on this engine process and applied when a cyberia-server reloads. They are volatile:
-          an engine restart returns the world to its code defaults.
-        </div>
-
-        <div class="in section-mp" style="margin-top: 10px;">
-          <div class="in input-label" style="font-size:14px;margin-bottom:5px;">Default Items</div>
-          ${await FallbackWorldEngineCyberia.buildItemIdsDropdown()}
-        </div>
-        <div class="in section-mp" style="margin-top: 5px;">
-          <div class="in input-label" style="font-size:13px;margin-bottom:5px;">Default Player Inventory</div>
-          <div class="in" style="color:#888;font-size:12px;margin-bottom:6px;">
-            Every selected id is resolved to an atlas at boot. Ids checked here are seeded into each new player's
-            inventory (inactive, never auto-equipped); unchecked ids are explicitly removed from the player's default
-            layers.
-          </div>
-          <div class="in ${idItemInventoryList}" style="max-height:200px;overflow-y:auto;"></div>
-          ${canMutate
-            ? html`<div class="in" style="display:flex;gap:5px;flex-wrap:wrap;margin-top:10px;">
-                ${await BtnIcon.instance({
-                  class: 'wfa btn-fallback-world-engine-load-defaults',
-                  label: html`<i class="fa-solid fa-list-check"></i> Load Canonical Defaults`,
-                })}
-                ${await BtnIcon.instance({
-                  class: 'wfa btn-fallback-world-engine-clear',
-                  label: html`<i class="fa-solid fa-eraser"></i> Clear Selection`,
-                })}
-              </div>`
-            : ''}
-        </div>
-
-        ${canMutate
-          ? html`<div class="in section-mp" style="margin-top: 10px;">
-              ${await BtnIcon.instance({
-                class: 'wfa btn-fallback-world-engine-toggle-hot-reload',
-                label: html`<i class="fa-solid fa-caret-right fallback-world-engine-hot-reload-caret"></i> Hot Reload`,
-              })}
-              <div class="in fallback-world-engine-hot-reload-body hide">
-                <div class="in" style="color:#888;font-size:12px;margin:5px 0;">
-                  Stages the items above on this engine, then rebuilds the world of a running cyberia-server so it
-                  re-fetches them. Tries the gRPC control service first and falls back to the REST endpoint. For a
-                  multi-instance deployment, append the variant sub-path so the trigger reaches the right world (e.g.
-                  <code>https://server.cyberiaonline.com/TEST</code>); the default world uses the bare origin.
-                </div>
-                ${await Input.instance({
-                  id: idHotReloadUrl,
-                  label: html`<i class="fa-solid fa-server"></i> Cyberia Server URL`,
-                  containerClass: 'in',
-                  placeholder: 'https://server.cyberiaonline.com/TEST',
-                  type: 'text',
-                })}
-                <div class="in" style="display:flex;gap:5px;flex-wrap:wrap;margin-top:5px;">
-                  ${await BtnIcon.instance({
-                    class: 'wfa btn-fallback-world-engine-hot-reload',
-                    label: html`<i class="fa-solid fa-rotate"></i> Trigger Hot Reload`,
-                  })}
-                  ${await BtnIcon.instance({
-                    class: 'wfa btn-fallback-world-engine-hot-reload-incremental',
-                    label: html`<i class="fa-solid fa-layer-group"></i> Incremental (assets only)`,
-                  })}
-                </div>
-                <div class="in fallback-world-engine-hot-reload-status" style="margin-top:5px;font-size:12px;"></div>
-              </div>
-            </div>`
-          : ''}
-      </div>
-    `;
-  }
-}
-
-export { FallbackWorldEngineCyberia };