@adhisang/minecraft-modding-mcp 2.0.0 → 3.0.0

package/dist/mod-remap-service.js

@@ -1,19 +1,20 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, statSync, rmSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
-import { createError, ERROR_CODES } from "./errors.js";
+import { createError, ERROR_CODES, isAppError } from "./errors.js";
 import { log } from "./logger.js";
 import { resolveTinyMappingFile } from "./mapping-service.js";
 import { resolveMojangTinyFile } from "./mojang-tiny-mapping-service.js";
 import { analyzeModJar } from "./mod-analyzer.js";
 import { normalizePathForHost } from "./path-converter.js";
+import { listJarEntries, readJarEntryAsBuffer } from "./source-jar-reader.js";
 import { remapJar } from "./tiny-remapper-service.js";
 import { resolveTinyRemapperJar } from "./tiny-remapper-resolver.js";
 function normalizeTargetNamespace(target) {
     return target === "yarn" ? "yarn" : "mojang";
 }
-function sourceNamespaceForLoader(loader) {
+function defaultSourceNamespaceForLoader(loader) {
     if (loader === "fabric" || loader === "quilt") {
         return "intermediary";
     }
@@ -35,6 +36,81 @@ function extractMinecraftVersion(dependencies) {
     const match = mcDep.versionRange.match(/(\d+\.\d+(?:\.\d+)?)/);
     return match?.[1];
 }
+function countMatches(input, pattern) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    let count = 0;
+    while (globalPattern.exec(input)) {
+        count += 1;
+    }
+    return count;
+}
+async function detectFabricLikeInputNamespace(inputJar) {
+    const warnings = [];
+    const classEntries = (await listJarEntries(inputJar))
+        .filter((entry) => entry.endsWith(".class"))
+        .slice(0, 24);
+    if (classEntries.length === 0) {
+        warnings.push("Could not inspect class entries to detect input mapping; assuming intermediary.");
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    let mojangScore = 0;
+    let intermediaryScore = 0;
+    for (const entry of classEntries) {
+        let text = "";
+        try {
+            text = (await readJarEntryAsBuffer(inputJar, entry)).toString("latin1");
+        }
+        catch {
+            continue;
+        }
+        mojangScore += countMatches(text, /net\/minecraft\/(?:advancements|client|commands|core|data|gametest|nbt|network|recipe|resources|server|sounds|stats|tags|util|world)\//g) * 3;
+        intermediaryScore += countMatches(text, /net\/minecraft\/class_\d+/g) * 3;
+        intermediaryScore += countMatches(text, /\b(?:method|field)_\d+\b/g);
+    }
+    if (mojangScore > intermediaryScore && mojangScore > 0) {
+        return {
+            fromNamespace: "mojang",
+            warnings
+        };
+    }
+    if (intermediaryScore > mojangScore && intermediaryScore > 0) {
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    warnings.push("Could not confidently detect whether the input jar uses intermediary or mojang names; assuming intermediary.");
+    return {
+        fromNamespace: "intermediary",
+        warnings
+    };
+}
+async function detectInputNamespaceForLoader(inputJar, loader) {
+    if (loader === "fabric" || loader === "quilt") {
+        return detectFabricLikeInputNamespace(inputJar);
+    }
+    return {
+        fromNamespace: defaultSourceNamespaceForLoader(loader),
+        warnings: []
+    };
+}
+function resolveOutputJarPath(input, normalizedInput, modId, modVersion) {
+    const defaultOutputName = `${modId ?? "mod"}-${modVersion ?? "0"}-${input.targetMapping}.jar`;
+    return input.outputJar
+        ? normalizePathForHost(input.outputJar, undefined, "outputJar")
+        : join(dirname(normalizedInput), defaultOutputName);
+}
+function copyJarToDestination(sourceJar, destinationJar) {
+    if (sourceJar === destinationJar) {
+        return;
+    }
+    mkdirSync(dirname(destinationJar), { recursive: true });
+    copyFileSync(sourceJar, destinationJar);
+}
 function buildCacheKey(inputJar, fromNamespace, targetNamespace, mcVersion) {
     const stat = statSync(inputJar, { throwIfNoEntry: false });
     const signature = stat ? `${stat.mtimeMs}:${stat.size}` : "unknown";
@@ -71,7 +147,9 @@ export async function remapModJar(input, config) {
             details: { inputJar: normalizedInput }
         });
     }
-    const fromNamespace = sourceNamespaceForLoader(analysis.loader);
+    const namespaceDetection = await detectInputNamespaceForLoader(normalizedInput, analysis.loader);
+    warnings.push(...namespaceDetection.warnings);
+    const fromNamespace = namespaceDetection.fromNamespace;
     // 3. Determine MC version
     const mcVersion = input.mcVersion ?? extractMinecraftVersion(analysis.dependencies);
     if (!mcVersion) {
@@ -85,21 +163,32 @@ export async function remapModJar(input, config) {
             }
         });
     }
+    const outputJar = resolveOutputJarPath(input, normalizedInput, analysis.modId, analysis.modVersion);
     // 4. Check cache after mapping context is known
     const cacheKey = buildCacheKey(normalizedInput, fromNamespace, resolvedTargetNamespace, mcVersion);
     const cacheDir = join(config.cacheDir, "remapped-mods");
     mkdirSync(cacheDir, { recursive: true });
     const cachedOutput = join(cacheDir, `${cacheKey}.jar`);
     if (existsSync(cachedOutput)) {
-        const outputJar = input.outputJar
-            ? normalizePathForHost(input.outputJar, undefined, "outputJar")
+        const cacheHitOutputJar = input.outputJar
+            ? outputJar
             : cachedOutput;
-        if (outputJar !== cachedOutput) {
-            const { copyFileSync } = await import("node:fs");
-            mkdirSync(dirname(outputJar), { recursive: true });
-            copyFileSync(cachedOutput, outputJar);
-        }
-        log("info", "remap.cache-hit", { inputJar: normalizedInput, outputJar });
+        copyJarToDestination(cachedOutput, cacheHitOutputJar);
+        log("info", "remap.cache-hit", { inputJar: normalizedInput, outputJar: cacheHitOutputJar });
+        return {
+            outputJar: cacheHitOutputJar,
+            mcVersion,
+            fromMapping: fromNamespace,
+            targetMapping: input.targetMapping,
+            resolvedTargetNamespace,
+            durationMs: Date.now() - startedAt,
+            warnings: [...warnings, "Result served from cache."]
+        };
+    }
+    if (fromNamespace === resolvedTargetNamespace) {
+        copyJarToDestination(normalizedInput, outputJar);
+        copyJarToDestination(normalizedInput, cachedOutput);
+        warnings.push(`Input JAR already uses ${fromNamespace} names; output is a copy of the input JAR.`);
         return {
             outputJar,
             mcVersion,
@@ -107,9 +196,23 @@ export async function remapModJar(input, config) {
             targetMapping: input.targetMapping,
             resolvedTargetNamespace,
             durationMs: Date.now() - startedAt,
-            warnings: ["Result served from cache."]
+            warnings
         };
     }
+    if (fromNamespace === "mojang" && resolvedTargetNamespace === "yarn") {
+        throw createError({
+            code: ERROR_CODES.REMAP_FAILED,
+            message: "Mojang-mapped Fabric/Quilt input jars cannot be remapped to yarn with the available mapping files.",
+            details: {
+                inputJar: normalizedInput,
+                mcVersion,
+                fromMapping: fromNamespace,
+                targetMapping: input.targetMapping,
+                resolvedTargetNamespace,
+                nextAction: 'Use targetMapping="mojang" for Mojang-mapped inputs, or rebuild the mod against intermediary mappings before requesting yarn output.'
+            }
+        });
+    }
     // 5. Resolve tiny-remapper
     const tinyRemapperJar = await resolveTinyRemapperJar(config.cacheDir, config.tinyRemapperJarPath);
     // 6. Resolve mapping file and remap
@@ -125,30 +228,39 @@ export async function remapModJar(input, config) {
         toNamespace = "mojang";
         warnings.push(...mojangTiny.warnings);
     }
-    // 7. Determine output path
-    const modId = analysis.modId ?? "mod";
-    const modVersion = analysis.modVersion ?? "0";
-    const defaultOutputName = `${modId}-${modVersion}-${input.targetMapping}.jar`;
-    const outputJar = input.outputJar
-        ? normalizePathForHost(input.outputJar, undefined, "outputJar")
-        : join(dirname(normalizedInput), defaultOutputName);
     mkdirSync(dirname(outputJar), { recursive: true });
     // 8. Use temporary directory for intermediate work
     const tempDir = join(tmpdir(), `mcp-remap-${cacheKey.slice(0, 12)}`);
     mkdirSync(tempDir, { recursive: true });
     try {
         const tempOutput = join(tempDir, "remapped.jar");
-        await remapJar(tinyRemapperJar, {
-            inputJar: normalizedInput,
-            outputJar: tempOutput,
-            mappingsFile,
-            fromNamespace,
-            toNamespace,
-            timeoutMs: config.remapTimeoutMs,
-            maxMemoryMb: config.remapMaxMemoryMb
-        });
+        try {
+            await remapJar(tinyRemapperJar, {
+                inputJar: normalizedInput,
+                outputJar: tempOutput,
+                mappingsFile,
+                fromNamespace,
+                toNamespace,
+                timeoutMs: config.remapTimeoutMs,
+                maxMemoryMb: config.remapMaxMemoryMb
+            });
+        }
+        catch (caughtError) {
+            if (isAppError(caughtError)) {
+                throw createError({
+                    code: caughtError.code,
+                    message: caughtError.message,
+                    details: {
+                        ...(caughtError.details ?? {}),
+                        fromMapping: fromNamespace,
+                        targetMapping: input.targetMapping,
+                        resolvedTargetNamespace
+                    }
+                });
+            }
+            throw caughtError;
+        }
         // Copy to final destination and cache
-        const { copyFileSync } = await import("node:fs");
         copyFileSync(tempOutput, outputJar);
         if (outputJar !== cachedOutput) {
             mkdirSync(dirname(cachedOutput), { recursive: true });

package/dist/path-resolver.js

@@ -2,12 +2,35 @@ import { realpathSync, statSync } from "node:fs";
 import { extname, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { normalizePathForHost } from "./path-converter.js";
-import { createError, ERROR_CODES } from "./errors.js";
+import { createError, ERROR_CODES, isAppError } from "./errors.js";
 const INVALID_ENTRY = /(^|\/|\\)\.\.(\/|\\|$)/;
 export function normalizeJarPath(jarPath) {
     const normalizedInput = normalizePathForHost(jarPath, undefined, "jarPath");
     const absolute = resolve(normalizedInput);
-    const stats = statSync(absolute);
+    let stats;
+    try {
+        stats = statSync(absolute, { throwIfNoEntry: false });
+    }
+    catch (cause) {
+        if (isAppError(cause)) {
+            throw cause;
+        }
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Could not access jar "${normalizedInput}".`,
+            details: {
+                jarPath: normalizedInput,
+                reason: cause instanceof Error ? cause.message : String(cause)
+            }
+        });
+    }
+    if (!stats) {
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Jar not found: "${normalizedInput}".`,
+            details: { jarPath: normalizedInput }
+        });
+    }
     if (!stats.isFile()) {
         throw createError({
             code: ERROR_CODES.JAR_NOT_FOUND,
@@ -22,8 +45,22 @@ export function normalizeJarPath(jarPath) {
             details: { jarPath: normalizedInput }
         });
     }
-    const resolved = realpathSync(absolute);
-    return resolved;
+    try {
+        return realpathSync(absolute);
+    }
+    catch (cause) {
+        if (isAppError(cause)) {
+            throw cause;
+        }
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Could not resolve jar "${normalizedInput}".`,
+            details: {
+                jarPath: normalizedInput,
+                reason: cause instanceof Error ? cause.message : String(cause)
+            }
+        });
+    }
 }
 export function resolveJarPathWithSymlinkCheck(jarPath) {
     const resolvedPath = normalizeJarPath(jarPath);

package/dist/registry-service.d.ts

@@ -3,6 +3,8 @@ import type { Config } from "./types.js";
 export type GetRegistryDataInput = {
     version: string;
     registry?: string;
+    includeData?: boolean;
+    maxEntriesPerRegistry?: number;
 };
 export type RegistryEntry = {
     protocol_id: number;
@@ -15,8 +17,11 @@ export type GetRegistryDataOutput = {
     version: string;
     registry?: string;
     registries?: string[];
-    data: Record<string, RegistryData> | RegistryData;
+    data?: Record<string, RegistryData> | RegistryData;
     entryCount: number;
+    returnedEntryCount?: number;
+    registryEntryCounts?: Record<string, number>;
+    dataTruncated?: boolean;
     warnings: string[];
 };
 export declare class RegistryService {
@@ -26,4 +31,8 @@ export declare class RegistryService {
     constructor(config: Config, versionService: VersionService);
     getRegistryData(input: GetRegistryDataInput): Promise<GetRegistryDataOutput>;
     private loadRegistries;
+    private loadExistingRegistries;
+    private readRegistryFileOrThrow;
+    private isInvalidRegistrySnapshot;
+    private cacheRegistries;
 }

package/dist/registry-service.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { spawn } from "node:child_process";
@@ -6,6 +6,40 @@ import { createError, ERROR_CODES } from "./errors.js";
 import { log } from "./logger.js";
 const DATAGEN_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_STDIO_SNAPSHOT = 6_240;
+function clampPositiveInt(value) {
+    if (!Number.isFinite(value) || value == null) {
+        return undefined;
+    }
+    return Math.max(1, Math.trunc(value));
+}
+function sortedRegistryEntryNames(entries) {
+    return Object.keys(entries).sort((left, right) => left.localeCompare(right));
+}
+function limitRegistryEntries(data, maxEntries) {
+    const entryNames = sortedRegistryEntryNames(data.entries);
+    const total = entryNames.length;
+    if (maxEntries == null || total <= maxEntries) {
+        return {
+            data,
+            total,
+            returned: total,
+            truncated: false
+        };
+    }
+    const limitedEntries = {};
+    for (const entryName of entryNames.slice(0, maxEntries)) {
+        limitedEntries[entryName] = data.entries[entryName];
+    }
+    return {
+        data: {
+            default: data.default,
+            entries: limitedEntries
+        },
+        total,
+        returned: maxEntries,
+        truncated: true
+    };
+}
 function limitOutput(text) {
     if (text.length <= MAX_STDIO_SNAPSHOT)
         return text;
@@ -25,6 +59,31 @@ function findRegistryFile(registryDir) {
     }
     return undefined;
 }
+function parseRegistrySnapshot(raw, version, registryFile) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw createError({
+            code: ERROR_CODES.REGISTRY_GENERATION_FAILED,
+            message: `Failed to parse registries.json for version "${version}".`,
+            details: {
+                version,
+                registryFile,
+                reason: error instanceof Error ? error.message : String(error)
+            }
+        });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw createError({
+            code: ERROR_CODES.REGISTRY_GENERATION_FAILED,
+            message: `registries.json for version "${version}" has invalid structure.`,
+            details: { version, registryFile }
+        });
+    }
+    return parsed;
+}
 function runDataGen(serverJarPath, outputDir, version) {
     return new Promise((resolve, reject) => {
         // MC 1.18+ uses bundler format, older versions use -cp with main class directly.
@@ -131,6 +190,12 @@ export class RegistryService {
         const warnings = [];
         const allRegistries = await this.loadRegistries(version, warnings);
         const registryNames = Object.keys(allRegistries).sort();
+        const includeData = input.includeData ?? true;
+        const maxEntriesPerRegistry = clampPositiveInt(input.maxEntriesPerRegistry);
+        const registryEntryCounts = Object.fromEntries(registryNames.map((registryName) => [
+            registryName,
+            Object.keys(allRegistries[registryName].entries).length
+        ]));
         if (input.registry) {
             const registryName = normalizeRegistryName(input.registry);
             const data = allRegistries[registryName];
@@ -145,11 +210,17 @@ export class RegistryService {
                     }
                 });
             }
+            const limited = limitRegistryEntries(data, maxEntriesPerRegistry);
             return {
                 version,
                 registry: registryName,
-                data,
-                entryCount: Object.keys(data.entries).length,
+                ...(includeData ? { data: limited.data } : {}),
+                entryCount: limited.total,
+                returnedEntryCount: includeData ? limited.returned : 0,
+                registryEntryCounts: {
+                    [registryName]: limited.total
+                },
+                ...(limited.truncated ? { dataTruncated: true } : {}),
                 warnings
             };
         }
@@ -157,11 +228,25 @@ export class RegistryService {
         for (const registry of Object.values(allRegistries)) {
             totalEntries += Object.keys(registry.entries).length;
         }
+        let returnedEntryCount = 0;
+        let dataTruncated = false;
+        const limitedData = {};
+        if (includeData) {
+            for (const registryName of registryNames) {
+                const limited = limitRegistryEntries(allRegistries[registryName], maxEntriesPerRegistry);
+                limitedData[registryName] = limited.data;
+                returnedEntryCount += limited.returned;
+                dataTruncated ||= limited.truncated;
+            }
+        }
         return {
             version,
             registries: registryNames,
-            data: allRegistries,
+            ...(includeData ? { data: limitedData } : {}),
             entryCount: totalEntries,
+            returnedEntryCount: includeData ? returnedEntryCount : 0,
+            registryEntryCounts,
+            ...(dataTruncated ? { dataTruncated: true } : {}),
             warnings
         };
     }
@@ -170,31 +255,79 @@ export class RegistryService {
         if (cached)
             return cached;
         const registryDir = join(this.config.cacheDir, "registries", version);
-        // Check if we already have generated data
-        let registryFile = findRegistryFile(registryDir);
+        const cachedRegistries = this.loadExistingRegistries(registryDir, version, warnings);
+        if (cachedRegistries) {
+            this.cacheRegistries(version, cachedRegistries);
+            return cachedRegistries;
+        }
+        await mkdir(registryDir, { recursive: true });
+        const serverJar = await this.versionService.resolveServerJar(version);
+        await runDataGen(serverJar.jarPath, registryDir, version);
+        const registryFile = findRegistryFile(registryDir);
         if (!registryFile) {
-            await mkdir(registryDir, { recursive: true });
-            const serverJar = await this.versionService.resolveServerJar(version);
-            await runDataGen(serverJar.jarPath, registryDir, version);
-            registryFile = findRegistryFile(registryDir);
-            if (!registryFile) {
-                throw createError({
-                    code: ERROR_CODES.REGISTRY_GENERATION_FAILED,
-                    message: `Registry data generation did not produce registries.json for version "${version}".`,
-                    details: { version, registryDir }
+            throw createError({
+                code: ERROR_CODES.REGISTRY_GENERATION_FAILED,
+                message: `Registry data generation did not produce registries.json for version "${version}".`,
+                details: { version, registryDir }
+            });
+        }
+        const parsed = this.readRegistryFileOrThrow(registryFile, version);
+        this.cacheRegistries(version, parsed);
+        return parsed;
+    }
+    loadExistingRegistries(registryDir, version, warnings) {
+        for (const candidate of resolveRegistryPaths(registryDir)) {
+            if (!existsSync(candidate)) {
+                continue;
+            }
+            try {
+                return this.readRegistryFileOrThrow(candidate, version);
+            }
+            catch (error) {
+                if (!this.isInvalidRegistrySnapshot(error)) {
+                    throw error;
+                }
+                warnings.push(`Ignored corrupt cached registry snapshot and regenerated it: ${candidate}`);
+                log("warn", "registry.cache.invalidated", {
+                    version,
+                    registryFile: candidate,
+                    reason: error.message
                 });
+                try {
+                    rmSync(candidate, { force: true });
+                }
+                catch {
+                    // best-effort cleanup
+                }
             }
         }
-        const raw = readFileSync(registryFile, "utf8");
-        const parsed = JSON.parse(raw);
-        // Validate structure
-        if (typeof parsed !== "object" || parsed === null) {
+        return undefined;
+    }
+    readRegistryFileOrThrow(registryFile, version) {
+        let raw;
+        try {
+            raw = readFileSync(registryFile, "utf8");
+        }
+        catch (error) {
             throw createError({
                 code: ERROR_CODES.REGISTRY_GENERATION_FAILED,
-                message: `registries.json for version "${version}" has invalid structure.`,
-                details: { version }
+                message: `Failed to read registries.json for version "${version}".`,
+                details: {
+                    version,
+                    registryFile,
+                    reason: error instanceof Error ? error.message : String(error)
+                }
             });
         }
+        return parseRegistrySnapshot(raw, version, registryFile);
+    }
+    isInvalidRegistrySnapshot(error) {
+        return (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === ERROR_CODES.REGISTRY_GENERATION_FAILED);
+    }
+    cacheRegistries(version, parsed) {
         this.registryCache.set(version, parsed);
         // Trim cache to avoid unbounded growth
         if (this.registryCache.size > 8) {
@@ -202,7 +335,6 @@ export class RegistryService {
             if (oldest !== undefined)
                 this.registryCache.delete(oldest);
         }
-        return parsed;
     }
 }
 function normalizeRegistryName(name) {

package/dist/search-hit-accumulator.js

@@ -107,6 +107,21 @@ function heapSiftUp(heap, index) {
         index = parent;
     }
 }
+function heapPopWorst(heap) {
+    if (heap.length === 0) {
+        return undefined;
+    }
+    const root = heap[0];
+    const tail = heap.pop();
+    if (heap.length === 0) {
+        return root;
+    }
+    if (tail) {
+        heap[0] = tail;
+        heapSiftDown(heap, 0, heap.length);
+    }
+    return root;
+}
 export function createSearchHitAccumulator(limit, cursor) {
     const pageLimit = Math.max(1, limit);
     const keepLimit = pageLimit + 1;
@@ -141,8 +156,14 @@ export function createSearchHitAccumulator(limit, cursor) {
             return heap.length;
         },
         finalize() {
-            // Sort heap contents by scoreHitOrder (best first)
-            const sorted = heap.slice().sort(scoreHitOrder);
+            const sorted = new Array(heap.length);
+            const heapCopy = heap.slice();
+            for (let index = heapCopy.length - 1; index >= 0; index -= 1) {
+                const next = heapPopWorst(heapCopy);
+                if (next) {
+                    sorted[index] = next;
+                }
+            }
             const page = sorted.slice(0, pageLimit);
             const hasMore = totalAfterCursor > page.length;
             return {

package/dist/source-jar-reader.js

@@ -9,6 +9,20 @@ function toErrorMessage(value) {
     }
     return String(value);
 }
+function hasJavaSourceExtension(entryPath) {
+    const suffix = ".java";
+    if (entryPath.length < suffix.length) {
+        return false;
+    }
+    for (let index = 0; index < suffix.length; index += 1) {
+        const charCode = entryPath.charCodeAt(entryPath.length - suffix.length + index);
+        const normalizedCharCode = charCode >= 65 && charCode <= 90 ? charCode + 32 : charCode;
+        if (normalizedCharCode !== suffix.charCodeAt(index)) {
+            return false;
+        }
+    }
+    return true;
+}
 function openZipFile(jarPath) {
     return new Promise((resolve, reject) => {
         yauzl.open(jarPath, {
@@ -128,7 +142,7 @@ export async function listJarEntries(jarPath) {
 }
 export async function listJavaEntries(jarPath) {
     const entries = await listJarEntries(jarPath);
-    return entries.filter((entry) => entry.toLowerCase().endsWith(".java") && isSecureJarEntryPath(entry));
+    return entries.filter((entry) => hasJavaSourceExtension(entry) && isSecureJarEntryPath(entry));
 }
 export async function readJarEntryAsUtf8(jarPath, entryPath) {
     const contentBuffer = await readJarEntryAsBuffer(jarPath, entryPath);
@@ -171,7 +185,7 @@ export async function* iterateJavaEntriesAsUtf8(jarPath, maxBytes) {
             if (!entry) {
                 break;
             }
-            if (!entry.fileName.toLowerCase().endsWith(".java")) {
+            if (!hasJavaSourceExtension(entry.fileName)) {
                 continue;
             }
             if (!isSecureJarEntryPath(entry.fileName)) {

package/dist/source-resolver.js

@@ -1,6 +1,7 @@
 import { readdirSync } from "node:fs";
 import { basename, dirname, join, resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
+import fastGlob from "fast-glob";
 import { createError, ERROR_CODES } from "./errors.js";
 import { buildRemoteBinaryUrls, buildRemoteSourceUrls, hasExistingJar, parseCoordinate, normalizedCoordinateValue } from "./maven-resolver.js";
 import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
@@ -104,13 +105,11 @@ function resolveGradleCacheCoordinateCandidate(coordinate) {
     ];
     let discoveredFiles = [];
     try {
-        const hashes = readdirSync(baseDir);
-        for (const hashDir of hashes) {
-            const fullDir = join(baseDir, hashDir);
-            for (const entry of readdirSync(fullDir)) {
-                discoveredFiles.push(join(fullDir, entry));
-            }
-        }
+        discoveredFiles = fastGlob.sync("*/*", {
+            cwd: baseDir,
+            absolute: true,
+            onlyFiles: true
+        });
     }
     catch {
         return undefined;