@reliverse/dler 1.7.91 → 1.7.93

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

@@ -0,0 +1,400 @@
+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, transpileSplitting, 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,
+      transpileSplitting,
+      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("success", `JSR distribution built in ${transpileFormattedDuration}`);
+    } else {
+      relinka("success", "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, transpileSplitting, 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,
+      transpileSplitting,
+      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("success", `NPM distribution built in ${transpileFormattedDuration}`);
+    } else {
+      relinka("success", "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, transpileSplitting, 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),
+      splitting: transpileSplitting,
+      target: transpileTarget,
+      throw: true
+    });
+    const duration = getElapsedPerfTime(timer);
+    const transpileFormattedDuration = prettyMilliseconds(duration, {
+      verbose: true
+    });
+    relinka(
+      "success",
+      `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(
+      "success",
+      `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(
+      "success",
+      `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,
+    transpileSplitting,
+    transpileStub,
+    transpileTarget,
+    transpileWatch,
+    unifiedBundlerOutExt
+  } = params;
+  if (builder === "jsr") {
+    await regular_bundleUsingJsr(srcDir, outDir);
+    return;
+  }
+  if (builder === "bun") {
+    await regular_bundleUsingBun(
+      singleFile,
+      outDir,
+      transpileTarget,
+      transpileFormat,
+      transpileSplitting,
+      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(
+    "info",
+    `[${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("info", `[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/app/build/cmd.js

@@ -1,7 +1,7 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerBuild } from "./impl.js";
-import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
-import { finalizeBuild } from "../../libs/sdk/sdk-mod.js";
+import { getConfigDler } from "../config/load.js";
+import { finalizeBuild } from "../utils/finalize.js";
 export default defineCommand({
   meta: {
     name: "build",

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

@@ -1,4 +1,4 @@
-import type { DlerConfig } from "../../libs/sdk/sdk-impl/config/types.js";
+import type { DlerConfig } from "../types/mod.js";
 /**
  * Main entry point for the dler build process.
  * Handles building for both main project and libraries.

package/bin/app/build/impl.js

@@ -1,14 +1,14 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
-import { library_buildFlow } from "../../libs/sdk/sdk-impl/library-flow.js";
-import { regular_buildFlow } from "../../libs/sdk/sdk-impl/regular-flow.js";
-import { createSpinner } from "../../libs/sdk/sdk-impl/utils/spinner.js";
-import { removeDistFolders } from "../../libs/sdk/sdk-impl/utils/utils-clean.js";
-import { PROJECT_ROOT } from "../../libs/sdk/sdk-impl/utils/utils-consts.js";
-import { handleDlerError } from "../../libs/sdk/sdk-impl/utils/utils-error-cwd.js";
-import { createPerfTimer } from "../../libs/sdk/sdk-impl/utils/utils-perf.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 { createSpinner } from "../utils/spinner.js";
+import { removeDistFolders } from "../utils/utils-clean.js";
+import { handleDlerError } from "../utils/utils-error-cwd.js";
+import { createPerfTimer } from "../utils/utils-perf.js";
 import { dlerPostBuild, wrapper_CopyNonBuildFiles } from "./postbuild.js";
 import { dlerPreBuild } from "./prebuild.js";
 export async function dlerBuild(isDev, config, debugOnlyCopyNonBuildFiles, debugDontCopyNonBuildFiles, disableOwnSpinner) {

package/bin/app/build/library-flow.d.ts

@@ -0,0 +1,25 @@
+import type { BundlerName, DlerConfig, Esbuild, LibConfig, NpmOutExt, PerfTimer, Sourcemap, transpileFormat, transpileTarget } from "../types/mod.js";
+/**
+ * Builds libraries based on build mode.
+ */
+export declare function library_buildFlow(timer: PerfTimer, isDev: boolean, config: DlerConfig): Promise<void>;
+/**
+ * Publishes libraries based on build mode.
+ */
+export declare function library_pubFlow(timer: PerfTimer, isDev: boolean, config: DlerConfig): Promise<void>;
+/**
+ * Builds all libs defined in config.libsList.
+ */
+export declare function libraries_build(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, libsDirDist: string, libsDirSrc: string, commonPubRegistry: "jsr" | "npm" | "npm-jsr", unifiedBundlerOutExt: NpmOutExt, distNpmBuilder: BundlerName, coreEntrySrcDir: string, filterDepsPatterns: {
+    global: string[];
+    "dist-npm": string[];
+    "dist-jsr": string[];
+    "dist-libs": Record<string, {
+        npm: string[];
+        jsr: string[];
+    }>;
+}, transpileEsbuild: Esbuild, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, distJsrBuilder: BundlerName, transpileStub: boolean, transpileWatch: boolean, distJsrOutFilesExt: NpmOutExt, config: DlerConfig): Promise<void>;
+/**
+ * Publishes all libs defined in config.libsList.
+ */
+export declare function libraries_publish(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, distJsrDryRun: boolean, distJsrFailOnWarn: boolean, libsDirDist: string, commonPubPause: boolean, commonPubRegistry: "jsr" | "npm" | "npm-jsr", distJsrAllowDirty: boolean, distJsrSlowTypes: boolean): Promise<void>;

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

@@ -0,0 +1,203 @@
+import path from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import pAll from "p-all";
+import { library_buildLibrary } from "./build-library.js";
+import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "../config/constants.js";
+import { library_publishLibrary } from "../pub/pub-library.js";
+import { resumePerfTimer } from "../utils/utils-perf.js";
+export async function library_buildFlow(timer, isDev, config) {
+  relinka("verbose", "\u2014 \u2014 \u2014 library_buildFlow \u2014 \u2014 \u2014");
+  if (config.libsActMode !== "libs-only" && config.libsActMode !== "main-and-libs") {
+    relinka("verbose", "Skipping libs build as libsActMode is set to 'main-project-only'");
+    return;
+  }
+  await libraries_build(
+    isDev,
+    timer,
+    config.libsList,
+    config.libsDirDist,
+    config.libsDirSrc,
+    config.commonPubRegistry,
+    config.distNpmOutFilesExt,
+    config.distNpmBuilder,
+    config.coreEntrySrcDir,
+    config.filterDepsPatterns,
+    config.transpileEsbuild,
+    config.transpileTarget,
+    config.transpileFormat,
+    config.transpileSplitting,
+    config.transpileSourcemap,
+    config.transpilePublicPath,
+    config.distJsrBuilder,
+    config.transpileStub,
+    config.transpileWatch,
+    config.distJsrOutFilesExt,
+    config
+  );
+}
+export async function library_pubFlow(timer, isDev, config) {
+  relinka("verbose", "\u2014 \u2014 \u2014 library_pubFlow \u2014 \u2014 \u2014");
+  if (config.libsActMode !== "libs-only" && config.libsActMode !== "main-and-libs") {
+    relinka("verbose", "Skipping libs publish as libsActMode is set to 'main-project-only'");
+    return;
+  }
+  await libraries_publish(
+    isDev,
+    timer,
+    config.libsList,
+    config.distJsrDryRun,
+    config.distJsrFailOnWarn,
+    config.libsDirDist,
+    config.commonPubPause,
+    config.commonPubRegistry,
+    config.distJsrAllowDirty,
+    config.distJsrSlowTypes
+  );
+}
+function extractFolderName(libName, libConfig) {
+  if (libConfig?.libDirName) {
+    return libConfig.libDirName;
+  }
+  const parts = libName.split("/");
+  let baseName = parts[parts.length - 1];
+  if (baseName?.includes("-")) {
+    const dashParts = baseName.split("-");
+    baseName = dashParts[dashParts.length - 1];
+  }
+  if (!baseName) {
+    baseName = libName;
+  }
+  return baseName;
+}
+export async function libraries_build(isDev, timer, libsList, libsDirDist, libsDirSrc, commonPubRegistry, unifiedBundlerOutExt, distNpmBuilder, coreEntrySrcDir, filterDepsPatterns, transpileEsbuild, transpileTarget, transpileFormat, transpileSplitting, transpileSourcemap, transpilePublicPath, distJsrBuilder, transpileStub, transpileWatch, distJsrOutFilesExt, config) {
+  relinka("verbose", "Starting libraries_build");
+  if (!libsList || Object.keys(libsList).length === 0) {
+    relinka("verbose", "No lib configs found in config, skipping libs build.");
+    return;
+  }
+  const libsEntries = Object.entries(libsList);
+  const tasks = libsEntries.map(([libName, libConfig]) => {
+    return async () => {
+      try {
+        if (!libConfig.libMainFile) {
+          throw new Error(`Library ${libName} is missing "libMainFile" property.`);
+        }
+        const folderName = extractFolderName(libName, libConfig);
+        const libBaseDir = path.resolve(PROJECT_ROOT, libsDirDist, folderName);
+        const npmOutDir = path.join(libBaseDir, "npm");
+        const jsrOutDir = path.join(libBaseDir, "jsr");
+        const libMainPath = path.parse(libConfig.libMainFile);
+        const libMainFile = libMainPath.base;
+        let libMainDir;
+        if (libConfig.libMainFile.startsWith(libsDirSrc)) {
+          libMainDir = libMainPath.dir || ".";
+        } else if (libMainPath.dir) {
+          libMainDir = path.join(libsDirSrc, libMainPath.dir);
+        } else {
+          libMainDir = path.join(libsDirSrc, folderName);
+        }
+        relinka(
+          "verbose",
+          `Processing library ${libName}: libMainDir=${libMainDir}, libMainFile=${libMainFile}`
+        );
+        const libTranspileMinify = libConfig?.libTranspileMinify === true;
+        await library_buildLibrary({
+          ...config,
+          effectivePubRegistry: libConfig.libPubRegistry || commonPubRegistry,
+          libName,
+          mainDir: libMainDir,
+          npm: {
+            npmOutDir,
+            distNpmBuilder,
+            coreEntrySrcDir
+          },
+          jsr: {
+            jsrOutDir,
+            distJsrBuilder,
+            distJsrOutFilesExt
+          },
+          libMainFile,
+          isDev,
+          libsList,
+          unifiedBundlerOutExt,
+          filterDepsPatterns,
+          transpileEsbuild,
+          transpileTarget,
+          transpileFormat,
+          transpileSplitting,
+          libTranspileMinify,
+          transpileSourcemap,
+          transpilePublicPath,
+          timer,
+          transpileStub,
+          transpileWatch
+        });
+      } catch (error) {
+        relinka(
+          "error",
+          `Failed to build library ${libName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw error;
+      }
+    };
+  });
+  try {
+    await pAll(tasks, {
+      concurrency: CONCURRENCY_DEFAULT
+    });
+    relinka("verbose", "Completed libraries_build");
+  } catch (error) {
+    if (timer) resumePerfTimer(timer);
+    throw error;
+  }
+}
+export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, commonPubPause, commonPubRegistry, distJsrAllowDirty, distJsrSlowTypes) {
+  relinka("verbose", "Starting libraries_publish");
+  if (!libsList || Object.keys(libsList).length === 0) {
+    relinka("verbose", "No lib configs found in config, skipping libs publish.");
+    return;
+  }
+  const libsEntries = Object.entries(libsList);
+  const tasks = libsEntries.map(([libName, libConfig]) => {
+    return async () => {
+      try {
+        const folderName = extractFolderName(libName, libConfig);
+        const libBaseDir = path.resolve(PROJECT_ROOT, libsDirDist, folderName);
+        const npmOutDir = path.join(libBaseDir, "npm");
+        const jsrOutDir = path.join(libBaseDir, "jsr");
+        if (!commonPubPause && !libConfig.libPubPause) {
+          const effectivePubRegistry = libConfig.libPubRegistry || commonPubRegistry;
+          await library_publishLibrary(
+            effectivePubRegistry,
+            libName,
+            npmOutDir,
+            jsrOutDir,
+            distJsrDryRun,
+            distJsrFailOnWarn,
+            distJsrAllowDirty,
+            distJsrSlowTypes,
+            isDev,
+            timer
+          );
+        } else if (libConfig.libPubPause && !commonPubPause) {
+          relinka("verbose", `Publishing is paused for lib ${libName} (libPubPause: true)`);
+        }
+      } catch (error) {
+        relinka(
+          "error",
+          `Failed to publish library ${libName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw error;
+      }
+    };
+  });
+  try {
+    await pAll(tasks, {
+      concurrency: CONCURRENCY_DEFAULT
+    });
+    relinka("verbose", "Completed libraries_publish");
+  } catch (error) {
+    if (timer) resumePerfTimer(timer);
+    throw error;
+  }
+}

package/bin/app/build/postbuild.d.ts

@@ -1,3 +1,3 @@
-import type { DlerConfig } from "../../libs/sdk/sdk-mod.js";
+import type { DlerConfig } from "../types/mod.js";
 export declare function dlerPostBuild(isDev: boolean, debugDontCopyNonBuildFiles?: boolean): Promise<void>;
 export declare function wrapper_CopyNonBuildFiles(config: DlerConfig): Promise<void>;