@intellectif/lk-core 0.3.1 → 0.5.0

package/dist/scoring.d.cts

@@ -1,13 +1,208 @@
-import { A as ActivityData, L as LearnerResponse, h as ItemOutcome, e as ActivityType, m as ScoringResult } from './activity-zdcAMtFB.cjs';
-export { T as TextMatchPolicy, n as TextMatchResult, E as levenshteinDistance, G as matchText } from './activity-zdcAMtFB.cjs';
+import { m as ItemOutcome, A as ActivityData, L as LearnerResponse, e as ActivityType, r as ScoringResult } from './activity-wkzRemHx.cjs';
+export { T as TextMatchPolicy, s as TextMatchResult, P as levenshteinDistance, Q as matchText } from './activity-wkzRemHx.cjs';
+
+/**
+ * Rounding for assessment scores.
+ *
+ * Rounding is **two different operations** that must not share one policy, and
+ * conflating them silently inverts one of them:
+ *
+ * - **Grade rounding** decides the number a learner is shown and recorded
+ *   against. It rounds to a fixed number of decimal places, conventionally
+ *   half-up, so a learner shown "70%" is not recorded as a fail at 69.6.
+ * - **Band / level classification** decides which level someone is placed in.
+ *   It deliberately **floors**: placing a learner above their real level is
+ *   the more harmful error, so a band boundary must not be reached by
+ *   rounding up.
+ *
+ * There is therefore no default `RoundingPolicy` anywhere in this SDK, and
+ * `dp` has no default either — an integrator's deliberate choice must never be
+ * supplied by us.
+ */
+/** How a value is rounded to `dp` decimal places. */
+type RoundingMode = 'half-up' | 'half-even' | 'floor' | 'ceil';
+/** A rounding policy. Both fields are required — the SDK never guesses either. */
+interface RoundingPolicy {
+    mode: RoundingMode;
+    /** Decimal places. Load-bearing: `dp: 2` is what stops 69.6 becoming a fail at 70. */
+    dp: number;
+}
+/**
+ * Rounds `value` to `policy.dp` places under `policy.mode`.
+ *
+ * Idempotent for every mode: rounding an already-rounded value returns it
+ * unchanged. That matters because a composed score is rounded once and then
+ * compared through {@link gte}, which rounds again.
+ */
+declare function roundGrade(value: number, policy: RoundingPolicy): number;
+/**
+ * Threshold comparison that rounds **both sides** before comparing.
+ *
+ * Comparing a raw float against a rounded threshold is how a learner ends up
+ * shown one number and recorded against another. Rounding both sides — and
+ * allowing an epsilon — makes "what the learner sees" and "what the gradebook
+ * decides" the same comparison.
+ */
+declare function gte(value: number, threshold: number, policy: RoundingPolicy): boolean;
+/** A named band with an inclusive lower bound, e.g. `{ name: 'B1', min: 0.6 }`. */
+interface Band {
+    name: string;
+    /** Inclusive lower bound on the same scale as the value being classified. */
+    min: number;
+}
+/**
+ * Classifies a value into a band by **flooring**: the highest band whose `min`
+ * the value actually reaches. Deliberately does NOT round up to a boundary —
+ * over-placement is the more harmful error, so a learner just below a boundary
+ * stays below it.
+ *
+ * Returns `null` when the value reaches no band's minimum.
+ */
+declare function classifyBand(value: number, bands: readonly Band[]): Band | null;
+
+/**
+ * Sectioned assessment scoring — weights, per-section thresholds, and an
+ * explicit reason when an attempt fails.
+ *
+ * This exists because the formula is invariably implemented twice: once on the
+ * server that records the grade, and again on the client that shows a learner
+ * their grade breakdown. Two implementations of one formula is exactly the
+ * duplication an SDK should remove, and they drift — usually in the scale
+ * (0–1 vs 0–100) or in whether a section override is honoured.
+ */
+/** One item's contribution to a section. */
+interface ScoredItem {
+    /**
+     * Identity of the SLOT, not the activity. The same activity can legitimately
+     * appear in two sections; keying on the activity id collapses them into one
+     * and silently scores the second occurrence as zero.
+     */
+    slotId: string;
+    /** The activity that filled this slot, for reporting. */
+    activityId?: string;
+    /** Maximum points this slot is worth. */
+    points: number;
+    /** What the learner achieved, or why there is no grade yet. */
+    outcome: ItemOutcome;
+}
+/** A weighted section of an assessment. */
+interface AssessmentSectionInput {
+    id: string;
+    title?: string;
+    /** Relative weight. Weights are normalised by their sum, so they need not total 1. */
+    weight: number;
+    /** Overrides the assessment-wide section threshold for this section only. */
+    passThresholdOverride?: number;
+    items: ScoredItem[];
+}
+/** Policy for {@link composeAssessmentScore}. */
+interface CompositionPolicy {
+    /** Scaled [0,1] overall score required to pass. */
+    passThreshold: number;
+    /** Scaled [0,1] score each section must reach, when sections gate the pass. */
+    sectionThreshold?: number;
+    /**
+     * How grades are rounded. Required, with no default: see `RoundingPolicy` —
+     * grade rounding and band classification are different operations and the
+     * SDK must not choose either for you.
+     */
+    rounding: RoundingPolicy;
+}
+/** Per-section result. */
+interface SectionScore {
+    id: string;
+    title?: string;
+    /** The authored weight, verbatim. */
+    weight: number;
+    /**
+     * The weight ACTUALLY used in the total, so a client can rebuild the grade
+     * from `sections[]` and agree with the record:
+     *
+     * ```ts
+     * roundGrade(
+     *   sections.reduce((sum, s) => sum + s.score * s.normalizedWeight, 0),
+     *   policy.rounding,
+     * ) === result.score            // exact, by construction
+     * ```
+     *
+     * Apply the same final rounding: the raw weighted sum of already-rounded
+     * section scores is not itself a rounded value (0.85 and 1.00 at equal
+     * weights sum to 0.925 against a recorded 0.93), so comparing it unrounded
+     * is off by up to half a quantum.
+     *
+     * Sections with nothing graded carry `0` here, because they contribute
+     * nothing; the remaining weights are renormalised among themselves.
+     */
+    normalizedWeight: number;
+    earnedPoints: number;
+    /** Points that are currently gradable — excludes items still awaiting a grade. */
+    gradedMaxPoints: number;
+    /** Every point in the section, whether graded yet or not. */
+    maxPoints: number;
+    /** Scaled [0,1] over the GRADED points, rounded once. */
+    score: number;
+    passed: boolean;
+    /** Threshold this section was judged against, after any override. */
+    appliedThreshold: number | null;
+    /** Slots still awaiting a grade. */
+    pendingSlotIds: string[];
+    /** Slots that can never be graded, excluded from the denominator. */
+    unscorableSlotIds: string[];
+}
+/** Why an attempt failed, or `null` when it passed. */
+type PassFailureReason = 'overall_below_threshold' | 'section_below_threshold' | 'both' | null;
+/** Result of composing an assessment. */
+interface AssessmentScore {
+    sections: SectionScore[];
+    /** Weighted total, scaled [0,1], rounded once. */
+    score: number;
+    /**
+     * Whether the attempt passed — `null` while `status` is `provisional`,
+     * because an attempt with work still ungraded has not passed OR failed yet.
+     * Returning `false` there would let a UI keyed on `passed` show a fail for
+     * an essay nobody has marked.
+     */
+    passed: boolean | null;
+    /** `null` while provisional, for the same reason as {@link passed}. */
+    passFailureReason: PassFailureReason;
+    /**
+     * `provisional` while any item is still awaiting a grade — the total is
+     * computed over what HAS been graded, so it can still move. Do not record a
+     * provisional score as final. Items that can NEVER be graded
+     * (`unscorableSlotIds`) do not hold the result provisional.
+     */
+    status: 'final' | 'provisional';
+    pendingSlotIds: string[];
+    /** Slots that can never be graded. Excluded from the denominator. */
+    unscorableSlotIds: string[];
+}
+/**
+ * Composes per-item outcomes into a sectioned assessment score.
+ *
+ * Weights are normalised by their sum. Each section's score is computed over
+ * the points that are actually gradable and rounded ONCE, before any threshold
+ * comparison, so the number a learner is shown is the number that decides the
+ * outcome. Items still awaiting a grade are excluded from the denominator
+ * rather than counted as zero, and the result is reported as `provisional`
+ * until every item has a grade.
+ */
+declare function composeAssessmentScore(sections: readonly AssessmentSectionInput[], policy: CompositionPolicy): AssessmentScore;
 
 /** Default minimum scaled score required to pass when `passThreshold` is absent. */
 declare const DEFAULT_PASS_THRESHOLD = 0.7;
 /**
  * Returns `true` iff `score` meets or exceeds the activity's `passThreshold`,
  * defaulting to {@link DEFAULT_PASS_THRESHOLD} (0.7) when the field is absent.
+ *
+ * Pass a {@link RoundingPolicy} to compare the way an assessment total is
+ * compared — both sides rounded, via {@link gte} — so an item shown as "70%"
+ * cannot be recorded as a fail at 69.6. It is **opt-in** rather than the
+ * default because switching it on changes item-level pass/fail for scores in
+ * the rounding band, and this SDK does not alter historical grades without an
+ * explicit decision. Absent, the comparison is the exact raw `>=` it has
+ * always been.
  */
