@reliverse/dler 1.7.121 → 1.7.123

package/bin/impl/auth/impl/init.d.ts

@@ -146,8 +146,8 @@ export declare const optionsSchema: z.ZodObject<{
     cwd: z.ZodString;
     config: z.ZodOptional<z.ZodString>;
     database: z.ZodOptional<z.ZodEnum<{
-        mysql: "mysql";
         sqlite: "sqlite";
+        mysql: "mysql";
         mongodb: "mongodb";
         postgres: "postgres";
         mssql: "mssql";
@@ -165,7 +165,7 @@ export declare const optionsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const outroText = "\uD83E\uDD73 All Done, Happy Hacking!";
 export declare function getLatestNpmVersion(packageName: string): Promise<string>;
-export declare function getPackageManager(): Promise<"bun" | "npm" | "pnpm" | "yarn">;
+export declare function getPackageManager(): Promise<"npm" | "yarn" | "pnpm" | "bun">;
 export declare function getEnvFiles(cwd: string): Promise<string[]>;
 export declare function updateEnvs({ envs, files, isCommented, }: {
     /**

package/bin/impl/build/binary-flow.js

@@ -9,6 +9,7 @@ import {
   parseTargets,
   validateInputFile
 } from "./providers/bun/single-file.js";
+import { createMultiStepSpinner } from "../utils/spinner.js";
 function getTargetPrefix(inputFile) {
   const filename = inputFile.split("/").pop()?.split("\\").pop() || "";
   const nameWithoutExt = filename.replace(/\.[^/.]+$/, "");
@@ -107,20 +108,39 @@ export async function binary_buildFlow(_timer, _isDev, config) {
           );
         }
       } else {
-        relinka("success", `\u{1F389} Build completed! All executables available in: ${options.outdir}`);
+        relinka("success", `\u2705 Build completed! All executables available in: ${options.outdir}`);
       }
     } else {
       relinka("info", "Building targets sequentially...");
+      const shouldShowSpinner = config.displayBuildPubLogs === false;
+      let sequentialSpinner = null;
+      if (shouldShowSpinner) {
+        sequentialSpinner = createMultiStepSpinner(
+          "Binary Build Process",
+          targets.map((target) => `Building ${target}`),
+          { color: "yellow" }
+        );
+      }
       let sequentialSuccessCount = 0;
       let sequentialFailureCount = 0;
-      for (const target of targets) {
+      for (const [index, target] of targets.entries()) {
         try {
           await buildForTarget(target, inputFile, options);
           sequentialSuccessCount++;
+          if (sequentialSpinner && index < targets.length - 1) {
+            sequentialSpinner.nextStep();
+          }
         } catch (error) {
+          if (sequentialSpinner) {
+            sequentialSpinner.error(error, index);
+            return;
+          }
           sequentialFailureCount++;
         }
       }
+      if (sequentialSpinner && sequentialSuccessCount > 0) {
+        sequentialSpinner.complete(`Built ${sequentialSuccessCount} targets successfully`);
+      }
       if (sequentialFailureCount > 0) {
         if (sequentialSuccessCount === 0) {
           relinka("error", `\u274C All builds failed! No executables were generated.`);
@@ -130,8 +150,8 @@ export async function binary_buildFlow(_timer, _isDev, config) {
             `\u26A0\uFE0F  Build completed with ${sequentialFailureCount} failure(s). ${sequentialSuccessCount} executable(s) available in: ${options.outdir}`
           );
         }
-      } else {
-        relinka("success", `\u{1F389} Build completed! All executables available in: ${options.outdir}`);
+      } else if (!sequentialSpinner) {
+        relinka("success", `\u2705 Build completed! All executables available in: ${options.outdir}`);
       }
     }
     if (existsSync(options.outdir)) {

package/bin/impl/build/build-regular.js

@@ -67,9 +67,9 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
       const transpileFormattedDuration = prettyMilliseconds(duration, {
         verbose: true
       });
-      relinka("success", `JSR distribution built in ${transpileFormattedDuration}`);
+      relinka("verbose", `JSR distribution built in ${transpileFormattedDuration}`);
     } else {
-      relinka("success", "JSR distribution built successfully");
+      relinka("verbose", "JSR distribution built successfully");
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -116,9 +116,9 @@ export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, di
       const transpileFormattedDuration = prettyMilliseconds(duration, {
         verbose: true
       });
-      relinka("success", `NPM distribution built in ${transpileFormattedDuration}`);
+      relinka("verbose", `NPM distribution built in ${transpileFormattedDuration}`);
     } else {
-      relinka("success", "NPM distribution built successfully");
+      relinka("verbose", "NPM distribution built successfully");
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -162,7 +162,7 @@ async function regular_bundleUsingBun(coreEntryFile, outDirBin, transpileTarget,
       verbose: true
     });
     relinka(
-      "success",
+      "verbose",
       `Regular bun build completed in ${transpileFormattedDuration} with ${buildResult.outputs.length} output file(s).`
     );
     if (buildResult.logs && buildResult.logs.length > 0) {
@@ -189,7 +189,7 @@ async function regular_bundleUsingJsr(src, dest) {
     await fs.copy(src, dest, { overwrite: true });
     relinka("verbose", `Copied directory from ${src} to ${dest}`);
     relinka(
-      "success",
+      "verbose",
       `Completed regular bundling via 'jsr' builder`
       // `${successCount} files processed, ${changedCount} modified`,
     );
@@ -248,7 +248,7 @@ async function regular_bundleUsingUnified(coreIsCLI, coreEntryFile, outDirBin, b
       verbose: true
     });
     relinka(
-      "success",
+      "verbose",
       `Regular bundle completed in ${transpileFormattedDuration} using ${builder} builder`
     );
   } catch (error) {
@@ -321,7 +321,7 @@ async function regular_performCommonBuildSteps({
 }) {
   relinka("verbose", `Performing common build steps in ${outDirBin} (regular)`);
   relinka(
-    "info",
+    "verbose",
     `[${isJsr ? "dist-jsr" : "dist-npm"}] Performing alias path conversion in ${outDirBin}`
   );
   await convertImportsAliasToRelative({
@@ -330,7 +330,10 @@ async function regular_performCommonBuildSteps({
     pathExtFilter: "js-ts-none"
   });
   if (isJsr) {
-    relinka("info", `[dist-jsr] Performing paths ext conversion in ${outDirBin} (from js to ts)`);
+    relinka(
+      "verbose",
+      `[dist-jsr] Performing paths ext conversion in ${outDirBin} (from js to ts)`
+    );
     await convertImportsExt({
       targetDir: outDirBin,
       extFrom: "js",

package/bin/impl/build/impl.d.ts

@@ -1,7 +1,7 @@
 import type { ReliverseConfig } from "../schema/mod.js";
 import type { PerfTimer } from "../types/mod.js";
 /**
- * Main entry point for the dler build process.
+ * Main entry point for the rse build process.
  * Handles building for both main project and libraries.
  * @see `src-ts/app/pub/impl.ts` for pub main function implementation.
  */

package/bin/impl/build/impl.js

@@ -6,7 +6,7 @@ import { library_buildFlow } from "./library-flow.js";
 import { regular_buildFlow } from "./regular-flow.js";
 import { PROJECT_ROOT } from "../config/constants.js";
 import { getConfigDler } from "../config/load.js";
-import { createSpinner } from "../utils/spinner.js";
+import { createMultiStepSpinner } from "../utils/spinner.js";
 import { removeDistFolders } from "../utils/utils-clean.js";
 import { handleDlerError } from "../utils/utils-error-cwd.js";
 import { dlerPostBuild, wrapper_CopyNonBuildFiles } from "./postbuild.js";
@@ -14,13 +14,23 @@ import { dlerPreBuild } from "./prebuild.js";
 export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles, debugDontCopyNonBuildFiles, disableOwnSpinner) {
   let effectiveConfig = config;
   let shouldShowSpinner = false;
-  let spinner = null;
+  let multiStepSpinner = null;
   try {
     if (!effectiveConfig) {
       effectiveConfig = await getConfigDler();
     }
     shouldShowSpinner = effectiveConfig.displayBuildPubLogs === false && !disableOwnSpinner;
-    spinner = shouldShowSpinner ? createSpinner("Building...").start() : null;
+    const buildSteps = [
+      "Loading configuration",
+      "Cleaning previous build",
+      "Pre-build setup",
+      "Building main project",
+      "Building libraries",
+      "Building binaries",
+      "Post-build cleanup"
+    ];
+    multiStepSpinner = shouldShowSpinner ? createMultiStepSpinner("Build Process", buildSteps, { color: "blue" }) : null;
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     if (effectiveConfig.logsFreshFile) {
       await fs.remove(path.join(PROJECT_ROOT, effectiveConfig.logsFileName));
     }
@@ -31,6 +41,7 @@ export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles
       effectiveConfig.libsList,
       "dist-tmp"
     );
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     if (debugOnlyCopyNonBuildFiles) {
       if (debugDontCopyNonBuildFiles) {
         relinka(
@@ -44,6 +55,7 @@ export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles
       process.exit(0);
     }
     await dlerPreBuild(effectiveConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     const tempDirs = {
       npm: "dist-tmp/tmp-npm",
       jsr: "dist-tmp/tmp-jsr",
@@ -55,19 +67,23 @@ export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles
       libsDirSrc: tempDirs.libs
     };
     await regular_buildFlow(timer, isDev, tempConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     await library_buildFlow(timer, isDev, tempConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     await binary_buildFlow(timer, isDev, tempConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     await dlerPostBuild(isDev, debugDontCopyNonBuildFiles);
     if (effectiveConfig.postBuildSettings?.deleteDistTmpAfterBuild) {
       await fs.remove(path.join(PROJECT_ROOT, "dist-tmp"));
     }
-    if (shouldShowSpinner && spinner) {
-      spinner.succeed("Build completed successfully!");
+    if (multiStepSpinner) {
+      multiStepSpinner.complete("Build completed successfully");
     }
     return { timer, effectiveConfig };
   } catch (error) {
-    if (shouldShowSpinner && spinner) {
-      spinner.fail("Build failed!");
+    if (multiStepSpinner) {
+      const currentStep = multiStepSpinner.getCurrentStep();
+      multiStepSpinner.error(error, currentStep);
     }
     handleDlerError(error);
   }

package/bin/impl/build/library-flow.js

@@ -4,6 +4,7 @@ import pAll from "p-all";
 import { library_buildLibrary } from "./build-library.js";
 import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "../config/constants.js";
 import { library_publishLibrary } from "../pub/pub-library.js";
+import { createSpinnerGroup } from "../utils/spinner.js";
 import { resumePerfTimer } from "../utils/utils-perf.js";
 export async function library_buildFlow(timer, isDev, config) {
   relinka("verbose", "\u2014 \u2014 \u2014 library_buildFlow \u2014 \u2014 \u2014");
@@ -76,8 +77,22 @@ export async function libraries_build(isDev, timer, libsList, libsDirDist, libsD
     return;
   }
   const libsEntries = Object.entries(libsList);
-  const tasks = libsEntries.map(([libName, libConfig]) => {
+  const shouldShowSpinner = config.displayBuildPubLogs === false;
+  let spinnerGroup = null;
+  if (shouldShowSpinner) {
+    const libraryNames = libsEntries.map(([libName]) => `Building ${libName}`);
+    spinnerGroup = createSpinnerGroup({
+      items: libraryNames,
+      concurrent: true,
+      color: "green"
+    });
+    for (const spinner of spinnerGroup.spinners) {
+      spinner.start();
+    }
+  }
+  const tasks = libsEntries.map(([libName, libConfig], index) => {
     return async () => {
+      const librarySpinner = spinnerGroup?.spinners[index];
       try {
         if (!libConfig.libMainFile) {
           throw new Error(`Library ${libName} is missing "libMainFile" property.`);
@@ -132,7 +147,14 @@ export async function libraries_build(isDev, timer, libsList, libsDirDist, libsD
           transpileStub,
           transpileWatch
         });
+        if (librarySpinner) {
+          librarySpinner.succeed(`${libName} built successfully`);
+        }
       } catch (error) {
+        if (librarySpinner) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          librarySpinner.fail(`${libName} build failed: ${errorMessage}`);
+        }
         relinka(
           "error",
           `Failed to build library ${libName}: ${error instanceof Error ? error.message : String(error)}`
@@ -158,8 +180,23 @@ export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, d
     return;
   }
   const libsEntries = Object.entries(libsList);
-  const tasks = libsEntries.map(([libName, libConfig]) => {
+  let publishSpinnerGroup = null;
+  if (!commonPubPause) {
+    const libraryNames = libsEntries.filter(([, libConfig]) => !libConfig.libPubPause).map(([libName]) => `Publishing ${libName} to ${commonPubRegistry}`);
+    if (libraryNames.length > 0) {
+      publishSpinnerGroup = createSpinnerGroup({
+        items: libraryNames,
+        concurrent: true,
+        color: "magenta"
+      });
+      for (const spinner of publishSpinnerGroup.spinners) {
+        spinner.start();
+      }
+    }
+  }
+  const tasks = libsEntries.map(([libName, libConfig], index) => {
     return async () => {
+      const publishSpinner = publishSpinnerGroup?.spinners[index];
       try {
         const folderName = extractFolderName(libName, libConfig);
         const libBaseDir = path.resolve(PROJECT_ROOT, libsDirDist, folderName);
@@ -179,10 +216,20 @@ export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, d
             isDev,
             timer
           );
+          if (publishSpinner) {
+            publishSpinner.succeed(`${libName} published to ${effectivePubRegistry} successfully`);
+          }
         } else if (libConfig.libPubPause && !commonPubPause) {
           relinka("verbose", `Publishing is paused for lib ${libName} (libPubPause: true)`);
+          if (publishSpinner) {
+            publishSpinner.info(`${libName} publish paused by configuration`);
+          }
         }
       } catch (error) {
+        if (publishSpinner) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          publishSpinner.fail(`${libName} publish failed: ${errorMessage}`);
+        }
         relinka(
           "error",
           `Failed to publish library ${libName}: ${error instanceof Error ? error.message : String(error)}`

package/bin/impl/build/providers/build.js

@@ -31,7 +31,7 @@ function shouldStopAtStep(stepNumber) {
 }
 export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, inputConfig, outDir, transpileStub = false) {
   shouldStopAtStep(1);
-  relinka("info", "Starting unified build process...");
+  relinka("verbose", "Starting unified build process...");
   relinka("verbose", `Processing build for source directory: ${inputSourceDir}`);
   relinka(
     "verbose",
@@ -73,7 +73,7 @@ export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, in
 }
 async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog, isLib) {
   const timer = createPerfTimer();
-  relinka("info", "Resolving build configuration...");
+  relinka("verbose", "Resolving build configuration...");
   const preset = await resolvePreset(
     buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
     rootDir
@@ -159,7 +159,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
   relinka("verbose", `Declaration files: ${options.declaration ? "enabled" : "disabled"}`);
   options.outDir = resolve(options.rootDir, options.outDir);
   const jiti = createJiti(options.rootDir, { interopDefault: true });
-  relinka("info", "Initializing build context...");
+  relinka("verbose", "Initializing build context...");
   const ctx = {
     buildEntries: [],
     hooks: createHooks(),
@@ -180,7 +180,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
     ctx.hooks.addHooks(buildConfig.hooks);
   }
   await ctx.hooks.callHook("build:prepare", ctx);
-  relinka("info", "Processing build entries...");
+  relinka("verbose", "Processing build entries...");
   options.entries = options.entries.map(
     (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
   );
@@ -225,7 +225,7 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     );
   }
   if (options.clean) {
-    relinka("info", "Cleaning output directories...");
+    relinka("verbose", "Cleaning output directories...");
     for (const dir of new Set(
       options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
     )) {
@@ -252,10 +252,10 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     return false;
   });
   if (activeTasks.length === 0) {
-    relinka("info", "No build tasks to execute");
+    relinka("verbose", "No build tasks to execute");
   } else {
     if (options.parallel) {
-      relinka("info", `Running ${activeTasks.length} build tasks in parallel...`);
+      relinka("verbose", `Running ${activeTasks.length} build tasks in parallel...`);
       await Promise.all(
         activeTasks.map(async ({ task }) => {
           await task(ctx);
@@ -263,7 +263,7 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
       );
     } else {
       for (const { task, name } of activeTasks) {
-        relinka("info", `Running ${name}...`);
+        relinka("verbose", `Running ${name}...`);
         await task(ctx);
       }
     }
@@ -272,8 +272,8 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     await ctx.hooks.callHook("build:done", ctx);
     return;
   }
-  relinka("info", "Finalizing build output...");
-  relinka("success", `Build succeeded for ${options.name}`);
+  relinka("verbose", "Finalizing build output...");
+  relinka("verbose", `Build succeeded for ${options.name}`);
   const outFiles = await glob(["**"], { cwd: options.outDir });
   for (const file of outFiles) {
     let entry = ctx.buildEntries.find((e) => e.path === file);
@@ -322,9 +322,9 @@ ${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.b
       verbose: true
     });
     const totalSize = ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0);
-    relinka("info", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
+    relinka("verbose", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
     relinka(
-      "info",
+      "verbose",
       `\u03A3 Total dist size: ${prettyBytes(totalSize)} (build time: ${transpileFormattedTime})`
     );
   }
@@ -346,6 +346,6 @@ ${[...ctx.warnings].map((msg) => `- ${msg}`).join("\n")}`
       process.exit(1);
     }
     shouldStopAtStep(15);
-    relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
+    relinka("verbose", `Build complete (with ${ctx.warnings.size} warnings)`);
   }
 }

package/bin/impl/build/providers/mkdist/mkdist-impl/make.js

@@ -180,7 +180,7 @@ export async function mkdist(options = {}) {
       relinka("error", `... and ${errors.length - 5} more errors`);
     }
   } else {
-    relinka("success", "Build completed successfully!");
+    relinka("verbose", "Build completed successfully!");
   }
   return {
     result: {

package/bin/impl/build/providers/mkdist/mkdist-mod.js

@@ -85,7 +85,7 @@ ${error.errors.map((e) => `  - ${e}`).join("\n")}`
     );
   } else {
     relinka(
-      "success",
+      "verbose",
       `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
     );
   }

package/bin/impl/build/regular-flow.js

@@ -1,6 +1,7 @@
 import { relinka } from "@reliverse/relinka";
 import pAll from "p-all";
 import { CONCURRENCY_DEFAULT } from "../config/constants.js";
+import { createSpinnerGroup } from "../utils/spinner.js";
 import { regular_pubToJsr, regular_pubToNpm } from "../pub/pub-regular.js";
 import { regular_buildJsrDist, regular_buildNpmDist } from "./build-regular.js";
 export async function regular_buildFlow(timer, isDev, config) {
@@ -58,47 +59,83 @@ export async function regular_buildFlow(timer, isDev, config) {
       break;
     case "npm-jsr": {
       relinka("verbose", "Initializing build process for main project to both NPM and JSR...");
+      const shouldShowSpinner = config.displayBuildPubLogs === false;
+      let buildSpinnerGroup = null;
+      if (shouldShowSpinner) {
+        buildSpinnerGroup = createSpinnerGroup({
+          items: ["Building for NPM", "Building for JSR"],
+          concurrent: true,
+          color: "cyan"
+        });
+        for (const spinner of buildSpinnerGroup.spinners) {
+          spinner.start();
+        }
+      }
       const buildTasks = [
-        () => regular_buildJsrDist(
-          isDev,
-          true,
-          config.coreIsCLI,
-          config.coreEntrySrcDir,
-          config.distJsrDirName,
-          config.distJsrBuilder,
-          config.coreEntryFile,
-          config.transpileTarget,
-          config.transpileFormat,
-          config.transpileMinify,
-          config.transpileSourcemap,
-          config.transpilePublicPath,
-          config.distNpmOutFilesExt,
-          config,
-          timer,
-          config.transpileStub,
-          config.transpileWatch,
-          config.distJsrGenTsconfig,
-          config.coreDeclarations
-        ),
-        () => regular_buildNpmDist(
-          isDev,
-          config.coreIsCLI,
-          config.coreEntrySrcDir,
-          config.distNpmDirName,
-          config.distNpmBuilder,
-          config.coreEntryFile,
-          config.distNpmOutFilesExt,
-          config,
-          config.transpileTarget,
-          config.transpileFormat,
-          config.transpileMinify,
-          config.transpileSourcemap,
-          config.transpilePublicPath,
-          config.transpileStub,
-          config.transpileWatch,
-          timer,
-          config.coreDeclarations
-        )
+        async () => {
+          try {
+            await regular_buildJsrDist(
+              isDev,
+              true,
+              config.coreIsCLI,
+              config.coreEntrySrcDir,
+              config.distJsrDirName,
+              config.distJsrBuilder,
+              config.coreEntryFile,
+              config.transpileTarget,
+              config.transpileFormat,
+              config.transpileMinify,
+              config.transpileSourcemap,
+              config.transpilePublicPath,
+              config.distNpmOutFilesExt,
+              config,
+              timer,
+              config.transpileStub,
+              config.transpileWatch,
+              config.distJsrGenTsconfig,
+              config.coreDeclarations
+            );
+            if (buildSpinnerGroup?.spinners[1]) {
+              buildSpinnerGroup.spinners[1].succeed("JSR build completed");
+            }
+          } catch (error) {
+            if (buildSpinnerGroup?.spinners[1]) {
+              buildSpinnerGroup.spinners[1].fail("JSR build failed");
+            }
+            throw error;
+          }
+        },
+        async () => {
+          try {
+            await regular_buildNpmDist(
+              isDev,
+              config.coreIsCLI,
+              config.coreEntrySrcDir,
+              config.distNpmDirName,
+              config.distNpmBuilder,
+              config.coreEntryFile,
+              config.distNpmOutFilesExt,
+              config,
+              config.transpileTarget,
+              config.transpileFormat,
+              config.transpileMinify,
+              config.transpileSourcemap,
+              config.transpilePublicPath,
+              config.transpileStub,
+              config.transpileWatch,
+              timer,
+              config.coreDeclarations
+            );
+            if (buildSpinnerGroup?.spinners[0]) {
+              buildSpinnerGroup.spinners[0].succeed("NPM build completed");
+            }
+          } catch (error) {
+            if (buildSpinnerGroup?.spinners[0]) {
+              buildSpinnerGroup.spinners[0].fail("NPM build failed");
+            }
+            throw error;
+          }
+        }
       ];
       await pAll(buildTasks, { concurrency: CONCURRENCY_DEFAULT });
       break;
@@ -140,24 +177,60 @@ export async function regular_pubFlow(timer, isDev, config) {
       break;
     case "npm-jsr": {
       relinka("verbose", "Publishing main project to both NPM and JSR...");
+      const shouldShowSpinner = config.displayBuildPubLogs === false;
+      let pubSpinnerGroup = null;
+      if (shouldShowSpinner) {
+        pubSpinnerGroup = createSpinnerGroup({
+          items: ["Publishing to NPM", "Publishing to JSR"],
+          concurrent: true,
+          color: "magenta"
+        });
+        for (const spinner of pubSpinnerGroup.spinners) {
+          spinner.start();
+        }
+      }
       const publishTasks = [
-        () => regular_pubToJsr(
-          config.distJsrDryRun,
-          config.distJsrFailOnWarn,
-          isDev,
-          config.commonPubPause,
-          config.distJsrDirName,
-          config.distJsrAllowDirty,
-          config.distJsrSlowTypes,
-          timer
-        ),
-        () => regular_pubToNpm(
-          config.distJsrDryRun,
-          isDev,
-          config.commonPubPause,
-          config.distNpmDirName,
-          timer
-        )
+        async () => {
+          try {
+            await regular_pubToJsr(
+              config.distJsrDryRun,
+              config.distJsrFailOnWarn,
+              isDev,
+              config.commonPubPause,
+              config.distJsrDirName,
+              config.distJsrAllowDirty,
+              config.distJsrSlowTypes,
+              timer
+            );
+            if (pubSpinnerGroup?.spinners[1]) {
+              pubSpinnerGroup.spinners[1].succeed("JSR publish completed");
+            }
+          } catch (error) {
+            if (pubSpinnerGroup?.spinners[1]) {
+              pubSpinnerGroup.spinners[1].fail("JSR publish failed");
+            }
+            throw error;
+          }
+        },
+        async () => {
+          try {
+            await regular_pubToNpm(
+              config.distJsrDryRun,
+              isDev,
+              config.commonPubPause,
+              config.distNpmDirName,
+              timer
+            );
+            if (pubSpinnerGroup?.spinners[0]) {
+              pubSpinnerGroup.spinners[0].succeed("NPM publish completed");
+            }
+          } catch (error) {
+            if (pubSpinnerGroup?.spinners[0]) {
+              pubSpinnerGroup.spinners[0].fail("NPM publish failed");
+            }
+            throw error;
+          }
+        }
       ];
       await pAll(publishTasks, { concurrency: CONCURRENCY_DEFAULT });
       break;