@adhisang/minecraft-modding-mcp 1.0.0

package/dist/storage/symbols-repo.js

@@ -0,0 +1,401 @@
+import { log } from "../logger.js";
+function toSymbolRow(artifactId, item) {
+    return {
+        artifactId,
+        filePath: item.filePath,
+        symbolKind: item.symbolKind,
+        symbolName: item.symbolName,
+        qualifiedName: item.qualifiedName,
+        line: item.line
+    };
+}
+function encodeCursor(symbolName, filePath, line) {
+    return Buffer.from(JSON.stringify({ symbolName, filePath, line }), "utf8").toString("base64");
+}
+function decodeCursor(cursor) {
+    if (!cursor) {
+        return undefined;
+    }
+    try {
+        const decoded = Buffer.from(cursor, "base64").toString("utf8");
+        const parsed = JSON.parse(decoded);
+        if (typeof parsed.symbolName !== "string" ||
+            typeof parsed.filePath !== "string" ||
+            typeof parsed.line !== "number") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        log("warn", "storage.symbols.invalid_cursor", { cursor });
+        return undefined;
+    }
+}
+function isAfterCursor(row, cursor) {
+    const symbolCompare = row.symbol_name.localeCompare(cursor.symbolName);
+    if (symbolCompare > 0) {
+        return true;
+    }
+    if (symbolCompare < 0) {
+        return false;
+    }
+    const fileCompare = row.file_path.localeCompare(cursor.filePath);
+    if (fileCompare > 0) {
+        return true;
+    }
+    if (fileCompare < 0) {
+        return false;
+    }
+    return row.line > cursor.line;
+}
+function escapeLikeLiteral(value) {
+    return value.replace(/[\\%_]/g, "\\$&");
+}
+export class SymbolsRepo {
+    db;
+    deleteStmt;
+    insertStmt;
+    searchStmt;
+    searchExactStmt;
+    listByArtifactStmt;
+    listByArtifactKindStmt;
+    listByFileStmt;
+    constructor(db) {
+        this.db = db;
+        this.deleteStmt = this.db.prepare(`
+      DELETE FROM symbols WHERE artifact_id = ?
+    `);
+        this.insertStmt = this.db.prepare(`
+      INSERT INTO symbols (artifact_id, file_path, symbol_kind, symbol_name, qualified_name, line)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        this.searchStmt = this.db.prepare(`
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ?
+        AND (symbol_kind = ? OR ? = '')
+        AND (symbol_name LIKE ? ESCAPE '\\')
+      ORDER BY symbol_name ASC, file_path ASC, line ASC
+      LIMIT ?
+    `);
+        this.searchExactStmt = this.db.prepare(`
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ?
+        AND (symbol_kind = ? OR ? = '')
+        AND symbol_name = ?
+      ORDER BY symbol_name ASC, file_path ASC, line ASC
+      LIMIT ?
+    `);
+        this.listByArtifactStmt = this.db.prepare(`
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ?
+      ORDER BY symbol_name ASC, file_path ASC, line ASC
+    `);
+        this.listByArtifactKindStmt = this.db.prepare(`
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ? AND symbol_kind = ?
+      ORDER BY symbol_name ASC, file_path ASC, line ASC
+    `);
+        this.listByFileStmt = this.db.prepare(`
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ? AND file_path = ?
+      ORDER BY line ASC, symbol_name ASC
+    `);
+    }
+    clearSymbolsForArtifact(artifactId) {
+        this.deleteStmt.run([artifactId]);
+    }
+    insertSymbolsForArtifact(artifactId, symbols) {
+        for (const item of symbols) {
+            this.insertStmt.run([
+                artifactId,
+                item.filePath,
+                item.symbolKind,
+                item.symbolName,
+                item.qualifiedName ?? null,
+                item.line
+            ]);
+        }
+    }
+    replaceSymbolsForArtifact(artifactId, symbols) {
+        const transaction = this.db.transaction(() => {
+            this.clearSymbolsForArtifact(artifactId);
+            this.insertSymbolsForArtifact(artifactId, symbols);
+        });
+        transaction();
+    }
+    findSymbols(options) {
+        const cursor = decodeCursor(options.cursor);
+        const symbolName = options.symbolNamePrefix ?? "";
+        const fetchLimit = options.limit + 1;
+        let rows;
+        if (cursor) {
+            const nameMatch = options.exact ? "AND symbol_name = ?" : "AND (symbol_name LIKE ? ESCAPE '\\')";
+            const sql = `
+        SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+        FROM symbols
+        WHERE artifact_id = ?
+          AND (symbol_kind = ? OR ? = '')
+          ${nameMatch}
+          AND (
+            symbol_name > ?
+            OR (symbol_name = ? AND file_path > ?)
+            OR (symbol_name = ? AND file_path = ? AND line > ?)
+          )
+        ORDER BY symbol_name ASC, file_path ASC, line ASC
+        LIMIT ?
+      `;
+            const nameParam = options.exact ? symbolName : `${symbolName}%`;
+            rows = this.db.prepare(sql).all(options.artifactId, options.symbolKind ?? "", options.symbolKind ?? "", nameParam, cursor.symbolName, cursor.symbolName, cursor.filePath, cursor.symbolName, cursor.filePath, cursor.line, Math.max(1, fetchLimit));
+        }
+        else {
+            const queryRows = options.exact ? this.searchExactStmt : this.searchStmt;
+            rows = queryRows.all(options.artifactId, options.symbolKind ?? "", options.symbolKind ?? "", options.exact ? symbolName : `${symbolName}%`, Math.max(1, fetchLimit));
+        }
+        const page = rows.slice(0, options.limit);
+        const hasMore = rows.length > options.limit;
+        const nextCursor = page.length > 0 && hasMore
+            ? encodeCursor(page[page.length - 1].symbol_name, page[page.length - 1].file_path, page[page.length - 1].line)
+            : undefined;
+        return {
+            items: page.map((row) => toSymbolRow(options.artifactId, {
+                filePath: row.file_path,
+                symbolKind: row.symbol_kind,
+                symbolName: row.symbol_name,
+                qualifiedName: row.qualified_name ?? undefined,
+                line: row.line
+            })),
+            nextCursor
+        };
+    }
+    listSymbolsForArtifact(artifactId, symbolKind) {
+        const rows = (symbolKind
+            ? this.listByArtifactKindStmt.all(artifactId, symbolKind)
+            : this.listByArtifactStmt.all(artifactId));
+        return rows.map((row) => toSymbolRow(artifactId, {
+            filePath: row.file_path,
+            symbolKind: row.symbol_kind,
+            symbolName: row.symbol_name,
+            qualifiedName: row.qualified_name ?? undefined,
+            line: row.line
+        }));
+    }
+    listSymbolsForFile(artifactId, filePath) {
+        const rows = this.listByFileStmt.all(artifactId, filePath);
+        return rows.map((row) => toSymbolRow(artifactId, {
+            filePath: row.file_path,
+            symbolKind: row.symbol_kind,
+            symbolName: row.symbol_name,
+            qualifiedName: row.qualified_name ?? undefined,
+            line: row.line
+        }));
+    }
+    listSymbolsForFiles(artifactId, filePaths, symbolKind) {
+        const uniqueFilePaths = [...new Set(filePaths)];
+        if (uniqueFilePaths.length === 0) {
+            return new Map();
+        }
+        const placeholders = uniqueFilePaths.map(() => "?").join(", ");
+        const sql = `
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ?
+        AND file_path IN (${placeholders})
+        ${symbolKind ? "AND symbol_kind = ?" : ""}
+      ORDER BY file_path ASC, line ASC, symbol_name ASC
+    `;
+        const params = symbolKind ? [artifactId, ...uniqueFilePaths, symbolKind] : [artifactId, ...uniqueFilePaths];
+        const rows = this.db.prepare(sql).all(...params);
+        const byFile = new Map();
+        for (const row of rows) {
+            const bucket = byFile.get(row.file_path) ?? [];
+            bucket.push(toSymbolRow(artifactId, {
+                filePath: row.file_path,
+                symbolKind: row.symbol_kind,
+                symbolName: row.symbol_name,
+                qualifiedName: row.qualified_name ?? undefined,
+                line: row.line
+            }));
+            byFile.set(row.file_path, bucket);
+        }
+        return byFile;
+    }
+    findBySymbolNames(artifactId, symbolNames) {
+        const unique = [...new Set(symbolNames.map((name) => name.trim()).filter(Boolean))];
+        if (unique.length === 0) {
+            return [];
+        }
+        const placeholders = unique.map(() => "?").join(", ");
+        const rows = this.db
+            .prepare(`
+        SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+        FROM symbols
+        WHERE artifact_id = ?
+          AND lower(symbol_name) IN (${placeholders})
+        ORDER BY symbol_name ASC, file_path ASC, line ASC
+      `)
+            .all(artifactId, ...unique.map((name) => name.toLowerCase()));
+        return rows.map((row) => toSymbolRow(artifactId, {
+            filePath: row.file_path,
+            symbolKind: row.symbol_kind,
+            symbolName: row.symbol_name,
+            qualifiedName: row.qualified_name ?? undefined,
+            line: row.line
+        }));
+    }
+    findScopedSymbols(options) {
+        const normalizedQuery = options.query.trim();
+        if (!normalizedQuery) {
+            return { items: [], nextCursor: undefined };
+        }
+        const normalizedLowerQuery = normalizedQuery.toLowerCase();
+        const escapedLowerQuery = escapeLikeLiteral(normalizedLowerQuery);
+        const params = [options.artifactId];
+        const where = [];
+        if (options.symbolKind) {
+            where.push("symbol_kind = ?");
+            params.push(options.symbolKind);
+        }
+        if (options.packagePrefix?.trim()) {
+            const normalizedPrefix = options.packagePrefix.replace(/\.+/g, "/").replace(/\/+$/, "");
+            where.push("file_path LIKE ? ESCAPE '\\'");
+            params.push(`${escapeLikeLiteral(normalizedPrefix)}/%`);
+        }
+        if (options.filePathLike?.trim()) {
+            where.push("file_path LIKE ? ESCAPE '\\'");
+            params.push(options.filePathLike);
+        }
+        if (options.match === "exact") {
+            where.push("symbol_name = ?");
+            params.push(normalizedQuery);
+        }
+        else if (options.match === "prefix") {
+            where.push("lower(symbol_name) LIKE ? ESCAPE '\\'");
+            params.push(`${escapedLowerQuery}%`);
+        }
+        else {
+            where.push("lower(symbol_name) LIKE ? ESCAPE '\\'");
+            params.push(`%${escapedLowerQuery}%`);
+        }
+        if (options.cursor) {
+            where.push(`(
+        symbol_name > ?
+        OR (symbol_name = ? AND file_path > ?)
+        OR (symbol_name = ? AND file_path = ? AND line > ?)
+      )`);
+            params.push(options.cursor.symbolName, options.cursor.symbolName, options.cursor.filePath, options.cursor.symbolName, options.cursor.filePath, options.cursor.line);
+        }
+        const rawLimit = Math.max(1, options.limit ?? 5000);
+        const fetchLimit = rawLimit + 1;
+        params.push(fetchLimit);
+        const sql = `
+      SELECT file_path, symbol_kind, symbol_name, qualified_name, line
+      FROM symbols
+      WHERE artifact_id = ?
+      ${where.length > 0 ? `AND ${where.join("\n      AND ")}` : ""}
+      ORDER BY symbol_name ASC, file_path ASC, line ASC
+      LIMIT ?
+    `;
+        const rows = this.db.prepare(sql).all(...params);
+        const hasMore = rows.length > rawLimit;
+        const page = hasMore ? rows.slice(0, rawLimit) : rows;
+        const lastRow = page.length > 0 ? page[page.length - 1] : undefined;
+        const nextCursor = hasMore && lastRow
+            ? encodeCursor(lastRow.symbol_name, lastRow.file_path, lastRow.line)
+            : undefined;
+        return {
+            items: page.map((row) => toSymbolRow(options.artifactId, {
+                filePath: row.file_path,
+                symbolKind: row.symbol_kind,
+                symbolName: row.symbol_name,
+                qualifiedName: row.qualified_name ?? undefined,
+                line: row.line
+            })),
+            nextCursor
+        };
+    }
+    countScopedSymbols(options) {
+        const normalizedQuery = options.query.trim();
+        if (!normalizedQuery) {
+            return 0;
+        }
+        const normalizedLowerQuery = normalizedQuery.toLowerCase();
+        const escapedLowerQuery = escapeLikeLiteral(normalizedLowerQuery);
+        const params = [options.artifactId];
+        const where = [];
+        if (options.symbolKind) {
+            where.push("symbol_kind = ?");
+            params.push(options.symbolKind);
+        }
+        if (options.packagePrefix?.trim()) {
+            const normalizedPrefix = options.packagePrefix.replace(/\.+/g, "/").replace(/\/+$/, "");
+            where.push("file_path LIKE ? ESCAPE '\\'");
+            params.push(`${escapeLikeLiteral(normalizedPrefix)}/%`);
+        }
+        if (options.match === "exact") {
+            where.push("symbol_name = ?");
+            params.push(normalizedQuery);
+        }
+        else if (options.match === "prefix") {
+            where.push("lower(symbol_name) LIKE ? ESCAPE '\\'");
+            params.push(`${escapedLowerQuery}%`);
+        }
+        else {
+            where.push("lower(symbol_name) LIKE ? ESCAPE '\\'");
+            params.push(`%${escapedLowerQuery}%`);
+        }
+        const sql = `
+      SELECT COUNT(*) AS cnt
+      FROM symbols
+      WHERE artifact_id = ?
+      ${where.length > 0 ? `AND ${where.join("\n      AND ")}` : ""}
+    `;
+        const row = this.db.prepare(sql).get(...params);
+        return row?.cnt ?? 0;
+    }
+    listDistinctFilePathsByKind(artifactId, symbolKind) {
+        const rows = this.db
+            .prepare(`
+        SELECT DISTINCT file_path
+        FROM symbols
+        WHERE artifact_id = ? AND symbol_kind = ?
+        ORDER BY file_path ASC
+      `)
+            .all(artifactId, symbolKind);
+        return rows.map((row) => row.file_path);
+    }
+    findBestClassFilePath(artifactId, className, simpleName) {
+        const normalizedClassName = className.trim();
+        const normalizedSimpleName = simpleName.trim();
+        if (!normalizedClassName || !normalizedSimpleName) {
+            return undefined;
+        }
+        const row = this.db
+            .prepare(`
+        SELECT file_path
+        FROM symbols
+        WHERE artifact_id = ?
+          AND symbol_kind = 'class'
+          AND (
+            qualified_name = ?
+            OR symbol_name = ?
+            OR qualified_name LIKE ?
+          )
+        ORDER BY
+          CASE
+            WHEN qualified_name = ? THEN 0
+            WHEN symbol_name = ? THEN 1
+            ELSE 2
+          END,
+          file_path ASC
+        LIMIT 1
+      `)
+            .get(artifactId, normalizedClassName, normalizedSimpleName, `%.${normalizedSimpleName}`, normalizedClassName, normalizedSimpleName);
+        return row?.file_path;
+    }
+}
+//# sourceMappingURL=symbols-repo.js.map

package/dist/symbols/symbol-extractor.d.ts

@@ -0,0 +1,7 @@
+export interface ExtractedSymbol {
+    symbolKind: "class" | "interface" | "enum" | "record" | "method" | "field";
+    symbolName: string;
+    qualifiedName: string | undefined;
+    line: number;
+}
+export declare function extractSymbolsFromSource(filePath: string, content: string): Array<ExtractedSymbol>;

package/dist/symbols/symbol-extractor.js

@@ -0,0 +1,64 @@
+const CLASS_DECLARATION = /^(?:\s*@[\w.]+\s+)*(?:\s*(?:public|private|protected|abstract|final|sealed|non-sealed|static)\s+)*\s*(class|interface|enum|record)\s+([A-Za-z_$][\w$]*)/;
+const METHOD_DECLARATION = /^(?:\s*@[\w.]+\s+)*[^{;]*?\b([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?:\{|;)/;
+const FIELD_DECLARATION = /^(?:\s*@[\w.]+\s+)*[^\s][\w<>\[\],.?]+\s+([A-Za-z_$][\w$]*)\s*(?:=|;|,)/;
+function normalizeLine(line) {
+    return line.replace(/\s+/g, " ").trim();
+}
+function isNoiseToken(token) {
+    return new Set(["if", "for", "while", "switch", "catch", "return", "new", "throw"]).has(token);
+}
+function lineIndexToLine(lineNo) {
+    return lineNo + 1;
+}
+export function extractSymbolsFromSource(filePath, content) {
+    const lines = content.split(/\r?\n/);
+    const symbols = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const rawLine = lines[index] ?? "";
+        const line = normalizeLine(rawLine);
+        if (!line) {
+            continue;
+        }
+        const classMatch = line.match(CLASS_DECLARATION);
+        if (classMatch) {
+            const symbolKind = classMatch[1];
+            const symbolName = classMatch[2];
+            if (symbolName && !isNoiseToken(symbolName)) {
+                symbols.push({
+                    symbolKind,
+                    symbolName,
+                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    line: lineIndexToLine(index)
+                });
+            }
+            continue;
+        }
+        const methodMatch = line.match(METHOD_DECLARATION);
+        if (methodMatch) {
+            const symbolName = methodMatch[1];
+            if (symbolName && !isNoiseToken(symbolName)) {
+                symbols.push({
+                    symbolKind: "method",
+                    symbolName,
+                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    line: lineIndexToLine(index)
+                });
+            }
+            continue;
+        }
+        const fieldMatch = line.match(FIELD_DECLARATION);
+        if (fieldMatch) {
+            const symbolName = fieldMatch[1];
+            if (symbolName && !isNoiseToken(symbolName)) {
+                symbols.push({
+                    symbolKind: "field",
+                    symbolName,
+                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    line: lineIndexToLine(index)
+                });
+            }
+        }
+    }
+    return symbols;
+}
+//# sourceMappingURL=symbol-extractor.js.map

package/dist/tiny-remapper-resolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveTinyRemapperJar(cacheDir: string, overridePath: string | undefined, fetchFn?: typeof fetch): Promise<string>;

package/dist/tiny-remapper-resolver.js

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createError, ERROR_CODES } from "./errors.js";
+import { log } from "./logger.js";
+import { downloadToCache } from "./repo-downloader.js";
+const DEFAULT_VERSION = "0.10.3";
+const DOWNLOAD_TIMEOUT_MS = 120_000;
+const inflightDownloads = new Map();
+function tinyRemapperCachePath(cacheDir, version) {
+    return join(cacheDir, "resources", `tiny-remapper-${version}-fat.jar`);
+}
+function tinyRemapperDownloadUrl(version) {
+    return `https://maven.fabricmc.net/net/fabricmc/tiny-remapper/${version}/tiny-remapper-${version}-fat.jar`;
+}
+export async function resolveTinyRemapperJar(cacheDir, overridePath, fetchFn) {
+    // 1. Environment / config override
+    if (overridePath) {
+        return overridePath;
+    }
+    const version = process.env.MCP_TINY_REMAPPER_VERSION ?? DEFAULT_VERSION;
+    const cached = tinyRemapperCachePath(cacheDir, version);
+    // 2. Already cached
+    if (existsSync(cached)) {
+        return cached;
+    }
+    // 3. Download with per-target lock
+    const inflight = inflightDownloads.get(cached);
+    if (inflight) {
+        return inflight;
+    }
+    const downloadPromise = downloadTinyRemapper(version, cached, fetchFn);
+    inflightDownloads.set(cached, downloadPromise);
+    try {
+        return await downloadPromise;
+    }
+    finally {
+        inflightDownloads.delete(cached);
+    }
+}
+async function downloadTinyRemapper(version, destination, fetchFn) {
+    const url = tinyRemapperDownloadUrl(version);
+    log("info", "tiny-remapper.download.start", { version, url });
+    const result = await downloadToCache(url, destination, {
+        timeoutMs: DOWNLOAD_TIMEOUT_MS,
+        retries: 2,
+        ...(fetchFn ? { fetchFn } : {})
+    });
+    if (!result.ok || !result.path) {
+        throw createError({
+            code: ERROR_CODES.REMAPPER_UNAVAILABLE,
+            message: `Failed to download tiny-remapper ${version} from Fabric Maven.`,
+            details: { version, url, statusCode: result.statusCode }
+        });
+    }
+    log("info", "tiny-remapper.download.done", {
+        version,
+        path: result.path,
+        contentLength: result.contentLength
+    });
+    return result.path;
+}
+//# sourceMappingURL=tiny-remapper-resolver.js.map

package/dist/tiny-remapper-service.d.ts

@@ -0,0 +1,16 @@
+export interface RemapOptions {
+    inputJar: string;
+    outputJar: string;
+    mappingsFile: string;
+    fromNamespace: string;
+    toNamespace: string;
+    threads?: number;
+    rebuildSourceFilenames?: boolean;
+    timeoutMs?: number;
+    maxMemoryMb?: number;
+}
+export interface RemapResult {
+    outputJar: string;
+    durationMs: number;
+}
+export declare function remapJar(tinyRemapperJarPath: string, options: RemapOptions): Promise<RemapResult>;

package/dist/tiny-remapper-service.js

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs";
+import { createError, ERROR_CODES } from "./errors.js";
+import { assertJavaAvailable, runJavaProcess } from "./java-process.js";
+import { log } from "./logger.js";
+export async function remapJar(tinyRemapperJarPath, options) {
+    const { inputJar, outputJar, mappingsFile, fromNamespace, toNamespace, threads = 4, rebuildSourceFilenames = false, timeoutMs = 600_000, maxMemoryMb = 4096 } = options;
+    await assertJavaAvailable();
+    log("info", "remap.start", {
+        inputJar,
+        outputJar,
+        fromNamespace,
+        toNamespace,
+        threads
+    });
+    const startedAt = Date.now();
+    const args = [inputJar, outputJar, mappingsFile, fromNamespace, toNamespace];
+    if (threads !== 4) {
+        args.push(`--threads=${threads}`);
+    }
+    if (rebuildSourceFilenames) {
+        args.push("--rebuildSourceFilenames");
+    }
+    try {
+        const result = await runJavaProcess({
+            jarPath: tinyRemapperJarPath,
+            args,
+            timeoutMs,
+            maxMemoryMb,
+            normalizePathArgs: true
+        });
+        const durationMs = Date.now() - startedAt;
+        if (result.exitCode !== 0) {
+            throw createError({
+                code: ERROR_CODES.REMAP_FAILED,
+                message: `tiny-remapper exited with code ${result.exitCode}.`,
+                details: {
+                    inputJar,
+                    outputJar,
+                    exitCode: result.exitCode,
+                    stderrTail: result.stderrTail
+                }
+            });
+        }
+        if (!existsSync(outputJar)) {
+            throw createError({
+                code: ERROR_CODES.REMAP_FAILED,
+                message: "tiny-remapper did not produce an output JAR.",
+                details: {
+                    inputJar,
+                    outputJar,
+                    stderrTail: result.stderrTail
+                }
+            });
+        }
+        log("info", "remap.done", {
+            inputJar,
+            outputJar,
+            durationMs
+        });
+        return { outputJar, durationMs };
+    }
+    catch (error) {
+        const durationMs = Date.now() - startedAt;
+        log("error", "remap.error", {
+            inputJar,
+            outputJar,
+            durationMs,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=tiny-remapper-service.js.map