@adhisang/minecraft-modding-mcp 7.0.0 → 7.1.1

package/dist/source/lifecycle/runtime-check.js

@@ -1,5 +1,18 @@
 import { ERROR_CODES, isAppError } from "../../errors.js";
+/**
+ * check-symbol-exists's runtime fallback: the result of `runUnobfuscatedRuntimeCheck`
+ * alone. Its callers keep the fallback base's status whenever the check could not be
+ * performed, so they need no `verified` flag.
+ */
 export async function checkSymbolExistsInUnobfuscatedRuntime(svc, input, fallbackBase) {
+    return (await runUnobfuscatedRuntimeCheck(svc, input, fallbackBase))?.result;
+}
+/**
+ * Checks a symbol against the Minecraft runtime jar of an unobfuscated version, whose
+ * names are the Mojang names. Undefined when the version or name is empty or the
+ * runtime jar cannot be resolved.
+ */
+export async function runUnobfuscatedRuntimeCheck(svc, input, fallbackBase) {
     const version = input.version.trim();
     const name = input.name.trim();
     const owner = input.owner?.trim();
@@ -8,11 +21,14 @@ export async function checkSymbolExistsInUnobfuscatedRuntime(svc, input, fallbac
     }
     if (input.kind === "class" && input.nameMode !== "fqcn" && !name.includes(".")) {
         return {
-            ...fallbackBase,
-            warnings: [
-                ...fallbackBase.warnings,
-                `Version ${version} is unobfuscated, but short class name "${name}" could not be checked against runtime bytecode without a fully-qualified name.`
-            ]
+            verified: false,
+            result: {
+                ...fallbackBase,
+                warnings: [
+                    ...fallbackBase.warnings,
+                    `Version ${version} is unobfuscated, but short class name "${name}" could not be checked against runtime bytecode without a fully-qualified name.`
+                ]
+            }
         };
     }
     const querySymbol = input.kind === "class"
@@ -37,7 +53,7 @@ export async function checkSymbolExistsInUnobfuscatedRuntime(svc, input, fallbac
             };
     const targetClass = input.kind === "class" ? name : owner;
     if (!targetClass) {
-        return fallbackBase;
+        return { verified: false, result: fallbackBase };
     }
     let jarPath;
     try {
@@ -61,16 +77,20 @@ export async function checkSymbolExistsInUnobfuscatedRuntime(svc, input, fallbac
         });
     }
     catch (error) {
+        // Only CLASS_NOT_FOUND is an answer; any other failure means the lookup never completed.
         const classMissing = isAppError(error) && error.code === ERROR_CODES.CLASS_NOT_FOUND;
         return {
-            ...fallbackBase,
-            querySymbol,
-            warnings: [
-                ...fallbackBase.warnings,
-                classMissing
-                    ? `Class "${targetClass}" was not found in the Minecraft ${version} runtime jar; it does not exist (or is not in this jar).`
-                    : `Version ${version} is unobfuscated; runtime bytecode lookup could not load class "${targetClass}".`
-            ]
+            verified: classMissing,
+            result: {
+                ...fallbackBase,
+                querySymbol,
+                warnings: [
+                    ...fallbackBase.warnings,
+                    classMissing
+                        ? `Class "${targetClass}" was not found in the Minecraft ${version} runtime jar; it does not exist (or is not in this jar).`
+                        : `Version ${version} is unobfuscated; runtime bytecode lookup could not load class "${targetClass}".`
+                ]
+            }
         };
     }
     const warnings = [...fallbackBase.warnings, ...signature.warnings];
@@ -80,33 +100,40 @@ export async function checkSymbolExistsInUnobfuscatedRuntime(svc, input, fallbac
         ...fallbackBase.mappingContext,
         runtimeValidated: true
     };
