@remnic/core 9.69.56 → 9.69.57

package/dist/chunk-75YZ5VAI.js

@@ -1,140 +0,0 @@
-import {
-  SupportPassportError,
-  SupportPassportOwnerCreateGrantRequestSchema,
-  getOperation
-} from "./chunk-ZBYVR5W4.js";
-
-// src/support-passport/access-http.ts
-var OWNER_ROOT = "/engram/v1/support-passport";
-var SUPPORT_PASSPORT_OWNER_HTTP_ROUTES = [
-  { method: "GET", pathname: `${OWNER_ROOT}/cards`, operation: "support_passport_cards_list" },
-  { method: "POST", pathname: `${OWNER_ROOT}/drafts`, operation: "support_passport_draft_create" },
-  { method: "POST", pathname: `${OWNER_ROOT}/drafts/generate`, operation: "support_passport_drafts_generate" },
-  { method: "GET", pathname: `${OWNER_ROOT}/grants`, operation: "support_passport_grants_list" },
-  { method: "POST", pathname: `${OWNER_ROOT}/grants`, operation: "support_passport_grant_create" },
-  { method: "GET", pathname: `${OWNER_ROOT}/memories/:id`, operation: "support_passport_memory_preview" },
-  { method: "PUT", pathname: `${OWNER_ROOT}/cards/:id`, operation: "support_passport_card_replace" },
-  { method: "POST", pathname: `${OWNER_ROOT}/cards/:id/approve`, operation: "support_passport_card_approve" },
-  { method: "POST", pathname: `${OWNER_ROOT}/cards/:id/reject`, operation: "support_passport_card_reject" },
-  { method: "POST", pathname: `${OWNER_ROOT}/cards/:id/withdraw`, operation: "support_passport_card_withdraw" },
-  { method: "POST", pathname: `${OWNER_ROOT}/grants/:id/revoke`, operation: "support_passport_grant_revoke" }
-];
-function decodeId(value, label) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    throw new SupportPassportError("invalid_input", `${label} is invalid.`, 400);
-  }
-}
-function closeUnreadRequestAfterResponse(req, res) {
-  const contentLength = req.headers["content-length"];
-  const declaresBody = req.headers["transfer-encoding"] !== void 0 || contentLength !== void 0 && contentLength !== "0";
-  if (!declaresBody || req.readableEnded || req.destroyed) return;
-  res.shouldKeepAlive = false;
-  res.setHeader("connection", "close");
-  res.once("finish", () => req.destroy());
-}
-async function runOperation(name, input, dependencies, recordWriteCommit) {
-  const operation = getOperation(name);
-  if (!operation) throw new Error(`access-boundary: operation not registered: ${name}`);
-  const output = await operation.run(input, {
-    service: dependencies.service,
-    authenticatedPrincipal: dependencies.principal,
-    abortSignal: dependencies.abortSignal,
-    ...recordWriteCommit ? { hooks: { recordWriteCommit } } : {}
-  });
-  return output.result;
-}
-async function runWrite(name, input, dependencies) {
-  const writeQuota = dependencies.reserveWriteRateLimitSlot();
-  try {
-    const result = await runOperation(name, input, dependencies, writeQuota.commit);
-    writeQuota.commit();
-    return result;
-  } catch (error) {
-    writeQuota.release();
-    throw error;
-  }
-}
-async function handleSupportPassportOwnerHttp(dependencies) {
-  const { req, pathname } = dependencies;
-  try {
-    let operation;
-    let input = {};
-    let quotaLimitedWrite = false;
-    if (req.method === "GET" && pathname === `${OWNER_ROOT}/cards`) {
-      operation = "support_passport_cards_list";
-    } else if (req.method === "POST" && pathname === `${OWNER_ROOT}/drafts`) {
-      operation = "support_passport_draft_create";
-      quotaLimitedWrite = true;
-    } else if (req.method === "POST" && pathname === `${OWNER_ROOT}/drafts/generate`) {
-      operation = "support_passport_drafts_generate";
-      quotaLimitedWrite = true;
-    } else if (pathname === `${OWNER_ROOT}/grants` && req.method === "GET") {
-      operation = "support_passport_grants_list";
-    } else if (pathname === `${OWNER_ROOT}/grants` && req.method === "POST") {
-      operation = "support_passport_grant_create";
-      quotaLimitedWrite = true;
-    } else {
-      const memoryMatch = new RegExp(`^${OWNER_ROOT}/memories/([^/]+)$`).exec(pathname);
-      const cardMatch = new RegExp(`^${OWNER_ROOT}/cards/([^/]+)(?:/(approve|reject|withdraw))?$`).exec(pathname);
-      const grantMatch = new RegExp(`^${OWNER_ROOT}/grants/([^/]+)/revoke$`).exec(pathname);
-      if (memoryMatch && req.method === "GET") {
-        operation = "support_passport_memory_preview";
-        input.memoryId = decodeId(memoryMatch[1] ?? "", "memoryId");
-      } else if (cardMatch && req.method === "PUT" && !cardMatch[2]) {
-        operation = "support_passport_card_replace";
-        input.cardId = decodeId(cardMatch[1] ?? "", "cardId");
-        quotaLimitedWrite = true;
-      } else if (cardMatch && req.method === "POST" && cardMatch[2]) {
-        operation = `support_passport_card_${cardMatch[2]}`;
-        input.cardId = decodeId(cardMatch[1] ?? "", "cardId");
-        quotaLimitedWrite = true;
-      } else if (grantMatch && req.method === "POST") {
-        operation = "support_passport_grant_revoke";
-        input.grantId = decodeId(grantMatch[1] ?? "", "grantId");
-        quotaLimitedWrite = true;
-      }
-    }
-    if (!operation) return false;
-    dependencies.res.setHeader("cache-control", "private, no-store");
-    dependencies.res.setHeader("vary", "Authorization");
-    if (dependencies.hasQuery) {
-      throw new SupportPassportError("invalid_input", "Support passport routes do not accept query values.", 400);
-    }
-    if (req.method !== "GET") {
-      const body = await dependencies.readJsonBody();
-      for (const pathField of Object.keys(input)) {
-        if (Object.hasOwn(body, pathField)) {
-          throw new SupportPassportError("invalid_input", `${pathField} belongs in the URL path.`, 400);
-        }
-      }
-      input = { ...input, ...body };
-    }
-    if (operation === "support_passport_drafts_generate" && !Object.hasOwn(input, "sourceMemoryRevisions")) {
-      throw new SupportPassportError("invalid_input", "Review the selected notes again before drafting.", 400);
-    }
-    if (operation === "support_passport_grant_create") {
-      const grant = SupportPassportOwnerCreateGrantRequestSchema.safeParse(input);
-      if (!grant.success) throw new SupportPassportError("invalid_input", "The share link request is invalid.", 400);
-      input = {
-        cardIds: grant.data.cardIds,
-        cardRevisions: grant.data.cardRevisions,
-        ...grant.data.expiresAt !== void 0 ? { expiresAt: grant.data.expiresAt } : { durationMs: grant.data.durationMs }
-      };
-    }
-    const result = quotaLimitedWrite ? await runWrite(operation, input, dependencies) : await runOperation(operation, input, dependencies);
-    dependencies.respondJson(200, result);
-  } catch (error) {
-    if (!(error instanceof SupportPassportError)) throw error;
-    closeUnreadRequestAfterResponse(req, dependencies.res);
-    dependencies.respondJson(error.status, { error: error.message, code: error.code });
-  }
-  return true;
-}
-
-export {
-  SUPPORT_PASSPORT_OWNER_HTTP_ROUTES,
-  handleSupportPassportOwnerHttp
-};
-//# sourceMappingURL=chunk-75YZ5VAI.js.map

