@actiondock/builder 2.0.11 → 2.2.0

package/src/archive.ts

@@ -1,248 +0,0 @@
-import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { deflateRawSync, gzipSync } from "node:zlib";
-import { basename, dirname, join, relative, sep } from "node:path";
-
-/**
- * 纯 Node 实现的归档压缩模块。
- *
- * zip 与 tar.gz 均在进程内完成打包，不依赖宿主机的 zip / tar 命令行工具
- * （Windows 与最小化 Linux 环境普遍缺少 zip 命令）。
- * 压缩能力复用 node:zlib 内置的 deflateRaw（zip 条目）与 gzip（tar.gz 容器）。
- */
-
-/** 目录内相对路径条目（目录在前、同级按名称排序，保证归档内容顺序稳定） */
-interface ArchiveEntry {
-  /** 相对根目录的 POSIX 风格路径（目录以 / 结尾仅出现在 zip 条目名层面） */
-  relPath: string;
-  /** 是否为目录 */
-  isDir: boolean;
-}
-
-/** 递归收集目录内全部条目 */
-function collectEntries(dir: string, baseDir = dir): ArchiveEntry[] {
-  const entries: ArchiveEntry[] = [];
-  for (const name of readdirSync(dir).sort()) {
-    const fullPath = join(dir, name);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      entries.push({ relPath: relative(baseDir, fullPath).split(sep).join("/"), isDir: true });
-      entries.push(...collectEntries(fullPath, baseDir));
-    } else if (stat.isFile()) {
-      entries.push({ relPath: relative(baseDir, fullPath).split(sep).join("/"), isDir: false });
-    }
-  }
-  return entries;
-}
-
-/* ------------------------------------------------------------------ */
-/* zip 格式写入                                                        */
-/* ------------------------------------------------------------------ */
-
-/** CRC32 查表（IEEE 802.3 多项式） */
-const CRC32_TABLE: Uint32Array = (() => {
-  const table = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) {
-      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    }
-    table[n] = c >>> 0;
-  }
-  return table;
-})();
-
-function crc32(buf: Buffer): number {
-  let crc = 0xffffffff;
-  for (let i = 0; i < buf.length; i++) {
-    crc = CRC32_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}
-
-/** Unix 毫秒时间戳转 DOS 时间格式（date/time 各 16 位） */
-function dosDateTime(ms: number): { date: number; time: number } {
-  const d = new Date(ms);
-  const year = Math.max(d.getFullYear(), 1980);
-  const time = (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1);
-  const date = ((year - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
-  return { date, time };
-}
-
-/** central directory 记录（写入 EOCD 前聚合） */
-interface ZipCentralRecord {
-  header: Buffer;
-  localOffset: number;
-}
-
-/**
- * 将目录打包为标准 zip 归档（PKZIP APPNOTE 结构）。
- *
- * @param dir 待打包目录（目录名即归档内根文件夹名）
- * @param outPath 输出 zip 文件路径
- */
-export function createZipArchive(dir: string, outPath: string): void {
-  const rootName = basename(dir);
-  const entries = collectEntries(dir);
-  const chunks: Buffer[] = [];
-  const centralRecords: ZipCentralRecord[] = [];
-  let offset = 0;
-
-  for (const entry of entries) {
-    // 归档内路径带根目录前缀；目录条目名以 / 结尾
-    const name = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
-    const nameBuf = Buffer.from(name, "utf8");
-    const stat = statSync(join(dir, entry.relPath));
-    const { date, time } = dosDateTime(stat.mtimeMs);
-    const content = entry.isDir ? Buffer.alloc(0) : readFileSync(join(dir, entry.relPath));
-
-    let method = 0;
-    let payload = content;
-    if (!entry.isDir && content.length > 0) {
-      const deflated = deflateRawSync(content, { level: 9 });
-      if (deflated.length < content.length) {
-        method = 8;
-        payload = deflated;
-      }
-    }
-
-    const crc = crc32(content);
-
-    // Local File Header（30 字节 + 文件名）
-    const local = Buffer.alloc(30);
-    local.writeUInt32LE(0x04034b50, 0);
-    local.writeUInt16LE(20, 4);
-    local.writeUInt16LE(0x0800, 6); // UTF-8 文件名标志
-    local.writeUInt16LE(method, 8);
-    local.writeUInt16LE(time, 10);
-    local.writeUInt16LE(date, 12);
-    local.writeUInt32LE(crc, 14);
-    local.writeUInt32LE(payload.length, 18);
-    local.writeUInt32LE(content.length, 22);
-    local.writeUInt16LE(nameBuf.length, 26);
-    local.writeUInt16LE(0, 28);
-    chunks.push(local, nameBuf, payload);
-
-    // Central Directory Header（46 字节 + 文件名）
-    const central = Buffer.alloc(46);
-    central.writeUInt32LE(0x02014b50, 0);
-    central.writeUInt16LE(20, 4); // version made by
-    central.writeUInt16LE(20, 6); // version needed
-    central.writeUInt16LE(0x0800, 8);
-    central.writeUInt16LE(method, 10);
-    central.writeUInt16LE(time, 12);
-    central.writeUInt16LE(date, 14);
-    central.writeUInt32LE(crc, 16);
-    central.writeUInt32LE(payload.length, 20);
-    central.writeUInt32LE(content.length, 24);
-    central.writeUInt16LE(nameBuf.length, 28);
-    central.writeUInt16LE(0, 30); // extra len
-    central.writeUInt16LE(0, 32); // comment len
-    central.writeUInt16LE(0, 34); // disk start
-    central.writeUInt16LE(0, 36); // internal attrs
-    // 外部属性：Unix 权限左移 16 位，目录附加 MS-DOS 目录位
-    const extAttrs = ((entry.isDir ? 0o40755 : 0o100644) << 16) | (entry.isDir ? 0x10 : 0);
-    central.writeUInt32LE(extAttrs >>> 0, 38);
-    central.writeUInt32LE(offset, 42);
-    centralRecords.push({ header: Buffer.concat([central, nameBuf]), localOffset: offset });
-
-    offset += local.length + nameBuf.length + payload.length;
-  }
-
-  const centralDirOffset = offset;
-  let centralDirSize = 0;
-  for (const record of centralRecords) {
-    chunks.push(record.header);
-    centralDirSize += record.header.length;
-  }
-
-  // End of Central Directory Record（22 字节）
-  const eocd = Buffer.alloc(22);
-  eocd.writeUInt32LE(0x06054b50, 0);
-  eocd.writeUInt16LE(0, 4);
-  eocd.writeUInt16LE(0, 6);
-  eocd.writeUInt16LE(centralRecords.length, 8);
-  eocd.writeUInt16LE(centralRecords.length, 10);
-  eocd.writeUInt32LE(centralDirSize, 12);
-  eocd.writeUInt32LE(centralDirOffset, 16);
-  eocd.writeUInt16LE(0, 20); // comment len
-  chunks.push(eocd);
-
-  writeFileSync(outPath, Buffer.concat(chunks));
-}
-
-/* ------------------------------------------------------------------ */
-/* tar.gz 格式写入                                                     */
-/* ------------------------------------------------------------------ */
-
-/**
- * 构造单个条目的 USTAR 头块（512 字节）。
- * 路径超长时按 USTAR prefix 字段拆分，仍放不下则抛错。
- */
-function tarHeader(path: string, size: number, mtimeSec: number, isDir: boolean): Buffer {
-  let name = path;
-  let prefix = "";
-  if (Buffer.byteLength(name, "utf8") > 100) {
-    const split = name.lastIndexOf("/");
-    if (split <= 0 || split > 155 || name.length - split - 1 > 100) {
-      throw new Error(`归档路径超出 USTAR 字段容量: ${path}`);
-    }
-    prefix = name.slice(0, split);
-    name = name.slice(split + 1);
-  }
-
-  const buf = Buffer.alloc(512);
-  buf.write(name, 0, 100, "utf8");
-  buf.write(isDir ? "0000755" : "0000644", 100, 8, "ascii"); // mode
-  buf.write("0000000", 108, 8, "ascii"); // uid
-  buf.write("0000000", 116, 8, "ascii"); // gid
-  buf.write(size.toString(8).padStart(11, "0"), 124, 12, "ascii"); // size
-  buf.write(Math.floor(mtimeSec).toString(8).padStart(11, "0"), 136, 12, "ascii"); // mtime
-  buf.fill(" ", 148, 156); // chksum 占位（计算时视为空格）
-  buf.write(isDir ? "5" : "0", 156, 1, "ascii"); // typeflag
-  buf.write("ustar\0", 257, 6, "ascii"); // magic
-  buf.write("00", 263, 2, "ascii"); // version
-  if (prefix) buf.write(prefix, 345, 155, "utf8");
-
-  // 校验和：整块字节的无符号累加和，写作 6 位八进制 + NUL + 空格
-  let sum = 0;
-  for (let i = 0; i < 512; i++) sum += buf[i];
-  buf.write(sum.toString(8).padStart(6, "0"), 148, 7, "ascii");
-  buf.write("\0", 154, 1, "ascii");
-  buf.write(" ", 155, 1, "ascii");
-  return buf;
-}
-
-/** 将字节数补齐到 512 的整数倍 */
-function pad512(length: number): Buffer {
-  const rem = length % 512;
-  return rem === 0 ? Buffer.alloc(0) : Buffer.alloc(512 - rem);
-}
-
-/**
- * 将目录打包为标准 tar.gz 归档（USTAR + gzip）。
- *
- * @param dir 待打包目录（目录名即归档内根文件夹名）
- * @param outPath 输出 tar.gz 文件路径
- */
-export function createTarGzArchive(dir: string, outPath: string): void {
-  const rootName = basename(dir);
-  const entries = collectEntries(dir);
-  const chunks: Buffer[] = [];
-
-  for (const entry of entries) {
-    const path = `${rootName}/${entry.relPath}`;
-    const fullPath = join(dir, entry.relPath);
-    const stat = statSync(fullPath);
-    const content = entry.isDir ? Buffer.alloc(0) : readFileSync(fullPath);
-
-    chunks.push(tarHeader(path, content.length, Math.floor(stat.mtimeMs / 1000), entry.isDir));
-    if (!entry.isDir) {
-      chunks.push(content, pad512(content.length));
-    }
-  }
-
-  // 归档结尾：两个全零块
-  chunks.push(Buffer.alloc(1024));
-
-  writeFileSync(outPath, gzipSync(Buffer.concat(chunks), { level: 9 }));
-}

package/src/build.ts

@@ -1,106 +0,0 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { generateStandaloneEntrypoint, getPackageSlug } from "@actiondock/core";
-import { BunCompiler } from "./compiler";
-import { BuilderError } from "./errors";
-import { BuildPlanner } from "./planner";
-
-/**
- * 独立二进制可执行文件构建选项。
- */
-export interface BuildOptions {
-  /** 目标项目根目录 */
-  projectRoot: string;
-  /** 目标架构（如 "bun-linux-x64", "bun-darwin-arm64", "bun-windows-x64" 等） */
-  target?: string;
-  /** 输出可执行文件的目标路径（默认输出到 dist/ 目录） */
-  outfile?: string;
-  /** 是否开启代码压缩混淆（默认 true） */
-  minify?: boolean;
-  /** 是否编译为 V8/JavaScriptCore 字节码（默认 true） */
-  bytecode?: boolean;
-  /** 显式挑选打包的 Action ID 清单（用于按需子集打包） */
-  actions?: string[];
-}
-
-/**
- * 独立二进制构建完成后的元数据结果对象。
- */
-export interface BuildResult {
-  /** 所属 Package ID */
-  packageId: string;
-  /** 打包的项目版本号 */
-  version: string;
-  /** 编译的目标平台架构 */
-  target: string;
-  /** 生成的独立二进制可执行文件绝对路径 */
-  executablePath: string;
-  /** 生成的 sidecar 元数据 JSON 文件绝对路径 */
-  metadataPath: string;
-  /** 打包内置的 Action ID 列表 */
-  actions: string[];
-}
-
-/**
- * 调用 Bun 原生编译引擎（Bun.build --compile）将 Action Package 打包为零外部依赖的独立二进制可执行文件。
- *
- * @param options 构建参数
- * @returns 构建产物结果元数据
- */
-export async function buildProject(options: BuildOptions): Promise<BuildResult> {
-  const root = resolve(options.projectRoot);
-  const plan = BuildPlanner.plan({
-    projectRoot: root,
-    actions: options.actions,
-  });
-
-  if (plan.actions.length === 0) {
-    throw new BuilderError("No actions resolved for standalone compilation");
-  }
-
-  const buildDir = join(root, ".actiondock", ".build");
-  mkdirSync(buildDir, { recursive: true });
-
-  const entryCode = generateStandaloneEntrypoint(
-    plan.packageId,
-    plan.version,
-    plan.description,
-    plan.actions.map((a) => ({ id: a.id, filePath: a.resolvedPath })),
-    plan.configDefs
-  );
-
-  const entryFileName = `entry-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.ts`;
-  const entryPath = join(buildDir, entryFileName);
-  writeFileSync(entryPath, entryCode, "utf-8");
-
-  const binaryName = getPackageSlug(plan.packageId);
-  const defaultOutfile = join(root, "dist", binaryName);
-  const outfile = resolve(options.outfile || defaultOutfile);
-
-  try {
-    const result = await BunCompiler.compile({
-      entrypoint: entryPath,
-      outfile,
-      target: options.target,
-      minify: options.minify,
-      bytecode: options.bytecode,
-      cwd: root,
-      packageId: plan.packageId,
-      version: plan.version,
-      actions: plan.actions.map((a) => a.id),
-    });
-
-    return {
-      packageId: result.packageId || plan.packageId,
-      version: result.version || plan.version,
-      target: result.target,
-      executablePath: result.executablePath,
-      metadataPath: result.metadataPath || "",
-      actions: plan.actions.map((a) => a.id),
-    };
-  } finally {
-    if (existsSync(entryPath)) {
-      rmSync(entryPath, { force: true });
-    }
-  }
-}

package/src/compiler.ts

@@ -1,303 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, resolve } from "node:path";
-import { CompilerError, CompilerValidationError } from "./errors";
-import type { BunCompilerOptions, BunCompilerResult } from "./types";
-
-/**
- * 官方支持的 Bun 独立二进制编译目标列表。
- */
-const SUPPORTED_TARGETS = new Set<string>([
-  "bun",
-  "host",
-  "bun-linux-x64",
-  "linux-x64",
-  "bun-linux-arm64",
-  "linux-arm64",
-  "bun-darwin-x64",
-  "darwin-x64",
-  "bun-darwin-arm64",
-  "darwin-arm64",
-  "bun-windows-x64",
-  "windows-x64",
-  "bun-linux-x64-baseline",
-  "linux-x64-baseline",
-  "bun-linux-x64-modern",
-  "linux-x64-modern",
-]);
-
-/**
- * 校验目标架构并规范化。
- */
-function normalizeAndValidateTarget(target?: string): string {
-  if (!target || target === "host" || target === "bun") {
-    return "bun";
-  }
-
-  const cleanTarget = target.trim();
-  if (!SUPPORTED_TARGETS.has(cleanTarget)) {
-    throw new CompilerValidationError(
-      `Unsupported compilation target: '${target}'. Standalone compilation only supports Bun targets (e.g. linux-x64, linux-arm64, darwin-x64, darwin-arm64, windows-x64).`,
-      { code: "UNSUPPORTED_TARGET", target }
-    );
-  }
-
-  return cleanTarget.startsWith("bun-") ? cleanTarget : `bun-${cleanTarget}`;
-}
-
-/**
- * 规范化编译器错误输出。
- */
-function normalizeCompilerError(rawStderr: string, rawStdout: string, exitCode: number, target?: string): CompilerError {
-  const combined = `${rawStderr}\n${rawStdout}`.trim();
-  const lines = combined
-    .split(/\r?\n/)
-    .map((l) => l.trim())
-    .filter((l) => l.length > 0);
-
-  let code = "COMPILATION_FAILED";
-  if (combined.includes("Unsupported target")) {
-    code = "UNSUPPORTED_TARGET";
-  } else if (
-    combined.includes("Cannot find package") ||
-    combined.includes("Cannot find module") ||
-    combined.includes("Could not resolve")
-  ) {
-    code = "MODULE_NOT_FOUND";
-  } else if (
-    combined.includes("SyntaxError") ||
-    combined.includes("Parse error") ||
-    combined.includes("Expected") ||
-    combined.includes("Unexpected")
-  ) {
-    code = "SYNTAX_ERROR";
-  } else if (combined.includes("EACCES") || combined.includes("Permission denied")) {
-    code = "PERMISSION_DENIED";
-  } else if (combined.includes("ENOSPC") || combined.includes("no space left")) {
-    code = "NO_SPACE";
-  }
-
-  const summaryLine = lines.find((l) => l.startsWith("error:")) || lines[0] || "Bun compilation failed";
-
-  return new CompilerError(
-    `Bun compilation failed with exit code ${exitCode} (${code}): ${summaryLine}`,
-    {
-      code,
-      exitCode,
-      rawError: combined,
-      details: lines,
-      target,
-    }
-  );
-}
-
-/**
- * Bun 独立二进制编译器。
- * 封装 bun build --compile 调用，提前校验选项组合，收集构建产物与元数据。
- */
-export class BunCompiler {
-  /**
-   * 执行独立二进制编译。
-   * 
-   * @param options 编译参数
-   * @returns 编译产物元数据结果
-   */
-  public async compile(options: BunCompilerOptions): Promise<BunCompilerResult> {
-    const startTime = Date.now();
-
-    // 1. 入口点存在性校验
-    if (!options.entrypoint) {
-      throw new CompilerValidationError("Entrypoint must be specified for standalone compilation", {
-        code: "INVALID_ENTRYPOINT",
-      });
-    }
-
-    const resolvedEntry = resolve(options.entrypoint);
-    if (!existsSync(resolvedEntry)) {
-      throw new CompilerValidationError(
-        `Entrypoint file not found: ${options.entrypoint}`,
-        { code: "ENTRYPOINT_NOT_FOUND" }
-      );
-    }
-
-    // 2. 输出路径校验
-    if (!options.outfile) {
-      throw new CompilerValidationError("Outfile path must be specified for standalone compilation", {
-        code: "INVALID_OUTFILE",
-      });
-    }
-
-    const resolvedOutfile = resolve(options.outfile);
-    const outDir = dirname(resolvedOutfile);
-    mkdirSync(outDir, { recursive: true });
-
-    // 3. 目标平台与选项校验
-    const normalizedTarget = normalizeAndValidateTarget(options.target);
-    const isWindowsTarget =
-      normalizedTarget.includes("windows") ||
-      (!options.target && process.platform === "win32");
-
-    // 校验布尔选项
-    if (options.minify !== undefined && typeof options.minify !== "boolean") {
-      throw new CompilerValidationError("Option 'minify' must be a boolean", {
-        code: "INVALID_MINIFY_OPTION",
-      });
-    }
-    if (options.bytecode !== undefined && typeof options.bytecode !== "boolean") {
-      throw new CompilerValidationError("Option 'bytecode' must be a boolean", {
-        code: "INVALID_BYTECODE_OPTION",
-      });
-    }
-
-    // 4. 组装 Bun build 命令参数
-    const args = [
-      "bun",
-      "build",
-      resolvedEntry,
-      "--compile",
-      "--outfile",
-      resolvedOutfile,
-    ];
-
-    const bytecode = options.bytecode !== false;
-    if (bytecode) {
-      args.push("--bytecode");
-    }
-
-    const minify = options.minify !== false;
-    if (minify) {
-      args.push("--minify");
-    }
-
-    if (normalizedTarget !== "bun") {
-      args.push(`--target=${normalizedTarget}`);
-    }
-
-    // 5. 执行外部编译器进程
-    const cwd = options.cwd ? resolve(options.cwd) : dirname(resolvedEntry);
-    const proc = spawnSync(args[0], args.slice(1), {
-      cwd,
-      stdio: "pipe",
-      env: {
-        ...process.env,
-        ...options.env,
-      },
-    });
-
-    if (proc.error) {
-      if ((proc.error as any).code === "ENOENT") {
-        throw new CompilerError(
-          "Bun binary not found in PATH. Standalone compilation requires Bun to be installed (e.g. via 'curl -fsSL https://bun.sh/install | bash' or 'npm install -g bun').",
-          {
-            code: "BUN_NOT_FOUND",
-            exitCode: 1,
-            rawError: proc.error.message,
-            target: options.target,
-          }
-        );
-      }
-      throw new CompilerError(`Failed to spawn Bun compiler: ${proc.error.message}`, {
-        code: "SPAWN_FAILED",
-        exitCode: 1,
-        rawError: proc.error.message,
-        target: options.target,
-      });
-    }
-
-    if (proc.status !== 0) {
-      const rawStderr = proc.stderr?.toString("utf-8") || "";
-      const rawStdout = proc.stdout?.toString("utf-8") || "";
-      throw normalizeCompilerError(rawStderr, rawStdout, proc.status ?? 1, options.target);
-    }
-
-    // 6. 解析生成的可执行二进制物理路径（适配 Windows .exe 后缀特性）
-    let actualExecutablePath = resolvedOutfile;
-    if (!existsSync(actualExecutablePath) && isWindowsTarget) {
-      const withExe = `${resolvedOutfile}.exe`;
-      if (existsSync(withExe)) {
-        actualExecutablePath = withExe;
-      }
-    }
-
-    if (!existsSync(actualExecutablePath)) {
-      throw new CompilerError(
-        `Compiler completed with exit code 0 but output executable not found at ${resolvedOutfile}`,
-        {
-          code: "OUTPUT_NOT_FOUND",
-          exitCode: 0,
-          rawError: "Output executable file not found on disk",
-          target: options.target,
-        }
-      );
-    }
-
-    // 7. 计算二进制大小与校验和
-    const binaryBuffer = readFileSync(actualExecutablePath);
-    const sizeBytes = statSync(actualExecutablePath).size;
-    const sha256 = createHash("sha256").update(binaryBuffer).digest("hex");
-    const durationMs = Date.now() - startTime;
-    const compiledAt = new Date().toISOString();
-
-    // 8. 写入 metadata 产物文件
-    let metadataPath: string | undefined;
-    if (options.emitMetadata !== false) {
-      metadataPath = resolve(outDir, "artifact.json");
-      const bunVersion =
-        (typeof (globalThis as any).Bun !== "undefined" && (globalThis as any).Bun.version) ||
-        (() => {
-          try {
-            const vProc = spawnSync("bun", ["--version"], { stdio: "pipe" });
-            if (vProc.status === 0) {
-              return vProc.stdout.toString().trim();
-            }
-          } catch {}
-          return "unknown";
-        })();
-
-      const metadata = {
-        packageId: options.packageId,
-        version: options.version,
-        target: options.target || "host",
-        executable: basename(actualExecutablePath),
-        sizeBytes,
-        sha256,
-        bunVersion,
-        minify,
-        bytecode,
-        actions: options.actions || [],
-        compiledAt,
-      };
-      writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + "\n", "utf-8");
-    }
-
-    return {
-      packageId: options.packageId,
-      version: options.version,
-      target: options.target || "host",
-      executablePath: actualExecutablePath,
-      sizeBytes,
-      sha256,
-      metadataPath,
-      minify,
-      bytecode,
-      durationMs,
-      compiledAt,
-    };
-  }
-
-  /**
-   * 静态辅助调用方法。
-   */
-  public static async compile(options: BunCompilerOptions): Promise<BunCompilerResult> {
-    const compiler = new BunCompiler();
-    return compiler.compile(options);
-  }
-}
-
-/**
- * 快捷独立二进制编译函数。
- */
-export async function compileBinary(options: BunCompilerOptions): Promise<BunCompilerResult> {
-  return BunCompiler.compile(options);
-}