@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-C3KCMAJP.js

@@ -0,0 +1,756 @@
+import {
+  LEGACY_REPO_LOCAL_TELEMETRY_DATABASE,
+  readCanonicalBuildConfig,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  resolveLabsRoot,
+  resolveProjectRuntimeDir,
+  resolveRunStateDir
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  applySqlitePragmas
+} from "./chunk-HEP3ILP4.js";
+import {
+  getConfigPaths
+} from "./chunk-35J4NE6S.js";
+import {
+  getDataDir,
+  getGlobalTelemetryDir,
+  getProjectDataDir,
+  getStableRepoIdentity
+} from "./chunk-56WPYDJH.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  BUILD_LAB_BASELINE,
+  BUILD_LAB_ID,
+  BUILD_LAB_MODE,
+  BUILD_LAB_RUN_ID,
+  BUILD_TELEMETRY_DB,
+  BUILD_WORKTREE_BASE,
+  emitCustomWarning,
+  getExecutionContext,
+  hasExecutionContext,
+  readEnv,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/telemetry/telemetry-path-resolver.ts
+import { execSync } from "child_process";
+import path3 from "path";
+
+// src/orchestrator/lab-mode.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+
+// src/core/lab-mode-env.ts
+function isLabModeFromEnv() {
+  const val = readRawEnv(BUILD_LAB_MODE)?.trim().toLowerCase();
+  return val === "1" || val === "true";
+}
+
+// src/orchestrator/lab-mode.ts
+var labContextStorage = new AsyncLocalStorage();
+var LabPathResolver = class _LabPathResolver {
+  static instance = null;
+  /** Process-wide fallback for single-run CLI / tests outside ALS. */
+  legacySlot = { context: null, source: null };
+  incompleteEnvWarningEmitted = false;
+  constructor() {
+  }
+  resolveSlot() {
+    return labContextStorage.getStore() ?? this.legacySlot;
+  }
+  isEnvLabModeEnabled() {
+    return isLabModeFromEnv();
+  }
+  hydrateContextFromEnv() {
+    const slot = this.resolveSlot();
+    if (slot.source === "cleared") {
+      return;
+    }
+    if (!this.isEnvLabModeEnabled()) {
+      if (slot.source === "env") {
+        slot.context = null;
+        slot.source = null;
+      }
+      return;
+    }
+    if (slot.source === "explicit") {
+      return;
+    }
+    const labId = readEnv(BUILD_LAB_ID).value;
+    const runId = readEnv(BUILD_LAB_RUN_ID).value;
+    if (!labId || !runId) {
+      if (!this.incompleteEnvWarningEmitted) {
+        this.incompleteEnvWarningEmitted = true;
+        console.warn(
+          "[LabPathResolver] BUILD_LAB_MODE is enabled but lab context is incomplete. Ignoring lab mode until both BUILD_LAB_ID and BUILD_LAB_RUN_ID are set."
+        );
+      }
+      return;
+    }
+    slot.context = {
+      labId,
+      runId,
+      baseline: readEnv(BUILD_LAB_BASELINE).value ?? "HEAD",
+      task: "env"
+    };
+    slot.source = "env";
+    this.incompleteEnvWarningEmitted = false;
+  }
+  /**
+   * Gets the singleton instance of the resolver.
+   */
+  static getInstance() {
+    if (!_LabPathResolver.instance) {
+      _LabPathResolver.instance = new _LabPathResolver();
+    }
+    return _LabPathResolver.instance;
+  }
+  /**
+   * True when the current async tree has an ALS lab slot (not merely legacy fallback).
+   */
+  hasScopedContext() {
+    return labContextStorage.getStore() !== void 0;
+  }
+  /**
+   * Run asynchronous work with an isolated lab slot pre-loaded with context.
+   */
+  runWithContextAsync(context, fn) {
+    return labContextStorage.run({ context: { ...context }, source: "explicit" }, fn);
+  }
+  /**
+   * Enter an empty isolated slot for asynchronous setup and execution.
+   */
+  runIsolatedAsync(fn) {
+    return labContextStorage.run({ context: null, source: null }, fn);
+  }
+  /**
+   * Bind delayed lifecycle work (signals, beforeExit, deferred cleanup) to the
+   * current slot. EventEmitter callbacks otherwise inherit the emitter's async
+   * context, which can be the production/legacy slot rather than the lab run
+   * that registered the cleanup.
+   */
+  bindCurrentContext(fn) {
+    const current = this.resolveSlot();
+    const captured = {
+      context: current.context ? { ...current.context } : null,
+      source: current.source
+    };
+    return (...args) => labContextStorage.run(
+      {
+        context: captured.context ? { ...captured.context } : null,
+        source: captured.source
+      },
+      () => fn(...args)
+    );
+  }
+  /**
+   * Sets the lab context for the current execution (scoped slot if active, else legacy).
+   * Must be called explicitly before path resolution when lab mode is active.
+   */
+  setContext(context) {
+    const slot = this.resolveSlot();
+    slot.context = context;
+    slot.source = "explicit";
+    this.incompleteEnvWarningEmitted = false;
+  }
+  /**
+   * Clears the lab context for the active slot only, returning that slot to
+   * standard path behavior. Concurrent ALS trees are unaffected.
+   * Must be called after lab execution to prevent state leakage.
+   */
+  clearContext() {
+    const slot = this.resolveSlot();
+    slot.context = null;
+    slot.source = "cleared";
+  }
+  /**
+   * Returns true if lab mode is currently active for the active slot.
+   */
+  isLabMode() {
+    this.hydrateContextFromEnv();
+    return this.resolveSlot().context !== null;
+  }
+  /**
+   * Returns the current lab context for the active slot, or null if not active.
+   */
+  getContext() {
+    this.hydrateContextFromEnv();
+    return this.resolveSlot().context;
+  }
+  /**
+   * Helper method to construct lab-specific or standard paths.
+   * Reduces duplication and prevents copy-paste errors in path resolution.
+   *
+   * The standard (non-lab) branch resolves `telemetry` through the same layout
+   * `TelemetryPathResolver.resolveDbDir()` uses, so `BUILD_TELEMETRY_DB` and a
+   * non-default `telemetry.database` relocate logs, synthesis, and readiness
+   * beside the database. Derivation is the resolver's own `telemetryDir`
+   * (see `telemetryDirFromDbDir`), never a second copy of the rule. Callers whose standard branch is
+   * not under this tree (`getStateDir` resolves through `resolveRunStateDir`;
+   * `getArtifactDir`, `getWorktreeBaseDir` are repo-local or external) return
+   * before reaching here and are unaffected.
+   */
+  getBasePath(buildDir, subpath) {
+    if (!this.isLabMode()) {
+      if (subpath === "telemetry") {
+        return TelemetryPathResolver.getInstance().resolveDbLayout(buildDir).telemetryDir;
+      }
+      return path.join(buildDir, subpath);
+    }
+    const context = this.resolveSlot().context;
+    if (!context) {
+      return path.join(buildDir, subpath);
+    }
+    return path.join(resolveLabsRoot(buildDir), context.labId, "runs", context.runId, subpath);
+  }
+  /**
+   * Resolves the telemetry directory path.
+   * Lab mode: `.build-project/labs/{labId}/runs/{runId}/telemetry/`
+   * Standard: the directory `TelemetryPathResolver` owns (data root, or an
+   * explicit `BUILD_TELEMETRY_DB` / `telemetry.database` override).
+   */
+  getTelemetryDir(buildDir) {
+    return this.getBasePath(buildDir, "telemetry");
+  }
+  /**
+   * Resolves the state directory path.
+   * Lab mode: `.build-project/labs/{labId}/runs/{runId}/state/`
+   * Standard: `telemetry/state/` under the project data dir (see `resolveRunStateDir`)
+   */
+  getStateDir(buildDir) {
+    if (!this.isLabMode()) {
+      return resolveRunStateDir(buildDir);
+    }
+    return this.getBasePath(buildDir, "state");
+  }
+  /**
+   * Resolves the per-variant state directory (`<state dir>/variants`) where variant
+   * state files are written and read back, lab-aware like the state dir.
+   */
+  getVariantStateDir(buildDir) {
+    return path.join(this.getStateDir(buildDir), "variants");
+  }
+  /**
+   * Resolves the worktree base directory path.
+   * Lab mode: `.build-project/labs/{labId}/runs/{runId}/worktrees/`
+   * Standard: BUILD_WORKTREE_BASE env or `/tmp/build-worktrees`
+   */
+  getWorktreeBaseDir(buildDir) {
+    if (!this.isLabMode()) {
+      return readEnv(BUILD_WORKTREE_BASE).value ?? "/tmp/build-worktrees";
+    }
+    return this.getBasePath(buildDir, "worktrees");
+  }
+  /**
+   * Resolves the artifact storage directory path.
+   * Lab mode: `.build-project/labs/{labId}/runs/{runId}/artifacts/`
+   * Standard: `{buildDir}/artifacts/`
+   */
+  getArtifactDir(buildDir) {
+    if (!this.isLabMode()) {
+      return path.join(buildDir, "artifacts");
+    }
+    return this.getBasePath(buildDir, "artifacts");
+  }
+  /**
+   * Resolves the JSONL logs directory path.
+   * Lab mode: `.build-project/labs/{labId}/runs/{runId}/logs/`
+   * Standard: `logs/` under the resolved telemetry directory (data root or override).
+   *
+   * Anchored on the telemetry directory rather than a repo-local join so it agrees
+   * with where `TelemetryCore` actually writes JSONL (it derives its logs directory
+   * from the same `resolveDbLayout` helper) and with the `telemetry/logs` migration
+   * target. A repo-local join here left readers pointed at an empty directory.
+   */
+  getLogsDir(buildDir) {
+    if (!this.isLabMode()) {
+      return path.join(this.getBasePath(buildDir, "telemetry"), "logs");
+    }
+    return this.getBasePath(buildDir, "logs");
+  }
+};
+function runWithLabContextAsync(context, fn) {
+  return LabPathResolver.getInstance().runWithContextAsync(context, fn);
+}
+function generateLabId(task, baseline) {
+  const normalizedTask = task.trim().toLowerCase();
+  const normalizedBaseline = baseline.trim();
+  const input = `${normalizedTask}:${normalizedBaseline}`;
+  const hash = createHash("sha256").update(input).digest("hex");
+  return `lab-${hash.substring(0, 8)}`;
+}
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const suffix = String(Math.floor(Math.random() * 1e3)).padStart(3, "0");
+  return `${year}${month}${day}-${hours}${minutes}${seconds}-${suffix}`;
+}
+function createLabContext(task, baseline = "HEAD") {
+  const labId = generateLabId(task, baseline);
+  const runId = generateRunId();
+  return {
+    labId,
+    runId,
+    baseline,
+    task
+  };
+}
+function resolveDefaultBuildDir() {
+  return hasExecutionContext() ? getExecutionContext().buildDir : path.join(resolveBuildRoot(process.cwd()), ".build-project");
+}
+function validateLabConfig() {
+  const errors = [];
+  const labId = readEnv(BUILD_LAB_ID).value;
+  if (labId !== void 0) {
+    if (!/^[a-zA-Z0-9-_]+$/.test(labId)) {
+      errors.push(
+        "BUILD_LAB_ID must contain only alphanumeric characters, hyphens, and underscores"
+      );
+    }
+  }
+  const runId = readEnv(BUILD_LAB_RUN_ID).value;
+  if (runId !== void 0) {
+    if (!/^\d{8}-\d{6}-\d{3}$/.test(runId)) {
+      errors.push(
+        "BUILD_LAB_RUN_ID must match format YYYYMMDD-HHMMSS-NNN (e.g., 20251220-195415-748)"
+      );
+    }
+  }
+  const labBaselineResult = readEnv(BUILD_LAB_BASELINE);
+  const baseline = labBaselineResult.source === "env" ? labBaselineResult.value : void 0;
+  if (baseline !== void 0) {
+    if (baseline.trim().length === 0) {
+      errors.push("BUILD_LAB_BASELINE must not be empty");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function verifyLabMode() {
+  const resolver = LabPathResolver.getInstance();
+  const context = resolver.getContext();
+  if (!context) {
+    return { active: false, context: null, paths: null };
+  }
+  const buildDir = resolveDefaultBuildDir();
+  return {
+    active: true,
+    context,
+    paths: {
+      telemetry: resolver.getTelemetryDir(buildDir),
+      state: resolver.getStateDir(buildDir),
+      worktrees: resolver.getWorktreeBaseDir(buildDir),
+      logs: resolver.getLogsDir(buildDir)
+    }
+  };
+}
+function initializeLabModeFromEnv(task) {
+  const isLabModeEnabled = isLabModeFromEnv();
+  if (!isLabModeEnabled) {
+    return false;
+  }
+  const baseline = readEnv(BUILD_LAB_BASELINE).value ?? "HEAD";
+  const customLabId = readEnv(BUILD_LAB_ID).value;
+  const customRunId = readEnv(BUILD_LAB_RUN_ID).value;
+  const resolver = LabPathResolver.getInstance();
+  if (customLabId && customRunId) {
+    resolver.setContext({
+      labId: customLabId,
+      runId: customRunId,
+      baseline,
+      task
+    });
+  } else if (customLabId) {
+    resolver.setContext({
+      labId: customLabId,
+      runId: generateRunId(),
+      baseline,
+      task
+    });
+  } else {
+    const context = createLabContext(task, baseline);
+    resolver.setContext(context);
+  }
+  return true;
+}
+function getMostRecentLabRun() {
+  const buildDir = resolveDefaultBuildDir();
+  const labsDir = resolveProjectRuntimeDir(buildDir, "labs");
+  if (!fs.existsSync(labsDir)) {
+    return null;
+  }
+  let mostRecentRun = null;
+  let mostRecentTimestamp = 0;
+  try {
+    const labIds = fs.readdirSync(labsDir);
+    for (const labId of labIds) {
+      const runsDir = path.join(labsDir, labId, "runs");
+      if (!fs.existsSync(runsDir)) {
+        continue;
+      }
+      const runIds = fs.readdirSync(runsDir);
+      for (const runId of runIds) {
+        const match = /^(\d{8})-(\d{6})-(\d{3})$/.exec(runId);
+        if (!match) {
+          continue;
+        }
+        const dateStr = match[1] ?? "";
+        const timeStr = match[2] ?? "";
+        const year = Number.parseInt(dateStr.substring(0, 4), 10);
+        const month = Number.parseInt(dateStr.substring(4, 6), 10) - 1;
+        const day = Number.parseInt(dateStr.substring(6, 8), 10);
+        const hours = Number.parseInt(timeStr.substring(0, 2), 10);
+        const minutes = Number.parseInt(timeStr.substring(2, 4), 10);
+        const seconds = Number.parseInt(timeStr.substring(4, 6), 10);
+        const timestamp = new Date(year, month, day, hours, minutes, seconds).getTime();
+        if (timestamp > mostRecentTimestamp) {
+          mostRecentTimestamp = timestamp;
+          mostRecentRun = {
+            labId,
+            runId,
+            baseline: "HEAD",
+            // We don't store this, default to HEAD
+            task: "unknown"
+            // We don't store this
+          };
+        }
+      }
+    }
+  } catch (_error) {
+    return null;
+  }
+  return mostRecentRun;
+}
+function getLabWarningStateFile() {
+  return path.join(resolveDefaultBuildDir(), ".last-lab-warning");
+}
+function checkAndWarnLabContext() {
+  const resolver = LabPathResolver.getInstance();
+  if (resolver.isLabMode()) {
+    return;
+  }
+  const warningStateFile = getLabWarningStateFile();
+  if (fs.existsSync(warningStateFile)) {
+    return;
+  }
+  const recentLabRun = getMostRecentLabRun();
+  if (!recentLabRun) {
+    return;
+  }
+  const buildDir = resolveDefaultBuildDir();
+  const labPath = path.join(buildDir, "labs", recentLabRun.labId, "runs", recentLabRun.runId);
+  console.log(
+    `Note: Most recent run was lab (${recentLabRun.labId}). Use --lab to continue in lab mode, or view results at: ${labPath}`
+  );
+  try {
+    fs.writeFileSync(warningStateFile, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+
+// src/utils/project-registry.ts
+import fs2 from "fs";
+import path2 from "path";
+import Database from "better-sqlite3";
+function getRegistryDbPath(dataDir = getDataDir()) {
+  return path2.join(dataDir, "registry.db");
+}
+function openRegistryDb(dataDir = getDataDir()) {
+  fs2.mkdirSync(dataDir, { recursive: true, mode: 448 });
+  const db = new Database(getRegistryDbPath(dataDir));
+  applySqlitePragmas(db);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      project_id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      git_common_dir TEXT NOT NULL,
+      first_seen TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      last_seen TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+  return db;
+}
+function upsertProjectRegistryEntry(entry, dataDir = getDataDir()) {
+  const db = openRegistryDb(dataDir);
+  try {
+    db.prepare(
+      `
+      INSERT INTO projects (project_id, name, git_common_dir)
+      VALUES (?, ?, ?)
+      ON CONFLICT(project_id) DO UPDATE SET
+        last_seen = CURRENT_TIMESTAMP,
+        name = excluded.name,
+        git_common_dir = excluded.git_common_dir
+    `
+    ).run(entry.projectId, entry.name, entry.gitCommonDir);
+  } finally {
+    db.close();
+  }
+}
+
+// src/telemetry/telemetry-path-resolver.ts
+function resolveRepoRootFromBuildDir(buildDir) {
+  const normalized = path3.resolve(buildDir);
+  return path3.basename(normalized) === ".build-project" ? path3.dirname(normalized) : normalized;
+}
+var warnedConfiguredTelemetryDbPaths = /* @__PURE__ */ new Set();
+function resetConfiguredTelemetryDbWarningCache() {
+  warnedConfiguredTelemetryDbPaths.clear();
+}
+function dbLocationToDir(location) {
+  return location.endsWith(".db") ? path3.dirname(location) : location;
+}
+function telemetryDirFromDbDir(dbDir) {
+  return path3.basename(dbDir) === "db" ? path3.dirname(dbDir) : dbDir;
+}
+function isLegacyRepoLocalTelemetryLocation(resolved, legacyDefaultFile) {
+  const legacyDbDir = path3.dirname(legacyDefaultFile);
+  const resolvedDir = dbLocationToDir(resolved);
+  return resolved === legacyDefaultFile || resolvedDir === legacyDbDir;
+}
+var TelemetryPathResolver = class _TelemetryPathResolver {
+  static instance = null;
+  projectIdByRepoRoot = /* @__PURE__ */ new Map();
+  registryUpsertAttempted = /* @__PURE__ */ new Set();
+  static getInstance() {
+    if (!_TelemetryPathResolver.instance) {
+      _TelemetryPathResolver.instance = new _TelemetryPathResolver();
+    }
+    return _TelemetryPathResolver.instance;
+  }
+  /**
+   * The one directory telemetry databases are written to.
+   *
+   * Resolution order, highest first:
+   *
+   * 1. `BUILD_TELEMETRY_DB` — the explicit escape hatch used by tests and CI.
+   * 2. Lab context — an explicitly requested, deliberately throwaway run tree
+   *    under `.build-project/labs/{lab}/runs/{run}/telemetry`.
+   * 3. `telemetry.database` in project or user config, honored only when it is
+   *    something other than the historical repo-local default, with a one-time
+   *    deprecation advisory.
+   * 4. The Build data root.
+   *
+   * Nothing here probes the filesystem for a repo-local database. A checkout is
+   * disposable, so anchoring telemetry inside one meant deleting the checkout
+   * destroyed the only copy of its history; the previous marker/probe chain also
+   * gave two clones of one repo two different stores. Repo-local data left by an
+   * older version stays on disk and is merged by `build data migrate execute`,
+   * which `build doctor` advises about; it is never resolved back into.
+   */
+  resolveDbDir(buildDir) {
+    return this.resolveDbLayout(buildDir).dbDir;
+  }
+  /**
+   * Database directory plus the telemetry directory that owns logs/synthesis.
+   *
+   * `telemetryDir` is derived with {@link telemetryDirFromDbDir} for every
+   * resolution branch, so consumers that go through this layout agree with
+   * `TelemetryCore` under overrides and in lab mode.
+   */
+  resolveDbLayout(buildDir) {
+    const absoluteBuildDir = path3.resolve(buildDir);
+    const telemetryDbOverride = readEnv(BUILD_TELEMETRY_DB).value;
+    if (telemetryDbOverride) {
+      const dbDir2 = dbLocationToDir(path3.resolve(telemetryDbOverride));
+      return {
+        dbDir: dbDir2,
+        telemetryDir: telemetryDirFromDbDir(dbDir2)
+      };
+    }
+    const labResolver = LabPathResolver.getInstance();
+    if (labResolver.isLabMode()) {
+      const telemetryDir2 = labResolver.getTelemetryDir(absoluteBuildDir);
+      const dbDir2 = path3.join(telemetryDir2, "db");
+      return {
+        dbDir: dbDir2,
+        telemetryDir: telemetryDirFromDbDir(dbDir2)
+      };
+    }
+    const configuredTelemetryDb = this.resolveConfiguredTelemetryDb(absoluteBuildDir);
+    if (configuredTelemetryDb) {
+      const dbDir2 = dbLocationToDir(configuredTelemetryDb);
+      return {
+        dbDir: dbDir2,
+        telemetryDir: telemetryDirFromDbDir(dbDir2)
+      };
+    }
+    const telemetryDir = getGlobalTelemetryDir();
+    const dbDir = path3.join(telemetryDir, "db");
+    return {
+      dbDir,
+      telemetryDir: telemetryDirFromDbDir(dbDir)
+    };
+  }
+  resolveTelemetryDir(buildDir) {
+    return this.resolveDbLayout(buildDir).telemetryDir;
+  }
+  resolveProjectDataDir(buildDir) {
+    const repoRoot = this.resolveRepoRootFromBuildDir(buildDir);
+    return getProjectDataDir(repoRoot);
+  }
+  getProjectId(buildDir, options = {}) {
+    const { register = true } = options;
+    const repoRoot = this.resolveRepoRootFromBuildDir(buildDir);
+    const cacheKey = path3.resolve(repoRoot);
+    const cached = this.projectIdByRepoRoot.get(cacheKey);
+    const projectId = cached ?? getStableRepoIdentity(repoRoot);
+    if (!cached) {
+      this.projectIdByRepoRoot.set(cacheKey, projectId);
+    }
+    if (register && !this.registryUpsertAttempted.has(projectId)) {
+      this.registryUpsertAttempted.add(projectId);
+      const gitCommonDir = this.resolveGitCommonDir(repoRoot);
+      try {
+        upsertProjectRegistryEntry({
+          projectId,
+          name: path3.basename(repoRoot),
+          gitCommonDir
+        });
+      } catch {
+      }
+    }
+    return projectId;
+  }
+  getDbContext() {
+    const labContext = LabPathResolver.getInstance().getContext();
+    if (!labContext) {
+      return { labId: null, labRunId: null };
+    }
+    return {
+      labId: labContext.labId,
+      labRunId: labContext.runId
+    };
+  }
+  resolveRepoRootFromBuildDir(buildDir) {
+    return resolveRepoRootFromBuildDir(buildDir);
+  }
+  /**
+   * The `telemetry.database` override, or null when there is nothing to honor.
+   *
+   * Two values are deliberately treated as "nothing":
+   *
+   * 1. An absent or blank setting. `build init` no longer writes one at all.
+   * 2. A value that resolves to the historical repo-local default
+   *    (`.build-project/telemetry/db/variants.db`). Every config generated before this
+   *    change carries that string, so honoring it would keep recreating the
+   *    database inside the checkout for exactly the installs the single write
+   *    path exists to fix. Comparison is on the resolved path, so relative and
+   *    `./`-prefixed spellings are all recognized, as is an absolute spelling that
+   *    uses the same filesystem alias `repoRoot` itself resolved through. The
+   *    directory itself (`.build-project/telemetry/db`) and other database files in it
+   *    (`.build-project/telemetry/db/validations.db`) are the same default, not an
+   *    override: comparison is on the resolved directory, not the file string.
+   *
+   *    Known limit: an absolute value reaching this same database through a
+   *    different alias (`/tmp/repo/...` against a `/private/tmp/repo` root) compares
+   *    unequal and is therefore honored as an override, leaving telemetry in the
+   *    checkout. That is left alone deliberately. It takes a hand-edited absolute
+   *    path — the generated default was relative and is no longer written at all —
+   *    and it announces itself, because the deprecation warning below names the
+   *    resolved path and the remedy. Closing it needs canonicalization that works
+   *    on a database file that does not exist yet, since `fs.realpathSync` throws
+   *    on a missing path; a plain realpath comparison would fail open in exactly
+   *    this case rather than fix it.
+   *
+   * Anything else is an operator's explicit relocation and is honored verbatim,
+   * including paths outside the repository — that is now the setting's only
+   * documented purpose. It is deprecated, so a resolved override is reported once
+   * per location per process.
+   */
+  resolveConfiguredTelemetryDb(buildDir) {
+    const repoRoot = this.resolveRepoRootFromBuildDir(buildDir);
+    const legacyDefault = path3.resolve(repoRoot, LEGACY_REPO_LOCAL_TELEMETRY_DATABASE);
+    const paths = getConfigPaths(repoRoot);
+    for (const configuredPath of [paths.projectConfigFile, paths.userConfigFile]) {
+      const configPath = selectedBuildConfigCandidate(configuredPath);
+      const read = readCanonicalBuildConfig(configPath);
+      if (read.status === "invalid") continue;
+      if (read.status === "missing") continue;
+      const database = read.config.telemetry?.database;
+      if (typeof database !== "string" || database.trim() === "") {
+        continue;
+      }
+      const resolved = path3.resolve(repoRoot, database);
+      if (isLegacyRepoLocalTelemetryLocation(resolved, legacyDefault)) {
+        continue;
+      }
+      this.warnConfiguredTelemetryDbDeprecated(configPath, resolved);
+      return resolved;
+    }
+    return null;
+  }
+  warnConfiguredTelemetryDbDeprecated(configPath, resolvedDb) {
+    if (warnedConfiguredTelemetryDbPaths.has(resolvedDb)) {
+      return;
+    }
+    warnedConfiguredTelemetryDbPaths.add(resolvedDb);
+    emitCustomWarning(
+      "WARN" /* WARN */,
+      "configuration" /* CONFIGURATION */,
+      `telemetry.database is deprecated; telemetry resolves to ${resolvedDb} instead of the Build data root. Remove it from ${configPath} to use the data root.`,
+      {
+        subsystem: "telemetry",
+        executionPhase: "setup"
+      },
+      {
+        metadata: {
+          setting: "telemetry.database",
+          configPath,
+          resolvedDb,
+          dataRootDb: path3.join(getGlobalTelemetryDir(), "db")
+        }
+      }
+    );
+  }
+  resolveGitCommonDir(repoRoot) {
+    try {
+      const stdout = execSync("git rev-parse --git-common-dir", {
+        cwd: repoRoot,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1500
+      }).toString().trim();
+      if (!stdout) {
+        return path3.join(repoRoot, ".git");
+      }
+      return path3.isAbsolute(stdout) ? stdout : path3.resolve(repoRoot, stdout);
+    } catch {
+      return path3.join(repoRoot, ".git");
+    }
+  }
+};
+
+export {
+  isLabModeFromEnv,
+  resolveRepoRootFromBuildDir,
+  resetConfiguredTelemetryDbWarningCache,
+  dbLocationToDir,
+  telemetryDirFromDbDir,
+  isLegacyRepoLocalTelemetryLocation,
+  TelemetryPathResolver,
+  LabPathResolver,
+  runWithLabContextAsync,
+  generateLabId,
+  generateRunId,
+  createLabContext,
+  validateLabConfig,
+  verifyLabMode,
+  initializeLabModeFromEnv,
+  getMostRecentLabRun,
+  checkAndWarnLabContext
+};
+//# sourceMappingURL=chunk-C3KCMAJP.js.map