@intellectif/lk-core 0.3.1 → 0.4.0

package/dist/{activity-zdcAMtFB.d.cts → activity-wkzRemHx.d.cts}

@@ -63,6 +63,104 @@ 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. */
+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;
+    /** Scaled [0,1]. Absent when the criterion is judged on an ordinal `band`. */
+    score?: 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, so a
+ * grader that works in points must normalise before handing one over
+ * (or set `maxScore` accordingly).
+ */
+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[];
+    /** 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;
+}
+
 /**
  * An xAPI Activity object — the thing a statement is about.
  * This SDK only builds Activity-type objects (xAPI 1.0.3 §4.1.4.1).
@@ -564,6 +662,20 @@ type ItemOutcome = {
     maxScore: number;
     /** Synchronously computable progress facts (word bounds, counts). */
     partial?: DeferredScoringPartial;
+} | {
+    status: 'graded';
+    /**
+     * A grade produced by an asynchronous grader (AI or human) and handed
+     * back to the SDK. This is the state a `deferred` outcome transitions
+     * to once grading completes; nothing in the SDK ever manufactures it.
+     */
+    grade: GradeRecord;
+    /** Scaled score in the range [0, 1], mirrored from `grade` for uniform reads. */
+    score: number;
+    maxScore: number;
+    passed: boolean;
+    /** Narrative feedback from the grader, mirrored from `grade`. */
+    feedback: string | null;
 } | {
     status: 'unscorable';
     /** Why no grade can be produced (e.g. unregistered activity type). */
@@ -623,4 +735,4 @@ interface InteractionEvent {
     payload: Record<string, unknown>;
 }
 
-export { type ActivityData as A, type BlankConfig as B, type XAPIVerbObject as C, type DeferredScoringPartial as D, levenshteinDistance as E, type FillInTheBlanksData as F, matchText as G, type InteractionEvent as I, type LearnerResponse as L, type MultipleChoiceData as M, type ScoringDetail as S, type TextMatchPolicy as T, type ValidationError as V, type WrittenResponseData as W, type XAPIActor as X, type ActivityDataMap as a, type ActivityFeedback as b, type ActivityMedia as c, type ActivityResult as d, type ActivityType as e, type FillInTheBlanksLearnerResponse as f, type InteractionKind as g, type ItemOutcome as h, type LearnerResponseMap as i, type MultipleChoiceLearnerResponse as j, type MultipleChoiceOption as k, type ScoringOutcome as l, type ScoringResult as m, type TextMatchResult as n, type ValidationResult as o, type WrittenResponseLearnerResponse as p, type WrittenResponseRubric as q, type WrittenResponseRubricCriterion as r, type XAPIConfig as s, type XAPIContext as t, type XAPIContextActivities as u, type XAPIError as v, type XAPIObject as w, type XAPIResult as x, type XAPIScore as y, type XAPIStatement as z };
+export { type ActivityData as A, type BlankConfig as B, type CriterionScore as C, type DeferredScoringPartial as D, type XAPIError as E, type FillInTheBlanksData as F, type GradeRecord as G, type XAPIObject as H, type InlineCorrection as I, type XAPIResult as J, type XAPIScore as K, type LearnerResponse as L, type MultipleChoiceData as M, type XAPIStatement as N, type XAPIVerbObject as O, levenshteinDistance as P, matchText as Q, type ScoringDetail as S, type TextMatchPolicy as T, type ValidationError as V, type WrittenResponseData as W, type XAPIActor as X, type ActivityDataMap as a, type ActivityFeedback as b, type ActivityMedia as c, type ActivityResult as d, type ActivityType as e, type FillInTheBlanksLearnerResponse as f, type Grader as g, type GraderKind as h, type GraderUsage as i, type GradingState as j, type InteractionEvent as k, type InteractionKind as l, type ItemOutcome as m, type LearnerResponseMap as n, type MultipleChoiceLearnerResponse as o, type MultipleChoiceOption as p, type ScoringOutcome as q, type ScoringResult as r, type TextMatchResult as s, type ValidationResult as t, type WrittenResponseLearnerResponse as u, type WrittenResponseRubric as v, type WrittenResponseRubricCriterion as w, type XAPIConfig as x, type XAPIContext as y, type XAPIContextActivities as z };

package/dist/{activity-zdcAMtFB.d.ts → activity-wkzRemHx.d.ts}

@@ -63,6 +63,104 @@ 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. */
+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;
+    /** Scaled [0,1]. Absent when the criterion is judged on an ordinal `band`. */
+    score?: 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, so a
+ * grader that works in points must normalise before handing one over
+ * (or set `maxScore` accordingly).
+ */
+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[];
+    /** 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;
+}
+
 /**
  * An xAPI Activity object — the thing a statement is about.
  * This SDK only builds Activity-type objects (xAPI 1.0.3 §4.1.4.1).
@@ -564,6 +662,20 @@ type ItemOutcome = {
     maxScore: number;
     /** Synchronously computable progress facts (word bounds, counts). */
     partial?: DeferredScoringPartial;
+} | {
+    status: 'graded';
+    /**
+     * A grade produced by an asynchronous grader (AI or human) and handed
+     * back to the SDK. This is the state a `deferred` outcome transitions
+     * to once grading completes; nothing in the SDK ever manufactures it.
+     */
+    grade: GradeRecord;
+    /** Scaled score in the range [0, 1], mirrored from `grade` for uniform reads. */
+    score: number;
+    maxScore: number;
+    passed: boolean;
+    /** Narrative feedback from the grader, mirrored from `grade`. */
+    feedback: string | null;
 } | {
     status: 'unscorable';
     /** Why no grade can be produced (e.g. unregistered activity type). */
@@ -623,4 +735,4 @@ interface InteractionEvent {
     payload: Record<string, unknown>;
 }
 
-export { type ActivityData as A, type BlankConfig as B, type XAPIVerbObject as C, type DeferredScoringPartial as D, levenshteinDistance as E, type FillInTheBlanksData as F, matchText as G, type InteractionEvent as I, type LearnerResponse as L, type MultipleChoiceData as M, type ScoringDetail as S, type TextMatchPolicy as T, type ValidationError as V, type WrittenResponseData as W, type XAPIActor as X, type ActivityDataMap as a, type ActivityFeedback as b, type ActivityMedia as c, type ActivityResult as d, type ActivityType as e, type FillInTheBlanksLearnerResponse as f, type InteractionKind as g, type ItemOutcome as h, type LearnerResponseMap as i, type MultipleChoiceLearnerResponse as j, type MultipleChoiceOption as k, type ScoringOutcome as l, type ScoringResult as m, type TextMatchResult as n, type ValidationResult as o, type WrittenResponseLearnerResponse as p, type WrittenResponseRubric as q, type WrittenResponseRubricCriterion as r, type XAPIConfig as s, type XAPIContext as t, type XAPIContextActivities as u, type XAPIError as v, type XAPIObject as w, type XAPIResult as x, type XAPIScore as y, type XAPIStatement as z };
+export { type ActivityData as A, type BlankConfig as B, type CriterionScore as C, type DeferredScoringPartial as D, type XAPIError as E, type FillInTheBlanksData as F, type GradeRecord as G, type XAPIObject as H, type InlineCorrection as I, type XAPIResult as J, type XAPIScore as K, type LearnerResponse as L, type MultipleChoiceData as M, type XAPIStatement as N, type XAPIVerbObject as O, levenshteinDistance as P, matchText as Q, type ScoringDetail as S, type TextMatchPolicy as T, type ValidationError as V, type WrittenResponseData as W, type XAPIActor as X, type ActivityDataMap as a, type ActivityFeedback as b, type ActivityMedia as c, type ActivityResult as d, type ActivityType as e, type FillInTheBlanksLearnerResponse as f, type Grader as g, type GraderKind as h, type GraderUsage as i, type GradingState as j, type InteractionEvent as k, type InteractionKind as l, type ItemOutcome as m, type LearnerResponseMap as n, type MultipleChoiceLearnerResponse as o, type MultipleChoiceOption as p, type ScoringOutcome as q, type ScoringResult as r, type TextMatchResult as s, type ValidationResult as t, type WrittenResponseLearnerResponse as u, type WrittenResponseRubric as v, type WrittenResponseRubricCriterion as w, type XAPIConfig as x, type XAPIContext as y, type XAPIContextActivities as z };

package/dist/chunk-5ZAW76F3.cjs

@@ -0,0 +1,334 @@
+"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 _chunkQOAORTA4cjs = require('./chunk-QOAORTA4.cjs');
+
+
+
+
+var _chunkPIMX4B4Dcjs = require('./chunk-PIMX4B4D.cjs');
+
+// src/grading.ts
+function gradeFromRubric(criteria, activityData, options = {}) {
+  const corrupt = criteria.find(
+    (criterion) => criterion.notApplicable !== true && criterion.score !== void 0 && !Number.isFinite(criterion.score)
+  );
+  if (corrupt !== void 0) {
+    return {
+      unscorable: true,
+      reason: `Criterion "${corrupt.name}" has a non-finite score (${String(corrupt.score)}). A grade cannot be computed from it.`
+    };
+  }
+  const scoreable = criteria.filter(
+    (criterion) => criterion.notApplicable !== true && typeof criterion.score === "number"
+  );
+  const EPSILON2 = 1e-9;
+  const outOfRange = scoreable.find(
+    (criterion) => criterion.score < -EPSILON2 || criterion.score > 1 + EPSILON2
+  );
+  if (outOfRange !== void 0) {
+    return {
+      unscorable: true,
+      reason: `Criterion "${outOfRange.name}" has score ${outOfRange.score}, outside the scaled [0,1] range. Normalise grader output before building a GradeRecord.`
+    };
+  }
+  if (scoreable.length === 0) {
+    return {
+      unscorable: true,
+      reason: "No criterion carried a numeric score, so no weighted total can be computed."
+    };
+  }
+  const totalWeight = scoreable.reduce((sum, criterion) => sum + (_nullishCoalesce(criterion.weight, () => ( 1))), 0);
+  if (!(totalWeight > 0)) {
+    return {
+      unscorable: true,
+      reason: "Criterion weights do not sum to a positive number, so the weighted total is undefined."
+    };
+  }
+  const weighted = scoreable.reduce(
+    (sum, criterion) => sum + criterion.score * (_nullishCoalesce(criterion.weight, () => ( 1))),
+    0
+  );
+  const rawScore = weighted / totalWeight;
+  if (!Number.isFinite(rawScore)) {
+    return {
+      unscorable: true,
+      reason: "The weighted total is not a finite number, so no grade can be produced."
+    };
+  }
+  const score2 = Math.min(1, Math.max(0, rawScore));
+  const passed = options.passThreshold !== void 0 ? score2 >= options.passThreshold : activityData !== void 0 ? computePassThreshold(activityData, score2) : score2 >= 0.7;
+  return {
+    score: score2,
+    maxScore: 1,
+    passed,
+    feedback: _nullishCoalesce(options.feedback, () => ( null)),
+    criteria: [...criteria]
+  };
+}
+function outcomeFromGrade(grade) {
+  return {
+    status: "graded",
+    grade,
+    score: grade.score,
+    maxScore: grade.maxScore,
+    passed: grade.passed,
+    feedback: grade.feedback
+  };
+}
+function hasGrade(outcome) {
+  return outcome.status === "scored" || outcome.status === "graded";
+}
+
+// src/scoring/rounding.ts
+var EPSILON = 1e-9;
+var TIE_TOLERANCE = 1e-6;
+function scaled(value, dp) {
+  return value * 10 ** dp;
+}
+function noNegZero(value) {
+  return Object.is(value, -0) ? 0 : value;
+}
+function roundGrade(value, policy) {
+  if (!Number.isFinite(value)) {
+    return value;
+  }
+  const factor = 10 ** policy.dp;
+  const raw = scaled(value, policy.dp);
+  switch (policy.mode) {
+    case "floor":
+      return noNegZero(Math.floor(raw + EPSILON) / factor);
+    case "ceil":
+      return noNegZero(Math.ceil(raw - EPSILON) / factor);
+    case "half-even": {
+      const floored = Math.floor(raw);
+      if (Math.abs(raw - floored - 0.5) > TIE_TOLERANCE) {
+        return noNegZero(halfAway(raw) / factor);
+      }
+      const even = floored % 2 === 0 ? floored : floored + 1;
+      return noNegZero(even / factor);
+    }
+    default:
+      return noNegZero(halfAway(raw) / factor);
+  }
+}
+function halfAway(raw) {
+  const nudged = raw >= 0 ? raw + EPSILON : raw - EPSILON;
+  return raw >= 0 ? Math.round(nudged) : -Math.round(-nudged);
+}
+function gte(value, threshold, policy) {
+  return roundGrade(value, policy) >= roundGrade(threshold, policy) - EPSILON;
+}
+function classifyBand(value, bands) {
+  let best = null;
+  for (const band of bands) {
+    if (value >= band.min - EPSILON && (best === null || band.min > best.min)) {
+      best = band;
+    }
+  }
+  return best;
+}
+
+// src/scoring/compose.ts
+function earned(item) {
+  const { outcome } = item;
+  if (hasGrade(outcome)) {
+    const max = outcome.maxScore > 0 ? outcome.maxScore : 1;
+    return { state: "graded", points: outcome.score / max * item.points };
+  }
+  if (outcome.status === "deferred") {
+    return { state: "pending" };
+  }
+  return { state: "unscorable" };
+}
+function composeAssessmentScore(sections, policy) {
+  const pendingAll = [];
+  const unscorableAll = [];
+  const partials = sections.map((section) => {
+    let earnedPoints = 0;
+    let gradedMaxPoints = 0;
+    let maxPoints = 0;
+    const pendingSlotIds = [];
+    const unscorableSlotIds = [];
+    for (const item of section.items) {
+      maxPoints += item.points;
+      const contribution = earned(item);
+      if (contribution.state === "pending") {
+        pendingSlotIds.push(item.slotId);
+        pendingAll.push(item.slotId);
+        continue;
+      }
+      if (contribution.state === "unscorable") {
+        unscorableSlotIds.push(item.slotId);
+        unscorableAll.push(item.slotId);
+        continue;
+      }
+      earnedPoints += contribution.points;
+      gradedMaxPoints += item.points;
+    }
+    const raw = gradedMaxPoints > 0 ? earnedPoints / gradedMaxPoints : 0;
+    const appliedThreshold = _nullishCoalesce(_nullishCoalesce(section.passThresholdOverride, () => ( policy.sectionThreshold)), () => ( null));
+    return {
+      section,
+      earnedPoints,
+      gradedMaxPoints,
+      maxPoints,
+      score: roundGrade(raw, policy.rounding),
+      appliedThreshold,
+      pendingSlotIds,
+      unscorableSlotIds
+    };
+  });
+  const contributingWeight = partials.reduce(
+    (sum, partial) => sum + (partial.gradedMaxPoints > 0 ? partial.section.weight : 0),
+    0
+  );
+  const scored = partials.map((partial) => ({
+    id: partial.section.id,
+    ...partial.section.title !== void 0 ? { title: partial.section.title } : {},
+    weight: partial.section.weight,
+    normalizedWeight: partial.gradedMaxPoints > 0 && contributingWeight > 0 ? partial.section.weight / contributingWeight : 0,
+    earnedPoints: partial.earnedPoints,
+    gradedMaxPoints: partial.gradedMaxPoints,
+    maxPoints: partial.maxPoints,
+    score: partial.score,
+    // A section with nothing graded yet cannot be said to have failed.
+    passed: partial.appliedThreshold === null || partial.gradedMaxPoints === 0 ? true : gte(partial.score, partial.appliedThreshold, policy.rounding),
+    appliedThreshold: partial.appliedThreshold,
+    pendingSlotIds: partial.pendingSlotIds,
+    unscorableSlotIds: partial.unscorableSlotIds
+  }));
+  const weightedRaw = scored.reduce(
+    (sum, section) => sum + section.score * section.normalizedWeight,
+    0
+  );
+  const score2 = roundGrade(weightedRaw, policy.rounding);
+  const status = pendingAll.length > 0 ? "provisional" : "final";
+  if (status === "provisional") {
+    return {
+      sections: scored,
+      score: score2,
+      passed: null,
+      passFailureReason: null,
+      status,
+      pendingSlotIds: pendingAll,
+      unscorableSlotIds: unscorableAll
+    };
+  }
+  if (scored.every((section) => section.gradedMaxPoints === 0)) {
+    return {
+      sections: scored,
+      score: score2,
+      passed: null,
+      passFailureReason: null,
+      status,
+      pendingSlotIds: pendingAll,
+      unscorableSlotIds: unscorableAll
+    };
+  }
+  const overallOk = gte(score2, policy.passThreshold, policy.rounding);
+  const sectionsOk = scored.every((section) => section.passed);
+  const passed = overallOk && sectionsOk;
+  const passFailureReason = passed ? null : !overallOk && !sectionsOk ? "both" : overallOk ? "section_below_threshold" : "overall_below_threshold";
+  return {
+    sections: scored,
+    score: score2,
+    passed,
+    passFailureReason,
+    status,
+    pendingSlotIds: pendingAll,
+    unscorableSlotIds: unscorableAll
+  };
+}
+
+// src/scoring/index.ts
+var DEFAULT_PASS_THRESHOLD = 0.7;
+function computePassThreshold(activityData, score2) {
+  return score2 >= (_nullishCoalesce(activityData.passThreshold, () => ( DEFAULT_PASS_THRESHOLD)));
+}
+function isRedacted(data) {
+  return typeof data === "object" && data !== null && data.redacted === true;
+}
+function selectFeedback(activityData, passed) {
+  const feedback = activityData.feedback;
+  if (feedback === void 0) {
+    return null;
+  }
+  return _nullishCoalesce((passed ? feedback.correct : feedback.incorrect), () => ( null));
+}
+function score(activityType, activityData, learnerResponse) {
+  const descriptor = _chunkQOAORTA4cjs.getActivityTypeDescriptor.call(void 0, activityType);
+  if (descriptor === void 0) {
+    throw new (0, _chunkPIMX4B4Dcjs.UnknownActivityTypeError)(String(activityType));
+  }
+  if (descriptor.scoring.kind === "deferred") {
+    throw new (0, _chunkPIMX4B4Dcjs.DeferredScoringError)(descriptor.type);
+  }
+  if (isRedacted(activityData)) {
+    throw new (0, _chunkPIMX4B4Dcjs.RedactedScoringError)(descriptor.type);
+  }
+  const result = descriptor.scoring.score(activityData, learnerResponse);
+  if (!Number.isFinite(result.score)) {
+    throw new (0, _chunkPIMX4B4Dcjs.RedactedScoringError)(descriptor.type);
+  }
+  const passed = computePassThreshold(activityData, result.score);
+  return { ...result, passed, feedback: _nullishCoalesce(result.feedback, () => ( selectFeedback(activityData, passed))) };
+}
+function evaluate(data, response) {
+  const type = data.type;
+  const descriptor = typeof type === "string" ? _chunkQOAORTA4cjs.getActivityTypeDescriptor.call(void 0, type) : void 0;
+  if (descriptor === void 0) {
+    return {
+      status: "unscorable",
+      reason: `Activity type "${String(type)}" is not registered`,
+      maxScore: 1
+    };
+  }
+  if (descriptor.scoring.kind === "deferred") {
+    const partial = _optionalChain([descriptor, 'access', _ => _.scoring, 'access', _2 => _2.partial, 'optionalCall', _3 => _3(data, response)]);
+    return {
+      status: "deferred",
+      reason: descriptor.scoring.reason,
+      maxScore: 1,
+      ...partial !== void 0 ? { partial } : {}
+    };
+  }
+  if (isRedacted(data)) {
+    return {
+      status: "unscorable",
+      reason: "Activity data is redacted (no answer key), so it cannot be scored on the client. Score against the full data server-side.",
+      maxScore: 1
+    };
+  }
+  const result = descriptor.scoring.score(data, response);
+  if (!Number.isFinite(result.score)) {
+    return {
+      status: "unscorable",
+      reason: `Scoring "${descriptor.type}" produced a non-finite score; the activity data is incomplete.`,
+      maxScore: result.maxScore
+    };
+  }
+  const passed = computePassThreshold(data, result.score);
+  return {
+    status: "scored",
+    score: result.score,
+    maxScore: result.maxScore,
+    passed,
+    feedback: _nullishCoalesce(result.feedback, () => ( selectFeedback(data, passed))),
+    details: result.details
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.roundGrade = roundGrade; exports.gte = gte; exports.classifyBand = classifyBand; exports.composeAssessmentScore = composeAssessmentScore; exports.DEFAULT_PASS_THRESHOLD = DEFAULT_PASS_THRESHOLD; exports.computePassThreshold = computePassThreshold; exports.score = score; exports.evaluate = evaluate; exports.gradeFromRubric = gradeFromRubric; exports.outcomeFromGrade = outcomeFromGrade; exports.hasGrade = hasGrade;
+//# sourceMappingURL=chunk-5ZAW76F3.cjs.map