@adhisang/minecraft-modding-mcp 5.0.0 → 6.1.0

package/dist/mapping-service.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
 import { buildSuggestedCall } from "./build-suggested-call.js";
 import { createError, ERROR_CODES } from "./errors.js";
 import { buildPageContextKey, encodeOffsetCursor, resolveCursorOffset } from "./page-cursor.js";
@@ -11,7 +12,7 @@ import { VersionService, isUnobfuscatedVersion } from "./version-service.js";
 import { buildSymbolKey, createClassSymbolRecord, mergeDirectionIndexes, normalizeMappedSymbolOutput } from "./mapping/parsers/symbol-records.js";
 import { buildAdjacency, buildTargetRecordIndex, pairKey } from "./mapping/parsers/normalize.js";
 import { MATCH_RANK, MAX_CANDIDATES } from "./mapping/internal-types.js";
-import { applyDisambiguationHints, clampRowLimit, collectTargetRecords, effectiveLoomSearchProjectPath, inferAmbiguityReasons, invalidInputError, limitResolutionCandidates, lookupCandidates, mappingPriorityFromInput, mappingSourceOrder, namespacePath, normalizeIncludedKinds, normalizeQuerySymbol, pathToTransformChain, pathUsesSource, projectLookupCandidateDescriptor, requiresOnlyObfuscatedMojangGraph, toLookupCandidate, toResolutionCandidate } from "./mapping/lookup.js";
+import { applyDisambiguationHints, clampRowLimit, collectExactRecordIndex, collectTargetRecords, effectiveLoomSearchProjectPath, inferAmbiguityReasons, invalidInputError, limitResolutionCandidates, lookupCandidates, lookupExactClassBySimpleName, lookupExactClassBySymbol, lookupExactMembers, lookupExactMembersByOwner, mappingPriorityFromInput, mappingSourceOrder, namespacePath, normalizeIncludedKinds, normalizeQuerySymbol, pathToTransformChain, pathUsesSource, projectLookupCandidateDescriptor, requiresOnlyObfuscatedMojangGraph, toLookupCandidate, toResolutionCandidate } from "./mapping/lookup.js";
 import { loadMojangPairs } from "./mapping/loaders/mojang.js";
 import { loadTinyPairsFromLoom } from "./mapping/loaders/tiny-loom.js";
 import { loadTinyPairsFromMaven } from "./mapping/loaders/tiny-maven.js";
