@underpostnet/cyberia 3.3.0 → 3.3.76

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

@@ -7,8 +7,14 @@
  */
 
 import fs from 'fs-extra';
-import { shellExec } from '../server/process.js';
-import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/runtime/process.js';
+import { loggerFactory } from '../server/ops/logger.js';
+import {
+  coverageReportCandidates,
+  coverageReportsFactory,
+  coverageUnavailablePage,
+  resolveCoverageReportPath,
+} from '../server/build/coverage.js';
 import { JSONweb } from './client-formatted.js';
 import { ssrFactory } from './ssr.js';
 
@@ -20,6 +26,8 @@ import { ssrFactory } from './ssr.js';
  * @param {string} options.host - The hostname for the API
  * @param {string} options.path - The base path for the API
  * @param {number} options.port - The port number for the API
+ * @param {string} [options.apiBaseHost] - Host serving the API when it is split from the client
+ * @param {string} [options.apiBaseProxyPath] - Proxy path of the API runtime when it is split from the client
  * @param {Object} options.metadata - Metadata for the API documentation
  * @param {Array<string>} options.apis - List of API modules to document
  * @param {string} options.publicClientId - Client ID for the public documentation
@@ -30,6 +38,8 @@ const buildApiDocs = async ({
   host,
   path,
   port,
+  apiBaseHost,
+  apiBaseProxyPath,
   metadata = {},
   apis = [],
   publicClientId,
@@ -37,7 +47,10 @@ const buildApiDocs = async ({
   packageData,
 }) => {
   const logger = loggerFactory(import.meta);
-  const basePath = path === '/' ? `${process.env.BASE_API}` : `/${process.env.BASE_API}`;
+  // The spec is rendered by the client instance but exercised against the API runtime;
+  // when the two are split the server url must follow the API, not the docs page.
+  const apiPath = apiBaseProxyPath ? apiBaseProxyPath : path;
+  const basePath = apiPath === '/' ? `${process.env.BASE_API}` : `/${process.env.BASE_API}`;
 
   const doc = {
     info: {
@@ -49,8 +62,8 @@ const buildApiDocs = async ({
       {
         url:
           process.env.NODE_ENV === 'development'
-            ? `http://localhost:${port}${path}${basePath}`
-            : `https://${host}${path}${basePath}`,
+            ? `http://${apiBaseHost ? apiBaseHost : `localhost:${port}`}${apiPath}${basePath}`
+            : `https://${apiBaseHost ? apiBaseHost : host}${apiPath}${basePath}`,
         description: `${process.env.NODE_ENV} server`,
       },
     ],
@@ -284,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');
+  }
 };
 
 /**
@@ -371,62 +382,60 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId, docs, do
   fs.writeFileSync(tmpConfigPath, JSON.stringify(runtimeConfig, null, 2), 'utf8');
   logger.warn('build typedoc view', docsDestination);
 
-  shellExec(`node_modules/.bin/typedoc --options ${tmpConfigPath}`, { silent: true });
+  // Non-fatal like every other docs surface: a typedoc failure leaves the reference site
+  // unpublished, it does not take a rollout down with it.
+  const result = shellExec(`node_modules/.bin/typedoc --options ${tmpConfigPath}`, {
+    silent: true,
+    silentOnError: true,
+  });
 
   fs.removeSync(tmpConfigPath);
+
+  if (fs.existsSync(`${docsDestination}index.html`)) return;
+  logger.warn('typedoc produced no HTML index', {
+    docsDestination,
+    code: result?.code,
+    stderr: `${result?.stderr ?? ''}`.trim().split('\n').slice(-1)[0],
+  });
 };
 
 /**
- * Builds test coverage documentation
+ * Publishes every coverage HTML report the deploy declares, each at `docs/coverage/<id>`.
+ *
+ * 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
+ * `container-status=error`, failing the deployment monitor on a healthy rollout.
  * @function buildCoverage
  * @memberof clientBuildDocs
  * @param {Object} options - Coverage build options
  * @param {Object} options.docs - Documentation config from server conf
- * @param {string} options.docs.coveragePath - Directory where coverage reports are generated
+ * @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;
+  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 coverageOutputPath = `${coveragePath}/coverage`;
-  if (!fs.existsSync(coverageOutputPath)) {
-    const pkgPath = `${coveragePath}/package.json`;
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.scripts && pkg.scripts.coverage) {
-        logger.info('generating coverage report', coveragePath);
-        try {
-          await shellExec(`cd ${coveragePath} && npm run coverage`, { silent: true });
-        } catch (err) {
-          logger.warn('coverage generation failed (non-fatal), skipping:', err.message);
-          return;
-        }
-      } else if (pkg.scripts && pkg.scripts.test) {
-        logger.info('generating coverage via test', coveragePath);
-        try {
-          await shellExec(`cd ${coveragePath} && npm test`, { silent: true, silentOnError: true });
-        } catch (err) {
-          logger.warn('coverage generation failed (non-fatal), skipping:', err.message);
-          return;
-        }
-      }
+    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 (fs.existsSync(coverageOutputPath) && fs.readdirSync(coverageOutputPath).length > 0) {
-    const coverageBuildPath = `${docsDestination}${coverageOutputDir}`;
-    fs.mkdirSync(coverageBuildPath, { recursive: true });
-    // Hardhat 3 outputs HTML to coverage/html/; Hardhat 2 / c8 output directly to coverage/
-    const coverageHtmlSubdir = `${coverageOutputPath}/html`;
-    if (fs.existsSync(coverageHtmlSubdir) && fs.existsSync(`${coverageHtmlSubdir}/index.html`)) {
-      fs.copySync(coverageHtmlSubdir, coverageBuildPath);
-    } else {
-      fs.copySync(coverageOutputPath, coverageBuildPath);
-    }
+    fs.copySync(reportPath, coverageBuildPath);
     logger.warn('build coverage', coverageBuildPath);
-  } else {
-    logger.warn('no coverage output found, skipping', coverageOutputPath);
   }
 };
 
@@ -438,6 +447,8 @@ const buildCoverage = async ({ docs, docsDestination }) => {
  * @param {string} options.host - The hostname
  * @param {string} options.path - The base path
  * @param {number} options.port - The port number
+ * @param {string} [options.apiBaseHost] - Host serving the API when it is split from the client
+ * @param {string} [options.apiBaseProxyPath] - Proxy path of the API runtime when it is split from the client
  * @param {Object} options.metadata - Metadata for the documentation
  * @param {Array<string>} options.apis - List of API modules to document
  * @param {string} options.publicClientId - Client ID for the public documentation
@@ -449,6 +460,8 @@ const buildDocs = async ({
   host,
   path,
   port,
+  apiBaseHost,
+  apiBaseProxyPath,
   metadata = {},
   apis = [],
   publicClientId,
@@ -460,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 });
@@ -468,6 +481,8 @@ const buildDocs = async ({
     host,
     path,
     port,
+    apiBaseHost,
+    apiBaseProxyPath,
     metadata,
     apis,
     publicClientId,
@@ -490,4 +505,4 @@ const buildSwaggerUiOptions = async () => {
   return { customCss: css, customJsStr: js };
 };
 
-export { buildDocs, buildSwaggerUiOptions };
+export { buildCoverage, buildDocs, buildSwaggerUiOptions };

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

@@ -5,8 +5,8 @@
  */
 
 import fs from 'fs-extra';
-import { Config, loadConf, readConfJson } from '../server/conf.js';
-import { loggerFactory } from '../server/logger.js';
+import { Config, loadConf, readConfJson } from '../server/runtime/conf.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import { buildClient } from './client-build.js';
 
 const logger = loggerFactory(import.meta);

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

@@ -8,24 +8,26 @@
 
 import fs from 'fs-extra';
 import { transformClientJs, JSONweb } from './client-formatted.js';
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import {
   getCapVariableName,
   newInstance,
   orderArrayFromAttrInt,
   uniqueArray,
 } from '../client/components/core/CommonJs.js';
-import { readConfJson } from '../server/conf.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/process.js';
+import { shellExec } from '../server/runtime/process.js';
 import { SitemapStream, streamToPromise } from 'sitemap';
 import { Readable } from 'stream';
 import { buildIcons } from './client-icons.js';
-import { statusPageBuildSegment } from '../server/underpost-gateway.js';
+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)
@@ -179,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);
@@ -268,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(/[-.]$/, '') + '-';
@@ -300,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', {
@@ -336,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],
@@ -533,6 +553,7 @@ const defaultSitemapXsl = `<?xml version="1.0" encoding="UTF-8"?>
 const buildClient = async (
   options = {
     deployId: '',
+    subConf: '',
     liveClientBuildPaths: [],
     instances: [],
     buildZip: false,
@@ -543,9 +564,13 @@ const buildClient = async (
 ) => {
   const logger = loggerFactory(import.meta);
   const deployId = options.deployId || process.env.DEPLOY_ID;
-  const confClient = readConfJson(deployId, 'client');
-  const confServer = readConfJson(deployId, 'server', { loadReplicas: true });
-  const confSSR = readConfJson(deployId, 'ssr');
+  // Carried as an argument rather than re-derived from DEPLOY_SUB_CONF: the caller already
+  // resolved which sub-configuration this build is for, and a build that reads a different
+  // conf.server than the one its caller loaded renders the wrong set of hosts.
+  const subConf = `${options.subConf ?? ''}`.trim();
+  const confClient = readConfJson(deployId, 'client', { subConf });
+  const confServer = readConfJson(deployId, 'server', { subConf, loadReplicas: true });
+  const confSSR = readConfJson(deployId, 'ssr', { subConf });
   const packageData = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
   const acmeChallengePath = `/.well-known/acme-challenge`;
   const publicPath = `./public`;
@@ -689,6 +714,20 @@ const buildClient = async (
       // ''; // process.env.NODE_ENV === 'production' ? `https://${host}` : ``;
       currentPort++;
 
+      // Every document this instance emits carries the same payload; the SSR
+      // views and the client index must never disagree about which repository
+      // published them.
+      const renderPayload = {
+        apiBaseProxyPath,
+        apiBaseHost,
+        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),
+      };
+
       const acmeChallengeFullPath = directory
         ? `${directory}${acmeChallengePath}`
         : `${publicPath}/${host}${acmeChallengePath}`;
