@adhisang/minecraft-modding-mcp 5.0.0 → 6.0.0

package/dist/mixin-parser.js

@@ -5,13 +5,15 @@
 /* ------------------------------------------------------------------ */
 /*  Regex patterns                                                     */
 /* ------------------------------------------------------------------ */
-const CLASS_DECL_RE = /(?:public\s+)?(?:abstract\s+)?(?:class|interface)\s+(\w+)/;
+const CLASS_DECL_RE = /^\s*(?:@[\w$.]+(?:\([^)]*\))?\s+)*(?:public\s+|final\s+|abstract\s+|sealed\s+)*\b(?:class|interface)\s+(\w+)/;
 // import statements for FQCN resolution
 const IMPORT_RE = /^\s*import\s+([\w.]+)\s*;/;
 // @Mixin(Foo.class)  or  @Mixin({Foo.class, Bar.class})  or  @Mixin(value = Foo.class)
 // Also handles  @Mixin(value = {Foo.class, Bar.class}, priority = 900)
 const MIXIN_ANNOTATION_START_RE = /^\s*@Mixin\s*\(/;
-const MIXIN_TARGET_RE = /(\w[\w.]*?)\.class/g;
+// `$` is a legal Java identifier character (e.g. generated classes like My$Class);
+// without it the capture would start mid-name and yield a wrong target.
+const MIXIN_TARGET_RE = /([\w$][\w.$]*?)\.class/g;
 const MIXIN_PRIORITY_RE = /priority\s*=\s*(\d+)/;
 // String-form targets: @Mixin(targets = "pkg.Class") or @Mixin(targets = {"pkg.A", "pkg.B"})
 const MIXIN_TARGETS_STRING_RE = /targets\s*=\s*(?:\{([^}]+)\}|"([^"]+)")/;
@@ -55,6 +57,62 @@ function collectMultilineAnnotation(lines, startIndex) {
     }
     return { text, endIndex: lines.length - 1 };
 }
