@joekytc/dsh-swarm 0.1.2 → 0.2.0

package/skills/llm-wiki-skill/packages/graph-engine/src/model/legacy-helpers.ts

@@ -0,0 +1,1379 @@
+// @ts-nocheck
+  var LABEL_CJK_WIDTH = 15;
+  var LABEL_LATIN_WIDTH = 8.5;
+  var LABEL_PADDING = 22;
+  var LABEL_MIN_WIDTH = 72;
+  var LABEL_MAX_WIDTH = 180;
+  var LABEL_ELLIPSIS = "…";
+  var LABEL_ELLIPSIS_WIDTH = 8;
+  var ATLAS_WORLD_WIDTH = 1000;
+  var ATLAS_WORLD_HEIGHT = 680;
+  var ATLAS_MIN_SCALE = 0.62;
+  var ATLAS_MAX_SCALE = 3.2;
+  var MINIMAP_VIEWBOX = { x: 5, y: 3, width: 150, height: 48 };
+
+  var labelSegmenter =
+    typeof Intl !== "undefined" && Intl.Segmenter
+      ? new Intl.Segmenter("zh", { granularity: "grapheme" })
+      : null;
+
+  function isVariationSelector(grapheme) {
+    var code = grapheme.codePointAt(0);
+    return code >= 0xFE00 && code <= 0xFE0F;
+  }
+
+  function isCombiningMark(grapheme) {
+    var code = grapheme.codePointAt(0);
+    return (code >= 0x0300 && code <= 0x036F)
+      || (code >= 0x1AB0 && code <= 0x1AFF)
+      || (code >= 0x1DC0 && code <= 0x1DFF)
+      || (code >= 0x20D0 && code <= 0x20FF)
+      || (code >= 0xFE20 && code <= 0xFE2F);
+  }
+
+  function isEmojiModifier(grapheme) {
+    var code = grapheme.codePointAt(0);
+    return code >= 0x1F3FB && code <= 0x1F3FF;
+  }
+
+  function splitLabelGraphemes(label) {
+    if (labelSegmenter) {
+      return Array.from(labelSegmenter.segment(label), function (s) {
+        return s.segment;
+      });
+    }
+
+    var parts = Array.from(label);
+    if (!parts.length) return [];
+
+    var graphemes = [parts[0]];
+    for (var i = 1; i < parts.length; i++) {
+      var current = parts[i];
+      var previous = parts[i - 1];
+      if (
+        current === "‍"
+        || previous === "‍"
+        || isVariationSelector(current)
+        || isCombiningMark(current)
+        || isEmojiModifier(current)
+      ) {
+        graphemes[graphemes.length - 1] += current;
+      } else {
+        graphemes.push(current);
+      }
+    }
+
+    return graphemes;
+  }
+
+  function labelCharWidth(grapheme) {
+    return /[一-鿿]/.test(grapheme) ? LABEL_CJK_WIDTH : LABEL_LATIN_WIDTH;
+  }
+
+  function measureLabelWidth(graphemes) {
+    var width = 0;
+    for (var i = 0; i < graphemes.length; i++) {
+      width += labelCharWidth(graphemes[i]);
+    }
+    return width;
+  }
+
+  function truncateLabel(label, maxWidth) {
+    if (!label || typeof label !== "string") {
+      return { text: "", truncated: false };
+    }
+
+    var graphemes = splitLabelGraphemes(label);
+    var totalWidth = measureLabelWidth(graphemes);
+    if (totalWidth + LABEL_PADDING <= maxWidth) {
+      return { text: label, truncated: false };
+    }
+
+    var out = "";
+    var width = 0;
+    for (var i = 0; i < graphemes.length; i++) {
+      var gw = labelCharWidth(graphemes[i]);
+      if (width + gw + LABEL_ELLIPSIS_WIDTH + LABEL_PADDING > maxWidth) break;
+      out += graphemes[i];
+      width += gw;
+    }
+    return { text: out + LABEL_ELLIPSIS, truncated: true };
+  }
+
+  function cardDims(n) {
+    var label = n.label || n.id;
+    var widthByLabel = measureLabelWidth(splitLabelGraphemes(label));
+    var width = Math.max(LABEL_MIN_WIDTH, Math.min(LABEL_MAX_WIDTH, widthByLabel + LABEL_PADDING));
+    var height = 36;
+    if (n.type === "topic") { height = 40; width += 6; }
+    if (n.type === "source") { height = 32; }
+    return { w: width, h: height };
+  }
+
+  function createSafeStorage(storage, logger) {
+    return {
+      get: function (key) {
+        try { return storage.getItem(key); }
+        catch (err) { if (logger) logger("[wiki] storage.get failed:", key, err); return null; }
+      },
+      set: function (key, value) {
+        try { storage.setItem(key, value); }
+        catch (err) { if (logger) logger("[wiki] storage.set failed:", key, err); }
+      }
+    };
+  }
+
+  function normalizeStorageSegment(value) {
+    return String(value == null ? "" : value)
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9一-鿿]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 48);
+  }
+
+  function hashString(value) {
+    var input = String(value == null ? "" : value);
+    var hash = 0;
+    for (var i = 0; i < input.length; i++) {
+      hash = ((hash << 5) - hash + input.charCodeAt(i)) >>> 0;
+    }
+    return hash.toString(36);
+  }
+
+  function getWikiStorageNamespace(meta, pathname) {
+    var title = normalizeStorageSegment(meta && meta.wiki_title ? meta.wiki_title : "");
+    var basis = typeof pathname === "string" && pathname
+      ? pathname
+      : (meta && meta.wiki_title) || title || "default";
+    return "llm-wiki:" + (title || "default") + ":" + hashString(basis);
+  }
+
+  function defaultQueue() {
+    return {
+      version: 1,
+      favorites: [],
+      notes: [],
+      recentNoteIds: []
+    };
+  }
+
+  function normalizeQueue(raw) {
+    if (!raw || typeof raw !== "object") return defaultQueue();
+    var d = defaultQueue();
+    var favorites = Array.isArray(raw.favorites) ? raw.favorites : d.favorites;
+    var notes = Array.isArray(raw.notes) ? raw.notes : d.notes;
+    var recentNoteIds = Array.isArray(raw.recentNoteIds) ? raw.recentNoteIds : d.recentNoteIds;
+    var seenFavorites = {};
+    var normalizedFavorites = favorites
+      .map(function (nodeId) {
+        return nodeId == null ? null : String(nodeId);
+      })
+      .filter(function (nodeId) {
+        if (!nodeId || seenFavorites[nodeId]) return false;
+        seenFavorites[nodeId] = true;
+        return true;
+      });
+    var normalizedNotes = notes
+      .map(function (note) {
+        if (!note || typeof note !== "object" || note.id == null || note.node_id == null) return null;
+        return {
+          id: String(note.id),
+          node_id: String(note.node_id),
+          label: note.label == null ? String(note.node_id) : String(note.label),
+          text: note.text == null ? "" : String(note.text),
+          created_at: note.created_at == null ? null : String(note.created_at)
+        };
+      })
+      .filter(function (note) {
+        return !!note;
+      });
+    var noteIdSet = {};
+    for (var i = 0; i < normalizedNotes.length; i++) {
+      noteIdSet[normalizedNotes[i].id] = true;
+    }
+    var seenRecent = {};
+    var normalizedRecentNoteIds = recentNoteIds
+      .map(function (noteId) {
+        return noteId == null ? null : String(noteId);
+      })
+      .filter(function (noteId) {
+        if (!noteId || !noteIdSet[noteId] || seenRecent[noteId]) return false;
+        seenRecent[noteId] = true;
+        return true;
+      });
+    if (!normalizedRecentNoteIds.length && normalizedNotes.length) {
+      normalizedRecentNoteIds = normalizedNotes.map(function (note) {
+        return note.id;
+      });
+    }
+    return {
+      version: d.version,
+      favorites: normalizedFavorites,
+      notes: normalizedNotes,
+      recentNoteIds: normalizedRecentNoteIds
+    };
+  }
+
+  function toggleQueueFavorite(queue, nodeId) {
+    var safe = normalizeQueue(queue);
+    var favoriteNodeId = nodeId == null ? "" : String(nodeId);
+    if (!favoriteNodeId) return safe;
+    var favorites = safe.favorites.slice();
+    var existingIndex = favorites.indexOf(favoriteNodeId);
+    if (existingIndex === -1) {
+      favorites.unshift(favoriteNodeId);
+    } else {
+      favorites.splice(existingIndex, 1);
+    }
+    return {
+      version: safe.version,
+      favorites: favorites,
+      notes: safe.notes.slice(),
+      recentNoteIds: safe.recentNoteIds.slice()
+    };
+  }
+
+  function appendQueueNote(queue, note, limit) {
+    var safe = normalizeQueue(queue);
+    if (!note || typeof note !== "object" || note.id == null || note.node_id == null) return safe;
+    var noteLimit = Number.isFinite(Number(limit)) ? Math.max(1, Math.round(Number(limit))) : 50;
+    var normalizedNote = {
+      id: String(note.id),
+      node_id: String(note.node_id),
+      label: note.label == null ? String(note.node_id) : String(note.label),
+      text: note.text == null ? "" : String(note.text),
+      created_at: note.created_at == null ? null : String(note.created_at)
+    };
+    var notes = [normalizedNote].concat(safe.notes.filter(function (item) {
+      return item.id !== normalizedNote.id;
+    })).slice(0, noteLimit);
+    var recentNoteIds = [normalizedNote.id].concat(safe.recentNoteIds.filter(function (noteId) {
+      return noteId !== normalizedNote.id;
+    })).slice(0, Math.min(noteLimit, 12));
+    return {
+      version: safe.version,
+      favorites: safe.favorites.slice(),
+      notes: notes,
+      recentNoteIds: recentNoteIds
+    };
+  }
+
+  function summarizeQueue(queue, nodesById, limit) {
+    var safe = normalizeQueue(queue);
+    var maxItems = Number.isFinite(Number(limit)) ? Math.max(1, Math.round(Number(limit))) : 4;
+    var byId = nodesById && typeof nodesById === "object" ? nodesById : {};
+    var notesById = {};
+    var recentItems = [];
+    var i;
+
+    for (i = 0; i < safe.notes.length; i++) {
+      notesById[safe.notes[i].id] = safe.notes[i];
+    }
+
+    for (i = 0; i < safe.recentNoteIds.length && recentItems.length < maxItems; i++) {
+      var note = notesById[safe.recentNoteIds[i]];
+      if (!note) continue;
+      var noteNode = byId[note.node_id];
+      recentItems.push({
+        kind: "note",
+        node_id: note.node_id,
+        label: note.label || (noteNode && (noteNode.label || noteNode.id)) || note.node_id,
+        text: note.text || ""
+      });
+    }
+
+    for (i = 0; i < safe.favorites.length && recentItems.length < maxItems; i++) {
+      var favoriteNodeId = safe.favorites[i];
+      var favoriteNode = byId[favoriteNodeId];
+      recentItems.push({
+        kind: "favorite",
+        node_id: favoriteNodeId,
+        label: favoriteNode && (favoriteNode.label || favoriteNode.id) ? (favoriteNode.label || favoriteNode.id) : favoriteNodeId,
+        text: ""
+      });
+    }
+
+    return {
+      favorite_count: safe.favorites.length,
+      note_count: safe.notes.length,
+      recent_items: recentItems
+    };
+  }
+
+  function defaultLearning() {
+    return {
+      version: 1,
+      entry: { recommended_start_node_id: null, recommended_start_reason: null, default_mode: "global" },
+      views: {
+        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
+        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
+        global: { enabled: true, node_ids: [], degraded: false }
+      },
+      communities: [],
+      degraded: { path_to_community: true, community_to_global: true }
+    };
+  }
+
+  function normalizeLearning(raw) {
+    if (!raw || typeof raw !== "object") return defaultLearning();
+    var d = defaultLearning();
+    function pick(obj, key, fallback) {
+      return obj && obj[key] != null ? obj[key] : fallback;
+    }
+    return {
+      version: pick(raw, "version", d.version),
+      entry: {
+        recommended_start_node_id: pick(raw.entry, "recommended_start_node_id", d.entry.recommended_start_node_id),
+        recommended_start_reason: pick(raw.entry, "recommended_start_reason", d.entry.recommended_start_reason),
+        default_mode: pick(raw.entry, "default_mode", d.entry.default_mode)
+      },
+      views: {
+        path: {
+          enabled: pick(raw.views && raw.views.path, "enabled", d.views.path.enabled),
+          start_node_id: pick(raw.views && raw.views.path, "start_node_id", d.views.path.start_node_id),
+          node_ids: Array.isArray(raw.views && raw.views.path && raw.views.path.node_ids) ? raw.views.path.node_ids : d.views.path.node_ids,
+          degraded: pick(raw.views && raw.views.path, "degraded", d.views.path.degraded)
+        },
+        community: {
+          enabled: pick(raw.views && raw.views.community, "enabled", d.views.community.enabled),
+          community_id: pick(raw.views && raw.views.community, "community_id", d.views.community.community_id),
+          label: pick(raw.views && raw.views.community, "label", d.views.community.label),
+          node_ids: Array.isArray(raw.views && raw.views.community && raw.views.community.node_ids) ? raw.views.community.node_ids : d.views.community.node_ids,
+          is_weak: pick(raw.views && raw.views.community, "is_weak", d.views.community.is_weak),
+          degraded: pick(raw.views && raw.views.community, "degraded", d.views.community.degraded)
+        },
+        global: {
+          enabled: pick(raw.views && raw.views.global, "enabled", d.views.global.enabled),
+          node_ids: Array.isArray(raw.views && raw.views.global && raw.views.global.node_ids) ? raw.views.global.node_ids : d.views.global.node_ids,
+          degraded: pick(raw.views && raw.views.global, "degraded", d.views.global.degraded)
+        }
+      },
+      communities: Array.isArray(raw.communities) ? raw.communities : d.communities,
+      degraded: {
+        path_to_community: pick(raw.degraded, "path_to_community", d.degraded.path_to_community),
+        community_to_global: pick(raw.degraded, "community_to_global", d.degraded.community_to_global)
+      }
+    };
+  }
+
+  function resolveInitialMode(learning) {
+    return "global";
+  }
+
+  function getCommunityNodeIds(nodes, communityId) {
+    if (!Array.isArray(nodes) || !communityId) return [];
+    return nodes
+      .filter(function (node) {
+        return node && node.community != null && String(node.community) === String(communityId);
+      })
+      .map(function (node) {
+        return node.id;
+      })
+      .sort();
+  }
+
+  function getVisibleNodeIds(learning, mode) {
+    if (!learning || !learning.views) return [];
+    var view = learning.views[mode];
+    if (!view || !view.enabled) return [];
+    return Array.isArray(view.node_ids) ? view.node_ids : [];
+  }
+
+  function getVisibleLinks(allLinks, visibleIds) {
+    if (!visibleIds || !visibleIds.length) return allLinks;
+    var idSet = {};
+    for (var i = 0; i < visibleIds.length; i++) idSet[visibleIds[i]] = true;
+    return allLinks.filter(function (l) {
+      var s = l.source.id || l.source;
+      var t = l.target.id || l.target;
+      return idSet[s] && idSet[t];
+    });
+  }
+
+  function buildSearchHaystack(node) {
+    return ((node && (node.label || node.id || "")) + "\n" + (((node && node.content) || "").slice(0, 500))).toLowerCase();
+  }
+
+  function buildSearchIndex(nodes) {
+    if (!Array.isArray(nodes)) return [];
+    return nodes.map(function (node) {
+      return { node: node, haystack: buildSearchHaystack(node) };
+    });
+  }
+
+  function filterLinksByTypes(allLinks, filters) {
+    if (!Array.isArray(allLinks)) return [];
+    if (!filters || typeof filters !== "object") return allLinks.slice();
+    return allLinks.filter(function (link) {
+      var type = link && link.type ? link.type : "EXTRACTED";
+      return filters[type] !== false;
+    });
+  }
+
+  function applySearchToNodeIds(searchIndex, query) {
+    if (!Array.isArray(searchIndex)) return [];
+    var normalizedQuery = typeof query === "string" ? query.trim().toLowerCase() : "";
+    var matches = !normalizedQuery
+      ? searchIndex
+      : searchIndex.filter(function (entry) {
+          return entry && typeof entry.haystack === "string" && entry.haystack.indexOf(normalizedQuery) !== -1;
+        });
+    return matches
+      .map(function (entry) {
+        return entry && entry.node ? entry.node.id : null;
+      })
+      .filter(function (id) {
+        return id != null;
+      });
+  }
+
+  function getLinkEndpointIds(link) {
+    return {
+      sourceId: link && link.source && link.source.id ? link.source.id : link && link.source,
+      targetId: link && link.target && link.target.id ? link.target.id : link && link.target
+    };
+  }
+
+  function sortNodeIdsByScore(nodeIds, scores, nodesById) {
+    return nodeIds.slice().sort(function (left, right) {
+      var scoreDiff = (scores[right] || 0) - (scores[left] || 0);
+      if (scoreDiff) return scoreDiff;
+      var leftDegree = nodesById[left] && Number.isFinite(Number(nodesById[left].degree)) ? Number(nodesById[left].degree) : 0;
+      var rightDegree = nodesById[right] && Number.isFinite(Number(nodesById[right].degree)) ? Number(nodesById[right].degree) : 0;
+      if (rightDegree !== leftDegree) return rightDegree - leftDegree;
+      return String(left).localeCompare(String(right));
+    });
+  }
+
+  function applyFocusMode(options) {
+    var safe = options && typeof options === "object" ? options : {};
+    var nodes = Array.isArray(safe.nodes) ? safe.nodes : [];
+    var links = Array.isArray(safe.links) ? safe.links : [];
+    var nodeIds = Array.isArray(safe.nodeIds) ? safe.nodeIds.slice() : [];
+    var mode = safe.mode || "all";
+    var anchorNodeId = safe.anchorNodeId != null ? String(safe.anchorNodeId) : null;
+    var highConfidenceThreshold = Number.isFinite(Number(safe.highConfidenceThreshold)) ? Number(safe.highConfidenceThreshold) : 0.75;
+    var nodesById = {};
+    var idSet = {};
+    var i;
+
+    for (i = 0; i < nodes.length; i++) {
+      if (nodes[i] && nodes[i].id != null) nodesById[nodes[i].id] = nodes[i];
+    }
+    for (i = 0; i < nodeIds.length; i++) idSet[nodeIds[i]] = true;
+
+    if (!nodeIds.length) return { node_ids: [], links: [] };
+
+    var scopedLinks = getVisibleLinks(links, nodeIds);
+    if (mode === "all") return { node_ids: nodeIds.slice(), links: scopedLinks };
+
+    if (mode === "high_confidence") {
+      var strongLinks = scopedLinks.filter(function (link) {
+        var weight = Number(link && link.weight);
+        return Number.isFinite(weight) && weight >= highConfidenceThreshold;
+      });
+      var strongIdSet = {};
+      for (i = 0; i < strongLinks.length; i++) {
+        var strongEdge = getLinkEndpointIds(strongLinks[i]);
+        if (idSet[strongEdge.sourceId]) strongIdSet[strongEdge.sourceId] = true;
+        if (idSet[strongEdge.targetId]) strongIdSet[strongEdge.targetId] = true;
+      }
+      if (anchorNodeId && idSet[anchorNodeId]) strongIdSet[anchorNodeId] = true;
+      var strongNodeIds = nodeIds.filter(function (id) {
+        return !!strongIdSet[id];
+      });
+      return { node_ids: strongNodeIds, links: getVisibleLinks(strongLinks, strongNodeIds) };
+    }
+
+    if (mode === "one_hop") {
+      var hopAnchorNodeId = anchorNodeId && idSet[anchorNodeId] ? anchorNodeId : nodeIds[0] || null;
+      if (!hopAnchorNodeId) return { node_ids: [], links: [] };
+      var hopIdSet = {};
+      hopIdSet[hopAnchorNodeId] = true;
+      for (i = 0; i < scopedLinks.length; i++) {
+        var hopEdge = getLinkEndpointIds(scopedLinks[i]);
+        if (hopEdge.sourceId === hopAnchorNodeId && idSet[hopEdge.targetId]) hopIdSet[hopEdge.targetId] = true;
+        if (hopEdge.targetId === hopAnchorNodeId && idSet[hopEdge.sourceId]) hopIdSet[hopEdge.sourceId] = true;
+      }
+      var hopNodeIds = nodeIds.filter(function (id) {
+        return !!hopIdSet[id];
+      });
+      return { node_ids: hopNodeIds, links: getVisibleLinks(scopedLinks, hopNodeIds) };
+    }
+
+    if (mode === "core") {
+      if (nodeIds.length <= 3) return { node_ids: nodeIds.slice(), links: scopedLinks };
+      var scores = {};
+      for (i = 0; i < nodeIds.length; i++) scores[nodeIds[i]] = 0;
+      for (i = 0; i < scopedLinks.length; i++) {
+        var coreEdge = getLinkEndpointIds(scopedLinks[i]);
+        var weight = Number(scopedLinks[i] && scopedLinks[i].weight);
+        var score = Number.isFinite(weight) ? 1 + weight : 1.5;
+        if (scores[coreEdge.sourceId] != null) scores[coreEdge.sourceId] += score;
+        if (scores[coreEdge.targetId] != null) scores[coreEdge.targetId] += score;
+      }
+      var coreLimit = Number.isFinite(Number(safe.coreLimit)) ? Number(safe.coreLimit) : Math.max(3, Math.min(8, Math.round(nodeIds.length * 0.5)));
+      coreLimit = Math.max(1, Math.min(nodeIds.length, Math.round(coreLimit)));
+      var coreNodeIds = sortNodeIdsByScore(nodeIds, scores, nodesById).slice(0, coreLimit);
+      return { node_ids: coreNodeIds, links: getVisibleLinks(scopedLinks, coreNodeIds) };
+    }
+
+    return { node_ids: nodeIds.slice(), links: scopedLinks };
+  }
+
+  function resolveVisibleSnapshot(options) {
+    var safe = options && typeof options === "object" ? options : {};
+    var nodes = Array.isArray(safe.nodes) ? safe.nodes : [];
+    var links = Array.isArray(safe.links) ? safe.links : [];
+    var baseNodeIds = Array.isArray(safe.baseNodeIds)
+      ? safe.baseNodeIds.slice()
+      : nodes.map(function (node) { return node.id; });
+    var filteredLinks = filterLinksByTypes(links, safe.filters);
+    var scopedLinks = getVisibleLinks(filteredLinks, baseNodeIds);
+    var focusResult = applyFocusMode({
+      mode: safe.focusMode,
+      nodes: nodes,
+      links: scopedLinks,
+      nodeIds: baseNodeIds,
+      anchorNodeId: safe.anchorNodeId,
+      highConfidenceThreshold: safe.highConfidenceThreshold,
+      coreLimit: safe.coreLimit
+    });
+    var focusNodeIds = focusResult.node_ids || [];
+    if (!focusNodeIds.length && safe.focusMode && safe.focusMode !== "all") {
+        return { node_ids: [], nodes: [], links: [], searchIndex: [] };
+    }
+    if (!focusNodeIds.length) focusNodeIds = baseNodeIds;
+    var focusNodes = nodes.filter(function (node) {
+      return focusNodeIds.indexOf(node.id) !== -1;
+    });
+    var searchIndex = buildSearchIndex(focusNodes);
+    var query = typeof safe.searchQuery === "string" ? safe.searchQuery.trim() : "";
+    var finalNodeIds = query ? applySearchToNodeIds(searchIndex, query) : focusNodeIds;
+    var idSet = {};
+    for (var i = 0; i < finalNodeIds.length; i++) idSet[finalNodeIds[i]] = true;
+    return {
+      node_ids: finalNodeIds,
+      nodes: nodes.filter(function (node) {
+        return !!idSet[node.id];
+      }),
+      links: finalNodeIds.length
+        ? getVisibleLinks(focusResult.links && focusResult.links.length ? focusResult.links : scopedLinks, finalNodeIds)
+        : [],
+      searchIndex: searchIndex
+    };
+  }
+
+  function shouldAutoOpenDrawer(mode) {
+    return mode === "path";
+  }
+
+  var ATLAS_CONFIDENCE_LABELS = {
+    EXTRACTED: "直接提取",
+    INFERRED: "推断关联",
+    AMBIGUOUS: "存在歧义",
+    UNVERIFIED: "未核实"
+  };
+
+  var ATLAS_TYPE_LABELS = {
+    topic: "主题",
+    entity: "实体",
+    source: "来源",
+    comparison: "对比",
+    synthesis: "综合",
+    query: "查询"
+  };
+
+  var ATLAS_TYPE_KINDS = {
+    topic: "TOPIC",
+    entity: "ENTITY",
+    source: "SOURCE",
+    comparison: "COMPARISON",
+    synthesis: "SYNTHESIS",
+    query: "QUERY"
+  };
+
+  function normalizeAtlasType(type) {
+    var normalized = String(type || "entity").toLowerCase();
+    return ATLAS_TYPE_LABELS[normalized] ? normalized : "entity";
+  }
+
+  function normalizeAtlasConfidence(confidence) {
+    var normalized = String(confidence || "EXTRACTED").toUpperCase();
+    return ATLAS_CONFIDENCE_LABELS[normalized] ? normalized : "EXTRACTED";
+  }
+
+  function atlasConfidenceLabel(confidence) {
+    var normalized = normalizeAtlasConfidence(confidence);
+    return ATLAS_CONFIDENCE_LABELS[normalized];
+  }
+
+  function normalizeAtlasRelationType(relationType) {
+    var normalized = String(relationType || "依赖").trim();
+    return normalized || "依赖";
+  }
+
+  function atlasTypeLabel(type) {
+    var normalized = normalizeAtlasType(type);
+    return ATLAS_TYPE_LABELS[normalized];
+  }
+
+  function atlasNodeKind(type) {
+    var normalized = normalizeAtlasType(type);
+    return ATLAS_TYPE_KINDS[normalized];
+  }
+
+  function clampAtlasNumber(value, fallback, min, max) {
+    var numeric = Number(value);
+    if (!Number.isFinite(numeric)) numeric = fallback;
+    if (Number.isFinite(Number(min))) numeric = Math.max(Number(min), numeric);
+    if (Number.isFinite(Number(max))) numeric = Math.min(Number(max), numeric);
+    return numeric;
+  }
+
+  function normalizeAtlasViewportSize(size) {
+    var safe = size && typeof size === "object" ? size : {};
+    return {
+      width: clampAtlasNumber(safe.width, ATLAS_WORLD_WIDTH, 1, 100000),
+      height: clampAtlasNumber(safe.height, ATLAS_WORLD_HEIGHT, 1, 100000)
+    };
+  }
+
+  function normalizeAtlasViewport(viewport) {
+    var safe = viewport && typeof viewport === "object" ? viewport : {};
+    return {
+      x: clampAtlasNumber(safe.x, 0, -1000000, 1000000),
+      y: clampAtlasNumber(safe.y, 0, -1000000, 1000000),
+      scale: clampAtlasNumber(safe.scale, 1, ATLAS_MIN_SCALE, ATLAS_MAX_SCALE)
+    };
+  }
+
+  function atlasNodePoint(node) {
+    var safe = node && typeof node === "object" ? node : {};
+    return {
+      x: clampAtlasNumber(safe.x, 50, 0, 100) / 100 * ATLAS_WORLD_WIDTH,
+      y: clampAtlasNumber(safe.y, 50, 0, 100) / 100 * ATLAS_WORLD_HEIGHT
+    };
+  }
+
+  function getAtlasModelBounds(nodes, padding) {
+    var list = Array.isArray(nodes) ? nodes : [];
+    var pad = Number.isFinite(Number(padding)) ? Math.max(0, Number(padding)) : 48;
+    if (!list.length) {
+      return {
+        x: 0,
+        y: 0,
+        width: ATLAS_WORLD_WIDTH,
+        height: ATLAS_WORLD_HEIGHT,
+        minX: 0,
+        minY: 0,
+        maxX: ATLAS_WORLD_WIDTH,
+        maxY: ATLAS_WORLD_HEIGHT
+      };
+    }
+
+    var minX = ATLAS_WORLD_WIDTH;
+    var minY = ATLAS_WORLD_HEIGHT;
+    var maxX = 0;
+    var maxY = 0;
+    list.forEach(function (node) {
+      var point = atlasNodePoint(node);
+      minX = Math.min(minX, point.x);
+      minY = Math.min(minY, point.y);
+      maxX = Math.max(maxX, point.x);
+      maxY = Math.max(maxY, point.y);
+    });
+
+    minX = clampAtlasNumber(minX - pad, 0, 0, ATLAS_WORLD_WIDTH);
+    minY = clampAtlasNumber(minY - pad, 0, 0, ATLAS_WORLD_HEIGHT);
+    maxX = clampAtlasNumber(maxX + pad, ATLAS_WORLD_WIDTH, 0, ATLAS_WORLD_WIDTH);
+    maxY = clampAtlasNumber(maxY + pad, ATLAS_WORLD_HEIGHT, 0, ATLAS_WORLD_HEIGHT);
+
+    return {
+      x: minX,
+      y: minY,
+      width: Math.max(1, maxX - minX),
+      height: Math.max(1, maxY - minY),
+      minX: minX,
+      minY: minY,
+      maxX: maxX,
+      maxY: maxY
+    };
+  }
+
+  function clampAtlasViewport(viewport, viewportSize, options) {
+    var size = normalizeAtlasViewportSize(viewportSize);
+    var safe = normalizeAtlasViewport(viewport);
+    var opts = options && typeof options === "object" ? options : {};
+    var minScale = clampAtlasNumber(opts.minScale, ATLAS_MIN_SCALE, 0.1, ATLAS_MAX_SCALE);
+    var maxScale = clampAtlasNumber(opts.maxScale, ATLAS_MAX_SCALE, minScale, 10);
+    var marginX = clampAtlasNumber(opts.marginX, size.width * 0.38, 0, size.width);
+    var marginY = clampAtlasNumber(opts.marginY, size.height * 0.38, 0, size.height);
+    var scale = clampAtlasNumber(safe.scale, 1, minScale, maxScale);
+    var scaledWidth = size.width * scale;
+    var scaledHeight = size.height * scale;
+    var minX = size.width - scaledWidth - marginX;
+    var maxX = marginX;
+    var minY = size.height - scaledHeight - marginY;
+    var maxY = marginY;
+
+    if (scaledWidth <= size.width) {
+      var centerX = (size.width - scaledWidth) / 2;
+      minX = centerX - marginX;
+      maxX = centerX + marginX;
+    }
+    if (scaledHeight <= size.height) {
+      var centerY = (size.height - scaledHeight) / 2;
+      minY = centerY - marginY;
+      maxY = centerY + marginY;
+    }
+
+    return {
+      x: clampAtlasNumber(safe.x, 0, minX, maxX),
+      y: clampAtlasNumber(safe.y, 0, minY, maxY),
+      scale: scale
+    };
+  }
+
+  function fitAtlasViewport(bounds, viewportSize, options) {
+    var safeBounds = bounds && typeof bounds === "object" ? bounds : getAtlasModelBounds([]);
+    var size = normalizeAtlasViewportSize(viewportSize);
+    var opts = options && typeof options === "object" ? options : {};
+    var padding = clampAtlasNumber(opts.padding, 0.84, 0.2, 1);
+    var minScale = clampAtlasNumber(opts.minScale, ATLAS_MIN_SCALE, 0.1, ATLAS_MAX_SCALE);
+    var maxScale = clampAtlasNumber(opts.maxScale, 2.15, minScale, ATLAS_MAX_SCALE);
+    var widthScale = ATLAS_WORLD_WIDTH * padding / Math.max(1, safeBounds.width || 1);
+    var heightScale = ATLAS_WORLD_HEIGHT * padding / Math.max(1, safeBounds.height || 1);
+    var scale = clampAtlasNumber(Math.min(widthScale, heightScale), 1, minScale, maxScale);
+    var centerX = (safeBounds.minX != null && safeBounds.maxX != null)
+      ? (safeBounds.minX + safeBounds.maxX) / 2
+      : (safeBounds.x || 0) + (safeBounds.width || ATLAS_WORLD_WIDTH) / 2;
+    var centerY = (safeBounds.minY != null && safeBounds.maxY != null)
+      ? (safeBounds.minY + safeBounds.maxY) / 2
+      : (safeBounds.y || 0) + (safeBounds.height || ATLAS_WORLD_HEIGHT) / 2;
+
+    return clampAtlasViewport({
+      x: size.width / 2 - scale * (centerX / ATLAS_WORLD_WIDTH * size.width),
+      y: size.height / 2 - scale * (centerY / ATLAS_WORLD_HEIGHT * size.height),
+      scale: scale
+    }, size, opts);
+  }
+
+  function centerAtlasViewportOnPoint(point, viewportSize, scale, options) {
+    var safePoint = point && typeof point === "object" ? point : { x: ATLAS_WORLD_WIDTH / 2, y: ATLAS_WORLD_HEIGHT / 2 };
+    var size = normalizeAtlasViewportSize(viewportSize);
+    var viewportScale = clampAtlasNumber(scale, 1, ATLAS_MIN_SCALE, ATLAS_MAX_SCALE);
+    return clampAtlasViewport({
+      x: size.width / 2 - viewportScale * (safePoint.x / ATLAS_WORLD_WIDTH * size.width),
+      y: size.height / 2 - viewportScale * (safePoint.y / ATLAS_WORLD_HEIGHT * size.height),
+      scale: viewportScale
+    }, size, options);
+  }
+
+  function zoomAtlasViewport(viewport, factor, screenPoint, viewportSize, options) {
+    var size = normalizeAtlasViewportSize(viewportSize);
+    var safe = normalizeAtlasViewport(viewport);
+    var point = screenPoint && typeof screenPoint === "object"
+      ? { x: clampAtlasNumber(screenPoint.x, size.width / 2, 0, size.width), y: clampAtlasNumber(screenPoint.y, size.height / 2, 0, size.height) }
+      : { x: size.width / 2, y: size.height / 2 };
+    var zoomFactor = clampAtlasNumber(factor, 1, 0.2, 5);
+    var opts = options && typeof options === "object" ? options : {};
+    var minScale = clampAtlasNumber(opts.minScale, ATLAS_MIN_SCALE, 0.1, ATLAS_MAX_SCALE);
+    var maxScale = clampAtlasNumber(opts.maxScale, ATLAS_MAX_SCALE, minScale, 10);
+    var nextScale = clampAtlasNumber(safe.scale * zoomFactor, safe.scale, minScale, maxScale);
+    var ratio = nextScale / safe.scale;
+    return clampAtlasViewport({
+      x: point.x - (point.x - safe.x) * ratio,
+      y: point.y - (point.y - safe.y) * ratio,
+      scale: nextScale
+    }, size, opts);
+  }
+
+  function atlasViewportRect(viewport, viewportSize) {
+    var size = normalizeAtlasViewportSize(viewportSize);
+    var safe = normalizeAtlasViewport(viewport);
+    var x = (0 - safe.x) / safe.scale / size.width * ATLAS_WORLD_WIDTH;
+    var y = (0 - safe.y) / safe.scale / size.height * ATLAS_WORLD_HEIGHT;
+    var width = size.width / safe.scale / size.width * ATLAS_WORLD_WIDTH;
+    var height = size.height / safe.scale / size.height * ATLAS_WORLD_HEIGHT;
+    var minX = clampAtlasNumber(x, 0, 0, ATLAS_WORLD_WIDTH);
+    var minY = clampAtlasNumber(y, 0, 0, ATLAS_WORLD_HEIGHT);
+    var maxX = clampAtlasNumber(x + width, ATLAS_WORLD_WIDTH, 0, ATLAS_WORLD_WIDTH);
+    var maxY = clampAtlasNumber(y + height, ATLAS_WORLD_HEIGHT, 0, ATLAS_WORLD_HEIGHT);
+    return {
+      x: minX,
+      y: minY,
+      width: Math.max(1, maxX - minX),
+      height: Math.max(1, maxY - minY),
+      minX: minX,
+      minY: minY,
+      maxX: maxX,
+      maxY: maxY
+    };
+  }
+
+  function atlasPointToMinimap(point) {
+    var safePoint = point && typeof point === "object" ? point : { x: 0, y: 0 };
+    return {
+      x: MINIMAP_VIEWBOX.x + clampAtlasNumber(safePoint.x, 0, 0, ATLAS_WORLD_WIDTH) / ATLAS_WORLD_WIDTH * MINIMAP_VIEWBOX.width,
+      y: MINIMAP_VIEWBOX.y + clampAtlasNumber(safePoint.y, 0, 0, ATLAS_WORLD_HEIGHT) / ATLAS_WORLD_HEIGHT * MINIMAP_VIEWBOX.height
+    };
+  }
+
+  function minimapPointToAtlasPoint(point) {
+    var safePoint = point && typeof point === "object" ? point : { x: MINIMAP_VIEWBOX.x, y: MINIMAP_VIEWBOX.y };
+    return {
+      x: clampAtlasNumber((safePoint.x - MINIMAP_VIEWBOX.x) / MINIMAP_VIEWBOX.width * ATLAS_WORLD_WIDTH, 0, 0, ATLAS_WORLD_WIDTH),
+      y: clampAtlasNumber((safePoint.y - MINIMAP_VIEWBOX.y) / MINIMAP_VIEWBOX.height * ATLAS_WORLD_HEIGHT, 0, 0, ATLAS_WORLD_HEIGHT)
+    };
+  }
+
+  function atlasViewportToMinimapRect(viewport, viewportSize) {
+    var rect = atlasViewportRect(viewport, viewportSize);
+    var topLeft = atlasPointToMinimap({ x: rect.x, y: rect.y });
+    var bottomRight = atlasPointToMinimap({ x: rect.x + rect.width, y: rect.y + rect.height });
+    return {
+      x: topLeft.x,
+      y: topLeft.y,
+      width: Math.max(2, bottomRight.x - topLeft.x),
+      height: Math.max(2, bottomRight.y - topLeft.y)
+    };
+  }
+
+  function atlasEndpointId(value) {
+    if (value && typeof value === "object" && value.id != null) return String(value.id);
+    return value == null ? "" : String(value);
+  }
+
+  function stripAtlasMarkdown(raw) {
+    return String(raw || "")
+      .replace(/^---[\s\S]*?---\s*/m, "")
+      .replace(/```[\s\S]*?```/g, " ")
+      .replace(/!\[[^\]]*\]\([^)]+\)/g, " ")
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+      .replace(/\[\[([^\]|]+)\|?([^\]]*)\]\]/g, function (_, target, label) {
+        return label || target;
+      })
+      .replace(/^#{1,6}\s+/gm, "")
+      .replace(/^[-*+]\s+/gm, "")
+      .replace(/^\d+\.\s+/gm, "")
+      .replace(/[*_`>#]/g, "")
+      .replace(/\s+/g, " ")
+      .trim();
+  }
+
+  function deriveAtlasSummary(node, content) {
+    var explicitSummary = node && node.summary != null ? String(node.summary).trim() : "";
+    if (explicitSummary) return explicitSummary.length > 170 ? explicitSummary.slice(0, 170).trim() + "…" : explicitSummary;
+    var summarySource = String(content || (node && node.content) || "").replace(/^#\s+.*(?:\r?\n)+/, "");
+    var stripped = stripAtlasMarkdown(summarySource);
+    if (!stripped) return "";
+    return stripped.length > 170 ? stripped.slice(0, 170).trim() + "…" : stripped;
+  }
+
+  function normalizeAtlasNode(rawNode, index) {
+    var raw = rawNode && typeof rawNode === "object" ? rawNode : {};
+    var id = raw.id == null ? "node-" + index : String(raw.id);
+    var label = raw.label == null || String(raw.label).trim() === "" ? id : String(raw.label).trim();
+    var content = raw.content == null ? "" : String(raw.content);
+    var type = normalizeAtlasType(raw.type);
+    var community = raw.community == null || raw.community === "" ? "_none" : String(raw.community);
+    var x = Number(raw.x);
+    var y = Number(raw.y);
+    var hasX = (typeof raw.x === "number" || (typeof raw.x === "string" && raw.x.trim() !== "")) && Number.isFinite(x);
+    var hasY = (typeof raw.y === "number" || (typeof raw.y === "string" && raw.y.trim() !== "")) && Number.isFinite(y);
+    return {
+      id: id,
+      label: label,
+      type: type,
+      type_label: atlasTypeLabel(type),
+      kind: atlasNodeKind(type),
+      community: community,
+      source_path: raw.source_path || raw.source || raw.path || "",
+      confidence: normalizeAtlasConfidence(raw.confidence || raw.type_confidence),
+      confidence_label: atlasConfidenceLabel(raw.confidence || raw.type_confidence),
+      content: content,
+      summary: deriveAtlasSummary(raw, content),
+      unavailable: raw.unavailable === true || raw.available === false,
+      degree: 0,
+      weight: clampAtlasNumber(raw.weight != null ? raw.weight : raw.score, 50, 0, 100),
+      priority: 0,
+      idx: index,
+      x: hasX ? x : null,
+      y: hasY ? y : null
+    };
+  }
+
+  function normalizeAtlasEdge(rawEdge, index) {
+    var raw = rawEdge && typeof rawEdge === "object" ? rawEdge : {};
+    var sourceId = atlasEndpointId(raw.from != null ? raw.from : raw.source);
+    var targetId = atlasEndpointId(raw.to != null ? raw.to : raw.target);
+    var confidence = normalizeAtlasConfidence(raw.confidence || raw.type || raw.type_confidence);
+    return {
+      id: raw.id == null ? "edge-" + index : String(raw.id),
+      source: sourceId,
+      target: targetId,
+      from: sourceId,
+      to: targetId,
+      type: confidence,
+      confidence: confidence,
+      confidence_label: atlasConfidenceLabel(confidence),
+      relation_type: normalizeAtlasRelationType(raw.relation_type || raw.relationship_type || raw.relation),
+      weight: clampAtlasNumber(raw.weight, 0.6, 0, 1),
+      signals: raw.signals && typeof raw.signals === "object" ? raw.signals : {},
+      source_signal_available: raw.source_signal_available === true
+    };
+  }
+
+  function buildAtlasSearchHaystack(node) {
+    return [
+      node && node.label,
+      node && node.id,
+      node && node.type_label,
+      node && node.source_path,
+      node && node.summary,
+      node && stripAtlasMarkdown(node.content)
+    ].join("\n").toLowerCase();
+  }
+
+  function buildAtlasSearchIndex(nodes) {
+    if (!Array.isArray(nodes)) return [];
+    return nodes.map(function (node) {
+      return { node: node, haystack: buildAtlasSearchHaystack(node) };
+    });
+  }
+
+  function deriveAtlasCommunities(rawGraph, nodes, communityById) {
+    var learning = normalizeLearning(rawGraph && rawGraph.learning);
+    var fromLearning = Array.isArray(learning.communities) ? learning.communities : [];
+    var communities = [];
+    var seen = {};
+
+    fromLearning.forEach(function (community) {
+      if (!community || community.id == null) return;
+      var id = String(community.id);
+      var derived = communityById[id] || { nodes: [] };
+      seen[id] = true;
+      communities.push({
+        id: id,
+        label: community.label || id,
+        node_count: Number.isFinite(Number(community.node_count)) ? Number(community.node_count) : derived.nodes.length,
+        source_count: Number.isFinite(Number(community.source_count)) ? Number(community.source_count) : 0,
+        is_primary: community.is_primary === true,
+        recommended_start_node_id: community.recommended_start_node_id || null,
+        color_index: communities.length
+      });
+    });
+
+    Object.keys(communityById).sort().forEach(function (id) {
+      if (seen[id]) return;
+      var group = communityById[id];
+      var topic = group.nodes.find(function (node) { return node.type === "topic"; });
+      communities.push({
+        id: id,
+        label: id === "_none" ? "未分组" : (topic && topic.label) || id,
+        node_count: group.nodes.length,
+        source_count: group.nodes.filter(function (node) { return node.type === "source"; }).length,
+        is_primary: communities.length === 0,
+        recommended_start_node_id: null,
+        color_index: communities.length
+      });
+    });
+
+    communities.sort(function (left, right) {
+      if (!!right.is_primary !== !!left.is_primary) return right.is_primary ? 1 : -1;
+      if ((right.node_count || 0) !== (left.node_count || 0)) return (right.node_count || 0) - (left.node_count || 0);
+      return String(left.label || left.id).localeCompare(String(right.label || right.id));
+    });
+    communities.forEach(function (community, index) {
+      community.color_index = index;
+    });
+    return communities;
+  }
+
+  function buildAtlasStarts(rawGraph, nodes, byId, communities) {
+    var starts = [];
+    var seen = {};
+    function add(id, reason) {
+      if (id == null) return;
+      var nodeId = String(id);
+      if (!byId[nodeId] || seen[nodeId]) return;
+      seen[nodeId] = true;
+      starts.push({ node: byId[nodeId], reason: reason || "" });
+    }
+    var learning = normalizeLearning(rawGraph && rawGraph.learning);
+    add(learning.entry && learning.entry.recommended_start_node_id, "全局推荐起点");
+    communities.forEach(function (community) {
+      add(community.recommended_start_node_id, community.label + " · 推荐起点");
+    });
+    nodes.slice().sort(function (left, right) {
+      return (right.priority || 0) - (left.priority || 0);
+    }).forEach(function (node) {
+      if (starts.length < 6) add(node.id, atlasTypeLabel(node.type) + " · " + atlasConfidenceLabel(node.confidence));
+    });
+    return starts.slice(0, 6);
+  }
+
+  function normalizeAtlasInsights(insights) {
+    var safe = insights && typeof insights === "object" ? insights : {};
+    return {
+      surprising_connections: Array.isArray(safe.surprising_connections) ? safe.surprising_connections : [],
+      isolated_nodes: Array.isArray(safe.isolated_nodes) ? safe.isolated_nodes : [],
+      bridge_nodes: Array.isArray(safe.bridge_nodes) ? safe.bridge_nodes : [],
+      sparse_communities: Array.isArray(safe.sparse_communities) ? safe.sparse_communities : [],
+      meta: safe.meta && typeof safe.meta === "object" ? safe.meta : { degraded: false }
+    };
+  }
+
+  function buildAtlasModel(rawGraph) {
+    var raw = rawGraph && typeof rawGraph === "object" ? rawGraph : {};
+    var nodes = Array.isArray(raw.nodes) ? raw.nodes.map(normalizeAtlasNode) : [];
+    var byId = {};
+    var communityById = {};
+    nodes.forEach(function (node) {
+      byId[node.id] = node;
+      if (!communityById[node.community]) communityById[node.community] = { id: node.community, nodes: [] };
+      communityById[node.community].nodes.push(node);
+    });
+
+    var edges = (Array.isArray(raw.edges) ? raw.edges : [])
+      .map(normalizeAtlasEdge)
+      .filter(function (edge) {
+        return !!(byId[edge.source] && byId[edge.target]);
+      });
+
+    edges.forEach(function (edge) {
+      byId[edge.source].degree += 1;
+      byId[edge.target].degree += 1;
+    });
+    nodes.forEach(function (node) {
+      node.priority = node.degree * 12 + node.weight + (node.type === "topic" ? 12 : node.type === "source" ? 6 : 0);
+    });
+
+    var communities = deriveAtlasCommunities(raw, nodes, communityById);
+    var communityMap = {};
+    communities.forEach(function (community) {
+      communityMap[community.id] = community;
+    });
+
+    return {
+      meta: {
+        wiki_title: raw.meta && raw.meta.wiki_title ? String(raw.meta.wiki_title) : "知识库",
+        total_nodes: nodes.length,
+        total_edges: edges.length,
+        build_date: raw.meta && raw.meta.build_date ? String(raw.meta.build_date) : ""
+      },
+      nodes: nodes,
+      edges: edges,
+      byId: byId,
+      communities: communities,
+      communityById: communityMap,
+      starts: buildAtlasStarts(raw, nodes, byId, communities),
+      searchIndex: buildAtlasSearchIndex(nodes),
+      insights: normalizeAtlasInsights(raw.insights)
+    };
+  }
+
+  function deriveAtlasLayout(model) {
+    var safe = model && typeof model === "object" ? model : { nodes: [], communities: [] };
+    var centers = [
+      { x: 50, y: 48 },
+      { x: 30, y: 34 },
+      { x: 70, y: 36 },
+      { x: 30, y: 72 },
+      { x: 72, y: 70 },
+      { x: 18, y: 52 },
+      { x: 84, y: 52 },
+      { x: 50, y: 78 }
+    ];
+    var communityIndex = {};
+    (safe.communities || []).forEach(function (community, index) {
+      communityIndex[community.id] = index;
+    });
+    var grouped = {};
+    (safe.nodes || []).forEach(function (node) {
+      if (!grouped[node.community]) grouped[node.community] = [];
+      grouped[node.community].push(node);
+    });
+    Object.keys(grouped).forEach(function (communityId) {
+      grouped[communityId].sort(function (left, right) {
+        return (right.priority || 0) - (left.priority || 0);
+      });
+      var center = centers[(communityIndex[communityId] || 0) % centers.length];
+      var count = grouped[communityId].length;
+      grouped[communityId].forEach(function (node, index) {
+        if (node.x != null && node.y != null && Number.isFinite(Number(node.x)) && Number.isFinite(Number(node.y))) {
+          node.x = clampAtlasNumber(node.x, center.x, 5, 95);
+          node.y = clampAtlasNumber(node.y, center.y, 8, 92);
+          return;
+        }
+        var ring = Math.floor(index / 8);
+        var ringIndex = index % 8;
+        var angle = ((ringIndex / Math.min(8, Math.max(1, count))) * Math.PI * 2) + ring * 0.42;
+        var radiusX = 7 + ring * 5 + Math.min(5, count * 0.16);
+        var radiusY = 5 + ring * 4 + Math.min(4, count * 0.12);
+        node.x = clampAtlasNumber(center.x + Math.cos(angle) * radiusX, center.x, 5, 95);
+        node.y = clampAtlasNumber(center.y + Math.sin(angle) * radiusY, center.y, 8, 92);
+      });
+    });
+    return {
+      nodes: (safe.nodes || []).slice(),
+      edges: (safe.edges || []).slice(),
+      nodePositions: (safe.nodes || []).reduce(function (out, node) {
+        out[node.id] = { x: node.x, y: node.y };
+        return out;
+      }, {})
+    };
+  }
+
+  function getAtlasDensityMode(count) {
+    var nodeCount = Number.isFinite(Number(count)) ? Number(count) : 0;
+    if (nodeCount > 500) return "overview";
+    if (nodeCount > 200) return "point-plus-focus";
+    if (nodeCount > 80) return "compact-card";
+    return "card";
+  }
+
+  function atlasLabelBudget(mode, count) {
+    if (mode === "overview") return 40;
+    if (mode === "point-plus-focus") return 60;
+    if (mode === "compact-card") return Math.min(120, count);
+    return count;
+  }
+
+  function atlasEdgeBudget(mode, count) {
+    if (mode === "overview") return 1000;
+    if (mode === "point-plus-focus") return 800;
+    return count;
+  }
+
+  function resolveAtlasVisibleSnapshot(model, layout, uiState) {
+    var safeModel = model && typeof model === "object" ? model : buildAtlasModel({});
+    var safeUI = uiState && typeof uiState === "object" ? uiState : {};
+    var activeCommunityId = safeUI.activeCommunityId == null ? "all" : String(safeUI.activeCommunityId);
+    var query = typeof safeUI.query === "string" ? safeUI.query.trim().toLowerCase() : "";
+    var focusMode = safeUI.focusMode || "all";
+    var selectedNodeId = safeUI.selectedNodeId == null ? null : String(safeUI.selectedNodeId);
+    var filters = safeUI.filters && typeof safeUI.filters === "object" ? safeUI.filters : {};
+
+    var baseNodes = safeModel.nodes.filter(function (node) {
+      if (activeCommunityId !== "all" && node.community !== activeCommunityId) return false;
+      if (focusMode === "source" && node.type !== "source") return false;
+      return true;
+    });
+
+    if (focusMode === "core" && baseNodes.length > 8) {
+      var keepCount = Math.max(8, Math.ceil(baseNodes.length * 0.45));
+      var keep = {};
+      baseNodes.slice().sort(function (left, right) {
+        return (right.priority || 0) - (left.priority || 0);
+      }).slice(0, keepCount).forEach(function (node) {
+        keep[node.id] = true;
+      });
+      if (selectedNodeId && safeModel.byId[selectedNodeId]) keep[selectedNodeId] = true;
+      baseNodes = baseNodes.filter(function (node) { return !!keep[node.id]; });
+    }
+
+    var baseIdSet = {};
+    baseNodes.forEach(function (node) { baseIdSet[node.id] = true; });
+    var searchIndex = buildAtlasSearchIndex(baseNodes);
+    var matchedIds = {};
+    var visibleNodes = !query
+      ? baseNodes
+      : searchIndex.filter(function (entry) {
+          return entry.haystack.indexOf(query) !== -1;
+        }).map(function (entry) {
+          matchedIds[entry.node.id] = true;
+          return entry.node;
+        });
+    var visibleIdSet = {};
+    visibleNodes.forEach(function (node) { visibleIdSet[node.id] = true; });
+
+    var visibleEdges = safeModel.edges.filter(function (edge) {
+      var edgeType = edge.type || "EXTRACTED";
+      if (filters[edgeType] === false) return false;
+      return !!(visibleIdSet[edge.source] && visibleIdSet[edge.target]);
+    });
+
+    var densityMode = getAtlasDensityMode(visibleNodes.length);
+    var labelBudget = atlasLabelBudget(densityMode, visibleNodes.length);
+    var labelNodeIds = {};
+    var startNodeIds = {};
+    var importantNodeIds = {};
+    var visibleStartEntries = safeModel.starts.filter(function (entry) {
+      return !!(entry && entry.node && visibleIdSet[entry.node.id]) &&
+        (activeCommunityId === "all" || entry.node.community === activeCommunityId);
+    });
+
+    visibleStartEntries.forEach(function (entry) {
+      startNodeIds[entry.node.id] = true;
+      importantNodeIds[entry.node.id] = true;
+    });
+
+    visibleNodes.slice().sort(function (left, right) {
+      return (right.priority || 0) - (left.priority || 0);
+    }).slice(0, Math.max(0, Math.min(8, Math.ceil(visibleNodes.length * 0.08)))).forEach(function (node) {
+      importantNodeIds[node.id] = true;
+    });
+
+    visibleNodes.slice().sort(function (left, right) {
+      var leftForced = (selectedNodeId === left.id || matchedIds[left.id] || importantNodeIds[left.id]) ? 1 : 0;
+      var rightForced = (selectedNodeId === right.id || matchedIds[right.id] || importantNodeIds[right.id]) ? 1 : 0;
+      if (rightForced !== leftForced) return rightForced - leftForced;
+      return (right.priority || 0) - (left.priority || 0);
+    }).slice(0, labelBudget).forEach(function (node) {
+      labelNodeIds[node.id] = true;
+    });
+    if (selectedNodeId && visibleIdSet[selectedNodeId]) labelNodeIds[selectedNodeId] = true;
+    Object.keys(matchedIds).forEach(function (id) {
+      if (visibleIdSet[id]) {
+        labelNodeIds[id] = true;
+        importantNodeIds[id] = true;
+      }
+    });
+    Object.keys(startNodeIds).forEach(function (id) {
+      if (visibleIdSet[id]) labelNodeIds[id] = true;
+    });
+    if (selectedNodeId && visibleIdSet[selectedNodeId]) importantNodeIds[selectedNodeId] = true;
+
+    var edgeBudget = atlasEdgeBudget(densityMode, visibleEdges.length);
+    visibleEdges = visibleEdges.slice().sort(function (left, right) {
+      var leftSelected = selectedNodeId && (left.source === selectedNodeId || left.target === selectedNodeId) ? 1 : 0;
+      var rightSelected = selectedNodeId && (right.source === selectedNodeId || right.target === selectedNodeId) ? 1 : 0;
+      if (rightSelected !== leftSelected) return rightSelected - leftSelected;
+      return (right.weight || 0) - (left.weight || 0);
+    }).slice(0, edgeBudget);
+
+    return {
+      node_ids: visibleNodes.map(function (node) { return node.id; }),
+      nodes: visibleNodes,
+      edges: visibleEdges,
+      links: visibleEdges,
+      searchIndex: searchIndex,
+      densityMode: densityMode,
+      labelNodeIds: labelNodeIds,
+      matchedNodeIds: matchedIds,
+      importantNodeIds: importantNodeIds,
+      startNodeIds: startNodeIds,
+      starts: visibleStartEntries,
+      counts: {
+        visible_nodes: visibleNodes.length,
+        visible_edges: visibleEdges.length,
+        total_nodes: safeModel.nodes.length,
+        total_edges: safeModel.edges.length,
+        total_communities: safeModel.communities.length
+      }
+    };
+  }
+
+  function resolveAtlasSelectedNodeId(model, visibleSnapshot, selectedNodeId) {
+    var safeModel = model && typeof model === "object" ? model : buildAtlasModel({});
+    var selected = selectedNodeId == null ? null : String(selectedNodeId);
+    var visible = visibleSnapshot && typeof visibleSnapshot === "object" ? visibleSnapshot : null;
+    var visibleIds = {};
+    if (visible && Array.isArray(visible.node_ids)) {
+      visible.node_ids.forEach(function (id) { visibleIds[String(id)] = true; });
+    }
+
+    if (selected && safeModel.byId && safeModel.byId[selected] && (!visible || visibleIds[selected])) {
+      return selected;
+    }
+    return null;
+  }
+
+  var helpers = {
+    splitLabelGraphemes: splitLabelGraphemes,
+    labelCharWidth: labelCharWidth,
+    measureLabelWidth: measureLabelWidth,
+    truncateLabel: truncateLabel,
+    cardDims: cardDims,
+    createSafeStorage: createSafeStorage,
+    getWikiStorageNamespace: getWikiStorageNamespace,
+    defaultQueue: defaultQueue,
+    normalizeQueue: normalizeQueue,
+    toggleQueueFavorite: toggleQueueFavorite,
+    appendQueueNote: appendQueueNote,
+    summarizeQueue: summarizeQueue,
+    defaultLearning: defaultLearning,
+    normalizeLearning: normalizeLearning,
+    resolveInitialMode: resolveInitialMode,
+    getCommunityNodeIds: getCommunityNodeIds,
+    getVisibleNodeIds: getVisibleNodeIds,
+    getVisibleLinks: getVisibleLinks,
+    buildSearchHaystack: buildSearchHaystack,
+    buildSearchIndex: buildSearchIndex,
+    filterLinksByTypes: filterLinksByTypes,
+    applySearchToNodeIds: applySearchToNodeIds,
+    applyFocusMode: applyFocusMode,
+    resolveVisibleSnapshot: resolveVisibleSnapshot,
+    shouldAutoOpenDrawer: shouldAutoOpenDrawer,
+    buildAtlasModel: buildAtlasModel,
+    deriveAtlasLayout: deriveAtlasLayout,
+    resolveAtlasVisibleSnapshot: resolveAtlasVisibleSnapshot,
+    resolveAtlasSelectedNodeId: resolveAtlasSelectedNodeId,
+    getAtlasDensityMode: getAtlasDensityMode,
+    normalizeAtlasViewport: normalizeAtlasViewport,
+    atlasNodePoint: atlasNodePoint,
+    getAtlasModelBounds: getAtlasModelBounds,
+    clampAtlasViewport: clampAtlasViewport,
+    fitAtlasViewport: fitAtlasViewport,
+    centerAtlasViewportOnPoint: centerAtlasViewportOnPoint,
+    zoomAtlasViewport: zoomAtlasViewport,
+    atlasViewportRect: atlasViewportRect,
+    atlasPointToMinimap: atlasPointToMinimap,
+    minimapPointToAtlasPoint: minimapPointToAtlasPoint,
+    atlasViewportToMinimapRect: atlasViewportToMinimapRect,
+    atlasConfidenceLabel: atlasConfidenceLabel,
+    atlasTypeLabel: atlasTypeLabel,
+    atlasNodeKind: atlasNodeKind,
+    stripAtlasMarkdown: stripAtlasMarkdown
+  };
+
+export {
+  splitLabelGraphemes,
+  labelCharWidth,
+  measureLabelWidth,
+  truncateLabel,
+  cardDims,
+  createSafeStorage,
+  getWikiStorageNamespace,
+  defaultQueue,
+  normalizeQueue,
+  toggleQueueFavorite,
+  appendQueueNote,
+  summarizeQueue,
+  defaultLearning,
+  normalizeLearning,
+  resolveInitialMode,
+  getCommunityNodeIds,
+  getVisibleNodeIds,
+  getVisibleLinks,
+  buildSearchHaystack,
+  buildSearchIndex,
+  filterLinksByTypes,
+  applySearchToNodeIds,
+  applyFocusMode,
+  resolveVisibleSnapshot,
+  shouldAutoOpenDrawer,
+  buildAtlasModel,
+  deriveAtlasLayout,
+  resolveAtlasVisibleSnapshot,
+  resolveAtlasSelectedNodeId,
+  getAtlasDensityMode,
+  normalizeAtlasViewport,
+  atlasNodePoint,
+  getAtlasModelBounds,
+  clampAtlasViewport,
+  fitAtlasViewport,
+  centerAtlasViewportOnPoint,
+  zoomAtlasViewport,
+  atlasViewportRect,
+  atlasPointToMinimap,
+  minimapPointToAtlasPoint,
+  atlasViewportToMinimapRect,
+  atlasConfidenceLabel,
+  atlasTypeLabel,
+  atlasNodeKind,
+  stripAtlasMarkdown
+};