@adhisang/minecraft-modding-mcp 4.1.1 → 4.2.1

package/dist/entry-tools/validate-project/internal.js

@@ -100,10 +100,10 @@ async function probeGradleReadable(projectPath) {
         };
     }
 }
-async function probeLoomCacheFound(projectPath) {
+async function probeLoomCacheFound(projectPath, gradleUserHome) {
     const startedAt = Date.now();
     try {
-        const roots = buildVersionSourceSearchRoots(projectPath);
+        const roots = buildVersionSourceSearchRoots({ projectPath, gradleUserHome });
         for (const root of roots) {
             if (await pathExists(root)) {
                 return {
@@ -147,6 +147,7 @@ async function probeMinecraftArtifactResolved(artifactProbe, args, stageEmitter)
             mapping: args.mapping,
             sourcePriority: args.sourcePriority,
             projectPath: args.projectPath,
+            gradleUserHome: args.gradleUserHome,
             scope: args.scope,
             preferProjectVersion: args.preferProjectVersion
         });
@@ -215,9 +216,9 @@ function projectTaskStatusReport(report, detail, include) {
     }
     return projected;
 }
-export async function runUpstreamProbes(projectPath) {
+export async function runUpstreamProbes(projectPath, gradleUserHome) {
     const workspace = await probeWorkspaceDetected(projectPath);
-    const loom = await probeLoomCacheFound(projectPath);
+    const loom = await probeLoomCacheFound(projectPath, gradleUserHome);
     let gradle;
     if (workspace.status !== "ok") {
         gradle = { status: "skipped" };
@@ -227,11 +228,11 @@ export async function runUpstreamProbes(projectPath) {
     }
     return { workspace, gradle, loom };
 }
-export async function buildEarlyTasksForBlocked(projectPath, detail, include, discovery) {
+export async function buildEarlyTasksForBlocked(projectPath, detail, include, discovery, gradleUserHome) {
     if (VALIDATE_PROJECT_TASKS_OFF) {
         return undefined;
     }
-    const { workspace, gradle, loom } = await runUpstreamProbes(projectPath);
+    const { workspace, gradle, loom } = await runUpstreamProbes(projectPath, gradleUserHome);
     const minecraftArtifactResolved = {
         status: "skipped"
     };
@@ -262,7 +263,7 @@ export async function buildFullTaskStatusReport(deps, args) {
     if (VALIDATE_PROJECT_TASKS_OFF) {
         return undefined;
     }
-    const { workspace, gradle, loom } = await runUpstreamProbes(args.projectPath);
+    const { workspace, gradle, loom } = await runUpstreamProbes(args.projectPath, args.gradleUserHome);
     let minecraftArtifactResolved;
     if (workspace.status !== "ok" || gradle.status !== "ok") {
         minecraftArtifactResolved = { status: "skipped" };
@@ -274,6 +275,7 @@ export async function buildFullTaskStatusReport(deps, args) {
             mapping: args.mapping,
             sourcePriority: args.sourcePriority,
             projectPath: args.projectPath,
+            gradleUserHome: args.gradleUserHome,
             scope: args.scope,
             preferProjectVersion: args.preferProjectVersion
         }, args.stageEmitter);

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

@@ -52,14 +52,17 @@ export declare const validateProjectShape: {
     subject: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"workspace">;
         projectPath: z.ZodString;
+        gradleUserHome: z.ZodOptional<z.ZodString>;
         discover: z.ZodOptional<z.ZodArray<z.ZodEnum<["mixins", "access-wideners", "access-transformers"]>, "many">>;
     }, "strip", z.ZodTypeAny, {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     }, {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"mixin">;
@@ -248,14 +251,17 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     subject: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"workspace">;
         projectPath: z.ZodString;
+        gradleUserHome: z.ZodOptional<z.ZodString>;
         discover: z.ZodOptional<z.ZodArray<z.ZodEnum<["mixins", "access-wideners", "access-transformers"]>, "many">>;
     }, "strip", z.ZodTypeAny, {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     }, {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"mixin">;
@@ -449,6 +455,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     subject: {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     } | {
         kind: "mixin";
@@ -504,6 +511,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     subject: {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     } | {
         kind: "mixin";
@@ -571,6 +579,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     subject: {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     } | {
         kind: "mixin";
@@ -626,6 +635,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     subject: {
         kind: "workspace";
         projectPath: string;
+        gradleUserHome?: string | undefined;
         discover?: ("mixins" | "access-wideners" | "access-transformers")[] | undefined;
     } | {
         kind: "mixin";

package/dist/entry-tools/validate-project-service.js

@@ -31,6 +31,7 @@ const subjectSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("workspace"),
         projectPath: nonEmptyString,
+        gradleUserHome: nonEmptyString.optional(),
         discover: z.array(z.enum(["mixins", "access-wideners", "access-transformers"])).optional()
     }),
     z.object({

package/dist/entry-tools/verify-mixin-target-service.d.ts

@@ -16,6 +16,7 @@ export type VerifyMixinTargetInput = {
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     projectPath?: string;
+    gradleUserHome?: string;
     target?: ResolveArtifactTargetInput;
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
@@ -82,6 +83,7 @@ export type VerifyMixinTargetDeps = {
         mapping?: SourceMapping;
         sourcePriority?: MappingSourcePriority;
         projectPath?: string;
+        gradleUserHome?: string;
         scope?: ArtifactScope;
         preferProjectVersion?: boolean;
         strictVersion?: boolean;

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

@@ -185,6 +185,7 @@ export class VerifyMixinTargetService {
             mapping: input.mapping,
             sourcePriority: input.sourcePriority,
             projectPath: input.projectPath,
+            gradleUserHome: input.gradleUserHome,
             scope: input.scope,
             preferProjectVersion: input.preferProjectVersion,
             strictVersion: input.strictVersion

package/dist/errors.js

@@ -49,7 +49,10 @@ export class AppError extends Error {
     }
 }
 export const createError = (payload) => new AppError(payload);
+// Narrow strictly by class identity. Duck-typing on `code` would also accept
+// arbitrary Errors whose `details` may leak unsanitised context (paths, tokens)
+// into AppError handling paths.
 export const isAppError = (value) => {
-    return value instanceof Error && value.code !== undefined;
+    return value instanceof AppError;
 };
 //# sourceMappingURL=errors.js.map

package/dist/gradle-paths.d.ts

@@ -1,4 +1,9 @@
 export declare function normalizeOptionalProjectPath(projectPath: string | undefined): string | undefined;
-export declare function resolveGradleUserHomePath(): string;
-export declare function buildVersionSourceSearchRoots(projectPath: string | undefined): string[];
-export declare function buildLoaderRuntimeSearchRoots(projectPath: string | undefined): string[];
+export declare function normalizeOptionalGradleUserHomePath(gradleUserHome: string | undefined): string | undefined;
+export declare function resolveGradleUserHomePath(gradleUserHome?: string): string;
+export type GradleCacheSearchInput = string | {
+    projectPath?: string;
+    gradleUserHome?: string;
+} | undefined;
+export declare function buildVersionSourceSearchRoots(input: GradleCacheSearchInput): string[];
+export declare function buildLoaderRuntimeSearchRoots(input: GradleCacheSearchInput): string[];

package/dist/gradle-paths.js

@@ -12,7 +12,22 @@ export function normalizeOptionalProjectPath(projectPath) {
     const normalized = normalizePathForHost(trimmed, undefined, "projectPath");
     return isAbsolute(normalized) ? normalized : resolvePath(process.cwd(), normalized);
 }
-export function resolveGradleUserHomePath() {
+export function normalizeOptionalGradleUserHomePath(gradleUserHome) {
+    if (!gradleUserHome) {
+        return undefined;
+    }
+    const trimmed = gradleUserHome.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = normalizePathForHost(trimmed, undefined, "gradleUserHome");
+    return isAbsolute(normalized) ? normalized : resolvePath(process.cwd(), normalized);
+}
+export function resolveGradleUserHomePath(gradleUserHome) {
+    const explicit = normalizeOptionalGradleUserHomePath(gradleUserHome);
+    if (explicit) {
+        return explicit;
+    }
     const configured = process.env.GRADLE_USER_HOME?.trim();
     if (!configured) {
         return resolvePath(homedir(), ".gradle");
@@ -20,7 +35,20 @@ export function resolveGradleUserHomePath() {
     const normalized = normalizePathForHost(configured, undefined, "GRADLE_USER_HOME");
     return isAbsolute(normalized) ? normalized : resolvePath(process.cwd(), normalized);
 }
-export function buildVersionSourceSearchRoots(projectPath) {
+function normalizeGradleCacheSearchInput(input) {
+    if (typeof input === "string" || input === undefined) {
+        return {
+            projectPath: normalizeOptionalProjectPath(input)
+        };
+    }
+    const gradleUserHome = normalizeOptionalGradleUserHomePath(input.gradleUserHome);
+    return {
+        projectPath: normalizeOptionalProjectPath(input.projectPath),
+        gradleUserHome
+    };
+}
+export function buildVersionSourceSearchRoots(input) {
+    const { projectPath, gradleUserHome } = normalizeGradleCacheSearchInput(input);
     const roots = new Set();
     if (projectPath) {
         roots.add(resolvePath(projectPath, ".gradle", "loom-cache"));
@@ -30,12 +58,13 @@ export function buildVersionSourceSearchRoots(projectPath) {
         roots.add(resolvePath(projectParent, ".gradle-user-home", "loom-cache"));
         roots.add(resolvePath(projectParent, ".gradle-user-home", "caches", "fabric-loom"));
     }
-    const homeGradle = resolveGradleUserHomePath();
+    const homeGradle = resolveGradleUserHomePath(gradleUserHome);
     roots.add(resolvePath(homeGradle, "loom-cache"));
     roots.add(resolvePath(homeGradle, "caches", "fabric-loom"));
     return [...roots];
 }
-export function buildLoaderRuntimeSearchRoots(projectPath) {
+export function buildLoaderRuntimeSearchRoots(input) {
+    const { projectPath, gradleUserHome } = normalizeGradleCacheSearchInput(input);
     const roots = new Set();
     if (projectPath) {
         roots.add(resolvePath(projectPath, "build"));
@@ -47,7 +76,7 @@ export function buildLoaderRuntimeSearchRoots(projectPath) {
         roots.add(resolvePath(projectPath, ".gradle", "caches", "neoformruntime"));
         roots.add(resolvePath(projectPath, ".gradle", "caches", "moddev"));
     }
-    const homeGradle = resolveGradleUserHomePath();
+    const homeGradle = resolveGradleUserHomePath(gradleUserHome);
     roots.add(resolvePath(homeGradle, "caches", "forge_gradle"));
     roots.add(resolvePath(homeGradle, "caches", "neogradle"));
     roots.add(resolvePath(homeGradle, "caches", "neoformruntime"));

package/dist/index.js

@@ -142,6 +142,7 @@ const validateProjectService = new ValidateProjectService({
             mapping: input.mapping,
             sourcePriority: input.sourcePriority,
             projectPath: input.projectPath,
+            gradleUserHome: input.gradleUserHome,
             scope: input.scope,
             preferProjectVersion: input.preferProjectVersion
         });
@@ -166,6 +167,7 @@ const verifyMixinTargetService = new VerifyMixinTargetService({
             mapping: input.mapping,
             sourcePriority: input.sourcePriority,
             projectPath: input.projectPath,
+            gradleUserHome: input.gradleUserHome,
             scope: input.scope,
             preferProjectVersion: input.preferProjectVersion,
             strictVersion: input.strictVersion
@@ -406,19 +408,19 @@ server.tool("list-versions", "List available Minecraft versions from Mojang mani
     limit: input.limit
 })));
 registerToolSchema("list-versions", listVersionsSchema);
-server.tool("inspect-minecraft", "High-level v3 entry 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)));
+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", "High-level v3 entry tool for symbol existence, mapping, lifecycle, workspace analysis, and API overview.", 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.", analyzeSymbolShape, { readOnlyHint: true }, async (args) => runTool("analyze-symbol", args, analyzeSymbolSchema, async (input) => analyzeSymbolService.execute(input)));
 registerToolSchema("analyze-symbol", analyzeSymbolSchema);
-server.tool("compare-minecraft", "High-level v3 entry 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)));
+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);
-server.tool("analyze-mod", "High-level v3 entry tool for mod metadata inspection, decompile/search flows, class source, and safe remap previews/applies.", analyzeModShape, { readOnlyHint: false }, async (args) => runTool("analyze-mod", args, analyzeModSchema, async (input) => analyzeModService.execute(input)));
+server.tool("analyze-mod", "Top-level workflow tool for mod metadata inspection, decompile/search flows, class source, and safe remap previews/applies.", analyzeModShape, { readOnlyHint: false }, async (args) => runTool("analyze-mod", args, analyzeModSchema, async (input) => analyzeModService.execute(input)));
 registerToolSchema("analyze-mod", analyzeModSchema);
-server.tool("validate-project", "High-level v3 entry tool for project summary, direct mixin validation, and access widener/access transformer validation.", validateProjectShape, { readOnlyHint: true }, async (args, extra) => runTool("validate-project", args, validateProjectSchema, async (input) => validateProjectService.execute(input, {
+server.tool("validate-project", "Top-level workflow tool for project summary, direct mixin validation, and access widener/access transformer validation.", validateProjectShape, { readOnlyHint: true }, async (args, extra) => runTool("validate-project", args, validateProjectSchema, async (input) => validateProjectService.execute(input, {
     stageEmitter: makeStageEmitter(extra)
 })));
 registerToolSchema("validate-project", validateProjectSchema);
-server.tool("manage-cache", "High-level v3 entry tool for cache summaries, listing, verification, previewed mutation, and explicit apply operations.", manageCacheShape, { readOnlyHint: false }, async (args) => runTool("manage-cache", args, manageCacheSchema, async (input) => manageCacheService.execute(input)));
+server.tool("manage-cache", "Top-level workflow tool for cache summaries, listing, verification, previewed mutation, and explicit apply operations.", manageCacheShape, { readOnlyHint: false }, async (args) => runTool("manage-cache", args, manageCacheSchema, async (input) => manageCacheService.execute(input)));
 registerToolSchema("manage-cache", manageCacheSchema);
 if (!VERIFY_MIXIN_TARGET_OFF) {
     server.tool("verify-mixin-target", "Single-call probe: does this target owner / member exist and which @Shadow / @Accessor / @Invoker should the mixin use? Reuses target.kind workspace/version/coordinate/dependency/jar.", verifyMixinTargetShape, { readOnlyHint: true }, async (args) => runTool("verify-mixin-target", args, verifyMixinTargetSchema, async (input) => verifyMixinTargetService.execute({
@@ -428,6 +430,7 @@ if (!VERIFY_MIXIN_TARGET_OFF) {
         mapping: input.mapping,
         sourcePriority: input.sourcePriority,
         projectPath: input.projectPath,
+        gradleUserHome: input.gradleUserHome,
         target: input.target,
         scope: input.scope,
         preferProjectVersion: input.preferProjectVersion,
@@ -451,6 +454,7 @@ server.tool("resolve-artifact", "Resolve source artifact from a target object ({
     sourcePriority: input.sourcePriority,
     allowDecompile: input.allowDecompile,
     projectPath: input.projectPath,
+    gradleUserHome: input.gradleUserHome,
     scope: input.scope,
     preferProjectVersion: input.preferProjectVersion,
     strictVersion: input.strictVersion,
@@ -480,6 +484,7 @@ server.tool("get-class-source", "Get Java source for a class by target ({ type:
         sourcePriority: input.sourcePriority,
         allowDecompile: input.allowDecompile,
         projectPath: input.projectPath,
+        gradleUserHome: input.gradleUserHome,
         scope: input.scope,
         preferProjectVersion: input.preferProjectVersion,
         strictVersion: input.strictVersion,
@@ -506,6 +511,7 @@ server.tool("get-class-members", "Get fields/methods/constructors for one class
         memberPattern: input.memberPattern,
         maxMembers: input.maxMembers,
         projectPath: input.projectPath,
+        gradleUserHome: input.gradleUserHome,
         scope: input.scope,
         preferProjectVersion: input.preferProjectVersion,
         strictVersion: input.strictVersion
@@ -530,7 +536,8 @@ server.tool("search-class-source", "Search indexed class source files for one ar
         limit: input.limit,
         cursor: input.cursor,
         queryNamespace: input.queryNamespace,
-        sourcePriority: input.sourcePriority
+        sourcePriority: input.sourcePriority,
+        gradleUserHome: input.gradleUserHome
     });
 }));
 registerToolSchema("search-class-source", searchClassSourceSchema);
@@ -554,6 +561,7 @@ server.tool("trace-symbol-lifecycle", "Trace which Minecraft versions contain a
     toVersion: input.toVersion,
     mapping: input.mapping,
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     includeSnapshots: input.includeSnapshots,
     maxVersions: input.maxVersions,
     includeTimeline: input.includeTimeline
@@ -565,6 +573,7 @@ server.tool("diff-class-signatures", "Compare one class signature between two Mi
     toVersion: input.toVersion,
     mapping: input.mapping,
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     includeFullDiff: input.includeFullDiff
 })));
 registerToolSchema("diff-class-signatures", diffClassSignaturesSchema);
@@ -577,6 +586,7 @@ server.tool("find-mapping", "Find symbol mapping candidates between namespaces u
     sourceMapping: input.sourceMapping,
     targetMapping: input.targetMapping,
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     signatureMode: input.signatureMode,
     disambiguation: input.disambiguation,
     maxCandidates: input.maxCandidates
@@ -590,6 +600,7 @@ server.tool("resolve-method-mapping-exact", "Resolve one method mapping exactly
     sourceMapping: input.sourceMapping,
     targetMapping: input.targetMapping,
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     maxCandidates: input.maxCandidates
 })));
 registerToolSchema("resolve-method-mapping-exact", resolveMethodMappingExactSchema);
@@ -599,6 +610,7 @@ server.tool("get-class-api-matrix", "List class/member API rows across obfuscate
     classNameMapping: input.classNameMapping,
     includeKinds: parseClassApiKinds(input.includeKinds),
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     maxRows: input.maxRows
 })));
 registerToolSchema("get-class-api-matrix", getClassApiMatrixSchema);
@@ -611,6 +623,7 @@ server.tool("resolve-workspace-symbol", "Resolve class/field/method names as see
     descriptor: input.descriptor,
     sourceMapping: input.sourceMapping,
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     maxCandidates: input.maxCandidates
 })));
 registerToolSchema("resolve-workspace-symbol", resolveWorkspaceSymbolSchema);
@@ -622,6 +635,7 @@ server.tool("check-symbol-exists", "Check whether a class/field/method symbol ex
     descriptor: input.descriptor,
     sourceMapping: input.sourceMapping,
     sourcePriority: input.sourcePriority,
+    gradleUserHome: input.gradleUserHome,
     nameMode: input.nameMode,
     signatureMode: input.signatureMode,
     maxCandidates: input.maxCandidates
@@ -657,6 +671,7 @@ server.tool("validate-mixin", "Validate Mixin source against Minecraft bytecode
     sourcePriority: input.sourcePriority,
     scope: input.scope,
     projectPath: input.projectPath,
+    gradleUserHome: input.gradleUserHome,
     preferProjectVersion: input.preferProjectVersion,
     minSeverity: input.minSeverity,
     hideUncertain: input.hideUncertain,
@@ -677,6 +692,7 @@ server.tool("validate-access-widener", "Validate Access Widener file entries aga
     mapping: input.mapping,
     sourcePriority: input.sourcePriority,
     projectPath: input.projectPath,
+    gradleUserHome: input.gradleUserHome,
     scope: input.scope,
     preferProjectVersion: input.preferProjectVersion
 })));
@@ -687,6 +703,7 @@ server.tool("validate-access-transformer", "Validate Access Transformer file ent
     atNamespace: input.atNamespace,
     sourcePriority: input.sourcePriority,
     projectPath: input.projectPath,
+    gradleUserHome: input.gradleUserHome,
     scope: input.scope,
     preferProjectVersion: input.preferProjectVersion
 })));

package/dist/java-process.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_STDIO_SNAPSHOT = 6240;
 export interface JavaProcessOptions {
     jarPath: string;
     args: string[];
@@ -12,5 +13,13 @@ export interface JavaProcessResult {
     stdoutTail: string;
     stderrTail: string;
 }
+export declare function limitStdio(text: string): string;
+export declare function isAbsolutePath(value: string): boolean;
+export declare function isOptionArg(value: string): boolean;
+export declare function normalizeArgs(args: string[]): string[];
 export declare function assertJavaAvailable(): Promise<void>;
 export declare function runJavaProcess(options: JavaProcessOptions): Promise<JavaProcessResult>;
+export declare const javaRunner: {
+    run: (options: JavaProcessOptions) => Promise<JavaProcessResult>;
+    assertAvailable: () => Promise<void>;
+};

package/dist/java-process.js

@@ -2,20 +2,20 @@ import { spawn } from "node:child_process";
 import { createError, ERROR_CODES } from "./errors.js";
 import { normalizePathForHost } from "./path-converter.js";
 const JAVA_CHECK_TIMEOUT_MS = 2_000;
-const MAX_STDIO_SNAPSHOT = 6_240;
-function limitStdio(text) {
+export const MAX_STDIO_SNAPSHOT = 6_240;
+export function limitStdio(text) {
     if (text.length <= MAX_STDIO_SNAPSHOT) {
         return text;
     }
     return text.slice(-MAX_STDIO_SNAPSHOT);
 }
-function isAbsolutePath(value) {
+export function isAbsolutePath(value) {
     return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
 }
-function isOptionArg(value) {
+export function isOptionArg(value) {
     return value.startsWith("-");
 }
-function normalizeArgs(args) {
+export function normalizeArgs(args) {
     return args.map((arg) => {
         if (isOptionArg(arg)) {
             return arg;
@@ -117,4 +117,10 @@ export function runJavaProcess(options) {
         });
     });
 }
+// Mutable container that lets tests stub the Java subprocess boundary via
+// `mock.method(javaRunner, "run", ...)` without rewriting ESM named imports.
+export const javaRunner = {
+    run: runJavaProcess,
+    assertAvailable: assertJavaAvailable
+};
 //# sourceMappingURL=java-process.js.map

package/dist/mapping/loaders/tiny-loom.d.ts

@@ -1,2 +1,2 @@
 import type { MappingLoaderResult } from "./types.js";
-export declare function loadTinyPairsFromLoom(version: string, projectPath?: string): Promise<MappingLoaderResult>;
+export declare function loadTinyPairsFromLoom(version: string, projectPath?: string, gradleUserHome?: string): Promise<MappingLoaderResult>;

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

@@ -7,8 +7,11 @@ import { effectiveLoomSearchProjectPath } from "../lookup.js";
 import { mergeDirectionIndexes } from "../parsers/symbol-records.js";
 import { parseTinyMappings } from "../parsers/tiny.js";
 const GLOB_SPECIAL_CHARS = /[\\!*+?()[\]{}@|]/g;
-export async function loadTinyPairsFromLoom(version, projectPath) {
-    const searchRoots = buildVersionSourceSearchRoots(effectiveLoomSearchProjectPath(projectPath));
+export async function loadTinyPairsFromLoom(version, projectPath, gradleUserHome) {
+    const searchRoots = buildVersionSourceSearchRoots({
+        projectPath: effectiveLoomSearchProjectPath(projectPath),
+        gradleUserHome
+    });
     const merged = new Map();
     const discoveredPaths = new Set();
     for (const root of searchRoots) {

package/dist/mapping/types.d.ts

@@ -60,6 +60,7 @@ export type FindMappingInput = {
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     projectPath?: string;
+    gradleUserHome?: string;
     disambiguation?: {
         ownerHint?: string;
         descriptorHint?: string;
@@ -73,6 +74,7 @@ export type EnsureMappingAvailableInput = {
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     projectPath?: string;
+    gradleUserHome?: string;
 };
 export type EnsureMappingAvailableOutput = {
     transformChain: string[];
@@ -88,6 +90,7 @@ export type ResolveMethodMappingExactInput = {
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     projectPath?: string;
+    gradleUserHome?: string;
     maxCandidates?: number;
 };
 export type ResolveMethodMappingExactOutput = SymbolResolutionOutput;
@@ -97,6 +100,7 @@ export type ClassApiMatrixInput = {
     className: string;
     classNameMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    gradleUserHome?: string;
     includeKinds?: ClassApiMatrixKind[];
     maxRows?: number;
 };
@@ -134,6 +138,7 @@ export type SymbolExistenceInput = {
     descriptor?: string;
     sourceMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    gradleUserHome?: string;
     nameMode?: "fqcn" | "auto";
     signatureMode?: "exact" | "name-only";
     maxCandidates?: number;

package/dist/mapping-service.d.ts

@@ -41,6 +41,7 @@ export declare class MappingService {
         version: string;
         requestedMapping: SourceMapping;
         sourcePriority?: MappingSourcePriority;
+        gradleUserHome?: string;
     }): Promise<{
         mojangMappingsAvailable: boolean;
         tinyMappingsAvailable: boolean;