noteconnection 1.8.0 → 1.9.0

package/dist/src/frontend/libs/path_core.js

@@ -8,10 +8,31 @@ var module = { exports: exports };
 // var Graph, PathEngine;
 
 
+    /* ResourceReference.js */
+    "use strict";
+
+normalizeResourceReference = normalizeResourceReference;
+/**
+ * Shared, host-neutral reference normalization used by Graph and backend
+ * identity generation. It intentionally has no Node or platform dependency so
+ * the path-core bundle can execute in a browser VM and in Godot WebView.
+ */
+function normalizeResourceReference(reference) {
+    if (typeof reference !== 'string') {
+        throw new Error('Resource reference must be a string');
+    }
+    if (reference.includes('\0')) {
+        throw new Error('Resource reference must not contain NUL characters');
+    }
+    return reference.normalize('NFC').replace(/\\/g, '/').toLowerCase();
+}
+
+
     /* Graph.js */
     "use strict";
 
 
+
 /**
  * Directed Graph implementation for managing notes and dependencies.
  * 用于管理笔记和依赖关系的有向图实现。
@@ -21,6 +42,7 @@ class Graph {
         this.nodes = new Map();
         this.adjacencyList = new Map();
         this.reverseAdjacencyList = new Map();
+        this.aliases = new Map();
     }
     /**
      * Adds a node to the graph.
@@ -28,11 +50,90 @@ class Graph {
      * @param node The node to add | 要添加的节点
      */
     addNode(node) {
-        if (!this.nodes.has(node.id)) {
-            this.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 });
-            this.adjacencyList.set(node.id, []);
-            this.reverseAdjacencyList.set(node.id, []);
+        if (this.nodes.has(node.id)) {
+            return;
+        }
+        const aliases = [node.id, node.sourceUri, ...(node.identityAliases ?? [])]
+            .filter((alias) => typeof alias === 'string' && alias.length > 0);
+        const normalizedAliases = new Set(aliases.map(alias => (0, normalizeResourceReference)(alias)));
+        normalizedAliases.forEach(alias => {
+            const existingNodeId = this.aliases.get(alias);
+            if (existingNodeId && existingNodeId !== node.id) {
+                throw new Error(`Resource identity alias collision: "${alias}" is claimed by both "${existingNodeId}" and "${node.id}"`);
+            }
+        });
+        this.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 });
+        this.adjacencyList.set(node.id, []);
+        this.reverseAdjacencyList.set(node.id, []);
+        normalizedAliases.forEach(alias => {
+            this.aliases.set(alias, node.id);
+        });
+    }
+    /**
+     * Rehydrates a graph from either a current or legacy JSON snapshot.
+     *
+     * The snapshot is validated before mutating the returned graph. Edges must
+     * reference declared nodes so a corrupt or partially-written snapshot cannot
+     * silently create synthetic nodes and change graph semantics during replay.
+     */
+    static fromJSON(data) {
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            throw new Error('Graph snapshot must be an object.');
+        }
+        const snapshot = data;
+        if (!Array.isArray(snapshot.nodes) || !Array.isArray(snapshot.edges)) {
+            throw new Error('Graph snapshot must contain nodes and edges arrays.');
         }