+/**
+ * Blank out `/* *\/` block comments and `//` line comments (outside string literals)
+ * while preserving line count and line numbers, so the annotation scans never match
+ * inside commented-out code.
+ */
+function stripComments(source) {
+    let out = "";
+    let inBlock = false;
+    let inString = false;
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        const next = source[i + 1];
+        if (inBlock) {
+            if (ch === "*" && next === "/") {
+                out += "  ";
+                i++;
+                inBlock = false;
+            }
+            else {
+                out += ch === "\n" ? "\n" : " ";
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            if (ch === "\\" && next !== undefined) {
+                out += next;
+                i++;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            out += "  ";
+            i++;
+            inBlock = true;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            while (i < source.length && source[i] !== "\n") {
+                i++;
+            }
+            i--;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
 /**
  * Skip past annotations (including multi-line ones) starting at `startIndex`.
  * Returns the index of the first non-annotation line.
@@ -169,7 +227,7 @@ function inferAccessorTarget(methodName) {
 /*  Main parser                                                        */
 /* ------------------------------------------------------------------ */
 export function parseMixinSource(source) {
-    const lines = source.split(/\r?\n/);
+    const lines = stripComments(source).split(/\r?\n/);
     const parseWarnings = [];
     const targets = [];
     const injections = [];
@@ -323,6 +381,16 @@ export function parseMixinSource(source) {
                 }
                 i = endIndex;
             }
+            // Try same-line declaration first (e.g. `@Accessor("x") int getX();`)
+            const inlineDecl = stripInlineAnnotations(line);
+            const inlineMethodMatch = inlineDecl.includes("(") ? METHOD_DECL_RE.exec(inlineDecl) : null;
+            if (inlineMethodMatch) {
+                const methodName = inlineMethodMatch[2];
+                const targetName = explicitTarget ?? inferAccessorTarget(methodName);
+                accessors.push({ annotation, name: methodName, targetName, line: lineNum });
+                i++;
+                continue;
+            }
             // Find the method declaration following the annotation (skip multi-line annotations)
             let methodLine = i + 1;
             methodLine = skipAnnotations(lines, methodLine);

package/dist/mod-decompile-service.d.ts

@@ -43,8 +43,10 @@ export type GetModClassSourceOutput = {
 export declare class ModDecompileService {
     private readonly config;
     private readonly decompileCache;
+    private readonly inflightDecompiles;
     constructor(config: Config);
     decompileModJar(input: DecompileModJarInput): Promise<DecompileModJarOutput>;
     getModClassSource(input: GetModClassSourceInput): Promise<GetModClassSourceOutput>;
     private ensureDecompiled;
+    private decompileAndCache;
 }

package/dist/mod-decompile-service.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve as resolvePath } from "node:path";
 import { createError, ERROR_CODES } from "./errors.js";
@@ -6,11 +7,12 @@ import { log } from "./logger.js";
 import { decompileBinaryJar } from "./decompiler/vineflower.js";
 import { resolveVineflowerJar } from "./vineflower-resolver.js";
 import { analyzeModJar } from "./mod-analyzer.js";
-import { validateAndNormalizeJarPath } from "./path-resolver.js";
+import { buildJarSignature, validateAndNormalizeJarPath } from "./path-resolver.js";
 import { sliceToMaxCharsSafe } from "./text-truncate.js";
 const DECOMPILE_TIMEOUT_MS = 300_000;
 function modDecompileCacheKey(jarPath) {
-    return createHash("sha256").update(jarPath).digest("hex");
+    const stats = statSync(jarPath);
+    return createHash("sha256").update(`${jarPath}|${buildJarSignature(stats)}`).digest("hex");
 }
 function classNameToFilePath(className) {
     return className.replaceAll(".", "/") + ".java";
@@ -28,6 +30,7 @@ export class ModDecompileService {
     config;
     // Cache: jarPath hash → decompiled output dir + file list
     decompileCache = new Map();
+    inflightDecompiles = new Map();
     constructor(config) {
         this.config = config;
     }
@@ -155,6 +158,20 @@ export class ModDecompileService {
             this.decompileCache.set(cacheKey, cached);
             return cached;
         }
+        const existingDecompile = this.inflightDecompiles.get(cacheKey);
+        if (existingDecompile) {
+            return existingDecompile;
+        }
+        const decompilePromise = this.decompileAndCache(jarPath, cacheKey, warnings);
+        this.inflightDecompiles.set(cacheKey, decompilePromise);
+        try {
+            return await decompilePromise;
+        }
+        finally {
+            this.inflightDecompiles.delete(cacheKey);
+        }
+    }
+    async decompileAndCache(jarPath, cacheKey, warnings) {
         log("info", "mod-decompile.start", { jarPath });
         const startedAt = Date.now();
         // Analyze mod metadata

package/dist/mod-remap-service.js

@@ -1,5 +1,5 @@
-import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { createError, ERROR_CODES, isAppError } from "./errors.js";
@@ -225,8 +225,7 @@ export async function remapModJar(input, config, deps = {}) {
     }
     mkdirSync(dirname(outputJar), { recursive: true });
     // 7. Use a temporary directory for intermediate work
-    const tempDir = join(tmpdir(), `mcp-remap-${cacheKey.slice(0, 12)}`);
-    mkdirSync(tempDir, { recursive: true });
+    const tempDir = mkdtempSync(join(tmpdir(), `mcp-remap-${cacheKey.slice(0, 12)}-`));
     try {
         let passInput = normalizedInput;
         let tempOutput = "";
@@ -266,7 +265,9 @@ export async function remapModJar(input, config, deps = {}) {
         copyFileSync(tempOutput, outputJar);
         if (outputJar !== cachedOutput) {
             mkdirSync(dirname(cachedOutput), { recursive: true });
-            copyFileSync(tempOutput, cachedOutput);
+            const tempCachedOutput = `${cachedOutput}.${randomBytes(4).toString("hex")}.tmp`;
+            copyFileSync(tempOutput, tempCachedOutput);
+            renameSync(tempCachedOutput, cachedOutput);
         }
         const durationMs = Date.now() - startedAt;
         log("info", "remap.pipeline.done", {

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

@@ -1,5 +1,6 @@
+import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { createError, ERROR_CODES } from "./errors.js";
 import { log } from "./logger.js";
@@ -339,7 +340,9 @@ export async function resolveMojangTinyFile(version, config, deps = {}) {
     const membersByOwner = normalizeMemberMappings(parsedMappings, classMap, warnings);
     const tinyContent = renderTinyV2(classMap, membersByOwner);
     await mkdir(dirname(cachedTiny), { recursive: true });
-    await writeFile(cachedTiny, tinyContent, "utf8");
+    const tempTiny = `${cachedTiny}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(tempTiny, tinyContent, "utf8");
+    await rename(tempTiny, cachedTiny);
     log("info", "mojang-tiny.generated", {
         version,
         path: cachedTiny,

package/dist/nbt/java-nbt-codec.js

@@ -225,12 +225,12 @@ class NbtWriter {
     }
     writeFloat32(value) {
         const chunk = Buffer.allocUnsafe(4);
-        chunk.writeFloatBE(value, 0);
+        chunk.writeFloatBE(Number(value), 0);
         this.chunks.push(chunk);
     }
     writeFloat64(value) {
         const chunk = Buffer.allocUnsafe(8);
-        chunk.writeDoubleBE(value, 0);
+        chunk.writeDoubleBE(Number(value), 0);
         this.chunks.push(chunk);
     }
     writeInt64(value) {
@@ -238,6 +238,27 @@ class NbtWriter {
         chunk.writeBigInt64BE(value, 0);
         this.chunks.push(chunk);
     }
+    writeInt8Array(values) {
+        const chunk = Buffer.allocUnsafe(values.length);
+        for (let i = 0; i < values.length; i += 1) {
+            chunk.writeInt8(values[i], i);
+        }
+        this.chunks.push(chunk);
+    }
+    writeInt32Array(values) {
+        const chunk = Buffer.allocUnsafe(values.length * 4);
+        for (let i = 0; i < values.length; i += 1) {
+            chunk.writeInt32BE(values[i], i * 4);
+        }
+        this.chunks.push(chunk);
+    }
+    writeInt64Array(values) {
+        const chunk = Buffer.allocUnsafe(values.length * 8);
+        for (let i = 0; i < values.length; i += 1) {
+            chunk.writeBigInt64BE(values[i], i * 8);
+        }
+        this.chunks.push(chunk);
+    }
     writeString(value) {
         const encoded = encodeMutf8(value);
         if (encoded.length > 0xffff) {
@@ -261,10 +282,14 @@ function readPayload(reader, tagId, pointer) {
             return { type: "int", value: reader.readInt32() };
         case "long":
             return { type: "long", value: reader.readInt64().toString() };
-        case "float":
-            return { type: "float", value: reader.readFloat32() };
-        case "double":
-            return { type: "double", value: reader.readFloat64() };
+        case "float": {
+            const value = reader.readFloat32();
+            return { type: "float", value: Number.isFinite(value) ? value : Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity" };
+        }
+        case "double": {
+            const value = reader.readFloat64();
+            return { type: "double", value: Number.isFinite(value) ? value : Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity" };
+        }
         case "byteArray": {
             const length = reader.readInt32();
             if (length < 0) {
@@ -315,7 +340,12 @@ function readPayload(reader, tagId, pointer) {
                     break;
                 }
                 const childName = reader.readString();
-                value[childName] = readPayload(reader, childType, `${pointer}/value/${childName}`);
+                Object.defineProperty(value, childName, {
+                    value: readPayload(reader, childType, `${pointer}/value/${childName}`),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true
+                });
             }
             return { type: "compound", value };
         }
@@ -380,9 +410,7 @@ function writePayload(writer, node, pointer) {
             return;
         case "byteArray":
             writer.writeInt32(node.value.length);
-            for (const value of node.value) {
-                writer.writeInt8(value);
-            }
+            writer.writeInt8Array(node.value);
             return;
         case "string":
             writer.writeString(node.value);
@@ -404,15 +432,11 @@ function writePayload(writer, node, pointer) {
             return;
         case "intArray":
             writer.writeInt32(node.value.length);
-            for (const value of node.value) {
-                writer.writeInt32(value);
-            }
+            writer.writeInt32Array(node.value);
             return;
         case "longArray":
             writer.writeInt32(node.value.length);
-            for (const value of node.value) {
-                writer.writeInt64(BigInt(value));
-            }
+            writer.writeInt64Array(node.value.map((value) => BigInt(value)));
             return;
         default:
             throw encodeError("Unsupported typed NBT node for encoding.", {

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) {