@adhisang/minecraft-modding-mcp 3.2.0 → 4.1.0

package/dist/observability.d.ts

@@ -22,6 +22,7 @@ export interface RuntimeMetricSnapshot {
     get_file_duration_ms: MetricTimingSnapshot;
     list_files_duration_ms: MetricTimingSnapshot;
     decompile_duration_ms: MetricTimingSnapshot;
+    binary_remap_duration_ms: MetricTimingSnapshot;
     search_intent_symbol_duration_ms: MetricTimingSnapshot;
     search_intent_text_duration_ms: MetricTimingSnapshot;
     search_intent_path_duration_ms: MetricTimingSnapshot;
@@ -47,8 +48,13 @@ export interface RuntimeMetricSnapshot {
     cache_artifact_bytes_lru: CacheArtifactByteAccountingRow[];
     cache_hit_rate: number;
     repo_failover_count: number;
+    tool_call_counts: Record<string, number>;
+    tool_call_duration_ms: Record<string, MetricTimingSnapshot>;
+    mapping_resolution_cache_hits: number;
+    mapping_resolution_cache_misses: number;
+    mapping_resolution_cache_size: number;
 }
-type DurationMetricName = keyof Pick<RuntimeMetricSnapshot, "resolve_duration_ms" | "search_duration_ms" | "get_file_duration_ms" | "list_files_duration_ms" | "decompile_duration_ms" | "search_intent_symbol_duration_ms" | "search_intent_text_duration_ms" | "search_intent_path_duration_ms">;
+type DurationMetricName = keyof Pick<RuntimeMetricSnapshot, "resolve_duration_ms" | "search_duration_ms" | "get_file_duration_ms" | "list_files_duration_ms" | "decompile_duration_ms" | "binary_remap_duration_ms" | "search_intent_symbol_duration_ms" | "search_intent_text_duration_ms" | "search_intent_path_duration_ms">;
 export declare class RuntimeMetrics {
     private readonly timings;
     private cacheHits;
@@ -74,6 +80,11 @@ export declare class RuntimeMetrics {
     private cacheEntries;
     private cacheTotalContentBytes;
     private cacheArtifactBytesLruRef;
+    private toolCallCounts;
+    private toolCallTimings;
+    private mappingResolutionCacheHits;
+    private mappingResolutionCacheMisses;
+    private mappingResolutionCacheSize;
     constructor();
     recordDuration(name: DurationMetricName, durationMs: number): void;
     recordArtifactCacheHit(): void;
@@ -97,6 +108,12 @@ export declare class RuntimeMetrics {
     setCacheEntries(entries: number): void;
     setCacheTotalContentBytes(totalBytes: number): void;
     setCacheArtifactByteAccountingRef(entries: ReadonlyArray<CacheArtifactByteAccountingRefRow>): void;
+    recordToolCall(tool: string, durationMs: number): void;
+    setMappingResolutionCacheStats(stats: {
+        hits: number;
+        misses: number;
+        size: number;
+    }): void;
     snapshot(): RuntimeMetricSnapshot;
     private toSnapshot;
     private resolveCacheHitRate;

package/dist/observability.js

@@ -32,6 +32,11 @@ export class RuntimeMetrics {
     cacheEntries = 0;
     cacheTotalContentBytes = 0;
     cacheArtifactBytesLruRef = [];
+    toolCallCounts = new Map();
+    toolCallTimings = new Map();
+    mappingResolutionCacheHits = 0;
+    mappingResolutionCacheMisses = 0;
+    mappingResolutionCacheSize = 0;
     constructor() {
         const names = [
             "resolve_duration_ms",
@@ -39,6 +44,7 @@ export class RuntimeMetrics {
             "get_file_duration_ms",
             "list_files_duration_ms",
             "decompile_duration_ms",
+            "binary_remap_duration_ms",
             "search_intent_symbol_duration_ms",
             "search_intent_text_duration_ms",
             "search_intent_path_duration_ms"
@@ -140,6 +146,27 @@ export class RuntimeMetrics {
     setCacheArtifactByteAccountingRef(entries) {
         this.cacheArtifactBytesLruRef = entries;
     }
+    recordToolCall(tool, durationMs) {
+        this.toolCallCounts.set(tool, (this.toolCallCounts.get(tool) ?? 0) + 1);
+        let timing = this.toolCallTimings.get(tool);
+        if (!timing) {
+            timing = { count: 0, totalMs: 0, lastMs: 0, samples: [] };
+            this.toolCallTimings.set(tool, timing);
+        }
+        const normalizedDuration = Math.max(0, Math.trunc(durationMs));
+        timing.count += 1;
+        timing.totalMs += normalizedDuration;
+        timing.lastMs = normalizedDuration;
+        timing.samples.push(normalizedDuration);
+        if (timing.samples.length > MAX_TIMING_SAMPLES) {
+            timing.samples.shift();
+        }
+    }
+    setMappingResolutionCacheStats(stats) {
+        this.mappingResolutionCacheHits = stats.hits;
+        this.mappingResolutionCacheMisses = stats.misses;
+        this.mappingResolutionCacheSize = stats.size;
+    }
     snapshot() {
         return {
             resolve_duration_ms: this.toSnapshot("resolve_duration_ms"),
@@ -147,6 +174,7 @@ export class RuntimeMetrics {
             get_file_duration_ms: this.toSnapshot("get_file_duration_ms"),
             list_files_duration_ms: this.toSnapshot("list_files_duration_ms"),
             decompile_duration_ms: this.toSnapshot("decompile_duration_ms"),
+            binary_remap_duration_ms: this.toSnapshot("binary_remap_duration_ms"),
             search_intent_symbol_duration_ms: this.toSnapshot("search_intent_symbol_duration_ms"),
             search_intent_text_duration_ms: this.toSnapshot("search_intent_text_duration_ms"),
             search_intent_path_duration_ms: this.toSnapshot("search_intent_path_duration_ms"),
@@ -175,7 +203,22 @@ export class RuntimeMetrics {
                 updated_at: entry.updatedAt
             })),
             cache_hit_rate: this.resolveCacheHitRate(),
-            repo_failover_count: this.repoFailoverCount
+            repo_failover_count: this.repoFailoverCount,
+            tool_call_counts: Object.fromEntries(this.toolCallCounts),
+            tool_call_duration_ms: Object.fromEntries([...this.toolCallTimings].map(([tool, timing]) => [
+                tool,
+                {
+                    count: timing.count,
+                    totalMs: timing.totalMs,
+                    avgMs: timing.count > 0 ? timing.totalMs / timing.count : 0,
+                    lastMs: timing.lastMs,
+                    p95Ms: percentile(timing.samples, 95),
+                    p99Ms: percentile(timing.samples, 99)
+                }
+            ])),
+            mapping_resolution_cache_hits: this.mappingResolutionCacheHits,
+            mapping_resolution_cache_misses: this.mappingResolutionCacheMisses,
+            mapping_resolution_cache_size: this.mappingResolutionCacheSize
         };
     }
     toSnapshot(name) {

package/dist/response-utils.d.ts

@@ -7,29 +7,63 @@
 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>;
+/** Source-oriented tools (get-class-source) that get compactSourceResponse projection. */
+export declare const COMPACT_SOURCE_TOOL_NAMES: Set<string>;
+/** Member-listing tools (get-class-members) that get compactMembersResponse projection. */
+export declare const COMPACT_MEMBERS_TOOL_NAMES: Set<string>;
+/**
+ * Tools that only need the light artifactContents projection (search hits,
+ * file listing). The primary payload is already small; the projection just
+ * drops the artifact-level summary that callers rarely consume.
+ */
+export declare const COMPACT_LIGHT_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;
+/**
+ * Primary-payload keys that compact mode must preserve per tool, even when
+ * the value is an empty array (no hits, no files, no members). Without this
+ * the generic {@link compactResponse} path would strip `hits: []` / `items: []`
+ * from successful zero-result responses and callers could not distinguish
+ * "empty success" from "field missing".
+ *
+ * Only tools whose primary payload can legitimately be an empty array need
+ * an entry here. `get-class-source` returns `sourceText: string` which is
+ * never stripped by compactResponse.
+ */
+export declare const TOOL_PRESERVE_PAYLOAD_KEYS: Record<string, ReadonlySet<string>>;
 /**
  * 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.
+ *
+ * `preserveKeys` names keys whose values MUST survive the strip even if
+ * empty (used by tools whose primary payload is an array that can legitimately
+ * be empty — e.g. zero-hit search, empty file listing). `null` / `undefined`
+ * values are still dropped even for preserved keys, so absent optional
+ * payload fields do not leak through as explicit nulls.
  */
-export declare function compactResponse(obj: Record<string, unknown>): Record<string, unknown>;
+export declare function compactResponse(obj: Record<string, unknown>, preserveKeys?: ReadonlySet<string>): Record<string, unknown>;
 /** resolve-artifact compact: omit debug/diagnostic fields. */
 export declare function compactArtifactResponse(obj: Record<string, unknown>): Record<string, unknown>;
+/** get-class-source compact: drop provenance, artifactContents, qualityFlags. */
+export declare function compactSourceResponse(obj: Record<string, unknown>): Record<string, unknown>;
+/** get-class-members compact: drop provenance, artifactContents, qualityFlags, context. */
+export declare function compactMembersResponse(obj: Record<string, unknown>): Record<string, unknown>;
+/** Light compact projection: drop the artifactContents summary only. */
+export declare function compactLightResponse(obj: Record<string, unknown>): Record<string, unknown>;
 /**
- * Mapping tool compact: omit candidates only when provably redundant.
+ * Mapping tool compact: project candidates for size reduction.
+ *
+ * Resolved-exact path: omit candidates entirely when provably redundant.
+ *   All of: resolved===true, resolvedSymbol exists, single exact candidate, not truncated,
+ *           confidence missing or 1.
  *
- * 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
+ * Unresolved/ambiguous path: keep top {@link UNRESOLVED_FULL_DETAIL_LIMIT} candidates with full
+ *   metadata, slim the tail to {kind,symbol,owner,name,descriptor,confidence,matchKind}, and
+ *   surface `candidatesTruncated:true` + `totalCandidateCount` so the caller knows what it's
+ *   seeing.
  */
 export declare function compactMappingResponse(obj: Record<string, unknown>): Record<string, unknown>;

package/dist/response-utils.js

@@ -9,7 +9,11 @@ export const COMPACT_ENABLED_TOOL_NAMES = new Set([
     "find-mapping",
     "resolve-method-mapping-exact",
     "resolve-workspace-symbol",
-    "check-symbol-exists"
+    "check-symbol-exists",
+    "get-class-source",
+    "get-class-members",
+    "search-class-source",
+    "list-artifact-files"
 ]);
 /** Mapping-oriented tools that get additional field projection via compactMappingResponse. */
 export const COMPACT_MAPPING_TOOL_NAMES = new Set([
@@ -18,6 +22,23 @@ export const COMPACT_MAPPING_TOOL_NAMES = new Set([
     "resolve-workspace-symbol",
     "check-symbol-exists"
 ]);
+/** Source-oriented tools (get-class-source) that get compactSourceResponse projection. */
+export const COMPACT_SOURCE_TOOL_NAMES = new Set([
+    "get-class-source"
+]);
+/** Member-listing tools (get-class-members) that get compactMembersResponse projection. */
+export const COMPACT_MEMBERS_TOOL_NAMES = new Set([
+    "get-class-members"
+]);
+/**
+ * Tools that only need the light artifactContents projection (search hits,
+ * file listing). The primary payload is already small; the projection just
+ * drops the artifact-level summary that callers rarely consume.
+ */
+export const COMPACT_LIGHT_TOOL_NAMES = new Set([
+    "search-class-source",
+    "list-artifact-files"
+]);
 /**
  * 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.
@@ -39,18 +60,44 @@ function isPlainObject(v) {
     const proto = Object.getPrototypeOf(v);
     return proto === Object.prototype || proto === null;
 }
+/**
+ * Primary-payload keys that compact mode must preserve per tool, even when
+ * the value is an empty array (no hits, no files, no members). Without this
+ * the generic {@link compactResponse} path would strip `hits: []` / `items: []`
+ * from successful zero-result responses and callers could not distinguish
+ * "empty success" from "field missing".
+ *
+ * Only tools whose primary payload can legitimately be an empty array need
+ * an entry here. `get-class-source` returns `sourceText: string` which is
+ * never stripped by compactResponse.
+ */
+export const TOOL_PRESERVE_PAYLOAD_KEYS = {
+    "search-class-source": new Set(["hits"]),
+    "list-artifact-files": new Set(["items"]),
+    "get-class-members": new Set(["members", "counts", "decompiledFallback", "decompiledMemberCounts"])
+};
 /**
  * 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.
+ *
+ * `preserveKeys` names keys whose values MUST survive the strip even if
+ * empty (used by tools whose primary payload is an array that can legitimately
+ * be empty — e.g. zero-hit search, empty file listing). `null` / `undefined`
+ * values are still dropped even for preserved keys, so absent optional
+ * payload fields do not leak through as explicit nulls.
  */
-export function compactResponse(obj) {
+export function compactResponse(obj, preserveKeys) {
     if (!isPlainObject(obj))
         return {};
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
         if (value === null || value === undefined)
             continue;
+        if (preserveKeys?.has(key)) {
+            result[key] = value;
+            continue;
+        }
         if (Array.isArray(value) && value.length === 0)
             continue;
         if (isPlainObject(value) && Object.keys(value).length === 0)
@@ -59,6 +106,15 @@ export function compactResponse(obj) {
     }
     return result;
 }
+function projectOmitKeys(obj, omit) {
+    const projected = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (omit.has(key))
+            continue;
+        projected[key] = value;
+    }
+    return projected;
+}
 /** Fields to omit from resolve-artifact in compact mode. */
 const ARTIFACT_COMPACT_OMIT_KEYS = new Set([
     "provenance",
@@ -72,25 +128,69 @@ const ARTIFACT_COMPACT_OMIT_KEYS = new Set([
 ]);
 /** 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 projectOmitKeys(obj, ARTIFACT_COMPACT_OMIT_KEYS);
+}
+/** Fields to omit from get-class-source in compact mode. */
+const SOURCE_COMPACT_OMIT_KEYS = new Set([
+    "provenance",
+    "artifactContents",
+    "qualityFlags"
+]);
+/** get-class-source compact: drop provenance, artifactContents, qualityFlags. */
+export function compactSourceResponse(obj) {
+    return projectOmitKeys(obj, SOURCE_COMPACT_OMIT_KEYS);
+}
+/** Fields to omit from get-class-members in compact mode. */
+const MEMBERS_COMPACT_OMIT_KEYS = new Set([
+    "provenance",
+    "artifactContents",
+    "qualityFlags",
+    "context"
+]);
+/** get-class-members compact: drop provenance, artifactContents, qualityFlags, context. */
+export function compactMembersResponse(obj) {
+    return projectOmitKeys(obj, MEMBERS_COMPACT_OMIT_KEYS);
+}
+/** Fields to omit from search-class-source / list-artifact-files in compact mode. */
+const LIGHT_COMPACT_OMIT_KEYS = new Set([
+    "artifactContents"
+]);
+/** Light compact projection: drop the artifactContents summary only. */
+export function compactLightResponse(obj) {
+    return projectOmitKeys(obj, LIGHT_COMPACT_OMIT_KEYS);
+}
+/** Max number of unresolved candidates that get full metadata in compact mode. */
+const UNRESOLVED_FULL_DETAIL_LIMIT = 3;
+/**
+ * Slim projection of a candidate: retains only identification + confidence fields.
+ *
+ * `kind` and `symbol` are part of the public `SymbolReference` / candidate contract that
+ * clients branch on and use as rendering keys, so they MUST survive the slim. The heavy
+ * fields removed here are the cycle-local diagnostic metadata (provenance, context,
+ * ambiguityReasons, warnings on the candidate, etc.) — not the identity fields.
+ */
+function slimCandidate(candidate) {
+    if (!isPlainObject(candidate))
+        return candidate;
+    const picked = {};
+    for (const key of ["kind", "symbol", "owner", "name", "descriptor", "confidence", "matchKind"]) {
+        if (candidate[key] !== undefined) {
+            picked[key] = candidate[key];
+        }
     }
-    return projected;
+    return picked;
 }
 /**
- * Mapping tool compact: omit candidates only when provably redundant.
+ * Mapping tool compact: project candidates for size reduction.
+ *
+ * Resolved-exact path: omit candidates entirely when provably redundant.
+ *   All of: resolved===true, resolvedSymbol exists, single exact candidate, not truncated,
+ *           confidence missing or 1.
  *
- * 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
+ * Unresolved/ambiguous path: keep top {@link UNRESOLVED_FULL_DETAIL_LIMIT} candidates with full
+ *   metadata, slim the tail to {kind,symbol,owner,name,descriptor,confidence,matchKind}, and
+ *   surface `candidatesTruncated:true` + `totalCandidateCount` so the caller knows what it's
+ *   seeing.
  */
 export function compactMappingResponse(obj) {
     const projected = { ...obj };
@@ -106,8 +206,22 @@ export function compactMappingResponse(obj) {
             candidate.matchKind === "exact" &&
             (candidate.confidence === undefined || candidate.confidence === 1)) {
             delete projected.candidates;
+            return projected;
         }
     }
+    if (projected.resolved === false &&
+        Array.isArray(candidates) &&
+        candidates.length > UNRESOLVED_FULL_DETAIL_LIMIT) {
+        const head = candidates.slice(0, UNRESOLVED_FULL_DETAIL_LIMIT);
+        const tail = candidates.slice(UNRESOLVED_FULL_DETAIL_LIMIT).map(slimCandidate);
+        projected.candidates = [...head, ...tail];
+        // Tail slimming keeps the full candidate array; only metadata was dropped. Use a
+        // dedicated `candidateDetailsTruncated` signal so clients do not confuse it with the
+        // existing `candidatesTruncated` semantics ("more candidates exist than this response
+        // contains"). If the upstream already reported list-level truncation via
+        // `candidatesTruncated`, that value is preserved unchanged.
+        projected.candidateDetailsTruncated = true;
+    }
     return projected;
 }
 //# sourceMappingURL=response-utils.js.map

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

@@ -0,0 +1,4 @@
+import type { SourceService } from "../source-service.js";
+import type { ValidateAccessTransformerInput, ValidateAccessTransformerOutput, ValidateAccessWidenerInput, ValidateAccessWidenerOutput } from "../source-service.js";
+export declare function validateAccessWidener(svc: SourceService, input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
+export declare function validateAccessTransformer(svc: SourceService, input: ValidateAccessTransformerInput): Promise<ValidateAccessTransformerOutput>;

package/dist/source/access-validate.js

@@ -0,0 +1,254 @@
+import { parseAccessTransformer } from "../access-transformer-parser.js";
+import { parseAccessWidener } from "../access-widener-parser.js";
+import { ERROR_CODES, createError } from "../errors.js";
+import { validateParsedAccessTransformer, validateParsedAccessWidener } from "../mixin-validator.js";
+import { normalizeMapping, normalizeOptionalString } from "./shared-utils.js";
+function normalizeAccessWidenerNamespace(namespace) {
+    const normalized = namespace?.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === "named") {
+        return "yarn";
+    }
+    if (normalized === "obfuscated" ||
+        normalized === "mojang" ||
+        normalized === "intermediary" ||
+        normalized === "yarn") {
+        return normalized;
+    }
+    return undefined;
+}
+function isSourceMappingNamespace(namespace) {
+    return (namespace === "obfuscated" ||
+        namespace === "mojang" ||
+        namespace === "intermediary" ||
+        namespace === "yarn");
+}
+export async function validateAccessWidener(svc, input) {
+    const version = input.version.trim();
+    if (!version) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "version must be non-empty." });
+    }
+    const content = input.content;
+    if (!content.trim()) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "content must be non-empty." });
+    }
+    const warnings = [];
+    const parsed = parseAccessWidener(content);
+    const headerNamespaceRaw = normalizeOptionalString(parsed.namespace);
+    const overrideMapping = input.mapping ? normalizeMapping(input.mapping) : undefined;
+    const headerNamespace = normalizeAccessWidenerNamespace(headerNamespaceRaw);
+    if (!headerNamespace && headerNamespaceRaw && !overrideMapping) {
+        warnings.push(`Unsupported access widener namespace "${headerNamespaceRaw}". Assuming intermediary.`);
+    }
+    const awNamespace = overrideMapping ?? headerNamespace ?? "intermediary";
+    if (overrideMapping && headerNamespace && overrideMapping !== headerNamespace) {
+        warnings.push(`Using mapping override "${overrideMapping}" instead of header namespace "${headerNamespaceRaw}".`);
+    }
+    const runtimeAware = input.projectPath != null || input.scope != null || input.preferProjectVersion === true;
+    let resolvedVersion = version;
+    let jarPath;
+    let lookupMapping = "obfuscated";
+    let provenance;
+    if (runtimeAware) {
+        provenance = await svc.resolveAccessWidenerRuntimeArtifact({
+            version,
+            awNamespace,
+            projectPath: input.projectPath,
+            scope: input.scope,
+            preferProjectVersion: input.preferProjectVersion
+        });
+        resolvedVersion = provenance.version;
+        jarPath = provenance.jarPath;
+        lookupMapping = provenance.mappingApplied;
+    }
+    else {
+        ({ jarPath } = await svc.versionService.resolveVersionJar(version));
+    }
+    const needsLookupMapping = awNamespace !== lookupMapping;
+    // Collect unique class FQNs from entries
+    const classFqns = new Set();
+    for (const entry of parsed.entries) {
+        const fqn = entry.target.replace(/\//g, ".");
+        classFqns.add(fqn);
+    }
+    const membersByClass = new Map();
+    for (const fqn of classFqns) {
+        let lookupFqn = fqn;
+        if (needsLookupMapping) {
+            try {
+                const mapped = await svc.mappingService.findMapping({
+                    version: resolvedVersion,
+                    kind: "class",
+                    name: fqn,
+                    sourceMapping: awNamespace,
+                    targetMapping: lookupMapping,
+                    sourcePriority: input.sourcePriority,
+                    projectPath: input.projectPath
+                });
+                if (mapped.resolved && mapped.resolvedSymbol) {
+                    lookupFqn = mapped.resolvedSymbol.name;
+                }
+                else {
+                    warnings.push(`Could not map class "${fqn}" from ${awNamespace} to ${lookupMapping}.`);
+                }
+            }
+            catch {
+                warnings.push(`Mapping lookup failed for class "${fqn}".`);
+            }
+        }
+        try {
+            const sig = await svc.explorerService.getSignature({
+                fqn: lookupFqn,
+                jarPath,
+                access: "all"
+            });
+            warnings.push(...sig.warnings);
+            let constructors = sig.constructors;
+            let methods = sig.methods;
+            let fields = sig.fields;
+            if (needsLookupMapping) {
+                const [ctorResult, methodResult, fieldResult] = await Promise.all([
+                    svc.remapSignatureMembers(sig.constructors, "method", resolvedVersion, lookupMapping, awNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.methods, "method", resolvedVersion, lookupMapping, awNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.fields, "field", resolvedVersion, lookupMapping, awNamespace, input.sourcePriority, warnings, input.projectPath)
+                ]);
+                constructors = ctorResult.members;
+                methods = methodResult.members;
+                fields = fieldResult.members;
+            }
+            membersByClass.set(fqn, {
+                className: fqn,
+                classAccessFlags: sig.classAccessFlags,
+                constructors,
+                methods,
+                fields
+            });
+        }
+        catch {
+            warnings.push(`Could not load signature for class "${lookupFqn}".`);
+        }
+    }
+    const result = validateParsedAccessWidener(parsed, membersByClass, warnings, {
+        includeRuntimeEvidence: runtimeAware
+    });
+    if (provenance) {
+        result.provenance = provenance;
+    }
+    return result;
+}
+export async function validateAccessTransformer(svc, input) {
+    const version = input.version.trim();
+    if (!version) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "version must be non-empty." });
+    }
+    const content = input.content;
+    if (!content.trim()) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "content must be non-empty." });
+    }
+    const warnings = [];
+    const parsed = parseAccessTransformer(content);
+    const atNamespace = await svc.resolveAccessTransformerNamespace({
+        atNamespace: input.atNamespace,
+        projectPath: input.projectPath
+    });
+    const runtimeAware = input.projectPath != null || input.scope != null || input.preferProjectVersion === true;
+    let resolvedVersion = version;
+    let jarPath;
+    let lookupMapping = "obfuscated";
+    let provenance;
+    if (runtimeAware) {
+        provenance = await svc.resolveAccessTransformerRuntimeArtifact({
+            version,
+            atNamespace,
+            projectPath: input.projectPath,
+            scope: input.scope,
+            preferProjectVersion: input.preferProjectVersion
+        });
+        resolvedVersion = provenance.version;
+        jarPath = provenance.jarPath;
+        lookupMapping = provenance.mappingApplied;
+    }
+    else {
+        if (atNamespace === "srg") {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "atNamespace=srg requires projectPath and scope=loader so a Forge runtime jar can be resolved."
+            });
+        }
+        ({ jarPath } = await svc.versionService.resolveVersionJar(version));
+    }
+    const needsLookupMapping = atNamespace !== lookupMapping;
+    const classFqns = new Set(parsed.entries.map((entry) => entry.owner));
+    const membersByClass = new Map();
+    for (const fqn of classFqns) {
+        let lookupFqn = fqn;
+        if (needsLookupMapping) {
+            if (!isSourceMappingNamespace(atNamespace) || !isSourceMappingNamespace(lookupMapping)) {
+                warnings.push(`Could not map class "${fqn}" from ${atNamespace} to ${lookupMapping}.`);
+            }
+            else {
+                try {
+                    const mapped = await svc.mappingService.findMapping({
+                        version: resolvedVersion,
+                        kind: "class",
+                        name: fqn,
+                        sourceMapping: atNamespace,
+                        targetMapping: lookupMapping,
+                        sourcePriority: input.sourcePriority,
+                        projectPath: input.projectPath
+                    });
+                    if (mapped.resolved && mapped.resolvedSymbol) {
+                        lookupFqn = mapped.resolvedSymbol.name;
+                    }
+                    else {
+                        warnings.push(`Could not map class "${fqn}" from ${atNamespace} to ${lookupMapping}.`);
+                    }
+                }
+                catch {
+                    warnings.push(`Mapping lookup failed for class "${fqn}".`);
+                }
+            }
+        }
+        try {
+            const sig = await svc.explorerService.getSignature({
+                fqn: lookupFqn,
+                jarPath,
+                access: "all"
+            });
+            warnings.push(...sig.warnings);
+            let constructors = sig.constructors;
+            let methods = sig.methods;
+            let fields = sig.fields;
+            if (needsLookupMapping && isSourceMappingNamespace(atNamespace) && isSourceMappingNamespace(lookupMapping)) {
+                const [ctorResult, methodResult, fieldResult] = await Promise.all([
+                    svc.remapSignatureMembers(sig.constructors, "method", resolvedVersion, lookupMapping, atNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.methods, "method", resolvedVersion, lookupMapping, atNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.fields, "field", resolvedVersion, lookupMapping, atNamespace, input.sourcePriority, warnings, input.projectPath)
+                ]);
+                constructors = ctorResult.members;
+                methods = methodResult.members;
+                fields = fieldResult.members;
+            }
+            membersByClass.set(fqn, {
+                className: fqn,
+                classAccessFlags: sig.classAccessFlags,
+                constructors,
+                methods,
+                fields
+            });
+        }
+        catch {
+            warnings.push(`Could not load signature for class "${lookupFqn}".`);
+        }
+    }
+    const result = validateParsedAccessTransformer(parsed, membersByClass, warnings, {
+        includeRuntimeEvidence: runtimeAware
+    });
+    if (provenance) {
+        result.provenance = provenance;
+    }
+    return result;
+}
+//# sourceMappingURL=access-validate.js.map