niceeval 0.13.1 → 0.13.2

package/dist/assertions/match.cjs

@@ -41,6 +41,7 @@ exports.commandMatch = commandMatch;
 exports.eventMatch = eventMatch;
 const json_match_ts_1 = require("../shared/json-match.cjs");
 const util_ts_1 = require("../util.cjs");
+const limits_ts_1 = require("./limits.cjs");
 // 这些 symbol 不导出。外部作者无法构造看似可消费的 Match；输入 variance 与 refinement
 // variance 也保持分离，ScoreMatch 不会伪造一个没有含义的输出 refinement。
 const matchInputBrand = Symbol("niceeval.match.input");
@@ -67,6 +68,7 @@ function diagnostic(code, message, options = {}) {
         ...(options.reason === undefined ? {} : { reason: options.reason }),
         ...(options.locator === undefined ? {} : { locator: options.locator }),
         ...(options.children === undefined ? {} : { children: Object.freeze([...options.children]) }),
+        ...(options.truncation === undefined ? {} : { truncation: Object.freeze({ ...options.truncation }) }),
     });
 }
 function matched(value, detail) {
@@ -1081,30 +1083,66 @@ function assertManagedEventMatch(value, label = "match") {
  * cannot manufacture a positive count or an absence proof.
  */
 async function evaluateToolMatchCollection(match, occurrences, options) {
-    const candidates = [];
-    for (const occurrence of occurrences) {
-        candidates.push(Object.freeze({
+    const sampledCandidates = [];
+    let matchCount = 0;
+    let firstMatch;
+    let firstUnavailable;
+    let exactOverage;
+    for (const [index, occurrence] of occurrences.entries()) {
+        const candidate = Object.freeze({
+            index,
             candidate: occurrence,
             result: await evaluateBooleanMatch(match, occurrence),
-        }));
+        });
+        if (sampledCandidates.length < limits_ts_1.assertionRuntimeLimits.collectionDiagnosticCandidates) {
+            sampledCandidates.push(candidate);
+        }
+        if (candidate.result.state === "matched") {
+            matchCount += 1;
+            firstMatch ??= candidate;
+            if (options.quantifier.kind === "exact" && matchCount === options.quantifier.count + 1) {
+                exactOverage = candidate;
+            }
+        }
+        else if (candidate.result.state === "unavailable") {
+            firstUnavailable ??= candidate;
+        }
     }
-    const children = candidates.map((candidate, index) => resultChild(candidate.result, index, `candidate ${candidate.candidate.id}`));
-    const matches = candidates.filter((candidate) => candidate.result.state === "matched");
-    const unavailableCandidate = candidates.find((candidate) => candidate.result.state === "unavailable");
-    const unavailableReason = unavailableCandidate?.result.state === "unavailable"
-        ? unavailableCandidate.result.reason
+    const unavailableReason = firstUnavailable?.result.state === "unavailable"
+        ? firstUnavailable.result.reason
         : options.coverageReason;
     const incomplete = unavailableReason !== undefined;
-    const received = `${matches.length} definite match${matches.length === 1 ? "" : "es"}`;
+    const received = `${matchCount} definite match${matchCount === 1 ? "" : "es"}`;
     const candidateLocator = (candidate) => candidate === undefined ? undefined : { kind: "tool-occurrence", id: candidate.candidate.id };
+    const diagnosticSample = (...decisive) => {
+        const byIndex = new Map();
+        for (const candidate of [...sampledCandidates, ...decisive]) {
+            if (candidate !== undefined)
+                byIndex.set(candidate.index, candidate);
+        }
+        const captured = [...byIndex.values()].sort((left, right) => left.index - right.index);
+        return Object.freeze({
+            children: Object.freeze(captured.map((candidate) => resultChild(candidate.result, candidate.index, `candidate ${candidate.candidate.id}`))),
+            ...(captured.length === occurrences.length
+                ? {}
+                : {
+                    truncation: Object.freeze({
+                        code: "diagnostic-truncated",
+                        reason: "sampled",
+                        captured: captured.length,
+                        knownTotal: occurrences.length,
+                    }),
+                }),
+        });
+    };
     if (options.quantifier.kind === "absent") {
-        const first = matches[0];
+        const first = firstMatch;
         if (first !== undefined) {
             return mismatched(diagnostic("tool-absence-mismatch", `notCalledTool(${match.name}) observed a matching tool`, {
                 expected: `no ${match.name}`,
                 received,
                 locator: candidateLocator(first),
-                children,
+                ...diagnosticSample(first),
             }));
         }
         if (incomplete) {
@@ -1112,38 +1150,38 @@ async function evaluateToolMatchCollection(match, occurrences, options) {
                 expected: `no ${match.name}`,
                 received,
                 reason: unavailableReason,
-                children,
+                ...diagnosticSample(firstUnavailable),
             }));
         }
         return matched(undefined, diagnostic("tool-absence-match", `notCalledTool(${match.name}) observed no matching tool`, {
             expected: `no ${match.name}`,
             received,
-            children,
+            ...diagnosticSample(),
         }));
     }
     const { kind, count } = options.quantifier;
     const expected = kind === "exact" ? `exactly ${count} × ${match.name}` : `at least ${count} × ${match.name}`;
-    if (kind === "exact" && matches.length > count) {
-        const overage = matches[count];
+    if (kind === "exact" && matchCount > count) {
+        const overage = exactOverage;
         return mismatched(diagnostic("tool-count-exceeded", `calledTool(${match.name}) exceeded its exact count`, {
             expected,
             received,
             locator: candidateLocator(overage),
-            children,
+            ...diagnosticSample(overage),
         }));
     }
-    if (kind === "at-least" && matches.length >= count) {
-        return matched(matches[0]?.candidate, diagnostic("tool-count-match", `calledTool(${match.name}) satisfied its lower bound`, {
+    if (kind === "at-least" && matchCount >= count) {
+        return matched(firstMatch?.candidate, diagnostic("tool-count-match", `calledTool(${match.name}) satisfied its lower bound`, {
             expected,
             received,
-            children,
+            ...diagnosticSample(firstMatch),
         }));
     }
-    if (kind === "exact" && matches.length === count && !incomplete) {
-        return matched(matches[0]?.candidate, diagnostic("tool-count-match", `calledTool(${match.name}) satisfied its exact count`, {
+    if (kind === "exact" && matchCount === count && !incomplete) {
+        return matched(firstMatch?.candidate, diagnostic("tool-count-match", `calledTool(${match.name}) satisfied its exact count`, {
             expected,
             received,
-            children,
+            ...diagnosticSample(firstMatch),
         }));
     }
     if (incomplete) {
@@ -1151,13 +1189,13 @@ async function evaluateToolMatchCollection(match, occurrences, options) {
             expected,
             received,
             reason: unavailableReason,
-            children,
+            ...diagnosticSample(firstUnavailable),
         }));
     }
     return mismatched(diagnostic("tool-count-mismatch", `calledTool(${match.name}) did not satisfy its count`, {
         expected,
         received,
-        children,
+        ...diagnosticSample(),
     }));
 }
 function commandResult(occurrence, executable, argsStart, excludes) {