@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.1

package/dist/mixin/helpers.js

@@ -0,0 +1,315 @@
+export const TOOL_RESOLUTION_PATHS = [
+    "target-mapping-failed",
+    "member-remap-failed",
+    "source-signature-unavailable"
+];
+const MAPPING_WARNING_RE = /(?:mapping|remap|fallback|could not map)/i;
+const CONFIG_WARNING_RE = /(?:version|gradle|jar\b|properties|project)/i;
+const PARSE_WARNING_RE = /(?:could not parse|parse\s+warning|missing method attribute)/i;
+export function classifyStructuredWarning(message) {
+    return {
+        severity: MAPPING_WARNING_RE.test(message) ? "warning" : PARSE_WARNING_RE.test(message) ? "warning" : "info",
+        message,
+        category: MAPPING_WARNING_RE.test(message)
+            ? "mapping"
+            : PARSE_WARNING_RE.test(message)
+                ? "parse"
+                : CONFIG_WARNING_RE.test(message)
+                    ? "configuration"
+                    : "validation"
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Levenshtein distance                                               */
+/* ------------------------------------------------------------------ */
+export function levenshteinDistance(a, b) {
+    const la = a.length;
+    const lb = b.length;
+    if (la === 0)
+        return lb;
+    if (lb === 0)
+        return la;
+    // Single-row DP
+    const prev = new Array(lb + 1);
+    for (let j = 0; j <= lb; j++)
+        prev[j] = j;
+    for (let i = 1; i <= la; i++) {
+        let diagPrev = prev[0];
+        prev[0] = i;
+        for (let j = 1; j <= lb; j++) {
+            const temp = prev[j];
+            if (a[i - 1] === b[j - 1]) {
+                prev[j] = diagPrev;
+            }
+            else {
+                prev[j] = 1 + Math.min(diagPrev, prev[j - 1], prev[j]);
+            }
+            diagPrev = temp;
+        }
+    }
+    return prev[lb];
+}
+export function suggestSimilar(name, candidates, maxDistance = 3, maxResults = 3) {
+    const normalizedName = name.toLowerCase();
+    const scored = [];
+    for (const candidate of candidates) {
+        const normalizedCandidate = candidate.toLowerCase();
+        if (Math.abs(normalizedName.length - normalizedCandidate.length) > maxDistance) {
+            continue;
+        }
+        const distance = levenshteinDistance(normalizedName, normalizedCandidate);
+        if (distance <= maxDistance && distance > 0) {
+            scored.push({ candidate, distance });
+        }
+    }
+    scored.sort((a, b) => a.distance - b.distance);
+    return scored.slice(0, maxResults).map((s) => s.candidate);
+}
+/* ------------------------------------------------------------------ */
+/*  Method reference helpers                                           */
+/* ------------------------------------------------------------------ */
+/**
+ * Strip owner prefix (`Lowner;`) and JVM descriptor (`(...)V`) from a
+ * Mixin method reference, returning just the method name.
+ *
+ * Examples:
+ *   "playerTouch(Lnet/minecraft/world/entity/player/Player;)V" → "playerTouch"
+ *   "Lnet/minecraft/SomeClass;tick(I)V"                        → "tick"
+ *   "<init>"                                                    → "<init>"
+ *   "<init>()V"                                                 → "<init>"
+ *   "tick"                                                      → "tick"
+ */
+function stripOwnerPrefix(ref) {
+    if (!ref.startsWith("L"))
+        return ref;
+    const ownerEnd = ref.indexOf(";");
+    if (ownerEnd === -1)
+        return ref;
+    const parenIdx = ref.indexOf("(");
+    // Owner prefixes appear before the descriptor, e.g. Lpkg/Class;method(I)V.
+    // If ';' appears inside the descriptor, this is not an owner prefix.
+    if (parenIdx !== -1 && ownerEnd > parenIdx)
+        return ref;
+    return ref.substring(ownerEnd + 1);
+}
+export function extractMethodName(ref) {
+    let s = stripOwnerPrefix(ref);
+    // Remove descriptor: everything from '(' onwards
+    const parenIdx = s.indexOf("(");
+    if (parenIdx !== -1) {
+        s = s.substring(0, parenIdx);
+    }
+    return s;
+}
+/**
+ * Extract the JVM descriptor portion from a method reference, if present.
+ *
+ * Examples:
+ *   "playerTouch(Lnet/minecraft/world/entity/player/Player;)V" → "(Lnet/minecraft/world/entity/player/Player;)V"
+ *   "tick"                                                      → undefined
+ */
+export function extractMethodDescriptor(ref) {
+    // After stripping optional owner prefix, find '('
+    const s = stripOwnerPrefix(ref);
+    const parenIdx = s.indexOf("(");
+    if (parenIdx !== -1) {
+        return s.substring(parenIdx);
+    }
+    return undefined;
+}
+/* ------------------------------------------------------------------ */
+/*  Member-set helpers                                                 */
+/* ------------------------------------------------------------------ */
+export function allMethodNames(members) {
+    return [
+        ...members.constructors.map((m) => m.name),
+        ...members.methods.map((m) => m.name)
+    ];
+}
+export function allFieldNames(members) {
+    return members.fields.map((m) => m.name);
+}
+export function accessLevelFromFlags(accessFlags) {
+    if (accessFlags == null) {
+        return undefined;
+    }
+    if ((accessFlags & 0x0001) !== 0) {
+        return "public";
+    }
+    if ((accessFlags & 0x0004) !== 0) {
+        return "protected";
+    }
+    if ((accessFlags & 0x0002) !== 0) {
+        return "private";
+    }
+    return "package-private";
+}
+/* ------------------------------------------------------------------ */
+/*  Confidence / risk scoring                                          */
+/* ------------------------------------------------------------------ */
+export function computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence) {
+    if (!healthReport)
+        return undefined;
+    if (healthReport.overallHealthy === false) {
+        if (resolutionPath === "source-signature-unavailable" ||
+            resolutionPath === "target-mapping-failed" ||
+            resolutionPath === "member-remap-failed")
+            return "high";
+        if (issueConfidence === "uncertain")
+            return "medium";
+        return "medium";
+    }
+    if (healthReport.memberRemapAvailable === false) {
+        if (resolutionPath === "member-remap-failed")
+            return "high";
+        if (issueConfidence === "uncertain")
+            return "medium";
+    }
+    return undefined;
+}
+export function computeConfidenceBreakdown(healthReport, provenance, remapFailureCount, skippedMemberCount) {
+    const baseScore = 100;
+    const penalties = [];
+    let score = baseScore;
+    if (healthReport) {
+        if (!healthReport.overallHealthy) {
+            penalties.push({ reason: "mapping-health", points: 30 });
+            score -= 30;
+        }
+        if (!healthReport.tinyMappingsAvailable) {
+            penalties.push({ reason: "tiny-mappings-unavailable", points: 20 });
+            score -= 20;
+        }
+        if (!healthReport.memberRemapAvailable) {
+            penalties.push({ reason: "member-remap-unavailable", points: 15 });
+            score -= 15;
+        }
+    }
+    if (provenance?.scopeFallback) {
+        penalties.push({ reason: "scope-fallback", points: 10 });
+        score -= 10;
+    }
+    if (provenance && provenance.requestedMapping !== provenance.mappingApplied) {
+        penalties.push({ reason: "mapping-mismatch", points: 15 });
+        score -= 15;
+    }
+    if (skippedMemberCount > 0) {
+        penalties.push({ reason: "members-skipped", points: 25 });
+        score -= 25;
+    }
+    const remapPenalty = Math.min(remapFailureCount * 2, 20);
+    if (remapPenalty > 0) {
+        penalties.push({ reason: "remap-failures", points: remapPenalty });
+        score -= remapPenalty;
+    }
+    return {
+        baseScore,
+        score: Math.max(score, 0),
+        penalties
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Resolved-member summarisation                                      */
+/* ------------------------------------------------------------------ */
+export function summarizeResolvedMembers(resolvedMembers) {
+    return {
+        membersValidated: resolvedMembers.filter((member) => member.status === "resolved").length,
+        membersSkipped: resolvedMembers.filter((member) => member.status === "skipped").length,
+        membersMissing: resolvedMembers.filter((member) => member.status === "not-found").length
+    };
+}
+export function computeValidationStatus(summary) {
+    if (summary.errors > 0 || summary.definiteErrors > 0) {
+        return "invalid";
+    }
+    if (summary.warnings > 0 ||
+        summary.membersSkipped > 0 ||
+        (summary.targetsDeferredBudget ?? 0) > 0 ||
+        summary.degradedReason !== undefined) {
+        return "partial";
+    }
+    return "full";
+}
+export function buildQuickSummary(status, summary, context) {
+    const base = status === "full"
+        ? `${summary.membersValidated} member(s) validated successfully.`
+        : `${summary.definiteErrors} error(s), ${summary.uncertainErrors} uncertain, ${summary.warnings} warning(s). ${summary.membersValidated} validated, ${summary.membersSkipped} member(s) skipped, ${summary.membersMissing} member(s) missing.`;
+    const notes = [];
+    const scopeFallback = context?.provenance?.scopeFallback;
+    if (scopeFallback) {
+        notes.push(`Scope fell back from "${scopeFallback.requested}" to "${scopeFallback.applied}" (${scopeFallback.reason}).`);
+    }
+    const healthReport = context?.healthReport;
+    if (healthReport && !healthReport.overallHealthy) {
+        const degradations = healthReport.degradations.length > 0
+            ? healthReport.degradations.join("; ")
+            : "mapping infrastructure degraded";
+        notes.push(`Mapping health degraded: ${degradations}.`);
+    }
+    if (summary.degradedReason === "stage-budget-pre-target") {
+        notes.push("Budget exhausted before any target processed — increase budget or split mixinConfigPath.");
+    }
+    else if ((summary.targetsDeferredBudget ?? 0) > 0) {
+        notes.push(`${summary.targetsDeferredBudget} target(s) deferred by stage budget — narrow mixinConfigPath or split the run.`);
+    }
+    return notes.length > 0 ? `${base} ${notes.join(" ")}` : base;
+}
+export function addSkippedMembers(parsed, resolvedMembers) {
+    for (const inj of parsed.injections) {
+        resolvedMembers.push({
+            annotation: `@${inj.annotation}`,
+            name: extractMethodName(inj.method),
+            line: inj.line,
+            status: "skipped"
+        });
+    }
+    for (const shadow of parsed.shadows) {
+        resolvedMembers.push({
+            annotation: "@Shadow",
+            name: shadow.name,
+            line: shadow.line,
+            status: "skipped"
+        });
+    }
+    for (const accessor of parsed.accessors) {
+        resolvedMembers.push({
+            annotation: `@${accessor.annotation}`,
+            name: accessor.targetName,
+            line: accessor.line,
+            status: "skipped"
+        });
+    }
+}
+export function refreshMixinValidationOutcome(result) {
+    const memberSummary = result.resolvedMembers
+        ? summarizeResolvedMembers(result.resolvedMembers)
+        : {
+            membersValidated: result.summary.membersValidated,
+            membersSkipped: result.summary.membersSkipped,
+            membersMissing: result.summary.membersMissing
+        };
+    // Preserve budget signals across refresh; otherwise pre-target partial
+    // paths regress to "full" on a second recompute.
+    const preservedBudget = {
+        targetsDeferredBudget: result.summary.targetsDeferredBudget,
+        degradedReason: result.summary.degradedReason
+    };
+    result.summary = {
+        ...result.summary,
+        ...memberSummary,
+        ...(preservedBudget.targetsDeferredBudget !== undefined
+            ? { targetsDeferredBudget: preservedBudget.targetsDeferredBudget }
+            : {}),
+        ...(preservedBudget.degradedReason !== undefined
+            ? { degradedReason: preservedBudget.degradedReason }
+            : {})
+    };
+    result.validationStatus = computeValidationStatus(result.summary);
+    result.valid = result.summary.definiteErrors === 0;
+    result.quickSummary = buildQuickSummary(result.validationStatus, result.summary, {
+        provenance: result.provenance,
+        healthReport: result.toolHealth
+    });
+    return result;
+}
+//# sourceMappingURL=helpers.js.map

package/dist/mixin/parsed-validator.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedMixin } from "../mixin-parser.js";
+import type { IssueConfidence, MappingHealthReport, MixinValidationProvenance, MixinValidationResult, ResolvedTargetMembers } from "./types.js";
+export declare function validateParsedMixin(parsed: ParsedMixin, targetMembers: Map<string, ResolvedTargetMembers>, warnings: string[], provenance?: MixinValidationProvenance, confidence?: IssueConfidence, mappingFailedTargets?: Set<string>, explain?: boolean, remapFailedMembers?: Map<string, Set<string>>, signatureFailedTargets?: Set<string>, suggestedCallContext?: {
+    scope?: string;
+    sourcePriority?: string;
+    projectPath?: string;
+    mapping?: string;
+}, warningMode?: "full" | "aggregated", healthReport?: MappingHealthReport, symbolExistsButSignatureFailed?: Set<string>, deferredBudgetTargets?: Set<string>): MixinValidationResult;

package/dist/mixin/parsed-validator.js

@@ -0,0 +1,337 @@
+import { buildSuggestedCall } from "../build-suggested-call.js";
+import { TOOL_RESOLUTION_PATHS, addSkippedMembers, buildQuickSummary, classifyStructuredWarning, computeConfidenceBreakdown, computeValidationStatus, summarizeResolvedMembers } from "./helpers.js";
+import { validateAccessor, validateInjection, validateShadow } from "./annotation-validators.js";
+export function validateParsedMixin(parsed, targetMembers, warnings, provenance, confidence, mappingFailedTargets, explain, remapFailedMembers, signatureFailedTargets, suggestedCallContext, warningMode, healthReport, symbolExistsButSignatureFailed, deferredBudgetTargets) {
+    const issues = [];
+    const targetNames = parsed.targets.map((t) => t.className);
+    const confidenceReason = confidence === "uncertain"
+        ? `Mapping fallback: requested "${provenance?.requestedMapping}" but applied "${provenance?.mappingApplied}".`
+        : confidence === "likely"
+            ? "Some members could not be remapped."
+            : undefined;
+    const resolvedMembers = [];
+    // Check target classes exist
+    for (const target of parsed.targets) {
+        if (!targetMembers.has(target.className)) {
+            if (mappingFailedTargets?.has(target.className)) {
+                // Mapping failure — report as warning with distinct kind
+                issues.push({
+                    severity: "warning",
+                    kind: "target-mapping-failed",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Could not map target class "${target.className}" to obfuscated namespace; class may still exist under a different mapping.`,
+                    confidence: "uncertain",
+                    confidenceReason: `Mapping from "${provenance?.requestedMapping}" to obfuscated failed for this class.`,
+                    category: "mapping",
+                    resolutionPath: "target-mapping-failed",
+                    falsePositiveRisk: healthReport?.overallHealthy === false ? "high" : "medium"
+                });
+            }
+            else if (symbolExistsButSignatureFailed?.has(target.className)) {
+                // Symbol exists in mapping graph but getSignature failed — tool limitation, not code issue
+                issues.push({
+                    severity: "warning",
+                    kind: "validation-incomplete",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Target class "${target.className}" exists in mapping data but could not be loaded from game jar (tool limitation). Members not validated.`,
+                    confidence: "uncertain",
+                    confidenceReason: "Class exists in mapping graph but bytecode signature extraction failed.",
+                    category: "resolution",
+                    resolutionPath: "source-signature-unavailable",
+                    issueOrigin: "tool_issue",
+                    falsePositiveRisk: "high"
+                });
+                addSkippedMembers(parsed, resolvedMembers);
+            }
+            else if (deferredBudgetTargets?.has(target.className)) {
+                // Deferred by stage budget; the targetOutcomes entry already records
+                // this, so skip member validation rather than emit a not-found error.
+                addSkippedMembers(parsed, resolvedMembers);
+            }
+            else if (signatureFailedTargets?.has(target.className)) {
+                issues.push({
+                    severity: "warning",
+                    kind: "validation-incomplete",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Target class "${target.className}" could not load enough target metadata for reliable validation. Members were not validated.`,
+                    confidence: "uncertain",
+                    confidenceReason: "Target bytecode could not be loaded and fallback existence checks were unavailable.",
+                    category: "resolution",
+                    resolutionPath: "source-signature-unavailable",
+                    issueOrigin: "tool_issue",
+                    falsePositiveRisk: "high"
+                });
+                addSkippedMembers(parsed, resolvedMembers);
+            }
+            else {
+                issues.push({
+                    severity: "error",
+                    kind: "target-not-found",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Target class "${target.className}" not found in game jar.`,
+                    confidence,
+                    confidenceReason,
+                    category: "validation",
+                    resolutionPath: "target-class-missing"
+                });
+            }
+        }
+    }
+    // Only validate members against targets that were resolved
+    const resolvedTargetNames = targetNames.filter((t) => targetMembers.has(t));
+    for (const inj of parsed.injections) {
+        validateInjection(inj, targetMembers, resolvedTargetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport);
+    }
+    for (const shadow of parsed.shadows) {
+        validateShadow(shadow, targetMembers, resolvedTargetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport);
+    }
+    for (const accessor of parsed.accessors) {
+        validateAccessor(accessor, targetMembers, resolvedTargetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport);
+    }
+    // Add parse warnings — escalate @Accessor/@Invoker/@Shadow parse failures to issues
+    for (const pw of parsed.parseWarnings) {
+        if (/@(Accessor|Invoker|Shadow)\b/.test(pw)) {
+            const annotation = pw.includes("@Accessor") ? "@Accessor"
+                : pw.includes("@Invoker") ? "@Invoker" : "@Shadow";
+            issues.push({
+                severity: "warning",
+                kind: "unknown-annotation",
+                annotation,
+                target: parsed.className,
+                message: pw,
+                confidence: "uncertain",
+                confidenceReason: "Parser could not extract member declaration; the annotation may be valid.",
+                category: "parse",
+                issueOrigin: "parser_limitation",
+                falsePositiveRisk: "high"
+            });
+        }
+        else {
+            warnings.push(pw);
+        }
+    }
+    // Contradiction detection: if some same-annotation members resolved OK but parse failed for others, note it
+    const resolvedAnnotations = new Set();
+    for (const member of resolvedMembers) {
+        if (member.status === "resolved") {
+            resolvedAnnotations.add(member.annotation);
+        }
+    }
+    let errorCount = 0;
+    let warningCount = 0;
+    let definiteErrors = 0;
+    let uncertainErrors = 0;
+    let resolutionErrors = 0;
+    let parseWarningCount = 0;
+    for (const issue of issues) {
+        if (issue.category === "parse" && resolvedAnnotations.has(issue.annotation)) {
+            issue.message += " (Note: other members with the same annotation resolved successfully.)";
+        }
+        if (!issue.category) {
+            issue.category = issue.resolutionPath ? "resolution" : "validation";
+        }
+        if (!issue.issueOrigin) {
+            if (issue.category === "parse") {
+                issue.issueOrigin = "parser_limitation";
+            }
+            else {
+                issue.issueOrigin = issue.resolutionPath && TOOL_RESOLUTION_PATHS.includes(issue.resolutionPath)
+                    ? "tool_issue"
+                    : "code_issue";
+            }
+        }
+        if (issue.severity === "error") {
+            errorCount++;
+            if (issue.confidence === "uncertain") {
+                uncertainErrors++;
+            }
+            else {
+                definiteErrors++;
+            }
+        }
+        else {
+            warningCount++;
+        }
+        if (issue.resolutionPath != null) {
+            resolutionErrors++;
+        }
+        if (issue.category === "parse") {
+            parseWarningCount++;
+        }
+    }
+    // Enrich issues with explanations and suggested calls when explain=true
+    if (explain) {
+        const version = provenance?.version;
+        const mapping = provenance?.requestedMapping;
+        const symbolLookupContext = {};
+        if (suggestedCallContext?.sourcePriority) {
+            symbolLookupContext.sourcePriority = suggestedCallContext.sourcePriority;
+        }
+        const classSourceContext = {};
+        if (suggestedCallContext?.scope)
+            classSourceContext.scope = suggestedCallContext.scope;
+        if (suggestedCallContext?.sourcePriority)
+            classSourceContext.sourcePriority = suggestedCallContext.sourcePriority;
+        if (suggestedCallContext?.projectPath)
+            classSourceContext.projectPath = suggestedCallContext.projectPath;
+        if (suggestedCallContext?.mapping)
+            classSourceContext.mapping = suggestedCallContext.mapping;
+        const assignSuggested = (issue, tool, params) => {
+            // Result-level suggestions go through the same schema gate as
+            // error-side suggestedCall payloads; a payload that does not parse
+            // stays unset rather than reaching the agent in broken form.
+            const gated = buildSuggestedCall({ tool, params });
+            if (gated.suggestedCall) {
+                issue.suggestedCall = gated.suggestedCall;
+            }
+        };
+        for (const issue of issues) {
+            switch (issue.kind) {
+                case "target-not-found":
+                    issue.explanation = `The class "${issue.target}" was not found in the game jar. It may be misspelled, from a different version, or use a different mapping namespace.`;
+                    if (version && mapping) {
+                        assignSuggested(issue, "check-symbol-exists", {
+                            kind: "class",
+                            name: issue.target,
+                            version,
+                            sourceMapping: mapping,
+                            nameMode: "auto",
+                            ...symbolLookupContext
+                        });
+                    }
+                    break;
+                case "validation-incomplete":
+                    issue.explanation = `Target metadata for "${issue.target}" could not be loaded reliably, so validation was only partial. This usually indicates a tool or environment limitation rather than a confirmed code error.`;
+                    if (version) {
+                        assignSuggested(issue, "get-class-source", {
+                            className: issue.target,
+                            target: { type: "resolve", kind: "version", value: version },
+                            ...(mapping ? { mapping } : {}),
+                            mode: "metadata",
+                            ...classSourceContext
+                        });
+                    }
+                    break;
+                case "target-mapping-failed":
+                    issue.explanation = `Mapping lookup failed for "${issue.target}". The class may exist under a different name in the target namespace.`;
+                    if (version && mapping) {
+                        assignSuggested(issue, "check-symbol-exists", {
+                            kind: "class",
+                            name: issue.target,
+                            version,
+                            sourceMapping: mapping,
+                            nameMode: "auto",
+                            ...symbolLookupContext
+                        });
+                    }
+                    break;
+                case "method-not-found": {
+                    const parts = issue.target.split("#");
+                    const className = parts[0] ?? issue.target;
+                    issue.explanation = `The method was not found in the target class. It may be named differently in the current mapping, or might not exist in this version.`;
+                    if (version) {
+                        assignSuggested(issue, "get-class-source", {
+                            className,
+                            target: { type: "resolve", kind: "version", value: version },
+                            ...(mapping ? { mapping } : {}),
+                            mode: "metadata",
+                            ...classSourceContext
+                        });
+                    }
+                    break;
+                }
+                case "field-not-found": {
+                    const parts = issue.target.split("#");
+                    const ownerName = parts[0] ?? issue.target;
+                    const fieldName = parts[1] ?? issue.target;
+                    issue.explanation = `The field "${fieldName}" was not found in the target class. Verify the field name matches the expected mapping namespace.`;
+                    if (version && mapping) {
+                        assignSuggested(issue, "check-symbol-exists", {
+                            kind: "field",
+                            owner: ownerName,
+                            name: fieldName,
+                            version,
+                            sourceMapping: mapping,
+                            ...symbolLookupContext
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    const structuredWarnings = warnings.map(classifyStructuredWarning);
+    // Warning aggregation mode
+    let aggregatedWarnings;
+    let outputWarnings = warnings;
+    let outputStructuredWarnings = structuredWarnings.length > 0 ? structuredWarnings : undefined;
+    if (warningMode === "aggregated" && structuredWarnings.length > 0) {
+        const groupMap = new Map();
+        for (const sw of structuredWarnings) {
+            const cat = sw.category ?? "validation";
+            const existing = groupMap.get(cat);
+            if (existing) {
+                existing.count++;
+                if (existing.samples.length < 2) {
+                    existing.samples.push(sw.message);
+                }
+            }
+            else {
+                groupMap.set(cat, { count: 1, samples: [sw.message] });
+            }
+        }
+        aggregatedWarnings = [...groupMap.entries()].map(([category, { count, samples }]) => ({
+            category,
+            count,
+            samples
+        }));
+        outputWarnings = [];
+        outputStructuredWarnings = undefined;
+    }
+    // Compute confidence score
+    const remapFailureCount = provenance?.remapFailures ?? 0;
+    const memberSummary = summarizeResolvedMembers(resolvedMembers);
+    const confidenceBreakdown = healthReport
+        ? computeConfidenceBreakdown(healthReport, provenance, remapFailureCount, memberSummary.membersSkipped)
+        : undefined;
+    const confidenceScore = confidenceBreakdown?.score;
+    const total = parsed.injections.length + parsed.shadows.length + parsed.accessors.length;
+    const summary = {
+        injections: parsed.injections.length,
+        shadows: parsed.shadows.length,
+        accessors: parsed.accessors.length,
+        total,
+        ...memberSummary,
+        errors: errorCount,
+        warnings: warningCount,
+        definiteErrors,
+        uncertainErrors,
+        resolutionErrors,
+        parseWarnings: parseWarningCount
+    };
+    const validationStatus = computeValidationStatus(summary);
+    const quickSummary = buildQuickSummary(validationStatus, summary, { provenance, healthReport });
+    return {
+        className: parsed.className,
+        targets: targetNames,
+        priority: parsed.priority,
+        valid: definiteErrors === 0,
+        validationStatus,
+        issues,
+        summary,
+        provenance,
+        warnings: outputWarnings,
+        structuredWarnings: outputStructuredWarnings,
+        aggregatedWarnings,
+        resolvedMembers: resolvedMembers.length > 0 ? resolvedMembers : undefined,
+        toolHealth: healthReport,
+        confidenceScore,
+        confidenceBreakdown,
+        quickSummary
+    };
+}
+//# sourceMappingURL=parsed-validator.js.map