-declare function computePassThreshold(activityData: ActivityData, score: number): boolean;
+declare function computePassThreshold(activityData: ActivityData, score: number, rounding?: RoundingPolicy): boolean;
 /**
  * Scores a learner response against activity data and returns a full
  * {@link ScoringResult}.
@@ -41,4 +236,4 @@ declare function score(activityType: ActivityType, activityData: ActivityData, l
  */
 declare function evaluate(data: ActivityData, response: LearnerResponse): ItemOutcome;
 
-export { DEFAULT_PASS_THRESHOLD, computePassThreshold, evaluate, score };
+export { type AssessmentScore, type AssessmentSectionInput, type Band, type CompositionPolicy, DEFAULT_PASS_THRESHOLD, type PassFailureReason, type RoundingMode, type RoundingPolicy, type ScoredItem, type SectionScore, classifyBand, composeAssessmentScore, computePassThreshold, evaluate, gte, roundGrade, score };

package/dist/scoring.d.ts

@@ -1,13 +1,208 @@
-import { A as ActivityData, L as LearnerResponse, h as ItemOutcome, e as ActivityType, m as ScoringResult } from './activity-zdcAMtFB.js';
-export { T as TextMatchPolicy, n as TextMatchResult, E as levenshteinDistance, G as matchText } from './activity-zdcAMtFB.js';
+import { m as ItemOutcome, A as ActivityData, L as LearnerResponse, e as ActivityType, r as ScoringResult } from './activity-wkzRemHx.js';
+export { T as TextMatchPolicy, s as TextMatchResult, P as levenshteinDistance, Q as matchText } from './activity-wkzRemHx.js';
+
+/**
+ * Rounding for assessment scores.
+ *
+ * Rounding is **two different operations** that must not share one policy, and
+ * conflating them silently inverts one of them:
+ *
+ * - **Grade rounding** decides the number a learner is shown and recorded
+ *   against. It rounds to a fixed number of decimal places, conventionally
+ *   half-up, so a learner shown "70%" is not recorded as a fail at 69.6.
+ * - **Band / level classification** decides which level someone is placed in.
+ *   It deliberately **floors**: placing a learner above their real level is
+ *   the more harmful error, so a band boundary must not be reached by
+ *   rounding up.
+ *
+ * There is therefore no default `RoundingPolicy` anywhere in this SDK, and
+ * `dp` has no default either — an integrator's deliberate choice must never be
+ * supplied by us.
+ */
+/** How a value is rounded to `dp` decimal places. */
+type RoundingMode = 'half-up' | 'half-even' | 'floor' | 'ceil';
+/** A rounding policy. Both fields are required — the SDK never guesses either. */
+interface RoundingPolicy {
+    mode: RoundingMode;
+    /** Decimal places. Load-bearing: `dp: 2` is what stops 69.6 becoming a fail at 70. */
+    dp: number;
+}
+/**
+ * Rounds `value` to `policy.dp` places under `policy.mode`.
+ *
+ * Idempotent for every mode: rounding an already-rounded value returns it
+ * unchanged. That matters because a composed score is rounded once and then
+ * compared through {@link gte}, which rounds again.
+ */
+declare function roundGrade(value: number, policy: RoundingPolicy): number;
+/**
+ * Threshold comparison that rounds **both sides** before comparing.
+ *
+ * Comparing a raw float against a rounded threshold is how a learner ends up
+ * shown one number and recorded against another. Rounding both sides — and
+ * allowing an epsilon — makes "what the learner sees" and "what the gradebook
+ * decides" the same comparison.
+ */
+declare function gte(value: number, threshold: number, policy: RoundingPolicy): boolean;
+/** A named band with an inclusive lower bound, e.g. `{ name: 'B1', min: 0.6 }`. */
+interface Band {
+    name: string;
+    /** Inclusive lower bound on the same scale as the value being classified. */
+    min: number;
+}
+/**
+ * Classifies a value into a band by **flooring**: the highest band whose `min`
+ * the value actually reaches. Deliberately does NOT round up to a boundary —
+ * over-placement is the more harmful error, so a learner just below a boundary
+ * stays below it.
+ *
+ * Returns `null` when the value reaches no band's minimum.
+ */
+declare function classifyBand(value: number, bands: readonly Band[]): Band | null;
+
+/**
+ * Sectioned assessment scoring — weights, per-section thresholds, and an
+ * explicit reason when an attempt fails.
+ *
+ * This exists because the formula is invariably implemented twice: once on the
+ * server that records the grade, and again on the client that shows a learner
+ * their grade breakdown. Two implementations of one formula is exactly the
+ * duplication an SDK should remove, and they drift — usually in the scale
+ * (0–1 vs 0–100) or in whether a section override is honoured.
+ */
+/** One item's contribution to a section. */
+interface ScoredItem {
+    /**
+     * Identity of the SLOT, not the activity. The same activity can legitimately
+     * appear in two sections; keying on the activity id collapses them into one
+     * and silently scores the second occurrence as zero.
+     */
+    slotId: string;
+    /** The activity that filled this slot, for reporting. */
+    activityId?: string;
+    /** Maximum points this slot is worth. */
+    points: number;
+    /** What the learner achieved, or why there is no grade yet. */
+    outcome: ItemOutcome;
+}
+/** A weighted section of an assessment. */
+interface AssessmentSectionInput {
+    id: string;
+    title?: string;
+    /** Relative weight. Weights are normalised by their sum, so they need not total 1. */
+    weight: number;
+    /** Overrides the assessment-wide section threshold for this section only. */
+    passThresholdOverride?: number;
+    items: ScoredItem[];
+}
+/** Policy for {@link composeAssessmentScore}. */
+interface CompositionPolicy {
+    /** Scaled [0,1] overall score required to pass. */
+    passThreshold: number;
+    /** Scaled [0,1] score each section must reach, when sections gate the pass. */
+    sectionThreshold?: number;
+    /**
+     * How grades are rounded. Required, with no default: see `RoundingPolicy` —
+     * grade rounding and band classification are different operations and the
+     * SDK must not choose either for you.
+     */
+    rounding: RoundingPolicy;
+}
+/** Per-section result. */
+interface SectionScore {
+    id: string;
+    title?: string;
+    /** The authored weight, verbatim. */
+    weight: number;
+    /**
+     * The weight ACTUALLY used in the total, so a client can rebuild the grade
+     * from `sections[]` and agree with the record:
+     *
+     * ```ts
+     * roundGrade(
+     *   sections.reduce((sum, s) => sum + s.score * s.normalizedWeight, 0),
+     *   policy.rounding,
+     * ) === result.score            // exact, by construction
+     * ```
+     *
+     * Apply the same final rounding: the raw weighted sum of already-rounded
+     * section scores is not itself a rounded value (0.85 and 1.00 at equal
+     * weights sum to 0.925 against a recorded 0.93), so comparing it unrounded
+     * is off by up to half a quantum.
+     *
+     * Sections with nothing graded carry `0` here, because they contribute
+     * nothing; the remaining weights are renormalised among themselves.
+     */
+    normalizedWeight: number;
+    earnedPoints: number;
+    /** Points that are currently gradable — excludes items still awaiting a grade. */
+    gradedMaxPoints: number;
+    /** Every point in the section, whether graded yet or not. */
+    maxPoints: number;
+    /** Scaled [0,1] over the GRADED points, rounded once. */
+    score: number;
+    passed: boolean;
+    /** Threshold this section was judged against, after any override. */
+    appliedThreshold: number | null;
+    /** Slots still awaiting a grade. */
+    pendingSlotIds: string[];
+    /** Slots that can never be graded, excluded from the denominator. */
+    unscorableSlotIds: string[];
+}
+/** Why an attempt failed, or `null` when it passed. */
+type PassFailureReason = 'overall_below_threshold' | 'section_below_threshold' | 'both' | null;
+/** Result of composing an assessment. */
+interface AssessmentScore {
+    sections: SectionScore[];
+    /** Weighted total, scaled [0,1], rounded once. */
+    score: number;
+    /**
+     * Whether the attempt passed — `null` while `status` is `provisional`,
+     * because an attempt with work still ungraded has not passed OR failed yet.
+     * Returning `false` there would let a UI keyed on `passed` show a fail for
+     * an essay nobody has marked.
+     */
+    passed: boolean | null;
+    /** `null` while provisional, for the same reason as {@link passed}. */
+    passFailureReason: PassFailureReason;
+    /**
+     * `provisional` while any item is still awaiting a grade — the total is
+     * computed over what HAS been graded, so it can still move. Do not record a
+     * provisional score as final. Items that can NEVER be graded
+     * (`unscorableSlotIds`) do not hold the result provisional.
+     */
+    status: 'final' | 'provisional';
+    pendingSlotIds: string[];
+    /** Slots that can never be graded. Excluded from the denominator. */
+    unscorableSlotIds: string[];
+}
+/**
+ * Composes per-item outcomes into a sectioned assessment score.
+ *
+ * Weights are normalised by their sum. Each section's score is computed over
+ * the points that are actually gradable and rounded ONCE, before any threshold
+ * comparison, so the number a learner is shown is the number that decides the
+ * outcome. Items still awaiting a grade are excluded from the denominator
+ * rather than counted as zero, and the result is reported as `provisional`
+ * until every item has a grade.
+ */
+declare function composeAssessmentScore(sections: readonly AssessmentSectionInput[], policy: CompositionPolicy): AssessmentScore;
 
 /** Default minimum scaled score required to pass when `passThreshold` is absent. */
 declare const DEFAULT_PASS_THRESHOLD = 0.7;
 /**
  * Returns `true` iff `score` meets or exceeds the activity's `passThreshold`,
  * defaulting to {@link DEFAULT_PASS_THRESHOLD} (0.7) when the field is absent.
+ *
+ * Pass a {@link RoundingPolicy} to compare the way an assessment total is
+ * compared — both sides rounded, via {@link gte} — so an item shown as "70%"
+ * cannot be recorded as a fail at 69.6. It is **opt-in** rather than the
+ * default because switching it on changes item-level pass/fail for scores in
+ * the rounding band, and this SDK does not alter historical grades without an
+ * explicit decision. Absent, the comparison is the exact raw `>=` it has
+ * always been.
  */
