@underpostnet/cyberia 3.3.73 → 3.3.76

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 };

package/src/client/services/object-layer/object-layer.management.js

@@ -26,7 +26,7 @@ class ObjectLayerManagement {
         this.eGui = document.createElement('div');
         const { data } = params;
 
-        if (!data || !data._id) {
+        if (!data?.data?.item?.id) {
           this.eGui.innerHTML = '';
           return;
         }
@@ -43,10 +43,8 @@ class ObjectLayerManagement {
           if (btn)
             btn.onclick = async () =>
               setTimeout(async () => {
-                // Navigate to viewer route first
                 setPath(`${getProxyPath()}object-layer-engine-viewer`);
-                // Then add query param without replacing history
-                setQueryParams({ id: data._id }, { replace: true });
+                setQueryParams({ id: null, itemId: data.data.item.id }, { replace: true });
                 if (s(`.modal-object-layer-engine-viewer`)) {
                   await ObjectLayerEngineViewer.Reload({ appStore, force: true });
                 }
@@ -72,7 +70,7 @@ class ObjectLayerManagement {
         this.eGui = document.createElement('div');
         const { data } = params;
 
-        if (!data || !data._id) {
+        if (!data?.data?.item?.id) {
           this.eGui.innerHTML = '';
           return;
         }
@@ -89,10 +87,8 @@ class ObjectLayerManagement {
           if (btn)
             btn.onclick = async () =>
               setTimeout(async () => {
-                // Navigate to editor route first
                 setPath(`${getProxyPath()}object-layer-engine`);
-                // Then add query param without replacing history
-                setQueryParams({ id: data._id }, { replace: true });
+                setQueryParams({ id: null, itemId: data.data.item.id }, { replace: true });
                 if (s(`.modal-object-layer-engine`)) await ObjectLayerEngineModal.Reload();
                 else s(`.main-btn-object-layer-engine`).click();
               });
@@ -121,8 +117,8 @@ class ObjectLayerManagement {
           return;
         }
 
-        const { type, id } = data.data.item;
-        const imagePath = `${getProxyPath()}assets/${type}/${id}/08/0.png`;
+        const { id } = data.data.item;
+        const imagePath = `${getProxyPath()}api/atlas-sprite-sheet/idle-preview/${id}`;
 
         // Container with both image and fallback
         this.eGui.innerHTML = html`

package/src/client/services/object-layer/object-layer.service.js

@@ -183,9 +183,11 @@ class ObjectLayerService {
         }),
     );
   };
-  static searchItemIds = (options = { q: '' }) => {
+  /** Item identity ({ id, type }) by id prefix (`q`) or by an exact id list (`ids`). */
+  static searchItemIds = (options = { q: '', ids: [] }) => {
     const url = new URL(getApiBaseUrl({ id: `search-item-ids`, endpoint }));
     if (options.q) url.searchParams.set('q', options.q);
+    if (options.ids?.length) url.searchParams.set('ids', options.ids.join(','));
     return new Promise((resolve, reject) =>
       fetch(url.toString(), {
         method: 'GET',

package/src/client-builder/client-build-docs.js

@@ -11,6 +11,7 @@ import { shellExec } from '../server/runtime/process.js';
 import { loggerFactory } from '../server/ops/logger.js';
 import {
   coverageReportCandidates,
+  coverageReportsFactory,
   coverageUnavailablePage,
   resolveCoverageReportPath,
 } from '../server/build/coverage.js';
@@ -296,43 +297,41 @@ const buildApiDocs = async ({
       ),
     'utf8',
   );
-  setTimeout(async () => {
-    const { default: swaggerAutoGen } = await import('swagger-autogen');
-    const outputFile = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
-    const routes = [];
-    for (const api of apis) {
-      if (['user', 'object-layer'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
-    }
+  // Imported after the patch above, and awaited: the spec is part of the client build
+  // output, so a bundle zipped before it landed shipped without one and the pod that
+  // restored that bundle served no `api-docs`.
+  const { default: swaggerAutoGen } = await import('swagger-autogen');
+  const outputFile = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
+  const routes = [];
+  for (const api of apis) {
+    if (['user', 'object-layer'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
+  }
 
-    await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
+  await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
 
-    // Post-process: inject requestBody into operations — swagger-autogen silently
-    // ignores #swagger.requestBody annotations and has no internal OAS-3 body support.
-    if (fs.existsSync(outputFile)) {
-      const swaggerJson = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
-      let patched = false;
+  // Post-process: inject requestBody into operations — swagger-autogen silently
+  // ignores #swagger.requestBody annotations and has no internal OAS-3 body support.
+  if (fs.existsSync(outputFile)) {
+    const swaggerJson = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
+    let patched = false;
 
-      for (const [key, requestBody] of Object.entries(requestBodies)) {
-        const [method, ...pathParts] = key.split(' ');
-        const opPath = pathParts.join(' ');
-        if (swaggerJson.paths?.[opPath]?.[method]) {
-          swaggerJson.paths[opPath][method].requestBody = requestBody;
-          // Remove any stale in:body entry from parameters (OAS 3.0 doesn't allow it)
-          if (Array.isArray(swaggerJson.paths[opPath][method].parameters)) {
-            swaggerJson.paths[opPath][method].parameters = swaggerJson.paths[opPath][method].parameters.filter(
-              (p) => p.in !== 'body',
-            );
-          }
-          patched = true;
+    for (const [key, requestBody] of Object.entries(requestBodies)) {
+      const [method, ...pathParts] = key.split(' ');
+      const opPath = pathParts.join(' ');
+      if (swaggerJson.paths?.[opPath]?.[method]) {
+        swaggerJson.paths[opPath][method].requestBody = requestBody;
+        // Remove any stale in:body entry from parameters (OAS 3.0 doesn't allow it)
+        if (Array.isArray(swaggerJson.paths[opPath][method].parameters)) {
+          swaggerJson.paths[opPath][method].parameters = swaggerJson.paths[opPath][method].parameters.filter(
+            (p) => p.in !== 'body',
+          );
         }
-      }
-
-      if (patched) {
-        fs.writeFileSync(outputFile, JSON.stringify(swaggerJson, null, 2), 'utf8');
-        // logger.warn('swagger post-process: requestBody injected', Object.keys(requestBodies));
+        patched = true;
       }
     }
-  });
+
+    if (patched) fs.writeFileSync(outputFile, JSON.stringify(swaggerJson, null, 2), 'utf8');
+  }
 };
 
 /**
@@ -401,9 +400,9 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId, docs, do
 };
 
 /**
- * Publishes the coverage HTML report a build carried into the docs route.
+ * Publishes every coverage HTML report the deploy declares, each at `docs/coverage/<id>`.
  *
- * Never generates it: the report belongs to the test stage, which bundles it into the
+ * Never generates one: a report belongs to the test stage, which bundles it into the
  * deploy artifact (see {@link module:src/server/build/coverage.js}). A client build that
  * shelled out to `npm test` here spent minutes of a pod's build phase on a runner the
  * workload has no business holding, and every expected non-zero exit of that suite latched
@@ -412,31 +411,32 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId, docs, do
  * @memberof clientBuildDocs
  * @param {Object} options - Coverage build options
  * @param {Object} options.docs - Documentation config from server conf
- * @param {string} options.docs.coveragePath - Source tree root the report was bundled into
- * @param {string} [options.docs.coverageOutputDir] - Route directory under the docs path
+ * @param {Array<{id: string, label?: string, suite?: string, path?: string}>} [options.docs.coverage] - Declared reports
  * @param {string} options.docsDestination - Resolved output path where docs were built
  */
 const buildCoverage = async ({ docs, docsDestination }) => {
   const logger = loggerFactory(import.meta);
-  const { coveragePath, coverageOutputDir = 'coverage' } = docs;
-  // No configured source tree is a deploy that never declared coverage — not a missing report.
-  if (!coveragePath) return;
+  const reports = coverageReportsFactory(docs);
+  if (reports.length === 0) return;
+  // The route holds exactly the declared reports: one dropped from the conf leaves with it.
+  fs.emptyDirSync(`${docsDestination}coverage`);
+  for (const report of reports) {
+    const coverageBuildPath = `${docsDestination}coverage/${report.id}`;
+    const reportPath = resolveCoverageReportPath(report);
 
-  const coverageBuildPath = `${docsDestination}${coverageOutputDir}`;
-  const reportPath = resolveCoverageReportPath(coveragePath);
+    if (!reportPath) {
+      fs.outputFileSync(`${coverageBuildPath}/index.html`, coverageUnavailablePage(report), 'utf8');
+      logger.warn('no coverage report bundled, publishing the unavailable page', {
+        id: report.id,
+        searched: coverageReportCandidates(report),
+        published: coverageBuildPath,
+      });
+      continue;
+    }
 
-  if (!reportPath) {
-    fs.outputFileSync(`${coverageBuildPath}/index.html`, coverageUnavailablePage(), 'utf8');
-    logger.warn('no coverage report bundled, publishing the unavailable page', {
-      searched: coverageReportCandidates(coveragePath),
-      published: coverageBuildPath,
-    });
-    return;
+    fs.copySync(reportPath, coverageBuildPath);
+    logger.warn('build coverage', coverageBuildPath);
   }
-
-  fs.emptyDirSync(coverageBuildPath);
-  fs.copySync(reportPath, coverageBuildPath);
-  logger.warn('build coverage', coverageBuildPath);
 };
 
 /**
@@ -473,7 +473,7 @@ const buildDocs = async ({
   // TypeDoc output is versioned: served at /docs/engine/{version}/
   const version = (packageData?.version || '').replace(/^v/, '');
   const jsDocsDestination = `./public/${host}${pathPrefix}docs/engine/${version}/`;
-  // Coverage output at /docs/coverage/ (or /docs/{coverageOutputDir}/)
+  // Coverage reports at /docs/coverage/<id>/
   const coverageBaseDestination = `./public/${host}${pathPrefix}docs/`;
   await buildJsDocs({ host, path, metadata, publicClientId, docs, docsDestination: jsDocsDestination });
   await buildCoverage({ docs, docsDestination: coverageBaseDestination });