@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.1

package/dist/entry-tools/batch-class-members-service.js

@@ -0,0 +1,97 @@
+import { buildSuggestedCall } from "../build-suggested-call.js";
+import { compactResponse, compactMembersResponse, TOOL_PRESERVE_PAYLOAD_KEYS } from "../response-utils.js";
+import { runBatch, splitEntryWarnings } from "./batch-runner.js";
+export class BatchClassMembersService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(input) {
+        const concurrency = input.concurrency ?? 4;
+        const failFast = input.failFast ?? false;
+        const compact = input.compact ?? true;
+        return runBatch({
+            entries: input.entries,
+            concurrency,
+            failFast,
+            resolveSharedArtifact: async () => {
+                const resolved = await this.deps.resolveArtifact({
+                    target: input.target,
+                    mapping: input.mapping,
+                    sourcePriority: input.sourcePriority,
+                    allowDecompile: input.allowDecompile,
+                    projectPath: input.projectPath,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion,
+                    strictVersion: input.strictVersion
+                });
+                return {
+                    artifactId: resolved.artifactId,
+                    provenance: resolved.provenance,
+                    ...(Array.isArray(resolved.warnings) && resolved.warnings.length > 0
+                        ? { warnings: [...resolved.warnings] }
+                        : {})
+                };
+            },
+            artifactSummary: (artifact) => ({
+                sharedArtifactId: artifact.artifactId,
+                ...(artifact.provenance ? { sharedArtifactProvenance: artifact.provenance } : {}),
+                ...(artifact.warnings && artifact.warnings.length > 0
+                    ? { sharedArtifactWarnings: artifact.warnings }
+                    : {})
+            }),
+            perEntry: async (entry, _index, sharedArtifact) => {
+                if (!sharedArtifact) {
+                    throw new Error("shared artifact not resolved");
+                }
+                const raw = (await this.deps.getClassMembers({
+                    artifactId: sharedArtifact.artifactId,
+                    className: entry.className,
+                    access: entry.access,
+                    includeSynthetic: entry.includeSynthetic,
+                    includeInherited: entry.includeInherited,
+                    memberPattern: entry.memberPattern,
+                    maxMembers: entry.maxMembers,
+                    mapping: input.mapping,
+                    sourcePriority: input.sourcePriority,
+                    allowDecompile: input.allowDecompile,
+                    projectPath: input.projectPath,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion,
+                    strictVersion: input.strictVersion
+                }));
+                const { result, warnings } = splitEntryWarnings(raw);
+                const projected = compact
+                    ? compactResponse(compactMembersResponse(result), TOOL_PRESERVE_PAYLOAD_KEYS["get-class-members"])
+                    : result;
+                return { result: projected, warnings };
+            },
+            buildErrorSuggestedCall: (entry, sharedArtifact) => {
+                if (!sharedArtifact)
+                    return undefined;
+                const params = {
+                    target: { type: "artifact", artifactId: sharedArtifact.artifactId },
+                    className: entry.className
+                };
+                if (entry.access !== undefined)
+                    params.access = entry.access;
+                if (entry.includeSynthetic !== undefined)
+                    params.includeSynthetic = entry.includeSynthetic;
+                if (entry.includeInherited !== undefined)
+                    params.includeInherited = entry.includeInherited;
+                if (entry.memberPattern !== undefined)
+                    params.memberPattern = entry.memberPattern;
+                if (entry.maxMembers !== undefined)
+                    params.maxMembers = entry.maxMembers;
+                if (input.mapping !== undefined)
+                    params.mapping = input.mapping;
+                const { suggestedCall } = buildSuggestedCall({
+                    tool: "get-class-members",
+                    params
+                });
+                return suggestedCall;
+            }
+        });
+    }
+}
+//# sourceMappingURL=batch-class-members-service.js.map

package/dist/entry-tools/batch-class-source-service.d.ts

