@adhisang/minecraft-modding-mcp 3.1.0 → 3.2.0

package/dist/mapping-service.js

@@ -3,8 +3,9 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import fastGlob from "fast-glob";
 import { createError, ERROR_CODES } from "./errors.js";
+import { buildVersionSourceSearchRoots, normalizeOptionalProjectPath } from "./gradle-paths.js";
 import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
-import { listJarEntries, readJarEntryAsUtf8 } from "./source-jar-reader.js";
+import { collectMatchedJarEntriesAsUtf8 } from "./source-jar-reader.js";
 import { VersionService, isUnobfuscatedVersion } from "./version-service.js";
 const SUPPORTED_MAPPINGS = new Set([
     "obfuscated",
@@ -19,6 +20,7 @@ const MATCH_RANK = {
 };
 const DESCRIPTOR_FALLBACK_CONFIDENCE = 0.85;
 const MAX_CANDIDATES = 200;
+const GLOB_SPECIAL_CHARS = /[\\!*+?()[\]{}@|]/g;
 function createDirectionIndex() {
     return {
         exact: new Map(),
@@ -420,7 +422,7 @@ function parseClientMappings(text) {
 }
 function normalizeTinyNamespace(namespace) {
     const normalized = namespace.trim().toLowerCase();
-    if (normalized === "obfuscated") {
+    if (normalized === "obfuscated" || normalized === "official") {
         return "obfuscated";
     }
     if (normalized === "mojang") {
@@ -590,6 +592,12 @@ function mappingSourceOrder(priority) {
     }
     return ["loom-cache", "maven"];
 }
+function requiresOnlyObfuscatedMojangGraph(sourceMapping, targetMapping) {
+    return sourceMapping !== "intermediary" &&
+        sourceMapping !== "yarn" &&
+        targetMapping !== "intermediary" &&
+        targetMapping !== "yarn";
+}
 function namespacePath(graph, sourceMapping, targetMapping) {
     if (sourceMapping === targetMapping) {
         return [sourceMapping];
@@ -709,7 +717,7 @@ function normalizeMethodDescriptor(descriptor) {
     }
     return normalized;
 }
-function normalizeQuerySymbol(input, signatureMode) {
+function normalizeQuerySymbol(input, signatureMode, options) {
     if (input.kind !== "class" && input.kind !== "field" && input.kind !== "method") {
         throw invalidInputError('kind must be one of "class", "field", or "method".', {
             kind: input.kind
@@ -735,7 +743,7 @@ function normalizeQuerySymbol(input, signatureMode) {
             });
         }
         const className = normalizeMappedSymbolOutput(normalizedName);
-        if (!className.includes(".")) {
+        if (!className.includes(".") && !options?.allowShortClassName) {
             throw invalidInputError("name must be a fully qualified class name when kind=class.", {
                 name: input.name
             });
@@ -805,13 +813,32 @@ function applyDisambiguationHints(candidates, disambiguation) {
     }
     const descriptorHint = normalizeDescriptorHint(disambiguation.descriptorHint);
     if (descriptorHint) {
-        const descriptorMatched = filtered.filter((candidate) => candidate.descriptor === descriptorHint);
+        const descriptorMatched = filtered.filter((candidate) => candidate.descriptor != null && candidate.descriptor === descriptorHint);
         if (descriptorMatched.length > 0) {
             filtered = descriptorMatched;
         }
     }
     return filtered;
 }
+function projectLookupCandidateDescriptor(candidate, sourceDescriptor, targetDescriptor) {
+    // Tiny mappings preserve method descriptors verbatim, so single-hop tiny paths often
+    // return the source descriptor even though the final symbol is already in the target
+    // namespace. Multi-hop paths that already produced a target-side descriptor are left
+    // unchanged by design.
+    if (candidate.kind !== "method" ||
+        !candidate.descriptor ||
+        !targetDescriptor ||
+        candidate.descriptor !== sourceDescriptor) {
+        return candidate;
+    }
+    return {
+        ...candidate,
+        descriptor: targetDescriptor
+    };
+}
+function effectiveLoomSearchProjectPath(projectPath) {
+    return normalizeOptionalProjectPath(projectPath) ?? normalizeOptionalProjectPath(process.cwd());
+}
 function collectTargetRecords(graph, targetMapping) {
     return [...(graph.recordsByTarget.get(targetMapping) ?? [])];
 }
@@ -905,7 +932,9 @@ export class MappingService {
                 }
             });
         }
-        const { record: queryRecord, querySymbol } = normalizeQuerySymbol(input, input.signatureMode);
+        const { record: queryRecord, querySymbol } = normalizeQuerySymbol(input, input.signatureMode, {
+            allowShortClassName: input.kind === "class" && input.sourceMapping === "obfuscated"
+        });
         const sourceMapping = input.sourceMapping;
         const targetMapping = input.targetMapping;
         if (!SUPPORTED_MAPPINGS.has(sourceMapping) || !SUPPORTED_MAPPINGS.has(targetMapping)) {
@@ -945,7 +974,7 @@ export class MappingService {
                 warnings: []
             };
         }
-        const graph = await this.loadGraph(version, priority);
+        const graph = await this.loadGraph(version, priority, requiresOnlyObfuscatedMojangGraph(sourceMapping, targetMapping) ? "obfuscated-mojang-only" : "full", input.projectPath);
         const path = namespacePath(graph, sourceMapping, targetMapping);
         if (!path) {
             return {
@@ -960,7 +989,15 @@ export class MappingService {
                 ]
             };
         }
-        const rawCandidates = this.mapCandidatesAlongPath(graph, path, queryRecord);
+        const descriptorProjection = queryRecord.kind === "method" && queryRecord.descriptor
+            ? this.projectMethodDescriptorToTarget(graph, path, queryRecord.descriptor)
+            : undefined;
+        const projectedDescriptor = descriptorProjection?.complete ? descriptorProjection.descriptor : undefined;
+        const rawCandidates = this
+            .mapCandidatesAlongPath(graph, path, queryRecord)
+            .map((candidate) => queryRecord.kind === "method" && queryRecord.descriptor
+            ? projectLookupCandidateDescriptor(candidate, queryRecord.descriptor, projectedDescriptor)
+            : candidate);
         const warnings = [];
         const disambiguatedCandidates = applyDisambiguationHints(rawCandidates, input.disambiguation);
         if (rawCandidates.length > disambiguatedCandidates.length) {
@@ -1029,7 +1066,7 @@ export class MappingService {
                 warnings: []
             };
         }
-        const graph = await this.loadGraph(version, priority);
+        const graph = await this.loadGraph(version, priority, requiresOnlyObfuscatedMojangGraph(sourceMapping, targetMapping) ? "obfuscated-mojang-only" : "full", input.projectPath);
         const path = namespacePath(graph, sourceMapping, targetMapping);
         if (!path) {
             throw createError({
@@ -1113,7 +1150,7 @@ export class MappingService {
                 warnings: []
             };
         }
-        const graph = await this.loadGraph(version, priority);
+        const graph = await this.loadGraph(version, priority, requiresOnlyObfuscatedMojangGraph(sourceMapping, targetMapping) ? "obfuscated-mojang-only" : "full", input.projectPath);
         const path = namespacePath(graph, sourceMapping, targetMapping);
         if (!path) {
             return {
@@ -1129,12 +1166,16 @@ export class MappingService {
             };
         }
         const warnings = [];
+        const descriptorProjection = this.projectMethodDescriptorToTarget(graph, path, descriptor);
+        const projectedDescriptor = descriptorProjection.complete ? descriptorProjection.descriptor : undefined;
         const rawCandidates = this
             .mapCandidatesAlongPath(graph, path, queryRecord)
-            .filter((candidate) => candidate.kind === "method");
+            .filter((candidate) => candidate.kind === "method")
+            .map((candidate) => projectLookupCandidateDescriptor(candidate, descriptor, projectedDescriptor));
         const candidates = rawCandidates.map(toResolutionCandidate);
         const limitedCandidates = limitResolutionCandidates(candidates, input.maxCandidates);
-        const strictCandidates = rawCandidates.filter((candidate) => candidate.descriptor === descriptor);
+        const strictDescriptor = projectedDescriptor ?? descriptor;
+        const strictCandidates = rawCandidates.filter((candidate) => candidate.descriptor === strictDescriptor);
         if (strictCandidates.length === 1) {
             const resolved = toResolutionCandidate(strictCandidates[0]);
             return {
@@ -1164,8 +1205,10 @@ export class MappingService {
                 provenance: this.provenanceForPath(graph, path)
             };
         }
-        if (pathUsesSource(graph.pairs, path, "mojang-client-mappings")) {
-            warnings.push("Method descriptor could not be preserved through mojang-client-mappings and exact resolution is unavailable.");
+        if (descriptorProjection.hadClassReferences && !descriptorProjection.complete) {
+            warnings.push(pathUsesSource(graph.pairs, path, "mojang-client-mappings")
+                ? "Method descriptor could not be preserved through mojang-client-mappings and exact resolution is unavailable."
+                : "Method descriptor could not be fully remapped across the mapping path and exact resolution is unavailable.");
             return {
                 querySymbol,
                 mappingContext,
@@ -1214,7 +1257,7 @@ export class MappingService {
             });
         }
         const priority = mappingPriorityFromInput(this.config.mappingSourcePriority, input.sourcePriority);
-        const graph = await this.loadGraph(version, priority);
+        const graph = await this.loadGraph(version, priority, "full");
         const warnings = [...graph.warnings];
         const includeKinds = normalizeIncludedKinds(input.includeKinds);
         const pathCache = new Map();
@@ -1246,7 +1289,7 @@ export class MappingService {
                 classByMapping[mapping] = mapped[0];
             }
         }
-        const baseMapping = classByMapping.obfuscated ? "obfuscated" : classNameMapping;
+        const baseMapping = classNameMapping;
         const baseClass = classByMapping[baseMapping];
         if (!baseClass) {
             return {
@@ -1435,7 +1478,7 @@ export class MappingService {
                     querySymbol
                 };
             })();
-        const graph = await this.loadGraph(version, priority);
+        const graph = await this.loadGraph(version, priority, sourceMapping === "mojang" ? "obfuscated-mojang-only" : "full");
         const warnings = [...graph.warnings];
         const records = collectTargetRecords(graph, sourceMapping);
         if (records.length === 0) {
@@ -1616,6 +1659,33 @@ export class MappingService {
             descriptor: item.record.descriptor
         }));
     }
+    projectMethodDescriptorToTarget(graph, path, descriptor) {
+        let hadClassReferences = false;
+        let complete = true;
+        const classProjectionCache = new Map();
+        const projectedDescriptor = descriptor.replace(/L([^;]+);/g, (fullMatch, internalName) => {
+            hadClassReferences = true;
+            const cached = classProjectionCache.get(internalName);
+            if (cached) {
+                return `L${cached};`;
+            }
+            const projectedClassCandidates = this
+                .mapCandidatesAlongPath(graph, path, createClassSymbolRecord(internalName.replace(/\//g, ".")))
+                .filter((candidate) => candidate.kind === "class");
+            if (projectedClassCandidates.length !== 1) {
+                complete = false;
+                return fullMatch;
+            }
+            const projectedInternalName = projectedClassCandidates[0].symbol.replace(/\./g, "/");
+            classProjectionCache.set(internalName, projectedInternalName);
+            return `L${projectedInternalName};`;
+        });
+        return {
+            descriptor: projectedDescriptor,
+            hadClassReferences,
+            complete
+        };
+    }
     provenanceForPath(graph, path) {
         if (path.length <= 1) {
             return undefined;
@@ -1638,9 +1708,21 @@ export class MappingService {
     async checkMappingHealth(input) {
         const priority = mappingPriorityFromInput(this.config.mappingSourcePriority, input.sourcePriority);
         const degradations = [];
+        if (isUnobfuscatedVersion(input.version)) {
+            const requestFulfillable = input.requestedMapping === "obfuscated" || input.requestedMapping === "mojang";
+            if (!requestFulfillable) {
+                degradations.push(`Version ${input.version} is unobfuscated; ${input.requestedMapping} mappings are not applicable.`);
+            }
+            return {
+                mojangMappingsAvailable: true,
+                tinyMappingsAvailable: false,
+                memberRemapAvailable: requestFulfillable,
+                degradations
+            };
+        }
         let graph;
         try {
-            graph = await this.loadGraph(input.version, priority);
+            graph = await this.loadGraph(input.version, priority, "full");
         }
         catch {
             return {
@@ -1684,8 +1766,9 @@ export class MappingService {
             degradations
         };
     }
-    async loadGraph(version, priority) {
-        const cacheKey = `${version}|${priority}`;
+    async loadGraph(version, priority, mode, projectPath) {
+        const effectiveProjectPath = effectiveLoomSearchProjectPath(projectPath);
+        const cacheKey = `${version}|${priority}|${mode}|${effectiveProjectPath ?? ""}`;
         const cached = this.graphCache.get(cacheKey);
         if (cached) {
             this.graphCache.delete(cacheKey);
@@ -1696,7 +1779,7 @@ export class MappingService {
         if (existingLock) {
             return existingLock;
         }
-        const buildPromise = this.buildGraph(version, priority);
+        const buildPromise = this.buildGraph(version, priority, mode, effectiveProjectPath);
         this.buildLocks.set(cacheKey, buildPromise);
         try {
             const built = await buildPromise;
@@ -1708,11 +1791,12 @@ export class MappingService {
             this.buildLocks.delete(cacheKey);
         }
     }
-    async buildGraph(version, priority) {
+    async buildGraph(version, priority, mode, projectPath) {
         if (isUnobfuscatedVersion(version)) {
             return {
                 version,
                 priority,
+                mode,
                 pairs: new Map(),
                 adjacency: new Map(),
                 pathCache: new Map(),
@@ -1725,6 +1809,7 @@ export class MappingService {
         const graph = {
             version,
             priority,
+            mode,
             pairs: new Map(),
             adjacency: new Map(),
             pathCache: new Map(),
@@ -1734,27 +1819,29 @@ export class MappingService {
         const mojangLoad = await this.loadMojangPairs(version);
         graph.warnings.push(...mojangLoad.warnings);
         this.mergePairs(graph.pairs, mojangLoad.pairs, "mojang-client-mappings", mojangLoad.mappingArtifact);
-        let tinyLoaded = false;
-        const deferredTinyWarnings = [];
-        for (const source of mappingSourceOrder(priority)) {
-            const tinyLoad = source === "loom-cache"
-                ? await this.loadTinyPairsFromLoom(version)
-                : await this.loadTinyPairsFromMaven(version);
-            if (tinyLoad.pairs.size === 0) {
-                deferredTinyWarnings.push(...tinyLoad.warnings);
-                continue;
+        if (mode === "full") {
+            let tinyLoaded = false;
+            const deferredTinyWarnings = [];
+            for (const source of mappingSourceOrder(priority)) {
+                const tinyLoad = source === "loom-cache"
+                    ? await this.loadTinyPairsFromLoom(version, projectPath)
+                    : await this.loadTinyPairsFromMaven(version);
+                if (tinyLoad.pairs.size === 0) {
+                    deferredTinyWarnings.push(...tinyLoad.warnings);
+                    continue;
+                }
+                tinyLoaded = true;
+                this.mergePairs(graph.pairs, tinyLoad.pairs, source, tinyLoad.mappingArtifact);
+                graph.warnings.push(...tinyLoad.warnings);
+                if (deferredTinyWarnings.length > 0) {
+                    graph.warnings.push(`Used ${source === "maven" ? "Maven" : "Loom cache"} tiny mappings for "${version}" after an earlier source lookup returned no data.`);
+                }
+                break;
             }
-            tinyLoaded = true;
-            this.mergePairs(graph.pairs, tinyLoad.pairs, source, tinyLoad.mappingArtifact);
-            graph.warnings.push(...tinyLoad.warnings);
-            if (deferredTinyWarnings.length > 0) {
-                graph.warnings.push(`Used ${source === "maven" ? "Maven" : "Loom cache"} tiny mappings for "${version}" after an earlier source lookup returned no data.`);
+            if (!tinyLoaded) {
+                graph.warnings.push(...deferredTinyWarnings);
+                graph.warnings.push("No intermediary/yarn tiny mappings were found for this version.");
             }
-            break;
-        }
-        if (!tinyLoaded) {
-            graph.warnings.push(...deferredTinyWarnings);
-            graph.warnings.push("No intermediary/yarn tiny mappings were found for this version.");
         }
         graph.adjacency = buildAdjacency(graph.pairs);
         graph.recordsByTarget = buildTargetRecordIndex(graph.pairs);
@@ -1835,46 +1922,67 @@ export class MappingService {
             };
         }
     }
-    async loadTinyPairsFromLoom(version) {
-        const patterns = [".gradle/loom-cache/**/*.tiny", ".gradle/loom-cache/**/*.tinyv2"];
-        const candidates = fastGlob.sync(patterns, {
-            cwd: process.cwd(),
-            absolute: true,
-            onlyFiles: true
-        });
-        const byVersion = candidates
-            .filter((p) => p.replaceAll("\\", "/").includes(`/${version}/`))
-            .sort((left, right) => left.localeCompare(right));
-        if (byVersion.length === 0) {
-            return {
-                pairs: new Map(),
-                warnings: [`No Loom tiny mapping files matched version "${version}".`],
-                mappingArtifact: "loom-cache:none"
-            };
-        }
+    async loadTinyPairsFromLoom(version, projectPath) {
+        const searchRoots = buildVersionSourceSearchRoots(effectiveLoomSearchProjectPath(projectPath));
         const merged = new Map();
-        for (const path of byVersion) {
+        const discoveredPaths = new Set();
+        for (const root of searchRoots) {
+            let discovered = [];
+            const versionRoot = join(root, version);
             try {
-                const content = await readFile(path, "utf8");
-                const parsed = parseTinyMappings(content);
-                for (const [key, index] of parsed.entries()) {
-                    const existing = merged.get(key);
-                    if (!existing) {
-                        merged.set(key, index);
-                    }
-                    else {
-                        mergeDirectionIndexes(existing, index);
-                    }
-                }
+                discovered = existsSync(versionRoot)
+                    ? await fastGlob.glob(["**/*.tiny", "**/*.tinyv2"], {
+                        cwd: versionRoot,
+                        absolute: true,
+                        onlyFiles: true
+                    })
+                    : await fastGlob.glob([`${version.replace(GLOB_SPECIAL_CHARS, "\\$&")}/**/*.tiny`, `${version.replace(GLOB_SPECIAL_CHARS, "\\$&")}/**/*.tinyv2`], {
+                        cwd: root,
+                        absolute: true,
+                        onlyFiles: true
+                    });
             }
             catch {
-                // best effort: skip unreadable or invalid files
+                continue;
+            }
+            const byVersion = discovered
+                .filter((path) => path.replaceAll("\\", "/").includes(`/${version}/`))
+                .sort((left, right) => left.localeCompare(right));
+            if (byVersion.length === 0) {
+                continue;
+            }
+            for (const path of byVersion) {
+                discoveredPaths.add(path);
+                try {
+                    const content = await readFile(path, "utf8");
+                    const parsed = parseTinyMappings(content);
+                    for (const [key, index] of parsed.entries()) {
+                        const existing = merged.get(key);
+                        if (!existing) {
+                            merged.set(key, index);
+                        }
+                        else {
+                            mergeDirectionIndexes(existing, index);
+                        }
+                    }
+                }
+                catch {
+                    // best effort: skip unreadable or invalid files
+                }
             }
         }
+        const orderedPaths = [...discoveredPaths].sort((left, right) => left.localeCompare(right));
+        if (orderedPaths.length > 0) {
+            return {
+                pairs: merged,
+                warnings: [],
+                mappingArtifact: orderedPaths[0]
+            };
+        }
         return {
-            pairs: merged,
-            warnings: [],
-            mappingArtifact: byVersion[0]
+            pairs: new Map(),
+            warnings: [`No Loom tiny mapping files matched version "${version}".`],
+            mappingArtifact: "loom-cache:none"
         };
     }
     async loadTinyPairsFromMaven(version) {
@@ -1930,15 +2038,11 @@ export class MappingService {
         };
     }
     async parseTinyFromJar(jarPath) {
-        const entries = await listJarEntries(jarPath);
-        const tinyEntries = entries
-            .filter((entry) => entry.toLowerCase().endsWith(".tiny") || entry.toLowerCase().endsWith(".tinyv2"))
-            .sort((left, right) => left.localeCompare(right));
+        const tinyEntries = (await collectMatchedJarEntriesAsUtf8(jarPath, (entry) => entry.toLowerCase().endsWith(".tiny") || entry.toLowerCase().endsWith(".tinyv2"), { continueOnError: true })).sort((left, right) => left.filePath.localeCompare(right.filePath));
         const merged = new Map();
         for (const entry of tinyEntries) {
             try {
-                const text = await readJarEntryAsUtf8(jarPath, entry);
-                const parsed = parseTinyMappings(text);
+                const parsed = parseTinyMappings(entry.content);
                 for (const [key, index] of parsed.entries()) {
                     const existing = merged.get(key);
                     if (!existing) {
@@ -1990,6 +2094,19 @@ export class MappingService {
             this.graphCache.delete(oldestKey);
         }
     }
+    releaseGraphCacheEntry(version, sourcePriority) {
+        const normalizedVersion = version.trim();
+        if (!normalizedVersion) {
+            return;
+        }
+        const priority = mappingPriorityFromInput(this.config.mappingSourcePriority, sourcePriority);
+        const prefix = `${normalizedVersion}|${priority}|`;
+        for (const key of this.graphCache.keys()) {
+            if (key.startsWith(prefix)) {
+                this.graphCache.delete(key);
+            }
+        }
+    }
 }
 // ---------------------------------------------------------------------------
 // Standalone: Tiny v2 mapping file resolution for remapping
@@ -2018,14 +2135,13 @@ async function fetchYarnCoordinatesStandalone(version, fetchFn = globalThis.fetc
     }
 }
 async function extractTinyFromJar(jarPath, outputPath) {
-    const entries = await listJarEntries(jarPath);
-    const tinyEntry = entries.find((entry) => entry === "mappings/mappings.tiny" || entry.toLowerCase().endsWith(".tiny"));
+    const matchedEntries = await collectMatchedJarEntriesAsUtf8(jarPath, (entry) => entry === "mappings/mappings.tiny" || entry.toLowerCase().endsWith(".tiny"), { maxEntries: 1 });
+    const tinyEntry = matchedEntries[0];
     if (!tinyEntry) {
         return false;
     }
-    const content = await readJarEntryAsUtf8(jarPath, tinyEntry);
     await mkdir(dirname(outputPath), { recursive: true });
-    await writeFile(outputPath, content, "utf8");
+    await writeFile(outputPath, tinyEntry.content, "utf8");
     return true;
 }
 /**

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;