@adhisang/minecraft-modding-mcp 1.2.1 → 2.1.0

package/dist/stdio-supervisor.d.ts

@@ -0,0 +1,46 @@
+type SupervisorOptions = {
+    entryFile: string;
+};
+export declare class StdioSupervisor {
+    private readonly entryFile;
+    private readonly clientReader;
+    private readonly workerReader;
+    private readonly queuedMessages;
+    private readonly pendingRequests;
+    private child;
+    private childReady;
+    private shuttingDown;
+    private restartTimer;
+    private workerStderrBuffer;
+    private clientMode;
+    private initializeRequest;
+    private initializedNotification;
+    private clientInitialized;
+    private replayingInitialization;
+    private initializeSentToWorker;
+    constructor(options: SupervisorOptions);
+    start(): Promise<void>;
+    private readonly handleClientData;
+    private readonly handleClientError;
+    private readonly handleClientClosed;
+    private readonly handleTerminateSignal;
+    private handleClientMessage;
+    private forwardToWorker;
+    private spawnWorker;
+    private readonly handleWorkerData;
+    private readonly handleWorkerStdinError;
+    private readonly handleWorkerStderr;
+    private readonly handleWorkerProcessError;
+    private readonly handleWorkerExit;
+    private handleWorkerMessage;
+    private handleWorkerReady;
+    private isInitializationResponse;
+    private flushQueue;
+    private failPendingRequestsOnWorkerExit;
+    private writeToClient;
+    private scheduleRestart;
+    private detachChild;
+    private shutdown;
+}
+export declare const STDIO_WORKER_MODE_ENV = "MCP_STDIO_WORKER_MODE";
+export {};

package/dist/stdio-supervisor.js

