@adhisang/minecraft-modding-mcp 4.2.0 → 5.0.0

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

@@ -67,17 +67,73 @@ export function extractDecompiledMembers(className, filePath, content) {
     }
     return { constructors, fields, methods };
 }
+/**
+ * Remove everything that must not count toward brace depth — line comments,
+ * (possibly multi-line) block comments, string literals, and char literals —
+ * in a single stateful pass so that block comments spanning lines and char
+ * literals like '{' / '}' never skew brace accounting. Line indices are
+ * preserved (one output entry per input line). Text blocks (""" … """) are not
+ * special-cased; they are vanishingly rare in decompiled output.
+ */
+function stripBraceNoise(lines) {
+    const out = new Array(lines.length);
+    let inBlockComment = false;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        let result = "";
+        let j = 0;
+        while (j < line.length) {
+            const ch = line[j];
+            const next = line[j + 1];
+            if (inBlockComment) {
+                if (ch === "*" && next === "/") {
+                    inBlockComment = false;
+                    j += 2;
+                }
+                else {
+                    j += 1;
+                }
+                continue;
+            }
+            if (ch === "/" && next === "/") {
+                break; // line comment: ignore the rest of the line
+            }
+            if (ch === "/" && next === "*") {
+                inBlockComment = true;
+                j += 2;
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                const quote = ch;
+                j += 1;
+                while (j < line.length) {
+                    if (line[j] === "\\") {
+                        j += 2;
+                        continue;
+                    }
+                    if (line[j] === quote) {
+                        j += 1;
+                        break;
+                    }
+                    j += 1;
+                }
+                continue;
+            }
+            result += ch;
+            j += 1;
+        }
+        out[i] = result;
+    }
+    return out;
+}
 export function computeLineBraceDepths(lines) {
+    const stripped = stripBraceNoise(lines);
     const depths = new Array(lines.length).fill(0);
     let depth = 0;
-    for (let i = 0; i < lines.length; i += 1) {
+    for (let i = 0; i < stripped.length; i += 1) {
         // Entry depth for this line = depth observed before any brace on it.
         depths[i] = depth;
-        const stripped = (lines[i] ?? "")
-            .replace(/\/\/.*/g, "")
-            .replace(/"(?:\\.|[^"\\])*"/g, "\"\"")
-            .replace(/'(?:\\.|[^'\\])*'/g, "''");
-        for (const char of stripped) {
+        for (const char of stripped[i] ?? "") {
             if (char === "{") {
                 depth += 1;
             }
@@ -98,13 +154,13 @@ export function computeBraceRange(lines, symbols, simpleName) {
     return scanBraceRange(lines, classSymbol.line);
 }
 export function scanBraceRange(lines, declarationLine) {
+    // 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);
     let depth = 0;
     let started = false;
-    for (let i = declarationLine - 1; i < lines.length; i += 1) {
-        const stripped = (lines[i] ?? "")
-            .replace(/\/\/.*/g, "")
-            .replace(/"(?:\\.|[^"\\])*"/g, "\"\"");
-        for (const char of stripped) {
+    for (let i = declarationLine - 1; i < stripped.length; i += 1) {
+        for (const char of stripped[i] ?? "") {
             if (char === "{") {
                 depth += 1;
                 started = true;

package/dist/source/class-source.js

@@ -5,7 +5,8 @@ import { ERROR_CODES, createError, isAppError } from "../errors.js";
 import * as artifactResolver from "./artifact-resolver.js";
 import * as classSourceHelpers from "./class-source-helpers.js";
 import { buildClassSourceSnippet } from "./class-source/snippet-builder.js";
-import { remapAndCountMembers, sliceMembersWithLimit } from "./class-source/members-builder.js";
+import { remapAndCountMembers, sliceMembersWithLimit, projectMembersForWire } from "./class-source/members-builder.js";
+import { buildPageContextKey, encodeOffsetCursor, resolveCursorOffset } from "../page-cursor.js";
 import { dedupeQualityFlags, normalizeMapping, normalizeOptionalString, normalizePathStyle } from "./shared-utils.js";
 const MEMBERS_STATUS_LEGACY = process.env.MEMBERS_STATUS_LEGACY === "1";
 function normalizeStrictPositiveInt(value, field) {
@@ -257,6 +258,9 @@ export function buildDecompiledFallback(svc, artifactId, lookupClassName, member
         }
     };
 }
+// The class-like symbol kinds findClass returns. MUST stay in sync with the JS-side
+// isTypeSymbol checks below; pushed down to SQL so non-type rows are never fetched.
+const TYPE_SYMBOL_KINDS = ["class", "interface", "enum", "record"];
 export function findClass(svc, input) {
     const className = input.className.trim();
     if (!className) {
@@ -278,12 +282,20 @@ export function findClass(svc, input) {
     const warnings = [];
     const isQualified = className.includes(".");
     if (isQualified) {
-        const classPath = className.replace(/\./g, "/");
+        // The innermost simple name (handles both dot- and $-separated inner types).
+        const simpleName = className.split(/[.$]/).at(-1) ?? className;
+        const directPath = `${classNameToClassPath(className)}.java`;
+        // The extractor stores ONE (outer) qualifiedName per file, so a nested type's
+        // FQCN never equals any stored qualifiedName and its synthetic file path
+        // (pkg/Outer/Inner.java) does not exist. resolveClassFilePath maps the FQCN —
+        // inner classes included — to the real outer file, which we match on.
+        const resolvedFilePath = resolveClassFilePath(svc, artifactId, className);
         const result = svc.symbolsRepo.findScopedSymbols({
             artifactId,
-            query: className.split(".").at(-1) ?? className,
+            query: simpleName,
             match: "exact",
-            limit: 5000
+            symbolKinds: TYPE_SYMBOL_KINDS,
+            limit: limit * 5
         });
         const matches = result.items
             .filter((row) => {
@@ -292,14 +304,22 @@ export function findClass(svc, input) {
             if (!isTypeSymbol)
                 return false;
             const rowQualified = row.qualifiedName ?? row.filePath.replace(/\.java$/, "").replaceAll("/", ".");
-            return rowQualified === className || row.filePath === `${classPath}.java`;
+            return (rowQualified === className ||
+                row.filePath === directPath ||
+                (resolvedFilePath != null && row.filePath === resolvedFilePath));
+        })
+            .map((row) => {
+            const rowQualified = row.qualifiedName ?? row.filePath.replace(/\.java$/, "").replaceAll("/", ".");
+            // For an inner-class match the stored qualifiedName is the outer type; the
+            // caller asked for the full nested FQCN, so report that.
+            const isInnerMatch = rowQualified !== className && row.filePath !== directPath;
+            return {
+                qualifiedName: isInnerMatch ? className : rowQualified,
+                filePath: row.filePath,
+                line: row.line,
+                symbolKind: row.symbolKind
+            };
         })
-            .map((row) => ({
-            qualifiedName: row.qualifiedName ?? row.filePath.replace(/\.java$/, "").replaceAll("/", "."),
-            filePath: row.filePath,
-            line: row.line,
-            symbolKind: row.symbolKind
-        }))
             .slice(0, limit);
         const partialVanillaLookup = hasPartialNetMinecraftCoverage(artifact.qualityFlags) && looksLikeDeobfuscatedClassName(className);
         const filteredMatches = partialVanillaLookup && matches.every((match) => !match.qualifiedName.startsWith("net.minecraft.") && !match.qualifiedName.startsWith("com.mojang."))
@@ -317,6 +337,7 @@ export function findClass(svc, input) {
         artifactId,
         query: className,
         match: "exact",
+        symbolKinds: TYPE_SYMBOL_KINDS,
         limit: limit * 5
     });
     const matches = [];
@@ -587,6 +608,27 @@ export async function getClassSource(svc, input) {
             requestedMapping,
             mappingApplied: activeMappingApplied
         });
+    const nextStartLine = snippet.nextStartLine;
+    // Continuation guidance: when output was truncated and was not redirected to
+    // a file, hand the caller the next line to read plus a replayable call that
+    // re-reads from the already-resolved artifact (no re-resolution needed).
+    // nextStartLine is only set for snippet/full mode, so `mode` here is never
+    // "metadata". The caller's original endLine window is preserved so the
+    // continuation never reads past the requested range.
+    const continuation = nextStartLine != null && !resolvedOutputFile
+        ? buildSuggestedCall({
+            tool: "get-class-source",
+            params: {
+                className,
+                target: { kind: "artifact", artifactId: activeArtifactId },
+                mode,
+                startLine: nextStartLine,
+                ...(input.endLine != null ? { endLine: input.endLine } : {}),
+                ...(input.maxLines != null ? { maxLines: input.maxLines } : {}),
+                ...(input.maxChars != null ? { maxChars: input.maxChars } : {})
+            }
+        })
+        : undefined;
     return {
         className,
         mode,
@@ -598,6 +640,8 @@ export async function getClassSource(svc, input) {
         },
         truncated,
         ...(charsTruncated ? { charsTruncated } : {}),
+        ...(snippet.outOfRange ? { outOfRange: true } : {}),
+        ...(nextStartLine != null ? { nextStartLine } : {}),
         origin: activeOrigin,
         artifactId: activeArtifactId,
         requestedMapping,
@@ -611,6 +655,7 @@ export async function getClassSource(svc, input) {
             isDecompiled: activeOrigin === "decompiled",
             qualityFlags: activeQualityFlags
         }),
+        ...(continuation?.suggestedCall ? { suggestedCall: continuation.suggestedCall } : {}),
         ...(resolvedOutputFile ? { outputFile: resolvedOutputFile } : {}),
         warnings
     };
@@ -629,7 +674,7 @@ export async function getClassMembers(svc, input) {
     const includeInherited = input.includeInherited ?? false;
     const memberPattern = normalizeOptionalString(input.memberPattern);
     const parsedMaxMembers = normalizeStrictPositiveInt(input.maxMembers, "maxMembers");
-    const maxMembers = parsedMaxMembers == null ? 500 : Math.min(parsedMaxMembers, 5000);
+    const maxMembers = parsedMaxMembers == null ? 150 : Math.min(parsedMaxMembers, 5000);
     const normalizedArtifactId = normalizeOptionalString(input.artifactId);
     if (normalizedArtifactId && input.target) {
         throw createError({
@@ -759,7 +804,23 @@ export async function getClassMembers(svc, input) {
     }
     catch (error) {
         if (isAppError(error) && error.code === ERROR_CODES.CLASS_NOT_FOUND) {
-            throw error;
+            // Re-raise with the shared recovery shape (find-class/api-matrix
+            // suggestedCall, namespace + scope hints) instead of the sparse bytecode
+            // error, so members and source agree on CLASS_NOT_FOUND guidance.
+            throw buildClassSourceNotFoundError(svc, {
+                artifactId,
+                className,
+                lookupClassName,
+                mappingApplied,
+                requestedMapping,
+                qualityFlags,
+                attemptedBinaryFallback: true,
+                targetKind: input.target?.kind,
+                targetValue: input.target && "value" in input.target ? input.target.value : undefined,
+                scope: input.scope,
+                projectPath: input.projectPath,
+                version
+            });
         }
         binaryExtractionFailed = true;
         binaryExtractionFailureReason = error instanceof Error ? error.message : String(error);
@@ -787,11 +848,29 @@ export async function getClassMembers(svc, input) {
         warnings
     });
     const counts = remapped.counts;
-    const sliced = sliceMembersWithLimit(remapped, counts.total, maxMembers, warnings);
+    // Offset cursor over the flat [constructors, fields, methods] member sequence.
+    // The context key ties a cursor to this exact query so a stale cursor restarts.
+    const memberCursorContext = buildPageContextKey([
+        artifactId,
+        lookupClassName,
+        requestedMapping,
+        mappingApplied,
+        access,
+        includeSynthetic,
+        includeInherited,
+        memberPattern
+    ]);
+    const { offset: memberOffset, cursorIgnored: memberCursorIgnored } = resolveCursorOffset(input.cursor, memberCursorContext);
+    const sliced = sliceMembersWithLimit(remapped, counts.total, maxMembers, warnings, memberOffset);
     const constructors = sliced.constructors;
     const fields = sliced.fields;
     const methods = sliced.methods;
+    // Slim the wire member shape: hoist a shared ownerFqn, drop accessFlags, omit
+    // isSynthetic:false, and drop FIELD jvmDescriptor unless includeDescriptors.
+    // Internal SignatureMember arrays above stay intact.
+    const projectedMembers = projectMembersForWire({ constructors, fields, methods }, includeInherited, input.includeDescriptors ?? false);
     const truncated = sliced.truncated;
+    const nextCursor = sliced.nextOffset != null ? encodeOffsetCursor(sliced.nextOffset, memberCursorContext) : undefined;
     const normalizedProvenance = provenance ??
         buildFallbackProvenance(svc, {
             artifactId,
@@ -843,7 +922,7 @@ export async function getClassMembers(svc, input) {
             suggestedCall = buildSuggestedCall({
                 tool: "get-class-source",
                 params: {
-                    target: { type: "artifact", artifactId },
+                    target: { kind: "artifact", artifactId },
                     className,
                     mode: "snippet",
                     mapping: requestedMapping
@@ -861,13 +940,11 @@ export async function getClassMembers(svc, input) {
     }
     return {
         className,
-        members: {
-            constructors,
-            fields,
-            methods
-        },
+        members: projectedMembers,
         counts,
         truncated,
+        ...(nextCursor ? { nextCursor } : {}),
+        ...(memberCursorIgnored ? { cursorIgnored: true } : {}),
         context: signatureContext,
         origin,
         artifactId,

package/dist/source/indexer.d.ts

@@ -1,7 +1,22 @@
+import { resolveMojangTinyFile } from "../mojang-tiny-mapping-service.js";
 import type { SourceService } from "../source-service.js";
 import type { ArtifactIndexMetaRow } from "../storage/index-meta-repo.js";
 import type { ArtifactRow, ResolvedSourceArtifact } from "../types.js";
+import { remapJar } from "../tiny-remapper-service.js";
+import { resolveTinyRemapperJar } from "../tiny-remapper-resolver.js";
 export declare const INDEX_SCHEMA_VERSION = 1;
+/**
+ * Injectable dependencies let remap-cache regression tests run without Java.
+ * Production callers use `defaultBinaryRemapDeps`; this is not a public MCP
+ * extension point.
+ */
+export type BinaryRemapDeps = {
+    resolveTinyRemapperJar: typeof resolveTinyRemapperJar;
+    resolveMojangTinyFile: typeof resolveMojangTinyFile;
+    remapJar: typeof remapJar;
+    now: () => number;
+    randomSuffix: () => string;
+};
 export type IndexRebuildReason = "force" | "missing_meta" | "schema_mismatch" | "signature_mismatch" | "already_current";
 export interface IndexedFileRecord {
     filePath: string;
@@ -57,13 +72,12 @@ export declare function ingestIfNeeded(svc: SourceService, resolved: ResolvedSou
  * binary remap, run tiny-remapper now and return the remapped jar path.
  * Otherwise return the original binaryJarPath unchanged.
  *
- * Cache safety: writes to a per-attempt temp file then atomic-renames into
- * <cacheDir>/remapped/<artifactId>.jar. A per-target inflight Promise map
- * collapses concurrent calls so two simultaneous resolveArtifact calls for
- * the same artifactId share one tiny-remapper run instead of racing on the
- * same output path.
+ * Cache safety: writes to a per-attempt `.jar` temp path, validates ZIP magic,
+ * then atomic-renames into <cacheDir>/remapped/<artifactId>.jar. A per-target
+ * inflight Promise map collapses concurrent calls so simultaneous
+ * resolveArtifact calls for the same artifactId share one tiny-remapper run.
  */
-export declare function maybeRemapBinaryForMojang(svc: SourceService, resolved: ResolvedSourceArtifact): Promise<string>;
+export declare function maybeRemapBinaryForMojang(svc: SourceService, resolved: ResolvedSourceArtifact, deps?: BinaryRemapDeps): Promise<string>;
 export declare function recordRemappedJarBytesFromDisk(svc: SourceService, artifactId: string, path: string): Promise<void>;
 /**
  * Best-effort structural check that `path` is a non-empty file beginning with
@@ -73,10 +87,21 @@ export declare function recordRemappedJarBytesFromDisk(svc: SourceService, artif
  * are not (a corrupt cache hit must be evicted).
  */
 export declare function isUsableJarFile(path: string): Promise<boolean>;
+export declare function buildBinaryRemapTempPath(remappedJarPath: string, input: {
+    pid: number;
+    now: number;
+    randomSuffix: string;
+}): string;
 export declare function runBinaryRemap(svc: SourceService, input: {
     version: string;
     inputJar: string;
     remappedDir: string;
     remappedJarPath: string;
 }): Promise<string>;
+export declare function runBinaryRemapWithDeps(svc: SourceService, input: {
+    version: string;
+    inputJar: string;
+    remappedDir: string;
+    remappedJarPath: string;
+}, deps: BinaryRemapDeps): Promise<string>;
 export declare function loadFromSourceJar(svc: SourceService, sourceJarPath: string): Promise<IndexedFileRecord[]>;

package/dist/source/indexer.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, open, rename, stat, unlink } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, open, rename, rm, stat } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 import { buildSuggestedCall } from "../build-suggested-call.js";
 import { decompileBinaryJar } from "../decompiler/vineflower.js";
 import { ERROR_CODES, createError, isAppError } from "../errors.js";
@@ -15,6 +15,13 @@ import { resolveVineflowerJar } from "../vineflower-resolver.js";
 import { enforceCacheLimits, recordRemappedJarBytes, releaseRemappedJarBytes, touchCacheMetrics, upsertCacheMetrics } from "./cache-metrics.js";
 import { normalizePathStyle } from "./shared-utils.js";
 export const INDEX_SCHEMA_VERSION = 1;
+const defaultBinaryRemapDeps = {
+    resolveTinyRemapperJar,
+    resolveMojangTinyFile,
+    remapJar,
+    now: () => Date.now(),
+    randomSuffix: () => Math.random().toString(36).slice(2, 8) || "0"
+};
 function chunkArray(items, chunkSize) {
     const size = Math.max(1, Math.trunc(chunkSize));
     if (items.length === 0) {
@@ -36,8 +43,8 @@ export async function indexArtifact(svc, input) {
     }
     const artifact = svc.getArtifact(artifactId);
     const force = input.force ?? false;
-    const hasFiles = svc.filesRepo.listFiles(artifact.artifactId, { limit: 1 }).items.length > 0;
     const meta = svc.indexMetaRepo.get(artifact.artifactId);
+    const hasFiles = meta ? meta.filesCount > 0 : false;
     const expectedSignature = artifact.artifactSignature ?? fallbackArtifactSignature(artifact.artifactId);
     const reason = resolveIndexRebuildReason({
         force,
@@ -284,8 +291,11 @@ export function getArtifact(svc, artifactId) {
 }
 export async function ingestIfNeeded(svc, resolved) {
     const existing = svc.artifactsRepo.getArtifact(resolved.artifactId);
-    const hasFiles = svc.filesRepo.listFiles(resolved.artifactId, { limit: 1 }).items.length > 0;
     const meta = svc.indexMetaRepo.get(resolved.artifactId);
+    // Derive hasFiles from meta instead of a separate listFiles probe: when meta is
+    // absent the reason is "missing_meta" regardless of hasFiles, and when present
+    // meta.filesCount is the authoritative count written alongside the file rows.
+    const hasFiles = meta ? meta.filesCount > 0 : false;
     const reason = resolveIndexRebuildReason({
         force: false,
         expectedSignature: resolved.artifactSignature,
@@ -354,13 +364,12 @@ async function rebuildMissingArtifactIndex(svc, resolved, reason) {
  * binary remap, run tiny-remapper now and return the remapped jar path.
  * Otherwise return the original binaryJarPath unchanged.
  *
- * Cache safety: writes to a per-attempt temp file then atomic-renames into
- * <cacheDir>/remapped/<artifactId>.jar. A per-target inflight Promise map
- * collapses concurrent calls so two simultaneous resolveArtifact calls for
- * the same artifactId share one tiny-remapper run instead of racing on the
- * same output path.
+ * Cache safety: writes to a per-attempt `.jar` temp path, validates ZIP magic,
+ * then atomic-renames into <cacheDir>/remapped/<artifactId>.jar. A per-target
+ * inflight Promise map collapses concurrent calls so simultaneous
+ * resolveArtifact calls for the same artifactId share one tiny-remapper run.
  */
-export async function maybeRemapBinaryForMojang(svc, resolved) {
+export async function maybeRemapBinaryForMojang(svc, resolved, deps = defaultBinaryRemapDeps) {
     const binaryJarPath = resolved.binaryJarPath;
     if (!binaryJarPath) {
         throw createError({
@@ -400,10 +409,19 @@ export async function maybeRemapBinaryForMojang(svc, resolved) {
             remappedJarPath
         });
         try {
-            await unlink(remappedJarPath);
+            await rm(remappedJarPath, { recursive: true, force: true });
         }
-        catch {
-            // ignore: race with another process or already-deleted file.
+        catch (caughtError) {
+            releaseRemappedJarBytes(svc, resolved.artifactId);
+            throw createError({
+                code: ERROR_CODES.REMAP_FAILED,
+                message: "Failed to remove corrupt binary remap cache entry.",
+                details: {
+                    artifactId: resolved.artifactId,
+                    remappedJarPath,
+                    cause: caughtError instanceof Error ? caughtError.message : String(caughtError)
+                }
+            });
         }
         releaseRemappedJarBytes(svc, resolved.artifactId);
     }
@@ -411,12 +429,12 @@ export async function maybeRemapBinaryForMojang(svc, resolved) {
     if (inflight) {
         return inflight;
     }
-    const remapPromise = runBinaryRemap(svc, {
+    const remapPromise = runBinaryRemapWithDeps(svc, {
         version: resolved.version,
         inputJar: binaryJarPath,
         remappedDir,
         remappedJarPath
-    });
+    }, deps);
     svc.state.inflightRemaps.set(remappedJarPath, remapPromise);
     try {
         const path = await remapPromise;
@@ -430,6 +448,9 @@ export async function maybeRemapBinaryForMojang(svc, resolved) {
 export async function recordRemappedJarBytesFromDisk(svc, artifactId, path) {
     try {
         const fileStat = await stat(path);
+        if (!fileStat.isFile()) {
+            return;
+        }
         recordRemappedJarBytes(svc, artifactId, fileStat.size);
     }
     catch {
@@ -467,14 +488,45 @@ export async function isUsableJarFile(path) {
         await handle?.close().catch(() => undefined);
     }
 }
+export function buildBinaryRemapTempPath(remappedJarPath, input) {
+    // Keep the final extension as `.jar`; the remap output is rejected unless it
+    // is a regular ZIP/JAR file, and manage-cache recognizes this temp shape.
+    const fileName = basename(remappedJarPath);
+    const artifactId = fileName.endsWith(".jar")
+        ? fileName.slice(0, -".jar".length)
+        : fileName;
+    return join(dirname(remappedJarPath), `${artifactId}.tmp.${input.pid}.${input.now}.${input.randomSuffix}.jar`);
+}
+async function describePathKind(path) {
+    try {
+        const stats = await stat(path);
+        if (stats.isFile()) {
+            return "file";
+        }
+        if (stats.isDirectory()) {
+            return "directory";
+        }
+        return "other";
+    }
+    catch {
+        return "missing";
+    }
+}
 export async function runBinaryRemap(svc, input) {
-    const tinyRemapperJarPath = await resolveTinyRemapperJar(svc.config.cacheDir, svc.config.tinyRemapperJarPath);
-    const mojangTiny = await resolveMojangTinyFile(input.version, svc.config);
+    return runBinaryRemapWithDeps(svc, input, defaultBinaryRemapDeps);
+}
+export async function runBinaryRemapWithDeps(svc, input, deps) {
+    const tinyRemapperJarPath = await deps.resolveTinyRemapperJar(svc.config.cacheDir, svc.config.tinyRemapperJarPath);
+    const mojangTiny = await deps.resolveMojangTinyFile(input.version, svc.config);
     await mkdir(input.remappedDir, { recursive: true });
-    const tempPath = `${input.remappedJarPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+    const tempPath = buildBinaryRemapTempPath(input.remappedJarPath, {
+        pid: process.pid,
+        now: deps.now(),
+        randomSuffix: deps.randomSuffix()
+    });
     const remapStartedAt = Date.now();
     try {
-        await remapJar(tinyRemapperJarPath, {
+        await deps.remapJar(tinyRemapperJarPath, {
             inputJar: input.inputJar,
             outputJar: tempPath,
             mappingsFile: mojangTiny.path,
@@ -483,20 +535,38 @@ export async function runBinaryRemap(svc, input) {
             timeoutMs: svc.config.remapTimeoutMs,
             maxMemoryMb: svc.config.remapMaxMemoryMb
         });
-        const tempStats = await stat(tempPath);
-        if (tempStats.size === 0) {
+        if (!(await isUsableJarFile(tempPath))) {
+            throw createError({
+                code: ERROR_CODES.REMAP_FAILED,
+                message: "tiny-remapper produced an invalid output jar.",
+                details: {
+                    inputJar: input.inputJar,
+                    tempPath,
+                    outputKind: await describePathKind(tempPath)
+                }
+            });
+        }
+        try {
+            await rename(tempPath, input.remappedJarPath);
+        }
+        catch (caughtError) {
             throw createError({
                 code: ERROR_CODES.REMAP_FAILED,
-                message: "tiny-remapper produced an empty output jar.",
-                details: { inputJar: input.inputJar, tempPath }
+                message: "Failed to finalize binary remap cache entry.",
+                details: {
+                    inputJar: input.inputJar,
+                    tempPath,
+                    remappedJarPath: input.remappedJarPath,
+                    outputKind: await describePathKind(input.remappedJarPath),
+                    cause: caughtError instanceof Error ? caughtError.message : String(caughtError)
+                }
             });
         }
-        await rename(tempPath, input.remappedJarPath);
         return input.remappedJarPath;
     }
     catch (caughtError) {
         try {
-            await unlink(tempPath);
+            await rm(tempPath, { recursive: true, force: true });
         }
         catch {
             // tempPath may not exist if remapJar failed before writing anything; ignore.

package/dist/source/search.d.ts

@@ -44,7 +44,7 @@ export declare function searchClassSource(svc: SourceService, input: SearchClass
 export declare function searchSymbolIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void): void;
 export declare function searchTextIntentIndexed(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, onHit: (hit: SearchSourceHit) => void): void;
 export declare function searchPathIntentIndexed(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, onHit: (hit: SearchSourceHit) => void): void;
-export declare function searchTextIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void): void;
+export declare function searchTextIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void, onWarning?: (warning: string) => void): void;
 export declare function searchPathIntent(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined, onHit: (hit: SearchSourceHit) => void): void;
 export declare function findSymbolHits(svc: SourceService, artifactId: string, query: string, match: SearchMatch, scope: SearchScope | undefined, regexPattern: RegExp | undefined): IndexedSymbolHit[];
 export declare function indexedCandidateLimit(svc: SourceService): number;