+        const graph = new Graph();
+        const nodeIds = new Set();
+        snapshot.nodes.forEach((rawNode, index) => {
+            if (!rawNode || typeof rawNode !== 'object' || Array.isArray(rawNode)) {
+                throw new Error(`Graph snapshot node at index ${index} must be an object.`);
+            }
+            const node = rawNode;
+            if (typeof node.id !== 'string' || node.id.trim().length === 0) {
+                throw new Error(`Graph snapshot node at index ${index} requires a non-empty id.`);
+            }
+            if (nodeIds.has(node.id)) {
+                throw new Error(`Graph snapshot contains duplicate node id: ${node.id}.`);
+            }
+            nodeIds.add(node.id);
+            graph.addNode({
+                ...node,
+                id: node.id,
+                label: typeof node.label === 'string' && node.label.length > 0 ? node.label : node.id,
+                inDegree: 0,
+                outDegree: 0,
+            });
+        });
+        snapshot.edges.forEach((rawEdge, index) => {
+            if (!rawEdge || typeof rawEdge !== 'object' || Array.isArray(rawEdge)) {
+                throw new Error(`Graph snapshot edge at index ${index} must be an object.`);
+            }
+            const edge = rawEdge;
+            if (typeof edge.source !== 'string' || typeof edge.target !== 'string') {
+                throw new Error(`Graph snapshot edge at index ${index} requires source and target ids.`);
+            }
+            if (!graph.hasNode(edge.source) || !graph.hasNode(edge.target)) {
+                throw new Error(`Graph snapshot edge at index ${index} references an undeclared node: ${edge.source} -> ${edge.target}.`);
+            }
+            graph.addEdge(edge.source, edge.target, edge.type, edge.weight);
+        });
+        return graph;
+    }
+    /** Restore this instance atomically from a legacy or current JSON snapshot. */
+    restore(data) {
+        const restored = Graph.fromJSON(data);
+        this.nodes = restored.nodes;
+        this.adjacencyList = restored.adjacencyList;
+        this.reverseAdjacencyList = restored.reverseAdjacencyList;
+        this.aliases = restored.aliases;
+    }
+    resolveNodeId(reference) {
+        if (this.nodes.has(reference)) {
+            return reference;
+        }
+        return this.aliases.get((0, normalizeResourceReference)(reference));
     }
     /**
      * Retrieves a node by its ID.
@@ -40,16 +141,17 @@ class Graph {
      * @param id The node ID | 节点 ID
      * @returns The node or undefined if not found | 节点，如果未找到则返回 undefined
      */
