@mongez/pkgist 1.0.0

package/dist/index.js

@@ -0,0 +1,824 @@
+// src/config/define-config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/config/load-config.ts
+import path2 from "path";
+import { pathToFileURL } from "url";
+import fs from "fs";
+
+// src/utils/paths.ts
+import path from "path";
+function toForwardSlash(p) {
+  return p.replace(/\\/g, "/");
+}
+function joinPath(...segments) {
+  return toForwardSlash(path.join(...segments));
+}
+function resolvePath(...segments) {
+  return toForwardSlash(path.resolve(...segments));
+}
+function scopelessName(packageName) {
+  const slash = packageName.indexOf("/");
+  return slash === -1 ? packageName : packageName.slice(slash + 1);
+}
+function buildOutputPath(buildDir, packageName, version) {
+  return joinPath(buildDir, scopelessName(packageName), version);
+}
+function sourceSnapshotPath(sourcesDir, packageName) {
+  return joinPath(sourcesDir, scopelessName(packageName));
+}
+
+// src/utils/errors.ts
+var BundlerError = class extends Error {
+  constructor(step, packageName, message, cause) {
+    super(message);
+    this.step = step;
+    this.packageName = packageName;
+    this.cause = cause;
+    this.name = "BundlerError";
+    if (cause instanceof Error && cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+  step;
+  packageName;
+  cause;
+};
+function wrapError(step, packageName, error) {
+  if (error instanceof BundlerError) return error;
+  const msg = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error);
+  return new BundlerError(step, packageName, `[${step}] ${packageName}: ${msg}`, error);
+}
+
+// src/config/load-config.ts
+async function loadConfig(configFilePath) {
+  const absolute = resolvePath(configFilePath);
+  if (!fs.existsSync(absolute)) {
+    throw new Error(`Config file not found: ${absolute}`);
+  }
+  let mod;
+  try {
+    const fileUrl = pathToFileURL(absolute).href;
+    mod = await import(fileUrl);
+  } catch (err) {
+    throw wrapError("load-config", absolute, err);
+  }
+  const config = mod.default;
+  if (!config || typeof config !== "object") {
+    throw new Error(
+      `Config file ${absolute} must export a default object from defineConfig(). Got: ${typeof config}`
+    );
+  }
+  validateConfig(config, absolute);
+  return {
+    config,
+    configPath: absolute,
+    configDir: resolvePath(path2.dirname(absolute))
+  };
+}
+function validateConfig(config, filePath) {
+  if (!config.settings) {
+    throw new Error(`Config "${filePath}" must have a "settings" object.`);
+  }
+  if (!config.settings.buildDir) {
+    throw new Error(`Config "${filePath}" settings.buildDir is required.`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const pkg of config.standalone ?? []) {
+    if (!pkg.name) throw new Error(`Standalone package is missing "name" in ${filePath}`);
+    if (!pkg.root) throw new Error(`Standalone package "${pkg.name}" is missing "root"`);
+    if (names.has(pkg.name)) throw new Error(`Duplicate package name: "${pkg.name}"`);
+    names.add(pkg.name);
+  }
+  for (const family of config.families ?? []) {
+    if (!family.name) throw new Error(`A family is missing "name" in ${filePath}`);
+    for (const pkg of family.packages) {
+      if (!pkg.name) throw new Error(`Package inside family "${family.name}" is missing "name"`);
+      if (!pkg.root) throw new Error(`Package "${pkg.name}" in family "${family.name}" is missing "root"`);
+      if (names.has(pkg.name)) throw new Error(`Duplicate package name: "${pkg.name}"`);
+      names.add(pkg.name);
+    }
+  }
+}
+function findDefaultConfigPath(cwd) {
+  const candidates = ["builder.ts", "builder.js", "mongez.ts", "mongez.js"];
+  for (const candidate of candidates) {
+    const full = path2.join(cwd, candidate);
+    if (fs.existsSync(full)) return full;
+  }
+  throw new Error(
+    `No config file found in ${cwd}. Tried: ${candidates.join(", ")}. Use --config <path> to specify a custom location.`
+  );
+}
+
+// src/files/file-manager.ts
+import fs2 from "fs";
+import path3 from "path";
+function ensureDir(dir) {
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    throw wrapError("ensure-dir", dir, err);
+  }
+}
+function copyFile(src, dest) {
+  ensureDir(path3.dirname(dest));
+  try {
+    fs2.copyFileSync(src, dest);
+  } catch (err) {
+    throw wrapError("copy-file", src, err);
+  }
+}
+var COPY_EXCLUDES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".turbo", ".cache"]);
+function copyDir(src, dest) {
+  ensureDir(dest);
+  const entries = fs2.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (COPY_EXCLUDES.has(entry.name)) continue;
+    const srcPath = joinPath(src, entry.name);
+    const destPath = joinPath(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+function readFile(filePath, packageName = filePath) {
+  try {
+    return fs2.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw wrapError("read-file", packageName, err);
+  }
+}
+function writeFile(filePath, content, packageName = filePath) {
+  ensureDir(path3.dirname(filePath));
+  try {
+    fs2.writeFileSync(filePath, content, "utf-8");
+  } catch (err) {
+    throw wrapError("write-file", packageName, err);
+  }
+}
+function moveFile(src, dest, packageName = src) {
+  ensureDir(path3.dirname(dest));
+  try {
+    fs2.renameSync(src, dest);
+  } catch (err) {
+    try {
+      fs2.copyFileSync(src, dest);
+      fs2.unlinkSync(src);
+    } catch (fallbackErr) {
+      throw wrapError("move-file", packageName, fallbackErr);
+    }
+  }
+}
+function pathExists(p) {
+  return fs2.existsSync(p);
+}
+
+// src/files/package-json.ts
+var KEPT_FIELDS = [
+  "name",
+  "description",
+  "keywords",
+  "author",
+  "license",
+  "repository",
+  "homepage",
+  "bugs",
+  "dependencies",
+  "peerDependencies",
+  "sideEffects",
+  "bin",
+  "engines"
+];
+function readSourcePackageJson(packageRoot, packageName) {
+  const pkgPath = joinPath(packageRoot, "package.json");
+  let raw;
+  try {
+    raw = readFile(pkgPath, packageName);
+  } catch {
+    throw wrapError(
+      "read-package-json",
+      packageName,
+      new Error(`package.json not found at ${pkgPath}`)
+    );
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed.version) {
+      throw new Error(`package.json at ${pkgPath} is missing "version" field`);
+    }
+    return parsed;
+  } catch (err) {
+    throw wrapError("parse-package-json", packageName, err);
+  }
+}
+function writeSourceVersion(packageRoot, packageName, newVersion) {
+  const pkgPath = joinPath(packageRoot, "package.json");
+  const raw = readFile(pkgPath, packageName);
+  const parsed = JSON.parse(raw);
+  parsed.version = newVersion;
+  writeFile(pkgPath, JSON.stringify(parsed, null, 2) + "\n", packageName);
+}
+function writeBuildPackageJson(pkg, sourceJson, buildPath, newVersion) {
+  const formats = pkg.formats ?? ["esm", "cjs"];
+  const hasEsm = formats.includes("esm");
+  const hasCjs = formats.includes("cjs");
+  const esmOnly = hasEsm && !hasCjs;
+  const preserve = pkg.preserveModules !== false;
+  const esmExt = preserve ? ".mjs" : ".js";
+  const cjsExt = preserve ? ".cjs" : ".js";
+  const esmDts = preserve ? ".d.mts" : ".d.ts";
+  const cjsDts = preserve ? ".d.cts" : ".d.ts";
+  const rawEntries = pkg.entries ?? ["index.ts"];
+  const entryList = Array.isArray(rawEntries) ? rawEntries : [rawEntries];
+  function entryPaths(entry) {
+    const basePath = entry.replace(/\.tsx?$/, "");
+    const parts = basePath.split("/");
+    const last = parts[parts.length - 1];
+    let exportPath;
+    if (last === "index") {
+      const dir = parts.slice(0, -1).join("/");
+      exportPath = dir ? `./${dir}` : ".";
+    } else {
+      exportPath = `./${basePath}`;
+    }
+    return { basePath, exportPath };
+  }
+  const { basePath: primaryBase } = entryPaths(entryList[0]);
+  const exportsMap = {};
+  for (const entry of entryList) {
+    const { basePath, exportPath } = entryPaths(entry);
+    const conditions = {};
+    if (hasEsm) {
+      conditions["import"] = {
+        types: `./esm/${basePath}${esmDts}`,
+        default: `./esm/${basePath}${esmExt}`
+      };
+    }
+    if (hasCjs) {
+      const cjsTypes = preserve && hasEsm ? `./esm/${basePath}${esmDts}` : `./cjs/${basePath}${cjsDts}`;
+      conditions["require"] = {
+        types: cjsTypes,
+        default: `./cjs/${basePath}${cjsExt}`
+      };
+    }
+    exportsMap[exportPath] = conditions;
+  }
+  const output = {};
+  for (const field of KEPT_FIELDS) {
+    if (field in sourceJson && sourceJson[field] !== void 0) {
+      output[field] = sourceJson[field];
+    }
+  }
+  output["name"] = pkg.name;
+  output["version"] = newVersion;
+  if (esmOnly) {
+    output["type"] = "module";
+  }
+  const mainType = pkg.mainType ?? "cjs";
+  if (mainType === "esm" || esmOnly) {
+    output["main"] = `./esm/${primaryBase}${esmExt}`;
+  } else {
+    output["main"] = `./cjs/${primaryBase}${cjsExt}`;
+  }
+  if (hasEsm) {
+    output["module"] = `./esm/${primaryBase}${esmExt}`;
+  }
+  output["types"] = `./esm/${primaryBase}${esmDts}`;
+  output["exports"] = exportsMap;
+  const pkgPath = joinPath(buildPath, "package.json");
+  writeFile(pkgPath, JSON.stringify(output, null, 2) + "\n", pkg.name);
+}
+
+// src/files/clone-files.ts
+import fs3 from "fs";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var _verbose = false;
+function log(level, message) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace("Z", "");
+  switch (level) {
+    case "info":
+      console.log(chalk.cyan(`[${ts}] INFO  ${message}`));
+      break;
+    case "success":
+      console.log(chalk.green(`[${ts}] OK    ${message}`));
+      break;
+    case "warn":
+      console.warn(chalk.yellow(`[${ts}] WARN  ${message}`));
+      break;
+    case "error":
+      console.error(chalk.red(`[${ts}] ERROR ${message}`));
+      break;
+    case "step":
+      console.log(chalk.blueBright(`[${ts}] STEP  ${message}`));
+      break;
+    case "debug":
+      if (_verbose) {
+        console.log(chalk.gray(`[${ts}] DEBUG ${message}`));
+      }
+      break;
+  }
+}
+var logger = {
+  info: (msg) => log("info", msg),
+  success: (msg) => log("success", msg),
+  warn: (msg) => log("warn", msg),
+  error: (msg) => log("error", msg),
+  step: (msg) => log("step", msg),
+  debug: (msg) => log("debug", msg)
+};
+
+// src/files/clone-files.ts
+function cloneFiles(packageRoot, buildDir, cloneList, packageName, dryRun) {
+  for (const entry of cloneList) {
+    const [srcRel, destRel] = typeof entry === "string" ? [entry, entry] : entry;
+    const src = joinPath(packageRoot, srcRel);
+    const dest = joinPath(buildDir, destRel);
+    if (!pathExists(src)) {
+      logger.warn(`[clone-files] ${packageName}: source file not found, skipping \u2014 ${src}`);
+      continue;
+    }
+    if (dryRun) {
+      logger.info(`[dry-run] clone ${src} \u2192 ${dest}`);
+      continue;
+    }
+    const stat = fs3.statSync(src);
+    if (stat.isDirectory()) {
+      copyDir(src, dest);
+    } else {
+      copyFile(src, dest);
+    }
+    logger.debug(`Cloned ${src} \u2192 ${dest}`);
+  }
+}
+
+// src/compile/tsdown-compiler.ts
+import path4 from "path";
+import fs4 from "fs";
+import { build } from "tsdown";
+function collectExternals(sourceJson) {
+  const deps = Object.keys(sourceJson["dependencies"] ?? {});
+  const peers = Object.keys(sourceJson["peerDependencies"] ?? {});
+  return [.../* @__PURE__ */ new Set([...deps, ...peers])];
+}
+function resolveEntries(pkg, packageRoot) {
+  const srcDir = pkg.srcDir ?? "src";
+  const rawEntries = pkg.entries ?? ["index.ts"];
+  const entryList = Array.isArray(rawEntries) ? rawEntries : [rawEntries];
+  return entryList.map((e) => toForwardSlash(resolvePath(packageRoot, srcDir, e)));
+}
+function findTsconfig(packageRoot) {
+  const local = joinPath(packageRoot, "tsconfig.json");
+  return pathExists(local) ? local : void 0;
+}
+async function compilePackage(pkg, packageRoot, buildPath, sourceJson, dryRun) {
+  if (dryRun) {
+    logger.info(`[dry-run] compile ${pkg.name} \u2192 ${buildPath}`);
+    return;
+  }
+  const entries = resolveEntries(pkg, packageRoot);
+  const formats = pkg.formats ?? ["esm", "cjs"];
+  const externals = collectExternals(sourceJson);
+  const tsconfig = findTsconfig(packageRoot);
+  const shouldPreserveModules = pkg.preserveModules !== false;
+  const srcDir = toForwardSlash(resolvePath(packageRoot, pkg.srcDir ?? "src"));
+  logger.step(`Compiling ${pkg.name} (${formats.join(", ")}) \u2192 ${buildPath}`);
+  logger.debug(`  entries:   ${entries.join(", ")}`);
+  logger.debug(`  externals: ${externals.slice(0, 8).join(", ")}${externals.length > 8 ? "\u2026" : ""}`);
+  for (const subDir of ["esm", "cjs"]) {
+    const dir = resolvePath(buildPath, subDir);
+    if (fs4.existsSync(dir)) {
+      fs4.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+  const rolldownInputOptions = pkg.type === "react" ? {
+    transform: {
+      jsx: "react-jsx"
+      // automatic runtime — works with React 17+
+    }
+  } : void 0;
+  const sharedOptions = {
+    entry: entries,
+    deps: { neverBundle: externals },
+    sourcemap: pkg.sourcemap !== false,
+    clean: true,
+    minify: pkg.minify ?? false,
+    tsconfig: tsconfig ?? true,
+    ...rolldownInputOptions ? { inputOptions: rolldownInputOptions } : {}
+  };
+  try {
+    if (shouldPreserveModules && formats.includes("esm") && formats.includes("cjs")) {
+      const tmpEsm = toForwardSlash(resolvePath(buildPath, "_tmp_esm"));
+      const tmpCjs = toForwardSlash(resolvePath(buildPath, "_tmp_cjs"));
+      ensureDir(tmpEsm);
+      ensureDir(tmpCjs);
+      await Promise.all([
+        build({
+          ...sharedOptions,
+          format: ["esm"],
+          dts: pkg.dts !== false,
+          outDir: tmpEsm,
+          outputOptions: {
+            preserveModules: true,
+            preserveModulesRoot: srcDir
+          }
+        }),
+        build({
+          ...sharedOptions,
+          format: ["cjs"],
+          // CJS skips DTS — types are served from ESM declarations (see package-json.ts).
+          dts: false,
+          outDir: tmpCjs
+        })
+      ]);
+      reorganiseOutput(tmpEsm, buildPath, ["esm"], pkg, true);
+      reorganiseOutput(tmpCjs, buildPath, ["cjs"], pkg, false, true);
+      rmTmp(tmpEsm);
+      rmTmp(tmpCjs);
+    } else {
+      const tmpDir = toForwardSlash(resolvePath(buildPath, "_tmp"));
+      ensureDir(tmpDir);
+      await build({
+        ...sharedOptions,
+        format: formats,
+        dts: pkg.dts !== false,
+        outDir: tmpDir,
+        ...shouldPreserveModules && formats.includes("esm") ? { outputOptions: { preserveModules: true, preserveModulesRoot: srcDir } } : {}
+      });
+      reorganiseOutput(tmpDir, buildPath, formats, pkg, shouldPreserveModules);
+      rmTmp(tmpDir);
+    }
+  } catch (err) {
+    throw wrapError("tsdown-build", pkg.name, err);
+  }
+  logger.success(`Compiled ${pkg.name}`);
+}
+function rmTmp(dir) {
+  try {
+    fs4.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function reorganiseOutput(tmpDir, buildPath, formats, pkg, preserveModules, keepNativeExtension = false) {
+  const esmDir = joinPath(buildPath, "esm");
+  const cjsDir = joinPath(buildPath, "cjs");
+  if (formats.includes("esm")) ensureDir(esmDir);
+  if (formats.includes("cjs")) ensureDir(cjsDir);
+  const mainType = pkg.mainType ?? (formats.includes("cjs") ? "cjs" : "esm");
+  processDirectory(tmpDir, { esmDir, cjsDir, formats, mainType, pkg, tmpDir, preserveModules, keepNativeExtension });
+}
+function processDirectory(dir, ctx) {
+  if (!fs4.existsSync(dir)) return;
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = joinPath(dir, entry.name);
+    if (entry.isDirectory()) {
+      processDirectory(fullPath, ctx);
+    } else {
+      processFile(fullPath, entry.name, ctx);
+    }
+  }
+}
+function processFile(filePath, name, ctx) {
+  const { esmDir, cjsDir, formats, mainType, pkg, tmpDir, preserveModules } = ctx;
+  const relDir = toForwardSlash(path4.relative(tmpDir, path4.dirname(filePath)));
+  if (preserveModules) {
+    if (isEsmFile(name)) {
+      if (formats.includes("esm")) {
+        moveFile(filePath, joinPath(esmDir, relDir, name), pkg.name);
+      }
+    } else if (isCjsFile(name)) {
+      if (formats.includes("cjs")) {
+        moveFile(filePath, joinPath(cjsDir, relDir, name), pkg.name);
+      }
+    } else if (isDtsFile(name)) {
+      const targetDir = formats.includes("esm") ? esmDir : cjsDir;
+      moveFile(filePath, joinPath(targetDir, relDir, name), pkg.name);
+    }
+    return;
+  }
+  const { keepNativeExtension } = ctx;
+  if (isEsmFile(name)) {
+    if (formats.includes("esm")) {
+      const destName = keepNativeExtension ? name : normaliseEsmName(name);
+      moveFile(filePath, joinPath(esmDir, relDir, destName), pkg.name);
+    }
+  } else if (isCjsFile(name)) {
+    if (formats.includes("cjs")) {
+      const destName = keepNativeExtension ? name : normaliseCjsName(name);
+      moveFile(filePath, joinPath(cjsDir, relDir, destName), pkg.name);
+    }
+  } else if (isDtsFile(name)) {
+    const targetDir = formats.includes("esm") ? esmDir : cjsDir;
+    moveFile(filePath, joinPath(targetDir, relDir, name), pkg.name);
+  } else if (isJsFile(name)) {
+    const targetDir = mainType === "esm" ? esmDir : cjsDir;
+    if (formats.includes(mainType)) {
+      const destName = targetDir === cjsDir ? name.replace(/\.js\.map$/, ".cjs.map").replace(/\.js$/, ".cjs") : name;
+      moveFile(filePath, joinPath(targetDir, relDir, destName), pkg.name);
+    }
+  }
+}
+function isEsmFile(name) {
+  return name.endsWith(".mjs") || name.endsWith(".mjs.map") || name.endsWith(".d.mts") || name.endsWith(".d.mts.map");
+}
+function isCjsFile(name) {
+  return name.endsWith(".cjs") || name.endsWith(".cjs.map") || name.endsWith(".d.cts") || name.endsWith(".d.cts.map");
+}
+function isDtsFile(name) {
+  return name.endsWith(".d.ts") || name.endsWith(".d.ts.map");
+}
+function isJsFile(name) {
+  return (name.endsWith(".js") || name.endsWith(".js.map")) && !name.endsWith(".d.ts") && !name.endsWith(".d.ts.map");
+}
+function normaliseEsmName(name) {
+  return name.replace(/\.mjs\.map$/, ".js.map").replace(/\.mjs$/, ".js").replace(/\.d\.mts\.map$/, ".d.ts.map").replace(/\.d\.mts$/, ".d.ts");
+}
+function normaliseCjsName(name) {
+  return name.replace(/\.cjs\.map$/, ".js.map").replace(/\.cjs$/, ".js").replace(/\.d\.cts\.map$/, ".d.ts.map").replace(/\.d\.cts$/, ".d.ts");
+}
+
+// src/version/increment.ts
+import semver from "semver";
+function resolveVersion(currentVersion, strategy = "auto", packageName) {
+  const bumpType = strategy === "auto" || strategy === "patch" ? "patch" : strategy === "minor" ? "minor" : strategy === "major" ? "major" : null;
+  if (bumpType) {
+    const bumped = semver.inc(currentVersion, bumpType);
+    if (!bumped) {
+      throw wrapError(
+        "version-increment",
+        packageName,
+        new Error(
+          `Cannot ${bumpType}-bump invalid semver version "${currentVersion}" for package "${packageName}"`
+        )
+      );
+    }
+    return bumped;
+  }
+  const cleaned = semver.valid(semver.coerce(strategy) ?? strategy);
+  if (!cleaned) {
+    throw wrapError(
+      "version-increment",
+      packageName,
+      new Error(
+        `Explicit version "${strategy}" is not a valid semver string for package "${packageName}"`
+      )
+    );
+  }
+  return cleaned;
+}
+
+// src/git/operations.ts
+import simpleGit from "simple-git";
+async function isGitRepo(dir) {
+  try {
+    const git = simpleGit(dir);
+    const result = await git.checkIsRepo();
+    return result;
+  } catch {
+    return false;
+  }
+}
+async function gitCommitTagPush(packageRoot, packageName, version, commitMessage, branch, dryRun) {
+  const isRepo = await isGitRepo(packageRoot);
+  if (!isRepo) {
+    logger.warn(`[git] ${packageName}: directory is not a git repo \u2014 skipping git operations`);
+    return;
+  }
+  const tag = `v${version}`;
+  logger.step(`[git] ${packageName}: commit "${commitMessage}", tag ${tag}, push to ${branch}`);
+  if (dryRun) {
+    logger.info(`[dry-run] git add + commit "${commitMessage}" + tag ${tag} + push`);
+    return;
+  }
+  const git = simpleGit(packageRoot);
+  try {
+    await git.add("-A");
+    await git.commit(commitMessage);
+    await git.push("origin", branch);
+    await git.addTag(tag);
+    await git.pushTags("origin");
+    logger.success(`[git] ${packageName}: pushed ${branch}, tagged ${tag}`);
+  } catch (err) {
+    throw wrapError("git-operations", packageName, err);
+  }
+}
+async function currentBranch(dir) {
+  try {
+    const git = simpleGit(dir);
+    const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+    return branch.trim() || "main";
+  } catch {
+    return "main";
+  }
+}
+
+// src/utils/exec.ts
+import { execa } from "execa";
+async function exec(step, packageName, command, args, cwd) {
+  try {
+    const result = await execa(command, args, {
+      cwd,
+      all: true,
+      reject: false
+    });
+    if (result.exitCode !== 0) {
+      const combined = result.all ?? result.stderr ?? "";
+      throw new Error(
+        `Command "${command} ${args.join(" ")}" exited with code ${result.exitCode}.
+${combined}`
+      );
+    }
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.exitCode
+    };
+  } catch (err) {
+    throw wrapError(step, packageName, err);
+  }
+}
+
+// src/publish/npm-publisher.ts
+async function publishPackage(pkg, buildPath, dryRun) {
+  if (pkg.publish === false) {
+    logger.info(`[publish] ${pkg.name}: publish=false, skipping`);
+    return;
+  }
+  const access = pkg.access ?? "public";
+  if (dryRun) {
+    logger.info(`[dry-run] npm publish --access ${access} from ${buildPath}`);
+    return;
+  }
+  logger.step(`Publishing ${pkg.name}@... to npm (access: ${access})`);
+  await exec(
+    "npm-publish",
+    pkg.name,
+    "npm",
+    ["publish", "--access", access],
+    buildPath
+  );
+  logger.success(`Published ${pkg.name}`);
+}
+
+// src/build/package-builder.ts
+async function buildPackage(pkg, versionStrategy = "auto", settings, options, configDir, overrideCommit, forcedVersion) {
+  const step = "package-builder";
+  try {
+    const packageRoot = resolvePath(configDir, pkg.root);
+    const sourceJson = readSourcePackageJson(packageRoot, pkg.name);
+    const currentVersion = sourceJson.version;
+    const newVersion = forcedVersion ?? resolveVersion(currentVersion, versionStrategy, pkg.name);
+    logger.info(`Building ${pkg.name}: ${currentVersion} \u2192 ${newVersion}`);
+    const absoluteBuildDir = resolvePath(configDir, settings.buildDir);
+    const buildPath = buildOutputPath(absoluteBuildDir, pkg.name, newVersion);
+    if (!options.dryRun) {
+      ensureDir(buildPath);
+    }
+    if (settings.sourcesDir) {
+      const absoluteSourcesDir = resolvePath(configDir, settings.sourcesDir);
+      const snapshotPath = sourceSnapshotPath(absoluteSourcesDir, pkg.name);
+      if (options.dryRun) {
+        logger.info(`[dry-run] snapshot ${packageRoot} \u2192 ${snapshotPath}`);
+      } else {
+        ensureDir(snapshotPath);
+        copyDir(packageRoot, snapshotPath);
+        logger.debug(`Snapshot: ${packageRoot} \u2192 ${snapshotPath}`);
+      }
+    }
+    await compilePackage(pkg, packageRoot, buildPath, sourceJson, options.dryRun);
+    if (pkg.clone && pkg.clone.length > 0) {
+      cloneFiles(packageRoot, buildPath, pkg.clone, pkg.name, options.dryRun);
+    }
+    if (!options.dryRun) {
+      writeBuildPackageJson(pkg, sourceJson, buildPath, newVersion);
+      logger.debug(`Wrote build package.json for ${pkg.name}@${newVersion}`);
+    } else {
+      logger.info(`[dry-run] write build package.json for ${pkg.name}@${newVersion}`);
+    }
+    if (!options.dryRun) {
+      writeSourceVersion(packageRoot, pkg.name, newVersion);
+      logger.debug(`Updated source version ${pkg.name} \u2192 ${newVersion}`);
+    } else {
+      logger.info(`[dry-run] update source package.json version \u2192 ${newVersion}`);
+    }
+    const commitMessage = overrideCommit ?? pkg.commit;
+    if (commitMessage && !options.noGit) {
+      const branch = pkg.branch ?? await currentBranch(packageRoot);
+      await gitCommitTagPush(
+        packageRoot,
+        pkg.name,
+        newVersion,
+        commitMessage,
+        branch,
+        options.dryRun
+      );
+    } else if (!commitMessage) {
+      logger.debug(`[git] ${pkg.name}: no commit message set \u2014 skipping git`);
+    }
+    if (!options.noPublish) {
+      await publishPackage(pkg, buildPath, options.dryRun);
+    } else {
+      logger.info(`[publish] ${pkg.name}: --no-publish, skipping`);
+    }
+    return { packageName: pkg.name, version: newVersion, buildPath, success: true };
+  } catch (err) {
+    const wrapped = wrapError(step, pkg.name, err);
+    logger.error(`Failed to build ${pkg.name}: ${wrapped.message}`);
+    return {
+      packageName: pkg.name,
+      version: "",
+      buildPath: "",
+      success: false,
+      error: wrapped
+    };
+  }
+}
+
+// src/build/family-builder.ts
+import semver2 from "semver";
+
+// src/build/parallel-builder.ts
+import pLimit from "p-limit";
+async function runParallel(tasks, concurrency) {
+  if (tasks.length === 0) return [];
+  const limit = pLimit(Math.max(1, concurrency));
+  logger.info(`Running ${tasks.length} task(s) with concurrency=${concurrency}`);
+  const results = await Promise.all(
+    tasks.map((task) => limit(task))
+  );
+  const succeeded = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  if (failed > 0) {
+    logger.warn(`${succeeded} succeeded, ${failed} failed`);
+    for (const r of results.filter((r2) => !r2.success)) {
+      logger.error(`  FAILED: ${r.packageName} \u2014 ${r.error?.message ?? "unknown error"}`);
+    }
+  } else {
+    logger.success(`All ${succeeded} package(s) built successfully`);
+  }
+  return results;
+}
+
+// src/build/family-builder.ts
+async function buildFamily(family, settings, options, configDir) {
+  if (family.packages.length === 0) {
+    logger.warn(`Family "${family.name}" has no packages \u2014 nothing to build`);
+    return [];
+  }
+  let newVersion;
+  try {
+    const strategy = family.version ?? "auto";
+    const isBumpKeyword = strategy === "auto" || strategy === "patch" || strategy === "minor" || strategy === "major";
+    if (!isBumpKeyword && semver2.valid(semver2.coerce(strategy) ?? strategy)) {
+      newVersion = strategy;
+    } else {
+      let highestVersion = "0.0.0";
+      for (const pkg of family.packages) {
+        const root = resolvePath(configDir, pkg.root);
+        const sourceJson = readSourcePackageJson(root, pkg.name);
+        const v = sourceJson.version ?? "0.0.0";
+        if (semver2.gt(v, highestVersion)) {
+          highestVersion = v;
+        }
+      }
+      newVersion = resolveVersion(highestVersion, strategy, family.name);
+    }
+  } catch (err) {
+    throw wrapError("family-version", family.name, err);
+  }
+  logger.info(`Family "${family.name}": shared version \u2192 ${newVersion} (${family.packages.length} packages)`);
+  const concurrency = options.concurrency ?? settings.concurrency ?? 4;
+  const familyCommit = family.commit;
+  const tasks = family.packages.map(
+    (pkg) => () => buildPackage(
+      pkg,
+      "auto",
+      // not used — forcedVersion overrides
+      settings,
+      options,
+      configDir,
+      familyCommit ?? pkg.commit,
+      newVersion
+      // all packages use the same version
+    )
+  );
+  return runParallel(tasks, concurrency);
+}
+export {
+  buildFamily,
+  buildPackage,
+  defineConfig,
+  findDefaultConfigPath,
+  loadConfig,
+  resolveVersion,
+  runParallel
+};
+//# sourceMappingURL=index.js.map