@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.1

package/dist/mapping/parsers/proguard.js

@@ -0,0 +1,138 @@
+import { ERROR_CODES, createError } from "../../errors.js";
+import { addLookupEntries, createClassSymbolRecord, createDirectionIndex, createFieldSymbolRecord, createMethodSymbolRecord, parseFieldName, stripLineInfo } from "./symbol-records.js";
+import { pairKey } from "./normalize.js";
+/** Map of proguard primitive type names to JVM type characters. */
+export const PROGUARD_PRIMITIVES = {
+    void: "V", boolean: "Z", byte: "B", char: "C",
+    short: "S", int: "I", long: "J", float: "F", double: "D"
+};
+/**
+ * Convert a single proguard type (e.g. "int", "net.minecraft.Foo", "int[][]")
+ * to JVM notation (e.g. "I", "Lnet/minecraft/Foo;", "[[I").
+ * `classLookup` maps mojang class names → obfuscated class names (for the obfuscated descriptor).
+ * Pass `undefined` to skip class name translation (for mojang descriptors).
+ */
+export function proguardTypeToJvm(type, classLookup) {
+    let arrayDepth = 0;
+    let base = type;
+    while (base.endsWith("[]")) {
+        arrayDepth += 1;
+        base = base.slice(0, -2);
+    }
+    const prefix = "[".repeat(arrayDepth);
+    const primitive = PROGUARD_PRIMITIVES[base];
+    if (primitive) {
+        return `${prefix}${primitive}`;
+    }
+    const translated = classLookup ? (classLookup.get(base) ?? base) : base;
+    return `${prefix}L${translated.replace(/\./g, "/")};`;
+}
+/**
+ * Parse a proguard method signature (after stripLineInfo) into a JVM descriptor.
+ * Input format: "returnType methodName(paramType1,paramType2,...)"
+ * Returns `{ name, descriptor }` or `undefined` if parsing fails.
+ */
+export function parseProguardMethod(value, classLookup) {
+    const match = /^(.+?)\s+([^\s(]+)\((.*)\)$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    const returnType = match[1].trim();
+    const name = match[2].trim();
+    const params = match[3].trim();
+    if (!name) {
+        return undefined;
+    }
+    const paramParts = params ? params.split(",").map((p) => p.trim()) : [];
+    const paramDescriptor = paramParts.map((p) => proguardTypeToJvm(p, classLookup)).join("");
+    const returnDescriptor = proguardTypeToJvm(returnType, classLookup);
+    return { name, descriptor: `(${paramDescriptor})${returnDescriptor}` };
+}
+export function parseClientMappings(text) {
+    const obfuscatedToMojang = createDirectionIndex();
+    const mojangToObfuscated = createDirectionIndex();
+    // Two-pass parsing: first collect class name mappings, then parse members with descriptors.
+    const lines = text.split(/\r?\n/);
+    // Pass 1: collect class name mappings (mojang → obfuscated)
+    const mojangToObfuscatedClass = new Map();
+    let classCount = 0;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const classMatch = /^(.+?)\s+->\s+(.+):$/.exec(line);
+        if (classMatch) {
+            const mojangClass = classMatch[1]?.trim() ?? "";
+            const obfuscatedClass = classMatch[2]?.trim() ?? "";
+            if (mojangClass && obfuscatedClass) {
+                mojangToObfuscatedClass.set(mojangClass, obfuscatedClass);
+                classCount += 1;
+            }
+        }
+    }
+    if (classCount === 0) {
+        throw createError({
+            code: ERROR_CODES.MAPPING_UNAVAILABLE,
+            message: "No class mappings could be parsed from client mappings."
+        });
+    }
+    // Pass 2: build full index with descriptors
+    let currentClass;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const classMatch = /^(.+?)\s+->\s+(.+):$/.exec(line);
+        if (classMatch) {
+            const mojangClass = classMatch[1]?.trim() ?? "";
+            const obfuscatedClass = classMatch[2]?.trim() ?? "";
+            if (!mojangClass || !obfuscatedClass) {
+                currentClass = undefined;
+                continue;
+            }
+            currentClass = {
+                obfuscated: obfuscatedClass,
+                mojang: mojangClass
+            };
+            addLookupEntries(obfuscatedToMojang, createClassSymbolRecord(obfuscatedClass), createClassSymbolRecord(mojangClass));
+            addLookupEntries(mojangToObfuscated, createClassSymbolRecord(mojangClass), createClassSymbolRecord(obfuscatedClass));
+            continue;
+        }
+        if (!currentClass) {
+            continue;
+        }
+        const arrowIndex = line.indexOf(" -> ");
+        if (arrowIndex < 0) {
+            continue;
+        }
+        const leftRaw = line.slice(0, arrowIndex).trim();
+        const rightRaw = line.slice(arrowIndex + 4).trim();
+        if (!leftRaw || !rightRaw) {
+            continue;
+        }
+        const mojangMemberSignature = stripLineInfo(leftRaw);
+        // Try method parsing with JVM descriptor
+        const obfuscatedMethod = parseProguardMethod(mojangMemberSignature, mojangToObfuscatedClass);
+        if (obfuscatedMethod) {
+            const mojangMethod = parseProguardMethod(mojangMemberSignature, undefined);
+            const obfuscatedDescriptor = obfuscatedMethod.descriptor;
+            const mojangDescriptor = mojangMethod?.descriptor;
+            addLookupEntries(obfuscatedToMojang, createMethodSymbolRecord(currentClass.obfuscated, rightRaw, obfuscatedDescriptor), createMethodSymbolRecord(currentClass.mojang, obfuscatedMethod.name, mojangDescriptor));
+            addLookupEntries(mojangToObfuscated, createMethodSymbolRecord(currentClass.mojang, obfuscatedMethod.name, mojangDescriptor), createMethodSymbolRecord(currentClass.obfuscated, rightRaw, obfuscatedDescriptor));
+            continue;
+        }
+        const fieldName = parseFieldName(mojangMemberSignature);
+        if (!fieldName) {
+            continue;
+        }
+        addLookupEntries(obfuscatedToMojang, createFieldSymbolRecord(currentClass.obfuscated, rightRaw), createFieldSymbolRecord(currentClass.mojang, fieldName));
+        addLookupEntries(mojangToObfuscated, createFieldSymbolRecord(currentClass.mojang, fieldName), createFieldSymbolRecord(currentClass.obfuscated, rightRaw));
+    }
+    const result = new Map();
+    result.set(pairKey("obfuscated", "mojang"), obfuscatedToMojang);
+    result.set(pairKey("mojang", "obfuscated"), mojangToObfuscated);
+    return result;
+}
+//# sourceMappingURL=proguard.js.map