@@ -375,7 +376,13 @@ export class MappingService {
         const candidates = rawCandidates.map(toResolutionCandidate);
         const limitedCandidates = limitResolutionCandidates(candidates, input.maxCandidates);
         const strictDescriptor = projectedDescriptor ?? descriptor;
-        const strictCandidates = rawCandidates.filter((candidate) => candidate.descriptor === strictDescriptor);
+        const acceptedDescriptors = new Set([descriptor, strictDescriptor]);
+        const toObfuscatedPath = namespacePath(graph, sourceMapping, "obfuscated");
+        if (toObfuscatedPath) {
+            const obfuscatedProjection = this.projectMethodDescriptorToTarget(graph, toObfuscatedPath, descriptor);
+            acceptedDescriptors.add(obfuscatedProjection.descriptor);
+        }
+        const strictCandidates = rawCandidates.filter((candidate) => candidate.descriptor !== undefined && acceptedDescriptors.has(candidate.descriptor));
         if (strictCandidates.length === 1) {
             const resolved = toResolutionCandidate(strictCandidates[0]);
             return {
@@ -510,18 +517,18 @@ export class MappingService {
                 warnings
             };
         }
-        const baseRecords = collectTargetRecords(graph, baseMapping).filter((record) => {
-            if (record.kind === "class") {
-                return includeKinds.has("class") && record.symbol === baseClass.symbol;
-            }
-            if (record.owner !== baseClass.symbol) {
-                return false;
+        const exactIndex = collectExactRecordIndex(graph, baseMapping);
+        const baseRecords = [];
+        if (includeKinds.has("class")) {
+            for (const record of lookupExactClassBySymbol(exactIndex, baseClass.symbol)) {
+                baseRecords.push(record);
             }
-            if (record.kind === "field") {
-                return includeKinds.has("field");
+        }
+        for (const record of lookupExactMembersByOwner(exactIndex, baseClass.symbol)) {
+            if (record.kind === "field" ? includeKinds.has("field") : includeKinds.has("method")) {
+                baseRecords.push(record);
             }
-            return includeKinds.has("method");
-        });
+        }
         const rowKindOrder = {
             class: 0,
             field: 1,
@@ -564,7 +571,8 @@ export class MappingService {
             className,
             classNameMapping,
             (input.includeKinds ?? []).join(","),
-            input.sourcePriority
+            input.sourcePriority,
+            resolveGradleUserHomePath(input.gradleUserHome)
         ]);
         const { offset: rowOffset, cursorIgnored: rowCursorIgnored } = resolveCursorOffset(input.cursor, rowCursorContext);
         const windowBase = rowLimit != null ? dedupedBase.slice(rowOffset, rowOffset + rowLimit) : dedupedBase.slice(rowOffset);
@@ -573,7 +581,7 @@ export class MappingService {
         const nextCursor = rowsTruncated ? encodeOffsetCursor(consumedRows, rowCursorContext) : undefined;
         // Map ONLY the requested window. Per-row mapping cost is therefore O(window),
         // not O(rowCount). warnings/ambiguousRowCount are accordingly page-scoped on
-        // paginated calls (caveat B1) and byte-identical to the old full-set values when
+        // paginated calls and byte-identical to the old full-set values when
         // no maxRows/cursor narrows the window.
         const rows = [];
         let ambiguousRowCount = 0;
@@ -709,7 +717,9 @@ export class MappingService {
                 };
             })()
             : (() => {
-                const { record: queryRecord, querySymbol } = normalizeQuerySymbol(input, effectiveSignatureMode);
+                const { record: queryRecord, querySymbol } = normalizeQuerySymbol(input, effectiveSignatureMode, {
+                    allowShortClassName: input.kind === "class" && sourceMapping === "obfuscated"
+                });
                 return {
                     mode: "strict",
                     queryRecord,
@@ -730,6 +740,7 @@ export class MappingService {
                 warnings
             };
         }
+        const exactIndex = collectExactRecordIndex(graph, sourceMapping);
         const buildOutput = (querySymbol, matched, status) => {
             const candidates = matched.map((record) => toResolutionCandidate(toLookupCandidate(record)));
             const limitedCandidates = limitResolutionCandidates(candidates, input.maxCandidates);
@@ -751,11 +762,11 @@ export class MappingService {
         if (normalizedQuery.mode === "auto-class") {
             const autoClassName = normalizedQuery.className;
             if (autoClassName.includes(".")) {
-                const matched = records.filter((record) => record.kind === "class" && record.symbol === autoClassName);
+                const matched = lookupExactClassBySymbol(exactIndex, autoClassName);
                 const status = matched.length === 1 ? "resolved" : matched.length > 1 ? "ambiguous" : "not_found";
                 return buildOutput(normalizedQuery.querySymbol, matched, status);
             }
-            const matched = records.filter((record) => record.kind === "class" && record.name === autoClassName);
+            const matched = lookupExactClassBySimpleName(exactIndex, autoClassName);
             const status = matched.length === 1 ? "resolved" : matched.length > 1 ? "ambiguous" : "not_found";
             if (status === "ambiguous") {
                 warnings.push(`Multiple class symbols matched short name "${autoClassName}". Provide fully-qualified class name.`);
@@ -764,16 +775,16 @@ export class MappingService {
         }
         const { queryRecord, querySymbol } = normalizedQuery;
         if (queryRecord.kind === "class") {
-            const matched = records.filter((record) => record.kind === "class" && record.symbol === queryRecord.symbol);
+            const matched = lookupExactClassBySymbol(exactIndex, queryRecord.symbol);
             const status = matched.length === 1 ? "resolved" : matched.length > 1 ? "ambiguous" : "not_found";
             return buildOutput(querySymbol, matched, status);
         }
         if (queryRecord.kind === "field") {
-            const matched = records.filter((record) => record.kind === "field" && record.owner === queryRecord.owner && record.name === queryRecord.name);
+            const matched = lookupExactMembers(exactIndex, "field", queryRecord.owner ?? "", queryRecord.name);
             const status = matched.length === 1 ? "resolved" : matched.length > 1 ? "ambiguous" : "not_found";
             return buildOutput(querySymbol, matched, status);
         }
-        const methodCandidates = records.filter((record) => record.kind === "method" && record.owner === queryRecord.owner && record.name === queryRecord.name);
+        const methodCandidates = lookupExactMembers(exactIndex, "method", queryRecord.owner ?? "", queryRecord.name);
         // name-only mode: skip descriptor matching, resolve by owner+name
         if (effectiveSignatureMode === "name-only") {
             const status = methodCandidates.length === 1 ? "resolved" : methodCandidates.length > 1 ? "ambiguous" : "not_found";
@@ -1102,6 +1113,7 @@ export class MappingService {
                 adjacency: new Map(),
                 pathCache: new Map(),
                 recordsByTarget: new Map(),
+                exactRecordIndex: new Map(),
                 classProjectionCache: new Map(),
                 warnings: [
                     `Version ${version} is unobfuscated; mapping graph is empty because the runtime already uses deobfuscated names.`
@@ -1116,6 +1128,7 @@ export class MappingService {
             adjacency: new Map(),
             pathCache: new Map(),
             recordsByTarget: new Map(),
+            exactRecordIndex: new Map(),
             classProjectionCache: new Map(),
             warnings: []
         };
@@ -1282,7 +1295,9 @@ async function extractTinyFromJar(jarPath, outputPath) {
         return false;
     }
     await mkdir(dirname(outputPath), { recursive: true });
-    await writeFile(outputPath, tinyEntry.content, "utf8");
+    const tempPath = `${outputPath}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(tempPath, tinyEntry.content, "utf8");
+    await rename(tempPath, outputPath);
     return true;
 }
 /**

package/dist/minecraft-explorer-service.js

@@ -2,6 +2,7 @@ import { createError, ERROR_CODES } from "./errors.js";
 import { loadConfig } from "./config.js";
 import { artifactSignatureFromFile, normalizeJarPath } from "./path-resolver.js";
 import { createJarEntryReader } from "./source-jar-reader.js";
+import { matchesMemberPattern } from "./source/member-pattern.js";
 const CLASSFILE_MAGIC = 0xcafebabe;
 const MAX_INHERITANCE_DEPTH = 64;
 const ACC_PUBLIC = 0x0001;
@@ -603,7 +604,7 @@ export class MinecraftExplorerService {
             if (access === "public" && !hasPublicVisibility(member.accessFlags)) {
                 return false;
             }
-            if (memberPattern && !lower(member.name).includes(memberPattern)) {
+            if (memberPattern && !matchesMemberPattern(member.name, memberPattern)) {
                 return false;
             }
             return true;

package/dist/mixin/annotation-validators.js

@@ -6,8 +6,26 @@ export function validateInjection(inj, targetMembers, targetNames, issues, resol
             continue;
         const methodNames = allMethodNames(members);
         // Strip owner prefix and JVM descriptor from the method reference
-        const methodName = extractMethodName(inj.method);
-        if (!methodNames.includes(methodName)) {
+        const rawMethodName = extractMethodName(inj.method);
+        // Strip a trailing target-selector quantifier (e.g. "tick*", "tick+", "tick{2,3}")
+        const quantifier = /(?:\*|\+|\{\d+(?:,\d+)?\})$/.exec(rawMethodName)?.[0];
+        const methodName = quantifier
+            ? rawMethodName.slice(0, rawMethodName.length - quantifier.length)
+            : rawMethodName;
+        if (quantifier && methodName === "") {
+            // Bare wildcard selector (e.g. method = "*") matches everything; unverifiable.
+            resolvedMembers.push({
+                annotation: `@${inj.annotation}`,
+                name: rawMethodName,
+                line: inj.line,
+                status: "skipped"
+            });
+            continue;
+        }
+        const matched = (quantifier === "*" || quantifier === "+")
+            ? methodNames.some((n) => n.startsWith(methodName))
+            : methodNames.includes(methodName);
+        if (!matched) {
             const suggestions = suggestSimilar(methodName, methodNames);
             const descriptor = extractMethodDescriptor(inj.method);
             const descriptorHint = descriptor ? ` (descriptor: ${descriptor})` : "";
@@ -46,7 +64,7 @@ export function validateInjection(inj, targetMembers, targetNames, issues, resol
             // Name matched. If the reference carries a JVM descriptor, require an
             // overload to match it; otherwise a wrong-signature target (e.g. tick(D)V
             // when only tick(I)V exists) is silently reported as resolved.
-            const refDescriptor = extractMethodDescriptor(inj.method);
+            const refDescriptor = quantifier ? undefined : extractMethodDescriptor(inj.method);
             const sameNameMembers = [...members.constructors, ...members.methods].filter((member) => member.name === methodName);
             if (refDescriptor &&
                 sameNameMembers.length > 0 &&

package/dist/mixin/parsed-validator.js

@@ -27,6 +27,7 @@ export function validateParsedMixin(parsed, targetMembers, warnings, provenance,
                     resolutionPath: "target-mapping-failed",
                     falsePositiveRisk: healthReport?.overallHealthy === false ? "high" : "medium"
                 });
+                addSkippedMembers(parsed, resolvedMembers);
             }
             else if (symbolExistsButSignatureFailed?.has(target.className)) {
                 // Symbol exists in mapping graph but getSignature failed — tool limitation, not code issue

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.", {