@intellectif/lk-core 0.17.0 → 0.19.0

package/dist/{activity-BmjBjXVJ.d.ts → activity-f0bgZSTP.d.ts}

@@ -63,6 +63,147 @@ declare function levenshteinDistance(a: string, b: string, max: number): number;
  */
 declare function matchText(input: string, accepted: string | readonly string[], policy?: TextMatchPolicy): TextMatchResult;
 
+/**
+ * The return trip for deferred grading.
+ *
+ * `evaluate()` can say a submission is `deferred` — graded later by an AI or a
+ * human — but until now there was no type for the grade that comes BACK, so
+ * every consumer invented one. The shapes here are the intersection of two
+ * independent production graders (a rubric-based essay grader and a CEFR
+ * speaking grader) that converged on the same envelope: a normalised total,
+ * per-criterion scores with comments, grader-authored artefacts, a confidence
+ * signal, an explicit human-review flag, and provenance.
+ *
+ * The SDK models the SHAPE and the arithmetic. It never calls a model, never
+ * holds a key, and never decides what a rubric means — that stays yours.
+ */
+
+/**
+ * Lifecycle of a deferred grade. A grade exists only in the `graded` state;
+ * every other state means "no grade, and here is why" — which is precisely the
+ * distinction that stops an ungraded submission being rendered as a zero.
+ */
+type GradingState = 'queued' | 'running' | 'graded' | 'failed' | 'skipped';
+/**
+ * Who produced a grade.
+ *
+ * - `'auto'` — a non-generative measurement engine, for example a
+ *   pronunciation-assessment service.
+ * - `'ai'` — a generative model.
+ * - `'human'` — a person.
+ */
+type GraderKind = 'ai' | 'human' | 'auto';
+/** Provenance of a grade, so a re-grade two years later is explicable. */
+interface Grader {
+    kind: GraderKind;
+    /** Identifier of the human grader, when `kind` is `'human'`. */
+    id?: string;
+    /** Model identifier, when `kind` is `'ai'` (e.g. a model name and version). */
+    model?: string;
+    /** Hash or id of the prompt/rubric revision used, for auditability. */
+    promptHash?: string;
+}
+/** Optional cost/usage telemetry emitted by an AI grader. */
+interface GraderUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    costUsd?: number;
+}
+/** A grader's verdict on one rubric criterion. */
+interface CriterionScore {
+    /** Matches a `WrittenResponseRubricCriterion.name` when a rubric is known. */
+    name: string;
+    /**
+     * The grader's score for this criterion, out of {@link CriterionScore.maxScore}
+     * (which defaults to 1, the SDK's scaled convention). Absent when the
+     * criterion is judged on an ordinal `band`.
+     */
+    score?: number;
+    /**
+     * What `score` is out of. Defaults to `1`.
+     *
+     * Real graders rarely work in [0,1]: rubrics come back out of 100, out of 9
+     * (CEFR/IELTS bands), or out of a points total that differs between
+     * criteria. Before this field the only way to use {@link gradeFromRubric}
+     * was to normalise by hand first — and a grader that skipped that step got
+     * its scores REJECTED, which pushed integrators back to letting the model
+     * compute the weighted total itself. That is precisely the arithmetic this
+     * SDK exists to take away from a language model.
+     *
+     * Set it per criterion, so a rubric mixing a /100 criterion with a /9 band
+     * score still composes. `gradeFromRubric` normalises `score / maxScore`
+     * before weighting; the resulting ratio must land in [0,1].
+     */
+    maxScore?: number;
+    /** Ordinal verdict when the rubric is banded rather than numeric (e.g. `"B1"`). */
+    band?: string;
+    /** The grader's comment for this criterion, addressed to the learner. */
+    comment?: string;
+    /**
+     * Weight actually applied, echoed from the rubric so the total is checkable.
+     * Defaults to `1`. Zero or more: `gradeFromRubric` refuses a negative weight
+     * rather than let it carry the total outside [0,1].
+     */
+    weight?: number;
+    /** Not applicable to this submission (e.g. interaction on a monologue task). */
+    notApplicable?: boolean;
+}
+/** A suggested correction anchored in the learner's own text. */
+interface InlineCorrection {
+    /** Verbatim span from the submission. */
+    original: string;
+    /** Suggested replacement. */
+    corrected: string;
+    explanation?: string;
+    /** Character offsets into the submitted text, so a UI can anchor it inline. */
+    range?: {
+        start: number;
+        end: number;
+    };
+    /** Error-type tag (`"article"`, `"tense"`, `"register"`). */
+    category?: string;
+}
+/**
+ * A grade that came back from an asynchronous grader. `score` is scaled
+ * [0,1] against `maxScore`, matching every other score in the SDK. A grader
+ * that works in points does not have to normalise by hand: declare
+ * `maxScore` on each {@link CriterionScore} and let `gradeFromRubric` do the
+ * arithmetic, which is the whole point of handing it the judgements.
+ *
+ * `maxScore` is a positive, finite number and `score` a finite number from 0
+ * to it. `outcomeFromGrade` refuses a record that is not, rather than mirror
+ * numbers nobody can defend onto an outcome.
+ */
+interface GradeRecord {
+    score: number;
+    maxScore: number;
+    passed: boolean;
+    /** Narrative feedback addressed to the learner. */
+    feedback: string | null;
+    /** Per-criterion breakdown, when the grader worked against a rubric. */
+    criteria?: CriterionScore[];
+    /**
+     * Per-item marks carried by a grade — for example the per-word marks of a
+     * read-aloud grade. `outcomeFromGrade` does not mirror them onto the
+     * outcome; read `outcome.grade.details`.
+     */
+    details?: ScoringDetail[];
+    /** Corrections anchored in the learner's text. */
+    corrections?: InlineCorrection[];
+    /** Supporting observations the grader cited. */
+    evidence?: string[];
+    /** How the grader reached this verdict. */
+    rationale?: string;
+    /** The grader's own confidence — a signal for routing to human review. */
+    confidence?: 'high' | 'medium' | 'low';
+    /** The grader is unsure or the submission is atypical; route to a human. */
+    requiresHumanReview?: boolean;
+    grader?: Grader;
+    usage?: GraderUsage;
+    /** ISO 8601 timestamp of when the grade was produced. */
+    gradedAt?: string;
+}
+
 /**
  * The contract between an activity and a model the HOST runs, for help a
  * learner reads: an explanation of a graded answer, and hints before one.
@@ -72,6 +213,7 @@ declare function matchText(input: string, accepted: string | readonly string[],
  * SDK's own scorer — and checks what comes back. The model explains a verdict
  * the SDK reached; it never reaches one.
  */