@@ -0,0 +1,37 @@
+import type { GetClassSourceInput, GetClassSourceOutput, ResolveArtifactInput, ResolveArtifactOutput } from "../source-service.js";
+import type { ArtifactScope, MappingSourcePriority, ResolveArtifactTargetInput, SourceMapping } from "../types.js";
+import { type BatchOutput } from "./batch-runner.js";
+type SourceMode = "metadata" | "snippet" | "full";
+export type BatchClassSourceEntry = {
+    className: string;
+    mode?: SourceMode;
+    startLine?: number;
+    endLine?: number;
+    maxLines?: number;
+    maxChars?: number;
+    outputFile?: string;
+};
+export type BatchClassSourceInput = {
+    target: ResolveArtifactTargetInput;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    allowDecompile?: boolean;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+    strictVersion?: boolean;
+    concurrency?: number;
+    failFast?: boolean;
+    compact?: boolean;
+    entries: readonly BatchClassSourceEntry[];
+};
+export type BatchClassSourceDeps = {
+    resolveArtifact: (input: ResolveArtifactInput) => Promise<ResolveArtifactOutput>;
+    getClassSource: (input: GetClassSourceInput) => Promise<GetClassSourceOutput>;
+};
+export declare class BatchClassSourceService {
+    private readonly deps;
+    constructor(deps: BatchClassSourceDeps);
+    execute(input: BatchClassSourceInput): Promise<BatchOutput<Record<string, unknown>>>;
+}
+export {};

package/dist/entry-tools/batch-class-source-service.js

@@ -0,0 +1,100 @@
+import { buildSuggestedCall } from "../build-suggested-call.js";
+import { compactResponse, compactSourceResponse, TOOL_PRESERVE_PAYLOAD_KEYS } from "../response-utils.js";
+import { runBatch, splitEntryWarnings } from "./batch-runner.js";
+export class BatchClassSourceService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(input) {
+        const concurrency = input.concurrency ?? 4;
+        const failFast = input.failFast ?? false;
+        const compact = input.compact ?? true;
+        return runBatch({
+            entries: input.entries,
+            concurrency,
+            failFast,
+            resolveSharedArtifact: async () => {
+                const resolved = await this.deps.resolveArtifact({
+                    target: input.target,
+                    mapping: input.mapping,
+                    sourcePriority: input.sourcePriority,
+                    allowDecompile: input.allowDecompile,
+                    projectPath: input.projectPath,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion,
+                    strictVersion: input.strictVersion
+                });
+                return {
+                    artifactId: resolved.artifactId,
+                    provenance: resolved.provenance,
+                    ...(Array.isArray(resolved.warnings) && resolved.warnings.length > 0
+                        ? { warnings: [...resolved.warnings] }
+                        : {})
+                };
+            },
+            artifactSummary: (artifact) => ({
+                sharedArtifactId: artifact.artifactId,
+                ...(artifact.provenance ? { sharedArtifactProvenance: artifact.provenance } : {}),
+                ...(artifact.warnings && artifact.warnings.length > 0
+                    ? { sharedArtifactWarnings: artifact.warnings }
+                    : {})
+            }),
+            perEntry: async (entry, _index, sharedArtifact) => {
+                if (!sharedArtifact) {
+                    throw new Error("shared artifact not resolved");
+                }
+                const raw = (await this.deps.getClassSource({
+                    artifactId: sharedArtifact.artifactId,
+                    className: entry.className,
+                    mode: entry.mode,
+                    startLine: entry.startLine,
+                    endLine: entry.endLine,
+                    maxLines: entry.maxLines,
+                    maxChars: entry.maxChars,
+                    outputFile: entry.outputFile,
+                    mapping: input.mapping,
+                    sourcePriority: input.sourcePriority,
+                    allowDecompile: input.allowDecompile,
+                    projectPath: input.projectPath,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion,
+                    strictVersion: input.strictVersion
+                }));
+                const { result, warnings } = splitEntryWarnings(raw);
+                const projected = compact
+                    ? compactResponse(compactSourceResponse(result), TOOL_PRESERVE_PAYLOAD_KEYS["get-class-source"])
+                    : result;
+                return { result: projected, warnings };
+            },
+            buildErrorSuggestedCall: (entry, sharedArtifact) => {
+                if (!sharedArtifact)
+                    return undefined;
+                const params = {
+                    target: { type: "artifact", artifactId: sharedArtifact.artifactId },
+                    className: entry.className
+                };
+                if (entry.mode !== undefined)
+                    params.mode = entry.mode;
+                if (entry.startLine !== undefined)
+                    params.startLine = entry.startLine;
+                if (entry.endLine !== undefined)
+                    params.endLine = entry.endLine;
+                if (entry.maxLines !== undefined)
+                    params.maxLines = entry.maxLines;
+                if (entry.maxChars !== undefined)
+                    params.maxChars = entry.maxChars;
+                if (entry.outputFile !== undefined)
+                    params.outputFile = entry.outputFile;
+                if (input.mapping !== undefined)
+                    params.mapping = input.mapping;
+                const { suggestedCall } = buildSuggestedCall({
+                    tool: "get-class-source",
+                    params
+                });
+                return suggestedCall;
+            }
+        });
+    }
+}
+//# sourceMappingURL=batch-class-source-service.js.map

