@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-7TUTZTI2.js

@@ -0,0 +1,911 @@
+import {
+  appendJsonlWithLockSync
+} from "./chunk-YKC75XK4.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  assertDataMigrationAtWorkTreeTopLevel,
+  getRepoDataMigrationMarkerPath,
+  getSharedDataMigrationMarkerPath,
+  readProjectDataMigrationMarker
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  applySqlitePragmas,
+  getSqliteBusyTimeoutMs
+} from "./chunk-HEP3ILP4.js";
+import {
+  getGlobalTelemetryDir,
+  getProjectDataDir,
+  getStableRepoIdentity
+} from "./chunk-56WPYDJH.js";
+
+// src/telemetry/data-migration-state.ts
+import fsSync2 from "fs";
+import fs2 from "fs/promises";
+import path2 from "path";
+import Database from "better-sqlite3";
+
+// src/telemetry/data-migration-columns.ts
+function quoteIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function migrationColumns(db, tableName) {
+  const columns = (schema) => db.prepare(`PRAGMA ${schema}.table_info(${quoteIdentifier(tableName)})`).all();
+  const destination = columns("main");
+  const sourceColumns = new Set(columns("local_db").map((column) => column.name));
+  const primaryKeys = destination.filter((column) => column.pk > 0);
+  const indexes = db.prepare(`PRAGMA main.index_list(${quoteIdentifier(tableName)})`).all();
+  const hasPrimaryKeyIndex = indexes.some((index) => index.origin === "pk");
+  const rowId = !hasPrimaryKeyIndex && primaryKeys.length === 1 && primaryKeys[0].type.toUpperCase() === "INTEGER" ? primaryKeys[0].name : void 0;
+  const insertColumns = destination.filter(
+    (column) => !(column.name === "id" && column.name === rowId) && (column.name === "project_id" || sourceColumns.has(column.name))
+  ).map((column) => column.name);
+  return { insertColumns, sourceColumns };
+}
+
+// src/telemetry/data-migration-content-probe.ts
+import fsSync from "fs";
+import fs from "fs/promises";
+import path from "path";
+async function pathHasAnyContent(targetPath) {
+  if (!fsSync.existsSync(targetPath)) {
+    return false;
+  }
+  const stat = await fs.stat(targetPath);
+  if (!stat.isDirectory()) {
+    return stat.size > 0;
+  }
+  const entries = await fs.readdir(targetPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (await pathHasAnyContent(path.join(targetPath, entry.name))) {
+      return true;
+    }
+  }
+  return false;
+}
+var BOOTSTRAP_STATE_FILES = /* @__PURE__ */ new Set([
+  "init.json",
+  ".init.lock",
+  "data-migration.json",
+  // src/core/git/clean-tree-guard.ts INIT_CREATED_ROOT_FILES_REL
+  "init-created-root-files.json",
+  // src/core/init-drift/state.ts stack-fingerprint baseline and nudge ledger
+  "init-fingerprint.json",
+  "init-nudges.json",
+  // src/core/knowledge/pending-notice.ts, written by init
+  path.join("knowledge", "pending-offer-notice.json")
+]);
+async function stateDirectoryHasMigratableContent(stateDir, relativeDir = "") {
+  if (!fsSync.existsSync(stateDir)) {
+    return false;
+  }
+  const entries = await fs.readdir(stateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = path.join(relativeDir, entry.name);
+    if (entry.isFile() && BOOTSTRAP_STATE_FILES.has(relativePath)) {
+      continue;
+    }
+    const entryPath = path.join(stateDir, entry.name);
+    if (entry.isDirectory()) {
+      if (await stateDirectoryHasMigratableContent(entryPath, relativePath)) {
+        return true;
+      }
+      continue;
+    }
+    if (await pathHasAnyContent(entryPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/telemetry/data-migration-state.ts
+var BENIGN_SKIP_REASONS = /* @__PURE__ */ new Set(["destination already has data"]);
+var UNSAFE_SQLITE_RETIREMENT_REASON = "legacy SQLite source cannot be retired without continuous writer exclusion";
+async function isBenignMigrationSkip(skip, alreadyMigrated) {
+  if (skip.reason === UNSAFE_SQLITE_RETIREMENT_REASON) {
+    return false;
+  }
+  if (BENIGN_SKIP_REASONS.has(skip.reason)) {
+    return true;
+  }
+  if (alreadyMigrated && await destinationHasData(skip.destination)) {
+    return true;
+  }
+  return false;
+}
+function pathExists(targetPath) {
+  return fsSync2.existsSync(targetPath);
+}
+function resolveBuildDir(buildDirOrRepoRoot) {
+  const resolved = path2.resolve(buildDirOrRepoRoot);
+  return path2.basename(resolved) === ".build-project" ? resolved : path2.join(resolved, ".build-project");
+}
+async function computePathSizeBytes(targetPath) {
+  if (!pathExists(targetPath)) {
+    return 0;
+  }
+  const stat = await fs2.stat(targetPath);
+  if (!stat.isDirectory()) {
+    return stat.size;
+  }
+  const entries = await fs2.readdir(targetPath, { withFileTypes: true });
+  let total = 0;
+  for (const entry of entries) {
+    total += await computePathSizeBytes(path2.join(targetPath, entry.name));
+  }
+  return total;
+}
+async function ensureDirectory(targetDir) {
+  await fs2.mkdir(targetDir, { recursive: true, mode: 448 });
+}
+function listUserTables(db, schemaName = "main") {
+  const rows = db.prepare(
+    `SELECT name FROM ${schemaName}.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`
+  ).all();
+  return rows.map((row) => row.name);
+}
+function checkpointSqliteWal(dbFile) {
+  if (!pathExists(dbFile) || !hasSqliteHeader(dbFile)) {
+    return;
+  }
+  let db;
+  try {
+    db = new Database(dbFile, { timeout: getSqliteBusyTimeoutMs() });
+    applySqlitePragmas(db);
+    const checkpointResult = db.pragma("wal_checkpoint(TRUNCATE)");
+    const row = checkpointResult[0];
+    if (row === void 0 || row.busy !== 0) {
+      throw new Error(
+        `SQLite WAL checkpoint incomplete for ${dbFile}: busy=${row?.busy ?? "unknown"}`
+      );
+    }
+  } finally {
+    db?.close();
+  }
+}
+function hasSqliteHeader(dbFile) {
+  try {
+    const fd = fsSync2.openSync(dbFile, "r");
+    try {
+      const header = Buffer.alloc(16);
+      return fsSync2.readSync(fd, header, 0, header.length, 0) === header.length && header.toString("utf8") === "SQLite format 3\0";
+    } finally {
+      fsSync2.closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+function removeSqliteSidecars(dbFile) {
+  for (const suffix of ["-wal", "-shm"]) {
+    try {
+      fsSync2.rmSync(`${dbFile}${suffix}`, { force: true });
+    } catch {
+    }
+  }
+}
+function mergeSqliteFile(sourceFile, destinationFile, projectId) {
+  checkpointSqliteWal(sourceFile);
+  if (!pathExists(destinationFile)) {
+    throw new Error(`Cannot merge SQLite into missing destination: ${destinationFile}`);
+  }
+  let destDb;
+  try {
+    destDb = new Database(destinationFile, {
+      timeout: getSqliteBusyTimeoutMs(),
+      fileMustExist: true
+    });
+    applySqlitePragmas(destDb);
+    destDb.prepare("ATTACH DATABASE ? AS local_db").run(sourceFile);
+    try {
+      const mergeTransaction = destDb.transaction(() => {
+        const destinationTables = new Set(listUserTables(destDb, "main"));
+        const sourceTables = listUserTables(destDb, "local_db");
+        for (const tableName of sourceTables) {
+          if (!destinationTables.has(tableName)) {
+            continue;
+          }
+          const { insertColumns, sourceColumns } = migrationColumns(destDb, tableName);
+          if (insertColumns.length === 0) {
+            continue;
+          }
+          const selectExpressions = insertColumns.map((column) => {
+            if (column === "project_id") {
+              if (sourceColumns.has("project_id")) {
+                return `COALESCE(NULLIF(s.${quoteIdentifier(column)}, ''), ?) AS ${quoteIdentifier(column)}`;
+              }
+              return `? AS ${quoteIdentifier(column)}`;
+            }
+            return `s.${quoteIdentifier(column)}`;
+          });
+          const scopeParams = insertColumns.filter((column) => column === "project_id").map(() => projectId);
+          const sql = `
+            INSERT OR IGNORE INTO ${quoteIdentifier(tableName)} (${insertColumns.map(quoteIdentifier).join(", ")})
+            SELECT ${selectExpressions.join(", ")}
+            FROM local_db.${quoteIdentifier(tableName)} s
+            WHERE 1=1
+          `;
+          destDb.prepare(sql).run(...scopeParams);
+        }
+      });
+      mergeTransaction.immediate();
+    } finally {
+      try {
+        destDb.prepare("DETACH DATABASE local_db").run();
+      } catch {
+      }
+    }
+  } finally {
+    try {
+      destDb?.close();
+    } catch {
+    }
+  }
+}
+async function filesHaveIdenticalContent(leftPath, rightPath) {
+  const [leftStat, rightStat] = await Promise.all([fs2.stat(leftPath), fs2.stat(rightPath)]);
+  if (leftStat.size !== rightStat.size) {
+    return false;
+  }
+  const [leftBuf, rightBuf] = await Promise.all([fs2.readFile(leftPath), fs2.readFile(rightPath)]);
+  return leftBuf.equals(rightBuf);
+}
+function isBootstrapStatePath(targetPath, repoRoot) {
+  const stateRoot = path2.join(path2.resolve(repoRoot), ".build-project", "state");
+  return BOOTSTRAP_STATE_FILES.has(path2.relative(stateRoot, path2.resolve(targetPath)));
+}
+function isDestinationAuthoritativeSourceFile(targetPath, repoRoot) {
+  const resolved = path2.resolve(targetPath);
+  const buildDir = path2.join(path2.resolve(repoRoot), ".build-project");
+  const logsDir = path2.join(buildDir, "telemetry", "logs");
+  return resolved.startsWith(logsDir + path2.sep) && resolved.endsWith(".jsonl");
+}
+async function appendMissingJsonlLines(sourcePath, destinationPath) {
+  const [sourceContent, destinationContent] = await Promise.all([
+    fs2.readFile(sourcePath, "utf8"),
+    fs2.readFile(destinationPath, "utf8")
+  ]);
+  const present = new Set(destinationContent.split("\n"));
+  const missing = sourceContent.split("\n").filter((line) => line.trim() && !present.has(line));
+  if (missing.length === 0) {
+    return;
+  }
+  const separator = destinationContent.length > 0 && !destinationContent.endsWith("\n") ? "\n" : "";
+  appendJsonlWithLockSync(destinationPath, `${separator}${missing.join("\n")}
+`);
+}
+function sourceContainsBootstrapState(sourcePath, repoRoot) {
+  const resolvedSource = path2.resolve(sourcePath);
+  return [...BOOTSTRAP_STATE_FILES].some((relativePath) => {
+    const bootstrapPath = path2.join(
+      path2.resolve(repoRoot),
+      ".build-project",
+      "state",
+      relativePath
+    );
+    if (!pathExists(bootstrapPath)) return false;
+    const relative = path2.relative(resolvedSource, bootstrapPath);
+    return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+  });
+}
+function isGenuineSqliteDatabaseFile(targetPath) {
+  return path2.basename(targetPath).endsWith(".db") && pathExists(targetPath) && hasSqliteHeader(targetPath);
+}
+function isManagedSqliteFile(targetPath) {
+  const base = path2.basename(targetPath);
+  if (base.endsWith("-wal") || base.endsWith("-shm")) {
+    const parentDbPath = targetPath.replace(/-(?:wal|shm)$/, "");
+    return isGenuineSqliteDatabaseFile(parentDbPath);
+  }
+  return isGenuineSqliteDatabaseFile(targetPath);
+}
+function isTelemetryDbMergeOperation(operation) {
+  return operation.category === "global-telemetry" && path2.basename(operation.source) === "db" && path2.dirname(operation.source).endsWith(path2.join(".build-project", "telemetry"));
+}
+async function findUnresolvedDirectoryCollisions(sourcePath, destinationPath, repoRoot, options = {}) {
+  if (isBootstrapStatePath(sourcePath, repoRoot)) {
+    return [];
+  }
+  if (isDestinationAuthoritativeSourceFile(sourcePath, repoRoot)) {
+    return [];
+  }
+  if (options.skipManagedSqliteFiles && isManagedSqliteFile(sourcePath)) {
+    return [];
+  }
+  if (!pathExists(destinationPath)) {
+    return [];
+  }
+  const [sourceStat, destinationStat] = await Promise.all([
+    fs2.stat(sourcePath),
+    fs2.stat(destinationPath)
+  ]);
+  if (sourceStat.isDirectory() !== destinationStat.isDirectory()) {
+    return [{ source: sourcePath, destination: destinationPath }];
+  }
+  if (!sourceStat.isDirectory()) {
+    return await filesHaveIdenticalContent(sourcePath, destinationPath) ? [] : [{ source: sourcePath, destination: destinationPath }];
+  }
+  const collisions = [];
+  for (const entry of await fs2.readdir(sourcePath)) {
+    collisions.push(
+      ...await findUnresolvedDirectoryCollisions(
+        path2.join(sourcePath, entry),
+        path2.join(destinationPath, entry),
+        repoRoot,
+        options
+      )
+    );
+  }
+  return collisions;
+}
+async function mergeDirectoryTree(sourceDir, destinationDir, repoRoot, options) {
+  await ensureDirectory(destinationDir);
+  const moved = [];
+  const skipped = [];
+  const entries = await fs2.readdir(sourceDir, { withFileTypes: true });
+  const managedSqliteSidecarNames = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.isDirectory() || !entry.name.endsWith(".db")) {
+      continue;
+    }
+    const candidateDbPath = path2.join(sourceDir, entry.name);
+    if (isGenuineSqliteDatabaseFile(candidateDbPath)) {
+      managedSqliteSidecarNames.add(`${entry.name}-wal`);
+      managedSqliteSidecarNames.add(`${entry.name}-shm`);
+    }
+  }
+  for (const entry of entries) {
+    const sourcePath = path2.join(sourceDir, entry.name);
+    const destinationPath = path2.join(destinationDir, entry.name);
+    if (isBootstrapStatePath(sourcePath, repoRoot)) {
+      continue;
+    }
+    if (isDestinationAuthoritativeSourceFile(sourcePath, repoRoot) && pathExists(destinationPath)) {
+      if (sourcePath.endsWith(".jsonl")) {
+        await appendMissingJsonlLines(sourcePath, destinationPath);
+      }
+      await fs2.rm(sourcePath, { force: true });
+      skipped.push({
+        source: sourcePath,
+        destination: destinationPath,
+        reason: "destination already has data"
+      });
+      continue;
+    }
+    if ((entry.name.endsWith("-wal") || entry.name.endsWith("-shm")) && managedSqliteSidecarNames.has(entry.name)) {
+      if (!pathExists(sourcePath)) {
+        continue;
+      }
+      const parentDbPath = sourcePath.replace(/-(?:wal|shm)$/, "");
+      if (!pathExists(parentDbPath)) {
+        skipped.push({
+          source: sourcePath,
+          destination: destinationPath,
+          reason: "orphaned SQLite sidecar"
+        });
+      }
+      continue;
+    }
+    if (!pathExists(sourcePath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (!pathExists(destinationPath) && !sourceContainsBootstrapState(sourcePath, repoRoot)) {
+        await movePath(sourcePath, destinationPath, repoRoot);
+        moved.push({ source: sourcePath, destination: destinationPath });
+        continue;
+      }
+      const destStat2 = pathExists(destinationPath) ? await fs2.stat(destinationPath) : void 0;
+      if (destStat2 && !destStat2.isDirectory()) {
+        skipped.push({
+          source: sourcePath,
+          destination: destinationPath,
+          reason: options.alreadyMigrated ? "destination already has data" : "unresolved file collision"
+        });
+        continue;
+      }
+      const nested = await mergeDirectoryTree(sourcePath, destinationPath, repoRoot, options);
+      moved.push(...nested.moved);
+      skipped.push(...nested.skipped);
+      if (pathExists(sourcePath)) {
+        const remainingNested = await fs2.readdir(sourcePath);
+        if (remainingNested.length === 0) {
+          await safeRmDir(sourcePath, {
+            protectedPaths: [repoRoot],
+            managedRoots: [path2.resolve(repoRoot, ".build-project")],
+            dryRun: false
+          });
+        }
+      }
+      continue;
+    }
+    if (!pathExists(destinationPath)) {
+      if (isGenuineSqliteDatabaseFile(sourcePath)) {
+        try {
+          checkpointSqliteWal(sourcePath);
+          removeSqliteSidecars(sourcePath);
+        } catch (error) {
+          skipped.push({
+            source: sourcePath,
+            destination: destinationPath,
+            reason: error instanceof Error ? error.message : String(error)
+          });
+          continue;
+        }
+      }
+      await movePath(sourcePath, destinationPath, repoRoot);
+      moved.push({ source: sourcePath, destination: destinationPath });
+      continue;
+    }
+    const destStat = await fs2.stat(destinationPath);
+    if (destStat.isDirectory()) {
+      skipped.push({
+        source: sourcePath,
+        destination: destinationPath,
+        reason: options.alreadyMigrated ? "destination already has data" : "unresolved file collision"
+      });
+      continue;
+    }
+    if (isGenuineSqliteDatabaseFile(sourcePath) && options.sqliteMerge) {
+      if (options.alreadyMigrated && await destinationHasData(destinationPath)) {
+        skipped.push({
+          source: sourcePath,
+          destination: destinationPath,
+          reason: "destination already has data"
+        });
+        continue;
+      }
+      try {
+        mergeSqliteFile(sourcePath, destinationPath, options.sqliteMerge.projectId);
+        await fs2.rm(sourcePath, { force: true });
+        removeSqliteSidecars(sourcePath);
+        moved.push({ source: sourcePath, destination: destinationPath });
+      } catch (error) {
+        skipped.push({
+          source: sourcePath,
+          destination: destinationPath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+      continue;
+    }
+    if (await filesHaveIdenticalContent(sourcePath, destinationPath)) {
+      await fs2.rm(sourcePath, { force: true });
+      skipped.push({
+        source: sourcePath,
+        destination: destinationPath,
+        reason: "destination already has data"
+      });
+      continue;
+    }
+    if (options.alreadyMigrated) {
+      skipped.push({
+        source: sourcePath,
+        destination: destinationPath,
+        reason: "destination already has data"
+      });
+      continue;
+    }
+    skipped.push({
+      source: sourcePath,
+      destination: destinationPath,
+      reason: "unresolved file collision"
+    });
+  }
+  if (pathExists(sourceDir)) {
+    const remaining = await fs2.readdir(sourceDir);
+    if (remaining.length === 0) {
+      await safeRmDir(sourceDir, {
+        protectedPaths: [repoRoot],
+        managedRoots: [path2.resolve(repoRoot, ".build-project")],
+        dryRun: false
+      });
+    }
+  }
+  return { moved, skipped };
+}
+async function mergeTelemetryDbDirectory(sourceDir, destinationDir, projectId, repoRoot, alreadyMigrated) {
+  const entries = await fs2.readdir(sourceDir);
+  const hasSqliteSource = entries.some(
+    (entry) => isGenuineSqliteDatabaseFile(path2.join(sourceDir, entry))
+  );
+  if (hasSqliteSource && !pathExists(destinationDir)) {
+    await ensureDirectory(path2.dirname(destinationDir));
+    await fs2.rename(sourceDir, destinationDir);
+    return {
+      moved: [{ source: sourceDir, destination: destinationDir }],
+      skipped: []
+    };
+  }
+  return mergeDirectoryTree(sourceDir, destinationDir, repoRoot, {
+    alreadyMigrated,
+    sqliteMerge: { projectId }
+  });
+}
+async function movePath(source, destination, repoRoot) {
+  await ensureDirectory(path2.dirname(destination));
+  try {
+    await fs2.rename(source, destination);
+    return;
+  } catch (error) {
+    if (error.code !== "EXDEV") {
+      throw error;
+    }
+  }
+  await fs2.cp(source, destination, { recursive: true, force: true });
+  const sourceStat = await fs2.stat(source);
+  if (sourceStat.isDirectory()) {
+    await safeRmDir(source, {
+      protectedPaths: [repoRoot],
+      managedRoots: [path2.resolve(repoRoot, ".build-project")],
+      dryRun: false
+    });
+    return;
+  }
+  await fs2.rm(source, { force: true });
+}
+function getDataMigrationMarkerPath(buildDir) {
+  return getRepoDataMigrationMarkerPath(buildDir);
+}
+function readDataMigrationMarker(buildDir) {
+  return readProjectDataMigrationMarker(buildDir);
+}
+function isDataMigrationComplete(buildDir) {
+  return readDataMigrationMarker(buildDir) !== null;
+}
+function sqliteFileHasMigratableRows(dbPath) {
+  if (!pathExists(dbPath)) {
+    return false;
+  }
+  let db;
+  try {
+    db = new Database(dbPath, { readonly: true, timeout: getSqliteBusyTimeoutMs() });
+    const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`).all();
+    for (const { name } of tables) {
+      const row = db.prepare(`SELECT 1 FROM ${quoteIdentifier(name)} LIMIT 1`).get();
+      if (row !== void 0) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    db?.close();
+  }
+}
+async function telemetryDbDirectoryHasMigratableRows(dbDir) {
+  if (!pathExists(dbDir)) {
+    return false;
+  }
+  const entries = await fs2.readdir(dbDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".db")) {
+      if (sqliteFileHasMigratableRows(path2.join(dbDir, entry.name))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function hasMigratableRepoLocalData(buildDir) {
+  const resolvedBuildDir = resolveBuildDir(buildDir);
+  const repoRoot = path2.dirname(resolvedBuildDir);
+  const targets = buildDataMigrationTargets(
+    repoRoot,
+    getGlobalTelemetryDir(),
+    getProjectDataDir(repoRoot)
+  );
+  const telemetryDbSuffix = path2.join(".build-project", "telemetry", "db");
+  const stateDirSuffix = path2.join(".build-project", "state");
+  if (sqliteFileHasMigratableRows(legacyInvocationsDbPath(resolvedBuildDir))) {
+    return true;
+  }
+  for (const target of targets) {
+    if (!pathExists(target.source)) {
+      continue;
+    }
+    const isTelemetryDbOperation = target.category === "global-telemetry" && path2.basename(target.source) === "db" && target.source.endsWith(telemetryDbSuffix);
+    if (isTelemetryDbOperation) {
+      if (await telemetryDbDirectoryHasMigratableRows(target.source)) {
+        return true;
+      }
+      continue;
+    }
+    if (target.source.endsWith(stateDirSuffix)) {
+      if (await stateDirectoryHasMigratableContent(target.source)) {
+        return true;
+      }
+      continue;
+    }
+    if (await pathHasAnyContent(target.source)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasLegacyRepoLocalTelemetryPaths(buildDir) {
+  const resolvedBuildDir = resolveBuildDir(buildDir);
+  const legacyDb = path2.join(resolvedBuildDir, "telemetry", "db", "variants.db");
+  const legacyInvocations = legacyInvocationsDbPath(resolvedBuildDir);
+  const legacySynthesis = path2.join(resolvedBuildDir, "telemetry", "synthesis");
+  return {
+    db: pathExists(legacyDb) ? legacyDb : null,
+    invocations: pathExists(legacyInvocations) ? legacyInvocations : null,
+    synthesis: pathExists(legacySynthesis) ? legacySynthesis : null
+  };
+}
+function legacyInvocationsDbPath(resolvedBuildDir) {
+  return path2.join(resolvedBuildDir, "telemetry", "invocations.db");
+}
+async function migrateLegacyInvocationsDb(repoRoot, globalTelemetryDir, projectId) {
+  const source = legacyInvocationsDbPath(path2.join(repoRoot, ".build-project"));
+  const destination = path2.join(globalTelemetryDir, "invocations.db");
+  if (!isGenuineSqliteDatabaseFile(source)) {
+    return { moved: [], skipped: [] };
+  }
+  try {
+    checkpointSqliteWal(source);
+    if (pathExists(destination)) {
+      mergeSqliteFile(source, destination, projectId);
+      await fs2.rm(source, { force: true });
+    } else {
+      removeSqliteSidecars(source);
+      await movePath(source, destination, repoRoot);
+    }
+    removeSqliteSidecars(source);
+    return { moved: [{ source, destination }], skipped: [] };
+  } catch (error) {
+    return {
+      moved: [],
+      skipped: [
+        { source, destination, reason: error instanceof Error ? error.message : String(error) }
+      ]
+    };
+  }
+}
+function buildDataMigrationTargets(repoRoot, globalTelemetryDir, projectDataDir) {
+  return [
+    {
+      category: "global-telemetry",
+      source: path2.join(repoRoot, ".build-project", "telemetry", "db"),
+      destination: path2.join(globalTelemetryDir, "db")
+    },
+    {
+      category: "global-telemetry",
+      source: path2.join(repoRoot, ".build-project", "telemetry", "logs"),
+      destination: path2.join(globalTelemetryDir, "logs")
+    },
+    {
+      category: "global-telemetry",
+      source: path2.join(repoRoot, ".build-project", "telemetry", "synthesis"),
+      destination: path2.join(globalTelemetryDir, "synthesis")
+    },
+    {
+      category: "project-data",
+      source: path2.join(repoRoot, ".build-project", "state"),
+      destination: path2.join(projectDataDir, "state")
+    },
+    {
+      category: "project-data",
+      source: path2.join(repoRoot, ".build-project", "provider-history"),
+      destination: path2.join(projectDataDir, "provider-history")
+    },
+    {
+      category: "project-data",
+      source: path2.join(repoRoot, ".build-project", "labs"),
+      destination: path2.join(projectDataDir, "labs")
+    },
+    {
+      category: "project-data",
+      source: path2.join(repoRoot, ".build-project", "backups"),
+      destination: path2.join(projectDataDir, "backups")
+    },
+    {
+      category: "project-data",
+      source: path2.join(repoRoot, ".build-project", "lifecycle"),
+      destination: path2.join(projectDataDir, "lifecycle")
+    },
+    {
+      category: "project-data",
+      source: path2.join(repoRoot, ".build-project", "cache"),
+      destination: path2.join(projectDataDir, "cache")
+    }
+  ];
+}
+async function collectDataMigrationStatus(buildDir) {
+  const repoRoot = path2.dirname(resolveBuildDir(buildDir));
+  const projectId = getStableRepoIdentity(repoRoot);
+  const globalTelemetryDir = getGlobalTelemetryDir();
+  const projectDataDir = getProjectDataDir(repoRoot);
+  const markerPath = getDataMigrationMarkerPath(path2.join(repoRoot, ".build-project"));
+  const ops = buildDataMigrationTargets(repoRoot, globalTelemetryDir, projectDataDir);
+  const operations = [];
+  for (const op of ops) {
+    const exists = pathExists(op.source);
+    const sizeBytes = exists ? await computePathSizeBytes(op.source) : 0;
+    operations.push({
+      ...op,
+      exists,
+      sizeBytes
+    });
+  }
+  return {
+    repoRoot,
+    projectId,
+    markerPath,
+    marker: readDataMigrationMarker(path2.join(repoRoot, ".build-project")),
+    globalTelemetryDir,
+    projectDataDir,
+    operations,
+    hasLegacyData: operations.some((op) => op.exists && op.sizeBytes > 0)
+  };
+}
+async function writeMarker(markerPath, marker) {
+  await ensureDirectory(path2.dirname(markerPath));
+  const tmpPath = `${markerPath}.tmp`;
+  await fs2.writeFile(tmpPath, JSON.stringify(marker, null, 2), { mode: 384 });
+  await fs2.rename(tmpPath, markerPath);
+}
+async function destinationHasData(destination) {
+  if (!pathExists(destination)) {
+    return false;
+  }
+  const stat = await fs2.stat(destination);
+  if (!stat.isDirectory()) {
+    return stat.size > 0;
+  }
+  const entries = await fs2.readdir(destination);
+  return entries.length > 0;
+}
+async function executeDataMigration(buildDir) {
+  await assertDataMigrationAtWorkTreeTopLevel(buildDir);
+  const status = await collectDataMigrationStatus(buildDir);
+  const alreadyMigrated = status.marker !== null;
+  const moved = [];
+  const skipped = [];
+  await ensureDirectory(status.globalTelemetryDir);
+  await ensureDirectory(status.projectDataDir);
+  if (!alreadyMigrated) {
+    const collisions = [];
+    for (const operation of status.operations) {
+      if (!operation.exists || !pathExists(operation.destination)) {
+        continue;
+      }
+      collisions.push(
+        ...await findUnresolvedDirectoryCollisions(
+          operation.source,
+          operation.destination,
+          status.repoRoot,
+          {
+            skipManagedSqliteFiles: isTelemetryDbMergeOperation(operation)
+          }
+        )
+      );
+    }
+    if (collisions.length > 0) {
+      throw new Error(
+        `Data migration found ${collisions.length} unresolved collision(s) before moving data; completion marker was not written`
+      );
+    }
+  }
+  for (const operation of status.operations) {
+    if (!operation.exists) {
+      continue;
+    }
+    if (isTelemetryDbMergeOperation(operation)) {
+      try {
+        const mergeResult = await mergeTelemetryDbDirectory(
+          operation.source,
+          operation.destination,
+          status.projectId,
+          status.repoRoot,
+          alreadyMigrated
+        );
+        moved.push(...mergeResult.moved);
+        skipped.push(...mergeResult.skipped);
+      } catch (error) {
+        skipped.push({
+          source: operation.source,
+          destination: operation.destination,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+      continue;
+    }
+    const forceEntryWiseMerge = sourceContainsBootstrapState(operation.source, status.repoRoot);
+    if (await destinationHasData(operation.destination) || forceEntryWiseMerge) {
+      try {
+        const mergeResult = await mergeDirectoryTree(
+          operation.source,
+          operation.destination,
+          status.repoRoot,
+          { alreadyMigrated }
+        );
+        moved.push(...mergeResult.moved);
+        skipped.push(...mergeResult.skipped);
+      } catch (error) {
+        skipped.push({
+          source: operation.source,
+          destination: operation.destination,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+      continue;
+    }
+    try {
+      await movePath(operation.source, operation.destination, status.repoRoot);
+      moved.push({ source: operation.source, destination: operation.destination });
+    } catch (error) {
+      skipped.push({
+        source: operation.source,
+        destination: operation.destination,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const invocationsResult = await migrateLegacyInvocationsDb(
+    status.repoRoot,
+    status.globalTelemetryDir,
+    status.projectId
+  );
+  moved.push(...invocationsResult.moved);
+  skipped.push(...invocationsResult.skipped);
+  const blockingSkips = [];
+  for (const skip of skipped) {
+    if (!await isBenignMigrationSkip(skip, alreadyMigrated)) {
+      blockingSkips.push(skip);
+    }
+  }
+  if (blockingSkips.length > 0) {
+    throw new Error(
+      `Data migration skipped ${blockingSkips.length} operation(s) due to errors; completion marker was not written`
+    );
+  }
+  const leftoverSynthesis = hasLegacyRepoLocalTelemetryPaths(
+    path2.join(status.repoRoot, ".build-project")
+  ).synthesis;
+  if (leftoverSynthesis && await pathHasAnyContent(leftoverSynthesis)) {
+    throw new Error(
+      `Data migration left legacy telemetry/synthesis at ${leftoverSynthesis}; completion marker was not written. Move that directory into ${path2.join(status.globalTelemetryDir, "synthesis")} and re-run \`build data migrate execute\`.`
+    );
+  }
+  if (leftoverSynthesis) {
+    await safeRmDir(leftoverSynthesis, {
+      protectedPaths: [status.repoRoot],
+      managedRoots: [path2.resolve(status.repoRoot, ".build-project")],
+      dryRun: false
+    });
+  }
+  const marker = {
+    version: 1,
+    migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoRoot: status.repoRoot,
+    projectId: status.projectId,
+    globalTelemetryDir: status.globalTelemetryDir,
+    projectDataDir: status.projectDataDir
+  };
+  const sharedMarkerPath = getSharedDataMigrationMarkerPath(status.repoRoot);
+  if (path2.resolve(sharedMarkerPath) !== path2.resolve(status.markerPath)) {
+    await writeMarker(sharedMarkerPath, marker);
+  }
+  await writeMarker(status.markerPath, marker);
+  return {
+    moved,
+    skipped,
+    markerPath: status.markerPath
+  };
+}
+
+export {
+  getDataMigrationMarkerPath,
+  readDataMigrationMarker,
+  isDataMigrationComplete,
+  hasMigratableRepoLocalData,
+  hasLegacyRepoLocalTelemetryPaths,
+  collectDataMigrationStatus,
+  executeDataMigration
+};
+//# sourceMappingURL=chunk-7TUTZTI2.js.map