@adhisang/minecraft-modding-mcp 5.0.0 → 6.1.0

package/dist/nbt/json-patch.js

@@ -1,6 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { createError, ERROR_CODES } from "../errors.js";
-import { assertValidTypedNbtDocument, validateTypedNbtDocument } from "./typed-json.js";
+import { assertValidTypedNbtDocument, validateTypedNbtDocument, validateTypedNbtNode } from "./typed-json.js";
 function isRecord(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -136,6 +136,9 @@ function parseArrayIndex(token, length, options) {
     }
     return index;
 }
+function isTypedNbtNode(value) {
+    return isRecord(value) && typeof value.type === "string";
+}
 function resolveParent(root, tokens, opIndex, path) {
     if (tokens.length === 0) {
         patchConflict("Operation path does not reference a child location.", {
@@ -144,6 +147,8 @@ function resolveParent(root, tokens, opIndex, path) {
         });
     }
     let cursor = root;
+    let enclosingNode;
+    let enclosingPointer = "";
     for (let i = 0; i < tokens.length - 1; i += 1) {
         const token = tokens[i];
         const pointer = `/${tokens.slice(0, i + 1).join("/")}`;
@@ -154,6 +159,10 @@ function resolveParent(root, tokens, opIndex, path) {
                 path: pointer
             });
             cursor = cursor[index];
+            if (isTypedNbtNode(cursor)) {
+                enclosingNode = cursor;
+                enclosingPointer = pointer;
+            }
             continue;
         }
         if (!isRecord(cursor)) {
@@ -169,8 +178,12 @@ function resolveParent(root, tokens, opIndex, path) {
             });
         }
         cursor = cursor[token];
+        if (isTypedNbtNode(cursor)) {
+            enclosingNode = cursor;
+            enclosingPointer = pointer;
+        }
     }
