@remnic/plugin-openclaw 1.0.0

package/dist/causal-trajectory-graph-7Z5DD66L.js

@@ -0,0 +1,59 @@
+import {
+  appendEdge
+} from "./chunk-H3SKMYPU.js";
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/causal-trajectory-graph.ts
+function causalTrajectoryGraphNodeId(trajectoryId, stage) {
+  return `causal-trajectory/${trajectoryId}#${stage}`;
+}
+function buildCausalTrajectoryGraphEdges(record) {
+  const edges = [
+    {
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "goal"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "action"),
+      type: "causal",
+      weight: 1,
+      label: "goal_to_action",
+      ts: record.recordedAt
+    },
+    {
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "action"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "observation"),
+      type: "causal",
+      weight: 1,
+      label: "action_to_observation",
+      ts: record.recordedAt
+    },
+    {
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "observation"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "outcome"),
+      type: "causal",
+      weight: 1,
+      label: `observation_to_outcome:${record.outcomeKind}`,
+      ts: record.recordedAt
+    }
+  ];
+  if (record.followUpSummary) {
+    edges.push({
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "outcome"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "follow_up"),
+      type: "causal",
+      weight: 1,
+      label: "outcome_to_follow_up",
+      ts: record.recordedAt
+    });
+  }
+  return edges;
+}
+async function appendCausalTrajectoryGraphEdges(options) {
+  const edges = buildCausalTrajectoryGraphEdges(options.record);
+  for (const edge of edges) {
+    await appendEdge(options.memoryDir, edge);
+  }
+}
+export {
+  appendCausalTrajectoryGraphEdges,
+  buildCausalTrajectoryGraphEdges,
+  causalTrajectoryGraphNodeId
+};

package/dist/chunk-5LE4HTVL.js

