@underpostnet/cyberia 3.3.73 → 3.3.77

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/ssr/views/Cyberia404.js

@@ -155,7 +155,7 @@ const main = () => {
           text-align: center;
           padding: 24px;
         }
-        .badge {
+        .status-badge {
           display: inline-flex;
           align-items: center;
           gap: 8px;
@@ -168,7 +168,7 @@ const main = () => {
           margin-bottom: 26px;
           box-shadow: 0 0 12px rgba(34, 211, 238, 0.35);
         }
-        .badge .dot {
+        .status-badge .dot {
           width: 8px;
           height: 8px;
           background: var(--green);
@@ -296,7 +296,7 @@ const main = () => {
       </style>
       <div class="grid"></div>
       <main class="wrap">
-        <span class="badge"><span class="dot"></span> INSTANCE ${instanceLabel()}</span>
+        <span class="status-badge"><span class="dot"></span> INSTANCE ${instanceLabel()}</span>
         <div class="code" data-text="404">404</div>
         <div class="headline">SIGNAL LOST</div>
         <p class="sub">

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

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

@@ -17,7 +17,7 @@ import {
 } from '../client/components/core/CommonJs.js';
 import { readConfJson } from '../server/runtime/conf.js';
 import { minify } from 'html-minifier-terser';
-import AdmZip from 'adm-zip';
+import { extractZipTo, findZipEntry, isZipBuffer, loadZip, zipFromLocalFiles } from '../server/storage/zip.js';
 import * as dir from 'path';
 import { shellExec } from '../server/runtime/process.js';
 import { SitemapStream, streamToPromise } from 'sitemap';
@@ -27,6 +27,7 @@ import { statusPageBuildSegment } from '../server/network/underpost-gateway.js';
 import { repositoryIdentityFactory } from '../server/storage/repository.js';
 import Underpost from '../index.js';
 import { buildDocs } from './client-build-docs.js';
+import { coverageReportsFactory } from '../server/build/coverage.js';
 import { ssrFactory } from './ssr.js';
 
 // Static Site Generation (SSG)
@@ -180,6 +181,17 @@ const splitFileByMb = ({ filePath, partSizeMb, logger }) => {
   return partPaths;
 };
 
+/**
+ * Names the zip artifact a served route builds to. Single source of truth for the bundle
+ * identity: the build writes `<id>.zip`, and push/pull address the same file by this name.
+ * @function clientBundleIdFactory
+ * @param {string} host - The served host.
+ * @param {string} routePath - The route's proxy sub-path (`/`, `/peer`, ...).
+ * @returns {string} The bundle id, e.g. `underpost.net-` for `/` or `underpost.net-peer`.
+ * @memberof clientBuild
+ */
+const clientBundleIdFactory = (host, routePath) => `${host}-${`${routePath ?? ''}`.replaceAll('/', '')}`;
+
 const getZipPartPaths = (zipPath) => {
   const zipDir = dir.dirname(zipPath);
   const zipBase = dir.basename(zipPath);
@@ -269,9 +281,9 @@ const resolveClientBuildZip = (buildPrefix) => {
  * @param {object} options
  * @param {string} options.buildPrefix - The build prefix path (e.g. build/underpost.net/underpost.net-).
  * @param {object} options.logger - Logger instance.
- * @returns {{ zipPath: string, partPaths: string[], mergedBytes: number }}
+ * @returns {Promise<{ zipPath: string, partPaths: string[], mergedBytes: number }>}
  */
-const mergeClientBuildZip = ({ buildPrefix, logger }) => {
+const mergeClientBuildZip = async ({ buildPrefix, logger }) => {
   // Normalize to get the zip path, then look for parts directly (bypassing resolveClientBuildZip
   // which prefers an existing monolithic zip over parts).
   const normalizedPrefix = buildPrefix.replace(/\.zip(?:[.-]part\d+)?$/, '').replace(/[-.]$/, '') + '-';
@@ -301,31 +313,41 @@ const mergeClientBuildZip = ({ buildPrefix, logger }) => {
   // For each part, extract raw bytes: if the part file is a Cloudinary wrapper zip
   // (downloaded via pull without --omit-unzip or with --omit-unzip keeping the .zip),
   // extract the inner entry rather than using the wrapper bytes.
-  const readPartBytes = (partPath) => {
+  const readPartBytes = async (partPath) => {
     const rawBytes = fs.readFileSync(partPath);
-    // Check for ZIP magic bytes (PK\x03\x04)
-    if (rawBytes[0] === 0x50 && rawBytes[1] === 0x4b && rawBytes[2] === 0x03 && rawBytes[3] === 0x04) {
-      try {
-        const wrapperZip = new AdmZip(rawBytes);
-        const entries = wrapperZip.getEntries();
-        // The inner entry is the original part file (without the outer .zip wrapper)
-        const partBase = dir.basename(partPath).replace(/\.zip$/i, '');
-        const entry = entries.find((e) => e.entryName === partBase || e.entryName.endsWith('/' + partBase));
-        if (entry) {
-          return entry.getData();
-        }
-        // Fallback: single-entry archive
-        if (entries.length === 1) {
-          return entries[0].getData();
-        }
-      } catch (_) {
-        // Not a valid zip or extraction failed — use raw bytes
-      }
+    if (!isZipBuffer(rawBytes)) return rawBytes;
+
+    let wrapper;
+    try {
+      wrapper = await loadZip(rawBytes);
+    } catch (_) {
+      // A raw split part carries the zip signature but no central directory, so failing to load
+      // is how a part that was never wrapped identifies itself.
+      return rawBytes;
     }
-    return rawBytes;
+
+    // A part pulled from storage arrives inside the archive the download produced. Falling back
+    // to that wrapper's own bytes merges compressed data into the bundle and surfaces much later
+    // as a corrupt archive, so a wrapper whose part cannot be found fails here and names itself.
+    const entry = findZipEntry(wrapper, dir.basename(partPath).replace(/\.zip$/i, ''));
+    if (!entry) throw new Error(`Bundle part wrapper holds no matching entry: ${partPath}`);
+    return await entry.async('nodebuffer');
   };
 
-  const mergedBuffer = Buffer.concat(partPaths.map(readPartBytes));
+  const partBuffers = [];
+  for (const partPath of partPaths) partBuffers.push(await readPartBytes(partPath));
+  const mergedBuffer = Buffer.concat(partBuffers);
+
+  // A short part anywhere in the sequence only shows up as a byte count against the assembled
+  // archive, which names nothing. Reporting each part's contribution is what makes the one that
+  // came up short identifiable.
+  logger.info('merge-zip: part sizes', {
+    zipPath,
+    parts: partPaths.map((partPath, index) => ({
+      part: dir.basename(partPath),
+      bytes: partBuffers[index].length,
+    })),
+  });
   fs.writeFileSync(zipPath, mergedBuffer);
 
   logger.warn('merge-zip: merged split parts into zip', {
@@ -337,19 +359,16 @@ const mergeClientBuildZip = ({ buildPrefix, logger }) => {
   return { zipPath, partPaths, mergedBytes: mergedBuffer.length };
 };
 
-const unzipClientBuild = ({ buildPrefix, logger }) => {
+const unzipClientBuild = async ({ buildPrefix, logger }) => {
   const { zipPath, partPaths, buildPrefix: resolvedBuildPrefix } = resolveClientBuildZip(buildPrefix);
   const outputPath = resolvedBuildPrefix.replace(/-$/, '');
 
   fs.removeSync(outputPath);
-  fs.mkdirSync(outputPath, { recursive: true });
-
-  const zip =
-    partPaths.length > 0
-      ? new AdmZip(Buffer.concat(partPaths.map((partPath) => fs.readFileSync(partPath))))
-      : new AdmZip(zipPath);
 
-  zip.extractAllTo(outputPath, true);
+  await extractZipTo(
+    partPaths.length > 0 ? Buffer.concat(partPaths.map((partPath) => fs.readFileSync(partPath))) : zipPath,
+    outputPath,
+  );
 
   logger.warn('unzip build', {
     source: partPaths.length > 0 ? partPaths : [zipPath],
@@ -704,6 +723,8 @@ const buildClient = async (
         apiBasePath: process.env.BASE_API,
         version: Underpost.version,
         repository: repositoryIdentityFactory(),
+        // The reports the docs menu offers, each published at /docs/coverage/<id>.
+        coverage: coverageReportsFactory(docs).map(({ id, label }) => ({ id, label })),
         ...(isDevelopment ? { dev: true } : undefined),
       };
 
@@ -833,14 +854,12 @@ const buildClient = async (
       }
 
       if (!ssrOnly && views) {
-        if (
-          !(
-            enableLiveRebuild &&
-            !options.liveClientBuildPaths.find(
-              (p) => p.srcBuildPath.startsWith(`./src/client/ssr`) || p.srcBuildPath.slice(-9) === '.index.js',
-            )
+        if (!(
+          enableLiveRebuild &&
+          !options.liveClientBuildPaths.find(
+            (p) => p.srcBuildPath.startsWith(`./src/client/ssr`) || p.srcBuildPath.slice(-9) === '.index.js',
           )
-        )
+        ))
           for (const view of views) {
             const buildPath = `${
               rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
@@ -1147,23 +1166,25 @@ ${swTransformedJs}`,
 
         if (!fs.existsSync('./build')) fs.mkdirSync('./build');
 
-        const zip = new AdmZip();
         const files = await fs.readdir(rootClientPath, { recursive: true });
+        const zipEntries = [];
 
         for (const relativePath of files) {
           const filePath = dir.resolve(`${rootClientPath}/${relativePath}`);
           if (!fs.lstatSync(filePath).isDirectory()) {
             const folder = dir.relative(`public/${host}${path}`, dir.dirname(filePath));
-            zip.addLocalFile(filePath, folder);
+            zipEntries.push({
+              localPath: filePath,
+              entryName: folder ? `${folder}/${dir.basename(filePath)}` : dir.basename(filePath),
+            });
           }
         }
 
-        const buildId = `${host}-${path.replaceAll('/', '')}`;
-        const zipPath = `./build/${buildId}.zip`;
+        const zipPath = `./build/${clientBundleIdFactory(host, path)}.zip`;
 
         logger.warn('write zip', zipPath);
 
-        zip.writeZip(zipPath);
+        fs.writeFileSync(zipPath, await zipFromLocalFiles(zipEntries));
 
         if (options.split) {
           splitFileByMb({
@@ -1181,7 +1202,9 @@ ${swTransformedJs}`,
 
 export {
   buildClient,
+  clientBundleIdFactory,
   copyNonExistingFiles,
+  getZipPartPaths,
   unzipClientBuild,
   mergeClientBuildZip,
   staticContextRoutesFactory,