-    return { parent: cursor, key: tokens[tokens.length - 1] };
+    return { parent: cursor, key: tokens[tokens.length - 1], enclosingNode, enclosingPointer };
 }
 function readValueAtPath(root, tokens, opIndex, path) {
     if (tokens.length === 0) {
@@ -205,8 +218,10 @@ function readValueAtPath(root, tokens, opIndex, path) {
     }
     return cursor;
 }
-function assertTypedNbtInvariant(root, opIndex, path) {
-    const validation = validateTypedNbtDocument(root);
+function assertTypedNbtInvariant(subtree, opIndex, path) {
+    const validation = "root" in subtree
+        ? validateTypedNbtDocument(subtree.root)
+        : validateTypedNbtNode(subtree.node, subtree.pointer);
     if (!validation.ok) {
         patchConflict("JSON Patch operation produced invalid typed NBT JSON.", {
             opIndex,
@@ -241,11 +256,13 @@ export function applyJsonPatch(document, patch) {
         }
         if (operation.op === "add") {
             const nextValue = structuredClone(operation.value);
+            let subtree = { root: working };
             if (tokens.length === 0) {
                 working = nextValue;
+                subtree = { root: working };
             }
             else {
-                const { parent, key } = resolveParent(working, tokens, i, operation.path);
+                const { parent, key, enclosingNode, enclosingPointer } = resolveParent(working, tokens, i, operation.path);
                 if (Array.isArray(parent)) {
                     const index = parseArrayIndex(key, parent.length, {
                         allowAppend: true,
@@ -255,7 +272,12 @@ export function applyJsonPatch(document, patch) {
                     parent.splice(index, 0, nextValue);
                 }
                 else if (isRecord(parent)) {
-                    parent[key] = nextValue;
+                    Object.defineProperty(parent, key, {
+                        value: nextValue,
+                        enumerable: true,
+                        writable: true,
+                        configurable: true
+                    });
                 }
                 else {
                     patchConflict("Add target parent is not a container.", {
@@ -263,9 +285,13 @@ export function applyJsonPatch(document, patch) {
                         jsonPointer: operation.path
                     });
                 }
+                subtree =
+                    enclosingNode === undefined
+                        ? { root: working }
+                        : { node: enclosingNode, pointer: enclosingPointer };
             }
             changed = true;
-            assertTypedNbtInvariant(working, i, operation.path);
+            assertTypedNbtInvariant(subtree, i, operation.path);
             continue;
         }
         if (operation.op === "remove") {
@@ -275,7 +301,7 @@ export function applyJsonPatch(document, patch) {
                     jsonPointer: operation.path
                 });
             }
-            const { parent, key } = resolveParent(working, tokens, i, operation.path);
+            const { parent, key, enclosingNode, enclosingPointer } = resolveParent(working, tokens, i, operation.path);
             if (Array.isArray(parent)) {
                 const index = parseArrayIndex(key, parent.length, {
                     allowAppend: false,
@@ -300,16 +326,20 @@ export function applyJsonPatch(document, patch) {
                 });
             }
             changed = true;
-            assertTypedNbtInvariant(working, i, operation.path);
+            assertTypedNbtInvariant(enclosingNode === undefined
+                ? { root: working }
+                : { node: enclosingNode, pointer: enclosingPointer }, i, operation.path);
             continue;
         }
         if (operation.op === "replace") {
             const nextValue = structuredClone(operation.value);
+            let subtree = { root: working };
             if (tokens.length === 0) {
                 working = nextValue;
+                subtree = { root: working };
             }
             else {
-                const { parent, key } = resolveParent(working, tokens, i, operation.path);
+                const { parent, key, enclosingNode, enclosingPointer } = resolveParent(working, tokens, i, operation.path);
                 if (Array.isArray(parent)) {
                     const index = parseArrayIndex(key, parent.length, {
                         allowAppend: false,
@@ -325,7 +355,12 @@ export function applyJsonPatch(document, patch) {
                             jsonPointer: operation.path
                         });
                     }
-                    parent[key] = nextValue;
+                    Object.defineProperty(parent, key, {
+                        value: nextValue,
+                        enumerable: true,
+                        writable: true,
+                        configurable: true
+                    });
                 }
                 else {
                     patchConflict("Replace target parent is not a container.", {
@@ -333,9 +368,13 @@ export function applyJsonPatch(document, patch) {
                         jsonPointer: operation.path
                     });
                 }
+                subtree =
+                    enclosingNode === undefined
+                        ? { root: working }
+                        : { node: enclosingNode, pointer: enclosingPointer };
             }
             changed = true;
-            assertTypedNbtInvariant(working, i, operation.path);
+            assertTypedNbtInvariant(subtree, i, operation.path);
             continue;
         }
     }

package/dist/nbt/typed-json.d.ts

@@ -5,6 +5,7 @@ type ValidationResult = {
     ok: false;
     issue: TypedNbtValidationIssue;
 };
+export declare function validateTypedNbtNode(value: unknown, pointer: string): ValidationResult;
 export declare function validateTypedNbtDocument(value: unknown): ValidationResult;
 export declare function assertValidTypedNbtDocument(value: unknown): asserts value is TypedNbtDocument;
 export type { TypedNbtDocument, TypedNbtValidationIssue } from "./types.js";

package/dist/nbt/typed-json.js

@@ -16,6 +16,7 @@ const NODE_TYPES = [
 const LIST_ELEMENT_TYPES = ["end", ...NODE_TYPES];
 const NODE_TYPE_SET = new Set(NODE_TYPES);
 const LIST_ELEMENT_TYPE_SET = new Set(LIST_ELEMENT_TYPES);
+const NON_FINITE_FLOAT_SENTINELS = new Set(["NaN", "Infinity", "-Infinity"]);
 const INT64_MIN = -9223372036854775808n;
 const INT64_MAX = 9223372036854775807n;
 function isRecord(value) {
@@ -119,8 +120,14 @@ function validateNode(value, pointer) {
             return validateLongString(node.value, `${pointer}/value`);
         case "float":
         case "double":
-            if (typeof node.value !== "number" || !Number.isFinite(node.value)) {
-                return fail(`${pointer}/value`, "finite-number", node.value);
+            if (typeof node.value === "string") {
+                if (!NON_FINITE_FLOAT_SENTINELS.has(node.value)) {
+                    return fail(`${pointer}/value`, "number-or-non-finite-sentinel", node.value);
+                }
+                return { ok: true };
+            }
+            if (typeof node.value !== "number") {
+                return fail(`${pointer}/value`, "number-or-non-finite-sentinel", node.value);
             }
             return { ok: true };
         case "string":
@@ -180,6 +187,9 @@ function validateNode(value, pointer) {
             return fail(`${pointer}/type`, "nbt-node-type", nodeType);
     }
 }
+export function validateTypedNbtNode(value, pointer) {
+    return validateNode(value, pointer);
+}
 export function validateTypedNbtDocument(value) {
     if (!isRecord(value)) {
         return fail("", "typed-nbt-document", value);

package/dist/nbt/types.d.ts

@@ -15,10 +15,10 @@ export type NbtNode = {
     value: string;
 } | {
     type: "float";
-    value: number;
+    value: number | "NaN" | "Infinity" | "-Infinity";
 } | {
     type: "double";
-    value: number;
+    value: number | "NaN" | "Infinity" | "-Infinity";
 } | {
     type: "byteArray";
     value: number[];

package/dist/path-converter.js

@@ -3,7 +3,7 @@ import { createError, ERROR_CODES } from "./errors.js";
 const WINDOWS_DRIVE_PATH = /^[A-Za-z]:[\\/]/;
 const MALFORMED_WINDOWS_DRIVE_PATH = /^[A-Za-z]:(?![\\/])/;
 const WSL_MOUNT_PATH = /^\/mnt\/[a-z](?:\/|$)/i;
-const UNC_WSL_PATH = /^(?:\\\\wsl\$\\|\/\/wsl\$\/)/i;
+const UNC_WSL_PATH = /^(?:\\\\(?:wsl\$|wsl\.localhost)\\|\/\/(?:wsl\$|wsl\.localhost)\/)/i;
 function normalizeToUnixSlashes(value) {
     return value.replace(/\\/g, "/");
 }
@@ -12,10 +12,11 @@ function normalizeToWindowsSlashes(value) {
 }
 function parseUncWslPath(pathValue) {
     const normalized = normalizeToUnixSlashes(pathValue);
-    if (!normalized.toLowerCase().startsWith("//wsl$/")) {
+    const prefixMatch = normalized.match(/^\/\/(?:wsl\$|wsl\.localhost)\//i);
+    if (!prefixMatch) {
         return undefined;
     }
-    const remainder = normalized.slice("//wsl$/".length).replace(/^\/+/, "");
+    const remainder = normalized.slice(prefixMatch[0].length).replace(/^\/+/, "");
     const slashIndex = remainder.indexOf("/");
     if (slashIndex < 0) {
         return {
@@ -99,6 +100,12 @@ function toWslPath(pathValue, runtime, field) {
     }
     const parsed = parseUncWslPath(pathValue);
     if (parsed) {
+        const distro = runtime.wslDistro?.trim();
+        if (!distro || parsed.distro.toLowerCase() !== distro.toLowerCase()) {
+            throwInvalidPath(pathValue, distro
+                ? `UNC WSL path targets distro "${parsed.distro}", but this server runs in distro "${distro}".`
+                : `Cannot resolve UNC WSL path for distro "${parsed.distro}" without a known WSL distro name.`, runtime, field);
+        }
         const rest = parsed.innerPath.replace(/^\/+/, "");
         return rest ? `/${rest}` : "/";
     }

package/dist/registry-service.d.ts

@@ -28,9 +28,11 @@ export declare class RegistryService {
     private readonly config;
     private readonly versionService;
     private readonly registryCache;
+    private readonly loadLocks;
     constructor(config: Config, versionService: VersionService);
     getRegistryData(input: GetRegistryDataInput): Promise<GetRegistryDataOutput>;
     private loadRegistries;
+    private loadRegistriesInternal;
     private loadExistingRegistries;
     private readRegistryFileOrThrow;
     private isInvalidRegistrySnapshot;

package/dist/registry-service.js

@@ -126,7 +126,7 @@ function runDataGen(serverJarPath, outputDir, version) {
             ];
         log("info", "registry.datagen.start", { version, isLegacy, serverJarPath, outputDir });
         const proc = spawn("java", args, {
-            stdio: ["ignore", "pipe", "pipe"],
+            stdio: ["ignore", "ignore", "pipe"],
             cwd: outputDir
         });
         let stderr = "";
@@ -194,6 +194,7 @@ export class RegistryService {
     config;
     versionService;
     registryCache = new Map();
+    loadLocks = new Map();
     constructor(config, versionService) {
         this.config = config;
         this.versionService = versionService;
@@ -270,6 +271,20 @@ export class RegistryService {
         };
     }
     async loadRegistries(version, warnings) {
+        const existingLock = this.loadLocks.get(version);
+        if (existingLock) {
+            return existingLock;
+        }
+        const loadPromise = this.loadRegistriesInternal(version, warnings);
+        this.loadLocks.set(version, loadPromise);
+        try {
+            return await loadPromise;
+        }
+        finally {
+            this.loadLocks.delete(version);
+        }
+    }
+    async loadRegistriesInternal(version, warnings) {
         const cached = this.registryCache.get(version);
         if (cached) {
             // LRU touch: move to most-recently-used so the bound evicts the true

package/dist/repo-downloader.js

@@ -40,7 +40,6 @@ export async function downloadToCache(url, destinationPath, opts = {}) {
         const timer = setTimeout(() => timeout.abort(), timeoutMs);
         try {
             const response = await fetchFn(url, { signal: timeout.signal });
-            clearTimeout(timer);
             const status = response.status;
             if (status === 404) {
                 return { ok: false, statusCode: status };
@@ -71,7 +70,7 @@ export async function downloadToCache(url, destinationPath, opts = {}) {
                 }
                 else {
                     const readable = Readable.fromWeb(response.body);
-                    await pipeline(readable, createWriteStream(tempPath));
+                    await pipeline(readable, createWriteStream(tempPath), { signal: timeout.signal });
                 }
                 const contentLength = statSync(tempPath).size;
                 renameSync(tempPath, destinationPath);
@@ -95,13 +94,15 @@ export async function downloadToCache(url, destinationPath, opts = {}) {
             }
         }
         catch (caughtError) {
-            clearTimeout(timer);
             if (attempt >= maxRetries) {
                 throw caughtError instanceof Error ? caughtError : new Error(String(caughtError));
             }
             await sleep(retryDelay(200, attempt));
             attempt += 1;
         }
+        finally {
+            clearTimeout(timer);
+        }
     }
 }
 export function defaultDownloadPath(cacheDir, url) {

package/dist/source/artifact-resolver.js

@@ -54,7 +54,7 @@ export function hasExactVersionToken(path, version) {
     // Avoid prefix false-positives like "1.21.1" matching "1.21.10".
     const cached = VERSION_TOKEN_REGEX_CACHE.get(normalizedVersion);
     const pattern = cached
-        ?? rememberCachedRegex(VERSION_TOKEN_REGEX_CACHE, normalizedVersion, new RegExp(`(^|[^0-9a-z])${escapeRegexLiteral(normalizedVersion)}([^0-9a-z]|$)`, "i"));
+        ?? rememberCachedRegex(VERSION_TOKEN_REGEX_CACHE, normalizedVersion, new RegExp(`(^|[^0-9a-z])${escapeRegexLiteral(normalizedVersion)}(?![0-9a-z]|\\.[0-9])`, "i"));
     return pattern.test(normalizedPath);
 }
 function inferMergedRuntimeNamespaceHint(path) {

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

@@ -76,3 +76,29 @@ export declare function projectMembersForWire(slice: {
     fields: SignatureMember[];
     methods: SignatureMember[];
 }, includeInherited: boolean, keepFieldDescriptors?: boolean): WireMembersBlock;
+/**
+ * Token-projection level for a member listing, narrowing the per-member fields
+ * an agent receives:
+ * - `full` (default): the complete {@link WireMember} shape (current behavior).
+ * - `signatures`: name + javaSignature (drops jvmDescriptor) — enough to read
+ *   the API without overload descriptors.
+ * - `names`: member name only — enough for an "does this member exist?" check.
+ * The block-level hoisted `ownerFqn` and any per-member `ownerFqn` (the
+ * multi-owner / includeInherited case) are preserved in every level so members
+ * stay attributable.
+ */
+export type MemberProjection = "names" | "signatures" | "full";
+export type ProjectedMember = {
+    name: string;
+    javaSignature?: string;
+    jvmDescriptor?: string;
+    ownerFqn?: string;
+    isSynthetic?: boolean;
+};
+export type ProjectedMembersBlock = {
+    ownerFqn?: string;
+    constructors: ProjectedMember[];
+    fields: ProjectedMember[];
+    methods: ProjectedMember[];
+};
+export declare function projectMembersByLevel(block: WireMembersBlock, level: MemberProjection): ProjectedMembersBlock;

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

@@ -1,3 +1,4 @@
+import { matchesMemberPattern } from "../member-pattern.js";
 export async function remapAndCountMembers(svc, input) {
     const remap = async (members, kind) => {
         if (input.version == null) {
@@ -10,10 +11,10 @@ export async function remapAndCountMembers(svc, input) {
     let fields = await remap(input.signatureFields, "field");
     let methods = await remap(input.signatureMethods, "method");
     if (input.requestedMapping !== input.mappingApplied && input.memberPattern) {
-        const lowerPattern = input.memberPattern.toLowerCase();
-        constructors = constructors.filter((m) => m.name.toLowerCase().includes(lowerPattern));
-        fields = fields.filter((m) => m.name.toLowerCase().includes(lowerPattern));
-        methods = methods.filter((m) => m.name.toLowerCase().includes(lowerPattern));
+        const pattern = input.memberPattern;
+        constructors = constructors.filter((m) => matchesMemberPattern(m.name, pattern));
+        fields = fields.filter((m) => matchesMemberPattern(m.name, pattern));
+        methods = methods.filter((m) => matchesMemberPattern(m.name, pattern));
     }
     const counts = {
         constructors: constructors.length,
@@ -90,4 +91,30 @@ export function projectMembersForWire(slice, includeInherited, keepFieldDescript
         methods: slice.methods.map((m) => toWire(m, true))
     };
 }
+export function projectMembersByLevel(block, level) {
+    if (level === "full") {
+        return block;
+    }
+    const reduce = (m) => {
+        if (level === "names") {
+            return {
+                name: m.name,
+                ...(m.ownerFqn ? { ownerFqn: m.ownerFqn } : {})
+            };
+        }
+        // "signatures": keep the readable signature, drop the JVM descriptor.
+        return {
+            name: m.name,
+            javaSignature: m.javaSignature,
+            ...(m.ownerFqn ? { ownerFqn: m.ownerFqn } : {}),
+            ...(m.isSynthetic ? { isSynthetic: true } : {})
+        };
+    };
+    return {
+        ...(block.ownerFqn ? { ownerFqn: block.ownerFqn } : {}),
+        constructors: block.constructors.map(reduce),
+        fields: block.fields.map(reduce),
+        methods: block.methods.map(reduce)
+    };
+}
 //# sourceMappingURL=members-builder.js.map

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

@@ -53,6 +53,12 @@ export function buildClassSourceSnippet(input) {
         sourceText = sliceToMaxCharsSafe(sourceText, input.maxChars);
         charsTruncated = true;
         truncated = true;
+        if (input.mode !== "metadata") {
+            const survivingNewlines = (sourceText.match(/\n/g) ?? []).length;
+            returnedEnd = sourceText.endsWith("\n")
+                ? returnedStart + survivingNewlines - 1
+                : returnedStart + survivingNewlines;
+        }
     }
     let nextStartLine;
     // Metadata mode returns a synthesized outline, not a line window into the

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

@@ -9,16 +9,16 @@ export declare function extractDecompiledMembers(className: string, filePath: st
     fields: DecompiledMember[];
     methods: DecompiledMember[];
 };
-export declare function computeLineBraceDepths(lines: string[]): number[];
+export declare function computeLineBraceDepths(lines: string[], strippedLines?: string[]): number[];
 export declare function computeBraceRange(lines: string[], symbols: Array<{
     symbolKind: string;
     symbolName: string;
     line: number;
-}>, simpleName: string): {
+}>, simpleName: string, strippedLines?: string[]): {
     declarationLine: number;
     endLine: number;
 } | undefined;
-export declare function scanBraceRange(lines: string[], declarationLine: number): {
+export declare function scanBraceRange(lines: string[], declarationLine: number, strippedLines?: string[]): {
     declarationLine: number;
     endLine: number;
 };
@@ -28,7 +28,7 @@ export declare function computeNestedTypeRanges(lines: string[], symbols: Array<
 }>, outerBody: {
     declarationLine: number;
     endLine: number;
-}): Array<{
+}, strippedLines?: string[]): Array<{
     declarationLine: number;
     endLine: number;
 }>;

package/dist/source/class-source-helpers.js

@@ -30,13 +30,14 @@ export function extractDecompiledMembers(className, filePath, content) {
     const symbols = extractSymbolsFromSource(filePath, content);
     const simpleName = className.split(/[.$]/).at(-1) ?? className;
     const lines = content.split(/\r?\n/);
-    const body = computeBraceRange(lines, symbols, simpleName);
+    const stripped = stripBraceNoise(lines);
+    const body = computeBraceRange(lines, symbols, simpleName, stripped);
     if (!body) {
         return { constructors: [], fields: [], methods: [] };
     }
-    const depths = computeLineBraceDepths(lines);
+    const depths = computeLineBraceDepths(lines, stripped);
     const baseDepth = depths[body.declarationLine - 1] ?? 0;
-    const nestedRanges = computeNestedTypeRanges(lines, symbols, body);
+    const nestedRanges = computeNestedTypeRanges(lines, symbols, body, stripped);
     const constructors = [];
     const fields = [];
     const methods = [];
@@ -126,8 +127,8 @@ function stripBraceNoise(lines) {
     }
     return out;
 }
-export function computeLineBraceDepths(lines) {
-    const stripped = stripBraceNoise(lines);
+export function computeLineBraceDepths(lines, strippedLines) {
+    const stripped = strippedLines ?? stripBraceNoise(lines);
     const depths = new Array(lines.length).fill(0);
     let depth = 0;
     for (let i = 0; i < stripped.length; i += 1) {
@@ -144,19 +145,19 @@ export function computeLineBraceDepths(lines) {
     }
     return depths;
 }
-export function computeBraceRange(lines, symbols, simpleName) {
+export function computeBraceRange(lines, symbols, simpleName, strippedLines) {
     const classSymbol = symbols.find((symbol) => (symbol.symbolKind === "class" || symbol.symbolKind === "interface"
         || symbol.symbolKind === "enum" || symbol.symbolKind === "record")
         && symbol.symbolName === simpleName);
     if (!classSymbol) {
         return undefined;
     }
-    return scanBraceRange(lines, classSymbol.line);
+    return scanBraceRange(lines, classSymbol.line, strippedLines);
 }
-export function scanBraceRange(lines, declarationLine) {
+export function scanBraceRange(lines, declarationLine, strippedLines) {
     // Strip from the start of the file so multi-line block-comment state is correct
     // by the time we reach declarationLine; indices stay aligned with `lines`.
-    const stripped = stripBraceNoise(lines);
+    const stripped = strippedLines ?? stripBraceNoise(lines);
     let depth = 0;
     let started = false;
     for (let i = declarationLine - 1; i < stripped.length; i += 1) {
@@ -175,7 +176,7 @@ export function scanBraceRange(lines, declarationLine) {
     }
     return { declarationLine, endLine: lines.length };
 }
-export function computeNestedTypeRanges(lines, symbols, outerBody) {
+export function computeNestedTypeRanges(lines, symbols, outerBody, strippedLines) {
     const ranges = [];
     for (const candidate of symbols) {
         if (candidate.symbolKind !== "class" && candidate.symbolKind !== "interface"
@@ -188,7 +189,7 @@ export function computeNestedTypeRanges(lines, symbols, outerBody) {
         if (ranges.some((range) => candidate.line >= range.declarationLine && candidate.line <= range.endLine)) {
             continue;
         }
-        const nestedRange = scanBraceRange(lines, candidate.line);
+        const nestedRange = scanBraceRange(lines, candidate.line, strippedLines);
         ranges.push(nestedRange);
     }
     return ranges;

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

@@ -2,6 +2,24 @@ import { type AppError } from "../errors.js";
 import type { SourceService } from "../source-service.js";
 import type { DecompiledFallback, FindClassInput, FindClassOutput, GetClassMembersInput, GetClassMembersOutput, GetClassSourceInput, GetClassSourceOutput } from "../source-service.js";
 import type { ArtifactProvenance, ArtifactScope, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping } from "../types.js";
+/**
+ * Unobfuscated Minecraft versions (26.1+) ship their runtime and decompiled source
+ * in deobfuscated (mojang) names directly — there is no real obfuscated namespace to
+ * map to. An artifact whose stored namespace label is "obfuscated" is therefore a
+ * mislabel for a mojang request: the bytes already carry mojang names.
+ *
+ * Without this reconciliation, requestedMapping="mojang" !== mappingApplied="obfuscated"
+ * triggers a cascade of doomed work: resolveClassNameForLookup attempts a mojang->obfuscated
+ * class remap, remapSignatureMembers tries to remap every member obfuscated->mojang and drops
+ * them all (counts.total===0), which forces a spurious decompiledFallback, disables
+ * memberPattern, and floods the response with one "Could not remap ..." warning per member.
+ *
+ * Collapsing mappingApplied to the requested mojang namespace makes the whole pipeline an
+ * identity no-op: members are returned from bytecode with correct mojang names, memberPattern
+ * applies, and the per-member warning flood disappears. This is the single highest-impact
+ * token-efficiency fix for unobfuscated versions.
+ */
+export declare function reconcileUnobfuscatedNamespace(version: string | undefined, requestedMapping: SourceMapping, mappingApplied: SourceMapping): SourceMapping;
 export declare function resolveClassFilePath(svc: SourceService, artifactId: string, className: string): string | undefined;
 export declare function resolveClassNameForLookup(svc: SourceService, input: {
     className: string;
@@ -37,6 +55,7 @@ export declare function buildClassSourceNotFoundError(_svc: SourceService, input
 export declare function buildDecompiledFallback(svc: SourceService, artifactId: string, lookupClassName: string, memberPattern: string | undefined, maxMembers: number): {
     fallback: DecompiledFallback;
     counts: NonNullable<GetClassMembersOutput["decompiledMemberCounts"]>;
+    truncated: boolean;
 } | undefined;
 export declare function findClass(svc: SourceService, input: FindClassInput): FindClassOutput;
 export declare function getClassSource(svc: SourceService, input: GetClassSourceInput): Promise<GetClassSourceOutput>;