@reliverse/dler 1.7.153 → 2.0.1

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

@@ -1,398 +0,0 @@
-import path, { convertImportsAliasToRelative, convertImportsExt } from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { build as bunBuild } from "bun";
-import prettyMilliseconds from "pretty-ms";
-import { unifiedBuild } from "./providers/build.js";
-import { CONCURRENCY_DEFAULT, PROJECT_ROOT, validExtensions } from "../config/constants.js";
-import { getBunSourcemapOption, getUnifiedSourcemapOption } from "../utils/utils-build.js";
-import { removeLogInternalCalls } from "../utils/utils-clean.js";
-import { copyRootFile, deleteSpecificFiles } from "../utils/utils-fs.js";
-import { createJsrJSON, renameTsxFiles } from "../utils/utils-jsr-json.js";
-import { regular_createPackageJSON } from "../utils/utils-package-json-regular.js";
-import { getElapsedPerfTime } from "../utils/utils-perf.js";
-const ALIAS_PREFIX_TO_CONVERT = "~";
-export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrcDir, distJsrDirName, distJsrBuilder, coreEntryFile, transpileTarget, transpileFormat, transpileMinify, transpileSourcemap, transpilePublicPath, unifiedBundlerOutExt, config, timer, transpileStub, transpileWatch, distJsrGenTsconfig, coreDeclarations) {
-  const outDirRoot = path.join(process.cwd(), distJsrDirName);
-  const outDirBin = path.join(outDirRoot, config.coreBuildOutDir || "bin");
-  const singleFile = path.join(process.cwd(), coreEntrySrcDir, coreEntryFile);
-  const srcDir = path.join(process.cwd(), coreEntrySrcDir);
-  relinka("verbose", `Building JSR distribution (isDev=${isDev}, isJsr=${isJsr})...`);
-  try {
-    await fs.ensureDir(outDirBin);
-    await regular_bundleWithBuilder(distJsrBuilder, {
-      coreIsCLI: { enabled: coreIsCLI.enabled, scripts: coreIsCLI.scripts },
-      coreDeclarations,
-      outDir: outDirBin,
-      singleFile,
-      srcDir,
-      timer,
-      transpileFormat,
-      transpileMinify,
-      transpilePublicPath,
-      transpileSourcemap,
-      transpileStub,
-      transpileTarget,
-      transpileWatch,
-      unifiedBundlerOutExt
-    });
-    await regular_performCommonBuildSteps({
-      coreIsCLI,
-      isJsr,
-      outDirBin,
-      outDirRoot,
-      config,
-      unifiedBundlerOutExt,
-      coreDescription: config.coreDescription,
-      coreBuildOutDir: config.coreBuildOutDir
-    });
-    if (distJsrGenTsconfig) {
-      await regular_createTsconfig(outDirRoot);
-    }
-    relinka("verbose", `Performing JSR-specific transformations in ${outDirBin}`);
-    await createJsrJSON(
-      outDirRoot,
-      false,
-      // isLib
-      {},
-      // libsList (empty for regular builds)
-      config,
-      void 0,
-      // libName (not needed for regular builds)
-      config.coreDescription
-    );
-    await renameTsxFiles(outDirBin);
-    if (config.commonPubPause) {
-      const duration = getElapsedPerfTime(timer);
-      const transpileFormattedDuration = prettyMilliseconds(duration, {
-        verbose: true
-      });
-      relinka("verbose", `JSR distribution built in ${transpileFormattedDuration}`);
-    } else {
-      relinka("verbose", "JSR distribution built successfully");
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    relinka("error", `Failed to build JSR distribution: ${errorMessage}`);
-    throw new Error(`JSR distribution build failed: ${errorMessage}`);
-  }
-}
-export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, distNpmDirName, distNpmBuilder, coreEntryFile, unifiedBundlerOutExt, config, transpileTarget, transpileFormat, transpileMinify, transpileSourcemap, transpilePublicPath, transpileStub, transpileWatch, timer, coreDeclarations) {
-  const outDirRoot = path.join(process.cwd(), distNpmDirName);
-  const outDirBin = path.join(outDirRoot, config.coreBuildOutDir || "bin");
-  const singleFile = path.join(process.cwd(), coreEntrySrcDir, coreEntryFile);
-  const srcDir = path.join(process.cwd(), coreEntrySrcDir);
-  relinka("verbose", `Building NPM distribution (isDev=${isDev})...`);
-  try {
-    await fs.ensureDir(outDirBin);
-    await regular_bundleWithBuilder(distNpmBuilder, {
-      coreIsCLI: { enabled: coreIsCLI.enabled, scripts: coreIsCLI.scripts },
-      coreDeclarations,
-      outDir: outDirBin,
-      singleFile,
-      srcDir,
-      timer,
-      transpileFormat,
-      transpileMinify,
-      transpilePublicPath,
-      transpileSourcemap,
-      transpileStub,
-      transpileTarget,
-      transpileWatch,
-      unifiedBundlerOutExt
-    });
-    await regular_performCommonBuildSteps({
-      coreIsCLI,
-      isJsr: false,
-      outDirBin,
-      outDirRoot,
-      config,
-      unifiedBundlerOutExt,
-      coreDescription: config.coreDescription,
-      coreBuildOutDir: config.coreBuildOutDir
-    });
-    if (config.commonPubPause) {
-      const duration = getElapsedPerfTime(timer);
-      const transpileFormattedDuration = prettyMilliseconds(duration, {
-        verbose: true
-      });
-      relinka("verbose", `NPM distribution built in ${transpileFormattedDuration}`);
-    } else {
-      relinka("verbose", "NPM distribution built successfully");
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    relinka("error", `Failed to build NPM distribution: ${errorMessage}`);
-    throw new Error(`NPM distribution build failed: ${errorMessage}`);
-  }
-}
-async function regular_bundleUsingBun(coreEntryFile, outDirBin, transpileTarget, transpileFormat, transpileMinify, transpileSourcemap, transpilePublicPath, timer) {
-  relinka(
-    "verbose",
-    `Bundling regular project using Bun (entry: ${coreEntryFile}, outDir: ${outDirBin})`
-  );
-  if (!await fs.pathExists(coreEntryFile)) {
-    relinka("error", `Could not find entry file at: ${coreEntryFile}`);
-    throw new Error(`Entry file not found: ${coreEntryFile}`);
-  }
-  try {
-    const buildResult = await bunBuild({
-      banner: "/* Bundled by @reliverse/dler */",
-      define: {
-        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "production")
-      },
-      drop: ["debugger"],
-      entrypoints: [coreEntryFile],
-      footer: "/* End of bundle */",
-      format: transpileFormat,
-      minify: transpileMinify,
-      naming: {
-        asset: "[name]-[hash].[ext]",
-        chunk: "[name]-[hash].[ext]",
-        entry: "[dir]/[name]-[hash].[ext]"
-      },
-      outdir: outDirBin,
-      publicPath: transpilePublicPath || "/",
-      sourcemap: getBunSourcemapOption(transpileSourcemap),
-      target: transpileTarget,
-      throw: true
-    });
-    const duration = getElapsedPerfTime(timer);
-    const transpileFormattedDuration = prettyMilliseconds(duration, {
-      verbose: true
-    });
-    relinka(
-      "verbose",
-      `Regular bun build completed in ${transpileFormattedDuration} with ${buildResult.outputs.length} output file(s).`
-    );
-    if (buildResult.logs && buildResult.logs.length > 0) {
-      buildResult.logs.forEach((log, index) => {
-        relinka("verbose", `Log ${index + 1}: ${JSON.stringify(log)}`);
-      });
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    relinka("error", `Regular build failed while using bun bundler: ${errorMessage}`);
-    throw new Error(`Regular bundle failed for ${outDirBin}: ${errorMessage}`);
-  }
-}
-async function 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()) {
-    throw new Error(
-      "Please provide path to directory instead of path to file when using 'jsr' builder."
-    );
-  }
-  try {
-    await fs.copy(src, dest, { overwrite: true });
-    relinka("verbose", `Copied directory from ${src} to ${dest}`);
-    relinka(
-      "verbose",
-      `Completed regular bundling via 'jsr' builder`
-      // `${successCount} files processed, ${changedCount} modified`,
-    );
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(errorMessage);
-  }
-}
-async function regular_bundleUsingUnified(coreIsCLI, coreEntryFile, outDirBin, builder, unifiedBundlerOutExt, coreEntrySrcDir, transpileStub, transpileWatch, transpileTarget, transpileMinify, transpileSourcemap, timer, coreDeclarations) {
-  if (builder === "jsr" || builder === "bun") {
-    throw new Error("'jsr'/'bun' builder not supported for regular_bundleUsingUnified");
-  }
-  try {
-    relinka(
-      "verbose",
-      `Starting regular_bundleUsingUnified (builder: ${builder}): ${coreEntryFile} -> ${outDirBin}`
-    );
-    const rootDir = PROJECT_ROOT;
-    const srcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
-    if (!validExtensions.includes(unifiedBundlerOutExt)) {
-      throw new Error(`Invalid output extension: ${unifiedBundlerOutExt}`);
-    }
-    const input = builder === "mkdist" ? path.dirname(coreEntryFile) : coreEntryFile;
-    const unifiedBuildConfig = {
-      clean: false,
-      concurrency: CONCURRENCY_DEFAULT,
-      declaration: coreDeclarations,
-      entries: [
-        {
-          builder,
-          ext: unifiedBundlerOutExt,
-          input: builder === "mkdist" ? path.relative(rootDir, srcDirResolved) : path.relative(rootDir, input),
-          // For other builders, use relative path to entry file
-          outDir: path.relative(rootDir, outDirBin),
-          isLib: false
-        }
-      ],
-      rollup: {
-        emitCJS: false,
-        esbuild: {
-          minify: transpileMinify,
-          target: transpileTarget
-        },
-        inlineDependencies: true,
-        output: {
-          sourcemap: getUnifiedSourcemapOption(transpileSourcemap)
-        }
-      },
-      showOutLog: true,
-      transpileStub,
-      transpileWatch: transpileWatch ?? false
-    };
-    await unifiedBuild(coreEntrySrcDir, coreIsCLI, false, rootDir, unifiedBuildConfig, outDirBin);
-    const duration = getElapsedPerfTime(timer);
-    const transpileFormattedDuration = prettyMilliseconds(duration, {
-      verbose: true
-    });
-    relinka(
-      "verbose",
-      `Regular bundle completed in ${transpileFormattedDuration} using ${builder} builder`
-    );
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    relinka("error", `Failed to bundle regular project using ${builder}: ${errorMessage}`);
-    throw new Error(`Regular bundle failed for ${outDirBin}: ${errorMessage}`);
-  }
-}
-async function regular_bundleWithBuilder(builder, params) {
-  const {
-    coreIsCLI,
-    coreDeclarations,
-    outDir,
-    singleFile,
-    srcDir,
-    timer,
-    transpileFormat,
-    transpileMinify,
-    transpilePublicPath,
-    transpileSourcemap,
-    transpileStub,
-    transpileTarget,
-    transpileWatch,
-    unifiedBundlerOutExt
-  } = params;
-  if (builder === "jsr") {
-    await regular_bundleUsingJsr(srcDir, outDir);
-    return;
-  }
-  if (builder === "bun") {
-    await regular_bundleUsingBun(
-      singleFile,
-      outDir,
-      transpileTarget,
-      transpileFormat,
-      transpileMinify,
-      transpileSourcemap,
-      transpilePublicPath,
-      timer
-    );
-    return;
-  }
-  await regular_bundleUsingUnified(
-    coreIsCLI,
-    singleFile,
-    outDir,
-    builder,
-    unifiedBundlerOutExt,
-    // For mkdist, we pass the directory. For others, we pass the single file
-    path.dirname(singleFile),
-    transpileStub,
-    transpileWatch,
-    transpileTarget,
-    transpileMinify,
-    transpileSourcemap,
-    timer,
-    coreDeclarations
-  );
-}
-async function regular_performCommonBuildSteps({
-  coreIsCLI,
-  deleteFiles = true,
-  isJsr,
-  outDirBin,
-  outDirRoot,
-  config,
-  unifiedBundlerOutExt,
-  coreDescription,
-  coreBuildOutDir
-}) {
-  relinka("verbose", `Performing common build steps in ${outDirBin} (regular)`);
-  relinka(
-    "verbose",
-    `[${isJsr ? "dist-jsr" : "dist-npm"}] Performing alias path conversion in ${outDirBin}`
-  );
-  await convertImportsAliasToRelative({
-    targetDir: outDirBin,
-    aliasToReplace: ALIAS_PREFIX_TO_CONVERT,
-    pathExtFilter: "js-ts-none"
-  });
-  if (isJsr) {
-    relinka(
-      "verbose",
-      `[dist-jsr] Performing paths ext conversion in ${outDirBin} (from js to ts)`
-    );
-    await convertImportsExt({
-      targetDir: outDirBin,
-      extFrom: "js",
-      extTo: "ts"
-    });
-    await convertImportsExt({
-      targetDir: outDirBin,
-      extFrom: "none",
-      extTo: "ts"
-    });
-  }
-  await removeLogInternalCalls(outDirBin);
-  if (deleteFiles) {
-    await deleteSpecificFiles(outDirBin);
-  }
-  await regular_createPackageJSON(
-    outDirRoot,
-    isJsr,
-    coreIsCLI,
-    unifiedBundlerOutExt,
-    config,
-    coreDescription,
-    coreBuildOutDir
-  );
-  await copyRootFile(outDirRoot, config.publishArtifacts?.global || ["README.md", "LICENSE"]);
-  if (isJsr && coreIsCLI.enabled) {
-    const jsrFiles = config.publishArtifacts?.["dist-jsr"] || [
-      ".gitignore",
-      "reliverse.ts",
-      "reliverse.jsonc",
-      "drizzle.config.ts",
-      "schema.json"
-    ];
-    await copyRootFile(outDirRoot, jsrFiles);
-  }
-}
-async function regular_createTsconfig(outDirRoot) {
-  const tsconfigPath = path.join(outDirRoot, "tsconfig.json");
-  const tsconfig = {
-    compilerOptions: {
-      target: "ES2022",
-      module: "ESNext",
-      moduleResolution: "bundler",
-      declaration: true,
-      declarationMap: true,
-      sourceMap: true,
-      strict: true,
-      skipLibCheck: true,
-      esModuleInterop: true,
-      resolveJsonModule: true,
-      isolatedModules: true,
-      noUnusedLocals: true,
-      noUnusedParameters: true,
-      noImplicitReturns: true,
-      noFallthroughCasesInSwitch: true
-    },
-    include: ["**/*.ts"],
-    exclude: ["node_modules", "dist"]
-  };
-  await fs.writeFile(tsconfigPath, JSON.stringify(tsconfig, null, 2));
-  relinka("verbose", `Created tsconfig.json at ${tsconfigPath}`);
-}

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

