@remnic/core 9.63.2 → 9.63.4

package/dist/chunk-RSLRGRBJ.js

@@ -0,0 +1,727 @@
+import {
+  hasMemoryData
+} from "./chunk-A4HXWNST.js";
+import {
+  resolveNamespaceStorageRoot
+} from "./chunk-QSIQVC32.js";
+import {
+  getConfiguredNamespaces
+} from "./chunk-Q57GOHLF.js";
+import {
+  displayErrorDetail
+} from "./chunk-RL6NEVXT.js";
+import {
+  namespaceIdentityToken
+} from "./chunk-VUFL7X3H.js";
+import {
+  resolveConversationContextCapabilities,
+  resolveNamespaceCapabilities
+} from "./chunk-JUOZ62Y7.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() : [];
+      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-RSLRGRBJ.js.map