@adhisang/minecraft-modding-mcp 1.2.1 → 2.0.0

package/dist/mapping-service.js

@@ -7,7 +7,7 @@ import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
 import { listJarEntries, readJarEntryAsUtf8 } from "./source-jar-reader.js";
 import { VersionService, isUnobfuscatedVersion } from "./version-service.js";
 const SUPPORTED_MAPPINGS = new Set([
-    "official",
+    "obfuscated",
     "mojang",
     "intermediary",
     "yarn"
@@ -254,7 +254,7 @@ const PROGUARD_PRIMITIVES = {
 /**
  * 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 → official class names (for the official descriptor).
+ * `classLookup` maps mojang class names → obfuscated class names (for the obfuscated descriptor).
  * Pass `undefined` to skip class name translation (for mojang descriptors).
  */
 function proguardTypeToJvm(type, classLookup) {
@@ -294,12 +294,12 @@ function parseProguardMethod(value, classLookup) {
     return { name, descriptor: `(${paramDescriptor})${returnDescriptor}` };
 }
 function parseClientMappings(text) {
-    const officialToMojang = createDirectionIndex();
-    const mojangToOfficial = createDirectionIndex();
+    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 → official)
-    const mojangToOfficialClass = new Map();
+    // Pass 1: collect class name mappings (mojang → obfuscated)
+    const mojangToObfuscatedClass = new Map();
     let classCount = 0;
     for (const rawLine of lines) {
         const line = rawLine.trim();
@@ -309,9 +309,9 @@ function parseClientMappings(text) {
         const classMatch = /^(.+?)\s+->\s+(.+):$/.exec(line);
         if (classMatch) {
             const mojangClass = classMatch[1]?.trim() ?? "";
-            const officialClass = classMatch[2]?.trim() ?? "";
-            if (mojangClass && officialClass) {
-                mojangToOfficialClass.set(mojangClass, officialClass);
+            const obfuscatedClass = classMatch[2]?.trim() ?? "";
+            if (mojangClass && obfuscatedClass) {
+                mojangToObfuscatedClass.set(mojangClass, obfuscatedClass);
                 classCount += 1;
             }
         }
@@ -332,17 +332,17 @@ function parseClientMappings(text) {
         const classMatch = /^(.+?)\s+->\s+(.+):$/.exec(line);
         if (classMatch) {
             const mojangClass = classMatch[1]?.trim() ?? "";
-            const officialClass = classMatch[2]?.trim() ?? "";
-            if (!mojangClass || !officialClass) {
+            const obfuscatedClass = classMatch[2]?.trim() ?? "";
+            if (!mojangClass || !obfuscatedClass) {
                 currentClass = undefined;
                 continue;
             }
             currentClass = {
-                official: officialClass,
+                obfuscated: obfuscatedClass,
                 mojang: mojangClass
             };
-            addLookupEntries(officialToMojang, createClassSymbolRecord(officialClass), createClassSymbolRecord(mojangClass));
-            addLookupEntries(mojangToOfficial, createClassSymbolRecord(mojangClass), createClassSymbolRecord(officialClass));
+            addLookupEntries(obfuscatedToMojang, createClassSymbolRecord(obfuscatedClass), createClassSymbolRecord(mojangClass));
+            addLookupEntries(mojangToObfuscated, createClassSymbolRecord(mojangClass), createClassSymbolRecord(obfuscatedClass));
             continue;
         }
         if (!currentClass) {
@@ -359,31 +359,31 @@ function parseClientMappings(text) {
         }
         const mojangMemberSignature = stripLineInfo(leftRaw);
         // Try method parsing with JVM descriptor
-        const officialMethod = parseProguardMethod(mojangMemberSignature, mojangToOfficialClass);
-        if (officialMethod) {
+        const obfuscatedMethod = parseProguardMethod(mojangMemberSignature, mojangToObfuscatedClass);
+        if (obfuscatedMethod) {
             const mojangMethod = parseProguardMethod(mojangMemberSignature, undefined);
-            const officialDescriptor = officialMethod.descriptor;
+            const obfuscatedDescriptor = obfuscatedMethod.descriptor;
             const mojangDescriptor = mojangMethod?.descriptor;
-            addLookupEntries(officialToMojang, createMethodSymbolRecord(currentClass.official, rightRaw, officialDescriptor), createMethodSymbolRecord(currentClass.mojang, officialMethod.name, mojangDescriptor));
-            addLookupEntries(mojangToOfficial, createMethodSymbolRecord(currentClass.mojang, officialMethod.name, mojangDescriptor), createMethodSymbolRecord(currentClass.official, rightRaw, officialDescriptor));
+            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(officialToMojang, createFieldSymbolRecord(currentClass.official, rightRaw), createFieldSymbolRecord(currentClass.mojang, fieldName));
-        addLookupEntries(mojangToOfficial, createFieldSymbolRecord(currentClass.mojang, fieldName), createFieldSymbolRecord(currentClass.official, rightRaw));
+        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("official", "mojang"), officialToMojang);
-    result.set(pairKey("mojang", "official"), mojangToOfficial);
+    result.set(pairKey("obfuscated", "mojang"), obfuscatedToMojang);
+    result.set(pairKey("mojang", "obfuscated"), mojangToObfuscated);
     return result;
 }
 function normalizeTinyNamespace(namespace) {
     const normalized = namespace.trim().toLowerCase();
-    if (normalized === "official") {
-        return "official";
+    if (normalized === "obfuscated") {
+        return "obfuscated";
     }
     if (normalized === "mojang") {
         return "mojang";
@@ -973,8 +973,8 @@ export class MappingService {
                     sourceMapping,
                     targetMapping,
                     sourcePriority: priority,
-                    nextAction: "Try mapping=official which is always available.",
-                    suggestedCall: { tool: "resolve-artifact", params: { mapping: "official" } }
+                    nextAction: "Try mapping=obfuscated which is always available.",
+                    suggestedCall: { tool: "resolve-artifact", params: { mapping: "obfuscated" } }
                 }
             });
         }
@@ -1000,16 +1000,10 @@ export class MappingService {
                 }
             });
         }
-        if (input.kind !== "method") {
-            throw createError({
-                code: ERROR_CODES.INVALID_INPUT,
-                message: 'resolveMethodMappingExact requires kind="method".',
-                details: {
-                    kind: input.kind
-                }
-            });
-        }
-        const { record: queryRecord, querySymbol } = normalizeQuerySymbol(input);
+        const { record: queryRecord, querySymbol } = normalizeQuerySymbol({
+            ...input,
+            kind: "method"
+        });
         const owner = queryRecord.owner;
         const method = queryRecord.name;
         const descriptor = queryRecord.descriptor;
@@ -1159,7 +1153,7 @@ export class MappingService {
                 classByMapping[mapping] = mapped[0];
             }
         }
-        const baseMapping = classByMapping.official ? "official" : classNameMapping;
+        const baseMapping = classByMapping.obfuscated ? "obfuscated" : classNameMapping;
         const baseClass = classByMapping[baseMapping];
         if (!baseClass) {
             return {
@@ -1167,7 +1161,7 @@ export class MappingService {
                 className,
                 classNameMapping,
                 classIdentity: {
-                    official: classByMapping.official?.symbol,
+                    obfuscated: classByMapping.obfuscated?.symbol,
                     mojang: classByMapping.mojang?.symbol,
                     intermediary: classByMapping.intermediary?.symbol,
                     yarn: classByMapping.yarn?.symbol
@@ -1255,7 +1249,7 @@ export class MappingService {
                 };
                 row[mapping] = entry;
             }
-            row.completeness = Boolean(row.official && row.mojang && row.intermediary && row.yarn);
+            row.completeness = Boolean(row.obfuscated && row.mojang && row.intermediary && row.yarn);
             rows.push(row);
             if (rowHadAmbiguity) {
                 ambiguousRowCount += 1;
@@ -1266,7 +1260,7 @@ export class MappingService {
             className,
             classNameMapping,
             classIdentity: {
-                official: classByMapping.official?.symbol,
+                obfuscated: classByMapping.obfuscated?.symbol,
                 mojang: classByMapping.mojang?.symbol,
                 intermediary: classByMapping.intermediary?.symbol,
                 yarn: classByMapping.yarn?.symbol
@@ -1568,16 +1562,16 @@ export class MappingService {
         if (!tinyAvailable) {
             degradations.push("No intermediary/yarn tiny mappings were found for this version.");
         }
-        // Check if member remap path exists (requestedMapping → official)
+        // Check if member remap path exists (requestedMapping → obfuscated)
         let memberRemapAvailable = false;
-        if (input.requestedMapping === "official") {
+        if (input.requestedMapping === "obfuscated") {
             memberRemapAvailable = true;
         }
         else {
-            const path = namespacePath(graph.pairs, input.requestedMapping, "official");
+            const path = namespacePath(graph.pairs, input.requestedMapping, "obfuscated");
             memberRemapAvailable = path != null && path.length > 1;
             if (!memberRemapAvailable) {
-                degradations.push(`No mapping path from ${input.requestedMapping} to official; member remap will fail.`);
+                degradations.push(`No mapping path from ${input.requestedMapping} to obfuscated; member remap will fail.`);
             }
         }
         return {
@@ -1618,7 +1612,7 @@ export class MappingService {
                 priority,
                 pairs: new Map(),
                 warnings: [
-                    `Version ${version} is unobfuscated; mapping graph is empty (official names are final).`
+                    `Version ${version} is unobfuscated; mapping graph is empty because the runtime already uses deobfuscated names.`
                 ]
             };
         }

package/dist/mcp-helpers.d.ts

@@ -1,5 +1,13 @@
 import type { CallToolResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
-export declare function objectResult<T extends Record<string, unknown>>(data: T): CallToolResult;
+import { type ErrorCode } from "./errors.js";
+type ObjectResultOptions = {
+    isError?: boolean;
+};
+export declare function objectResult<T extends Record<string, unknown>>(data: T, options?: ObjectResultOptions): CallToolResult;
 export declare function textResource(uri: string, value: string): ReadResourceResult;
 export declare function objectResource(uri: string, data: Record<string, unknown>): ReadResourceResult;
-export declare function errorResource(uri: string, message: string): ReadResourceResult;
+export declare function errorResource(uri: string, error: string | {
+    message: string;
+    code?: ErrorCode;
+}): ReadResourceResult;
+export {};

package/dist/mcp-helpers.js

@@ -1,13 +1,67 @@
-export function objectResult(data) {
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+import { ERROR_CODES } from "./errors.js";
+export function objectResult(data, options = {}) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data) }],
+        structuredContent: data,
+        ...(options.isError ? { isError: true } : {})
+    };
 }
 export function textResource(uri, value) {
     return { contents: [{ uri, text: value }] };
 }
 export function objectResource(uri, data) {
-    return { contents: [{ uri, text: JSON.stringify(data) }] };
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                    result: data,
+                    meta: { uri }
+                })
+            }
+        ]
+    };
 }
-export function errorResource(uri, message) {
-    return { contents: [{ uri, text: JSON.stringify({ error: message }) }] };
+function statusForResourceErrorCode(code) {
+    if (code === ERROR_CODES.INVALID_INPUT) {
+        return 400;
+    }
+    if (code === ERROR_CODES.FILE_NOT_FOUND ||
+        code === ERROR_CODES.SOURCE_NOT_FOUND ||
+        code === ERROR_CODES.CLASS_NOT_FOUND ||
+        code === ERROR_CODES.VERSION_NOT_FOUND ||
+        code === ERROR_CODES.JAR_NOT_FOUND) {
+        return 404;
+    }
+    if (code === ERROR_CODES.MAPPING_UNAVAILABLE ||
+        code === ERROR_CODES.MAPPING_NOT_APPLIED ||
+        code === ERROR_CODES.NAMESPACE_MISMATCH) {
+        return 422;
+    }
+    return 500;
+}
+export function errorResource(uri, error) {
+    const detail = typeof error === "string" ? error : error.message;
+    const code = typeof error === "string" ? ERROR_CODES.INVALID_INPUT : error.code ?? ERROR_CODES.INTERNAL;
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                    error: {
+                        type: "https://minecraft-modding-mcp.dev/problems/resource",
+                        title: "Resource read failed",
+                        detail,
+                        status: statusForResourceErrorCode(code),
+                        code,
+                        instance: uri
+                    },
+                    meta: { uri }
+                })
+            }
+        ]
+    };
 }
 //# sourceMappingURL=mcp-helpers.js.map

package/dist/minecraft-explorer-service.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from "./types.js";
-export type MappingNamespace = "official" | "mojang" | "yarn";
+export type MappingNamespace = "obfuscated" | "mojang" | "yarn";
 type SignatureAccess = "public" | "all";
 export interface ResponseContext {
     minecraftVersion: string;

package/dist/minecraft-explorer-service.js

@@ -531,7 +531,7 @@ export class MinecraftExplorerService {
         return {
             minecraftVersion: extractVersionFromPath(jarPath) ?? "unknown",
             mappingType: "unknown",
-            mappingNamespace: "official",
+            mappingNamespace: "obfuscated",
             jarHash: artifactSignatureFromFile(jarPath).sourceArtifactId,
             generatedAt: new Date().toISOString()
         };

package/dist/mixin-validator.js

@@ -161,7 +161,7 @@ function validateInjection(inj, targetMembers, targetNames, issues, resolvedMemb
             const isSigFailed = signatureFailedTargets?.has(targetName);
             const issueConfidence = isRemapFailed ? "uncertain" : confidence;
             const issueConfidenceReason = isRemapFailed
-                ? `Member remap from official→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
+                ? `Member remap from obfuscated→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
                 : confidenceReason;
             const resolutionPath = isRemapFailed
                 ? "member-remap-failed"
@@ -207,7 +207,7 @@ function validateShadow(shadow, targetMembers, targetNames, issues, resolvedMemb
         const isSigFailed = signatureFailedTargets?.has(targetName);
         const issueConfidence = isRemapFailed ? "uncertain" : confidence;
         const issueConfidenceReason = isRemapFailed
-            ? `Member remap from official→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
+            ? `Member remap from obfuscated→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
             : confidenceReason;
         const resolutionPath = isRemapFailed
             ? "member-remap-failed"
@@ -274,7 +274,7 @@ function validateAccessor(accessor, targetMembers, targetNames, issues, resolved
             const isSigFailed = signatureFailedTargets?.has(targetName);
             const issueConfidence = isRemapFailed ? "uncertain" : confidence;
             const issueConfidenceReason = isRemapFailed
-                ? `Member remap from official→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
+                ? `Member remap from obfuscated→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
                 : confidenceReason;
             const resolutionPath = isRemapFailed
                 ? "member-remap-failed"
@@ -323,9 +323,9 @@ export function validateParsedMixin(parsed, targetMembers, warnings, provenance,
                     kind: "target-mapping-failed",
                     annotation: "@Mixin",
                     target: target.className,
-                    message: `Could not map target class "${target.className}" to official namespace; class may still exist under a different mapping.`,
+                    message: `Could not map target class "${target.className}" to obfuscated namespace; class may still exist under a different mapping.`,
                     confidence: "uncertain",
-                    confidenceReason: `Mapping from "${provenance?.requestedMapping}" to official failed for this class.`,
+                    confidenceReason: `Mapping from "${provenance?.requestedMapping}" to obfuscated failed for this class.`,
                     category: "mapping",
                     resolutionPath: "target-mapping-failed",
                     falsePositiveRisk: healthReport?.overallHealthy === false ? "high" : "medium"

package/dist/mojang-tiny-mapping-service.js

@@ -30,13 +30,13 @@ function parseProguardMappings(text) {
         const classMatch = /^(.+?)\s+->\s+(.+):$/.exec(line);
         if (classMatch) {
             const mojangFqn = normalizeFqn(classMatch[1] ?? "");
-            const officialInternal = normalizeInternalName(classMatch[2] ?? "");
-            if (!mojangFqn || !officialInternal) {
+            const obfuscatedInternal = normalizeInternalName(classMatch[2] ?? "");
+            if (!mojangFqn || !obfuscatedInternal) {
                 currentClass = undefined;
                 continue;
             }
             currentClass = mojangFqn;
-            classes.push({ mojangFqn, officialInternal });
+            classes.push({ mojangFqn, obfuscatedInternal });
             continue;
         }
         if (!currentClass) {
@@ -47,14 +47,14 @@ function parseProguardMappings(text) {
             continue;
         }
         const leftRaw = stripLineInfo(line.slice(0, arrowIndex));
-        const officialName = line.slice(arrowIndex + 4).trim();
-        if (!leftRaw || !officialName) {
+        const obfuscatedName = line.slice(arrowIndex + 4).trim();
+        if (!leftRaw || !obfuscatedName) {
             continue;
         }
         members.push({
             ownerMojangFqn: currentClass,
             leftSignature: leftRaw,
-            officialName
+            obfuscatedName
         });
     }
     return { classes, members };
@@ -164,8 +164,8 @@ function normalizeMemberMappings(rawMappings, classMap, warnings) {
     const seen = new Set();
     for (const mapping of rawMappings) {
         for (const member of mapping.members) {
-            const ownerOfficial = classMap.get(normalizeFqn(member.ownerMojangFqn));
-            if (!ownerOfficial) {
+            const ownerObfuscated = classMap.get(normalizeFqn(member.ownerMojangFqn));
+            if (!ownerObfuscated) {
                 warnings.push(`Skipping member mapping for "${member.ownerMojangFqn}" because class mapping is missing.`);
                 continue;
             }
@@ -183,7 +183,7 @@ function normalizeMemberMappings(rawMappings, classMap, warnings) {
                 record = {
                     kind: "m",
                     descriptor,
-                    officialName: member.officialName,
+                    obfuscatedName: member.obfuscatedName,
                     mojangName
                 };
             }
@@ -203,19 +203,19 @@ function normalizeMemberMappings(rawMappings, classMap, warnings) {
                 record = {
                     kind: "f",
                     descriptor,
-                    officialName: member.officialName,
+                    obfuscatedName: member.obfuscatedName,
                     mojangName
                 };
             }
-            const dedupeKey = `${ownerOfficial}|${record.kind}|${record.officialName}|` +
+            const dedupeKey = `${ownerObfuscated}|${record.kind}|${record.obfuscatedName}|` +
                 `${record.mojangName}|${record.descriptor}`;
             if (seen.has(dedupeKey)) {
                 continue;
             }
             seen.add(dedupeKey);
-            const list = membersByOwner.get(ownerOfficial) ?? [];
+            const list = membersByOwner.get(ownerObfuscated) ?? [];
             list.push(record);
-            membersByOwner.set(ownerOfficial, list);
+            membersByOwner.set(ownerObfuscated, list);
         }
     }
     return membersByOwner;
@@ -225,38 +225,38 @@ function mergeClasses(rawMappings, warnings) {
     for (const mapping of rawMappings) {
         for (const clazz of mapping.classes) {
             const mojang = normalizeFqn(clazz.mojangFqn);
-            const official = normalizeInternalName(clazz.officialInternal);
+            const obfuscated = normalizeInternalName(clazz.obfuscatedInternal);
             const existing = classMap.get(mojang);
-            if (existing && existing !== official) {
-                warnings.push(`Conflicting class mapping for "${mojang}" (${existing} vs ${official}); keeping first.`);
+            if (existing && existing !== obfuscated) {
+                warnings.push(`Conflicting class mapping for "${mojang}" (${existing} vs ${obfuscated}); keeping first.`);
                 continue;
             }
-            classMap.set(mojang, official);
+            classMap.set(mojang, obfuscated);
         }
     }
     return classMap;
 }
 function renderTinyV2(classMap, membersByOwner) {
     const classEntries = [...classMap.entries()]
-        .map(([mojangFqn, officialInternal]) => ({
-        officialInternal,
+        .map(([mojangFqn, obfuscatedInternal]) => ({
+        obfuscatedInternal,
         mojangInternal: mojangFqn.replace(/\./g, "/")
     }))
-        .sort((left, right) => left.officialInternal.localeCompare(right.officialInternal));
-    const lines = ["tiny\t2\t0\tofficial\tmojang"];
+        .sort((left, right) => left.obfuscatedInternal.localeCompare(right.obfuscatedInternal));
+    const lines = ["tiny\t2\t0\tobfuscated\tmojang"];
     for (const entry of classEntries) {
-        lines.push(`c\t${entry.officialInternal}\t${entry.mojangInternal}`);
-        const members = [...(membersByOwner.get(entry.officialInternal) ?? [])].sort((left, right) => {
+        lines.push(`c\t${entry.obfuscatedInternal}\t${entry.mojangInternal}`);
+        const members = [...(membersByOwner.get(entry.obfuscatedInternal) ?? [])].sort((left, right) => {
             if (left.kind !== right.kind) {
                 return left.kind.localeCompare(right.kind);
             }
-            if (left.officialName !== right.officialName) {
-                return left.officialName.localeCompare(right.officialName);
+            if (left.obfuscatedName !== right.obfuscatedName) {
+                return left.obfuscatedName.localeCompare(right.obfuscatedName);
             }
             return left.descriptor.localeCompare(right.descriptor);
         });
         for (const member of members) {
-            lines.push(`\t${member.kind}\t${member.descriptor}\t${member.officialName}\t${member.mojangName}`);
+            lines.push(`\t${member.kind}\t${member.descriptor}\t${member.obfuscatedName}\t${member.mojangName}`);
         }
     }
     return `${lines.join("\n")}\n`;

package/dist/resources.js

@@ -30,7 +30,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });
@@ -41,7 +41,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });
@@ -56,7 +56,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });
@@ -70,7 +70,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });
@@ -87,7 +87,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });
@@ -101,7 +101,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });
@@ -112,7 +112,7 @@ export function registerResources(server, sourceService) {
         }
         catch (e) {
             if (isAppError(e))
-                return errorResource(uri.href, e.message);
+                return errorResource(uri.href, { message: e.message, code: e.code });
             throw e;
         }
     });

package/dist/search-hit-accumulator.d.ts

@@ -9,9 +9,6 @@ export type SearchSourceHit = {
     filePath: string;
     score: number;
     matchedIn: "symbol" | "path" | "content";
-    startLine: number;
-    endLine: number;
-    snippet: string;
     reasonCodes: string[];
     symbol?: SearchResultSymbol;
 };

package/dist/search-hit-accumulator.js

@@ -12,8 +12,8 @@ export function scoreHitOrder(left, right) {
     if (symbolCompare !== 0) {
         return symbolCompare;
     }
-    const leftLine = left.symbol?.line ?? left.startLine;
-    const rightLine = right.symbol?.line ?? right.startLine;
+    const leftLine = left.symbol?.line ?? 0;
+    const rightLine = right.symbol?.line ?? 0;
     return leftLine - rightLine;
 }
 export function encodeSearchCursor(hit, contextKey) {
@@ -21,7 +21,7 @@ export function encodeSearchCursor(hit, contextKey) {
         score: hit.score,
         filePath: hit.filePath,
         symbolName: hit.symbol?.symbolName ?? "",
-        line: hit.symbol?.line ?? hit.startLine,
+        line: hit.symbol?.line ?? 0,
         contextKey
     }), "utf8").toString("base64");
 }
@@ -66,7 +66,7 @@ export function isAfterSearchCursor(hit, cursor) {
     if (symbolCompare < 0) {
         return false;
     }
-    const hitLine = hit.symbol?.line ?? hit.startLine;
+    const hitLine = hit.symbol?.line ?? 0;
     return hitLine > cursor.line;
 }
 /**

package/dist/source-resolver.d.ts

@@ -1,6 +1,7 @@
 import type { Config, ResolvedSourceArtifact, SourceTargetInput } from "./types.js";
 export interface ResolveSourceTargetOptions {
     allowDecompile: boolean;
+    preferBinaryOnly?: boolean;
     preferredRepos?: string[];
     onRepoFailover?: (event: {
         stage: "source" | "binary";