-    getNode(id) {
-        return this.nodes.get(id);
+    getNode(reference) {
+        const nodeId = this.resolveNodeId(reference);
+        return nodeId ? this.nodes.get(nodeId) : undefined;
     }
     /**
      * Checks if a node exists in the graph.
      * 检查图中是否存在该节点。
      * @param id The node ID | 节点 ID
      */
-    hasNode(id) {
-        return this.nodes.has(id);
+    hasNode(reference) {
+        return this.resolveNodeId(reference) !== undefined;
     }
     /**
      * Adds a directed edge between two nodes.
@@ -60,30 +162,32 @@ class Graph {
      * @param weight Edge weight (confidence) | 边权重 (置信度)
      */
     addEdge(source, target, type = 'dependency', weight = 1) {
-        if (!this.nodes.has(source)) {
-            this.addNode({ id: source, label: source, inDegree: 0, outDegree: 0 });
+        const sourceId = this.resolveNodeId(source) ?? source;
+        const targetId = this.resolveNodeId(target) ?? target;
+        if (!this.nodes.has(sourceId)) {
+            this.addNode({ id: sourceId, label: sourceId, inDegree: 0, outDegree: 0 });
         }
-        if (!this.nodes.has(target)) {
-            this.addNode({ id: target, label: target, inDegree: 0, outDegree: 0 });
+        if (!this.nodes.has(targetId)) {
+            this.addNode({ id: targetId, label: targetId, inDegree: 0, outDegree: 0 });
         }
-        const edge = { source, target, type, weight };
+        const edge = { source: sourceId, target: targetId, type, weight };
         // Add to adjacency list (outgoing)
-        const outgoing = this.adjacencyList.get(source) || [];
+        const outgoing = this.adjacencyList.get(sourceId) || [];
         // Prevent duplicate edges
-        if (!outgoing.some(e => e.target === target && e.type === type)) {
+        if (!outgoing.some(e => e.target === targetId && e.type === type)) {
             outgoing.push(edge);
-            this.adjacencyList.set(source, outgoing);
+            this.adjacencyList.set(sourceId, outgoing);
             // Update out-degree
-            const sourceNode = this.nodes.get(source);
+            const sourceNode = this.nodes.get(sourceId);
             sourceNode.outDegree++;
         }
         // Add to reverse adjacency list (incoming)
-        const incoming = this.reverseAdjacencyList.get(target) || [];
-        if (!incoming.some(e => e.source === source && e.type === type)) {
+        const incoming = this.reverseAdjacencyList.get(targetId) || [];
+        if (!incoming.some(e => e.source === sourceId && e.type === type)) {
             incoming.push(edge);
-            this.reverseAdjacencyList.set(target, incoming);
+            this.reverseAdjacencyList.set(targetId, incoming);
             // Update in-degree
-            const targetNode = this.nodes.get(target);
+            const targetNode = this.nodes.get(targetId);
             targetNode.inDegree++;
         }
     }
@@ -92,16 +196,17 @@ class Graph {
      * 获取节点的所有出边。
      * @param id Node ID | 节点 ID
      */
-    getOutgoingEdges(id) {
-        return this.adjacencyList.get(id) || [];
+    getOutgoingEdges(reference) {
+        const nodeId = this.resolveNodeId(reference);
+        return nodeId ? (this.adjacencyList.get(nodeId) || []) : [];
     }
     /**
      * Gets all outgoing neighbor IDs for a node.
      * 获取节点的所有出度邻居 ID。
      * @param id Node ID | 节点 ID
      */
-    getNeighbors(id) {
-        return (this.adjacencyList.get(id) || []).map(edge => edge.target);
+    getNeighbors(reference) {
+        return this.getOutgoingEdges(reference).map(edge => edge.target);
     }
     /**
      * Gets all nodes in the graph.
@@ -122,8 +227,9 @@ class Graph {
      * 获取节点的所有入边。
      * @param id Node ID | 节点 ID
      */
-    getIncomingEdges(id) {
-        return this.reverseAdjacencyList.get(id) || [];
+    getIncomingEdges(reference) {
+        const nodeId = this.resolveNodeId(reference);
+        return nodeId ? (this.reverseAdjacencyList.get(nodeId) || []) : [];
     }
     /**
      * Returns the graph data in a serializable format.
@@ -140,11 +246,14 @@ class Graph {
      * 获取所有前驱节点（入边的传递闭包）。
      * @param id Target node ID
      */
-    getPredecessors(id) {
+    getPredecessors(reference) {
         const predecessors = new Set();
-        const queue = [id];
+        const nodeId = this.resolveNodeId(reference);
+        if (!nodeId)
+            return predecessors;
+        const queue = [nodeId];
         const visited = new Set();
-        visited.add(id);
+        visited.add(nodeId);
         while (queue.length > 0) {
             const current = queue.shift();
             const incoming = this.getIncomingEdges(current);
@@ -163,11 +272,14 @@ class Graph {
      * 获取所有后继节点（出边的传递闭包）。
      * @param id Source node ID
      */
-    getSuccessors(id) {
+    getSuccessors(reference) {
         const successors = new Set();
-        const queue = [id];
+        const nodeId = this.resolveNodeId(reference);
+        if (!nodeId)
+            return successors;
+        const queue = [nodeId];
         const visited = new Set();
-        visited.add(id);
+        visited.add(nodeId);
         while (queue.length > 0) {
             const current = queue.shift();
             const outgoing = this.getOutgoingEdges(current);
@@ -189,15 +301,19 @@ class Graph {
      * @returns Array of node IDs representing the path, or empty if no path found
      */
     getShortestPath(source, target) {
-        if (source === target)
-            return [source];
-        const queue = [source];
+        const sourceId = this.resolveNodeId(source);
+        const targetId = this.resolveNodeId(target);
+        if (!sourceId || !targetId)
+            return [];
+        if (sourceId === targetId)
+            return [sourceId];
+        const queue = [sourceId];
         const visited = new Set();
         const parent = new Map();
-        visited.add(source);
+        visited.add(sourceId);
         while (queue.length > 0) {
             const current = queue.shift();
-            if (current === target)
+            if (current === targetId)
                 break;
             const neighbors = this.getNeighbors(current);
             for (const neighbor of neighbors) {
@@ -208,12 +324,12 @@ class Graph {
                 }
             }
         }
-        if (!visited.has(target))
+        if (!visited.has(targetId))
             return [];
         // Reconstruct path
-        const path = [target];
-        let curr = target;
-        while (curr !== source) {
+        const path = [targetId];
+        let curr = targetId;
+        while (curr !== sourceId) {
             curr = parent.get(curr);
             path.unshift(curr);
         }

package/dist/src/frontend/locales/en.json

@@ -392,6 +392,30 @@
     "subtitle": "Grounded conversation, knowledge search, and guided learning",
     "conversationTitle": "Grounded Conversation",
     "conversationSubtitle": "Scoped knowledge, citations, and guided learning actions",
+    "answerLanguage": {
+      "label": "Answer language",
+      "english": "English",
+      "chinese": "Chinese",
+      "summary": "Matches software language",
+      "summaryEnglish": "English answer",
+      "summaryChinese": "Chinese answer"
+    },
+    "responseMode": {
+      "label": "Answer detail",
+      "slim": "Slim",
+      "full": "Full report",
+      "summary": "Short grounded answer",
+      "summarySlim": "Short grounded answer",
+      "summaryFull": "Complete evidence-bounded technical report"
+    },
+    "responseBudget": {
+      "label": "Full report budget",
+      "adaptive": "Adaptive",
+      "unbounded": "No product cap",
+      "summary": "Host-adaptive report budget",
+      "summaryAdaptive": "Host-adaptive report budget",
+      "summaryUnbounded": "Product cap disabled; runtime safety limits remain"
+    },
     "userId": "Learner ID",
     "inputLabel": "Ask the scoped knowledge corpus",
     "inputPlaceholder": "Ask about a concept, citation, prerequisite, or study step...",
@@ -500,6 +524,12 @@
       "graphDiagnosticsSupportCountLabel": "Support nodes",
       "graphDiagnosticsBudgetLabel": "Path depth budget",
       "graphDiagnosticsMissingLookupsLabel": "Missing graph lookups",
+      "graphAnswerPlanLabel": "Graph answer plan",
+      "graphAnswerIntentLabel": "Intent / depth",
+      "graphAnswerCoverageLabel": "Required claim coverage",
+      "graphAnswerMissingLabel": "Missing required claims",
+      "graphAnswerOmissionsLabel": "Omitted graph candidates",
+      "graphExpansionLabel": "Bounded expansion",
       "graphTemporalValid": "valid",
       "graphTemporalWarning": "warning",
       "ragContextLabel": "RAG context",
@@ -946,6 +976,8 @@
     },
     "reply": {
       "structuredAnswer": "Grounded Answer",
+      "showNextActions": "Show next actions",
+      "hideNextActions": "Hide next actions",
       "citations": "Citations",
       "citationsEmpty": "No citations were returned.",
       "citationUntitled": "Untitled citation",

package/dist/src/frontend/locales/zh.json

@@ -388,10 +388,34 @@
   "opt_visible": "可见节点 (默认)",
   "opt_total": "统计总数",
   "agentWorkspace": {
+    "responseBudget": {
+      "label": "\u5b8c\u6574\u62a5\u544a\u9884\u7b97",
+      "adaptive": "\u81ea\u9002\u5e94",
+      "unbounded": "\u5173\u95ed\u4ea7\u54c1\u4e0a\u9650",
+      "summary": "\u6309\u5bbf\u4e3b\u80fd\u529b\u81ea\u9002\u5e94\u62a5\u544a\u9884\u7b97",
+      "summaryAdaptive": "\u6309\u5bbf\u4e3b\u80fd\u529b\u81ea\u9002\u5e94\u62a5\u544a\u9884\u7b97",
+      "summaryUnbounded": "\u5df2\u5173\u95ed\u4ea7\u54c1\u4e0a\u9650\uff1b\u8fd0\u884c\u65f6\u5b89\u5168\u9600\u4ecd\u751f\u6548"
+    },
     "title": "知识工作区",
     "subtitle": "可信对话、知识检索与引导式学习",
     "conversationTitle": "可信对话",
     "conversationSubtitle": "限定范围的知识、引用依据与引导式学习动作",
+    "answerLanguage": {
+      "label": "回答语言",
+      "english": "English",
+      "chinese": "中文",
+      "summary": "跟随软件语言",
+      "summaryEnglish": "使用英文回答",
+      "summaryChinese": "使用中文回答"
+    },
+    "responseMode": {
+      "label": "回答详略",
+      "slim": "简洁",
+      "full": "完整报告",
+      "summary": "简洁的依据型回答",
+      "summarySlim": "简洁的依据型回答",
+      "summaryFull": "完整且受证据约束的技术报告"
+    },
     "userId": "学习者 ID",
     "inputLabel": "向当前限定知识域提问",
     "inputPlaceholder": "可以询问概念、引用依据、先修依赖或学习步骤...",
@@ -500,6 +524,12 @@
       "graphDiagnosticsSupportCountLabel": "支撑节点",
       "graphDiagnosticsBudgetLabel": "路径深度预算",
       "graphDiagnosticsMissingLookupsLabel": "缺失图查询",
+      "graphAnswerPlanLabel": "图回答规划",
+      "graphAnswerIntentLabel": "意图 / 深度",
+      "graphAnswerCoverageLabel": "必要主张覆盖",
+      "graphAnswerMissingLabel": "缺失的必要主张",
+      "graphAnswerOmissionsLabel": "已排除的图候选",
+      "graphExpansionLabel": "有界图扩展",
       "graphTemporalValid": "有效",
       "graphTemporalWarning": "告警",
       "ragContextLabel": "RAG 上下文",
@@ -946,6 +976,8 @@
     },
     "reply": {
       "structuredAnswer": "可信回答",
+      "showNextActions": "显示下一步行动",
+      "hideNextActions": "隐藏下一步行动",
       "citations": "引用",
       "citationsEmpty": "未返回引用。",
       "citationUntitled": "未命名引用",

package/dist/src/frontend/mobile_budget_runtime.js

@@ -0,0 +1,33 @@
+(function attachMobileBudgetRuntime(root) {
+    'use strict';
+
+    // This is the intentionally tiny browser projection of config/mobile-budget.v1.json.
+    // The Node/Rust contract remains the source of truth; contract tests reject drift.
+    if (!root || root.NoteConnectionMobileBudget) {
+        return;
+    }
+
+    root.NoteConnectionMobileBudget = Object.freeze({
+        schemaVersion: 1,
+        profiles: Object.freeze({
+            'mobile-low': Object.freeze({
+                artifactCompressedBytes: 25 * 1024 * 1024,
+                maxResidentBytes: 256 * 1024 * 1024,
+                maxDeviceRamBytes: 4 * 1024 * 1024 * 1024
+            }),
+            'mobile-standard': Object.freeze({
+                artifactCompressedBytes: 35 * 1024 * 1024,
+                maxResidentBytes: 384 * 1024 * 1024,
+                maxDeviceRamBytes: 8 * 1024 * 1024 * 1024
+            })
+        }),
+        runtime: Object.freeze({
+            maxDocuments: 5000,
+            maxDocumentBytes: 16 * 1024 * 1024,
+            maxTotalInputBytes: 64 * 1024 * 1024,
+            maxEdges: 250000,
+            maxDepth: 64,
+            maxProjectionBytes: 48 * 1024 * 1024
+        })
+    });
+}(typeof globalThis !== 'undefined' ? globalThis : this));