@adhisang/minecraft-modding-mcp 6.2.0 → 7.0.0-rc.0

package/dist/mapping/loaders/tiny-loom-selection.js

@@ -0,0 +1,223 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import v8 from "node:v8";
+import { pairKey } from "../parsers/normalize.js";
+import { parseTinyHeader } from "../parsers/tiny.js";
+/** Upper bound on the bytes read while sniffing a file's header line. */
+const HEADER_PROBE_BYTES = 64 * 1024;
+/**
+ * Bytes of JS heap one index slot costs, measured on Minecraft 1.21.10 loom
+ * mappings (2,080 MB peak / 6,755,994 slots ~= 323 B; the Mojang proguard index
+ * lands at 330 B). Rounded up so the derived budget errs toward stopping early.
+ */
+export const HEAP_BYTES_PER_INDEX_ENTRY = 340;
+/** Share of the heap still free at load time that a single tiny load may claim. */
+const HEAP_BUDGET_FRACTION = 0.7;
+const MIN_INDEX_ENTRY_BUDGET = 1_000_000;
+const MAX_INDEX_ENTRY_BUDGET = 64_000_000;
+/**
+ * How many index slots one Loom tiny load may accumulate before it stops and
+ * warns instead of exhausting the heap.
+ *
+ * The default is derived from the live V8 heap limit, so raising
+ * `--max-old-space-size` raises the budget automatically. `MCP_LOOM_TINY_MAX_INDEX_ENTRIES`
+ * overrides it outright.
+ */
+export function resolveTinyIndexEntryBudget(value = process.env.MCP_LOOM_TINY_MAX_INDEX_ENTRIES, heapStats = v8.getHeapStatistics()) {
+    const override = Number.parseInt(value ?? "", 10);
+    if (Number.isFinite(override) && override > 0) {
+        return override;
+    }
+    const free = Math.max(0, heapStats.heap_size_limit - heapStats.used_heap_size);
+    const derived = Math.floor((free * HEAP_BUDGET_FRACTION) / HEAP_BYTES_PER_INDEX_ENTRY);
+    return Math.min(MAX_INDEX_ENTRY_BUDGET, Math.max(MIN_INDEX_ENTRY_BUDGET, derived));
+}
+/**
+ * Read just the first line of a tiny file and derive its namespace layout.
+ * Returns `undefined` for anything {@link parseTinyHeader} rejects, so the body
+ * of an unusable file is never read.
+ */
+export async function readTinyFileCandidate(path) {
+    let handle;
+    try {
+        const info = await stat(path);
+        if (!info.isFile() || info.size === 0) {
+            return undefined;
+        }
+        handle = await open(path, "r");
+        const buffer = Buffer.allocUnsafe(Math.min(HEADER_PROBE_BYTES, info.size));
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        const chunk = buffer.subarray(0, bytesRead).toString("utf8");
+        const newlineIndex = chunk.search(/\r?\n/);
+        // A file whose first line does not fit the probe cannot be a tiny header.
+        const headerLine = newlineIndex >= 0 ? chunk.slice(0, newlineIndex) : bytesRead < HEADER_PROBE_BYTES ? chunk : "";
+        const header = parseTinyHeader(headerLine);
+        if (!header) {
+            return undefined;
+        }
+        return {
+            path,
+            bytes: info.size,
+            descriptorNamespace: header.descriptorNamespace,
+            namespaces: header.namespaces
+        };
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function hashFile(path) {
+    try {
+        const hash = createHash("sha256");
+        for await (const chunk of createReadStream(path)) {
+            hash.update(chunk);
+        }
+        return hash.digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Every ordered namespace pair a candidate's rows would populate. */
+export function candidatePairKeys(candidate) {
+    const keys = [];
+    for (const from of candidate.namespaces) {
+        for (const to of candidate.namespaces) {
+            if (from !== to) {
+                keys.push(pairKey(from, to));
+            }
+        }
+    }
+    return keys;
+}
+/**
+ * Richest first: more namespaces beats fewer; then a file whose descriptors are
+ * written in obfuscated coordinates beats one that is not, because that is the
+ * form callers query with and the form every other tiny source this server reads
+ * (Fabric intermediary and yarn artifacts, the Maven loader) produces; then larger
+ * beats smaller; then path order so the result never depends on filesystem
+ * enumeration order.
+ *
+ * The descriptor-coordinate rule also decides which rendering becomes the one the
+ * descriptor-conflict filter measures the rest against, so it must come before size:
+ * Loom's `mappings-base.tiny` is written with `intermediary` first AND is the larger
+ * file, and letting it win would leave the whole index carrying intermediary-coordinate
+ * descriptors.
+ */
+export function compareCandidates(left, right) {
+    if (left.namespaces.length !== right.namespaces.length) {
+        return right.namespaces.length - left.namespaces.length;
+    }
+    const leftCanonical = left.descriptorNamespace === "obfuscated" ? 1 : 0;
+    const rightCanonical = right.descriptorNamespace === "obfuscated" ? 1 : 0;
+    if (leftCanonical !== rightCanonical) {
+        return rightCanonical - leftCanonical;
+    }
+    if (left.bytes !== right.bytes) {
+        return right.bytes - left.bytes;
+    }
+    return left.path.localeCompare(right.path);
+}
+/**
+ * Decide which of the discovered tiny files to merge.
+ *
+ * Loom keeps several renderings of one layered mapping set side by side in one
+ * output directory: the final `mappings.tiny`, a `-mojang` rendering with an extra
+ * column, `-migrated` renderings per loader build, and a `mappings-base.tiny`
+ * written with the namespace columns rotated. Two filters apply:
+ *
+ * 1. Byte-identical files are collapsed. Loom copies the same rendering into every
+ *    layered variant directory, so re-reading them is pure repeated work.
+ * 2. A file is dropped as an alternative rendering when ALL of the following hold:
+ *    it declares its descriptors in a different namespace than the rendering
+ *    already chosen, it sits in a directory that already yielded a selected file,
+ *    and every namespace pair it carries is already covered. Tiny v2 writes each
+ *    descriptor once, in the file's first namespace; merging an `intermediary`-first
+ *    rendering into an `official`-first index registers every method a second time
+ *    under an incompatible descriptor, which turns unique lookups into ambiguous
+ *    ones. All three conditions are required so that a genuinely different mapping
+ *    file — a standalone yarn tiny, a cache in another Gradle root — is never
+ *    mistaken for a rendering of data already loaded.
+ */
+export async function selectTinyFiles(paths) {
+    const candidates = [];
+    const unsupported = [];
+    for (const path of paths) {
+        const candidate = await readTinyFileCandidate(path);
+        if (candidate) {
+            candidates.push(candidate);
+        }
+        else {
+            unsupported.push(path);
+        }
+    }
+    candidates.sort(compareCandidates);
+    // Only equal-sized files can be byte-identical, so hash nothing unless a size
+    // actually collides.
+    const sizeCounts = new Map();
+    for (const candidate of candidates) {
+        sizeCounts.set(candidate.bytes, (sizeCounts.get(candidate.bytes) ?? 0) + 1);
+    }
+    const hashes = new Map();
+    const directoriesByHash = new Map();
+    for (const candidate of candidates) {
+        if ((sizeCounts.get(candidate.bytes) ?? 0) < 2) {
+            continue;
+        }
+        const digest = await hashFile(candidate.path);
+        if (!digest) {
+            continue;
+        }
+        const hash = `${candidate.bytes}:${digest}`;
+        hashes.set(candidate.path, hash);
+        const directories = directoriesByHash.get(hash) ?? new Set();
+        directories.add(dirname(candidate.path));
+        directoriesByHash.set(hash, directories);
+    }
+    const selected = [];
+    const descriptorConflicts = [];
+    const duplicateOf = new Map();
+    const seenHashes = new Map();
+    const coveredPairs = new Set();
+    // Directories a selected rendering was read from, including the directories its
+    // byte-identical copies live in: any of them may hold sibling renderings.
+    const renderedDirectories = new Set();
+    let descriptorNamespace;
+    for (const candidate of candidates) {
+        const hash = hashes.get(candidate.path);
+        if (hash) {
+            const previous = seenHashes.get(hash);
+            if (previous) {
+                duplicateOf.set(candidate.path, previous);
+                continue;
+            }
+            seenHashes.set(hash, candidate.path);
+        }
+        const pairs = candidatePairKeys(candidate);
+        if (descriptorNamespace != null &&
+            candidate.descriptorNamespace !== descriptorNamespace &&
+            renderedDirectories.has(dirname(candidate.path)) &&
+            pairs.every((key) => coveredPairs.has(key))) {
+            descriptorConflicts.push(candidate);
+            continue;
+        }
+        descriptorNamespace ??= candidate.descriptorNamespace;
+        for (const key of pairs) {
+            coveredPairs.add(key);
+        }
+        renderedDirectories.add(dirname(candidate.path));
+        if (hash) {
+            for (const directory of directoriesByHash.get(hash) ?? []) {
+                renderedDirectories.add(directory);
+            }
+        }
+        selected.push(candidate);
+    }
+    return { selected, duplicateOf, descriptorConflicts, unsupported };
+}
+//# sourceMappingURL=tiny-loom-selection.js.map

package/dist/mapping/loaders/tiny-loom.js

@@ -4,15 +4,14 @@ import { join } from "node:path";
 import fastGlob from "fast-glob";
 import { buildVersionSourceSearchRoots } from "../../gradle-paths.js";
 import { effectiveLoomSearchProjectPath } from "../lookup.js";
-import { mergeDirectionIndexes } from "../parsers/symbol-records.js";
-import { parseTinyMappings } from "../parsers/tiny.js";
+import { parseTinyMappingsInto } from "../parsers/tiny.js";
+import { resolveTinyIndexEntryBudget, selectTinyFiles } from "./tiny-loom-selection.js";
 const GLOB_SPECIAL_CHARS = /[\\!*+?()[\]{}@|]/g;
 export async function loadTinyPairsFromLoom(version, projectPath, gradleUserHome) {
     const searchRoots = buildVersionSourceSearchRoots({
         projectPath: effectiveLoomSearchProjectPath(projectPath),
         gradleUserHome
     });
-    const merged = new Map();
     const discoveredPaths = new Set();
     for (const root of searchRoots) {
         let discovered = [];
@@ -33,44 +32,57 @@ export async function loadTinyPairsFromLoom(version, projectPath, gradleUserHome
         catch {
             continue;
         }
-        const byVersion = discovered
-            .filter((path) => path.replaceAll("\\", "/").includes(`/${version}/`))
-            .sort((left, right) => left.localeCompare(right));
-        if (byVersion.length === 0) {
-            continue;
-        }
-        for (const path of byVersion) {
-            discoveredPaths.add(path);
-            try {
-                const content = await readFile(path, "utf8");
-                const parsed = parseTinyMappings(content);
-                for (const [key, index] of parsed.entries()) {
-                    const existing = merged.get(key);
-                    if (!existing) {
-                        merged.set(key, index);
-                    }
-                    else {
-                        mergeDirectionIndexes(existing, index);
-                    }
-                }
-            }
-            catch {
-                // best effort: skip unreadable or invalid files
+        for (const path of discovered) {
+            if (path.replaceAll("\\", "/").includes(`/${version}/`)) {
+                discoveredPaths.add(path);
             }
         }
     }
     const orderedPaths = [...discoveredPaths].sort((left, right) => left.localeCompare(right));
-    if (orderedPaths.length > 0) {
+    if (orderedPaths.length === 0) {
         return {
-            pairs: merged,
-            warnings: [],
-            mappingArtifact: orderedPaths[0]
+            pairs: new Map(),
+            warnings: [`No Loom tiny mapping files matched version "${version}".`],
+            mappingArtifact: "loom-cache:none"
         };
     }
+    // Read headers only, then drop byte-identical copies and descriptor-namespace
+    // conflicts before any file body is loaded. See tiny-loom-selection.ts.
+    const selection = await selectTinyFiles(orderedPaths);
+    const warnings = [];
+    const merged = new Map();
+    const maxIndexEntries = resolveTinyIndexEntryBudget();
+    const mergedPaths = [];
+    let truncatedAt;
+    for (const candidate of selection.selected) {
+        if (truncatedAt) {
+            break;
+        }
+        try {
+            const content = await readFile(candidate.path, "utf8");
+            const result = parseTinyMappingsInto(merged, content, { maxIndexEntries });
+            if (result.parsed) {
+                mergedPaths.push(candidate.path);
+            }
+            if (result.truncated) {
+                truncatedAt = candidate.path;
+            }
+        }
+        catch {
+            // best effort: skip unreadable or invalid files
+        }
+    }
+    if (truncatedAt) {
+        const skipped = selection.selected.length - mergedPaths.length;
+        warnings.push(`Loom tiny mappings for "${version}" hit the ${maxIndexEntries}-entry index budget while reading "${truncatedAt}"; ` +
+            `${skipped} of ${selection.selected.length} selected file(s) were left unread and some symbols may be missing. ` +
+            `Raise MCP_LOOM_TINY_MAX_INDEX_ENTRIES or start the server with a larger --max-old-space-size.`);
+    }
     return {
-        pairs: new Map(),
-        warnings: [`No Loom tiny mapping files matched version "${version}".`],
-        mappingArtifact: "loom-cache:none"
+        pairs: merged,
+        warnings,
+        // The richest merged file, not merely the alphabetically first discovered one.
+        mappingArtifact: mergedPaths[0] ?? orderedPaths[0]
     };
 }
 //# sourceMappingURL=tiny-loom.js.map

package/dist/mapping/loaders/tiny-maven.js

@@ -1,7 +1,7 @@
 import { defaultDownloadPath, downloadToCache } from "../../repo-downloader.js";
 import { collectMatchedJarEntriesAsUtf8 } from "../../source-jar-reader.js";
 import { mergeDirectionIndexes } from "../parsers/symbol-records.js";
-import { parseTinyMappings } from "../parsers/tiny.js";
+import { parseTinyMappingsInto } from "../parsers/tiny.js";
 async function fetchYarnCoordinates(fetchFn, repoBase, version) {
     const metadataUrl = `${repoBase}/net/fabricmc/yarn/maven-metadata.xml`;
     try {
@@ -29,19 +29,14 @@ async function fetchYarnCoordinates(fetchFn, repoBase, version) {
 }
 async function parseTinyFromJar(jarPath) {
     const tinyEntries = (await collectMatchedJarEntriesAsUtf8(jarPath, (entry) => entry.toLowerCase().endsWith(".tiny") || entry.toLowerCase().endsWith(".tinyv2"), { continueOnError: true })).sort((left, right) => left.filePath.localeCompare(right.filePath));
+    // Parsed straight into the shared accumulator: a parse-then-merge loop would
+    // hold each entry's full index alongside the accumulated one. `ensurePairIndex`
+    // + `addLookupEntries` union into what is already there, matching what
+    // `mergeDirectionIndexes` did.
     const merged = new Map();
     for (const entry of tinyEntries) {
         try {
-            const parsed = parseTinyMappings(entry.content);
-            for (const [key, index] of parsed.entries()) {
-                const existing = merged.get(key);
-                if (!existing) {
-                    merged.set(key, index);
-                }
-                else {
-                    mergeDirectionIndexes(existing, index);
-                }
-            }
+            parseTinyMappingsInto(merged, entry.content);
         }
         catch {
             // skip malformed tiny entries

package/dist/mapping/parsers/tiny.d.ts

@@ -5,5 +5,62 @@
 import type { SourceMapping } from "../../types.js";
 import type { DirectionIndex, MappingSymbolRecord, PairKey } from "../internal-types.js";
 export declare function normalizeTinyNamespace(namespace: string): SourceMapping | undefined;
+/**
+ * Namespace layout of a tiny v2 file, derivable from the header line alone.
+ *
+ * `descriptorNamespace` identifies the FIRST namespace column, normalized when this
+ * server recognizes it (so `official` and `obfuscated` compare equal) and otherwise
+ * the raw lower-cased token. Tiny v2 stores every field/method descriptor in that
+ * namespace's coordinates and never repeats it per namespace, so two files whose
+ * first column differs describe the same members with mutually incompatible
+ * descriptors. Callers that merge several files into one index must compare this
+ * value — see `src/mapping/loaders/tiny-loom-selection.ts`.
+ */
+export type TinyHeader = {
+    descriptorNamespace: SourceMapping | string;
+    /** Recognized namespaces paired with their data-column offset, in file order. */
+    columns: Array<{
+        mapping: SourceMapping;
+        columnIndex: number;
+    }>;
+    /** Distinct recognized namespaces, in file order. */
+    namespaces: SourceMapping[];
+};
+/**
+ * Parse only the header line of a tiny v2 file. Returns `undefined` when the line
+ * is not a tiny v2 header or declares fewer than two namespaces this server knows,
+ * which is exactly when {@link parseTinyMappingsInto} would contribute nothing.
+ * Lets callers classify a file without reading its body.
+ */
+export declare function parseTinyHeader(headerLine: string): TinyHeader | undefined;
 export declare function addPairRecords(target: Map<PairKey, DirectionIndex>, records: Map<SourceMapping, MappingSymbolRecord>): void;
+/** Total number of index slots held by a pair map; the unit the parse budget counts. */
+export declare function countIndexEntries(pairs: Map<PairKey, DirectionIndex>): number;
+export type TinyParseOptions = {
+    /**
+     * Stop parsing once the target holds this many index slots (see
+     * {@link countIndexEntries}). Guards a single unbounded accumulator against
+     * caches large enough to exhaust the V8 heap. Omit for no bound.
+     */
+    maxIndexEntries?: number;
+};
+export type TinyParseResult = {
+    /** False when the header was not usable, so nothing was added. */
+    parsed: boolean;
+    /** True when `maxIndexEntries` stopped the parse before the last line. */
+    truncated: boolean;
+    /** Index slots held by the target after this parse. */
+    indexEntries: number;
+};
+/**
+ * Parse `text` directly into `target`.
+ *
+ * Writing into the caller's accumulator rather than into a private map and
+ * merging afterwards is what keeps multi-file loads inside the heap: a
+ * parse-then-merge loop holds the whole per-file index AND the accumulated index
+ * at the same time, roughly doubling peak usage on the largest file. Merging is
+ * not lost — `ensurePairIndex` + `addLookupEntries` union into whatever is
+ * already present, which is precisely what `mergeDirectionIndexes` did.
+ */
+export declare function parseTinyMappingsInto(target: Map<PairKey, DirectionIndex>, text: string, options?: TinyParseOptions): TinyParseResult;
 export declare function parseTinyMappings(text: string): Map<PairKey, DirectionIndex>;

package/dist/mapping/parsers/tiny.js

@@ -20,6 +20,40 @@ export function normalizeTinyNamespace(namespace) {
     }
     return undefined;
 }
+/**
+ * Parse only the header line of a tiny v2 file. Returns `undefined` when the line
+ * is not a tiny v2 header or declares fewer than two namespaces this server knows,
+ * which is exactly when {@link parseTinyMappingsInto} would contribute nothing.
+ * Lets callers classify a file without reading its body.
+ */
+export function parseTinyHeader(headerLine) {
+    const header = headerLine.split("\t");
+    if (header.length < 5 || header[0] !== "tiny" || header[1] !== "2") {
+        return undefined;
+    }
+    const columns = header
+        .slice(3)
+        .map((namespace, index) => ({
+        mapping: normalizeTinyNamespace(namespace),
+        columnIndex: index + 1
+    }))
+        .filter((entry) => entry.mapping != null);
+    if (columns.length < 2) {
+        return undefined;
+    }
+    const namespaces = [];
+    for (const column of columns) {
+        if (!namespaces.includes(column.mapping)) {
+            namespaces.push(column.mapping);
+        }
+    }
+    const rawDescriptorNamespace = header[3].trim().toLowerCase();
+    return {
+        descriptorNamespace: normalizeTinyNamespace(rawDescriptorNamespace) ?? rawDescriptorNamespace,
+        columns,
+        namespaces
+    };
+}
 export function addPairRecords(target, records) {
     for (const [sourceMapping, sourceRecord] of records.entries()) {
         for (const [targetMapping, targetRecord] of records.entries()) {
@@ -30,30 +64,68 @@ export function addPairRecords(target, records) {
         }
     }
 }
-export function parseTinyMappings(text) {
-    const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
-    if (lines.length === 0) {
-        return new Map();
+/** Total number of index slots held by a pair map; the unit the parse budget counts. */
+export function countIndexEntries(pairs) {
+    let total = 0;
+    for (const index of pairs.values()) {
+        total += index.exact.size + index.normalized.size + index.simple.size + index.records.size;
     }
-    const header = lines[0].split("\t");
-    if (header.length < 5 || header[0] !== "tiny" || header[1] !== "2") {
-        return new Map();
+    return total;
+}
+/** How often the running index size is re-measured while parsing. */
+const BUDGET_CHECK_INTERVAL = 512;
+/**
+ * Parse `text` directly into `target`.
+ *
+ * Writing into the caller's accumulator rather than into a private map and
+ * merging afterwards is what keeps multi-file loads inside the heap: a
+ * parse-then-merge loop holds the whole per-file index AND the accumulated index
+ * at the same time, roughly doubling peak usage on the largest file. Merging is
+ * not lost — `ensurePairIndex` + `addLookupEntries` union into whatever is
+ * already present, which is precisely what `mergeDirectionIndexes` did.
+ */
+export function parseTinyMappingsInto(target, text, options) {
+    const budget = options?.maxIndexEntries;
+    const lines = text.split(/\r?\n/);
+    let headerIndex = -1;
+    for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index].trim().length > 0) {
+            headerIndex = index;
+            break;
+        }
     }
-    const namespaceColumns = header.slice(3).map((namespace, index) => ({
-        mapping: normalizeTinyNamespace(namespace),
-        columnIndex: index + 1
-    }));
-    const recognized = namespaceColumns.filter((entry) => entry.mapping != null);
-    if (recognized.length < 2) {
-        return new Map();
+    if (headerIndex < 0) {
+        return { parsed: false, truncated: false, indexEntries: countIndexEntries(target) };
+    }
+    const header = parseTinyHeader(lines[headerIndex]);
+    if (!header) {
+        return { parsed: false, truncated: false, indexEntries: countIndexEntries(target) };
+    }
+    let entries = countIndexEntries(target);
+    if (budget != null && entries >= budget) {
+        return { parsed: true, truncated: true, indexEntries: entries };
     }
-    const result = new Map();
     const currentClassNames = new Map();
-    for (const line of lines.slice(1)) {
+    let sinceBudgetCheck = 0;
+    for (let lineIndex = headerIndex + 1; lineIndex < lines.length; lineIndex += 1) {
+        const line = lines[lineIndex];
+        if (line.trim().length === 0) {
+            continue;
+        }
+        if (budget != null) {
+            sinceBudgetCheck += 1;
+            if (sinceBudgetCheck >= BUDGET_CHECK_INTERVAL) {
+                sinceBudgetCheck = 0;
+                entries = countIndexEntries(target);
+                if (entries >= budget) {
+                    return { parsed: true, truncated: true, indexEntries: entries };
+                }
+            }
+        }
         const columns = line.split("\t");
         if (columns[0] === "c") {
             const classRecords = new Map();
-            for (const namespace of recognized) {
+            for (const namespace of header.columns) {
                 const value = columns[namespace.columnIndex]?.trim() ?? "";
                 if (!value) {
                     continue;
@@ -61,12 +133,12 @@ export function parseTinyMappings(text) {
                 currentClassNames.set(namespace.mapping, value);
                 classRecords.set(namespace.mapping, createClassSymbolRecord(value));
             }
-            addPairRecords(result, classRecords);
+            addPairRecords(target, classRecords);
             continue;
         }
         if (columns[0] === "" && columns[1] === "f") {
             const fieldRecords = new Map();
-            for (const namespace of recognized) {
+            for (const namespace of header.columns) {
                 const owner = currentClassNames.get(namespace.mapping);
                 const value = columns[namespace.columnIndex + 2]?.trim() ?? "";
                 if (!owner || !value) {
@@ -74,13 +146,13 @@ export function parseTinyMappings(text) {
                 }
                 fieldRecords.set(namespace.mapping, createFieldSymbolRecord(owner, value));
             }
-            addPairRecords(result, fieldRecords);
+            addPairRecords(target, fieldRecords);
             continue;
         }
         if (columns[0] === "" && columns[1] === "m") {
             const descriptor = columns[2]?.trim() || undefined;
             const methodRecords = new Map();
-            for (const namespace of recognized) {
+            for (const namespace of header.columns) {
                 const owner = currentClassNames.get(namespace.mapping);
                 const value = columns[namespace.columnIndex + 2]?.trim() ?? "";
                 if (!owner || !value) {
@@ -88,9 +160,14 @@ export function parseTinyMappings(text) {
                 }
                 methodRecords.set(namespace.mapping, createMethodSymbolRecord(owner, value, descriptor));
             }
-            addPairRecords(result, methodRecords);
+            addPairRecords(target, methodRecords);
         }
     }
+    return { parsed: true, truncated: false, indexEntries: countIndexEntries(target) };
+}
+export function parseTinyMappings(text) {
+    const result = new Map();
+    parseTinyMappingsInto(result, text);
     return result;
 }
 //# sourceMappingURL=tiny.js.map

package/dist/mapping-service.d.ts

@@ -37,6 +37,25 @@ export declare class MappingService {
     checkSymbolExists(input: SymbolExistenceInput): Promise<SymbolExistenceOutput>;
     private mapRecordBetweenMappings;
     private mapCandidatesAlongPath;
+    /**
+     * The owner names that a query owner is allowed to appear under once candidates have
+     * been projected along `path`.
+     *
+     * The query owner arrives in the SOURCE namespace while `mapCandidatesAlongPath`
+     * hands back records whose `owner` is the declaring class in the TARGET namespace
+     * (both parsers build member records with `createMethodSymbolRecord(<owner in that
+     * namespace>, ...)`), so the two are only comparable after the owner itself has been
+     * carried along the same path. Projecting the owner as a class record through
+     * `mapCandidatesAlongPath` is that carriage, and it is the same mechanism
+     * `projectMethodDescriptorToTarget` already uses for class references inside a
+     * descriptor.
+     *
+     * `simple-name` class matches are excluded on purpose: they mean "some other class
+     * that happens to share this simple name", which is exactly the foreign-owner noise
+     * the strict filter exists to remove. The source-namespace name is kept as an
+     * accepted alias so an owner that the mapping does not rename still matches itself.
+     */
+    private acceptedOwnersAlongPath;
     private projectMethodDescriptorToTarget;
     private provenanceForPath;
     /**