@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-BIUV23HH.js

@@ -0,0 +1,729 @@
+import {
+  ProjectLinkRetargetError,
+  clearDependencySetupFailure,
+  cloneDirectory,
+  describeDependencySourceMismatch,
+  ensureEmptyTarget,
+  ensureWorktreeDependencyExcludes,
+  ensureWorktreeGitExclude,
+  findProjectLinks,
+  listNodeWorkspaceMembers,
+  parseProjectDependencySetupCommand,
+  prepareWorktreeEnvironments,
+  recordDependencySetupFailure,
+  retargetProjectLinks,
+  runDependencySetup
+} from "./chunk-AHU3FKPA.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  isTrustedProjectRoot
+} from "./chunk-QJ6OEH4K.js";
+import {
+  BUILD_WORKTREE_DEPENDENCY_ROOT,
+  BUILD_WORKTREE_DEPENDENCY_ROOTS,
+  BUILD_WORKTREE_NODE_MODULES_STRATEGY,
+  getRuntimeEnv,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/project/installed-dependency-drift.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var NODE_MODULES_SEGMENT = "node_modules/";
+async function readLockfilePackages(filePath) {
+  const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const packages = parsed.packages;
+  return typeof packages === "object" && packages !== null ? packages : null;
+}
+function entryVersion(entry) {
+  if (typeof entry !== "object" || entry === null) return void 0;
+  const version = entry.version;
+  return typeof version === "string" ? version : void 0;
+}
+function compareInstalledDependencyPackages(locked, installed) {
+  const drift = [];
+  for (const [key, entry] of Object.entries(installed)) {
+    const installedVersion = entryVersion(entry);
+    const lockedVersion = entryVersion(locked[key]);
+    if (!installedVersion || !lockedVersion || installedVersion === lockedVersion) continue;
+    const nameStart = key.lastIndexOf(NODE_MODULES_SEGMENT);
+    drift.push({
+      name: nameStart >= 0 ? key.slice(nameStart + NODE_MODULES_SEGMENT.length) : key,
+      installed: installedVersion,
+      locked: lockedVersion
+    });
+  }
+  return drift;
+}
+async function findInstalledDependencyDrift(projectRoot, installedRoot = projectRoot) {
+  const lockfilePath = path.join(projectRoot, "package-lock.json");
+  const installedPath = path.join(installedRoot, "node_modules", ".package-lock.json");
+  try {
+    const [locked, installed] = await Promise.all([
+      readLockfilePackages(lockfilePath),
+      readLockfilePackages(installedPath)
+    ]);
+    if (!locked || !installed) return [];
+    return compareInstalledDependencyPackages(locked, installed);
+  } catch {
+    return [];
+  }
+}
+
+// src/utils/node-modules.ts
+import { existsSync, readFileSync } from "fs";
+import * as fs3 from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { execa } from "execa";
+
+// src/utils/node-workspace-modules.ts
+import { lstatSync } from "fs";
+import * as fs2 from "fs/promises";
+import path2 from "path";
+function isRealDirectory(target) {
+  try {
+    const stat = lstatSync(target);
+    return stat.isDirectory() && !stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function exists(target) {
+  try {
+    lstatSync(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function materializeWorkspaceNodeModules(options) {
+  const created = [];
+  try {
+    for (const member of listNodeWorkspaceMembers(options.worktreePath)) {
+      const from = path2.join(options.sourceRoot, member, "node_modules");
+      const to = path2.join(options.worktreePath, member, "node_modules");
+      if (!isRealDirectory(from) || exists(to)) continue;
+      await fs2.mkdir(path2.dirname(to), { recursive: true });
+      created.push(to);
+      await cloneDirectory(from, to);
+      retargetProjectLinks(to, options.sourceRoot, options.worktreePath);
+    }
+  } catch (error) {
+    for (const directory of created) await ensureEmptyTarget(directory);
+    throw error;
+  }
+  const relative = created.map(
+    (directory) => path2.relative(options.worktreePath, directory).replace(/\\/g, "/")
+  );
+  if (relative.length > 0) {
+    await ensureWorktreeDependencyExcludes(options.worktreePath, relative);
+  }
+  return relative;
+}
+
+// src/utils/node-modules.ts
+var BUILD_PACKAGE_NAME = "@ebrindley/build";
+function parseStrategy(raw) {
+  const value = (raw ?? "").trim().toLowerCase();
+  if (value === "clone" || value === "symlink" || value === "off") return value;
+  return "clone";
+}
+async function pathExists(p) {
+  try {
+    await fs3.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function recordWarning(warnings, logger, message) {
+  warnings.push(message);
+  logger?.warn?.(message);
+}
+function uniqueExistingRoots(roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const root of roots) {
+    const trimmed = root?.trim();
+    if (!trimmed) continue;
+    const resolved = path3.resolve(trimmed);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    result.push(resolved);
+  }
+  return result;
+}
+function splitEnvPathList(value) {
+  return value ? value.split(path3.delimiter).map((entry) => entry.trim()).filter(Boolean) : [];
+}
+async function findBuildPackageRoot() {
+  let current = path3.dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const packageJson = path3.join(current, "package.json");
+    try {
+      const parsed = JSON.parse(await fs3.readFile(packageJson, "utf8"));
+      if (parsed.name === "@ebrindley/build") return current;
+    } catch {
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+async function readPackageName(root) {
+  try {
+    const parsed = JSON.parse(await fs3.readFile(path3.join(root, "package.json"), "utf8"));
+    return typeof parsed.name === "string" ? parsed.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolvePackageRootFallback(repoRoot) {
+  const packageRoot = await findBuildPackageRoot();
+  if (!packageRoot) return void 0;
+  const [repoName, packageName] = await Promise.all([
+    readPackageName(repoRoot),
+    readPackageName(packageRoot)
+  ]);
+  return repoName && repoName === packageName ? packageRoot : void 0;
+}
+async function resolveLinkedWorktreeSourceRoot(repoRoot) {
+  try {
+    const dotGit = await fs3.readFile(path3.join(repoRoot, ".git"), "utf8");
+    const match = /^gitdir:\s*(.+)$/m.exec(dotGit.trim());
+    if (!match?.[1]) return void 0;
+    const gitDir = path3.resolve(repoRoot, match[1]);
+    const worktreesDir = path3.dirname(gitDir);
+    if (path3.basename(worktreesDir) !== "worktrees") return void 0;
+    const commonGitDir = path3.dirname(worktreesDir);
+    const sourceRoot = path3.dirname(commonGitDir);
+    if (sourceRoot === repoRoot) return void 0;
+    await fs3.access(path3.join(sourceRoot, ".git"));
+    return sourceRoot;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveNodeModulesSource(options, warnings) {
+  const repoRoot = path3.resolve(options.repoRoot);
+  const repoPackageName = await readPackageName(repoRoot);
+  const log = options.logger;
+  const roots = uniqueExistingRoots([
+    ...splitEnvPathList(readRawEnv(BUILD_WORKTREE_DEPENDENCY_ROOTS)),
+    ...splitEnvPathList(readRawEnv(BUILD_WORKTREE_DEPENDENCY_ROOT)),
+    ...options.sourceRoots ?? [],
+    repoRoot,
+    await resolveLinkedWorktreeSourceRoot(repoRoot),
+    await resolvePackageRootFallback(options.repoRoot)
+  ]);
+  for (const root of roots) {
+    const nodeModulesPath = path3.join(root, "node_modules");
+    if (!await pathExists(nodeModulesPath)) continue;
+    const mismatch = await describeDependencySourceMismatch(options.worktreePath, root, "node");
+    const drift = await findInstalledDependencyDrift(options.worktreePath, root);
+    if (mismatch || drift.length > 0) {
+      recordWarning(
+        warnings,
+        log,
+        `[worktrees] skipping node_modules source ${root}: ${mismatch ?? "installed dependencies differ from candidate package-lock.json"}`
+      );
+      continue;
+    }
+    const sourcePackageName = root === repoRoot ? repoPackageName : await readPackageName(root);
+    if (root !== repoRoot) {
+      if (repoPackageName && sourcePackageName && repoPackageName !== sourcePackageName) {
+        recordWarning(
+          warnings,
+          log,
+          `[worktrees] skipping node_modules source ${root}: package name "${sourcePackageName}" does not match "${repoPackageName}"`
+        );
+        continue;
+      }
+      if (repoPackageName && !sourcePackageName) {
+        recordWarning(
+          warnings,
+          log,
+          `[worktrees] skipping node_modules source ${root}: missing package.json name for compatibility check`
+        );
+        continue;
+      }
+      if (!repoPackageName || !sourcePackageName) {
+        recordWarning(
+          warnings,
+          log,
+          `[worktrees] using node_modules source ${root} without package-name compatibility confirmation`
+        );
+      }
+    }
+    if (sourcePackageName === BUILD_PACKAGE_NAME) {
+      const preflightPath = path3.join(root, "scripts", "assert-node-runtime.mjs");
+      if (!await pathExists(preflightPath)) {
+        recordWarning(
+          warnings,
+          log,
+          `[worktrees] skipping node_modules source ${root}: Node runtime preflight is unavailable`
+        );
+        continue;
+      }
+      const preflight = await execa(
+        process.execPath,
+        [preflightPath, "--root", root, "--native", "required"],
+        { reject: false, stdio: "pipe" }
+      );
+      if ((preflight.exitCode ?? 1) !== 0) {
+        const detail = String(preflight.stderr ?? preflight.stdout ?? "").trim();
+        recordWarning(
+          warnings,
+          log,
+          `[worktrees] skipping node_modules source ${root}: Node/native readiness failed${detail ? ` (${detail.slice(-500)})` : ""}`
+        );
+        continue;
+      }
+    }
+    return { root, nodeModulesPath };
+  }
+  return void 0;
+}
+async function resolveSymlinkSource(source, repoRoot, candidateRoot) {
+  const repoNodeModules = path3.join(repoRoot, "node_modules");
+  if (await pathExists(repoNodeModules) && !await describeDependencySourceMismatch(candidateRoot, repoRoot, "node") && (await findInstalledDependencyDrift(candidateRoot, repoRoot)).length === 0) {
+    return { root: repoRoot, nodeModulesPath: repoNodeModules };
+  }
+  return source;
+}
+function usesYarnPnp(root) {
+  if (existsSync(path3.join(root, ".pnp.cjs")) || existsSync(path3.join(root, ".pnp.js"))) {
+    return true;
+  }
+  try {
+    return /^\s*nodeLinker:\s*["']?pnp["']?\s*(?:#.*)?$/m.test(
+      readFileSync(path3.join(root, ".yarnrc.yml"), "utf8")
+    );
+  } catch {
+    return false;
+  }
+}
+async function provisionWorkspaceMemberModules(worktreePath, sourceRoot) {
+  if (usesYarnPnp(worktreePath)) return;
+  await materializeWorkspaceNodeModules({ sourceRoot, worktreePath });
+}
+function isDisposableWorktree(options) {
+  const own = path3.resolve(options.worktreePath);
+  return ![options.repoRoot, ...options.sourceRoots ?? []].some(
+    (root) => path3.resolve(root) === own
+  );
+}
+async function installNodeDependenciesFromLockfile(options, setupPlan, warnings) {
+  if (!isDisposableWorktree(options) || usesYarnPnp(options.worktreePath)) return void 0;
+  const installs = (setupPlan?.commands ?? []).filter((command) => {
+    const setup = parseProjectDependencySetupCommand(command);
+    return setup !== null && ["npm", "pnpm", "yarn", "bun"].includes(setup.file) && (setup.args[0] === "ci" || setup.args[0] === "install");
+  });
+  if (installs.length === 0) return void 0;
+  const worktreePath = options.worktreePath;
+  const target = path3.join(worktreePath, "node_modules");
+  const locked = installs.every((command) => {
+    const args = parseProjectDependencySetupCommand(command)?.args ?? [];
+    return args[0] === "ci" || args.includes("--frozen-lockfile");
+  });
+  const bootstrap = options.allowManifestBootstrap === true && !await pathExists(path3.join(options.repoRoot, "package.json"));
+  if (!locked && !bootstrap) {
+    const reason = "No node_modules source and no lockfile to install from; run the package manager install in the worktree";
+    recordDependencySetupFailure(worktreePath, {
+      ecosystem: "node",
+      cause: reason,
+      ignoredOnceInstalled: true
+    });
+    return { ecosystem: "node", action: "setup-required", reason, warnings };
+  }
+  try {
+    await ensureWorktreeGitExclude(worktreePath, ["node_modules/"]);
+    await ensureWorktreeDependencyExcludes(worktreePath, ["node_modules"]);
+    for (const command of installs) await runDependencySetup(worktreePath, command);
+    if (!await pathExists(target)) {
+      throw new Error("Lockfile install completed without creating node_modules");
+    }
+    clearDependencySetupFailure(worktreePath, "node");
+    return {
+      ecosystem: "node",
+      action: "provisioned",
+      reason: `Installed project dependencies in the worktree (${installs.join(" && ")})`,
+      warnings
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await ensureEmptyTarget(target);
+    recordWarning(
+      warnings,
+      options.logger,
+      `[worktrees] failed to install node dependencies for ${worktreePath}: ${message}`
+    );
+    recordDependencySetupFailure(worktreePath, { ecosystem: "node", cause: message });
+    if (!(options.bestEffort ?? true)) throw error;
+    return { ecosystem: "node", action: "setup-required", reason: message, warnings };
+  }
+}
+async function prepareNodeWorktreeDependencies(options, setupPlan) {
+  const explicitStrategy = readRawEnv(BUILD_WORKTREE_NODE_MODULES_STRATEGY);
+  if (options.artifactMode === "cache-only" && !explicitStrategy && !options.strategy) {
+    return {
+      ecosystem: "node",
+      action: "cache-relied",
+      reason: "Node dependency preparation relies on package-manager caches; repo-local node_modules cloning is disabled for this worktree",
+      warnings: []
+    };
+  }
+  const strategy = options.strategy ?? parseStrategy(explicitStrategy);
+  const bestEffort = options.bestEffort ?? true;
+  const log = options.logger;
+  const warnings = [];
+  if (strategy === "off") {
+    return {
+      ecosystem: "node",
+      action: "skipped",
+      reason: "Node dependency preparation disabled by strategy off",
+      warnings
+    };
+  }
+  const target = path3.join(options.worktreePath, "node_modules");
+  const excludeDependencies = async () => {
+    await ensureWorktreeDependencyExcludes(options.worktreePath, ["node_modules"]).catch(
+      (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        recordWarning(
+          warnings,
+          log,
+          `[worktrees] failed to exclude node_modules for ${options.worktreePath}: ${message}`
+        );
+        if (!bestEffort) throw error;
+      }
+    );
+  };
+  let existingTarget;
+  try {
+    existingTarget = await fs3.lstat(target);
+  } catch {
+  }
+  if (existingTarget && !existingTarget.isSymbolicLink()) {
+    await excludeDependencies();
+    return {
+      ecosystem: "node",
+      action: "skipped",
+      reason: "Worktree already has node_modules",
+      sourcePath: target,
+      warnings
+    };
+  }
+  const source = await resolveNodeModulesSource(options, warnings);
+  if (!source) {
+    const installed = await pathExists(target) ? void 0 : await installNodeDependenciesFromLockfile(options, setupPlan, warnings);
+    if (installed) return installed;
+    return {
+      ecosystem: "node",
+      action: "skipped",
+      reason: "No compatible node_modules source found",
+      warnings
+    };
+  }
+  await excludeDependencies();
+  try {
+    if (existingTarget?.isSymbolicLink() && strategy !== "symlink") {
+      await ensureEmptyTarget(target);
+    } else if (existingTarget) {
+      return {
+        ecosystem: "node",
+        action: "skipped",
+        reason: "Worktree already has node_modules",
+        sourcePath: source.nodeModulesPath,
+        sourceRoot: source.root,
+        warnings
+      };
+    }
+  } catch {
+  }
+  try {
+    const symlinkSource = strategy === "symlink" ? await resolveSymlinkSource(source, path3.resolve(options.repoRoot), options.worktreePath) : void 0;
+    const projectLinks = symlinkSource ? findProjectLinks(symlinkSource.nodeModulesPath, symlinkSource.root) : [];
+    if (symlinkSource && projectLinks.length === 0) {
+      await fs3.symlink(
+        symlinkSource.nodeModulesPath,
+        target,
+        process.platform === "win32" ? "junction" : "dir"
+      );
+      await provisionWorkspaceMemberModules(options.worktreePath, symlinkSource.root);
+      clearDependencySetupFailure(options.worktreePath, "node");
+      return {
+        ecosystem: "node",
+        action: "symlinked",
+        reason: "Symlinked node_modules from compatible dependency source",
+        sourcePath: symlinkSource.nodeModulesPath,
+        sourceRoot: symlinkSource.root,
+        warnings
+      };
+    }
+    log?.debug?.(`[worktrees] cloning node_modules from ${source.root} into ${target}`);
+    await cloneDirectory(source.nodeModulesPath, target);
+    retargetProjectLinks(target, source.root, options.worktreePath);
+    await provisionWorkspaceMemberModules(options.worktreePath, source.root);
+    clearDependencySetupFailure(options.worktreePath, "node");
+    return {
+      ecosystem: "node",
+      action: "cloned",
+      reason: projectLinks.length > 0 ? "Cloned node_modules instead of symlinking it: workspace or file: links would load the source checkout" : "Cloned node_modules from compatible dependency source",
+      sourcePath: source.nodeModulesPath,
+      sourceRoot: source.root,
+      warnings
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await ensureEmptyTarget(target);
+    recordWarning(
+      warnings,
+      log,
+      `[worktrees] failed to provision node_modules for ${options.worktreePath}: ${message}`
+    );
+    recordDependencySetupFailure(options.worktreePath, {
+      ecosystem: "node",
+      cause: message
+    });
+    if (!bestEffort) throw error;
+    return {
+      ecosystem: "node",
+      action: "skipped",
+      reason: error instanceof ProjectLinkRetargetError ? `node_modules cloned from the source checkout is unusable for verification: ${message}` : "Failed to provision node_modules; continuing because preparation is best-effort",
+      sourcePath: source.nodeModulesPath,
+      sourceRoot: source.root,
+      warnings
+    };
+  }
+}
+function toEnvironmentResult(result) {
+  const provisioned = result.action === "cloned" || result.action === "symlinked" || result.action === "provisioned";
+  const present = result.action === "skipped" && /already has/.test(result.reason);
+  const action = provisioned || present ? "provisioned" : result.action === "cache-relied" ? "cache-relied" : "setup-required";
+  return {
+    ecosystem: result.ecosystem,
+    action,
+    reason: result.reason,
+    envRoot: result.sourcePath,
+    sourceRoot: result.sourceRoot,
+    warnings: result.warnings
+  };
+}
+async function prepareWorktreeDependencies(options) {
+  const repoRoot = path3.resolve(options.repoRoot);
+  let nodeResult;
+  const environments = await prepareWorktreeEnvironments({
+    repoRoot,
+    worktreePath: options.worktreePath,
+    sourceRoots: options.sourceRoots,
+    bestEffort: options.bestEffort,
+    logger: options.logger,
+    prepareNode: async (setupPlan) => {
+      nodeResult = await prepareNodeWorktreeDependencies({ ...options, repoRoot }, setupPlan);
+      return toEnvironmentResult(nodeResult);
+    }
+  });
+  const warnings = environments.flatMap((environment) => environment.warnings);
+  if (nodeResult)
+    return { ...nodeResult, warnings, environments };
+  const primary = environments[0];
+  if (!primary) throw new Error("worktree environment preparation returned no result");
+  return {
+    ecosystem: primary.ecosystem,
+    action: primary.action === "unavailable" ? "unsupported" : primary.action,
+    reason: primary.reason,
+    sourcePath: primary.envRoot,
+    sourceRoot: primary.sourceRoot,
+    warnings,
+    environments
+  };
+}
+
+// src/utils/worktree-env-files.ts
+import { chmod, copyFile, lstat as lstat2, mkdir as mkdir2, realpath } from "fs/promises";
+import path4 from "path";
+var LEGACY_ENV_FILE_NAMES = [".env", ".env.local"];
+var USER_SCOPE_SOURCE_TYPES = ["user", "profile"];
+var GIT_PROBE_TIMEOUT_MS = 15e3;
+var managersByRoot = /* @__PURE__ */ new Map();
+var untrustedProjectNoticeRoots = /* @__PURE__ */ new Set();
+function normalizeEnvFileName(raw) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.includes("\0") || /[*?[\]{}]/.test(trimmed)) return void 0;
+  if (path4.isAbsolute(trimmed) || path4.win32.isAbsolute(trimmed)) return void 0;
+  const normalized = path4.posix.normalize(trimmed.replace(/\\/g, "/"));
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../")) return void 0;
+  if (normalized.endsWith("/")) return void 0;
+  const firstSegment = normalized.split("/")[0];
+  if (firstSegment === ".git") return void 0;
+  return normalized;
+}
+function configuredNamesFromSources(sources, repoRoot, logger) {
+  const names = [];
+  for (const source of sources) {
+    const list = source.data?.worktree?.copyEnvFiles;
+    if (!Array.isArray(list)) continue;
+    if (USER_SCOPE_SOURCE_TYPES.includes(source.type)) {
+      names.push(...list);
+    } else if (source.type === "project") {
+      if (isTrustedProjectRoot(repoRoot)) {
+        names.push(...list);
+      } else if (!untrustedProjectNoticeRoots.has(repoRoot)) {
+        untrustedProjectNoticeRoots.add(repoRoot);
+        logger?.warn?.(
+          "Ignoring worktree.copyEnvFiles from project config: copying env files needs BUILD_TRUST_PROJECT_PROVIDER_TEMPLATES to name this project root, or set it in user config."
+        );
+      }
+    }
+  }
+  return names;
+}
+async function resolveWorktreeEnvFileNames(repoRoot, logger) {
+  const raw = [];
+  if (getRuntimeEnv("BUILD_COPY_ENV_TO_WORKTREES") === "1") raw.push(...LEGACY_ENV_FILE_NAMES);
+  try {
+    let manager = managersByRoot.get(repoRoot);
+    if (!manager) {
+      const { ConfigManager: Manager } = await import("./config-manager-J2UTO635.js");
+      manager = new Manager({ cwd: repoRoot });
+      managersByRoot.set(repoRoot, manager);
+    }
+    const loaded = await manager.loadConfig();
+    raw.push(...configuredNamesFromSources(loaded.sources, repoRoot, logger));
+  } catch {
+  }
+  const names = [];
+  for (const entry of raw) {
+    const name = normalizeEnvFileName(entry);
+    if (name === void 0) {
+      logger?.warn?.(
+        "Ignoring an invalid worktree.copyEnvFiles entry: use a repo-relative file path."
+      );
+      continue;
+    }
+    if (!names.includes(name)) names.push(name);
+  }
+  return names;
+}
+async function isTracked(worktreePath, name) {
+  try {
+    const result = await execGit(["ls-files", "--error-unmatch", "--", name], {
+      cwd: worktreePath,
+      timeoutMs: GIT_PROBE_TIMEOUT_MS
+    });
+    return result.exitCode !== 1;
+  } catch {
+    return true;
+  }
+}
+async function isIgnored(worktreePath, name) {
+  try {
+    const result = await execGit(["check-ignore", "-q", "--", name], {
+      cwd: worktreePath,
+      timeoutMs: GIT_PROBE_TIMEOUT_MS
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+function isWithin(root, candidate) {
+  const relative = path4.relative(root, candidate);
+  return !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+async function sourceRejection(repoRoot, name) {
+  const source = path4.join(repoRoot, ...name.split("/"));
+  let stat;
+  try {
+    stat = await lstat2(source);
+  } catch {
+    return "not present in the checkout";
+  }
+  if (!stat.isFile()) return "not a regular file";
+  try {
+    if (!isWithin(await realpath(repoRoot), await realpath(source))) {
+      return "resolves outside the checkout";
+    }
+  } catch {
+    return "not present in the checkout";
+  }
+  return void 0;
+}
+async function destinationRejection(worktreePath, name) {
+  const destination = path4.join(worktreePath, ...name.split("/"));
+  try {
+    const stat = await lstat2(destination);
+    if (stat.isSymbolicLink() || !stat.isFile()) return "destination is not a regular file";
+  } catch {
+  }
+  try {
+    await mkdir2(path4.dirname(destination), { recursive: true });
+    if (!isWithin(await realpath(worktreePath), await realpath(path4.dirname(destination)))) {
+      return "destination resolves outside the worktree";
+    }
+  } catch {
+    return "destination directory is not writable";
+  }
+  return void 0;
+}
+async function copyConfiguredEnvFilesToWorktree(options) {
+  const result = { copied: [], skipped: [] };
+  const repoRoot = path4.resolve(options.repoRoot);
+  const worktreePath = path4.resolve(options.worktreePath);
+  const names = options.names ?? await resolveWorktreeEnvFileNames(repoRoot, options.logger);
+  if (names.length === 0 || repoRoot === worktreePath) return result;
+  const skip = (name, reason) => {
+    result.skipped.push({ name, reason });
+    options.logger?.warn?.(`Skipping ${name} env file copy: ${reason}.`);
+  };
+  for (const name of names) {
+    const rejected = await sourceRejection(repoRoot, name);
+    if (rejected) {
+      result.skipped.push({ name, reason: rejected });
+      options.logger?.debug?.(`Skipping ${name} env file copy: ${rejected}.`);
+      continue;
+    }
+    if (await isTracked(worktreePath, name)) {
+      skip(name, "tracked at the requested ref, so copying would dirty the worktree");
+      continue;
+    }
+    if (!await isIgnored(worktreePath, name)) {
+      await ensureWorktreeGitExclude(worktreePath, [`/${name}`]).catch(() => void 0);
+      if (!await isIgnored(worktreePath, name)) {
+        skip(name, "could not exclude it from git status");
+        continue;
+      }
+    }
+    const blocked = await destinationRejection(worktreePath, name);
+    if (blocked) {
+      skip(name, blocked);
+      continue;
+    }
+    try {
+      const destination = path4.join(worktreePath, ...name.split("/"));
+      await copyFile(path4.join(repoRoot, ...name.split("/")), destination);
+      await chmod(destination, 384);
+      result.copied.push(name);
+    } catch {
+      skip(name, "copy failed");
+    }
+  }
+  if (result.copied.length > 0) {
+    options.logger?.debug?.(`Copied ${result.copied.length} env file(s) into the worktree.`);
+  }
+  return result;
+}
+
+export {
+  findInstalledDependencyDrift,
+  prepareWorktreeDependencies,
+  copyConfiguredEnvFilesToWorktree
+};
+//# sourceMappingURL=chunk-BIUV23HH.js.map