@adhisang/minecraft-modding-mcp 3.1.1 → 3.2.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project aims to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.2.0] - 2026-04-12
+
+### Added
+- `resolve-artifact`, `find-mapping`, `resolve-method-mapping-exact`, `resolve-workspace-symbol`, and `check-symbol-exists` now accept an optional `compact` parameter (default `false`). When `true`, empty arrays, null values, and empty objects are stripped from the top-level response. For `resolve-artifact`, compact mode additionally omits `provenance`, `artifactContents`, `sampleEntries`, `adjacentSourceCandidates`, `binaryJarPath`, `coordinate`, `repoUrl`, and `resolvedSourceJarPath`. For mapping tools, compact mode omits the redundant `candidates` array when the result is a single full-confidence exact-match resolution.
+- `validate-access-widener` now accepts `projectPath`, `scope`, and `preferProjectVersion` for runtime-aware validation against Loom runtime jars, and reports additive `provenance`, `resolvedInRuntime`, and `resolvedRuntimeAccess` evidence for matched class, method, and field entries.
+- Added `validate-access-transformer` for Forge / NeoForge Access Transformer validation, including `atNamespace` support, workspace-driven namespace inference, runtime artifact provenance, and per-entry runtime access evidence.
+- `analyze-mod-jar` now surfaces packaged Access Transformer paths alongside mod metadata.
+
+### Fixed
+- `validate-access-widener` and `validate-access-transformer` runtime-aware method validation now preserves remapped JVM descriptors through exact and fallback member remaps, eliminating false-negative `method not found` results for entries whose descriptors reference remapped Minecraft classes such as `Level#setBlock(BlockPos, BlockState, int)`.
+- `validate-access-widener` runtime-aware `scope: "merged"` now prefers explicit `*merged-intermediary*` / `*merged-mojang*` runtime jars over ambiguous `minecraft-merged.jar` candidates, and Loom tiny lookup now scans workspace and Gradle user-home caches so runtime validation can resolve descriptor remaps in normal Loom setups.
+- `validate-project` now forwards workspace runtime context to discovered Access Widener validation so project-summary runs can use the same runtime-aware behavior as direct `validate-access-widener` calls.
+- `validate-project` now discovers Access Transformer files, supports `task="access-transformer"`, and can include those validations in workspace summaries when `discover` requests them.
+- `resolve-artifact`, `get-class-source`, `get-class-members`, and `inspect-minecraft` source/class-member flows now treat unobfuscated releases such as `26.1+` as native `mojang` runtime namespaces for both version and versioned-coordinate targets, avoiding false `ERR_MAPPING_NOT_APPLIED` failures and wrong-version Loom source-jar approximations when no exact source jar is present.
+- `validate-mixin` tool-health diagnostics now treat unobfuscated `mojang` runtime names as available, while still flagging `intermediary`/`yarn` as unavailable on `26.1+`.
+- `validate-project task="project-summary"` now pre-resolves `preferProjectVersion=true` consistently across discovered Access Widener and workspace Mixin checks, and returns a blocked summary with version-agnostic recovery guidance when discovered validators need a version but neither the request nor `gradle.properties` can supply one.
+- `check-symbol-exists` and `analyze-symbol task="exists"` now fall back to unobfuscated runtime bytecode for `mojang`/runtime-name existence checks on `26.1+`, preserve the original `mapping_unavailable` result when the runtime JAR cannot be resolved, and return a targeted warning when callers provide only a short class name.
+- Loom tiny mapping discovery no longer performs unbounded directory traversal when the version-specific cache directory is absent, preventing excessive memory consumption on systems with large Gradle caches.
+- Mapping graph cache eviction after lifecycle scans now correctly releases all cached entries for a version instead of silently skipping them.
+
+### Performance
+- `resolve-artifact` source-jar detection and mapping tiny-jar loading now reuse a single ZIP walk per jar probe instead of reopening and fully enumerating matching archives on each helper call.
+- `search-mod-source`, `decompile-mod-jar`, `get-mod-class-source`, `validate-project` workspace discovery, and workspace mapping detection now avoid synchronous hot-path file/glob reads and use bounded concurrent text reads where safe, reducing event-loop stalls on larger decompiled outputs and multi-module workspaces.
+
 ## [3.1.1] - 2026-03-21
 
 ### Fixed