+
 /**
  * What an author allows AI to do for one item. Absent, or a feature left out,
  * leaves the choice to the deployment. `false` switches a feature off for this
@@ -250,142 +392,20 @@ interface AiTextResult {
     /** For an explanation: the verdict the model explained. */
     verdict?: AiVerdict;
     provenance?: AiProvenance;
-}
-/** Why a result was not shown. */
-type AiRefusal = 'malformed' | 'empty' | 'too-long' | 'contradicts-grade' | 'reveals-answer';
-
-/**
- * The return trip for deferred grading.
- *
- * `evaluate()` can say a submission is `deferred` — graded later by an AI or a
- * human — but until now there was no type for the grade that comes BACK, so
- * every consumer invented one. The shapes here are the intersection of two
- * independent production graders (a rubric-based essay grader and a CEFR
- * speaking grader) that converged on the same envelope: a normalised total,
- * per-criterion scores with comments, grader-authored artefacts, a confidence
- * signal, an explicit human-review flag, and provenance.
- *
- * The SDK models the SHAPE and the arithmetic. It never calls a model, never
- * holds a key, and never decides what a rubric means — that stays yours.
- */
-
-/**
- * Lifecycle of a deferred grade. A grade exists only in the `graded` state;
- * every other state means "no grade, and here is why" — which is precisely the
- * distinction that stops an ungraded submission being rendered as a zero.
- */
-type GradingState = 'queued' | 'running' | 'graded' | 'failed' | 'skipped';
-/**
- * Who produced a grade.
- *
- * - `'auto'` — a non-generative measurement engine, for example a
- *   pronunciation-assessment service.
- * - `'ai'` — a generative model.
- * - `'human'` — a person.
- */
-type GraderKind = 'ai' | 'human' | 'auto';
-/** Provenance of a grade, so a re-grade two years later is explicable. */
-interface Grader {
-    kind: GraderKind;
-    /** Identifier of the human grader, when `kind` is `'human'`. */
-    id?: string;
-    /** Model identifier, when `kind` is `'ai'` (e.g. a model name and version). */
-    model?: string;
-    /** Hash or id of the prompt/rubric revision used, for auditability. */
-    promptHash?: string;
-}
-/** Optional cost/usage telemetry emitted by an AI grader. */
-interface GraderUsage {
-    promptTokens?: number;
-    completionTokens?: number;
-    costUsd?: number;
-}
-/** A grader's verdict on one rubric criterion. */
-interface CriterionScore {
-    /** Matches a `WrittenResponseRubricCriterion.name` when a rubric is known. */
-    name: string;
     /**
-     * The grader's score for this criterion, out of {@link CriterionScore.maxScore}
-     * (which defaults to 1, the SDK's scaled convention). Absent when the
-     * criterion is judged on an ordinal `band`.
-     */
-    score?: number;
-    /**
-     * What `score` is out of. Defaults to `1`.
-     *
-     * Real graders rarely work in [0,1]: rubrics come back out of 100, out of 9
-     * (CEFR/IELTS bands), or out of a points total that differs between
-     * criteria. Before this field the only way to use {@link gradeFromRubric}
-     * was to normalise by hand first — and a grader that skipped that step got
-     * its scores REJECTED, which pushed integrators back to letting the model
-     * compute the weighted total itself. That is precisely the arithmetic this
-     * SDK exists to take away from a language model.
+     * What the call cost, as the provider reported it to your port: the same
+     * {@link GraderUsage} a returned grade carries, so one shape covers help for
+     * a learner and marking by a grader.
      *
-     * Set it per criterion, so a rubric mixing a /100 criterion with a /9 band
-     * score still composes. `gradeFromRubric` normalises `score / maxScore`
-     * before weighting; the resulting ratio must land in [0,1].
-     */
-    maxScore?: number;
-    /** Ordinal verdict when the rubric is banded rather than numeric (e.g. `"B1"`). */
-    band?: string;
-    /** The grader's comment for this criterion, addressed to the learner. */
-    comment?: string;
-    /** Weight actually applied, echoed from the rubric so the total is checkable. */
-    weight?: number;
-    /** Not applicable to this submission (e.g. interaction on a monologue task). */
-    notApplicable?: boolean;
-}
-/** A suggested correction anchored in the learner's own text. */
-interface InlineCorrection {
-    /** Verbatim span from the submission. */
-    original: string;
-    /** Suggested replacement. */
-    corrected: string;
-    explanation?: string;
-    /** Character offsets into the submitted text, so a UI can anchor it inline. */
-    range?: {
-        start: number;
-        end: number;
-    };
-    /** Error-type tag (`"article"`, `"tense"`, `"register"`). */
-    category?: string;
-}
-/**
- * A grade that came back from an asynchronous grader. `score` is scaled
- * [0,1] against `maxScore`, matching every other score in the SDK. A grader
- * that works in points does not have to normalise by hand: declare
- * `maxScore` on each {@link CriterionScore} and let `gradeFromRubric` do the
- * arithmetic, which is the whole point of handing it the judgements.
- */
-interface GradeRecord {
-    score: number;
-    maxScore: number;
-    passed: boolean;
-    /** Narrative feedback addressed to the learner. */
-    feedback: string | null;
-    /** Per-criterion breakdown, when the grader worked against a rubric. */
-    criteria?: CriterionScore[];
-    /**
-     * Per-item marks carried by a grade — for example the per-word marks of a
-     * read-aloud grade. `outcomeFromGrade` does not mirror them onto the
-     * outcome; read `outcome.grade.details`.
+     * The SDK never estimates it and never adds it up. It carries what a port
+     * sends through to `onInteraction`, beside the provenance, so the record of
+     * what a learner was shown and the record of what it cost are the same
+     * record. Numbers that are not finite and zero or more are dropped.
      */
-    details?: ScoringDetail[];
-    /** Corrections anchored in the learner's text. */
-    corrections?: InlineCorrection[];
-    /** Supporting observations the grader cited. */
-    evidence?: string[];
-    /** How the grader reached this verdict. */
-    rationale?: string;
-    /** The grader's own confidence — a signal for routing to human review. */
-    confidence?: 'high' | 'medium' | 'low';
-    /** The grader is unsure or the submission is atypical; route to a human. */
-    requiresHumanReview?: boolean;
-    grader?: Grader;
     usage?: GraderUsage;
-    /** ISO 8601 timestamp of when the grade was produced. */
-    gradedAt?: string;
 }
