cwtools-mcp 0.1.0 → 0.2.0

package/dist/cwtools-mcp.cjs

@@ -592,6 +592,7 @@ var require_mcpTools = __commonJS({
                   "localisation",
                   "identifiers",
                   "validation",
+                  "compatibility",
                   "promptCards",
                   "all"
                 ],
@@ -751,7 +752,11 @@ var require_mcpTools = __commonJS({
               },
               "includeReferences": {
                 "type": "boolean",
-                "description": "If true, include lightweight cross-file reference contexts captured by the index. Default false."
+                "description": "Include lightweight cross-file reference contexts. Default false."
+              },
+              "includeAssetChain": {
+                "type": "boolean",
+                "description": "Check bounded GUI/GFX/model targets, path case, and DDS frame layout."
               },
               "limit": {
                 "type": "number",
@@ -773,7 +778,7 @@ var require_mcpTools = __commonJS({
       {
         "tool": {
           "name": "explore_pdx_project",
-          "description": "Primary semantic exploration entry point for large Paradox projects. Queries the live CWTools type/reference graph and returns bounded entry points, typed nodes, dependency edges, file facts, provenance, truncation, and freshness without scanning or reading whole files. Use this FIRST for questions such as how an entity is connected, what calls or references an ID, what a file depends on, or what may be affected by a change. Follow with exact query_rules/query_scope/query_types/get_pdx_block checks before writing.",
+          "description": "Primary semantic exploration for large Paradox projects: live CWTools type/reference graph with bounded nodes, edges, file facts, provenance and freshness. Use FIRST for connectivity and impact; follow with exact query_rules/query_scope/query_types/get_pdx_block before writing.",
           "inputSchema": {
             "type": "object",
             "properties": {
@@ -814,6 +819,17 @@ var require_mcpTools = __commonJS({
               "includeMetadata": {
                 "type": "boolean",
                 "description": "Include documentation, variables, event targets, and block metadata. Default true."
+              },
+              "relationshipKinds": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "enum": [
+                    "inline_invocation",
+                    "inline_expansion"
+                  ]
+                },
+                "description": "Extra graph kinds: inline_invocation or inline_expansion."
               }
             },
             "required": []
@@ -828,6 +844,109 @@ var require_mcpTools = __commonJS({
           "concurrencyClass": "lsp-limited"
         }
       },
+      {
+        "tool": {
+          "name": "query_inline_instantiation",
+          "description": "Preview one inline_script template instantiation: parameters, arguments, expanded symbol, and problems (missing/unused/unresolved). Precise template path or file+line only; no whole-project expansion. Use before editing a template or caller.",
+          "inputSchema": {
+            "type": "object",
+            "properties": {
+              "template": {
+                "type": "string",
+                "description": "Template path, e.g. common/inline_scripts/example.txt."
+              },
+              "file": {
+                "type": "string",
+                "description": "Caller file; narrows to one invocation."
+              },
+              "line": {
+                "type": "number",
+                "description": "Caller line; combined with file selects one invocation."
+              },
+              "limit": {
+                "type": "number",
+                "description": "Maximum invocations to return. Default 50, max 200."
+              }
+            },
+            "required": []
+          }
+        },
+        "registry": {
+          "name": "query_inline_instantiation",
+          "isWrite": false,
+          "isReadOnly": true,
+          "effect": "workspace_read",
+          "riskLevel": 0,
+          "concurrencyClass": "lsp-limited"
+        }
+      },
+      {
+        "tool": {
+          "name": "analyze_pdx_flow",
+          "description": "Static cost model and gameplay relations for a file or definition: traversals (every_*/while), pulse handlers, nested fan-out, and typed edges (tech prerequisites, special project events, megastructure upgrades). Relative weights only.",
+          "inputSchema": {
+            "type": "object",
+            "properties": {
+              "file": {
+                "type": "string",
+                "description": "Optional file path to analyze; when omitted a definitionId must be given."
+              },
+              "definitionId": {
+                "type": "string",
+                "description": "Optional exact definition ID; combined with file to scope the analysis."
+              },
+              "entityType": {
+                "type": "string",
+                "description": "Optional exact CWTools entity type; use with definitionId to disambiguate duplicate IDs."
+              },
+              "limit": {
+                "type": "number",
+                "description": "Maximum costs and relations returned per collection. Default 100, max 500."
+              }
+            },
+            "required": []
+          }
+        },
+        "registry": {
+          "name": "analyze_pdx_flow",
+          "isWrite": false,
+          "isReadOnly": true,
+          "effect": "workspace_read",
+          "riskLevel": 0,
+          "concurrencyClass": "lsp-limited"
+        }
+      },
+      {
+        "tool": {
+          "name": "compare_definition_with_vanilla",
+          "description": "Field-level diff of one definition against its vanilla counterpart: added, removed and modified fields with stable source locations. Accepts exact entityType + symbolId only; returns the resolved winner and never fabricates a conclusion when the winner is ambiguous. Use before editing any file that overrides vanilla.",
+          "inputSchema": {
+            "type": "object",
+            "properties": {
+              "entityType": {
+                "type": "string",
+                "description": "Exact CWTools type name (e.g. event, technology, ship_size)."
+              },
+              "symbolId": {
+                "type": "string",
+                "description": "Exact definition ID shared by workspace and vanilla candidates."
+              }
+            },
+            "required": [
+              "entityType",
+              "symbolId"
+            ]
+          }
+        },
+        "registry": {
+          "name": "compare_definition_with_vanilla",
+          "isWrite": false,
+          "isReadOnly": true,
+          "effect": "workspace_read",
+          "riskLevel": 0,
+          "concurrencyClass": "lsp-limited"
+        }
+      },
       {
         "tool": {
           "name": "query_localisation_index",
@@ -855,6 +974,26 @@ var require_mcpTools = __commonJS({
                 "type": "boolean",
                 "description": "Only applies to prefix/contains searches. Default false."
               },
+              "includeDuplicates": {
+                "type": "boolean",
+                "description": "Include per-key duplicate groups with all occurrences (file/line), so duplicate keys are auditable instead of trusting the last write. Default false."
+              },
+              "compareLanguages": {
+                "type": "boolean",
+                "description": "Include true missing/extra key-set differences per language, independent of result truncation. Default false."
+              },
+              "referenceLanguage": {
+                "type": "string",
+                "description": "Reference language for missing/extra differences. Defaults to l_english when indexed."
+              },
+              "referenceStatus": {
+                "type": "boolean",
+                "description": "Include bounded LSP reference status and origin; dynamic keys remain uncertain."
+              },
+              "auditMode": {
+                "type": "boolean",
+                "description": "Include authoritative CWTools localisation diagnostics: completely missing script-referenced keys, inline/dynamic-key provenance, and localisation command/scope issues."
+              },
               "limit": {
                 "type": "number",
                 "description": "Maximum entries to return. Default 20, max 100."
@@ -906,7 +1045,7 @@ var require_mcpTools = __commonJS({
       {
         "tool": {
           "name": "get_completion_at",
-          "description": "Get auto-completion suggestions and structured context at a specific position. The CWTools language server returns candidates from both the current mod and the vanilla game cache, plus line/token/scope context for deciding what values can go here.",
+          "description": "Get auto-completion suggestions and bounded context at a specific position through the active VS Code language provider. In Paradox projects, CWTools may enrich the result with game-aware scope and schema context.",
           "inputSchema": {
             "type": "object",
             "properties": {
@@ -1064,7 +1203,7 @@ var require_mcpTools = __commonJS({
       {
         "tool": {
           "name": "query_references",
-          "description": "Find all references to a specific identifier in the mod files. Use this to understand how an event, trigger, or effect is used across the codebase.",
+          "description": "Find references to an identifier through the active language provider, with a bounded workspace text-search fallback.",
           "inputSchema": {
             "type": "object",
             "properties": {
@@ -3216,16 +3355,17 @@ var require_profile = __commonJS({
       }
     }
     function isProjectProfile(value) {
-      return !!value && typeof value === "object" && value.schemaVersion === 1 && typeof value.projectName === "string";
+      return !!value && typeof value === "object" && (value.schemaVersion === 1 || value.schemaVersion === 2) && typeof value.projectName === "string";
     }
     function buildProfileSummary(profile) {
       const dirs = profile.keyDirectories.filter((dir) => dir.exists).map((dir) => dir.path).slice(0, 8).join(", ") || "none";
       const namespaces = Array.isArray(profile.identifiers.namespaces) ? profile.identifiers.namespaces.slice(0, 8).join(", ") || "none" : "none";
       const languages = profile.localisation.languages.join(", ") || "unknown";
+      const supportedVersion = typeof profile.modInfo?.supportedVersion === "string" ? ` (${profile.modInfo.supportedVersion})` : "";
       return [
         `Project: ${profile.projectName}`,
         `Kind: ${profile.workspaceKind}`,
-        `Game: ${profile.game.displayName}`,
+        `Game: ${profile.game.displayName}${supportedVersion}`,
         `Key dirs: ${dirs}`,
         `Namespaces: ${namespaces}`,
         `Localisation: ${languages} (${profile.localisation.encoding})`
@@ -3254,6 +3394,14 @@ var require_profile = __commonJS({
           return profile.identifiers;
         case "validation":
           return profile.validation;
+        case "compatibility":
+          return {
+            supportedVersion: profile.modInfo?.supportedVersion,
+            remoteFileId: profile.modInfo?.remoteFileId,
+            dependencies: profile.modInfo?.dependencies ?? [],
+            vanillaCache: profile.validation?.vanillaCache,
+            game: profile.game
+          };
         case "promptCards":
           return profile.promptCards;
         case "all":
@@ -3264,7 +3412,10 @@ var require_profile = __commonJS({
             workspaceKind: profile.workspaceKind,
             projectName: profile.projectName,
             game: profile.game,
+            supportedVersion: profile.modInfo?.supportedVersion,
             generatedAt: profile.generatedAt,
+            freshness: profile.freshness,
+            warnings: profile.warnings ?? [],
             efficiencyHints: profile.efficiencyHints
           };
       }
@@ -3297,7 +3448,7 @@ var require_profile = __commonJS({
             source: "cwtools-shared",
             error: {
               code: "invalid_profile",
-              message: "Project profile exists but is not schemaVersion 1."
+              message: "Project profile exists but is not a valid schemaVersion 1 or 2 profile."
             }
           };
         }
@@ -3382,21 +3533,13 @@ var require_knowledge = __commonJS({
     exports2.queryProjectKnowledgeWithHost = queryProjectKnowledgeWithHost;
     var path = __importStar(require("path"));
     var KNOWLEDGE_DIR = path.join(".cwtools", "project", "knowledge");
+    var CURRENT_KNOWLEDGE_SCHEMA_VERSION = 7;
     function asRecord(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : {};
     }
     function stringArray(value) {
       return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
     }
-    function tokensFor(args) {
-      return [args.intent ?? "", ...args.identifiers ?? [], ...args.entityTypes ?? []].join(" ").toLowerCase().match(/[@a-z0-9_.:-]{2,}/g)?.slice(0, 30) ?? [];
-    }
-    function score(value, tokens) {
-      if (tokens.length === 0)
-        return 1;
-      const text = JSON.stringify(value).toLowerCase();
-      return tokens.reduce((total, token) => total + (text.includes(token) ? 3 : 0), 0);
-    }
     async function readJson(host, filePath) {
       const read = await host.filesystem.readTextFile(filePath);
       if (!read.exists)
@@ -3408,19 +3551,9 @@ var require_knowledge = __commonJS({
       }
     }
     async function queryProjectKnowledgeWithHost(host, args = {}) {
-      let root = path.join(host.workspaceRoot, KNOWLEDGE_DIR);
-      let manifestPath = path.join(root, "manifest.json");
-      let manifest = await readJson(host, manifestPath);
-      if (!manifest) {
-        const legacyRoot = path.join(host.workspaceRoot, ".cwtools-ai", "project", "knowledge");
-        const legacyManifestPath = path.join(legacyRoot, "manifest.json");
-        const legacyManifest = await readJson(host, legacyManifestPath);
-        if (legacyManifest) {
-          root = legacyRoot;
-          manifestPath = legacyManifestPath;
-          manifest = legacyManifest;
-        }
-      }
+      const root = path.join(host.workspaceRoot, KNOWLEDGE_DIR);
+      const manifestPath = path.join(root, "manifest.json");
+      const manifest = await readJson(host, manifestPath);
       if (!manifest) {
         return {
           ok: false,
@@ -3437,8 +3570,29 @@ var require_knowledge = __commonJS({
           }
         };
       }
-      if (Number(manifest.schemaVersion) >= 2) {
-        const database = asRecord(manifest.database);
+      const database = asRecord(manifest.database);
+      const foundSchemaVersion = Number(database.schemaVersion ?? manifest.schemaVersion) || 0;
+      if (Number(manifest.schemaVersion) !== CURRENT_KNOWLEDGE_SCHEMA_VERSION || foundSchemaVersion !== CURRENT_KNOWLEDGE_SCHEMA_VERSION) {
+        return {
+          ok: false,
+          status: "stale",
+          source: "cwtools-project-knowledge-sqlite",
+          error: {
+            code: "knowledge_schema_obsolete",
+            message: `Project knowledge schema V${foundSchemaVersion} is obsolete. Rebuild it with the current V${CURRENT_KNOWLEDGE_SCHEMA_VERSION} extension.`
+          },
+          data: {
+            status: "stale",
+            manifestPath,
+            rebuildRequired: true,
+            foundSchemaVersion,
+            currentSchemaVersion: CURRENT_KNOWLEDGE_SCHEMA_VERSION,
+            staleReasons: ["schema_version_obsolete"],
+            _hint: "Run /init or reopen the project and wait for the automatic full rebuild. Old database schemas are not queried."
+          }
+        };
+      }
+      {
         const relativeDatabasePath = typeof database.path === "string" && database.path.trim() ? database.path : "knowledge.sqlite";
         const databasePath = path.resolve(root, relativeDatabasePath);
         const relative = path.relative(root, databasePath);
@@ -3463,74 +3617,22 @@ var require_knowledge = __commonJS({
             data: { manifestPath, databasePath }
           };
         }
-        const manifestStatus2 = String(manifest.status ?? "stale");
-        const staleReasons2 = stringArray(manifest.staleReasons);
-        const ready2 = String(result.status ?? manifestStatus2) === "ready" && manifestStatus2 === "ready" && staleReasons2.length === 0;
-        const partial = staleReasons2.length === 0 && (String(result.status ?? manifestStatus2) === "partial" || manifestStatus2 === "partial");
+        const manifestStatus = String(manifest.status ?? "stale");
+        const staleReasons = stringArray(manifest.staleReasons);
+        const ready = String(result.status ?? manifestStatus) === "ready" && manifestStatus === "ready" && staleReasons.length === 0;
+        const partial = staleReasons.length === 0 && (String(result.status ?? manifestStatus) === "partial" || manifestStatus === "partial");
         return {
           ok: true,
-          status: ready2 ? "ready" : partial ? "partial" : "stale",
+          status: ready ? "ready" : partial ? "partial" : "stale",
           source: "cwtools-project-knowledge-sqlite",
           data: {
             ...result,
-            status: ready2 ? "ready" : partial ? "partial" : "stale",
+            status: ready ? "ready" : partial ? "partial" : "stale",
             manifestPath,
-            staleReasons: staleReasons2
+            staleReasons
           }
         };
       }
-      const manifestDomains = stringArray(manifest.domains);
-      const domains = (args.domains?.length ? args.domains : manifestDomains).map((value) => value.trim().toLowerCase()).filter(Boolean).slice(0, 12);
-      const tokens = tokensFor(args);
-      const limit = Math.max(1, Math.min(Number(args.limit ?? 80) || 80, 300));
-      const evidence = [];
-      const capabilities = [];
-      for (const domain of domains) {
-        const capability = await readJson(host, path.join(root, "capabilities", `${domain}.json`));
-        if (!capability)
-          continue;
-        capabilities.push({ domain, summary: capability.summary, evidencePolicy: capability.evidencePolicy });
-        const candidates = [];
-        if (Array.isArray(capability.definitions))
-          candidates.push(...capability.definitions.map(asRecord));
-        if (args.includeProjectPatterns !== false && Array.isArray(capability.projectExamples))
-          candidates.push(...capability.projectExamples.map(asRecord));
-        if (args.includeVanillaArchetypes !== false && Array.isArray(capability.vanillaArchetypes))
-          candidates.push(...capability.vanillaArchetypes.map(asRecord));
-        if (args.includeTopology !== false) {
-          const topology = asRecord(capability.topology);
-          if (Array.isArray(topology.edges))
-            candidates.push(...topology.edges.map(asRecord));
-        }
-        evidence.push(...candidates.map((item) => ({ ...item, domain, score: score(item, tokens) })).filter((item) => tokens.length === 0 || Number(item.score) > 0).sort((a, b) => Number(b.score) - Number(a.score)).slice(0, Math.max(5, Math.ceil(limit / Math.max(1, domains.length)))));
-      }
-      const unresolvedFile = args.includeUnresolved === false ? void 0 : await readJson(host, path.join(root, "unresolved.json"));
-      const unresolved = Array.isArray(unresolvedFile?.entries) ? unresolvedFile.entries.map(asRecord).slice(0, 100) : [];
-      const manifestStatus = String(manifest.status ?? "stale");
-      const staleReasons = stringArray(manifest.staleReasons);
-      const ready = manifestStatus === "ready" && staleReasons.length === 0;
-      return {
-        ok: true,
-        status: ready ? "ready" : "stale",
-        source: "cwtools-project-knowledge",
-        data: {
-          status: ready ? "ready" : "stale",
-          manifestPath,
-          generatedAt: manifest.generatedAt,
-          game: manifest.game,
-          graphVersion: manifest.graphVersion,
-          staleReasons,
-          domains,
-          capabilities,
-          evidence: evidence.slice(0, limit),
-          unresolved,
-          requiredNextChecks: [
-            "Use query_cwt_schema/query_rules/query_scope for legality before writing.",
-            "Use query_override_modes for target directories with vanilla definitions.",
-            "Read exact source blocks before approving a complex blueprint."
-          ]
-        }
-      };
     }
   }
 });
@@ -3711,6 +3813,9 @@ var require_names = __commonJS({
       "query_project_knowledge",
       "query_workspace_index",
       "explore_pdx_project",
+      "query_inline_instantiation",
+      "analyze_pdx_flow",
+      "compare_definition_with_vanilla",
       "query_localisation_index",
       "get_pdx_block",
       "get_completion_at",
@@ -4753,17 +4858,81 @@ var require_toolHandlers = __commonJS({
             args.maxEdges ?? 80,
             args.includeMetadata !== false
           ], "Start the CWTools LSP process and wait for the game model to load before exploring the semantic graph.");
+        case "analyze_pdx_flow": {
+          const file = typeof args.file === "string" ? args.file.trim() : "";
+          const definitionId = typeof args.definitionId === "string" ? args.definitionId.trim() : "";
+          if (!file && !definitionId) {
+            return {
+              ok: false,
+              status: "error",
+              source: "cwtools-shared",
+              error: {
+                code: "invalid_arguments",
+                message: "analyze_pdx_flow requires a file or a definitionId."
+              }
+            };
+          }
+          return executeLspTool(host, "cwtools.ai.analyzePdxFlow", [{
+            ...file ? { file } : {},
+            ...definitionId ? { definitionId } : {},
+            ...typeof args.entityType === "string" && args.entityType.trim() ? { entityType: args.entityType.trim() } : {},
+            limit: Math.max(1, Math.min(Number(args.limit ?? 100) || 100, 500))
+          }], "Start the CWTools LSP process and wait for the game model to load before analyzing flow cost and gameplay relations.");
+        }
+        case "compare_definition_with_vanilla": {
+          if (typeof args.entityType !== "string" || typeof args.symbolId !== "string" || !args.entityType.trim() || !args.symbolId.trim()) {
+            return {
+              ok: false,
+              status: "error",
+              source: "cwtools-shared",
+              error: {
+                code: "invalid_arguments",
+                message: "compare_definition_with_vanilla requires entityType and symbolId."
+              }
+            };
+          }
+          return executeLspTool(host, "cwtools.ai.compareDefinitionWithVanilla", [args.entityType.trim(), args.symbolId.trim()], "Start the CWTools LSP process and wait for the game model to load before comparing the definition with vanilla.");
+        }
+        case "query_inline_instantiation": {
+          const template = typeof args.template === "string" ? args.template.trim() : "";
+          const file = typeof args.file === "string" ? args.file.trim() : "";
+          if (!template && !file) {
+            return {
+              ok: false,
+              status: "error",
+              source: "cwtools-shared",
+              error: {
+                code: "invalid_arguments",
+                message: "query_inline_instantiation requires a template path or a caller file (optionally with line)."
+              }
+            };
+          }
+          return executeLspTool(host, "cwtools.ai.exploreInlineGraph", [{
+            ...template ? { template } : {},
+            ...file ? { file } : {},
+            ...Number.isInteger(args.line) ? { line: Number(args.line) } : {},
+            limit: Math.max(1, Math.min(Number(args.limit ?? 50) || 50, 200))
+          }], "Start the CWTools LSP process and wait for the game model to load before resolving the inline template instantiation.");
+        }
         case "query_localisation_index": {
           if (!host.indexing) {
             return (0, schema_1.toolUnavailable)(name, "Localisation index is not available in this host.", [
               "Wire an LSP index command or a thin Node index before using this tool for localisation evidence."
             ]);
           }
+          const data = await host.indexing.queryLocalisation(args);
+          const semanticAudit = args.auditMode === true ? await executeLspTool(host, "cwtools.ai.queryLocalisationAudit", [{
+            ...typeof args.key === "string" ? { key: args.key } : {},
+            prefix: args.prefix === true,
+            contains: args.contains === true,
+            caseSensitive: args.caseSensitive === true,
+            limit: Math.max(1, Math.min(Number(args.limit ?? 100) || 100, 500))
+          }], "Start the CWTools LSP process and wait for localisation validation before requesting auditMode.") : void 0;
           return {
             ok: true,
             status: "ready",
             source: "cwtools-index",
-            data: await host.indexing.queryLocalisation(args)
+            data: semanticAudit ? { ...data, semanticAudit } : data
           };
         }
         case "get_diagnostics": {
@@ -46446,16 +46615,8 @@ var require_resources = __commonJS({
           };
         }
         case "cwtools://project/knowledge-manifest": {
-          let manifestPath = path.join(host.workspaceRoot, ".cwtools", "project", "knowledge", "manifest.json");
-          let read = await host.filesystem.readTextFile(manifestPath);
-          if (!read.exists) {
-            const legacyPath = path.join(host.workspaceRoot, ".cwtools-ai", "project", "knowledge", "manifest.json");
-            const legacyRead = await host.filesystem.readTextFile(legacyPath);
-            if (legacyRead.exists) {
-              manifestPath = legacyPath;
-              read = legacyRead;
-            }
-          }
+          const manifestPath = path.join(host.workspaceRoot, ".cwtools", "project", "knowledge", "manifest.json");
+          const read = await host.filesystem.readTextFile(manifestPath);
           return read.exists ? JSON.parse(read.content) : {
             status: "missing",
             manifestPath,

package/dist/mcp/resources.js

@@ -121,16 +121,8 @@ async function readResourceData(host, uri) {
                 };
         }
         case 'cwtools://project/knowledge-manifest': {
-            let manifestPath = path.join(host.workspaceRoot, '.cwtools', 'project', 'knowledge', 'manifest.json');
-            let read = await host.filesystem.readTextFile(manifestPath);
-            if (!read.exists) {
-                const legacyPath = path.join(host.workspaceRoot, '.cwtools-ai', 'project', 'knowledge', 'manifest.json');
-                const legacyRead = await host.filesystem.readTextFile(legacyPath);
-                if (legacyRead.exists) {
-                    manifestPath = legacyPath;
-                    read = legacyRead;
-                }
-            }
+            const manifestPath = path.join(host.workspaceRoot, '.cwtools', 'project', 'knowledge', 'manifest.json');
+            const read = await host.filesystem.readTextFile(manifestPath);
             return read.exists
                 ? JSON.parse(read.content)
                 : {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cwtools-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Read-only MCP server exposing CWTools Paradox/Stellaris semantic tools to external agents",
   "license": "MIT",
   "repository": {
@@ -37,7 +37,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "chokidar": "^4.0.3",
-    "cwtools-shared": "0.1.0",
+    "cwtools-shared": "0.2.0",
     "vscode-jsonrpc": "^8.2.0"
   },
   "devDependencies": {