@reliverse/dler 1.7.91 → 1.7.93

package/bin/app/build/postbuild.js

@@ -3,11 +3,11 @@ import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { runCmd } from "@reliverse/rempts";
 import { glob } from "tinyglobby";
-import { getCheckCmd } from "../cmds.js";
-import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
-import { applyMagicSpells } from "../../libs/sdk/sdk-impl/magic/magic-apply.js";
-import { resolveAllCrossLibs } from "../../libs/sdk/sdk-impl/utils/resolve-cross-libs.js";
-import { PROJECT_ROOT } from "../../libs/sdk/sdk-impl/utils/utils-consts.js";
+import { getCheckCmd } from "@/app/cmds";
+import { PROJECT_ROOT } from "../config/constants.js";
+import { getConfigDler } from "../config/load.js";
+import { applyMagicSpells } from "../magic/magic-apply.js";
+import { resolveAllCrossLibs } from "../utils/resolve-cross-libs.js";
 import { directoryExists, executeDlerHooks } from "./ppb-utils.js";
 const ALIAS_TO_REPLACE = "~";
 export async function dlerPostBuild(isDev, debugDontCopyNonBuildFiles) {

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

@@ -1,2 +1,2 @@
-import type { DlerConfig } from "../../libs/sdk/sdk-impl/config/types.js";
+import type { DlerConfig } from "../types/mod.js";
 export declare function dlerPreBuild(config: DlerConfig): Promise<void>;

package/bin/app/build/prebuild.js

@@ -3,8 +3,8 @@ import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { runCmd } from "@reliverse/rempts";
 import { glob } from "tinyglobby";
-import { getCheckCmd } from "../cmds.js";
-import { PROJECT_ROOT } from "../../libs/sdk/sdk-impl/utils/utils-consts.js";
+import { getCheckCmd } from "@/app/cmds";
+import { PROJECT_ROOT } from "../config/constants.js";
 import { executeCommand, executeDlerHooks, isCommandAvailable } from "./ppb-utils.js";
 const createToolRunner = () => ({
   tsc: {

package/bin/app/build/providers/auto.d.ts

@@ -0,0 +1,3 @@
+import type { BuildPreset } from "../../types/mod.js";
+export declare function definePreset(preset: BuildPreset): BuildPreset;
+export declare const autoPreset: BuildPreset;

package/bin/app/build/providers/auto.js

@@ -0,0 +1,105 @@
+import { existsSync } from "node:fs";
+import { join, normalize, resolve } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { extractExportFilenames, listRecursively, warn } from "./utils.js";
+export function definePreset(preset) {
+  return preset;
+}
+export const autoPreset = definePreset(() => {
+  return {
+    hooks: {
+      "build:prepare"(ctx) {
+        if (!ctx.pkg || ctx.options.entries.length > 0) {
+          return;
+        }
+        const sourceFiles = listRecursively(join(ctx.options.rootDir, "src"));
+        const res = inferEntries(ctx.pkg, sourceFiles, ctx.options.isLib, ctx.options.rootDir);
+        for (const message of res.warnings) {
+          warn(ctx, message);
+        }
+        ctx.options.entries.push(...res.entries);
+        if (res.cjs) {
+          ctx.options.rollup.emitCJS = true;
+        }
+        if (ctx.options.declaration === void 0) {
+          ctx.options.declaration = res.dts ? "compatible" : false;
+        }
+        relinka(
+          "log",
+          "Automatically detected entries:",
+          ctx.options.entries.map((e) => e.input.replace(`${ctx.options.rootDir}/`, "").replace(/\/$/, "/*")).join(", "),
+          ["esm", res.cjs && "cjs", res.dts && "dts"].filter(Boolean).map((tag) => `[${tag}]`).join(" ")
+        );
+      }
+    }
+  };
+});
+const getEntrypointPaths = (path) => {
+  const segments = normalize(path).split("/");
+  return segments.map((_, index) => segments.slice(index).join("/")).filter(Boolean);
+};
+function inferEntries(pkg, sourceFiles, isLib, rootDir) {
+  const warnings = [];
+  sourceFiles.sort((a, b) => a.split("/").length - b.split("/").length);
+  const outputs = extractExportFilenames(pkg.exports);
+  if (pkg.bin) {
+    const binaries = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin);
+    for (const file of binaries) {
+      outputs.push({ file });
+    }
+  }
+  if (pkg.main) {
+    outputs.push({ file: pkg.main });
+  }
+  if (pkg.module) {
+    outputs.push({ file: pkg.module, type: "esm" });
+  }
+  if (pkg.types || pkg.typings) {
+    outputs.push({ file: pkg.types || pkg.typings });
+  }
+  const isESMPkg = pkg.type === "module";
+  for (const output of outputs.filter((o) => !o.type)) {
+    const isJS = output.file.endsWith(".js");
+    if (isESMPkg && isJS || output.file.endsWith(".mjs")) {
+      output.type = "esm";
+    } else if (!isESMPkg && isJS || output.file.endsWith(".cjs")) {
+      output.type = "cjs";
+    }
+  }
+  let cjs = false;
+  let dts = false;
+  const entries = [];
+  for (const output of outputs) {
+    const outputSlug = output.file.replace(/(\*[^/\\]*|\.d\.(m|c)?ts|\.\w+)$/, "");
+    const isDir = outputSlug.endsWith("/");
+    if (isDir && ["./", "/"].includes(outputSlug)) {
+      continue;
+    }
+    const possiblePaths = getEntrypointPaths(outputSlug);
+    const input = possiblePaths.reduce((source, d) => {
+      if (source) {
+        return source;
+      }
+      const SOURCE_RE = new RegExp(`(?<=/|$)${d}${isDir ? "" : String.raw`\.\w+`}$`);
+      return sourceFiles.find((i) => SOURCE_RE.test(i))?.replace(/(\.d\.(m|c)?ts|\.\w+)$/, "");
+    }, void 0);
+    if (!input) {
+      if (!existsSync(resolve(rootDir || ".", output.file))) {
+        warnings.push(`Could not find entrypoint for \`${output.file}\``);
+      }
+      continue;
+    }
+    if (output.type === "cjs") {
+      cjs = true;
+    }
+    const entry = entries.find((i) => i.input === input) || entries[entries.push({ input, isLib }) - 1];
+    if (/\.d\.(m|c)?ts$/.test(output.file)) {
+      dts = true;
+    }
+    if (isDir && entry) {
+      entry.outDir = outputSlug;
+      entry.format = output.type;
+    }
+  }
+  return { cjs, dts, entries, warnings };
+}

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

@@ -0,0 +1,8 @@
+import type { UnifiedBuildConfig } from "../../types/mod.js";
+export declare function unifiedBuild(inputSourceDir: string, coreIsCLI: {
+    enabled: boolean;
+    scripts: Record<string, string>;
+}, isLib: boolean, rootDir: string, inputConfig: UnifiedBuildConfig & {
+    config?: string;
+    showOutLog?: boolean;
+}, outDir: string, transpileStub?: boolean): Promise<void>;

package/bin/app/build/providers/build.js

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

package/bin/app/build/providers/bun/single-file.js

@@ -0,0 +1,146 @@
+import { join } from "@reliverse/pathkit";
+import { existsSync, mkdir, readdir, unlink } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+const TARGETS = [
+  { platform: "linux", arch: "x64", extension: "", target: "bun-linux-x64" },
+  { platform: "linux", arch: "x64-baseline", extension: "", target: "bun-linux-x64-baseline" },
+  { platform: "linux", arch: "x64-modern", extension: "", target: "bun-linux-x64-modern" },
+  { platform: "linux", arch: "arm64", extension: "", target: "bun-linux-arm64" },
+  { platform: "linux", arch: "x64-musl", extension: "", target: "bun-linux-x64-musl" },
+  { platform: "linux", arch: "arm64-musl", extension: "", target: "bun-linux-arm64-musl" },
+  { platform: "windows", arch: "x64", extension: ".exe", target: "bun-windows-x64" },
+  { platform: "windows", arch: "arm64", extension: ".exe", target: "bun-windows-arm64" },
+  {
+    platform: "windows",
+    arch: "x64-baseline",
+    extension: ".exe",
+    target: "bun-windows-x64-baseline"
+  },
+  { platform: "windows", arch: "x64-modern", extension: ".exe", target: "bun-windows-x64-modern" },
+  { platform: "darwin", arch: "x64", extension: "", target: "bun-darwin-x64" },
+  { platform: "darwin", arch: "arm64", extension: "", target: "bun-darwin-arm64" }
+];
+export const getOutputFileName = (target, baseName, isCompiled) => {
+  const suffix = `-${target.arch}`;
+  const extension = isCompiled ? target.extension : ".js";
+  return `${baseName}-${target.platform}${suffix}${extension}`;
+};
+export const buildForTarget = async (target, inputFile, options) => {
+  const outputFile = join(options.outdir, getOutputFileName(target, "dler", options.compile));
+  const buildArgs = [
+    "build",
+    ...options.compile ? ["--compile", `--target=${target.target}`] : [],
+    inputFile,
+    `--outfile=${outputFile}`
+  ];
+  if (options.minify) {
+    buildArgs.push("--minify");
+  }
+  if (options.sourcemap) {
+    buildArgs.push("--sourcemap");
+  }
+  if (options.bytecode) {
+    buildArgs.push("--bytecode");
+  }
+  if (options.assetNaming !== "[name]-[hash].[ext]") {
+    buildArgs.push(`--asset-naming=${options.assetNaming}`);
+  }
+  if (options.external && options.external.length > 0) {
+    for (const ext of options.external) {
+      buildArgs.push(`--external=${ext}`);
+    }
+  }
+  if (target.platform === "windows") {
+    if (options.windowsIcon && existsSync(options.windowsIcon)) {
+      buildArgs.push(`--windows-icon=${options.windowsIcon}`);
+    }
+    if (options.windowsHideConsole) {
+      buildArgs.push("--windows-hide-console");
+    }
+  }
+  relinka("info", `Building for ${target.platform}-${target.arch}...`);
+  try {
+    const proc = Bun.spawn(["bun", ...buildArgs], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      relinka("error", `Build failed for ${target.platform}-${target.arch}:`);
+      if (stderr) relinka("error", stderr);
+      if (stdout) relinka("error", stdout);
+      throw new Error(`Build failed with exit code ${exitCode}`);
+    }
+    relinka("success", `\u2705 Built: ${outputFile}`);
+    if (stdout.includes("bundle")) {
+      const bundleMatch = stdout.match(/bundle (\d+) modules/);
+      const compileMatch = stdout.match(/compile .* \[(\d+ms)\]/);
+      if (bundleMatch || compileMatch) {
+        const bundleInfo = bundleMatch ? `${bundleMatch[1]} modules` : "";
+        const compileInfo = compileMatch ? `${compileMatch[1]}` : "";
+        relinka("verbose", `  ${bundleInfo} ${compileInfo}`.trim());
+      }
+    }
+  } catch (error) {
+    relinka("error", `Failed to build for ${target.platform}-${target.arch}: ${error}`);
+    throw error;
+  }
+};
+export const cleanOutputDir = async (outdir) => {
+  if (existsSync(outdir)) {
+    relinka("info", `Cleaning dler-* files from output directory: ${outdir}`);
+    try {
+      const entries = await readdir(outdir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.startsWith("dler-")) {
+          const filePath = join(outdir, entry.name);
+          await unlink(filePath);
+          relinka("verbose", `Deleted: ${entry.name}`);
+        }
+      }
+    } catch (error) {
+      relinka("warn", `Failed to clean dler-* files: ${error}`);
+    }
+  } else {
+    await mkdir(outdir, { recursive: true });
+  }
+};
+export const validateInputFile = (inputFile) => {
+  if (!existsSync(inputFile)) {
+    throw new Error(`Input file not found: ${inputFile}`);
+  }
+};
+export const parseTargets = (targetStr) => {
+  if (targetStr === "all") {
+    return TARGETS;
+  }
+  const requestedTargets = targetStr.split(",").map((t) => t.trim());
+  const validTargets = [];
+  for (const requested of requestedTargets) {
+    const exactMatch = TARGETS.find(
+      (target) => target.target === requested || `${target.platform}-${target.arch}` === requested || target.platform === requested
+    );
+    if (exactMatch) {
+      validTargets.push(exactMatch);
+      continue;
+    }
+    const platformTargets = TARGETS.filter((t) => t.platform === requested);
+    if (platformTargets.length > 0) {
+      validTargets.push(...platformTargets);
+    } else {
+      relinka("warn", `Unknown target: ${requested}`);
+    }
+  }
+  return validTargets.length > 0 ? validTargets : [TARGETS[0]];
+};
+export const listAvailableTargets = () => {
+  relinka("info", "Available targets:");
+  for (const target of TARGETS) {
+    const name = `${target.platform}-${target.arch}`;
+    relinka("info", `  ${target.target.padEnd(25)} (${name})`);
+  }
+};

package/bin/app/build/providers/copy/copy-mod.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../../../types/mod.js";
+export declare function copyBuild(ctx: BuildContext): Promise<void>;