@remnic/core 9.63.3 → 9.63.4

package/dist/{chunk-5W5N7XJZ.js → chunk-A4HXWNST.js}

@@ -2,12 +2,6 @@ import {
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
 } from "./chunk-QSIQVC32.js";
-import {
-  getConfiguredNamespaces
-} from "./chunk-Q57GOHLF.js";
-import {
-  displayErrorDetail
-} from "./chunk-RL6NEVXT.js";
 import {
   MutationSerializer,
   withHeldFileLock
@@ -22,7 +16,6 @@ import {
   normalizeNamespaceIdentity
 } from "./chunk-VUFL7X3H.js";
 import {
-  resolveConversationContextCapabilities,
   resolveNamespaceCapabilities
 } from "./chunk-JUOZ62Y7.js";
 import {
@@ -45,13 +38,11 @@ import {
 import { StringDecoder } from "string_decoder";
 var NAMESPACE_KINDS = [
   "default",
-  "self",
   "shared",
   "project",
   "branch",
   "team-project",
-  "explicit",
-  "legacy"
+  "explicit"
 ];
 var NAMESPACE_DISCOVERY_SOURCES = [
   "config",
@@ -144,8 +135,7 @@ function coerceRecord(value) {
   if (typeof v.storageDir !== "string" || v.storageDir.length === 0) return null;
   if (typeof v.createdAt !== "string" || v.createdAt.length === 0) return null;
   if (!isValidIsoTimestamp(v.createdAt)) return null;
-  const kind = v.kind === void 0 ? "explicit" : isNamespaceKind(v.kind) ? v.kind : null;
-  if (!kind) return null;
+  const kind = isNamespaceKind(v.kind) ? v.kind : "explicit";
   const discoveredBy = v.discoveredBy === void 0 ? "scan" : isNamespaceDiscoverySource(v.discoveredBy) ? v.discoveredBy : null;
   if (!discoveredBy) return null;
   const record = {
@@ -156,10 +146,6 @@ function coerceRecord(value) {
     storageDir: v.storageDir,
     discoveredBy
   };
-  if (typeof v.principal === "string") record.principal = v.principal;
-  if (typeof v.projectId === "string") record.projectId = v.projectId;
-  if (typeof v.branch === "string") record.branch = v.branch;
-  if (typeof v.parentNamespace === "string") record.parentNamespace = v.parentNamespace;
   if (typeof v.lastReadAt === "string" && isValidIsoTimestamp(v.lastReadAt)) {
     record.lastReadAt = v.lastReadAt;
   }
@@ -509,12 +495,6 @@ var NamespaceCatalog = class {
     if (kind === "read" && cached.lastReadAt === void 0) return true;
     if (!metadata) return false;
     if (metadata.kind !== void 0 && metadata.kind !== cached.kind) return true;
-    if (metadata.principal !== void 0 && metadata.principal !== cached.principal) return true;
-    if (metadata.projectId !== void 0 && metadata.projectId !== cached.projectId) return true;
-    if (metadata.branch !== void 0 && metadata.branch !== cached.branch) return true;
-    if (metadata.parentNamespace !== void 0 && metadata.parentNamespace !== cached.parentNamespace) {
-      return true;
-    }
     if (metadata.storageDir !== void 0 && metadata.storageDir !== cached.storageDir) return true;
     return false;
   }
@@ -655,9 +635,9 @@ var NamespaceCatalog = class {
     }
     if (await this.hasSymlinkedAncestor(candidate)) return false;
     try {
-      const stat3 = await lstat(candidate);
-      if (stat3.isSymbolicLink()) return false;
-      if (!stat3.isDirectory()) return false;
+      const stat2 = await lstat(candidate);
+      if (stat2.isSymbolicLink()) return false;
+      if (!stat2.isDirectory()) return false;
     } catch {
       return this.isNearestExistingAncestorContained(candidate, memoryReal);
     }
@@ -718,8 +698,8 @@ var NamespaceCatalog = class {
       }
       if (!(isPathInside(memoryReal, real) || real === memoryReal)) return false;
       try {
-        const stat3 = await lstat(real);
-        return stat3.isDirectory();
+        const stat2 = await lstat(real);
+        return stat2.isDirectory();
       } catch {
         return false;
       }
@@ -883,14 +863,14 @@ var NamespaceCatalog = class {
     if (normalizeNamespaceIdentity(namespace) !== this.defaultNamespaceIdentity && path.resolve(root) === path.resolve(this.memoryDir)) {
       return false;
     }
-    let stat3;
+    let stat2;
     try {
-      stat3 = await lstat(root);
+      stat2 = await lstat(root);
     } catch {
       return false;
     }
-    if (stat3.isSymbolicLink()) return false;
-    if (!stat3.isDirectory()) return false;
+    if (stat2.isSymbolicLink()) return false;
+    if (!stat2.isDirectory()) return false;
     try {
       const real = await realpath(root);
       if (memoryReal && !isPathInside(memoryReal, real)) return false;
@@ -933,11 +913,6 @@ var NamespaceCatalog = class {
         };
         record.storageDir = storageDir;
         if (metadata?.kind) record.kind = metadata.kind;
-        if (metadata?.principal !== void 0) record.principal = metadata.principal;
-        if (metadata?.projectId !== void 0) record.projectId = metadata.projectId;
-        if (metadata?.branch !== void 0) record.branch = metadata.branch;
-        if (metadata?.parentNamespace !== void 0)
-          record.parentNamespace = metadata.parentNamespace;
         if (kind === "write" && existing && record.discoveredBy === "config") {
           record.discoveredBy = "write";
         }
@@ -1091,18 +1066,18 @@ var NamespaceCatalog = class {
     for (const entry of entries) {
       const token = entry.name;
       const fullPath = path.join(namespacesDir, token);
-      let stat3;
+      let stat2;
       try {
-        stat3 = await lstat(fullPath);
+        stat2 = await lstat(fullPath);
       } catch (err) {
         skipped.push({ token, reason: "error", detail: err instanceof Error ? err.message : String(err) });
         continue;
       }
-      if (stat3.isSymbolicLink()) {
+      if (stat2.isSymbolicLink()) {
         skipped.push({ token, reason: "symlink", detail: fullPath });
         continue;
       }
-      if (!stat3.isDirectory()) continue;
+      if (!stat2.isDirectory()) continue;
       try {
         const real = await realpath(fullPath);
         if (memoryReal && !isPathInside(memoryReal, real)) {
@@ -1312,10 +1287,6 @@ var NamespaceCatalog = class {
     if (prior.lastReadAt) merged.lastReadAt = prior.lastReadAt;
     if (prior.lastWriteAt) merged.lastWriteAt = prior.lastWriteAt;
     if (prior.lastMaintenanceAt) merged.lastMaintenanceAt = { ...prior.lastMaintenanceAt };
-    if (prior.principal !== void 0) merged.principal = prior.principal;
-    if (prior.projectId !== void 0) merged.projectId = prior.projectId;
-    if (prior.branch !== void 0) merged.branch = prior.branch;
-    if (prior.parentNamespace !== void 0) merged.parentNamespace = prior.parentNamespace;
     return merged;
   }
   // ── Persistence ──────────────────────────────────────────────────────────
@@ -1497,713 +1468,9 @@ function isPathInside(root, child) {
   return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
 }
 
-// src/maintenance/namespace-planner.ts
-import { createHash, randomUUID } from "crypto";
-import { lstat as lstat2, mkdir as mkdir2, open as open2, readFile, readdir as readdir2, rename as rename2, rm, rmdir, utimes, writeFile as writeFile2 } from "fs/promises";
-import path2 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: open2, 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 (path2.resolve(liveRoot) !== path2.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 === "self") return 5;
-  if (candidate.kind === "legacy") return 6;
-  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 path2.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 readdir2(filePath, { withFileTypes: true });
-  } catch (error) {
-    if (errorCode(error) === "ENOENT") return;
-    throw error;
-  }
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    await namespaceMaintenanceFs.rm(path2.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 mkdir2(path2.dirname(filePath), { recursive: true });
-  try {
-    const lockId = randomUUID();
-    await mkdir2(filePath);
-    const ownerPath = path2.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 lstat2(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 path2.join(config.memoryDir, "state", STATUS_BASE);
-}
-function statusPath(config, jobName, namespace) {
-  return path2.join(statusBasePath(config), stablePathSegment(jobName), `${namespacePathSegment(namespace)}.json`);
-}
-function lastRanStatusPath(config, jobName, namespace) {
-  return path2.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 readdir2(root, { withFileTypes: true });
-  } catch {
-    return statuses;
-  }
-  for (const jobDir of jobDirs) {
-    if (!jobDir.isDirectory()) continue;
-    let files;
-    try {
-      files = await readdir2(path2.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(path2.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 readdir2(root, { withFileTypes: true });
-  } catch {
-    return statuses;
-  }
-  for (const jobDir of jobDirs) {
-    if (!jobDir.isDirectory()) continue;
-    let files;
-    try {
-      files = await readdir2(path2.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(path2.join(root, jobDir.name, file.name));
-      if (status) statuses.push(status);
-    }
-  }
-  return statuses;
-}
-async function writeStatusPayload(target, status) {
-  const dir = path2.dirname(target);
-  await mkdir2(dir, { recursive: true });
-  const temp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  const payload = {
-    version: 1,
-    ...status
-  };
-  await writeFile2(temp, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
-  await rename2(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 {
-  NamespaceCatalog,
-  planNamespaceMaintenance,
-  readNamespaceMaintenanceStatuses,
-  readNamespaceMaintenanceLastRanStatuses,
-  runNamespaceMaintenancePlan,
-  runNamespaceMaintenanceBatchPlan
+  hasMemoryData,
+  isNamespaceKind,
+  NamespaceCatalog
 };
-//# sourceMappingURL=chunk-5W5N7XJZ.js.map
+//# sourceMappingURL=chunk-A4HXWNST.js.map