@adhisang/minecraft-modding-mcp 7.0.0-rc.3 → 7.1.0

package/dist/source/artifact-resolver.js

@@ -219,6 +219,40 @@ const RUNTIME_JAR_VERSION_REGEX = /(?:^|[^0-9.])(1\.\d+(?:\.\d+)?)(?![0-9.])/;
 export function inferRuntimeJarMinecraftVersion(path) {
     return RUNTIME_JAR_VERSION_REGEX.exec(normalizePathStyle(path))?.[1];
 }
+/**
+ * The Minecraft version a `kind: "jar"` target PROVES it is the unobfuscated
+ * runtime of, or undefined. The file path is never evidence: Loom and other
+ * tools lay jars out in ways that path heuristics have misread before.
+ *
+ * All three must hold: the walk met no `.java` entry, the jar ships
+ * `net/minecraft/SharedConstants.class`, and its root `version.json` parses with a
+ * string `id` that `isUnobfuscatedVersion` accepts. The id is put to that test
+ * only once the other two hold, so it is the id a Minecraft `version.json`
+ * declares, never a library's own release number. A Loom-mapped 1.x jar carries
+ * both signals too; its `1.x` id is what keeps it out. The path is never read.
+ */
+export function provenUnobfuscatedRuntimeJarVersion(scan) {
+    const signals = scan?.minecraftRuntimeSignals;
+    if (!scan || scan.hasJavaSources || !signals?.hasSharedConstantsClass || signals.versionJsonText === undefined) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(signals.versionJsonText);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const id = parsed.id;
+    if (typeof id !== "string") {
+        return undefined;
+    }
+    const version = id.trim();
+    return isUnobfuscatedVersion(version) ? version : undefined;
+}
 /**
  * Segment that opens a directory tree a BUILD TOOL wrote: a dot-directory
  * (`.gradle`, `.gradle-user-home`, `.m2`), Gradle's `caches` root, or a project
@@ -378,7 +412,8 @@ function buildProvenance(input) {
             version: input.resolved.version,
             repoUrl: input.resolved.repoUrl
         },
-        transformChain: [...input.transformChain]
+        transformChain: [...input.transformChain],
+        ...(input.unobfuscatedRuntime ? { unobfuscatedRuntime: true } : {})
     };
     if (!provenance.resolvedAt || !provenance.target.kind || !provenance.target.value) {
         throw createError({
@@ -1238,7 +1273,14 @@ export async function buildMappingFallbackSuggestedCall(svc, args) {
         return buildLegacyMappingFallback({ kind, value, scope, isVanillaMojang, projectPath: undefined });
     }
     if (kind !== "version") {
-        return buildLegacyMappingFallback({ kind, value, scope, isVanillaMojang, projectPath });
+        return buildLegacyMappingFallback({
+            kind,
+            value,
+            scope,
+            isVanillaMojang,
+            projectPath,
+            projectRuntimeUnobfuscated: isVanillaMojang && (await projectNamesUnobfuscatedMinecraft(svc, projectPath))
+        });
     }
     const cached = svc.workspaceContextCache.read(projectPath);
     if (cached &&
@@ -1299,9 +1341,28 @@ export async function buildMappingFallbackSuggestedCall(svc, args) {
     }
     return buildLegacyMappingFallback({ kind, value, scope, isVanillaMojang, projectPath });
 }
+/**
+ * Whether the project's gradle.properties names a Minecraft 26.1+ release. The
+ * property is a Minecraft version by name (`minecraft_version` and its aliases), so
+ * it may be put to `isUnobfuscatedVersion`. Unreadable or absent answers false.
+ */
+async function projectNamesUnobfuscatedMinecraft(svc, projectPath) {
+    try {
+        const version = await svc.workspaceMappingService.detectProjectMinecraftVersion(projectPath);
+        return version !== undefined && isUnobfuscatedVersion(version);
+    }
+    catch {
+        return false;
+    }
+}
 function buildLegacyMappingFallback(args) {
     const { kind, value, scope, isVanillaMojang, projectPath } = args;
-    if (isVanillaMojang && projectPath) {
+    // scope=merged reaches Loom source discovery only for a version target. For a
+    // jar or coordinate in a 26.1+ project, re-suggesting mojang+merged on the same
+    // target repeats the request that was just refused, so that case takes the
+    // generic retry below instead.
+    const mergedRetryWouldRepeat = kind !== "version" && args.projectRuntimeUnobfuscated === true;
+    if (isVanillaMojang && projectPath && !mergedRetryWouldRepeat) {
         return {
             ...buildSuggestedCall({
                 tool: "resolve-artifact",
@@ -1311,7 +1372,7 @@ function buildLegacyMappingFallback(args) {
                 "Retry with scope=merged to allow source-jar resolution from the project cache."
         };
     }
-    if (isVanillaMojang) {
+    if (isVanillaMojang && !projectPath) {
         return {
             ...buildSuggestedCall({
                 tool: "resolve-artifact",
@@ -1326,7 +1387,14 @@ function buildLegacyMappingFallback(args) {
             tool: "resolve-artifact",
             params: buildResolveArtifactParams({ kind, value }, { mapping: "obfuscated", ...(scope ? { scope } : {}) })
         }),
-        nextAction: "Retry with mapping=obfuscated to use the runtime obfuscated namespace."
+        // A jar reaches here only when it was NOT proven to be a Minecraft runtime jar,
+        // so its version is unknown and "obfuscated" must not be described as
+        // obfuscated names: on 26.1+ the as-shipped names are Mojang names. Version and
+        // coordinate refusals keep their established wording.
+        nextAction: kind === "jar"
+            ? "Retry with mapping=obfuscated to read this jar's names as shipped (already Mojang names on Minecraft 26.1+). " +
+                "For a vanilla Minecraft release, use target kind \"version\" instead."
+            : "Retry with mapping=obfuscated to use the runtime obfuscated namespace."
     };
 }
 export async function resolveArtifact(svc, input) {
@@ -1431,13 +1499,19 @@ export async function resolveArtifact(svc, input) {
         // below), so its mapping is never actually enforced either way.
         const versionNamesMinecraft = kind === "version" ||
             (kind === "coordinate" && !dependencyOrigin && coordinateIsMinecraftRuntime);
-        const minecraftVersion = versionNamesMinecraft ? resolvedVersion : undefined;
-        const runtimeNamesUnobfuscated = minecraftVersion !== undefined && isUnobfuscatedVersion(minecraftVersion);
+        // A kind="jar" target names no version at all. It joins this gate only AFTER its
+        // archive has been walked and proved to be a Minecraft 26.1+ runtime jar (see
+        // `provenUnobfuscatedRuntimeJarVersion` below); until then it stays out.
+        let minecraftVersion = versionNamesMinecraft ? resolvedVersion : undefined;
+        let runtimeNamesUnobfuscated = minecraftVersion !== undefined && isUnobfuscatedVersion(minecraftVersion);
         let effectiveMapping = mapping;
-        if ((mapping === "intermediary" || mapping === "yarn") && runtimeNamesUnobfuscated) {
-            warnings.push(`Version ${minecraftVersion} is unobfuscated; ${mapping} mappings are not applicable. Using the obfuscated namespace label for the deobfuscated runtime names.`);
-            effectiveMapping = "obfuscated";
-        }
+        const dropInapplicableUnobfuscatedMapping = () => {
+            if ((effectiveMapping === "intermediary" || effectiveMapping === "yarn") && runtimeNamesUnobfuscated) {
+                warnings.push(`Version ${minecraftVersion} is unobfuscated; ${effectiveMapping} mappings are not applicable. Using the obfuscated namespace label for the deobfuscated runtime names.`);
+                effectiveMapping = "obfuscated";
+            }
+        };
+        dropInapplicableUnobfuscatedMapping();
         if (kind === "version" &&
             resolvedVersion &&
             effectiveMapping === "mojang" &&
@@ -1471,9 +1545,21 @@ export async function resolveArtifact(svc, input) {
         if (binaryRemapGate.warnings.length > 0) {
             warnings.push(...binaryRemapGate.warnings);
         }
+        // Only a jar the caller named directly can be proved from its contents. A
+        // dependency-origin jar is excluded for the reason given above, and a version
+        // target is rewritten into a jar but already carries its version.
+        const proveRuntimeJar = kind === "jar" && !dependencyOrigin;
+        let subjectJarScan = undefined;
         const resolved = await resolveSourceTargetInternal(resolvedTarget, {
             allowDecompile: effectiveMapping === "mojang" ? true : input.allowDecompile ?? true,
             mappingVariant: binaryRemapGate.mappingVariant,
+            ...(proveRuntimeJar
+                ? {
+                    onSubjectJarScanned: (scan) => {
+                        subjectJarScan = scan;
+                    }
+                }
+                : {}),
             onRepoFailover: (event) => {
                 svc.metrics.recordRepoFailover();
                 log("warn", "repo.failover", {
@@ -1486,6 +1572,13 @@ export async function resolveArtifact(svc, input) {
                 });
             }
         }, svc.config);
+        const provenJarVersion = proveRuntimeJar ? provenUnobfuscatedRuntimeJarVersion(subjectJarScan) : undefined;
+        if (provenJarVersion) {
+            resolvedVersion = provenJarVersion;
+            minecraftVersion = provenJarVersion;
+            runtimeNamesUnobfuscated = true;
+            dropInapplicableUnobfuscatedMapping();
+        }
         resolved.version = resolvedVersion;
         let mappingDecision;
         try {
@@ -1569,7 +1662,8 @@ export async function resolveArtifact(svc, input) {
         const provenance = buildProvenance({
             requestedTarget: { kind, value },
             resolved,
-            transformChain: [...mappingDecision.transformChain, ...additionalTransformChain]
+            transformChain: [...mappingDecision.transformChain, ...additionalTransformChain],
+            unobfuscatedRuntime: runtimeNamesUnobfuscated
         });
         if (workspaceProvenance) {
             provenance.workspaceResolution = workspaceProvenance;

package/dist/source/class-source/members-builder.d.ts

@@ -17,6 +17,13 @@ export type RemapMembersInput = {
     signatureFields: SignatureMember[];
     signatureMethods: SignatureMember[];
     version: string | undefined;
+    /**
+     * `version` when it is a Minecraft version, else undefined: a dependency
+     * artifact's `version` is its own release number, which must not reach the
+     * 26.1+ obfuscated<->mojang identity shortcut, which may only be asked about a
+     * string proven to be a Minecraft version.
+     */
+    minecraftVersion: string | undefined;
     mappingApplied: SourceMapping;
     requestedMapping: SourceMapping;
     sourcePriority: MappingSourcePriority | undefined;

package/dist/source/class-source/members-builder.js

@@ -1,10 +1,13 @@
+import { remapSignatureMembers } from "../lifecycle/mapping-helpers.js";
 import { matchesMemberPattern } from "../member-pattern.js";
 export async function remapAndCountMembers(svc, input) {
     const remap = async (members, kind) => {
         if (input.version == null) {
             return members;
         }
-        const result = await svc.remapSignatureMembers(members, kind, input.version, input.mappingApplied, input.requestedMapping, input.sourcePriority, input.warnings, undefined, input.gradleUserHome);
+        // Called directly rather than through svc.remapSignatureMembers, whose fixed
+        // parameter list cannot carry minecraftVersion.
+        const result = await remapSignatureMembers(svc, members, kind, input.version, input.mappingApplied, input.requestedMapping, input.sourcePriority, input.warnings, undefined, input.gradleUserHome, { minecraftVersion: input.minecraftVersion });
         return result.members;
     };
     let constructors = await remap(input.signatureConstructors, "method");

package/dist/source/class-source.d.ts

@@ -21,7 +21,7 @@ import type { ArtifactProvenance, ArtifactScope, MappingSourcePriority, Resolved
  */
 export declare function reconcileUnobfuscatedNamespace(version: string | undefined, requestedMapping: SourceMapping, mappingApplied: SourceMapping): SourceMapping;
 export declare function resolveClassFilePath(svc: SourceService, artifactId: string, className: string): string | undefined;
-export declare function resolveClassNameForLookup(svc: SourceService, input: {
+type ClassNameLookupInput = {
     className: string;
     version?: string;
     sourceMapping: SourceMapping;
@@ -30,7 +30,13 @@ export declare function resolveClassNameForLookup(svc: SourceService, input: {
     gradleUserHome?: string;
     warnings: string[];
     context: string;
-}): Promise<string>;
+};
+/**
+ * The class-name translation behind `svc.resolveClassNameForLookup`, whose callers
+ * (the lifecycle tools) pass a Minecraft version, so `version` also keys the 26.1+
+ * identity shortcut.
+ */
+export declare function resolveClassNameForLookup(svc: SourceService, input: ClassNameLookupInput): Promise<string>;
 export declare function buildFallbackProvenance(svc: SourceService, input: {
     artifactId: string;
     origin: ResolvedSourceArtifact["origin"];
@@ -98,3 +104,4 @@ export declare function findClass(svc: SourceService, input: FindClassInput): Fi
 export declare function findClassIncludingNested(svc: SourceService, input: FindClassInput): Promise<FindClassOutput>;
 export declare function getClassSource(svc: SourceService, input: GetClassSourceInput): Promise<GetClassSourceOutput>;
 export declare function getClassMembers(svc: SourceService, input: GetClassMembersInput): Promise<GetClassMembersOutput>;
+export {};