@adhisang/minecraft-modding-mcp 3.1.0 → 3.2.0

package/dist/index.js

@@ -4,6 +4,7 @@ import { ZodError, z } from "zod";
 import { CompatStdioServerTransport } from "./compat-stdio-transport.js";
 import { objectResult } from "./mcp-helpers.js";
 import { prepareToolInput } from "./tool-input.js";
+import { isCompactEnabled, COMPACT_MAPPING_TOOL_NAMES, compactResponse, compactArtifactResponse, compactMappingResponse } from "./response-utils.js";
 import { loadConfig } from "./config.js";
 import { createError, ERROR_CODES, isAppError } from "./errors.js";
 import { log } from "./logger.js";
@@ -18,7 +19,7 @@ import { InspectMinecraftService, inspectMinecraftSchema, inspectMinecraftShape
 import { AnalyzeSymbolService, analyzeSymbolSchema, analyzeSymbolShape } from "./entry-tools/analyze-symbol-service.js";
 import { CompareMinecraftService, compareMinecraftSchema, compareMinecraftShape } from "./entry-tools/compare-minecraft-service.js";
 import { AnalyzeModService, analyzeModSchema, analyzeModShape } from "./entry-tools/analyze-mod-service.js";
-import { ValidateProjectService, validateProjectSchema, validateProjectShape, discoverWorkspaceAccessWideners, discoverWorkspaceMixins } from "./entry-tools/validate-project-service.js";
+import { ValidateProjectService, validateProjectSchema, validateProjectShape, discoverWorkspaceAccessTransformers, discoverWorkspaceAccessWideners, discoverWorkspaceMixins } from "./entry-tools/validate-project-service.js";
 import { ManageCacheService, manageCacheSchema, manageCacheShape } from "./entry-tools/manage-cache-service.js";
 import { createCacheRegistry } from "./cache-registry.js";
 import { buildEntryToolMeta } from "./entry-tools/response-contract.js";
@@ -89,7 +90,7 @@ const sourceLookupTargetSchema = z.discriminatedUnion("type", [
 ]);
 const RESOLVE_ARTIFACT_TARGET_DESCRIPTION = "Object with kind and value. Example: {\"kind\":\"version\",\"value\":\"1.21.10\"}. Must be an object, not a string.";
 const SOURCE_LOOKUP_TARGET_DESCRIPTION = "Object: {\"type\":\"resolve\",\"kind\":\"version\",\"value\":\"1.21.10\"} or {\"type\":\"artifact\",\"artifactId\":\"...\"}. Must be an object, not a string.";
-const SOURCE_SCOPE_DESCRIPTION = 'vanilla = Mojang client jar only; merged = Loom cache discovery (default); loader = currently behaves the same as "merged".';
+const SOURCE_SCOPE_DESCRIPTION = "vanilla = Mojang client jar only; merged = source-oriented merged runtime discovery; loader = loader/runtime artifact discovery when the workspace exposes transformed runtime jars.";
 const SUGGESTED_CALL_DEFAULTS = {
     allowDecompile: true,
     preferProjectVersion: false,
@@ -109,6 +110,10 @@ const SUGGESTED_CALL_DEFAULTS = {
 function isSuggestedCallDefault(field, value) {
     return value === SUGGESTED_CALL_DEFAULTS[field];
 }
+const ANALYZE_MOD_INCLUDE_GROUPS = ["warnings", "files", "source", "samples", "timings"];
+const ANALYZE_MOD_LEGACY_METADATA_INCLUDES = ["metadata", "entrypoints", "mixins", "dependencies"];
+const VALIDATE_PROJECT_INCLUDE_GROUPS = ["warnings", "issues", "workspace", "recovery"];
+const VALIDATE_PROJECT_LEGACY_WORKSPACE_INCLUDES = ["detectedConfig", "mixins", "accessWideners"];
 const listVersionsShape = {
     includeSnapshots: z.boolean().default(false),
     limit: optionalPositiveInt.default(20).describe("max 200")
@@ -125,7 +130,9 @@ const resolveArtifactShape = {
     projectPath: optionalNonEmptyString.describe("Optional workspace root path for Loom cache-assisted source resolution"),
     scope: artifactScopeSchema.optional().describe(SOURCE_SCOPE_DESCRIPTION),
     preferProjectVersion: z.boolean().optional().describe("When true, detect MC version from gradle.properties and override target.value"),
-    strictVersion: z.boolean().optional().describe("When true, reject version-approximated results instead of returning them. Default false.")
+    strictVersion: z.boolean().optional().describe("When true, reject version-approximated results instead of returning them. Default false."),
+    compact: z.boolean().default(false).describe("When true, return minimal fields (artifactId, origin, isDecompiled, version, requestedMapping, mappingApplied, qualityFlags). "
+        + "Omit provenance, artifactContents, sampleEntries, adjacentSourceCandidates, binaryJarPath, coordinate, repoUrl, resolvedSourceJarPath.")
 };
 const resolveArtifactSchema = z.object(resolveArtifactShape);
 const getClassSourceShape = {
@@ -246,7 +253,9 @@ const findMappingShape = {
     })
         .partial()
         .optional(),
-    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates (max 200)")
+    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates (max 200)"),
+    compact: z.boolean().default(false).describe("When true, omit top-level empty arrays, null/undefined values, and empty objects from the response. "
+        + "Also omit redundant candidates array for single full-confidence exact-match resolutions.")
 };
 const findMappingSchema = z.object(findMappingShape).superRefine((value, ctx) => {
     if (value.kind === "class") {
@@ -264,7 +273,7 @@ const findMappingSchema = z.object(findMappingShape).superRefine((value, ctx) =>
                 path: ["descriptor"]
             });
         }
-        if (!value.name.includes(".")) {
+        if (value.sourceMapping !== "obfuscated" && !value.name.includes(".")) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
                 message: "name must be fully-qualified class name when kind=class.",
@@ -313,7 +322,9 @@ const resolveMethodMappingExactShape = {
     sourceMapping: sourceMappingSchema.describe("obfuscated | mojang | intermediary | yarn"),
     targetMapping: sourceMappingSchema.describe("obfuscated | mojang | intermediary | yarn"),
     sourcePriority: mappingSourcePrioritySchema.optional().describe("loom-first | maven-first"),
-    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates (max 200)")
+    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates (max 200)"),
+    compact: z.boolean().default(false).describe("When true, omit top-level empty arrays, null/undefined values, and empty objects from the response. "
+        + "Also omit redundant candidates array for single full-confidence exact-match resolutions.")
 };
 const resolveMethodMappingExactSchema = z
     .object(resolveMethodMappingExactShape)
@@ -364,7 +375,9 @@ const resolveWorkspaceSymbolShape = {
     descriptor: optionalNonEmptyString,
     sourceMapping: sourceMappingSchema.describe("obfuscated | mojang | intermediary | yarn"),
     sourcePriority: mappingSourcePrioritySchema.optional().describe("loom-first | maven-first"),
-    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates for field/method lookups (max 200)")
+    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates for field/method lookups (max 200)"),
+    compact: z.boolean().default(false).describe("When true, omit top-level empty arrays, null/undefined values, and empty objects from the response. "
+        + "Also omit redundant candidates array for single full-confidence exact-match resolutions.")
 };
 const resolveWorkspaceSymbolSchema = z
     .object(resolveWorkspaceSymbolShape)
@@ -436,7 +449,9 @@ const checkSymbolExistsShape = {
     nameMode: classNameModeSchema.default("fqcn").describe("fqcn | auto"),
     signatureMode: z.enum(["exact", "name-only"]).default("exact")
         .describe("exact: require descriptor for methods; name-only: match by owner+name only"),
-    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates (max 200)")
+    maxCandidates: optionalPositiveInt.default(200).describe("Limit returned candidates (max 200)"),
+    compact: z.boolean().default(false).describe("When true, omit top-level empty arrays, null/undefined values, and empty objects from the response. "
+        + "Also omit redundant candidates array for single full-confidence exact-match resolutions.")
 };
 const checkSymbolExistsSchema = z.object(checkSymbolExistsShape).superRefine((value, ctx) => {
     if (value.kind === "class") {
@@ -577,9 +592,24 @@ const validateAccessWidenerShape = {
     content: nonEmptyString.describe("Access Widener file content"),
     version: nonEmptyString.describe("Minecraft version"),
     mapping: sourceMappingSchema.optional().describe("obfuscated | mojang | intermediary | yarn"),
-    sourcePriority: mappingSourcePrioritySchema.optional().describe("loom-first | maven-first")
+    sourcePriority: mappingSourcePrioritySchema.optional().describe("loom-first | maven-first"),
+    projectPath: optionalNonEmptyString.describe("Optional workspace root path for Loom cache-assisted runtime validation"),
+    scope: artifactScopeSchema.optional().describe(SOURCE_SCOPE_DESCRIPTION),
+    preferProjectVersion: z.boolean().default(false)
+        .describe("When true, detect MC version from gradle.properties and override version")
 };
 const validateAccessWidenerSchema = z.object(validateAccessWidenerShape);
+const validateAccessTransformerShape = {
+    content: nonEmptyString.describe("Access Transformer file content"),
+    version: nonEmptyString.describe("Minecraft version"),
+    atNamespace: z.enum(["srg", "mojang", "obfuscated"]).optional().describe("srg | mojang | obfuscated"),
+    sourcePriority: mappingSourcePrioritySchema.optional().describe("loom-first | maven-first"),
+    projectPath: optionalNonEmptyString.describe("Optional workspace root path for Forge/NeoForge runtime validation"),
+    scope: artifactScopeSchema.optional().describe(SOURCE_SCOPE_DESCRIPTION),
+    preferProjectVersion: z.boolean().default(false)
+        .describe("When true, detect MC version from gradle.properties and override version")
+};
+const validateAccessTransformerSchema = z.object(validateAccessTransformerShape);
 const analyzeModJarShape = {
     jarPath: nonEmptyString.describe("Local path to the mod JAR file"),
     includeClasses: z.boolean().default(false).describe("Include full class listing")
@@ -680,6 +710,7 @@ const inspectMinecraftService = new InspectMinecraftService({
     listVersions: (input) => sourceService.listVersions(input),
     resolveArtifact: (input) => sourceService.resolveArtifact(input),
     findClass: (input) => Promise.resolve(sourceService.findClass(input)),
+    checkSymbolExists: (input) => sourceService.checkSymbolExists(input),
     getClassSource: (input) => sourceService.getClassSource(input),
     getClassMembers: (input) => sourceService.getClassMembers(input),
     searchClassSource: (input) => sourceService.searchClassSource(input),
@@ -710,8 +741,11 @@ const analyzeModService = new AnalyzeModService({
 const validateProjectService = new ValidateProjectService({
     validateMixin: (input) => sourceService.validateMixin(input),
     validateAccessWidener: (input) => sourceService.validateAccessWidener(input),
+    validateAccessTransformer: (input) => sourceService.validateAccessTransformer(input),
     discoverMixins: discoverWorkspaceMixins,
-    discoverAccessWideners: discoverWorkspaceAccessWideners
+    discoverAccessWideners: discoverWorkspaceAccessWideners,
+    discoverAccessTransformers: discoverWorkspaceAccessTransformers,
+    detectProjectMinecraftVersion: (projectPath) => workspaceMappingService.detectProjectMinecraftVersion(projectPath)
 });
 const manageCacheService = new ManageCacheService({
     registry: createCacheRegistry({
@@ -1154,6 +1188,184 @@ function buildSourceLookupSuggestedParams(tool, normalizedInput) {
     }
     return result;
 }
+function filterAllowedIncludeValues(values, allowed) {
+    if (!values?.length) {
+        return [];
+    }
+    const allowedSet = new Set(allowed);
+    const filtered = values.filter((value) => allowedSet.has(value));
+    return [...new Set(filtered)];
+}
+function buildAnalyzeModSuggestedParams(normalizedInput) {
+    const record = asObjectRecord(normalizedInput);
+    if (!record) {
+        return {
+            task: "summary",
+            detail: "standard",
+            subject: {
+                kind: "jar",
+                jarPath: "<mod-jar-path>"
+            }
+        };
+    }
+    const task = asNonEmptyString(record.task) ?? "summary";
+    const result = { task };
+    const subjectRecord = asObjectRecord(record.subject);
+    const include = asStringArray(record.include);
+    const canonicalInclude = filterAllowedIncludeValues(include, ANALYZE_MOD_INCLUDE_GROUPS);
+    const wantsLegacyMetadata = include?.some((value) => ANALYZE_MOD_LEGACY_METADATA_INCLUDES.includes(value)) ?? false;
+    const detail = asNonEmptyString(record.detail);
+    if (task === "summary" && wantsLegacyMetadata) {
+        result.detail = detail && detail !== "summary" ? detail : "standard";
+    }
+    else if (detail && detail !== "summary") {
+        result.detail = detail;
+    }
+    if (canonicalInclude.length > 0) {
+        result.include = canonicalInclude;
+    }
+    if (task === "class-source") {
+        result.subject = {
+            kind: "class",
+            jarPath: asNonEmptyString(subjectRecord?.jarPath) ?? asNonEmptyString(record.subject) ?? "<mod-jar-path>",
+            className: asNonEmptyString(subjectRecord?.className) ?? asNonEmptyString(record.className) ?? "<fully-qualified-class-name>"
+        };
+    }
+    else {
+        result.subject = {
+            kind: "jar",
+            jarPath: asNonEmptyString(subjectRecord?.jarPath) ?? asNonEmptyString(record.subject) ?? asNonEmptyString(record.jarPath) ?? "<mod-jar-path>"
+        };
+    }
+    const stringFields = ["query", "searchType", "targetMapping", "outputJar", "executionMode"];
+    for (const field of stringFields) {
+        const value = record[field];
+        if (typeof value === "string" && value.trim()) {
+            result[field] = value;
+        }
+    }
+    const booleanFields = ["includeFiles"];
+    for (const field of booleanFields) {
+        const value = record[field];
+        if (typeof value === "boolean") {
+            result[field] = value;
+        }
+    }
+    const numericFields = ["limit", "maxFiles", "maxLines", "maxChars"];
+    for (const field of numericFields) {
+        const value = record[field];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            result[field] = value;
+        }
+    }
+    return result;
+}
+function buildValidateProjectSuggestedParams(normalizedInput) {
+    const record = asObjectRecord(normalizedInput);
+    if (!record) {
+        return {
+            task: "project-summary",
+            subject: {
+                kind: "workspace",
+                projectPath: "<workspace-path>"
+            },
+            preferProjectVersion: true
+        };
+    }
+    const task = asNonEmptyString(record.task) ?? "project-summary";
+    const result = { task };
+    const subjectRecord = asObjectRecord(record.subject);
+    const include = asStringArray(record.include);
+    const canonicalInclude = filterAllowedIncludeValues(include, VALIDATE_PROJECT_INCLUDE_GROUPS);
+    const wantsWorkspaceInclude = include?.some((value) => VALIDATE_PROJECT_LEGACY_WORKSPACE_INCLUDES.includes(value)) ?? false;
+    const detail = asNonEmptyString(record.detail);
+    if (detail && detail !== "summary") {
+        result.detail = detail;
+    }
+    const includeSuggestion = wantsWorkspaceInclude
+        ? [...new Set([...canonicalInclude, "workspace"])]
+        : canonicalInclude;
+    if (includeSuggestion.length > 0) {
+        result.include = includeSuggestion;
+    }
+    const stringFields = [
+        "version",
+        "mapping",
+        "sourcePriority",
+        "scope",
+        "minSeverity",
+        "warningMode"
+    ];
+    for (const field of stringFields) {
+        const value = record[field];
+        if (typeof value === "string" && value.trim()) {
+            result[field] = value;
+        }
+    }
+    const booleanFields = [
+        "preferProjectVersion",
+        "preferProjectMapping",
+        "hideUncertain",
+        "explain",
+        "treatInfoAsWarning",
+        "includeIssues"
+    ];
+    for (const field of booleanFields) {
+        const value = record[field];
+        if (typeof value === "boolean" &&
+            (!Object.prototype.hasOwnProperty.call(SUGGESTED_CALL_DEFAULTS, field) ||
+                !isSuggestedCallDefault(field, value))) {
+            result[field] = value;
+        }
+    }
+    const sourceRoots = asStringArray(record.sourceRoots);
+    if (sourceRoots?.length) {
+        result.sourceRoots = sourceRoots;
+    }
+    const configPaths = asStringArray(record.configPaths);
+    if (configPaths?.length) {
+        result.configPaths = configPaths;
+    }
+    const warningCategoryFilter = asStringArray(record.warningCategoryFilter);
+    if (warningCategoryFilter?.length) {
+        result.warningCategoryFilter = warningCategoryFilter;
+    }
+    if (task === "project-summary") {
+        const subject = {
+            kind: "workspace",
+            projectPath: asNonEmptyString(subjectRecord?.projectPath) ??
+                asNonEmptyString(record.subject) ??
+                asNonEmptyString(record.projectPath) ??
+                "<workspace-path>"
+        };
+        const discover = asStringArray(subjectRecord?.discover);
+        if (discover?.length) {
+            subject.discover = discover;
+        }
+        result.subject = subject;
+        return result;
+    }
+    if (task === "mixin") {
+        const inputRecord = asObjectRecord(subjectRecord?.input) ?? asObjectRecord(record.input);
+        result.subject = {
+            kind: "mixin",
+            input: inputRecord ?? {
+                mode: "inline",
+                source: "<Mixin Java source>"
+            }
+        };
+        return result;
+    }
+    const inputRecord = asObjectRecord(subjectRecord?.input) ?? asObjectRecord(record.input);
+    result.subject = {
+        kind: "access-widener",
+        input: inputRecord ?? {
+            mode: "inline",
+            content: "<access widener contents>"
+        }
+    };
+    return result;
+}
 function buildInvalidInputGuidance(tool, normalizedInput) {
     if (tool === "validate-mixin") {
         const hints = [
@@ -1193,6 +1405,32 @@ function buildInvalidInputGuidance(tool, normalizedInput) {
             }
         };
     }
+    if (tool === "validate-project") {
+        return {
+            hints: [
+                "validate-project.subject must be an object with subject.kind=workspace|mixin|access-widener|access-transformer.",
+                "task=\"project-summary\" uses {\"subject\":{\"kind\":\"workspace\",\"projectPath\":\"/workspace\"}}.",
+                "Legacy include names like projectSummary/detectedConfig/validationSummary are not accepted; use include:[\"workspace\"] only when you need discovery details."
+            ],
+            suggestedCall: {
+                tool,
+                params: buildValidateProjectSuggestedParams(normalizedInput)
+            }
+        };
+    }
+    if (tool === "analyze-mod") {
+        return {
+            hints: [
+                "analyze-mod.subject must be an object with subject.kind=jar|class.",
+                "task=\"summary\" uses {\"subject\":{\"kind\":\"jar\",\"jarPath\":\"/path/to/mod.jar\"}}.",
+                "Legacy include names like metadata/entrypoints/mixins/dependencies are not accepted; use detail=\"standard\" to surface the metadata block, and canonical include groups only for warnings/files/source/samples/timings."
+            ],
+            suggestedCall: {
+                tool,
+                params: buildAnalyzeModSuggestedParams(normalizedInput)
+            }
+        };
+    }
     return undefined;
 }
 function mapErrorToProblem(caughtError, requestId, context) {
@@ -1293,6 +1531,17 @@ async function runTool(tool, rawInput, schema, action) {
             ? heavyToolExecutionGate.run(tool, () => action(parsedInput))
             : action(parsedInput));
         const { result, warnings, meta: resultMeta } = splitWarnings(payload);
+        const isCompact = isCompactEnabled(tool, parsedInput);
+        let projectedResult = result;
+        if (isCompact) {
+            if (tool === "resolve-artifact") {
+                projectedResult = compactArtifactResponse(projectedResult);
+            }
+            if (COMPACT_MAPPING_TOOL_NAMES.has(tool)) {
+                projectedResult = compactMappingResponse(projectedResult);
+            }
+            projectedResult = compactResponse(projectedResult);
+        }
         const entryMeta = ENTRY_TOOL_NAMES.has(tool)
             ? buildEntryToolMeta({
                 detail: normalizedInput &&
@@ -1310,7 +1559,7 @@ async function runTool(tool, rawInput, schema, action) {
             })
             : undefined;
         return objectResult({
-            result,
+            result: projectedResult,
             meta: {
                 ...(entryMeta ?? {}),
                 ...resultMeta,
@@ -1375,7 +1624,7 @@ server.tool("inspect-minecraft", "High-level v3 entry tool for version discovery
 server.tool("analyze-symbol", "High-level v3 entry tool for symbol existence, mapping, lifecycle, workspace analysis, and API overview.", analyzeSymbolShape, { readOnlyHint: true }, async (args) => runTool("analyze-symbol", args, analyzeSymbolSchema, async (input) => analyzeSymbolService.execute(input)));
 server.tool("compare-minecraft", "High-level v3 entry tool for version comparisons, class diffs, registry diffs, and migration overviews.", compareMinecraftShape, { readOnlyHint: true }, async (args) => runTool("compare-minecraft", args, compareMinecraftSchema, async (input) => compareMinecraftService.execute(input)));
 server.tool("analyze-mod", "High-level v3 entry tool for mod metadata inspection, decompile/search flows, class source, and safe remap previews/applies.", analyzeModShape, { readOnlyHint: false }, async (args) => runTool("analyze-mod", args, analyzeModSchema, async (input) => analyzeModService.execute(input)));
-server.tool("validate-project", "High-level v3 entry tool for project summary, direct mixin validation, and access widener validation.", validateProjectShape, { readOnlyHint: true }, async (args) => runTool("validate-project", args, validateProjectSchema, async (input) => validateProjectService.execute(input)));
+server.tool("validate-project", "High-level v3 entry tool for project summary, direct mixin validation, and access widener/access transformer validation.", validateProjectShape, { readOnlyHint: true }, async (args) => runTool("validate-project", args, validateProjectSchema, async (input) => validateProjectService.execute(input)));
 server.tool("manage-cache", "High-level v3 entry tool for cache summaries, listing, verification, previewed mutation, and explicit apply operations.", manageCacheShape, { readOnlyHint: false }, async (args) => runTool("manage-cache", args, manageCacheSchema, async (input) => manageCacheService.execute(input)));
 server.tool("resolve-artifact", "Resolve source artifact from a target object ({ kind, value }) and return artifact metadata. For target.kind=jar, only <basename>-sources.jar is auto-adopted; other adjacent *-sources.jar files are informational.", resolveArtifactShape, { readOnlyHint: true }, async (args) => runTool("resolve-artifact", args, resolveArtifactSchema, async (input) => sourceService.resolveArtifact({
     target: input.target,
@@ -1576,7 +1825,19 @@ server.tool("validate-access-widener", "Validate Access Widener file entries aga
     content: input.content,
     version: input.version,
     mapping: input.mapping,
-    sourcePriority: input.sourcePriority
+    sourcePriority: input.sourcePriority,
+    projectPath: input.projectPath,
+    scope: input.scope,
+    preferProjectVersion: input.preferProjectVersion
+})));
+server.tool("validate-access-transformer", "Validate Access Transformer file entries against Minecraft bytecode signatures for a given version.", validateAccessTransformerShape, { readOnlyHint: true }, async (args) => runTool("validate-access-transformer", args, validateAccessTransformerSchema, async (input) => sourceService.validateAccessTransformer({
+    content: input.content,
+    version: input.version,
+    atNamespace: input.atNamespace,
+    sourcePriority: input.sourcePriority,
+    projectPath: input.projectPath,
+    scope: input.scope,
+    preferProjectVersion: input.preferProjectVersion
 })));
 server.tool("analyze-mod-jar", "Analyze a Minecraft mod JAR to extract loader type, metadata, entrypoints, mixins, and dependencies.", analyzeModJarShape, { readOnlyHint: true }, async (args) => runTool("analyze-mod-jar", args, analyzeModJarSchema, async (input) => {
     const result = await analyzeModJar(input.jarPath, {

package/dist/mapping-pipeline-service.d.ts

@@ -3,6 +3,7 @@ export interface MappingPipelineInput {
     requestedMapping: SourceMapping;
     target: SourceTargetInput;
     resolved: ResolvedSourceArtifact;
+    runtimeNamesUnobfuscated?: boolean;
 }
 export interface MappingPipelineResult {
     mappingApplied: SourceMapping;
@@ -13,6 +14,7 @@ export interface MappingPipelineResult {
  * Mapping pipeline for v0.3.
  * Current implementation enforces explicit guarantees:
  * - obfuscated: always pass-through
- * - mojang: requires source-backed artifact; decompile-only artifacts are rejected
+ * - mojang: requires source-backed artifacts on legacy obfuscated versions,
+ *   but unobfuscated runtime jars can pass through directly
  */
 export declare function applyMappingPipeline(input: MappingPipelineInput): MappingPipelineResult;

package/dist/mapping-pipeline-service.js

@@ -3,7 +3,8 @@ import { createError, ERROR_CODES } from "./errors.js";
  * Mapping pipeline for v0.3.
  * Current implementation enforces explicit guarantees:
  * - obfuscated: always pass-through
- * - mojang: requires source-backed artifact; decompile-only artifacts are rejected
+ * - mojang: requires source-backed artifacts on legacy obfuscated versions,
+ *   but unobfuscated runtime jars can pass through directly
  */
 export function applyMappingPipeline(input) {
     const transformChain = [];
@@ -22,6 +23,20 @@ export function applyMappingPipeline(input) {
             transformChain
         };
     }
+    if (input.requestedMapping === "mojang" && input.runtimeNamesUnobfuscated) {
+        transformChain.push("mapping:mojang-runtime-unobfuscated");
+        if (input.resolved.isDecompiled) {
+            qualityFlags.push("decompiled");
+        }
+        else {
+            qualityFlags.push("source-backed");
+        }
+        return {
+            mappingApplied: "mojang",
+            qualityFlags,
+            transformChain
+        };
+    }
     if (input.requestedMapping !== "mojang" &&
         input.requestedMapping !== "intermediary" &&
         input.requestedMapping !== "yarn") {

package/dist/mapping-service.d.ts

@@ -62,6 +62,7 @@ export type FindMappingInput = {
     sourceMapping: SourceMapping;
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
     disambiguation?: {
         ownerHint?: string;
         descriptorHint?: string;
@@ -74,6 +75,7 @@ export type EnsureMappingAvailableInput = {
     sourceMapping: SourceMapping;
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
 };
 export type EnsureMappingAvailableOutput = {
     transformChain: string[];
@@ -88,6 +90,7 @@ export type ResolveMethodMappingExactInput = {
     sourceMapping: SourceMapping;
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
     maxCandidates?: number;
 };
 export type ResolveMethodMappingExactOutput = SymbolResolutionOutput;
@@ -153,6 +156,7 @@ export declare class MappingService {
     checkSymbolExists(input: SymbolExistenceInput): Promise<SymbolExistenceOutput>;
     private mapRecordBetweenMappings;
     private mapCandidatesAlongPath;
+    private projectMethodDescriptorToTarget;
     private provenanceForPath;
     /**
      * Probe the mapping graph health for a given version.
@@ -177,6 +181,7 @@ export declare class MappingService {
     private parseTinyFromJar;
     private fetchYarnCoordinates;
     private trimGraphCache;
+    releaseGraphCacheEntry(version: string, sourcePriority?: MappingSourcePriority): void;
 }
 /**
  * Resolve and cache a Tiny v2 mapping file for the given Minecraft version.