@@ -815,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
@@ -854,7 +891,7 @@ const buildClient = async (
                 confSSR[view.ssr].head.unshift('Production');
 
               for (const ssrHeadComponent of confSSR[view.ssr].head) {
-                const SrrComponent = await ssrFactory(`./src/client/ssr/head/${ssrHeadComponent}.js`);
+                const SSRComponent = await ssrFactory(`./src/client/ssr/head/${ssrHeadComponent}.js`);
 
                 switch (ssrHeadComponent) {
                   case 'Pwa':
@@ -909,11 +946,11 @@ const buildClient = async (
                       // ],
                       // "prefer_related_applications": true
                     }
-                    if (validPwaBuild) ssrHeadComponents += SrrComponent({ title, ssrPath, canonicalURL, ...metadata });
+                    if (validPwaBuild) ssrHeadComponents += SSRComponent({ title, ssrPath, canonicalURL, ...metadata });
                     break;
                   case 'Seo':
                     if (metadata) {
-                      ssrHeadComponents += SrrComponent({ title, ssrPath, canonicalURL, ...metadata });
+                      ssrHeadComponents += SSRComponent({ title, ssrPath, canonicalURL, ...metadata });
                     }
                     break;
                   case 'Microdata':
@@ -925,18 +962,18 @@ const buildClient = async (
                       const microdata = JSON.parse(
                         fs.readFileSync(`./src/client/public/${publicClientId}/microdata.json`, 'utf8'),
                       );
-                      ssrHeadComponents += SrrComponent({ microdata });
+                      ssrHeadComponents += SSRComponent({ microdata });
                     }
                     break;
                   default:
-                    ssrHeadComponents += SrrComponent({ ssrPath, host, path });
+                    ssrHeadComponents += SSRComponent({ ssrPath, host, path });
                     break;
                 }
               }
 
               for (const ssrBodyComponent of confSSR[view.ssr].body) {
-                const SrrComponent = await ssrFactory(`./src/client/ssr/body/${ssrBodyComponent}.js`);
-                ssrBodyComponents += SrrComponent({
+                const SSRComponent = await ssrFactory(`./src/client/ssr/body/${ssrBodyComponent}.js`);
+                ssrBodyComponents += SSRComponent({
                   ...metadata,
                   ssrPath,
                   host,
@@ -962,13 +999,7 @@ const buildClient = async (
               ssrPath,
               ssrHeadComponents,
               ssrBodyComponents,
-              renderPayload: {
-                apiBaseProxyPath,
-                apiBaseHost,
-                apiBasePath: process.env.BASE_API,
-                version: Underpost.version,
-                ...(isDevelopment ? { dev: true } : undefined),
-              },
+              renderPayload,
               renderApi: {
                 JSONweb,
               },
@@ -1031,6 +1062,8 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
           host,
           path,
           port,
+          apiBaseHost,
+          apiBaseProxyPath,
           metadata,
           apis,
           publicClientId,
@@ -1064,13 +1097,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
             ssrPath,
             ssrHeadComponents: '<base target="_top">',
             ssrBodyComponents: SsrComponent(),
-            renderPayload: {
-              apiBaseProxyPath,
-              apiBaseHost,
-              apiBasePath: process.env.BASE_API,
-              version: Underpost.version,
-              ...(isDevelopment ? { dev: true } : undefined),
-            },
+            renderPayload,
             renderApi: { JSONweb },
           });
 
@@ -1116,7 +1143,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
 
         if (swShouldRebuild) {
           const cacheScope = path === '/' ? 'root' : path.replaceAll('/', '_');
-          const renderPayload = {
+          const swRenderPayload = {
             PRE_CACHED_RESOURCES: uniqueArray(PRE_CACHED_RESOURCES),
             PROXY_PATH: path,
             CACHE_PREFIX: `engine-core-${cacheScope}`,
@@ -1127,7 +1154,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
           // Single write: prepend the payload prelude to the transformed SW JS.
           fs.writeFileSync(
             swPublicPath,
-            `self.renderPayload = ${JSONweb(renderPayload)};
+            `self.renderPayload = ${JSONweb(swRenderPayload)};
 self.__WB_DISABLE_DEV_LOGS = true;
 ${swTransformedJs}`,
             'utf8',
@@ -1139,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({
@@ -1173,7 +1202,9 @@ ${swTransformedJs}`,
 
 export {
   buildClient,
+  clientBundleIdFactory,
   copyNonExistingFiles,
+  getZipPartPaths,
   unzipClientBuild,
   mergeClientBuildZip,
   staticContextRoutesFactory,