package/dist/entry-tools/batch-mappings-service.d.ts

@@ -0,0 +1,36 @@
+import type { FindMappingInput, FindMappingOutput } from "../source-service.js";
+import type { MappingSourcePriority, SourceMapping } from "../types.js";
+export type BatchMappingsDeps = {
+    findMapping: (input: FindMappingInput) => Promise<FindMappingOutput>;
+};
+import { type BatchOutput } from "./batch-runner.js";
+type SymbolKind = "class" | "field" | "method";
+export type BatchMappingsEntry = {
+    kind: SymbolKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+    sourceMapping: SourceMapping;
+    targetMapping: SourceMapping;
+    signatureMode?: "exact" | "name-only";
+    disambiguation?: {
+        ownerHint?: string;
+        descriptorHint?: string;
+    };
+    maxCandidates?: number;
+};
+export type BatchMappingsInput = {
+    version: string;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    concurrency?: number;
+    failFast?: boolean;
+    compact?: boolean;
+    entries: readonly BatchMappingsEntry[];
+};
+export declare class BatchMappingsService {
+    private readonly deps;
+    constructor(deps: BatchMappingsDeps);
+    execute(input: BatchMappingsInput): Promise<BatchOutput<Record<string, unknown>>>;
+}
+export {};

package/dist/entry-tools/batch-mappings-service.js

@@ -0,0 +1,66 @@
+import { buildSuggestedCall } from "../build-suggested-call.js";
+import { compactResponse, compactMappingResponse } from "../response-utils.js";
+import { runBatch, splitEntryWarnings } from "./batch-runner.js";
+export class BatchMappingsService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(input) {
+        const concurrency = input.concurrency ?? 4;
+        const failFast = input.failFast ?? false;
+        const compact = input.compact ?? true;
+        return runBatch({
+            entries: input.entries,
+            concurrency,
+            failFast,
+            resolveSharedArtifact: async () => undefined,
+            perEntry: async (entry, _index) => {
+                const raw = (await this.deps.findMapping({
+                    version: input.version,
+                    kind: entry.kind,
+                    name: entry.name,
+                    owner: entry.owner,
+                    descriptor: entry.descriptor,
+                    sourceMapping: entry.sourceMapping,
+                    targetMapping: entry.targetMapping,
+                    sourcePriority: input.sourcePriority,
+                    projectPath: input.projectPath,
+                    signatureMode: entry.signatureMode,
+                    disambiguation: entry.disambiguation,
+                    maxCandidates: entry.maxCandidates
+                }));
+                const { result, warnings } = splitEntryWarnings(raw);
+                const projected = compact
+                    ? compactResponse(compactMappingResponse(result))
+                    : result;
+                return { result: projected, warnings };
+            },
+            buildErrorSuggestedCall: (entry) => {
+                const params = {
+                    version: input.version,
+                    kind: entry.kind,
+                    name: entry.name,
+                    sourceMapping: entry.sourceMapping,
+                    targetMapping: entry.targetMapping
+                };
+                if (entry.owner !== undefined)
+                    params.owner = entry.owner;
+                if (entry.descriptor !== undefined)
+                    params.descriptor = entry.descriptor;
+                if (entry.signatureMode !== undefined)
+                    params.signatureMode = entry.signatureMode;
+                if (entry.disambiguation !== undefined)
+                    params.disambiguation = entry.disambiguation;
+                if (entry.maxCandidates !== undefined)
+                    params.maxCandidates = entry.maxCandidates;
+                const { suggestedCall } = buildSuggestedCall({
+                    tool: "find-mapping",
+                    params
+                });
+                return suggestedCall;
+            }
+        });
+    }
+}
+//# sourceMappingURL=batch-mappings-service.js.map

package/dist/entry-tools/batch-runner.d.ts

