@adhisang/minecraft-modding-mcp 5.0.0 → 6.1.0

package/dist/entry-tools/validate-project-service.d.ts

@@ -454,7 +454,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     reportMode: "full" | "summary-first" | "compact";
     treatInfoAsWarning: boolean;
     includeIssues: boolean;
-    task: "project-summary" | "mixin" | "access-widener" | "access-transformer";
+    task: "project-summary" | "mixin" | "access-transformer" | "access-widener";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -510,7 +510,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     include?: string[] | undefined;
     atNamespace?: "obfuscated" | "mojang" | "srg" | undefined;
 }, {
-    task: "project-summary" | "mixin" | "access-widener" | "access-transformer";
+    task: "project-summary" | "mixin" | "access-transformer" | "access-widener";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -580,7 +580,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     reportMode: "full" | "summary-first" | "compact";
     treatInfoAsWarning: boolean;
     includeIssues: boolean;
-    task: "project-summary" | "mixin" | "access-widener" | "access-transformer";
+    task: "project-summary" | "mixin" | "access-transformer" | "access-widener";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -636,7 +636,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     include?: string[] | undefined;
     atNamespace?: "obfuscated" | "mojang" | "srg" | undefined;
 }, {
-    task: "project-summary" | "mixin" | "access-widener" | "access-transformer";
+    task: "project-summary" | "mixin" | "access-transformer" | "access-widener";
     subject: {
         kind: "workspace";
         projectPath: string;

package/dist/entry-tools/verify-mixin-target-service.js

@@ -5,7 +5,7 @@ import { suggestSimilar } from "../mixin-validator.js";
 export const VERIFY_MIXIN_TARGET_OFF = process.env.VERIFY_MIXIN_TARGET_OFF === "1";
 const ACCESSOR_NAME_RE = /^(get|set|is)([A-Z]\w*)$/;
 const INVOKER_NAME_RE = /^(invoke|call)([A-Z]\w*)$/;
-function decodeAccessFlags(flags) {
+function decodeAccessFlags(flags, kind) {
     const labels = [];
     if (flags == null) {
         return labels;
@@ -23,9 +23,9 @@ function decodeAccessFlags(flags) {
     if ((flags & 0x0020) !== 0)
         labels.push("synchronized");
     if ((flags & 0x0040) !== 0)
-        labels.push("volatile");
+        labels.push(kind === "method" ? "bridge" : "volatile");
     if ((flags & 0x0080) !== 0)
-        labels.push("transient");
+        labels.push(kind === "method" ? "varargs" : "transient");
     if ((flags & 0x0100) !== 0)
         labels.push("native");
     if ((flags & 0x0400) !== 0)
@@ -137,11 +137,11 @@ function deriveVisibility(accessFlags) {
         return "private";
     return "package-private";
 }
-function buildMatch(member) {
+function buildMatch(member, kind) {
     return {
         name: member.name,
         descriptor: member.jvmDescriptor,
-        accessFlags: decodeAccessFlags(member.accessFlags),
+        accessFlags: decodeAccessFlags(member.accessFlags, kind),
         javaSignature: member.javaSignature,
         ...(member.sourceLine ? { sourceLine: member.sourceLine } : {})
     };
@@ -267,7 +267,7 @@ export class VerifyMixinTargetService {
         if (member.descriptor) {
             const descriptorHits = exactNameHits.filter((m) => m.jvmDescriptor === member.descriptor);
             if (descriptorHits.length > 0) {
-                matches = descriptorHits.map(buildMatch);
+                matches = descriptorHits.map((m) => buildMatch(m, member.kind));
             }
             else {
                 matches = [];
@@ -279,7 +279,7 @@ export class VerifyMixinTargetService {
             }
         }
         else {
-            matches = exactNameHits.map(buildMatch);
+            matches = exactNameHits.map((m) => buildMatch(m, member.kind));
         }
         if (matches.length === 0 && candidates.length === 0) {
             const suggestions = suggestSimilar(memberName, allMemberNames);

package/dist/index.js

@@ -15,7 +15,7 @@ import { remapModJar } from "./mod-remap-service.js";
 import { registerResources } from "./resources.js";
 import { SourceService } from "./source-service.js";
 import { ToolExecutionGate } from "./tool-execution-gate.js";
-import { classifyWarnings } from "./warning-details.js";
+import { capWarningDetailsForSummary, classifyWarnings } from "./warning-details.js";
 import { WorkspaceMappingService } from "./workspace-mapping-service.js";
 import { InspectMinecraftService, inspectMinecraftSchema, inspectMinecraftShape } from "./entry-tools/inspect-minecraft-service.js";
 import { AnalyzeSymbolService, analyzeSymbolSchema, analyzeSymbolShape } from "./entry-tools/analyze-symbol-service.js";
@@ -90,7 +90,7 @@ server.validateToolInput = async (_tool, args) => args;
 // server.tool() but appends a note steering agents to the entry tools first.
 // Entry tools, batch tools, and the NBT/runtime utilities (which have no entry
 // equivalent) keep their plain descriptions via server.tool().
-const EXPERT_TOOL_NOTE = " Expert/follow-up tool: prefer the entry tools (inspect-minecraft, analyze-symbol, compare-minecraft, analyze-mod, validate-project) first; reach for this only for the narrow operation it names.";
+const EXPERT_TOOL_NOTE = " Expert tool: prefer the entry tools (inspect-minecraft, analyze-symbol, compare-minecraft, analyze-mod, validate-project) first.";
 const expertTool = ((name, description, ...rest) => server.tool(name, description + EXPERT_TOOL_NOTE, ...rest));
 const config = loadConfig();
 const nbtLimits = {
@@ -385,18 +385,23 @@ async function runTool(tool, rawInput, schema, action) {
         if (DETAIL_ENABLED_TOOL_NAMES.has(tool)) {
             projectedResult = projectByDetail(tool, projectedResult, effectiveDetail, shapeInput.include);
         }
-        // Entry, expert, and batch tools all report the applied detail/include shape in meta.
+        // Entry, expert, and batch tools report the applied detail/include shape in meta.
+        // detailApplied is omitted when it matches the tool's default to keep responses lean.
+        const defaultDetail = ENTRY_TOOL_NAMES.has(tool)
+            ? "summary"
+            : DEFAULT_DETAIL_BY_TOOL[tool] ?? "summary";
         const entryMeta = ENTRY_TOOL_NAMES.has(tool) ||
             DETAIL_ENABLED_TOOL_NAMES.has(tool) ||
             BATCH_DETAIL_TOOL_NAMES.has(tool)
             ? buildEntryToolMeta({
                 detail: effectiveDetail,
+                defaultDetail,
                 include: shapeInput.include.size > 0 ? [...shapeInput.include] : undefined
             })
             : undefined;
         const durationMs = Date.now() - startedAt;
         sourceService.recordToolCall(tool, durationMs);
-        const warningDetails = classifyWarnings(warnings);
+        const warningDetails = capWarningDetailsForSummary(classifyWarnings(warnings), effectiveDetail === "summary");
         return objectResult({
             result: projectedResult,
             meta: {
@@ -405,7 +410,7 @@ async function runTool(tool, rawInput, schema, action) {
                 requestId,
                 tool,
                 durationMs,
-                warnings,
+                ...(warnings.length > 0 ? { warnings } : {}),
                 ...(warningDetails.length > 0 ? { warningDetails } : {})
             }
         });
@@ -450,8 +455,7 @@ async function runTool(tool, rawInput, schema, action) {
         const errorMeta = {
             requestId,
             tool,
-            durationMs: errorDurationMs,
-            warnings: []
+            durationMs: errorDurationMs
         };
         applyErrorMetaExtensions(errorMeta, caughtError);
         return objectResult({
@@ -467,7 +471,7 @@ expertTool("list-versions", "List available Minecraft versions from Mojang manif
 registerToolSchema("list-versions", listVersionsSchema);
 server.tool("inspect-minecraft", "Top-level workflow tool for version discovery, artifact resolution, class inspection, source search, file reads, and file listings.", inspectMinecraftShape, { readOnlyHint: true }, async (args) => runTool("inspect-minecraft", args, inspectMinecraftSchema, async (input) => inspectMinecraftService.execute(input)));
 registerToolSchema("inspect-minecraft", inspectMinecraftSchema);
-server.tool("analyze-symbol", "Top-level workflow tool for symbol existence, mapping, lifecycle (with fromVersion/toVersion/maxVersions/includeTimeline range controls), workspace analysis, and API overview. subject.kind accepts 'symbol' to auto-detect class/field/method from the selector (inferred kind is returned as a warning).", analyzeSymbolShape, { readOnlyHint: true }, async (args) => runTool("analyze-symbol", args, analyzeSymbolSchema, async (input) => analyzeSymbolService.execute(input)));
+server.tool("analyze-symbol", "Top-level workflow tool for symbol existence, mapping, lifecycle, workspace analysis, and API overview. subject.kind='symbol' auto-detects class/field/method from the selector.", analyzeSymbolShape, { readOnlyHint: true }, async (args) => runTool("analyze-symbol", args, analyzeSymbolSchema, async (input) => analyzeSymbolService.execute(input)));
 registerToolSchema("analyze-symbol", analyzeSymbolSchema);
 server.tool("compare-minecraft", "Top-level workflow tool for version comparisons, class diffs, registry diffs, and migration overviews.", compareMinecraftShape, { readOnlyHint: true }, async (args) => runTool("compare-minecraft", args, compareMinecraftSchema, async (input) => compareMinecraftService.execute(input)));
 registerToolSchema("compare-minecraft", compareMinecraftSchema);
@@ -497,16 +501,16 @@ if (!VERIFY_MIXIN_TARGET_OFF) {
     registerToolSchema("verify-mixin-target", verifyMixinTargetSchema);
 }
 if (!BATCH_TOOLS_OFF) {
-    server.tool("batch-class-source", "Batch lookup: read source for many classes in one call, sharing a single resolved artifact. Returns per-entry { status, result?, error? } plus aggregate summary. Per-entry retry suggestions point at get-class-source. Not read-only: per-entry outputFile writes source files to disk.", batchClassSourceShape, { readOnlyHint: false }, async (args) => runTool("batch-class-source", args, batchClassSourceSchema, async (input) => batchClassSourceService.execute(input)));
+    server.tool("batch-class-source", "Batch get-class-source for many classes sharing one resolved artifact; returns per-entry status plus aggregate summary. Not read-only: per-entry outputFile writes to disk.", batchClassSourceShape, { readOnlyHint: false }, async (args) => runTool("batch-class-source", args, batchClassSourceSchema, async (input) => batchClassSourceService.execute(input)));
     registerToolSchema("batch-class-source", batchClassSourceSchema);
-    server.tool("batch-class-members", "Batch lookup: list members for many classes in one call, sharing a single resolved artifact. Returns per-entry { status, result?, error? } plus aggregate summary. Per-entry retry suggestions point at get-class-members.", batchClassMembersShape, { readOnlyHint: true }, async (args) => runTool("batch-class-members", args, batchClassMembersSchema, async (input) => batchClassMembersService.execute(input)));
+    server.tool("batch-class-members", "Batch get-class-members for many classes sharing one resolved artifact; returns per-entry status plus aggregate summary.", batchClassMembersShape, { readOnlyHint: true }, async (args) => runTool("batch-class-members", args, batchClassMembersSchema, async (input) => batchClassMembersService.execute(input)));
     registerToolSchema("batch-class-members", batchClassMembersSchema);
-    server.tool("batch-symbol-exists", "Batch existence/mapping query: probe many symbols in one call against a shared Minecraft-version artifact. Accepts target.kind=workspace or version only (other kinds carry library versions, not Minecraft versions). Per-entry retry suggestions point at check-symbol-exists.", batchSymbolExistsShape, { readOnlyHint: true }, async (args) => runTool("batch-symbol-exists", args, batchSymbolExistsSchema, async (input) => batchSymbolExistsService.execute(input)));
+    server.tool("batch-symbol-exists", "Batch check-symbol-exists for many symbols against one shared Minecraft version (target.kind=version or workspace only).", batchSymbolExistsShape, { readOnlyHint: true }, async (args) => runTool("batch-symbol-exists", args, batchSymbolExistsSchema, async (input) => batchSymbolExistsService.execute(input)));
     registerToolSchema("batch-symbol-exists", batchSymbolExistsSchema);
-    server.tool("batch-mappings", "Batch mapping translation: resolve many symbols across mapping namespaces with one shared Minecraft version. Per-entry retry suggestions point at find-mapping.", batchMappingsShape, { readOnlyHint: true }, async (args) => runTool("batch-mappings", args, batchMappingsSchema, async (input) => batchMappingsService.execute(input)));
+    server.tool("batch-mappings", "Batch find-mapping: resolve many symbols across mapping namespaces with one shared Minecraft version.", batchMappingsShape, { readOnlyHint: true }, async (args) => runTool("batch-mappings", args, batchMappingsSchema, async (input) => batchMappingsService.execute(input)));
     registerToolSchema("batch-mappings", batchMappingsSchema);
 }
-expertTool("resolve-artifact", "Resolve source artifact from a target object ({ kind, value }) and return artifact metadata. For target.kind=jar, only <basename>-sources.jar is auto-adopted; other adjacent *-sources.jar files are informational.", resolveArtifactShape, { readOnlyHint: true }, async (args) => runTool("resolve-artifact", args, resolveArtifactSchema, async (input) => sourceService.resolveArtifact({
+expertTool("resolve-artifact", "Resolve a source artifact and return artifact metadata. For target.kind=jar, only <basename>-sources.jar is auto-adopted.", resolveArtifactShape, { readOnlyHint: true }, async (args) => runTool("resolve-artifact", args, resolveArtifactSchema, async (input) => sourceService.resolveArtifact({
     target: input.target,
     mapping: input.mapping,
     sourcePriority: input.sourcePriority,
@@ -532,7 +536,7 @@ expertTool("find-class", "Resolve a simple or qualified class name to fully-qual
     limit: input.limit
 })));
 registerToolSchema("find-class", findClassSchema);
-expertTool("get-class-source", "Get Java source for a class by target ({ kind: 'artifact', artifactId } or { kind: 'version'|'jar'|'coordinate'|'workspace'|'dependency', ... } — same shape as resolve-artifact). To read source text, pass mode=snippet (bounded excerpt) or mode=full (entire source); the default mode=metadata returns a symbol outline only, not the body. Not read-only: outputFile writes the source to disk.", getClassSourceShape, { readOnlyHint: false }, async (args) => runTool("get-class-source", args, getClassSourceSchema, async (input) => {
+expertTool("get-class-source", "Get Java source for a class. Default mode=metadata returns a symbol outline only; pass mode=snippet or mode=full to read source text. Not read-only: outputFile writes to disk.", getClassSourceShape, { readOnlyHint: false }, async (args) => runTool("get-class-source", args, getClassSourceSchema, async (input) => {
     const normalizedTarget = normalizeSourceLookupTarget(input.target);
     return sourceService.getClassSource({
         className: input.className,
@@ -555,7 +559,7 @@ expertTool("get-class-source", "Get Java source for a class by target ({ kind: '
     });
 }));
 registerToolSchema("get-class-source", getClassSourceSchema);
-expertTool("get-class-members", "Get fields/methods/constructors for one class from binary bytecode by target ({ kind: 'artifact', artifactId } or { kind: 'version'|'jar'|'coordinate'|'workspace'|'dependency', ... } — same shape as resolve-artifact).", getClassMembersShape, { readOnlyHint: true }, async (args) => runTool("get-class-members", args, getClassMembersSchema, async (input) => {
+expertTool("get-class-members", "Get fields/methods/constructors for one class from binary bytecode.", getClassMembersShape, { readOnlyHint: true }, async (args) => runTool("get-class-members", args, getClassMembersSchema, async (input) => {
     const normalizedTarget = normalizeSourceLookupTarget(input.target);
     return sourceService.getClassMembers({
         className: input.className,
@@ -569,6 +573,7 @@ expertTool("get-class-members", "Get fields/methods/constructors for one class f
         includeInherited: input.includeInherited,
         memberPattern: input.memberPattern,
         maxMembers: input.maxMembers,
+        projection: input.projection,
         cursor: input.cursor,
         projectPath: input.projectPath,
         gradleUserHome: input.gradleUserHome,
@@ -657,7 +662,7 @@ expertTool("find-mapping", "Find symbol mapping candidates between namespaces us
     maxCandidates: input.maxCandidates
 })));
 registerToolSchema("find-mapping", findMappingSchema);
-expertTool("resolve-method-mapping-exact", "Strict shortcut for find-mapping(kind=method, signatureMode=exact): resolve one method mapping by owner+name+descriptor between namespaces and report resolved/not_found/ambiguous. Stricter than find-mapping's exact mode — it requires a COMPLETE descriptor projection and returns mapping_unavailable when the descriptor's class references cannot all be projected to the target namespace (find-mapping is more lenient there). Use find-mapping kind=method signatureMode=exact unless you specifically need that strict-completeness guarantee.", resolveMethodMappingExactShape, { readOnlyHint: true }, async (args) => runTool("resolve-method-mapping-exact", args, resolveMethodMappingExactSchema, async (input) => sourceService.resolveMethodMappingExact({
+expertTool("resolve-method-mapping-exact", "Strict variant of find-mapping(kind=method, signatureMode=exact): requires a COMPLETE descriptor projection and returns mapping_unavailable when any descriptor class reference cannot be projected. Prefer find-mapping unless you need that guarantee.", resolveMethodMappingExactShape, { readOnlyHint: true }, async (args) => runTool("resolve-method-mapping-exact", args, resolveMethodMappingExactSchema, async (input) => sourceService.resolveMethodMappingExact({
     version: input.version,
     name: input.name,
     owner: input.owner,

package/dist/java-process.js

@@ -107,7 +107,7 @@ export function runJavaProcess(options) {
                 }
             }));
         });
-        proc.once("exit", (code) => {
+        proc.once("close", (code) => {
             clearTimeout(timer);
             resolve({
                 exitCode: code ?? -1,

package/dist/json-rpc-framing.d.ts

@@ -9,6 +9,9 @@ export declare function encodeJsonRpcMessage(message: JSONRPCMessage, mode: Conc
 export declare class JsonRpcFrameReader {
     private mode;
     private buffer;
+    private pendingChunks;
+    private pendingBytes;
+    private awaitedFrameEnd;
     get currentMode(): FramingMode;
     reset(): void;
     clear(): void;
@@ -16,6 +19,7 @@ export declare class JsonRpcFrameReader {
         onFrame: (frame: ParsedJsonRpcFrame) => void;
         onError: (error: Error) => void;
     }): void;
+    private canCompleteFrame;
     private detectMode;
     private readLineDelimitedMessage;
     private readContentLengthMessage;

package/dist/json-rpc-framing.js

@@ -25,21 +25,35 @@ export function encodeJsonRpcMessage(message, mode) {
 export class JsonRpcFrameReader {
     mode = "unknown";
     buffer = Buffer.alloc(0);
+    pendingChunks = [];
+    pendingBytes = 0;
+    awaitedFrameEnd = -1;
     get currentMode() {
         return this.mode;
     }
     reset() {
         this.mode = "unknown";
+        this.awaitedFrameEnd = -1;
     }
     clear() {
         this.mode = "unknown";
         this.buffer = Buffer.alloc(0);
+        this.pendingChunks = [];
+        this.pendingBytes = 0;
+        this.awaitedFrameEnd = -1;
     }
     processChunk(chunk, handlers) {
         if (chunk.length === 0) {
             return;
         }
-        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.pendingChunks.push(chunk);
+        this.pendingBytes += chunk.length;
+        if (!this.canCompleteFrame(chunk)) {
+            return;
+        }
+        this.buffer = Buffer.concat([this.buffer, ...this.pendingChunks]);
+        this.pendingChunks = [];
+        this.pendingBytes = 0;
         while (true) {
             try {
                 if (this.mode === "unknown") {
@@ -71,6 +85,12 @@ export class JsonRpcFrameReader {
             }
         }
     }
+    canCompleteFrame(chunk) {
+        if (this.mode === "content-length" && this.awaitedFrameEnd >= 0) {
+            return this.buffer.length + this.pendingBytes >= this.awaitedFrameEnd;
+        }
+        return chunk.includes(0x0a);
+    }
     detectMode() {
         while (this.buffer.length > 0) {
             if (this.buffer[0] === 0x0a) {
@@ -124,6 +144,7 @@ export class JsonRpcFrameReader {
         }
     }
     readContentLengthMessage() {
+        this.awaitedFrameEnd = -1;
         const headerBoundary = findHeaderBoundary(this.buffer);
         if (!headerBoundary) {
             return undefined;
@@ -158,6 +179,7 @@ export class JsonRpcFrameReader {
         const messageStart = headerBoundary.index + headerBoundary.delimiterBytes;
         const frameEnd = messageStart + contentLength;
         if (this.buffer.length < frameEnd) {
+            this.awaitedFrameEnd = frameEnd;
             return undefined;
         }
         const body = this.buffer.subarray(messageStart, frameEnd).toString("utf8");

package/dist/mapping/internal-types.d.ts

@@ -20,6 +20,18 @@ export type DirectionIndex = {
     simple: Map<string, Set<string>>;
     records: Map<string, MappingSymbolRecord>;
 };
+/**
+ * O(1) exact-lookup index over a single target namespace's records, used by
+ * existence checks. `byKey` is keyed by `kind|owner|name` (owner empty for
+ * classes, which key on their FQCN symbol); `classBySimpleName` resolves the
+ * auto-class short-name path. Values are arrays so callers can still tell a
+ * unique match (resolved) from multiple (ambiguous).
+ */
+export type ExactRecordIndex = {
+    byKey: Map<string, MappingSymbolRecord[]>;
+    classBySimpleName: Map<string, MappingSymbolRecord[]>;
+    membersByOwner: Map<string, MappingSymbolRecord[]>;
+};
 export type MappingLookupSource = "loom-cache" | "maven" | "mojang-client-mappings";
 export type PairRecord = {
     index: DirectionIndex;
@@ -50,6 +62,11 @@ export type LoadedGraph = {
     adjacency: Map<import("../types.js").SourceMapping, import("../types.js").SourceMapping[]>;
     pathCache: Map<PairKey, import("../types.js").SourceMapping[] | undefined>;
     recordsByTarget: Map<import("../types.js").SourceMapping, MappingSymbolRecord[]>;
+    /**
+     * Graph-scoped, lazily-built exact-lookup indexes keyed by target namespace.
+     * Populated on first existence check for a namespace; dies with graph eviction.
+     */
+    exactRecordIndex: Map<import("../types.js").SourceMapping, ExactRecordIndex>;
     /**
      * Graph-scoped cache of class-to-class descriptor projections, keyed by
      * `path.join(">") + NUL + internalName`. Value is the projected internal name,

package/dist/mapping/loaders/tiny-maven.js

@@ -53,36 +53,62 @@ export async function loadTinyPairsFromMaven(deps, version) {
     const warnings = [];
     const merged = new Map();
     const repos = deps.config.sourceRepos;
-    const intermediaryUrls = [];
-    const yarnUrls = [];
+    const attemptedUrls = [];
     const repoBases = repos.map((repo) => repo.replace(/\/+$/, ""));
     const yarnCoordinatesByRepo = await Promise.all(repoBases.map(async (base) => ({
         base,
         yarnCoordinates: await fetchYarnCoordinates(deps.fetchFn, base, version)
     })));
+    const tryUrls = async (urls) => {
+        for (const url of urls) {
+            attemptedUrls.push(url);
+            try {
+                const downloaded = await downloadToCache(url, defaultDownloadPath(deps.config.cacheDir, url), {
+                    fetchFn: deps.fetchFn,
+                    retries: deps.config.fetchRetries,
+                    timeoutMs: deps.config.fetchTimeoutMs
+                });
+                if (!downloaded.ok || !downloaded.path) {
+                    continue;
+                }
+                const parsed = await parseTinyFromJar(downloaded.path);
+                if (parsed.size > 0) {
+                    return parsed;
+                }
+            }
+            catch {
+                // try the next candidate URL
+            }
+        }
+        return undefined;
+    };
+    let intermediaryParsed;
+    let yarnParsed;
     for (const { base, yarnCoordinates } of yarnCoordinatesByRepo) {
-        intermediaryUrls.push(`${base}/net/fabricmc/intermediary/${version}/intermediary-${version}-v2.jar`, `${base}/net/fabricmc/intermediary/${version}/intermediary-${version}.jar`);
+        if (!intermediaryParsed) {
+            intermediaryParsed = await tryUrls([
+                `${base}/net/fabricmc/intermediary/${version}/intermediary-${version}-v2.jar`,
+                `${base}/net/fabricmc/intermediary/${version}/intermediary-${version}.jar`
+            ]);
+        }
         for (const coordinate of yarnCoordinates) {
-            yarnUrls.push(`${base}/net/fabricmc/yarn/${coordinate}/yarn-${coordinate}-v2.jar`, `${base}/net/fabricmc/yarn/${coordinate}/yarn-${coordinate}.jar`);
+            if (yarnParsed) {
+                break;
+            }
+            yarnParsed = await tryUrls([
+                `${base}/net/fabricmc/yarn/${coordinate}/yarn-${coordinate}-v2.jar`,
+                `${base}/net/fabricmc/yarn/${coordinate}/yarn-${coordinate}.jar`
+            ]);
         }
-    }
-    const allUrls = [...intermediaryUrls, ...yarnUrls];
-    const parsedResults = await Promise.allSettled(allUrls.map(async (url) => {
-        const downloaded = await downloadToCache(url, defaultDownloadPath(deps.config.cacheDir, url), {
-            fetchFn: deps.fetchFn,
-            retries: deps.config.fetchRetries,
-            timeoutMs: deps.config.fetchTimeoutMs
-        });
-        if (!downloaded.ok || !downloaded.path) {
-            return undefined;
+        if (intermediaryParsed && yarnParsed) {
+            break;
         }
-        return parseTinyFromJar(downloaded.path);
-    }));
-    for (const result of parsedResults) {
-        if (result.status !== "fulfilled" || !result.value) {
+    }
+    for (const parsed of [intermediaryParsed, yarnParsed]) {
+        if (!parsed) {
             continue;
         }
-        for (const [key, index] of result.value.entries()) {
+        for (const [key, index] of parsed.entries()) {
             const existing = merged.get(key);
             if (!existing) {
                 merged.set(key, index);
@@ -98,7 +124,7 @@ export async function loadTinyPairsFromMaven(deps, version) {
     return {
         pairs: merged,
         warnings,
-        mappingArtifact: allUrls[0] ?? "maven:none"
+        mappingArtifact: attemptedUrls[0] ?? "maven:none"
     };
 }
 //# sourceMappingURL=tiny-maven.js.map

package/dist/mapping/lookup.d.ts

@@ -1,5 +1,5 @@
 import type { MappingSourcePriority, SourceMapping } from "../types.js";
-import type { CandidateAccumulator, DirectionIndex, LoadedGraph, MappingLookupSource, MappingSymbolRecord, MatchRankKey, PairKey, PairRecord } from "./internal-types.js";
+import type { CandidateAccumulator, DirectionIndex, ExactRecordIndex, LoadedGraph, MappingLookupSource, MappingSymbolRecord, MatchRankKey, PairKey, PairRecord } from "./internal-types.js";
 import { MAX_CANDIDATES } from "./internal-types.js";
 import type { ClassApiMatrixKind, DescriptorProjection, MappingLookupCandidate, ResolutionCandidate, SymbolQueryInput, SymbolReference } from "./types.js";
 export type { DescriptorProjection };
@@ -41,6 +41,17 @@ export declare function applyDisambiguationHints(candidates: MappingLookupCandid
 export declare function projectLookupCandidateDescriptor(candidate: MappingLookupCandidate, sourceDescriptor: string, targetDescriptor: string | undefined): MappingLookupCandidate;
 export declare function effectiveLoomSearchProjectPath(projectPath: string | undefined): string | undefined;
 export declare function collectTargetRecords(graph: LoadedGraph, targetMapping: SourceMapping): MappingSymbolRecord[];
+/**
+ * Lazily build (and memoize on the graph) an O(1) exact-lookup index for a
+ * target namespace. Classes key on their FQCN symbol (owner left empty) and are
+ * additionally indexed by simple name for the auto-class short-name path;
+ * fields/methods key on `kind|owner|name`.
+ */
+export declare function collectExactRecordIndex(graph: LoadedGraph, targetMapping: SourceMapping): ExactRecordIndex;
+export declare function lookupExactClassBySymbol(index: ExactRecordIndex, symbol: string): MappingSymbolRecord[];
+export declare function lookupExactMembersByOwner(index: ExactRecordIndex, owner: string): MappingSymbolRecord[];
+export declare function lookupExactClassBySimpleName(index: ExactRecordIndex, name: string): MappingSymbolRecord[];
+export declare function lookupExactMembers(index: ExactRecordIndex, kind: "field" | "method", owner: string, name: string): MappingSymbolRecord[];
 export declare function normalizeIncludedKinds(inputKinds: ClassApiMatrixKind[] | undefined): Set<ClassApiMatrixKind>;
 export declare function inferAmbiguityReasons(candidates: ResolutionCandidate[], usedMojangClientMappings: boolean): string[];
 export declare function clampCandidateLimit(limit: number | undefined): number;

package/dist/mapping/lookup.js

@@ -429,7 +429,59 @@ export function effectiveLoomSearchProjectPath(projectPath) {
     return normalizeOptionalProjectPath(projectPath) ?? normalizeOptionalProjectPath(process.cwd());
 }
 export function collectTargetRecords(graph, targetMapping) {
-    return [...(graph.recordsByTarget.get(targetMapping) ?? [])];
+    return graph.recordsByTarget.get(targetMapping) ?? [];
+}
+function exactRecordKey(kind, owner, name) {
+    return `${kind}|${owner}|${name}`;
+}
+/**
+ * Lazily build (and memoize on the graph) an O(1) exact-lookup index for a
+ * target namespace. Classes key on their FQCN symbol (owner left empty) and are
+ * additionally indexed by simple name for the auto-class short-name path;
+ * fields/methods key on `kind|owner|name`.
+ */
+export function collectExactRecordIndex(graph, targetMapping) {
+    const cached = graph.exactRecordIndex.get(targetMapping);
+    if (cached) {
+        return cached;
+    }
+    const byKey = new Map();
+    const classBySimpleName = new Map();
+    const membersByOwner = new Map();
+    const push = (map, key, record) => {
+        const bucket = map.get(key);
+        if (bucket) {
+            bucket.push(record);
+        }
+        else {
+            map.set(key, [record]);
+        }
+    };
+    for (const record of collectTargetRecords(graph, targetMapping)) {
+        if (record.kind === "class") {
+            push(byKey, exactRecordKey("class", "", record.symbol), record);
+            push(classBySimpleName, record.name, record);
+        }
+        else {
+            push(byKey, exactRecordKey(record.kind, record.owner ?? "", record.name), record);
+            push(membersByOwner, record.owner ?? "", record);
+        }
+    }
+    const index = { byKey, classBySimpleName, membersByOwner };
+    graph.exactRecordIndex.set(targetMapping, index);
+    return index;
+}
+export function lookupExactClassBySymbol(index, symbol) {
+    return index.byKey.get(exactRecordKey("class", "", symbol)) ?? [];
+}
+export function lookupExactMembersByOwner(index, owner) {
+    return index.membersByOwner.get(owner) ?? [];
+}
+export function lookupExactClassBySimpleName(index, name) {
+    return index.classBySimpleName.get(name) ?? [];
+}
+export function lookupExactMembers(index, kind, owner, name) {
+    return index.byKey.get(exactRecordKey(kind, owner, name)) ?? [];
 }
 export function normalizeIncludedKinds(inputKinds) {
     const normalized = new Set();