+    // From here on the class loaded, so every answer below is a completed lookup.
     const buildResolved = (resolvedSymbol) => ({
-        ...fallbackBase,
-        mappingContext: runtimeValidatedContext,
-        querySymbol,
-        resolved: true,
-        status: "resolved",
-        resolvedSymbol,
-        candidates: resolvedSymbol
-            ? [{
-                    ...resolvedSymbol,
-                    matchKind: "exact",
-                    confidence: 1
-                }]
-            : [],
-        candidateCount: resolvedSymbol ? 1 : 0,
-        warnings
+        verified: true,
+        result: {
+            ...fallbackBase,
+            mappingContext: runtimeValidatedContext,
+            querySymbol,
+            resolved: true,
+            status: "resolved",
+            resolvedSymbol,
+            candidates: resolvedSymbol
+                ? [{
+                        ...resolvedSymbol,
+                        matchKind: "exact",
+                        confidence: 1
+                    }]
+                : [],
+            candidateCount: resolvedSymbol ? 1 : 0,
+            warnings
+        }
     });
     const buildUnresolved = (status) => ({
-        ...fallbackBase,
-        mappingContext: runtimeValidatedContext,
-        querySymbol,
-        resolved: false,
-        status,
-        resolvedSymbol: undefined,
-        candidates: [],
-        candidateCount: 0,
-        warnings
+        verified: true,
+        result: {
+            ...fallbackBase,
+            mappingContext: runtimeValidatedContext,
+            querySymbol,
+            resolved: false,
+            status,
+            resolvedSymbol: undefined,
+            candidates: [],
+            candidateCount: 0,
+            warnings
+        }
     });
     if (input.kind === "class") {
         return buildResolved({
@@ -127,7 +154,9 @@ export async function checkSymbolExistsInUnobfuscatedRuntime(svc, input, fallbac
             symbol: `${owner}.${name}`
         });
     }
-    const methodCandidates = signature.methods.filter((method) => method.name === name);
+    // The bytecode reader lists constructors apart from methods (and only the owner's
+    // own: constructors are not inherited), so "<init>" is answered from them.
+    const methodCandidates = (name === "<init>" ? signature.constructors : signature.methods).filter((method) => method.name === name);
     const signatureMode = input.signatureMode ?? "name-only";
     if (signatureMode === "name-only") {
         // Existence semantics: any overload with this name means the method exists. Multiple

package/dist/source/nested-jars.d.ts

@@ -1,3 +1,4 @@
+import { rename } from "node:fs/promises";
 /**
  * A jar with at most this many own `.class` entries can qualify as a
  * Jar-in-Jar shell. Real Fabric API umbrella jars carry zero to a handful of
@@ -23,6 +24,10 @@ export interface NestedClassMatch {
     filePath: string;
     line: number;
     symbolKind: "class";
+    /** Set when the match is a type declared INSIDE another type. */
+    nested?: boolean;
+    /** The enclosing top-level type, present only on a nested match. */
+    enclosingClass?: string;
 }
 /**
  * Finds exact class-name matches across a shell's nested bytecode inventory.
@@ -50,6 +55,15 @@ export declare function detectShellJarInventory(jarPath: string): Promise<string
  * shell always maps to the same extracted file and re-resolution reuses it.
  */
 export declare function nestedJarCachePath(cacheDir: string, outerJarPath: string, outerSignature: string, entryName: string): string;
+/**
+ * Seam for injecting the temp->final rename primitive so tests can simulate a
+ * non-race rename failure (e.g. EBUSY/EPERM/ENOSPC), which cannot be provoked
+ * for real against a plain filesystem under the allowed test commands.
+ * Defaults to the module-level `rename` from node:fs/promises.
+ */
+export interface ExtractNestedJarDeps {
+    rename?: typeof rename;
+}
 /**
  * Extracts one nested jar to the content-addressed cache (no-op when already
  * present). Entry-name safety is enforced by readJarEntryAsBuffer, and the
@@ -62,7 +76,7 @@ export declare function nestedJarCachePath(cacheDir: string, outerJarPath: strin
  * one extraction with ERR_LIMIT_EXCEEDED — `loadNestedJarClassSet` swallows it
  * and keeps resolving the shell's other nested jars.
  */
-export declare function extractNestedJar(cacheDir: string, outerJarPath: string, outerSignature: string, entryName: string, maxEntryBytes?: number): Promise<string>;
+export declare function extractNestedJar(cacheDir: string, outerJarPath: string, outerSignature: string, entryName: string, maxEntryBytes?: number, deps?: ExtractNestedJarDeps): Promise<string>;
 /**
  * Finds every nested jar of a shell that contains the class. Zero matches
  * means the class genuinely is not bundled; more than one means the caller

package/dist/source/nested-jars.js

@@ -98,11 +98,17 @@ function nestedClassMatch(entry) {
     if (innerSegments.some((segment) => segment.length === 0 || /^\d/.test(segment))) {
         return undefined;
     }
+    // Mirror the indexed find-class branch's shape (class-source.ts): a `$`
+    // inner-class match reports `nested`/`enclosingClass` against its top-level
+    // enclosing type, exactly like an indexed lookup would.
+    const outerBinaryName = internalName.split("$")[0];
+    const isNested = innerSegments.length > 0;
     return {
         qualifiedName: internalName.replaceAll("/", ".").replaceAll("$", "."),
-        filePath: `${internalName.split("$")[0]}.java`,
+        filePath: `${outerBinaryName}.java`,
         line: 1,
-        symbolKind: "class"
+        symbolKind: "class",
+        ...(isNested ? { nested: true, enclosingClass: outerBinaryName.replaceAll("/", ".") } : {})
     };
 }
 /**
@@ -206,7 +212,8 @@ export function nestedJarCachePath(cacheDir, outerJarPath, outerSignature, entry
  * one extraction with ERR_LIMIT_EXCEEDED — `loadNestedJarClassSet` swallows it
  * and keeps resolving the shell's other nested jars.
  */
-export async function extractNestedJar(cacheDir, outerJarPath, outerSignature, entryName, maxEntryBytes) {
+export async function extractNestedJar(cacheDir, outerJarPath, outerSignature, entryName, maxEntryBytes, deps = {}) {
+    const renameFn = deps.rename ?? rename;
     const finalPath = nestedJarCachePath(cacheDir, outerJarPath, outerSignature, entryName);
     try {
         await access(finalPath);
@@ -243,16 +250,18 @@ export async function extractNestedJar(cacheDir, outerJarPath, outerSignature, e
     const tempPath = `${finalPath}.tmp.${process.pid}.${Date.now()}.${randomBytes(6).toString("hex")}`;
     await writeFile(tempPath, bytes);
     try {
-        await rename(tempPath, finalPath);
+        await renameFn(tempPath, finalPath);
     }
     catch (renameError) {
         // A concurrent extraction of the same entry may have won the rename.
         // The content-addressed final file being present makes this call a
-        // success; anything else is a real failure.
+        // success; anything else is a real failure. Either way, best-effort
+        // remove the orphaned temp file before returning/rethrowing.
         try {
             await access(finalPath);
         }
         catch {
+            await rm(tempPath, { force: true }).catch(() => { });
             throw renameError;
         }
         await rm(tempPath, { force: true });

package/dist/source/search.d.ts

@@ -22,6 +22,14 @@ export declare function canUseIndexedSearchPath(indexedSearchEnabled: boolean, i
 export declare function buildGlobRegex(pattern: string): RegExp;
 export declare function globToSqlLike(pattern: string): string;
 export declare function checkPackagePrefix(filePath: string, packagePrefix?: string): boolean;
+/**
+ * A literal file_path prefix every path accepted by the scope starts with, or
+ * undefined when the scope implies none. The indexed candidate query matches it
+ * with an ASCII case-insensitive LIKE, a superset of checkPackagePrefix and the
+ * glob regex (indexed paths are stored with `/` separators), so both exact
+ * checks still run on every candidate.
+ */
+export declare function indexedScopePathPrefix(scope: SearchScope | undefined): string | undefined;
 export declare function buildSearchCursorContext(input: {
     artifactId: string;
     query: string;
@@ -42,8 +50,8 @@ export declare function scorePathMatch(match: SearchMatch, index: number): numbe
 export declare function matchRegexIndex(target: string, regex: RegExp): number;
 export declare function searchClassSource(svc: SourceService, input: SearchClassSourceInput): Promise<SearchClassSourceOutput>;
 export declare function searchSymbolIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void): void;
-export declare function searchTextIntentIndexed(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, onHit: (hit: SearchSourceHit) => void): void;
-export declare function searchPathIntentIndexed(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, onHit: (hit: SearchSourceHit) => void): void;
+export declare function searchTextIntentIndexed(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, onHit: (hit: SearchSourceHit) => void): boolean;
+export declare function searchPathIntentIndexed(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, onHit: (hit: SearchSourceHit) => void): boolean;
 export declare function searchTextIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void, onWarning?: (warning: string) => void): void;
 export declare function searchPathIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void): void;
 export declare function findSymbolHits(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined): IndexedSymbolHit[];

package/dist/source/search.js

@@ -49,7 +49,9 @@ export function canUseIndexedSearchPath(indexedSearchEnabled, intent, match, _sc
     if (match === "regex") {
         return false;
     }
-    // packagePrefix and fileGlob are applied as post-filters on indexed candidates.
+    // packagePrefix and a fileGlob's literal directory prefix narrow the indexed
+    // candidate query (see indexedScopePathPrefix); both scope filters are also
+    // checked exactly on every candidate.
     return true;
 }
 export function buildGlobRegex(pattern) {
@@ -108,12 +110,36 @@ export function globToSqlLike(pattern) {
     }
     return result;
 }
+function packagePrefixPath(packagePrefix) {
+    return `${packagePrefix.replace(/\.+/g, "/").replace(/\/+$/, "")}/`;
+}
 export function checkPackagePrefix(filePath, packagePrefix) {
     if (!packagePrefix) {
         return true;
     }
-    const normalizedPrefix = packagePrefix.replace(/\.+/g, "/").replace(/\/+$/, "");
-    return normalizePathStyle(filePath).startsWith(`${normalizedPrefix}/`);
+    return normalizePathStyle(filePath).startsWith(packagePrefixPath(packagePrefix));
+}
+/**
+ * A literal file_path prefix every path accepted by the scope starts with, or
+ * undefined when the scope implies none. The indexed candidate query matches it
+ * with an ASCII case-insensitive LIKE, a superset of checkPackagePrefix and the
+ * glob regex (indexed paths are stored with `/` separators), so both exact
+ * checks still run on every candidate.
+ */
+export function indexedScopePathPrefix(scope) {
+    const packagePath = scope?.packagePrefix ? packagePrefixPath(scope.packagePrefix) : undefined;
+    let globPath;
+    if (scope?.fileGlob) {
+        // buildGlobRegex treats everything before the first `*`/`?` as literal.
+        const glob = normalizePathStyle(scope.fileGlob);
+        const wildcardIndex = glob.search(/[*?]/);
+        globPath = (wildcardIndex < 0 ? glob : glob.slice(0, wildcardIndex)) || undefined;
+    }
+    if (packagePath && globPath) {
+        // Keep the longer when one extends the other; otherwise either is a superset.
+        return globPath.startsWith(packagePath) ? globPath : packagePath;
+    }
+    return packagePath ?? globPath;
 }
 export function buildSearchCursorContext(input) {
     return JSON.stringify({
@@ -363,6 +389,7 @@ export async function searchClassSource(svc, input) {
             searchWarnings.push(warning);
         };
         const tokenOnlyTextIntent = intent === "text" && queryMode === "token";
+        let indexedWindowFull = false;
         if (intent === "symbol") {
             searchSymbolIntent(svc, artifact.artifactId, query, match, scope, regexPattern, recordHit);
         }
@@ -384,12 +411,9 @@ export async function searchClassSource(svc, input) {
         }
         else if (canUseIndexedSearchPath(indexedSearchEnabled, intent, match, scope)) {
             try {
-                if (intent === "path") {
-                    searchPathIntentIndexed(svc, artifact.artifactId, query, match, scope, recordHit);
-                }
-                else {
-                    searchTextIntentIndexed(svc, artifact.artifactId, query, match, scope, recordHit);
-                }
+                indexedWindowFull = intent === "path"
+                    ? searchPathIntentIndexed(svc, artifact.artifactId, query, match, scope, recordHit)
+                    : searchTextIntentIndexed(svc, artifact.artifactId, query, match, scope, recordHit);
                 svc.metrics.recordSearchIndexedHit();
             }
             catch (caughtError) {
@@ -424,6 +448,9 @@ export async function searchClassSource(svc, input) {
         svc.metrics.recordSearchIntentDuration(intent, Date.now() - intentStartedAt);
         const finalizedHits = accumulator.finalize();
         const page = finalizedHits.page;
+        if (indexedWindowFull && page.length < limit) {
+            searchWarnings.push(indexedCandidateWindowWarning(intent, indexedCandidateLimitForMatch(svc, match)));
+        }
         svc.metrics.recordSearchRowsReturned(page.length);
         const nextCursor = finalizedHits.nextCursorHit
             ? encodeSearchCursor(finalizedHits.nextCursorHit, cursorContext)
@@ -468,17 +495,19 @@ export function searchSymbolIntent(svc, artifactId, query, match, scope, regexPa
 }
 export function searchTextIntentIndexed(svc, artifactId, query, match, scope, onHit) {
     const candidateLimit = indexedCandidateLimitForMatch(svc, match);
+    const pathPrefix = indexedScopePathPrefix(scope);
     const indexed = svc.filesRepo.searchFileCandidates(artifactId, {
         query,
         match,
         limit: candidateLimit,
-        mode: "text"
+        mode: "text",
+        ...(pathPrefix ? { pathPrefix } : {})
     });
     svc.metrics.recordSearchDbRoundtrip(indexed.dbRoundtrips);
     svc.metrics.recordSearchRowsScanned(indexed.scannedRows);
     if (indexed.items.length === 0) {
         svc.metrics.recordSearchIndexedZeroShortcircuit();
-        return;
+        return false;
     }
     const globFilter = scope?.fileGlob ? buildGlobRegex(normalizePathStyle(scope.fileGlob)) : undefined;
     const candidatePaths = indexed.items
@@ -508,19 +537,22 @@ export function searchTextIntentIndexed(svc, artifactId, query, match, scope, on
             reasonCodes: ["content_match", `text_${match}`, "indexed"]
         });
     }
+    return isCandidateWindowFull(indexed);
 }
 export function searchPathIntentIndexed(svc, artifactId, query, match, scope, onHit) {
     const candidateLimit = indexedCandidateLimitForMatch(svc, match);
+    const pathPrefix = indexedScopePathPrefix(scope);
     const indexed = svc.filesRepo.searchFileCandidates(artifactId, {
         query,
         limit: candidateLimit,
-        mode: "path"
+        mode: "path",
+        ...(pathPrefix ? { pathPrefix } : {})
     });
     svc.metrics.recordSearchDbRoundtrip(indexed.dbRoundtrips);
     svc.metrics.recordSearchRowsScanned(indexed.scannedRows);
     if (indexed.items.length === 0) {
         svc.metrics.recordSearchIndexedZeroShortcircuit();
-        return;
+        return false;
     }
     const globFilter = scope?.fileGlob ? buildGlobRegex(normalizePathStyle(scope.fileGlob)) : undefined;
     const candidateRows = [];
@@ -551,6 +583,21 @@ export function searchPathIntentIndexed(svc, artifactId, query, match, scope, on
             reasonCodes: ["path_match", `path_${match}`, "indexed"]
         });
     }
+    return isCandidateWindowFull(indexed);
+}
+/**
+ * True when the index held more candidates than the window it returned: the
+ * repository reports that with a continuation cursor, which the single-window
+ * indexed search never follows.
+ */
+function isCandidateWindowFull(indexed) {
+    return indexed.nextCursor !== undefined;
+}
+function indexedCandidateWindowWarning(intent, candidateLimit) {
+    const fullScan = intent === "text"
+        ? 'queryMode="literal" for a full substring scan'
+        : 'match="regex" for a full path scan';
+    return `indexed ${intent} search examined only its candidate window (the first ${candidateLimit} index candidates) and more matched the index, so results may be incomplete. Use ${fullScan}, or narrow the scope with packagePrefix or a fileGlob that starts with a literal directory.`;
 }
 const ASCII_RE = /^[\x00-\x7F]*$/;
 /** True when every code unit is ASCII, so SQLite LIKE folds case identically to JS. */

package/dist/source/symbol-resolver.js

@@ -1,4 +1,83 @@
 import { ERROR_CODES, createError } from "../errors.js";
+import { isUnobfuscatedVersion } from "../version-service.js";
+import { runUnobfuscatedRuntimeCheck } from "./lifecycle/runtime-check.js";
+/**
+ * Minecraft 26.1+ ships its runtime in Mojang names, so a Loom project for it has no
+ * `mappings` declaration: it compiles against the runtime names directly. Resolving a
+ * workspace symbol there is an identity lookup, checked against runtime bytecode the
+ * same way checkSymbolExists validates unobfuscated versions.
+ */
+async function resolveUnobfuscatedWorkspaceSymbol(svc, input, context) {
+    const { version, querySymbol, sourcePriorityApplied } = context;
+    const workspaceDetection = {
+        resolved: true,
+        mappingApplied: "mojang",
+        evidence: [],
+        warnings: [
+            `Minecraft ${version} is unobfuscated; no mappings declaration is needed — symbols are resolved against runtime (Mojang) names.`
+        ]
+    };
+    // The requested/defaulted sourceMapping label is echoed unchanged: on 26.1+ an
+    // "obfuscated" label already means the as-shipped Mojang names, and rewriting it to
+    // "mojang" would break callers that compare namespace labels for equality.
+    const base = {
+        querySymbol,
+        mappingContext: {
+            version,
+            sourceMapping: input.sourceMapping,
+            targetMapping: "mojang",
+            sourcePriorityApplied,
+            unobfuscatedRuntime: true
+        },
+        resolved: false,
+        status: "not_found",
+        candidates: [],
+        candidateCount: 0,
+        warnings: [...workspaceDetection.warnings]
+    };
+    // The runtime names are both the "obfuscated" (as-shipped) and the Mojang names;
+    // intermediary and yarn names do not exist for these versions.
+    if (input.sourceMapping !== "obfuscated" && input.sourceMapping !== "mojang") {
+        return {
+            ...base,
+            status: "mapping_unavailable",
+            workspaceDetection,
+            warnings: [
+                ...base.warnings,
+                `sourceMapping "${input.sourceMapping}" has no names on unobfuscated Minecraft ${version}; pass sourceMapping "mojang" (or "obfuscated") to resolve against runtime names.`
+            ]
+        };
+    }
+    const runtime = await runUnobfuscatedRuntimeCheck(svc, {
+        version,
+        kind: querySymbol.kind,
+        name: querySymbol.name,
+        owner: querySymbol.owner,
+        descriptor: querySymbol.descriptor,
+        sourceMapping: input.sourceMapping,
+        signatureMode: "exact"
+    }, base);
+    if (!runtime) {
+        // Mirrors checkSymbolExists: a symbol that could not be checked is not reported missing.
+        return {
+            ...base,
+            status: "mapping_unavailable",
+            workspaceDetection,
+            warnings: [
+                ...base.warnings,
+                `Minecraft ${version} runtime jar could not be resolved; symbol existence was not verified.`
+            ]
+        };
+    }
+    if (!runtime.verified) {
+        // The jar was reached but did not answer (short class name, class that failed to
+        // load for a reason other than being absent): the result carries the reason, and
+        // an unanswered lookup is not a definitive miss. `not_found` stays reserved for a
+        // class confirmed missing or a member lookup that completed without a match.
+        return { ...runtime.result, status: "mapping_unavailable", workspaceDetection };
+    }
+    return { ...runtime.result, workspaceDetection };
+}
 export async function resolveWorkspaceSymbol(svc, input) {
     const projectPath = input.projectPath?.trim();
     const version = input.version?.trim();
@@ -77,6 +156,15 @@ export async function resolveWorkspaceSymbol(svc, input) {
     const workspaceDetection = await svc.workspaceMappingService.detectCompileMapping({
         projectPath
     });
+    // No evidence also means no build script was found at all (a missing, mistyped or
+    // empty projectPath). Only a build that was read and declares no mappings is a
+    // 26.1+ Loom project compiling against the runtime names.
+    if (!workspaceDetection.resolved &&
+        workspaceDetection.evidence.length === 0 &&
+        isUnobfuscatedVersion(version) &&
+        (await svc.workspaceMappingService.hasReadableBuildScript(projectPath))) {
+        return resolveUnobfuscatedWorkspaceSymbol(svc, input, { version, querySymbol, sourcePriorityApplied });
+    }
     const warnings = [...workspaceDetection.warnings];
     if (!workspaceDetection.resolved || !workspaceDetection.mappingApplied) {
         return {

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

@@ -1,4 +1,23 @@
 import { existsSync } from "node:fs";
+/**
+ * Whether the mapping data required by `requestedMapping` is present.
+ *
+ * Mojang mappings are only on the resolution path for `"mojang"` requests.
+ * `"yarn"`/`"intermediary"` requests resolve through Tiny mappings instead
+ * and never touch Mojang mappings. `"obfuscated"` requests need neither —
+ * the jar itself (checked separately via `jarAvailable`) is sufficient.
+ */
+function requiredMappingHealthy(requestedMapping, health) {
+    switch (requestedMapping) {
+        case "mojang":
+            return health.mojangMappingsAvailable;
+        case "yarn":
+        case "intermediary":
+            return health.tinyMappingsAvailable;
+        case "obfuscated":
+            return true;
+    }
+}
 export async function runMappingHealthStage(svc, ctx) {
     const mappingHealthStartedAt = await ctx.enterStage("mapping-health");
     try {
@@ -15,7 +34,7 @@ export async function runMappingHealthStage(svc, ctx) {
             mojangMappingsAvailable: health.mojangMappingsAvailable,
             tinyMappingsAvailable: health.tinyMappingsAvailable,
             memberRemapAvailable: health.memberRemapAvailable,
-            overallHealthy: jarAvailable && health.mojangMappingsAvailable,
+            overallHealthy: jarAvailable && requiredMappingHealthy(ctx.requestedMapping, health),
             degradations: [
                 ...(jarAvailable ? [] : ["Game jar not found."]),
                 ...health.degradations

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

@@ -101,10 +101,13 @@ export async function processSingleMixinTarget(svc, ctx, target, targetIndex) {
         }
     }
     try {
+        // Mixin can target synthetic members (lambda bodies, bridges, $VALUES, this$0) and counts
+        // synthetic methods in quantifiers.
         const sig = await svc.explorerService.getSignature({
             fqn: obfuscatedName,
             jarPath: ctx.jarPath,
-            access: "all"
+            access: "all",
+            includeSynthetic: true
         });
         ctx.warnings.push(...sig.warnings);
         ctx.resolutionTrace?.push({ target: target.className, step: "signature", input: obfuscatedName, output: `${sig.methods.length} methods, ${sig.fields.length} fields`, success: true });
@@ -112,15 +115,21 @@ export async function processSingleMixinTarget(svc, ctx, target, targetIndex) {
         let methods = sig.methods;
         let fields = sig.fields;
         if (ctx.requestedMapping !== ctx.signatureLookupMapping) {
+            const remap = (members, kind, warnings) => svc.remapSignatureMembers(members, kind, ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, warnings, ctx.input.projectPath, ctx.input.gradleUserHome);
+            // Unnamed lambdas routinely have no mapping; a synthetic member that fails to remap
+            // stays listed under its source name without degrading the target or the result.
+            const syntheticWarnings = [];
             try {
-                const [ctorResult, methodResult, fieldResult] = await Promise.all([
-                    svc.remapSignatureMembers(sig.constructors, "method", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath, ctx.input.gradleUserHome),
-                    svc.remapSignatureMembers(sig.methods, "method", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath, ctx.input.gradleUserHome),
-                    svc.remapSignatureMembers(sig.fields, "field", ctx.version, ctx.signatureLookupMapping, ctx.requestedMapping, ctx.currentSourcePriority, ctx.warnings, ctx.input.projectPath, ctx.input.gradleUserHome)
+                const [ctorResult, methodResult, fieldResult, syntheticMethodResult, syntheticFieldResult] = await Promise.all([
+                    remap(sig.constructors, "method", ctx.warnings),
+                    remap(sig.methods.filter((member) => !member.isSynthetic), "method", ctx.warnings),
+                    remap(sig.fields.filter((member) => !member.isSynthetic), "field", ctx.warnings),
+                    remap(sig.methods.filter((member) => member.isSynthetic), "method", syntheticWarnings),
+                    remap(sig.fields.filter((member) => member.isSynthetic), "field", syntheticWarnings)
                 ]);
                 constructors = ctorResult.members;
-                methods = methodResult.members;
-                fields = fieldResult.members;
+                methods = [...methodResult.members, ...syntheticMethodResult.members];
+                fields = [...fieldResult.members, ...syntheticFieldResult.members];
                 const targetFailed = new Set();
                 for (const n of ctorResult.failedNames)
                     targetFailed.add(n);

package/dist/source/validate-mixin.d.ts

@@ -8,6 +8,11 @@ export type ValidateMixinSingleInput = Omit<ValidateMixinInput, "input" | "versi
     version: string;
     source?: string;
     sourcePath?: string;
+    /**
+     * Validate only the `@Mixin` class at this simple-name path from the source's top-level class
+     * down (`["Outer"]` for a config entry `Outer`, `["Outer", "Inner"]` for `Outer$Inner`).
+     */
+    nestedClassPath?: string[];
     batchCaches?: {
         classMappings: Map<string, Promise<MappingFindMappingOutput>>;
     };