@remnic/core 9.69.55 → 9.69.57

package/dist/chunk-CEO4DONG.js

@@ -1,28 +0,0 @@
-import {
-  BUILTIN_CONNECTORS,
-  loadRegistry
-} from "./chunk-SGUDMW2K.js";
-
-// src/connectors/label.ts
-var CONNECTOR_LABEL_MAX_LENGTH = 64;
-var knownIds = null;
-var knownIdsAt = 0;
-var KNOWN_IDS_TTL_MS = 6e4;
-function knownConnectorIds() {
-  const now = Date.now();
-  if (knownIds !== null && now - knownIdsAt < KNOWN_IDS_TTL_MS) return knownIds;
-  try {
-    const ids = new Set(loadRegistry().connectors.map((c) => c.id));
-    knownIds = ids;
-    knownIdsAt = now;
-    return knownIds;
-  } catch {
-    return new Set(BUILTIN_CONNECTORS.map((c) => c.id));
-  }
-}
-
-export {
-  CONNECTOR_LABEL_MAX_LENGTH,
-  knownConnectorIds
-};
-//# sourceMappingURL=chunk-CEO4DONG.js.map

package/dist/chunk-CVILPI77.js

@@ -1,432 +0,0 @@
-import {
-  resolveReplicaPeersConfig
-} from "./chunk-WNIUPHWV.js";
-import {
-  resolveAgentAccessAuthToken
-} from "./chunk-IJ6WHMFB.js";
-import {
-  capabilityAllowsNamespace,
-  isCapabilityRestricted,
-  isValidNamespaceValue
-} from "./chunk-MZWSOLMT.js";
-
-// src/replica-divergence.ts
-var DEFAULT_MAX_CONCURRENT_PEER_FETCHES = 4;
-function writeAgeDeltaMs(local, peer) {
-  if (local === null || peer === null) return null;
-  const a = Date.parse(local);
-  const b = Date.parse(peer);
-  if (!Number.isFinite(a) || !Number.isFinite(b)) return null;
-  return Math.abs(a - b);
-}
-function verdictFromDeltas(namespaces) {
-  if (namespaces.some((delta) => delta.diverged)) return { state: "diverged" };
-  if (namespaces.some((delta) => delta.presence === "local_only")) {
-    return { state: "unknown", reason: "namespace_scope_unverifiable" };
-  }
-  if (!namespaces.some((delta) => delta.presence === "both")) {
-    return { state: "unknown", reason: "no_shared_namespaces" };
-  }
-  return { state: "converged" };
-}
-function compareReplicaWatermarks(local, peer, thresholds) {
-  const byLocal = new Map(local.map((watermark) => [watermark.namespace, watermark]));
-  const byPeer = new Map(peer.map((watermark) => [watermark.namespace, watermark]));
-  const allNamespaces = [.../* @__PURE__ */ new Set([...byLocal.keys(), ...byPeer.keys()])].sort(
-    (a, b) => a < b ? -1 : a > b ? 1 : 0
-  );
-  const namespaces = allNamespaces.map((namespace) => {
-    const localWatermark = byLocal.get(namespace);
-    const peerWatermark = byPeer.get(namespace);
-    if (localWatermark && !peerWatermark) {
-      return {
-        namespace,
-        presence: "local_only",
-        localFileCount: localWatermark.memoryFileCount,
-        peerFileCount: null,
-        fileCountDelta: null,
-        localNewestWriteAt: localWatermark.newestWriteAt,
-        peerNewestWriteAt: null,
-        writeAgeDeltaMs: null,
-        digestMatch: null,
-        diverged: false,
-        reasons: ["namespace_absent_from_peer_response"]
-      };
-    }
-    if (!localWatermark && peerWatermark) {
-      return {
-        namespace,
-        presence: "peer_only",
-        localFileCount: null,
-        peerFileCount: peerWatermark.memoryFileCount,
-        fileCountDelta: null,
-        localNewestWriteAt: null,
-        peerNewestWriteAt: peerWatermark.newestWriteAt,
-        writeAgeDeltaMs: null,
-        digestMatch: null,
-        diverged: true,
-        reasons: ["namespace_absent_locally"]
-      };
-    }
-    const l = localWatermark;
-    const p = peerWatermark;
-    const fileCountDelta = Math.abs(l.memoryFileCount - p.memoryFileCount);
-    const digestMatch = l.digest === p.digest;
-    const ageDelta = writeAgeDeltaMs(l.newestWriteAt, p.newestWriteAt);
-    const reasons = [];
-    if (fileCountDelta > thresholds.maxFileCountDelta) {
-      reasons.push(`file_count_delta=${fileCountDelta}`);
-    } else if (fileCountDelta === 0 && !digestMatch) {
-      reasons.push("digest_mismatch");
-    }
-    if (ageDelta !== null && ageDelta > thresholds.maxWatermarkAgeDeltaMs) {
-      reasons.push(`write_age_delta_ms=${ageDelta}`);
-    }
-    if (l.newestWriteAt === null !== (p.newestWriteAt === null)) {
-      reasons.push("newest_write_presence_mismatch");
-    }
-    return {
-      namespace,
-      presence: "both",
-      localFileCount: l.memoryFileCount,
-      peerFileCount: p.memoryFileCount,
-      fileCountDelta,
-      localNewestWriteAt: l.newestWriteAt,
-      peerNewestWriteAt: p.newestWriteAt,
-      writeAgeDeltaMs: ageDelta,
-      digestMatch,
-      diverged: reasons.length > 0,
-      reasons
-    };
-  });
-  const divergedNamespaceCount = namespaces.filter((delta) => delta.diverged).length;
-  const verdict = verdictFromDeltas(namespaces);
-  return { state: verdict.state, reason: verdict.reason, namespaces, divergedNamespaceCount };
-}
-var HEALTH_PATHS = ["/engram/v1/health", "/remnic/v1/health"];
-var MAX_PEER_RESPONSE_BYTES = 8 * 1024 * 1024;
-var PeerResponseTooLarge = class extends Error {
-};
-async function readBoundedJson(response) {
-  const stream = response.body;
-  if (!stream || typeof stream.getReader !== "function") {
-    return response.json();
-  }
-  const reader = stream.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > MAX_PEER_RESPONSE_BYTES) throw new PeerResponseTooLarge();
-      chunks.push(value);
-    }
-  } finally {
-    await reader.cancel().catch(() => void 0);
-  }
-  const merged = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    merged.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return JSON.parse(new TextDecoder().decode(merged));
-}
-function redactPeerUrl(url) {
-  try {
-    return new URL(url).host;
-  } catch {
-    return "peer";
-  }
-}
-function networkReason(error) {
-  if (error && typeof error === "object") {
-    if ("name" in error && error.name === "TimeoutError") return "timeout";
-    if ("name" in error && error.name === "AbortError") return "aborted";
-    if ("cause" in error && error.cause && typeof error.cause === "object" && "code" in error.cause && typeof error.cause.code === "string") {
-      return `network_${error.cause.code}`;
-    }
-    if ("code" in error && typeof error.code === "string") return `network_${error.code}`;
-  }
-  return "unreachable";
-}
-function coerceCorpusWatermark(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const record = raw;
-  if (!isValidNamespaceValue(record.namespace)) return null;
-  if (typeof record.memoryFileCount !== "number" || !Number.isInteger(record.memoryFileCount) || record.memoryFileCount < 0) {
-    return null;
-  }
-  if (typeof record.digest !== "string" || record.digest.length === 0) return null;
-  let newestWriteAt = null;
-  if (record.newestWriteAt !== void 0 && record.newestWriteAt !== null) {
-    if (typeof record.newestWriteAt !== "string" || !Number.isFinite(Date.parse(record.newestWriteAt))) return null;
-    newestWriteAt = record.newestWriteAt;
-  }
-  if (typeof record.computedAt !== "string" || !Number.isFinite(Date.parse(record.computedAt))) {
-    return null;
-  }
-  return {
-    namespace: record.namespace,
-    memoryFileCount: record.memoryFileCount,
-    newestPartition: typeof record.newestPartition === "string" ? record.newestPartition : null,
-    newestWriteAt,
-    digest: record.digest,
-    computedAt: record.computedAt
-  };
-}
-var DEADLINE_TIMEOUT = /* @__PURE__ */ Symbol("deadline_timeout");
-async function withDeadline(promise, deadlineMs) {
-  const { promise: expiry, reject } = Promise.withResolvers();
-  const timer = setTimeout(() => reject(DEADLINE_TIMEOUT), Math.max(1, deadlineMs - Date.now()));
-  try {
-    return await Promise.race([promise, expiry]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function fetchPeerWatermarks(peer, options) {
-  const doFetch = options.fetchImpl ?? globalThis.fetch;
-  const deadline = Date.now() + options.timeoutMs;
-  let token;
-  try {
-    token = await withDeadline(
-      resolveAgentAccessAuthToken(peer.token, { resolveSecretRef: options.resolveSecretRef }),
-      deadline
-    );
-  } catch (error) {
-    return { kind: "unreachable", reason: error === DEADLINE_TIMEOUT ? "timeout" : "token_error" };
-  }
-  const base = peer.url.replace(/\/+$/, "");
-  for (let i = 0; i < HEALTH_PATHS.length; i += 1) {
-    const path = HEALTH_PATHS[i];
-    const isLastPath = i === HEALTH_PATHS.length - 1;
-    let response;
-    try {
-      response = await doFetch(`${base}${path}`, {
-        headers: token ? { authorization: `Bearer ${token}` } : void 0,
-        signal: AbortSignal.timeout(Math.max(1, deadline - Date.now()))
-      });
-    } catch (error) {
-      return { kind: "unreachable", reason: networkReason(error) };
-    }
-    if (response.status === 404 && !isLastPath) continue;
-    if (!response.ok) return { kind: "unreachable", reason: `http_${response.status}` };
-    let body;
-    try {
-      body = await readBoundedJson(response);
-    } catch (error) {
-      if (error instanceof PeerResponseTooLarge) {
-        return { kind: "unknown", reason: "response_too_large" };
-      }
-      const name = error?.name;
-      if (name === "TimeoutError" || name === "AbortError") {
-        return { kind: "unreachable", reason: networkReason(error) };
-      }
-      return { kind: "unknown", reason: "invalid_json" };
-    }
-    if (!body || typeof body !== "object" || !("corpus" in body) || !Array.isArray(body.corpus)) {
-      return { kind: "unknown", reason: "missing_corpus" };
-    }
-    const corpus = body.corpus.map(coerceCorpusWatermark).filter((watermark) => watermark !== null);
-    if (corpus.length !== body.corpus.length) {
-      return { kind: "unknown", reason: "malformed_corpus" };
-    }
-    if (new Set(corpus.map((watermark) => watermark.namespace)).size !== corpus.length) {
-      return { kind: "unknown", reason: "malformed_corpus" };
-    }
-    const peerBody = body;
-    if (peerBody.corpusComplete !== void 0 && typeof peerBody.corpusComplete !== "boolean") {
-      return { kind: "unknown", reason: "malformed_corpus" };
-    }
-    const legacyComplete = peerBody.replica?.censusComplete;
-    if (peerBody.corpusComplete === void 0 && legacyComplete !== void 0 && typeof legacyComplete !== "boolean") {
-      return { kind: "unknown", reason: "malformed_corpus" };
-    }
-    const peerComplete = typeof peerBody.corpusComplete === "boolean" ? peerBody.corpusComplete : legacyComplete;
-    if (peerComplete === false) {
-      return { kind: "unknown", reason: "peer_census_incomplete" };
-    }
-    const maxCensusAgeMs = options.maxCensusAgeMs;
-    if (maxCensusAgeMs !== void 0 && maxCensusAgeMs > 0) {
-      const now = options.nowMs ?? Date.now();
-      if (corpus.some((watermark) => Math.abs(now - Date.parse(watermark.computedAt)) > maxCensusAgeMs)) {
-        return { kind: "unknown", reason: "peer_census_stale" };
-      }
-    }
-    return { kind: "ok", corpus };
-  }
-  return { kind: "unreachable", reason: "http_404" };
-}
-async function mapWithConcurrency(items, limit, worker) {
-  const results = new Array(items.length);
-  let cursor = 0;
-  const runners = new Array(Math.min(Math.max(1, limit), items.length || 1)).fill(null).map(async () => {
-    while (cursor < items.length) {
-      const index = cursor;
-      cursor += 1;
-      results[index] = await worker(items[index], index);
-    }
-  });
-  await Promise.all(runners);
-  return results;
-}
-async function pollReplicaPeers(options) {
-  const { config, localWatermarks } = options;
-  if (!config.enabled || config.peers.length === 0) {
-    return { enabled: config.enabled, pending: false, polledAt: null, peers: [] };
-  }
-  const polledAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const thresholds = {
-    maxFileCountDelta: config.maxFileCountDelta,
-    maxWatermarkAgeDeltaMs: config.maxWatermarkAgeDeltaMs
-  };
-  const peers = await mapWithConcurrency(
-    config.peers,
-    options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT_PEER_FETCHES,
-    async (peer) => {
-      const label = redactPeerUrl(peer.url);
-      try {
-        const outcome = await fetchPeerWatermarks(peer, {
-          timeoutMs: config.requestTimeoutMs,
-          resolveSecretRef: options.resolveSecretRef,
-          fetchImpl: options.fetchImpl,
-          maxCensusAgeMs: config.maxWatermarkAgeDeltaMs,
-          nowMs: options.now?.getTime()
-        });
-        if (outcome.kind !== "ok") {
-          return { peer: label, state: outcome.kind, polledAt, namespaces: [], divergedNamespaceCount: 0, reason: outcome.reason };
-        }
-        const comparison = compareReplicaWatermarks(localWatermarks, outcome.corpus, thresholds);
-        const peerReport = {
-          peer: label,
-          state: comparison.state,
-          polledAt,
-          namespaces: comparison.namespaces,
-          divergedNamespaceCount: comparison.divergedNamespaceCount
-        };
-        if (comparison.reason) peerReport.reason = comparison.reason;
-        return peerReport;
-      } catch {
-        return { peer: label, state: "unreachable", polledAt, namespaces: [], divergedNamespaceCount: 0, reason: "error" };
-      }
-    }
-  );
-  const report = { enabled: true, pending: false, polledAt, peers };
-  logDivergence(options.log, report);
-  return report;
-}
-function logDivergence(log, report) {
-  if (!log) return;
-  const flagged = report.peers.filter((peer) => peer.state !== "converged");
-  if (flagged.length === 0) return;
-  const detail = flagged.map((peer) => peer.state === "diverged" ? `${peer.peer}=diverged(${peer.divergedNamespaceCount}ns)` : `${peer.peer}=${peer.state}`).join(", ");
-  log(`replica divergence: ${flagged.length} of ${report.peers.length} peer(s) flagged: ${detail}`);
-}
-function filterReplicaReportByCaps(report, caps) {
-  if (!isCapabilityRestricted(caps ?? void 0)) return report;
-  const peers = report.peers.map((peer) => {
-    if (peer.namespaces.length === 0) return peer;
-    const namespaces = peer.namespaces.filter((delta) => capabilityAllowsNamespace(caps ?? void 0, delta.namespace));
-    const divergedNamespaceCount = namespaces.filter((delta) => delta.diverged).length;
-    if (peer.state === "unknown" && peer.reason === "local_census_incomplete") {
-      return { ...peer, namespaces, divergedNamespaceCount };
-    }
-    const verdict = verdictFromDeltas(namespaces);
-    const filtered = { ...peer, namespaces, divergedNamespaceCount, state: verdict.state };
-    if (verdict.reason) filtered.reason = verdict.reason;
-    else delete filtered.reason;
-    return filtered;
-  });
-  return gateReportByCensus({ ...report, peers }, report.censusComplete !== false);
-}
-function gateReportByCensus(report, censusComplete) {
-  if (censusComplete) return { ...report, censusComplete: true };
-  return {
-    ...report,
-    censusComplete: false,
-    peers: report.peers.map((peer) => {
-      if (peer.state === "unreachable" || peer.state === "unknown") return peer;
-      const namespaces = peer.namespaces.map(
-        (delta) => delta.presence === "peer_only" && delta.diverged ? { ...delta, diverged: false, reasons: ["namespace_absent_locally_unverified"] } : delta
-      );
-      const divergedNamespaceCount = namespaces.filter((delta) => delta.diverged).length;
-      const hasSharedDivergence = namespaces.some((delta) => delta.presence === "both" && delta.diverged);
-      if (hasSharedDivergence) return { ...peer, namespaces, divergedNamespaceCount };
-      return { ...peer, namespaces, divergedNamespaceCount, state: "unknown", reason: "local_census_incomplete" };
-    })
-  };
-}
-var ReplicaDivergenceMonitor = class {
-  cached;
-  /** Earliest clock() at which a failed poll may retry — enforces backoff (round 6). */
-  nextAttemptAt = 0;
-  inFlight;
-  clock;
-  resolveSecretRef;
-  fetchImpl;
-  maxConcurrent;
-  log;
-  constructor(options = {}) {
-    this.clock = options.clock ?? Date.now;
-    this.resolveSecretRef = options.resolveSecretRef;
-    this.fetchImpl = options.fetchImpl;
-    this.maxConcurrent = options.maxConcurrent;
-    this.log = options.log;
-  }
-  getReport(input) {
-    const config = resolveReplicaPeersConfig(input.config);
-    if (!config.enabled) return { enabled: false, pending: false, polledAt: null, peers: [] };
-    if (config.peers.length === 0) return { enabled: true, pending: false, polledAt: null, peers: [] };
-    const fresh = this.cached !== void 0 && this.clock() < this.cached.expiresAt;
-    if (!fresh && this.clock() >= this.nextAttemptAt) this.refresh(config, input.computeLocalWatermarks);
-    if (this.cached) {
-      const gated = input.localCensusComplete === false ? gateReportByCensus(this.cached.report, false) : this.cached.report;
-      return filterReplicaReportByCaps(gated, input.caps ?? null);
-    }
-    return { enabled: true, pending: true, polledAt: null, peers: [] };
-  }
-  refresh(config, computeLocalWatermarks) {
-    if (this.inFlight) return;
-    this.inFlight = (async () => {
-      const census = await computeLocalWatermarks();
-      const localWatermarks = census.watermarks;
-      const report = await pollReplicaPeers({
-        config,
-        localWatermarks,
-        resolveSecretRef: this.resolveSecretRef,
-        fetchImpl: this.fetchImpl,
-        maxConcurrent: this.maxConcurrent,
-        log: this.log
-      });
-      const gated = gateReportByCensus(report, census.complete);
-      const freshnessCap = config.maxWatermarkAgeDeltaMs > 0 ? config.maxWatermarkAgeDeltaMs : Number.POSITIVE_INFINITY;
-      const ttl = Math.min(config.pollIntervalMs, freshnessCap);
-      this.cached = { report: gated, expiresAt: this.clock() + ttl };
-      this.nextAttemptAt = 0;
-    })().catch(() => {
-      this.nextAttemptAt = this.clock() + config.pollIntervalMs;
-    }).finally(() => {
-      this.inFlight = void 0;
-    });
-  }
-  /** Await any in-flight background poll (deterministic tests / shutdown). */
-  async whenIdle() {
-    while (this.inFlight) await this.inFlight;
-  }
-};
-
-export {
-  compareReplicaWatermarks,
-  MAX_PEER_RESPONSE_BYTES,
-  redactPeerUrl,
-  fetchPeerWatermarks,
-  pollReplicaPeers,
-  filterReplicaReportByCaps,
-  gateReportByCensus,
-  ReplicaDivergenceMonitor
-};
-//# sourceMappingURL=chunk-CVILPI77.js.map

package/dist/chunk-D2N3PMAE.js

@@ -1,51 +0,0 @@
-import {
-  RECALL_DISCLOSURE_LEVELS
-} from "./chunk-4UVJ6EIT.js";
-
-// src/recall-navigate.ts
-var RECALL_NAV_LINK_TYPES = [
-  "supports",
-  "contradicts",
-  "elaborates",
-  "supersedes",
-  "causes"
-];
-function isRecallNavLinkType(value) {
-  return typeof value === "string" && RECALL_NAV_LINK_TYPES.includes(value);
-}
-function expandRecallNode(node, options) {
-  if (!Number.isFinite(options.budget) || options.budget <= 0) {
-    return { status: "unavailable", reason: "budget_off" };
-  }
-  const current = RECALL_DISCLOSURE_LEVELS.indexOf(node.disclosure);
-  const next = current >= 0 ? RECALL_DISCLOSURE_LEVELS[current + 1] : void 0;
-  if (next === void 0) return { status: "empty" };
-  const text = node.payloads?.[next];
-  if (typeof text !== "string") return { status: "empty" };
-  return { status: "ok", node: { id: node.id, disclosure: next, text } };
-}
-function traverseRecallLink(from, linkType, options) {
-  if (!isRecallNavLinkType(linkType)) {
-    throw new Error(
-      `unknown recall nav linkType: ${JSON.stringify(linkType)}. Valid: ${RECALL_NAV_LINK_TYPES.join(", ")}`
-    );
-  }
-  if (!Number.isFinite(options.budget) || options.budget <= 0) {
-    return { status: "unavailable", reason: "budget_off" };
-  }
-  const neighbors = (from.links ?? []).filter((link) => link.linkType === linkType).map((link) => {
-    const neighbor = { id: link.targetId, linkType };
-    if (link.preview !== void 0) neighbor.preview = link.preview;
-    return neighbor;
-  }).sort((a, b) => a.id.localeCompare(b.id, "en"));
-  if (neighbors.length === 0) return { status: "empty" };
-  return { status: "ok", neighbors };
-}
-
-export {
-  RECALL_NAV_LINK_TYPES,
-  isRecallNavLinkType,
-  expandRecallNode,
-  traverseRecallLink
-};
-//# sourceMappingURL=chunk-D2N3PMAE.js.map