@actiondock/builder 2.0.12 → 2.2.1

package/dist/index.js

@@ -1,1875 +1,21 @@
-// packages/builder/src/errors.ts
-class BuilderError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BuilderError";
-  }
-}
-
-class PlannerError extends BuilderError {
-  code;
-  constructor(message, code = "PLANNER_ERROR") {
-    super(message);
-    this.name = "PlannerError";
-    this.code = code;
-  }
-}
-
-class CompilerValidationError extends BuilderError {
-  code;
-  target;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "CompilerValidationError";
-    this.code = options.code || "COMPILER_VALIDATION_ERROR";
-    this.target = options.target;
-  }
-}
-
-class CompilerError extends BuilderError {
-  code;
-  exitCode;
-  rawError;
-  details;
-  target;
-  constructor(message, options) {
-    super(message);
-    this.name = "CompilerError";
-    this.code = options.code;
-    this.exitCode = options.exitCode;
-    this.rawError = options.rawError;
-    this.details = options.details || [];
-    this.target = options.target;
-  }
-}
-// packages/builder/src/build.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join2, resolve as resolve3 } from "node:path";
-import { generateStandaloneEntrypoint, getPackageSlug } from "@actiondock/core";
-
-// packages/builder/src/compiler.ts
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { createReadStream, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, resolve } from "node:path";
-async function execCommandAsync(command, args, options) {
-  return new Promise((res) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: options.env
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout?.on("data", (chunk) => stdoutChunks.push(Buffer.from(chunk)));
-    child.stderr?.on("data", (chunk) => stderrChunks.push(Buffer.from(chunk)));
-    child.on("error", (err) => {
-      res({
-        status: null,
-        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-        error: err
-      });
-    });
-    child.on("close", (code) => {
-      res({
-        status: code,
-        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-        stderr: Buffer.concat(stderrChunks).toString("utf-8")
-      });
-    });
-  });
-}
-async function computeFileSha256(filePath) {
-  return new Promise((res, rej) => {
-    const hash = createHash("sha256");
-    const stream = createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => res(hash.digest("hex")));
-    stream.on("error", rej);
-  });
-}
-async function getBunVersion() {
-  if (typeof globalThis.Bun !== "undefined" && globalThis.Bun.version) {
-    return globalThis.Bun.version;
-  }
-  try {
-    const res = await execCommandAsync("bun", ["--version"], { cwd: process.cwd(), env: process.env });
-    if (res.status === 0) {
-      return res.stdout.trim();
-    }
-  } catch {}
-  return "unknown";
-}
-var SUPPORTED_TARGETS = new Set([
-  "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) {
-  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, rawStdout, exitCode, target) {
-  const combined = `${rawStderr}
-${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
-  });
-}
-
-class BunCompiler {
-  async compile(options) {
-    const startTime = Date.now();
-    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" });
-    }
-    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 });
-    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"
-      });
-    }
-    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}`);
-    }
-    const cwd = options.cwd ? resolve(options.cwd) : dirname(resolvedEntry);
-    const proc = await execCommandAsync(args[0], args.slice(1), {
-      cwd,
-      env: {
-        ...process.env,
-        ...options.env
-      }
-    });
-    if (proc.error) {
-      if (proc.error.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) {
-      throw normalizeCompilerError(proc.stderr, proc.stdout, proc.status ?? 1, options.target);
-    }
-    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
-      });
-    }
-    const sizeBytes = statSync(actualExecutablePath).size;
-    const sha256 = await computeFileSha256(actualExecutablePath);
-    const durationMs = Date.now() - startTime;
-    const compiledAt = new Date().toISOString();
-    let metadataPath;
-    if (options.emitMetadata !== false) {
-      const targetSlug = (options.target || "host").replace(/[^a-zA-Z0-9_-]/g, "-");
-      const targetMetadataPath = resolve(outDir, `artifact.${targetSlug}.json`);
-      metadataPath = resolve(outDir, "artifact.json");
-      const bunVersion = await getBunVersion();
-      const metadata = {
-        packageId: options.packageId,
-        version: options.version,
-        target: options.target || "host",
-        executable: basename(actualExecutablePath),
-        sizeBytes,
-        sha256,
-        bunVersion,
-        minify,
-        bytecode,
-        actions: options.actions || [],
-        compiledAt
-      };
-      const metadataContent = JSON.stringify(metadata, null, 2) + `
-`;
-      writeFileSync(targetMetadataPath, metadataContent, "utf-8");
-      writeFileSync(metadataPath, metadataContent, "utf-8");
-      metadataPath = targetMetadataPath;
-    }
-    return {
-      packageId: options.packageId,
-      version: options.version,
-      target: options.target || "host",
-      executablePath: actualExecutablePath,
-      sizeBytes,
-      sha256,
-      metadataPath,
-      minify,
-      bytecode,
-      durationMs,
-      compiledAt
-    };
-  }
-  static async compile(options) {
-    const compiler = new BunCompiler;
-    return compiler.compile(options);
-  }
-}
-async function compileBinary(options) {
-  return BunCompiler.compile(options);
-}
-
-// packages/builder/src/planner.ts
-import { existsSync as existsSync2, readdirSync, readFileSync, realpathSync, statSync as statSync2 } from "node:fs";
-import { basename as basename2, dirname as dirname2, isAbsolute, join, relative, resolve as resolve2 } from "node:path";
-import ts from "typescript";
-import YAML from "yaml";
-import {
-  assertPathWithinRoot,
-  loadManifest,
-  loadProjectConfig,
-  resolveActionProjectSync,
-  validateManifest
-} from "@actiondock/core";
-function walkDirectory(dir, rootDir = dir, visited = new Set) {
-  if (!existsSync2(dir))
-    return [];
-  const results = [];
-  const entries = readdirSync(dir);
-  for (const entry of entries) {
-    const fullPath = join(dir, entry);
-    if (rootDir) {
-      try {
-        assertPathWithinRoot(rootDir, fullPath, "planner path");
-      } catch {
-        continue;
-      }
-    }
-    let real;
-    try {
-      real = existsSync2(fullPath) ? realpathSync(fullPath) : fullPath;
-    } catch {
-      continue;
-    }
-    if (rootDir) {
-      try {
-        assertPathWithinRoot(rootDir, real, "planner path");
-      } catch {
-        continue;
-      }
-    }
-    if (visited.has(real)) {
-      continue;
-    }
-    visited.add(real);
-    try {
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
-        results.push(...walkDirectory(fullPath, rootDir, visited));
-      } else if (stat.isFile()) {
-        results.push(fullPath);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return results;
-}
-function isIgnoredModulePath(relPath) {
-  const normalized = relPath.replace(/\\/g, "/");
-  return normalized.startsWith("node_modules/") || normalized.includes("/node_modules/") || normalized.startsWith(".git/") || normalized.startsWith("dist/") || normalized.startsWith(".actiondock/") || normalized.endsWith(".test.ts") || normalized.endsWith(".test.js") || normalized.endsWith(".test.tsx") || normalized.endsWith(".test.jsx") || normalized.endsWith(".spec.ts") || normalized.endsWith(".spec.js") || normalized.endsWith(".spec.tsx") || normalized.endsWith(".spec.jsx") || normalized.endsWith(".d.ts");
-}
-function extractImportsUsingAst(source, fileName) {
-  try {
-    let visit = function(node) {
-      if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-        specifiers.add(node.moduleSpecifier.text);
-      } else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-        specifiers.add(node.moduleSpecifier.text);
-      } else if (ts.isCallExpression(node)) {
-        if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
-          specifiers.add(node.arguments[0].text);
-        } else if (ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
-          specifiers.add(node.arguments[0].text);
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
-    const specifiers = new Set;
-    visit(sourceFile);
-    return Array.from(specifiers);
-  } catch {
-    const stripped = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
-    const specifiers = new Set;
-    const fromRegex = /\bfrom\s*["'`]([^"'`]+)["'`]/g;
-    let match;
-    while ((match = fromRegex.exec(stripped)) !== null) {
-      specifiers.add(match[1].trim());
-    }
-    const importRegex = /\bimport\s*(?:\(\s*)?["'`]([^"'`]+)["'`]/g;
-    while ((match = importRegex.exec(stripped)) !== null) {
-      specifiers.add(match[1].trim());
-    }
-    const requireRegex = /\brequire\s*\(\s*["'`]([^"'`]+)["'`]/g;
-    while ((match = requireRegex.exec(stripped)) !== null) {
-      specifiers.add(match[1].trim());
-    }
-    return Array.from(specifiers);
-  }
-}
-var CANDIDATE_EXTENSIONS = [
-  "",
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".mts",
-  ".cts",
-  ".json"
-];
-function resolveLocalModulePath(baseDir, specifier) {
-  const candidate = resolve2(baseDir, specifier);
-  if (existsSync2(candidate)) {
-    try {
-      if (statSync2(candidate).isFile()) {
-        return candidate;
-      }
-    } catch {}
-  }
-  if (candidate.endsWith(".js")) {
-    const tsPath = candidate.slice(0, -3) + ".ts";
-    if (existsSync2(tsPath))
-      return tsPath;
-    const tsxPath = candidate.slice(0, -3) + ".tsx";
-    if (existsSync2(tsxPath))
-      return tsxPath;
-  } else if (candidate.endsWith(".mjs")) {
-    const mtsPath = candidate.slice(0, -4) + ".mts";
-    if (existsSync2(mtsPath))
-      return mtsPath;
-  } else if (candidate.endsWith(".cjs")) {
-    const ctsPath = candidate.slice(0, -4) + ".cts";
-    if (existsSync2(ctsPath))
-      return ctsPath;
-  }
-  for (const ext of CANDIDATE_EXTENSIONS) {
-    if (!ext)
-      continue;
-    const withExt = candidate + ext;
-    if (existsSync2(withExt)) {
-      try {
-        if (statSync2(withExt).isFile()) {
-          return withExt;
-        }
-      } catch {}
-    }
-  }
-  if (existsSync2(candidate)) {
-    try {
-      if (statSync2(candidate).isDirectory()) {
-        for (const ext of [".ts", ".tsx", ".js", ".mjs", ".json"]) {
-          const indexFile = join(candidate, `index${ext}`);
-          if (existsSync2(indexFile)) {
-            return indexFile;
-          }
-        }
-      }
-    } catch {}
-  }
-  return null;
-}
-function loadTsConfigInfo(projectRoot) {
-  const tsconfigPath = join(projectRoot, "tsconfig.json");
-  if (!existsSync2(tsconfigPath))
-    return null;
-  try {
-    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-    if (configFile.error)
-      return null;
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, projectRoot);
-    return {
-      baseUrl: parsed.options.baseUrl || projectRoot,
-      paths: parsed.options.paths || {},
-      options: parsed.options
-    };
-  } catch {
-    return null;
-  }
-}
-function resolveModulePathWithAliases(currentFile, specifier, projectRoot, tsconfigInfo) {
-  const dir = dirname2(currentFile);
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return resolveLocalModulePath(dir, specifier);
-  }
-  if (tsconfigInfo && Object.keys(tsconfigInfo.paths).length > 0) {
-    const host = {
-      fileExists: ts.sys.fileExists,
-      readFile: ts.sys.readFile,
-      directoryExists: ts.sys.directoryExists,
-      getCurrentDirectory: () => projectRoot,
-      getDirectories: ts.sys.getDirectories
-    };
-    try {
-      const resolved = ts.resolveModuleName(specifier, currentFile, tsconfigInfo.options, host);
-      if (resolved.resolvedModule && !resolved.resolvedModule.isExternalLibraryImport) {
-        const found = resolve2(resolved.resolvedModule.resolvedFileName);
-        if (existsSync2(found)) {
-          return found;
-        }
-      }
-    } catch {}
-    for (const [pattern, targets] of Object.entries(tsconfigInfo.paths)) {
-      let matched = false;
-      let star = "";
-      if (pattern.endsWith("*")) {
-        const prefix = pattern.slice(0, -1);
-        if (specifier.startsWith(prefix)) {
-          matched = true;
-          star = specifier.slice(prefix.length);
-        }
-      } else if (pattern === specifier) {
-        matched = true;
-      }
-      if (matched) {
-        for (const target of targets) {
-          const replaced = target.endsWith("*") ? target.slice(0, -1) + star : target;
-          const candidate = resolve2(tsconfigInfo.baseUrl, replaced);
-          const resolved = resolveLocalModulePath(dirname2(candidate), `./${basename2(candidate)}`);
-          if (resolved) {
-            return resolved;
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-function traceLocalModuleDependencies(entryFiles, projectRoot) {
-  const visited = new Set;
-  const modules = new Set;
-  const queue = [...entryFiles];
-  const tsconfigInfo = loadTsConfigInfo(projectRoot);
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (visited.has(current))
-      continue;
-    visited.add(current);
-    const relToRoot = relative(projectRoot, current);
-    if (relToRoot.startsWith("..") || isAbsolute(relToRoot)) {
-      continue;
-    }
-    let content = "";
-    try {
-      content = readFileSync(current, "utf-8");
-    } catch {
-      continue;
-    }
-    const specifiers = extractImportsUsingAst(content, current);
-    for (const spec of specifiers) {
-      const resolved = resolveModulePathWithAliases(current, spec, projectRoot, tsconfigInfo);
-      if (resolved) {
-        const rel = relative(projectRoot, resolved);
-        if (!rel.startsWith("..") && !isAbsolute(rel) && !isIgnoredModulePath(rel)) {
-          modules.add(resolved);
-          if (!visited.has(resolved)) {
-            queue.push(resolved);
-          }
-        }
-      }
-    }
-  }
-  return Array.from(modules);
-}
-function parsePlaybookFile(filePath) {
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (match) {
-      const parsed = YAML.parse(match[1]) || {};
-      const id = parsed.id || basename2(filePath.replace(/\\/g, "/"), ".md");
-      return {
-        id,
-        filePath,
-        actions: Array.isArray(parsed.actions) ? parsed.actions : [],
-        description: parsed.description
-      };
-    }
-    return {
-      id: basename2(filePath.replace(/\\/g, "/"), ".md"),
-      filePath,
-      actions: []
-    };
-  } catch {
-    return null;
-  }
-}
-function loadProjectPlaybooks(projectRoot, playbooksDir = "playbooks") {
-  const map = new Map;
-  const dir = join(projectRoot, playbooksDir);
-  if (!existsSync2(dir))
-    return map;
-  const files = walkDirectory(dir, projectRoot).filter((f) => f.endsWith(".md"));
-  for (const file of files) {
-    const pb = parsePlaybookFile(file);
-    if (pb) {
-      map.set(pb.id, pb);
-    }
-  }
-  return map;
-}
-function generateStaticManifest(projectRoot, actionsDir = "actions") {
-  const dir = join(projectRoot, actionsDir);
-  const actions = {};
-  if (existsSync2(dir)) {
-    const files = walkDirectory(dir, projectRoot).filter((f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.endsWith(".d.ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts"));
-    for (const file of files) {
-      const relPath = relative(projectRoot, file);
-      const filename = basename2(file);
-      const actionId = filename.replace(/\.(ts|js)$/, "");
-      let parsedId = actionId;
-      const uses = [];
-      try {
-        const source = readFileSync(file, "utf-8");
-        const idMatch = source.match(/id\s*:\s*["'`]([^"'`]+)["'`]/);
-        if (idMatch && idMatch[1]) {
-          parsedId = idMatch[1];
-        }
-        const usesMatch = source.match(/uses\s*:\s*\[([^\]]*)\]/);
-        if (usesMatch && usesMatch[1]) {
-          const rawItems = usesMatch[1].split(",");
-          for (const raw of rawItems) {
-            const clean = raw.trim().replace(/^["'`]|["'`]$/g, "");
-            if (clean) {
-              uses.push(clean);
-            }
-          }
-        }
-      } catch {}
-      actions[parsedId] = {
-        entry: relPath,
-        description: `Action ${parsedId}`,
-        uses
-      };
-    }
-  }
-  return {
-    schemaVersion: 1,
-    actions
-  };
-}
-function extractExternalDependencies(projectRoot) {
-  const pkgPath = join(projectRoot, "package.json");
-  if (!existsSync2(pkgPath))
-    return [];
-  try {
-    const raw = readFileSync(pkgPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const deps = [];
-    if (parsed.dependencies && typeof parsed.dependencies === "object") {
-      for (const [name, versionRange] of Object.entries(parsed.dependencies)) {
-        deps.push({
-          name,
-          versionRange: String(versionRange),
-          isDev: false
-        });
-      }
-    }
-    if (parsed.devDependencies && typeof parsed.devDependencies === "object") {
-      for (const [name, versionRange] of Object.entries(parsed.devDependencies)) {
-        deps.push({
-          name,
-          versionRange: String(versionRange),
-          isDev: true
-        });
-      }
-    }
-    return deps;
-  } catch {
-    return [];
-  }
-}
-
-class BuildPlanner {
-  projectRoot;
-  constructor(options) {
-    this.projectRoot = resolve2(options?.projectRoot || process.cwd());
-  }
-  plan(options) {
-    const root = resolve2(options?.projectRoot || this.projectRoot);
-    let config = options?.config;
-    if (!config) {
-      try {
-        config = loadProjectConfig(root);
-      } catch (err) {
-        throw new PlannerError(`Failed to load project config: ${err.message}`, "CONFIG_LOAD_ERROR");
-      }
-    }
-    let manifest = options?.manifest;
-    if (!manifest) {
-      const loaded = loadManifest(root);
-      if (loaded) {
-        manifest = loaded;
-      } else {
-        manifest = generateStaticManifest(root, config.actionsDir || "actions");
-      }
-    }
-    const validation = validateManifest(manifest, { projectRoot: root });
-    if (!validation.valid) {
-      throw new PlannerError(`Invalid actiondock.manifest.json: ${(validation.errors || []).join("; ")}`, "INVALID_MANIFEST");
-    }
-    const playbooksMap = loadProjectPlaybooks(root, config.playbooksDir || "playbooks");
-    const initialActionIds = new Set;
-    let selectedPlaybooks = [];
-    if (options?.playbooks && options.playbooks.length > 0) {
-      for (const pbId of options.playbooks) {
-        const pb = playbooksMap.get(pbId);
-        if (!pb) {
-          throw new PlannerError(`Playbook '${pbId}' specified in build options was not found in project`, "PLAYBOOK_NOT_FOUND");
-        }
-        selectedPlaybooks.push(pb);
-        if (pb.actions && pb.actions.length > 0) {
-          for (const act of pb.actions) {
-            initialActionIds.add(act);
-          }
-        }
-      }
-    } else {
-      selectedPlaybooks = Array.from(playbooksMap.values());
-    }
-    if (options?.actions && options.actions.length > 0) {
-      for (const actId of options.actions) {
-        if (!manifest.actions[actId]) {
-          throw new PlannerError(`Action '${actId}' specified in build options was not found in manifest`, "ACTION_NOT_FOUND");
-        }
-        initialActionIds.add(actId);
-      }
-    }
-    if ((!options?.actions || options.actions.length === 0) && (!options?.playbooks || options.playbooks.length === 0)) {
-      for (const actId of Object.keys(manifest.actions)) {
-        initialActionIds.add(actId);
-      }
-    }
-    const resolvedActionIds = new Set;
-    const queue = Array.from(initialActionIds);
-    const externalActionRoots = new Map;
-    const externalActionEntries = new Map;
-    while (queue.length > 0) {
-      const currentId = queue.shift();
-      if (resolvedActionIds.has(currentId)) {
-        continue;
-      }
-      let entry = manifest.actions[currentId];
-      let entryRoot = root;
-      if (!entry) {
-        try {
-          const resolvedExternal = resolveActionProjectSync(currentId, root);
-          if (resolvedExternal && existsSync2(resolvedExternal.projectRoot)) {
-            let externalManifest = loadManifest(resolvedExternal.projectRoot);
-            let externalEntry = externalManifest?.actions?.[resolvedExternal.actionId];
-            if (!externalEntry) {
-              const extConfig = loadProjectConfig(resolvedExternal.projectRoot);
-              const staticManifest = generateStaticManifest(resolvedExternal.projectRoot, extConfig.actionsDir || "actions");
-              externalEntry = staticManifest.actions[resolvedExternal.actionId];
-            }
-            if (externalEntry) {
-              entry = externalEntry;
-              entryRoot = resolvedExternal.projectRoot;
-            }
-          }
-        } catch {}
-      }
-      if (!entry) {
-        throw new PlannerError(`Action '${currentId}' referenced in dependency closure (uses) was not found in manifest or linked packages`, "MISSING_DEPENDENCY");
-      }
-      if (entryRoot !== root) {
-        externalActionRoots.set(currentId, entryRoot);
-        externalActionEntries.set(currentId, entry);
-      }
-      resolvedActionIds.add(currentId);
-      if (entry.uses && Array.isArray(entry.uses)) {
-        for (const depId of entry.uses) {
-          if (!resolvedActionIds.has(depId)) {
-            queue.push(depId);
-          }
-        }
-      }
-    }
-    if (options?.actions && options.actions.length > 0 && (!options.playbooks || options.playbooks.length === 0)) {
-      selectedPlaybooks = selectedPlaybooks.filter((pb) => {
-        if (!pb.actions || pb.actions.length === 0)
-          return true;
-        return pb.actions.every((a) => resolvedActionIds.has(a));
-      });
-    }
-    const actionDependencies = [];
-    for (const actId of resolvedActionIds) {
-      const entry = manifest.actions[actId] || externalActionEntries.get(actId);
-      const entryRoot = externalActionRoots.get(actId) || root;
-      if (!entry) {
-        throw new PlannerError(`Action '${actId}' entry not found`, "ENTRY_FILE_NOT_FOUND");
-      }
-      const resolvedPath = resolve2(entryRoot, entry.entry);
-      if (!existsSync2(resolvedPath)) {
-        throw new PlannerError(`Action '${actId}' entry file not found on disk: ${entry.entry}`, "ENTRY_FILE_NOT_FOUND");
-      }
-      actionDependencies.push({
-        id: actId,
-        entry: entry.entry,
-        resolvedPath,
-        uses: entry.uses || [],
-        description: entry.description,
-        inputSchema: entry.inputSchema,
-        outputSchema: entry.outputSchema,
-        tags: entry.tags,
-        annotations: entry.annotations
-      });
-    }
-    const modulesAndAssets = [];
-    const assetPathSet = new Set;
-    const modulePathSet = new Set;
-    const actionPathSet = new Set(actionDependencies.map((a) => a.resolvedPath));
-    const rootActionsMap = new Map;
-    for (const act of actionDependencies) {
-      const actRoot = externalActionRoots.get(act.id) || root;
-      if (!rootActionsMap.has(actRoot)) {
-        rootActionsMap.set(actRoot, []);
-      }
-      rootActionsMap.get(actRoot).push(act.resolvedPath);
-    }
-    for (const [actRoot, files] of rootActionsMap) {
-      const tracedModulePaths = traceLocalModuleDependencies(files, actRoot);
-      for (const modPath of tracedModulePaths) {
-        if (!actionPathSet.has(modPath)) {
-          const rel = relative(actRoot, modPath).replace(/\\/g, "/");
-          if (!modulePathSet.has(rel) && !isIgnoredModulePath(rel)) {
-            modulePathSet.add(rel);
-            modulesAndAssets.push({
-              path: rel,
-              resolvedPath: modPath,
-              type: "module"
-            });
-          }
-        }
-      }
-    }
-    const isSelective = Boolean(options?.actions && options.actions.length > 0) || Boolean(options?.playbooks && options.playbooks.length > 0);
-    if (!isSelective) {
-      const defaultLibDir = join(root, "lib");
-      if (existsSync2(defaultLibDir)) {
-        const libFiles = walkDirectory(defaultLibDir, root);
-        for (const file of libFiles) {
-          const rel = relative(root, file).replace(/\\/g, "/");
-          if (!isIgnoredModulePath(rel) && !actionPathSet.has(file) && !modulePathSet.has(rel)) {
-            modulePathSet.add(rel);
-            modulesAndAssets.push({
-              path: rel,
-              resolvedPath: file,
-              type: "module"
-            });
-          }
-        }
-      }
-    }
-    if (manifest.assets && Array.isArray(manifest.assets)) {
-      for (const assetRel of manifest.assets) {
-        const resolvedAsset = resolve2(root, assetRel);
-        assertPathWithinRoot(root, resolvedAsset, "asset");
-        if (!assetPathSet.has(assetRel)) {
-          assetPathSet.add(assetRel);
-          modulesAndAssets.push({
-            path: assetRel,
-            resolvedPath: resolvedAsset,
-            type: "asset"
-          });
-        }
-      }
-    }
-    const defaultAssetsDir = join(root, "assets");
-    if (existsSync2(defaultAssetsDir)) {
-      const assetFiles = walkDirectory(defaultAssetsDir, root);
-      for (const file of assetFiles) {
-        const rel = relative(root, file);
-        if (!assetPathSet.has(rel)) {
-          assetPathSet.add(rel);
-          modulesAndAssets.push({
-            path: rel,
-            resolvedPath: file,
-            type: "asset"
-          });
-        }
-      }
-    }
-    for (const pb of selectedPlaybooks) {
-      const rel = relative(root, pb.filePath);
-      modulesAndAssets.push({
-        path: rel,
-        resolvedPath: pb.filePath,
-        type: "playbook"
-      });
-    }
-    const configPath = join(root, "actiondock.json");
-    if (existsSync2(configPath)) {
-      modulesAndAssets.push({
-        path: "actiondock.json",
-        resolvedPath: configPath,
-        type: "config"
-      });
-    }
-    const manifestPath = join(root, "actiondock.manifest.json");
-    if (existsSync2(manifestPath)) {
-      modulesAndAssets.push({
-        path: "actiondock.manifest.json",
-        resolvedPath: manifestPath,
-        type: "config"
-      });
-    }
-    const externalDependencies = extractExternalDependencies(root);
-    const dependencies = {
-      actions: actionDependencies,
-      modulesAndAssets,
-      external: externalDependencies
-    };
-    return {
-      packageId: config.id,
-      packageName: config.name || config.id,
-      version: config.version || "0.1.0",
-      description: config.description,
-      projectRoot: root,
-      actionsDir: config.actionsDir || "actions",
-      playbooksDir: config.playbooksDir || "playbooks",
-      actions: actionDependencies,
-      playbooks: selectedPlaybooks,
-      dependencies,
-      assets: Array.from(assetPathSet),
-      configDefs: config.config,
-      metadata: {
-        plannedAt: new Date().toISOString(),
-        schemaVersion: 1,
-        actionCount: actionDependencies.length,
-        playbookCount: selectedPlaybooks.length
-      }
-    };
-  }
-  static plan(options) {
-    const planner = new BuildPlanner({ projectRoot: options.projectRoot });
-    return planner.plan(options);
-  }
-}
-function buildPlan(options) {
-  return BuildPlanner.plan(options);
-}
-
-// packages/builder/src/build.ts
-async function buildProject(options) {
-  const root = resolve3(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 = join2(root, ".actiondock", ".build");
-  mkdirSync2(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 = join2(buildDir, entryFileName);
-  writeFileSync2(entryPath, entryCode, "utf-8");
-  const binaryName = getPackageSlug(plan.packageId);
-  const defaultOutfile = join2(root, "dist", binaryName);
-  const outfile = resolve3(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 (existsSync3(entryPath)) {
-      rmSync(entryPath, { force: true });
-    }
-  }
-}
-// packages/builder/src/exporter.ts
-import { copyFileSync, cpSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, renameSync, rmSync as rmSync2, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename4, dirname as dirname4, join as join4, relative as relative3, resolve as resolve4 } from "node:path";
-import {
-  ACTIONDOCK_VERSION,
-  generateCompositeSkillMd,
-  generateSourceSkillMd,
-  generateStandaloneEntrypoint as generateStandaloneEntrypoint2,
-  generateStandaloneSkillMd,
-  getPackageSlug as getPackageSlug2,
-  loadManifest as loadManifest2,
-  loadPlaybooks,
-  loadProjectConfig as loadProjectConfig2
-} from "@actiondock/core";
-
-// packages/builder/src/archive.ts
-import { closeSync, createReadStream as createReadStream2, createWriteStream, openSync, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync3, writeFileSync as writeFileSync3, writeSync } from "node:fs";
-import { deflateRawSync, gzipSync, createGzip } from "node:zlib";
-import { basename as basename3, join as join3, relative as relative2, sep } from "node:path";
-import { pipeline } from "node:stream/promises";
-function collectEntries(dir, baseDir = dir) {
-  const entries = [];
-  for (const name of readdirSync2(dir).sort()) {
-    const fullPath = join3(dir, name);
-    const stat = statSync3(fullPath);
-    if (stat.isDirectory()) {
-      entries.push({ relPath: relative2(baseDir, fullPath).split(sep).join("/"), isDir: true });
-      entries.push(...collectEntries(fullPath, baseDir));
-    } else if (stat.isFile()) {
-      entries.push({ relPath: relative2(baseDir, fullPath).split(sep).join("/"), isDir: false });
-    }
-  }
-  return entries;
-}
-var CRC32_TABLE = (() => {
-  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 ? 3988292384 ^ c >>> 1 : c >>> 1;
-    }
-    table[n] = c >>> 0;
-  }
-  return table;
-})();
-function crc32(buf) {
-  let crc = 4294967295;
-  for (let i = 0;i < buf.length; i++) {
-    crc = CRC32_TABLE[(crc ^ buf[i]) & 255] ^ crc >>> 8;
-  }
-  return (crc ^ 4294967295) >>> 0;
-}
-function dosDateTime(ms) {
-  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 };
-}
-function createZipArchive(dir, outPath) {
-  const rootName = basename3(dir);
-  const entries = collectEntries(dir);
-  const fd = openSync(outPath, "w");
-  const centralRecords = [];
-  let offset = 0;
-  try {
-    for (const entry of entries) {
-      const name = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
-      const nameBuf = Buffer.from(name, "utf8");
-      const stat = statSync3(join3(dir, entry.relPath));
-      const { date, time } = dosDateTime(stat.mtimeMs);
-      const content = entry.isDir ? Buffer.alloc(0) : readFileSync2(join3(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);
-      const local = Buffer.alloc(30);
-      local.writeUInt32LE(67324752, 0);
-      local.writeUInt16LE(20, 4);
-      local.writeUInt16LE(2048, 6);
-      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);
-      writeSync(fd, local);
-      writeSync(fd, nameBuf);
-      if (payload.length > 0) {
-        writeSync(fd, payload);
-      }
-      const central = Buffer.alloc(46);
-      central.writeUInt32LE(33639248, 0);
-      central.writeUInt16LE(3 << 8 | 20, 4);
-      central.writeUInt16LE(20, 6);
-      central.writeUInt16LE(2048, 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);
-      central.writeUInt16LE(0, 32);
-      central.writeUInt16LE(0, 34);
-      central.writeUInt16LE(0, 36);
-      const isExec = !entry.isDir && (Boolean(stat.mode & 73) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-      const fileMode = isExec ? 33261 : 33188;
-      const extAttrs = (entry.isDir ? 16877 : fileMode) << 16 | (entry.isDir ? 16 : 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) {
-      writeSync(fd, record.header);
-      centralDirSize += record.header.length;
-    }
-    const eocd = Buffer.alloc(22);
-    eocd.writeUInt32LE(101010256, 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);
-    writeSync(fd, eocd);
-  } finally {
-    closeSync(fd);
-  }
-}
-async function createZipArchiveAsync(dir, outPath) {
-  createZipArchive(dir, outPath);
-}
-function tarHeader(path, size, mtimeSec, isDir, modeOrExec = false) {
-  let name = path;
-  let prefix = "";
-  if (Buffer.byteLength(name, "utf8") > 100) {
-    const trailingSlash = name.endsWith("/");
-    const cleanPath = trailingSlash ? name.slice(0, -1) : name;
-    const split = cleanPath.lastIndexOf("/");
-    prefix = cleanPath.slice(0, split);
-    name = cleanPath.slice(split + 1) + (trailingSlash ? "/" : "");
-    if (split <= 0 || Buffer.byteLength(prefix, "utf8") > 155 || Buffer.byteLength(name, "utf8") > 100) {
-      throw new Error(`归档路径超出 USTAR 字段容量: ${path}`);
-    }
-  }
-  const buf = Buffer.alloc(512);
-  buf.write(name, 0, 100, "utf8");
-  let mode;
-  if (typeof modeOrExec === "string") {
-    mode = modeOrExec;
-  } else {
-    mode = isDir ? "0000755" : modeOrExec ? "0000755" : "0000644";
-  }
-  buf.write(mode, 100, 8, "ascii");
-  buf.write("0000000", 108, 8, "ascii");
-  buf.write("0000000", 116, 8, "ascii");
-  buf.write(size.toString(8).padStart(11, "0"), 124, 12, "ascii");
-  buf.write(Math.floor(mtimeSec).toString(8).padStart(11, "0"), 136, 12, "ascii");
-  buf.fill(" ", 148, 156);
-  buf.write(isDir ? "5" : "0", 156, 1, "ascii");
-  buf.write("ustar\x00", 257, 6, "ascii");
-  buf.write("00", 263, 2, "ascii");
-  if (prefix)
-    buf.write(prefix, 345, 155, "utf8");
-  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("\x00", 154, 1, "ascii");
-  buf.write(" ", 155, 1, "ascii");
-  return buf;
-}
-function pad512(length) {
-  const rem = length % 512;
-  return rem === 0 ? Buffer.alloc(0) : Buffer.alloc(512 - rem);
-}
-function createTarGzArchive(dir, outPath) {
-  const rootName = basename3(dir);
-  const entries = collectEntries(dir);
-  const chunks = [];
-  for (const entry of entries) {
-    const path = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
-    const fullPath = join3(dir, entry.relPath);
-    const stat = statSync3(fullPath);
-    const content = entry.isDir ? Buffer.alloc(0) : readFileSync2(fullPath);
-    const isExec = !entry.isDir && (Boolean(stat.mode & 73) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-    chunks.push(tarHeader(path, content.length, Math.floor(stat.mtimeMs / 1000), entry.isDir, isExec));
-    if (!entry.isDir) {
-      chunks.push(content, pad512(content.length));
-    }
-  }
-  chunks.push(Buffer.alloc(1024));
-  writeFileSync3(outPath, gzipSync(Buffer.concat(chunks), { level: 9 }));
-}
-async function createTarGzArchiveAsync(dir, outPath) {
-  const rootName = basename3(dir);
-  const entries = collectEntries(dir);
-  const gzip = createGzip({ level: 9 });
-  const writeStream = createWriteStream(outPath);
-  const pipePromise = pipeline(gzip, writeStream);
-  for (const entry of entries) {
-    const path = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
-    const fullPath = join3(dir, entry.relPath);
-    const stat = statSync3(fullPath);
-    const isExec = !entry.isDir && (Boolean(stat.mode & 73) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-    const header = tarHeader(path, entry.isDir ? 0 : stat.size, Math.floor(stat.mtimeMs / 1000), entry.isDir, isExec);
-    gzip.write(header);
-    if (!entry.isDir && stat.size > 0) {
-      await new Promise((resolve, reject) => {
-        const fileStream = createReadStream2(fullPath);
-        fileStream.on("data", (chunk) => gzip.write(chunk));
-        fileStream.on("end", () => {
-          const rem = stat.size % 512;
-          if (rem !== 0) {
-            gzip.write(Buffer.alloc(512 - rem));
-          }
-          resolve();
-        });
-        fileStream.on("error", reject);
-      });
-    }
-  }
-  gzip.write(Buffer.alloc(1024));
-  gzip.end();
-  await pipePromise;
-}
-
-// packages/builder/src/exporter.ts
-function moveDirAtomic(src, dest) {
-  try {
-    renameSync(src, dest);
-  } catch (err) {
-    if (err?.code === "EXDEV") {
-      cpSync(src, dest, { recursive: true });
-      rmSync2(src, { recursive: true, force: true });
-    } else {
-      throw err;
-    }
-  }
-}
-function getInternalDependencyVersion(version = ACTIONDOCK_VERSION) {
-  if (version.includes("-")) {
-    return version;
-  }
-  return `^${version}`;
-}
-function resolveWorkspaceDepVersion(root, depName, ver) {
-  if (depName.startsWith("@actiondock/")) {
-    return getInternalDependencyVersion();
-  }
-  const stripped = ver.replace(/^workspace:/, "").trim();
-  if (stripped && stripped !== "*" && stripped !== "^" && stripped !== "~") {
-    return stripped;
-  }
-  const candidates = [
-    resolve4(root, "node_modules", depName, "package.json"),
-    resolve4(root, "packages", depName, "package.json"),
-    resolve4(root, "packages", depName.split("/").pop(), "package.json"),
-    resolve4(root, "..", depName, "package.json"),
-    resolve4(root, "..", depName.split("/").pop(), "package.json"),
-    resolve4(root, "..", "packages", depName, "package.json"),
-    resolve4(root, "..", "packages", depName.split("/").pop(), "package.json"),
-    resolve4(root, "..", "..", "packages", depName, "package.json"),
-    resolve4(root, "..", "..", "packages", depName.split("/").pop(), "package.json")
-  ];
-  for (const cand of candidates) {
-    if (existsSync4(cand)) {
-      try {
-        const pkgData = JSON.parse(readFileSync3(cand, "utf-8"));
-        if (pkgData.version) {
-          const prefix = stripped === "~" ? "~" : "^";
-          return `${prefix}${pkgData.version}`;
-        }
-      } catch {}
-    }
-  }
-  throw new BuilderError(`Failed to resolve workspace dependency '${depName}' (${ver}) in '${root}'. Target package version could not be found.`);
-}
-function scanRelativeFiles(dir, baseDir = dir) {
-  if (!existsSync4(dir))
-    return [];
-  const results = [];
-  const entries = readdirSync3(dir);
-  for (const entry of entries) {
-    const fullPath = join4(dir, entry);
-    const stat = statSync4(fullPath);
-    if (stat.isDirectory()) {
-      results.push(...scanRelativeFiles(fullPath, baseDir));
-    } else if (stat.isFile()) {
-      results.push(relative3(baseDir, fullPath));
-    }
-  }
-  return results;
-}
-async function createArchive(skillDir, format) {
-  const parentDir = dirname4(skillDir);
-  const folderName = basename4(skillDir);
-  const archiveName = `${folderName}.${format === "tar.gz" ? "tar.gz" : "zip"}`;
-  const archivePath = join4(parentDir, archiveName);
-  if (existsSync4(archivePath)) {
-    rmSync2(archivePath, { force: true });
-  }
-  try {
-    if (format === "tar.gz") {
-      await createTarGzArchiveAsync(skillDir, archivePath);
-    } else {
-      await createZipArchiveAsync(skillDir, archivePath);
-    }
-  } catch (err) {
-    throw new BuilderError(`Failed to create ${format} archive: ${err?.message || String(err)}`);
-  }
-  return archivePath;
-}
-function findExistingSingleSkillMd(projectRoot, explicitPath, pkgSlug) {
-  if (explicitPath && existsSync4(explicitPath)) {
-    try {
-      if (statSync4(explicitPath).isFile())
-        return resolve4(explicitPath);
-    } catch {}
-  }
-  const candidates = [
-    join4(projectRoot, "SKILL.md"),
-    join4(projectRoot, "skill.md"),
-    join4(projectRoot, "skills", "SKILL.md"),
-    join4(projectRoot, "skills", "skill.md")
-  ];
-  if (pkgSlug) {
-    candidates.push(join4(projectRoot, "skills", pkgSlug, "SKILL.md"), join4(projectRoot, "skills", pkgSlug, "skill.md"));
-  }
-  for (const candidate of candidates) {
-    if (existsSync4(candidate)) {
-      try {
-        if (statSync4(candidate).isFile())
-          return resolve4(candidate);
-      } catch {}
-    }
-  }
-  return;
-}
-function findExistingCompositeSkillMd(options) {
-  if (options.skillMdPath && existsSync4(options.skillMdPath)) {
-    try {
-      if (statSync4(options.skillMdPath).isFile())
-        return resolve4(options.skillMdPath);
-    } catch {}
-  }
-  const bundleSlug = getPackageSlug2(options.bundleName);
-  const searchDirs = new Set;
-  if (options.workspaceRoot && existsSync4(options.workspaceRoot)) {
-    searchDirs.add(resolve4(options.workspaceRoot));
-  }
-  searchDirs.add(process.cwd());
-  for (const root of options.projectRoots) {
-    const absRoot = resolve4(root);
-    const parentDir = dirname4(absRoot);
-    searchDirs.add(parentDir);
-    searchDirs.add(dirname4(parentDir));
-  }
-  const candidateRelativePaths = [
-    join4("skills", options.bundleName, "SKILL.md"),
-    join4("skills", bundleSlug, "SKILL.md"),
-    join4("skills", "SKILL.md"),
-    "SKILL.md",
-    join4("skills", options.bundleName, "skill.md"),
-    join4("skills", bundleSlug, "skill.md"),
-    join4("skills", "skill.md"),
-    "skill.md"
-  ];
-  for (const dir of searchDirs) {
-    for (const rel of candidateRelativePaths) {
-      const fullPath = join4(dir, rel);
-      if (existsSync4(fullPath)) {
-        try {
-          if (statSync4(fullPath).isFile())
-            return fullPath;
-        } catch {}
-      }
-    }
-  }
-  return;
-}
-
-class SkillExporter {
-  async export(options) {
-    const root = resolve4(options.projectRoot);
-    const mode = options.standalone || options.mode === "standalone" ? "standalone" : "source";
-    const target = options.target ? String(options.target) : "host";
-    const planner = new BuildPlanner({ projectRoot: root });
-    const plan = planner.plan({
-      projectRoot: root,
-      config: options.config,
-      manifest: options.manifest,
-      actions: options.actions,
-      playbooks: options.playbooks
-    });
-    const pkgSlug = getPackageSlug2(plan.packageId);
-    const targetSuffix = mode === "standalone" && target !== "host" && target !== "bun" ? `-${target}` : "";
-    const defaultFolderName = `${pkgSlug}-skill${targetSuffix}`;
-    const defaultSkillDir = join4(root, "dist", defaultFolderName);
-    const targetSkillDir = resolve4(options.outDir || defaultSkillDir);
-    const parentDir = dirname4(targetSkillDir);
-    mkdirSync3(parentDir, { recursive: true });
-    const stagingDir = join4(parentDir, `.tmp-${basename4(targetSkillDir)}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-    mkdirSync3(stagingDir, { recursive: true });
-    const actionsDir = plan.actionsDir || "actions";
-    const playbooksDir = plan.playbooksDir || "playbooks";
-    const playbooksDestDir = join4(stagingDir, playbooksDir);
-    if (plan.playbooks.length > 0) {
-      mkdirSync3(playbooksDestDir, { recursive: true });
-    }
-    const skillDir = stagingDir;
-    const configForTemplates = {
-      id: plan.packageId,
-      name: plan.packageName,
-      version: plan.version,
-      description: plan.description,
-      actionsDir,
-      playbooksDir,
-      config: plan.configDefs
-    };
-    let usedExistingSkillMd;
-    try {
-      if (mode === "source") {
-        const existingSkill = !options.skipSkillMd ? findExistingSingleSkillMd(root, options.skillMdPath, pkgSlug) : undefined;
-        if (existingSkill) {
-          usedExistingSkillMd = existingSkill;
-          const destSkillMd = join4(skillDir, "SKILL.md");
-          if (resolve4(existingSkill) !== resolve4(destSkillMd)) {
-            copyFileSync(existingSkill, destSkillMd);
-          }
-        } else if (!options.skipSkillMd) {
-          const skillMd = generateSourceSkillMd(configForTemplates, plan.actions, plan.playbooks);
-          writeFileSync4(join4(skillDir, "SKILL.md"), skillMd, "utf-8");
-        }
-        const manifestActions = {};
-        for (const a of plan.actions) {
-          manifestActions[a.id] = {
-            entry: a.entry,
-            description: a.description,
-            inputSchema: a.inputSchema,
-            outputSchema: a.outputSchema,
-            uses: a.uses,
-            tags: a.tags,
-            annotations: a.annotations
-          };
-          if (a.id.includes("/")) {
-            const shortId = a.id.slice(a.id.lastIndexOf("/") + 1);
-            if (!manifestActions[shortId]) {
-              manifestActions[shortId] = manifestActions[a.id];
-            }
-          }
-        }
-        const exportedManifest = {
-          schemaVersion: 1,
-          actions: manifestActions,
-          assets: plan.assets
-        };
-        writeFileSync4(join4(skillDir, "actiondock.manifest.json"), JSON.stringify(exportedManifest, null, 2) + `
-`, "utf-8");
-        const exportedConfig = {
-          id: plan.packageId,
-          name: plan.packageName,
-          version: plan.version,
-          description: plan.description,
-          actionsDir,
-          playbooksDir,
-          config: plan.configDefs
-        };
-        writeFileSync4(join4(skillDir, "actiondock.json"), JSON.stringify(exportedConfig, null, 2) + `
-`, "utf-8");
-        const projectPkgPath = join4(root, "package.json");
-        const sanitizeDependencies = (deps) => {
-          const result = {};
-          if (deps && typeof deps === "object") {
-            for (const [k, v] of Object.entries(deps)) {
-              const verStr = String(v);
-              if (verStr.startsWith("file:")) {
-                throw new BuilderError(`Unsupported file: dependency for '${k}'. Runtime dependencies must not use file: protocol in exported skill packages.`);
-              }
-              if (k.startsWith("@actiondock/")) {
-                result[k] = getInternalDependencyVersion();
-              } else if (verStr.startsWith("workspace:")) {
-                result[k] = resolveWorkspaceDepVersion(root, k, verStr);
-              } else {
-                result[k] = verStr;
-              }
-            }
-          }
-          if (!result["@actiondock/sdk"]) {
-            result["@actiondock/sdk"] = getInternalDependencyVersion();
-          }
-          return result;
-        };
-        let exportedPkg;
-        if (existsSync4(projectPkgPath)) {
-          try {
-            const raw = readFileSync3(projectPkgPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            exportedPkg = {
-              name: parsed.name || pkgSlug,
-              version: plan.version || parsed.version || "0.1.0",
-              description: plan.description || parsed.description,
-              type: "module",
-              dependencies: sanitizeDependencies(parsed.dependencies)
-            };
-          } catch (err) {
-            if (err instanceof BuilderError) {
-              throw err;
-            }
-            exportedPkg = {
-              name: pkgSlug,
-              version: plan.version,
-              description: plan.description,
-              type: "module",
-              dependencies: { "@actiondock/sdk": getInternalDependencyVersion() }
-            };
-          }
-        } else {
-          exportedPkg = {
-            name: pkgSlug,
-            version: plan.version,
-            description: plan.description,
-            type: "module",
-            dependencies: { "@actiondock/sdk": getInternalDependencyVersion() }
-          };
-        }
-        writeFileSync4(join4(skillDir, "package.json"), JSON.stringify(exportedPkg, null, 2) + `
-`, "utf-8");
-        const tsconfigPath = join4(root, "tsconfig.json");
-        if (existsSync4(tsconfigPath)) {
-          copyFileSync(tsconfigPath, join4(skillDir, "tsconfig.json"));
-        }
-        for (const act of plan.actions) {
-          if (existsSync4(act.resolvedPath)) {
-            const destFile = join4(skillDir, act.entry);
-            mkdirSync3(dirname4(destFile), { recursive: true });
-            copyFileSync(act.resolvedPath, destFile);
-          }
-        }
-        for (const dep of plan.dependencies.modulesAndAssets) {
-          if ((dep.type === "asset" || dep.type === "module") && existsSync4(dep.resolvedPath)) {
-            const destAsset = join4(skillDir, dep.path);
-            mkdirSync3(dirname4(destAsset), { recursive: true });
-            copyFileSync(dep.resolvedPath, destAsset);
-          }
-        }
-        for (const pb of plan.playbooks) {
-          if (existsSync4(pb.filePath)) {
-            const destPb = join4(playbooksDestDir, basename4(pb.filePath));
-            copyFileSync(pb.filePath, destPb);
-          }
-        }
-      } else {
-        const binDir = join4(skillDir, "bin");
-        mkdirSync3(binDir, { recursive: true });
-        const binaryName = pkgSlug;
-        const binaryPath = join4(binDir, binaryName);
-        const buildDir = join4(root, ".actiondock", ".build");
-        mkdirSync3(buildDir, { recursive: true });
-        const entryCode = generateStandaloneEntrypoint2(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 = join4(buildDir, entryFileName);
-        writeFileSync4(entryPath, entryCode, "utf-8");
-        let compileRes;
-        try {
-          compileRes = await BunCompiler.compile({
-            entrypoint: entryPath,
-            outfile: binaryPath,
-            target: options.target,
-            minify: options.minify,
-            bytecode: options.bytecode,
-            cwd: root,
-            packageId: plan.packageId,
-            version: plan.version,
-            actions: plan.actions.map((a) => a.id)
-          });
-        } finally {
-          if (existsSync4(entryPath)) {
-            rmSync2(entryPath, { force: true });
-          }
-        }
-        const actualBinaryName = basename4(compileRes.executablePath);
-        const existingSkill = !options.skipSkillMd ? findExistingSingleSkillMd(root, options.skillMdPath, pkgSlug) : undefined;
-        if (existingSkill) {
-          usedExistingSkillMd = existingSkill;
-          const destSkillMd = join4(skillDir, "SKILL.md");
-          if (resolve4(existingSkill) !== resolve4(destSkillMd)) {
-            copyFileSync(existingSkill, destSkillMd);
-          }
-        } else if (!options.skipSkillMd) {
-          const skillMd = generateStandaloneSkillMd(configForTemplates, plan.actions, plan.playbooks, `./bin/${actualBinaryName}`);
-          writeFileSync4(join4(skillDir, "SKILL.md"), skillMd, "utf-8");
-        }
-        for (const pb of plan.playbooks) {
-          if (existsSync4(pb.filePath)) {
-            const destPb = join4(playbooksDestDir, basename4(pb.filePath));
-            copyFileSync(pb.filePath, destPb);
-          }
-        }
-        for (const dep of plan.dependencies.modulesAndAssets) {
-          if (dep.type === "asset" && existsSync4(dep.resolvedPath)) {
-            const destAsset = join4(skillDir, dep.path);
-            mkdirSync3(dirname4(destAsset), { recursive: true });
-            copyFileSync(dep.resolvedPath, destAsset);
-          }
-        }
-      }
-      if (existsSync4(targetSkillDir)) {
-        const backupDir = `${targetSkillDir}.old-${Date.now()}`;
-        try {
-          moveDirAtomic(targetSkillDir, backupDir);
-          moveDirAtomic(stagingDir, targetSkillDir);
-          rmSync2(backupDir, { recursive: true, force: true });
-        } catch {
-          rmSync2(targetSkillDir, { recursive: true, force: true });
-          moveDirAtomic(stagingDir, targetSkillDir);
-        }
-      } else {
-        moveDirAtomic(stagingDir, targetSkillDir);
-      }
-    } finally {
-      if (existsSync4(stagingDir)) {
-        rmSync2(stagingDir, { recursive: true, force: true });
-      }
-    }
-    let archivePath;
-    if (options.archive) {
-      let format = "zip";
-      if (options.archiveFormat === "tar.gz" || options.archive === "tar.gz") {
-        format = "tar.gz";
-      } else if (options.archiveFormat === "zip" || options.archive === "zip") {
-        format = "zip";
-      }
-      archivePath = await createArchive(targetSkillDir, format);
-    }
-    const files = scanRelativeFiles(targetSkillDir);
-    return {
-      packageId: plan.packageId,
-      version: plan.version,
-      mode,
-      target,
-      skillDir: targetSkillDir,
-      archivePath,
-      actionsCount: plan.actions.length,
-      playbooksCount: plan.playbooks.length,
-      actions: plan.actions.map((a) => a.id),
-      playbooks: plan.playbooks.map((p) => p.id),
-      files,
-      usedExistingSkillMd
-    };
-  }
-  async exportBatch(options) {
-    if (!options.projectRoots || options.projectRoots.length === 0) {
-      throw new BuilderError("No project roots provided for batch skill export.");
-    }
-    const results = [];
-    const baseOutDir = resolve4(options.outDir || join4(process.cwd(), "dist", "skills"));
-    mkdirSync3(baseOutDir, { recursive: true });
-    const usedDirNames = new Set;
-    for (const projectRoot of options.projectRoots) {
-      const config = loadProjectConfig2(projectRoot);
-      let pkgSlug = getPackageSlug2(config.id);
-      if (usedDirNames.has(pkgSlug)) {
-        pkgSlug = config.id.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/^-+|-+$/g, "");
-      }
-      usedDirNames.add(pkgSlug);
-      const pkgOutDir = join4(baseOutDir, `${pkgSlug}-skill`);
-      const res = await this.export({
-        ...options,
-        projectRoot,
-        outDir: pkgOutDir
-      });
-      results.push(res);
-    }
-    const totalActions = results.reduce((sum, r) => sum + r.actionsCount, 0);
-    const totalPlaybooks = results.reduce((sum, r) => sum + r.playbooksCount, 0);
-    return {
-      results,
-      outDir: baseOutDir,
-      totalActions,
-      totalPlaybooks
-    };
-  }
-  static async exportBatch(options) {
-    const exporter = new SkillExporter;
-    return exporter.exportBatch(options);
-  }
-  async exportComposite(options) {
-    if (!options.projectRoots || options.projectRoots.length === 0) {
-      throw new BuilderError("No project roots provided for composite skill export.");
-    }
-    if (!options.bundleName || !options.bundleName.trim()) {
-      throw new BuilderError("bundleName is required for composite skill export.");
-    }
-    const bundleSlug = getPackageSlug2(options.bundleName);
-    const defaultSkillDir = join4(process.cwd(), "dist", `${bundleSlug}-skill`);
-    const targetSkillDir = resolve4(options.outDir || defaultSkillDir);
-    const parentDir = dirname4(targetSkillDir);
-    mkdirSync3(parentDir, { recursive: true });
-    const stagingDir = join4(parentDir, `.tmp-composite-${bundleSlug}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-    mkdirSync3(stagingDir, { recursive: true });
-    const packagesDestDir = join4(stagingDir, "packages");
-    mkdirSync3(packagesDestDir, { recursive: true });
-    const packageInfos = [];
-    const packageSummaries = [];
-    try {
-      const usedDirNames = new Set;
-      for (const projectRoot of options.projectRoots) {
-        const config = loadProjectConfig2(projectRoot);
-        let pkgSlug = getPackageSlug2(config.id);
-        if (usedDirNames.has(pkgSlug)) {
-          pkgSlug = config.id.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/^-+|-+$/g, "");
-        }
-        usedDirNames.add(pkgSlug);
-        const destPkgDir = join4(packagesDestDir, pkgSlug);
-        const singleExport = await this.export({
-          projectRoot,
-          outDir: destPkgDir,
-          archive: false,
-          skipSkillMd: true
-        });
-        const manifest = loadManifest2(destPkgDir) || loadManifest2(projectRoot);
-        const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
-        const actionEntries = singleExport.actions.map((actId) => ({
-          id: actId,
-          description: manifest?.actions?.[actId]?.description
-        }));
-        packageInfos.push({
-          config,
-          actions: actionEntries,
-          playbooks: Array.from(playbooks.values()),
-          packageDir: pkgSlug
-        });
-        packageSummaries.push({
-          packageId: config.id,
-          actions: singleExport.actions,
-          playbooks: singleExport.playbooks
-        });
-      }
-      const existingSkillPath = findExistingCompositeSkillMd(options);
-      if (existingSkillPath) {
-        const destSkillMdPath = join4(stagingDir, "SKILL.md");
-        if (resolve4(existingSkillPath) !== resolve4(destSkillMdPath)) {
-          copyFileSync(existingSkillPath, destSkillMdPath);
-        }
-      } else {
-        const description = options.description || `ActionDock 复合技能套件，聚合 ${packageInfos.map((p) => p.config.name).join("、")}`;
-        const compositeSkillMd = generateCompositeSkillMd(options.bundleName, description, packageInfos);
-        writeFileSync4(join4(stagingDir, "SKILL.md"), compositeSkillMd, "utf-8");
-      }
-      const aggregatedDeps = {
-        "@actiondock/sdk": getInternalDependencyVersion()
-      };
-      for (const info of packageInfos) {
-        const pkgJsonPath = join4(packagesDestDir, info.packageDir, "package.json");
-        if (existsSync4(pkgJsonPath)) {
-          try {
-            const raw = readFileSync3(pkgJsonPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            if (parsed.dependencies && typeof parsed.dependencies === "object") {
-              for (const [dep, ver] of Object.entries(parsed.dependencies)) {
-                const verStr = String(ver);
-                if (verStr.startsWith("file:")) {
-                  throw new BuilderError(`Unsupported file: dependency for '${dep}'. Runtime dependencies must not use file: protocol in exported skill packages.`);
-                }
-                if (dep.startsWith("@actiondock/")) {
-                  aggregatedDeps[dep] = getInternalDependencyVersion();
-                } else if (verStr.startsWith("workspace:")) {
-                  aggregatedDeps[dep] = resolveWorkspaceDepVersion(join4(packagesDestDir, info.packageDir), dep, verStr);
-                } else {
-                  aggregatedDeps[dep] = verStr;
-                }
-              }
-            }
-          } catch (err) {
-            if (err instanceof BuilderError)
-              throw err;
-          }
-        }
-      }
-      writeFileSync4(join4(stagingDir, "package.json"), JSON.stringify({
-        name: bundleSlug,
-        version: "1.0.0",
-        description: options.description || "Composite ActionDock Skill bundle",
-        type: "module",
-        dependencies: aggregatedDeps
-      }, null, 2) + `
-`, "utf-8");
-      if (existsSync4(targetSkillDir)) {
-        const backupDir = `${targetSkillDir}.old-${Date.now()}`;
-        try {
-          moveDirAtomic(targetSkillDir, backupDir);
-          moveDirAtomic(stagingDir, targetSkillDir);
-          rmSync2(backupDir, { recursive: true, force: true });
-        } catch {
-          rmSync2(targetSkillDir, { recursive: true, force: true });
-          moveDirAtomic(stagingDir, targetSkillDir);
-        }
-      } else {
-        moveDirAtomic(stagingDir, targetSkillDir);
-      }
-    } finally {
-      if (existsSync4(stagingDir)) {
-        rmSync2(stagingDir, { recursive: true, force: true });
-      }
-    }
-    let archivePath;
-    if (options.archive) {
-      let format = "zip";
-      if (options.archiveFormat === "tar.gz" || options.archive === "tar.gz") {
-        format = "tar.gz";
-      } else if (options.archiveFormat === "zip" || options.archive === "zip") {
-        format = "zip";
-      }
-      archivePath = await createArchive(targetSkillDir, format);
-    }
-    const files = scanRelativeFiles(targetSkillDir);
-    const totalActions = packageSummaries.reduce((sum, p) => sum + p.actions.length, 0);
-    const totalPlaybooks = packageSummaries.reduce((sum, p) => sum + p.playbooks.length, 0);
-    return {
-      bundleName: options.bundleName,
-      skillDir: targetSkillDir,
-      archivePath,
-      packagesCount: packageInfos.length,
-      actionsCount: totalActions,
-      playbooksCount: totalPlaybooks,
-      packages: packageSummaries,
-      files,
-      usedExistingSkillMd: findExistingCompositeSkillMd(options)
-    };
-  }
-  static async exportComposite(options) {
-    const exporter = new SkillExporter;
-    return exporter.exportComposite(options);
-  }
-  static async export(options) {
-    const exporter = new SkillExporter;
-    return exporter.export(options);
-  }
-}
-async function exportSkill(options) {
-  return SkillExporter.export(options);
-}
-async function exportSkillBatch(options) {
-  return SkillExporter.exportBatch(options);
-}
-async function exportCompositeSkill(options) {
-  return SkillExporter.exportComposite(options);
-}
-export {
-  BuildPlanner,
-  BuilderError,
-  BunCompiler,
-  CompilerError,
-  CompilerValidationError,
-  PlannerError,
-  SkillExporter,
-  buildPlan,
-  buildProject,
-  compileBinary,
-  createTarGzArchive,
-  createTarGzArchiveAsync,
-  createZipArchive,
-  createZipArchiveAsync,
-  exportCompositeSkill,
-  exportSkill,
-  exportSkillBatch,
-  findExistingCompositeSkillMd,
-  findExistingSingleSkillMd,
-  getInternalDependencyVersion
-};
+/**
+ * @actiondock/builder 公共导出面。
+ * 采用显式命名导出替代全量 export *，保证公开 API 边界清晰可控。
+ */
+// 错误类型
+export { BuilderError, PlannerError } from "./errors.js";
+// 共享基础设施（内部复用的通用能力，随包公开便于下游校验）
+export { collectRelativeFiles, getInternalDependencyVersion, moveDirAtomic, replaceDirAtomic, } from "./fs-utils.js";
+// 清单组装与依赖协议校验
+export { assertNoFileProtocolDeps, assertValidManifestActionIds, serializeManifestAction, serializeManifestPlaybooks, serializePlanManifest, } from "./manifest.js";
+// 归档压缩
+export { createTarGzArchive, createTarGzArchiveAsync, createZipArchive, createZipArchiveAsync, writeToStream, } from "./archive.js";
+// 构建规划
+export { BuildPlanner, buildPlan, SelectionPlanner, selectionPlan } from "./planner.js";
+// 相对依赖完整性校验
+export { assertRelativeDependenciesIntegrity, extractRelativeSpecifiers, resolveRelativeModule, } from "./dependency-check.js";
+// 目录型构建与 npm 打包
+export { buildProject } from "./build.js";
+export { packProject } from "./pack.js";
+// Skill 导出
+export { exportCompositeSkill, exportSkill, exportSkillBatch, findExistingCompositeSkillMd, findExistingSingleSkillMd, SkillExporter, } from "./exporter.js";