@reliverse/dler 1.7.63 → 1.7.64

package/bin/libs/cfg/cfg-impl/rse-config/rse-impl/rse-define.d.ts

@@ -9,12 +9,12 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
     projectRepository?: string | undefined;
     projectDomain?: string | undefined;
     projectGitService?: "none" | "github" | "gitlab" | "bitbucket" | undefined;
-    projectDeployService?: "none" | "vercel" | "netlify" | "railway" | "deno" | undefined;
-    projectPackageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+    projectDeployService?: "none" | "deno" | "vercel" | "netlify" | "railway" | undefined;
+    projectPackageManager?: "npm" | "yarn" | "pnpm" | "bun" | undefined;
     projectState?: "creating" | "created" | undefined;
-    projectCategory?: "browser" | "cli" | "unknown" | "website" | "vscode" | "library" | "mobile" | undefined;
+    projectCategory?: "cli" | "unknown" | "website" | "vscode" | "browser" | "library" | "mobile" | undefined;
     projectSubcategory?: "unknown" | "e-commerce" | "tool" | undefined;
-    projectFramework?: "rempts" | "npm-jsr" | "vue" | "svelte" | "unknown" | "vscode" | "nextjs" | "vite" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
+    projectFramework?: "rempts" | "npm-jsr" | "unknown" | "vscode" | "nextjs" | "vite" | "svelte" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "vue" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
     projectTemplate?: "unknown" | "blefnk/relivator-nextjs-template" | "blefnk/relivator-docker-template" | "blefnk/next-react-ts-src-minimal" | "blefnk/all-in-one-nextjs-template" | "blefnk/create-t3-app" | "blefnk/create-next-app" | "blefnk/astro-starlight-template" | "blefnk/versator-nextjs-template" | "blefnk/relivator-lynxjs-template" | "blefnk/relivator-react-native-template" | "reliverse/template-browser-extension" | "microsoft/vscode-extension-samples" | "microsoft/vscode-extension-template" | "rsetarter-template" | "blefnk/deno-cli-tutorial" | undefined;
     projectTemplateDate?: string | undefined;
     features?: {
@@ -38,13 +38,13 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         analytics?: "unknown" | "vercel" | undefined;
         authentication?: "unknown" | "better-auth" | "clerk" | "next-auth" | "supabase-auth" | "auth0" | undefined;
         api?: "unknown" | "hono" | "trpc" | "graphql" | "rest" | undefined;
-        testing?: "bun" | "jest" | "vitest" | "unknown" | "playwright" | "cypress" | undefined;
+        testing?: "bun" | "unknown" | "vitest" | "jest" | "playwright" | "cypress" | undefined;
         stateManagement?: "unknown" | "zustand" | "jotai" | "redux-toolkit" | undefined;
         formManagement?: "unknown" | "react-hook-form" | "formik" | undefined;
         styling?: "unknown" | "tailwind" | "styled-components" | "css-modules" | "sass" | undefined;
         uiComponents?: "unknown" | "shadcn-ui" | "chakra-ui" | "material-ui" | undefined;
         databaseLibrary?: "unknown" | "drizzle" | "prisma" | "supabase" | undefined;
-        databaseProvider?: "pg" | "unknown" | "mysql" | "sqlite" | "mongodb" | undefined;
+        databaseProvider?: "unknown" | "pg" | "mysql" | "sqlite" | "mongodb" | undefined;
         linting?: "unknown" | "eslint" | undefined;
         formatting?: "unknown" | "biome" | undefined;
         payment?: "unknown" | "stripe" | undefined;
@@ -57,7 +57,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         documentation?: "unknown" | "starlight" | "nextra" | undefined;
         icons?: "unknown" | "lucide" | undefined;
         mail?: "unknown" | "resend" | undefined;
-        cache?: "redis" | "unknown" | undefined;
+        cache?: "unknown" | "redis" | undefined;
         storage?: "unknown" | "cloudflare" | undefined;
         cdn?: "unknown" | "cloudflare" | undefined;
         cms?: "unknown" | "contentlayer" | undefined;
@@ -67,7 +67,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         dates?: "unknown" | "dayjs" | undefined;
         markdown?: "unknown" | "mdx" | undefined;
         security?: "unknown" | "auth" | undefined;
-        routing?: "next" | "unknown" | "react-router" | "tanstack-router" | undefined;
+        routing?: "unknown" | "next" | "react-router" | "tanstack-router" | undefined;
     } | undefined;
     codeStyle?: {
         lineWidth?: number | undefined;
@@ -83,7 +83,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         dontRemoveComments?: boolean | undefined;
         shouldAddComments?: boolean | undefined;
         typeOrInterface?: "type" | "interface" | "mixed" | undefined;
-        importOrRequire?: "import" | "require" | "mixed" | undefined;
+        importOrRequire?: "require" | "import" | "mixed" | undefined;
         cjsToEsm?: boolean | undefined;
         modernize?: {
             replaceFs?: boolean | undefined;
@@ -96,7 +96,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         importSymbol?: string | undefined;
     } | undefined;
     monorepo?: {
-        type?: "none" | "bun" | "turborepo" | "nx" | "pnpm" | undefined;
+        type?: "none" | "pnpm" | "bun" | "turborepo" | "nx" | undefined;
         packages?: string[] | undefined;
         sharedPackages?: string[] | undefined;
     } | undefined;
@@ -113,7 +113,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
     repoBranch?: string | undefined;
     repoPrivacy?: "unknown" | "public" | "private" | undefined;
     projectArchitecture?: "unknown" | "fullstack" | "separated" | undefined;
-    projectRuntime?: "bun" | "node" | "deno" | undefined;
+    projectRuntime?: "bun" | "deno" | "node" | undefined;
     skipPromptsUseAutoBehavior?: boolean | undefined;
     deployBehavior?: "prompt" | "autoYes" | "autoNo" | undefined;
     depsBehavior?: "prompt" | "autoYes" | "autoNo" | undefined;

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

@@ -1,6 +1,5 @@
 import { isAbsolute, normalize, relative, resolve } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { useSpinner } from "@reliverse/rempts";
 import { defu } from "defu";
 import { createHooks } from "hookable";
 import { createJiti } from "jiti";
@@ -73,305 +72,280 @@ export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, in
   }
 }
 async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog, isLib) {
-  await useSpinner.withTiming(
-    async (buildSpinner) => {
-      const timer = createPerfTimer();
-      buildSpinner.setText("Resolving build configuration...");
-      const preset = await resolvePreset(
-        buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
-        rootDir
-      );
-      const options = defu(buildConfig, pkg.dler || pkg.build, inputConfig, preset, {
-        alias: {},
-        clean: false,
-        declaration: void 0,
-        dependencies: [],
-        devDependencies: [],
-        entries: [],
-        externals: [...Module.builtinModules, ...Module.builtinModules.map((m) => `node:${m}`)],
-        transpileFailOnWarn: true,
-        name: (pkg?.name || "").split("/").pop() || "default",
-        outDir,
-        parallel: false,
-        peerDependencies: [],
-        replace: {},
-        rollup: {
-          alias: {},
-          cjsBridge: false,
-          commonjs: {
-            ignoreTryCatch: true
-          },
-          dts: {
-            compilerOptions: {
-              /**
-               * @see https://github.com/Swatinem/rollup-plugin-dts/issues/127
-               */
-              composite: false,
-              /**
-               * @see https://github.com/Swatinem/rollup-plugin-dts/issues/143
-               */
-              preserveSymlinks: false
-            },
-            respectExternal: true
-          },
-          emitCJS: false,
-          esbuild: { target: "esnext" },
-          inlineDependencies: false,
-          json: {
-            preferConst: true
-          },
-          output: {
-            /**
-             * @see https://v8.dev/features/import-attributes
-             */
-            importAttributesKey: "with"
-          },
-          preserveDynamicImports: true,
-          // Plugins
-          replace: {
-            preventAssignment: true
-          },
-          resolve: {
-            preferBuiltins: true
-          },
-          watch: false
-        },
-        rootDir,
-        showOutLog: true,
-        transpileSourcemap: false,
-        transpileStub: _transpileStubMode,
-        transpileStubOptions: {
+  const timer = createPerfTimer();
+  relinka("info", "Resolving build configuration...");
+  const preset = await resolvePreset(
+    buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
+    rootDir
+  );
+  const options = defu(buildConfig, pkg.dler || pkg.build, inputConfig, preset, {
+    alias: {},
+    clean: false,
+    declaration: void 0,
+    dependencies: [],
+    devDependencies: [],
+    entries: [],
+    externals: [...Module.builtinModules, ...Module.builtinModules.map((m) => `node:${m}`)],
+    transpileFailOnWarn: true,
+    name: (pkg?.name || "").split("/").pop() || "default",
+    outDir,
+    parallel: false,
+    peerDependencies: [],
+    replace: {},
+    rollup: {
+      alias: {},
+      cjsBridge: false,
+      commonjs: {
+        ignoreTryCatch: true
+      },
+      dts: {
+        compilerOptions: {
           /**
-           * @see https://github.com/unjs/jiti#%EF%B8%8F-options
+           * @see https://github.com/Swatinem/rollup-plugin-dts/issues/127
            */
-          jiti: {
-            alias: {},
-            interopDefault: true
-          }
+          composite: false,
+          /**
+           * @see https://github.com/Swatinem/rollup-plugin-dts/issues/143
+           */
+          preserveSymlinks: false
         },
-        transpileWatch: _transpileWatchMode,
-        transpileWatchOptions: _transpileWatchMode ? {
-          exclude: "node_modules/**",
-          include: "src/**"
-        } : void 0,
-        isLib
-      });
-      shouldStopAtStep(5);
-      relinka("log", "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);
-      const jiti = createJiti(options.rootDir, { interopDefault: true });
-      buildSpinner.setText("Initializing build context...");
-      const ctx = {
-        buildEntries: [],
-        hooks: createHooks(),
-        jiti,
-        options,
-        pkg,
-        usedImports: /* @__PURE__ */ new Set(),
-        warnings: /* @__PURE__ */ new Set(),
-        isLib
-      };
-      if (preset.hooks) {
-        ctx.hooks.addHooks(preset.hooks);
-      }
-      if (inputConfig.hooks) {
-        ctx.hooks.addHooks(inputConfig.hooks);
-      }
-      if (buildConfig.hooks) {
-        ctx.hooks.addHooks(buildConfig.hooks);
+        respectExternal: true
+      },
+      emitCJS: false,
+      esbuild: { target: "esnext" },
+      inlineDependencies: false,
+      json: {
+        preferConst: true
+      },
+      output: {
+        /**
+         * @see https://v8.dev/features/import-attributes
+         */
+        importAttributesKey: "with"
+      },
+      preserveDynamicImports: true,
+      // Plugins
+      replace: {
+        preventAssignment: true
+      },
+      resolve: {
+        preferBuiltins: true
+      },
+      watch: false
+    },
+    rootDir,
+    showOutLog: true,
+    transpileSourcemap: false,
+    transpileStub: _transpileStubMode,
+    transpileStubOptions: {
+      /**
+       * @see https://github.com/unjs/jiti#%EF%B8%8F-options
+       */
+      jiti: {
+        alias: {},
+        interopDefault: true
       }
-      await ctx.hooks.callHook("build:prepare", ctx);
-      buildSpinner.setText("Processing build entries...");
-      options.entries = options.entries.map(
-        (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
-      );
-      for (const entry of options.entries) {
-        if (typeof entry.name !== "string") {
-          let relativeInput = isAbsolute(entry.input) ? relative(rootDir, entry.input) : normalize(entry.input);
-          if (relativeInput.startsWith("./")) {
-            relativeInput = relativeInput.slice(2);
-          }
-          entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
-        }
-        if (!entry.input) {
-          throw new Error(`Missing entry input: ${dumpObject(entry)}`);
-        }
-        if (!entry.builder) {
-          entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
-        }
-        if (options.declaration !== void 0 && entry.declaration === void 0) {
-          entry.declaration = options.declaration;
-        }
-        entry.input = resolve(options.rootDir, entry.input);
-        entry.outDir = resolve(options.rootDir, entry.outDir || options.outDir);
-        entry.isLib = isLib;
+    },
+    transpileWatch: _transpileWatchMode,
+    transpileWatchOptions: _transpileWatchMode ? {
+      exclude: "node_modules/**",
+      include: "src/**"
+    } : void 0,
+    isLib
+  });
+  shouldStopAtStep(5);
+  relinka("log", "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);
+  const jiti = createJiti(options.rootDir, { interopDefault: true });
+  relinka("info", "Initializing build context...");
+  const ctx = {
+    buildEntries: [],
+    hooks: createHooks(),
+    jiti,
+    options,
+    pkg,
+    usedImports: /* @__PURE__ */ new Set(),
+    warnings: /* @__PURE__ */ new Set(),
+    isLib
+  };
+  if (preset.hooks) {
+    ctx.hooks.addHooks(preset.hooks);
+  }
+  if (inputConfig.hooks) {
+    ctx.hooks.addHooks(inputConfig.hooks);
+  }
+  if (buildConfig.hooks) {
+    ctx.hooks.addHooks(buildConfig.hooks);
+  }
+  await ctx.hooks.callHook("build:prepare", ctx);
+  relinka("info", "Processing build entries...");
+  options.entries = options.entries.map(
+    (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
+  );
+  for (const entry of options.entries) {
+    if (typeof entry.name !== "string") {
+      let relativeInput = isAbsolute(entry.input) ? relative(rootDir, entry.input) : normalize(entry.input);
+      if (relativeInput.startsWith("./")) {
+        relativeInput = relativeInput.slice(2);
       }
-      options.dependencies = Object.keys(pkg.dependencies || {});
-      options.peerDependencies = Object.keys(pkg.peerDependencies || {});
-      options.devDependencies = Object.keys(pkg.devDependencies || {});
-      options.externals.push(...inferPkgExternals(pkg));
-      options.externals = [...new Set(options.externals)];
-      await ctx.hooks.callHook("build:before", ctx);
-      relinka(
-        "verbose",
-        `${options.transpileStub ? "Stubbing" : "[unified] Building"} ${options.name}`
-      );
-      if (process.env.DEBUG) {
-        relinka(
-          "log",
-          `Root dir: ${options.rootDir}
+      entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
+    }
+    if (!entry.input) {
+      throw new Error(`Missing entry input: ${dumpObject(entry)}`);
+    }
+    if (!entry.builder) {
+      entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
+    }
+    if (options.declaration !== void 0 && entry.declaration === void 0) {
+      entry.declaration = options.declaration;
+    }
+    entry.input = resolve(options.rootDir, entry.input);
+    entry.outDir = resolve(options.rootDir, entry.outDir || options.outDir);
+    entry.isLib = isLib;
+  }
+  options.dependencies = Object.keys(pkg.dependencies || {});
+  options.peerDependencies = Object.keys(pkg.peerDependencies || {});
+  options.devDependencies = Object.keys(pkg.devDependencies || {});
+  options.externals.push(...inferPkgExternals(pkg));
+  options.externals = [...new Set(options.externals)];
+  await ctx.hooks.callHook("build:before", ctx);
+  relinka(
+    "verbose",
+    `${options.transpileStub ? "Stubbing" : "[unified] Building"} ${options.name}`
+  );
+  if (process.env.DEBUG) {
+    relinka(
+      "log",
+      `Root dir: ${options.rootDir}
 Entries:
 ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
 `
-        );
-      }
-      if (options.clean) {
-        buildSpinner.setText("Cleaning output directories...");
-        for (const dir of new Set(
-          options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
-        )) {
-          if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
-            continue;
-          }
-          cleanedDirs.push(dir);
-          relinka("log", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
-          await rmdir(dir);
-          await fsp.mkdir(dir, { recursive: true });
-        }
-      }
-      const buildTasks = [
-        { name: "Type generation", task: typesBuild },
-        { name: "mkdist build", task: mkdistBuild },
-        { name: "Rollup build", task: rollupBuild },
-        { name: "Copy files", task: copyBuild }
-      ];
-      const activeTasks = buildTasks.filter(({ task }) => {
-        if (task === typesBuild) return options.entries.some((e) => e.builder === "untyped");
-        if (task === mkdistBuild) return options.entries.some((e) => e.builder === "mkdist");
-        if (task === rollupBuild) return options.entries.some((e) => e.builder === "rollup");
-        if (task === copyBuild) return options.entries.some((e) => e.builder === "copy");
-        return false;
-      });
-      if (activeTasks.length === 0) {
-        buildSpinner.setText("No build tasks to execute");
-      } else {
-        let completedTasks = 0;
-        if (options.parallel) {
-          buildSpinner.setText(`Running ${activeTasks.length} build tasks in parallel...`);
-          await Promise.all(
-            activeTasks.map(async ({ task }) => {
-              await task(ctx);
-              completedTasks++;
-              buildSpinner.setProgress({
-                current: completedTasks,
-                total: activeTasks.length
-              });
-            })
-          );
-        } else {
-          for (const { task, name } of activeTasks) {
-            completedTasks++;
-            buildSpinner.setProgress({
-              current: completedTasks,
-              total: activeTasks.length
-            });
-            buildSpinner.setText(`Running ${name}...`);
-            await task(ctx);
-          }
-        }
+    );
+  }
+  if (options.clean) {
+    relinka("info", "Cleaning output directories...");
+    for (const dir of new Set(
+      options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
+    )) {
+      if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
+        continue;
       }
-      if (options.transpileStub || options.transpileWatch) {
-        await ctx.hooks.callHook("build:done", ctx);
-        return;
+      cleanedDirs.push(dir);
+      relinka("log", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
+      await rmdir(dir);
+      await fsp.mkdir(dir, { recursive: true });
+    }
+  }
+  const buildTasks = [
+    { name: "Type generation", task: typesBuild },
+    { name: "mkdist build", task: mkdistBuild },
+    { name: "Rollup build", task: rollupBuild },
+    { name: "Copy files", task: copyBuild }
+  ];
+  const activeTasks = buildTasks.filter(({ task }) => {
+    if (task === typesBuild) return options.entries.some((e) => e.builder === "untyped");
+    if (task === mkdistBuild) return options.entries.some((e) => e.builder === "mkdist");
+    if (task === rollupBuild) return options.entries.some((e) => e.builder === "rollup");
+    if (task === copyBuild) return options.entries.some((e) => e.builder === "copy");
+    return false;
+  });
+  if (activeTasks.length === 0) {
+    relinka("info", "No build tasks to execute");
+  } else {
+    if (options.parallel) {
+      relinka("info", `Running ${activeTasks.length} build tasks in parallel...`);
+      await Promise.all(
+        activeTasks.map(async ({ task }) => {
+          await task(ctx);
+        })
+      );
+    } else {
+      for (const { task, name } of activeTasks) {
+        relinka("info", `Running ${name}...`);
+        await task(ctx);
       }
-      buildSpinner.setText("Finalizing build output...");
-      relinka("success", `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);
-        if (!entry) {
-          entry = {
-            chunk: true,
-            path: file,
-            isLib: ctx.options.isLib
-          };
-          ctx.buildEntries.push(entry);
-        }
-        if (!entry.bytes) {
-          const stat = await fsp.stat(resolve(options.outDir, file));
-          entry.bytes = stat.size;
-        }
+    }
+  }
+  if (options.transpileStub || options.transpileWatch) {
+    await ctx.hooks.callHook("build:done", ctx);
+    return;
+  }
+  relinka("info", "Finalizing build output...");
+  relinka("success", `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);
+    if (!entry) {
+      entry = {
+        chunk: true,
+        path: file,
+        isLib: ctx.options.isLib
+      };
+      ctx.buildEntries.push(entry);
+    }
+    if (!entry.bytes) {
+      const stat = await fsp.stat(resolve(options.outDir, file));
+      entry.bytes = stat.size;
+    }
+  }
+  const rPath = (p) => relative(process.cwd(), resolve(options.outDir, p));
+  if (showOutLog) {
+    for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
+      let totalBytes = entry.bytes || 0;
+      for (const chunk of entry.chunks || []) {
+        totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
       }
-      const rPath = (p) => relative(process.cwd(), resolve(options.outDir, p));
-      if (showOutLog) {
-        for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
-          let totalBytes = entry.bytes || 0;
-          for (const chunk of entry.chunks || []) {
-            totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
-          }
-          let line = `  ${rPath(entry.path)} (${[
-            totalBytes && `total size: ${prettyBytes(totalBytes)}`,
-            entry.bytes && `chunk size: ${prettyBytes(entry.bytes)}`,
-            entry.exports?.length && `exports: ${entry.exports.join(", ")}`
-          ].filter(Boolean).join(", ")})`;
-          if (entry.chunks?.length) {
-            line += `
+      let line = `  ${rPath(entry.path)} (${[
+        totalBytes && `total size: ${prettyBytes(totalBytes)}`,
+        entry.bytes && `chunk size: ${prettyBytes(entry.bytes)}`,
+        entry.exports?.length && `exports: ${entry.exports.join(", ")}`
+      ].filter(Boolean).join(", ")})`;
+      if (entry.chunks?.length) {
+        line += `
 ${entry.chunks.map((p) => {
-              const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
-              return `  \u2514\u2500 ${rPath(p)}${chunk.bytes ? ` (${prettyBytes(chunk.bytes)})` : ""}`;
-            }).join("\n")}`;
-          }
-          if (entry.modules?.length) {
-            line += `
+          const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
+          return `  \u2514\u2500 ${rPath(p)}${chunk.bytes ? ` (${prettyBytes(chunk.bytes)})` : ""}`;
+        }).join("\n")}`;
+      }
+      if (entry.modules?.length) {
+        line += `
 ${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
-              return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
-            }).join("\n")}`;
-          }
-          relinka("log", entry.chunk ? line : line);
-        }
-        const elapsedTime = getElapsedPerfTime(timer);
-        const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
-          verbose: true
-        });
-        const totalSize = ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0);
-        buildSpinner.setText(
-          `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`
-        );
-        relinka(
-          "info",
-          `\u03A3 Total dist size: ${prettyBytes(totalSize)} (build time: ${transpileFormattedTime})`
-        );
+          return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
+        }).join("\n")}`;
       }
-      validateDependencies(ctx);
-      validatePackage(pkg, rootDir, ctx);
-      await ctx.hooks.callHook("build:done", ctx);
-      if (ctx.warnings.size > 0) {
-        const warningMessage = `Build completed with ${ctx.warnings.size} warnings`;
-        buildSpinner.warn(warningMessage);
-        relinka(
-          "warn",
-          `Build is done with some warnings:
+      relinka("log", entry.chunk ? line : line);
+    }
+    const elapsedTime = getElapsedPerfTime(timer);
+    const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
+      verbose: true
+    });
+    const totalSize = ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0);
+    relinka("info", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
+    relinka(
+      "info",
+      `\u03A3 Total dist size: ${prettyBytes(totalSize)} (build time: ${transpileFormattedTime})`
+    );
+  }
+  validateDependencies(ctx);
+  validatePackage(pkg, rootDir, ctx);
+  await ctx.hooks.callHook("build:done", ctx);
+  if (ctx.warnings.size > 0) {
+    relinka("warn", `Build completed with ${ctx.warnings.size} warnings`);
+    relinka(
+      "warn",
+      `Build is done with some warnings:
 ${[...ctx.warnings].map((msg) => `- ${msg}`).join("\n")}`
-        );
-        if (ctx.options.transpileFailOnWarn) {
-          relinka(
-            "error",
-            "Exiting with code (1). You can change this behavior by setting `transpileFailOnWarn: false` ."
-          );
-          process.exit(1);
-        }
-        shouldStopAtStep(15);
-        relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
-      }
-    },
-    {
-      text: _transpileStubMode ? `Stubbing ${pkg?.name || "project"}...` : `Building ${pkg?.name || "project"}...`,
-      color: "green",
-      successText: `${pkg?.name || "Project"} built successfully!`,
-      failText: `Build failed for ${pkg?.name || "project"}`,
-      prefixText: "[unified]"
+    );
+    if (ctx.options.transpileFailOnWarn) {
+      relinka(
+        "error",
+        "Exiting with code (1). You can change this behavior by setting `transpileFailOnWarn: false` ."
+      );
+      process.exit(1);
     }
