@reliverse/dler 1.7.153 → 2.0.1

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

@@ -1,105 +0,0 @@
-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/impl/build/providers/build.d.ts

@@ -1,8 +0,0 @@
-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/impl/build/providers/build.js

@@ -1,351 +0,0 @@
-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("verbose", "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("verbose", "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("verbose", "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("verbose", "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("verbose", "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("verbose", "No build tasks to execute");
-  } else {
-    if (options.parallel) {
-      relinka("verbose", `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("verbose", `Running ${name}...`);
-        await task(ctx);
-      }
-    }
-  }
-  if (options.transpileStub || options.transpileWatch) {
-    await ctx.hooks.callHook("build:done", ctx);
-    return;
-  }
-  relinka("verbose", "Finalizing build output...");
-  relinka("verbose", `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("verbose", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
-    relinka(
-      "verbose",
-      `\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("verbose", `Build complete (with ${ctx.warnings.size} warnings)`);
-  }
-}

package/bin/impl/build/providers/bun/single-file.d.ts

@@ -1,25 +0,0 @@
-interface BuildTarget {
-    platform: string;
-    arch: string;
-    extension: string;
-    target: string;
-}
-export interface BunBuildOptions {
-    minify: boolean;
-    sourcemap: boolean;
-    bytecode: boolean;
-    outdir: string;
-    clean: boolean;
-    windowsIcon?: string;
-    windowsHideConsole: boolean;
-    assetNaming: string;
-    external?: string[];
-    compile: boolean;
-}
-export declare const getOutputFileName: (target: BuildTarget, baseName: string, isCompiled: boolean) => string;
-export declare const buildForTarget: (target: BuildTarget, inputFile: string, options: BunBuildOptions) => Promise<void>;
-export declare const cleanOutputDir: (outdir: string) => Promise<void>;
-export declare const validateInputFile: (inputFile: string) => void;
-export declare const parseTargets: (targetStr: string) => BuildTarget[];
-export declare const listAvailableTargets: () => void;
-export {};

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

@@ -1,146 +0,0 @@
-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/impl/build/providers/copy/copy-mod.d.ts

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