@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-JBBB2Y47.js

@@ -0,0 +1,432 @@
+import {
+  providerExecutionTransportStreamOptions,
+  sanitizeDiagnosticText
+} from "./chunk-RBKLOUXA.js";
+import {
+  tailLines
+} from "./chunk-2VLJUXJU.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  isDebugMode
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeError,
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/providers/shared/execa-error-classification.ts
+import { existsSync as existsSync2 } from "fs";
+import os2 from "os";
+
+// src/core/providers/shared/command-not-found.ts
+import { accessSync, existsSync, constants as fsConstants } from "fs";
+import os from "os";
+import path from "path";
+function expandTilde(command) {
+  if (command === "~") return os.homedir();
+  if (command.startsWith("~/") || command.startsWith("~\\")) {
+    return path.join(os.homedir(), command.slice(2));
+  }
+  return command;
+}
+function isExecutableFile(candidate) {
+  try {
+    accessSync(candidate, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isCommandBinaryAbsent(command) {
+  const trimmed = command?.trim();
+  if (!trimmed) return false;
+  const looksLikePath = trimmed.startsWith("~") || trimmed.includes("/") || trimmed.includes("\\");
+  if (looksLikePath) {
+    return !existsSync(expandTilde(trimmed));
+  }
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return false;
+  const exts = process.platform === "win32" ? [".cmd", ".exe", ""] : [""];
+  for (const dir of pathEnv.split(path.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      if (isExecutableFile(path.join(dir, `${trimmed}${ext}`))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function shellReportedCommandMissing(text, command) {
+  const name = path.basename(expandTilde(command?.trim() ?? "")).replace(/\.(?:cmd|exe|bat)$/i, "");
+  if (!name) return false;
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const named = new RegExp(
+    `(?:^|[\\s:'"/\\\\])${escaped}(?:\\.(?:cmd|exe|bat))?(?=$|[\\s:'"])`,
+    "i"
+  );
+  return text.split(/\r?\n/).some(
+    (line) => /command not found|is not recognized as an internal or external command/i.test(line) && named.test(line)
+  );
+}
+function handleCommandNotFound(error, command, metadata) {
+  const err = error;
+  const message = err?.message ?? "";
+  const stderr = err?.stderr ?? "";
+  const combined = error instanceof ProviderExecutionError ? stderr : `${message}
+${stderr}`;
+  const enoent = err?.code === "ENOENT" || /spawn .* ENOENT/i.test(message);
+  const spawnMissed = enoent && isCommandBinaryAbsent(command);
+  const notFound = spawnMissed || shellReportedCommandMissing(combined, command);
+  if (notFound) {
+    const docsPath = metadata.docsPath || "docs/PROVIDER_SETUP.md";
+    const docsRef = metadata.docsAnchor ? `${docsPath}#${metadata.docsAnchor}` : docsPath;
+    const providerId = metadata.id;
+    const lines = [
+      `'${command}' is not available on this system.`,
+      "",
+      `Please install ${metadata.name} first.`,
+      "",
+      `The '${command}' command is required but not installed.`,
+      "",
+      "To fix:",
+      `  1. Install:  ${metadata.installCommand}`
+    ];
+    if (metadata.authHint) {
+      lines.push(`  2. Auth:     ${metadata.authHint}`);
+      lines.push(`  3. Verify:   build doctor --provider ${providerId || command}`);
+    } else {
+      lines.push(`  2. Verify:   build doctor --provider ${providerId || command}`);
+    }
+    lines.push("", `Full setup guide: ${docsRef}`);
+    throw new ProviderExecutionError(lines.join("\n"), {
+      retryable: false,
+      reason: "command_not_found",
+      providerName: providerId || metadata.name,
+      prelaunch: spawnMissed
+    });
+  }
+  throw error;
+}
+
+// src/core/providers/shared/execa-error-classification.ts
+function hasSignal(result) {
+  return result.signal !== void 0 && result.signal !== null;
+}
+var PLATFORM_SIGNALS = os2.constants?.signals || {};
+var NUMBER_TO_SIGNAL = Object.fromEntries(
+  Object.entries(PLATFORM_SIGNALS).map(([name, num]) => [num, name])
+);
+function exitCodeToSignal(exitCode, explicitSignal) {
+  if (exitCode >= 128 && exitCode <= 255) {
+    if (explicitSignal && !/^SIG/i.test(explicitSignal)) {
+      return void 0;
+    }
+    const signalNum = exitCode - 128;
+    const decodedSignal = NUMBER_TO_SIGNAL[signalNum];
+    if (!decodedSignal) {
+      return void 0;
+    }
+    if (explicitSignal && decodedSignal.toUpperCase() !== explicitSignal.toUpperCase()) {
+      return void 0;
+    }
+    return decodedSignal;
+  }
+  return void 0;
+}
+var TIMEOUT_TERMINATION_REASONS = /* @__PURE__ */ new Set([
+  "timeout",
+  "hard_timeout",
+  "plm_timeout",
+  "idle_timeout"
+]);
+function isTimeoutTerminationReason(reason) {
+  return reason !== void 0 && TIMEOUT_TERMINATION_REASONS.has(reason);
+}
+var TIMEOUT_TERMINATION_EXIT_CODE = 124;
+function resolveTerminationExitCode(reason, observedExitCode) {
+  if (!isTimeoutTerminationReason(reason)) {
+    return observedExitCode;
+  }
+  return observedExitCode === void 0 || observedExitCode === 0 ? TIMEOUT_TERMINATION_EXIT_CODE : observedExitCode;
+}
+function formatTimeoutLimit(timeoutMs) {
+  return timeoutMs >= 6e4 ? `${Math.round(timeoutMs / 6e3) / 10}min` : `${Math.round(timeoutMs / 1e3)}s`;
+}
+var TIMEOUT_REMEDY_HINT_SENTENCE = "Rerun with a longer --timeout (in minutes) if this provider needs more time.";
+function formatTimeoutRemedyHint(timeoutMs, reason) {
+  const limit = reason !== "idle_timeout" && typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? ` The limit was ${formatTimeoutLimit(timeoutMs)}.` : "";
+  return `${limit} ${TIMEOUT_REMEDY_HINT_SENTENCE}`;
+}
+function formatTerminationRemedy(reason, timeoutMs) {
+  return isTimeoutTerminationReason(reason) ? formatTimeoutRemedyHint(timeoutMs, reason) : "";
+}
+function getExecaErrorLike(error) {
+  return error && typeof error === "object" ? error : {};
+}
+function getErrorConstructorName(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  return Object.getPrototypeOf(error)?.constructor?.name;
+}
+function getSpawnDiagnosticText(error) {
+  return [error.message, error.shortMessage, error.stderr].filter((part) => typeof part === "string" && part.length > 0).join("\n");
+}
+function isArgumentListTooLong(error) {
+  if (error.code === "E2BIG") {
+    return true;
+  }
+  const combined = getSpawnDiagnosticText(error);
+  return /\bE2BIG\b/i.test(combined) && /argument list too long|posix_spawn|spawn/i.test(combined);
+}
+function isSandboxApplyDenied(error) {
+  return /sandbox_apply:\s*Operation not permitted/i.test(getSpawnDiagnosticText(error));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isProviderStatePermissionDenied(error, metadata) {
+  const combined = getSpawnDiagnosticText(error);
+  const providerTokens = [metadata.id, metadata.name].filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => escapeRegExp(value.trim().toLowerCase()));
+  const providerPattern = providerTokens.length > 0 ? new RegExp(`[\\\\/~.](${providerTokens.join("|")})(?:[\\\\/]|$)`, "i") : null;
+  return /\b(?:EPERM|EACCES)\b|Operation not permitted|permission denied/i.test(combined) && (providerPattern?.test(combined) === true || /oauth_creds\.json|auth\.json|credentials|credential cache/i.test(combined));
+}
+function classifyAndWrapExecaError(ctx) {
+  const {
+    error,
+    metadata,
+    terminationState,
+    startTime,
+    timeout,
+    maxBufferBytes,
+    command,
+    args,
+    workingDir
+  } = ctx;
+  const pickStream = (value, captured) => typeof value === "string" && value.length > 0 ? value : captured ?? value;
+  const streamOptionsFor = (stdout, stderr) => providerExecutionTransportStreamOptions(
+    pickStream(stdout, ctx.capturedStdout),
+    pickStream(stderr, ctx.capturedStderr),
+    { streamBytes: ctx.streamBytes }
+  );
+  try {
+    handleCommandNotFound(error, command, metadata);
+  } catch (notFoundHandled) {
+    if (notFoundHandled !== error) {
+      throw notFoundHandled;
+    }
+  }
+  if (error instanceof ProviderExecutionError) {
+    throw error;
+  }
+  {
+    const enoentError = getExecaErrorLike(error);
+    const enoentMessage = String(enoentError.message ?? "");
+    const isEnoent = enoentError.code === "ENOENT" || /spawn .* ENOENT/i.test(enoentMessage);
+    if (isEnoent && !isCommandBinaryAbsent(command)) {
+      const cwdMissing = workingDir !== void 0 && !existsSync2(workingDir);
+      const detail = cwdMissing ? `working directory not found: ${workingDir}` : "spawn ENOENT despite the binary being present (likely a transient filesystem/working-directory condition)";
+      throw new ProviderExecutionError(`${metadata.name} CLI failed to spawn (${detail}).`, {
+        retryable: true,
+        reason: cwdMissing ? "working_directory_missing" : "spawn_failed",
+        ...streamOptionsFor(enoentError.stdout, enoentError.stderr)
+      });
+    }
+  }
+  const termination = terminationState.getPrimaryRecord();
+  if (termination !== null) {
+    const record = termination;
+    const execaError2 = getExecaErrorLike(error);
+    const observedExitCode = typeof execaError2.exitCode === "number" ? execaError2.exitCode : void 0;
+    const exitCode2 = resolveTerminationExitCode(record.reason, observedExitCode);
+    const signal2 = typeof execaError2.signal === "string" ? execaError2.signal : void 0;
+    const detailSuffix = record.detail ? ` (${record.detail})` : "";
+    const remedy = isTimeoutTerminationReason(record.reason) ? formatTimeoutRemedyHint(timeout, record.reason) : "";
+    throw new ProviderExecutionError(
+      `${metadata.name} CLI terminated (${record.reason} via ${record.source})${detailSuffix}.${remedy}`,
+      {
+        retryable: false,
+        exitCode: exitCode2,
+        reason: record.reason,
+        signal: signal2,
+        terminationSource: record.source,
+        ...streamOptionsFor(execaError2?.stdout, execaError2?.stderr)
+      }
+    );
+  }
+  const execaError = getExecaErrorLike(error);
+  if (error && typeof error === "object") {
+    const maxBufferErrorDetected = execaError.isMaxBuffer === true || /maxbuffer/i.test(String(execaError.shortMessage ?? execaError.message ?? ""));
+    if (maxBufferErrorDetected) {
+      const configuredMaxBuffer = typeof maxBufferBytes === "number" && Number.isFinite(maxBufferBytes) && maxBufferBytes > 0 ? Math.floor(maxBufferBytes) : void 0;
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI output exceeded max buffer${configuredMaxBuffer ? ` (${configuredMaxBuffer} bytes)` : ""}.`,
+        {
+          retryable: false,
+          reason: "output_limit_exceeded",
+          ...streamOptionsFor(execaError.stdout, execaError.stderr)
+        }
+      );
+    }
+    if (execaError.timedOut === true) {
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI execution timed out after ${timeout}ms. The operation exceeded the configured timeout limit.${formatTimeoutRemedyHint()}`,
+        {
+          retryable: false,
+          exitCode: resolveTerminationExitCode(
+            "timeout",
+            typeof execaError.exitCode === "number" ? execaError.exitCode : void 0
+          ),
+          reason: "timeout",
+          ...streamOptionsFor(execaError.stdout, execaError.stderr)
+        }
+      );
+    }
+    if (isDebugMode()) {
+      console.error("[BaseRunner] Error object properties:", {
+        timedOut: execaError.timedOut,
+        signal: execaError.signal,
+        isCanceled: execaError.isCanceled,
+        exitCode: execaError.exitCode,
+        elapsedTime: Date.now() - startTime,
+        timeout
+      });
+    }
+    if (isArgumentListTooLong(execaError)) {
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI failed to spawn because the prompt/argument payload exceeded the operating system argument limit. Use stdin or prompt-file transport for large prompts.`,
+        {
+          retryable: false,
+          reason: "argument_list_too_long",
+          ...streamOptionsFor(execaError.stdout, execaError.stderr)
+        }
+      );
+    }
+    if (isSandboxApplyDenied(execaError)) {
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI could not start because the sandbox profile could not be applied by the host environment.`,
+        {
+          retryable: false,
+          reason: "sandbox_environment_failure",
+          ...streamOptionsFor(execaError.stdout, execaError.stderr)
+        }
+      );
+    }
+    if (isProviderStatePermissionDenied(execaError, metadata)) {
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI could not access its provider state or credential cache in this environment.`,
+        {
+          retryable: false,
+          reason: "provider_auth_environment",
+          ...streamOptionsFor(execaError.stdout, execaError.stderr)
+        }
+      );
+    }
+    const signal2 = execaError.signal;
+    const elapsedTime = Date.now() - startTime;
+    const timeoutThreshold = timeout * 0.8;
+    const streamFields = streamOptionsFor(execaError.stdout, execaError.stderr);
+    if (typeof signal2 === "string" && /^SIG/i.test(signal2)) {
+      if (elapsedTime >= timeoutThreshold) {
+        throw new ProviderExecutionError(
+          `${metadata.name} CLI execution timed out after ${Math.round(elapsedTime)}ms (killed by ${signal2} signal, timeout: ${timeout}ms). The operation exceeded the configured timeout limit.${formatTimeoutRemedyHint()}`,
+          {
+            retryable: false,
+            exitCode: resolveTerminationExitCode(
+              "timeout",
+              typeof execaError.exitCode === "number" ? execaError.exitCode : void 0
+            ),
+            reason: "timeout",
+            signal: signal2,
+            ...streamFields
+          }
+        );
+      }
+    }
+    if (execaError.isCanceled === true) {
+      throw new ProviderExecutionError(
+        `${metadata.name} CLI execution was cancelled (AbortSignal triggered).`,
+        { retryable: false, reason: "cancelled", ...streamFields }
+      );
+    }
+  }
+  const sanitized = error instanceof Error ? sanitizeError(error) : void 0;
+  let errorMessage = sanitized?.message || sanitizeDiagnosticText(execaError.shortMessage) || "Provider execution failed";
+  if (!sanitized?.message && !execaError.shortMessage) {
+    const diagnostics = [];
+    if (execaError.exitCode !== void 0 && execaError.exitCode !== null) {
+      diagnostics.push(`exit code ${execaError.exitCode}`);
+    }
+    if (execaError.signal) {
+      diagnostics.push(`signal ${execaError.signal}`);
+    }
+    if (execaError.code) {
+      diagnostics.push(`code ${execaError.code}`);
+    }
+    if (diagnostics.length > 0) {
+      errorMessage += ` (${diagnostics.join(", ")})`;
+    } else {
+      const elapsedTime = Date.now() - startTime;
+      errorMessage += ` (no diagnostic info - elapsed: ${elapsedTime}ms, check provider CLI installation and authentication)`;
+    }
+    if (isDebugMode()) {
+      console.error("[BaseRunner] Error diagnostic details:", {
+        provider: metadata.name,
+        command,
+        argsCount: args.length,
+        workingDir,
+        elapsedTime: Date.now() - startTime,
+        errorType: typeof error,
+        errorConstructor: getErrorConstructorName(error),
+        sanitizedMessage: sanitized?.message,
+        shortMessage: execaError.shortMessage,
+        exitCode: execaError.exitCode,
+        signal: execaError.signal,
+        code: execaError.code
+      });
+    }
+  }
+  const exitCode = typeof execaError.exitCode === "number" && Number.isFinite(execaError.exitCode) ? execaError.exitCode : void 0;
+  const signal = typeof execaError.signal === "string" ? execaError.signal : void 0;
+  const reason = exitCode !== void 0 ? "non_zero_exit" : typeof execaError.code === "string" && execaError.code.length > 0 ? "spawn_failed" : "provider_cli_error";
+  throw new ProviderExecutionError(errorMessage, {
+    retryable: false,
+    exitCode,
+    signal,
+    reason,
+    ...streamOptionsFor(execaError.stdout ?? "", execaError.stderr ?? "")
+  });
+}
+
+// src/core/providers/shared/invocation-diagnostics.ts
+var DEFAULT_PROVIDER_OUTPUT_TAIL_LINES = 200;
+var PROMPT_REDACTION = "[prompt-redacted]";
+function redactProviderArgv(argv, options) {
+  const promptValues = new Set(
+    (options?.promptValues ?? []).filter((value) => typeof value === "string" && value.length > 0)
+  );
+  return argv.map((arg) => {
+    if (promptValues.has(arg)) return PROMPT_REDACTION;
+    return sanitizeString(arg);
+  });
+}
+function providerOutputTail(text, maxLines = DEFAULT_PROVIDER_OUTPUT_TAIL_LINES) {
+  return sanitizeString(tailLines(text ?? "", maxLines));
+}
+
+export {
+  hasSignal,
+  exitCodeToSignal,
+  isTimeoutTerminationReason,
+  TIMEOUT_TERMINATION_EXIT_CODE,
+  resolveTerminationExitCode,
+  TIMEOUT_REMEDY_HINT_SENTENCE,
+  formatTimeoutRemedyHint,
+  formatTerminationRemedy,
+  classifyAndWrapExecaError,
+  redactProviderArgv,
+  providerOutputTail
+};
+//# sourceMappingURL=chunk-JBBB2Y47.js.map

package/dist/chunk-JDCZQZU7.js

@@ -0,0 +1,42 @@
+import {
+  assertUsableProviderOrder,
+  loadProviderRegistryForCwd,
+  resolveProviderOrder
+} from "./chunk-C3DH3NCY.js";
+import {
+  isProviderCliResolvable
+} from "./chunk-KKQKWAMF.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+
+// src/core/config/reviewer-eligibility.ts
+var DEFAULT_DEPS = {
+  loadRegistry: loadProviderRegistryForCwd,
+  isProviderInstalled: isProviderCliResolvable
+};
+function resolveReviewerEligibility(cwd = process.cwd(), deps = DEFAULT_DEPS) {
+  try {
+    const registry = deps.loadRegistry(cwd);
+    const installed = ProviderRegistry.getEnabledProviders(registry).map((provider) => provider.id).filter((providerId) => deps.isProviderInstalled(providerId, registry));
+    if (installed.length === 0) return {};
+    const { ordered } = resolveProviderOrder({ cwd });
+    return {
+      eligibleReviewerProviders: ordered.filter((providerId) => installed.includes(providerId)),
+      installedReviewerProviders: installed
+    };
+  } catch {
+    return {};
+  }
+}
+function assertReviewerOrderUsable(roles, eligibleReviewerProviders, cwd) {
+  if (eligibleReviewerProviders?.length === 0 && roles.reviewer.bindingSource !== "explicit") {
+    assertUsableProviderOrder(resolveProviderOrder({ cwd }), []);
+  }
+}
+
+export {
+  resolveReviewerEligibility,
+  assertReviewerOrderUsable
+};
+//# sourceMappingURL=chunk-JDCZQZU7.js.map

package/dist/chunk-JEDNXGSS.js

@@ -0,0 +1,169 @@
+import {
+  findBackupDatabases,
+  resolveBackupBase,
+  resolveBuildBase
+} from "./chunk-OI734GRS.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+
+// src/telemetry/backup-maintenance.ts
+import { existsSync, readdirSync, rmSync } from "fs";
+import path from "path";
+var DEFAULT_RETENTION_COUNT = 24;
+async function loadBetterSqlite3() {
+  try {
+    const sqliteModule = await import("better-sqlite3");
+    return sqliteModule.default ?? sqliteModule;
+  } catch {
+    return null;
+  }
+}
+async function findExternalDatabases(buildBase) {
+  const { inspectActiveStores } = await import("./backup-active-store-XHWLN34M.js");
+  const { external } = await inspectActiveStores(buildBase);
+  const databases = /* @__PURE__ */ new Set();
+  for (const store of external) {
+    if (store.kind === "file") {
+      if (existsSync(store.location)) {
+        databases.add(store.location);
+      }
+      continue;
+    }
+    if (!existsSync(store.location)) {
+      continue;
+    }
+    for (const entry of readdirSync(store.location, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".db")) {
+        databases.add(path.join(store.location, entry.name));
+      }
+    }
+  }
+  return [...databases].sort();
+}
+async function verifyDatabaseIntegrity(buildBase = resolveBuildBase()) {
+  const Database = await loadBetterSqlite3();
+  if (!Database) {
+    return {
+      available: false,
+      unavailableReason: "better-sqlite3 is not installed, so integrity cannot be checked",
+      results: [],
+      corruptCount: 0,
+      externalCount: 0
+    };
+  }
+  const results = [];
+  const localDatabases = findBackupDatabases(buildBase);
+  const externalDatabases = await findExternalDatabases(buildBase);
+  for (const dbPath of [...localDatabases, ...externalDatabases]) {
+    const external = !localDatabases.includes(dbPath);
+    const label = external ? dbPath : path.relative(buildBase, dbPath);
+    let db;
+    try {
+      db = new Database(dbPath, { readonly: true, fileMustExist: true });
+      const rows = db.pragma("integrity_check");
+      const verdict = rows[0]?.integrity_check ?? "unknown";
+      results.push(
+        verdict === "ok" ? { database: label, status: "ok", ...external ? { external } : {} } : {
+          database: label,
+          status: "corrupt",
+          detail: verdict,
+          ...external ? { external } : {}
+        }
+      );
+    } catch (error) {
+      results.push({
+        database: label,
+        status: "corrupt",
+        detail: error instanceof Error ? error.message : String(error),
+        ...external ? { external } : {}
+      });
+    } finally {
+      db?.close();
+    }
+  }
+  return {
+    available: true,
+    results,
+    corruptCount: results.filter((result) => result.status === "corrupt").length,
+    externalCount: results.filter((result) => result.external).length
+  };
+}
+function listManifestBackupDirs(backupDir) {
+  if (!existsSync(backupDir)) {
+    return [];
+  }
+  return readdirSync(backupDir, { withFileTypes: true }).filter(
+    (entry) => entry.isDirectory() && !entry.name.startsWith(".") && existsSync(path.join(backupDir, entry.name, "backup-manifest.json"))
+  ).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
+}
+function groupLegacyShellFiles(backupDir) {
+  const grouped = /* @__PURE__ */ new Map();
+  if (!existsSync(backupDir)) {
+    return grouped;
+  }
+  for (const entry of readdirSync(backupDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".db")) {
+      continue;
+    }
+    const match = entry.name.match(/^(.+)_(\d{8}_\d{6})\.db$/);
+    const timestamp = match?.[2];
+    if (!timestamp) {
+      continue;
+    }
+    const files = grouped.get(timestamp) ?? [];
+    files.push(path.join(backupDir, entry.name));
+    grouped.set(timestamp, files);
+  }
+  return grouped;
+}
+async function pruneBackups(retentionCount = DEFAULT_RETENTION_COUNT, buildBase = resolveBuildBase()) {
+  if (!Number.isInteger(retentionCount) || retentionCount < 1) {
+    throw new Error(`Retention count must be a positive integer (got ${retentionCount})`);
+  }
+  const backupDir = resolveBackupBase(buildBase);
+  const manifestDirs = listManifestBackupDirs(backupDir);
+  const manifestToRemove = manifestDirs.slice(retentionCount);
+  for (const name of manifestToRemove) {
+    const backupPath = path.join(backupDir, name);
+    const removal = await safeRmDir(backupPath, {
+      protectedPaths: [buildBase, backupDir],
+      managedRoots: [backupDir]
+    });
+    if (!removal.deleted) {
+      throw new Error(removal.reason ?? `Refusing to delete backup directory ${backupPath}`);
+    }
+  }
+  const legacyGroups = groupLegacyShellFiles(backupDir);
+  const legacyTimestamps = [...legacyGroups.keys()].sort((a, b) => b.localeCompare(a));
+  const legacyToRemove = legacyTimestamps.slice(retentionCount);
+  const removedLegacyFiles = [];
+  for (const timestamp of legacyToRemove) {
+    for (const filePath of legacyGroups.get(timestamp) ?? []) {
+      rmSync(filePath, { force: true });
+      removedLegacyFiles.push(path.basename(filePath));
+    }
+  }
+  return {
+    retentionCount,
+    removedManifestBackups: manifestToRemove,
+    removedLegacyFiles,
+    retainedManifestBackups: Math.min(manifestDirs.length, retentionCount),
+    retainedLegacyTimestamps: Math.min(legacyTimestamps.length, retentionCount)
+  };
+}
+function resolveRetentionCount(env = process.env) {
+  const raw = env.BACKUP_RETENTION_COUNT;
+  if (!raw) {
+    return DEFAULT_RETENTION_COUNT;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_RETENTION_COUNT;
+}
+
+export {
+  verifyDatabaseIntegrity,
+  pruneBackups,
+  resolveRetentionCount
+};
+//# sourceMappingURL=chunk-JEDNXGSS.js.map