@reliverse/dler 1.7.86 → 1.7.88

package/bin/app/update/cmd.js

@@ -334,7 +334,7 @@ async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApp
 }
 async function updateWorkspacePackages(workspacePaths, args, options) {
   if (workspacePaths.length === 0) return 0;
-  relinka("info", `Scanning ${workspacePaths.length} workspace packages...`);
+  relinka("log", `Scanning ${workspacePaths.length} workspace packages...`);
   let totalWorkspaceUpdated = 0;
   for (const packageJsonPath of workspacePaths) {
     try {
@@ -392,13 +392,13 @@ function displayUpdateResults(results) {
     }
   }
   if (upToDate.length > 0) {
-    relinka("success", `${upToDate.length} dependencies are up to date`);
+    relinka("log", `${upToDate.length} deps are already up to date`);
   }
   if (toUpdate.length === 0) {
-    relinka("success", `All ${upToDate.length} deps are already up to date`);
+    relinka("verbose", `All ${upToDate.length} deps are already up to date`);
     return;
   }
-  relinka("info", `${toUpdate.length} dependencies can be updated:`);
+  relinka("log", `${toUpdate.length} deps can be updated:`);
   const byLocation = /* @__PURE__ */ new Map();
   for (const update of toUpdate) {
     const location = update.location || "unknown";
@@ -551,7 +551,7 @@ async function handleGlobalUpdates(args) {
     relinka("error", "No supported package managers found");
     return process.exit(1);
   }
-  relinka("info", `Found package managers: ${availablePackageManagers.join(", ")}`);
+  relinka("log", `Found package managers: ${availablePackageManagers.join(", ")}`);
   const allGlobalPackages = {};
   for (const pm of availablePackageManagers) {
     const packages = await getGlobalPackages(pm);
@@ -581,7 +581,7 @@ async function handleGlobalUpdates(args) {
     relinka("warn", "No global packages to update");
     return;
   }
-  relinka("info", `Checking ${filteredPackages.length} global packages for updates...`);
+  relinka("log", `Checking ${filteredPackages.length} global packages for updates...`);
   const results = await pMap(
     filteredPackages,
     async (packageName) => {
@@ -629,13 +629,13 @@ async function handleGlobalUpdates(args) {
     }
   }
   if (upToDate.length > 0) {
-    relinka("success", `${upToDate.length} global packages are up to date`);
+    relinka("log", `${upToDate.length} global packages are up to date`);
   }
   if (toUpdate.length === 0) {
-    relinka("success", "All global packages are up to date");
+    relinka("log", "All global packages are up to date");
     return;
   }
-  relinka("info", `${toUpdate.length} global packages can be updated:`);
+  relinka("log", `${toUpdate.length} global packages can be updated:`);
   for (const update of toUpdate) {
     relinka(
       "log",
@@ -671,15 +671,15 @@ async function handleGlobalUpdates(args) {
       ]
     });
     if (selectedPackages.length === 0 || selectedPackages.includes("exit")) {
-      relinka("info", "Exiting global update process");
+      relinka("log", "Exiting global update process");
       return;
     }
     const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
     toUpdate = toUpdate.filter((update) => actualSelectedPackages.includes(update.package));
-    relinka("info", `Updating ${actualSelectedPackages.length} selected global packages...`);
+    relinka("log", `Updating ${actualSelectedPackages.length} selected global packages...`);
   }
   if (args["dry-run"]) {
-    relinka("info", "Dry run mode - no changes were made");
+    relinka("log", "Dry run mode - no changes were made");
     return;
   }
   let successCount = 0;
@@ -689,7 +689,7 @@ async function handleGlobalUpdates(args) {
       successCount++;
     }
   }
-  relinka("success", `Successfully updated ${successCount}/${toUpdate.length} global packages`);
+  relinka("log", `Successfully updated ${successCount}/${toUpdate.length} global packages`);
 }
 export default defineCommand({
   meta: {
@@ -931,15 +931,15 @@ export default defineCommand({
           ]
         });
         if (selectedPackages.length === 0 || selectedPackages.includes("exit")) {
-          relinka("info", "Exiting update process");
+          relinka("log", "Exiting update process");
           return;
         }
         const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
         toUpdate = toUpdate.filter((update) => actualSelectedPackages.includes(update.package));
-        relinka("info", `Updating ${actualSelectedPackages.length} selected dependencies...`);
+        relinka("log", `Updating ${actualSelectedPackages.length} selected dependencies...`);
       }
       if (args["dry-run"]) {
-        relinka("info", "Dry run mode - no changes were made");
+        relinka("log", "Dry run mode - no changes were made");
         return;
       }
       const rootUpdated = await updatePackageJsonFile(
@@ -960,8 +960,6 @@ export default defineCommand({
           );
           const recursiveUpdated = await updateWorkspacePackages(otherPackageJsons, args, options);
           totalUpdated += recursiveUpdated;
-        } else {
-          relinka("info", "No additional package.json files found for recursive update");
         }
       } else {
         const isMonorepoProject = await isMonorepo(process.cwd());
@@ -979,7 +977,7 @@ export default defineCommand({
             relinka("warn", "No workspace packages found but --all-workspaces flag was provided");
           }
         } else if (isMonorepoProject) {
-          relinka("info", "Skipping workspace packages due to --root-only flag");
+          relinka("log", "Skipping workspace packages due to --root-only flag");
         }
       }
       if (args.recursive) {
@@ -997,9 +995,9 @@ export default defineCommand({
             `Updated ${totalUpdated} dependencies across workspace (root + workspaces)`
           );
         } else if (isMonorepoProject) {
-          relinka("success", `Updated ${totalUpdated} dependencies in root package.json only`);
+          relinka("log", `Updated ${totalUpdated} dependencies in root package.json only`);
         } else {
-          relinka("success", `Updated ${totalUpdated} dependencies`);
+          relinka("log", `Updated ${totalUpdated} dependencies`);
         }
       }
       const packageManager = await detectPackageManager(process.cwd());
@@ -1027,7 +1025,7 @@ export default defineCommand({
             "warn",
             `Install failed: ${error instanceof Error ? error.message : String(error)}`
           );
-          relinka("info", `Run '${packageManager.command} install' manually to apply the changes`);
+          relinka("log", `Run '${packageManager.command} install' manually to apply the changes`);
         }
       } else {
         relinka("warn", "Could not detect package manager. Please run install manually.");

package/bin/app/upgrade/cmd.js

@@ -90,19 +90,25 @@ export default defineCommand({
     const errors = results.filter((r) => r.status === "error");
     if (upgraded.length > 0) {
       relinka("success", `Upgraded ${upgraded.length} tools:`);
-      upgraded.forEach((r) => relinka("log", `  \u2713 ${r.tool}${r.message ? ` - ${r.message}` : ""}`));
+      upgraded.forEach(
+        (r) => relinka("verbose", `  \u2713 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
+      );
     }
     if (upToDate.length > 0) {
       relinka("info", `${upToDate.length} tools already up-to-date:`);
-      upToDate.forEach((r) => relinka("log", `  \u2022 ${r.tool}${r.message ? ` - ${r.message}` : ""}`));
+      upToDate.forEach(
+        (r) => relinka("verbose", `  \u2022 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
+      );
     }
     if (notFound.length > 0) {
       relinka("warn", `${notFound.length} tools not installed (skipped):`);
-      notFound.forEach((r) => relinka("log", `  - ${r.tool}`));
+      notFound.forEach((r) => relinka("verbose", `  - ${r.tool}`));
     }
     if (errors.length > 0) {
       relinka("error", `${errors.length} tools had errors:`);
-      errors.forEach((r) => relinka("log", `  \u2717 ${r.tool}${r.message ? ` - ${r.message}` : ""}`));
+      errors.forEach(
+        (r) => relinka("verbose", `  \u2717 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
+      );
     }
     relinka("success", "Upgrade check completed!");
   }

package/bin/app/x/cmd.js

@@ -117,7 +117,7 @@ export default defineCommand({
           relinka.error(`Cannot detect package manager in \`${cwd}\``);
           return process.exit(1);
         }
-        relinka.log(
+        relinka.verbose(
           `Detected package manager in \`${cwd}\`: \`${packageManager.name}@${packageManager.version}\``
         );
         break;
@@ -143,7 +143,7 @@ export default defineCommand({
             relinka.error("No command provided");
             return process.exit(1);
           }
-          relinka.log(`Executing: ${target}`);
+          relinka.verbose(`Executing: ${target}`);
           const result = x(command, commandArgs, {
             nodeOptions: {
               cwd: options.cwd ? path.resolve(options.cwd) : process.cwd(),
@@ -172,7 +172,7 @@ export default defineCommand({
       }
       default: {
         relinka.error(`Unknown action: ${action}`);
-        relinka.log("Available actions: detect, run, exec, or package name to run directly");
+        relinka.verbose("Available actions: detect, run, exec, or package name to run directly");
         return process.exit(1);
       }
     }
@@ -200,7 +200,7 @@ async function runPackage({
     }
     if (forcedPmFlags.length === 1) {
       pmName = forcedPmFlags[0][0];
-      relinka.log(`Forcing package manager: ${pmName}`);
+      relinka.verbose(`Forcing package manager: ${pmName}`);
     } else {
       const packageManager = await detectPackageManager(workingDir);
       if (!packageManager) {
@@ -236,8 +236,8 @@ async function runPackage({
     }
     runCommand.push(packageName);
     runCommand.push(...packageArgs);
-    relinka.log(`Running package: ${packageName}`);
-    relinka.log(`Using command: ${runCommand.join(" ")}`);
+    relinka.verbose(`Running package: ${packageName}`);
+    relinka.verbose(`Using command: ${runCommand.join(" ")}`);
     const result = x(runCommand[0], runCommand.slice(1), {
       nodeOptions: {
         cwd: workingDir,

package/bin/libs/cfg/cfg-impl/cfg-dler.d.ts

@@ -1,3 +1,111 @@
+/** Configuration for directory-related settings. */
+export interface RelinkaDirsConfig {
+    maxLogFiles?: number;
+}
+/** Log level types used by the logger. */
+export type LogLevel = "error" | "fatal" | "info" | "success" | "verbose" | "warn" | "log" | "internal" | "null" | "step" | "box" | "message";
+/** Configuration for a single log level. */
+export interface LogLevelConfig {
+    /**
+     * Symbol to display for this log level.
+     * @see https://symbl.cc
+     */
+    symbol: string;
+    /**
+     * Fallback symbol to use if Unicode is not supported.
+     */
+    fallbackSymbol: string;
+    /**
+     * Color to use for this log level.
+     */
+    color: string;
+    /**
+     * Number of spaces after the symbol/fallback
+     */
+    spacing?: number;
+}
+/** Configuration for all log levels. */
+export type LogLevelsConfig = Partial<Record<LogLevel, LogLevelConfig>>;
+/**
+ * Configuration options for the Relinka logger.
+ * All properties are optional to allow for partial configuration.
+ * Defaults will be applied during initialization.
+ */
+export interface RelinkaConfig {
+    /**
+     * Enables verbose (aka debug) mode for detailed logging.
+     *
+     * `true` here works only for end-users of CLIs/libs when theirs developers
+     * has been awaited for user's config via `@reliverse/relinka`'s `await relinkaConfig;`
+     */
+    verbose?: boolean;
+    /**
+     * Configuration for directory-related settings.
+     * - `maxLogFiles`: The maximum number of log files to keep before cleanup.
+     */
+    dirs?: RelinkaDirsConfig;
+    /**
+     * Disables color output in the console.
+     */
+    disableColors?: boolean;
+    /**
+     * Configuration for log file output.
+     */
+    logFile?: {
+        /**
+         * Path to the log file.
+         */
+        outputPath?: string;
+        /**
+         * How to handle date in the filename.
+         * - `disable`: No date prefix/suffix
+         * - `append-before`: Add date before the filename (e.g., "2024-01-15-log.txt")
+         * - `append-after`: Add date after the filename (e.g., "log-2024-01-15.txt")
+         */
+        nameWithDate?: "disable" | "append-before" | "append-after";
+        /**
+         * If true, clears the log file when relinkaConfig is executed with supportFreshLogFile: true.
+         * This is useful for starting with a clean log file on each run.
+         */
+        freshLogFile?: boolean;
+    };
+    /**
+     * If true, logs will be saved to a file.
+     */
+    saveLogsToFile?: boolean;
+    /**
+     * Configuration for timestamp in log messages.
+     */
+    timestamp?: {
+        /**
+         * If true, timestamps will be added to log messages.
+         */
+        enabled: boolean;
+        /**
+         * The format for timestamps. Default is YYYY-MM-DD HH:mm:ss.SSS
+         */
+        format?: string;
+    };
+    /**
+     * Allows to customize the log levels.
+     */
+    levels?: LogLevelsConfig;
+    /**
+     * Controls how often the log cleanup runs (in milliseconds)
+     * Default: 10000 (10 seconds)
+     */
+    cleanupInterval?: number;
+    /**
+     * Maximum size of the log write buffer before flushing to disk (in bytes)
+     * Default: 4096 (4KB)
+     */
+    bufferSize?: number;
+    /**
+     * Maximum time to hold logs in buffer before flushing to disk (in milliseconds)
+     * Default: 5000 (5 seconds)
+     */
+    maxBufferAge?: number;
+}
 /**
  * Defines the configuration for building and publishing packages. This includes: versioning,
  * build settings, publishing options, libraries-dler-plugin built-in plugin, and more.
@@ -504,6 +612,13 @@ export interface DlerConfig {
      * @default "templates"
      */
     buildTemplatesDir: string;
+    /**
+     * Integrated relinka logger configuration.
+     * @see https://github.com/reliverse/relinka
+     *
+     * @default See DEFAULT_RELINKA_CONFIG in defaults
+     */
+    relinka: RelinkaConfig;
 }
 export type BumpMode = "patch" | "minor" | "major" | "auto" | "manual";
 /**
@@ -693,4 +808,5 @@ export declare const defineConfig: (userConfig?: Partial<DlerConfig>) => {
     };
     buildPreExtensions: string[];
     buildTemplatesDir: string;
+    relinka: RelinkaConfig;
 };

package/bin/libs/cfg/cfg-impl/cfg-dler.js

@@ -79,7 +79,82 @@ export const DEFAULT_CONFIG_DLER = {
   buildPreExtensions: ["ts", "js"],
   // If you need to exclude some ts/js files from being built,
   // you can store them in the dirs with buildTemplatesDir name
-  buildTemplatesDir: "templates"
+  buildTemplatesDir: "templates",
+  // Integrated relinka logger configuration
+  relinka: {
+    verbose: false,
+    dirs: {
+      maxLogFiles: 5
+    },
+    disableColors: false,
+    logFile: {
+      outputPath: "logs.log",
+      nameWithDate: "disable",
+      freshLogFile: true
+    },
+    saveLogsToFile: true,
+    timestamp: {
+      enabled: false,
+      format: "HH:mm:ss"
+    },
+    cleanupInterval: 1e4,
+    // 10 seconds
+    bufferSize: 4096,
+    // 4KB
+    maxBufferAge: 5e3,
+    // 5 seconds
+    levels: {
+      success: {
+        symbol: "\u2713",
+        fallbackSymbol: "[OK]",
+        color: "greenBright",
+        spacing: 3
+      },
+      info: {
+        symbol: "i",
+        fallbackSymbol: "[i]",
+        color: "cyanBright",
+        spacing: 3
+      },
+      error: {
+        symbol: "\u2716",
+        fallbackSymbol: "[ERR]",
+        color: "redBright",
+        spacing: 3
+      },
+      warn: {
+        symbol: "\u26A0",
+        fallbackSymbol: "[WARN]",
+        color: "yellowBright",
+        spacing: 3
+      },
+      fatal: {
+        symbol: "\u203C",
+        fallbackSymbol: "[FATAL]",
+        color: "redBright",
+        spacing: 3
+      },
+      verbose: {
+        symbol: "\u2727",
+        fallbackSymbol: "[VERBOSE]",
+        color: "gray",
+        spacing: 3
+      },
+      internal: {
+        symbol: "\u2699",
+        fallbackSymbol: "[INTERNAL]",
+        color: "magentaBright",
+        spacing: 3
+      },
+      log: { symbol: "\u2502", fallbackSymbol: "|", color: "dim", spacing: 3 },
+      message: {
+        symbol: "\u{1F7A0}",
+        fallbackSymbol: "[MSG]",
+        color: "cyan",
+        spacing: 3
+      }
+    }
+  }
 };
 export const defineConfig = (userConfig = {}) => {
   return { ...DEFAULT_CONFIG_DLER, ...userConfig };

package/bin/libs/get/get-impl/get-core.js

@@ -24,8 +24,8 @@ export async function installDlerStandalone(installDir, appsPath, args) {
   const binaryPath = path.resolve(installDir, binaryInfo.localName);
   if (args["dry-run"]) {
     relinka("info", "Dry run mode - would download:");
-    relinka("log", `  From: ${downloadUrl}`);
-    relinka("log", `  To: ${binaryPath}`);
+    relinka("verbose", `  From: ${downloadUrl}`);
+    relinka("verbose", `  To: ${binaryPath}`);
     return;
   }
   await downloadBinary(downloadUrl, binaryPath);
@@ -54,7 +54,7 @@ export async function installFromGitHub(repoUrl, installDir, appsPath, args) {
   const asset = findBinaryAsset(release.assets, args.binary);
   if (!asset) {
     relinka("error", "Available assets:");
-    release.assets.forEach((a) => relinka("log", `  - ${a.name}`));
+    release.assets.forEach((a) => relinka("verbose", `  - ${a.name}`));
     throw new Error(`No suitable binary found for your platform`);
   }
   const binaryName = args.binary || asset.name;
@@ -62,9 +62,9 @@ export async function installFromGitHub(repoUrl, installDir, appsPath, args) {
   const binaryKey = path.basename(binaryName, path.extname(binaryName));
   if (args["dry-run"]) {
     relinka("info", "Dry run mode - would download:");
-    relinka("log", `  Asset: ${asset.name}`);
-    relinka("log", `  From: ${asset.browser_download_url}`);
-    relinka("log", `  To: ${binaryPath}`);
+    relinka("verbose", `  Asset: ${asset.name}`);
+    relinka("verbose", `  From: ${asset.browser_download_url}`);
+    relinka("verbose", `  To: ${binaryPath}`);
     return;
   }
   await downloadBinary(asset.browser_download_url, binaryPath);
@@ -184,15 +184,18 @@ export async function checkPowerShellVersion() {
     const isVersionValid = major > 7 || major === 7 && minor >= 5;
     if (!isVersionValid) {
       relinka("error", "\u274C PowerShell 7.5+ is required for dler installation on Windows");
-      relinka("log", `   Current version: ${versionString}`);
-      relinka("log", `   Required version: 7.5.0 or higher`);
-      relinka("log", "");
+      relinka("verbose", `   Current version: ${versionString}`);
+      relinka("verbose", `   Required version: 7.5.0 or higher`);
+      relinka("verbose", "");
       relinka("info", "\u{1F527} To install PowerShell 7.5+:");
-      relinka("log", "   \u2022 Visit: https://github.com/PowerShell/PowerShell/releases");
-      relinka("log", "   \u2022 Or use Windows Package Manager: winget install Microsoft.PowerShell");
-      relinka("log", "   \u2022 Or use Chocolatey: choco install powershell-core");
-      relinka("log", "   \u2022 Or use Scoop: scoop install pwsh");
-      relinka("log", "");
+      relinka("verbose", "   \u2022 Visit: https://github.com/PowerShell/PowerShell/releases");
+      relinka(
+        "verbose",
+        "   \u2022 Or use Windows Package Manager: winget install Microsoft.PowerShell"
+      );
+      relinka("verbose", "   \u2022 Or use Chocolatey: choco install powershell-core");
+      relinka("verbose", "   \u2022 Or use Scoop: scoop install pwsh");
+      relinka("verbose", "");
       relinka("info", "After installation, restart your terminal and try again.");
       process.exit(1);
     }
@@ -261,7 +264,7 @@ async function checkGlobalDlerConflicts(force) {
     });
     relinka("warn", "\n\u{1F527} To avoid conflicts, please remove the global installation(s) first:");
     conflicts.forEach((conflict) => {
-      relinka("log", `  ${conflict.command}`);
+      relinka("verbose", `  ${conflict.command}`);
     });
     relinka(
       "info",
@@ -417,7 +420,7 @@ async function ensureInPath(installDir) {
     } catch (error) {
       relinka("warn", `Failed to automatically modify PATH: ${error}`);
       relinka("warn", "Please add manually:");
-      relinka("log", `Add ${installDir} to your PATH environment variable`);
+      relinka("verbose", `Add ${installDir} to your PATH environment variable`);
       relinka(
         "log",
         "You can do this through Environment Variables > System Properties > Path > Edit"

package/bin/libs/sdk/sdk-impl/build/build-library.js

@@ -44,7 +44,7 @@ export async function library_buildLibrary(options) {
 }
 async function executeBuildTasks(options) {
   const { libName, npm, jsr, effectivePubRegistry } = options;
-  relinka("log", `Executing build tasks for ${libName} (Registry: ${effectivePubRegistry})...`);
+  relinka("verbose", `Executing build tasks for ${libName} (Registry: ${effectivePubRegistry})...`);
   const buildTasks = [];
   if (effectivePubRegistry === "jsr" || effectivePubRegistry === "npm-jsr") {
     if (!jsr) {
@@ -79,7 +79,7 @@ async function library_buildJsrDist(options) {
   const jsrOptions = options.jsr;
   const { jsrOutDir, distJsrBuilder, distJsrOutFilesExt } = jsrOptions;
   const targetType = "jsr";
-  relinka("log", `[JSR] Initializing JSR build for ${libName}...`);
+  relinka("verbose", `[JSR] Initializing JSR build for ${libName}...`);
   const libSourceDirResolved = path.resolve(PROJECT_ROOT, options.mainDir);
   const entryFilePathResolved = path.resolve(libSourceDirResolved, libMainFile);
   const outputDirRootResolved = path.resolve(PROJECT_ROOT, jsrOutDir);
@@ -139,7 +139,7 @@ async function library_buildNpmDist(options) {
   const distJsrOutFilesExt = options.jsr?.distJsrOutFilesExt || "ts";
   const targetType = "npm";
   const distName = determineDistName(npmOutDir, false, libsList);
-  relinka("log", `[NPM:${distName}] Initializing NPM build for ${libName}...`);
+  relinka("verbose", `[NPM:${distName}] Initializing NPM build for ${libName}...`);
   const outputDirRootResolved = path.resolve(PROJECT_ROOT, npmOutDir);
   const outputDirBinResolved = path.resolve(outputDirRootResolved, BIN_DIR_NAME);
   await fs.ensureDir(outputDirRootResolved);
@@ -216,10 +216,10 @@ async function library_buildDistributionTarget(params) {
   } = options;
   const isJsr = targetType === "jsr";
   const logPrefix = isJsr ? "[JSR]" : `[NPM:${determineDistName(path.relative(PROJECT_ROOT, outputDirRoot), false, libsList)}]`;
-  relinka("log", `${logPrefix} Starting build target processing...`);
+  relinka("verbose", `${logPrefix} Starting build target processing...`);
   await fs.ensureDir(outputDirRoot);
   await fs.ensureDir(outputDirBin);
-  relinka("log", `${logPrefix} Using builder: ${builder}`);
+  relinka("verbose", `${logPrefix} Using builder: ${builder}`);
   const bundleRequest = {
     builder,
     entryPoint: entryFilePath,
@@ -256,7 +256,7 @@ async function library_buildDistributionTarget(params) {
     effectivePubRegistry: options.effectivePubRegistry
   };
   await library_performCommonBuildSteps(commonStepsParams);
-  relinka("log", `${logPrefix} Completed build target processing.`);
+  relinka("verbose", `${logPrefix} Completed build target processing.`);
 }
 async function library_bundleWithBuilder(params) {
   const { builder, ...executorParams } = params;

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

@@ -24,7 +24,7 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
   const outDirBin = path.join(outDirRoot, config.coreBuildOutDir || "bin");
   const singleFile = path.join(process.cwd(), coreEntrySrcDir, coreEntryFile);
   const srcDir = path.join(process.cwd(), coreEntrySrcDir);
-  relinka("log", `Building JSR distribution (isDev=${isDev}, isJsr=${isJsr})...`);
+  relinka("verbose", `Building JSR distribution (isDev=${isDev}, isJsr=${isJsr})...`);
   try {
     await fs.ensureDir(outDirBin);
     await regular_bundleWithBuilder(distJsrBuilder, {
@@ -90,7 +90,7 @@ export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, di
   const outDirBin = path.join(outDirRoot, config.coreBuildOutDir || "bin");
   const singleFile = path.join(process.cwd(), coreEntrySrcDir, coreEntryFile);
   const srcDir = path.join(process.cwd(), coreEntrySrcDir);
-  relinka("log", `Building NPM distribution (isDev=${isDev})...`);
+  relinka("verbose", `Building NPM distribution (isDev=${isDev})...`);
   try {
     await fs.ensureDir(outDirBin);
     await regular_bundleWithBuilder(distNpmBuilder, {
@@ -187,7 +187,7 @@ async function regular_bundleUsingBun(coreEntryFile, outDirBin, transpileTarget,
   }
 }
 async function regular_bundleUsingJsr(src, dest) {
-  relinka("log", `Starting regular_bundleUsingJsr: ${src} -> ${dest}`);
+  relinka("verbose", `Starting regular_bundleUsingJsr: ${src} -> ${dest}`);
   await fs.ensureDir(path.dirname(dest));
   const stats = await fs.stat(src);
   if (!stats.isDirectory()) {
@@ -331,7 +331,7 @@ async function regular_performCommonBuildSteps({
   coreDescription,
   coreBuildOutDir
 }) {
-  relinka("log", `Performing common build steps in ${outDirBin} (regular)`);
+  relinka("verbose", `Performing common build steps in ${outDirBin} (regular)`);
   relinka(
     "info",
     `[${isJsr ? "dist-jsr" : "dist-npm"}] Performing alias path conversion in ${outDirBin}`

package/bin/libs/sdk/sdk-impl/build/providers/build.js

@@ -154,7 +154,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
     isLib
   });
   shouldStopAtStep(5);
-  relinka("log", "Build-specific configuration merged with defaults");
+  relinka("verbose", "Build-specific configuration merged with defaults");
   relinka("verbose", `Build options: clean=${options.clean}, parallel=${options.parallel}`);
   relinka("verbose", `Declaration files: ${options.declaration ? "enabled" : "disabled"}`);
   options.outDir = resolve(options.rootDir, options.outDir);
@@ -233,7 +233,7 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
         continue;
       }
       cleanedDirs.push(dir);
-      relinka("log", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
+      relinka("verbose", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
       await rmdir(dir);
       await fsp.mkdir(dir, { recursive: true });
     }
@@ -315,7 +315,7 @@ ${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.b
           return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
         }).join("\n")}`;
       }
-      relinka("log", entry.chunk ? line : line);
+      relinka("verbose", entry.chunk ? line : line);
     }
     const elapsedTime = getElapsedPerfTime(timer);
     const transpileFormattedTime = prettyMilliseconds(elapsedTime, {

package/bin/libs/sdk/sdk-impl/build/providers/rollup/watch.js

@@ -17,10 +17,10 @@ export function rollupWatch(rollupOptions) {
   );
   relinka("warn", "[dler] [rollup] Watch mode is experimental and may be unstable");
   transpileWatcher.on("change", (id, { event }) => {
-    relinka("log", `${relative(".", id)} was ${event}d`);
+    relinka("verbose", `${relative(".", id)} was ${event}d`);
   });
   transpileWatcher.on("restart", () => {
-    relinka("log", "[dler] [rollup] Rebuilding bundle");
+    relinka("verbose", "[dler] [rollup] Rebuilding bundle");
   });
   transpileWatcher.on("event", (event) => {
     if (event.code === "END") {