@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-56WPYDJH.js

@@ -0,0 +1,624 @@
+import {
+  legacyTmpWorktreeBase,
+  pathHasHiddenSegment,
+  visibleWorktreeBase
+} from "./chunk-RSYTSBOO.js";
+import {
+  getRejectedPathEnvWarnings,
+  isRealPathWithin,
+  sanitizeEnvPath
+} from "./chunk-STW7OFOA.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  BUILD_HOME_DIR_NAME,
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/config/default-paths.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { existsSync, readdirSync, realpathSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/contained-runtime-root.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function resolveExistingPathPrefix(candidate) {
+  const segments = [];
+  let current = path.resolve(candidate);
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(candidate);
+    }
+    segments.unshift(path.basename(current));
+    current = parent;
+  }
+  const realPrefix = fs.realpathSync(current);
+  return path.join(realPrefix, ...segments);
+}
+function isPathWithin(candidate, parent) {
+  const relative = path.relative(parent, candidate);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function trueUserHome() {
+  try {
+    const passwdHome = os.userInfo().homedir;
+    return passwdHome ? resolveExistingPathPrefix(passwdHome) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isFilesystemRoot(candidate) {
+  const parsed = path.parse(candidate);
+  return candidate === parsed.root;
+}
+function trustedTempRoots() {
+  const roots = /* @__PURE__ */ new Set();
+  for (const root of [
+    os.tmpdir(),
+    "/tmp",
+    "/private/tmp",
+    "/var/tmp",
+    "/private/var/tmp",
+    "/var/folders",
+    "/private/var/folders"
+  ]) {
+    if (root) roots.add(resolveExistingPathPrefix(root));
+  }
+  return [...roots];
+}
+function findTrustedBuildTmpAncestor(candidate) {
+  const parts = candidate.split(path.sep);
+  for (let i = parts.length - 2; i >= 0; i -= 1) {
+    if (parts[i] !== ".build-project" || parts[i + 1] !== "tmp") continue;
+    const buildTmp = parts.slice(0, i + 2).join(path.sep) || path.sep;
+    const projectRoot = parts.slice(0, i).join(path.sep) || path.sep;
+    if (fs.existsSync(path.join(projectRoot, ".git"))) {
+      return buildTmp;
+    }
+  }
+  return void 0;
+}
+function isUnderTrustedRoot(candidate) {
+  if (trustedTempRoots().some((root) => isPathWithin(candidate, root))) {
+    return true;
+  }
+  const buildTmp = findTrustedBuildTmpAncestor(candidate);
+  return !!buildTmp && isPathWithin(candidate, buildTmp);
+}
+function isContainedHomeDirName(name) {
+  return name === "home" || /^home-[A-Za-z0-9._-]+$/.test(name);
+}
+function getContainedHomeSiblingRuntimeRoot(env = process.env) {
+  const rawHome = env?.HOME?.trim();
+  if (!rawHome || rawHome.includes("\0")) return void 0;
+  const resolvedHome = resolveExistingPathPrefix(path.resolve(rawHome));
+  if (!isContainedHomeDirName(path.basename(resolvedHome))) return void 0;
+  const realHome = trueUserHome();
+  if (!realHome || resolvedHome === realHome) return void 0;
+  const runtimeRoot = path.dirname(resolvedHome);
+  if (isFilesystemRoot(runtimeRoot)) return void 0;
+  if (realHome === runtimeRoot) return void 0;
+  if (!isUnderTrustedRoot(runtimeRoot)) return void 0;
+  return runtimeRoot;
+}
+function resolveTrustedBuildHome(candidate, env = process.env, home = env?.HOME?.trim() || os.homedir()) {
+  if (!candidate || candidate.includes("\0") || !path.isAbsolute(candidate)) return void 0;
+  try {
+    const resolved = resolveExistingPathPrefix(candidate);
+    const roots = trustedTempRoots();
+    const containedRoot = getContainedHomeSiblingRuntimeRoot(env);
+    if (containedRoot) roots.push(containedRoot);
+    if (home) {
+      const realHome = resolveExistingPathPrefix(home);
+      if (!isFilesystemRoot(realHome)) roots.push(realHome);
+    }
+    return roots.some((root) => isPathWithin(resolved, root)) ? resolved : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/config/default-paths.ts
+function getDefaultBuildHome() {
+  return join(homedir(), BUILD_HOME_DIR_NAME);
+}
+function expandedBuildHome(env = process.env) {
+  return env.BUILD_HOME?.replace(/^~(?=\/|$)/, () => homedir());
+}
+function sanitizeBuildHome(env = process.env) {
+  const containedRuntimeRoot = getContainedHomeSiblingRuntimeRoot(env);
+  const sanitized = sanitizeEnvPath(expandedBuildHome(env), "BUILD_HOME", {
+    allowHomeDir: true,
+    allowTempDir: true,
+    allowedDirs: containedRuntimeRoot ? [containedRuntimeRoot] : void 0,
+    allowMissingParentDir: true,
+    strictAllowedDirs: true
+  });
+  if (!sanitized) return null;
+  return resolveTrustedBuildHome(sanitized, env, homedir()) ? sanitized : null;
+}
+function getUserCacheDir(env = process.env, home = homedir()) {
+  const buildHome = env.BUILD_HOME ? sanitizeBuildHome(env) : null;
+  return join(buildHome ?? join(home, ".build"), "cache");
+}
+function getUserConfigDir() {
+  if (process.env.BUILD_CONFIG_DIR) {
+    const sanitizedPath = sanitizeEnvPath(process.env.BUILD_CONFIG_DIR, "BUILD_CONFIG_DIR", {
+      allowHomeDir: true,
+      allowTempDir: true,
+      allowMissingParentDir: true,
+      // Only allow config directories, not system paths
+      allowedDirs: [resolve(homedir(), ".config"), resolve(homedir(), ".build")]
+    });
+    if (sanitizedPath) {
+      return sanitizedPath;
+    }
+    emitWarning(
+      "CFG-001",
+      {
+        taskId: "config-paths",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          envVar: "BUILD_CONFIG_DIR",
+          value: process.env.BUILD_CONFIG_DIR,
+          operation: "getUserConfigDir"
+        }
+      }
+    );
+  }
+  if (process.env.BUILD_HOME) {
+    const sanitizedBuildHome = sanitizeBuildHome();
+    if (sanitizedBuildHome) {
+      return join(sanitizedBuildHome, "config");
+    }
+    emitWarning(
+      "CFG-001",
+      {
+        taskId: "config-paths",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          envVar: "BUILD_HOME",
+          value: process.env.BUILD_HOME,
+          operation: "getUserConfigDir"
+        }
+      }
+    );
+  }
+  if (process.env.XDG_CONFIG_HOME) {
+    const containedRuntimeRoot = getContainedHomeSiblingRuntimeRoot(process.env);
+    const xdgPath = sanitizeEnvPath(process.env.XDG_CONFIG_HOME, "XDG_CONFIG_HOME", {
+      allowHomeDir: true,
+      allowTempDir: true,
+      allowedDirs: containedRuntimeRoot ? [containedRuntimeRoot] : void 0,
+      allowMissingParentDir: true,
+      strictAllowedDirs: true
+    });
+    if (xdgPath) {
+      return join(xdgPath, "build");
+    }
+    emitWarning(
+      "CFG-001",
+      {
+        taskId: "config-paths",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          envVar: "XDG_CONFIG_HOME",
+          value: process.env.XDG_CONFIG_HOME,
+          operation: "getUserConfigDir"
+        }
+      }
+    );
+  }
+  return join(getDefaultBuildHome(), "config");
+}
+function getUserConfigFile() {
+  return join(getUserConfigDir(), "build.config.jsonc");
+}
+function getUserPreferencesPath() {
+  return join(getUserConfigDir(), "user-preferences.json");
+}
+function resolveWorktreeBase(startDir) {
+  const buildProjectRoot = resolveBuildRoot(startDir);
+  const override = sanitizeWorktreeBaseOverride(buildProjectRoot);
+  if (override) {
+    return override;
+  }
+  const dataPool = join(getProjectDataDir(buildProjectRoot), "worktrees");
+  if (!pathHasHiddenSegment(dataPool)) {
+    return dataPool;
+  }
+  const visibleBase = visibleWorktreeBase();
+  if (pathHasHiddenSegment(visibleBase)) {
+    return dataPool;
+  }
+  return join(visibleBase, getStableRepoIdentity(buildProjectRoot));
+}
+function listPreviousWorktreePools(startDir) {
+  const buildProjectRoot = resolveBuildRoot(startDir);
+  const current = resolve(resolveWorktreeBase(startDir));
+  const candidates = [
+    join(getProjectDataDir(buildProjectRoot), "worktrees"),
+    join(legacyTmpWorktreeBase(), getStableRepoIdentity(buildProjectRoot))
+  ].map((pool) => resolve(pool));
+  return [...new Set(candidates)].filter((pool) => pool !== current);
+}
+function resolveSessionBase(startDir) {
+  const buildProjectRoot = resolveBuildRoot(startDir);
+  const override = sanitizeWorktreeBaseOverride(buildProjectRoot);
+  if (override) {
+    return override;
+  }
+  return join(getProjectDataDir(buildProjectRoot), "sessions");
+}
+function sanitizeWorktreeBaseOverride(buildProjectRoot) {
+  if (!process.env.BUILD_WORKTREE_BASE) {
+    return void 0;
+  }
+  const sanitizedPath = sanitizeEnvPath(process.env.BUILD_WORKTREE_BASE, "BUILD_WORKTREE_BASE", {
+    allowHomeDir: true,
+    allowTempDir: true,
+    allowMissingParentDir: true,
+    // Worktrees should be in safe locations
+    allowedDirs: [
+      resolve(buildProjectRoot, ".build-project"),
+      resolve(getProjectDataDir(buildProjectRoot)),
+      resolve(homedir(), ".cache", "build")
+    ]
+  });
+  if (sanitizedPath) {
+    return sanitizedPath;
+  }
+  emitWarning(
+    "CFG-001",
+    {
+      taskId: "config-paths",
+      subsystem: "config",
+      executionPhase: "setup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        envVar: "BUILD_WORKTREE_BASE",
+        value: process.env.BUILD_WORKTREE_BASE,
+        operation: "getWorktreeBase"
+      }
+    }
+  );
+  return void 0;
+}
+function canonicalizePath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+}
+var repoIdentityByCwd = /* @__PURE__ */ new Map();
+var repoIdentityByCommonDir = /* @__PURE__ */ new Map();
+function getStableRepoIdentity(cwd = process.cwd()) {
+  const normalizedCwd = resolve(cwd);
+  const cachedByCwd = repoIdentityByCwd.get(normalizedCwd);
+  if (cachedByCwd) {
+    return cachedByCwd;
+  }
+  let commonDir = null;
+  try {
+    const stdout = execSync("git rev-parse --git-common-dir", {
+      cwd: normalizedCwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1500
+    }).toString().trim();
+    if (stdout) {
+      commonDir = isAbsolute(stdout) ? stdout : resolve(normalizedCwd, stdout);
+    }
+  } catch {
+  }
+  const stablePath = canonicalizePath(commonDir ?? resolve(normalizedCwd, ".git"));
+  const cachedByCommonDir = repoIdentityByCommonDir.get(stablePath);
+  if (cachedByCommonDir) {
+    repoIdentityByCwd.set(normalizedCwd, cachedByCommonDir);
+    return cachedByCommonDir;
+  }
+  const identity = createHash("sha256").update(stablePath).digest("hex").slice(0, 12);
+  repoIdentityByCommonDir.set(stablePath, identity);
+  repoIdentityByCwd.set(normalizedCwd, identity);
+  return identity;
+}
+var warnedDataRootRejections = /* @__PURE__ */ new Set();
+function resetGetDataDirRejectionWarningCache() {
+  warnedDataRootRejections.clear();
+}
+function warnRejectedDataRootEnv(envVar, value, fallbackDir, reason) {
+  const cacheKey = `${envVar}\0${value}`;
+  if (warnedDataRootRejections.has(cacheKey)) {
+    return;
+  }
+  warnedDataRootRejections.add(cacheKey);
+  emitWarning(
+    "CFG-001",
+    {
+      taskId: "config-paths",
+      subsystem: "config",
+      executionPhase: "setup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      ...envVar === "BUILD_HOME" ? {
+        message: "Invalid BUILD_HOME; data isolation blocked",
+        recoveryMechanism: "No data-root fallback"
+      } : {},
+      metadata: {
+        envVar,
+        value,
+        reason,
+        ...envVar === "BUILD_DATA_DIR" ? { fallbackTarget: fallbackDir } : {},
+        operation: "getDataDir"
+      }
+    }
+  );
+}
+function getDataDir(env = process.env) {
+  const home = homedir();
+  const fallbackDir = resolve(getDefaultBuildHome(), "data");
+  const xdgBuildDir = env.XDG_DATA_HOME ? resolve(env.XDG_DATA_HOME, "build") : resolve(home, ".local", "share", "build");
+  const containedRuntimeRoot = getContainedHomeSiblingRuntimeRoot(env);
+  if (env.BUILD_DATA_DIR) {
+    const buildDataDirOptions = {
+      allowHomeDir: true,
+      allowTempDir: true,
+      allowMissingParentDir: true,
+      strictAllowedDirs: true,
+      allowedDirs: [
+        fallbackDir,
+        xdgBuildDir,
+        ...containedRuntimeRoot ? [containedRuntimeRoot] : []
+      ]
+    };
+    const sanitizedPath = sanitizeEnvPath(
+      env.BUILD_DATA_DIR,
+      "BUILD_DATA_DIR",
+      buildDataDirOptions
+    );
+    if (sanitizedPath) {
+      return sanitizedPath;
+    }
+    const rejection = getRejectedPathEnvWarnings().find(
+      (warning) => warning.envVar === "BUILD_DATA_DIR" && warning.value === env.BUILD_DATA_DIR
+    );
+    warnRejectedDataRootEnv("BUILD_DATA_DIR", env.BUILD_DATA_DIR, fallbackDir, rejection?.reason);
+  }
+  if (env.BUILD_HOME) {
+    const sanitizedBuildHome = sanitizeBuildHome(env);
+    if (sanitizedBuildHome) {
+      return resolve(sanitizedBuildHome, "data");
+    }
+    const rejection = getRejectedPathEnvWarnings().find(
+      (warning) => warning.envVar === "BUILD_HOME" && warning.value === env.BUILD_HOME
+    );
+    const reason = rejection?.reason;
+    warnRejectedDataRootEnv("BUILD_HOME", env.BUILD_HOME, fallbackDir, reason);
+    throw new Error(`Invalid BUILD_HOME for Build data isolation: ${reason ?? "path rejected"}`);
+  }
+  if (env.XDG_DATA_HOME) {
+    const xdgDataHome = sanitizeEnvPath(env.XDG_DATA_HOME, "XDG_DATA_HOME", {
+      allowHomeDir: true,
+      allowTempDir: true,
+      allowedDirs: containedRuntimeRoot ? [containedRuntimeRoot] : void 0,
+      allowMissingParentDir: true,
+      strictAllowedDirs: true
+    });
+    if (xdgDataHome) {
+      return join(xdgDataHome, "build");
+    }
+    emitWarning(
+      "CFG-001",
+      {
+        taskId: "config-paths",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          envVar: "XDG_DATA_HOME",
+          value: env.XDG_DATA_HOME,
+          operation: "getDataDir"
+        }
+      }
+    );
+  }
+  return fallbackDir;
+}
+function findCwdGitRepoRoot(cwd = process.cwd()) {
+  let current = resolve(cwd);
+  while (true) {
+    if (existsSync(join(current, ".git"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function isPathInsideCwdGitRepo(candidate) {
+  const repoRoot = findCwdGitRepoRoot();
+  return repoRoot !== void 0 && isRealPathWithin(candidate, repoRoot);
+}
+function getStateDir() {
+  if (process.env.BUILD_HOME) {
+    const sanitizedBuildHome = sanitizeBuildHome();
+    if (sanitizedBuildHome) {
+      const candidate = join(sanitizedBuildHome, "state");
+      if (!isPathInsideCwdGitRepo(candidate)) {
+        return candidate;
+      }
+    }
+    emitWarning(
+      "CFG-001",
+      {
+        taskId: "config-paths",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          envVar: "BUILD_HOME",
+          value: process.env.BUILD_HOME,
+          operation: "getStateDir"
+        }
+      }
+    );
+  }
+  if (process.env.XDG_STATE_HOME) {
+    const containedRuntimeRoot = getContainedHomeSiblingRuntimeRoot(process.env);
+    const xdgPath = sanitizeEnvPath(process.env.XDG_STATE_HOME, "XDG_STATE_HOME", {
+      allowHomeDir: true,
+      allowTempDir: true,
+      allowedDirs: containedRuntimeRoot ? [containedRuntimeRoot] : void 0,
+      allowMissingParentDir: true,
+      strictAllowedDirs: true
+    });
+    if (xdgPath) {
+      const candidate = join(xdgPath, "build");
+      if (!isPathInsideCwdGitRepo(candidate)) {
+        return candidate;
+      }
+    }
+    emitWarning(
+      "CFG-001",
+      {
+        taskId: "config-paths",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          envVar: "XDG_STATE_HOME",
+          value: process.env.XDG_STATE_HOME,
+          operation: "getStateDir"
+        }
+      }
+    );
+  }
+  return join(getDefaultBuildHome(), "state");
+}
+function getGlobalTelemetryDir() {
+  return join(getDataDir(), "telemetry");
+}
+function getProjectDataDir(cwd = process.cwd()) {
+  return join(getDataDir(), "projects", getStableRepoIdentity(cwd));
+}
+var PROJECT_WORKTREE_BASES_CACHE_TTL_MS = 5e3;
+var cachedProjectWorktreeBases = null;
+function listDataDirProjectWorktreeBases(dataDir) {
+  const resolvedDataDir = dataDir ?? getDataDir();
+  const now = Date.now();
+  if (cachedProjectWorktreeBases !== null && cachedProjectWorktreeBases.dataDir === resolvedDataDir && now - cachedProjectWorktreeBases.at < PROJECT_WORKTREE_BASES_CACHE_TTL_MS) {
+    return [...cachedProjectWorktreeBases.bases];
+  }
+  const bases = enumerateDataDirProjectWorktreeBases(resolvedDataDir);
+  cachedProjectWorktreeBases = { dataDir: resolvedDataDir, bases, at: now };
+  return [...bases];
+}
+function enumerateDataDirProjectWorktreeBases(dataDir) {
+  try {
+    const projectsDir = join(dataDir, "projects");
+    if (!existsSync(projectsDir)) {
+      return [];
+    }
+    return readdirSync(projectsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^[0-9a-f]{12}$/.test(entry.name)).map((entry) => join(projectsDir, entry.name, "worktrees")).filter((worktreeBase) => existsSync(worktreeBase));
+  } catch {
+    return [];
+  }
+}
+function _resetDataDirProjectWorktreeBasesCache() {
+  cachedProjectWorktreeBases = null;
+}
+function getTemplateDir() {
+  if (process.env.BUILD_TEMPLATE_DIR) {
+    return process.env.BUILD_TEMPLATE_DIR;
+  }
+  const currentFile = fileURLToPath(import.meta.url);
+  const packageRoot = resolve(dirname(currentFile), "../../..");
+  return join(packageRoot, "templates");
+}
+function getDefaultPaths() {
+  const userConfigDir = getUserConfigDir();
+  const templateDir = getTemplateDir();
+  const dataDir = getDataDir();
+  return {
+    // Project configuration (relative to cwd)
+    projectConfigDir: ".build-project/config",
+    projectConfigFile: ".build-project/config/build.config.jsonc",
+    // User configuration
+    userConfigDir,
+    userConfigFile: getUserConfigFile(),
+    userPreferencesFile: join(userConfigDir, "user-preferences.json"),
+    // Runtime directories
+    worktreeBase: resolveWorktreeBase(),
+    dataDir,
+    globalTelemetryDir: join(dataDir, "telemetry"),
+    projectDataDir: getProjectDataDir(),
+    // Template configuration (bundled with CLI)
+    templateConfigDir: templateDir,
+    templateConfigFile: join(templateDir, ".build-project", "config", "build.config.jsonc")
+  };
+}
+function getEnvOverrides() {
+  return {
+    BUILD_CONFIG_DIR: process.env.BUILD_CONFIG_DIR,
+    BUILD_WORKTREE_BASE: process.env.BUILD_WORKTREE_BASE,
+    BUILD_TELEMETRY_DB: process.env.BUILD_TELEMETRY_DB,
+    BUILD_DATA_DIR: process.env.BUILD_DATA_DIR,
+    BUILD_HOME: process.env.BUILD_HOME,
+    XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+    BUILD_TEMPLATE_DIR: process.env.BUILD_TEMPLATE_DIR
+  };
+}
+
+export {
+  getContainedHomeSiblingRuntimeRoot,
+  resolveTrustedBuildHome,
+  getDefaultBuildHome,
+  getUserCacheDir,
+  getUserConfigDir,
+  getUserConfigFile,
+  getUserPreferencesPath,
+  resolveWorktreeBase,
+  listPreviousWorktreePools,
+  resolveSessionBase,
+  getStableRepoIdentity,
+  resetGetDataDirRejectionWarningCache,
+  getDataDir,
+  getStateDir,
+  getGlobalTelemetryDir,
+  getProjectDataDir,
+  listDataDirProjectWorktreeBases,
+  _resetDataDirProjectWorktreeBasesCache,
+  getDefaultPaths,
+  getEnvOverrides
+};
+//# sourceMappingURL=chunk-56WPYDJH.js.map

package/dist/chunk-57WRCJJW.js

@@ -0,0 +1,50 @@
+import {
+  GitWorktreeManager
+} from "./chunk-VJER3FUS.js";
+import {
+  BUILD_VARIANT_WORKER,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/orchestrator/worktrees/worktree-manager-factory.ts
+function getWorktreeManager(options = {}) {
+  const { baseDir, gitCwd } = options;
+  const isVariantWorker = readEnv(BUILD_VARIANT_WORKER).value === true;
+  const enablePooling = isVariantWorker ? false : options.enablePooling ?? true;
+  return new GitWorktreeManager(baseDir, enablePooling, gitCwd, {
+    preserveWorktrees: options.preserveWorktrees
+  });
+}
+var WorktreeManagerPresets = {
+  /**
+   * Default preset - pooling enabled for best performance
+   * Recommended for all production use cases
+   */
+  default: (gitCwd, preserveWorktrees) => getWorktreeManager({ enablePooling: true, gitCwd, preserveWorktrees }),
+  /**
+   * For long-running orchestrators (LocalExecutor)
+   * Enables pooling for 50-75% faster allocation
+   * @deprecated Use default preset instead - pooling is now enabled by default
+   */
+  orchestrator: () => getWorktreeManager({ enablePooling: true }),
+  /**
+   * For debugging - disables pooling for manual worktree inspection
+   * Only use when you need to preserve worktrees for debugging
+   */
+  debug: () => getWorktreeManager({ enablePooling: false }),
+  /**
+   * Legacy preset - no pooling (minimal overhead, simple cleanup)
+   * @deprecated Pooling is now enabled by default for better performance
+   */
+  simple: () => getWorktreeManager({ enablePooling: false }),
+  /**
+   * For testing - allows full control over options
+   */
+  test: (options) => getWorktreeManager(options)
+};
+
+export {
+  getWorktreeManager,
+  WorktreeManagerPresets
+};
+//# sourceMappingURL=chunk-57WRCJJW.js.map

package/dist/chunk-5AW4RMNG.js

@@ -0,0 +1,24 @@
+// src/cli/errors/exit-code-error.ts
+function reportExitCodeError(error) {
+  if (error.exitCode === 0 || error.reported) return;
+  const message = error.message.trim();
+  if (message === "") return;
+  process.stderr.write(`Error: ${message}
+`);
+}
+var PartialSyncError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PartialSyncError";
+  }
+};
+function isPartialSyncError(error) {
+  return error instanceof Error && error.name === "PartialSyncError";
+}
+
+export {
+  reportExitCodeError,
+  PartialSyncError,
+  isPartialSyncError
+};
+//# sourceMappingURL=chunk-5AW4RMNG.js.map