package/README.md

@@ -20,8 +20,8 @@
 - **Source Exploration**: browse and search decompiled Minecraft source code with line-level precision and cursor-paginated file listing
 - **Multi-Mapping Conversion**: translate class, field, and method names between `obfuscated`, `mojang`, `intermediary`, and `yarn`
 - **Version Comparison**: diff class signatures and registry entries between Minecraft versions
-- **Mod JAR Analysis**: extract metadata, dependencies, entrypoints, and Mixin configs from Fabric, Forge, and NeoForge mod JARs
-- **Mixin and Access Widener Validation**: validate source and `.accesswidener` files against a target Minecraft version
+- **Mod JAR Analysis**: extract metadata, dependencies, entrypoints, Mixin configs, and packaged Access Transformer paths from Fabric, Forge, and NeoForge mod JARs
+- **Mixin, Access Widener, and Access Transformer Validation**: validate source, `.accesswidener`, and Forge/NeoForge access transformer files against a target Minecraft version
 - **NBT Round-Trip**: decode NBT binary to typed JSON, apply RFC 6902 patches, and encode it back to NBT
 - **Registry Data and Runtime Metrics**: query generated registry snapshots and inspect cache and latency counters
 - **MCP Resources**: expose versions, class source, artifact metadata, and mappings through URI-based resources
@@ -136,7 +136,7 @@ All six return `result.summary` first, and can include `summary.nextActions` whe
 | `analyze-symbol` | symbol existence checks, mapping conversion, lifecycle tracing, and workspace symbol resolution |
 | `compare-minecraft` | version-pair diffs, class diffs, registry diffs, and migration-oriented overviews |
 | `analyze-mod` | mod metadata, decompile/search flows, class source, and safe remap preview/apply |
-| `validate-project` | workspace summaries plus direct Mixin and Access Widener validation |
+| `validate-project` | workspace summaries plus direct Mixin, Access Widener, and Access Transformer validation |
 | `manage-cache` | cache inventory, verification, and preview/apply cleanup workflows |
 
 ### Workflow Notes
@@ -147,7 +147,10 @@ Keep only the high-frequency notes here. For the full pitfall list, exact contra
 - If you do not already have an artifact, prefer `subject.kind="workspace"` for `inspect-minecraft` instead of guessing artifact details. When artifact context is the only missing input, a retryable `suggestedCall` preserves the requested task.
 - `trace-symbol-lifecycle` expects `Class.method` in `symbol`. Keep exact overload matching in the separate `descriptor` field.
 - Workspace inspection can still confirm vanilla classes when source coverage is partial, and `inspect-minecraft task="list-files"` reports a partial result with follow-up guidance when that happens.
+- `check-symbol-exists` and `analyze-symbol task="exists"` now validate `mojang` lookups on unobfuscated releases such as `26.1+` against runtime bytecode when no mapping graph exists, preserve the original `mapping_unavailable` result if the runtime JAR itself cannot be resolved, and return a targeted warning when callers provide only a short class name.
 - `analyze-mod` and `validate-project` still require structured `subject` objects and canonical `include` groups, but stale string-subject or domain-include payloads now return `ERR_INVALID_INPUT` with a retryable `suggestedCall`.
+- `validate-project task="project-summary"` now pre-resolves `preferProjectVersion=true` consistently across discovered Access Widener, Access Transformer, and Mixin checks, and blocks with version-agnostic recovery guidance when discovered validators need a version but neither the request nor `gradle.properties` can supply one.
+- Local source-jar probing, decompiled mod source reads, and workspace discovery now avoid synchronous hot-path ZIP/file scans and use bounded concurrent reads where safe, so cold `resolve-artifact`, `analyze-mod`, and `validate-project` workflows stay more responsive on larger jars and multi-module workspaces.
 
 ### Inspect Minecraft source from a version
 