-declare function computePassThreshold(activityData: ActivityData, score: number): boolean;
+declare function computePassThreshold(activityData: ActivityData, score: number, rounding?: RoundingPolicy): boolean;
 /**
  * Scores a learner response against activity data and returns a full
  * {@link ScoringResult}.
@@ -41,4 +236,4 @@ declare function score(activityType: ActivityType, activityData: ActivityData, l
  */
 declare function evaluate(data: ActivityData, response: LearnerResponse): ItemOutcome;
 
-export { DEFAULT_PASS_THRESHOLD, computePassThreshold, evaluate, score };
+export { type AssessmentScore, type AssessmentSectionInput, type Band, type CompositionPolicy, DEFAULT_PASS_THRESHOLD, type PassFailureReason, type RoundingMode, type RoundingPolicy, type ScoredItem, type SectionScore, classifyBand, composeAssessmentScore, computePassThreshold, evaluate, gte, roundGrade, score };

package/dist/scoring.js

@@ -1,20 +1,27 @@
 import {
   DEFAULT_PASS_THRESHOLD,
+  classifyBand,
+  composeAssessmentScore,
   computePassThreshold,
   evaluate,
+  gte,
+  roundGrade,
   score
-} from "./chunk-QSVBYTNM.js";
+} from "./chunk-DUQVGLQ3.js";
 import {
   levenshteinDistance,
   matchText
-} from "./chunk-5GJJHGY5.js";
-import "./chunk-3YAVDV5F.js";
+} from "./chunk-NUCEUU4P.js";
 export {
   DEFAULT_PASS_THRESHOLD,
+  classifyBand,
+  composeAssessmentScore,
   computePassThreshold,
   evaluate,
+  gte,
   levenshteinDistance,
   matchText,
+  roundGrade,
   score
 };
 //# sourceMappingURL=scoring.js.map