@@ -0,0 +1,72 @@
+import { type ProblemDetails, type SuggestedCall } from "../error-mapping.js";
+export declare const BATCH_TOOLS_OFF: boolean;
+export type BatchEntryOk<TResult> = {
+    index: number;
+    status: "ok";
+    result: TResult;
+    warnings: string[];
+    durationMs: number;
+};
+export type BatchEntryError = {
+    index: number;
+    status: "error";
+    error: ProblemDetails;
+    warnings: string[];
+    durationMs: number;
+};
+export type BatchEntryResult<TResult> = BatchEntryOk<TResult> | BatchEntryError;
+export type BatchSummary = {
+    total: number;
+    ok: number;
+    error: number;
+    sharedArtifactId?: string;
+    sharedArtifactProvenance?: Record<string, unknown>;
+    /** Warnings from the one-shot shared `resolveArtifact` call (version
+     * approximation, mapping fallback, source coverage gaps, workspace /
+     * dependency resolution caveats). Per-entry dispatch is by `artifactId`
+     * and never re-runs resolution, so these warnings reach the caller only
+     * via this field. Omitted when the resolution emitted none. */
+    sharedArtifactWarnings?: string[];
+};
+export type BatchOutput<TResult> = {
+    results: BatchEntryResult<TResult>[];
+    summary: BatchSummary;
+};
+export type BatchRunOptions<TEntry, TResult, TArtifact> = {
+    entries: readonly TEntry[];
+    concurrency: number;
+    failFast: boolean;
+    /** Resolve the shared artifact once. May return undefined for batch tools that
+     * do not need a shared artifact (e.g. `batch-mappings`, where each entry is
+     * mapping-graph-only and does not depend on the artifact). Throws to abort the
+     * batch entirely with a top-level error envelope (handled by `runTool`). */
+    resolveSharedArtifact: () => Promise<TArtifact | undefined>;
+    /** Summary metadata derived from the resolved shared artifact. */
+    artifactSummary?: (artifact: TArtifact) => {
+        sharedArtifactId?: string;
+        sharedArtifactProvenance?: Record<string, unknown>;
+        sharedArtifactWarnings?: string[];
+    };
+    /** Per-entry handler. Returns `{ result, warnings }` on success. Errors thrown
+     * here are caught and converted to a per-entry ProblemDetails — the mapper
+     * itself never throws into `mapWithConcurrencyLimit`. */
+    perEntry: (entry: TEntry, index: number, sharedArtifact: TArtifact | undefined) => Promise<{
+        result: TResult;
+        warnings?: string[];
+    }>;
+    /** Synthesize the per-entry retry suggestedCall (proposing the matching single
+     * tool). Already validated through `buildSuggestedCall` by the caller; pass
+     * `undefined` when the suggestedCall could not be synthesized for this entry. */
+    buildErrorSuggestedCall: (entry: TEntry, sharedArtifact: TArtifact | undefined, error: unknown) => SuggestedCall | undefined;
+    /** Generate a fresh request-instance id per entry — defaults to the same
+     * scheme `runTool` uses (`<base36-time>-<base36-rand>`). Per-entry uniqueness
+     * is required so callers can correlate failed entries individually. */
+    buildEntryInstance?: (index: number) => string;
+};
+export declare function runBatch<TEntry, TResult, TArtifact>(opts: BatchRunOptions<TEntry, TResult, TArtifact>): Promise<BatchOutput<TResult>>;
+/** Lift `warnings: string[]` off a service result onto the per-entry batch
+ * envelope, mirroring `runTool`'s `splitWarnings` for single-tool calls. */
+export declare function splitEntryWarnings<T extends Record<string, unknown>>(raw: T): {
+    result: Omit<T, "warnings">;
+    warnings: string[];
+};

package/dist/entry-tools/batch-runner.js