@@ -216,7 +219,7 @@ Keep only the high-frequency notes here. For the full pitfall list, exact contra
     "subject": {
       "kind": "workspace",
       "projectPath": "/workspace/modid",
-      "discover": ["mixins", "access-wideners"]
+      "discover": ["mixins", "access-wideners", "access-transformers"]
     },
     "preferProjectVersion": true,
     "preferProjectMapping": true
@@ -224,6 +227,8 @@ Keep only the high-frequency notes here. For the full pitfall list, exact contra
 }
 ```
 
+Workspace summaries still default to discovering mixins and access wideners. Add `"access-transformers"` to `subject.discover` when you want Access Transformer files included in the summary run.
+
 ## Documentation
 
 - [Detailed example requests](docs/examples.md) for copyable payloads and common workflows
@@ -243,7 +248,7 @@ Start with these top-level workflow tools unless you already know the exact spec
 | `analyze-symbol` | Handle symbol existence checks, namespace mapping, lifecycle tracing, workspace symbol resolution, and API overviews |
 | `compare-minecraft` | Compare version pairs, class diffs, registry diffs, and migration-oriented summaries |
 | `analyze-mod` | Summarize mod metadata, decompile and search mod code, inspect class source, and preview or apply remaps |
-| `validate-project` | Summarize workspaces and run direct Mixin or Access Widener validation |
+| `validate-project` | Summarize workspaces and run direct Mixin, Access Widener, or Access Transformer validation |
 | `manage-cache` | List, verify, and preview or apply cache cleanup and rebuild operations |
 <!-- END GENERATED TOOL TABLE: v3-entry-tools -->
 
@@ -265,6 +270,8 @@ Tools for browsing Minecraft versions, resolving source artifacts, and reading o
 | `index-artifact` | Rebuild indexed metadata for an existing artifact |
 <!-- END GENERATED TOOL TABLE: source-exploration -->
 
+For unobfuscated releases such as `26.1+`, `mapping="mojang"` now uses the runtime/decompile path directly for version and versioned-coordinate targets and skips Loom source-jar discovery entirely, while `intermediary` and `yarn` still fall back to `obfuscated` with a warning.
+
 ### Version Comparison & Symbol Tracking
 
 Tools for comparing class and registry changes across Minecraft versions and tracing symbol existence over time.
@@ -291,6 +298,8 @@ Tools for converting symbol names between namespaces and checking symbol existen
 | `check-symbol-exists` | Check whether a class, field, or method exists in a namespace |
 <!-- END GENERATED TOOL TABLE: mapping-symbols -->
 
+`resolve-artifact`, `find-mapping`, `resolve-method-mapping-exact`, `resolve-workspace-symbol`, and `check-symbol-exists` accept an optional `compact` parameter (default `false`). When `true`, empty arrays, null values, and empty objects are stripped from the top-level response to reduce token overhead. For `resolve-artifact`, compact mode additionally omits diagnostic fields (`provenance`, `artifactContents`, `sampleEntries`, `adjacentSourceCandidates`, `binaryJarPath`, `coordinate`, `repoUrl`, `resolvedSourceJarPath`), returning only the essential fields needed for downstream tool calls. For mapping tools, compact mode omits the redundant `candidates` array when the result is a single full-confidence exact-match resolution (`resolved=true`, `resolvedSymbol` present, `candidates.length=1`, `candidateCount=1`, `!candidatesTruncated`, `matchKind="exact"`, `confidence` missing or `1`).
+
 ### NBT Utilities
 
 Tools for decoding, patching, and encoding Java Edition NBT binary data using a typed JSON representation.
@@ -310,7 +319,7 @@ Tools for extracting metadata from mod JARs, decompiling mod source, searching m
 <!-- BEGIN GENERATED TOOL TABLE: mod-analysis -->
 | Tool | Purpose |
 | --- | --- |
-| `analyze-mod-jar` | Extract mod metadata, dependencies, entrypoints, and mixin config info from a JAR |
+| `analyze-mod-jar` | Extract mod metadata, dependencies, entrypoints, mixin config info, and packaged access transformer paths from a JAR |
 | `decompile-mod-jar` | Decompile a mod JAR and optionally return one class source |
 | `get-mod-class-source` | Read one class source from the decompiled mod cache |
 | `search-mod-source` | Search decompiled mod source by class, method, field, or content |
@@ -319,13 +328,16 @@ Tools for extracting metadata from mod JARs, decompiling mod source, searching m
 
 ### Validation
 
-Tools for validating Mixin source and Access Widener files against a target Minecraft version.
+Tools for validating Mixin source, Access Widener files, and Forge/NeoForge Access Transformer files against a target Minecraft version.
+`validate-access-widener` keeps vanilla bytecode validation by default, and now also supports runtime-aware validation through `projectPath`, `scope`, and `preferProjectVersion`, returning runtime `provenance` plus per-entry `resolvedRuntimeAccess` evidence when that mode is used. Runtime-aware method validation now preserves remapped JVM descriptors across namespace changes, searches Loom tiny mappings from workspace and Gradle user-home caches, and prefers explicit `*merged-intermediary*` / `*merged-mojang*` jars over ambiguous `minecraft-merged.jar` candidates.
+`validate-access-transformer` infers `atNamespace` from Forge or NeoForge workspace context when `projectPath` is provided, validates packaged or inline AT content, and uses loader/runtime artifacts for `scope="loader"` instead of treating loader as a merged-only alias.
 
 <!-- BEGIN GENERATED TOOL TABLE: validation -->
 | Tool | Purpose |
 | --- | --- |
 | `validate-mixin` | Validate Mixin source against a target Minecraft version |
-| `validate-access-widener` | Validate Access Widener content against a target Minecraft version |
+| `validate-access-widener` | Validate Access Widener content against a target Minecraft version, optionally using runtime-aware Loom artifacts |
+| `validate-access-transformer` | Validate Access Transformer content against a target Minecraft version, optionally using Forge/NeoForge runtime artifacts |
 <!-- END GENERATED TOOL TABLE: validation -->
 
 ### Registry & Diagnostics

package/dist/access-transformer-parser.d.ts

@@ -0,0 +1,17 @@
+export type AccessTransformerAccessAction = "public" | "protected" | "package-private" | "private";
+export type AccessTransformerFinalAction = "add" | "remove";
+export type AccessTransformerEntry = {
+    line: number;
+    targetKind: "class" | "field" | "method";
+    owner: string;
+    target: string;
+    name?: string;
+    descriptor?: string;
+    accessAction: AccessTransformerAccessAction;
+    finalAction?: AccessTransformerFinalAction;
+};
+export type ParsedAccessTransformer = {
+    entries: AccessTransformerEntry[];
+    parseWarnings: string[];
+};
+export declare function parseAccessTransformer(content: string): ParsedAccessTransformer;

package/dist/access-transformer-parser.js

@@ -0,0 +1,97 @@
+function parseAccessDeclaration(raw) {
+    const match = raw.match(/^(public|protected|default|private)([+-]f)?$/i);
+    if (!match) {
+        return undefined;
+    }
+    const finalModifier = match[2]?.toLowerCase();
+    return {
+        accessAction: match[1]?.toLowerCase() === "default"
+            ? "package-private"
+            : match[1]?.toLowerCase(),
+        ...(finalModifier === "+f" ? { finalAction: "add" } : {}),
+        ...(finalModifier === "-f" ? { finalAction: "remove" } : {})
+    };
+}
+function splitMemberToken(tokens) {
+    if (tokens.length === 0) {
+        return { targetKind: "class" };
+    }
+    if (tokens.length === 1) {
+        const token = tokens[0] ?? "";
+        const descriptorStart = token.indexOf("(");
+        if (descriptorStart >= 0) {
+            return {
+                targetKind: "method",
+                name: token.slice(0, descriptorStart),
+                descriptor: token.slice(descriptorStart)
+            };
+        }
+        return {
+            targetKind: "field",
+            name: token
+        };
+    }
+    return {
+        targetKind: "method",
+        name: tokens[0],
+        descriptor: tokens.slice(1).join("")
+    };
+}
+export function parseAccessTransformer(content) {
+    const entries = [];
+    const parseWarnings = [];
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index++) {
+        const lineNumber = index + 1;
+        const rawLine = (lines[index] ?? "").trim();
+        if (!rawLine || rawLine.startsWith("#")) {
+            continue;
+        }
+        const withoutComment = rawLine.replace(/\s+#.*$/, "").trim();
+        if (!withoutComment) {
+            continue;
+        }
+        const parts = withoutComment.split(/\s+/);
+        if (parts.length < 2) {
+            parseWarnings.push(`Line ${lineNumber}: Incomplete access transformer entry "${withoutComment}".`);
+            continue;
+        }
+        const declaration = parseAccessDeclaration(parts[0] ?? "");
+        if (!declaration) {
+            parseWarnings.push(`Line ${lineNumber}: Unsupported access declaration "${parts[0]}".`);
+            continue;
+        }
+        const owner = parts[1] ?? "";
+        if (!owner) {
+            parseWarnings.push(`Line ${lineNumber}: Incomplete access transformer entry "${withoutComment}".`);
+            continue;
+        }
+        const member = splitMemberToken(parts.slice(2));
+        if (member.targetKind === "method" && (!member.name || !member.descriptor)) {
+            parseWarnings.push(`Line ${lineNumber}: Method entry requires a method name and JVM descriptor.`);
+            continue;
+        }
+        if ((member.targetKind === "field" || member.targetKind === "method") && !member.name) {
+            parseWarnings.push(`Line ${lineNumber}: Member entry requires a target name.`);
+            continue;
+        }
+        const target = member.targetKind === "class"
+            ? owner
+            : `${owner}#${member.name}${member.descriptor ?? ""}`;
+        entries.push({
+            line: lineNumber,
+            owner,
+            target,
+            targetKind: member.targetKind,
+            ...(member.name ? { name: member.name } : {}),
+            ...(member.descriptor ? { descriptor: member.descriptor } : {}),
+            accessAction: declaration.accessAction,
+            ...(declaration.finalAction ? { finalAction: declaration.finalAction } : {})
+        });
+    }
+    return {
+        entries,
+        parseWarnings
+    };
+}
+//# sourceMappingURL=access-transformer-parser.js.map