package/dist/xapi.cjs

@@ -3,12 +3,14 @@
 
 
 
-var _chunkRUGIOQZYcjs = require('./chunk-RUGIOQZY.cjs');
-require('./chunk-PIMX4B4D.cjs');
 
+var _chunkR7PDJBRXcjs = require('./chunk-R7PDJBRX.cjs');
+require('./chunk-4JR3UXX6.cjs');
 
 
 
 
-exports.XAPIVerb = _chunkRUGIOQZYcjs.XAPIVerb; exports.XAPI_VERB_DISPLAY = _chunkRUGIOQZYcjs.XAPI_VERB_DISPLAY; exports.validateXAPIStatement = _chunkRUGIOQZYcjs.validateXAPIStatement; exports.xAPIBuilder = _chunkRUGIOQZYcjs.xAPIBuilder;
+
+
+exports.XAPIVerb = _chunkR7PDJBRXcjs.XAPIVerb; exports.XAPI_VERB_DISPLAY = _chunkR7PDJBRXcjs.XAPI_VERB_DISPLAY; exports.validateXAPIStatement = _chunkR7PDJBRXcjs.validateXAPIStatement; exports.xAPIBuilder = _chunkR7PDJBRXcjs.xAPIBuilder; exports.xapiDefinitionFor = _chunkR7PDJBRXcjs.xapiDefinitionFor;
 //# sourceMappingURL=xapi.cjs.map