@@ -0,0 +1,90 @@
+import { mapWithConcurrencyLimit } from "../concurrency.js";
+import { buildBatchAbortedProblem, errorToBatchEntryProblem } from "../error-mapping.js";
+export const BATCH_TOOLS_OFF = process.env.BATCH_TOOLS_OFF === "1";
+function defaultEntryInstance(index) {
+    return `${Date.now().toString(36)}-${index}-${Math.random().toString(36).slice(2, 10)}`;
+}
+export async function runBatch(opts) {
+    const sharedArtifact = await opts.resolveSharedArtifact();
+    const artifactSummary = sharedArtifact !== undefined && opts.artifactSummary
+        ? opts.artifactSummary(sharedArtifact)
+        : {};
+    let abort = false;
+    const buildInstance = opts.buildEntryInstance ?? defaultEntryInstance;
+    const results = await mapWithConcurrencyLimit(opts.entries, opts.concurrency, async (entry, index) => {
+        const startedAt = Date.now();
+        if (abort) {
+            return {
+                index,
+                status: "error",
+                error: buildBatchAbortedProblem(buildInstance(index)),
+                warnings: [],
+                durationMs: Date.now() - startedAt
+            };
+        }
+        try {
+            const { result, warnings } = await opts.perEntry(entry, index, sharedArtifact);
+            return {
+                index,
+                status: "ok",
+                result,
+                warnings: warnings ?? [],
+                durationMs: Date.now() - startedAt
+            };
+        }
+        catch (caught) {
+            const suggestedCall = opts.buildErrorSuggestedCall(entry, sharedArtifact, caught);
+            const problem = errorToBatchEntryProblem(caught, buildInstance(index), suggestedCall ? { suggestedCall } : undefined);
+            if (opts.failFast) {
+                abort = true;
+            }
+            return {
+                index,
+                status: "error",
+                error: problem,
+                warnings: [],
+                durationMs: Date.now() - startedAt
+            };
+        }
+    });
+    let okCount = 0;
+    let errorCount = 0;
+    for (const entry of results) {
+        if (entry.status === "ok")
+            okCount += 1;
+        else
+            errorCount += 1;
+    }
+    return {
+        results,
+        summary: {
+            total: results.length,
+            ok: okCount,
+            error: errorCount,
+            ...(artifactSummary.sharedArtifactId !== undefined
+                ? { sharedArtifactId: artifactSummary.sharedArtifactId }
+                : {}),
+            ...(artifactSummary.sharedArtifactProvenance !== undefined
+                ? { sharedArtifactProvenance: artifactSummary.sharedArtifactProvenance }
+                : {}),
+            ...(artifactSummary.sharedArtifactWarnings !== undefined &&
+                artifactSummary.sharedArtifactWarnings.length > 0
+                ? { sharedArtifactWarnings: artifactSummary.sharedArtifactWarnings }
+                : {})
+        }
+    };
+}
+/** Lift `warnings: string[]` off a service result onto the per-entry batch
+ * envelope, mirroring `runTool`'s `splitWarnings` for single-tool calls. */
+export function splitEntryWarnings(raw) {
+    const { warnings, ...rest } = raw;
+    const list = [];
+    if (Array.isArray(warnings)) {
+        for (const w of warnings) {
+            if (typeof w === "string")
+                list.push(w);
+        }
+    }
+    return { result: rest, warnings: list };
+}
+//# sourceMappingURL=batch-runner.js.map

package/dist/entry-tools/batch-symbol-exists-service.d.ts

@@ -0,0 +1,46 @@
+import type { CheckSymbolExistsInput, CheckSymbolExistsOutput, ResolveArtifactInput, ResolveArtifactOutput } from "../source-service.js";
+import type { ArtifactScope, MappingSourcePriority, SourceMapping, WorkspaceTargetInput, SourceTargetInput } from "../types.js";
+export type BatchSymbolExistsDeps = {
+    resolveArtifact: (input: ResolveArtifactInput) => Promise<ResolveArtifactOutput>;
+    checkSymbolExists: (input: CheckSymbolExistsInput) => Promise<CheckSymbolExistsOutput>;
+};
+import { type BatchOutput } from "./batch-runner.js";
+type SymbolKind = "class" | "field" | "method";
+export type BatchSymbolExistsEntry = {
+    kind: SymbolKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+    nameMode?: "fqcn" | "auto";
+    signatureMode?: "exact" | "name-only";
+    maxCandidates?: number;
+};
+/**
+ * Subset of `ResolveArtifactTargetInput` accepted by `batch-symbol-exists`.
+ * Library/jar/coordinate targets carry the library's own version, not the
+ * Minecraft version, so querying the Minecraft mapping graph with that value
+ * would be a category error. The zod schema rejects the disallowed kinds.
+ */
+export type BatchSymbolExistsTarget = (SourceTargetInput & {
+    kind: "version";
+}) | WorkspaceTargetInput;
+export type BatchSymbolExistsInput = {
+    target: BatchSymbolExistsTarget;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    allowDecompile?: boolean;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+    strictVersion?: boolean;
+    concurrency?: number;
+    failFast?: boolean;
+    compact?: boolean;
+    entries: readonly BatchSymbolExistsEntry[];
+};
+export declare class BatchSymbolExistsService {
+    private readonly deps;
+    constructor(deps: BatchSymbolExistsDeps);
+    execute(input: BatchSymbolExistsInput): Promise<BatchOutput<Record<string, unknown>>>;
+}
+export {};

package/dist/entry-tools/batch-symbol-exists-service.js

