@adhisang/minecraft-modding-mcp 3.1.1 → 3.2.0

package/dist/minecraft-explorer-service.d.ts

@@ -25,12 +25,25 @@ export interface GetSignatureInput {
     includeInherited?: boolean;
 }
 export interface GetSignatureOutput {
+    classAccessFlags?: number;
     constructors: SignatureMember[];
     methods: SignatureMember[];
     fields: SignatureMember[];
     warnings: string[];
     context: ResponseContext;
 }
+export declare function modifierPrefix(flags: number, category: "method" | "field"): string;
+export declare function parseFieldType(descriptor: string, position?: number, options?: {
+    allowVoid?: boolean;
+    invalidVoidMessage?: string;
+}): {
+    type: string;
+    next: number;
+};
+export declare function parseMethodDescriptor(descriptor: string): {
+    args: string[];
+    returnType: string;
+};
 export declare class MinecraftExplorerService {
     private readonly config;
     private readonly signatureCache;

package/dist/minecraft-explorer-service.js

@@ -21,7 +21,7 @@ const ACC_SYNTHETIC = 0x1000;
 function lower(value) {
     return value.toLocaleLowerCase();
 }
-function modifierPrefix(flags, category) {
+export function modifierPrefix(flags, category) {
     const parts = [];
     if ((flags & ACC_PUBLIC) !== 0) {
         parts.push("public");
@@ -68,7 +68,7 @@ function modifierPrefix(flags, category) {
     }
     return parts.join(" ");
 }
-function parseFieldType(descriptor, position = 0, options = {}) {
+export function parseFieldType(descriptor, position = 0, options = {}) {
     if (position >= descriptor.length) {
         throw createError({
             code: ERROR_CODES.INVALID_INPUT,
@@ -127,7 +127,7 @@ function parseFieldType(descriptor, position = 0, options = {}) {
             });
     }
 }
-function parseMethodDescriptor(descriptor) {
+export function parseMethodDescriptor(descriptor) {
     if (!descriptor.startsWith("(")) {
         throw createError({
             code: ERROR_CODES.INVALID_INPUT,
@@ -372,7 +372,7 @@ function parseClassFile(buffer) {
                 });
         }
     }
-    reader.readU2();
+    const accessFlags = reader.readU2();
     const thisClassIndex = reader.readU2();
     const superClassIndex = reader.readU2();
     const interfacesCount = reader.readU2();
@@ -404,6 +404,7 @@ function parseClassFile(buffer) {
     const attributesCount = reader.readU2();
     readAttributes(reader, cp, attributesCount);
     return {
+        accessFlags,
         internalName: readClassName(cp, thisClassIndex),
         superInternalName: readOptionalClassName(cp, superClassIndex),
         interfaceInternalNames,
@@ -442,6 +443,7 @@ export class MinecraftExplorerService {
         const cached = this.signatureCache.get(cacheKey);
         if (cached) {
             return {
+                classAccessFlags: cached.classAccessFlags,
                 constructors: cached.constructors,
                 methods: cached.methods,
                 fields: cached.fields,
@@ -619,6 +621,7 @@ export class MinecraftExplorerService {
         const fields = dedupeMembers(hierarchyClasses.flatMap((classFile) => toMembers(classFile, "field", (member) => shouldIncludeMember(member))));
         const methods = dedupeMembers(hierarchyClasses.flatMap((classFile) => toMembers(classFile, "method", (member) => member.name !== "<init>" && shouldIncludeMember(member))));
         const output = {
+            classAccessFlags: parsed.accessFlags,
             constructors,
             methods,
             fields,
@@ -626,6 +629,7 @@ export class MinecraftExplorerService {
         };
         this.signatureCache.set(cacheKey, output);
         return {
+            classAccessFlags: output.classAccessFlags,
             constructors: output.constructors,
             methods: output.methods,
             fields: output.fields,

package/dist/mixin-validator.d.ts

@@ -5,7 +5,8 @@
 import type { SignatureMember } from "./minecraft-explorer-service.js";
 import type { ParsedMixin } from "./mixin-parser.js";
 import type { ParsedAccessWidener, AccessWidenerEntry } from "./access-widener-parser.js";
-import type { SourceMapping } from "./types.js";
+import type { ParsedAccessTransformer, AccessTransformerEntry } from "./access-transformer-parser.js";
+import type { AccessTransformerNamespace, RuntimeValidationProvenance, SourceMapping } from "./types.js";
 export type MappingHealthReport = {
     jarAvailable: boolean;
     jarPath: string;
@@ -131,6 +132,7 @@ export type MixinValidationResult = {
 };
 export type ResolvedTargetMembers = {
     className: string;
+    classAccessFlags?: number;
     constructors: SignatureMember[];
     methods: SignatureMember[];
     fields: SignatureMember[];
@@ -143,12 +145,36 @@ export type AccessWidenerValidationResult = {
         valid: boolean;
         issue?: string;
         suggestions?: string[];
+        resolvedInRuntime?: boolean;
+        resolvedRuntimeAccess?: "public" | "protected" | "private" | "package-private";
+        resolvedRuntimeJvmDescriptor?: string;
+        resolvedRuntimeJavaSignature?: string;
     }>;
     summary: {
         total: number;
         valid: number;
         invalid: number;
     };
+    provenance?: RuntimeValidationProvenance<SourceMapping>;
+    warnings: string[];
+};
+export type AccessTransformerValidationResult = {
+    valid: boolean;
+    entries: Array<AccessTransformerEntry & {
+        valid: boolean;
+        issue?: string;
+        suggestions?: string[];
+        resolvedInRuntime?: boolean;
+        resolvedRuntimeAccess?: "public" | "protected" | "private" | "package-private";
+        resolvedRuntimeJvmDescriptor?: string;
+        resolvedRuntimeJavaSignature?: string;
+    }>;
+    summary: {
+        total: number;
+        valid: number;
+        invalid: number;
+    };
+    provenance?: RuntimeValidationProvenance<AccessTransformerNamespace>;
     warnings: string[];
 };
 export declare function levenshteinDistance(a: string, b: string): number;
@@ -169,4 +195,9 @@ export declare function validateParsedMixin(parsed: ParsedMixin, targetMembers:
     projectPath?: string;
     mapping?: string;
 }, warningMode?: "full" | "aggregated", healthReport?: MappingHealthReport, symbolExistsButSignatureFailed?: Set<string>): MixinValidationResult;
-export declare function validateParsedAccessWidener(parsed: ParsedAccessWidener, membersByClass: Map<string, ResolvedTargetMembers>, warnings: string[]): AccessWidenerValidationResult;
+export declare function validateParsedAccessWidener(parsed: ParsedAccessWidener, membersByClass: Map<string, ResolvedTargetMembers>, warnings: string[], options?: {
+    includeRuntimeEvidence?: boolean;
+}): AccessWidenerValidationResult;
+export declare function validateParsedAccessTransformer(parsed: ParsedAccessTransformer, membersByClass: Map<string, ResolvedTargetMembers>, warnings: string[], options?: {
+    includeRuntimeEvidence?: boolean;
+}): AccessTransformerValidationResult;

package/dist/mixin-validator.js

@@ -133,6 +133,21 @@ function allMethodNames(members) {
 function allFieldNames(members) {
     return members.fields.map((m) => m.name);
 }
+function accessLevelFromFlags(accessFlags) {
+    if (accessFlags == null) {
+        return undefined;
+    }
+    if ((accessFlags & 0x0001) !== 0) {
+        return "public";
+    }
+    if ((accessFlags & 0x0004) !== 0) {
+        return "protected";
+    }
+    if ((accessFlags & 0x0002) !== 0) {
+        return "private";
+    }
+    return "package-private";
+}
 function computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence) {
     if (!healthReport)
         return undefined;
@@ -735,7 +750,7 @@ export function validateParsedMixin(parsed, targetMembers, warnings, provenance,
 /* ------------------------------------------------------------------ */
 /*  Access Widener validation                                          */
 /* ------------------------------------------------------------------ */
-export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
+export function validateParsedAccessWidener(parsed, membersByClass, warnings, options) {
     warnings.push(...parsed.parseWarnings);
     const validatedEntries = [];
     let validCount = 0;
@@ -743,15 +758,29 @@ export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
     for (const entry of parsed.entries) {
         const ownerFqn = entry.target.replace(/\//g, ".");
         if (entry.targetKind === "class") {
-            if (membersByClass.has(ownerFqn)) {
-                validatedEntries.push({ ...entry, valid: true });
+            const members = membersByClass.get(ownerFqn);
+            if (members) {
+                const runtimeAccess = accessLevelFromFlags(members.classAccessFlags);
+                validatedEntries.push({
+                    ...entry,
+                    valid: true,
+                    ...(options?.includeRuntimeEvidence
+                        ? {
+                            resolvedInRuntime: true,
+                            ...(runtimeAccess
+                                ? { resolvedRuntimeAccess: runtimeAccess }
+                                : {})
+                        }
+                        : {})
+                });
                 validCount++;
             }
             else {
                 validatedEntries.push({
                     ...entry,
                     valid: false,
-                    issue: `Class "${ownerFqn}" not found in game jar.`
+                    issue: `Class "${ownerFqn}" not found in game jar.`,
+                    ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
                 });
                 invalidCount++;
             }
@@ -763,16 +792,37 @@ export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
             validatedEntries.push({
                 ...entry,
                 valid: false,
-                issue: `Owner class "${ownerFqn}" not found in game jar.`
+                issue: `Owner class "${ownerFqn}" not found in game jar.`,
+                ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
             });
             invalidCount++;
             continue;
         }
         if (entry.targetKind === "method") {
             const methodNames = allMethodNames(members);
-            const found = members.methods.some((m) => m.name === entry.name && (!entry.descriptor || m.jvmDescriptor === entry.descriptor)) || members.constructors.some((m) => m.name === entry.name && (!entry.descriptor || m.jvmDescriptor === entry.descriptor));
+            const matchedMember = members.methods.find((m) => m.name === entry.name && (!entry.descriptor || m.jvmDescriptor === entry.descriptor)) ?? members.constructors.find((m) => m.name === entry.name && (!entry.descriptor || m.jvmDescriptor === entry.descriptor));
+            const found = matchedMember != null;
             if (found) {
-                validatedEntries.push({ ...entry, valid: true });
+                const runtimeMember = matchedMember;
+                const runtimeAccess = accessLevelFromFlags(runtimeMember.accessFlags);
+                validatedEntries.push({
+                    ...entry,
+                    valid: true,
+                    ...(options?.includeRuntimeEvidence
+                        ? {
+                            resolvedInRuntime: true,
+                            ...(runtimeAccess
+                                ? { resolvedRuntimeAccess: runtimeAccess }
+                                : {}),
+                            ...(runtimeMember.jvmDescriptor
+                                ? { resolvedRuntimeJvmDescriptor: runtimeMember.jvmDescriptor }
+                                : {}),
+                            ...(runtimeMember.javaSignature
+                                ? { resolvedRuntimeJavaSignature: runtimeMember.javaSignature }
+                                : {})
+                        }
+                        : {})
+                });
                 validCount++;
             }
             else {
@@ -781,7 +831,8 @@ export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
                     ...entry,
                     valid: false,
                     issue: `Method "${entry.name}" not found in class "${ownerFqn}".`,
-                    suggestions: suggestions.length > 0 ? suggestions : undefined
+                    suggestions: suggestions.length > 0 ? suggestions : undefined,
+                    ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
                 });
                 invalidCount++;
             }
@@ -789,9 +840,29 @@ export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
         else {
             // field
             const fieldNames = allFieldNames(members);
-            const found = members.fields.some((m) => m.name === entry.name && (!entry.descriptor || m.jvmDescriptor === entry.descriptor));
+            const matchedMember = members.fields.find((m) => m.name === entry.name && (!entry.descriptor || m.jvmDescriptor === entry.descriptor));
+            const found = matchedMember != null;
             if (found) {
-                validatedEntries.push({ ...entry, valid: true });
+                const runtimeMember = matchedMember;
+                const runtimeAccess = accessLevelFromFlags(runtimeMember.accessFlags);
+                validatedEntries.push({
+                    ...entry,
+                    valid: true,
+                    ...(options?.includeRuntimeEvidence
+                        ? {
+                            resolvedInRuntime: true,
+                            ...(runtimeAccess
+                                ? { resolvedRuntimeAccess: runtimeAccess }
+                                : {}),
+                            ...(runtimeMember.jvmDescriptor
+                                ? { resolvedRuntimeJvmDescriptor: runtimeMember.jvmDescriptor }
+                                : {}),
+                            ...(runtimeMember.javaSignature
+                                ? { resolvedRuntimeJavaSignature: runtimeMember.javaSignature }
+                                : {})
+                        }
+                        : {})
+                });
                 validCount++;
             }
             else {
@@ -800,7 +871,8 @@ export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
                     ...entry,
                     valid: false,
                     issue: `Field "${entry.name}" not found in class "${ownerFqn}".`,
-                    suggestions: suggestions.length > 0 ? suggestions : undefined
+                    suggestions: suggestions.length > 0 ? suggestions : undefined,
+                    ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
                 });
                 invalidCount++;
             }
@@ -819,4 +891,118 @@ export function validateParsedAccessWidener(parsed, membersByClass, warnings) {
         warnings
     };
 }
+export function validateParsedAccessTransformer(parsed, membersByClass, warnings, options) {
+    warnings.push(...parsed.parseWarnings);
+    const validatedEntries = [];
+    let validCount = 0;
+    let invalidCount = 0;
+    for (const entry of parsed.entries) {
+        const ownerFqn = entry.owner;
+        const members = membersByClass.get(ownerFqn);
+        if (entry.targetKind === "class") {
+            if (!members) {
+                validatedEntries.push({
+                    ...entry,
+                    valid: false,
+                    issue: `Class "${ownerFqn}" not found in runtime jar.`,
+                    ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
+                });
+                invalidCount++;
+                continue;
+            }
+            const runtimeAccess = accessLevelFromFlags(members.classAccessFlags);
+            validatedEntries.push({
+                ...entry,
+                valid: true,
+                ...(options?.includeRuntimeEvidence
+                    ? {
+                        resolvedInRuntime: true,
+                        ...(runtimeAccess ? { resolvedRuntimeAccess: runtimeAccess } : {})
+                    }
+                    : {})
+            });
+            validCount++;
+            continue;
+        }
+        if (!members) {
+            validatedEntries.push({
+                ...entry,
+                valid: false,
+                issue: `Owner class "${ownerFqn}" not found in runtime jar.`,
+                ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
+            });
+            invalidCount++;
+            continue;
+        }
+        if (entry.targetKind === "field") {
+            const fieldNames = allFieldNames(members);
+            const matchedField = members.fields.find((member) => member.name === entry.name);
+            if (!matchedField) {
+                const suggestions = entry.name ? suggestSimilar(entry.name, fieldNames) : [];
+                validatedEntries.push({
+                    ...entry,
+                    valid: false,
+                    issue: `Field "${entry.name}" not found in class "${ownerFqn}".`,
+                    ...(suggestions.length > 0 ? { suggestions } : {}),
+                    ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
+                });
+                invalidCount++;
+                continue;
+            }
+            const runtimeAccess = accessLevelFromFlags(matchedField.accessFlags);
+            validatedEntries.push({
+                ...entry,
+                valid: true,
+                ...(options?.includeRuntimeEvidence
+                    ? {
+                        resolvedInRuntime: true,
+                        ...(runtimeAccess ? { resolvedRuntimeAccess: runtimeAccess } : {}),
+                        ...(matchedField.jvmDescriptor ? { resolvedRuntimeJvmDescriptor: matchedField.jvmDescriptor } : {}),
+                        ...(matchedField.javaSignature ? { resolvedRuntimeJavaSignature: matchedField.javaSignature } : {})
+                    }
+                    : {})
+            });
+            validCount++;
+            continue;
+        }
+        const methodNames = allMethodNames(members);
+        const matchedMethod = members.methods.find((member) => member.name === entry.name && member.jvmDescriptor === entry.descriptor) ?? members.constructors.find((member) => member.name === entry.name && member.jvmDescriptor === entry.descriptor);
+        if (!matchedMethod) {
+            const suggestions = entry.name ? suggestSimilar(entry.name, methodNames) : [];
+            validatedEntries.push({
+                ...entry,
+                valid: false,
+                issue: `Method "${entry.name}" not found in class "${ownerFqn}".`,
+                ...(suggestions.length > 0 ? { suggestions } : {}),
+                ...(options?.includeRuntimeEvidence ? { resolvedInRuntime: false } : {})
+            });
+            invalidCount++;
+            continue;
+        }
+        const runtimeAccess = accessLevelFromFlags(matchedMethod.accessFlags);
+        validatedEntries.push({
+            ...entry,
+            valid: true,
+            ...(options?.includeRuntimeEvidence
+                ? {
+                    resolvedInRuntime: true,
+                    ...(runtimeAccess ? { resolvedRuntimeAccess: runtimeAccess } : {}),
+                    ...(matchedMethod.jvmDescriptor ? { resolvedRuntimeJvmDescriptor: matchedMethod.jvmDescriptor } : {}),
+                    ...(matchedMethod.javaSignature ? { resolvedRuntimeJavaSignature: matchedMethod.javaSignature } : {})
+                }
+                : {})
+        });
+        validCount++;
+    }
+    return {
+        valid: invalidCount === 0,
+        entries: validatedEntries,
+        summary: {
+            total: parsed.entries.length,
+            valid: validCount,
+            invalid: invalidCount
+        },
+        warnings
+    };
+}
 //# sourceMappingURL=mixin-validator.js.map

package/dist/mod-analyzer.d.ts

@@ -15,6 +15,7 @@ export interface ModAnalysisResult {
     entrypoints?: Record<string, string[]>;
     mixinConfigs?: string[];
     accessWidener?: string;
+    accessTransformers?: string[];
     dependencies?: ModDependency[];
     classCount: number;
     classes?: string[];

package/dist/mod-analyzer.js

@@ -72,7 +72,8 @@ const forgeModsTomlSchema = z
         .passthrough())
         .optional(),
     dependencies: z.record(z.array(z.unknown())).optional(),
-    mixins: z.array(z.object({ config: z.string() }).passthrough()).optional()
+    mixins: z.array(z.object({ config: z.string() }).passthrough()).optional(),
+    accessTransformers: z.array(z.object({ file: z.string().optional() }).passthrough()).optional()
 })
     .passthrough();
 const legacyForgeSchema = z.array(z
@@ -214,6 +215,9 @@ function parseForgeMod(content, entries) {
     }
     // Mixin configs
     const mixinConfigs = toml.mixins?.map((m) => m.config);
+    const accessTransformers = toml.accessTransformers
+        ?.map((entry) => entry.file)
+        .filter((file) => typeof file === "string" && file.trim().length > 0);
     return {
         detectedLoader,
         modId: firstMod?.modId,
@@ -221,6 +225,7 @@ function parseForgeMod(content, entries) {
         modVersion: firstMod?.version,
         description: firstMod?.description,
         mixinConfigs: mixinConfigs && mixinConfigs.length > 0 ? mixinConfigs : undefined,
+        accessTransformers: accessTransformers && accessTransformers.length > 0 ? accessTransformers : undefined,
         dependencies: dependencies.length > 0 ? dependencies : undefined
     };
 }
@@ -288,6 +293,9 @@ export async function analyzeModJar(jarPath, options) {
     // Detect loader and parse metadata
     let loader = "unknown";
     let metadata = {};
+    const packagedAccessTransformers = [...new Set(entries.filter((entry) => /(^|\/)META-INF\/accesstransformer\.cfg$/i.test(entry) ||
+            /(^|\/)[^/]+_at\.cfg$/i.test(entry) ||
+            /(^|\/)accesstransformer[^/]*\.cfg$/i.test(entry)))].sort((left, right) => left.localeCompare(right));
     if (entries.includes("fabric.mod.json")) {
         loader = "fabric";
         try {
@@ -346,6 +354,14 @@ export async function analyzeModJar(jarPath, options) {
         loader,
         jarKind,
         ...metadata,
+        ...(packagedAccessTransformers.length > 0 || metadata.accessTransformers
+            ? {
+                accessTransformers: [...new Set([
+                        ...(metadata.accessTransformers ?? []),
+                        ...packagedAccessTransformers
+                    ])]
+            }
+            : {}),
         classCount,
         ...(classes !== undefined ? { classes } : {})
     };

package/dist/mod-decompile-service.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve as resolvePath } from "node:path";
 import { createError, ERROR_CODES } from "./errors.js";
 import { log } from "./logger.js";
@@ -41,7 +41,7 @@ export class ModDecompileService {
             const targetFile = classNameToFilePath(input.className);
             const matched = files.find((f) => f === targetFile || f.endsWith(`/${targetFile}`) || f === input.className);
             if (matched) {
-                const content = readFileSync(join(outputDir, matched), "utf8");
+                const content = await readFile(join(outputDir, matched), "utf8");
                 sourceResult = {
                     className: filePathToClassName(matched),
                     content,
@@ -106,7 +106,7 @@ export class ModDecompileService {
                 details: { className, jarPath, availableCount: files.length }
             });
         }
-        const fullContent = readFileSync(join(outputDir, matched), "utf8");
+        const fullContent = await readFile(join(outputDir, matched), "utf8");
         const totalLines = fullContent.split("\n").length;
         let content = fullContent;
         let truncated;
@@ -131,7 +131,7 @@ export class ModDecompileService {
             const outPath = isAbsolute(input.outputFile)
                 ? input.outputFile
                 : resolvePath(input.outputFile);
-            writeFileSync(outPath, content, "utf8");
+            await writeFile(outPath, content, "utf8");
             outputFilePath = outPath;
             content = `[Written to ${outPath}]`;
         }

package/dist/mod-remap-service.js

@@ -8,7 +8,7 @@ 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 { detectFabricLikeInputNamespace } from "./source-jar-reader.js";
 import { remapJar } from "./tiny-remapper-service.js";
 import { resolveTinyRemapperJar } from "./tiny-remapper-resolver.js";
 function normalizeTargetNamespace(target) {
@@ -36,59 +36,6 @@ 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);

package/dist/mod-search-service.d.ts

@@ -26,4 +26,5 @@ export declare class ModSearchService {
     constructor(modDecompileService: ModDecompileService);
     searchModSource(input: SearchModSourceInput): Promise<SearchModSourceOutput>;
     private searchSourceJarEntriesDirect;
+    private searchDecompiledClassFile;
 }