package/dist/chunk-7IRZK6MM.js

@@ -1,256 +0,0 @@
-import {
-  TOKEN_CAPABILITIES_VERSION,
-  normalizeCapabilities
-} from "./chunk-MZWSOLMT.js";
-import {
-  resolveHomeDir
-} from "./chunk-P2QRMMVQ.js";
-
-// src/tokens.ts
-import fs from "fs";
-import path from "path";
-import { randomBytes, randomUUID } from "crypto";
-var TOKEN_PREFIXES = {
-  "openclaw": "remnic_oc_",
-  "claude-code": "remnic_cc_",
-  "codex-cli": "remnic_cx_",
-  "codex": "remnic_cx_",
-  "hermes": "remnic_hm_",
-  "pi": "remnic_pi_",
-  "omp": "remnic_op_",
-  "replit": "remnic_rl_",
-  "cursor": "remnic_cu_",
-  "cline": "remnic_cl_",
-  "github-copilot": "remnic_gh_",
-  "roo-code": "remnic_rc_",
-  "windsurf": "remnic_ws_",
-  "amp": "remnic_am_",
-  "generic-mcp": "remnic_gm_",
-  "chatgpt": "remnic_cg_"
-};
-function defaultTokensPath() {
-  return path.join(resolveHomeDir(), ".remnic", "tokens.json");
-}
-function legacyTokensPath() {
-  return path.join(resolveHomeDir(), ".engram", "tokens.json");
-}
-function resolveReadPath(tokensPath) {
-  const primary = tokensPath ?? defaultTokensPath();
-  if (tokensPath) return primary;
-  if (fs.existsSync(primary)) return primary;
-  const legacy = legacyTokensPath();
-  return fs.existsSync(legacy) ? legacy : primary;
-}
-function ensureDir(filePath) {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-}
-function isEnoent(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function validateTokenEntry(raw, index) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new Error(`invalid token entry at index ${index}: expected object`);
-  }
-  const entry = raw;
-  if (typeof entry.token !== "string" || entry.token.length === 0) {
-    throw new Error(`invalid token entry at index ${index}: token must be a non-empty string`);
-  }
-  if (typeof entry.connector !== "string" || entry.connector.length === 0) {
-    throw new Error(`invalid token entry at index ${index}: connector must be a non-empty string`);
-  }
-  const capabilities = entry.capabilities !== void 0 ? normalizeCapabilities(entry.capabilities) : void 0;
-  return {
-    token: entry.token,
-    connector: entry.connector,
-    createdAt: typeof entry.createdAt === "string" && entry.createdAt.length > 0 ? entry.createdAt : (/* @__PURE__ */ new Date(0)).toISOString(),
-    ...capabilities ? { capabilities } : {}
-  };
-}
-function parseTokenStore(rawText, filePath) {
-  let raw;
-  try {
-    raw = JSON.parse(rawText);
-  } catch (error) {
-    throw new Error(
-      `failed to parse token store at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
-    const record = raw;
-    if (record.tokens !== void 0) {
-      if (!Array.isArray(record.tokens)) {
-        throw new Error(`invalid token store at ${filePath}: tokens must be an array`);
-      }
-      return {
-        store: {
-          tokens: record.tokens.map((entry, index) => validateTokenEntry(entry, index))
-        },
-        migratedLegacy: false
-      };
-    }
-    const migrated = [];
-    for (const [key, value] of Object.entries(record)) {
-      if (typeof value === "string" && value.length > 0) {
-        migrated.push(
-          validateTokenEntry(
-            { token: value, connector: key, createdAt: (/* @__PURE__ */ new Date()).toISOString() },
-            migrated.length
-          )
-        );
-      }
-    }
-    if (migrated.length > 0) {
-      return { store: { tokens: migrated }, migratedLegacy: true };
-    }
-  }
-  throw new Error(`invalid token store at ${filePath}: expected token array or legacy connector map`);
-}
-function loadTokenStore(tokensPath) {
-  const p = resolveReadPath(tokensPath);
-  try {
-    const rawText = fs.readFileSync(p, "utf8");
-    const { store, migratedLegacy } = parseTokenStore(rawText, p);
-    if (migratedLegacy) {
-      try {
-        saveTokenStore(store, tokensPath);
-      } catch {
-      }
-    }
-    return store;
-  } catch (error) {
-    if (isEnoent(error)) {
-      return { tokens: [] };
-    }
-    throw error;
-  }
-}
-function fsyncDirectoryBestEffort(dirPath) {
-  let dirFd = null;
-  try {
-    dirFd = fs.openSync(dirPath, "r");
-    fs.fsyncSync(dirFd);
-  } catch {
-  } finally {
-    if (dirFd !== null) {
-      try {
-        fs.closeSync(dirFd);
-      } catch {
-      }
-    }
-  }
-}
-function saveTokenStore(store, tokensPath) {
-  const p = tokensPath ?? defaultTokensPath();
-  ensureDir(p);
-  const validated = {
-    tokens: store.tokens.map((entry, index) => validateTokenEntry(entry, index))
-  };
-  const dir = path.dirname(p);
-  const tmpPath = path.join(dir, `.${path.basename(p)}.${process.pid}.${randomUUID()}.tmp`);
-  let fd = null;
-  try {
-    fd = fs.openSync(tmpPath, "w", 384);
-    fs.writeFileSync(fd, JSON.stringify(validated, null, 2) + "\n", "utf8");
-    fs.fsyncSync(fd);
-    fs.closeSync(fd);
-    fd = null;
-    fs.renameSync(tmpPath, p);
-    try {
-      fs.chmodSync(p, 384);
-    } catch {
-    }
-    fsyncDirectoryBestEffort(dir);
-    invalidateTokenCache();
-  } catch (error) {
-    if (fd !== null) {
-      try {
-        fs.closeSync(fd);
-      } catch {
-      }
-    }
-    try {
-      fs.rmSync(tmpPath, { force: true });
-    } catch {
-    }
-    throw error;
-  }
-}
-function buildTokenEntry(connector, capabilities) {
-  const prefix = TOKEN_PREFIXES[connector] ?? "remnic_xx_";
-  const token = prefix + randomBytes(24).toString("hex");
-  return {
-    token,
-    connector,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    capabilities: capabilities ?? { version: TOKEN_CAPABILITIES_VERSION }
-  };
-}
-function commitTokenEntry(entry, tokensPath) {
-  const store = loadTokenStore(tokensPath);
-  store.tokens = store.tokens.filter((t) => t.connector !== entry.connector);
-  store.tokens.push(entry);
-  saveTokenStore(store, tokensPath);
-}
-function generateToken(connector, tokensPath, capabilities) {
-  const store = loadTokenStore(tokensPath);
-  store.tokens = store.tokens.filter((t) => t.connector !== connector);
-  const entry = buildTokenEntry(connector, capabilities);
-  store.tokens.push(entry);
-  saveTokenStore(store, tokensPath);
-  return entry;
-}
-function listTokens(tokensPath) {
-  return loadTokenStore(tokensPath).tokens;
-}
-function revokeToken(connector, tokensPath) {
-  const store = loadTokenStore(tokensPath);
-  const before = store.tokens.length;
-  store.tokens = store.tokens.filter((t) => t.connector !== connector);
-  if (store.tokens.length < before) {
-    saveTokenStore(store, tokensPath);
-    return true;
-  }
-  return false;
-}
-function getAllValidTokens(tokensPath) {
-  return loadTokenStore(tokensPath).tokens.map((t) => t.token);
-}
-var TOKEN_CACHE_TTL_MS = 5e3;
-var _cachedEntries = [];
-var _cachedAt = 0;
-var _cachedPath;
-function invalidateTokenCache() {
-  _cachedEntries = [];
-  _cachedAt = 0;
-  _cachedPath = void 0;
-}
-function getAllValidTokenEntriesCached(tokensPath) {
-  const now = Date.now();
-  if (now - _cachedAt < TOKEN_CACHE_TTL_MS && tokensPath === _cachedPath) return _cachedEntries;
-  _cachedEntries = loadTokenStore(tokensPath).tokens;
-  _cachedAt = now;
-  _cachedPath = tokensPath;
-  return _cachedEntries;
-}
-function getAllValidTokensCached(tokensPath) {
-  return getAllValidTokenEntriesCached(tokensPath).map((entry) => entry.token);
-}
-function resolveConnectorFromToken(token, tokensPath) {
-  return loadTokenStore(tokensPath).tokens.find((t) => t.token === token)?.connector;
-}
-
-export {
-  loadTokenStore,
-  saveTokenStore,
-  buildTokenEntry,
-  commitTokenEntry,
-  generateToken,
-  listTokens,
-  revokeToken,
-  getAllValidTokens,
-  getAllValidTokenEntriesCached,
-  getAllValidTokensCached,
-  resolveConnectorFromToken
-};
-//# sourceMappingURL=chunk-7IRZK6MM.js.map

package/dist/chunk-7QVYVSEH.js

@@ -1,285 +0,0 @@
-import {
-  listNamespaces
-} from "./chunk-UCH2RWFX.js";
-import {
-  capabilityAllowsNamespace
-} from "./chunk-MZWSOLMT.js";
-
-// src/corpus-watermark.ts
-import { createHash } from "crypto";
-import { stat } from "fs/promises";
-import path from "path";
-var UNPARTITIONED_BUCKET = "unpartitioned";
-var DAY_PARTITION_RE = /^\d{4}-\d{2}-\d{2}$/;
-var COLD_TIER_DIR = "cold";
-function isRealCalendarDay(token) {
-  if (!DAY_PARTITION_RE.test(token)) return false;
-  const [year, month, day] = token.split("-").map(Number);
-  const date = new Date(Date.UTC(year, month - 1, day));
-  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
-}
-function parsePartition(baseDir, filePath) {
-  const rel = path.relative(baseDir, filePath).split(path.sep).join("/");
-  const parts = rel.split("/");
-  const tier = parts[0] === COLD_TIER_DIR ? "cold" : "hot";
-  const categoryParts = tier === "cold" ? parts.slice(1) : parts;
-  if (categoryParts.length >= 2 && isRealCalendarDay(categoryParts[1])) {
-    return { bucket: `${tier}:${categoryParts[0]}/${categoryParts[1]}`, date: categoryParts[1], tier };
-  }
-  return { bucket: `${tier}:${UNPARTITIONED_BUCKET}`, date: null, tier };
-}
-function buildPartitionCensus(paths, baseDir) {
-  const census = /* @__PURE__ */ new Map();
-  for (const filePath of paths) {
-    const { bucket } = parsePartition(baseDir, filePath);
-    census.set(bucket, (census.get(bucket) ?? 0) + 1);
-  }
-  return census;
-}
-function digestPartitionCensus(census) {
-  const entries = census instanceof Map ? [...census.entries()] : Object.entries(census);
-  const serialized = entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([bucket, count]) => `${bucket}:${count}`).join("\n");
-  return createHash("sha256").update(serialized).digest("hex");
-}
-async function computeCorpusWatermark(input) {
-  const { namespace, paths, baseDir } = input;
-  const census = /* @__PURE__ */ new Map();
-  let newestPartition = null;
-  const parsedByPath = [];
-  for (const filePath of paths) {
-    const parsed = parsePartition(baseDir, filePath);
-    parsedByPath.push(parsed);
-    census.set(parsed.bucket, (census.get(parsed.bucket) ?? 0) + 1);
-    if (parsed.tier === "hot" && parsed.date !== null && (newestPartition === null || parsed.date > newestPartition)) {
-      newestPartition = parsed.date;
-    }
-  }
-  const digest = digestPartitionCensus(census);
-  let newestWriteAt = null;
-  if (newestPartition !== null) {
-    let maxMtimeMs = Number.NEGATIVE_INFINITY;
-    for (let i = 0; i < paths.length; i += 1) {
-      if (parsedByPath[i].tier !== "hot" || parsedByPath[i].date !== newestPartition) continue;
-      try {
-        const st = await stat(paths[i]);
-        if (st.mtimeMs > maxMtimeMs) maxMtimeMs = st.mtimeMs;
-      } catch (err) {
-        if (err.code !== "ENOENT") throw err;
-      }
-    }
-    if (maxMtimeMs > Number.NEGATIVE_INFINITY) {
-      newestWriteAt = new Date(maxMtimeMs).toISOString();
-    }
-  }
-  const computedAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
-  return {
-    namespace,
-    memoryFileCount: paths.length,
-    newestPartition,
-    newestWriteAt,
-    digest,
-    computedAt
-  };
-}
-var CENSUS_RACE_MAX_ATTEMPTS = 3;
-async function computeNamespaceWatermark(namespace, storage, now) {
-  const readVersion = storage.getCorpusScanVersion?.bind(storage);
-  const maxAttempts = readVersion ? CENSUS_RACE_MAX_ATTEMPTS : 1;
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const before = readVersion ? await readVersion() : null;
-    const [hotPaths, coldPaths] = await Promise.all([
-      storage.collectActiveMemoryPaths({ propagateReadErrors: true }),
-      storage.collectColdMemoryPaths({ propagateReadErrors: true })
-    ]);
-    const result = await computeCorpusWatermark({ namespace, paths: [...hotPaths, ...coldPaths], baseDir: storage.dir, now });
-    const after = readVersion ? await readVersion() : null;
-    if (before === after) return result;
-  }
-  throw new Error(`corpus census for namespace "${namespace}" did not stabilize after ${maxAttempts} attempts`);
-}
-async function computeCorpusWatermarks(namespaces, storageFor, now) {
-  const watermarks = [];
-  for (const namespace of namespaces) {
-    try {
-      watermarks.push(await computeNamespaceWatermark(namespace, await storageFor(namespace), now));
-    } catch {
-    }
-  }
-  return watermarks;
-}
-async function resolveCorpusNamespaceRoots(options) {
-  const { config } = options;
-  const configDriven = await listNamespaces({
-    config,
-    propagateDiscoveryErrors: options.propagateDiscoveryErrors
-  });
-  const ordered = [
-    ...configDriven.filter((entry) => entry.namespace === config.defaultNamespace),
-    ...configDriven.filter((entry) => entry.namespace !== config.defaultNamespace)
-  ];
-  const seenNamespaces = /* @__PURE__ */ new Set();
-  const byRoot = /* @__PURE__ */ new Map();
-  for (const entry of ordered) {
-    if (seenNamespaces.has(entry.namespace)) continue;
-    seenNamespaces.add(entry.namespace);
-    const existing = byRoot.get(entry.rootDir);
-    if (existing) {
-      existing.namespaces.push(entry.namespace);
-    } else {
-      byRoot.set(entry.rootDir, { namespace: entry.namespace, rootDir: entry.rootDir, namespaces: [entry.namespace] });
-    }
-  }
-  const roots = [...byRoot.values()];
-  if (roots.length === 0) {
-    roots.push({ namespace: config.defaultNamespace, rootDir: config.memoryDir, namespaces: [config.defaultNamespace] });
-  }
-  return roots;
-}
-var WATERMARK_CACHE_TTL_MS = 6e4;
-var MAX_CONCURRENT_WATERMARK_REFRESHES = 4;
-var CorpusWatermarkCache = class {
-  entries = /* @__PURE__ */ new Map();
-  inFlight = /* @__PURE__ */ new Map();
-  ttlMs;
-  clock;
-  rootsEntry;
-  rootsInFlight;
-  rootsRefreshError;
-  queued = /* @__PURE__ */ new Map();
-  activeRefreshes = 0;
-  maxConcurrentRefreshes;
-  constructor(options = {}) {
-    this.ttlMs = options.ttlMs ?? WATERMARK_CACHE_TTL_MS;
-    this.clock = options.clock ?? Date.now;
-    this.maxConcurrentRefreshes = Math.max(1, options.maxConcurrentRefreshes ?? MAX_CONCURRENT_WATERMARK_REFRESHES);
-  }
-  get(namespace, compute) {
-    const cached = this.entries.get(namespace);
-    const fresh = cached !== void 0 && this.clock() < cached.expiresAt;
-    if (!fresh) this.refresh(namespace, compute);
-    return cached?.value;
-  }
-  refresh(namespace, compute) {
-    if (this.inFlight.has(namespace) || this.queued.has(namespace)) return;
-    const run = () => {
-      this.activeRefreshes += 1;
-      const pending = compute().then((value) => {
-        this.entries.set(namespace, { value, expiresAt: this.clock() + this.ttlMs });
-      }).catch(() => {
-      }).finally(() => {
-        this.inFlight.delete(namespace);
-        this.activeRefreshes -= 1;
-        this.drainQueue();
-      });
-      this.inFlight.set(namespace, pending);
-    };
-    if (this.activeRefreshes < this.maxConcurrentRefreshes) {
-      run();
-    } else {
-      this.queued.set(namespace, run);
-    }
-  }
-  drainQueue() {
-    while (this.activeRefreshes < this.maxConcurrentRefreshes && this.queued.size > 0) {
-      const next = this.queued.entries().next().value;
-      if (!next) break;
-      const [namespace, run] = next;
-      this.queued.delete(namespace);
-      run();
-    }
-  }
-  /**
-   * Stale-while-revalidate the resolved namespace roots (issue #2156 round-7).
-   * Namespace enumeration (config scan + persisted-catalog parse) is O(tenants)
-   * filesystem work; without this it ran on every probe ahead of the watermark
-   * cache. NEVER awaits: returns the cached/stale roots (or undefined when cold)
-   * and single-flights a background refresh.
-   */
-  getResolvedRoots(compute) {
-    const fresh = this.rootsEntry !== void 0 && this.clock() < this.rootsEntry.expiresAt;
-    if (!fresh && this.rootsInFlight === void 0) {
-      this.rootsInFlight = compute().then((value) => {
-        this.rootsEntry = { value, expiresAt: this.clock() + this.ttlMs };
-        this.rootsRefreshError = void 0;
-      }).catch((error) => {
-        this.rootsRefreshError = error;
-      }).finally(() => {
-        this.rootsInFlight = void 0;
-      });
-    }
-    return this.rootsEntry?.value;
-  }
-  getResolvedRootsStatus(compute) {
-    const roots = this.getResolvedRoots(compute);
-    return { roots, refreshError: this.rootsRefreshError };
-  }
-  /** Await every background refresh — in-flight AND queued (issue #2156 round-9) —
-   *  plus any roots refresh (shutdown / deterministic tests). */
-  async whenIdle() {
-    while (this.inFlight.size > 0 || this.rootsInFlight !== void 0 || this.queued.size > 0) {
-      const pending = [...this.inFlight.values()];
-      if (this.rootsInFlight) pending.push(this.rootsInFlight);
-      if (pending.length === 0) {
-        this.drainQueue();
-        await Promise.resolve();
-        continue;
-      }
-      await Promise.all(pending);
-    }
-  }
-};
-async function computeServiceCorpusWatermarks(host, options = {}) {
-  return (await computeServiceCorpusCensus(host, options)).watermarks;
-}
-async function computeServiceCorpusCensus(host, options = {}) {
-  let roots;
-  if (options.cache) {
-    const { roots: cachedRoots, refreshError } = options.cache.getResolvedRootsStatus(
-      () => resolveCorpusNamespaceRoots({ config: host.config, propagateDiscoveryErrors: true })
-    );
-    if (refreshError !== void 0) return { watermarks: [], complete: false };
-    roots = cachedRoots;
-  } else {
-    try {
-      roots = await resolveCorpusNamespaceRoots({
-        config: host.config,
-        propagateDiscoveryErrors: true
-      });
-    } catch {
-      return { watermarks: [], complete: false };
-    }
-  }
-  if (!roots) return { watermarks: [], complete: false };
-  const visible = roots.filter((root) => root.namespaces.some((ns) => capabilityAllowsNamespace(options.caps, ns)));
-  const watermarks = [];
-  let complete = true;
-  for (const { namespace } of visible) {
-    const compute = async () => computeNamespaceWatermark(namespace, await host.getStorage(namespace), options.now);
-    if (options.cache) {
-      const cached = options.cache.get(namespace, compute);
-      if (cached) watermarks.push(cached);
-      else complete = false;
-    } else {
-      try {
-        watermarks.push(await compute());
-      } catch {
-        complete = false;
-      }
-    }
-  }
-  return { watermarks, complete };
-}
-
-export {
-  UNPARTITIONED_BUCKET,
-  buildPartitionCensus,
-  digestPartitionCensus,
-  computeCorpusWatermark,
-  computeCorpusWatermarks,
-  resolveCorpusNamespaceRoots,
-  WATERMARK_CACHE_TTL_MS,
-  CorpusWatermarkCache,
-  computeServiceCorpusWatermarks,
-  computeServiceCorpusCensus
-};
-//# sourceMappingURL=chunk-7QVYVSEH.js.map