+/** Why a result was not shown. */
+type AiRefusal = 'malformed' | 'empty' | 'too-long' | 'contradicts-grade' | 'reveals-answer';
 
 /**
  * An xAPI Activity object — the thing a statement is about.
@@ -1388,8 +1408,13 @@ interface DeferredScoringPartial {
  *   a grade has not landed, or the attempt is still open has earned nothing
  *   yet, and recording it as zero is how an incomplete attempt becomes a
  *   plausible-looking fail.
+ * - `grade_rejected` — a grade came back, and `outcomeFromGrade` refused it
+ *   because its numbers cannot be a grade (a `score` or `maxScore` that is not
+ *   a finite number, a `maxScore` of 0 or less, or a score outside 0 to
+ *   `maxScore`). The record is kept on `rejectedGrade`. A real grade is still
+ *   owed, so re-grade the slot: waiting will not bring one.
  */
-type DeferredReason = 'requires_async_grading' | 'no_response_recorded';
+type DeferredReason = 'requires_async_grading' | 'no_response_recorded' | 'grade_rejected';
 /**
  * The outcome of evaluating a learner response against an activity — the
  * union `evaluate()` returns. Unlike {@link ScoringResult}, it can express
@@ -1416,6 +1441,12 @@ type ItemOutcome = {
     maxScore: number;
     /** Synchronously computable progress facts (word bounds, counts). */
     partial?: DeferredScoringPartial;