@@ -0,0 +1,349 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { encodeJsonRpcMessage, JsonRpcFrameReader } from "./json-rpc-framing.js";
+import { log } from "./logger.js";
+const DEFAULT_CLIENT_MODE = "line";
+const WORKER_MODE_ENV = "MCP_STDIO_WORKER_MODE";
+const WORKER_READY_MARKER = "__MCP_STDIO_WORKER_READY__";
+const SUPERVISOR_DEBUG_ENABLED = process.env.MCP_SUPERVISOR_DEBUG === "1";
+function isRequest(message) {
+    return "method" in message && "id" in message;
+}
+function isNotification(message) {
+    return "method" in message && !("id" in message);
+}
+function isResponse(message) {
+    return !("method" in message) && "id" in message;
+}
+function getTrackedRequestId(message) {
+    return typeof message.id === "string" || typeof message.id === "number"
+        ? message.id
+        : undefined;
+}
+function requestKey(id) {
+    return `${typeof id}:${String(id)}`;
+}
+function buildWorkerRestartError(id) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code: -32603,
+            message: "MCP worker restarted while handling the request. Retry the request."
+        }
+    };
+}
+function debugSupervisor(event, details) {
+    if (!SUPERVISOR_DEBUG_ENABLED) {
+        return;
+    }
+    log("info", `supervisor.debug.${event}`, details);
+}
+export class StdioSupervisor {
+    entryFile;
+    clientReader = new JsonRpcFrameReader();
+    workerReader = new JsonRpcFrameReader();
+    queuedMessages = [];
+    pendingRequests = new Map();
+    child;
+    childReady = false;
+    shuttingDown = false;
+    restartTimer;
+    workerStderrBuffer = "";
+    clientMode = DEFAULT_CLIENT_MODE;
+    initializeRequest;
+    initializedNotification;
+    clientInitialized = false;
+    replayingInitialization = false;
+    initializeSentToWorker = false;
+    constructor(options) {
+        this.entryFile = options.entryFile;
+    }
+    async start() {
+        process.stdin.on("data", this.handleClientData);
+        process.stdin.on("error", this.handleClientError);
+        process.stdin.on("end", this.handleClientClosed);
+        process.stdin.on("close", this.handleClientClosed);
+        process.stdin.resume();
+        process.on("SIGINT", this.handleTerminateSignal);
+        process.on("SIGTERM", this.handleTerminateSignal);
+        this.spawnWorker();
+    }
+    handleClientData = (chunk) => {
+        this.clientReader.processChunk(chunk, {
+            onFrame: ({ message, mode }) => {
+                this.clientMode = mode;
+                this.handleClientMessage(message);
+            },
+            onError: (error) => {
+                log("warn", "supervisor.client_parse_error", { message: error.message });
+            }
+        });
+    };
+    handleClientError = (error) => {
+        log("warn", "supervisor.client_stream_error", { message: error.message });
+    };
+    handleClientClosed = () => {
+        void this.shutdown();
+    };
+    handleTerminateSignal = () => {
+        void this.shutdown();
+    };
+    handleClientMessage(message) {
+        debugSupervisor("client_message", {
+            hasMethod: "method" in message,
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined,
+            childReady: this.childReady
+        });
+        if (isRequest(message) && message.method === "initialize") {
+            this.initializeRequest = message;
+            this.clientInitialized = false;
+        }
+        else if (isNotification(message) && message.method === "notifications/initialized") {
+            this.initializedNotification = message;
+        }
+        if (!this.childReady) {
+            this.queuedMessages.push(message);
+            return;
+        }
+        this.forwardToWorker(message);
+    }
+    forwardToWorker(message) {
+        const child = this.child;
+        if (!child || child.stdin.destroyed) {
+            this.queuedMessages.push(message);
+            if (!this.shuttingDown) {
+                this.scheduleRestart();
+            }
+            return;
+        }
+        if (isRequest(message)) {
+            const id = getTrackedRequestId(message);
+            if (id !== undefined) {
+                this.pendingRequests.set(requestKey(id), {
+                    id,
+                    method: message.method
+                });
+            }
+            if (message.method === "initialize") {
+                this.initializeSentToWorker = true;
+            }
+        }
+        debugSupervisor("forward_to_worker", {
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined
+        });
+        child.stdin.write(encodeJsonRpcMessage(message, "content-length"));
+    }
+    spawnWorker() {
+        if (this.shuttingDown) {
+            return;
+        }
+        const child = spawn(process.execPath, [...process.execArgv, this.entryFile], {
+            env: {
+                ...process.env,
+                [WORKER_MODE_ENV]: "1"
+            },
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        this.child = child;
+        this.childReady = false;
+        this.initializeSentToWorker = false;
+        this.workerReader.clear();
+        this.workerStderrBuffer = "";
+        child.stdout.on("data", this.handleWorkerData);
+        child.stderr.on("data", this.handleWorkerStderr);
+        child.stdin.on("error", this.handleWorkerStdinError);
+        child.once("error", this.handleWorkerProcessError);
+        child.once("exit", this.handleWorkerExit);
+        log("info", "supervisor.worker_spawn", { pid: child.pid });
+    }
+    handleWorkerData = (chunk) => {
+        this.workerReader.processChunk(chunk, {
+            onFrame: ({ message }) => {
+                this.handleWorkerMessage(message);
+            },
+            onError: (error) => {
+                log("warn", "supervisor.worker_parse_error", { message: error.message });
+            }
+        });
+    };
+    handleWorkerStdinError = (error) => {
+        if (error.code === "EPIPE") {
+            return;
+        }
+        log("warn", "supervisor.worker_stdin_error", { message: error.message });
+    };
+    handleWorkerStderr = (chunk) => {
+        this.workerStderrBuffer += chunk.toString();
+        const lines = this.workerStderrBuffer.split(/\r?\n/);
+        this.workerStderrBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line === WORKER_READY_MARKER) {
+                this.handleWorkerReady();
+                continue;
+            }
+            process.stderr.write(`${line}\n`);
+        }
+    };
+    handleWorkerProcessError = (error) => {
+        log("error", "supervisor.worker_process_error", { message: error.message });
+    };
+    handleWorkerExit = (code, signal) => {
+        const childPid = this.child?.pid;
+        this.detachChild();
+        if (this.shuttingDown) {
+            return;
+        }
+        log("warn", "supervisor.worker_exit", {
+            pid: childPid,
+            code,
+            signal,
+            pendingRequests: this.pendingRequests.size
+        });
+        this.failPendingRequestsOnWorkerExit();
+        this.scheduleRestart();
+    };
+    handleWorkerMessage(message) {
+        debugSupervisor("worker_message", {
+            hasMethod: "method" in message,
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined,
+            replayingInitialization: this.replayingInitialization
+        });
+        if (this.isInitializationResponse(message)) {
+            const id = getTrackedRequestId(message);
+            if (id !== undefined) {
+                this.pendingRequests.delete(requestKey(id));
+            }
+            if (this.replayingInitialization) {
+                this.replayingInitialization = false;
+                if (this.initializedNotification) {
+                    this.forwardToWorker(this.initializedNotification);
+                }
+                this.childReady = true;
+                this.flushQueue();
+                return;
+            }
+            this.clientInitialized = true;
+            this.childReady = true;
+            this.writeToClient(message);
+            this.flushQueue();
+            return;
+        }
+        if (isResponse(message)) {
+            const id = getTrackedRequestId(message);
+            if (id !== undefined) {
+                this.pendingRequests.delete(requestKey(id));
+            }
+        }
+        this.writeToClient(message);
+    }
+    handleWorkerReady() {
+        debugSupervisor("worker_ready", {
+            hasInitializeRequest: this.initializeRequest !== undefined,
+            clientInitialized: this.clientInitialized
+        });
+        if (!this.initializeRequest) {
+            this.childReady = true;
+            this.flushQueue();
+            return;
+        }
+        this.replayingInitialization = this.clientInitialized;
+        this.forwardToWorker(this.initializeRequest);
+    }
+    isInitializationResponse(message) {
+        const id = isResponse(message) ? getTrackedRequestId(message) : undefined;
+        const initializeId = this.initializeRequest
+            ? getTrackedRequestId(this.initializeRequest)
+            : undefined;
+        return (id !== undefined &&
+            initializeId !== undefined &&
+            requestKey(id) === requestKey(initializeId));
+    }
+    flushQueue() {
+        if (!this.childReady || this.queuedMessages.length === 0) {
+            return;
+        }
+        const pending = this.queuedMessages.splice(0, this.queuedMessages.length);
+        for (const message of pending) {
+            if (this.initializeSentToWorker &&
+                isRequest(message) &&
+                message.method === "initialize" &&
+                this.initializeRequest !== undefined &&
+                getTrackedRequestId(message) === getTrackedRequestId(this.initializeRequest)) {
+                continue;
+            }
+            this.forwardToWorker(message);
+        }
+    }
+    failPendingRequestsOnWorkerExit() {
+        const preservedInitializeKey = this.initializeRequest && !this.clientInitialized
+            ? requestKey(this.initializeRequest.id)
+            : undefined;
+        for (const [key, pending] of [...this.pendingRequests.entries()]) {
+            if (key === preservedInitializeKey) {
+                continue;
+            }
+            this.pendingRequests.delete(key);
+            this.writeToClient(buildWorkerRestartError(pending.id));
+        }
+    }
+    writeToClient(message) {
+        debugSupervisor("write_to_client", {
+            hasMethod: "method" in message,
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined,
+            clientMode: this.clientMode
+        });
+        const frame = encodeJsonRpcMessage(message, this.clientMode);
+        process.stdout.write(frame);
+    }
+    scheduleRestart() {
+        if (this.restartTimer || this.shuttingDown) {
+            return;
+        }
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = undefined;
+            this.spawnWorker();
+        }, 100);
+    }
+    detachChild() {
+        const child = this.child;
+        if (!child) {
+            this.childReady = false;
+            return;
+        }
+        child.stdout.off("data", this.handleWorkerData);
+        child.stderr.off("data", this.handleWorkerStderr);
+        child.stdin.off("error", this.handleWorkerStdinError);
+        child.off("error", this.handleWorkerProcessError);
+        child.off("exit", this.handleWorkerExit);
+        this.child = undefined;
+        this.childReady = false;
+    }
+    async shutdown() {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        if (this.restartTimer) {
+            clearTimeout(this.restartTimer);
+            this.restartTimer = undefined;
+        }
+        process.stdin.off("data", this.handleClientData);
+        process.stdin.off("error", this.handleClientError);
+        process.stdin.off("end", this.handleClientClosed);
+        process.stdin.off("close", this.handleClientClosed);
+        process.off("SIGINT", this.handleTerminateSignal);
+        process.off("SIGTERM", this.handleTerminateSignal);
+        const child = this.child;
+        this.detachChild();
+        if (child && child.exitCode === null) {
+            child.kill("SIGTERM");
+        }
+    }
+}
+export const STDIO_WORKER_MODE_ENV = WORKER_MODE_ENV;
+//# sourceMappingURL=stdio-supervisor.js.map

