@adhisang/minecraft-modding-mcp 4.1.0 → 4.2.0

package/dist/source/indexer.js

@@ -323,6 +323,23 @@ export async function ingestIfNeeded(svc, resolved) {
         touchCacheMetrics(svc, resolved.artifactId, touchedAt);
         return;
     }
+    const inflight = svc.state.inflightArtifactIngests.get(resolved.artifactId);
+    if (inflight) {
+        await inflight;
+        return;
+    }
+    const ingestPromise = rebuildMissingArtifactIndex(svc, resolved, reason);
+    svc.state.inflightArtifactIngests.set(resolved.artifactId, ingestPromise);
+    try {
+        await ingestPromise;
+    }
+    finally {
+        if (svc.state.inflightArtifactIngests.get(resolved.artifactId) === ingestPromise) {
+            svc.state.inflightArtifactIngests.delete(resolved.artifactId);
+        }
+    }
+}
+async function rebuildMissingArtifactIndex(svc, resolved, reason) {
     svc.metrics.recordArtifactCacheMiss();
     svc.metrics.recordReindex();
     log("info", "index.rebuild.start", {

package/dist/source/lifecycle/diff.js

@@ -63,10 +63,10 @@ export async function diffClassSignatures(svc, input) {
         });
     }
     const mappingWarnings = [];
-    const obfuscatedFromClassName = await resolveToObfuscatedClassName(svc, className, fromVersion, mapping, input.sourcePriority, mappingWarnings);
+    const obfuscatedFromClassName = await resolveToObfuscatedClassName(svc, className, fromVersion, mapping, input.sourcePriority, mappingWarnings, input.gradleUserHome);
     const obfuscatedToClassName = fromVersion === toVersion
         ? obfuscatedFromClassName
-        : await resolveToObfuscatedClassName(svc, className, toVersion, mapping, input.sourcePriority, mappingWarnings);
+        : await resolveToObfuscatedClassName(svc, className, toVersion, mapping, input.sourcePriority, mappingWarnings, input.gradleUserHome);
     const [fromResolved, toResolved] = await Promise.all([
         svc.versionService.resolveVersionJar(fromVersion),
         svc.versionService.resolveVersionJar(toVersion)
@@ -176,8 +176,8 @@ export async function diffClassSignatures(svc, input) {
     // Remap diff delta members for non-obfuscated mappings
     const remapDelta = async (delta, kind) => {
         const [addedResult, removedResult] = await Promise.all([
-            svc.remapSignatureMembers(delta.added, kind, toVersion, "obfuscated", mapping, input.sourcePriority, warnings),
-            svc.remapSignatureMembers(delta.removed, kind, fromVersion, "obfuscated", mapping, input.sourcePriority, warnings)
+            svc.remapSignatureMembers(delta.added, kind, toVersion, "obfuscated", mapping, input.sourcePriority, warnings, undefined, input.gradleUserHome),
+            svc.remapSignatureMembers(delta.removed, kind, fromVersion, "obfuscated", mapping, input.sourcePriority, warnings, undefined, input.gradleUserHome)
         ]);
         const remappedModified = await Promise.all(delta.modified.map(async (change) => {
             if (!change.from || !change.to) {
@@ -194,8 +194,8 @@ export async function diffClassSignatures(svc, input) {
                 });
             }
             const [fromResult, toResult] = await Promise.all([
-                svc.remapSignatureMembers([change.from], kind, fromVersion, "obfuscated", mapping, input.sourcePriority, warnings),
-                svc.remapSignatureMembers([change.to], kind, toVersion, "obfuscated", mapping, input.sourcePriority, warnings)
+                svc.remapSignatureMembers([change.from], kind, fromVersion, "obfuscated", mapping, input.sourcePriority, warnings, undefined, input.gradleUserHome),
+                svc.remapSignatureMembers([change.to], kind, toVersion, "obfuscated", mapping, input.sourcePriority, warnings, undefined, input.gradleUserHome)
             ]);
             const fromMember = fromResult.members[0];
             const toMember = toResult.members[0];

package/dist/source/lifecycle/mapping-helpers.d.ts

@@ -11,12 +11,12 @@ export declare function rejectLifecycleClassLikeInput(svc: SourceService, input:
     sourcePriority?: MappingSourcePriority;
 }): void;
 export declare function releaseLifecycleMappingGraph(svc: SourceService, version: string, sourcePriority: MappingSourcePriority | undefined): void;
-export declare function resolveToObfuscatedClassName(svc: SourceService, className: string, version: string, mapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[]): Promise<string>;
-export declare function resolveToObfuscatedMemberName(svc: SourceService, name: string, ownerInSourceMapping: string, descriptor: string | undefined, kind: "field" | "method", version: string, mapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[]): Promise<{
+export declare function resolveToObfuscatedClassName(svc: SourceService, className: string, version: string, mapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[], gradleUserHome?: string): Promise<string>;
+export declare function resolveToObfuscatedMemberName(svc: SourceService, name: string, ownerInSourceMapping: string, descriptor: string | undefined, kind: "field" | "method", version: string, mapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[], gradleUserHome?: string): Promise<{
     name: string;
     descriptor?: string;
 }>;
-export declare function remapSignatureMembers(svc: SourceService, members: SignatureMember[], kind: "field" | "method", version: string, sourceMapping: SourceMapping, targetMapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[], projectPath?: string): Promise<{
+export declare function remapSignatureMembers(svc: SourceService, members: SignatureMember[], kind: "field" | "method", version: string, sourceMapping: SourceMapping, targetMapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[], projectPath?: string, gradleUserHome?: string): Promise<{
     members: SignatureMember[];
     failedNames: Set<string>;
 }>;

package/dist/source/lifecycle/mapping-helpers.js

@@ -58,18 +58,19 @@ export function releaseLifecycleMappingGraph(svc, version, sourcePriority) {
         svc.mappingService.releaseGraphCacheEntry(version, sourcePriority);
     }
 }
-export async function resolveToObfuscatedClassName(svc, className, version, mapping, sourcePriority, warnings) {
+export async function resolveToObfuscatedClassName(svc, className, version, mapping, sourcePriority, warnings, gradleUserHome) {
     return svc.resolveClassNameForLookup({
         className,
         version,
         sourceMapping: mapping,
         targetMapping: "obfuscated",
         sourcePriority,
+        gradleUserHome,
         warnings,
         context: "bytecode lookup"
     });
 }
-export async function resolveToObfuscatedMemberName(svc, name, ownerInSourceMapping, descriptor, kind, version, mapping, sourcePriority, warnings) {
+export async function resolveToObfuscatedMemberName(svc, name, ownerInSourceMapping, descriptor, kind, version, mapping, sourcePriority, warnings, gradleUserHome) {
     if (mapping === "obfuscated") {
         return {
             name,
@@ -89,7 +90,8 @@ export async function resolveToObfuscatedMemberName(svc, name, ownerInSourceMapp
                 descriptor,
                 sourceMapping: mapping,
                 targetMapping: "obfuscated",
-                sourcePriority
+                sourcePriority,
+                gradleUserHome
             })
             : await svc.mappingService.findMapping({
                 version,
@@ -108,7 +110,8 @@ export async function resolveToObfuscatedMemberName(svc, name, ownerInSourceMapp
                     : undefined,
                 sourceMapping: mapping,
                 targetMapping: "obfuscated",
-                sourcePriority
+                sourcePriority,
+                gradleUserHome
             });
         warnings.push(...mapped.warnings);
         if (mapped.resolved && mapped.resolvedSymbol) {
@@ -127,7 +130,8 @@ export async function resolveToObfuscatedMemberName(svc, name, ownerInSourceMapp
                 signatureMode: "exact",
                 sourceMapping: mapping,
                 targetMapping: "obfuscated",
-                sourcePriority
+                sourcePriority,
+                gradleUserHome
             });
             warnings.push(...fallbackMapped.warnings);
             if (fallbackMapped.resolved && fallbackMapped.resolvedSymbol) {
@@ -147,7 +151,7 @@ export async function resolveToObfuscatedMemberName(svc, name, ownerInSourceMapp
         descriptor: kind === "method" ? descriptor : undefined
     };
 }
-export async function remapSignatureMembers(svc, members, kind, version, sourceMapping, targetMapping, sourcePriority, warnings, projectPath) {
+export async function remapSignatureMembers(svc, members, kind, version, sourceMapping, targetMapping, sourcePriority, warnings, projectPath, gradleUserHome) {
     const failedNames = new Set();
     if (sourceMapping === targetMapping) {
         return { members, failedNames };
@@ -174,7 +178,8 @@ export async function remapSignatureMembers(svc, members, kind, version, sourceM
                 sourceMapping,
                 targetMapping,
                 sourcePriority,
-                projectPath
+                projectPath,
+                gradleUserHome
             });
             if (mapped.resolved && mapped.resolvedSymbol) {
                 ownerToRemapped.set(obfuscatedFqn, mapped.resolvedSymbol.name);
@@ -207,7 +212,8 @@ export async function remapSignatureMembers(svc, members, kind, version, sourceM
                     sourceMapping,
                     targetMapping,
                     sourcePriority,
-                    projectPath
+                    projectPath,
+                    gradleUserHome
                 });
                 if (mapped.resolved && mapped.resolvedSymbol) {
                     ownerToRemapped.set(dotFqn, mapped.resolvedSymbol.name);
@@ -242,7 +248,8 @@ export async function remapSignatureMembers(svc, members, kind, version, sourceM
                         sourceMapping,
                         targetMapping,
                         sourcePriority,
-                        projectPath
+                        projectPath,
+                        gradleUserHome
                     });
                     if (exactResult.resolved && exactResult.resolvedSymbol) {
                         memberKeyToRemapped.set(key, exactResult.resolvedSymbol.name);
@@ -270,6 +277,7 @@ export async function remapSignatureMembers(svc, members, kind, version, sourceM
                 targetMapping,
                 sourcePriority,
                 projectPath,
+                gradleUserHome,
                 disambiguation: {
                     ownerHint: targetOwner,
                     descriptorHint: remappedDescriptorHint

package/dist/source/lifecycle/trace.js

@@ -123,8 +123,8 @@ export async function traceSymbolLifecycle(svc, input) {
         const versionWarnings = [];
         try {
             const [obfuscatedClassName, obfuscatedMethod, resolvedJar] = await Promise.all([
-                resolveToObfuscatedClassName(svc, userClassName, version, mapping, input.sourcePriority, versionWarnings),
-                resolveToObfuscatedMemberName(svc, userMethodName, userClassName, descriptor, "method", version, mapping, input.sourcePriority, versionWarnings),
+                resolveToObfuscatedClassName(svc, userClassName, version, mapping, input.sourcePriority, versionWarnings, input.gradleUserHome),
+                resolveToObfuscatedMemberName(svc, userMethodName, userClassName, descriptor, "method", version, mapping, input.sourcePriority, versionWarnings, input.gradleUserHome),
                 svc.versionService.resolveVersionJar(version)
             ]);
             const signature = await svc.explorerService.getSignature({

package/dist/source/search.js

@@ -250,6 +250,7 @@ export async function searchClassSource(svc, input) {
                         sourceMapping: input.queryNamespace,
                         targetMapping: artifactMapping,
                         sourcePriority: input.sourcePriority,
+                        gradleUserHome: input.gradleUserHome,
                         signatureMode: "name-only",
                         maxCandidates: 5
                     });

package/dist/source/state.d.ts

@@ -14,6 +14,11 @@ export declare class SourceServiceState {
      * tiny-remapper run.
      */
     readonly inflightRemaps: Map<string, Promise<string>>;
+    /**
+     * Process-local artifact ingest jobs keyed by artifactId. This collapses
+     * concurrent class source/member lookups inside one MCP server process.
+     */
+    readonly inflightArtifactIngests: Map<string, Promise<void>>;
     readonly lru: LruList<{
         totalContentBytes: number;
         updatedAt: string;

package/dist/source/state.js

@@ -14,6 +14,11 @@ export class SourceServiceState {
      * tiny-remapper run.
      */
     inflightRemaps = new Map();
+    /**
+     * Process-local artifact ingest jobs keyed by artifactId. This collapses
+     * concurrent class source/member lookups inside one MCP server process.
+     */
+    inflightArtifactIngests = new Map();
     lru = new LruList();
 }
 //# sourceMappingURL=state.js.map

package/dist/source/symbol-resolver.js

@@ -106,6 +106,7 @@ export async function resolveWorkspaceSymbol(svc, input) {
             sourceMapping: input.sourceMapping,
             targetMapping: mappingApplied,
             sourcePriority: input.sourcePriority,
+            gradleUserHome: input.gradleUserHome,
             maxCandidates: input.maxCandidates
         });
         return {
@@ -121,7 +122,8 @@ export async function resolveWorkspaceSymbol(svc, input) {
             className,
             classNameMapping: input.sourceMapping,
             includeKinds: ["class"],
-            sourcePriority: input.sourcePriority
+            sourcePriority: input.sourcePriority,
+            gradleUserHome: input.gradleUserHome
         });
         const resolvedClass = matrix.classIdentity[mappingApplied];
         if (!resolvedClass) {
@@ -180,6 +182,7 @@ export async function resolveWorkspaceSymbol(svc, input) {
         sourceMapping: input.sourceMapping,
         targetMapping: mappingApplied,
         sourcePriority: input.sourcePriority,
+        gradleUserHome: input.gradleUserHome,
         maxCandidates: input.maxCandidates
     });
     const filtered = mapped.candidates.filter((candidate) => candidate.kind === kind);

package/dist/source/validate-mixin/pipeline/mapping-health.js

@@ -5,7 +5,8 @@ export async function runMappingHealthStage(svc, ctx) {
         const health = await svc.mappingService.checkMappingHealth({
             version: ctx.version,
             requestedMapping: ctx.requestedMapping,
-            sourcePriority: ctx.currentSourcePriority
+            sourcePriority: ctx.currentSourcePriority,
+            gradleUserHome: ctx.input.gradleUserHome
         });
         const jarAvailable = existsSync(ctx.jarPath);
         ctx.healthReport = {

package/dist/source/validate-mixin/pipeline/resolve.js

@@ -36,6 +36,7 @@ export async function runResolveStage(svc, ctx) {
                 mapping: ctx.requestedMapping,
                 sourcePriority: ctx.currentSourcePriority,
                 projectPath: ctx.input.projectPath,
+                gradleUserHome: ctx.input.gradleUserHome,
                 scope: ctx.input.scope,
                 preferProjectVersion: false
             });

package/dist/source/validate-mixin/pipeline/target-lookup.js

@@ -9,7 +9,8 @@ function findValidateMixinClassMapping(svc, input) {
             sourceMapping: input.sourceMapping,
             targetMapping: input.targetMapping,
             sourcePriority: input.sourcePriority,
-            projectPath: input.projectPath
+            projectPath: input.projectPath,
+            gradleUserHome: input.gradleUserHome
         });
     }
     const cacheKey = [
@@ -18,7 +19,8 @@ function findValidateMixinClassMapping(svc, input) {
         input.sourceMapping,
         input.targetMapping,
         input.sourcePriority,
-        input.projectPath ?? ""
+        input.projectPath ?? "",
+        input.gradleUserHome ?? ""
     ].join("\0");
     const cached = cache.get(cacheKey);
     if (cached) {
@@ -31,7 +33,8 @@ function findValidateMixinClassMapping(svc, input) {
         sourceMapping: input.sourceMapping,
         targetMapping: input.targetMapping,
         sourcePriority: input.sourcePriority,
-        projectPath: input.projectPath
+        projectPath: input.projectPath,
+        gradleUserHome: input.gradleUserHome
     }).catch((error) => {
         cache.delete(cacheKey);
         throw error;
@@ -78,6 +81,7 @@ export async function processSingleMixinTarget(svc, ctx, target, targetIndex) {
                 targetMapping: ctx.signatureLookupMapping,
                 sourcePriority: ctx.currentSourcePriority,
                 projectPath: ctx.input.projectPath,
+                gradleUserHome: ctx.input.gradleUserHome,
                 batchCaches: ctx.input.batchCaches
             });
             if (mapped.resolved && mapped.resolvedSymbol) {
@@ -110,9 +114,9 @@ export async function processSingleMixinTarget(svc, ctx, target, targetIndex) {
         if (ctx.requestedMapping !== ctx.signatureLookupMapping) {
             try {
                 const [ctorResult, methodResult, fieldResult] = await Promise.all([
-                    svc.remapSignatureMembers(sig.constructors, "method", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath),
-                    svc.remapSignatureMembers(sig.methods, "method", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath),
-                    svc.remapSignatureMembers(sig.fields, "field", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath)
+                    svc.remapSignatureMembers(sig.constructors, "method", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath, ctx.input.gradleUserHome),
+                    svc.remapSignatureMembers(sig.methods, "method", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath, ctx.input.gradleUserHome),
+                    svc.remapSignatureMembers(sig.fields, "field", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath, ctx.input.gradleUserHome)
                 ]);
                 constructors = ctorResult.members;
                 methods = methodResult.members;
@@ -160,7 +164,8 @@ export async function processSingleMixinTarget(svc, ctx, target, targetIndex) {
         try {
             const existenceCheck = await svc.mappingService.checkSymbolExists({
                 version: ctx.version, kind: "class", name: resolvedClassName,
-                sourceMapping: ctx.requestedMapping, nameMode: "auto", sourcePriority: ctx.currentSourcePriority
+                sourceMapping: ctx.requestedMapping, nameMode: "auto", sourcePriority: ctx.currentSourcePriority,
+                gradleUserHome: ctx.input.gradleUserHome
             });
             if (existenceCheck.resolved) {
                 ctx.symbolExistsButSignatureFailed.add(target.className);

package/dist/source-resolver.d.ts

@@ -1,5 +1,6 @@
 import type { Config, MappingVariant, ResolvedSourceArtifact, SourceTargetInput } from "./types.js";
 export type { MappingVariant } from "./types.js";
+export declare function artifactIdForJar(inputKind: string, artifactPath: string, signature: string, suffix?: string, mappingVariant?: MappingVariant): string;
 export interface ResolveSourceTargetOptions {
     allowDecompile: boolean;
     preferBinaryOnly?: boolean;

package/dist/source-resolver.js

@@ -133,7 +133,7 @@ async function resolveGradleCacheCoordinateCandidate(coordinate) {
 function resolveRemoteBinaryCandidate(coordinate, repos) {
     return buildRemoteBinaryUrls(repos, coordinate);
 }
-function artifactIdForJar(inputKind, artifactPath, signature, suffix, mappingVariant = "pass") {
+export function artifactIdForJar(inputKind, artifactPath, signature, suffix, mappingVariant = "pass") {
     const parts = [inputKind, artifactPath, signature, suffix ?? "source"];
     if (mappingVariant === "mojang-remapped") {
         parts.push("mojang-remapped");

package/dist/source-service.d.ts

@@ -26,6 +26,7 @@ export type ResolveArtifactInput = {
     sourcePriority?: MappingSourcePriority;
     allowDecompile?: boolean;
     projectPath?: string;
+    gradleUserHome?: string;
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
     strictVersion?: boolean;
@@ -50,6 +51,23 @@ export type ResolveArtifactOutput = {
     warnings: string[];
     sampleEntries?: string[];
 };
+export type ProbeMinecraftArtifactInput = {
+    target: {
+        kind: "version";
+        value: string;
+    };
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    gradleUserHome?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+};
+export type ProbeMinecraftArtifactOutput = {
+    artifactId: string;
+    mappingApplied: SourceMapping;
+    warnings?: string[];
+};
 export type ArtifactContentsSummary = {
     sourceKind: "source-jar" | "decompiled-binary";
     indexedContentKinds: string[];
@@ -89,6 +107,7 @@ export type SearchClassSourceInput = {
     cursor?: string;
     queryNamespace?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    gradleUserHome?: string;
 };
 export type SearchClassSourceOutput = {
     hits: SearchSourceHit[];
@@ -149,6 +168,7 @@ export type ResolveWorkspaceSymbolInput = {
     descriptor?: string;
     sourceMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    gradleUserHome?: string;
     maxCandidates?: number;
 };
 export type ResolveWorkspaceSymbolOutput = MappingSymbolResolutionOutput & {
@@ -164,6 +184,7 @@ export type GetClassSourceInput = {
     sourcePriority?: MappingSourcePriority;
     allowDecompile?: boolean;
     projectPath?: string;
+    gradleUserHome?: string;
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
     strictVersion?: boolean;
@@ -225,6 +246,7 @@ export type GetClassMembersInput = {
     memberPattern?: string;
     maxMembers?: number;
     projectPath?: string;
+    gradleUserHome?: string;
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
     strictVersion?: boolean;
@@ -286,6 +308,7 @@ export type TraceSymbolLifecycleInput = {
     toVersion?: string;
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    gradleUserHome?: string;
     includeSnapshots?: boolean;
     maxVersions?: number;
     includeTimeline?: boolean;
@@ -336,6 +359,7 @@ export type DiffClassSignaturesInput = {
     toVersion: string;
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    gradleUserHome?: string;
     includeFullDiff?: boolean;
 };
 export type DiffClassSignaturesOutput = {
@@ -401,6 +425,7 @@ export type ValidateMixinInput = {
     sourcePriority?: MappingSourcePriority;
     scope?: ArtifactScope;
     projectPath?: string;
+    gradleUserHome?: string;
     preferProjectVersion?: boolean;
     minSeverity?: "error" | "warning" | "all";
     hideUncertain?: boolean;
@@ -472,6 +497,7 @@ export type ValidateAccessWidenerInput = {
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     projectPath?: string;
+    gradleUserHome?: string;
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
 };
@@ -482,6 +508,7 @@ export type ValidateAccessTransformerInput = {
     atNamespace?: AccessTransformerNamespace;
     sourcePriority?: MappingSourcePriority;
     projectPath?: string;
+    gradleUserHome?: string;
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
 };
@@ -508,6 +535,7 @@ export declare class SourceService {
         workspaceContextCache?: WorkspaceContextCache;
     });
     resolveArtifact(input: ResolveArtifactInput): Promise<ResolveArtifactOutput>;
+    probeMinecraftArtifact(input: ProbeMinecraftArtifactInput): Promise<ProbeMinecraftArtifactOutput>;
     synthesizeWorkspaceTarget(input: ResolveArtifactInput, workspace: import("./types.js").WorkspaceTargetInput): ReturnType<typeof workspaceTarget.synthesizeWorkspaceTarget>;
     synthesizeDependencyTarget(input: ResolveArtifactInput, dep: import("./types.js").DependencyTargetInput): ReturnType<typeof workspaceTarget.synthesizeDependencyTarget>;
     loadOrDetectWorkspaceContext(projectPath: string): ReturnType<typeof workspaceTarget.loadOrDetectWorkspaceContext>;
@@ -515,6 +543,7 @@ export declare class SourceService {
         version: string;
         awNamespace: SourceMapping;
         projectPath?: string;
+        gradleUserHome?: string;
         scope?: ArtifactScope;
         preferProjectVersion?: boolean;
     }): Promise<RuntimeValidationProvenance<SourceMapping>>;
@@ -526,6 +555,7 @@ export declare class SourceService {
         version: string;
         atNamespace: AccessTransformerNamespace;
         projectPath?: string;
+        gradleUserHome?: string;
         scope?: ArtifactScope;
         preferProjectVersion?: boolean;
     }): Promise<RuntimeValidationProvenance<AccessTransformerNamespace>>;
@@ -538,15 +568,18 @@ export declare class SourceService {
     discoverVersionSourceJar(input: {
         version: string;
         projectPath?: string;
+        gradleUserHome?: string;
     }): ReturnType<typeof artifactResolver.discoverVersionSourceJar>;
     discoverAccessWidenerRuntimeCandidates(input: {
         version: string;
         projectPath?: string;
+        gradleUserHome?: string;
         requestedScope: ArtifactScope;
     }): ReturnType<typeof artifactResolver.discoverAccessWidenerRuntimeCandidates>;
     discoverAccessTransformerRuntimeCandidates(input: {
         version: string;
         projectPath?: string;
+        gradleUserHome?: string;
         requestedScope: ArtifactScope;
         atNamespace: AccessTransformerNamespace;
         loader: import("./workspace-mapping-service.js").WorkspaceProjectLoader | "unknown";
@@ -580,7 +613,7 @@ export declare class SourceService {
     getClassMembers(input: GetClassMembersInput): Promise<GetClassMembersOutput>;
     validateMixin(input: ValidateMixinInput, options?: ValidateMixinOptions): Promise<ValidateMixinOutput>;
     validateMixinSingle(input: validateMixinModule.ValidateMixinSingleInput): Promise<MixinValidationResult>;
-    remapSignatureMembers(members: SignatureMember[], kind: "field" | "method", version: string, sourceMapping: SourceMapping, targetMapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[], projectPath?: string): Promise<{
+    remapSignatureMembers(members: SignatureMember[], kind: "field" | "method", version: string, sourceMapping: SourceMapping, targetMapping: SourceMapping, sourcePriority: MappingSourcePriority | undefined, warnings: string[], projectPath?: string, gradleUserHome?: string): Promise<{
         members: SignatureMember[];
         failedNames: Set<string>;
     }>;
@@ -595,6 +628,7 @@ export declare class SourceService {
         sourceMapping: SourceMapping;
         targetMapping: SourceMapping;
         sourcePriority: MappingSourcePriority | undefined;
+        gradleUserHome?: string;
         warnings: string[];
         context: string;
     }): Promise<string>;

package/dist/source-service.js

@@ -67,6 +67,9 @@ export class SourceService {
     async resolveArtifact(input) {
         return artifactResolver.resolveArtifact(this, input);
     }
+    async probeMinecraftArtifact(input) {
+        return artifactResolver.probeMinecraftArtifact(this, input);
+    }
     async synthesizeWorkspaceTarget(input, workspace) {
         return workspaceTarget.synthesizeWorkspaceTarget(this, input, workspace);
     }
@@ -173,8 +176,8 @@ export class SourceService {
     async validateMixinSingle(input) {
         return validateMixinModule.validateMixinSingle(this, input);
     }
-    async remapSignatureMembers(members, kind, version, sourceMapping, targetMapping, sourcePriority, warnings, projectPath) {
-        return lifecycle.remapSignatureMembers(this, members, kind, version, sourceMapping, targetMapping, sourcePriority, warnings, projectPath);
+    async remapSignatureMembers(members, kind, version, sourceMapping, targetMapping, sourcePriority, warnings, projectPath, gradleUserHome) {
+        return lifecycle.remapSignatureMembers(this, members, kind, version, sourceMapping, targetMapping, sourcePriority, warnings, projectPath, gradleUserHome);
     }
     async validateAccessWidener(input) {
         return accessValidate.validateAccessWidener(this, input);

package/dist/tool-contract-manifest.d.ts

@@ -1,4 +1,4 @@
-export declare const TOOL_SURFACE_SECTION_IDS: readonly ["v3-entry-tools", "source-exploration", "version-comparison-symbol-tracking", "mapping-symbols", "nbt-utilities", "mod-analysis", "validation", "registry-diagnostics", "batch-lookup"];
+export declare const TOOL_SURFACE_SECTION_IDS: readonly ["top-level-workflow-tools", "source-exploration", "version-comparison-symbol-tracking", "mapping-symbols", "nbt-utilities", "mod-analysis", "validation", "registry-diagnostics", "batch-lookup"];
 export type ToolSurfaceSectionId = (typeof TOOL_SURFACE_SECTION_IDS)[number];
 export type ToolSurfaceLocale = "en" | "ja";
 export declare function renderToolSurfaceSection(locale: ToolSurfaceLocale, sectionId: ToolSurfaceSectionId): string;

package/dist/tool-contract-manifest.js

@@ -1,5 +1,5 @@
 export const TOOL_SURFACE_SECTION_IDS = [
-    "v3-entry-tools",
+    "top-level-workflow-tools",
     "source-exploration",
     "version-comparison-symbol-tracking",
     "mapping-symbols",
@@ -10,7 +10,7 @@ export const TOOL_SURFACE_SECTION_IDS = [
     "batch-lookup"
 ];
 const SECTION_ROWS = {
-    "v3-entry-tools": {
+    "top-level-workflow-tools": {
         en: [
             "| `inspect-minecraft` | Inspect versions, artifacts, classes, files, source text, and workspace-aware lookup flows |",
             "| `analyze-symbol` | Handle symbol existence checks, namespace mapping, lifecycle tracing, workspace symbol resolution, and API overviews |",