+    /**
+     * The record `outcomeFromGrade` refused, verbatim, when `reason` is
+     * `grade_rejected` — kept for audit and for the re-grade. Nothing on it
+     * is mirrored onto the outcome, and nothing reads it as a grade.
+     */
+    rejectedGrade?: GradeRecord;
 } | {
     status: 'graded';
     /**
@@ -1530,8 +1561,18 @@ type InteractionKind = 'option-selected' | 'option-deselected' | 'blank-filled'
  * is never shown and never reported here.
  */
  | 'ai-hint-shown'
-/** An AI explanation of the graded answer was shown (`provenance` when sent). */
- | 'ai-explanation-shown' | (string & {});
+/** An AI explanation of the graded answer was shown (`provenance`, `usage` when sent). */
+ | 'ai-explanation-shown'
+/**
+ * An AI answer was refused, and the learner was told help was not available
+ * (`feature`, `reason` — an {@link AiRefusal} — and `hintNumber` for a hint).
+ *
+ * **The text itself is never carried**: a hint refused for revealing the
+ * answer contains the answer, and this event is logged. It is how a host
+ * watches its own model in production, where the development console warning
+ * it accompanies is silent.
+ */
+ | 'ai-help-refused' | (string & {});
 /** Fired by activity components on every discrete learner interaction. */
 interface InteractionEvent {
     /** The kind of interaction that occurred. */

package/dist/ai-check.cjs

@@ -0,0 +1,283 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkFVZJ4X3Ycjs = require('./chunk-FVZJ4X3Y.cjs');
+require('./chunk-COBK2RUX.cjs');
+require('./chunk-D4TOPSHV.cjs');
+
+// src/ai-check/cases.ts
+var capital = {
+  schemaVersion: "1.0",
+  type: "multiple-choice",
+  id: "ai-check-mc",
+  title: "Capital cities",
+  question: "What is the capital of Spain?",
+  mode: "single",
+  scoringStrategy: "all-or-nothing",
+  options: [
+    { id: "madrid", text: "Madrid", isCorrect: true },
+    { id: "barcelona", text: "Barcelona", isCorrect: false },
+    { id: "seville", text: "Seville", isCorrect: false }
+  ]
+};
+var introduction = {
+  schemaVersion: "1.0",
+  type: "fill-in-the-blanks",
+  id: "ai-check-fib",
+  title: "Introducing yourself",
+  passage: "My name {{be}} Rossi and I {{live}} in Madrid.",
+  blanks: [
+    { id: "be", acceptedAnswers: ["is"] },
+    { id: "live", acceptedAnswers: ["live"], hint: "Present simple, first person." }
+  ],
+  scoringStrategy: "partial"
+};
+var landscape = {
+  schemaVersion: "1.0",
+  type: "gap-select",
+  id: "ai-check-gap",
+  title: "Geography",
+  locale: "es-ES",
+  passage: "El r\xEDo pasa por un {{g1}} muy profundo, y el agua {{g2}} fr\xEDa.",
+  gaps: [
+    {
+      id: "g1",
+      choices: [
+        { id: "canon", text: "ca\xF1\xF3n" },
+        { id: "campo", text: "campo" }
+      ],
+      correctChoiceId: "canon"
+    },
+    {
+      id: "g2",
+      choices: [
+        { id: "esta", text: "est\xE1" },
+        { id: "es", text: "es" }
+      ],
+      correctChoiceId: "esta"
+    }
+  ],
+  scoringStrategy: "partial"
+};
+var listening = {
+  schemaVersion: "1.0",
+  type: "dictation",
+  id: "ai-check-dictation",
+  title: "Listen and type",
+  transcript: "The train leaves at half past nine."
+};
+var chose = (ids) => ({
+  type: "multiple-choice",
+  selectedOptionIds: ids
+});
+var typed = (answers) => ({
+  type: "fill-in-the-blanks",
+  answers
+});
+var picked = (choices) => ({
+  type: "gap-select",
+  selections: choices
+});
+var wrote = (text) => ({ type: "dictation", text });
+function explanationCase(id, about, data, response) {
+  const request = _chunkFVZJ4X3Ycjs.aiExplanationRequest.call(void 0, { data, response });
+  if (request === null) {
+    throw new Error(`ai-check: no explanation request for "${id}"`);
+  }
+  return { id, feature: "explanation", about, request };
+}
+function hintCase(id, about, data, response, previousHints = []) {
+  const request = _chunkFVZJ4X3Ycjs.aiHintRequest.call(void 0, { data, response, previousHints });
+  if (request === null) {
+    throw new Error(`ai-check: no hint request for "${id}"`);
+  }
+  return { id, feature: "hint", about, request };
+}
+function aiCheckCases() {
+  return [
+    explanationCase("mc-correct", "Chose the right city", capital, chose(["madrid"])),
+    explanationCase("mc-wrong", "Chose Barcelona", capital, chose(["barcelona"])),
+    explanationCase("mc-blank", "Chose nothing and submitted", capital, chose([])),
+    explanationCase(
+      "fib-correct",
+      "Filled both blanks correctly",
+      introduction,
+      typed({ be: "is", live: "live" })
+    ),
+    explanationCase(
+      "fib-partly",
+      "One blank right, one wrong",
+      introduction,
+      typed({ be: "is", live: "lives" })
+    ),
+    explanationCase(
+      "fib-wrong",
+      "Both blanks wrong",
+      introduction,
+      typed({ be: "are", live: "living" })
+    ),
+    explanationCase(
+      "gap-partly",
+      "One gap right, one wrong, in Spanish",
+      landscape,
+      picked({ g1: "canon", g2: "es" })
+    ),
+    explanationCase(
+      "gap-wrong",
+      "Both gaps wrong, in Spanish",
+      landscape,
+      picked({ g1: "campo", g2: "es" })
+    ),
+    explanationCase(
+      "dictation-near",
+      "Typed the sentence with two words wrong",
+      listening,
+      wrote("The train leaves at half past five")
+    ),
+    explanationCase(
+      "dictation-correct",
+      "Typed the sentence correctly",
+      listening,
+      wrote("The train leaves at half past nine.")
+    ),
+    hintCase("mc-hint-1", "Has not answered yet", capital, chose([])),
+    hintCase("mc-hint-2", "Asked again after choosing Seville", capital, chose(["seville"]), [
+      "Think about where the government sits."
+    ]),
+    hintCase("fib-hint-1", "Both blanks empty", introduction, typed({})),
+    hintCase(
+      "fib-hint-2",
+      "Asked again with one blank wrong",
+      introduction,
+      typed({ be: "are", live: "" }),
+      ["Look again at the first blank."]
+    ),
+    hintCase("gap-hint-1", "Neither gap chosen, in Spanish", landscape, picked({})),
+    hintCase(
+      "gap-hint-2",
+      "Asked again with the first gap wrong",
+      landscape,
+      picked({ g1: "campo" }),
+      ["Piensa en la forma del terreno."]
+    )
+  ];
+}
+
+// src/ai-check/index.ts
+var REFUSALS = [
+  "malformed",
+  "empty",
+  "too-long",
+  "contradicts-grade",
+  "reveals-answer"
+];
+var now = () => Date.now();
+async function runCase(ports, one) {
+  const started = now();
+  const explaining = one.request.feature === "explanation";
+  const port = explaining ? ports.explain : ports.hint;
+  if (port === void 0) {
+    throw new Error(`ai-check: no port for "${one.id}"`);
+  }
+  let raw;
+  try {
+    raw = await port(one.request);
+  } catch (error) {
+    return {
+      case: one,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ms: now() - started
+    };
+  }
+  const ms = now() - started;
+  const checked = explaining ? _chunkFVZJ4X3Ycjs.checkAiExplanation.call(void 0, raw, one.request) : _chunkFVZJ4X3Ycjs.checkAiHint.call(void 0, raw, one.request);
+  if (checked.ok) {
+    return { case: one, ok: true, result: checked.result, ms };
+  }
+  const text = typeof _optionalChain([raw, 'optionalAccess', _ => _.text]) === "string" ? raw : void 0;
+  return {
+    case: one,
+    ok: false,
+    refusal: checked.refusal,
+    ...text !== void 0 ? { result: text } : {},
+    ms
+  };
+}
+async function runAiCheck(ports, options = {}) {
+  const all = _nullishCoalesce(options.cases, () => ( aiCheckCases()));
+  const asked = Math.trunc(_nullishCoalesce(options.concurrency, () => ( 1)));
+  const lanes = Number.isFinite(asked) && asked >= 1 ? Math.min(asked, 16) : 1;
+  const runnable = all.filter(
+    (one) => one.request.feature === "explanation" ? ports.explain !== void 0 : ports.hint !== void 0
+  );
+  const results = new Array(runnable.length);
+  let next = 0;
+  const lane = async () => {
+    while (next < runnable.length) {
+      const mine = next;
+      next += 1;
+      const one = runnable[mine];
+      if (one === void 0) {
+        return;
+      }
+      results[mine] = await runCase(ports, one);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(lanes, runnable.length) }, lane));
+  const byRefusal = Object.fromEntries(REFUSALS.map((reason) => [reason, 0]));
+  let shown = 0;
+  let refused = 0;
+  let errors = 0;
+  for (const result of results) {
+    if (result.ok) {
+      shown += 1;
+    } else if (result.refusal !== void 0) {
+      refused += 1;
+      byRefusal[result.refusal] += 1;
+    } else {
+      errors += 1;
+    }
+  }
+  return {
+    total: results.length,
+    shown,
+    refused,
+    errors,
+    skipped: all.length - runnable.length,
+    byRefusal,
+    results
+  };
+}
+function formatAiCheckReport(report) {
+  const lines = [];
+  const slowest = report.results.reduce((worst, one) => Math.max(worst, one.ms), 0);
+  lines.push(
+    `ai-check: ${report.shown}/${report.total} shown, ${report.refused} refused, ${report.errors} failed${report.skipped > 0 ? `, ${report.skipped} skipped (no port)` : ""} \u2014 slowest ${slowest} ms`
+  );
+  for (const reason of REFUSALS) {
+    const count = report.byRefusal[reason];
+    if (count > 0) {
+      lines.push(`  ${reason}: ${count}`);
+    }
+  }
+  for (const result of report.results) {
+    if (result.ok) {
+      continue;
+    }
+    const why = _nullishCoalesce(result.refusal, () => ( `port failed (${_nullishCoalesce(result.error, () => ( "no message"))})`));
+    lines.push(`  \u2717 ${result.case.id} [${result.case.feature}] ${result.case.about}: ${why}`);
+    if (result.result !== void 0) {
+      lines.push(`      ${result.result.text.replace(/\s+/g, " ").slice(0, 200)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+
+
+
+exports.aiCheckCases = aiCheckCases; exports.formatAiCheckReport = formatAiCheckReport; exports.runAiCheck = runAiCheck;
+//# sourceMappingURL=ai-check.cjs.map