package/dist/concurrency.d.ts

@@ -0,0 +1 @@
+export declare function mapWithConcurrencyLimit<T, R>(items: readonly T[], limit: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/concurrency.js

@@ -0,0 +1,24 @@
+export async function mapWithConcurrencyLimit(items, limit, mapper) {
+    if (!Number.isInteger(limit) || limit < 1) {
+        throw new Error("limit must be a positive integer");
+    }
+    if (items.length === 0) {
+        return [];
+    }
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(limit, items.length);
+    const worker = async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    };
+    await Promise.all(Array.from({ length: workerCount }, async () => worker()));
+    return results;
+}
+//# sourceMappingURL=concurrency.js.map

package/dist/decompiler/vineflower.js

@@ -1,11 +1,13 @@
-import { access, constants } from "node:fs/promises";
-import { mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import { access, constants, mkdir, readFile, readdir, stat } from "node:fs/promises";
+import { mkdirSync, rmSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { basename, join, relative, sep } from "node:path";
+import { mapWithConcurrencyLimit } from "../concurrency.js";
 import { createError, ERROR_CODES, isAppError } from "../errors.js";
 import { assertJavaAvailable, runJavaProcess } from "../java-process.js";
 import { log } from "../logger.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
+const DECOMPILED_JAVA_READ_CONCURRENCY = 8;
 const VINEFLOWER_FLAG_PROFILES = [
     { label: "default", flags: ["-din=1", "-rbr=1", "-dgs=1"] },
     { label: "relaxed", flags: ["-din=1", "-rbr=0", "-dgs=0"] },
@@ -47,14 +49,14 @@ async function assertVineflowerAvailable(vineflowerJarPath) {
         });
     }
 }
