@adhisang/minecraft-modding-mcp 3.1.1 → 3.2.0

package/dist/mod-search-service.js

@@ -1,5 +1,6 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { mapWithConcurrencyLimit } from "./concurrency.js";
 import { createError, ERROR_CODES } from "./errors.js";
 import { log } from "./logger.js";
 import { validateAndNormalizeJarPath } from "./path-resolver.js";
@@ -9,6 +10,7 @@ const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 200;
 const MAX_QUERY_LENGTH = 200;
 const CONTEXT_LINES = 1;
+const DECOMPILED_JAVA_READ_CONCURRENCY = 8;
 const METHOD_PATTERN = /^\s*(public|private|protected)\s+.*\(/;
 const FIELD_PATTERN = /^\s*(public|private|protected)\s+(?:static\s+)?(?:final\s+)?[\w<>,\[\]?]+\s+\w+\s*[;=]/;
 function buildRegex(query) {
@@ -41,6 +43,9 @@ function extractContext(lines, lineIndex) {
 function filePathToClassName(filePath) {
     return filePath.replace(/\.java$/, "").replaceAll("/", ".");
 }
+function cloneRegex(regex) {
+    return new RegExp(regex.source, regex.flags);
+}
 export class ModSearchService {
     modDecompileService;
     constructor(modDecompileService) {
@@ -112,65 +117,40 @@ export class ModSearchService {
         const hits = [];
         let totalHits = 0;
         let reachedLimit = false;
-        for (const className of classNames) {
+        for (let batchStartIndex = 0; batchStartIndex < classNames.length; batchStartIndex += DECOMPILED_JAVA_READ_CONCURRENCY) {
             if (hits.length >= limit) {
                 reachedLimit = true;
                 break;
             }
-            const filePath = className.replaceAll(".", "/") + ".java";
-            // Class name search: check if the simple class name matches
-            if (searchType === "class" || searchType === "all") {
-                const simpleClassName = className.split(".").pop() ?? className;
-                regex.lastIndex = 0;
-                if (regex.test(simpleClassName)) {
-                    totalHits++;
-                    if (hits.length < limit) {
-                        hits.push({
-                            type: "class",
-                            name: className,
-                            file: filePath
-                        });
-                    }
-                    // If searching only classes, skip content search for this file
-                    if (searchType === "class")
-                        continue;
-                }
-            }
-            // Content/method/field search: read and scan the file
-            if (searchType === "method" || searchType === "field" || searchType === "content" || searchType === "all") {
-                let content;
-                try {
-                    content = readFileSync(join(outputDir, filePath), "utf8");
+            const batchClassNames = classNames.slice(batchStartIndex, batchStartIndex + DECOMPILED_JAVA_READ_CONCURRENCY);
+            const batchHitLimit = Math.max(1, limit - hits.length);
+            const fileResults = await mapWithConcurrencyLimit(batchClassNames, DECOMPILED_JAVA_READ_CONCURRENCY, async (className) => this.searchDecompiledClassFile({
+                className,
+                outputDir,
+                searchType,
+                regex: cloneRegex(regex),
+                maxHits: batchHitLimit
+            }));
+            for (const fileResult of fileResults) {
+                if (hits.length >= limit) {
+                    reachedLimit = true;
+                    break;
                 }
-                catch {
-                    // File might not exist at the expected path, skip
+                if (fileResult.hits.length === 0) {
                     continue;
                 }
-                const lines = content.split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    if (hits.length >= limit) {
-                        reachedLimit = true;
-                        break;
-                    }
-                    regex.lastIndex = 0;
-                    if (!regex.test(lines[i]))
-                        continue;
-                    const lineType = classifyLine(lines[i]);
-                    // Filter by search type
-                    if (searchType !== "all" && searchType !== lineType)
-                        continue;
-                    totalHits++;
-                    if (hits.length < limit) {
-                        hits.push({
-                            type: lineType,
-                            name: lineType === "content" ? className : extractSymbolName(lines[i], lineType),
-                            file: filePath,
-                            line: i + 1,
-                            context: extractContext(lines, i)
-                        });
-                    }
+                const remaining = limit - hits.length;
+                const acceptedHits = fileResult.hits.slice(0, remaining);
+                hits.push(...acceptedHits);
+                totalHits += acceptedHits.length;
+                if (hits.length >= limit || fileResult.hits.length > remaining) {
+                    reachedLimit = true;
+                    break;
                 }
             }
+            if (reachedLimit) {
+                break;
+            }
         }
         log("info", "mod-search.done", {
             jarPath,
@@ -255,6 +235,59 @@ export class ModSearchService {
             warnings
         };
     }
+    async searchDecompiledClassFile(input) {
+        const hits = [];
+        const filePath = input.className.replaceAll(".", "/") + ".java";
+        if (input.searchType === "class" || input.searchType === "all") {
+            const simpleClassName = input.className.split(".").pop() ?? input.className;
+            input.regex.lastIndex = 0;
+            if (input.regex.test(simpleClassName)) {
+                hits.push({
+                    type: "class",
+                    name: input.className,
+                    file: filePath
+                });
+                if (input.searchType === "class" || hits.length >= input.maxHits) {
+                    return { hits };
+                }
+            }
+        }
+        if (input.searchType !== "method" &&
+            input.searchType !== "field" &&
+            input.searchType !== "content" &&
+            input.searchType !== "all") {
+            return { hits };
+        }
+        let content;
+        try {
+            content = await readFile(join(input.outputDir, filePath), "utf8");
+        }
+        catch {
+            return { hits };
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            if (hits.length >= input.maxHits) {
+                break;
+            }
+            input.regex.lastIndex = 0;
+            if (!input.regex.test(lines[i])) {
+                continue;
+            }
+            const lineType = classifyLine(lines[i]);
+            if (input.searchType !== "all" && input.searchType !== lineType) {
+                continue;
+            }
+            hits.push({
+                type: lineType,
+                name: lineType === "content" ? input.className : extractSymbolName(lines[i], lineType),
+                file: filePath,
+                line: i + 1,
+                context: extractContext(lines, i)
+            });
+        }
+        return { hits };
+    }
 }
 function extractSymbolName(line, type) {
     const trimmed = line.trim();

package/dist/response-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Compact-mode response utilities.
+ *
+ * Applied at the public boundary (runTool) only — internal service types are never modified.
+ */
+/** Tools that accept the `compact` parameter. */
+export declare const COMPACT_ENABLED_TOOL_NAMES: Set<string>;
+/** Mapping-oriented tools that get additional field projection via compactMappingResponse. */
+export declare const COMPACT_MAPPING_TOOL_NAMES: Set<string>;
+/**
+ * Double-gated compact check: tool must be in the allowlist AND parsedInput.compact must be true.
+ * Prevents activation on passthrough schemas where Zod doesn't strip unknown keys.
+ */
+export declare function isCompactEnabled(tool: string, parsedInput: unknown): boolean;
+/**
+ * Shallow-strip empty values from a response object.
+ * Only operates on the top level — nested structures are preserved as-is.
+ * Non-plain objects (Date, Map, class instances) are never treated as empty.
+ */
+export declare function compactResponse(obj: Record<string, unknown>): Record<string, unknown>;
+/** resolve-artifact compact: omit debug/diagnostic fields. */
+export declare function compactArtifactResponse(obj: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Mapping tool compact: omit candidates only when provably redundant.
+ *
+ * Candidates are omitted when ALL of:
+ * 1. resolved === true
+ * 2. resolvedSymbol exists
+ * 3. candidates is an array of length 1
+ * 4. candidateCount === 1
+ * 5. candidatesTruncated is falsy
+ * 6. candidates[0].matchKind === "exact"
+ * 7. candidates[0].confidence is undefined or 1
+ */
+export declare function compactMappingResponse(obj: Record<string, unknown>): Record<string, unknown>;

package/dist/response-utils.js

@@ -0,0 +1,113 @@
+/**
+ * Compact-mode response utilities.
+ *
+ * Applied at the public boundary (runTool) only — internal service types are never modified.
+ */
+/** Tools that accept the `compact` parameter. */
+export const COMPACT_ENABLED_TOOL_NAMES = new Set([
+    "resolve-artifact",
+    "find-mapping",
+    "resolve-method-mapping-exact",
+    "resolve-workspace-symbol",
+    "check-symbol-exists"
+]);
+/** Mapping-oriented tools that get additional field projection via compactMappingResponse. */
+export const COMPACT_MAPPING_TOOL_NAMES = new Set([
+    "find-mapping",
+    "resolve-method-mapping-exact",
+    "resolve-workspace-symbol",
+    "check-symbol-exists"
+]);
+/**
+ * Double-gated compact check: tool must be in the allowlist AND parsedInput.compact must be true.
+ * Prevents activation on passthrough schemas where Zod doesn't strip unknown keys.
+ */
+export function isCompactEnabled(tool, parsedInput) {
+    if (!COMPACT_ENABLED_TOOL_NAMES.has(tool))
+        return false;
+    if (parsedInput &&
+        typeof parsedInput === "object" &&
+        !Array.isArray(parsedInput) &&
+        parsedInput.compact === true) {
+        return true;
+    }
+    return false;
+}
+function isPlainObject(v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Shallow-strip empty values from a response object.
+ * Only operates on the top level — nested structures are preserved as-is.
+ * Non-plain objects (Date, Map, class instances) are never treated as empty.
+ */
+export function compactResponse(obj) {
+    if (!isPlainObject(obj))
+        return {};
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null || value === undefined)
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        if (isPlainObject(value) && Object.keys(value).length === 0)
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/** Fields to omit from resolve-artifact in compact mode. */
+const ARTIFACT_COMPACT_OMIT_KEYS = new Set([
+    "provenance",
+    "artifactContents",
+    "sampleEntries",
+    "adjacentSourceCandidates",
+    "binaryJarPath",
+    "coordinate",
+    "repoUrl",
+    "resolvedSourceJarPath"
+]);
+/** resolve-artifact compact: omit debug/diagnostic fields. */
+export function compactArtifactResponse(obj) {
+    const projected = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (ARTIFACT_COMPACT_OMIT_KEYS.has(key))
+            continue;
+        projected[key] = value;
+    }
+    return projected;
+}
+/**
+ * Mapping tool compact: omit candidates only when provably redundant.
+ *
+ * Candidates are omitted when ALL of:
+ * 1. resolved === true
+ * 2. resolvedSymbol exists
+ * 3. candidates is an array of length 1
+ * 4. candidateCount === 1
+ * 5. candidatesTruncated is falsy
+ * 6. candidates[0].matchKind === "exact"
+ * 7. candidates[0].confidence is undefined or 1
+ */
+export function compactMappingResponse(obj) {
+    const projected = { ...obj };
+    const candidates = projected.candidates;
+    if (projected.resolved === true &&
+        projected.resolvedSymbol !== undefined &&
+        Array.isArray(candidates) &&
+        candidates.length === 1 &&
+        projected.candidateCount === 1 &&
+        !projected.candidatesTruncated) {
+        const candidate = candidates[0];
+        if (candidate &&
+            candidate.matchKind === "exact" &&
+            (candidate.confidence === undefined || candidate.confidence === 1)) {
+            delete projected.candidates;
+        }
+    }
+    return projected;
+}
+//# sourceMappingURL=response-utils.js.map

package/dist/source-jar-reader.d.ts

@@ -2,12 +2,28 @@ export interface JavaEntryText {
     filePath: string;
     content: string;
 }
+export interface JarEntryText {
+    filePath: string;
+    content: string;
+}
+export interface CollectMatchedJarEntriesOptions {
+    maxBytes?: number;
+    maxEntries?: number;
+    continueOnError?: boolean;
+}
+export declare function hasJavaSourceExtension(entryPath: string): boolean;
 export declare class EntryTooLargeError extends Error {
     constructor(entryPath: string, jarPath: string, maxBytes: number);
 }
 export declare function listJarEntries(jarPath: string): Promise<string[]>;
 export declare function listJavaEntries(jarPath: string): Promise<string[]>;
+export declare function hasAnyJarEntry(jarPath: string, predicate: (entryPath: string) => boolean): Promise<boolean>;
 export declare function readJarEntryAsUtf8(jarPath: string, entryPath: string): Promise<string>;
 export declare function readJarEntryAsBuffer(jarPath: string, entryPath: string): Promise<Buffer>;
+export declare function collectMatchedJarEntriesAsUtf8(jarPath: string, predicate: (entryPath: string) => boolean, options?: CollectMatchedJarEntriesOptions): Promise<JarEntryText[]>;
 export declare function iterateJavaEntriesAsUtf8(jarPath: string, maxBytes?: number): AsyncGenerator<JavaEntryText>;
 export declare function readAllJavaEntriesAsUtf8(jarPath: string, maxBytes?: number): Promise<JavaEntryText[]>;
+export declare function detectFabricLikeInputNamespace(inputJar: string): Promise<{
+    fromNamespace: "intermediary" | "mojang";
+    warnings: string[];
+}>;

package/dist/source-jar-reader.js

@@ -9,7 +9,7 @@ function toErrorMessage(value) {
     }
     return String(value);
 }
-function hasJavaSourceExtension(entryPath) {
+export function hasJavaSourceExtension(entryPath) {
     const suffix = ".java";
     if (entryPath.length < suffix.length) {
         return false;
@@ -144,6 +144,22 @@ export async function listJavaEntries(jarPath) {
     const entries = await listJarEntries(jarPath);
     return entries.filter((entry) => hasJavaSourceExtension(entry) && isSecureJarEntryPath(entry));
 }
+export async function hasAnyJarEntry(jarPath, predicate) {
+    return withZipFile(jarPath, async (zipFile) => {
+        while (true) {
+            const entry = await readNextEntry(zipFile);
+            if (!entry) {
+                return false;
+            }
+            if (!isSecureJarEntryPath(entry.fileName)) {
+                continue;
+            }
+            if (predicate(entry.fileName)) {
+                return true;
+            }
+        }
+    });
+}
 export async function readJarEntryAsUtf8(jarPath, entryPath) {
     const contentBuffer = await readJarEntryAsBuffer(jarPath, entryPath);
     return decodeUtf8OrThrow(contentBuffer, jarPath, entryPath);
@@ -177,6 +193,39 @@ export async function readJarEntryAsBuffer(jarPath, entryPath) {
         }
     });
 }
+export async function collectMatchedJarEntriesAsUtf8(jarPath, predicate, options = {}) {
+    return withZipFile(jarPath, async (zipFile) => {
+        const entries = [];
+        const maxEntries = options.maxEntries == null ? undefined : Math.max(1, Math.trunc(options.maxEntries));
+        while (true) {
+            const entry = await readNextEntry(zipFile);
+            if (!entry) {
+                return entries;
+            }
+            if (!isSecureJarEntryPath(entry.fileName)) {
+                continue;
+            }
+            if (!predicate(entry.fileName)) {
+                continue;
+            }
+            try {
+                const contentBuffer = await readEntryStream(zipFile, entry, jarPath, options.maxBytes);
+                entries.push({
+                    filePath: entry.fileName,
+                    content: decodeUtf8OrThrow(contentBuffer, jarPath, entry.fileName)
+                });
+                if (maxEntries != null && entries.length >= maxEntries) {
+                    return entries;
+                }
+            }
+            catch (error) {
+                if (!options.continueOnError) {
+                    throw error;
+                }
+            }
+        }
+    });
+}
 export async function* iterateJavaEntriesAsUtf8(jarPath, maxBytes) {
     const zipFile = await openZipFile(jarPath);
     try {
@@ -227,4 +276,57 @@ export async function readAllJavaEntriesAsUtf8(jarPath, maxBytes) {
     }
     return entries;
 }
+function countMatches(input, pattern) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    let count = 0;
+    while (globalPattern.exec(input)) {
+        count += 1;
+    }
+    return count;
+}
+export async function detectFabricLikeInputNamespace(inputJar) {
+    const warnings = [];
+    const classEntries = (await listJarEntries(inputJar))
+        .filter((entry) => entry.endsWith(".class"))
+        .slice(0, 24);
+    if (classEntries.length === 0) {
+        warnings.push("Could not inspect class entries to detect input mapping; assuming intermediary.");
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    let mojangScore = 0;
+    let intermediaryScore = 0;
+    for (const entry of classEntries) {
+        let text = "";
+        try {
+            text = (await readJarEntryAsBuffer(inputJar, entry)).toString("latin1");
+        }
+        catch {
+            continue;
+        }
+        mojangScore += countMatches(text, /net\/minecraft\/(?:advancements|client|commands|core|data|gametest|nbt|network|recipe|resources|server|sounds|stats|tags|util|world)\//g) * 3;
+        intermediaryScore += countMatches(text, /net\/minecraft\/class_\d+/g) * 3;
+        intermediaryScore += countMatches(text, /\b(?:method|field)_\d+\b/g);
+    }
+    if (mojangScore > intermediaryScore && mojangScore > 0) {
+        return {
+            fromNamespace: "mojang",
+            warnings
+        };
+    }
+    if (intermediaryScore > mojangScore && intermediaryScore > 0) {
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    warnings.push("Could not confidently detect whether the input jar uses intermediary or mojang names; assuming intermediary.");
+    return {
+        fromNamespace: "intermediary",
+        warnings
+    };
+}
 //# sourceMappingURL=source-jar-reader.js.map

package/dist/source-resolver.js

@@ -1,4 +1,4 @@
-import { readdirSync } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { basename, dirname, join, resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
 import fastGlob from "fast-glob";
@@ -7,7 +7,7 @@ import { buildRemoteBinaryUrls, buildRemoteSourceUrls, hasExistingJar, parseCoor
 import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
 import { artifactSignatureFromFile, normalizeJarPath } from "./path-resolver.js";
 import { stableArtifactId } from "./config.js";
-import { listJavaEntries } from "./source-jar-reader.js";
+import { hasAnyJarEntry, hasJavaSourceExtension } from "./source-jar-reader.js";
 function readStatsSignature(filePath) {
     const stats = artifactSignatureFromFile(filePath);
     return stats.signature;
@@ -16,8 +16,7 @@ async function hasJavaSources(jarPath) {
     if (!hasExistingJar(jarPath)) {
         return false;
     }
-    const entries = await listJavaEntries(jarPath);
-    return entries.length > 0;
+    return hasAnyJarEntry(jarPath, hasJavaSourceExtension);
 }
 function resolveExactJarSourceCandidate(inputJarPath) {
     const directory = dirname(inputJarPath);
@@ -35,12 +34,12 @@ function resolveSiblingBinaryJarCandidate(inputJarPath) {
     const candidate = join(directory, binaryName);
     return hasExistingJar(candidate) ? candidate : undefined;
 }
-function listAdjacentJarSourceCandidates(inputJarPath) {
+async function listAdjacentJarSourceCandidates(inputJarPath) {
     const directory = dirname(inputJarPath);
     const exact = resolveExactJarSourceCandidate(inputJarPath);
     const candidates = new Set();
     try {
-        for (const file of readdirSync(directory)) {
+        for (const file of await readdir(directory)) {
             if (file.toLowerCase().endsWith("-sources.jar")) {
                 const candidate = join(directory, file);
                 if (candidate !== inputJarPath && candidate !== exact) {
@@ -90,7 +89,7 @@ function resolveGradleUserHome() {
     }
     return resolvePath(homedir(), ".gradle");
 }
-function resolveGradleCacheCoordinateCandidate(coordinate) {
+async function resolveGradleCacheCoordinateCandidate(coordinate) {
     const parsed = parseCoordinate(coordinate);
     const baseDir = resolvePath(resolveGradleUserHome(), "caches", "modules-2", "files-2.1", parsed.groupId, parsed.artifactId, parsed.version);
     const base = `${parsed.artifactId}-${parsed.version}`;
@@ -105,7 +104,7 @@ function resolveGradleCacheCoordinateCandidate(coordinate) {
     ];
     let discoveredFiles = [];
     try {
-        discoveredFiles = fastGlob.sync("*/*", {
+        discoveredFiles = await fastGlob.glob("*/*", {
             cwd: baseDir,
             absolute: true,
             onlyFiles: true
@@ -150,7 +149,7 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
         const resolvedJarPath = normalizeJarPath(input.value);
         const binarySignature = readStatsSignature(resolvedJarPath);
         const exactSourceJarPath = resolveExactJarSourceCandidate(resolvedJarPath);
-        const adjacentSourceCandidates = listAdjacentJarSourceCandidates(resolvedJarPath);
+        const adjacentSourceCandidates = await listAdjacentJarSourceCandidates(resolvedJarPath);
         const maybeAdjacentSourceCandidates = adjacentSourceCandidates.length > 0 ? adjacentSourceCandidates : undefined;
         const preferBinaryOnly = options.preferBinaryOnly ?? false;
         if (await hasJavaSources(resolvedJarPath)) {
@@ -225,7 +224,7 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
             };
         }
     }
-    const gradleCacheCandidate = resolveGradleCacheCoordinateCandidate(coordinate);
+    const gradleCacheCandidate = await resolveGradleCacheCoordinateCandidate(coordinate);
     if (gradleCacheCandidate?.sourceJarPath && (await hasJavaSources(gradleCacheCandidate.sourceJarPath))) {
         const signature = readStatsSignature(gradleCacheCandidate.sourceJarPath);
         return {

package/dist/source-service.d.ts

@@ -1,9 +1,9 @@
 import { type ResponseContext as ExplorerResponseContext, type SignatureMember } from "./minecraft-explorer-service.js";
-import { type MixinValidationResult, type MixinValidationProvenance, type MappingHealthReport, type AccessWidenerValidationResult } from "./mixin-validator.js";
+import { type MixinValidationResult, type MixinValidationProvenance, type MappingHealthReport, type AccessWidenerValidationResult, type AccessTransformerValidationResult } from "./mixin-validator.js";
 import { type ClassApiMatrixInput as MappingClassApiMatrixInput, type ClassApiMatrixOutput as MappingClassApiMatrixOutput, type FindMappingInput as MappingFindMappingInput, type FindMappingOutput as MappingFindMappingOutput, type ResolveMethodMappingExactInput as MappingResolveMethodMappingExactInput, type ResolveMethodMappingExactOutput as MappingResolveMethodMappingExactOutput, type SymbolResolutionOutput as MappingSymbolResolutionOutput, type SymbolExistenceInput as MappingSymbolExistenceInput, type SymbolExistenceOutput as MappingSymbolExistenceOutput } from "./mapping-service.js";
 import { RuntimeMetrics, type RuntimeMetricSnapshot } from "./observability.js";
 import { type WorkspaceCompileMappingOutput } from "./workspace-mapping-service.js";
-import type { ArtifactProvenance, ArtifactRow, ArtifactScope, Config, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping, SourceTargetInput } from "./types.js";
+import type { AccessTransformerNamespace, ArtifactProvenance, ArtifactRow, ArtifactScope, Config, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping, SourceTargetInput } from "./types.js";
 import { type ListVersionsInput, type ListVersionsOutput } from "./version-service.js";
 import { type GetRegistryDataInput, type GetRegistryDataOutput } from "./registry-service.js";
 import { type CompareVersionsInput, type CompareVersionsOutput } from "./version-diff-service.js";
@@ -424,8 +424,21 @@ export type ValidateAccessWidenerInput = {
     version: string;
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
 };
 export type ValidateAccessWidenerOutput = AccessWidenerValidationResult;
+export type ValidateAccessTransformerInput = {
+    content: string;
+    version: string;
+    atNamespace?: AccessTransformerNamespace;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+};
+export type ValidateAccessTransformerOutput = AccessTransformerValidationResult;
 export declare class SourceService {
     private readonly config;
     private readonly db;
@@ -445,6 +458,11 @@ export declare class SourceService {
     private cacheMetricsState;
     constructor(explicitConfig?: Config, metrics?: RuntimeMetrics);
     private discoverVersionSourceJar;
+    private discoverAccessWidenerRuntimeCandidates;
+    private discoverAccessTransformerRuntimeCandidates;
+    private resolveAccessWidenerRuntimeArtifact;
+    private resolveAccessTransformerNamespace;
+    private resolveAccessTransformerRuntimeArtifact;
     private buildVersionSourceRecoveryCommand;
     private buildArtifactContentsSummary;
     private inferVersionFromContext;
@@ -464,6 +482,7 @@ export declare class SourceService {
     getClassApiMatrix(input: GetClassApiMatrixInput): Promise<GetClassApiMatrixOutput>;
     checkSymbolExists(input: CheckSymbolExistsInput): Promise<CheckSymbolExistsOutput>;
     resolveWorkspaceSymbol(input: ResolveWorkspaceSymbolInput): Promise<ResolveWorkspaceSymbolOutput>;
+    private checkSymbolExistsInUnobfuscatedRuntime;
     traceSymbolLifecycle(input: TraceSymbolLifecycleInput): Promise<TraceSymbolLifecycleOutput>;
     diffClassSignatures(input: DiffClassSignaturesInput): Promise<DiffClassSignaturesOutput>;
     findClass(input: FindClassInput): FindClassOutput;
@@ -480,6 +499,7 @@ export declare class SourceService {
     private applyValidateMixinOutputCompaction;
     private buildValidateMixinOutput;
     validateAccessWidener(input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
+    validateAccessTransformer(input: ValidateAccessTransformerInput): Promise<ValidateAccessTransformerOutput>;
     getRuntimeMetrics(): RuntimeMetricSnapshot;
     indexArtifact(input: IndexArtifactInput): Promise<IndexArtifactOutput>;
     private searchSymbolIntent;