@@ -1,25 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-import type { PerfTimer } from "../types/mod.js";
-import type { WorkspacePackage } from "../utils/workspace-utils.js";
-/**
- * Main entry point for the rse build process.
- * Handles building for both main project and libraries.
- * @see `src/impl/pub/impl.ts` for pub main function implementation.
- */
-export declare function dlerBuild({ flow, timer, isDev, config, debugOnlyCopyNonBuildFiles, debugDontCopyNonBuildFiles, disableOwnSpinner, workspacePackages, enableCache, depsOnly, showGraph, cleanCacheFlag, }: {
-    flow: "build" | "pub";
-    timer: PerfTimer;
-    isDev: boolean;
-    config?: ReliverseConfig;
-    debugOnlyCopyNonBuildFiles?: boolean;
-    debugDontCopyNonBuildFiles?: boolean;
-    disableOwnSpinner?: boolean;
-    workspacePackages?: WorkspacePackage[] | null;
-    enableCache?: boolean;
-    depsOnly?: boolean;
-    showGraph?: boolean;
-    cleanCacheFlag?: boolean;
-}): Promise<{
-    timer: PerfTimer;
-    effectiveConfig: any;
-} | undefined>;

package/bin/impl/build/impl.js

@@ -1,264 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { createMultiStepSpinner } from "@reliverse/rempts";
-import { binary_buildFlow } from "./binary-flow.js";
-import { library_buildFlow } from "./library-flow.js";
-import { regular_buildFlow } from "./regular-flow.js";
-import { PROJECT_ROOT } from "../config/constants.js";
-import { getConfigDler } from "../config/load.js";
-import { removeDistFolders } from "../utils/utils-clean.js";
-import { handleDlerError } from "../utils/utils-error-cwd.js";
-import { sortPackagesByDependencies } from "../utils/workspace-utils.js";
-import {
-  cachePackageOutput,
-  cleanCache,
-  DependencyGraph,
-  findMonorepo,
-  hashPackage,
-  isPackageCached,
-  readMonorepoPackageJson,
-  restorePackageCache
-} from "../../mod.js";
-import { createCompletionTexts } from "../utils/finish-text.js";
-import { dlerPostBuild, wrapper_CopyNonBuildFiles } from "./postbuild.js";
-import { dlerPreBuild } from "./prebuild.js";
-export async function dlerBuild({
-  flow,
-  timer,
-  isDev,
-  config,
-  debugOnlyCopyNonBuildFiles,
-  debugDontCopyNonBuildFiles,
-  disableOwnSpinner,
-  workspacePackages,
-  enableCache,
-  depsOnly,
-  showGraph,
-  cleanCacheFlag
-}) {
-  let effectiveConfig = config;
-  let shouldShowSpinner = false;
-  let multiStepSpinner = null;
-  try {
-    if (!effectiveConfig) {
-      effectiveConfig = await getConfigDler();
-    }
-    let monorepo = null;
-    let dependencyGraph = null;
-    if (enableCache || depsOnly || showGraph || cleanCacheFlag) {
-      monorepo = await findMonorepo();
-      if (monorepo) {
-        relinka("verbose", `Monorepo detected at: ${monorepo.root}`);
-        if (cleanCacheFlag) {
-          await cleanCache(monorepo);
-          relinka("log", "\u2713 Cache cleaned");
-        }
-        const { globby } = await import("globby");
-        const packageJsonGlobs = monorepo.packageGlobs.map((glob) => `${glob}/package.json`);
-        const matches = await globby(packageJsonGlobs, { cwd: monorepo.root, absolute: true });
-        const packages = [];
-        for (const packageJsonPath of matches) {
-          const pkg = await readMonorepoPackageJson(packageJsonPath);
-          if (pkg) {
-            packages.push(pkg);
-          }
-        }
-        dependencyGraph = new DependencyGraph(packages);
-        if (showGraph) {
-          dependencyGraph.print();
-        }
-        if (depsOnly) {
-          const activePackage = dependencyGraph.findActivePackage();
-          if (activePackage) {
-            const dependencies = dependencyGraph.getPackageDependenciesBuildOrder(activePackage.name);
-            relinka("info", `Building dependencies for ${activePackage.name}: ${dependencies.map((p) => p.name).join(", ")}`);
-            for (const pkg of dependencies) {
-              await buildCachedPackage(pkg, monorepo, enableCache || false);
-            }
-            relinka("log", "\u2713 Dependencies built");
-            return;
-          } else {
-            relinka("warn", "Not in a package directory, cannot determine dependencies");
-          }
-        }
-      } else {
-        relinka("warn", "Monorepo features requested but no monorepo detected");
-      }
-    }
-    if (workspacePackages && workspacePackages.length > 0) {
-      relinka("info", `Building ${workspacePackages.length} workspace package(s)`);
-      relinka("verbose", `Workspace packages: ${workspacePackages.map((p) => p.name).join(", ")}`);
-      const sortedPackages = sortPackagesByDependencies(workspacePackages);
-      for (const pkg of sortedPackages) {
-        relinka("info", `Building package: ${pkg.name}`);
-        const packageConfig = {
-          ...effectiveConfig,
-          // Override package-specific settings
-          projectName: pkg.name,
-          projectAuthor: "reliverse",
-          projectDescription: "Dler plugin for code migration and modernization codemods",
-          projectLicense: "MIT",
-          coreEntrySrcDir: path.join(pkg.path, "src"),
-          // Assume src dir in package
-          coreEntryFile: "mod.ts",
-          // Default entry file for workspace packages
-          // Override dist directories to be package-specific
-          distNpmDirName: path.join("dist-workspace", pkg.name, "npm"),
-          distJsrDirName: path.join("dist-workspace", pkg.name, "jsr"),
-          libsDirDist: path.join("dist-workspace", pkg.name, "libs"),
-          // Ensure it's treated as a library, not CLI
-          coreIsCLI: { enabled: false, scripts: {} },
-          // Use ESM format for workspace packages
-          transpileFormat: "esm",
-          transpileTarget: "node",
-          // Keep readable for libraries
-          transpileMinify: false,
-          transpileSourcemap: "none",
-          // Use package-specific package.json
-          corePackageJsonPath: pkg.packageJsonPath
-        };
-        await regular_buildFlow(timer, isDev, packageConfig);
-        await library_buildFlow(timer, isDev, packageConfig);
-        await binary_buildFlow(timer, isDev, packageConfig);
-        const distPackageJsonPath = path.join(packageConfig.distNpmDirName, "package.json");
-        relinka("verbose", `Copying package.json from ${pkg.packageJsonPath} to ${distPackageJsonPath}`);
-        await fs.copy(pkg.packageJsonPath, distPackageJsonPath);
-        const packageJsonContent = await fs.readFile(distPackageJsonPath, "utf-8");
-        const packageJson = JSON.parse(packageJsonContent);
-        packageJson.main = "./bin/mod.js";
-        packageJson.types = "./bin/mod.d.ts";
-        packageJson.exports = {
-          ".": {
-            "types": "./bin/mod.d.ts",
-            "default": "./bin/mod.js"
-          }
-        };
-        packageJson.files = ["bin"];
-        packageJson.module = "./bin/mod.js";
-        packageJson.publishConfig = { access: "public" };
-        if (!packageJson.homepage) {
-          packageJson.homepage = "https://docs.reliverse.org/cli";
-        }
-        if (!packageJson.bugs) {
-          packageJson.bugs = {
-            email: "blefnk@gmail.com",
-            url: `https://github.com/reliverse/dler/issues`
-          };
-        }
-        if (!packageJson.devDependencies) {
-          packageJson.devDependencies = {};
-        }
-        await fs.writeFile(distPackageJsonPath, JSON.stringify(packageJson, null, 2));
-        relinka("verbose", `Updated package.json paths to point to bin directory`);
-        relinka("success", `Successfully built package: ${pkg.name}`);
-      }
-      relinka("success", `Successfully built all ${workspacePackages.length} workspace package(s)`);
-      relinka("info", "Building main project and libraries...");
-    }
-    shouldShowSpinner = effectiveConfig.displayBuildPubLogs === false && !disableOwnSpinner;
-    const buildSteps = [
-      "Loading configuration",
-      "Cleaning previous build",
-      "Pre-build setup",
-      "Building main project",
-      "Building libraries",
-      "Building binaries",
-      "Post-build cleanup"
-    ];
-    multiStepSpinner = shouldShowSpinner ? createMultiStepSpinner("Build Process", buildSteps, { color: "blue" }) : null;
-    if (multiStepSpinner) multiStepSpinner.nextStep();
-    if (effectiveConfig.logsFreshFile) {
-      await fs.remove(path.join(PROJECT_ROOT, effectiveConfig.logsFileName));
-    }
-    await removeDistFolders(
-      effectiveConfig.distNpmDirName,
-      effectiveConfig.distJsrDirName,
-      effectiveConfig.libsDirDist,
-      effectiveConfig.libsList,
-      "dist-tmp"
-    );
-    if (multiStepSpinner) multiStepSpinner.nextStep();
-    if (debugOnlyCopyNonBuildFiles) {
-      if (debugDontCopyNonBuildFiles) {
-        relinka(
-          "error",
-          "\u{1F4DD} debugOnlyCopyNonBuildFiles and debugDontCopyNonBuildFiles cannot be used together"
-        );
-        process.exit(1);
-      }
-      await wrapper_CopyNonBuildFiles(effectiveConfig);
-      relinka("info", "\u{1F4DD} debugOnlyCopyNonBuildFiles was used, build finished, exiting...");
-      process.exit(0);
-    }
-    await dlerPreBuild(effectiveConfig);
-    if (multiStepSpinner) multiStepSpinner.nextStep();
-    const tempDirs = {
-      npm: "dist-tmp/tmp-npm",
-      jsr: "dist-tmp/tmp-jsr",
-      libs: "dist-tmp/tmp-libs"
-    };
-    const tempConfig = {
-      ...effectiveConfig,
-      coreEntrySrcDir: tempDirs.npm,
-      libsDirSrc: tempDirs.libs
-    };
-    await regular_buildFlow(timer, isDev, tempConfig);
-    if (multiStepSpinner) multiStepSpinner.nextStep();
-    await library_buildFlow(timer, isDev, tempConfig);
-    if (multiStepSpinner) multiStepSpinner.nextStep();
-    await binary_buildFlow(timer, isDev, tempConfig);
-    if (multiStepSpinner) multiStepSpinner.nextStep();
-    await dlerPostBuild(isDev, debugDontCopyNonBuildFiles);
-    if (effectiveConfig.postBuildSettings?.deleteDistTmpAfterBuild) {
-      await fs.remove(path.join(PROJECT_ROOT, "dist-tmp"));
-    }
-    if (flow === "build") {
-      const { plain, withEmoji } = await createCompletionTexts(effectiveConfig, timer, "build");
-      if (multiStepSpinner) {
-        multiStepSpinner.complete(plain);
-      } else {
-        relinka("success", withEmoji);
-      }
-    }
-    return { timer, effectiveConfig };
-  } catch (error) {
-    if (multiStepSpinner) {
-      const currentStep = multiStepSpinner.getCurrentStep();
-      multiStepSpinner.error(error, currentStep);
-    }
-    handleDlerError(error);
-  }
-}
-async function buildCachedPackage(pkg, monorepo, enableCache) {
-  if (!pkg.buildScript) {
-    relinka("log", `\u2713 ${pkg.name}: Nothing to build`);
-    return;
-  }
-  relinka("log", `\u25D0 ${pkg.name}: ${pkg.buildScript}`);
-  if (enableCache) {
-    const { packageHash } = await hashPackage(pkg);
-    if (await isPackageCached(monorepo, pkg, packageHash) && pkg.config.cache) {
-      await restorePackageCache(monorepo, pkg, packageHash);
-      relinka("log", `\u2713 ${pkg.name}: Cached!`);
-      return;
-    }
-    const { execaCommand } = await import("execa");
-    const args = [...monorepo.packageManager.runCmd, "build"];
-    await execaCommand(args.join(" "), {
-      cwd: pkg.dir,
-      env: { ...process.env, INSIDE_DLER: "true" }
-    });
-    if (pkg.config.cache) {
-      await cachePackageOutput(monorepo, pkg, packageHash);
-    }
-  } else {
-    const { execaCommand } = await import("execa");
-    const args = [...monorepo.packageManager.runCmd, "build"];
-    await execaCommand(args.join(" "), {
-      cwd: pkg.dir,
-      env: { ...process.env, INSIDE_DLER: "true" }
-    });
-  }
-  relinka("log", `\u2713 ${pkg.name}: Built`);
-}