@remnic/core 10.0.92 → 10.0.94

package/dist/chunk-R2LBF4HH.js

@@ -1,729 +0,0 @@
-import {
-  hasMemoryData
-} from "./chunk-BRLXOZLM.js";
-import {
-  resolveNamespaceStorageRoot
-} from "./chunk-E3A7ELSG.js";
-import {
-  getConfiguredNamespaces
-} from "./chunk-I6QGI65T.js";
-import {
-  displayErrorDetail
-} from "./chunk-RL6NEVXT.js";
-import {
-  namespaceIdentityToken
-} from "./chunk-VUFL7X3H.js";
-import {
-  resolveConversationContextCapabilities,
-  resolveNamespaceCapabilities
-} from "./chunk-C5LWPYS3.js";
-
-// src/maintenance/namespace-planner.ts
-import { createHash, randomUUID } from "crypto";
-import { lstat, mkdir, open, readFile, readdir, rename, rm, rmdir, utimes, writeFile } from "fs/promises";
-import path from "path";
-var DEFAULT_MAX_NAMESPACES_PER_CYCLE = 20;
-var DEFAULT_LOCK_STALE_MS = 10 * 6e4;
-var LOCK_BASE = "maintenance-locks";
-var STATUS_BASE = "namespace-maintenance-status";
-var namespaceMaintenanceFs = { open, rm };
-function inferConfiguredKind(config, namespace) {
-  if (namespace === config.defaultNamespace.trim()) return "default";
-  if (namespace === config.sharedNamespace.trim()) return "shared";
-  return "explicit";
-}
-function maxNamespacesPerCycle(config) {
-  return Math.max(
-    1,
-    Math.floor(
-      typeof config.maintenanceMaxNamespacesPerCycle === "number" && Number.isFinite(config.maintenanceMaxNamespacesPerCycle) ? config.maintenanceMaxNamespacesPerCycle : DEFAULT_MAX_NAMESPACES_PER_CYCLE
-    )
-  );
-}
-function namespaceKindAllowed(config, kind) {
-  switch (kind) {
-    case "branch":
-      return config.maintenanceIncludeBranchNamespaces === true;
-    case "project":
-      return config.maintenanceIncludeProjectNamespaces !== false;
-    case "team-project":
-      return config.maintenanceIncludeTeamProjectNamespaces !== false;
-    default:
-      return true;
-  }
-}
-function disabledReasonForKind(kind) {
-  if (kind === "branch") return "branch_disabled";
-  if (kind === "project") return "project_disabled";
-  if (kind === "team-project") return "team_project_disabled";
-  return "fanout_disabled";
-}
-async function catalogRootIsLive(config, record) {
-  if (typeof record.storageDir !== "string" || record.storageDir.length === 0) {
-    return false;
-  }
-  try {
-    const liveRoot = await resolveNamespaceStorageRoot(config, record.namespace);
-    if (path.resolve(liveRoot) !== path.resolve(record.storageDir)) return false;
-    return hasMemoryData(liveRoot);
-  } catch {
-    return false;
-  }
-}
-function candidateSortKey(candidate) {
-  const write = candidate.lastWriteAt ?? "";
-  return `${write}\0${candidate.namespace}`;
-}
-function candidatePriority(candidate) {
-  if (candidate.kind === "default") return 0;
-  if (candidate.kind === "shared") return 1;
-  if (candidate.source === "configured") return 2;
-  if (candidate.kind === "team-project") return 3;
-  if (candidate.kind === "project") return 4;
-  if (candidate.kind === "branch") return 8;
-  return 7;
-}
-function sortCandidates(a, b) {
-  const priority = candidatePriority(a) - candidatePriority(b);
-  if (priority !== 0) return priority;
-  const am = Date.parse(a.lastMaintenanceAt ?? "");
-  const bm = Date.parse(b.lastMaintenanceAt ?? "");
-  const aMaintained = Number.isFinite(am);
-  const bMaintained = Number.isFinite(bm);
-  if (aMaintained && bMaintained && am !== bm) return am - bm;
-  if (aMaintained !== bMaintained) return aMaintained ? 1 : -1;
-  const aw = Date.parse(a.lastWriteAt ?? "");
-  const bw = Date.parse(b.lastWriteAt ?? "");
-  const aValid = Number.isFinite(aw);
-  const bValid = Number.isFinite(bw);
-  if (aValid && bValid && aw !== bw) return bw - aw;
-  if (aValid !== bValid) return aValid ? -1 : 1;
-  const byKey = candidateSortKey(a).localeCompare(candidateSortKey(b));
-  if (byKey !== 0) return byKey;
-  return a.namespace.localeCompare(b.namespace);
-}
-async function planNamespaceMaintenance(config, options) {
-  const generatedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const configured = resolveNamespaceCapabilities(config).namespaces ? getConfiguredNamespaces(config) : [config.defaultNamespace.trim()].filter(Boolean);
-  const byNamespace = /* @__PURE__ */ new Map();
-  const skipped = [];
-  for (const namespace of configured) {
-    const kind = inferConfiguredKind(config, namespace);
-    byNamespace.set(namespace, {
-      namespace,
-      kind,
-      source: "configured"
-    });
-  }
-  if (resolveNamespaceCapabilities(config).namespaces && resolveConversationContextCapabilities(config).maintenanceNamespaceFanout !== false) {
-    const configuredSet = new Set(configured);
-    try {
-      const records = options.catalog?.enabled ? await options.catalog.listNamespaces(void 0, {
-        onIncomplete: (reason) => skipped.push({ namespace: "*", reason: "catalog_read_failed", detail: reason })
-      }) : [];
-      for (const record of records) {
-        const namespace = record.namespace.trim();
-        if (!namespace) continue;
-        const isConfigured = configuredSet.has(namespace);
-        const kind = isConfigured ? inferConfiguredKind(config, namespace) : record.kind;
-        if (!namespaceKindAllowed(config, kind)) {
-          skipped.push({
-            namespace,
-            kind,
-            reason: disabledReasonForKind(kind)
-          });
-          continue;
-        }
-        if (!isConfigured && !await catalogRootIsLive(config, record)) {
-          skipped.push({
-            namespace,
-            kind,
-            reason: "unsafe_or_stale_root"
-          });
-          continue;
-        }
-        byNamespace.set(namespace, {
-          namespace,
-          kind,
-          storageDir: record.storageDir,
-          source: isConfigured ? "configured" : "catalog",
-          lastWriteAt: record.lastWriteAt,
-          lastMaintenanceAt: record.lastMaintenanceAt?.[options.jobName]
-        });
-      }
-    } catch (error) {
-      skipped.push({
-        namespace: "*",
-        reason: "catalog_read_failed",
-        detail: error instanceof Error ? error.message : String(error)
-      });
-    }
-  } else if (resolveNamespaceCapabilities(config).namespaces) {
-    skipped.push({
-      namespace: "*",
-      reason: "fanout_disabled"
-    });
-  }
-  if (options.budgetMode !== "unbounded") {
-    const latestStatusAtByNamespace = await readLatestStatusAtByNamespace(config, options.jobName);
-    for (const candidate of byNamespace.values()) {
-      if (!candidate.lastMaintenanceAt) {
-        candidate.lastMaintenanceAt = latestStatusAtByNamespace.get(candidate.namespace);
-      }
-    }
-  }
-  const candidates = [...byNamespace.values()].filter((candidate) => namespaceKindAllowed(config, candidate.kind)).sort(sortCandidates);
-  const max = maxNamespacesPerCycle(config);
-  const applyCycleBudget = options.budgetMode !== "unbounded";
-  const selected = applyCycleBudget ? candidates.slice(0, max) : candidates;
-  if (applyCycleBudget) {
-    for (const candidate of candidates.slice(max)) {
-      skipped.push({
-        namespace: candidate.namespace,
-        kind: candidate.kind,
-        reason: "budget_exhausted"
-      });
-    }
-  }
-  return {
-    jobName: options.jobName,
-    generatedAt,
-    namespaces: selected,
-    skipped,
-    budget: {
-      maxNamespacesPerCycle: max,
-      selected: selected.length
-    }
-  };
-}
-function stablePathSegment(value) {
-  const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 128) || "unnamed";
-  if (sanitized.length <= 128 && sanitized === value) return sanitized;
-  return `${sanitized.slice(0, 80)}-${createHash("sha256").update(value).digest("hex").slice(0, 16)}`;
-}
-function namespacePathSegment(namespace) {
-  const token = namespaceIdentityToken(namespace);
-  if (token.length <= 160) return token;
-  return `ns-${createHash("sha256").update(namespace).digest("hex")}`;
-}
-function lockPath(config, jobName, namespace) {
-  return path.join(
-    config.memoryDir,
-    "state",
-    LOCK_BASE,
-    stablePathSegment(jobName),
-    `${namespacePathSegment(namespace)}.lock`
-  );
-}
-function namespaceMaintenanceLockStaleMs(config) {
-  if (typeof config.maintenanceNamespaceLockStaleMs === "number" && Number.isFinite(config.maintenanceNamespaceLockStaleMs) && config.maintenanceNamespaceLockStaleMs > 0) {
-    return Math.floor(config.maintenanceNamespaceLockStaleMs);
-  }
-  return DEFAULT_LOCK_STALE_MS;
-}
-function namespaceMaintenanceLockHeartbeatMs(config) {
-  const staleMs = namespaceMaintenanceLockStaleMs(config);
-  return Math.max(1, Math.min(3e4, Math.floor(staleMs / 3) || 1));
-}
-function errorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-}
-async function withNamespaceMaintenanceLockHeartbeat(config, locks, task) {
-  const activeLocks = Array.isArray(locks) ? locks : [locks];
-  const interval = setInterval(() => {
-    for (const lock of activeLocks) {
-      void lock.touch().catch(() => void 0);
-    }
-  }, namespaceMaintenanceLockHeartbeatMs(config));
-  interval.unref?.();
-  try {
-    return await task();
-  } finally {
-    clearInterval(interval);
-  }
-}
-async function removeStaleLockDirectory(filePath) {
-  let entries;
-  try {
-    entries = await readdir(filePath, { withFileTypes: true });
-  } catch (error) {
-    if (errorCode(error) === "ENOENT") return;
-    throw error;
-  }
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    await namespaceMaintenanceFs.rm(path.join(filePath, entry.name), { force: true });
-  }
-  try {
-    await rmdir(filePath);
-  } catch (error) {
-    if (errorCode(error) === "ENOENT") return;
-    throw error;
-  }
-}
-async function tryAcquireNamespaceMaintenanceLock(config, jobName, namespace) {
-  const filePath = lockPath(config, jobName, namespace);
-  await mkdir(path.dirname(filePath), { recursive: true });
-  try {
-    const lockId = randomUUID();
-    await mkdir(filePath);
-    const ownerPath = path.join(filePath, `${lockId}.json`);
-    let handle;
-    try {
-      handle = await namespaceMaintenanceFs.open(ownerPath, "wx");
-      await handle.writeFile(
-        `${JSON.stringify({
-          lockId,
-          pid: process.pid,
-          jobName,
-          namespace,
-          acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
-        })}
-`,
-        "utf8"
-      );
-      await handle.close();
-    } catch (setupError) {
-      await handle?.close().catch(() => void 0);
-      await namespaceMaintenanceFs.rm(ownerPath, { force: true }).catch(() => void 0);
-      await rmdir(filePath).catch(() => void 0);
-      throw setupError;
-    }
-    return {
-      path: filePath,
-      async touch() {
-        try {
-          const parsed = JSON.parse(await readFile(ownerPath, "utf8"));
-          if (parsed.lockId === lockId) {
-            const now = /* @__PURE__ */ new Date();
-            await utimes(ownerPath, now, now);
-            await utimes(filePath, now, now);
-          }
-        } catch {
-        }
-      },
-      async release() {
-        try {
-          const parsed = JSON.parse(await readFile(ownerPath, "utf8"));
-          if (parsed.lockId === lockId) {
-            await namespaceMaintenanceFs.rm(ownerPath, { force: true });
-            await rmdir(filePath).catch(() => void 0);
-          }
-        } catch {
-        }
-      }
-    };
-  } catch (error) {
-    if (errorCode(error) === "EEXIST") {
-      const staleMs = namespaceMaintenanceLockStaleMs(config);
-      try {
-        const s = await lstat(filePath);
-        if (s.isSymbolicLink()) {
-          return null;
-        }
-        if ((s.isFile() || s.isDirectory()) && Date.now() - s.mtimeMs > staleMs) {
-          try {
-            if (s.isDirectory()) {
-              await removeStaleLockDirectory(filePath);
-            } else {
-              await namespaceMaintenanceFs.rm(filePath, { force: true });
-            }
-          } catch (removeError) {
-            if (errorCode(removeError) === "ENOENT") {
-              return tryAcquireNamespaceMaintenanceLock(config, jobName, namespace);
-            }
-            if (errorCode(removeError) === "ENOTEMPTY") {
-              return null;
-            }
-            throw removeError;
-          }
-          return tryAcquireNamespaceMaintenanceLock(config, jobName, namespace);
-        }
-      } catch (statError) {
-        if (errorCode(statError) === "ENOENT") {
-          return tryAcquireNamespaceMaintenanceLock(config, jobName, namespace);
-        }
-        throw statError;
-      }
-      return null;
-    }
-    throw error;
-  }
-}
-function statusBasePath(config) {
-  return path.join(config.memoryDir, "state", STATUS_BASE);
-}
-function statusPath(config, jobName, namespace) {
-  return path.join(statusBasePath(config), stablePathSegment(jobName), `${namespacePathSegment(namespace)}.json`);
-}
-function lastRanStatusPath(config, jobName, namespace) {
-  return path.join(statusBasePath(config), stablePathSegment(jobName), `${namespacePathSegment(namespace)}.last-ran.json`);
-}
-function parseStatus(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const v = value;
-  if (typeof v.namespace === "string" && typeof v.jobName === "string" && (v.state === "ran" || v.state === "skipped" || v.state === "failed") && typeof v.startedAt === "string" && typeof v.completedAt === "string") {
-    return v;
-  }
-  return null;
-}
-async function readLatestStatusAtByNamespace(config, jobName) {
-  const latest = /* @__PURE__ */ new Map();
-  const latestMs = /* @__PURE__ */ new Map();
-  for (const status of [...await readStatusFiles(config), ...await readLastRanStatusFiles(config)]) {
-    if (status.state !== "ran") continue;
-    if (status.jobName !== jobName) continue;
-    const completedAtMs = Date.parse(status.completedAt);
-    if (!Number.isFinite(completedAtMs)) continue;
-    const previousMs = latestMs.get(status.namespace);
-    if (previousMs !== void 0 && previousMs >= completedAtMs) continue;
-    latestMs.set(status.namespace, completedAtMs);
-    latest.set(status.namespace, status.completedAt);
-  }
-  return latest;
-}
-async function readStatusFile(filePath) {
-  try {
-    const parsed = JSON.parse(await readFile(filePath, "utf8"));
-    return parseStatus(parsed);
-  } catch {
-    return null;
-  }
-}
-async function readStatusFiles(config) {
-  if (typeof config.memoryDir !== "string" || config.memoryDir.length === 0) {
-    return [];
-  }
-  const root = statusBasePath(config);
-  const statuses = [];
-  let jobDirs;
-  try {
-    jobDirs = await readdir(root, { withFileTypes: true });
-  } catch {
-    return statuses;
-  }
-  for (const jobDir of jobDirs) {
-    if (!jobDir.isDirectory()) continue;
-    let files;
-    try {
-      files = await readdir(path.join(root, jobDir.name), { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const file of files) {
-      if (!file.isFile() || !file.name.endsWith(".json")) continue;
-      if (file.name.endsWith(".last-ran.json")) continue;
-      const status = await readStatusFile(path.join(root, jobDir.name, file.name));
-      if (status) statuses.push(status);
-    }
-  }
-  return statuses;
-}
-async function readLastRanStatusFiles(config) {
-  if (typeof config.memoryDir !== "string" || config.memoryDir.length === 0) {
-    return [];
-  }
-  const root = statusBasePath(config);
-  const statuses = [];
-  let jobDirs;
-  try {
-    jobDirs = await readdir(root, { withFileTypes: true });
-  } catch {
-    return statuses;
-  }
-  for (const jobDir of jobDirs) {
-    if (!jobDir.isDirectory()) continue;
-    let files;
-    try {
-      files = await readdir(path.join(root, jobDir.name), { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const file of files) {
-      if (!file.isFile() || !file.name.endsWith(".last-ran.json")) continue;
-      const status = await readStatusFile(path.join(root, jobDir.name, file.name));
-      if (status) statuses.push(status);
-    }
-  }
-  return statuses;
-}
-async function writeStatusPayload(target, status) {
-  const dir = path.dirname(target);
-  await mkdir(dir, { recursive: true });
-  const temp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  const payload = {
-    version: 1,
-    ...status
-  };
-  await writeFile(temp, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
-  await rename(temp, target);
-}
-async function writeStatusFile(config, status) {
-  await writeStatusPayload(statusPath(config, status.jobName, status.namespace), status);
-  if (status.state === "ran") {
-    await writeStatusPayload(lastRanStatusPath(config, status.jobName, status.namespace), status);
-  }
-}
-async function recordNamespaceMaintenanceStatusSafely(config, status) {
-  try {
-    await writeStatusFile(config, status);
-  } catch {
-  }
-}
-function maintenanceErrorDetail(error) {
-  return displayErrorDetail(error) || "Error";
-}
-async function readNamespaceMaintenanceStatuses(config) {
-  return (await readStatusFiles(config)).sort((a, b) => {
-    const byJob = a.jobName.localeCompare(b.jobName);
-    if (byJob !== 0) return byJob;
-    return a.namespace.localeCompare(b.namespace);
-  });
-}
-async function readNamespaceMaintenanceLastRanStatuses(config) {
-  return (await readLastRanStatusFiles(config)).sort((a, b) => {
-    const byJob = a.jobName.localeCompare(b.jobName);
-    if (byJob !== 0) return byJob;
-    return a.namespace.localeCompare(b.namespace);
-  });
-}
-async function runNamespaceMaintenancePlan(config, plan, runner, catalog) {
-  const statuses = [];
-  for (const skipped of plan.skipped) {
-    if (skipped.namespace === "*") continue;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const status = {
-      namespace: skipped.namespace,
-      jobName: plan.jobName,
-      state: "skipped",
-      reason: skipped.reason,
-      startedAt: now,
-      completedAt: now
-    };
-    statuses.push(status);
-    await recordNamespaceMaintenanceStatusSafely(config, status);
-  }
-  for (const candidate of plan.namespaces) {
-    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const lock = await tryAcquireNamespaceMaintenanceLock(config, plan.jobName, candidate.namespace);
-    if (!lock) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const status = {
-        namespace: candidate.namespace,
-        jobName: plan.jobName,
-        state: "skipped",
-        reason: "lock_held",
-        startedAt,
-        completedAt
-      };
-      statuses.push(status);
-      await recordNamespaceMaintenanceStatusSafely(config, status);
-      continue;
-    }
-    try {
-      const result = await withNamespaceMaintenanceLockHeartbeat(config, lock, () => runner(candidate));
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      if (result?.skipped) {
-        const status = {
-          namespace: candidate.namespace,
-          jobName: plan.jobName,
-          state: "skipped",
-          reason: result.skipReason ?? "throttled",
-          startedAt,
-          completedAt
-        };
-        statuses.push(status);
-        await recordNamespaceMaintenanceStatusSafely(config, status);
-      } else {
-        const status = {
-          namespace: candidate.namespace,
-          jobName: plan.jobName,
-          state: "ran",
-          startedAt,
-          completedAt,
-          itemCount: result?.itemCount
-        };
-        statuses.push(status);
-        await recordNamespaceMaintenanceStatusSafely(config, status);
-        try {
-          await catalog?.markMaintenance(candidate.namespace, plan.jobName, new Date(completedAt));
-        } catch {
-        }
-      }
-    } catch (error) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const status = {
-        namespace: candidate.namespace,
-        jobName: plan.jobName,
-        state: "failed",
-        reason: "job_failed",
-        startedAt,
-        completedAt,
-        error: maintenanceErrorDetail(error)
-      };
-      statuses.push(status);
-      await recordNamespaceMaintenanceStatusSafely(config, status);
-    } finally {
-      await lock.release().catch(() => void 0);
-    }
-  }
-  return {
-    jobName: plan.jobName,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ran: statuses.filter((s) => s.state === "ran").length,
-    skipped: statuses.filter((s) => s.state === "skipped").length,
-    failed: statuses.filter((s) => s.state === "failed").length,
-    statuses
-  };
-}
-async function runNamespaceMaintenanceBatchPlan(config, plan, runner, catalog, options = {}) {
-  const statuses = [];
-  for (const skipped of plan.skipped) {
-    if (skipped.namespace === "*") continue;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const status = {
-      namespace: skipped.namespace,
-      jobName: plan.jobName,
-      state: "skipped",
-      reason: skipped.reason,
-      startedAt: now,
-      completedAt: now
-    };
-    statuses.push(status);
-    await recordNamespaceMaintenanceStatusSafely(config, status);
-  }
-  const acquired = [];
-  try {
-    for (const candidate of plan.namespaces) {
-      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const lock = await tryAcquireNamespaceMaintenanceLock(config, plan.jobName, candidate.namespace);
-      if (!lock) {
-        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const status = {
-          namespace: candidate.namespace,
-          jobName: plan.jobName,
-          state: "skipped",
-          reason: "lock_held",
-          startedAt,
-          completedAt
-        };
-        statuses.push(status);
-        await recordNamespaceMaintenanceStatusSafely(config, status);
-        continue;
-      }
-      acquired.push({ candidate, lock, startedAt });
-    }
-  } catch (error) {
-    await Promise.all(acquired.map(({ lock }) => lock.release().catch(() => void 0)));
-    throw error;
-  }
-  if (options.requireAllLocks && acquired.length > 0 && acquired.length < plan.namespaces.length) {
-    for (const { candidate, startedAt } of acquired) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const status = {
-        namespace: candidate.namespace,
-        jobName: plan.jobName,
-        state: "skipped",
-        reason: "batch_lock_incomplete",
-        startedAt,
-        completedAt
-      };
-      statuses.push(status);
-      await recordNamespaceMaintenanceStatusSafely(config, status);
-    }
-    await Promise.all(acquired.map(({ lock }) => lock.release().catch(() => void 0)));
-    return {
-      jobName: plan.jobName,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ran: statuses.filter((s) => s.state === "ran").length,
-      skipped: statuses.filter((s) => s.state === "skipped").length,
-      failed: statuses.filter((s) => s.state === "failed").length,
-      statuses
-    };
-  }
-  if (acquired.length === 0) {
-    return {
-      jobName: plan.jobName,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ran: statuses.filter((s) => s.state === "ran").length,
-      skipped: statuses.filter((s) => s.state === "skipped").length,
-      failed: statuses.filter((s) => s.state === "failed").length,
-      statuses
-    };
-  }
-  try {
-    const result = await withNamespaceMaintenanceLockHeartbeat(
-      config,
-      acquired.map(({ lock }) => lock),
-      () => runner(acquired.map(({ candidate }) => candidate))
-    );
-    for (const { candidate, startedAt } of acquired) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const status = {
-        namespace: candidate.namespace,
-        jobName: plan.jobName,
-        state: "ran",
-        startedAt,
-        completedAt,
-        itemCount: itemCountForNamespace(result, candidate.namespace)
-      };
-      statuses.push(status);
-      await recordNamespaceMaintenanceStatusSafely(config, status);
-      try {
-        await catalog?.markMaintenance(candidate.namespace, plan.jobName, new Date(completedAt));
-      } catch {
-      }
-    }
-  } catch (error) {
-    const skipReason = options.skipReasonForError?.(error);
-    for (const { candidate, startedAt } of acquired) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const status = skipReason ? {
-        namespace: candidate.namespace,
-        jobName: plan.jobName,
-        state: "skipped",
-        reason: skipReason,
-        startedAt,
-        completedAt
-      } : {
-        namespace: candidate.namespace,
-        jobName: plan.jobName,
-        state: "failed",
-        reason: "job_failed",
-        startedAt,
-        completedAt,
-        error: maintenanceErrorDetail(error)
-      };
-      statuses.push(status);
-      await recordNamespaceMaintenanceStatusSafely(config, status);
-    }
-  } finally {
-    await Promise.all(acquired.map(({ lock }) => lock.release().catch(() => void 0)));
-  }
-  return {
-    jobName: plan.jobName,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ran: statuses.filter((s) => s.state === "ran").length,
-    skipped: statuses.filter((s) => s.state === "skipped").length,
-    failed: statuses.filter((s) => s.state === "failed").length,
-    statuses
-  };
-}
-function itemCountForNamespace(result, namespace) {
-  const itemCounts = result?.itemCounts;
-  if (itemCounts instanceof Map) return itemCounts.get(namespace);
-  if (itemCounts && Object.prototype.hasOwnProperty.call(itemCounts, namespace)) {
-    return itemCounts[namespace];
-  }
-  return result?.itemCount;
-}
-
-export {
-  planNamespaceMaintenance,
-  readNamespaceMaintenanceStatuses,
-  readNamespaceMaintenanceLastRanStatuses,
-  runNamespaceMaintenancePlan,
-  runNamespaceMaintenanceBatchPlan
-};
-//# sourceMappingURL=chunk-R2LBF4HH.js.map