@reliverse/dler 1.2.1 → 1.2.3

package/bin/init.js

@@ -1,6 +1,7 @@
 import { relinka } from "@reliverse/relinka";
 import fs from "fs-extra";
 import path from "pathe";
+import { readPackageJSON } from "pkg-types";
 import { DEFAULT_CONFIG } from "./libs/cfg/cfg-default.js";
 const CONFIG_FILENAME = ".config/dler.ts";
 export async function initDlerConfig(isDev) {
@@ -10,15 +11,23 @@ export async function initDlerConfig(isDev) {
     return;
   }
   try {
-    const configContent = generateConfig(isDev);
+    let pkgDescription = void 0;
+    try {
+      const pkg = await readPackageJSON();
+      if (pkg && typeof pkg.description === "string" && pkg.description.trim()) {
+        pkgDescription = pkg.description.trim();
+      }
+    } catch {
+    }
+    const configContent = generateConfig(isDev, pkgDescription);
     await fs.outputFile(configPath, configContent, "utf-8");
     relinka("success", `Config was created at ${configPath}`);
-    relinka("info", "Edit this file to customize build and publish settings");
+    relinka("log", "Edit this file to customize build and publish settings");
     if (!isDev) {
-      relinka("info", "Please note: commonPubPause is set to true by default");
-      relinka("info", "When you're ready, run `dler` to build and publish");
+      relinka("log", "Please note: commonPubPause is set to true by default");
+      relinka("log", "When you're ready, run `dler` to build and publish");
     } else {
-      relinka("info", "When you're ready, run `bun pub` to build and publish");
+      relinka("log", "When you're ready, run `bun pub` to build and publish");
     }
     process.exit(0);
   } catch (error) {
@@ -29,7 +38,7 @@ export async function initDlerConfig(isDev) {
     process.exit(1);
   }
 }
-function generateConfig(isDev) {
+function generateConfig(isDev, pkgDescription) {
   const importDefineConfigStatement = isDev ? `import { defineConfig } from "./libs/cfg/cfg-mod.js";` : `import { defineConfig } from "@reliverse/dler-cfg";`;
   const verboseValue = getValue(isDev, true, DEFAULT_CONFIG.commonVerbose);
   const isCLIValue = getValue(isDev, true, DEFAULT_CONFIG.coreIsCLI);
@@ -48,6 +57,12 @@ function generateConfig(isDev) {
     false,
     DEFAULT_CONFIG.coreDeclarations
   );
+  const coreDescriptionValue = getValue(
+    isDev,
+    // TODO: remove `description` from dler's `package.json` when ensured that whole dler's codebase can optionally read dler.ts' `coreDescription`
+    "dler (prev. relidler) is a flexible, unified, and fully automated bundler for TypeScript and JavaScript projects, as well as an NPM and JSR publishing tool.",
+    pkgDescription || DEFAULT_CONFIG.coreDescription
+  );
   const libsActModeValue = getValue(
     isDev,
     "main-and-libs",
@@ -100,6 +115,7 @@ export default defineConfig({
 
   // Core configuration
   coreDeclarations: ${coreDeclarationsValue},
+  coreDescription: ${JSON.stringify(coreDescriptionValue)},
   coreEntryFile: "${DEFAULT_CONFIG.coreEntryFile}",
   coreEntrySrcDir: "${DEFAULT_CONFIG.coreEntrySrcDir}",
   coreIsCLI: ${isCLIValue},

package/bin/libs/cfg/cfg-default.js

@@ -6,6 +6,7 @@ export const DEFAULT_CONFIG = {
   commonPubRegistry: "npm",
   commonVerbose: false,
   coreDeclarations: true,
+  coreDescription: "",
   coreEntryFile: "mod.ts",
   coreEntrySrcDir: "src",
   coreIsCLI: false,

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

@@ -51,7 +51,7 @@ export async function library_buildLibrary(options) {
     replacementMarker: REPLACEMENT_MARKER
   };
   try {
-    relinka("info", `Running pre-build replacements for ${libName}...`);
+    relinka("log", `Running pre-build replacements for ${libName}...`);
     replacedFiles = await preBuildReplacements(replacementConfig);
     relinka("verbose", `Pre-build: ${replacedFiles.length} files modified.`);
     await executeBuildTasks(options);
@@ -94,7 +94,7 @@ async function executeBuildTasks(options) {
         `JSR build requested for ${libName} but 'options.jsr' is missing.`
       );
     }
-    relinka("info", `Queueing JSR build for lib ${libName}...`);
+    relinka("log", `Queueing JSR build for lib ${libName}...`);
     buildTasks.push(() => library_buildJsrDist(options));
   }
   if (commonPubRegistry === "npm" || commonPubRegistry === "npm-jsr") {
@@ -103,7 +103,7 @@ async function executeBuildTasks(options) {
         `NPM build requested for ${libName} but 'options.npm' is missing.`
       );
     }
-    relinka("info", `Queueing NPM build for lib ${libName}...`);
+    relinka("log", `Queueing NPM build for lib ${libName}...`);
     buildTasks.push(() => library_buildNpmDist(options));
   }
   if (buildTasks.length === 0) {
@@ -114,11 +114,11 @@ async function executeBuildTasks(options) {
     return;
   }
   if (buildTasks.length > 1) {
-    relinka("info", `Building lib ${libName} for NPM and JSR concurrently...`);
+    relinka("log", `Building lib ${libName} for NPM and JSR concurrently...`);
     await pAll(buildTasks, { concurrency: CONCURRENCY_DEFAULT });
   } else {
     relinka(
-      "info",
+      "log",
       `Building lib ${libName} for ${options.commonPubRegistry || "single target"}...`
     );
     const task = buildTasks[0];
@@ -137,7 +137,7 @@ async function library_buildJsrDist(options) {
   const jsrOptions = options.jsr;
   const { jsrOutDir, distJsrBuilder, distJsrOutFilesExt } = jsrOptions;
   const targetType = "jsr";
-  relinka("info", `[JSR] Initializing JSR build for ${libName}...`);
+  relinka("log", `[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);
@@ -145,20 +145,28 @@ async function library_buildJsrDist(options) {
     outputDirRootResolved,
     BIN_DIR_NAME
   );
-  const bundlerEntryPoint = distJsrBuilder === "jsr" ? libSourceDirResolved : entryFilePathResolved;
+  const { libSpecificSrcDir, libDirName } = await determineNpmSourceDirectory(
+    libName,
+    libMainFile,
+    libSourceDirResolved,
+    libsList,
+    "jsr"
+  );
+  const bundlerEntryPoint = distJsrBuilder === "jsr" ? libSpecificSrcDir : entryFilePathResolved;
   const libConfig = libsList[libName];
   const libDeclarations = libConfig?.libDeclarations ?? false;
   const buildParams = {
     targetType,
     builder: distJsrBuilder,
-    libSourceDir: libSourceDirResolved,
+    libSourceDir: libSpecificSrcDir,
     entryFilePath: bundlerEntryPoint,
     outputDirRoot: outputDirRootResolved,
     outputDirBin: outputDirBinResolved,
     libDeclarations,
     distJsrOutFilesExt,
-    options
-    // libDirName is generally not needed/used for JSR target logic
+    options,
+    libDirName
+    // Pass determined libDirName
   };
   await buildDistributionTarget(buildParams);
   relinka(
@@ -192,7 +200,7 @@ async function library_buildNpmDist(options) {
   const distJsrOutFilesExt = options.jsr?.distJsrOutFilesExt || "ts";
   const targetType = "npm";
   const distName = determineDistName(npmOutDir, false, libsList);
-  relinka("info", `[NPM:${distName}] Initializing NPM build for ${libName}...`);
+  relinka("log", `[NPM:${distName}] Initializing NPM build for ${libName}...`);
   const coreEntrySrcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
   const outputDirRootResolved = path.resolve(PROJECT_ROOT, npmOutDir);
   const outputDirBinResolved = path.resolve(
@@ -281,10 +289,10 @@ async function buildDistributionTarget(params) {
   } = options;
   const isJsr = targetType === "jsr";
   const logPrefix = isJsr ? "[JSR]" : `[NPM:${determineDistName(path.relative(PROJECT_ROOT, outputDirRoot), false, libsList)}]`;
-  relinka("info", `${logPrefix} Starting build target processing...`);
+  relinka("log", `${logPrefix} Starting build target processing...`);
   await ensuredir(outputDirRoot);
   await ensuredir(outputDirBin);
-  relinka("info", `${logPrefix} Using builder: ${builder}`);
+  relinka("log", `${logPrefix} Using builder: ${builder}`);
   const bundleRequest = {
     builder,
     entryPoint: entryFilePath,
@@ -304,22 +312,37 @@ async function buildDistributionTarget(params) {
     unifiedBundlerOutExt
   };
   await library_bundleWithBuilder(bundleRequest);
-  const commonStepsParams = {
-    coreEntryFileName: path.basename(libMainFile),
-    outDirRoot: outputDirRoot,
-    outDirBin: outputDirBin,
-    isJsr,
-    libName,
-    libsList,
-    rmDepsMode,
-    rmDepsPatterns,
-    unifiedBundlerOutExt,
-    distJsrOutFilesExt,
-    deleteFiles: isJsr,
-    libDirName
-  };
-  await library_performCommonBuildSteps(commonStepsParams);
-  relinka("info", `${logPrefix} Completed build target processing.`);
+  if (await fs.pathExists(outputDirBin)) {
+    const files = await fs.readdir(outputDirBin);
+    if (files.length > 0) {
+      await library_performCommonBuildSteps({
+        coreEntryFileName: path.basename(libMainFile),
+        outDirRoot: outputDirRoot,
+        outDirBin: outputDirBin,
+        isJsr,
+        libName,
+        libsList,
+        rmDepsMode,
+        rmDepsPatterns,
+        unifiedBundlerOutExt,
+        distJsrOutFilesExt,
+        deleteFiles: isJsr,
+        // Only delete files for JSR builds
+        libDirName
+      });
+    } else {
+      relinka(
+        "warn",
+        `${logPrefix} No files found in ${outputDirBin} after bundling`
+      );
+    }
+  } else {
+    relinka(
+      "warn",
+      `${logPrefix} Output directory ${outputDirBin} does not exist after bundling`
+    );
+  }
+  relinka("log", `${logPrefix} Completed build target processing.`);
 }
 async function library_bundleWithBuilder(params) {
   const { builder, ...executorParams } = params;
@@ -494,19 +517,26 @@ async function library_bundleUsingUnified(entryPoint, outDirBin, builder, source
     );
     validatedExt = "js";
   }
-  const inputRelative = path.relative(rootDir, entryPoint);
-  const outDirRelative = path.relative(rootDir, outDirBin);
+  await ensuredir(outDirBin);
   const unifiedBuildConfig = {
     clean: false,
     declaration: libDeclarations ? "compatible" : false,
     entries: [
       {
         builder,
-        input: inputRelative,
-        outDir: outDirRelative,
-        ext: validatedExt
+        input: entryPoint,
+        outDir: outDirBin,
+        // Explicitly set the output directory
+        rootDir: sourceDirContext,
+        ext: validatedExt,
+        ...builder === "mkdist" && {
+          cleanDist: true
+          // Clean the output directory before building
+        }
       }
     ],
+    outDir: outDirBin,
+    rootDir: sourceDirContext,
     rollup: {
       emitCJS: false,
       esbuild: {
@@ -519,7 +549,9 @@ async function library_bundleUsingUnified(entryPoint, outDirBin, builder, source
       }
     },
     hooks: {},
-    stub: transpileStub
+    stub: transpileStub,
+    transpileWatch: false
+    // Not supported by mkdist
   };
   try {
     await unifiedBuild(rootDir, unifiedBuildConfig, outDirBin);
@@ -777,7 +809,7 @@ async function preBuildReplacements(config) {
           });
           await fs.writeFile(filePath, updatedCode, "utf-8");
           relinka(
-            "info",
+            "log",
             `Applied pre-build replacement in ${path.relative(PROJECT_ROOT, filePath)}`
           );
         } else {

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

@@ -34,15 +34,15 @@ import {
 import { regular_createPackageJSON } from "../utils/utils-pkg-json-reg.js";
 import { createTSConfig } from "../utils/utils-tsconfig.js";
 import { ensuredir } from "./bundlers/unified/utils.js";
-export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrcDir, distJsrDirName, distJsrBuilder, coreEntryFile, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, unifiedBundlerOutExt, rmDepsMode, timer, transpileStub, transpileWatch, distJsrGenTsconfig, coreDeclarations) {
-  relinka("info", "Building JSR distribution...");
+export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrcDir, distJsrDirName, distJsrBuilder, coreEntryFile, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, unifiedBundlerOutExt, rmDepsMode, timer, transpileStub, transpileWatch, distJsrGenTsconfig, coreDeclarations, config) {
+  relinka("log", "Building JSR distribution...");
   const coreEntrySrcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
   const coreEntryFilePath = path.join(coreEntrySrcDirResolved, coreEntryFile);
   const distJsrDirNameResolved = path.resolve(PROJECT_ROOT, distJsrDirName);
   const outDirBin = path.resolve(distJsrDirNameResolved, "bin");
   await ensuredir(distJsrDirNameResolved);
   await ensuredir(outDirBin);
-  relinka("info", `Using JSR builder: ${distJsrBuilder}`);
+  relinka("log", `Using JSR builder: ${distJsrBuilder}`);
   await regular_bundleWithBuilder(distJsrBuilder, {
     coreDeclarations,
     outDir: outDirBin,
@@ -69,11 +69,18 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
     outDirBin,
     outDirRoot: distJsrDirNameResolved,
     rmDepsMode,
-    unifiedBundlerOutExt
+    unifiedBundlerOutExt,
+    coreDescription: config.coreDescription
   });
   await convertImportExtensionsJsToTs({ dirPath: outDirBin });
   await renameTsxFiles(outDirBin);
-  await createJsrJSON(distJsrDirNameResolved, false);
+  await createJsrJSON(
+    distJsrDirNameResolved,
+    false,
+    void 0,
+    void 0,
+    config.coreDescription
+  );
   if (coreIsCLI && isJsr && distJsrGenTsconfig) {
     await createTSConfig(distJsrDirNameResolved, true);
   }
@@ -86,15 +93,15 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
     )}))`
   );
 }
-export async function regular_buildNpmDist(isDev, coreEntrySrcDir, distNpmDirName, distNpmBuilder, coreEntryFile, unifiedBundlerOutExt, rmDepsMode, coreIsCLI, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, transpileStub, transpileWatch, timer, coreDeclarations) {
-  relinka("info", "Building NPM distribution...");
+export async function regular_buildNpmDist(isDev, coreEntrySrcDir, distNpmDirName, distNpmBuilder, coreEntryFile, unifiedBundlerOutExt, rmDepsMode, coreIsCLI, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, transpileStub, transpileWatch, timer, coreDeclarations, config) {
+  relinka("log", "Building NPM distribution...");
   const coreEntrySrcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
   const coreEntryFilePath = path.join(coreEntrySrcDirResolved, coreEntryFile);
   const distNpmDirNameResolved = path.resolve(PROJECT_ROOT, distNpmDirName);
   const outDirBin = path.resolve(distNpmDirNameResolved, "bin");
   await ensuredir(distNpmDirNameResolved);
   await ensuredir(outDirBin);
-  relinka("info", `Using NPM builder: ${distNpmBuilder}`);
+  relinka("log", `Using NPM builder: ${distNpmBuilder}`);
   await regular_bundleWithBuilder(distNpmBuilder, {
     coreDeclarations,
     outDir: outDirBin,
@@ -119,7 +126,8 @@ export async function regular_buildNpmDist(isDev, coreEntrySrcDir, distNpmDirNam
     outDirBin,
     outDirRoot: distNpmDirNameResolved,
     rmDepsMode,
-    unifiedBundlerOutExt
+    unifiedBundlerOutExt,
+    coreDescription: config.coreDescription
   });
   const dirSize = await getDirectorySize(distNpmDirNameResolved, isDev);
   const filesCount = await outDirBinFilesCount(outDirBin);
@@ -197,7 +205,7 @@ async function regular_bundleUsingBun(coreEntryFile, outDirBin, transpileTarget,
   }
 }
 async function regular_bundleUsingJsr(src, dest) {
-  relinka("info", `Starting regular_bundleUsingJsr: ${src} -> ${dest}`);
+  relinka("log", `Starting regular_bundleUsingJsr: ${src} -> ${dest}`);
   await ensuredir(path.dirname(dest));
   const stats = await fs.stat(src);
   if (!stats.isDirectory()) {
@@ -340,7 +348,8 @@ async function regular_performCommonBuildSteps({
   outDirBin,
   outDirRoot,
   rmDepsMode,
-  unifiedBundlerOutExt
+  unifiedBundlerOutExt,
+  coreDescription
 }) {
   await convertImportPaths({
     aliasPrefix: "~/",
@@ -358,7 +367,8 @@ async function regular_performCommonBuildSteps({
     coreIsCLI,
     unifiedBundlerOutExt,
     rmDepsMode,
-    []
+    [],
+    coreDescription
   );
   await copyRootFile(outDirRoot, ["README.md", "LICENSE"]);
   if (isJsr) {

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/auto.js

@@ -23,7 +23,7 @@ export const autoPreset = definePreset(() => {
           ctx.options.declaration = res.dts ? "compatible" : false;
         }
         relinka(
-          "info",
+          "log",
           "Automatically detected entries:",
           ctx.options.entries.map(
             (e) => e.input.replace(`${ctx.options.rootDir}/`, "").replace(/\/$/, "/*")

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/build.js

@@ -202,7 +202,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
   );
   if (process.env.DEBUG) {
     relinka(
-      "info",
+      "log",
       `Root dir: ${options.rootDir}
 Entries:
 ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
@@ -218,7 +218,7 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
       }
       cleanedDirs.push(dir);
       relinka(
-        "info",
+        "log",
         `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``
       );
       await rmdir(dir);
@@ -287,7 +287,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("info", entry.chunk ? line : line);
+      relinka("log", entry.chunk ? line : line);
     }
     const elapsedTime = getElapsedPerfTime(timer);
     const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
@@ -295,15 +295,12 @@ ${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.b
     });
     relinka(
       "info",
-      "\u03A3 Total dist size:",
-      prettyBytes(ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0)),
-      `(build time: ${transpileFormattedTime})`
+      `\u03A3 Total dist size: ${prettyBytes(ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0))} (build time: ${transpileFormattedTime})`
     );
   }
   validateDependencies(ctx);
   validatePackage(pkg, rootDir, ctx);
   await ctx.hooks.callHook("build:done", ctx);
-  relinka("info", "");
   if (ctx.warnings.size > 0) {
     relinka(
       "warn",

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist.js

@@ -2,6 +2,7 @@ import { relinka } from "@reliverse/relinka";
 import { mkdist } from "mkdist";
 import { relative } from "pathe";
 import {
+  ensuredir,
   rmdir,
   symlink,
   warn
@@ -13,12 +14,13 @@ export async function mkdistBuild(ctx) {
   await ctx.hooks.callHook("mkdist:entries", ctx, entries);
   for (const entry of entries) {
     const distDir = entry.outDir || entry.input;
+    await ensuredir(distDir);
     if (ctx.options.transpileStub) {
       await rmdir(distDir);
       await symlink(entry.input, distDir);
     } else {
       const mkdistOptions = {
-        cleanDist: false,
+        cleanDist: true,
         distDir,
         rootDir: ctx.options.rootDir,
         srcDir: entry.input,

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

@@ -12,7 +12,7 @@ export function rollupWatch(rollupOptions) {
     inputs = Object.keys(rollupOptions.input || {});
   }
   relinka(
-    "info",
+    "log",
     `[dler] [rollup] Starting watchers for entries: ${inputs.map((input) => `./${relative(process.cwd(), input)}`).join(", ")}`
   );
   relinka(
@@ -20,10 +20,10 @@ export function rollupWatch(rollupOptions) {
     "[dler] [rollup] Watch mode is experimental and may be unstable"
   );
   transpileWatcher.on("change", (id, { event }) => {
-    relinka("info", `${relative(".", id)} was ${event}d`);
+    relinka("log", `${relative(".", id)} was ${event}d`);
   });
   transpileWatcher.on("restart", () => {
-    relinka("info", "[dler] [rollup] Rebuilding bundle");
+    relinka("log", "[dler] [rollup] Rebuilding bundle");
   });
   transpileWatcher.on("event", (event) => {
     if (event.code === "END") {

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

@@ -57,7 +57,7 @@ function extractFolderName(libName, libConfig) {
 export async function libraries_buildPublish(isDev, timer, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, libsDirSrc, commonPubPause, commonPubRegistry, unifiedBundlerOutExt, distNpmBuilder, coreEntrySrcDir, rmDepsMode, rmDepsPatterns, transpileEsbuild, transpileTarget, transpileFormat, transpileSplitting, transpileSourcemap, transpilePublicPath, distJsrBuilder, transpileStub, transpileWatch, distJsrOutFilesExt) {
   relinka("verbose", "Starting libraries_buildPublish");
   if (!libsList || Object.keys(libsList).length === 0) {
-    relinka("info", "No lib configs found in config, skipping libs build.");
+    relinka("log", "No lib configs found in config, skipping libs build.");
     return;
   }
   const libsEntries = Object.entries(libsList);

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

@@ -10,14 +10,14 @@ import {
 export async function library_publishLibrary(commonPubRegistry, libName, npmOutDir, jsrOutDir, distJsrDryRun, distJsrFailOnWarn, distJsrAllowDirty, distJsrSlowTypes, isDev, timer) {
   if (isDev) {
     relinka(
-      "info",
+      "log",
       `Skipping publishing for lib ${libName} in development mode`
     );
     return;
   }
   switch (commonPubRegistry) {
     case "jsr":
-      relinka("info", `Publishing lib ${libName} to JSR only...`);
+      relinka("log", `Publishing lib ${libName} to JSR only...`);
       await library_pubToJsr(
         jsrOutDir,
         distJsrDryRun,
@@ -30,7 +30,7 @@ export async function library_publishLibrary(commonPubRegistry, libName, npmOutD
       );
       break;
     case "npm":
-      relinka("info", `Publishing lib ${libName} to NPM only...`);
+      relinka("log", `Publishing lib ${libName} to NPM only...`);
       await library_pubToNpm(
         npmOutDir,
         distJsrDryRun,
@@ -41,7 +41,7 @@ export async function library_publishLibrary(commonPubRegistry, libName, npmOutD
       );
       break;
     case "npm-jsr": {
-      relinka("info", `Publishing lib ${libName} to both NPM and JSR...`);
+      relinka("log", `Publishing lib ${libName} to both NPM and JSR...`);
       const publishTasks = [
         () => library_pubToNpm(
           npmOutDir,
@@ -67,7 +67,7 @@ export async function library_publishLibrary(commonPubRegistry, libName, npmOutD
     }
     default:
       relinka(
-        "info",
+        "log",
         `Registry "${commonPubRegistry}" not recognized for lib ${libName}. Skipping publishing for this lib.`
       );
   }
@@ -75,13 +75,13 @@ export async function library_publishLibrary(commonPubRegistry, libName, npmOutD
 async function library_pubToJsr(libOutDir, distJsrDryRun, distJsrFailOnWarn, distJsrAllowDirty, distJsrSlowTypes, libName, isDev, timer) {
   relinka("verbose", `Starting library_pubToJsr for lib: ${libName}`);
   if (isDev) {
-    relinka("info", `Skipping lib ${libName} JSR publish in development mode`);
+    relinka("log", `Skipping lib ${libName} JSR publish in development mode`);
     return;
   }
   try {
     if (timer) pausePerfTimer(timer);
     await withWorkingDirectory(libOutDir, async () => {
-      relinka("info", `Publishing lib ${libName} to JSR from ${libOutDir}`);
+      relinka("log", `Publishing lib ${libName} to JSR from ${libOutDir}`);
       const command = [
         "bun x jsr publish",
         distJsrDryRun ? "--dry-run" : "",
@@ -107,13 +107,13 @@ async function library_pubToJsr(libOutDir, distJsrDryRun, distJsrFailOnWarn, dis
 async function library_pubToNpm(libOutDir, distJsrDryRun, distJsrFailOnWarn, libName, isDev, timer) {
   relinka("verbose", `Starting library_pubToNpm for lib: ${libName}`);
   if (isDev) {
-    relinka("info", `Skipping lib ${libName} NPM publish in development mode`);
+    relinka("log", `Skipping lib ${libName} NPM publish in development mode`);
     return;
   }
   try {
     if (timer) pausePerfTimer(timer);
     await withWorkingDirectory(libOutDir, async () => {
-      relinka("info", `Publishing lib ${libName} to NPM from ${libOutDir}`);
+      relinka("log", `Publishing lib ${libName} to NPM from ${libOutDir}`);
       const command = ["bun publish", distJsrDryRun ? "--dry-run" : ""].filter(Boolean).join(" ");
       await execaCommand(command, { stdio: "inherit" });
       relinka(

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

@@ -10,11 +10,11 @@ import {
 export async function regular_pubToJsr(distJsrDryRun, distJsrFailOnWarn, isDev, commonPubPause, distJsrDirName, distJsrAllowDirty, distJsrSlowTypes, timer) {
   try {
     if (isDev) {
-      relinka("info", "Skipping JSR publish in development mode");
+      relinka("log", "Skipping JSR publish in development mode");
       return;
     }
     if (!commonPubPause) {
-      relinka("info", "Publishing to JSR...");
+      relinka("log", "Publishing to JSR...");
       const distJsrDirNameResolved = path.resolve(PROJECT_ROOT, distJsrDirName);
       if (timer) pausePerfTimer(timer);
       await withWorkingDirectory(distJsrDirNameResolved, async () => {
@@ -43,11 +43,11 @@ export async function regular_pubToJsr(distJsrDryRun, distJsrFailOnWarn, isDev,
 export async function regular_pubToNpm(distJsrDryRun, isDev, commonPubPause, distNpmDirName, timer) {
   try {
     if (isDev) {
-      relinka("info", "Skipping NPM publish in development mode");
+      relinka("log", "Skipping NPM publish in development mode");
       return;
     }
     if (!commonPubPause) {
-      relinka("info", "Publishing to NPM...");
+      relinka("log", "Publishing to NPM...");
       const distNpmDirNameResolved = path.resolve(PROJECT_ROOT, distNpmDirName);
       if (timer) pausePerfTimer(timer);
       await withWorkingDirectory(distNpmDirNameResolved, async () => {