package/dist/xapi.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/xapi.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACF,6OAAC","file":"/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/xapi.cjs"}
+{"version":3,"sources":["/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/xapi.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACF,8SAAC","file":"/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/xapi.cjs"}

package/dist/xapi.d.cts

@@ -1,4 +1,4 @@
-import { X as XAPIActor, m as ScoringResult, t as XAPIContext, x as XAPIResult, z as XAPIStatement } from './activity-zdcAMtFB.cjs';
+import { X as XAPIActor, r as ScoringResult, y as XAPIContext, J as XAPIResult, N as XAPIStatement } from './activity-wkzRemHx.cjs';
 
 /**
  * The set of xAPI verbs emitted by SDK activities, keyed by a stable
@@ -21,6 +21,13 @@ declare const XAPIVerb: {
      * community choice (design decision recorded per Task 25.4).
      */
     readonly SUBMITTED: "http://activitystrea.ms/schema/1.0/submit";
+    /**
+     * Emitted when an asynchronous grader produces a grade for work that was
+     * previously only SUBMITTED. Distinct from `answered`, which asserts the
+     * grade existed at submission time — here the learner acted earlier and the
+     * grade arrived later, often from a different actor (an AI or a teacher).
+     */
+    readonly SCORED: "http://adlnet.gov/expapi/verbs/scored";
 };
 /** Union of the valid `XAPIVerb` keys. */
 type XAPIVerbKey = keyof typeof XAPIVerb;
