@adhisang/minecraft-modding-mcp 4.2.1 → 6.0.0

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

@@ -98,6 +98,9 @@ function decodeMutf8(buffer, start, end) {
                 throw parseError("Truncated MUTF-8 2-byte sequence.", { offset: i - 1 });
             }
             const b1 = buffer[i++];
+            if ((b1 & 0xc0) !== 0x80) {
+                throw parseError("Invalid MUTF-8 continuation byte.", { byte: b1, offset: i - 1 });
+            }
             codeUnits.push(((b0 & 0x1f) << 6) | (b1 & 0x3f));
         }
         else if ((b0 & 0xf0) === 0xe0) {
@@ -106,6 +109,9 @@ function decodeMutf8(buffer, start, end) {
             }
             const b1 = buffer[i++];
             const b2 = buffer[i++];
+            if ((b1 & 0xc0) !== 0x80 || (b2 & 0xc0) !== 0x80) {
+                throw parseError("Invalid MUTF-8 continuation byte.", { offset: i - 2 });
+            }
             codeUnits.push(((b0 & 0x0f) << 12) | ((b1 & 0x3f) << 6) | (b2 & 0x3f));
         }
         else {
@@ -219,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) {
@@ -232,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) {
@@ -255,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) {
@@ -309,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 };
         }
@@ -374,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);
@@ -398,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/observability.d.ts

@@ -40,6 +40,8 @@ export interface RuntimeMetricSnapshot {
     search_rows_scanned: number;
     search_rows_returned: number;
     search_indexed_zero_shortcircuit_count: number;
+    search_like_prefilter_count: number;
+    search_scan_truncated_count: number;
     reindex_count: number;
     reindex_skip_count: number;
     cache_evictions: number;
@@ -74,6 +76,8 @@ export declare class RuntimeMetrics {
     private searchRowsScanned;
     private searchRowsReturned;
     private searchIndexedZeroShortcircuitCount;
+    private searchLikePrefilterCount;
+    private searchScanTruncatedCount;
     private reindexCount;
     private reindexSkipCount;
     private cacheEvictions;
@@ -102,6 +106,8 @@ export declare class RuntimeMetrics {
     recordSearchRowsScanned(count: number): void;
     recordSearchRowsReturned(count: number): void;
     recordSearchIndexedZeroShortcircuit(): void;
+    recordSearchLikePrefilter(): void;
+    recordSearchScanTruncated(): void;
     recordReindex(): void;
     recordReindexSkip(): void;
     recordCacheEviction(count?: number): void;

package/dist/observability.js

@@ -26,6 +26,8 @@ export class RuntimeMetrics {
     searchRowsScanned = 0;
     searchRowsReturned = 0;
     searchIndexedZeroShortcircuitCount = 0;
+    searchLikePrefilterCount = 0;
+    searchScanTruncatedCount = 0;
     reindexCount = 0;
     reindexSkipCount = 0;
     cacheEvictions = 0;
@@ -128,6 +130,12 @@ export class RuntimeMetrics {
     recordSearchIndexedZeroShortcircuit() {
         this.searchIndexedZeroShortcircuitCount += 1;
     }
+    recordSearchLikePrefilter() {
+        this.searchLikePrefilterCount += 1;
+    }
+    recordSearchScanTruncated() {
+        this.searchScanTruncatedCount += 1;
+    }
     recordReindex() {
         this.reindexCount += 1;
     }
@@ -192,6 +200,8 @@ export class RuntimeMetrics {
             search_rows_scanned: this.searchRowsScanned,
             search_rows_returned: this.searchRowsReturned,
             search_indexed_zero_shortcircuit_count: this.searchIndexedZeroShortcircuitCount,
+            search_like_prefilter_count: this.searchLikePrefilterCount,
+            search_scan_truncated_count: this.searchScanTruncatedCount,
             reindex_count: this.reindexCount,
             reindex_skip_count: this.reindexSkipCount,
             cache_evictions: this.cacheEvictions,

package/dist/page-cursor.d.ts

@@ -0,0 +1,17 @@
+export type OffsetCursor = {
+    offset: number;
+    contextKey: string;
+};
+/** Build a stable context key from the query parameters a cursor belongs to. */
+export declare function buildPageContextKey(parts: Array<string | number | boolean | undefined>): string;
+export declare function encodeOffsetCursor(offset: number, contextKey: string): string;
+export declare function decodeOffsetCursor(cursor: string | undefined): OffsetCursor | undefined;
+/**
+ * Resolve the starting offset from an incoming cursor. Returns offset 0 when the
+ * cursor is absent, malformed, or belongs to a different query context, and
+ * reports whether a provided cursor was ignored.
+ */
+export declare function resolveCursorOffset(cursor: string | undefined, contextKey: string): {
+    offset: number;
+    cursorIgnored: boolean;
+};

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

@@ -82,6 +82,25 @@ function parseRegistrySnapshot(raw, version, registryFile) {
             details: { version, registryFile }
         });
     }
+    // Every registry value must carry an `entries` object. Without this guard a
+    // malformed value slips through and later throws a raw TypeError on `.entries`
+    // (registry-service.ts:268/305, version-diff-service.ts), bypassing the
+    // corrupt-snapshot regeneration path that keys off REGISTRY_GENERATION_FAILED.
+    for (const [registryName, value] of Object.entries(parsed)) {
+        const entries = value?.entries;
+        if (typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value) ||
+            typeof entries !== "object" ||
+            entries === null ||
+            Array.isArray(entries)) {
+            throw createError({
+                code: ERROR_CODES.REGISTRY_GENERATION_FAILED,
+                message: `registries.json for version "${version}" has a malformed "${registryName}" registry (missing entries).`,
+                details: { version, registryFile, registryName }
+            });
+        }
+    }
     return parsed;
 }
 function runDataGen(serverJarPath, outputDir, version) {
@@ -107,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 = "";
@@ -175,6 +194,7 @@ export class RegistryService {
     config;
     versionService;
     registryCache = new Map();
+    loadLocks = new Map();
     constructor(config, versionService) {
         this.config = config;
         this.versionService = versionService;
@@ -251,9 +271,28 @@ 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)
+        if (cached) {
+            // LRU touch: move to most-recently-used so the bound evicts the true
+            // coldest entry (Map preserves insertion order).
+            this.registryCache.delete(version);
+            this.registryCache.set(version, cached);
             return cached;
+        }
         const registryDir = join(this.config.cacheDir, "registries", version);
         const cachedRegistries = this.loadExistingRegistries(registryDir, version, warnings);
         if (cachedRegistries) {

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