package/dist/mapping/parsers/symbol-records.d.ts

@@ -0,0 +1,27 @@
+import type { DirectionIndex, MappingSymbolRecord } from "../internal-types.js";
+export declare function createDirectionIndex(): DirectionIndex;
+export declare function addToSetMap(map: Map<string, Set<string>>, key: string, value: string): void;
+export declare function normalizedVariants(symbol: string): string[];
+export declare function simpleName(symbol: string): string | undefined;
+export declare function normalizeMappedSymbolOutput(symbol: string): string;
+export declare function splitOwnerAndName(symbol: string): {
+    owner: string;
+    name: string;
+} | undefined;
+export declare function stripLineInfo(input: string): string;
+export declare function parseMethodName(value: string): string | undefined;
+export declare function parseFieldName(value: string): string | undefined;
+export declare function buildSymbolKey(record: MappingSymbolRecord): string;
+export declare function classNameParts(classFqn: string): {
+    owner?: string;
+    name: string;
+};
+export declare function createClassSymbolRecord(className: string): MappingSymbolRecord;
+export declare function createFieldSymbolRecord(owner: string, fieldName: string): MappingSymbolRecord;
+export declare function createMethodSymbolRecord(owner: string, methodName: string, descriptor: string | undefined): MappingSymbolRecord;
+export declare function parseInputSymbol(symbol: string): MappingSymbolRecord | undefined;
+export declare function exactLookupKeys(record: MappingSymbolRecord): string[];
+export declare function simpleLookupKeys(record: MappingSymbolRecord): string[];
+export declare function registerRecord(index: DirectionIndex, record: MappingSymbolRecord): string;
+export declare function addLookupEntries(index: DirectionIndex, fromRecord: MappingSymbolRecord, toRecord: MappingSymbolRecord): void;
+export declare function mergeDirectionIndexes(target: DirectionIndex, source: DirectionIndex): void;