@@ -107,6 +114,23 @@ declare const xAPIBuilder: {
     buildSubmittedStatement(params: SubmittedStatementParams): XAPIStatement;
     buildCompletedStatement(params: CompletedStatementParams): XAPIStatement;
 };
+/**
+ * Builds the xAPI `object.definition` interop fields for an activity from its
+ * REGISTERED descriptor, rather than having every renderer hand-roll them.
+ *
+ * `ActivityTypeDescriptor.interop` declares the activity-type IRI, the
+ * cmi.interaction type and how to derive `correctResponsesPattern`; before
+ * this, those fields had no reader anywhere and each component rebuilt the
+ * same strings inline — the same "declared but never used" defect the SDK
+ * fixed elsewhere. Reading them here also means a consumer-registered type
+ * gets correct interop for free.
+ *
+ * Returns an empty object for an unregistered type or one that declares no
+ * interop, so it is always safe to spread.
+ */
+declare function xapiDefinitionFor(data: {
+    type: string;
+}): Partial<XAPIObjectParams>;
 
 /**
  * Validates a constructed {@link XAPIStatement} against the xAPI 1.0.3
@@ -123,4 +147,4 @@ declare const xAPIBuilder: {
  */
 declare function validateXAPIStatement(statement: XAPIStatement): void;
 
