@reliverse/build 2.2.7

package/dist/mod.js

@@ -0,0 +1,1390 @@
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import {
+  getPackageBuildConfig,
+  mergeBuildOptions
+} from "@reliverse/config/impl/build";
+import {
+  findMonorepoRoot,
+  loadDlerConfig
+} from "@reliverse/config/impl/discovery";
+import { writeErrorLines } from "@reliverse/helpers";
+import pMap from "@reliverse/mapkit";
+import {
+  createIgnoreFilter,
+  createIncludeFilter,
+  normalizePatterns
+} from "@reliverse/matcha";
+import { relinka } from "@reliverse/relinka";
+import {
+  getWorkspacePatterns,
+  preparePackageJsonForPublishing,
+  readPackageJSON,
+  readTSConfig
+} from "@reliverse/typerso";
+import { processAssetsForPackage, processCSSForPackage } from "./impl/assets.js";
+import { BuildCache } from "./impl/cache.js";
+import {
+  ALWAYS_IGNORED_PACKAGES,
+  FRONTEND_FRAMEWORKS,
+  FRONTEND_HTML_PATTERNS,
+  GO_PROJECT_DIRS,
+  JS_ENTRY_PATTERNS,
+  LIBRARY_ENTRY_PATTERNS
+} from "./impl/constants.js";
+import { createDebugLogger } from "./impl/debug.js";
+import { startDevServer } from "./impl/dev-server.js";
+import { processHTMLForPackage } from "./impl/html-processor.js";
+import {
+  AssetOptimizationPlugin,
+  applyPlugins,
+  BundleAnalyzerPlugin,
+  CSSModulesPlugin,
+  loadPlugins,
+  PerformancePlugin,
+  pluginRegistry,
+  ReactRefreshPlugin,
+  SVGAsReactPlugin,
+  TypeScriptDeclarationsPlugin,
+  WorkerPlugin
+} from "./impl/plugins/index.js";
+import { validateTSConfig } from "./impl/tsconfig-validator.js";
+import { validateBuildConfig } from "./impl/type-guards.js";
+import {
+  handleGoBuild,
+  handleGoOnlyBuild
+} from "./impl/utils/go-build-handler.js";
+import {
+  extractErrors,
+  extractWarnings,
+  formatLogMessages
+} from "./impl/utils/log-extraction.js";
+import { filterPrivatePackages } from "./impl/utils/package-filtering.js";
+import { startWatchMode } from "./impl/watch.js";
+export {
+  addBinFieldToPackageJson,
+  extractPackageName,
+  parseBinArgument,
+  preparePackageJsonForPublishing,
+  transformExportsForBuild
+} from "@reliverse/typerso";
+export { generateDeclarations } from "./impl/dts-generator.js";
+export { buildGo } from "./impl/go-build.js";
+export { applyPresets } from "./impl/presets.js";
+export {
+  logValidationResults,
+  validateAllTSConfigs,
+  validateTSConfig
+} from "./impl/tsconfig-validator.js";
+export { validateAndExit } from "./impl/validation.js";
+import { DEFAULT_CONCURRENCY } from "./impl/constants.js";
+let pluginsInitialized = false;
+const initializePlugins = () => {
+  if (pluginsInitialized) return;
+  pluginRegistry.register(ReactRefreshPlugin);
+  pluginRegistry.register(TypeScriptDeclarationsPlugin);
+  pluginRegistry.register(AssetOptimizationPlugin);
+  pluginRegistry.register(BundleAnalyzerPlugin);
+  pluginRegistry.register(CSSModulesPlugin);
+  pluginRegistry.register(SVGAsReactPlugin);
+  pluginRegistry.register(WorkerPlugin);
+  pluginRegistry.register(PerformancePlugin);
+  pluginsInitialized = true;
+};
+const formatBytes = (bytes) => {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
+};
+const getWorkspacePackages = async (cwd) => {
+  const monorepoRoot = await findMonorepoRoot(cwd);
+  if (!monorepoRoot) {
+    const currentDir = cwd || process.cwd();
+    const pkgInfo = await resolvePackageInfo(currentDir, null);
+    if (pkgInfo) {
+      return [pkgInfo];
+    }
+    throw new Error(
+      "\u274C No monorepo or valid package found. Ensure package.json has 'workspaces' field or contains a valid 'name' field."
+    );
+  }
+  const rootPkg = await readPackageJSON(monorepoRoot);
+  if (!rootPkg) {
+    throw new Error("\u274C Could not read root package.json");
+  }
+  const patterns = getWorkspacePatterns(rootPkg);
+  if (!patterns.length) {
+    throw new Error("\u274C No workspace patterns found in package.json");
+  }
+  const dlerConfig = await loadDlerConfig(monorepoRoot);
+  const packages = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  const patternPromises = patterns.map(async (pattern) => {
+    let matches = [];
+    if (pattern.includes("*")) {
+      const glob = new Bun.Glob(pattern);
+      matches = Array.from(
+        glob.scanSync({ cwd: monorepoRoot, onlyFiles: false })
+      );
+    } else {
+      matches = [pattern];
+    }
+    const packagePromises = matches.map(async (match) => {
+      const packagePath = resolve(monorepoRoot, match);
+      if (seenPaths.has(packagePath)) return null;
+      seenPaths.add(packagePath);
+      return await resolvePackageInfo(packagePath, dlerConfig);
+    });
+    return await Promise.all(packagePromises);
+  });
+  const patternResults = await Promise.all(patternPromises);
+  for (const patternResult of patternResults) {
+    for (const pkgInfo of patternResult) {
+      if (pkgInfo) {
+        packages.push(pkgInfo);
+      }
+    }
+  }
+  const filteredPackages = packages.filter((pkg) => {
+    const normalizedPkgPath = resolve(pkg.path);
+    const normalizedRootPath = resolve(monorepoRoot);
+    return normalizedPkgPath !== normalizedRootPath;
+  });
+  return filteredPackages;
+};
+const packageJsonCache = /* @__PURE__ */ new Map();
+const entryPointCache = /* @__PURE__ */ new Map();
+const isBuildArtifact = (path) => {
+  return path.includes("/dist/") || path.includes("/build/") || path.includes("\\dist\\") || path.includes("\\build\\");
+};
+const detectEntryPoints = async (packagePath) => {
+  const cached = entryPointCache.get(packagePath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let pkg = packageJsonCache.get(packagePath);
+  if (!pkg) {
+    pkg = await readPackageJSON(packagePath);
+    if (pkg) {
+      packageJsonCache.set(packagePath, pkg);
+    }
+  }
+  if (!pkg) {
+    entryPointCache.set(packagePath, []);
+    return [];
+  }
+  const entryPoints = [];
+  if (pkg.build?.entrypoints) {
+    const entrypoints = Array.isArray(pkg.build.entrypoints) ? pkg.build.entrypoints : [pkg.build.entrypoints];
+    const result = entrypoints.map((ep) => resolve(packagePath, ep));
+    entryPointCache.set(packagePath, result);
+    return result;
+  }
+  if (pkg.exports) {
+    const extractFromExports = (exports, basePath = "") => {
+      if (typeof exports === "string") {
+        const fullPath = resolve(packagePath, basePath, exports);
+        if (existsSync(fullPath) && !isBuildArtifact(fullPath)) {
+          entryPoints.push(fullPath);
+        }
+      } else if (typeof exports === "object" && exports !== null) {
+        for (const [key, value] of Object.entries(exports)) {
+          if (key === "." || key.startsWith("./")) {
+            extractFromExports(value, basePath);
+          } else if (key === "import" || key === "require" || key === "types" || key === "default") {
+            if (key !== "types") {
+              extractFromExports(value, basePath);
+            }
+          } else if (typeof value === "object" && value !== null) {
+            extractFromExports(value, basePath);
+          } else if (typeof value === "string") {
+            const fullPath = resolve(packagePath, basePath, value);
+            if (existsSync(fullPath) && !isBuildArtifact(fullPath)) {
+              entryPoints.push(fullPath);
+            }
+          }
+        }
+      }
+    };
+    extractFromExports(pkg.exports);
+  }
+  const binEntries = await detectBinEntryPoints(packagePath, pkg);
+  if (binEntries.length > 0) {
+    entryPoints.push(...binEntries);
+  }
+  if (entryPoints.length > 0) {
+    const result = [...new Set(entryPoints)];
+    entryPointCache.set(packagePath, result);
+    return result;
+  }
+  for (const pattern of FRONTEND_HTML_PATTERNS) {
+    const fullPath = resolve(packagePath, pattern);
+    if (existsSync(fullPath)) {
+      const jsEntryPoints = await detectJSEntryPoints(packagePath);
+      const result = [fullPath, ...jsEntryPoints];
+      entryPointCache.set(packagePath, result);
+      return result;
+    }
+  }
+  for (const pattern of LIBRARY_ENTRY_PATTERNS) {
+    const fullPath = resolve(packagePath, pattern);
+    if (existsSync(fullPath)) {
+      entryPointCache.set(packagePath, [fullPath]);
+      return [fullPath];
+    }
+  }
+  entryPointCache.set(packagePath, []);
+  return [];
+};
+const detectJSEntryPoints = async (packagePath) => {
+  const entryPoints = [];
+  for (const pattern of JS_ENTRY_PATTERNS) {
+    const fullPath = resolve(packagePath, pattern);
+    if (existsSync(fullPath)) {
+      entryPoints.push(fullPath);
+    }
+  }
+  return entryPoints;
+};
+const detectBinEntryPoints = async (packagePath, pkg) => {
+  if (!pkg.bin) return [];
+  const binEntries = [];
+  const binField = pkg.bin;
+  const binPaths = typeof binField === "string" ? [binField] : Object.values(binField);
+  for (const binPath of binPaths) {
+    const sourcePath = binPath.replace(/^\.\/dist\//, "src/").replace(/^dist\//, "src/").replace(/\.js$/, ".ts");
+    const potentialPaths = [
+      sourcePath,
+      // Direct conversion
+      sourcePath.replace(/^src\//, ""),
+      // Remove src/ prefix
+      `src/${sourcePath}`
+      // Add src/ prefix
+    ];
+    for (const potential of new Set(potentialPaths)) {
+      const fullPath = resolve(packagePath, potential);
+      if (existsSync(fullPath)) {
+        binEntries.push(fullPath);
+        break;
+      }
+    }
+  }
+  return binEntries;
+};
+const detectFrontendApp = async (packagePath, pkg) => {
+  for (const pattern of FRONTEND_HTML_PATTERNS) {
+    const fullPath = resolve(packagePath, pattern);
+    if (existsSync(fullPath)) {
+      return true;
+    }
+  }
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies
+  };
+  for (const framework of FRONTEND_FRAMEWORKS) {
+    if (allDeps[framework]) {
+      return true;
+    }
+  }
+  const publicDir = resolve(packagePath, "public");
+  if (existsSync(publicDir) && statSync(publicDir).isDirectory()) {
+    return true;
+  }
+  return false;
+};
+const detectGoProject = async (packagePath) => {
+  const mainGoPath = resolve(packagePath, "main.go");
+  if (existsSync(mainGoPath)) {
+    return true;
+  }
+  const goModPath = resolve(packagePath, "go.mod");
+  if (!existsSync(goModPath)) {
+    return false;
+  }
+  try {
+    const entries = await readdir(packagePath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".go")) {
+        return true;
+      }
+      if (entry.isDirectory()) {
+        if (GO_PROJECT_DIRS.includes(
+          entry.name
+        )) {
+          const subPath = resolve(packagePath, entry.name);
+          try {
+            const subEntries = await readdir(subPath, { recursive: true });
+            if (subEntries.some((name) => name.endsWith(".go"))) {
+              return true;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+    return true;
+  }
+  return false;
+};
+const resolveOutputDir = async (packagePath) => {
+  try {
+    const tsconfig = await readTSConfig(packagePath);
+    if (tsconfig?.compilerOptions?.outDir) {
+      return resolve(packagePath, tsconfig.compilerOptions.outDir);
+    }
+  } catch {
+  }
+  return resolve(packagePath, "dist");
+};
+const resolvePackageInfo = async (packagePath, dlerConfig) => {
+  const pkgJsonPath = join(packagePath, "package.json");
+  if (!existsSync(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    let pkg = packageJsonCache.get(packagePath);
+    if (!pkg) {
+      pkg = await readPackageJSON(packagePath);
+      if (pkg) {
+        packageJsonCache.set(packagePath, pkg);
+      }
+    }
+    if (!pkg?.name) {
+      return null;
+    }
+    const hasTsConfig = existsSync(join(packagePath, "tsconfig.json"));
+    const entryPoints = await detectEntryPoints(packagePath);
+    const outputDir = await resolveOutputDir(packagePath);
+    const isFrontendApp = await detectFrontendApp(packagePath, pkg);
+    const hasHtmlEntry = entryPoints.some((ep) => ep.endsWith(".html"));
+    const hasPublicDir = existsSync(join(packagePath, "public")) && statSync(join(packagePath, "public")).isDirectory();
+    const hasGoFiles = await detectGoProject(packagePath);
+    const buildConfig = await getPackageBuildConfig(pkg.name, dlerConfig);
+    const isCLI = !!(pkg.bin && (typeof pkg.bin === "string" || typeof pkg.bin === "object" && Object.keys(pkg.bin).length > 0));
+    return {
+      name: pkg.name,
+      path: packagePath,
+      hasTsConfig,
+      entryPoints,
+      outputDir,
+      buildConfig,
+      isFrontendApp,
+      hasHtmlEntry,
+      hasPublicDir,
+      private: pkg.private === true,
+      isCLI,
+      hasGoFiles
+    };
+  } catch {
+    return null;
+  }
+};
+const filterPackages = (packages, ignore, allowPrivateBuild, filter) => {
+  if (filter) {
+    const includeFilter = createIncludeFilter(filter);
+    const filteredPackages2 = includeFilter(packages);
+    return filterPrivatePackages(filteredPackages2, allowPrivateBuild);
+  }
+  const combinedIgnore = ignore ? Array.isArray(ignore) ? [...ALWAYS_IGNORED_PACKAGES, ...ignore] : [...ALWAYS_IGNORED_PACKAGES, ignore] : ALWAYS_IGNORED_PACKAGES;
+  const ignoreFilter = createIgnoreFilter(combinedIgnore);
+  const filteredPackages = ignoreFilter(packages);
+  return filterPrivatePackages(filteredPackages, allowPrivateBuild);
+};
+const compileToExecutable = async (pkg, _outputs, options) => {
+  const entryPoint = pkg.entryPoints[0];
+  if (!entryPoint) {
+    await relinka.warn(`\u26A0\uFE0F  ${pkg.name}: No entry point found for compilation`);
+    return;
+  }
+  const executableName = entryPoint.split("/").pop()?.split("\\").pop()?.replace(/\.(ts|js|mjs|cjs)$/, "") || "app";
+  const executablePath = join(
+    pkg.outputDir,
+    executableName + (process.platform === "win32" ? ".exe" : "")
+  );
+  if (!existsSync(pkg.outputDir)) {
+    mkdirSync(pkg.outputDir, { recursive: true });
+  }
+  await relinka.info(
+    `\u{1F528} Compiling ${pkg.name} to executable: ${executablePath}`
+  );
+  try {
+    const buildConfig = {
+      entrypoints: [entryPoint],
+      outfile: executablePath,
+      compile: true,
+      target: options.target || "bun",
+      format: options.format || "cjs"
+    };
+    if (process.platform === "win32") {
+      if (options.windowsHideConsole)
+        buildConfig.windowsHideConsole = options.windowsHideConsole;
+      if (options.windowsIcon) buildConfig.windowsIcon = options.windowsIcon;
+      if (options.windowsTitle) buildConfig.windowsTitle = options.windowsTitle;
+      if (options.windowsPublisher)
+        buildConfig.windowsPublisher = options.windowsPublisher;
+      if (options.windowsVersion)
+        buildConfig.windowsVersion = options.windowsVersion;
+      if (options.windowsDescription)
+        buildConfig.windowsDescription = options.windowsDescription;
+      if (options.windowsCopyright)
+        buildConfig.windowsCopyright = options.windowsCopyright;
+    }
+    const { $ } = await import("bun");
+    try {
+      const cmd = $`bun build ${entryPoint} --outfile ${executablePath} --compile --target ${buildConfig.target || "bun"}`;
+      await cmd.cwd(pkg.path).quiet();
+    } catch (error) {
+      await relinka.error(`\u274C Bun CLI compilation failed: ${error}`);
+      throw error;
+    }
+    if (!existsSync(executablePath)) {
+      throw new Error(`Executable was not created at ${executablePath}`);
+    }
+    const stats = statSync(executablePath);
+    await relinka.success(
+      `\u2705 ${pkg.name}: Executable created (${formatBytes(stats.size)})`
+    );
+  } catch (error) {
+    await relinka.error(`\u274C ${pkg.name}: Compilation failed - ${error}`);
+    throw error;
+  }
+};
+const buildWithMkdist = async (pkg, options, _bunBuildConfig) => {
+  const startTime = Date.now();
+  try {
+    const { mkdist } = await import("./impl/providers/mkdist/make.js");
+    const mkdistOptions = {
+      srcDir: "src",
+      distDir: pkg.outputDir,
+      rootDir: pkg.path,
+      format: options.format === "cjs" ? "cjs" : "esm",
+      ext: options.format === "cjs" ? ".cjs" : ".js",
+      cleanDist: false,
+      addRelativeDeclarationExtensions: true,
+      declaration: true,
+      verbose: options.verbose,
+      typescript: {
+        compilerOptions: {
+          // Don't override emitDeclarationOnly here - let mkdist handle it
+          // mkdist will set it to true to generate declarations
+          allowJs: true,
+          skipLibCheck: true
+        }
+      }
+    };
+    const { result, duration } = await mkdist(mkdistOptions);
+    let bundleSize = 0;
+    const outputFiles = [];
+    for (const filePath of result.writtenFiles) {
+      try {
+        const stats = statSync(filePath);
+        bundleSize += stats.size;
+        outputFiles.push(filePath);
+      } catch {
+      }
+    }
+    const buildSuccess = result.errors.length === 0;
+    if (buildSuccess) {
+      try {
+        const prepResult = await preparePackageJsonForPublishing(pkg.path, {
+          kind: options.kind,
+          binDefinitions: options.bin,
+          access: "public",
+          addPublishConfig: true,
+          transformExports: options.replaceExports === true
+        });
+        if (!prepResult.success && options.verbose) {
+          await relinka.warn(
+            `\u26A0\uFE0F  ${pkg.name}: Failed to prepare package.json for publishing: ${prepResult.error}`
+          );
+        } else if (options.verbose) {
+          await relinka.info(
+            `\u{1F4E6} ${pkg.name}: Package.json prepared for publishing`
+          );
+        }
+      } catch (error) {
+        await relinka.warn(
+          `\u26A0\uFE0F  ${pkg.name}: Error preparing package.json for publishing: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      await handleGoBuild(pkg, options, options.verbose ?? false);
+    }
+    return {
+      package: pkg,
+      success: buildSuccess,
+      skipped: false,
+      output: `Built ${result.writtenFiles.length} files`,
+      errors: result.errors.map((e) => e.filename),
+      warnings: [],
+      buildTime: duration,
+      bundleSize
+    };
+  } catch (error) {
+    const buildTime = Date.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await relinka.error(
+      `\u274C ${pkg.name}: mkdist build failed - ${errorMessage}`
+    );
+    return {
+      package: pkg,
+      success: false,
+      skipped: false,
+      output: errorMessage,
+      errors: [errorMessage],
+      warnings: [],
+      buildTime,
+      bundleSize: 0
+    };
+  }
+};
+export const buildPackage = async (pkg, options = {}, cache) => {
+  const mergedOptions = mergeBuildOptions(options, pkg.buildConfig);
+  if (mergedOptions.goOnly) {
+    const startTime2 = Date.now();
+    if (!pkg.hasGoFiles) {
+      return {
+        package: pkg,
+        success: true,
+        skipped: true,
+        output: "Skipped (no Go files)",
+        errors: [],
+        warnings: [],
+        buildTime: Date.now() - startTime2,
+        bundleSize: 0
+      };
+    }
+    const goResult = await handleGoOnlyBuild(pkg, mergedOptions);
+    return {
+      package: pkg,
+      success: goResult.success,
+      skipped: false,
+      output: goResult.success ? "Go binaries built successfully" : `Go build failed: ${goResult.errors.join(", ")}`,
+      errors: goResult.errors,
+      warnings: [],
+      buildTime: Date.now() - startTime2,
+      bundleSize: 0
+    };
+  }
+  const debugLogger = createDebugLogger(mergedOptions);
+  debugLogger.start();
+  const {
+    verbose = false,
+    bundler,
+    target = "node",
+    format = "esm",
+    minify = false,
+    sourcemap = "none",
+    splitting = true,
+    external,
+    bytecode = false,
+    drop,
+    packages = "bundle",
+    publicPath,
+    root,
+    define,
+    naming,
+    env = "disable",
+    banner,
+    footer,
+    conditions,
+    loader,
+    ignoreDCEAnnotations = false,
+    emitDCEAnnotations = true,
+    throw: throwOnError = false,
+    jsx,
+    keepNames = false,
+    // Frontend-specific options
+    assets,
+    cssChunking,
+    // Enhanced features
+    macros = false,
+    sideEffects,
+    bundleAnalyzer = false,
+    typeCheck = false,
+    generateTypes = true,
+    // bundleSizeLimit, // Used in performance monitoring
+    performanceBudget,
+    imageOptimization = false,
+    fontOptimization = false,
+    cssOptimization = false,
+    svgAsReact = false,
+    cssModules = false,
+    workerSupport = false,
+    plugins = [],
+    performanceMonitoring = false,
+    bundleAnalysis = false,
+    // TSConfig validation
+    validateTsconfig = true,
+    strictTsconfig = false
+  } = mergedOptions;
+  const isFrontendApp = pkg.isFrontendApp || pkg.hasHtmlEntry;
+  const shouldUseCssChunking = cssChunking !== false && (cssChunking === true || isFrontendApp);
+  const effectiveBundler = bundler || (pkg.buildConfig?.kind === "browser-app" || pkg.buildConfig?.kind === "native-app" ? "bun" : "mkdist");
+  const frontendTarget = isFrontendApp && !mergedOptions.compile ? "browser" : target;
+  const frontendFormat = isFrontendApp && !mergedOptions.compile ? "esm" : format;
+  const frontendSplitting = isFrontendApp && !mergedOptions.compile ? true : splitting;
+  initializePlugins();
+  const activePlugins = [];
+  if (mergedOptions.reactFastRefresh || isFrontendApp && !mergedOptions.production) {
+    activePlugins.push(ReactRefreshPlugin);
+  }
+  if (generateTypes || typeCheck || typeof pkg.buildConfig?.dts === "object" && pkg.buildConfig.dts?.enable) {
+    activePlugins.push(TypeScriptDeclarationsPlugin);
+  }
+  if (imageOptimization || fontOptimization || cssOptimization) {
+    activePlugins.push(AssetOptimizationPlugin);
+  }
+  if (bundleAnalyzer || bundleAnalysis) {
+    activePlugins.push(BundleAnalyzerPlugin);
+  }
+  if (cssModules) {
+    activePlugins.push(CSSModulesPlugin);
+  }
+  if (svgAsReact) {
+    activePlugins.push(SVGAsReactPlugin);
+  }
+  if (workerSupport) {
+    activePlugins.push(WorkerPlugin);
+  }
+  if (performanceMonitoring || performanceBudget) {
+    activePlugins.push(PerformancePlugin);
+  }
+  if (plugins.length > 0) {
+    const customPlugins = loadPlugins(plugins);
+    activePlugins.push(...customPlugins);
+  }
+  const validTarget = frontendTarget;
+  const validFormat = frontendFormat === "cjs" || frontendFormat === "iife" ? frontendFormat : "esm";
+  let validSourcemap = sourcemap;
+  if (typeof sourcemap === "boolean") {
+    validSourcemap = sourcemap ? "inline" : "none";
+  } else if (sourcemap === "linked" || sourcemap === "inline" || sourcemap === "external") {
+    validSourcemap = sourcemap;
+  } else {
+    validSourcemap = "none";
+  }
+  if (pkg.entryPoints.length === 0) {
+    if (verbose) {
+      await relinka.info(`\u23ED\uFE0F  Skipping ${pkg.name} (no entry points found)`);
+    }
+    return {
+      package: pkg,
+      success: true,
+      skipped: true,
+      output: "",
+      errors: [],
+      warnings: [],
+      buildTime: 0
+    };
+  }
+  if (validateTsconfig) {
+    try {
+      const validationResult = await validateTSConfig(pkg, {
+        strict: strictTsconfig,
+        checkDeclarations: generateTypes || typeCheck,
+        checkBuildOutput: true
+      });
+      if (!validationResult.valid) {
+        if (strictTsconfig) {
+          return {
+            package: pkg,
+            success: false,
+            skipped: false,
+            output: `TSConfig validation failed: ${validationResult.errors.join(", ")}`,
+            errors: validationResult.errors,
+            warnings: validationResult.warnings,
+            buildTime: 0
+          };
+        } else {
+          for (const warning of validationResult.warnings) {
+            await relinka.warn(`\u26A0\uFE0F  ${pkg.name}: ${warning}`);
+          }
+          for (const error of validationResult.errors) {
+            await relinka.warn(`\u26A0\uFE0F  ${pkg.name}: ${error}`);
+          }
+        }
+      } else if (validationResult.warnings.length > 0 && verbose) {
+        for (const warning of validationResult.warnings) {
+          await relinka.warn(`\u26A0\uFE0F  ${pkg.name}: ${warning}`);
+        }
+      }
+    } catch (error) {
+      if (strictTsconfig) {
+        return {
+          package: pkg,
+          success: false,
+          skipped: false,
+          output: `TSConfig validation error: ${error instanceof Error ? error.message : String(error)}`,
+          errors: [error instanceof Error ? error.message : String(error)],
+          warnings: [],
+          buildTime: 0
+        };
+      } else {
+        await relinka.warn(
+          `\u26A0\uFE0F  ${pkg.name}: TSConfig validation failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  if (cache) {
+    const cacheEntry = await cache.get(pkg, mergedOptions);
+    if (cacheEntry) {
+      if (verbose) {
+        await relinka.info(
+          `\u26A1 ${pkg.name}: Using cache (${cacheEntry.buildTime}ms, ${formatBytes(cacheEntry.bundleSize)})`
+        );
+      }
+      return {
+        package: pkg,
+        success: true,
+        skipped: false,
+        output: "",
+        errors: [],
+        warnings: [],
+        buildTime: cacheEntry.buildTime,
+        bundleSize: cacheEntry.bundleSize,
+        cacheHit: true
+      };
+    }
+  }
+  if (verbose) {
+    await relinka.info(`\u{1F528} Building ${pkg.name}...`);
+  }
+  debugLogger.logConfigResolution(pkg, pkg.buildConfig ? "dler" : "default");
+  debugLogger.logBuildOptions(mergedOptions, pkg);
+  debugLogger.logEntryPoints(pkg);
+  const startTime = Date.now();
+  try {
+    const validation = validateBuildConfig(mergedOptions);
+    if (!validation.valid) {
+      await relinka.warn(
+        `\u26A0\uFE0F  ${pkg.name}: Invalid build options - ${validation.errors.join(", ")}`
+      );
+    }
+    const buildConfig = {
+      entrypoints: pkg.entryPoints,
+      outdir: pkg.outputDir,
+      target: validTarget,
+      format: validFormat,
+      sourcemap: validSourcemap,
+      splitting: frontendSplitting,
+      verbose
+    };
+    if (pkg.name === "@reliverse/native-app-example") {
+      await relinka.info(
+        `\u{1F50D} Debug: target=${validTarget}, format=${validFormat}, bytecode=${bytecode}`
+      );
+    }
+    applyPlugins(activePlugins, buildConfig);
+    if (jsx) {
+      buildConfig.jsx = jsx;
+    }
+    if (keepNames) {
+      buildConfig.keepNames = keepNames;
+    }
+    if (isFrontendApp) {
+      buildConfig.loader = {
+        ...loader,
+        ".png": "file",
+        ".jpg": "file",
+        ".jpeg": "file",
+        ".gif": "file",
+        ".svg": "file",
+        ".webp": "file",
+        ".ico": "file",
+        ".woff": "file",
+        ".woff2": "file",
+        ".ttf": "file",
+        ".eot": "file",
+        ".css": "css",
+        ...loader
+      };
+    }
+    if (typeof minify === "boolean") {
+      buildConfig.minify = minify;
+    } else if (typeof minify === "object" && minify !== null) {
+      const validMinify = {};
+      if (minify.whitespace !== void 0)
+        validMinify.whitespace = minify.whitespace;
+      if (minify.syntax !== void 0) validMinify.syntax = minify.syntax;
+      if (minify.identifiers !== void 0)
+        validMinify.identifiers = minify.identifiers;
+      buildConfig.minify = validMinify;
+    }
+    if (external) {
+      const externalArray = Array.isArray(external) ? external : [external];
+      if (!externalArray.includes("node-fetch-native")) {
+        externalArray.push("node-fetch-native");
+      }
+      buildConfig.external = externalArray;
+    } else {
+      buildConfig.external = ["node-fetch-native"];
+    }
+    if (bytecode) {
+      buildConfig.bytecode = bytecode;
+    }
+    if (drop) {
+      buildConfig.drop = Array.isArray(drop) ? drop : [drop];
+    }
+    if (packages) {
+      buildConfig.packages = packages;
+    }
+    if (publicPath) {
+      buildConfig.publicPath = publicPath;
+    }
+    if (root) {
+      buildConfig.root = root;
+    }
+    if (define) {
+      buildConfig.define = define;
+    }
+    if (naming) {
+      buildConfig.naming = naming;
+    }
+    if (env) {
+      buildConfig.env = env;
+    }
+    if (banner) {
+      buildConfig.banner = banner;
+    }
+    if (footer) {
+      buildConfig.footer = footer;
+    }
+    if (conditions) {
+      buildConfig.conditions = Array.isArray(conditions) ? conditions : [conditions];
+    }
+    if (loader) {
+      buildConfig.loader = loader;
+    }
+    if (ignoreDCEAnnotations !== void 0) {
+      buildConfig.ignoreDCEAnnotations = ignoreDCEAnnotations;
+    }
+    if (emitDCEAnnotations !== void 0) {
+      buildConfig.emitDCEAnnotations = emitDCEAnnotations;
+    }
+    if (throwOnError !== void 0) {
+      buildConfig.throw = throwOnError;
+    }
+    if (mergedOptions.noBundle) {
+      buildConfig.noBundle = true;
+    }
+    if (mergedOptions.reactFastRefresh) {
+      buildConfig.reactFastRefresh = true;
+    }
+    if (mergedOptions.noClearScreen) {
+      buildConfig.noClearScreen = true;
+    }
+    if (mergedOptions.windowsHideConsole) {
+      buildConfig.windowsHideConsole = true;
+    }
+    if (mergedOptions.windowsIcon) {
+      buildConfig.windowsIcon = mergedOptions.windowsIcon;
+    }
+    if (mergedOptions.windowsTitle) {
+      buildConfig.windowsTitle = mergedOptions.windowsTitle;
+    }
+    if (mergedOptions.windowsPublisher) {
+      buildConfig.windowsPublisher = mergedOptions.windowsPublisher;
+    }
+    if (mergedOptions.windowsVersion) {
+      buildConfig.windowsVersion = mergedOptions.windowsVersion;
+    }
+    if (mergedOptions.windowsDescription) {
+      buildConfig.windowsDescription = mergedOptions.windowsDescription;
+    }
+    if (mergedOptions.windowsCopyright) {
+      buildConfig.windowsCopyright = mergedOptions.windowsCopyright;
+    }
+    if (mergedOptions.app) {
+      buildConfig.app = true;
+    }
+    if (mergedOptions.serverComponents) {
+      buildConfig.serverComponents = true;
+    }
+    if (mergedOptions.debugDumpServerFiles) {
+      buildConfig.debugDumpServerFiles = true;
+    }
+    if (mergedOptions.debugNoMinify) {
+      buildConfig.debugNoMinify = true;
+    }
+    if (macros) {
+      buildConfig.macros = true;
+    }
+    if (sideEffects !== void 0) {
+      buildConfig.sideEffects = sideEffects;
+    }
+    if (pkg.name === "@reliverse/native-app-example") {
+      await relinka.info(
+        `\u{1F50D} Final build config: ${JSON.stringify(buildConfig, null, 2)}`
+      );
+    }
+    if (effectiveBundler === "mkdist") {
+      return await buildWithMkdist(pkg, mergedOptions, buildConfig);
+    }
+    const result = await Bun.build(buildConfig);
+    const buildTime = Date.now() - startTime;
+    let bundleSize = 0;
+    const outputFiles = [];
+    if (result.outputs) {
+      for (const output of result.outputs) {
+        if (output.path) {
+          try {
+            const stats = statSync(output.path);
+            bundleSize += stats.size;
+            outputFiles.push(output.path);
+          } catch {
+          }
+        }
+      }
+    }
+    if (!result.success) {
+      const errors = extractErrors(result.logs);
+      const warnings = extractWarnings(result.logs);
+      if (verbose) {
+        await relinka.error(`\u274C ${pkg.name}: Build failed (${buildTime}ms)`);
+        for (const error of errors) {
+          await relinka.error(`   ${error}`);
+        }
+        if (warnings.length > 0) {
+          await relinka.warn(`   Warnings:`);
+          for (const warning of warnings) {
+            await relinka.warn(`   ${warning}`);
+          }
+        }
+      }
+      return {
+        package: pkg,
+        success: false,
+        skipped: false,
+        output: formatLogMessages(result.logs),
+        errors,
+        warnings,
+        buildTime,
+        bundleSize
+      };
+    }
+    if (result.success) {
+      await handleGoBuild(pkg, mergedOptions, verbose);
+    } else if (verbose && pkg.hasGoFiles) {
+      await relinka.info(
+        `\u23ED\uFE0F  ${pkg.name}: Skipping Go build (TypeScript build failed)`
+      );
+    }
+    if (isFrontendApp) {
+      try {
+        await processAssetsForPackage(pkg, pkg.outputDir, assets);
+        await processCSSForPackage(pkg, pkg.outputDir, shouldUseCssChunking);
+        await processHTMLForPackage(pkg, pkg.outputDir, {
+          minify: typeof minify === "boolean" ? minify : minify?.whitespace ?? false,
+          injectAssets: true,
+          publicPath: publicPath || "/"
+        });
+      } catch (error) {
+        await relinka.warn(
+          `\u26A0\uFE0F  ${pkg.name}: Asset processing failed - ${error}`
+        );
+      }
+    }
+    for (const plugin of activePlugins) {
+      if (plugin.onBuildEnd) {
+        try {
+          await plugin.onBuildEnd(
+            {
+              package: pkg,
+              success: true,
+              skipped: false,
+              output: formatLogMessages(result.logs),
+              errors: [],
+              warnings: extractWarnings(result.logs),
+              buildTime,
+              bundleSize
+            },
+            mergedOptions
+          );
+        } catch (error) {
+          await relinka.warn(
+            `\u26A0\uFE0F  ${pkg.name}: Plugin ${plugin.name} onBuildEnd failed - ${error}`
+          );
+        }
+      }
+    }
+    if (cache) {
+      await cache.set(pkg, mergedOptions, {
+        buildTime,
+        bundleSize,
+        outputFiles
+      });
+    }
+    if (mergedOptions.compile && result.success && result.outputs) {
+      await compileToExecutable(pkg, result.outputs, mergedOptions);
+    }
+    if (result.success) {
+      try {
+        const prepResult = await preparePackageJsonForPublishing(pkg.path, {
+          kind: mergedOptions.kind,
+          binDefinitions: mergedOptions.bin,
+          access: "public",
+          addPublishConfig: true,
+          transformExports: mergedOptions.replaceExports === true
+        });
+        if (!prepResult.success) {
+          await relinka.warn(
+            `\u26A0\uFE0F  ${pkg.name}: Failed to prepare package.json for publishing: ${prepResult.error}`
+          );
+        } else if (verbose) {
+          await relinka.info(
+            `\u{1F4E6} ${pkg.name}: Package.json prepared for publishing`
+          );
+        }
+      } catch (error) {
+        await relinka.warn(
+          `\u26A0\uFE0F  ${pkg.name}: Error preparing package.json for publishing: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (verbose) {
+      await relinka.success(
+        `\u2705 ${pkg.name}: Built successfully (${buildTime}ms, ${formatBytes(bundleSize)})`
+      );
+    }
+    return {
+      package: pkg,
+      success: true,
+      skipped: false,
+      output: formatLogMessages(result.logs),
+      errors: [],
+      warnings: extractWarnings(result.logs),
+      buildTime,
+      bundleSize
+    };
+  } catch (error) {
+    const buildTime = Date.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await relinka.error(`\u274C ${pkg.name}: Build failed - ${errorMessage}`);
+    return {
+      package: pkg,
+      success: false,
+      skipped: false,
+      output: errorMessage,
+      errors: [errorMessage],
+      warnings: [],
+      buildTime,
+      bundleSize: 0
+    };
+  }
+};
+const collectAllResults = async (packages, options = {}, cache) => {
+  const {
+    concurrency = DEFAULT_CONCURRENCY,
+    stopOnError = false,
+    verbose = false,
+    watch = false
+  } = options;
+  if (watch) {
+    await startWatchMode(packages, options);
+    return new Promise(() => {
+    });
+  }
+  if (!verbose) {
+    await relinka.info(`Building ${packages.length} packages...`);
+  }
+  try {
+    const buildResults = await pMap(
+      packages,
+      async (pkg, index) => {
+        if (!verbose) {
+          await relinka.info(
+            `Building ${pkg.name} (${index + 1}/${packages.length})...`
+          );
+        }
+        return buildPackage(pkg, options, cache);
+      },
+      {
+        concurrency,
+        stopOnError
+      }
+    );
+    const failedPackages = buildResults.filter(
+      (r) => !r.success && !r.skipped
+    ).length;
+    const successfulPackages = buildResults.filter((r) => r.success).length;
+    const skippedPackages = buildResults.filter((r) => r.skipped).length;
+    const totalBuildTime = buildResults.reduce(
+      (sum, r) => sum + r.buildTime,
+      0
+    );
+    const totalBundleSize = buildResults.reduce(
+      (sum, r) => sum + (r.bundleSize || 0),
+      0
+    );
+    const cacheHits = buildResults.filter((r) => r.cacheHit).length;
+    return {
+      totalPackages: packages.length,
+      failedPackages,
+      successfulPackages,
+      skippedPackages,
+      hasErrors: failedPackages > 0,
+      results: buildResults,
+      totalBuildTime,
+      totalBundleSize,
+      cacheHits
+    };
+  } catch (error) {
+    if (error instanceof AggregateError) {
+      const buildResults = error.errors.map((err, index) => {
+        const pkg = packages[index];
+        if (!pkg) {
+          throw new Error(`Package at index ${index} not found`);
+        }
+        if (verbose) {
+          void relinka.error(
+            `\u274C ${pkg.name}: Aggregate error - ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        return {
+          package: pkg,
+          success: false,
+          skipped: false,
+          output: err instanceof Error ? err.message : String(err),
+          errors: [err instanceof Error ? err.message : String(err)],
+          warnings: [],
+          buildTime: 0
+        };
+      });
+      const failedPackages = buildResults.filter(
+        (r) => !r.success && !r.skipped
+      ).length;
+      const successfulPackages = buildResults.filter((r) => r.success).length;
+      const skippedPackages = buildResults.filter((r) => r.skipped).length;
+      const totalBuildTime = buildResults.reduce(
+        (sum, r) => sum + r.buildTime,
+        0
+      );
+      const totalBundleSize = buildResults.reduce(
+        (sum, r) => sum + (r.bundleSize || 0),
+        0
+      );
+      const cacheHits = buildResults.filter((r) => r.cacheHit).length;
+      return {
+        totalPackages: packages.length,
+        failedPackages,
+        successfulPackages,
+        skippedPackages,
+        hasErrors: failedPackages > 0,
+        results: buildResults,
+        totalBuildTime,
+        totalBundleSize,
+        cacheHits
+      };
+    }
+    throw error;
+  }
+};
+const formatOutput = async (summary, verbose) => {
+  const {
+    totalPackages,
+    failedPackages,
+    successfulPackages,
+    skippedPackages,
+    totalBuildTime,
+    totalBundleSize,
+    cacheHits
+  } = summary;
+  await relinka.log("\u2501".repeat(60));
+  await relinka.log(`\u{1F4E6} Build Summary:`);
+  await relinka.log(`   Total packages: ${totalPackages}`);
+  await relinka.log(`   \u2705 Built: ${successfulPackages}`);
+  await relinka.log(`   \u274C Failed: ${failedPackages}`);
+  await relinka.log(`   \u23ED\uFE0F  Skipped: ${skippedPackages}`);
+  if (cacheHits > 0) {
+    await relinka.log(`   \u26A1 Cache hits: ${cacheHits}`);
+  }
+  await relinka.log(`   \u23F1\uFE0F  Total time: ${totalBuildTime}ms`);
+  await relinka.log(`   \u{1F4E6} Total size: ${formatBytes(totalBundleSize)}`);
+  await relinka.log("\u2501".repeat(60));
+  const failed = summary.results.filter((r) => !r.success && !r.skipped);
+  if (failed.length > 0) {
+    await relinka.error("\n\u274C Failed Packages:\n");
+    for (const result of failed) {
+      await relinka.error(`\u{1F4E6} ${result.package.name} (${result.buildTime}ms)`);
+      await relinka.error(
+        `   Entry points: ${result.package.entryPoints.join(", ")}`
+      );
+      await relinka.error(`   Output dir: ${result.package.outputDir}`);
+      if (result.errors.length > 0) {
+        await relinka.error("   \u2500".repeat(30));
+        const errorLines = result.errors.map((error) => `   ${error}`);
+        writeErrorLines(errorLines);
+        await relinka.error("");
+      }
+    }
+  }
+  if (verbose) {
+    const successful = summary.results.filter((r) => r.success && !r.skipped);
+    if (successful.length > 0) {
+      await relinka.success("\n\u2705 Successful Packages:\n");
+      for (const result of successful) {
+        const sizeInfo = result.bundleSize ? `, ${formatBytes(result.bundleSize)}` : "";
+        const cacheInfo = result.cacheHit ? " (cached)" : "";
+        await relinka.success(
+          `   \u2022 ${result.package.name} (${result.buildTime}ms${sizeInfo})${cacheInfo}`
+        );
+        if (result.warnings.length > 0) {
+          await relinka.log(`     Warnings: ${result.warnings.length}`);
+        }
+      }
+    }
+    const skipped = summary.results.filter((r) => r.skipped);
+    if (skipped.length > 0) {
+      await relinka.info("\n\u23ED\uFE0F  Skipped Packages (no entry points):\n");
+      for (const result of skipped) {
+        await relinka.info(`   \u2022 ${result.package.name}`);
+      }
+    }
+    await relinka.log("");
+  }
+};
+export const runBuildOnAllPackages = async (ignore, cwd, options = {}) => {
+  const {
+    verbose = false,
+    watch = false,
+    cache: enableCache = true,
+    noCache = false,
+    devServer = false,
+    port = 3e3,
+    open = false,
+    allowPrivateBuild,
+    filter
+  } = options;
+  const cache = enableCache && !noCache ? new BuildCache() : void 0;
+  if (verbose) {
+    await relinka.info("\u{1F50D} Discovering workspace packages...");
+  }
+  const result = await (async () => {
+    const allPackages = await getWorkspacePackages(cwd);
+    if (verbose) {
+      await relinka.info(`   Found ${allPackages.length} packages`);
+      const dlerConfig = await loadDlerConfig(cwd);
+      if (dlerConfig?.build) {
+        await relinka.info("   \u{1F4CB} Using dler.ts configuration");
+        if (dlerConfig.build.global) {
+          await relinka.info("     Global config: \u2705");
+        }
+        if (dlerConfig.build.packages) {
+          await relinka.info(
+            `     Package configs: ${Object.keys(dlerConfig.build.packages).length}`
+          );
+        }
+        if (dlerConfig.build.patterns) {
+          await relinka.info(
+            `     Pattern configs: ${dlerConfig.build.patterns.length}`
+          );
+        }
+      } else {
+        await relinka.info(
+          "   \u2699\uFE0F  No dler.ts found, using default configuration"
+        );
+      }
+      await relinka.info("   Packages found:");
+      for (const pkg of allPackages) {
+        const entryStatus = pkg.entryPoints.length > 0 ? "\u2705" : "\u23ED\uFE0F";
+        const configSource = pkg.buildConfig ? "\u{1F4CB}" : "\u2699\uFE0F";
+        const frontendStatus = pkg.isFrontendApp ? "\u{1F310}" : "\u{1F4E6}";
+        const htmlStatus = pkg.hasHtmlEntry ? "\u{1F4C4}" : "";
+        const cliStatus = pkg.isCLI ? "\u26A1" : "";
+        await relinka.info(
+          `     ${entryStatus} ${configSource} ${frontendStatus}${htmlStatus}${cliStatus} ${pkg.name} (${pkg.entryPoints.length} entry points)`
+        );
+        if (pkg.entryPoints.length > 0) {
+          await relinka.info(
+            `       Entry points: ${pkg.entryPoints.join(", ")}`
+          );
+          await relinka.info(`       Output dir: ${pkg.outputDir}`);
+          if (pkg.isFrontendApp) {
+            await relinka.info(`       Type: Frontend app`);
+            if (pkg.hasHtmlEntry) await relinka.info(`       HTML entry: \u2705`);
+            if (pkg.hasPublicDir) await relinka.info(`       Public dir: \u2705`);
+          } else if (pkg.isCLI) {
+            await relinka.info(
+              `       Type: CLI${pkg.entryPoints.length > 1 ? " (with library exports)" : ""}`
+            );
+          } else {
+            await relinka.info(`       Type: Library`);
+          }
+          if (pkg.buildConfig) {
+            await relinka.info(
+              `       Build config: ${JSON.stringify(pkg.buildConfig, null, 2).split("\n").map((line) => `         ${line}`).join("\n")}`
+            );
+          }
+        }
+      }
+      await relinka.info("");
+    }
+    const packages = filterPackages(
+      allPackages,
+      ignore,
+      allowPrivateBuild,
+      filter
+    );
+    const filteredCount = allPackages.length - packages.length;
+    if (filter) {
+      const patterns = normalizePatterns(filter);
+      await relinka.info(
+        `   Filtering to ${packages.length} packages matching: ${patterns.join(", ")}`
+      );
+    } else if (filteredCount > 0) {
+      const combinedIgnore = ignore ? Array.isArray(ignore) ? [...ALWAYS_IGNORED_PACKAGES, ...ignore] : [...ALWAYS_IGNORED_PACKAGES, ignore] : ALWAYS_IGNORED_PACKAGES;
+      const patterns = normalizePatterns(combinedIgnore);
+      await relinka.info(
+        `   Ignoring ${filteredCount} packages matching: ${patterns.join(", ")}`
+      );
+    }
+    const { concurrency = DEFAULT_CONCURRENCY, stopOnError = false } = options;
+    await relinka.info(
+      `   Building ${packages.length} packages (concurrency: ${concurrency}, stopOnError: ${stopOnError})...
+`
+    );
+    if (watch || devServer) {
+      if (devServer) {
+        const frontendPackages = packages.filter(
+          (pkg) => pkg.isFrontendApp || pkg.hasHtmlEntry
+        );
+        if (frontendPackages.length === 0) {
+          await relinka.warn("\u26A0\uFE0F  No frontend packages found for dev server");
+          await relinka.info(
+            "   Dev server works best with packages that have HTML entry points"
+          );
+        }
+        await relinka.info(
+          `\u{1F680} Starting dev server for ${frontendPackages.length} frontend packages...`
+        );
+        try {
+          await startDevServer(frontendPackages, options, {
+            port,
+            open,
+            hmr: true
+          });
+          return new Promise(() => {
+          });
+        } catch (error) {
+          await relinka.error(`\u274C Failed to start dev server: ${error}`);
+          throw error;
+        }
+      }
+      return collectAllResults(packages, options);
+    }
+    if (verbose) {
+      await relinka.info("\u{1F680} Starting build process...\n");
+    }
+    const summary = await collectAllResults(packages, options, cache);
+    await formatOutput(summary, verbose);
+    return summary;
+  })();
+  return result;
+};