@@ -0,0 +1,113 @@
+import { buildSuggestedCall } from "../build-suggested-call.js";
+import { createError, ERROR_CODES } from "../errors.js";
+import { compactResponse, compactMappingResponse } from "../response-utils.js";
+import { runBatch, splitEntryWarnings } from "./batch-runner.js";
+function deriveMinecraftVersion(resolvedVersion, workspaceVersion) {
+    const candidate = resolvedVersion?.trim() || workspaceVersion?.trim();
+    if (!candidate) {
+        throw createError({
+            code: ERROR_CODES.WORKSPACE_VERSION_UNRESOLVED,
+            message: "batch-symbol-exists could not derive a Minecraft version from the shared artifact (use target.kind=version or set projectPath so the workspace resolution detects it).",
+            details: {
+                nextAction: "Pass target.kind=\"version\" with the desired Minecraft version, or ensure target.kind=\"workspace\" projectPath points to a Loom/Forge project whose gradle.properties carries minecraft_version."
+            }
+        });
+    }
+    return candidate;
+}
+export class BatchSymbolExistsService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(input) {
+        const concurrency = input.concurrency ?? 4;
+        const failFast = input.failFast ?? false;
+        const compact = input.compact ?? true;
+        return runBatch({
+            entries: input.entries,
+            concurrency,
+            failFast,
+            resolveSharedArtifact: async () => {
+                const resolved = await this.deps.resolveArtifact({
+                    target: input.target,
+                    mapping: input.mapping,
+                    sourcePriority: input.sourcePriority,
+                    allowDecompile: input.allowDecompile,
+                    projectPath: input.projectPath,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion,
+                    strictVersion: input.strictVersion
+                });
+                const provenance = resolved.provenance;
+                const workspaceVersion = provenance?.workspaceResolution?.detected?.minecraftVersion;
+                const version = deriveMinecraftVersion(resolved.version, workspaceVersion);
+                return {
+                    artifactId: resolved.artifactId,
+                    provenance: resolved.provenance,
+                    version,
+                    sourceMapping: resolved.mappingApplied,
+                    ...(Array.isArray(resolved.warnings) && resolved.warnings.length > 0
+                        ? { warnings: [...resolved.warnings] }
+                        : {})
+                };
+            },
+            artifactSummary: (artifact) => ({
+                sharedArtifactId: artifact.artifactId,
+                ...(artifact.provenance ? { sharedArtifactProvenance: artifact.provenance } : {}),
+                ...(artifact.warnings && artifact.warnings.length > 0
+                    ? { sharedArtifactWarnings: artifact.warnings }
+                    : {})
+            }),
+            perEntry: async (entry, _index, sharedArtifact) => {
+                if (!sharedArtifact) {
+                    throw new Error("shared artifact not resolved");
+                }
+                const raw = (await this.deps.checkSymbolExists({
+                    version: sharedArtifact.version,
+                    kind: entry.kind,
+                    name: entry.name,
+                    owner: entry.owner,
+                    descriptor: entry.descriptor,
+                    sourceMapping: sharedArtifact.sourceMapping,
+                    sourcePriority: input.sourcePriority,
+                    nameMode: entry.nameMode,
+                    signatureMode: entry.signatureMode,
+                    maxCandidates: entry.maxCandidates,
+                    projectPath: input.projectPath
+                }));
+                const { result, warnings } = splitEntryWarnings(raw);
+                const projected = compact
+                    ? compactResponse(compactMappingResponse(result))
+                    : result;
+                return { result: projected, warnings };
+            },
+            buildErrorSuggestedCall: (entry, sharedArtifact) => {
+                if (!sharedArtifact)
+                    return undefined;
+                const params = {
+                    version: sharedArtifact.version,
+                    kind: entry.kind,
+                    name: entry.name,
+                    sourceMapping: sharedArtifact.sourceMapping
+                };
+                if (entry.owner !== undefined)
+                    params.owner = entry.owner;
+                if (entry.descriptor !== undefined)
+                    params.descriptor = entry.descriptor;
+                if (entry.nameMode !== undefined)
+                    params.nameMode = entry.nameMode;
+                if (entry.signatureMode !== undefined)
+                    params.signatureMode = entry.signatureMode;
+                if (entry.maxCandidates !== undefined)
+                    params.maxCandidates = entry.maxCandidates;
+                const { suggestedCall } = buildSuggestedCall({
+                    tool: "check-symbol-exists",
+                    params
+                });
+                return suggestedCall;
+            }
+        });
+    }
+}
+//# sourceMappingURL=batch-symbol-exists-service.js.map