package/dist/mapping/parsers/symbol-records.js

@@ -0,0 +1,216 @@
+export function createDirectionIndex() {
+    return {
+        exact: new Map(),
+        normalized: new Map(),
+        simple: new Map(),
+        records: new Map()
+    };
+}
+export function addToSetMap(map, key, value) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey) {
+        return;
+    }
+    const existing = map.get(normalizedKey) ?? new Set();
+    existing.add(value);
+    map.set(normalizedKey, existing);
+}
+export function normalizedVariants(symbol) {
+    const variants = [symbol];
+    let dotted;
+    if (symbol.includes("/")) {
+        dotted = symbol.replace(/\//g, ".");
+        if (dotted !== symbol) {
+            variants.push(dotted);
+        }
+    }
+    if (symbol.includes(".")) {
+        const slashed = symbol.replace(/\./g, "/");
+        if (slashed !== symbol && slashed !== dotted) {
+            variants.push(slashed);
+        }
+    }
+    return variants;
+}
+export function simpleName(symbol) {
+    const trimmed = symbol.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const withoutDescriptor = trimmed.includes("(") ? trimmed.slice(0, trimmed.indexOf("(")) : trimmed;
+    const base = withoutDescriptor.split(/[./]/).at(-1)?.trim();
+    return base || undefined;
+}
+export function normalizeMappedSymbolOutput(symbol) {
+    return symbol.replace(/\//g, ".");
+}
+export function splitOwnerAndName(symbol) {
+    const trimmed = symbol.trim();
+    const separatorIndex = Math.max(trimmed.lastIndexOf("."), trimmed.lastIndexOf("/"));
+    if (separatorIndex <= 0 || separatorIndex >= trimmed.length - 1) {
+        return undefined;
+    }
+    return {
+        owner: trimmed.slice(0, separatorIndex),
+        name: trimmed.slice(separatorIndex + 1)
+    };
+}
+export function stripLineInfo(input) {
+    let value = input.trim();
+    while (/^\d+:\d+:/.test(value)) {
+        value = value.replace(/^\d+:\d+:/, "");
+    }
+    return value.replace(/:\d+:\d+$/, "").trim();
+}
+export function parseMethodName(value) {
+    const match = /^(.+?)\s+([^\s(]+)\((.*)\)$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    return match[2]?.trim() || undefined;
+}
+export function parseFieldName(value) {
+    const match = /^(.+?)\s+([^\s]+)$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    return match[2]?.trim() || undefined;
+}
+export function buildSymbolKey(record) {
+    return `${record.kind}|${record.owner ?? ""}|${record.name}|${record.descriptor ?? ""}`;
+}
+export function classNameParts(classFqn) {
+    const separatorIndex = classFqn.lastIndexOf(".");
+    if (separatorIndex <= 0 || separatorIndex >= classFqn.length - 1) {
+        return {
+            owner: undefined,
+            name: classFqn
+        };
+    }
+    return {
+        owner: classFqn.slice(0, separatorIndex),
+        name: classFqn.slice(separatorIndex + 1)
+    };
+}
+export function createClassSymbolRecord(className) {
+    const symbol = normalizeMappedSymbolOutput(className.trim());
+    const parts = classNameParts(symbol);
+    return {
+        kind: "class",
+        symbol,
+        owner: parts.owner,
+        name: parts.name
+    };
+}
+export function createFieldSymbolRecord(owner, fieldName) {
+    const normalizedOwner = normalizeMappedSymbolOutput(owner.trim());
+    const normalizedName = fieldName.trim();
+    return {
+        kind: "field",
+        symbol: `${normalizedOwner}.${normalizedName}`,
+        owner: normalizedOwner,
+        name: normalizedName
+    };
+}
+export function createMethodSymbolRecord(owner, methodName, descriptor) {
+    const normalizedOwner = normalizeMappedSymbolOutput(owner.trim());
+    const normalizedName = methodName.trim();
+    const normalizedDescriptor = descriptor?.trim() || undefined;
+    return {
+        kind: "method",
+        symbol: `${normalizedOwner}.${normalizedName}${normalizedDescriptor ?? ""}`,
+        owner: normalizedOwner,
+        name: normalizedName,
+        descriptor: normalizedDescriptor
+    };
+}
+export function parseInputSymbol(symbol) {
+    const trimmed = symbol.trim();
+    if (!trimmed || /\s/.test(trimmed)) {
+        return undefined;
+    }
+    const openIndex = trimmed.indexOf("(");
+    if (openIndex >= 0) {
+        const closeIndex = trimmed.indexOf(")", openIndex);
+        if (closeIndex < 0) {
+            return undefined;
+        }
+        const ownerAndMethod = splitOwnerAndName(trimmed.slice(0, openIndex));
+        if (!ownerAndMethod) {
+            return undefined;
+        }
+        const descriptor = trimmed.slice(openIndex);
+        return createMethodSymbolRecord(ownerAndMethod.owner, ownerAndMethod.name, descriptor);
+    }
+    const ownerAndName = splitOwnerAndName(trimmed);
+    if (!ownerAndName) {
+        return createClassSymbolRecord(trimmed);
+    }
+    if (/^[A-Z$]/.test(ownerAndName.name)) {
+        return createClassSymbolRecord(trimmed);
+    }
+    return createFieldSymbolRecord(ownerAndName.owner, ownerAndName.name);
+}
+export function exactLookupKeys(record) {
+    const keys = new Set([record.symbol]);
+    if (record.kind === "method" && record.owner && record.descriptor) {
+        keys.add(`${record.owner}.${record.name}`);
+    }
+    return [...keys];
+}
+export function simpleLookupKeys(record) {
+    if (record.kind === "class") {
+        return [record.name];
+    }
+    if (record.kind === "field") {
+        return [record.name];
+    }
+    if (record.descriptor) {
+        return [record.name, `${record.name}${record.descriptor}`];
+    }
+    return [record.name];
+}
+export function registerRecord(index, record) {
+    const key = buildSymbolKey(record);
+    if (!index.records.has(key)) {
+        index.records.set(key, record);
+    }
+    return key;
+}
+export function addLookupEntries(index, fromRecord, toRecord) {
+    if (!fromRecord.symbol || !toRecord.symbol) {
+        return;
+    }
+    const targetKey = registerRecord(index, toRecord);
+    for (const key of exactLookupKeys(fromRecord)) {
+        addToSetMap(index.exact, key, targetKey);
+        for (const variant of normalizedVariants(key)) {
+            if (variant !== key) {
+                addToSetMap(index.normalized, variant, targetKey);
+            }
+        }
+    }
+    for (const key of simpleLookupKeys(fromRecord)) {
+        addToSetMap(index.simple, key, targetKey);
+    }
+}
+export function mergeDirectionIndexes(target, source) {
+    const mergeMap = (targetMap, sourceMap) => {
+        for (const [key, values] of sourceMap.entries()) {
+            const existing = targetMap.get(key) ?? new Set();
+            for (const value of values) {
+                existing.add(value);
+            }
+            targetMap.set(key, existing);
+        }
+    };
+    mergeMap(target.exact, source.exact);
+    mergeMap(target.normalized, source.normalized);
+    mergeMap(target.simple, source.simple);
+    for (const [key, value] of source.records.entries()) {
+        if (!target.records.has(key)) {
+            target.records.set(key, value);
+        }
+    }
+}
+//# sourceMappingURL=symbol-records.js.map

package/dist/mapping/parsers/tiny.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tiny v2 mapping format parser. Pure; extracted from
+ * `src/mapping-service.ts`.
+ */
+import type { SourceMapping } from "../../types.js";
+import type { DirectionIndex, MappingSymbolRecord, PairKey } from "../internal-types.js";
+export declare function normalizeTinyNamespace(namespace: string): SourceMapping | undefined;
+export declare function addPairRecords(target: Map<PairKey, DirectionIndex>, records: Map<SourceMapping, MappingSymbolRecord>): void;
+export declare function parseTinyMappings(text: string): Map<PairKey, DirectionIndex>;

package/dist/mapping/parsers/tiny.js

@@ -0,0 +1,96 @@
+/**
+ * Tiny v2 mapping format parser. Pure; extracted from
+ * `src/mapping-service.ts`.
+ */
+import { addLookupEntries, createClassSymbolRecord, createFieldSymbolRecord, createMethodSymbolRecord } from "./symbol-records.js";
+import { ensurePairIndex } from "./normalize.js";
+export function normalizeTinyNamespace(namespace) {
+    const normalized = namespace.trim().toLowerCase();
+    if (normalized === "obfuscated" || normalized === "official") {
+        return "obfuscated";
+    }
+    if (normalized === "mojang") {
+        return "mojang";
+    }
+    if (normalized === "intermediary") {
+        return "intermediary";
+    }
+    if (normalized === "named" || normalized === "yarn") {
+        return "yarn";
+    }
+    return undefined;
+}
+export function addPairRecords(target, records) {
+    for (const [sourceMapping, sourceRecord] of records.entries()) {
+        for (const [targetMapping, targetRecord] of records.entries()) {
+            if (sourceMapping === targetMapping) {
+                continue;
+            }
+            addLookupEntries(ensurePairIndex(target, sourceMapping, targetMapping), sourceRecord, targetRecord);
+        }
+    }
+}
+export function parseTinyMappings(text) {
+    const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+        return new Map();
+    }
+    const header = lines[0].split("\t");
+    if (header.length < 5 || header[0] !== "tiny" || header[1] !== "2") {
+        return new Map();
+    }
+    const namespaceColumns = header.slice(3).map((namespace, index) => ({
+        mapping: normalizeTinyNamespace(namespace),
+        columnIndex: index + 1
+    }));
+    const recognized = namespaceColumns.filter((entry) => entry.mapping != null);
+    if (recognized.length < 2) {
+        return new Map();
+    }
+    const result = new Map();
+    const currentClassNames = new Map();
+    for (const line of lines.slice(1)) {
+        const columns = line.split("\t");
+        if (columns[0] === "c") {
+            const classRecords = new Map();
+            for (const namespace of recognized) {
+                const value = columns[namespace.columnIndex]?.trim() ?? "";
+                if (!value) {
+                    continue;
+                }
+                currentClassNames.set(namespace.mapping, value);
+                classRecords.set(namespace.mapping, createClassSymbolRecord(value));
+            }
+            addPairRecords(result, classRecords);
+            continue;
+        }
+        if (columns[0] === "" && columns[1] === "f") {
+            const fieldRecords = new Map();
+            for (const namespace of recognized) {
+                const owner = currentClassNames.get(namespace.mapping);
+                const value = columns[namespace.columnIndex + 2]?.trim() ?? "";
+                if (!owner || !value) {
+                    continue;
+                }
+                fieldRecords.set(namespace.mapping, createFieldSymbolRecord(owner, value));
+            }
+            addPairRecords(result, fieldRecords);
+            continue;
+        }
+        if (columns[0] === "" && columns[1] === "m") {
+            const descriptor = columns[2]?.trim() || undefined;
+            const methodRecords = new Map();
+            for (const namespace of recognized) {
+                const owner = currentClassNames.get(namespace.mapping);
+                const value = columns[namespace.columnIndex + 2]?.trim() ?? "";
+                if (!owner || !value) {
+                    continue;
+                }
+                methodRecords.set(namespace.mapping, createMethodSymbolRecord(owner, value, descriptor));
+            }
+            addPairRecords(result, methodRecords);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=tiny.js.map

package/dist/mapping/types.d.ts

@@ -0,0 +1,147 @@
+import type { MappingSourcePriority, SourceMapping } from "../types.js";
+import type { MappingLookupSource, MappingSymbolKind } from "./internal-types.js";
+export type MappingMatchKind = "exact" | "normalized" | "simple-name";
+export type MappingLookupCandidate = {
+    symbol: string;
+    matchKind: MappingMatchKind;
+    confidence: number;
+    kind: MappingSymbolKind;
+    owner?: string;
+    name: string;
+    descriptor?: string;
+};
+export type MappingLookupProvenance = {
+    source: MappingLookupSource;
+    mappingArtifact: string;
+    version: string;
+    priority: MappingSourcePriority;
+};
+export type SymbolQueryKind = MappingSymbolKind;
+export type SymbolQueryInput = {
+    kind: SymbolQueryKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+};
+export type SymbolReference = {
+    kind: SymbolQueryKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+    symbol: string;
+};
+export type SymbolResolutionStatus = "resolved" | "not_found" | "ambiguous" | "mapping_unavailable";
+export type SymbolResolutionOutput = {
+    querySymbol: SymbolReference;
+    mappingContext: {
+        version: string;
+        sourceMapping: SourceMapping;
+        targetMapping?: SourceMapping;
+        sourcePriorityApplied: MappingSourcePriority;
+    };
+    resolved: boolean;
+    status: SymbolResolutionStatus;
+    resolvedSymbol?: SymbolReference;
+    candidates: Array<SymbolReference & Pick<MappingLookupCandidate, "matchKind" | "confidence">>;
+    candidateCount: number;
+    candidatesTruncated?: boolean;
+    warnings: string[];
+    provenance?: MappingLookupProvenance;
+    ambiguityReasons?: string[];
+};
+export type FindMappingInput = {
+    version: string;
+    kind: SymbolQueryKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+    signatureMode?: "exact" | "name-only";
+    sourceMapping: SourceMapping;
+    targetMapping: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    disambiguation?: {
+        ownerHint?: string;
+        descriptorHint?: string;
+    };
+    maxCandidates?: number;
+};
+export type FindMappingOutput = SymbolResolutionOutput;
+export type EnsureMappingAvailableInput = {
+    version: string;
+    sourceMapping: SourceMapping;
+    targetMapping: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+};
+export type EnsureMappingAvailableOutput = {
+    transformChain: string[];
+    warnings: string[];
+    provenance?: MappingLookupProvenance;
+};
+export type ResolveMethodMappingExactInput = {
+    version: string;
+    name: string;
+    owner: string;
+    descriptor: string;
+    sourceMapping: SourceMapping;
+    targetMapping: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    maxCandidates?: number;
+};
+export type ResolveMethodMappingExactOutput = SymbolResolutionOutput;
+export type ClassApiMatrixKind = "class" | "field" | "method";
+export type ClassApiMatrixInput = {
+    version: string;
+    className: string;
+    classNameMapping: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    includeKinds?: ClassApiMatrixKind[];
+    maxRows?: number;
+};
+export type ClassApiMatrixEntry = {
+    symbol: string;
+    owner?: string;
+    name: string;
+    descriptor?: string;
+};
+export type ClassApiMatrixRow = {
+    kind: ClassApiMatrixKind;
+    descriptor?: string;
+    obfuscated?: ClassApiMatrixEntry;
+    mojang?: ClassApiMatrixEntry;
+    intermediary?: ClassApiMatrixEntry;
+    yarn?: ClassApiMatrixEntry;
+    completeness: boolean;
+};
+export type ClassApiMatrixOutput = {
+    version: string;
+    className: string;
+    classNameMapping: SourceMapping;
+    classIdentity: Partial<Record<SourceMapping, string>>;
+    rows: ClassApiMatrixRow[];
+    rowCount: number;
+    rowsTruncated?: boolean;
+    warnings: string[];
+    ambiguousRowCount?: number;
+};
+export type SymbolExistenceInput = {
+    version: string;
+    kind: SymbolQueryKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+    sourceMapping: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    nameMode?: "fqcn" | "auto";
+    signatureMode?: "exact" | "name-only";
+    maxCandidates?: number;
+};
+export type SymbolExistenceOutput = SymbolResolutionOutput;
+export type ResolutionCandidate = SymbolReference & Pick<MappingLookupCandidate, "matchKind" | "confidence">;
+export type DescriptorProjection = {
+    descriptor: string;
+    hadClassReferences: boolean;
+    complete: boolean;
+};

package/dist/mapping/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/mapping-pipeline-service.js

@@ -1,3 +1,4 @@
+import { buildSuggestedCall } from "./build-suggested-call.js";
 import { createError, ERROR_CODES } from "./errors.js";
 /**
  * Mapping pipeline for v0.3.
@@ -74,13 +75,13 @@ export function applyMappingPipeline(input) {
                 binaryJarPath: input.resolved.binaryJarPath,
                 sourceJarPath: input.resolved.sourceJarPath,
                 nextAction: "Provide a source-backed artifact (source jar) or use mapping=obfuscated.",
-                suggestedCall: {
+                ...buildSuggestedCall({
                     tool: "resolve-artifact",
                     params: {
                         target: input.target,
                         mapping: "obfuscated"
                     }
-                }
+                })
             }
         });
     }