package/dist/storage/files-repo.d.ts

@@ -50,6 +50,7 @@ export declare class FilesRepo {
     private readonly searchPathStmt;
     private readonly searchFtsStmt;
     private readonly getByPathsStmtCache;
+    private readonly classLookupStmtCache;
     constructor(db: SqliteDatabase);
     clearFilesForArtifact(artifactId: string): void;
     insertFilesForArtifact(artifactId: string, files: IndexedFile[]): void;
@@ -70,6 +71,8 @@ export declare class FilesRepo {
     countTextCandidates(artifactId: string, query: string): number;
     countPathCandidates(artifactId: string, query: string): number;
     findFirstFilePathByName(artifactId: string, fileName: string): string | undefined;
+    private getClassLookupStmt;
+    findBestClassLookupPath(artifactId: string, exactFilePaths: string[], qualifiedClassName: string, simpleName: string, expectedPrefix: string): string | undefined;
     searchFiles(artifactId: string, options: SearchFilesOptions): PagedResult<SearchFilesResult>;
     totalContentBytes(): number;
     contentBytesForArtifact(artifactId: string): number;

package/dist/storage/files-repo.js

@@ -114,6 +114,7 @@ export class FilesRepo {
     searchPathStmt;
     searchFtsStmt;
     getByPathsStmtCache = new Map();
+    classLookupStmtCache = new Map();
     constructor(db) {
         this.db = db;
         this.deleteStmt = this.db.prepare(`
@@ -416,6 +417,65 @@ export class FilesRepo {
             .get(artifactId, normalized, `%/${normalized}`);
         return row?.file_path;
     }
+    getClassLookupStmt(exactPathCount) {
+        const cached = this.classLookupStmtCache.get(exactPathCount);
+        if (cached) {
+            return cached;
+        }
+        const exactPlaceholders = Array.from({ length: exactPathCount }, () => "?").join(", ");
+        const statement = this.db.prepare(`
+      WITH ranked_candidates AS (
+        SELECT file_path, 0 AS rank
+        FROM files
+        WHERE artifact_id = ?
+          AND file_path IN (${exactPlaceholders})
+
+        UNION ALL
+
+        SELECT file_path,
+          CASE
+            WHEN qualified_name = ? THEN 1
+            WHEN symbol_name = ? THEN 2
+            ELSE 3
+          END AS rank
+        FROM symbols
+        WHERE artifact_id = ?
+          AND symbol_kind = 'class'
+          AND (
+            qualified_name = ?
+            OR symbol_name = ?
+            OR qualified_name LIKE ?
+          )
+          AND (? = '' OR instr(file_path, ?) = 1)
+
+        UNION ALL
+
+        SELECT file_path, 4 AS rank
+        FROM files
+        WHERE artifact_id = ?
+          AND (file_path = ? OR file_path LIKE ? ESCAPE '\\')
+          AND (? = '' OR instr(file_path, ?) = 1)
+      )
+      SELECT file_path
+      FROM ranked_candidates
+      ORDER BY rank ASC, file_path ASC
+      LIMIT 1
+    `);
+        this.classLookupStmtCache.set(exactPathCount, statement);
+        return statement;
+    }
+    findBestClassLookupPath(artifactId, exactFilePaths, qualifiedClassName, simpleName, expectedPrefix) {
+        const normalizedExactFilePaths = [...new Set(exactFilePaths.map((entry) => entry.trim()).filter(Boolean))];
+        const normalizedClassName = qualifiedClassName.trim();
+        const normalizedSimpleName = simpleName.trim();
+        if (normalizedExactFilePaths.length === 0 || !normalizedClassName || !normalizedSimpleName) {
+            return undefined;
+        }
+        const stmt = this.getClassLookupStmt(normalizedExactFilePaths.length);
+        const fileName = `${normalizedSimpleName}.java`;
+        const row = stmt.get(artifactId, ...normalizedExactFilePaths, normalizedClassName, normalizedSimpleName, artifactId, normalizedClassName, normalizedSimpleName, `%.${normalizedSimpleName}`, expectedPrefix, expectedPrefix, artifactId, fileName, `%/${fileName}`, expectedPrefix, expectedPrefix);
+        return row?.file_path;
+    }
     searchFiles(artifactId, options) {
         const page = this.searchFilesWithContent(artifactId, options);
         return {
@@ -446,10 +506,15 @@ export class FilesRepo {
         const normalizedCount = Math.max(1, Math.trunc(pathCount));
         const cached = this.getByPathsStmtCache.get(normalizedCount);
         if (cached) {
+            this.getByPathsStmtCache.delete(normalizedCount);
+            this.getByPathsStmtCache.set(normalizedCount, cached);
             return cached;
         }
         if (this.getByPathsStmtCache.size >= 64) {
-            this.getByPathsStmtCache.clear();
+            const oldestKey = this.getByPathsStmtCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.getByPathsStmtCache.delete(oldestKey);
+            }
         }
         const placeholders = Array.from({ length: normalizedCount }, () => "?").join(", ");
         const stmt = this.db.prepare(`

package/dist/storage/migrations.d.ts

@@ -6,6 +6,6 @@ type MigrationRunner = {
     };
     transaction<T>(fn: () => T): () => T;
 };
-export declare const LATEST_SCHEMA_VERSION = 1;
+export declare const LATEST_SCHEMA_VERSION = 2;
 export declare function runMigrations(db: MigrationRunner): number;
 export {};

package/dist/storage/migrations.js

@@ -1,10 +1,14 @@
 import { createError, ERROR_CODES } from "../errors.js";
-import { SCHEMA_V1_STATEMENTS } from "./schema.js";
-export const LATEST_SCHEMA_VERSION = 1;
+import { SCHEMA_V1_STATEMENTS, SCHEMA_V2_STATEMENTS } from "./schema.js";
+export const LATEST_SCHEMA_VERSION = 2;
 const migrations = [
     {
         version: 1,
         statements: SCHEMA_V1_STATEMENTS
+    },
+    {
+        version: 2,
+        statements: SCHEMA_V2_STATEMENTS
     }
 ];
 function selectSchemaVersion(tx) {

package/dist/storage/schema.d.ts

@@ -1 +1,2 @@
 export declare const SCHEMA_V1_STATEMENTS: string[];
+export declare const SCHEMA_V2_STATEMENTS: string[];

package/dist/storage/schema.js

@@ -157,4 +157,11 @@ export const SCHEMA_V1_STATEMENTS = [
        );
    END`
 ];
+export const SCHEMA_V2_STATEMENTS = [
+    `DELETE FROM symbols`,
+    `DELETE FROM files`,
+    `DELETE FROM artifact_content_bytes`,
+    `DELETE FROM artifact_index_meta`,
+    `DELETE FROM artifacts`
+];
 //# sourceMappingURL=schema.js.map

package/dist/symbols/symbol-extractor.js

@@ -1,11 +1,12 @@
 const CLASS_DECLARATION = /^(?:\s*@[\w.]+\s+)*(?:\s*(?:public|private|protected|abstract|final|sealed|non-sealed|static)\s+)*\s*(class|interface|enum|record)\s+([A-Za-z_$][\w$]*)/;
 const METHOD_DECLARATION = /^(?:\s*@[\w.]+\s+)*[^{;]*?\b([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?:\{|;)/;
 const FIELD_DECLARATION = /^(?:\s*@[\w.]+\s+)*[^\s][\w<>\[\],.?]+\s+([A-Za-z_$][\w$]*)\s*(?:=|;|,)/;
+const NOISE_TOKENS = new Set(["if", "for", "while", "switch", "catch", "return", "new", "throw"]);
 function normalizeLine(line) {
     return line.replace(/\s+/g, " ").trim();
 }
 function isNoiseToken(token) {
-    return new Set(["if", "for", "while", "switch", "catch", "return", "new", "throw"]).has(token);
+    return NOISE_TOKENS.has(token);
 }
 function lineIndexToLine(lineNo) {
     return lineNo + 1;
@@ -13,6 +14,7 @@ function lineIndexToLine(lineNo) {
 export function extractSymbolsFromSource(filePath, content) {
     const lines = content.split(/\r?\n/);
     const symbols = [];
+    const qualifiedName = filePath.replace(/\.java$/, "").replaceAll("/", ".");
     for (let index = 0; index < lines.length; index += 1) {
         const rawLine = lines[index] ?? "";
         const line = normalizeLine(rawLine);
@@ -27,7 +29,7 @@ export function extractSymbolsFromSource(filePath, content) {
                 symbols.push({
                     symbolKind,
                     symbolName,
-                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    qualifiedName,
                     line: lineIndexToLine(index)
                 });
             }
@@ -40,7 +42,7 @@ export function extractSymbolsFromSource(filePath, content) {
                 symbols.push({
                     symbolKind: "method",
                     symbolName,
-                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    qualifiedName,
                     line: lineIndexToLine(index)
                 });
             }
@@ -53,7 +55,7 @@ export function extractSymbolsFromSource(filePath, content) {
                 symbols.push({
                     symbolKind: "field",
                     symbolName,
-                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    qualifiedName,
                     line: lineIndexToLine(index)
                 });
             }

package/dist/tool-execution-gate.d.ts

@@ -0,0 +1,15 @@
+type GateOptions = {
+    maxConcurrent: number;
+    maxQueue: number;
+};
+export declare class ToolExecutionGate {
+    private readonly maxConcurrent;
+    private readonly maxQueue;
+    private activeCount;
+    private readonly queue;
+    constructor(options?: Partial<GateOptions>);
+    run<T>(tool: string, task: () => Promise<T>): Promise<T>;
+    private execute;
+    private drain;
+}
+export {};

package/dist/tool-execution-gate.js

@@ -0,0 +1,58 @@
+import { createError, ERROR_CODES } from "./errors.js";
+const DEFAULT_OPTIONS = {
+    maxConcurrent: 1,
+    maxQueue: 2
+};
+export class ToolExecutionGate {
+    maxConcurrent;
+    maxQueue;
+    activeCount = 0;
+    queue = [];
+    constructor(options = {}) {
+        this.maxConcurrent = Math.max(1, Math.trunc(options.maxConcurrent ?? DEFAULT_OPTIONS.maxConcurrent));
+        this.maxQueue = Math.max(0, Math.trunc(options.maxQueue ?? DEFAULT_OPTIONS.maxQueue));
+    }
+    run(tool, task) {
+        if (this.activeCount < this.maxConcurrent) {
+            return this.execute({ tool, task: task });
+        }
+        if (this.queue.length >= this.maxQueue) {
+            return Promise.reject(createError({
+                code: ERROR_CODES.LIMIT_EXCEEDED,
+                message: `Heavy tool queue is full; "${tool}" was not started.`,
+                details: {
+                    tool,
+                    activeCount: this.activeCount,
+                    queuedCount: this.queue.length,
+                    maxConcurrent: this.maxConcurrent,
+                    maxQueue: this.maxQueue,
+                    nextAction: "Retry after the current heavy analysis request completes. Avoid sending multiple heavy mapping/version analysis tools in parallel."
+                }
+            }));
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                tool,
+                task: task,
+                resolve: resolve,
+                reject
+            });
+        });
+    }
+    execute(entry) {
+        this.activeCount += 1;
+        return Promise.resolve()
+            .then(entry.task)
+            .finally(() => {
+            this.activeCount = Math.max(0, this.activeCount - 1);
+            this.drain();
+        });
+    }
+    drain() {
+        while (this.activeCount < this.maxConcurrent && this.queue.length > 0) {
+            const next = this.queue.shift();
+            this.execute(next).then(next.resolve, next.reject);
+        }
+    }
+}
+//# sourceMappingURL=tool-execution-gate.js.map

package/dist/tool-input.d.ts

@@ -0,0 +1,6 @@
+export type PreparedToolInput = {
+    normalizedInput: unknown;
+    removedOfficialPaths: string[];
+    suggestedReplacementInput?: Record<string, unknown>;
+};
+export declare function prepareToolInput(rawInput: unknown): PreparedToolInput;