-function collectJavaFilesSync(baseDir, currentDir = "") {
+async function collectJavaFilesRecursive(baseDir, currentDir = "") {
     const absoluteBase = currentDir ? join(baseDir, currentDir) : baseDir;
-    const entries = readdirSync(absoluteBase, { withFileTypes: true });
+    const entries = await readdir(absoluteBase, { withFileTypes: true });
     const result = [];
     for (const entry of entries) {
         const next = currentDir ? join(currentDir, entry.name) : entry.name;
         if (entry.isDirectory()) {
-            result.push(...collectJavaFilesSync(baseDir, next));
+            result.push(...await collectJavaFilesRecursive(baseDir, next));
             continue;
         }
         if (entry.isFile() && entry.name.endsWith(".java")) {
@@ -66,23 +68,21 @@ function collectJavaFilesSync(baseDir, currentDir = "") {
 async function collectJavaFiles(baseDir) {
     try {
         const fastGlobModule = (await import("fast-glob"));
-        const sync = fastGlobModule.default?.sync;
-        if (typeof sync === "function") {
-            return sync("**/*.java", { cwd: baseDir, onlyFiles: true });
+        const glob = fastGlobModule.default?.glob;
+        if (typeof glob === "function") {
+            return (await glob("**/*.java", { cwd: baseDir, onlyFiles: true }))
+                .sort((left, right) => left.localeCompare(right));
         }
     }
     catch {
         // optional dependency: fallback to recursive traversal
     }
-    return collectJavaFilesSync(baseDir).map((candidate) => candidate.split(sep).join("/"));
+    return (await collectJavaFilesRecursive(baseDir))
+        .map((candidate) => candidate.split(sep).join("/"))
+        .sort((left, right) => left.localeCompare(right));
 }
 function readFileTreeText(filePath) {
-    return new Promise((resolve, reject) => {
-        import("node:fs/promises")
-            .then((fs) => fs.readFile(filePath, "utf8"))
-            .then(resolve)
-            .catch(reject);
-    });
+    return readFile(filePath, "utf8");
 }
 function decompileOutputDir(cacheDir, binaryJarPath, signature) {
     const digest = createHash("sha256").update(binaryJarPath).update(signature).digest("hex");
@@ -130,17 +130,18 @@ export async function decompileBinaryJar(binaryJarPath, cacheDir, options) {
     const signature = options.signature ?? basename(normalizedBinaryJarPath);
     const outputDir = decompileOutputDir(cacheDir, normalizedBinaryJarPath, signature).replace(/[/\\]$/, "");
     try {
-        mkdirSync(outputDir, { recursive: true });
-        if (statSync(outputDir, { throwIfNoEntry: false })) {
+        await mkdir(outputDir, { recursive: true });
+        const outputDirStats = await stat(outputDir).catch(() => undefined);
+        if (outputDirStats) {
             const existingJavaFiles = await collectJavaFiles(outputDir);
             if (existingJavaFiles.length > 0) {
-                const results = await Promise.all(existingJavaFiles.map(async (candidate) => {
+                const results = await mapWithConcurrencyLimit(existingJavaFiles, DECOMPILED_JAVA_READ_CONCURRENCY, async (candidate) => {
                     const abs = join(outputDir, candidate);
                     return {
                         filePath: normalizeOutputPath(outputDir, abs),
                         content: await readFileTreeText(abs)
                     };
-                }));
+                });
                 emitDecompileLog("decompile.done", {
                     durationMs: Date.now() - startedAt,
                     artifactIdCandidate: options.artifactIdCandidate,
@@ -181,13 +182,13 @@ export async function decompileBinaryJar(binaryJarPath, cacheDir, options) {
                         }
                     });
                 }
-                const javaFiles = await Promise.all(javaFileNames.map(async (candidate) => {
+                const javaFiles = await mapWithConcurrencyLimit(javaFileNames, DECOMPILED_JAVA_READ_CONCURRENCY, async (candidate) => {
                     const abs = join(outputDir, candidate);
                     return {
                         filePath: normalizeOutputPath(outputDir, abs),
                         content: await readFileTreeText(abs)
                     };
-                }));
+                });
                 emitDecompileLog("decompile.done", {
                     durationMs: Date.now() - startedAt,
                     artifactIdCandidate: options.artifactIdCandidate,

package/dist/entry-tools/analyze-mod-service.d.ts

@@ -75,7 +75,7 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
 }, "strip", z.ZodTypeAny, {
     limit: number;
-    searchType: "class" | "method" | "field" | "all" | "content";
+    searchType: "class" | "field" | "method" | "all" | "content";
     task: "search" | "remap" | "summary" | "class-source" | "decompile";
     subject: {
         kind: "jar";
@@ -111,7 +111,7 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
     targetMapping?: "mojang" | "yarn" | undefined;
     outputJar?: string | undefined;
     query?: string | undefined;
-    searchType?: "class" | "method" | "field" | "all" | "content" | undefined;
+    searchType?: "class" | "field" | "method" | "all" | "content" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
     includeFiles?: boolean | undefined;
@@ -119,7 +119,7 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
     executionMode?: "preview" | "apply" | undefined;
 }>, {
     limit: number;
-    searchType: "class" | "method" | "field" | "all" | "content";
+    searchType: "class" | "field" | "method" | "all" | "content";
     task: "search" | "remap" | "summary" | "class-source" | "decompile";
     subject: {
         kind: "jar";
@@ -155,7 +155,7 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
     targetMapping?: "mojang" | "yarn" | undefined;
     outputJar?: string | undefined;
     query?: string | undefined;
-    searchType?: "class" | "method" | "field" | "all" | "content" | undefined;
+    searchType?: "class" | "field" | "method" | "all" | "content" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
     includeFiles?: boolean | undefined;

package/dist/entry-tools/analyze-symbol-service.d.ts

@@ -8,15 +8,15 @@ export declare const analyzeSymbolShape: {
         owner: z.ZodOptional<z.ZodString>;
         descriptor: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     }, {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     }>;
     version: z.ZodOptional<z.ZodString>;
     sourceMapping: z.ZodOptional<z.ZodEnum<["obfuscated", "mojang", "intermediary", "yarn"]>>;
@@ -39,15 +39,15 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
         owner: z.ZodOptional<z.ZodString>;
         descriptor: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     }, {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     }>;
     version: z.ZodOptional<z.ZodString>;
     sourceMapping: z.ZodOptional<z.ZodEnum<["obfuscated", "mojang", "intermediary", "yarn"]>>;
@@ -65,10 +65,10 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     nameMode: "auto" | "fqcn";
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     };
     signatureMode: "exact" | "name-only";
     maxCandidates: number;
@@ -79,15 +79,15 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     classNameMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
-    includeKinds?: ("class" | "method" | "field")[] | undefined;
+    includeKinds?: ("class" | "field" | "method")[] | undefined;
     maxRows?: number | undefined;
 }, {
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     };
     projectPath?: string | undefined;
     version?: string | undefined;
@@ -98,17 +98,17 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
     signatureMode?: "exact" | "name-only" | undefined;
-    includeKinds?: ("class" | "method" | "field")[] | undefined;
+    includeKinds?: ("class" | "field" | "method")[] | undefined;
     maxRows?: number | undefined;
     maxCandidates?: number | undefined;
 }>, {
     nameMode: "auto" | "fqcn";
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     };
     signatureMode: "exact" | "name-only";
     maxCandidates: number;
@@ -119,15 +119,15 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     classNameMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
-    includeKinds?: ("class" | "method" | "field")[] | undefined;
+    includeKinds?: ("class" | "field" | "method")[] | undefined;
     maxRows?: number | undefined;
 }, {
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
-        kind: "symbol" | "class" | "method" | "field";
         name: string;
-        owner?: string | undefined;
+        kind: "symbol" | "class" | "field" | "method";
         descriptor?: string | undefined;
+        owner?: string | undefined;
     };
     projectPath?: string | undefined;
     version?: string | undefined;
@@ -138,7 +138,7 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
     signatureMode?: "exact" | "name-only" | undefined;
-    includeKinds?: ("class" | "method" | "field")[] | undefined;
+    includeKinds?: ("class" | "field" | "method")[] | undefined;
     maxRows?: number | undefined;
     maxCandidates?: number | undefined;
 }>;