@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-PEBWDYIW.js

@@ -0,0 +1,726 @@
+import {
+  DEFAULT_LOCAL_CI_MAX_CONCURRENT,
+  DEFAULT_LOCAL_CI_STATUS_CONTEXT,
+  selectCommandsForLocalCi
+} from "./chunk-VBENAHDA.js";
+import {
+  buildProjectVerificationGuidance,
+  deriveProjectDependencySetupPlan,
+  nestedCoverageGap,
+  parseProjectDependencySetupCommand,
+  verificationCommandsCoverChangedPaths
+} from "./chunk-AHU3FKPA.js";
+import {
+  consumeBuildConfigRead,
+  readCanonicalBuildConfig,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  BUILD_LOCAL_CI_LANDING_LEASE,
+  emitCustomWarning,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/ci/local-ci-config.ts
+import path2 from "path";
+
+// src/core/project/validation-authority.ts
+import { readFileSync } from "fs";
+import path from "path";
+var AUTHORITY_EXACT_PATHS = /* @__PURE__ */ new Set([
+  ".build-project/config/build.config.jsonc",
+  "build.config.jsonc",
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "tox.ini",
+  "pytest.ini",
+  "go.mod",
+  "cargo.toml",
+  "pom.xml",
+  "gradle.properties",
+  "package.swift",
+  "pubspec.yaml",
+  "gemfile",
+  "rakefile",
+  "composer.json",
+  "makefile",
+  "cmakelists.txt",
+  "cmakepresets.json",
+  "meson.build",
+  "deno.json",
+  "deno.jsonc",
+  "turbo.json",
+  "justfile",
+  "taskfile.yml",
+  "taskfile.yaml"
+]);
+var AUTHORITY_PREFIXES = [".githooks/", ".build-project/config/", ".build-project/guard/"];
+var BUILD_SOURCE_AUTHORITY_PREFIXES = [
+  "src/core/ci/",
+  "src/core/project/",
+  "src/core/verification/",
+  "scripts/release/"
+];
+var SHELL_INTERPRETERS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh", "fish"]);
+var PYTHON_INTERPRETERS = /* @__PURE__ */ new Set(["python", "python2", "python3", "pypy", "pypy3"]);
+var LANGUAGE_INTERPRETERS = /* @__PURE__ */ new Set([
+  "node",
+  "nodejs",
+  "deno",
+  "bun",
+  "ruby",
+  "perl",
+  "php",
+  "lua",
+  "luajit",
+  "raku",
+  "racket",
+  "julia",
+  ...PYTHON_INTERPRETERS
+]);
+var DIRECT_TEST_RUNNERS = /* @__PURE__ */ new Set([
+  "pytest",
+  "py.test",
+  "unittest",
+  "nose",
+  "nose2",
+  "vitest",
+  "jest",
+  "mocha",
+  "ava",
+  "tap",
+  "rspec",
+  "phpunit",
+  "prove",
+  "bats",
+  "cram"
+]);
+function normalize(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+}
+function normalizeRepoRelativePath(filePath) {
+  const raw = filePath.trim();
+  if (!raw || raw.includes("\0")) return null;
+  if (raw.startsWith("/") || raw.startsWith("\\")) return null;
+  if (raw.startsWith("\\\\")) return null;
+  if (/^[a-zA-Z]:/.test(raw)) return null;
+  let withForward = raw.replace(/\\/g, "/");
+  if (withForward.startsWith("/")) return null;
+  if (withForward.startsWith("//")) return null;
+  if (/^[a-zA-Z]:/.test(withForward)) return null;
+  withForward = withForward.replace(/^\.\//, "");
+  if (withForward.length === 0) return null;
+  const hadTrailingSlash = withForward.endsWith("/") && withForward.length > 1;
+  const segments = withForward.split("/");
+  for (const segment of segments) {
+    if (segment === "..") return null;
+  }
+  const cleaned = segments.filter((segment) => segment.length > 0 && segment !== ".").join("/");
+  if (!cleaned || cleaned === ".") return null;
+  const result = `${cleaned}${hadTrailingSlash ? "/" : ""}`;
+  if (result === ".." || result.startsWith("../") || result.includes("/../") || result.endsWith("/..")) {
+    return null;
+  }
+  return result;
+}
+function normalizeAuthorityPath(filePath) {
+  const normalized = normalizeRepoRelativePath(filePath);
+  return normalized === null ? null : normalized.toLowerCase();
+}
+function commandReferencedPaths(commands) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const command of commands) {
+    if (opaqueCommandReason(command)) continue;
+    for (const raw of command.split(/\s+/)) {
+      const token = raw.replace(/^['"]|['"]$/g, "").replace(/[;,]$/, "");
+      if (!token || token.startsWith("-") || token.includes("://")) continue;
+      if (token.startsWith("./") || token.includes("/") || /\.[a-z0-9]{1,8}$/i.test(token)) {
+        const normalized = normalize(token);
+        if (!normalized.startsWith("../") && !path.isAbsolute(token)) paths.add(normalized);
+      }
+    }
+  }
+  return [...paths];
+}
+function isBuildSourceCheckout(projectRoot) {
+  if (!projectRoot) return false;
+  try {
+    const manifest = JSON.parse(readFileSync(path.join(projectRoot, "package.json"), "utf8"));
+    return manifest.name === "@ebrindley/build";
+  } catch {
+    return false;
+  }
+}
+function opaqueCommandReason(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return "empty verification command";
+  if (/['"]/.test(trimmed) || /\\/.test(trimmed)) {
+    return `opaque quoted or escaped shell tokens: ${trimmed}`;
+  }
+  if (/[\n|&;`$<>()]/.test(trimmed)) {
+    return `opaque shell composition: ${trimmed}`;
+  }
+  if (parseProjectDependencySetupCommand(trimmed)) {
+    return null;
+  }
+  const tokens = trimmed.split(/\s+/).filter(Boolean);
+  const head = (tokens[0] ?? "").toLowerCase();
+  const headBase = head.includes("/") ? head.split("/").pop() ?? head : head;
+  if (SHELL_INTERPRETERS.has(headBase)) {
+    return `opaque shell interpreter: ${trimmed}`;
+  }
+  if (PYTHON_INTERPRETERS.has(headBase)) {
+    for (let index = 1; index < tokens.length; index += 1) {
+      const token = tokens[index] ?? "";
+      if (token === "-m") {
+        return `opaque interpreter module: ${trimmed}`;
+      }
+      if (token && !token.startsWith("-")) break;
+    }
+    return `opaque interpreter: ${trimmed}`;
+  }
+  if (head === "npm" || head === "pnpm" || head === "yarn" || head === "bun") {
+    const verb = (tokens[1] ?? "").toLowerCase();
+    if (verb === "ci" || verb === "install") {
+      return `opaque package-manager install variant: ${trimmed}`;
+    }
+    if (verb === "run" || verb === "test" || verb === "start" || verb === "exec") {
+      return `opaque package-manager script: ${trimmed}`;
+    }
+    if (head === "yarn" && verb && !verb.startsWith("-")) {
+      return `opaque package-manager script: ${trimmed}`;
+    }
+    if (verb === "run-script") {
+      return `opaque package-manager script: ${trimmed}`;
+    }
+  }
+  if (head === "npx" || head === "pnpx" || head === "bunx") {
+    return `opaque package-manager launcher: ${trimmed}`;
+  }
+  if (head === "make" || head === "just" || head === "task" || head === "turbo" || head === "nx") {
+    return `opaque task-runner command: ${trimmed}`;
+  }
+  if (headBase === "go" && (tokens[1] ?? "").toLowerCase() === "test") {
+    return `opaque test runner: ${trimmed}`;
+  }
+  if (headBase === "dotnet" && (tokens[1] ?? "").toLowerCase() === "test") {
+    return `opaque test runner: ${trimmed}`;
+  }
+  if (headBase === "cargo" && (tokens[1] ?? "").toLowerCase() === "test") {
+    return `opaque test runner: ${trimmed}`;
+  }
+  if (DIRECT_TEST_RUNNERS.has(headBase)) {
+    return `opaque test runner: ${trimmed}`;
+  }
+  if (LANGUAGE_INTERPRETERS.has(headBase)) {
+    return `opaque interpreter: ${trimmed}`;
+  }
+  return `opaque unresolved command: ${trimmed}`;
+}
+function staticAuthorityPaths(buildSourceCheckout) {
+  const paths = /* @__PURE__ */ new Set([...AUTHORITY_EXACT_PATHS, ...AUTHORITY_PREFIXES]);
+  if (buildSourceCheckout) {
+    for (const prefix of BUILD_SOURCE_AUTHORITY_PREFIXES) paths.add(prefix);
+  }
+  return [...paths].sort();
+}
+function resolveProjectVerificationAuthority(trustedCommands, options = {}) {
+  const buildSourceCheckout = isBuildSourceCheckout(options.projectRoot);
+  const pathSet = new Set(staticAuthorityPaths(buildSourceCheckout));
+  for (const referenced of commandReferencedPaths(trustedCommands)) {
+    pathSet.add(referenced);
+  }
+  const normalizedAdditional = [];
+  for (const raw of options.additionalAuthorityPaths ?? []) {
+    const normalized = normalizeAuthorityPath(raw);
+    if (!normalized) continue;
+    pathSet.add(normalized);
+    normalizedAdditional.push(normalized);
+  }
+  const reasons = [];
+  for (const command of trustedCommands) {
+    const reason = opaqueCommandReason(command);
+    if (reason) reasons.push(reason);
+  }
+  const assertedComplete = options.authorityPathsComplete === true && normalizedAdditional.length > 0;
+  return {
+    paths: [...pathSet].sort(),
+    complete: reasons.length === 0 || assertedComplete,
+    reasons
+  };
+}
+
+// src/core/ci/local-ci-change-set.ts
+var InvalidGitRawDiffPathEncodingError = class extends Error {
+  invalidPathBytes;
+  constructor(invalidPathBytes) {
+    super("Changed path is not valid UTF-8; exact Git path identity required.");
+    this.name = "InvalidGitRawDiffPathEncodingError";
+    this.invalidPathBytes = invalidPathBytes;
+  }
+};
+var RAW_META_RE = /^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]{40}|0{40}) ([0-9a-f]{40}|0{40}) ([A-Z])(\d*)$/i;
+function decodeStrictUtf8Path(part) {
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  try {
+    return decoder.decode(part);
+  } catch {
+    throw new InvalidGitRawDiffPathEncodingError(Buffer.from(part));
+  }
+}
+function splitNulFields(stdout) {
+  if (stdout.length === 0) return [];
+  const parts = [];
+  let start = 0;
+  for (let i = 0; i < stdout.length; i++) {
+    if (stdout[i] === 0) {
+      parts.push(stdout.subarray(start, i));
+      start = i + 1;
+    }
+  }
+  if (parts.length > 0 && parts[parts.length - 1].length === 0) {
+    parts.pop();
+  }
+  return parts;
+}
+function parseGitRawDiffChangeSet(stdout) {
+  if (stdout.length === 0) {
+    return { complete: true, entries: [] };
+  }
+  if (stdout[stdout.length - 1] !== 0) {
+    return {
+      complete: false,
+      reason: "Malformed raw diff: nonempty -z output lacks final NUL terminator",
+      entries: []
+    };
+  }
+  let parts;
+  try {
+    parts = splitNulFields(stdout);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { complete: false, reason, entries: [] };
+  }
+  const entries = [];
+  let index = 0;
+  while (index < parts.length) {
+    const metaBuf = parts[index];
+    if (!metaBuf || metaBuf.length === 0) {
+      return {
+        complete: false,
+        reason: "Malformed raw diff: empty metadata field",
+        entries
+      };
+    }
+    let meta;
+    try {
+      meta = decodeStrictUtf8Path(metaBuf);
+    } catch (error) {
+      if (error instanceof InvalidGitRawDiffPathEncodingError) {
+        return {
+          complete: false,
+          reason: "Raw diff metadata is not valid UTF-8",
+          entries
+        };
+      }
+      throw error;
+    }
+    const match = RAW_META_RE.exec(meta);
+    if (!match) {
+      return {
+        complete: false,
+        reason: `Malformed raw diff metadata: ${meta.slice(0, 120)}`,
+        entries
+      };
+    }
+    const oldMode = match[1].toLowerCase();
+    const newMode = match[2].toLowerCase();
+    const status = match[5].toUpperCase();
+    if (match[6] && match[6].length > 0) {
+      return {
+        complete: false,
+        reason: `Raw diff status carries rename/copy score under --no-renames: ${status}${match[6]}`,
+        entries
+      };
+    }
+    index += 1;
+    const pathBuf = parts[index];
+    if (!pathBuf || pathBuf.length === 0) {
+      return {
+        complete: false,
+        reason: "Malformed raw diff: missing path after metadata",
+        entries
+      };
+    }
+    let pathText;
+    try {
+      pathText = decodeStrictUtf8Path(pathBuf);
+    } catch (error) {
+      if (error instanceof InvalidGitRawDiffPathEncodingError) {
+        return {
+          complete: false,
+          reason: "Changed path is not valid UTF-8; exact Git path identity required.",
+          entries
+        };
+      }
+      throw error;
+    }
+    entries.push({
+      path: pathText,
+      status,
+      oldMode,
+      newMode
+    });
+    index += 1;
+  }
+  return { complete: true, entries };
+}
+function changeSetPathsMatchNameOnly(changedFiles, changeSet) {
+  if (!changeSet.complete) return false;
+  if (changedFiles.length !== changeSet.entries.length) return false;
+  const nameOnly = [...changedFiles].sort();
+  const raw = changeSet.entries.map((entry) => entry.path).sort();
+  for (let i = 0; i < nameOnly.length; i += 1) {
+    if (nameOnly[i] !== raw[i]) return false;
+  }
+  return true;
+}
+
+// src/core/ci/local-ci-profile.ts
+var LOCAL_CI_FULL_VALIDATION_PROFILE = "full";
+var LOCAL_CI_VALIDATION_PROFILE_REASON_MAX = 500;
+var LOCAL_CI_MAX_VALIDATION_PROFILES = 8;
+var LOCAL_CI_MAX_PROFILE_INCLUDE_PATHS = 32;
+var LOCAL_CI_MAX_PROFILE_EXTENSIONS = 16;
+var PROFILE_ID_RE = /^[a-z][a-z0-9_-]{0,31}$/;
+var PROFILE_EXTENSION_RE = /^\.[A-Za-z0-9_+.-]{1,32}$/;
+function boundLocalCiValidationProfileReason(reason) {
+  if (reason.length <= LOCAL_CI_VALIDATION_PROFILE_REASON_MAX) return reason;
+  return reason.slice(0, LOCAL_CI_VALIDATION_PROFILE_REASON_MAX);
+}
+function full(reason) {
+  return {
+    validationProfile: LOCAL_CI_FULL_VALIDATION_PROFILE,
+    reason: boundLocalCiValidationProfileReason(reason)
+  };
+}
+function resolveLocalCiValidationProfiles(raw) {
+  if (!Array.isArray(raw)) return [];
+  const profiles = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    if (profiles.length >= LOCAL_CI_MAX_VALIDATION_PROFILES) break;
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry;
+    if (typeof record.id !== "string") continue;
+    const id = record.id.trim();
+    if (!PROFILE_ID_RE.test(id) || id === LOCAL_CI_FULL_VALIDATION_PROFILE) continue;
+    if (seenIds.has(id)) {
+      return [];
+    }
+    const include = normalizeIncludeList(record.include);
+    if (include.length === 0) continue;
+    const extensions = normalizeExtensionList(record.extensions);
+    if (extensions.length === 0) continue;
+    seenIds.add(id);
+    profiles.push({ id, include, extensions });
+  }
+  if (profilesHaveOverlappingIncludes(profiles)) {
+    return [];
+  }
+  return profiles;
+}
+function normalizeIncludeList(value) {
+  if (!Array.isArray(value)) return [];
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    if (paths.length >= LOCAL_CI_MAX_PROFILE_INCLUDE_PATHS) break;
+    const normalized = normalizeRepoRelativePath(entry);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    paths.push(normalized);
+  }
+  return paths;
+}
+function normalizeExtensionList(value) {
+  if (!Array.isArray(value)) return [];
+  const extensions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    if (extensions.length >= LOCAL_CI_MAX_PROFILE_EXTENSIONS) break;
+    const trimmed = entry.trim();
+    if (!PROFILE_EXTENSION_RE.test(trimmed) || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    extensions.push(trimmed);
+  }
+  return extensions;
+}
+function profilesHaveOverlappingIncludes(profiles) {
+  for (let i = 0; i < profiles.length; i += 1) {
+    for (let j = i + 1; j < profiles.length; j += 1) {
+      const a = profiles[i];
+      const b = profiles[j];
+      for (const includeA of a.include) {
+        for (const includeB of b.include) {
+          if (includesOverlap(includeA, includeB)) return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function includesOverlap(a, b) {
+  if (a === b) return true;
+  const aPrefix = a.endsWith("/");
+  const bPrefix = b.endsWith("/");
+  if (aPrefix && bPrefix) {
+    return a.startsWith(b) || b.startsWith(a);
+  }
+  if (aPrefix) {
+    return b === a.slice(0, -1) || b.startsWith(a);
+  }
+  if (bPrefix) {
+    return a === b.slice(0, -1) || a.startsWith(b);
+  }
+  return false;
+}
+function pathMatchesInclude(filePath, include) {
+  if (include.endsWith("/")) {
+    return filePath === include.slice(0, -1) || filePath.startsWith(include);
+  }
+  return filePath === include;
+}
+function fileExtension(filePath) {
+  const base = filePath.includes("/") ? filePath.slice(filePath.lastIndexOf("/") + 1) : filePath;
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0 || dot === base.length - 1) return null;
+  return base.slice(dot);
+}
+function gitPathIsSafeRepoRelativeLiteral(filePath) {
+  const safeForm = normalizeRepoRelativePath(filePath);
+  return safeForm !== null && safeForm === filePath;
+}
+function entryMatchesProfile(entry, profile) {
+  if (!gitPathIsSafeRepoRelativeLiteral(entry.path)) return false;
+  const extension = fileExtension(entry.path);
+  if (!extension || !profile.extensions.includes(extension)) return false;
+  return profile.include.some((include) => pathMatchesInclude(entry.path, include));
+}
+function changePathIntersectsAuthority(filePath, authorityPaths) {
+  const folded = normalizeAuthorityPath(filePath);
+  if (!folded) return true;
+  for (const auth of authorityPaths) {
+    if (auth.endsWith("/")) {
+      if (folded === auth.slice(0, -1) || folded.startsWith(auth)) return true;
+    } else if (folded === auth || folded.startsWith(`${auth}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function entryIsRegularAddOrModify(entry) {
+  if (entry.status !== "A" && entry.status !== "M") return false;
+  if (entry.newMode !== "100644") return false;
+  if (entry.status === "A") {
+    return entry.oldMode === "000000";
+  }
+  return entry.oldMode === "100644";
+}
+function selectLocalCiValidationProfile(input) {
+  if (!input.trusted) {
+    return full("Authority is not trusted; full validation required.");
+  }
+  if (!input.verificationAuthority.complete) {
+    return full("Verification authority is incomplete; full validation required.");
+  }
+  if (input.changedFiles.length === 0) {
+    return full("Change set is empty; full validation required.");
+  }
+  if (!input.changeSet.complete) {
+    return full(
+      input.changeSet.reason || "Raw change-set metadata is incomplete; full validation required."
+    );
+  }
+  if (!changeSetPathsMatchNameOnly(input.changedFiles, input.changeSet)) {
+    return full("Name-only and raw change-set paths disagree; full validation required.");
+  }
+  if (input.profiles.length === 0) {
+    return full("No trusted-base validation profiles configured; full validation required.");
+  }
+  for (const entry of input.changeSet.entries) {
+    if (!entryIsRegularAddOrModify(entry)) {
+      return full(
+        `Change ${entry.status} ${entry.oldMode}->${entry.newMode} on ${entry.path} is not a regular A/M 100644 edit; full validation required.`
+      );
+    }
+    if (changePathIntersectsAuthority(entry.path, input.verificationAuthority.paths)) {
+      return full(
+        `Change path intersects validation authority (${entry.path}); full validation required.`
+      );
+    }
+  }
+  let selectedId;
+  for (const entry of input.changeSet.entries) {
+    const matches = input.profiles.filter((profile) => entryMatchesProfile(entry, profile));
+    if (matches.length === 0) {
+      return full(`No validation profile matches ${entry.path}; full validation required.`);
+    }
+    if (matches.length > 1) {
+      return full(
+        `Ambiguous validation profiles for ${entry.path}: ${matches.map((p) => p.id).join(", ")}; full validation required.`
+      );
+    }
+    const id = matches[0].id;
+    if (selectedId === void 0) {
+      selectedId = id;
+    } else if (selectedId !== id) {
+      return full(`Mixed validation profiles (${selectedId} vs ${id}); full validation required.`);
+    }
+  }
+  if (!selectedId) {
+    return full("Unable to select a validation profile; full validation required.");
+  }
+  return {
+    validationProfile: selectedId,
+    reason: boundLocalCiValidationProfileReason(
+      `All changes match trusted-base validation profile '${selectedId}'.`
+    )
+  };
+}
+function resolveLocalCiValidationProfileEnv(value) {
+  if (typeof value !== "string") return LOCAL_CI_FULL_VALIDATION_PROFILE;
+  const trimmed = value.trim();
+  if (!trimmed) return LOCAL_CI_FULL_VALIDATION_PROFILE;
+  if (trimmed === LOCAL_CI_FULL_VALIDATION_PROFILE) return LOCAL_CI_FULL_VALIDATION_PROFILE;
+  if (!PROFILE_ID_RE.test(trimmed)) return LOCAL_CI_FULL_VALIDATION_PROFILE;
+  return trimmed;
+}
+
+// src/core/ci/local-ci-config.ts
+function resolveLocalCiFallbackCommands(root, changedFiles = []) {
+  const guidance = buildProjectVerificationGuidance(root, changedFiles);
+  return [
+    ...deriveProjectDependencySetupPlan(root, { capabilities: guidance.capabilities }).commands,
+    ...selectCommandsForLocalCi({
+      resolved: guidance.commands
+    })
+  ];
+}
+function stringArray(value) {
+  if (typeof value === "string") return [value];
+  return value;
+}
+function normalizeSafePathList(value, normalizeEntry) {
+  if (!Array.isArray(value)) return [];
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    const normalized = normalizeEntry(entry);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    paths.push(normalized);
+  }
+  return paths;
+}
+function warnDeprecatedLocalCiMergeKeys(ci) {
+  if (!ci) return;
+  const present = Object.hasOwn(ci, "autoMerge") || Object.hasOwn(ci, "autoMergePaths") || Object.hasOwn(ci, "mergeMethod");
+  if (!present) return;
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "configuration" /* CONFIGURATION */,
+    "Warning: ci.autoMerge, ci.autoMergePaths, and ci.mergeMethod are deprecated and ignored; merge requests require explicit build ci merge admission.",
+    { subsystem: "ci/local-ci-config", executionPhase: "setup" }
+  );
+}
+function resolveMergeBatchingEnabled(root) {
+  const candidate = selectedBuildConfigCandidate(
+    path2.join(root, ".build-project", "config", "build.config.jsonc")
+  );
+  return consumeBuildConfigRead(readCanonicalBuildConfig(candidate))?.ci?.mergeBatching === true;
+}
+function resolveLandingLeaseEnabled(root) {
+  if (readEnv(BUILD_LOCAL_CI_LANDING_LEASE).value === false) return false;
+  try {
+    const candidate = selectedBuildConfigCandidate(
+      path2.join(root, ".build-project", "config", "build.config.jsonc")
+    );
+    return consumeBuildConfigRead(readCanonicalBuildConfig(candidate))?.ci?.landingLease !== false;
+  } catch {
+    return true;
+  }
+}
+function resolveLocalCiConfig(root, changedFiles = []) {
+  const candidate = selectedBuildConfigCandidate(
+    path2.join(root, ".build-project", "config", "build.config.jsonc")
+  );
+  const projectConfig = consumeBuildConfigRead(readCanonicalBuildConfig(candidate));
+  const ci = projectConfig?.ci;
+  warnDeprecatedLocalCiMergeKeys(
+    ci && typeof ci === "object" ? ci : void 0
+  );
+  const guidance = buildProjectVerificationGuidance(root, changedFiles);
+  const explicitCommands = stringArray(ci?.commands);
+  const selectedCommands = selectCommandsForLocalCi({
+    explicit: explicitCommands,
+    resolved: guidance.commands
+  });
+  const coverageUnavailable = !explicitCommands?.length && !verificationCommandsCoverChangedPaths(
+    guidance.capabilities,
+    selectedCommands,
+    guidance.relevantLanguages,
+    changedFiles
+  );
+  const verificationCommands = coverageUnavailable ? [] : selectedCommands;
+  const coverageGap = explicitCommands?.length || coverageUnavailable ? void 0 : nestedCoverageGap({
+    projectRoot: root,
+    changedPaths: changedFiles,
+    commands: guidance.commands.flatMap(
+      (entry) => selectedCommands.includes(entry.command) && (entry.kind === "test" || entry.kind === "build" || entry.kind === "typecheck") ? [{ command: entry.command, channel: entry.kind }] : []
+    )
+  })?.reason;
+  const setupPlan = explicitCommands?.length ? { commands: [], unavailable: [] } : deriveProjectDependencySetupPlan(root, { capabilities: guidance.capabilities });
+  const setupCommands = setupPlan.commands;
+  const verifyCommands = verificationCommands;
+  const commands = [...setupCommands, ...verifyCommands];
+  const authorityPaths = normalizeSafePathList(ci?.authorityPaths, normalizeAuthorityPath);
+  const authorityPathsComplete = ci?.authorityPathsComplete === true && authorityPaths.length > 0;
+  const validationProfiles = resolveLocalCiValidationProfiles(
+    ci && typeof ci === "object" && "validationProfiles" in ci ? ci.validationProfiles : void 0
+  );
+  return {
+    enabled: ci?.enabled ?? true,
+    commands,
+    setupCommands,
+    setupUnavailable: setupPlan.unavailable,
+    verifyCommands,
+    ...coverageGap ? { coverageGap } : {},
+    authorityPaths,
+    authorityPathsComplete,
+    validationProfiles,
+    statusContext: ci?.statusContext ?? DEFAULT_LOCAL_CI_STATUS_CONTEXT,
+    maxConcurrent: ci?.maxConcurrent ?? DEFAULT_LOCAL_CI_MAX_CONCURRENT
+  };
+}
+
+export {
+  normalizeRepoRelativePath,
+  normalizeAuthorityPath,
+  resolveProjectVerificationAuthority,
+  parseGitRawDiffChangeSet,
+  LOCAL_CI_FULL_VALIDATION_PROFILE,
+  boundLocalCiValidationProfileReason,
+  selectLocalCiValidationProfile,
+  resolveLocalCiValidationProfileEnv,
+  resolveLocalCiFallbackCommands,
+  resolveMergeBatchingEnabled,
+  resolveLandingLeaseEnabled,
+  resolveLocalCiConfig
+};
+//# sourceMappingURL=chunk-PEBWDYIW.js.map