@zokizuan/satori-mcp 6.2.0 → 6.3.0

package/dist/server/shared-runtime.js

@@ -0,0 +1,300 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { withSourceMeasurementOperation } from "@zokizuan/satori-core";
+import { CapabilityResolver } from "../core/capabilities.js";
+import { CallGraphSidecarManager } from "../core/call-graph.js";
+import { SearchContinuationCoordinator, ToolHandlers, } from "../core/handlers.js";
+import { MutationLeaseCoordinator } from "../core/mutation-lease.js";
+import { RuntimeOwnerRegistry, buildRuntimeOwnerIdentityFromConfig, } from "../core/runtime-owner.js";
+import { SnapshotManager } from "../core/snapshot.js";
+import { SyncManager } from "../core/sync.js";
+import { getMcpToolList, toolRegistry } from "../tools/registry.js";
+import { createLocalOnlyContext, ProviderRuntime } from "./provider-runtime.js";
+import { SHARED_RUNTIME_MAX_PENDING_REQUESTS } from "./shared-runtime-identity.js";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isMissingProviderConfigIssue(value) {
+    return "code" in value && value.code === "MISSING_PROVIDER_CONFIG";
+}
+class SessionProviderRuntime {
+    constructor(providerRuntime, continuationCoordinator, mutationLeaseCoordinator, callGraphManager) {
+        this.providerRuntime = providerRuntime;
+        this.continuationCoordinator = continuationCoordinator;
+        this.mutationLeaseCoordinator = mutationLeaseCoordinator;
+        this.callGraphManager = callGraphManager;
+        this.contexts = new Map();
+        this.handlers = new Set();
+    }
+    async requireToolContext(operation) {
+        const shared = await this.providerRuntime.requireToolContext(operation);
+        if (isMissingProviderConfigIssue(shared)) {
+            return shared;
+        }
+        const existing = this.contexts.get(shared);
+        if (existing) {
+            return existing;
+        }
+        const toolHandlers = new ToolHandlers(shared.context, shared.snapshotManager, shared.syncManager, shared.runtimeFingerprint, shared.capabilities, () => Date.now(), this.callGraphManager, shared.reranker, undefined, undefined, shared.runtimeOwnerGate, this.mutationLeaseCoordinator, this.continuationCoordinator);
+        const sessionContext = {
+            ...shared,
+            toolHandlers,
+            providerRuntime: this,
+        };
+        this.contexts.set(shared, sessionContext);
+        this.handlers.add(toolHandlers);
+        return sessionContext;
+    }
+    release() {
+        for (const handler of this.handlers) {
+            handler.releaseSearchContinuationOwnership();
+        }
+        this.handlers.clear();
+        this.contexts.clear();
+    }
+}
+export class SharedRuntimeHost {
+    constructor(config, runtimeFingerprint, runMode) {
+        this.config = config;
+        this.runtimeFingerprint = runtimeFingerprint;
+        this.runMode = runMode;
+        this.activeSessions = 0;
+        this.activeOperations = 0;
+        this.shutdownStarted = false;
+        this.activityListeners = new Set();
+        this.capabilities = new CapabilityResolver(config);
+        this.readFileMaxLines = Math.max(1, config.readFileMaxLines ?? 1000);
+        this.watchSyncEnabled = config.watchSyncEnabled === true;
+        this.watchDebounceMs = Math.max(1, config.watchDebounceMs ?? 5000);
+        console.log(`[FINGERPRINT] Runtime index fingerprint: ${JSON.stringify(runtimeFingerprint)}`);
+        this.runtimeOwnerRegistry = new RuntimeOwnerRegistry({
+            identity: buildRuntimeOwnerIdentityFromConfig({
+                config,
+                runtimeFingerprint,
+            }),
+        });
+        try {
+            this.runtimeOwnerRegistry.registerCurrentOwner();
+        }
+        catch (error) {
+            console.warn("[RUNTIME-OWNER] Failed to register current Satori runtime owner; "
+                + `index mutations will fail closed until the owner registry is writable: ${errorMessage(error)}`);
+        }
+        this.mutationLeaseCoordinator = new MutationLeaseCoordinator();
+        this.snapshotManager = new SnapshotManager(runtimeFingerprint);
+        this.callGraphManager = new CallGraphSidecarManager(runtimeFingerprint);
+        this.localContext = createLocalOnlyContext(config, this.mutationLeaseCoordinator);
+        this.localSyncManager = new SyncManager(this.localContext, this.snapshotManager, {
+            watchEnabled: this.watchSyncEnabled,
+            watchDebounceMs: this.watchDebounceMs,
+            mutationLeaseCoordinator: this.mutationLeaseCoordinator,
+        });
+        this.recoveryHandlers = new ToolHandlers(this.localContext, this.snapshotManager, this.localSyncManager, runtimeFingerprint, this.capabilities, () => Date.now(), this.callGraphManager, null, undefined, undefined, this.runtimeOwnerRegistry, this.mutationLeaseCoordinator, new SearchContinuationCoordinator());
+        this.providerRuntime = new ProviderRuntime({
+            config,
+            snapshotManager: this.snapshotManager,
+            runtimeFingerprint,
+            capabilities: this.capabilities,
+            readFileMaxLines: this.readFileMaxLines,
+            watchSyncEnabled: this.watchSyncEnabled,
+            watchDebounceMs: this.watchDebounceMs,
+            startSyncLifecycle: runMode === "mcp" || runMode === "host",
+            callGraphManager: this.callGraphManager,
+            runtimeOwnerGate: this.runtimeOwnerRegistry,
+            mutationLeaseCoordinator: this.mutationLeaseCoordinator,
+            onLifecycleActivityChanged: () => this.notifyActivityChanged(),
+        });
+        this.snapshotManager.loadCodebaseSnapshot();
+    }
+    createSession() {
+        if (this.shutdownStarted) {
+            throw new Error("Shared Satori runtime host is shutting down.");
+        }
+        return new McpSession(this);
+    }
+    createSessionResources(continuationCoordinator) {
+        const localHandlers = new ToolHandlers(this.localContext, this.snapshotManager, this.localSyncManager, this.runtimeFingerprint, this.capabilities, () => Date.now(), this.callGraphManager, null, undefined, undefined, this.runtimeOwnerRegistry, this.mutationLeaseCoordinator, continuationCoordinator);
+        const providerRuntime = new SessionProviderRuntime(this.providerRuntime, continuationCoordinator, this.mutationLeaseCoordinator, this.callGraphManager);
+        return {
+            localHandlers,
+            providerRuntime,
+            toolContext: {
+                context: this.localContext,
+                snapshotManager: this.snapshotManager,
+                syncManager: this.localSyncManager,
+                capabilities: this.capabilities,
+                reranker: null,
+                runtimeFingerprint: this.runtimeFingerprint,
+                toolHandlers: localHandlers,
+                readFileMaxLines: this.readFileMaxLines,
+                runtimeOwnerGate: this.runtimeOwnerRegistry,
+                providerRuntime,
+            },
+        };
+    }
+    registerSession() {
+        this.activeSessions += 1;
+        this.notifyActivityChanged();
+    }
+    unregisterSession() {
+        this.activeSessions = Math.max(0, this.activeSessions - 1);
+        this.notifyActivityChanged();
+    }
+    beginOperation() {
+        this.activeOperations += 1;
+        this.notifyActivityChanged();
+    }
+    endOperation() {
+        this.activeOperations = Math.max(0, this.activeOperations - 1);
+        this.notifyActivityChanged();
+    }
+    getActivity() {
+        return Object.freeze({
+            sessions: this.activeSessions,
+            operations: this.activeOperations
+                + this.providerRuntime.getActiveLifecycleOperationCount(),
+        });
+    }
+    getProviderRuntime() {
+        return this.providerRuntime;
+    }
+    subscribeActivity(listener) {
+        this.activityListeners.add(listener);
+        return () => this.activityListeners.delete(listener);
+    }
+    notifyActivityChanged() {
+        for (const listener of this.activityListeners) {
+            listener();
+        }
+    }
+    async recoverInterruptedIndexingAtStartup() {
+        await this.recoveryHandlers.recoverInterruptedIndexingAtStartup();
+    }
+    async shutdown() {
+        if (this.shutdownStarted)
+            return;
+        this.shutdownStarted = true;
+        await this.localSyncManager.stopAndDrainLifecycle();
+        await this.providerRuntime.shutdown();
+        this.recoveryHandlers.releaseSearchContinuationOwnership();
+        this.runtimeOwnerRegistry.unregisterCurrentOwner();
+    }
+}
+export class McpSession {
+    constructor(host) {
+        this.host = host;
+        this.continuationCoordinator = new SearchContinuationCoordinator();
+        this.activeToolCalls = 0;
+        this.connected = false;
+        this.closed = false;
+        this.resourcesReleased = false;
+        this.resourceReleasePromise = null;
+        this.resolveResourceRelease = null;
+        this.keepAliveTimer = null;
+        this.server = new Server({
+            name: host.config.name,
+            version: host.config.version,
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.resources = host.createSessionResources(this.continuationCoordinator);
+        this.setupTools();
+    }
+    setupTools() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: getMcpToolList(this.resources.toolContext),
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const tool = toolRegistry[name];
+            if (!tool) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Unknown tool: ${name}. Supported tools: ${Object.keys(toolRegistry).join(", ")}`,
+                        }],
+                    isError: true,
+                };
+            }
+            if (this.activeToolCalls >= SHARED_RUNTIME_MAX_PENDING_REQUESTS) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `This Satori session already has ${SHARED_RUNTIME_MAX_PENDING_REQUESTS} active tool calls. Wait for one to finish, then retry.`,
+                        }],
+                    isError: true,
+                };
+            }
+            this.activeToolCalls += 1;
+            this.host.beginOperation();
+            try {
+                return await withSourceMeasurementOperation({ operation: name }, () => tool.execute(args || {}, this.resources.toolContext));
+            }
+            finally {
+                this.activeToolCalls -= 1;
+                this.host.endOperation();
+                this.releaseResourcesIfIdle();
+            }
+        });
+    }
+    async connect(transport, resumeInput) {
+        if (this.connected) {
+            throw new Error("MCP session is already connected.");
+        }
+        this.connected = true;
+        this.host.registerSession();
+        try {
+            await this.server.connect(transport);
+            resumeInput?.resume();
+        }
+        catch (error) {
+            this.host.unregisterSession();
+            this.connected = false;
+            throw error;
+        }
+    }
+    async connectStdio(input, output) {
+        const transportInput = input ?? process.stdin;
+        const transportOutput = output ?? process.stdout;
+        await this.connect(new StdioServerTransport(transportInput, transportOutput), transportInput);
+        this.keepAliveTimer = setInterval(() => {
+            // Keep direct stdio sessions alive when provider lifecycle is lazy.
+        }, 60 * 60 * 1000);
+    }
+    async shutdown() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = null;
+        }
+        if (this.connected) {
+            this.connected = false;
+            this.host.unregisterSession();
+        }
+        await this.server.close().catch(() => undefined);
+        if (this.activeToolCalls > 0) {
+            this.resourceReleasePromise = new Promise((resolve) => {
+                this.resolveResourceRelease = resolve;
+            });
+            await this.resourceReleasePromise;
+        }
+        else {
+            this.releaseResourcesIfIdle();
+        }
+    }
+    releaseResourcesIfIdle() {
+        if (!this.closed || this.activeToolCalls > 0 || this.resourcesReleased)
+            return;
+        this.resourcesReleased = true;
+        this.resources.localHandlers.releaseSearchContinuationOwnership();
+        this.resources.providerRuntime.release();
+        this.resolveResourceRelease?.();
+        this.resolveResourceRelease = null;
+    }
+}
+//# sourceMappingURL=shared-runtime.js.map

package/dist/server/start-server.d.ts

@@ -1,6 +1,6 @@
 import { Readable, Writable } from "node:stream";
-import { ContextMcpConfig, IndexFingerprint } from "../config.js";
-export type ServerRunMode = "mcp" | "cli" | "postflight";
+import { ServerRunMode, SharedRuntimeHost } from "./shared-runtime.js";
+export type { ServerRunMode } from "./shared-runtime.js";
 export interface StartMcpServerOptions {
     runMode?: ServerRunMode;
     protocolStdin?: Readable;
@@ -19,38 +19,15 @@ interface StartupLifecycleDependencies {
  * pass bumps mutation generation and invalidates warm prepared-read observations.
  */
 export declare function runPostConnectStartupLifecycle(runMode: ServerRunMode, dependencies: StartupLifecycleDependencies): Promise<void>;
-declare class ContextMcpServer {
-    private server;
-    private toolContext;
-    private snapshotManager;
-    private syncManager;
-    private toolHandlers;
-    private capabilities;
-    private runtimeFingerprint;
-    private readFileMaxLines;
-    private watchSyncEnabled;
-    private watchDebounceMs;
-    private callGraphManager;
-    private providerRuntime;
-    private runtimeOwnerRegistry;
-    private mutationLeaseCoordinator;
-    private searchContinuationCoordinator;
-    private runMode;
-    private protocolStdin?;
-    private protocolStdout?;
-    private keepAliveTimer;
-    constructor(config: ContextMcpConfig, runtimeFingerprint: IndexFingerprint, runMode: ServerRunMode, protocolStdout?: Writable, protocolStdin?: Readable);
-    private getCliTransportStdout;
-    private getToolContext;
-    /**
-     * Verify interrupted indexing snapshots via the fenced recovery path.
-     * Must not publish lifecycle transitions without a mutation lease.
-     */
-    private verifyCloudState;
-    private setupTools;
+export declare class ContextMcpServer {
+    private readonly runMode;
+    private readonly protocolStdout?;
+    private readonly protocolStdin?;
+    private readonly host;
+    private readonly session;
+    constructor(config: ConstructorParameters<typeof SharedRuntimeHost>[0], runtimeFingerprint: ConstructorParameters<typeof SharedRuntimeHost>[1], runMode: ServerRunMode, protocolStdout?: Writable | undefined, protocolStdin?: Readable | undefined);
     start(): Promise<void>;
     shutdown(): Promise<void>;
 }
 export declare function startMcpServerFromEnv(options?: StartMcpServerOptions): Promise<ContextMcpServer | null>;
-export {};
 //# sourceMappingURL=start-server.d.ts.map

package/dist/server/start-server.js

@@ -1,20 +1,8 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { withSourceMeasurementOperation } from "@zokizuan/satori-core";
 import { createMcpConfig, logConfigurationSummary, resolveMcpRuntimeBootstrap, showHelpMessage, } from "../config.js";
-import { CapabilityResolver } from "../core/capabilities.js";
-import { SnapshotManager } from "../core/snapshot.js";
-import { SyncManager } from "../core/sync.js";
-import { SearchContinuationCoordinator, ToolHandlers, } from "../core/handlers.js";
-import { CallGraphSidecarManager } from "../core/call-graph.js";
-import { RuntimeOwnerRegistry, buildRuntimeOwnerIdentityFromConfig, } from "../core/runtime-owner.js";
-import { MutationLeaseCoordinator } from "../core/mutation-lease.js";
-import { getMcpToolList, toolRegistry } from "../tools/registry.js";
-import { createLocalOnlyContext, ProviderRuntime } from "./provider-runtime.js";
+import { SharedRuntimeHost, } from "./shared-runtime.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -66,134 +54,26 @@ function migrateLegacyStateDir() {
         console.error(`[MIGRATION] Failed to migrate '${legacyDir}' -> '${newDir}':`, errorMessage(copyError));
     }
 }
-class ContextMcpServer {
+export class ContextMcpServer {
     constructor(config, runtimeFingerprint, runMode, protocolStdout, protocolStdin) {
-        this.keepAliveTimer = null;
         this.runMode = runMode;
-        this.protocolStdin = protocolStdin;
         this.protocolStdout = protocolStdout;
-        this.server = new Server({
-            name: config.name,
-            version: config.version,
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.capabilities = new CapabilityResolver(config);
-        this.runtimeFingerprint = runtimeFingerprint;
-        this.readFileMaxLines = Math.max(1, config.readFileMaxLines ?? 1000);
-        this.watchSyncEnabled = config.watchSyncEnabled === true;
-        this.watchDebounceMs = Math.max(1, config.watchDebounceMs ?? 5000);
-        console.log(`[FINGERPRINT] Runtime index fingerprint: ${JSON.stringify(this.runtimeFingerprint)}`);
-        this.runtimeOwnerRegistry = new RuntimeOwnerRegistry({
-            identity: buildRuntimeOwnerIdentityFromConfig({
-                config,
-                runtimeFingerprint: this.runtimeFingerprint,
-            }),
-        });
-        try {
-            this.runtimeOwnerRegistry.registerCurrentOwner();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.warn(`[RUNTIME-OWNER] Failed to register current Satori runtime owner; index mutations will fail closed until the owner registry is writable: ${message}`);
-        }
-        this.mutationLeaseCoordinator = new MutationLeaseCoordinator();
-        this.searchContinuationCoordinator = new SearchContinuationCoordinator();
-        this.snapshotManager = new SnapshotManager(this.runtimeFingerprint);
-        this.callGraphManager = new CallGraphSidecarManager(this.runtimeFingerprint);
-        const localContext = createLocalOnlyContext(config, this.mutationLeaseCoordinator);
-        this.syncManager = new SyncManager(localContext, this.snapshotManager, {
-            watchEnabled: this.watchSyncEnabled,
-            watchDebounceMs: this.watchDebounceMs,
-            mutationLeaseCoordinator: this.mutationLeaseCoordinator,
-        });
-        this.toolHandlers = new ToolHandlers(localContext, this.snapshotManager, this.syncManager, this.runtimeFingerprint, this.capabilities, () => Date.now(), this.callGraphManager, null, undefined, undefined, this.runtimeOwnerRegistry, this.mutationLeaseCoordinator, this.searchContinuationCoordinator);
-        this.providerRuntime = new ProviderRuntime({
-            config,
-            snapshotManager: this.snapshotManager,
-            runtimeFingerprint: this.runtimeFingerprint,
-            capabilities: this.capabilities,
-            readFileMaxLines: this.readFileMaxLines,
-            watchSyncEnabled: this.watchSyncEnabled,
-            watchDebounceMs: this.watchDebounceMs,
-            startSyncLifecycle: this.runMode === "mcp",
-            callGraphManager: this.callGraphManager,
-            runtimeOwnerGate: this.runtimeOwnerRegistry,
-            mutationLeaseCoordinator: this.mutationLeaseCoordinator,
-            searchContinuationCoordinator: this.searchContinuationCoordinator,
-        });
-        this.toolContext = {
-            context: localContext,
-            snapshotManager: this.snapshotManager,
-            syncManager: this.syncManager,
-            capabilities: this.capabilities,
-            reranker: null,
-            runtimeFingerprint: this.runtimeFingerprint,
-            toolHandlers: this.toolHandlers,
-            readFileMaxLines: this.readFileMaxLines,
-            runtimeOwnerGate: this.runtimeOwnerRegistry,
-            providerRuntime: this.providerRuntime,
-        };
-        this.snapshotManager.loadCodebaseSnapshot();
-        this.setupTools();
-    }
-    getCliTransportStdout() {
-        if (this.protocolStdout) {
-            return this.protocolStdout;
-        }
-        if (this.runMode !== "cli") {
-            return process.stdout;
-        }
-        throw new Error("E_PROTOCOL_FAILURE Missing protocolStdout for cli mode");
-    }
-    getToolContext() {
-        return this.toolContext;
-    }
-    /**
-     * Verify interrupted indexing snapshots via the fenced recovery path.
-     * Must not publish lifecycle transitions without a mutation lease.
-     */
-    async verifyCloudState(_toolContext) {
-        console.log("[STARTUP] Verifying interrupted indexing state against completion markers...");
-        await this.toolHandlers.recoverInterruptedIndexingAtStartup();
-    }
-    setupTools() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: getMcpToolList(this.getToolContext()),
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            const tool = toolRegistry[name];
-            if (!tool) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Unknown tool: ${name}. Supported tools: ${Object.keys(toolRegistry).join(", ")}`,
-                        }],
-                    isError: true,
-                };
-            }
-            return withSourceMeasurementOperation({ operation: name }, () => tool.execute(args || {}, this.getToolContext()));
-        });
+        this.protocolStdin = protocolStdin;
+        this.host = new SharedRuntimeHost(config, runtimeFingerprint, runMode);
+        this.session = this.host.createSession();
     }
     async start() {
         console.log("Starting Satori MCP server...");
-        const transportStdin = this.protocolStdin ?? process.stdin;
-        const transport = this.runMode === "cli" || this.protocolStdin || this.protocolStdout
-            ? new StdioServerTransport(transportStdin, this.getCliTransportStdout())
-            : new StdioServerTransport();
-        await this.server.connect(transport);
-        transportStdin.resume();
-        this.keepAliveTimer = setInterval(() => {
-            // Keep stdio MCP process alive when startup has no background provider lifecycle.
-        }, 60 * 60 * 1000);
+        if (this.runMode === "cli" && !this.protocolStdout) {
+            throw new Error("E_PROTOCOL_FAILURE Missing protocolStdout for cli mode");
+        }
+        await this.session.connectStdio(this.protocolStdin, this.protocolStdout);
         console.log("MCP server started and listening on stdio.");
         await runPostConnectStartupLifecycle(this.runMode, {
-            verifyCloudState: () => this.verifyCloudState(this.getToolContext()),
+            verifyCloudState: async () => {
+                console.log("[STARTUP] Verifying interrupted indexing state against completion markers...");
+                await this.host.recoverInterruptedIndexingAtStartup();
+            },
             onVerifyCloudStateError: (error) => {
                 console.error("[STARTUP] Error verifying cloud state:", errorMessage(error));
             },
@@ -201,15 +81,8 @@ class ContextMcpServer {
     }
     async shutdown() {
         console.log("Shutting down Satori MCP server...");
-        if (this.keepAliveTimer) {
-            clearInterval(this.keepAliveTimer);
-            this.keepAliveTimer = null;
-        }
-        this.syncManager.stopBackgroundSync();
-        await this.syncManager.stopWatcherMode();
-        await this.providerRuntime.shutdown();
-        this.toolHandlers.releaseSearchContinuationOwnership();
-        this.runtimeOwnerRegistry.unregisterCurrentOwner();
+        await this.session.shutdown();
+        await this.host.shutdown();
     }
 }
 function isHelpRequested(args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zokizuan/satori-mcp",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Repo-aware MCP tools for AI coding agents: intent search, symbol navigation, advisory call graphs, exact reads, and freshness-aware recovery.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "jsonc-parser": "^3.3.1",
     "zod": "^3.25.55",
     "zod-to-json-schema": "^3.25.1",
-    "@zokizuan/satori-core": "3.1.0"
+    "@zokizuan/satori-core": "3.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",