@@ -0,0 +1,46 @@
+// ../remnic-core/src/json-store.ts
+import path from "path";
+import { readFile, readdir } from "fs/promises";
+async function listJsonFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        out.push(...await listJsonFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+        out.push(fullPath);
+      }
+    }
+    return out.sort();
+  } catch {
+    return [];
+  }
+}
+async function listNamedFiles(dir, fileName) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        out.push(...await listNamedFiles(fullPath, fileName));
+      } else if (entry.isFile() && entry.name === fileName) {
+        out.push(fullPath);
+      }
+    }
+    return out.sort();
+  } catch {
+    return [];
+  }
+}
+async function readJsonFile(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+export {
+  listJsonFiles,
+  listNamedFiles,
+  readJsonFile
+};

package/dist/chunk-BZ27H3BL.js

@@ -0,0 +1,158 @@
+import {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  countRecallTokenOverlap,
+  isRecord,
+  normalizeRecallTokens,
+  optionalString,
+  optionalStringArray,
+  validateStringRecord
+} from "./chunk-JGEKL3WH.js";
+import {
+  listJsonFiles,
+  readJsonFile
+} from "./chunk-5LE4HTVL.js";
+
+// ../remnic-core/src/causal-trajectory.ts
+import path from "path";
+import { mkdir, writeFile } from "fs/promises";
+function validateMetadata(raw) {
+  return validateStringRecord(raw, "metadata");
+}
+function resolveCausalTrajectoryStoreDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path.join(memoryDir, "state", "causal-trajectories");
+}
+function validateCausalTrajectoryRecord(raw) {
+  if (!isRecord(raw)) throw new Error("causal trajectory record must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  const outcomeKind = assertString(raw.outcomeKind, "outcomeKind");
+  if (!["success", "failure", "partial", "unknown"].includes(outcomeKind)) {
+    throw new Error("outcomeKind must be one of success|failure|partial|unknown");
+  }
+  return {
+    schemaVersion: 1,
+    trajectoryId: assertSafePathSegment(assertString(raw.trajectoryId, "trajectoryId"), "trajectoryId"),
+    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString(raw.sessionKey, "sessionKey"),
+    goal: assertString(raw.goal, "goal"),
+    actionSummary: assertString(raw.actionSummary, "actionSummary"),
+    observationSummary: assertString(raw.observationSummary, "observationSummary"),
+    outcomeKind,
+    outcomeSummary: assertString(raw.outcomeSummary, "outcomeSummary"),
+    followUpSummary: optionalString(raw.followUpSummary),
+    objectiveStateSnapshotRefs: optionalStringArray(raw.objectiveStateSnapshotRefs, "objectiveStateSnapshotRefs"),
+    entityRefs: optionalStringArray(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray(raw.tags, "tags"),
+    metadata: validateMetadata(raw.metadata)
+  };
+}
+async function readCausalTrajectoryRecords(options) {
+  const rootDir = resolveCausalTrajectoryStoreDir(options.memoryDir, options.causalTrajectoryStoreDir);
+  const files = await listJsonFiles(path.join(rootDir, "trajectories"));
+  const trajectories = [];
+  const invalidTrajectories = [];
+  for (const filePath of files) {
+    try {
+      trajectories.push(validateCausalTrajectoryRecord(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidTrajectories.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { files, trajectories, invalidTrajectories };
+}
+async function getCausalTrajectoryStoreStatus(options) {
+  const rootDir = resolveCausalTrajectoryStoreDir(options.memoryDir, options.causalTrajectoryStoreDir);
+  const trajectoriesDir = path.join(rootDir, "trajectories");
+  const { files, trajectories, invalidTrajectories } = await readCausalTrajectoryRecords(options);
+  trajectories.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byOutcome = {};
+  for (const trajectory of trajectories) {
+    byOutcome[trajectory.outcomeKind] = (byOutcome[trajectory.outcomeKind] ?? 0) + 1;
+  }
+  return {
+    enabled: options.enabled,
+    rootDir,
+    trajectoriesDir,
+    trajectories: {
+      total: files.length,
+      valid: trajectories.length,
+      invalid: invalidTrajectories.length,
+      byOutcome,
+      latestTrajectoryId: trajectories[0]?.trajectoryId,
+      latestRecordedAt: trajectories[0]?.recordedAt,
+      latestSessionKey: trajectories[0]?.sessionKey
+    },
+    latestTrajectory: trajectories[0],
+    invalidTrajectories
+  };
+}
+function lexicalScoreCausalTrajectoryRecord(record, queryTokens) {
+  const weightedFields = [
+    ["goal", record.goal, 4],
+    ["action", record.actionSummary, 3],
+    ["observation", record.observationSummary, 3],
+    ["outcome", record.outcomeSummary, 3],
+    ["follow_up", record.followUpSummary, 2],
+    ["outcome_kind", record.outcomeKind, 1],
+    ["tags", record.tags?.join(" "), 2],
+    ["entity_refs", record.entityRefs?.join(" "), 2],
+    ["objective_state_refs", record.objectiveStateSnapshotRefs?.join(" "), 1]
+  ];
+  let score = 0;
+  const matchedFields = [];
+  for (const [field, value, weight] of weightedFields) {
+    const matches = countRecallTokenOverlap(queryTokens, value, ["make"]);
+    if (matches > 0) matchedFields.push(field);
+    score += matches * weight;
+  }
+  return { score, matchedFields };
+}
+function scoreCausalTrajectoryRecord(record, lexicalScore, sessionKey) {
+  let score = lexicalScore;
+  if (sessionKey && record.sessionKey === sessionKey) score += 1.5;
+  const recordedAtMs = Date.parse(record.recordedAt);
+  if (Number.isFinite(recordedAtMs)) {
+    const ageHours = Math.max(0, (Date.now() - recordedAtMs) / 36e5);
+    score += 1 / (1 + ageHours);
+  }
+  return score;
+}
+async function searchCausalTrajectories(options) {
+  const maxResults = Math.max(0, Math.floor(options.maxResults));
+  if (maxResults === 0) return [];
+  const { trajectories } = await readCausalTrajectoryRecords(options);
+  if (trajectories.length === 0) return [];
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["make"]));
+  if (queryTokens.size === 0) return [];
+  const scored = trajectories.map((record) => {
+    const lexical = lexicalScoreCausalTrajectoryRecord(record, queryTokens);
+    return {
+      record,
+      matchedFields: lexical.matchedFields,
+      lexicalScore: lexical.score,
+      score: scoreCausalTrajectoryRecord(record, lexical.score, options.sessionKey)
+    };
+  });
+  const filtered = scored.filter((result) => result.lexicalScore > 0);
+  filtered.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return right.record.recordedAt.localeCompare(left.record.recordedAt);
+  });
+  return filtered.slice(0, maxResults).map(({ record, score, matchedFields }) => ({
+    record,
+    score,
+    matchedFields
+  }));
+}
+
+export {
+  getCausalTrajectoryStoreStatus,
+  searchCausalTrajectories
+};

package/dist/chunk-DMGIUDBO.js

@@ -0,0 +1,41 @@
+// ../remnic-core/src/logger.ts
+var NOOP_LOGGER = {
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  },
+  debug() {
+  }
+};
+var _backend = NOOP_LOGGER;
+var _debug = false;
+function initLogger(backend, debug) {
+  _backend = backend;
+  _debug = debug;
+}
+var log = {
+  info(msg, ...args) {
+    _backend.info(`remnic: ${msg}`, ...args);
+  },
+  warn(msg, ...args) {
+    _backend.warn(`remnic: ${msg}`, ...args);
+  },
+  error(msg, err) {
+    const detail = err instanceof Error ? err.message : err ? String(err) : "";
+    _backend.error(
+      `remnic: ${msg}${detail ? ` \u2014 ${detail}` : ""}`
+    );
+  },
+  debug(msg, ...args) {
+    if (!_debug) return;
+    const fn = _backend.debug ?? _backend.info;
+    fn(`remnic [debug]: ${msg}`, ...args);
+  }
+};
+
+export {
+  initLogger,
+  log
+};

package/dist/chunk-GUSMRW4H.js

@@ -0,0 +1,12 @@
+// ../remnic-core/src/version-utils.ts
+function compareVersions(a, b) {
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] > b[i]) return 1;
+    if (a[i] < b[i]) return -1;
+  }
+  return 0;
+}
+
+export {
+  compareVersions
+};

