@nmakarov/cli-toolkit 0.51.0 → 0.55.0

package/dist/index.cjs

@@ -1147,11 +1147,14 @@ __export(src_exports, {
   ensureTasksRuntime: () => ensureTasksRuntime,
   flushTaskIpcLogs: () => flushTaskIpcLogs,
   getArgsInstance: () => getArgsInstance,
+  getPm2Process: () => getPm2Process,
   h: () => import_react5.createElement,
   initServiceStructure: () => initServiceStructure,
   installDeps: () => installDeps,
   installOperatorShell: () => installOperatorShell,
   ipcFileLogsTableNameForSourceResource: () => ipcFileLogsTableNameForSourceResource,
+  isFreshOnline: () => isFreshOnline,
+  isPidAlive: () => isPidAlive,
   joiEdateType: () => joiEdateType,
   joiStringArrayType: () => joiStringArrayType,
   listAliveRunnerHeartbeats: () => listServicesRegistry,
@@ -1193,6 +1196,7 @@ __export(src_exports, {
   resolveSteps: () => resolveSteps,
   rollbackService: () => rollbackService,
   run: () => run,
+  runCapture: () => runCapture,
   runNodeTaskScript: () => runNodeTaskScript,
   runReleaseTests: () => runReleaseTests,
   runRemoteCli: () => runRemoteCli,
@@ -1210,6 +1214,8 @@ __export(src_exports, {
   showScreen: () => showScreen,
   showWordGridScreen: () => showWordGridScreen,
   sshRun: () => sshRun,
+  startPm2: () => startPm2,
+  stopPm2: () => stopPm2,
   syncEnv: () => syncEnv,
   taskHistoryInsertFromQueueRow: () => taskHistoryInsertFromQueueRow,
   timeMatcher: () => timeMatcher,
@@ -1227,6 +1233,7 @@ __export(src_exports, {
   useRef: () => import_react5.useRef,
   useState: () => import_react5.useState,
   waitForTaskResult: () => waitForTaskResult,
+  waitPm2: () => waitPm2,
   writeReleaseBuildInfo: () => writeReleaseBuildInfo
 });
 module.exports = __toCommonJS(src_exports);
@@ -5383,8 +5390,13 @@ function defineService(service) {
   const pm2 = {
     appName: service.name,
     args: "",
+    stopAllowance: 60,
     ...service.pm2
   };
+  if (pm2.killTimeout == null) {
+    const stopSec = Number(pm2.stopAllowance);
+    pm2.killTimeout = Number.isFinite(stopSec) && stopSec > 0 ? Math.floor(stopSec * 1e3) + 5e3 : 65e3;
+  }
   const nginx = service.nginx ? { siteName: service.name, ...service.nginx } : null;
   return {
     repoDirName: deriveRepoDirName(service.repoUrl),
@@ -5465,6 +5477,30 @@ function run(cmd, args, options = {}) {
 function runShell(command, options = {}) {
   return run("bash", ["-lc", command], options);
 }
+function runCapture(cmd, args, options = {}) {
+  const { cwd, env, logger, allowFail = false } = options;
+  return new Promise((resolve3, reject) => {
+    logger?.info?.(`$ ${cmd} ${args.join(" ")}${cwd ? `  (cwd=${cwd})` : ""}`);
+    const child = (0, import_node_child_process.spawn)(cmd, args, {
+      cwd,
+      env: env ?? process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0 || allowFail) resolve3({ stdout, stderr, code });
+      else reject(new Error(`${cmd} exited with code ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}
 
 // src/deploy/log.js
 var import_promises = require("fs/promises");
@@ -5682,7 +5718,7 @@ async function runReleaseTests(service, releasePath, paths, options = {}) {
 // src/deploy/prune.js
 var import_promises7 = require("fs/promises");
 async function pruneReleases(service, paths, options = {}) {
-  const { dryRun = false, logger = console } = options;
+  const { dryRun = false, logger = console, protect = [] } = options;
   const keep = service.keepReleases ?? 3;
   const releases = await listReleases(paths);
   let activeName = null;
@@ -5696,6 +5732,9 @@ async function pruneReleases(service, paths, options = {}) {
     if (keepSet.size < keep) keepSet.add(rel.name);
   }
   if (activeName) keepSet.add(activeName);
+  for (const name of protect) {
+    if (name) keepSet.add(name);
+  }
   const toRemove = releases.filter((rel) => !keepSet.has(rel.name));
   for (const rel of toRemove) {
     if (dryRun) {
@@ -5709,14 +5748,139 @@ async function pruneReleases(service, paths, options = {}) {
 }
 
 // src/deploy/pm2.js
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function isPidAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 0) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getPm2Process(appName, options = {}) {
+  const { logger } = options;
+  const { stdout } = await runCapture("bash", ["-lc", "pm2 jlist"], { logger });
+  let list;
+  try {
+    list = JSON.parse(stdout || "[]");
+  } catch (err) {
+    throw new Error(`pm2 jlist: invalid JSON (${err?.message ?? err})`);
+  }
+  if (!Array.isArray(list)) return null;
+  return list.find((p) => p?.name === appName) ?? null;
+}
+async function waitPm2(appName, predicate, options = {}) {
+  const {
+    timeoutMs = 65e3,
+    pollMs = 500,
+    dryRun = false,
+    logger = console,
+    label = "condition"
+  } = options;
+  if (dryRun) {
+    logger.info?.(`[dryRun] would wait pm2 ${appName} for ${label}`);
+    return null;
+  }
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "(unknown)";
+  while (Date.now() < deadline) {
+    const proc = await getPm2Process(appName, { logger });
+    lastStatus = proc?.pm2_env?.status ?? "(missing)";
+    if (predicate(proc)) return proc;
+    await sleep(pollMs);
+  }
+  throw new Error(
+    `pm2 wait timed out after ${timeoutMs}ms for ${appName} (${label}); last status=${lastStatus}`
+  );
+}
+function isFreshOnline(proc, oldPid) {
+  if (proc?.pm2_env?.status !== "online") return false;
+  const pid = Number(proc.pid);
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  if (oldPid != null) {
+    if (pid === oldPid) return false;
+    if (isPidAlive(oldPid)) return false;
+  }
+  return true;
+}
 async function reloadPm2(paths, options = {}) {
-  const { dryRun = false, logger = console } = options;
+  const { dryRun = false, logger = console, appName = null, waitTimeoutMs = 65e3 } = options;
   if (dryRun) {
     logger.info(`[dryRun] would pm2 startOrReload ${paths.ecosystem} --update-env`);
     return;
   }
+  let oldPid = null;
+  if (appName) {
+    const before = await getPm2Process(appName, { logger });
+    const n = Number(before?.pid);
+    if (Number.isFinite(n) && n > 0 && before?.pm2_env?.status === "online") {
+      oldPid = n;
+      logger.info(`pm2 ${appName}: reloading (old pid=${oldPid})`);
+    }
+  }
   await runShell(`pm2 startOrReload "${paths.ecosystem}" --update-env`, { logger });
   logger.info("pm2 reloaded");
+  if (appName) {
+    const proc = await waitPm2(
+      appName,
+      (p) => isFreshOnline(p, oldPid),
+      {
+        timeoutMs: waitTimeoutMs,
+        logger,
+        label: oldPid ? `online on new pid (old ${oldPid} gone)` : "online after reload"
+      }
+    );
+    logger.info(`pm2 ${appName} online pid=${proc?.pid ?? "?"}`);
+  }
+}
+async function stopPm2(appName, options = {}) {
+  const { dryRun = false, logger = console, waitTimeoutMs = 65e3 } = options;
+  if (dryRun) {
+    logger.info(`[dryRun] would pm2 stop ${appName}`);
+    return;
+  }
+  const before = await getPm2Process(appName, { logger });
+  if (!before) {
+    logger.info(`pm2 ${appName}: not present (already stopped)`);
+    return;
+  }
+  if (before.pm2_env?.status === "stopped") {
+    logger.info(`pm2 ${appName}: already stopped`);
+    return;
+  }
+  const oldPid = Number(before.pid);
+  await runShell(`pm2 stop "${appName}"`, { logger });
+  await waitPm2(
+    appName,
+    (proc) => {
+      if (proc && proc.pm2_env?.status !== "stopped") return false;
+      if (Number.isFinite(oldPid) && oldPid > 0 && isPidAlive(oldPid)) return false;
+      return true;
+    },
+    { timeoutMs: waitTimeoutMs, logger, label: "stopped" }
+  );
+  logger.info(`pm2 ${appName} stopped`);
+}
+async function startPm2(paths, options = {}) {
+  const { dryRun = false, logger = console, appName = null, waitTimeoutMs = 65e3 } = options;
+  if (dryRun) {
+    logger.info(`[dryRun] would pm2 start ${paths.ecosystem} --update-env`);
+    return;
+  }
+  await runShell(`pm2 start "${paths.ecosystem}" --update-env`, { logger });
+  logger.info("pm2 started");
+  if (appName) {
+    const proc = await waitPm2(
+      appName,
+      (p) => isFreshOnline(p, null),
+      { timeoutMs: waitTimeoutMs, logger, label: "online after start" }
+    );
+    logger.info(`pm2 ${appName} online pid=${proc?.pid ?? "?"}`);
+  }
 }
 
 // src/deploy/nginx.js
@@ -5945,10 +6109,26 @@ async function requireDeployRoot(parentDir, serviceRoot) {
 This is meant to run on the target host (where ${parentDir} exists). For a local dry run use --appsRoot=/tmp/<service>.`
   );
 }
+function resolveKillTimeoutMs(pm2) {
+  const explicit = Number(pm2?.killTimeout);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+  const stopSec = Number(pm2?.stopAllowance);
+  if (Number.isFinite(stopSec) && stopSec > 0) return Math.floor(stopSec * 1e3) + 5e3;
+  return 65e3;
+}
+function resolvePm2Args(pm2) {
+  const base = String(pm2?.args ?? "").trim();
+  const stopSec = Number(pm2?.stopAllowance);
+  if (!Number.isFinite(stopSec) || stopSec <= 0) return base;
+  if (/(?:^|\s)--stopAllowance=/.test(base)) return base;
+  return `${base}${base ? " " : ""}--stopAllowance=${Math.floor(stopSec)}`.trim();
+}
 function buildEcosystemConfig(service, paths) {
   const { pm2 } = service;
   const outLog = (0, import_node_path8.join)(paths.logs, `${pm2.appName}.out.log`);
   const errLog = (0, import_node_path8.join)(paths.logs, `${pm2.appName}.err.log`);
+  const killTimeoutMs = resolveKillTimeoutMs(pm2);
+  const args = resolvePm2Args(pm2);
   return `/**
  * pm2 ecosystem for ${service.name} \u2014 written by cli-toolkit deploy from the
  * service manifest (init/deploy). Do not hand-edit; change pm2.* in the
@@ -5960,7 +6140,7 @@ module.exports = {
             name: "${pm2.appName}",
             script: "${pm2.script}",
             cwd: "${paths.current}",
-            args: "${pm2.args ?? ""}",
+            args: ${JSON.stringify(args)},
             instances: 1,
             exec_mode: "fork",
             autorestart: true,
@@ -5968,6 +6148,8 @@ module.exports = {
             max_restarts: 10,
             restart_delay: 2000,
             max_memory_restart: "1500M",
+            // Grace window after SIGINT/SIGTERM before SIGKILL (ms). Align with --stopAllowance.
+            kill_timeout: ${killTimeoutMs},
             out_file: "${outLog}",
             error_file: "${errLog}",
             merge_logs: true,
@@ -6168,15 +6350,27 @@ async function bootstrapHost(service, options = {}) {
 }
 
 // src/deploy/deploy-service.js
+var import_promises13 = require("fs/promises");
+function resolveKillTimeoutMs2(service) {
+  const explicit = Number(service.pm2?.killTimeout);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+  const stopSec = Number(service.pm2?.stopAllowance);
+  if (Number.isFinite(stopSec) && stopSec > 0) return Math.floor(stopSec * 1e3) + 5e3;
+  return 65e3;
+}
 async function deployService(service, options = {}) {
   const {
     dryRun = false,
     skipPull = false,
     skipTests = false,
     skipNginx = false,
+    stopFirst = false,
     logger = console
   } = options;
   const paths = servicePaths(service);
+  const appName = service.pm2.appName;
+  const killTimeoutMs = resolveKillTimeoutMs2(service);
+  const waitTimeoutMs = killTimeoutMs + 1e4;
   await initServiceStructure(service, { dryRun, logger });
   if (!skipPull) await pullRepo(service, { dryRun, logger });
   await syncEnv(service, { dryRun, logger });
@@ -6184,21 +6378,38 @@ async function deployService(service, options = {}) {
   await writeReleaseBuildInfo(service, releasePath, { stamp, dryRun, logger });
   await installDeps(service, releasePath, paths, { dryRun, logger });
   if (!skipTests) await runReleaseTests(service, releasePath, paths, { dryRun, logger });
-  await activateRelease(releasePath, paths, { dryRun, logger });
-  await pruneReleases(service, paths, { dryRun, logger });
-  await reloadPm2(paths, { dryRun, logger });
+  let previousReleaseName = null;
+  try {
+    const prev = await (0, import_promises13.readlink)(paths.current);
+    previousReleaseName = prev.split("/").pop() || null;
+  } catch {
+  }
+  if (stopFirst) {
+    logger.info(`deploy mode=stopFirst app=${appName} killTimeoutMs=${killTimeoutMs}`);
+    await stopPm2(appName, { dryRun, logger, waitTimeoutMs });
+    await activateRelease(releasePath, paths, { dryRun, logger });
+    await pruneReleases(service, paths, { dryRun, logger });
+    await startPm2(paths, { dryRun, logger, appName, waitTimeoutMs });
+  } else {
+    logger.info(
+      `deploy mode=rolling app=${appName} killTimeoutMs=${killTimeoutMs}` + (previousReleaseName ? ` previous=${previousReleaseName}` : "")
+    );
+    await activateRelease(releasePath, paths, { dryRun, logger });
+    await reloadPm2(paths, { dryRun, logger, appName, waitTimeoutMs });
+    await pruneReleases(service, paths, { dryRun, logger });
+  }
   if (!skipNginx) await enableNginxUpstream(service, { dryRun, logger });
-  const summary = `deploy complete stamp=${stamp} dryRun=${dryRun}`;
+  const summary = `deploy complete stamp=${stamp} mode=${stopFirst ? "stopFirst" : "rolling"} dryRun=${dryRun}`;
   logger.info(summary);
   if (!dryRun) await appendDeployLog(paths.deployLog, summary);
-  return { stamp, releasePath };
+  return { stamp, releasePath, mode: stopFirst ? "stopFirst" : "rolling" };
 }
 
 // src/deploy/provision-service.js
-var import_promises13 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 async function pathExists6(path5) {
   try {
-    await (0, import_promises13.access)(path5);
+    await (0, import_promises14.access)(path5);
     return true;
   } catch {
     return false;
@@ -6232,7 +6443,7 @@ async function provisionService(service, options = {}) {
 }
 
 // src/deploy/rollback-service.js
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 async function rollbackService(service, options = {}) {
   const { release: targetName, dryRun = false, logger = console } = options;
   const paths = servicePaths(service);
@@ -6240,7 +6451,7 @@ async function rollbackService(service, options = {}) {
   if (releases.length === 0) throw new Error("No releases to roll back to");
   let activeName = null;
   try {
-    const target = await (0, import_promises14.readlink)(paths.current);
+    const target = await (0, import_promises15.readlink)(paths.current);
     activeName = target.split("/").pop();
   } catch {
     throw new Error("No active release (current symlink missing)");
@@ -6267,14 +6478,14 @@ async function rollbackService(service, options = {}) {
 }
 
 // src/deploy/ssh-remote.js
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_node_os3 = require("os");
 var import_node_path10 = require("path");
 var import_node_child_process4 = require("child_process");
 var REMOTE_CLI_REL = "node_modules/@nmakarov/cli-toolkit/scripts/deploy/cli.js";
 async function pathExists7(path5) {
   try {
-    await (0, import_promises15.access)(path5);
+    await (0, import_promises16.access)(path5);
     return true;
   } catch {
     return false;
@@ -6366,9 +6577,9 @@ async function ensureEnvOnRemote(host, service, options = {}) {
   if (!await pathExists7(localPath)) return false;
   logger.info(`copying .env ${localPath} \u2192 ${host}:${paths.repoEnv}`);
   await sshRun(host, `mkdir -p ${shellQuote((0, import_node_path10.dirname)(paths.repoEnv))}`, { logger });
-  const scrubbed = scrubEnvContent(await (0, import_promises15.readFile)(localPath, "utf8"), service.envScrubPatterns ?? []);
+  const scrubbed = scrubEnvContent(await (0, import_promises16.readFile)(localPath, "utf8"), service.envScrubPatterns ?? []);
   const tmp = (0, import_node_path10.join)((0, import_node_os3.tmpdir)(), `deploy-env-${Date.now()}`);
-  await (0, import_promises15.writeFile)(tmp, scrubbed, { mode: 384 });
+  await (0, import_promises16.writeFile)(tmp, scrubbed, { mode: 384 });
   await scp(tmp, `${host}:${paths.repoEnv}`, { logger });
   await sshRun(host, `chmod 600 ${shellQuote(paths.repoEnv)}`, { logger });
   return true;
@@ -7702,7 +7913,7 @@ var TaskShellCommand = class extends AbstractTask {
 
 // src/tasks/coreTasks/TaskSystemInfo.js
 var import_node_os5 = __toESM(require("os"), 1);
-var import_promises16 = __toESM(require("fs/promises"), 1);
+var import_promises17 = __toESM(require("fs/promises"), 1);
 function toGb(valueBytes) {
   return `${(valueBytes / 1024 ** 3).toFixed(2)} GB`;
 }
@@ -7710,7 +7921,7 @@ function toMb(valueBytes) {
   return `${(valueBytes / 1024 ** 2).toFixed(2)} MB`;
 }
 async function getDiskStats() {
-  const stats = await import_promises16.default.statfs("/");
+  const stats = await import_promises17.default.statfs("/");
   const total = Number(stats.bsize) * Number(stats.blocks);
   const free = Number(stats.bsize) * Number(stats.bavail);
   const used = total - free;
@@ -7863,7 +8074,7 @@ var TaskStopRunner = class extends AbstractTask {
    */
   static async resolveCustomParams(context, overrides = {}) {
     const merged = AbstractTask._mergeTypedParams(context, "task-stop", {
-      allowanceMs: "number default 5000"
+      allowanceMs: "number default 60000"
     }, overrides);
     const allowanceMs = Number(merged.allowanceMs);
     if (!Number.isFinite(allowanceMs) || allowanceMs < 0) {
@@ -7877,7 +8088,7 @@ var TaskStopRunner = class extends AbstractTask {
    * @returns {Promise<{ success: true, results: { stopRunner: true, allowanceMs: number, message: string } }>}
    */
   async run() {
-    const allowanceMs = Number(this.task?.params?.allowanceMs ?? 5e3);
+    const allowanceMs = Number(this.task?.params?.allowanceMs ?? 6e4);
     this.context.logger.warn?.(`[TaskStopRunner] stop requested (allowanceMs=${allowanceMs})`);
     return {
       success: true,
@@ -8562,7 +8773,7 @@ function normalizeRegistry(registry) {
   if (registry instanceof TasksRegistry) return registry;
   return new TasksRegistry().addMany(registry);
 }
-async function enqueueStopTask(context, serviceGroup, queueName = "tasks", allowanceMs = 5e3) {
+async function enqueueStopTask(context, serviceGroup, queueName = "tasks", allowanceMs = 6e4) {
   return enqueueTask(context, {
     queueName,
     name: "stopRunner",
@@ -8701,7 +8912,7 @@ async function executeClaimedTask(context, tasksTable, historyTable, row, regist
     await db(tasksTable).where({ id: row.id }).delete();
   }
   const stopRunnerRequested = !!(results && typeof results === "object" && results.stopRunner === true);
-  const stopAllowanceMs = stopRunnerRequested ? Number(results.allowanceMs ?? 5e3) : 0;
+  const stopAllowanceMs = stopRunnerRequested ? Number(results.allowanceMs ?? 6e4) : 0;
   return { stopRunnerRequested, stopAllowanceMs };
 }
 function shuffleTaskRowsInPlace(rows) {
@@ -8791,7 +9002,7 @@ async function runTasksLoop(context, options) {
   const runningTaskInstances = /* @__PURE__ */ new Map();
   let runningControlPromise = null;
   let stopRequested = false;
-  let stopAllowanceMs = 5e3;
+  let stopAllowanceMs = Number(context.stopAllowanceMs) > 0 ? Number(context.stopAllowanceMs) : 6e4;
   context.tasksRunnerStop = false;
   let registryReg = null;
   let registryInterval = null;
@@ -8858,7 +9069,7 @@ async function runTasksLoop(context, options) {
           ).then(async (outcome) => {
             if (outcome.stopRunnerRequested && !stopRequested) {
               stopRequested = true;
-              stopAllowanceMs = outcome.stopAllowanceMs || 5e3;
+              stopAllowanceMs = outcome.stopAllowanceMs || stopAllowanceMs;
               context.tasksRunnerStop = true;
               await signalRunningTasksStop(context, runningTaskInstances, stopAllowanceMs);
             }
@@ -8884,7 +9095,7 @@ async function runTasksLoop(context, options) {
         const p = executeClaimedTask(context, tasksTable, historyTable, claimed, registry, runningTaskInstances).then(async (outcome) => {
           if (outcome.stopRunnerRequested && !stopRequested) {
             stopRequested = true;
-            stopAllowanceMs = outcome.stopAllowanceMs || 5e3;
+            stopAllowanceMs = outcome.stopAllowanceMs || stopAllowanceMs;
             context.tasksRunnerStop = true;
             await signalRunningTasksStop(context, runningTaskInstances, stopAllowanceMs);
           }
@@ -8905,7 +9116,9 @@ async function runTasksLoop(context, options) {
       }
     }
     if (context.isStop() && !stopRequested) {
-      await signalRunningTasksStop(context, runningTaskInstances, 5e3);
+      stopRequested = true;
+      stopAllowanceMs = Number(context.stopAllowanceMs) > 0 ? Number(context.stopAllowanceMs) : stopAllowanceMs;
+      await signalRunningTasksStop(context, runningTaskInstances, stopAllowanceMs);
     }
     if (runningPromises.size > 0) {
       if (stopRequested) {
@@ -9190,11 +9403,14 @@ var TasksManager = class _TasksManager {
   ensureTasksRuntime,
   flushTaskIpcLogs,
   getArgsInstance,
+  getPm2Process,
   h,
   initServiceStructure,
   installDeps,
   installOperatorShell,
   ipcFileLogsTableNameForSourceResource,
+  isFreshOnline,
+  isPidAlive,
   joiEdateType,
   joiStringArrayType,
   listAliveRunnerHeartbeats,
@@ -9236,6 +9452,7 @@ var TasksManager = class _TasksManager {
   resolveSteps,
   rollbackService,
   run,
+  runCapture,
   runNodeTaskScript,
   runReleaseTests,
   runRemoteCli,
@@ -9253,6 +9470,8 @@ var TasksManager = class _TasksManager {
   showScreen,
   showWordGridScreen,
   sshRun,
+  startPm2,
+  stopPm2,
   syncEnv,
   taskHistoryInsertFromQueueRow,
   timeMatcher,
@@ -9270,6 +9489,7 @@ var TasksManager = class _TasksManager {
   useRef,
   useState,
   waitForTaskResult,
+  waitPm2,
   writeReleaseBuildInfo
 });
 //# sourceMappingURL=index.cjs.map