-export { type AnsweredStatementParams, type CompletedStatementParams, type SubmittedStatementParams, type XAPIObjectParams, type XAPIStatementParams, XAPIVerb, type XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder };
+export { type AnsweredStatementParams, type CompletedStatementParams, type SubmittedStatementParams, type XAPIObjectParams, type XAPIStatementParams, XAPIVerb, type XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor };

package/dist/xapi.d.ts

@@ -1,4 +1,4 @@
-import { X as XAPIActor, m as ScoringResult, t as XAPIContext, x as XAPIResult, z as XAPIStatement } from './activity-zdcAMtFB.js';
+import { X as XAPIActor, r as ScoringResult, y as XAPIContext, J as XAPIResult, N as XAPIStatement } from './activity-wkzRemHx.js';
 
 /**
  * The set of xAPI verbs emitted by SDK activities, keyed by a stable
@@ -21,6 +21,13 @@ declare const XAPIVerb: {
      * community choice (design decision recorded per Task 25.4).
      */
     readonly SUBMITTED: "http://activitystrea.ms/schema/1.0/submit";
+    /**
+     * Emitted when an asynchronous grader produces a grade for work that was
+     * previously only SUBMITTED. Distinct from `answered`, which asserts the
+     * grade existed at submission time — here the learner acted earlier and the
+     * grade arrived later, often from a different actor (an AI or a teacher).
+     */
+    readonly SCORED: "http://adlnet.gov/expapi/verbs/scored";
 };
 /** Union of the valid `XAPIVerb` keys. */
 type XAPIVerbKey = keyof typeof XAPIVerb;
@@ -107,6 +114,23 @@ declare const xAPIBuilder: {
     buildSubmittedStatement(params: SubmittedStatementParams): XAPIStatement;
     buildCompletedStatement(params: CompletedStatementParams): XAPIStatement;
 };
+/**
+ * Builds the xAPI `object.definition` interop fields for an activity from its
+ * REGISTERED descriptor, rather than having every renderer hand-roll them.
+ *
+ * `ActivityTypeDescriptor.interop` declares the activity-type IRI, the
+ * cmi.interaction type and how to derive `correctResponsesPattern`; before
+ * this, those fields had no reader anywhere and each component rebuilt the
+ * same strings inline — the same "declared but never used" defect the SDK
+ * fixed elsewhere. Reading them here also means a consumer-registered type
+ * gets correct interop for free.
+ *
+ * Returns an empty object for an unregistered type or one that declares no
+ * interop, so it is always safe to spread.
+ */
+declare function xapiDefinitionFor(data: {
+    type: string;
+}): Partial<XAPIObjectParams>;
 
 /**
  * Validates a constructed {@link XAPIStatement} against the xAPI 1.0.3
@@ -123,4 +147,4 @@ declare const xAPIBuilder: {
  */
 declare function validateXAPIStatement(statement: XAPIStatement): void;
 
-export { type AnsweredStatementParams, type CompletedStatementParams, type SubmittedStatementParams, type XAPIObjectParams, type XAPIStatementParams, XAPIVerb, type XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder };
+export { type AnsweredStatementParams, type CompletedStatementParams, type SubmittedStatementParams, type XAPIObjectParams, type XAPIStatementParams, XAPIVerb, type XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor };

package/dist/xapi.js

@@ -2,13 +2,15 @@ import {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
-  xAPIBuilder
-} from "./chunk-HS7BYCGE.js";
-import "./chunk-3YAVDV5F.js";
+  xAPIBuilder,
+  xapiDefinitionFor
+} from "./chunk-WV5WQ3SZ.js";
+import "./chunk-NUCEUU4P.js";
 export {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
-  xAPIBuilder
+  xAPIBuilder,
+  xapiDefinitionFor
 };
 //# sourceMappingURL=xapi.js.map