package/dist/chunk-H3SKMYPU.js

@@ -0,0 +1,340 @@
+// ../remnic-core/src/graph.ts
+import { mkdir, appendFile, readFile } from "fs/promises";
+import * as path from "path";
+var CAUSAL_PHRASES = [
+  "as a result",
+  "led to",
+  "because of",
+  "therefore",
+  "caused",
+  "because"
+];
+function graphsDir(memoryDir) {
+  return path.join(memoryDir, "state", "graphs");
+}
+function graphFilePath(memoryDir, type) {
+  return path.join(graphsDir(memoryDir), `${type}.jsonl`);
+}
+async function ensureGraphsDir(memoryDir) {
+  await mkdir(graphsDir(memoryDir), { recursive: true });
+}
+async function appendEdge(memoryDir, edge) {
+  await ensureGraphsDir(memoryDir);
+  const line = JSON.stringify(edge) + "\n";
+  await appendFile(graphFilePath(memoryDir, edge.type), line, "utf8");
+}
+async function readEdges(memoryDir, type) {
+  const filePath = graphFilePath(memoryDir, type);
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const edges = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        edges.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return edges;
+  } catch {
+    return [];
+  }
+}
+async function readAllEdges(memoryDir, config) {
+  const parts = await Promise.all([
+    config.entityGraphEnabled ? readEdges(memoryDir, "entity") : Promise.resolve([]),
+    config.timeGraphEnabled ? readEdges(memoryDir, "time") : Promise.resolve([]),
+    config.causalGraphEnabled ? readEdges(memoryDir, "causal") : Promise.resolve([])
+  ]);
+  return parts.flat();
+}
+function isValidGraphEdge(raw, expectedType) {
+  if (!raw || typeof raw !== "object") return false;
+  const edge = raw;
+  return edge.type === expectedType && typeof edge.from === "string" && edge.from.length > 0 && typeof edge.to === "string" && edge.to.length > 0 && typeof edge.weight === "number" && Number.isFinite(edge.weight) && typeof edge.label === "string" && typeof edge.ts === "string";
+}
+async function analyzeGraphHealth(memoryDir, options) {
+  const enabledTypes = [];
+  if (options?.entityGraphEnabled !== false) enabledTypes.push("entity");
+  if (options?.timeGraphEnabled !== false) enabledTypes.push("time");
+  if (options?.causalGraphEnabled !== false) enabledTypes.push("causal");
+  const files = [];
+  const globalNodes = /* @__PURE__ */ new Set();
+  for (const type of enabledTypes) {
+    const filePath = graphFilePath(memoryDir, type);
+    let exists = true;
+    let totalLines = 0;
+    let validEdges = 0;
+    let corruptLines = 0;
+    const nodes = /* @__PURE__ */ new Set();
+    try {
+      const raw = await readFile(filePath, "utf8");
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        totalLines += 1;
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (!isValidGraphEdge(parsed, type)) {
+            corruptLines += 1;
+            continue;
+          }
+          validEdges += 1;
+          nodes.add(parsed.from);
+          nodes.add(parsed.to);
+          globalNodes.add(parsed.from);
+          globalNodes.add(parsed.to);
+        } catch {
+          corruptLines += 1;
+        }
+      }
+    } catch {
+      exists = false;
+    }
+    files.push({
+      type,
+      filePath,
+      exists,
+      totalLines,
+      validEdges,
+      corruptLines,
+      uniqueNodes: nodes.size
+    });
+  }
+  const totals = files.reduce(
+    (acc, item) => {
+      acc.totalLines += item.totalLines;
+      acc.validEdges += item.validEdges;
+      acc.corruptLines += item.corruptLines;
+      return acc;
+    },
+    {
+      totalLines: 0,
+      validEdges: 0,
+      corruptLines: 0,
+      uniqueNodes: globalNodes.size
+    }
+  );
+  totals.uniqueNodes = globalNodes.size;
+  const report = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    enabledTypes,
+    totals,
+    files
+  };
+  if (options?.includeRepairGuidance === true) {
+    const guidance = [];
+    if (totals.corruptLines > 0) {
+      guidance.push("Corrupt graph lines detected: back up memory/state/graphs, then rebuild graphs from clean memory replay/extraction runs.");
+    }
+    if (totals.validEdges === 0) {
+      guidance.push("No valid edges detected yet: run normal extraction traffic (or replay ingestion) to seed graph files.");
+    }
+    if (guidance.length > 0) report.repairGuidance = guidance;
+  }
+  return report;
+}
+function detectCausalPhrase(text) {
+  const lower = text.toLowerCase();
+  for (const phrase of CAUSAL_PHRASES) {
+    if (lower.includes(phrase)) return phrase;
+  }
+  return null;
+}
+var GraphIndex = class _GraphIndex {
+  memoryDir;
+  cfg;
+  // Cache for readAllEdges() result.  With 30k+ entity edges (6 MB JSONL) the
+  // file read + JSON parse takes 2-4 s per call.  This instance-level cache
+  // eliminates that overhead on every spreadingActivation() call; it is
+  // invalidated (set to null) in onMemoryWritten() so new edges appear promptly.
+  edgeCache = null;
+  static EDGE_CACHE_TTL_MS = 3e5;
+  // 5 minutes
+  constructor(memoryDir, cfg) {
+    this.memoryDir = memoryDir;
+    this.cfg = cfg;
+  }
+  /** Clear the edge cache so the next spreadingActivation() re-reads from disk.
+   *  Call after any code path that appends edges outside of onMemoryWritten(). */
+  invalidateEdgeCache() {
+    this.edgeCache = null;
+  }
+  async loadEdgesCached() {
+    if (this.edgeCache && Date.now() - this.edgeCache.loadedAt < _GraphIndex.EDGE_CACHE_TTL_MS) {
+      return this.edgeCache.allEdges;
+    }
+    const allEdges = await readAllEdges(this.memoryDir, {
+      entityGraphEnabled: this.cfg.entityGraphEnabled,
+      timeGraphEnabled: this.cfg.timeGraphEnabled,
+      causalGraphEnabled: this.cfg.causalGraphEnabled
+    });
+    this.edgeCache = { allEdges, loadedAt: Date.now() };
+    return allEdges;
+  }
+  /**
+   * Called after a memory is written to disk.
+   *
+   * @param memoryPath - relative path from memoryDir (e.g. "facts/2026-02-22/abc.md")
+   * @param entityRef  - entityRef frontmatter field (if any)
+   * @param content    - full memory text (for causal detection)
+   * @param created    - ISO timestamp of this memory
+   * @param threadId   - current thread ID (for time graph)
+   * @param recentInThread - paths of the N most-recent memories in this thread (for time graph)
+   * @param entitySiblings - paths of other memories that share the same entityRef (for entity graph)
+   */
+  async onMemoryWritten(opts) {
+    if (!this.cfg.multiGraphMemoryEnabled) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      if (this.cfg.entityGraphEnabled && opts.entityRef && opts.entitySiblings?.length) {
+        const siblings = opts.entitySiblings.slice(0, this.cfg.maxEntityGraphEdgesPerMemory);
+        for (const sibling of siblings) {
+          await appendEdge(this.memoryDir, {
+            from: opts.memoryPath,
+            to: sibling,
+            type: "entity",
+            weight: 1,
+            label: opts.entityRef,
+            ts
+          });
+        }
+      }
+      if (this.cfg.timeGraphEnabled && opts.threadId && opts.recentInThread?.length) {
+        const predecessor = opts.recentInThread[opts.recentInThread.length - 1];
+        if (predecessor && predecessor !== opts.memoryPath) {
+          await appendEdge(this.memoryDir, {
+            from: predecessor,
+            to: opts.memoryPath,
+            type: "time",
+            weight: 1,
+            label: opts.threadId,
+            ts
+          });
+        }
+      }
+      if (this.cfg.causalGraphEnabled && opts.causalPredecessor) {
+        const phrase = detectCausalPhrase(opts.content);
+        if (phrase) {
+          await appendEdge(this.memoryDir, {
+            from: opts.causalPredecessor,
+            to: opts.memoryPath,
+            type: "causal",
+            weight: 1,
+            label: phrase,
+            ts
+          });
+        }
+      }
+    } catch (err) {
+      const { log } = await import("./logger-NZE2OBVA.js");
+      log.warn(`[graph] onMemoryWritten error: ${err}`);
+    } finally {
+      this.edgeCache = null;
+    }
+  }
+  /**
+   * Spreading activation BFS (SYNAPSE-inspired).
+   *
+   * Starting from `seeds`, traverse the combined graph for up to `maxSteps` hops.
+   * Each candidate gets an activation score = edge.weight × decay^hop.
+   * Returns top-N candidate paths sorted by descending activation score.
+   *
+   * @param seeds   - initial memory paths to expand from (e.g. QMD top results)
+   * @param maxSteps - max BFS hops (from config: maxGraphTraversalSteps)
+   * @returns Array of {path, score} sorted descending, not including seed paths
+   */
+  async spreadingActivation(seeds, maxSteps) {
+    if (!this.cfg.multiGraphMemoryEnabled) return [];
+    const steps = maxSteps ?? this.cfg.maxGraphTraversalSteps;
+    const decay = this.cfg.graphActivationDecay;
+    try {
+      const allEdges = await this.loadEdgesCached();
+      const adj = /* @__PURE__ */ new Map();
+      for (const edge of allEdges) {
+        if (!adj.has(edge.from)) adj.set(edge.from, []);
+        adj.get(edge.from).push(edge);
+        if (edge.type !== "causal") {
+          if (!adj.has(edge.to)) adj.set(edge.to, []);
+          adj.get(edge.to).push({ ...edge, from: edge.to, to: edge.from });
+        }
+      }
+      const seedSet = new Set(seeds);
+      const scores = /* @__PURE__ */ new Map();
+      const provenance = /* @__PURE__ */ new Map();
+      const visited = new Set(seeds);
+      const queue = seeds.map((s) => [s, 0, s]);
+      while (queue.length > 0) {
+        const [node, hop, sourceSeed] = queue.shift();
+        if (hop >= steps) continue;
+        const edges = adj.get(node) ?? [];
+        for (const edge of edges) {
+          const neighbor = edge.to === node ? edge.from : edge.to;
+          const score = edge.weight * Math.pow(decay, hop + 1);
+          if (!seedSet.has(neighbor)) {
+            const existing = scores.get(neighbor) ?? 0;
+            scores.set(neighbor, existing + score);
+            const prev = provenance.get(neighbor);
+            if (!prev || hop + 1 < prev.hopDepth || hop + 1 === prev.hopDepth && score > prev.decayedWeight) {
+              provenance.set(neighbor, {
+                seed: sourceSeed,
+                hopDepth: hop + 1,
+                decayedWeight: score,
+                graphType: edge.type
+              });
+            }
+          }
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push([neighbor, hop + 1, sourceSeed]);
+          }
+        }
+      }
+      if (this.cfg.graphLateralInhibitionEnabled && scores.size > 1) {
+        const inhibited = applyLateralInhibition(scores, {
+          beta: this.cfg.graphLateralInhibitionBeta,
+          topM: this.cfg.graphLateralInhibitionTopM
+        });
+        for (const [k, v] of inhibited) {
+          scores.set(k, v);
+        }
+      }
+      return Array.from(scores.entries()).map(([p, score]) => ({
+        path: p,
+        score,
+        seed: provenance.get(p)?.seed ?? "",
+        hopDepth: provenance.get(p)?.hopDepth ?? 0,
+        decayedWeight: provenance.get(p)?.decayedWeight ?? 0,
+        graphType: provenance.get(p)?.graphType ?? "entity"
+      })).sort((a, b) => b.score - a.score);
+    } catch (err) {
+      const { log } = await import("./logger-NZE2OBVA.js");
+      log.warn(`[graph] spreadingActivation error: ${err}`);
+      return [];
+    }
+  }
+};
+function applyLateralInhibition(scores, opts) {
+  const { beta, topM } = opts;
+  if (beta === 0 || topM === 0) return new Map(scores);
+  const sorted = Array.from(scores.entries()).sort((a, b) => b[1] - a[1]);
+  const topCompetitors = sorted.slice(0, topM);
+  const result = /* @__PURE__ */ new Map();
+  for (const [node, u] of scores) {
+    let inhibition = 0;
+    for (const [, uK] of topCompetitors) {
+      if (uK > u) {
+        inhibition += uK - u;
+      }
+    }
+    result.set(node, Math.max(0, u - beta * inhibition));
+  }
+  return result;
+}
+
+export {
+  appendEdge,
+  analyzeGraphHealth,
+  GraphIndex
+};