-  );
+    shouldStopAtStep(15);
+    relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
+  }
 }

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

@@ -1,5 +1,5 @@
 import { resolve, extname, join, basename, dirname } from "@reliverse/pathkit";
-import { useSpinner } from "@reliverse/rempts";
+import { relinka } from "@reliverse/relinka";
 import defu from "defu";
 import fsp from "node:fs/promises";
 import { glob } from "tinyglobby";
@@ -8,206 +8,196 @@ import { getDeclarations, normalizeCompilerOptions } from "./utils/dts.js";
 import { copyFileWithStream } from "./utils/fs.js";
 import { getVueDeclarations } from "./utils/vue-dts.js";
 export async function mkdist(options = {}) {
-  return await useSpinner.withTiming(
-    async (mainSpinner) => {
-      options.rootDir = resolve(process.cwd(), options.rootDir || ".");
-      options.srcDir = resolve(options.rootDir, options.srcDir || "src");
-      options.distDir = resolve(options.rootDir, options.distDir || "dist");
-      if (options.cleanDist !== false) {
-        mainSpinner.setText("Cleaning distribution directory...");
-        await fsp.unlink(options.distDir).catch(() => {
-        });
-        await fsp.rm(options.distDir, { recursive: true, force: true });
-        await fsp.mkdir(options.distDir, { recursive: true });
+  const startTime = Date.now();
+  options.rootDir = resolve(process.cwd(), options.rootDir || ".");
+  options.srcDir = resolve(options.rootDir, options.srcDir || "src");
+  options.distDir = resolve(options.rootDir, options.distDir || "dist");
+  if (options.cleanDist !== false) {
+    relinka("info", "Cleaning distribution directory...");
+    await fsp.unlink(options.distDir).catch(() => {
+    });
+    await fsp.rm(options.distDir, { recursive: true, force: true });
+    await fsp.mkdir(options.distDir, { recursive: true });
+  }
+  relinka("info", "Scanning input files...");
+  const filePaths = await glob(options.pattern || "**", {
+    absolute: false,
+    ignore: ["**/node_modules", "**/coverage", "**/.git"],
+    cwd: options.srcDir,
+    dot: true,
+    ...options.globOptions
+  });
+  const files = filePaths.map((path) => {
+    const sourcePath = resolve(options.srcDir, path);
+    return {
+      path,
+      srcPath: sourcePath,
+      extension: extname(path),
+      getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
+    };
+  });
+  relinka("info", `Found ${files.length} files to process`);
+  options.typescript ||= {};
+  if (options.typescript.compilerOptions) {
+    relinka("info", "Normalizing TypeScript compiler options...");
+    options.typescript.compilerOptions = await normalizeCompilerOptions(
+      options.typescript.compilerOptions
+    );
+  }
+  options.typescript.compilerOptions = defu(
+    { noEmit: false },
+    options.typescript.compilerOptions,
+    {
+      allowJs: true,
+      declaration: true,
+      skipLibCheck: true,
+      strictNullChecks: true,
+      emitDeclarationOnly: true,
+      allowImportingTsExtensions: true,
+      allowNonTsExtensions: true
+    }
+  );
+  relinka("info", "Creating file loaders...");
+  const { loadFile } = createLoader(options);
+  relinka("info", "Processing files with loaders...");
+  const outputs = [];
+  let processedCount = 0;
+  await Promise.all(
+    files.map(async (file) => {
+      const result = await loadFile(file);
+      if (result) {
+        outputs.push(...result);
       }
-      mainSpinner.setText("Scanning input files...");
-      const filePaths = await glob(options.pattern || "**", {
-        absolute: false,
-        ignore: ["**/node_modules", "**/coverage", "**/.git"],
-        cwd: options.srcDir,
-        dot: true,
-        ...options.globOptions
-      });
-      const files = filePaths.map((path) => {
-        const sourcePath = resolve(options.srcDir, path);
-        return {
-          path,
-          srcPath: sourcePath,
-          extension: extname(path),
-          getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
-        };
-      });
-      mainSpinner.setText(`Found ${files.length} files to process`);
-      options.typescript ||= {};
-      if (options.typescript.compilerOptions) {
-        mainSpinner.setText("Normalizing TypeScript compiler options...");
-        options.typescript.compilerOptions = await normalizeCompilerOptions(
-          options.typescript.compilerOptions
-        );
+      processedCount++;
+      const shouldUpdate = processedCount % Math.max(1, Math.floor(files.length / 10)) === 0 || processedCount === files.length;
+      if (shouldUpdate) {
+        relinka("verbose", `Processing files: ${file.path} (${processedCount}/${files.length})`);
       }
-      options.typescript.compilerOptions = defu(
-        { noEmit: false },
-        options.typescript.compilerOptions,
-        {
-          allowJs: true,
-          declaration: true,
-          skipLibCheck: true,
-          strictNullChecks: true,
-          emitDeclarationOnly: true,
-          allowImportingTsExtensions: true,
-          allowNonTsExtensions: true
-        }
-      );
-      mainSpinner.setText("Creating file loaders...");
-      const { loadFile } = createLoader(options);
-      mainSpinner.setText("Processing files with loaders...");
-      const outputs = [];
-      let processedCount = 0;
-      await Promise.all(
-        files.map(async (file) => {
-          const result = await loadFile(file);
-          if (result) {
-            outputs.push(...result);
-          }
-          processedCount++;
-          const shouldUpdate = processedCount % Math.max(1, Math.floor(files.length / 10)) === 0 || processedCount === files.length;
-          if (shouldUpdate) {
-            mainSpinner.setProgress({
-              current: processedCount,
-              total: files.length
-            });
-            mainSpinner.setText(`Processing files: ${file.path}`);
-          }
-        })
-      );
-      mainSpinner.setText("Normalizing output extensions...");
-      const pathConflicts = [];
-      for (const output of outputs.filter((o) => o.extension)) {
-        const renamed = basename(output.path, extname(output.path)) + output.extension;
-        output.path = join(dirname(output.path), renamed);
-        const conflictingOutput = outputs.find((o) => o !== output && o.path === output.path);
-        if (conflictingOutput) {
-          pathConflicts.push(output.path);
-        }
+    })
+  );
+  relinka("info", "Normalizing output extensions...");
+  const pathConflicts = [];
+  for (const output of outputs.filter((o) => o.extension)) {
+    const renamed = basename(output.path, extname(output.path)) + output.extension;
+    output.path = join(dirname(output.path), renamed);
+    const conflictingOutput = outputs.find((o) => o !== output && o.path === output.path);
+    if (conflictingOutput) {
+      pathConflicts.push(output.path);
+    }
+  }
+  if (pathConflicts.length > 0) {
+    const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
+    relinka("error", errorMessage);
+    throw new Error(errorMessage);
+  }
+  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
+  if (dtsOutputs.length > 0) {
+    relinka("info", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
+    const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
+    const declarations = /* @__PURE__ */ Object.create(null);
+    for (const loader of [getVueDeclarations, getDeclarations]) {
+      Object.assign(declarations, await loader(vfs, options));
+    }
+    let dtsProcessed = 0;
+    for (const output of dtsOutputs) {
+      const result = declarations[output.srcPath];
+      output.contents = result?.contents || "";
+      if (result.errors) {
+        output.errors = result.errors;
       }
-      if (pathConflicts.length > 0) {
-        const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
-        mainSpinner.fail(errorMessage);
-        throw new Error(errorMessage);
+      dtsProcessed++;
+      if (dtsProcessed % Math.max(1, Math.floor(dtsOutputs.length / 5)) === 0) {
+        relinka("verbose", `Generated declarations for ${dtsProcessed}/${dtsOutputs.length} files`);
       }
-      const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
-      if (dtsOutputs.length > 0) {
-        mainSpinner.setText(`Generating TypeScript declarations for ${dtsOutputs.length} files...`);
-        const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
-        const declarations = /* @__PURE__ */ Object.create(null);
-        for (const loader of [getVueDeclarations, getDeclarations]) {
-          Object.assign(declarations, await loader(vfs, options));
-        }
-        let dtsProcessed = 0;
-        for (const output of dtsOutputs) {
-          const result = declarations[output.srcPath];
-          output.contents = result?.contents || "";
-          if (result.errors) {
-            output.errors = result.errors;
-          }
-          dtsProcessed++;
-          if (dtsProcessed % Math.max(1, Math.floor(dtsOutputs.length / 5)) === 0) {
-            mainSpinner.setProgress({
-              current: dtsProcessed,
-              total: dtsOutputs.length
-            });
-          }
-        }
+    }
+  }
+  relinka("info", "Resolving relative imports...");
+  const outPaths = new Set(outputs.map((o) => o.path));
+  const resolveId = (from, id = "", resolveExtensions) => {
+    if (!id.startsWith(".")) {
+      return id;
+    }
+    for (const extension of resolveExtensions) {
+      if (outPaths.has(join(dirname(from), id + extension))) {
+        return id + extension;
       }
-      mainSpinner.setText("Resolving relative imports...");
-      const outPaths = new Set(outputs.map((o) => o.path));
-      const resolveId = (from, id = "", resolveExtensions) => {
-        if (!id.startsWith(".")) {
-          return id;
-        }
-        for (const extension of resolveExtensions) {
-          if (outPaths.has(join(dirname(from), id + extension))) {
-            return id + extension;
-          }
+    }
+    return id;
+  };
+  const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
+  const esmOutputs = outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js");
+  for (const output of esmOutputs) {
+    output.contents = output.contents.replace(
+      /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
+      (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
+    ).replace(
+      /import\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
+    );
+  }
+  const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
+  const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
+  for (const output of cjsOutputs) {
+    output.contents = output.contents.replace(
+      /require\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
+    );
+  }
+  const outputsToWrite = outputs.filter((o) => !o.skip);
+  relinka("info", `Writing ${outputsToWrite.length} output files...`);
+  const writtenFiles = [];
+  const errors = [];
+  let writtenCount = 0;
+  await Promise.all(
+    outputsToWrite.map(async (output) => {
+      try {
+        const outFile = join(options.distDir, output.path);
+        await fsp.mkdir(dirname(outFile), { recursive: true });
+        await (output.raw ? (
+          // @ts-expect-error TODO: fix ts
+          copyFileWithStream(output.srcPath, outFile)
+        ) : (
+          // @ts-expect-error TODO: fix ts
+          fsp.writeFile(outFile, output.contents, "utf8")
+        ));
+        writtenFiles.push(outFile);
+        if (output.errors) {
+          errors.push({ filename: outFile, errors: output.errors });
         }
-        return id;
-      };
-      const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
-      const esmOutputs = outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js");
-      for (const output of esmOutputs) {
-        output.contents = output.contents.replace(
-          /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
-          (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
-        ).replace(
-          /import\((["'])(.*)(["'])\)/g,
-          (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
-        );
+      } catch (error) {
+        const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
+        errors.push({
+          filename: output.path,
+          errors: [new TypeError(errorMessage)]
+        });
       }
-      const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
-      const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
-      for (const output of cjsOutputs) {
-        output.contents = output.contents.replace(
-          /require\((["'])(.*)(["'])\)/g,
-          (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
-        );
+      writtenCount++;
+      const progressUpdateInterval = Math.max(10, Math.floor(outputsToWrite.length / 10));
+      if (writtenCount % progressUpdateInterval === 0 || writtenCount === outputsToWrite.length) {
+        relinka("verbose", `Written ${writtenCount}/${outputsToWrite.length} files`);
       }
-      const outputsToWrite = outputs.filter((o) => !o.skip);
-      mainSpinner.setText(`Writing ${outputsToWrite.length} output files...`);
-      const writtenFiles = [];
-      const errors = [];
-      let writtenCount = 0;
-      await Promise.all(
-        outputsToWrite.map(async (output) => {
-          try {
-            const outFile = join(options.distDir, output.path);
-            await fsp.mkdir(dirname(outFile), { recursive: true });
-            await (output.raw ? (
-              // @ts-expect-error TODO: fix ts
-              copyFileWithStream(output.srcPath, outFile)
-            ) : (
-              // @ts-expect-error TODO: fix ts
-              fsp.writeFile(outFile, output.contents, "utf8")
-            ));
-            writtenFiles.push(outFile);
-            if (output.errors) {
-              errors.push({ filename: outFile, errors: output.errors });
-            }
-          } catch (error) {
-            const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
-            errors.push({
-              filename: output.path,
-              errors: [new TypeError(errorMessage)]
-            });
-          }
-          writtenCount++;
-          const progressUpdateInterval = Math.max(10, Math.floor(outputsToWrite.length / 10));
-          if (writtenCount % progressUpdateInterval === 0 || writtenCount === outputsToWrite.length) {
-            mainSpinner.setProgress({
-              current: writtenCount,
-              total: outputsToWrite.length
-            });
-          }
-        })
+    })
+  );
+  const duration = Date.now() - startTime;
+  if (errors.length > 0) {
+    relinka("warn", `Build completed with ${errors.length} errors`);
+    for (const error of errors.slice(0, 5)) {
+      relinka(
+        "error",
+        `Error in ${error.filename}: ${error.errors[0]?.message || "Unknown error"}`
       );
-      if (errors.length > 0) {
-        mainSpinner.warn(`Build completed with ${errors.length} errors`);
-        for (const error of errors.slice(0, 5)) {
-          console.error(`Error in ${error.filename}:`, error.errors[0]?.message || "Unknown error");
-        }
-        if (errors.length > 5) {
-          console.error(`... and ${errors.length - 5} more errors`);
-        }
-      }
-      return {
-        errors,
-        writtenFiles
-      };
-    },
-    {
-      text: "Building using mkdist...",
-      color: "cyan",
-      successText: "Build completed successfully!",
-      failText: "Build failed!"
     }
-  );
+    if (errors.length > 5) {
+      relinka("error", `... and ${errors.length - 5} more errors`);
+    }
+  } else {
+    relinka("success", "Build completed successfully!");
+  }
+  return {
+    result: {
+      errors,
+      writtenFiles
+    },
+    duration
+  };
 }

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

@@ -1,6 +1,5 @@
 import { relative, dirname as pathDirname } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { useSpinner } from "@reliverse/rempts";
 import { rmdir, symlink, warn } from "../utils.js";
 import { mkdist } from "./mkdist-impl/make.js";
 export async function mkdistBuild(ctx) {
@@ -8,100 +7,86 @@ export async function mkdistBuild(ctx) {
   if (entries.length === 0) {
     return;
   }
-  await useSpinner.promise(
-    async (mainSpinner) => {
-      await ctx.hooks.callHook("mkdist:entries", ctx, entries);
-      let processedEntries = 0;
-      let totalWrittenFiles = 0;
-      let totalErrors = 0;
-      for (const entry of entries) {
-        processedEntries++;
-        mainSpinner.setProgress({
-          current: processedEntries,
-          total: entries.length
-        });
-        mainSpinner.setText(
-          `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`
-        );
-        const distDir = entry.outDir || entry.input;
-        if (ctx.options.transpileStub) {
-          await rmdir(distDir);
-          await symlink(entry.input, distDir);
-          continue;
-        }
-        let srcDir;
-        if (typeof entry.input === "string" && !entry.input.endsWith("/")) {
-          srcDir = ctx.options.isLib ? pathDirname(entry.input) : entry.input;
-          relinka(
-            "verbose",
-            `[mkdist] Using directory from file path: ${srcDir} (from: ${entry.input})`
-          );
-        } else {
-          srcDir = entry.input;
-          relinka("verbose", `[mkdist] Using directory directly: ${srcDir}`);
-        }
-        const mkdistOptions = {
-          cleanDist: false,
-          distDir,
-          rootDir: ctx.options.rootDir,
-          srcDir,
-          format: "esm",
-          ext: entry.ext || "js",
-          ...entry
-        };
-        relinka(
-          "info",
-          `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
-        );
-        await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
-        try {
-          const { result: output, duration } = await mkdist(mkdistOptions);
-          relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
-          totalWrittenFiles += output.writtenFiles.length;
-          ctx.buildEntries.push({
-            chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
-            path: distDir,
-            isLib: ctx.options.isLib
-          });
-          await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
-          if (output.errors && output.errors.length > 0) {
-            totalErrors += output.errors.length;
-            for (const error of output.errors) {
-              warn(
-                ctx,
-                `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
-${error.errors.map((e) => `  - ${e}`).join("\n")}`
-              );
-            }
-          }
-        } catch (error) {
-          totalErrors++;
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  let processedEntries = 0;
+  let totalWrittenFiles = 0;
+  let totalErrors = 0;
+  relinka("info", `Processing ${entries.length} mkdist entries...`);
+  for (const entry of entries) {
+    processedEntries++;
+    relinka("info", `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`);
+    const distDir = entry.outDir || entry.input;
+    if (ctx.options.transpileStub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+      continue;
+    }
+    let srcDir;
+    if (typeof entry.input === "string" && !entry.input.endsWith("/")) {
+      srcDir = ctx.options.isLib ? pathDirname(entry.input) : entry.input;
+      relinka(
+        "verbose",
+        `[mkdist] Using directory from file path: ${srcDir} (from: ${entry.input})`
+      );
+    } else {
+      srcDir = entry.input;
+      relinka("verbose", `[mkdist] Using directory directly: ${srcDir}`);
+    }
+    const mkdistOptions = {
+      cleanDist: false,
+      distDir,
+      rootDir: ctx.options.rootDir,
+      srcDir,
+      format: "esm",
+      ext: entry.ext || "js",
+      ...entry
+    };
+    relinka(
+      "info",
+      `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
+    );
+    await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
+    try {
+      const { result: output, duration } = await mkdist(mkdistOptions);
+      relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
+      totalWrittenFiles += output.writtenFiles.length;
+      ctx.buildEntries.push({
+        chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
+        path: distDir,
+        isLib: ctx.options.isLib
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors && output.errors.length > 0) {
+        totalErrors += output.errors.length;
+        for (const error of output.errors) {
           warn(
             ctx,
-            `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
+            `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
           );
         }
       }
-      await ctx.hooks.callHook("mkdist:done", ctx);
-      if (entries.length > 0 && ctx.options.transpileWatch) {
-        relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
-      }
-      if (totalErrors > 0) {
-        mainSpinner.warn(
-          `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
-        );
-      } else {
-        mainSpinner.setText(
-          `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
-        );
-      }
-    },
-    {
-      text: entries.length === 1 ? "Processing mkdist entry..." : `Processing ${entries.length} mkdist entries...`,
-      color: "blue",
-      successText: entries.length === 1 ? "mkdist entry completed!" : `All ${entries.length} mkdist entries completed!`,
-      failText: "mkdist build failed!",
-      prefixText: "[mkdist]"
+    } catch (error) {
+      totalErrors++;
+      warn(
+        ctx,
+        `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
     }
-  );
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
+  }
+  if (totalErrors > 0) {
+    relinka(
+      "warn",
+      `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
+    );
+  } else {
+    relinka(
+      "success",
+      `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
+    );
+  }
 }

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.63";
+const version = "1.7.64";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/package.json

@@ -55,7 +55,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.63",
+  "version": "1.7.64",
   "keywords": [
     "reliverse",
     "cli",