@intellectif/lk-core 1.1.0 → 1.3.0

package/dist/index.d.cts

@@ -1,26 +1,23 @@
-import { F as AiSupportedActivityType, g as AiActivityInput, p as AiFeature, ab as LearnerResponse, aa as ItemOutcome, o as AiExplanationRequest, t as AiGrade, u as AiHintRequest, ar as ScoringDetail, v as AiItemFacts, G as AiTextResult, C as AiRefusal, a2 as GradeRecord, j as AiCoachingRequest, i as AiCoaching, M as AiWritingFeedbackRequest, L as AiWritingFeedback, a as ActivityData, aw as ValidationError, f as ActivityType, b as ActivityDataMap, P as CriterionScore, aj as NativeControlHint, d as ActivityMedia, at as ScoringResult, R as DeferredScoringPartial, S as DictationData, U as DictationLearnerResponse, X as FillInTheBlanksData, Y as FillInTheBlanksLearnerResponse, $ as GapSelectData, a1 as GapSelectLearnerResponse, af as MultipleChoiceData, ag as MultipleChoiceLearnerResponse, ak as ReadAloudData, an as ReadAloudLearnerResponse, ay as WrittenResponseData, az as WrittenResponseLearnerResponse } from './activity-MBOYLBjR.cjs';
-export { A as ActivityAiPermissions, c as ActivityFeedback, e as ActivityResult, h as AiBlankFact, k as AiCoachingResult, l as AiCoachingWord, m as AiCriterionJudgement, n as AiDictationFacts, q as AiFillInTheBlanksFacts, r as AiGapFact, s as AiGapSelectFacts, w as AiMultipleChoiceFacts, x as AiOptionFact, y as AiProvenance, z as AiReadingFacts, B as AiReadingWordFact, D as AiRubricCriterionFact, E as AiSoundFact, H as AiVerdict, I as AiWordFact, J as AiWritingCorrection, K as AiWritingFacts, N as AiWritingFeedbackResult, O as BlankConfig, Q as DeferredReason, T as DictationEquivalence, V as DictationSlowMedia, W as DictationTolerance, Z as GapSelectBank, _ as GapSelectChoice, a0 as GapSelectGap, a3 as Grader, a4 as GraderKind, a5 as GraderUsage, a6 as GradingState, a7 as InlineCorrection, a8 as InteractionEvent, a9 as InteractionKind, ac as LearnerResponseMap, ad as MediaPlaybackPolicy, ae as MediaTrack, ah as MultipleChoiceOption, ai as MultipleChoiceOptionMedia, al as ReadAloudDimension, am as ReadAloudDimensionWeight, ao as ReadAloudSlowMedia, ap as RecordingBounds, aq as RecordingRef, as as ScoringOutcome, au as TextMatchPolicy, av as TextMatchResult, ax as ValidationResult, aA as WrittenResponseRubric, aB as WrittenResponseRubricCriterion, aC as XAPIActor, aD as XAPIConfig, aE as XAPIContext, aF as XAPIContextActivities, aG as XAPIError, aH as XAPIObject, aI as XAPIResult, aJ as XAPIScore, aK as XAPIStatement, aL as XAPIVerbObject, aM as levenshteinDistance, aN as matchText } from './activity-MBOYLBjR.cjs';
-import { SpeechAssessment, ResolvedItemScoringPolicy, ItemScoringPolicy, ScoredItem, RoundingPolicy, CompositionPolicy, AssessmentScore } from './scoring.cjs';
-export { AssessmentSectionInput, Band, DEFAULT_ITEM_SCORING_POLICY, DEFAULT_PASS_THRESHOLD, DICTATION_MAX_ACCEPTED_TRANSCRIPTS, DICTATION_MAX_EQUIVALENCES, DICTATION_MAX_EQUIVALENCE_LENGTH, DICTATION_MAX_TEXT_LENGTH, DICTATION_MAX_TRANSCRIPT_LENGTH, DictationAlignment, DictationCharOp, DictationReference, DictationWordAlignment, EvaluateOptions, GradeReadAloudOptions, ITEM_SCORING_MAX_RETRIES, ItemScoringCount, ItemScoringPolicyIssue, ItemTriesOutcome, ItemTriesScore, ItemTry, ItemTryScore, PassFailureReason, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, ReadAloudWordAlignment, ReadAloudWordState, RoundingMode, SPEECH_ASSESSMENT_MAX_WORDS, ScoringOptions, SectionScore, SpeechMeasurement, SpeechPhoneme, SpeechPhonemeCandidate, SpeechPlausibilityPolicy, SpeechSyllable, SpeechUnscorable, SpeechUnscorableCode, SpeechWord, SpeechWordError, WavInspection, WavInspectionPolicy, alignDictation, alignReadAloud, classifyBand, composeAssessmentScore, computePassThreshold, dictationReferenceWords, diffDictationChars, evaluate, evaluateTries, gradeReadAloud, gte, inspectWav, outcomeFromUnscorable, resolveItemScoringPolicy, roundGrade, score, scoreTries, validateItemScoringPolicy, validateSpeechAssessment } from './scoring.cjs';
-import { p as SequenceSlot, S as SequenceEntry, I as ItemGroup, M as MediaProgress } from './index-DlCW0XaQ.cjs';
-export { a as MediaTimeline, R as RedactedActivity, b as RedactedBlankConfig, c as RedactedDictationData, d as RedactedDictationSlowMedia, e as RedactedFillInTheBlanksData, f as RedactedGapSelectBank, g as RedactedGapSelectChoice, h as RedactedGapSelectData, i as RedactedGapSelectGap, j as RedactedMultipleChoiceData, k as RedactedMultipleChoiceOption, l as RedactedMultipleChoiceOptionMedia, m as RedactedReadAloudData, n as RedactedStimulus, o as RedactedWrittenResponseData, q as SequenceSlotGroup, r as Stimulus, s as StimulusKind, T as TimelineChapter, t as TimelineCue, u as dictationJsonSchema, v as fillInTheBlanksJsonSchema, w as gapSelectJsonSchema, x as itemGroupJsonSchema, y as jsonSchemaFor, z as multipleChoiceJsonSchema, A as readAloudJsonSchema, B as stimulusJsonSchema, C as validateActivity, D as validateItemGroup, E as validateMedia, F as validateOptionMedia, G as writtenResponseJsonSchema } from './index-DlCW0XaQ.cjs';
-export { AnsweredStatementParams, CompletedStatementParams, SubmittedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor } from './xapi.cjs';
-
+import { $ as DraftComplete, $t as WrittenResponseLearnerResponse, A as AiGapSelectFacts, At as ItemOutcome, B as AiRefusal, Bt as ReadAloudData, C as AiDraftsCall, Ct as GapSelectBank, D as AiFeature, Dt as GapSelectLearnerResponse, E as AiExplanationRequest, Et as GapSelectGap, F as AiMultipleChoiceFacts, Ft as MultipleChoiceData, G as AiVerdict, Gt as RecordingBounds, H as AiSoundFact, Ht as ReadAloudDimensionWeight, I as AiOptionFact, It as MultipleChoiceLearnerResponse, J as AiWritingCorrection, Jt as ScoringOutcome, K as AiVideoDraft, Kt as RecordingRef, L as AiProvenance, Lt as MultipleChoiceOption, M as AiGrade, Mt as LearnerResponseMap, N as AiHintRequest, Nt as MediaPlaybackPolicy, O as AiFillInTheBlanksFacts, Ot as InteractionEvent, P as AiItemFacts, Pt as MediaTrack, Q as AiWritingFeedbackResult, Qt as WrittenResponseData, R as AiReadingFacts, Rt as MultipleChoiceOptionMedia, S as AiDrafts, Sn as matchText, St as FillInTheBlanksLearnerResponse, T as AiDraftsRun, Tt as GapSelectData, U as AiSupportedActivityType, Ut as ReadAloudLearnerResponse, V as AiRubricCriterionFact, Vt as ReadAloudDimension, W as AiTextResult, Wt as ReadAloudSlowMedia, X as AiWritingFeedback, Xt as ValidationError, Y as AiWritingFacts, Yt as ScoringResult, Z as AiWritingFeedbackRequest, Zt as ValidationResult, _ as AiDraftCaption, _n as GradingState, _t as DictationEquivalence, a as AiCoachingRequest, an as XAPIContextActivities, at as ItemFinding, b as AiDraftSource, bn as TextMatchResult, bt as DictationTolerance, c as AiCriterionJudgement, cn as XAPIResult, ct as ActivityDataMap, d as AiCritiqueFinding, dn as XAPIVerbObject, dt as ActivityResult, en as WrittenResponseRubric, et as DraftContext, f as AiCritiqueFindingResult, fn as CriterionScore, ft as ActivityType, g as AiDictationFacts, gn as GraderUsage, gt as DictationData, h as AiCritiqueResult, hn as GraderKind, ht as DeferredScoringPartial, i as AiCoaching, in as XAPIContext, it as DraftValidationResult, j as AiGeneratedDraft, jt as LearnerResponse, k as AiGapFact, kt as InteractionKind, l as AiCritique, ln as XAPIScore, lt as ActivityFeedback, m as AiCritiqueRequest, mn as Grader, mt as DeferredReason, n as AiActivityInput, nn as XAPIActor, nt as DraftNotComplete, o as AiCoachingResult, on as XAPIError, ot as ItemFindingSeverity, p as AiCritiqueKind, pn as GradeRecord, pt as BlankConfig, q as AiWordFact, qt as ScoringDetail, r as AiBlankFact, rn as XAPIConfig, rt as DraftSeverity, s as AiCoachingWord, sn as XAPIObject, st as ActivityData, t as ActivityAiPermissions, tn as WrittenResponseRubricCriterion, tt as DraftIssue, u as AiCritiqueField, un as XAPIStatement, ut as ActivityMedia, v as AiDraftProblem, vn as InlineCorrection, vt as DictationLearnerResponse, w as AiDraftsRequest, wt as GapSelectChoice, x as AiDraftType, xn as levenshteinDistance, xt as FillInTheBlanksData, y as AiDraftSettings, yn as TextMatchPolicy, yt as DictationSlowMedia, z as AiReadingWordFact, zt as NativeControlHint } from "./ai-B222dtHH.cjs";
+import { $ as SpeechAssessment, A as diffDictationChars, B as ItemTry, C as validateItemScoringPolicy, D as DICTATION_MAX_TEXT_LENGTH, E as DICTATION_MAX_EQUIVALENCE_LENGTH, F as dictationReferenceWords, G as CompositionPolicy, H as ResolvedItemScoringPolicy, I as ItemScoringCount, J as SectionScore, K as PassFailureReason, L as ItemScoringPolicy, M as DictationReference, N as DictationWordAlignment, O as DICTATION_MAX_TRANSCRIPT_LENGTH, P as alignDictation, Q as ReadAloudWordState, R as ItemScoringPolicyIssue, S as scoreTries, T as DICTATION_MAX_EQUIVALENCES, U as AssessmentScore, V as ItemTryScore, W as AssessmentSectionInput, X as GradeReadAloudOptions, Y as composeAssessmentScore, Z as ReadAloudWordAlignment, _ as DEFAULT_PASS_THRESHOLD, a as evaluateTries, at as SpeechUnscorable, b as ITEM_SCORING_MAX_RETRIES, c as inspectWav, ct as SpeechWordError, d as READ_ALOUD_MAX_SECONDS, dt as Band, et as SpeechMeasurement, f as READ_ALOUD_MAX_TAKES, ft as RoundingMode, g as alignReadAloud, gt as roundGrade, h as validateSpeechAssessment, ht as gte, i as evaluate, it as SpeechSyllable, j as DictationAlignment, k as DictationCharOp, l as READ_ALOUD_MAX_DIMENSION_WEIGHT, lt as WavInspection, m as gradeReadAloud, mt as classifyBand, n as ItemTriesOutcome, nt as SpeechPhonemeCandidate, o as score, ot as SpeechUnscorableCode, p as SPEECH_ASSESSMENT_MAX_WORDS, pt as RoundingPolicy, q as ScoredItem, r as ScoringOptions, rt as SpeechPlausibilityPolicy, s as outcomeFromUnscorable, st as SpeechWord, t as EvaluateOptions, tt as SpeechPhoneme, u as READ_ALOUD_MAX_REFERENCE_LENGTH, ut as WavInspectionPolicy, v as computePassThreshold, w as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, x as resolveItemScoringPolicy, y as DEFAULT_ITEM_SCORING_POLICY, z as ItemTriesScore } from "./index-Dyu66R4-.cjs";
+import { A as MediaProgress, C as RedactedMultipleChoiceData, D as RedactedStimulus, E as RedactedReadAloudData, F as Stimulus, I as StimulusKind, L as TimelineChapter, M as SequenceEntry, N as SequenceSlot, O as RedactedWrittenResponseData, P as SequenceSlotGroup, R as TimelineCue, S as RedactedGapSelectGap, T as RedactedMultipleChoiceOptionMedia, _ as RedactedDictationSlowMedia, a as fillInTheBlanksJsonSchema, b as RedactedGapSelectChoice, c as jsonSchemaFor, d as stimulusJsonSchema, f as writtenResponseJsonSchema, g as RedactedDictationData, h as RedactedBlankConfig, i as dictationJsonSchema, j as MediaTimeline, k as ItemGroup, l as multipleChoiceJsonSchema, m as RedactedActivity, n as validateMedia, o as gapSelectJsonSchema, p as validateItemGroup, r as validateOptionMedia, s as itemGroupJsonSchema, t as validateActivity, u as readAloudJsonSchema, v as RedactedFillInTheBlanksData, w as RedactedMultipleChoiceOption, x as RedactedGapSelectData, y as RedactedGapSelectBank } from "./index-O4_ExlAD.cjs";
+import { a as XAPIObjectParams, c as xapiDefinitionFor, d as XAPI_VERB_DISPLAY, i as SubmittedStatementParams, l as XAPIVerb, n as AnsweredStatementParams, o as XAPIStatementParams, r as CompletedStatementParams, s as xAPIBuilder, t as validateXAPIStatement, u as XAPIVerbKey } from "./index-CXyOV8sm.cjs";
+//#region src/ai.d.ts
 /**
  * The activity types the SDK builds facts for, and which of them take hints.
  * A dictation takes none: its answer is the whole sentence, and it has
  * word-by-word hints of its own.
  */
-declare const AI_EXPLANATION_TYPES: readonly AiSupportedActivityType[];
-declare const AI_HINT_TYPES: readonly AiSupportedActivityType[];
+export declare const AI_EXPLANATION_TYPES: readonly AiSupportedActivityType[];
+export declare const AI_HINT_TYPES: readonly AiSupportedActivityType[];
 /** The longest AI text shown, in code points. Longer is refused, not cut. */
-declare const AI_TEXT_MAX_LENGTH = 2000;
+export declare const AI_TEXT_MAX_LENGTH = 2000;
 /**
  * Whether the SDK supports `feature` for this activity type: explanations and
  * hints for the types it builds facts for, and writing feedback for a written
  * response, and coaching for a read-aloud. A consumer's own type has none.
  */
-declare function aiSupports(activityType: string, feature: AiFeature): boolean;
+export declare function aiSupports(activityType: string, feature: AiFeature): boolean;
 /**
  * Whether the item's author allows `feature`. Only an explicit `false`
  * switches it off: an author can refuse a feature, never force one on.
@@ -29,12 +26,12 @@ declare function aiSupports(activityType: string, feature: AiFeature): boolean;
  * model's words about the learner's own answer, and an author who switched one
  * off has switched off the others.
  */
-declare function aiAllowedByContent(data: AiActivityInput, feature: AiFeature): boolean;
+export declare function aiAllowedByContent(data: AiActivityInput, feature: AiFeature): boolean;
 /** A grade as an explanation must speak to it: all marks, some, or none. */
-declare function aiGradeOf(result: {
-    score: number;
-    maxScore: number;
-    passed: boolean;
+export declare function aiGradeOf(result: {
+  score: number;
+  maxScore: number;
+  passed: boolean;
 }): AiGrade;
 /**
  * The facts a model is given about one item and one answer. `details` are the
@@ -45,7 +42,7 @@ declare function aiGradeOf(result: {
  *
  * `null` for a type the SDK builds no facts for.
  */
-declare function buildAiFacts(data: AiActivityInput, response: LearnerResponse | null, details: readonly ScoringDetail[] | null): AiItemFacts | null;
+export declare function buildAiFacts(data: AiActivityInput, response: LearnerResponse | null, details: readonly ScoringDetail[] | null): AiItemFacts | null;
 /**
  * The request for an explanation of `response`, or `null` when there is none
  * to give: an unsupported type, an author who switched explanations off,
@@ -58,11 +55,11 @@ declare function buildAiFacts(data: AiActivityInput, response: LearnerResponse |
  * explaining 85 "out of 1" would tell the model a wrong answer was correct, and
  * grading locally instead would speak to a grade the screen does not show.
  */
-declare function aiExplanationRequest(input: {
-    data: AiActivityInput;
-    response: LearnerResponse | null;
-    outcome?: ItemOutcome;
-    learnerLocale?: string;
+export declare function aiExplanationRequest(input: {
+  data: AiActivityInput;
+  response: LearnerResponse | null;
+  outcome?: ItemOutcome;
+  learnerLocale?: string;
 }): AiExplanationRequest | null;
 /**
  * The request for the next hint on an unsubmitted answer, or `null` when
@@ -73,23 +70,23 @@ declare function aiExplanationRequest(input: {
  * model can hint where it helps. The learner never sees them; a hint that
  * contains an answer is refused by {@link checkAiHint}.
  */
-declare function aiHintRequest(input: {
-    data: AiActivityInput;
-    response: LearnerResponse | null;
-    previousHints: readonly string[];
-    learnerLocale?: string;
+export declare function aiHintRequest(input: {
+  data: AiActivityInput;
+  response: LearnerResponse | null;
+  previousHints: readonly string[];
+  learnerLocale?: string;
 }): AiHintRequest | null;
 /**
  * Reads what a port returned. Anything but an object with a string `text` is
  * `malformed`; text that is empty once cleaned, or longer than
  * {@link AI_TEXT_MAX_LENGTH}, is refused rather than shown or cut.
  */
-declare function readAiTextResult(raw: unknown): {
-    ok: true;
-    result: AiTextResult;
+export declare function readAiTextResult(raw: unknown): {
+  ok: true;
+  result: AiTextResult;
 } | {
-    ok: false;
-    refusal: AiRefusal;
+  ok: false;
+  refusal: AiRefusal;
 };
 /**
  * Checks an explanation a port returned for `request`. On top of
@@ -97,24 +94,24 @@ declare function readAiTextResult(raw: unknown): {
  * the SDK's grade is refused (`contradicts-grade`) — it explains an answer
  * the learner did not get.
  */
-declare function checkAiExplanation(raw: unknown, request: AiExplanationRequest): {
-    ok: true;
-    result: AiTextResult;
+export declare function checkAiExplanation(raw: unknown, request: AiExplanationRequest): {
+  ok: true;
+  result: AiTextResult;
 } | {
-    ok: false;
-    refusal: AiRefusal;
+  ok: false;
+  refusal: AiRefusal;
 };
 /**
  * Checks a hint a port returned for `request`. On top of
  * {@link readAiTextResult}: a hint that contains an answer is refused
  * (`reveals-answer`) — see {@link hintRevealsAnswer}.
  */
-declare function checkAiHint(raw: unknown, request: AiHintRequest): {
-    ok: true;
-    result: AiTextResult;
+export declare function checkAiHint(raw: unknown, request: AiHintRequest): {
+  ok: true;
+  result: AiTextResult;
 } | {
-    ok: false;
-    refusal: AiRefusal;
+  ok: false;
+  refusal: AiRefusal;
 };
 /**
  * Whether a hint gives away an answer, judged against the facts it was asked
@@ -126,15 +123,18 @@ declare function checkAiHint(raw: unknown, request: AiHintRequest): {
  *   An answer of one short word ("is", "the") counts only where the hint
  *   writes it beside a neighbour it has in the passage — "name is", "is
  *   Rossi" — so a hint may still use the word on its own.
+ * - **Facts of any other kind:** revealing. A hint the check cannot read is
+ *   withheld, not shown unchecked.
  *
  * Case, accents and punctuation are ignored on both sides.
  */
-declare function hintRevealsAnswer(facts: AiItemFacts, hint: string): boolean;
-
+export declare function hintRevealsAnswer(facts: AiItemFacts, hint: string): boolean;
+//#endregion
+//#region src/ai-coaching.d.ts
 /** The most words one coaching may work on. More is refused, not cut. */
-declare const AI_COACHING_MAX_WORDS = 20;
+export declare const AI_COACHING_MAX_WORDS = 20;
 /** The longest tip for one word, in code points. */
-declare const AI_COACHING_MAX_TIP_LENGTH = 500;
+export declare const AI_COACHING_MAX_TIP_LENGTH = 500;
 /**
  * The request for coaching on a graded reading, or `null` when there is none
  * to give: not a read-aloud, an author who switched explanations off (coaching
@@ -151,11 +151,11 @@ declare const AI_COACHING_MAX_TIP_LENGTH = 500;
  * the engine's dimension scores. The marks are the engine's; the model
  * explains them.
  */
-declare function aiCoachingRequest(input: {
-    data: AiActivityInput;
-    assessment?: SpeechAssessment | null;
-    grade?: GradeRecord | null;
-    learnerLocale?: string;
+export declare function aiCoachingRequest(input: {
+  data: AiActivityInput;
+  assessment?: SpeechAssessment | null;
+  grade?: GradeRecord | null;
+  learnerLocale?: string;
 }): AiCoachingRequest | null;
 /**
  * Checks coaching a port returned for `request`, and turns it into what a
@@ -180,18 +180,207 @@ declare function aiCoachingRequest(input: {
  * (the SDK's reading of the text, never the model's), and each sound spelt as
  * the engine spelt it.
  */
-declare function checkAiCoaching(raw: unknown, request: AiCoachingRequest): {
-    ok: true;
-    coaching: AiCoaching;
+export declare function checkAiCoaching(raw: unknown, request: AiCoachingRequest): {
+  ok: true;
+  coaching: AiCoaching;
 } | {
-    ok: false;
-    refusal: AiRefusal;
+  ok: false;
+  refusal: AiRefusal;
 };
-
+//#endregion
+//#region src/ai-critique.d.ts
+/** The most findings one critique may carry. More is refused, not cut. */
+export declare const AI_CRITIQUE_MAX_FINDINGS = 20;
+/** The longest message or quote in a finding, in code points. */
+export declare const AI_CRITIQUE_MAX_FIELD_LENGTH = 500;
+/**
+ * What a model is given to review an item, or `null` when there is nothing to
+ * review: a draft that is not an object, or one with no words in it yet.
+ *
+ * The facts are the item as the author wrote it — the answer key included; this
+ * is for an author, never a learner — every text field a finding may point at,
+ * and what the SDK's own critic already found there, so a model spends its
+ * words on what a rule cannot see: a stem that reads two ways, a distractor
+ * that is defensibly right, a key that is wrong, language above the level.
+ *
+ * Works for every registered type, the SDK's own and yours: the fields are read
+ * from the draft itself.
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ */
+export declare function aiCritiqueRequest(input: {
+  type: ActivityType;
+  draft: unknown;
+  level?: string;
+  authorLocale?: string;
+}): AiCritiqueRequest | null;
+/**
+ * Checks a critique a port returned for `request`, and turns it into findings
+ * an editor lists beside the SDK's own. As every AI answer, it is shown whole
+ * or not at all.
+ *
+ * - **Every finding points at a field the item has.** Its `path` is one of
+ *   `facts.fields`, exactly; a path to a field the item does not have refuses
+ *   the whole reply as `contradicts-item`.
+ * - **A quote is words that field contains**, typographic quotes and runs of
+ *   spacing aside, case kept; one it does not refuses the reply the same way.
+ * - **Every finding is `advice`.** It is a model's opinion about the item, and
+ *   nothing in the SDK acts on it; its code is `ai_` and the kind
+ *   (`ai_second_answer`).
+ * - **Limits:** {@link AI_CRITIQUE_MAX_FINDINGS} findings; a message or quote of
+ *   {@link AI_CRITIQUE_MAX_FIELD_LENGTH} code points; over them `too-long`. A
+ *   kind the SDK does not name, or any other shape, is `malformed`.
+ */
+export declare function checkAiCritique(raw: unknown, request: AiCritiqueRequest): {
+  ok: true;
+  critique: AiCritique;
+} | {
+  ok: false;
+  refusal: AiRefusal;
+};
+//#endregion
+//#region src/ai-drafts.d.ts
+/** The most drafts one request may ask for, and the most a reply may hold when it names no count. */
+export declare const AI_DRAFTS_MAX_COUNT = 50;
+/** The most repair passes `generateDrafts` makes. */
+export declare const AI_DRAFTS_MAX_REPAIRS = 3;
+/**
+ * What a model is given to draft items from a source, or `null` when there is
+ * no source to draft from: an empty text, or no caption with words in it.
+ *
+ * `types` are the ones the author chose, in the author's order: the model
+ * leans on the first, and where several drafts share a moment of a video — or
+ * the end of one — they are shown in this order. `count` is how many to write
+ * at most; left out, the model writes as many as the source is worth, up to
+ * {@link AI_DRAFTS_MAX_COUNT}.
+ *
+ * The facts are the source — a caption list numbered, with its times in
+ * seconds — the types, the count, and the language, level and instructions
+ * the author gave. `shape` is the JSON Schema of the reply: each draft names
+ * its type and writes that type's own fields, with no ids, no HTML, no media
+ * and no settings. Those are not a model's to write. `settings` are yours, put
+ * on every draft of a type: a read-aloud's `recording` and `scoring`, say, which
+ * the SDK has no default for.
+ *
+ * @throws RangeError when `types` is empty, repeats a type or names one a model
+ *   does not draft, or `count` is not a whole number from 1 to
+ *   {@link AI_DRAFTS_MAX_COUNT}.
+ */
+export declare function aiDraftsRequest(input: {
+  types: readonly AiDraftType[];
+  source: AiDraftSource;
+  count?: number;
+  locale?: string;
+  level?: string;
+  instructions?: string;
+  settings?: AiDraftSettings;
+}): AiDraftsRequest | null;
+/**
+ * Reads a model's reply to {@link aiDraftsRequest} into drafts an editor can
+ * show for approval: each with ids from `newId`, your settings for its type,
+ * what `validateDraft` says of it, what the item critic finds in it, and — from
+ * captions — where it goes, and for a dictation the stretch of the video that
+ * says its words. They come back in the author's order of types.
+ *
+ * Drafts are independent: one that is unfinished or wrong is returned as such,
+ * for an author or {@link aiDraftsRepairRequest} to fix, beside the ones that
+ * are complete. `complete` means valid, never approved: a model wrote it, and a
+ * person decides whether learners see it. The whole reply is refused only when
+ * it is not `{ drafts: [...] }` of objects of the chosen types (`malformed`), or
+ * holds more drafts than asked for (`too-long`) — on a repair, not exactly one
+ * per draft to fix (`malformed`).
+ *
+ * Only the fields a type's shape names are read: a model cannot set an id,
+ * HTML, media, a switch or a scoring setting through this. A question is scored
+ * `all-or-nothing` unless your settings say otherwise, a written response's
+ * criteria are weighted equally, and a dictation carries no recording — attach
+ * one, or cut it from the video at `clip`.
+ *
+ * @throws Error when `newId` returns an empty or repeated id.
+ */
+export declare function checkAiDrafts(raw: unknown, request: AiDraftsRequest, options: {
+  newId: () => string;
+}): {
+  ok: true;
+  drafts: AiDrafts;
+} | {
+  ok: false;
+  refusal: AiRefusal;
+};
+/**
+ * A second request, for the drafts with something wrong the model can fix —
+ * unfinished, wrong, or a flaw the critic warns about, at a field the model
+ * writes — each as the model wrote it, with those problems at the paths the
+ * model wrote. `null` when there is none.
+ *
+ * The reply holds one draft for each, in order; {@link checkAiDrafts} reads it
+ * and gives each the `index` of the draft it replaces.
+ */
+export declare function aiDraftsRepairRequest(request: AiDraftsRequest, drafts: AiDrafts | readonly AiGeneratedDraft[]): AiDraftsRequest | null;
+/**
+ * Drafts items from a source, with a bounded repair loop: asks the port with
+ * `request`, reads the reply with {@link checkAiDrafts}, then — up to `repairs`
+ * times — sends back the drafts with something wrong the model can fix
+ * ({@link aiDraftsRepairRequest}), and keeps a repaired draft only when it is
+ * no worse than the one it replaces. A repaired draft keeps its id.
+ *
+ * Never throws for a model's failure: a port that throws or a reply the SDK
+ * refuses ends the loop, and is recorded in `calls` beside the provenance and
+ * usage of every call — which the SDK never adds up. A first call that fails
+ * leaves no drafts.
+ *
+ * ```ts
+ * const run = await generateDrafts({
+ *   request: aiDraftsRequest({ types: ['multiple-choice', 'dictation'], source: { kind: 'transcript', text } }),
+ *   port: (request) => callMyModel(DRAFTS_PROMPT, request),
+ *   newId: () => crypto.randomUUID(),
+ * });
+ * // run.drafts: store each as proposed, for a person to approve.
+ * ```
+ *
+ * @throws RangeError when `repairs` is not a whole number from 0 to
+ *   {@link AI_DRAFTS_MAX_REPAIRS} (default 1), and Error when `newId` returns an
+ *   empty or repeated id.
+ */
+export declare function generateDrafts(input: {
+  request: AiDraftsRequest;
+  port: (request: AiDraftsRequest) => Promise<unknown> | unknown;
+  newId: () => string;
+  repairs?: number;
+}): Promise<AiDraftsRun>;
+/**
+ * An interactive video made of drafts: an item group whose stimulus is
+ * `video`, whose items are the drafts, and whose timeline opens a quiz at each
+ * moment a draft was placed — drafts placed at one moment share its quiz, in
+ * the author's order of types — and one more at `durationSeconds` for every
+ * draft placed nowhere: all of them when the source had no times.
+ *
+ * The SDK never reads the video, so it cannot know where the end is: without
+ * `durationSeconds` that last quiz has no time yet, which
+ * `validateItemGroupDraft` reports for the author to set. The source is kept on
+ * the stimulus as its author-only `transcript`.
+ *
+ * Like every draft it is checked (`validateItemGroupDraft`) and critiqued
+ * (`critiqueItemGroupDraft`), never approved. A dictation still needs its own
+ * recording; a type a video does not take — a written response — is reported,
+ * not dropped.
+ *
+ * @throws Error when `newId` returns an empty or repeated id.
+ */
+export declare function interactiveVideoFromDrafts(input: {
+  request: AiDraftsRequest;
+  drafts: AiDrafts | AiDraftsRun | readonly AiGeneratedDraft[];
+  video: ActivityMedia;
+  durationSeconds?: number;
+  title?: string;
+  newId: () => string;
+}): AiVideoDraft;
+//#endregion
+//#region src/ai-writing.d.ts
 /** The most corrections one piece of writing feedback may carry. More is refused, not cut. */
-declare const AI_WRITING_MAX_CORRECTIONS = 20;
+export declare const AI_WRITING_MAX_CORRECTIONS = 20;
 /** The longest quote, correction, explanation or criterion comment, in code points. */
-declare const AI_WRITING_MAX_FIELD_LENGTH = 500;
+export declare const AI_WRITING_MAX_FIELD_LENGTH = 500;
 /**
  * The request for feedback on a draft, or `null` when there is none to give:
  * not a written response, an author who switched explanations off (writing
@@ -203,11 +392,11 @@ declare const AI_WRITING_MAX_FIELD_LENGTH = 500;
  * will be graded on. `previousFeedback` is the text of the feedback already
  * shown on earlier drafts, so a model can speak to what changed.
  */
-declare function aiWritingFeedbackRequest(input: {
-    data: AiActivityInput;
-    response: LearnerResponse | null;
-    previousFeedback?: readonly string[];
-    learnerLocale?: string;
+export declare function aiWritingFeedbackRequest(input: {
+  data: AiActivityInput;
+  response: LearnerResponse | null;
+  previousFeedback?: readonly string[];
+  learnerLocale?: string;
 }): AiWritingFeedbackRequest | null;
 /**
  * Checks writing feedback a port returned for `request`, and turns it into what
@@ -233,14 +422,15 @@ declare function aiWritingFeedbackRequest(input: {
  *   `gradeFromRubric` computes a grade, when every criterion of the rubric was
  *   judged; `null` otherwise. An indication, never a grade.
  */
-declare function checkAiWritingFeedback(raw: unknown, request: AiWritingFeedbackRequest): {
-    ok: true;
-    feedback: AiWritingFeedback;
+export declare function checkAiWritingFeedback(raw: unknown, request: AiWritingFeedbackRequest): {
+  ok: true;
+  feedback: AiWritingFeedback;
 } | {
-    ok: false;
-    refusal: AiRefusal;
+  ok: false;
+  refusal: AiRefusal;
 };
-
+//#endregion
+//#region src/types/delivery.d.ts
 /**
  * How a paper is delivered: what a learner is shown around the questions, as
  * the school running it decides — separately from the content, so that one
@@ -253,45 +443,45 @@ declare function checkAiWritingFeedback(raw: unknown, request: AiWritingFeedback
  * because the client in an exam has no answer key to grade with.
  */
 interface DeliveryPolicy {
-    /**
-     * Whether a graded answer shows as graded: right and wrong marks, the score,
-     * and the author's feedback. `false` leaves the learner with "Answer
-     * submitted." — a homework quiz marked on the client and shown to the
-     * learner at the end, or a review that shows what was answered and not how
-     * it was marked. Never on in `exam`.
-     */
-    feedback?: boolean | null;
-    /**
-     * Whether the right answer is shown beside a wrong one, wherever an activity
-     * would show it: the correct option of a multiple-choice question, the
-     * correct answers `showCorrectAnswers` puts in the blanks, a dictation's
-     * transcript. `false` still marks what the learner answered right or wrong.
-     * Use it on a paper that will be sat again, or before a retry.
-     */
-    solutions?: boolean | null;
-    /**
-     * Whether the learner can ask for hints: the author's hints on a
-     * fill-in-the-blanks blank, a dictation's word hints, and AI hints. `false`
-     * switches every kind off.
-     *
-     * **The author's fill-in-the-blanks hints are on in `exam` unless this says
-     * otherwise** — they are public content, and were designed to be. Set
-     * `hints: false` on a paper of record whose hints are not part of the test.
-     */
+  /**
+   * Whether a graded answer shows as graded: right and wrong marks, the score,
+   * and the author's feedback. `false` leaves the learner with "Answer
+   * submitted." — a homework quiz marked on the client and shown to the
+   * learner at the end, or a review that shows what was answered and not how
+   * it was marked. Never on in `exam`.
+   */
+  feedback?: boolean | null;
+  /**
+   * Whether the right answer is shown beside a wrong one, wherever an activity
+   * would show it: the correct option of a multiple-choice question, the
+   * correct answers `showCorrectAnswers` puts in the blanks, a dictation's
+   * transcript. `false` still marks what the learner answered right or wrong.
+   * Use it on a paper that will be sat again, or before a retry.
+   */
+  solutions?: boolean | null;
+  /**
+   * Whether the learner can ask for hints: the author's hints on a
+   * fill-in-the-blanks blank, a dictation's word hints, and AI hints. `false`
+   * switches every kind off.
+   *
+   * **The author's fill-in-the-blanks hints are on in `exam` unless this says
+   * otherwise** — they are public content, and were designed to be. Set
+   * `hints: false` on a paper of record whose hints are not part of the test.
+   */
+  hints?: boolean | null;
+  /**
+   * The deployment's switches for AI help, beside the author's switch on the
+   * item and the ports the host supplies: a feature appears only where all
+   * three allow it. `false` switches a feature off; nothing here can switch one
+   * on, and nothing switches AI help on in an `exam`.
+   *
+   * `ai: false` switches both off and `ai: true` leaves both as the other
+   * settings allow — the same as leaving `ai` out.
+   */
+  ai?: boolean | {
     hints?: boolean | null;
-    /**
-     * The deployment's switches for AI help, beside the author's switch on the
-     * item and the ports the host supplies: a feature appears only where all
-     * three allow it. `false` switches a feature off; nothing here can switch one
-     * on, and nothing switches AI help on in an `exam`.
-     *
-     * `ai: false` switches both off and `ai: true` leaves both as the other
-     * settings allow — the same as leaving `ai` out.
-     */
-    ai?: boolean | {
-        hints?: boolean | null;
-        explanations?: boolean | null;
-    } | null;
+    explanations?: boolean | null;
+  } | null;
 }
 /**
  * A policy with every setting spelled out: what {@link resolveDeliveryPolicy}
@@ -300,231 +490,220 @@ interface DeliveryPolicy {
  * change.
  */
 interface ResolvedDeliveryPolicy {
-    feedback: boolean;
-    solutions: boolean;
+  feedback: boolean;
+  solutions: boolean;
+  hints: boolean;
+  ai: {
     hints: boolean;
-    ai: {
-        hints: boolean;
-        explanations: boolean;
-    };
+    explanations: boolean;
+  };
 }
 /** One thing {@link validateDeliveryPolicy} found wrong with a policy. */
 interface DeliveryPolicyIssue {
-    /** Where, as a dotted path: `hints`, `ai.explanations`, or `''` for the policy itself. */
-    path: string;
-    message: string;
+  /** Where, as a dotted path: `hints`, `ai.explanations`, or `''` for the policy itself. */
+  path: string;
+  message: string;
 }
-
-/**
- * The frozen record of what one attempt was served.
- *
- * A sequence definition is live content: it gets edited, re-ordered, corrected.
- * An attempt is a historical fact. Everything that decides a grade — which
- * questions, in what order, each worth how much, against which version of the
- * content — has to be pinned at the moment the attempt starts, or a re-grade
- * six months later silently answers a different question than the learner was
- * asked.
- *
- * This is the thing you persist next to the responses.
- */
-
+//#endregion
+//#region src/types/attempt-plan.d.ts
 /** One planned position: an item, its identity, its worth, and its fingerprint. */
 interface AttemptPlanSlot {
+  /**
+   * Slot identity, from `flattenSequence`. Stable under shuffling; stable
+   * under editing too when the entries declare `slotKey`. This is the key to
+   * store responses and scores against.
+   */
+  slotId: string;
+  /** 0-based PRESENTED position in this attempt. */
+  index: number;
+  /** The activity that filled the slot. */
+  activityId: string;
+  /** The activity's `type` discriminator. */
+  activityType: string;
+  /**
+   * What this slot is worth, frozen. Points belong to the PAPER, not the item:
+   * the same question can be worth 1 in a quiz and 3 in a final, so they are
+   * resolved when the attempt is planned and never read from content again.
+   */
+  points: number;
+  /**
+   * Fingerprint of the activity's content as served. Compare it later with
+   * {@link verifyAttemptPlan} to find out whether the item has been edited
+   * since — the difference between "re-grading this attempt" and "grading a
+   * different exam".
+   */
+  contentHash: string;
+  /** Present when the slot came from an item group. */
+  group?: {
+    id: string;
+    title?: string;
+    /** Fingerprint of the stimulus as served — a corrected passage changes the question. */
+    stimulusHash: string;
     /**
-     * Slot identity, from `flattenSequence`. Stable under shuffling; stable
-     * under editing too when the entries declare `slotKey`. This is the key to
-     * store responses and scores against.
-     */
-    slotId: string;
-    /** 0-based PRESENTED position in this attempt. */
-    index: number;
-    /** The activity that filled the slot. */
-    activityId: string;
-    /** The activity's `type` discriminator. */
-    activityType: string;
-    /**
-     * What this slot is worth, frozen. Points belong to the PAPER, not the item:
-     * the same question can be worth 1 in a quiz and 3 in a final, so they are
-     * resolved when the attempt is planned and never read from content again.
-     */
-    points: number;
-    /**
-     * Fingerprint of the activity's content as served. Compare it later with
-     * {@link verifyAttemptPlan} to find out whether the item has been edited
-     * since — the difference between "re-grading this attempt" and "grading a
-     * different exam".
+     * The quiz this slot's question sat in, when the group is an interactive
+     * video. Frozen because WHEN a question is asked is part of what is asked:
+     * moved from before the passage it is about to after it, the same item is
+     * a different question.
      */
-    contentHash: string;
-    /** Present when the slot came from an item group. */
-    group?: {
-        id: string;
-        title?: string;
-        /** Fingerprint of the stimulus as served — a corrected passage changes the question. */
-        stimulusHash: string;
-        /**
-         * The quiz this slot's question sat in, when the group is an interactive
-         * video. Frozen because WHEN a question is asked is part of what is asked:
-         * moved from before the passage it is about to after it, the same item is
-         * a different question.
-         */
-        cue?: {
-            id: string;
-            at: number;
-            required?: boolean;
-        };
+    cue?: {
+      id: string;
+      at: number;
+      required?: boolean;
     };
-    /**
-     * Play budgets in force for this slot when the attempt was planned.
-     *
-     * Frozen for the same reason `points` is: a budget decides the grade, so an
-     * author who edits `maxPlays: 2 → 4` mid-window must not be able to change
-     * what a past learner was held to. A group's stimulus budget repeats on every
-     * slot of the group, exactly as `group.stimulusHash` already does.
-     *
-     * Absent when the slot budgets nothing, which keeps the plan — and therefore
-     * `planHash` — byte-identical for every paper written before 0.8.0.
-     */
-    mediaBudgets?: MediaBudgetRef[];
+  };
+  /**
+   * Play budgets in force for this slot when the attempt was planned.
+   *
+   * Frozen for the same reason `points` is: a budget decides the grade, so an
+   * author who edits `maxPlays: 2 → 4` mid-window must not be able to change
+   * what a past learner was held to. A group's stimulus budget repeats on every
+   * slot of the group, exactly as `group.stimulusHash` already does.
+   *
+   * Absent when the slot budgets nothing, which keeps the plan — and therefore
+   * `planHash` — byte-identical for every paper written before 0.8.0.
+   */
+  mediaBudgets?: MediaBudgetRef[];
 }
 /** A budgeted recording a slot presents, frozen as served. */
 interface MediaBudgetRef {
-    /** `slot:<slotId>` or `stimulus:<entryKey>`. */
-    key: string;
-    /** The `maxPlays` in force when the attempt was planned. */
-    maxPlays: number;
+  /** `slot:<slotId>` or `stimulus:<entryKey>`. */
+  key: string;
+  /** The `maxPlays` in force when the attempt was planned. */
+  maxPlays: number;
 }
 /** Everything needed to reproduce and re-grade one attempt. */
 interface AttemptPlan {
-    /** Version of this envelope, so a stored plan stays readable as it evolves. */
-    planVersion: '1.0';
-    /**
-     * The seed every shuffle in this attempt used, when anything shuffled.
-     * Absent means nothing was shuffled and the order is the authored one.
-     */
-    seed?: string;
-    /**
-     * Whether the top-level entries were shuffled. Recorded because
-     * {@link verifyAttemptPlan} needs to rebuild the SAME presented order: a
-     * re-plan that omitted this returned authored order, every slot compared as
-     * re-ordered, and unchanged content reported as drift.
-     */
-    shuffleEntries?: boolean;
-    /**
-     * Fingerprint of the whole plan's content — every slot's identity, order,
-     * points and content hash. One value to store against an attempt and compare
-     * later; the per-slot hashes then say WHICH item moved.
-     */
-    planHash: string;
-    /**
-     * The delivery policy the attempt was sat under, every setting spelled out:
-     * whether feedback, solutions and hints showed, and which AI help was on.
-     * Absent when `planAttempt` was given none. Part of `planHash` when present.
-     */
-    delivery?: ResolvedDeliveryPolicy;
-    /**
-     * The scoring policy the attempt was sat under, every setting spelled out:
-     * the tries each question gave, which counted, and what tries and hints
-     * cost. Absent when `planAttempt` was given none. Part of `planHash` when
-     * present.
-     */
-    scoring?: ResolvedItemScoringPolicy;
-    slots: AttemptPlanSlot[];
-    /** Sum of every slot's `points`, frozen. The denominator of the paper. */
-    totalPoints: number;
+  /** Version of this envelope, so a stored plan stays readable as it evolves. */
+  planVersion: '1.0';
+  /**
+   * The seed every shuffle in this attempt used, when anything shuffled.
+   * Absent means nothing was shuffled and the order is the authored one.
+   */
+  seed?: string;
+  /**
+   * Whether the top-level entries were shuffled. Recorded because
+   * {@link verifyAttemptPlan} needs to rebuild the SAME presented order: a
+   * re-plan that omitted this returned authored order, every slot compared as
+   * re-ordered, and unchanged content reported as drift.
+   */
+  shuffleEntries?: boolean;
+  /**
+   * Fingerprint of the whole plan's content — every slot's identity, order,
+   * points and content hash. One value to store against an attempt and compare
+   * later; the per-slot hashes then say WHICH item moved.
+   */
+  planHash: string;
+  /**
+   * The delivery policy the attempt was sat under, every setting spelled out:
+   * whether feedback, solutions and hints showed, and which AI help was on.
+   * Absent when `planAttempt` was given none. Part of `planHash` when present.
+   */
+  delivery?: ResolvedDeliveryPolicy;
+  /**
+   * The scoring policy the attempt was sat under, every setting spelled out:
+   * the tries each question gave, which counted, and what tries and hints
+   * cost. Absent when `planAttempt` was given none. Part of `planHash` when
+   * present.
+   */
+  scoring?: ResolvedItemScoringPolicy;
+  slots: AttemptPlanSlot[];
+  /** Sum of every slot's `points`, frozen. The denominator of the paper. */
+  totalPoints: number;
 }
 /** What {@link verifyAttemptPlan} found when a plan met current content. */
 interface AttemptPlanDrift {
-    /** True when the plan and the content still agree in every respect. */
-    matches: boolean;
-    /** Slots in the plan that no longer exist in the content at all. */
-    missingSlotIds: string[];
-    /** Slots present now that the plan never held — content added since. */
-    addedSlotIds: string[];
-    /** Slots whose activity content has been edited since the attempt. */
-    changedSlotIds: string[];
-    /** Slots whose item group's stimulus has been edited since the attempt. */
-    changedStimulusSlotIds: string[];
-    /**
-     * Slots of an interactive video whose question now sits in a different quiz,
-     * at a different moment, or under a different `required` — or that gained or
-     * lost a quiz altogether. Always empty for content without a timeline.
-     */
-    changedCueSlotIds: string[];
-    /**
-     * Slots now worth a different number of points. A reweight is a paper
-     * change — it moves the grade without touching a single question — so it
-     * cannot be left out of a remark or an appeal.
-     */
-    changedPointsSlotIds: string[];
-    /** Slots presented at a different position now than they were then. */
-    reorderedSlotIds: string[];
-    /**
-     * The delivery policy differs: one plan records a policy the other does not,
-     * or a setting differs. Not a change to any question, but a change to the
-     * conditions it was asked under — hints on in one, off in the other — so it
-     * breaks `matches` like any other difference.
-     *
-     * Present only when it is `true`, so a report between two plans without a
-     * policy has exactly the shape it had before policies existed.
-     */
-    deliveryChanged?: true;
-    /**
-     * The scoring policy differs: one plan records a policy the other does not,
-     * or a setting differs. The same answers are worth something else under
-     * another policy, so it breaks `matches`. Present only when it is `true`.
-     */
-    scoringChanged?: true;
+  /** True when the plan and the content still agree in every respect. */
+  matches: boolean;
+  /** Slots in the plan that no longer exist in the content at all. */
+  missingSlotIds: string[];
+  /** Slots present now that the plan never held — content added since. */
+  addedSlotIds: string[];
+  /** Slots whose activity content has been edited since the attempt. */
+  changedSlotIds: string[];
+  /** Slots whose item group's stimulus has been edited since the attempt. */
+  changedStimulusSlotIds: string[];
+  /**
+   * Slots of an interactive video whose question now sits in a different quiz,
+   * at a different moment, or under a different `required` — or that gained or
+   * lost a quiz altogether. Always empty for content without a timeline.
+   */
+  changedCueSlotIds: string[];
+  /**
+   * Slots now worth a different number of points. A reweight is a paper
+   * change — it moves the grade without touching a single question — so it
+   * cannot be left out of a remark or an appeal.
+   */
+  changedPointsSlotIds: string[];
+  /** Slots presented at a different position now than they were then. */
+  reorderedSlotIds: string[];
+  /**
+   * The delivery policy differs: one plan records a policy the other does not,
+   * or a setting differs. Not a change to any question, but a change to the
+   * conditions it was asked under — hints on in one, off in the other — so it
+   * breaks `matches` like any other difference.
+   *
+   * Present only when it is `true`, so a report between two plans without a
+   * policy has exactly the shape it had before policies existed.
+   */
+  deliveryChanged?: true;
+  /**
+   * The scoring policy differs: one plan records a policy the other does not,
+   * or a setting differs. The same answers are worth something else under
+   * another policy, so it breaks `matches`. Present only when it is `true`.
+   */
+  scoringChanged?: true;
 }
-
+//#endregion
+//#region src/attempt-plan.d.ts
 /** Options for {@link planAttempt}. */
-interface PlanAttemptOptions<TItem> {
-    /** Shuffle the top-level entries. A group moves as one block. */
-    shuffleEntries?: boolean;
-    /**
-     * Seed for every shuffle in this attempt. Required whenever anything
-     * shuffles — the attempt has to be reproducible, which is the entire point
-     * of writing a plan down. Use the attempt id.
-     */
-    seed?: string;
-    /**
-     * What each slot is worth. Defaults to 1 for every slot.
-     *
-     * Points are resolved HERE, not read from content, because they belong to
-     * the paper rather than the item: the same question is worth 1 in a practice
-     * quiz and 3 in a final. Whatever this returns is frozen into the plan and
-     * is what `composeAssessmentScore` will weight by.
-     *
-     * @throws Error when it returns a value that is not a finite, non-negative
-     *         number — a slot worth `NaN` points would poison the whole total.
-     */
-    points?: (slot: SequenceSlot<TItem>) => number;
-    /**
-     * The delivery policy this attempt is sat under — whether hints were
-     * offered, whether AI help was, whether feedback and solutions showed.
-     * Frozen into the plan with every setting spelled out, so the record of the
-     * conditions a grade was earned under does not depend on today's defaults.
-     *
-     * Recorded only when given: a plan made without one is byte-identical to a
-     * plan made before policies existed, `planHash` included.
-     *
-     * @throws Error when the policy does not pass `validateDeliveryPolicy` —
-     *         a misspelled restriction is no restriction, and a plan is the
-     *         record an appeal reads.
-     */
-    delivery?: DeliveryPolicy | null;
-    /**
-     * The scoring policy this attempt is sat under — how many tries each
-     * question gives, which one counts, and what tries and hints cost. Frozen
-     * into the plan with every setting spelled out, like `delivery`, and for a
-     * stronger reason: every setting in it moves a grade, so a re-grade must
-     * apply the rules the learner sat under, not today's.
-     *
-     * Recorded only when given: a plan made without one is byte-identical to a
-     * plan made before scoring policies existed, `planHash` included.
-     *
-     * @throws Error when the policy does not pass `validateItemScoringPolicy`.
-     */
-    scoring?: ItemScoringPolicy | null;
+export interface PlanAttemptOptions<TItem> {
+  /** Shuffle the top-level entries. A group moves as one block. */
+  shuffleEntries?: boolean;
+  /**
+   * Seed for every shuffle in this attempt. Required whenever anything
+   * shuffles — the attempt has to be reproducible, which is the entire point
+   * of writing a plan down. Use the attempt id.
+   */
+  seed?: string;
+  /**
+   * What each slot is worth. Defaults to 1 for every slot.
+   *
+   * Points are resolved HERE, not read from content, because they belong to
+   * the paper rather than the item: the same question is worth 1 in a practice
+   * quiz and 3 in a final. Whatever this returns is frozen into the plan and
+   * is what `composeAssessmentScore` will weight by.
+   *
+   * @throws Error when it returns a value that is not a finite, non-negative
+   *         number — a slot worth `NaN` points would poison the whole total.
+   */
+  points?: (slot: SequenceSlot<TItem>) => number;
+  /**
+   * The delivery policy this attempt is sat under — whether hints were
+   * offered, whether AI help was, whether feedback and solutions showed.
+   * Frozen into the plan with every setting spelled out, so the record of the
+   * conditions a grade was earned under does not depend on today's defaults.
+   *
+   * Recorded only when given: a plan made without one is byte-identical to a
+   * plan made before policies existed, `planHash` included.
+   *
+   * @throws Error when the policy does not pass `validateDeliveryPolicy` —
+   *         a misspelled restriction is no restriction, and a plan is the
+   *         record an appeal reads.
+   */
+  delivery?: DeliveryPolicy | null;
+  /**
+   * The scoring policy this attempt is sat under — how many tries each
+   * question gives, which one counts, and what tries and hints cost. Frozen
+   * into the plan with every setting spelled out, like `delivery`, and for a
+   * stronger reason: every setting in it moves a grade, so a re-grade must
+   * apply the rules the learner sat under, not today's.
+   *
+   * Recorded only when given: a plan made without one is byte-identical to a
+   * plan made before scoring policies existed, `planHash` included.
+   *
+   * @throws Error when the policy does not pass `validateItemScoringPolicy`.
+   */
+  scoring?: ItemScoringPolicy | null;
 }
 /**
  * Freezes what an attempt is being served: the presented order, each slot's
@@ -542,9 +721,9 @@ interface PlanAttemptOptions<TItem> {
  *         empty, when two entries collide on a `slotKey`, or when `points`
  *         returns a value that is not finite and non-negative.
  */
-declare function planAttempt<TItem extends {
-    id: string;
-    type: string;
+export declare function planAttempt<TItem extends {
+  id: string;
+  type: string;
 }>(entries: readonly SequenceEntry<TItem>[], options?: PlanAttemptOptions<TItem>): AttemptPlan;
 /**
  * Compares a stored plan with the content as it stands now, and reports every
@@ -570,23 +749,23 @@ declare function planAttempt<TItem extends {
  * A drift is not automatically a problem — a fixed typo changes a hash without
  * changing what was asked. It is a fact somebody has to be able to see.
  */
-declare function verifyAttemptPlan(plan: AttemptPlan, current: AttemptPlan): AttemptPlanDrift;
+export declare function verifyAttemptPlan(plan: AttemptPlan, current: AttemptPlan): AttemptPlanDrift;
 /** How {@link scoredItemsFromPlan} fills a slot that has no recorded outcome. */
-type MissingOutcomePolicy = 
+export type MissingOutcomePolicy =
 /**
  * Default. `{ status: 'deferred', reason: 'no_response_recorded' }` — a
  * non-terminal state, so the composed result stays `provisional` and cannot
  * be recorded as a final pass or fail.
  */
-'deferred'
+'deferred' |
 /**
  * `{ status: 'scored', score: 0 }` — the learner left it blank on a paper
  * that IS complete. Choose this only when you know the attempt was
  * submitted; it is a real zero and makes the result final.
  */
- | 'zero'
+'zero' |
 /** Build the outcome yourself, per slot. */
- | ((slot: AttemptPlanSlot) => ItemOutcome);
+((slot: AttemptPlanSlot) => ItemOutcome);
 /**
  * Turns a plan plus whatever outcomes exist into the `ScoredItem[]`
  * `composeAssessmentScore` consumes.
@@ -607,12 +786,13 @@ type MissingOutcomePolicy =
  * Pass outcomes keyed by `slotId`. Keys the plan does not know are ignored:
  * a plan is the authority on what the attempt contained.
  */
-declare function scoredItemsFromPlan(plan: AttemptPlan, outcomes: Readonly<Record<string, ItemOutcome>>, options?: {
-    missing?: MissingOutcomePolicy;
+export declare function scoredItemsFromPlan(plan: AttemptPlan, outcomes: Readonly<Record<string, ItemOutcome>>, options?: {
+  missing?: MissingOutcomePolicy;
 }): ScoredItem[];
 /** Convenience alias: the entry type a plan is built from. */
-type PlannableEntry = SequenceEntry<ActivityData>;
-
+export type PlannableEntry = SequenceEntry<ActivityData>;
+//#endregion
+//#region src/types/attempt-state.d.ts
 /**
  * A resumable snapshot of an attempt in progress.
  *
@@ -626,46 +806,47 @@ type PlannableEntry = SequenceEntry<ActivityData>;
  * slot ids alone would happily line up against the wrong questions.
  */
 interface AttemptState {
-    /** Version of this envelope, so a stored snapshot stays readable as it evolves. */
-    stateVersion: '1.0';
-    /**
-     * `planHash` of the {@link AttemptPlan} this state belongs to. `restoreAttemptState`
-     * refuses a plan that does not match, rather than restoring a learner's
-     * answers onto a paper they never sat.
-     */
-    planHash: string;
-    /** The learner's answers so far, keyed by `slotId`. */
-    responses: Record<string, LearnerResponse>;
-    /**
-     * Slots the learner has already submitted. Kept apart from `responses`
-     * because they answer different questions: what did they write, and may they
-     * still change it.
-     */
-    submittedSlotIds: string[];
-    /** Presented position the learner was on, so a resume reopens there. */
-    index: number;
-    /** ISO 8601 timestamp of the snapshot, when the caller supplies one. */
-    savedAt?: string;
+  /** Version of this envelope, so a stored snapshot stays readable as it evolves. */
+  stateVersion: '1.0';
+  /**
+   * `planHash` of the {@link AttemptPlan} this state belongs to. `restoreAttemptState`
+   * refuses a plan that does not match, rather than restoring a learner's
+   * answers onto a paper they never sat.
+   */
+  planHash: string;
+  /** The learner's answers so far, keyed by `slotId`. */
+  responses: Record<string, LearnerResponse>;
+  /**
+   * Slots the learner has already submitted. Kept apart from `responses`
+   * because they answer different questions: what did they write, and may they
+   * still change it.
+   */
+  submittedSlotIds: string[];
+  /** Presented position the learner was on, so a resume reopens there. */
+  index: number;
+  /** ISO 8601 timestamp of the snapshot, when the caller supplies one. */
+  savedAt?: string;
 }
 /** One slot whose response differs between two snapshots. */
 interface ResponseDiffEntry {
-    slotId: string;
-    /** `added` — answered since; `removed` — cleared; `changed` — a different answer. */
-    change: 'added' | 'removed' | 'changed';
-    before?: LearnerResponse;
-    after?: LearnerResponse;
+  slotId: string;
+  /** `added` — answered since; `removed` — cleared; `changed` — a different answer. */
+  change: 'added' | 'removed' | 'changed';
+  before?: LearnerResponse;
+  after?: LearnerResponse;
 }
-
+//#endregion
+//#region src/attempt-state.d.ts
 /** What {@link serializeAttemptState} is given about an attempt in progress. */
-interface AttemptProgress {
-    /** Answers so far, keyed by `slotId`. */
-    responses: Readonly<Record<string, LearnerResponse>>;
-    /** Slots already submitted. Defaults to none. */
-    submittedSlotIds?: readonly string[];
-    /** Presented position the learner is on. Defaults to 0. */
-    index?: number;
-    /** ISO 8601 timestamp to stamp the snapshot with. The SDK does not read a clock. */
-    savedAt?: string;
+export interface AttemptProgress {
+  /** Answers so far, keyed by `slotId`. */
+  responses: Readonly<Record<string, LearnerResponse>>;
+  /** Slots already submitted. Defaults to none. */
+  submittedSlotIds?: readonly string[];
+  /** Presented position the learner is on. Defaults to 0. */
+  index?: number;
+  /** ISO 8601 timestamp to stamp the snapshot with. The SDK does not read a clock. */
+  savedAt?: string;
 }
 /**
  * Captures an in-progress attempt as a storable snapshot, bound to its plan.
@@ -681,7 +862,7 @@ interface AttemptProgress {
  * @throws Error when a response or submitted slot is not in the plan, or when
  *         `index` is not a position the plan actually has.
  */
-declare function serializeAttemptState(plan: AttemptPlan, progress: AttemptProgress): AttemptState;
+export declare function serializeAttemptState(plan: AttemptPlan, progress: AttemptProgress): AttemptState;
 /**
  * Reopens a stored snapshot against a plan, refusing anything that does not
  * belong to it.
@@ -695,7 +876,7 @@ declare function serializeAttemptState(plan: AttemptPlan, progress: AttemptProgr
  * @throws Error when the snapshot belongs to a different plan, or references
  *         slots the plan does not contain.
  */
-declare function restoreAttemptState(plan: AttemptPlan, state: AttemptState): AttemptState;
+export declare function restoreAttemptState(plan: AttemptPlan, state: AttemptState): AttemptState;
 /**
  * Reports how two snapshots' responses differ, slot by slot.
  *
@@ -707,63 +888,9 @@ declare function restoreAttemptState(plan: AttemptPlan, state: AttemptState): At
  * Entries come back sorted by `slotId`, so the output is stable regardless of
  * the order the two objects happened to be written in.
  */
-declare function diffResponses(before: Pick<AttemptState, 'responses'>, after: Pick<AttemptState, 'responses'>): ResponseDiffEntry[];
-
-/**
- * Why a draft is not an activity yet.
- *
- * - `incomplete` — something the author has not written yet: an empty title, an
- *   option with no text, no option marked correct. The fix is to add it.
- * - `invalid` — something is wrong in a way that writing more cannot fix: two
- *   correct options on a single-selection question, a maximum word count below
- *   the minimum, a media address with a scheme the SDK refuses, a `null` in an
- *   optional field that accepts none. The fix is to change it.
- */
-type DraftSeverity = 'incomplete' | 'invalid';
-/**
- * One problem with a draft. A {@link ValidationError} with a severity, so code
- * that already lists `validateActivity` errors can list these unchanged.
- */
-interface DraftIssue extends ValidationError {
-    severity: DraftSeverity;
-}
-/** A draft that is a valid activity and has nothing left to write. */
-interface DraftComplete<T> {
-    status: 'complete';
-    /** The validated activity, exactly as `validateActivity` returns it. */
-    data: T;
-    /** Always empty. Present so that every result can be read the same way. */
-    issues: DraftIssue[];
-}
-/**
- * A draft that is not an activity yet: `invalid` when any issue is invalid,
- * otherwise `incomplete`. It carries no `data`, because nothing here may be
- * stored or rendered as an activity.
- */
-interface DraftNotComplete {
-    status: 'incomplete' | 'invalid';
-    issues: DraftIssue[];
-}
-/**
- * The result of `validateDraft`.
- *
- * There is deliberately no `success` boolean. A boolean has to call an
- * incomplete draft either a success, which lets a half-written answer key
- * through anything that checks it, or a failure, which is the conflation this
- * result exists to remove. Branch on `status`.
- */
-type DraftValidationResult<T> = DraftComplete<T> | DraftNotComplete;
-/** What `createDraft` hands an activity type's `authoring.createDraft`. */
-interface DraftContext {
-    /**
-     * Returns a new id on every call. The SDK invents none: an id made here would
-     * need `crypto`, which plain-http origins do not have, or would be positional —
-     * and option ids reach the learner, so ids like `"a"` and `"b"` would tell them
-     * which option was written first.
-     */
-    newId: () => string;
-}
-
+export declare function diffResponses(before: Pick<AttemptState, 'responses'>, after: Pick<AttemptState, 'responses'>): ResponseDiffEntry[];
+//#endregion
+//#region src/authoring/item-group.d.ts
 /**
  * A new, empty reading or listening testlet for an editor to start from.
  *
@@ -775,7 +902,7 @@ interface DraftContext {
  *
  * @throws Error when `newId` returns an empty or repeated id.
  */
-declare function createItemGroupDraft(context: DraftContext): ItemGroup;
+export declare function createItemGroupDraft(context: DraftContext): ItemGroup;
 /**
  * A new, empty interactive video for an editor to start from: an item group
  * whose stimulus is a video with no file yet, no questions, and a timeline with
@@ -788,7 +915,7 @@ declare function createItemGroupDraft(context: DraftContext): ItemGroup;
  *
  * @throws Error when `newId` returns an empty or repeated id.
  */
-declare function createInteractiveVideoDraft(context: DraftContext): ItemGroup;
+export declare function createInteractiveVideoDraft(context: DraftContext): ItemGroup;
 /**
  * Tells an unfinished testlet from a broken one — {@link validateDraft} for the
  * container that holds several questions around one passage or recording.
@@ -814,8 +941,27 @@ declare function createInteractiveVideoDraft(context: DraftContext): ItemGroup;
  *   turned into an issue: a fault in a type's own code is not a problem with the
  *   draft, and reporting it as an unknown type would hide it.
  */
-declare function validateItemGroupDraft(draft: unknown): DraftValidationResult<ItemGroup>;
-
+/**
+ * The item critic over a testlet: each item's findings, under `items.N.…`, and
+ * what only the set shows — every single-answer question keeping its right
+ * option in one place. The stimulus is not searched for answers: a reading
+ * group's answers are meant to be in its passage.
+ *
+ * An item of a type that is not registered, or without a `type`, is skipped:
+ * {@link validateItemGroupDraft} already reports it.
+ */
+export declare function critiqueItemGroupDraft(draft: unknown): ItemFinding[];
+/**
+ * The item critic over a question set, as `<ActivitySequence>` takes one: each
+ * entry's findings under its index — an item group's under `N.items.M.…` — and,
+ * over the entries that are items, what only the set shows (see
+ * {@link critiqueItemGroupDraft}). An entry of a type that is not registered is
+ * skipped.
+ */
+export declare function critiqueDrafts(entries: readonly unknown[]): ItemFinding[];
+export declare function validateItemGroupDraft(draft: unknown): DraftValidationResult<ItemGroup>;
+//#endregion
+//#region src/authoring/index.d.ts
 /**
  * Tells a draft that is not finished from a draft that is wrong.
  *
@@ -853,7 +999,7 @@ declare function validateItemGroupDraft(draft: unknown): DraftValidationResult<I
  * @throws UnknownActivityTypeError when `type` has no registered descriptor —
  *   including `'item-group'`, which is a container, not an activity type.
  */
-declare function validateDraft<T extends ActivityType>(type: T, draft: unknown): DraftValidationResult<ActivityDataMap[T]>;
+export declare function validateDraft<T extends ActivityType>(type: T, draft: unknown): DraftValidationResult<ActivityDataMap[T]>;
 /**
  * A new, empty draft of an activity type, for an editor to start from.
  *
@@ -871,8 +1017,52 @@ declare function validateDraft<T extends ActivityType>(type: T, draft: unknown):
  * @throws Error when the type declares no `authoring.createDraft`, or when
  *   `newId` returns an empty or repeated id.
  */
-declare function createDraft<T extends ActivityType>(type: T, context: DraftContext): ActivityDataMap[T];
-
+export declare function createDraft<T extends ActivityType>(type: T, context: DraftContext): ActivityDataMap[T];
+/**
+ * What an experienced item writer would point out on review: flaws a learner
+ * can exploit or trip over (`warning`) and item-writing guidelines the item
+ * departs from (`advice`) — the right option much longer than the rest, an
+ * answer printed in the passage, a hint that gives the answer away, two
+ * options that read the same, "all of the above" under shuffle.
+ *
+ * A finding is never a reason to refuse an item. It does not change what
+ * {@link validateDraft} says: a valid item with findings is still valid. The
+ * shape is a `DraftIssue`'s, so an editor shows both in one list.
+ *
+ * It reads a draft, finished or not, and skips any rule whose fields are not
+ * written yet. The codes are documented in `docs/authoring.md`, each with its
+ * severity; the rule behind a code is advice and may be refined in a minor.
+ *
+ * ```ts
+ * const list = [...validateDraft(type, draft).issues, ...critiqueDraft(type, draft)];
+ * ```
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor —
+ *   including `'item-group'`: use {@link critiqueItemGroupDraft}.
+ */
+export declare function critiqueDraft(type: ActivityType, draft: unknown): ItemFinding[];
+//#endregion
+//#region src/built-in-types.d.ts
+/**
+ * The activity types the SDK ships, in one closed list.
+ *
+ * {@link ActivityType} is `keyof ActivityDataMap`, which a host widens by
+ * module augmentation to name its own types, so it cannot say which types are
+ * the SDK's. This list can: every table the SDK keeps per built-in type is
+ * typed against it (`satisfies Record<BuiltInActivityType, …>`) or walks it, so
+ * a type added here is a compile error, or a failing test, everywhere it has
+ * not been handled yet.
+ *
+ * The SDK's own registry holds exactly these, in this order, before a host
+ * registers anything.
+ */
+export declare const BUILT_IN_ACTIVITY_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "written-response", "gap-select", "dictation", "read-aloud"];
+/** One of {@link BUILT_IN_ACTIVITY_TYPES}: an activity type the SDK ships, not one a host registered. */
+type BuiltInActivityType = (typeof BUILT_IN_ACTIVITY_TYPES)[number];
+/** Whether `type` names an activity type the SDK ships. */
+export declare function isBuiltInActivityType(type: unknown): type is BuiltInActivityType;
+//#endregion
+//#region src/content-hash.d.ts
 /**
  * Content fingerprinting — "is this the same content the learner was served?"
  *
@@ -893,7 +1083,7 @@ declare function createDraft<T extends ActivityType>(type: T, context: DraftCont
  * that disagreed would raise a false alarm every time a payload made a
  * round-trip through a different serializer.
  */
-declare function canonicalJson(value: unknown, seen?: Set<object>): string;
+export declare function canonicalJson(value: unknown, seen?: Set<object>): string;
 /**
  * FNV-1a over the UTF-8 bytes of `input`, as 16 lowercase hex digits.
  *
@@ -904,28 +1094,30 @@ declare function canonicalJson(value: unknown, seen?: Set<object>): string;
  * property, sign the plan with a key the content author does not hold; this
  * exists to catch honest edits, which is what actually happens.
  */
-declare function fingerprint(input: string): string;
+export declare function fingerprint(input: string): string;
 /**
  * Fingerprints any JSON-serialisable value through {@link canonicalJson}, so
  * the result depends on the content and not on how it was written.
  */
-declare function contentHash(value: unknown): string;
-
+export declare function contentHash(value: unknown): string;
+//#endregion
+//#region src/count-words.d.ts
 /**
- * Canonical word counter for written-response bounds (Req 22.9): tokens are
+ * Canonical word counter for written-response bounds: tokens are
  * maximal runs of non-whitespace (split on `\s+`), so hyphenated forms
  * (`well-known`) count as one word. The empty / whitespace-only string counts
  * 0. Consumers must use this helper rather than re-implementing the split so
  * client previews, SDK scoring, and stored `wordCount` values always agree.
  */
-declare function countWords(text: string): number;
-
+export declare function countWords(text: string): number;
+//#endregion
+//#region src/delivery.d.ts
 /**
  * The policy that restricts nothing: every setting `true`. It is what an absent
  * policy resolves to, and it is exactly the behaviour the SDK had before
  * delivery policies existed.
  */
-declare const OPEN_DELIVERY_POLICY: ResolvedDeliveryPolicy;
+export declare const OPEN_DELIVERY_POLICY: ResolvedDeliveryPolicy;
 /**
  * A policy with every setting spelled out — see {@link DeliveryPolicy}.
  *
@@ -934,13 +1126,13 @@ declare const OPEN_DELIVERY_POLICY: ResolvedDeliveryPolicy;
  * policy that is not an object at all restricts everything. Check a policy
  * before you store it with {@link validateDeliveryPolicy}; `planAttempt` does.
  */
-declare function resolveDeliveryPolicy(policy: unknown): ResolvedDeliveryPolicy;
+export declare function resolveDeliveryPolicy(policy: unknown): ResolvedDeliveryPolicy;
 /**
  * The strictest of several policies: a setting is on only where every one of
  * them leaves it on. How a course's policy and an assessment's combine, and
  * how a pager's policy wins over whatever a question it draws was handed.
  */
-declare function combineDeliveryPolicies(...policies: unknown[]): ResolvedDeliveryPolicy;
+export declare function combineDeliveryPolicies(...policies: unknown[]): ResolvedDeliveryPolicy;
 /**
  * Checks a policy before it is stored: each setting `true`, `false`, `null`
  * or absent, and nothing else — no misspelled setting, no string standing in
@@ -951,24 +1143,25 @@ declare function combineDeliveryPolicies(...policies: unknown[]): ResolvedDelive
  * policy is a record of the conditions a paper was sat under: it is worth
  * refusing before it is written down, rather than read charitably after.
  */
-declare function validateDeliveryPolicy(policy: unknown): {
-    success: true;
-    data: DeliveryPolicy;
+export declare function validateDeliveryPolicy(policy: unknown): {
+  success: true;
+  data: DeliveryPolicy;
 } | {
-    success: false;
-    issues: DeliveryPolicyIssue[];
+  success: false;
+  issues: DeliveryPolicyIssue[];
 };
-
+//#endregion
+//#region src/errors.d.ts
 /** Thrown when activity data fails schema validation at a component boundary. */
-declare class ActivitySchemaError extends Error {
-    readonly activityType: string;
-    readonly errors: ValidationError[];
-    constructor(activityType: string, errors: ValidationError[]);
+export declare class ActivitySchemaError extends Error {
+  readonly activityType: string;
+  readonly errors: ValidationError[];
+  constructor(activityType: string, errors: ValidationError[]);
 }
 /** Thrown when an unrecognised activity type is passed to the scoring engine. */
-declare class UnknownActivityTypeError extends Error {
-    readonly activityType: string;
-    constructor(activityType: string);
+export declare class UnknownActivityTypeError extends Error {
+  readonly activityType: string;
+  constructor(activityType: string);
 }
 /**
  * Thrown when a grading entry point is asked to grade a `redact()` projection
@@ -980,9 +1173,9 @@ declare class UnknownActivityTypeError extends Error {
  * type comes back `unscorable`, and a deferred one `deferred`, as it does for
  * any item of that type.
  */
-declare class RedactedScoringError extends Error {
-    readonly activityType: string;
-    constructor(activityType: string);
+export declare class RedactedScoringError extends Error {
+  readonly activityType: string;
+  constructor(activityType: string);
 }
 /**
  * Thrown when `score()` is called for an activity type whose grading is
@@ -991,33 +1184,34 @@ declare class RedactedScoringError extends Error {
  * a learner a failing grade for work that simply has not been graded yet.
  * Call `evaluate()` instead, which returns `{ status: 'deferred', ... }`.
  */
-declare class DeferredScoringError extends Error {
-    readonly activityType: string;
-    constructor(activityType: string);
+export declare class DeferredScoringError extends Error {
+  readonly activityType: string;
+  constructor(activityType: string);
 }
-
+//#endregion
+//#region src/grading.d.ts
 /** Options for {@link gradeFromRubric}. */
-interface GradeFromRubricOptions {
-    /**
-     * Scaled score [0,1] required to pass. Defaults to the activity's
-     * `passThreshold`, or {@link DEFAULT_PASS_THRESHOLD} when absent.
-     */
-    passThreshold?: number;
-    /** Narrative feedback for the learner, carried onto the record verbatim. */
-    feedback?: string | null;
-    /**
-     * Compare the pass line the way the score is displayed — both sides rounded,
-     * via `gte` — whichever threshold applies: `passThreshold` above, the
-     * activity's own, or the 0.7 default. The returned `score` stays unrounded.
-     * Opt-in, as on `score()` and `evaluate()`: switching it on moves pass/fail
-     * for totals in the rounding band.
-     *
-     * Checked before any criterion is read: `null` reads as no policy, and a
-     * policy that cannot be applied — an unknown `mode`, or a `dp` that is not a
-     * whole number from 0 to 15 — throws a `RangeError`, even for a rubric that
-     * turns out to be unscorable.
-     */
-    rounding?: RoundingPolicy;
+export interface GradeFromRubricOptions {
+  /**
+   * Scaled score [0,1] required to pass. Defaults to the activity's
+   * `passThreshold`, or {@link DEFAULT_PASS_THRESHOLD} when absent.
+   */
+  passThreshold?: number;
+  /** Narrative feedback for the learner, carried onto the record verbatim. */
+  feedback?: string | null;
+  /**
+   * Compare the pass line the way the score is displayed — both sides rounded,
+   * via `gte` — whichever threshold applies: `passThreshold` above, the
+   * activity's own, or the 0.7 default. The returned `score` stays unrounded.
+   * Opt-in, as on `score()` and `evaluate()`: switching it on moves pass/fail
+   * for totals in the rounding band.
+   *
+   * Checked before any criterion is read: `null` reads as no policy, and a
+   * policy that cannot be applied — an unknown `mode`, or a `dp` that is not a
+   * whole number from 0 to 15 — throws a `RangeError`, even for a rubric that
+   * turns out to be unscorable.
+   */
+  rounding?: RoundingPolicy;
 }
 /**
  * Computes the weighted total from per-criterion scores — the arithmetic that
@@ -1051,9 +1245,9 @@ interface GradeFromRubricOptions {
  * The returned `GradeRecord.score` is always scaled [0,1] against
  * `maxScore: 1`, like every other score in the SDK.
  */
-declare function gradeFromRubric(criteria: readonly CriterionScore[], activityData?: ActivityData, options?: GradeFromRubricOptions): GradeRecord | {
-    unscorable: true;
-    reason: string;
+export declare function gradeFromRubric(criteria: readonly CriterionScore[], activityData?: ActivityData, options?: GradeFromRubricOptions): GradeRecord | {
+  unscorable: true;
+  reason: string;
 };
 /**
  * Lifts a {@link GradeRecord} into the `graded` arm of {@link ItemOutcome}, so
@@ -1074,36 +1268,37 @@ declare function gradeFromRubric(criteria: readonly CriterionScore[], activityDa
  * is what it is: the slot is still owed a real grade, so a composed attempt
  * stays `provisional` and names the slot in `rejectedSlotIds`.
  */
-declare function outcomeFromGrade(grade: GradeRecord): ItemOutcome;
+export declare function outcomeFromGrade(grade: GradeRecord): ItemOutcome;
 /**
  * True when an outcome carries a real grade — either the SDK scored it
  * synchronously or a grader returned one. Use this instead of testing
  * `status === 'scored'`, which silently misses asynchronously graded work.
  */
-declare function hasGrade(outcome: ItemOutcome): outcome is Extract<ItemOutcome, {
-    status: 'scored' | 'graded';
+export declare function hasGrade(outcome: ItemOutcome): outcome is Extract<ItemOutcome, {
+  status: 'scored' | 'graded';
 }>;
-
+//#endregion
+//#region src/item-group.d.ts
 /** Narrows a sequence entry to an item group. */
-declare function isItemGroup<TItem extends {
-    type: string;
+export declare function isItemGroup<TItem extends {
+  type: string;
 }>(entry: SequenceEntry<TItem>): entry is ItemGroup<TItem>;
 /** Options for {@link flattenSequence}. */
-interface FlattenSequenceOptions {
-    /**
-     * Shuffle the top-level entries. A group moves as ONE block — its items are
-     * never interleaved with other entries — which is the reason a group exists
-     * as a container rather than as a flag on each item.
-     */
-    shuffleEntries?: boolean;
-    /**
-     * Seed for every shuffle in this call: the entries, and each group whose
-     * `shuffle` is `within-group`. REQUIRED whenever anything shuffles. The SDK
-     * never invents one, because the server that stores an attempt and the
-     * client that renders it must derive the SAME order, and only a shared seed
-     * makes that true. The attempt id is the natural choice.
-     */
-    seed?: string;
+export interface FlattenSequenceOptions {
+  /**
+   * Shuffle the top-level entries. A group moves as ONE block — its items are
+   * never interleaved with other entries — which is the reason a group exists
+   * as a container rather than as a flag on each item.
+   */
+  shuffleEntries?: boolean;
+  /**
+   * Seed for every shuffle in this call: the entries, and each group whose
+   * `shuffle` is `within-group`. REQUIRED whenever anything shuffles. The SDK
+   * never invents one, because the server that stores an attempt and the
+   * client that renders it must derive the SAME order, and only a shared seed
+   * makes that true. The attempt id is the natural choice.
+   */
+  seed?: string;
 }
 /**
  * Turns a sequence definition — loose activities and item groups, in authored
@@ -1119,30 +1314,31 @@ interface FlattenSequenceOptions {
  *
  * @throws Error when a shuffle is requested without a `seed`.
  */
-declare function flattenSequence<TItem extends {
-    id: string;
-    type: string;
+export declare function flattenSequence<TItem extends {
+  id: string;
+  type: string;
 }>(entries: readonly SequenceEntry<TItem>[], options?: FlattenSequenceOptions): SequenceSlot<TItem>[];
-
+//#endregion
+//#region src/types/media-budget.d.ts
 /**
  * What one budgeted recording has cost the learner so far.
  */
 interface MediaPlayLedgerEntry {
-    /**
-     * Plays consumed. A non-negative integer. It MAY exceed the budget: an
-     * invigilator override and a race the server resolved both legitimately
-     * produce that, and clamping here would hide it.
-     */
-    plays: number;
-    /**
-     * Where playback stood at the last report, in seconds.
-     *
-     * Restored on mount so a refresh RESUMES the play the learner already paid
-     * for instead of charging them again for it. It can only ever let them
-     * continue from where they were, never restart, because `seek` resolves to
-     * `'none'` under a budget.
-     */
-    at?: number;
+  /**
+   * Plays consumed. A non-negative integer. It MAY exceed the budget: an
+   * invigilator override and a race the server resolved both legitimately
+   * produce that, and clamping here would hide it.
+   */
+  plays: number;
+  /**
+   * Where playback stood at the last report, in seconds.
+   *
+   * Restored on mount so a refresh RESUMES the play the learner already paid
+   * for instead of charging them again for it. It can only ever let them
+   * continue from where they were, never restart, because `seek` resolves to
+   * `'none'` under a budget.
+   */
+  at?: number;
 }
 /**
  * The spent-play ledger for one attempt.
@@ -1162,13 +1358,13 @@ interface MediaPlayLedgerEntry {
  * Bound to its paper by `planHash` for the same reason `AttemptState` is.
  */
 interface MediaPlayLedger {
-    ledgerVersion: '1.0';
-    /** The `planHash` of the paper these counts were spent on. */
-    planHash: string;
-    /** Keyed by `slotMediaKey()` / `stimulusMediaKey()`. An absent key means nothing spent. */
-    entries: Record<string, MediaPlayLedgerEntry>;
-    /** ISO 8601, when the caller supplies one. The SDK reads no clock. */
-    savedAt?: string;
+  ledgerVersion: '1.0';
+  /** The `planHash` of the paper these counts were spent on. */
+  planHash: string;
+  /** Keyed by `slotMediaKey()` / `stimulusMediaKey()`. An absent key means nothing spent. */
+  entries: Record<string, MediaPlayLedgerEntry>;
+  /** ISO 8601, when the caller supplies one. The SDK reads no clock. */
+  savedAt?: string;
 }
 /**
  * What the SDK asks the consumer to record, before a sample of audio is
@@ -1178,28 +1374,29 @@ interface MediaPlayLedger {
  * seeded at 0 both claim 1, and only an atomic write can tell them apart.
  */
 interface MediaPlayClaim {
-    /** `slot:…` / `stimulus:…`. */
-    key: string;
-    /** The count the client believes was already spent — the value to compare against. */
-    previousPlaysUsed: number;
-    /** The count the client is claiming: `previousPlaysUsed + 1`. */
-    playsUsed: number;
-    maxPlays: number;
-    playsRemaining: number;
-    /** Where the learner stood when the claim was made. Forensics; never identity. */
-    slotId: string;
-    index: number;
-    activityId?: string;
+  /** `slot:…` / `stimulus:…`. */
+  key: string;
+  /** The count the client believes was already spent — the value to compare against. */
+  previousPlaysUsed: number;
+  /** The count the client is claiming: `previousPlaysUsed + 1`. */
+  playsUsed: number;
+  maxPlays: number;
+  playsRemaining: number;
+  /** Where the learner stood when the claim was made. Forensics; never identity. */
+  slotId: string;
+  index: number;
+  activityId?: string;
 }
 /** The consumer's authoritative answer to a {@link MediaPlayClaim}. */
 interface MediaPlayGrant {
-    /**
-     * The count AFTER the server's atomic write. A value greater than
-     * `maxPlays` refuses the play — which is how a second tab is caught.
-     */
-    playsUsed: number;
+  /**
+   * The count AFTER the server's atomic write. A value greater than
+   * `maxPlays` refuses the play — which is how a second tab is caught.
+   */
+  playsUsed: number;
 }
-
+//#endregion
+//#region src/media-budget.d.ts
 /**
  * The authored-entry prefix of a slot id: `"3"` for both `"3"` and `"3.1"`.
  *
@@ -1207,9 +1404,9 @@ interface MediaPlayGrant {
  * `keyOf` rejects a `.` in both an entry key and an item key — so the first
  * `.` is always the group/item separator.
  */
-declare function entryKeyOf(slotId: string): string;
+export declare function entryKeyOf(slotId: string): string;
 /** Budget key for an activity's OWN `data.media`. One budget per slot. */
-declare function slotMediaKey(slotId: string): string;
+export declare function slotMediaKey(slotId: string): string;
 /**
  * Budget key for an item group's `stimulus.media`.
  *
@@ -1219,15 +1416,15 @@ declare function slotMediaKey(slotId: string): string;
  * `stimulus.id` would collide across papers, which is the thing slot keys and
  * `planHash` exist to prevent.
  */
-declare function stimulusMediaKey(slotId: string): string;
+export declare function stimulusMediaKey(slotId: string): string;
 /** A playback policy with every default resolved. One derivation, used everywhere. */
-interface ResolvedPlaybackPolicy {
-    controls: 'native' | 'minimal';
-    /** `null` when the recording is unbudgeted. */
-    maxPlays: number | null;
-    seek: 'allow' | 'none';
-    rate: 'allow' | 'fixed';
-    nativeControlHints: readonly NativeControlHint[];
+export interface ResolvedPlaybackPolicy {
+  controls: 'native' | 'minimal';
+  /** `null` when the recording is unbudgeted. */
+  maxPlays: number | null;
+  seek: 'allow' | 'none';
+  rate: 'allow' | 'fixed';
+  nativeControlHints: readonly NativeControlHint[];
 }
 /**
  * Resolves the defaults once, so the schema refinements, the plan and the
@@ -1236,7 +1433,7 @@ interface ResolvedPlaybackPolicy {
  * Absent `playback` resolves to exactly the SDK's pre-0.8.0 behaviour:
  * `controls: 'native'`, no budget, free seeking, free speed, no hints.
  */
-declare function resolvePlaybackPolicy(media: ActivityMedia): ResolvedPlaybackPolicy;
+export declare function resolvePlaybackPolicy(media: ActivityMedia): ResolvedPlaybackPolicy;
 /**
  * Every budgeted recording a plan contains: budget key → the `maxPlays` that
  * was frozen when the attempt was planned.
@@ -1244,7 +1441,7 @@ declare function resolvePlaybackPolicy(media: ActivityMedia): ResolvedPlaybackPo
  * Use it to build the storage rows an attempt needs, and to check a stored
  * ledger against the paper it claims to belong to.
  */
-declare function planMediaBudgets(plan: AttemptPlan): Record<string, number>;
+export declare function planMediaBudgets(plan: AttemptPlan): Record<string, number>;
 /**
  * Validates a set of spent-play counts against the plan that budgeted them,
  * and stamps the envelope.
@@ -1256,8 +1453,8 @@ declare function planMediaBudgets(plan: AttemptPlan): Record<string, number>;
  * @throws Error when a key is not budgeted by the plan, or a count is not a
  *         non-negative integer, or a position is not a finite number.
  */
-declare function serializeMediaPlayLedger(plan: AttemptPlan, entries: Readonly<Record<string, MediaPlayLedgerEntry>>, options?: {
-    savedAt?: string;
+export declare function serializeMediaPlayLedger(plan: AttemptPlan, entries: Readonly<Record<string, MediaPlayLedgerEntry>>, options?: {
+  savedAt?: string;
 }): MediaPlayLedger;
 /**
  * Reopens a stored ledger against the paper it was spent on.
@@ -1271,8 +1468,9 @@ declare function serializeMediaPlayLedger(plan: AttemptPlan, entries: Readonly<R
  * @throws Error on an unrecognised `ledgerVersion`, a `planHash` mismatch, or
  *         anything `serializeMediaPlayLedger` refuses.
  */
-declare function restoreMediaPlayLedger(plan: AttemptPlan, stored: MediaPlayLedger): MediaPlayLedger;
-
+export declare function restoreMediaPlayLedger(plan: AttemptPlan, stored: MediaPlayLedger): MediaPlayLedger;
+//#endregion
+//#region src/standard-schema.d.ts
 /**
  * Standard Schema v1 (https://standardschema.dev): the interface zod, valibot,
  * ArkType and other validators implement, so a library can accept a schema from
@@ -1285,68 +1483,85 @@ declare function restoreMediaPlayLedger(plan: AttemptPlan, stored: MediaPlayLedg
  */
 /** A schema that validates unknown input and produces `Output`. */
 interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
 }
 declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
-    interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
-        readonly version: 1;
-        /** The vendor name of the schema library. */
-        readonly vendor: string;
-        /**
-         * Validates unknown input values. lk-core validates synchronously, so a
-         * schema whose validation returns a Promise is refused when it is read.
-         */
-        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
-        /** Inferred types associated with the schema. */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /** The result interface of the validate function. */
-    type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
-    interface SuccessResult<Output> {
-        /** The typed output value. */
-        readonly value: Output;
-        /** The absence of issues indicates success. */
-        readonly issues?: undefined;
-    }
-    /** Options for the validate function. */
-    interface Options {
-        /** Implicit support for additional vendor-specific parameters, if needed. */
-        readonly libraryOptions?: Record<string, unknown> | undefined;
-    }
-    /** The result interface if validation fails. */
-    interface FailureResult {
-        /** The issues of failed validation. */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /** The issue interface of the failure output. */
-    interface Issue {
-        /** The error message of the issue. */
-        readonly message: string;
-        /** The path of the issue, if any. */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /** The path segment interface of the issue. */
-    interface PathSegment {
-        /** The key representing a path segment. */
-        readonly key: PropertyKey;
-    }
-    /** The Standard Schema types interface. */
-    interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /** Infers the input type of a Standard Schema. */
-    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-    /** Infers the output type of a Standard Schema. */
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /**
+     * Validates unknown input values. lk-core validates synchronously, so a
+     * schema whose validation returns a Promise is refused when it is read.
+     */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The absence of issues indicates success. */
+    readonly issues?: undefined;
+  }
+  /** Options for the validate function. */
+  interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
 }
-
+//#endregion
+//#region src/registry/define.d.ts
+/**
+ * Identity helper that gives full type inference when authoring a descriptor:
+ *
+ * ```ts
+ * const myType = defineActivityType<MyTypeData, MyTypeLearnerResponse>({ ... });
+ * registerActivityType(myType);
+ * ```
+ *
+ * In a module of its own so the SDK's built-in descriptors can use it without
+ * importing the registry they are read into.
+ */
+export declare function defineActivityType<TData extends {
+  type: string;
+}, TResponse>(descriptor: ActivityTypeDescriptor<TData, TResponse>): ActivityTypeDescriptor<TData, TResponse>;
+//#endregion
+//#region src/registry/registry.d.ts
 /** ScoringResult without `passed` — the public `score()` / `evaluate()` fill that in. */
 type PartialScoringResult = Omit<ScoringResult, 'passed'>;
 /**
@@ -1369,18 +1584,18 @@ type Sensitivity = 'public' | 'answer-key' | 'author-only';
  * without classifying it hides it, never leaks it.
  */
 interface FieldPolicy {
-    readonly [field: string]: Sensitivity | FieldPolicy;
+  readonly [field: string]: Sensitivity | FieldPolicy;
 }
 /** xAPI interaction types defined by xAPI 1.0.3 (cmi.interaction vocabulary). */
 type XAPIInteractionType = 'choice' | 'fill-in' | 'long-fill-in' | 'matching' | 'sequencing' | 'performance' | 'true-false' | 'other';
 /** Interop facts a generic statement builder cannot infer from data alone. */
 interface ActivityTypeInterop<TData> {
-    /** IRI for the xAPI Activity `definition.type`. */
-    readonly xapiActivityTypeIri?: string;
-    /** xAPI `definition.interactionType` for this activity type. */
-    readonly xapiInteractionType?: XAPIInteractionType;
-    /** Builds the xAPI `correctResponsesPattern` strings for an item. */
-    readonly correctResponsesPattern?: (data: TData) => string[];
+  /** IRI for the xAPI Activity `definition.type`. */
+  readonly xapiActivityTypeIri?: string;
+  /** xAPI `definition.interactionType` for this activity type. */
+  readonly xapiInteractionType?: XAPIInteractionType;
+  /** Builds the xAPI `correctResponsesPattern` strings for an item. */
+  readonly correctResponsesPattern?: (data: TData) => string[];
 }
 /**
  * How responses to an activity type are graded:
@@ -1390,12 +1605,12 @@ interface ActivityTypeInterop<TData> {
  *   (e.g. word counts), surfaced in `ItemOutcome.partial`.
  */
 type ActivityTypeScoring<TData, TResponse> = {
-    readonly kind: 'sync';
-    readonly score: (data: TData, response: TResponse) => PartialScoringResult;
+  readonly kind: 'sync';
+  readonly score: (data: TData, response: TResponse) => PartialScoringResult;
 } | {
-    readonly kind: 'deferred';
-    readonly reason: 'requires_async_grading';
-    readonly partial?: (data: TData, response: TResponse | undefined) => DeferredScoringPartial;
+  readonly kind: 'deferred';
+  readonly reason: 'requires_async_grading';
+  readonly partial?: (data: TData, response: TResponse | undefined) => DeferredScoringPartial;
 };
 /**
  * Authoring support for an activity type: the empty draft an editor starts
@@ -1405,34 +1620,47 @@ type ActivityTypeScoring<TData, TResponse> = {
  * `createDraft()` throws for the type.
  */
 interface ActivityTypeAuthoring<TData> {
-    /**
-     * A new draft: every required field present, nothing authored yet. It must
-     * come back from `validateDraft` as `incomplete` — never `invalid`, and never
-     * `complete` — so a freshly added question is not reported as an error, and
-     * cannot pass validation before anyone has written it.
-     */
-    readonly createDraft?: (context: DraftContext) => TData;
-    /**
-     * Reports what is missing (`incomplete`) and what is wrong (`invalid`) in a
-     * draft. Receives any plain object and must not throw on one.
-     *
-     * Report each problem at the path the schema reports it. `validateDraft` adds
-     * every schema failure as `invalid` unless an issue returned here sits at that
-     * path or inside it — so an issue at the wrong path leaves the schema's
-     * message standing beside yours, and makes an unfinished draft read as wrong.
-     * An issue inside a path accounts for every failure at that path, a list's
-     * length included, so report a rule about a whole list at the list's own path.
-     * A failure at the root of the draft is accounted for only by an issue at the
-     * root. A `null` the schema refuses, where nothing here reports it, comes back
-     * as `null_not_allowed`. A zod 4 schema tells a refused `null` from a rule of
-     * yours that merely points at one, which keeps its own code; a schema from
-     * another library cannot, so report such a rule here, at its path.
-     *
-     * A code documented in `docs/authoring.md` is reported with its documented
-     * severity. For a code of your own, a severity other than `'incomplete'` is
-     * reported as `invalid`.
-     */
-    readonly checkDraft?: (draft: Readonly<Record<string, unknown>>) => DraftIssue[];
+  /**
+   * A new draft: every required field present, nothing authored yet. It must
+   * come back from `validateDraft` as `incomplete` — never `invalid`, and never
+   * `complete` — so a freshly added question is not reported as an error, and
+   * cannot pass validation before anyone has written it.
+   */
+  readonly createDraft?: (context: DraftContext) => TData;
+  /**
+   * Reports what is missing (`incomplete`) and what is wrong (`invalid`) in a
+   * draft. Receives any plain object and must not throw on one.
+   *
+   * Report each problem at the path the schema reports it. `validateDraft` adds
+   * every schema failure as `invalid` unless an issue returned here sits at that
+   * path or inside it — so an issue at the wrong path leaves the schema's
+   * message standing beside yours, and makes an unfinished draft read as wrong.
+   * An issue inside a path accounts for every failure at that path, a list's
+   * length included, so report a rule about a whole list at the list's own path.
+   * A failure at the root of the draft is accounted for only by an issue at the
+   * root. A `null` the schema refuses, where nothing here reports it, comes back
+   * as `null_not_allowed`. A zod 4 schema tells a refused `null` from a rule of
+   * yours that merely points at one, which keeps its own code; a schema from
+   * another library cannot, so report such a rule here, at its path.
+   *
+   * A code documented in `docs/authoring.md` is reported with its documented
+   * severity. For a code of your own, a severity other than `'incomplete'` is
+   * reported as `invalid`.
+   */
+  readonly checkDraft?: (draft: Readonly<Record<string, unknown>>) => DraftIssue[];
+  /**
+   * The item critic for the type: what `critiqueDraft` reports about a draft
+   * that may be perfectly valid — a flaw a learner can exploit (`warning`), or
+   * an item-writing guideline it departs from (`advice`). Receives any plain
+   * object, finished or not, and must not throw on one: skip a rule whose
+   * fields are not there yet. Never a reason to refuse the item; that is
+   * `checkDraft`'s.
+   *
+   * A code documented in `docs/authoring.md` is reported with its documented
+   * severity. For a code of your own, a severity other than `'advice'` is
+   * reported as `warning`.
+   */
+  readonly critique?: (draft: Readonly<Record<string, unknown>>) => ItemFinding[];
 }
 /**
  * A value-level description of an activity type: its contract (schema), its
@@ -1455,77 +1683,66 @@ interface ActivityTypeAuthoring<TData> {
  * ```
  */
 interface ActivityTypeDescriptor<TData extends {
-    type: string;
+  type: string;
 }, TResponse> {
-    /** The `type` discriminator string (kebab-case by convention). */
-    readonly type: TData['type'];
-    /**
-     * The activity's data contract, as a Standard Schema whose output is the
-     * data. Its validation must be synchronous: every entry point that reads it
-     * is.
-     */
-    readonly schema: StandardSchemaV1<unknown, TData>;
-    /**
-     * The contract as JSON Schema, for `jsonSchemaFor`. Leave it out when
-     * `schema` can produce one itself through the Standard JSON Schema converter
-     * (`'~standard'.jsonSchema`), as a zod 4.6 schema can; give it to override
-     * that, or for a library that cannot.
-     */
-    readonly jsonSchema?: Readonly<Record<string, unknown>>;
-    /** How responses are graded. */
-    readonly scoring: ActivityTypeScoring<TData, TResponse>;
-    /** Whether a response counts as an answer (vs. blank/untouched). */
-    readonly isAnswered?: (response: TResponse | undefined) => boolean;
-    /** Per-field sensitivity map driving `redact()`. Fail-closed. */
-    readonly fieldPolicy?: FieldPolicy;
-    /**
-     * Schema the output of `redact(data)` (with default `reveal: 'none'`) must
-     * satisfy, as a Standard Schema. Strict by design: it proves the ABSENCE of
-     * answer-key fields, so `assertRedacted` can guarantee a payload is safe to
-     * send to a learner.
-     */
-    readonly redactedSchema?: StandardSchemaV1;
-    /** Interop facts for xAPI (and later QTI) statement building. */
-    readonly interop?: ActivityTypeInterop<TData>;
-    /** The interaction-event kinds components for this type emit. */
-    readonly interactions?: readonly string[];
-    /** Draft support for authoring tools. See {@link ActivityTypeAuthoring}. */
-    readonly authoring?: ActivityTypeAuthoring<TData>;
+  /** The `type` discriminator string (kebab-case by convention). */
+  readonly type: TData['type'];
+  /**
+   * The activity's data contract, as a Standard Schema whose output is the
+   * data. Its validation must be synchronous: every entry point that reads it
+   * is.
+   */
+  readonly schema: StandardSchemaV1<unknown, TData>;
+  /**
+   * The contract as JSON Schema, for `jsonSchemaFor`. Leave it out when
+   * `schema` can produce one itself through the Standard JSON Schema converter
+   * (`'~standard'.jsonSchema`), as a zod 4.6 schema can; give it to override
+   * that, or for a library that cannot.
+   */
+  readonly jsonSchema?: Readonly<Record<string, unknown>>;
+  /** How responses are graded. */
+  readonly scoring: ActivityTypeScoring<TData, TResponse>;
+  /** Whether a response counts as an answer (vs. blank/untouched). */
+  readonly isAnswered?: (response: TResponse | undefined) => boolean;
+  /** Per-field sensitivity map driving `redact()`. Fail-closed. */
+  readonly fieldPolicy?: FieldPolicy;
+  /**
+   * Schema the output of `redact(data)` (with default `reveal: 'none'`) must
+   * satisfy, as a Standard Schema. Strict by design: it proves the ABSENCE of
+   * answer-key fields, so `assertRedacted` can guarantee a payload is safe to
+   * send to a learner.
+   */
+  readonly redactedSchema?: StandardSchemaV1;
+  /** Interop facts for xAPI (and later QTI) statement building. */
+  readonly interop?: ActivityTypeInterop<TData>;
+  /** The interaction-event kinds components for this type emit. */
+  readonly interactions?: readonly string[];
+  /** Draft support for authoring tools. See {@link ActivityTypeAuthoring}. */
+  readonly authoring?: ActivityTypeAuthoring<TData>;
 }
 /**
  * Internal type-erased descriptor shape stored in the registry. Dispatch call
  * sites cast payloads back; the public generic API preserves inference.
  */
 interface RegisteredActivityTypeDescriptor {
-    readonly type: string;
-    readonly schema: StandardSchemaV1;
-    readonly jsonSchema?: Readonly<Record<string, unknown>>;
-    readonly scoring: {
-        readonly kind: 'sync';
-        readonly score: (data: unknown, response: unknown) => PartialScoringResult;
-    } | {
-        readonly kind: 'deferred';
-        readonly reason: 'requires_async_grading';
-        readonly partial?: (data: unknown, response: unknown) => DeferredScoringPartial;
-    };
-    readonly isAnswered?: (response: unknown) => boolean;
-    readonly fieldPolicy?: FieldPolicy;
-    readonly redactedSchema?: StandardSchemaV1;
-    readonly interop?: ActivityTypeInterop<unknown>;
-    readonly interactions?: readonly string[];
-    readonly authoring?: ActivityTypeAuthoring<unknown>;
+  readonly type: string;
+  readonly schema: StandardSchemaV1;
+  readonly jsonSchema?: Readonly<Record<string, unknown>>;
+  readonly scoring: {
+    readonly kind: 'sync';
+    readonly score: (data: unknown, response: unknown) => PartialScoringResult;
+  } | {
+    readonly kind: 'deferred';
+    readonly reason: 'requires_async_grading';
+    readonly partial?: (data: unknown, response: unknown) => DeferredScoringPartial;
+  };
+  readonly isAnswered?: (response: unknown) => boolean;
+  readonly fieldPolicy?: FieldPolicy;
+  readonly redactedSchema?: StandardSchemaV1;
+  readonly interop?: ActivityTypeInterop<unknown>;
+  readonly interactions?: readonly string[];
+  readonly authoring?: ActivityTypeAuthoring<unknown>;
 }
-/**
- * Identity helper that gives full type inference when authoring a descriptor:
- *
- * ```ts
- * const myType = defineActivityType<MyTypeData, MyTypeLearnerResponse>({ ... });
- * registerActivityType(myType);
- * ```
- */
-declare function defineActivityType<TData extends {
-    type: string;
-}, TResponse>(descriptor: ActivityTypeDescriptor<TData, TResponse>): ActivityTypeDescriptor<TData, TResponse>;
 /**
  * Registers an activity type on the default registry, making it live for
  * `validateActivity`, `score`, `evaluate`, `redact`, and `jsonSchemaFor`.
@@ -1534,14 +1751,15 @@ declare function defineActivityType<TData extends {
  * type's contract or scoring is exactly the class of accident a summative
  * SDK must not allow.
  */
-declare function registerActivityType<TData extends {
-    type: string;
+export declare function registerActivityType<TData extends {
+  type: string;
 }, TResponse>(descriptor: ActivityTypeDescriptor<TData, TResponse>): void;
 /** Returns the registered descriptor for `type`, or `undefined`. */
-declare function getActivityTypeDescriptor(type: string): RegisteredActivityTypeDescriptor | undefined;
+export declare function getActivityTypeDescriptor(type: string): RegisteredActivityTypeDescriptor | undefined;
 /** The type strings currently registered (built-ins plus consumer-registered). */
-declare function registeredActivityTypes(): string[];
-
+export declare function registeredActivityTypes(): string[];
+//#endregion
+//#region src/redact.d.ts
 /**
  * A learner-safe projection of activity data produced by {@link redact}:
  * the activity's public fields plus the `redacted: true` marker. Renderable
@@ -1549,49 +1767,49 @@ declare function registeredActivityTypes(): string[];
  * but stripped of the answer key, scoring rules, authored feedback, and
  * author-only assets.
  */
-interface RedactedActivityData {
-    redacted: true;
-    schemaVersion: string;
-    type: string;
-    id: string;
-    title: string;
-    [key: string]: unknown;
+export interface RedactedActivityData {
+  redacted: true;
+  schemaVersion: string;
+  type: string;
+  id: string;
+  title: string;
+  [key: string]: unknown;
 }
 /** Options for {@link redact}. */
-interface RedactOptions {
-    /**
-     * Which sensitivity tiers to keep beyond `public`:
-     * - `'none'` (default) — public fields only; the output satisfies the
-     *   type's strict redacted schema and `assertRedacted`.
-     * - `'after-submit'` — public + answer-key fields (for post-submission
-     *   review renders). `author-only` fields and unclassified fields are
-     *   STILL removed; the output will NOT pass `assertRedacted`.
-     */
-    reveal?: 'none' | 'after-submit';
-    /**
-     * Per-call sensitivity overrides, merged over the type's registered
-     * `fieldPolicy` (top-level keys replace; nested objects merge one level).
-     *
-     * Sensitivity is partly a PEDAGOGICAL decision, not purely a security one —
-     * whether a rubric or a hint is learner-visible differs legitimately between
-     * deployments — and the SDK must not freeze that choice. Use this to tighten
-     * a field the SDK ships as `public`:
-     *
-     * ```ts
-     * redact(essay, { policy: { rubric: 'author-only' } });
-     * ```
-     *
-     * Overrides can only be applied to fields; they cannot re-open a field the
-     * caller has not classified, because unclassified still means removed.
-     * What can be tightened is a field the type's `redactedSchema` leaves
-     * OPTIONAL, as it leaves the rubric above: the schema check rejects a
-     * payload that reveals more than the learner-safe shape, and equally one
-     * that is missing part of it. Tightening a field the redacted shape requires
-     * — a read-aloud item's `scoring`, `recording`, `referenceText` or `locale`,
-     * without which the learner has no item to read — throws
-     * {@link ActivitySchemaError} instead of hiding it.
-     */
-    policy?: FieldPolicy;
+export interface RedactOptions {
+  /**
+   * Which sensitivity tiers to keep beyond `public`:
+   * - `'none'` (default) — public fields only; the output satisfies the
+   *   type's strict redacted schema and `assertRedacted`.
+   * - `'after-submit'` — public + answer-key fields (for post-submission
+   *   review renders). `author-only` fields and unclassified fields are
+   *   STILL removed; the output will NOT pass `assertRedacted`.
+   */
+  reveal?: 'none' | 'after-submit';
+  /**
+   * Per-call sensitivity overrides, merged over the type's registered
+   * `fieldPolicy` (top-level keys replace; nested objects merge one level).
+   *
+   * Sensitivity is partly a PEDAGOGICAL decision, not purely a security one —
+   * whether a rubric or a hint is learner-visible differs legitimately between
+   * deployments — and the SDK must not freeze that choice. Use this to tighten
+   * a field the SDK ships as `public`:
+   *
+   * ```ts
+   * redact(essay, { policy: { rubric: 'author-only' } });
+   * ```
+   *
+   * Overrides can only be applied to fields; they cannot re-open a field the
+   * caller has not classified, because unclassified still means removed.
+   * What can be tightened is a field the type's `redactedSchema` leaves
+   * OPTIONAL, as it leaves the rubric above: the schema check rejects a
+   * payload that reveals more than the learner-safe shape, and equally one
+   * that is missing part of it. Tightening a field the redacted shape requires
+   * — a read-aloud item's `scoring`, `recording`, `referenceText` or `locale`,
+   * without which the learner has no item to read — throws
+   * {@link ActivitySchemaError} instead of hiding it.
+   */
+  policy?: FieldPolicy;
 }
 /**
  * Produces the learner-safe projection of activity data (R7), driven by the
@@ -1608,8 +1826,8 @@ interface RedactOptions {
  * @throws Error when the registered descriptor declares no `fieldPolicy`
  *         (redaction cannot guess sensitivities).
  */
-declare function redact<T extends {
-    type: string;
+export declare function redact<T extends {
+  type: string;
 }>(data: T, options?: RedactOptions): RedactedActivityData;
 /**
  * Asserts that `data` is a learner-safe redacted projection: it carries the
@@ -1618,10 +1836,10 @@ declare function redact<T extends {
  * Use this at the server boundary before sending activity data to a client
  * that must not hold the key.
  */
-declare function assertRedacted(data: unknown): asserts data is RedactedActivityData;
+export declare function assertRedacted(data: unknown): asserts data is RedactedActivityData;
 /** A learner-safe item group: the container with its marker, holding `redact()` projections. */
-type RedactedItemGroup = ItemGroup<RedactedActivityData> & {
-    redacted: true;
+export type RedactedItemGroup = ItemGroup<RedactedActivityData> & {
+  redacted: true;
 };
 /**
  * Produces the learner-safe projection of an item group: the container and
@@ -1633,8 +1851,8 @@ type RedactedItemGroup = ItemGroup<RedactedActivityData> & {
  * With the default `reveal: 'none'` the container is verified against the
  * strict redacted schema; each item was already verified by `redact`.
  */
-declare function redactItemGroup<TItem extends {
-    type: string;
+export declare function redactItemGroup<TItem extends {
+  type: string;
 }>(group: ItemGroup<TItem>, options?: RedactOptions): RedactedItemGroup;
 /**
  * Asserts that `data` is a learner-safe item group: it carries the marker,
@@ -1644,12 +1862,13 @@ declare function redactItemGroup<TItem extends {
  * failures are reported at `items.<index>.…`. Use it at the server boundary
  * before sending a group to a client that must not hold the key.
  */
-declare function assertRedactedItemGroup(data: unknown): asserts data is RedactedItemGroup;
-
+export declare function assertRedactedItemGroup(data: unknown): asserts data is RedactedItemGroup;
+//#endregion
+//#region src/registry/builtins.d.ts
 /** Built-in Multiple Choice descriptor. */
-declare const multipleChoiceType: ActivityTypeDescriptor<MultipleChoiceData, MultipleChoiceLearnerResponse>;
+export declare const multipleChoiceType: ActivityTypeDescriptor<MultipleChoiceData, MultipleChoiceLearnerResponse>;
 /** Built-in Fill-in-the-Blanks descriptor. */
-declare const fillInTheBlanksType: ActivityTypeDescriptor<FillInTheBlanksData, FillInTheBlanksLearnerResponse>;
+export declare const fillInTheBlanksType: ActivityTypeDescriptor<FillInTheBlanksData, FillInTheBlanksLearnerResponse>;
 /**
  * Built-in Written Response descriptor. Grading is DEFERRED: submissions are
  * graded asynchronously (AI or human) by the consumer; the synchronous
@@ -1657,23 +1876,24 @@ declare const fillInTheBlanksType: ActivityTypeDescriptor<FillInTheBlanksData, F
  * submitted text with the canonical `countWords()` — the client-supplied
  * count is informational, never trusted.
  */
-declare const writtenResponseType: ActivityTypeDescriptor<WrittenResponseData, WrittenResponseLearnerResponse>;
+export declare const writtenResponseType: ActivityTypeDescriptor<WrittenResponseData, WrittenResponseLearnerResponse>;
 /** Built-in Gap Select descriptor. */
-declare const gapSelectType: ActivityTypeDescriptor<GapSelectData, GapSelectLearnerResponse>;
+export declare const gapSelectType: ActivityTypeDescriptor<GapSelectData, GapSelectLearnerResponse>;
 /**
  * Built-in Dictation descriptor. Graded synchronously: the score is the
  * character-level similarity of the typed text to the transcript, a pure
  * computation identical in a browser and on a server.
  */
-declare const dictationType: ActivityTypeDescriptor<DictationData, DictationLearnerResponse>;
+export declare const dictationType: ActivityTypeDescriptor<DictationData, DictationLearnerResponse>;
 /**
  * Built-in Read Aloud descriptor. Grading is DEFERRED: the SDK calls no
  * assessor, so the synchronous outcome reports only whether a recording was
  * stored, and `gradeReadAloud` produces the grade once the application holds a
  * speech assessment.
  */
-declare const readAloudType: ActivityTypeDescriptor<ReadAloudData, ReadAloudLearnerResponse>;
-
+export declare const readAloudType: ActivityTypeDescriptor<ReadAloudData, ReadAloudLearnerResponse>;
+//#endregion
+//#region src/shuffle.d.ts
 /**
  * Seeded, deterministic shuffling — the ONE algorithm every presentation-order
  * decision in the SDK goes through: option order in a multiple-choice item,
@@ -1688,7 +1908,7 @@ declare const readAloudType: ActivityTypeDescriptor<ReadAloudData, ReadAloudLear
  * permutation test exists so an accidental one fails loudly.
  */
 /** FNV-1a hash of a string → unsigned 32-bit integer. */
-declare function hashSeed(input: string): number;
+export declare function hashSeed(input: string): number;
 /**
  * Which draw the Fisher–Yates step uses.
  *
@@ -1720,11 +1940,16 @@ declare function hashSeed(input: string): number;
  * is a package major — scheduled, not smuggled in. Choose v2 for new content
  * where no attempt has been recorded yet.
  */
-type ShuffleVersion = 1 | 2;
+export type ShuffleVersion = 1 | 2;
 /** Options for {@link seededShuffle}. */
-interface SeededShuffleOptions {
-    /** Draw algorithm. Defaults to `1` — see {@link ShuffleVersion}. */
-    version?: ShuffleVersion;
+export interface SeededShuffleOptions {
+  /**
+   * Draw algorithm — see {@link ShuffleVersion}. Left out, it is `1`; leaving
+   * it out is deprecated since lk-core 1.3, since a 2.0 may make `2` the
+   * default. Name it: `1` to reproduce an order already recorded, `2` for new
+   * content.
+   */
+  version?: ShuffleVersion;
 }
 /**
  * Returns a new array holding a permutation of `items` determined entirely by
@@ -1735,8 +1960,17 @@ interface SeededShuffleOptions {
  * (`${attemptId}:${itemId}`), so two shuffles in one attempt do not share an
  * order.
  */
-declare function seededShuffle<T>(items: readonly T[], seed: string, options?: SeededShuffleOptions): T[];
-
+export declare function seededShuffle<T>(items: readonly T[], seed: string, options: SeededShuffleOptions & {
+  version: ShuffleVersion;
+}): T[];
+/**
+ * @deprecated Since lk-core 1.3, name the version: `{ version: 1 }` draws
+ * exactly what this does, `{ version: 2 }` reaches every order. A 2.0 may make
+ * `2` the default, which would re-order what this call returns.
+ */
+export declare function seededShuffle<T>(items: readonly T[], seed: string, options?: SeededShuffleOptions): T[];
+//#endregion
+//#region src/timeline.d.ts
 /**
  * Reads a stored {@link MediaProgress}. Never throws: anything that is not one
  * — a string, a stale shape, an object whose getters throw — answers `null`,
@@ -1748,7 +1982,7 @@ declare function seededShuffle<T>(items: readonly T[], seed: string, options?: S
  * re-cut must not put the playhead somewhere it cannot be. Give `duration`
  * once the video's metadata is known, and both positions are held inside it.
  */
-declare function readMediaProgress(value: unknown, duration?: number): MediaProgress | null;
+export declare function readMediaProgress(value: unknown, duration?: number): MediaProgress | null;
 /**
  * One interactive video's composed result: the scored items whose slot belongs
  * to the entry, composed as one section of weight 1. A slot belongs when
@@ -1763,8 +1997,9 @@ declare function readMediaProgress(value: unknown, duration?: number): MediaProg
  *         otherwise compose nothing into a `final` result, and a refusal must
  *         never read as a grade.
  */
-declare function composeTimelineScore(entryKey: string, items: readonly ScoredItem[], policy: CompositionPolicy): AssessmentScore;
-
+export declare function composeTimelineScore(entryKey: string, items: readonly ScoredItem[], policy: CompositionPolicy): AssessmentScore;
+//#endregion
+//#region src/timeline-limits.d.ts
 /**
  * The bounds of an interactive video — an item group with a `timeline`.
  *
@@ -1778,78 +2013,80 @@ declare function composeTimelineScore(entryKey: string, items: readonly ScoredIt
  * a read-aloud's microphone included, because every quiz pauses the video
  * first.
  */
-declare const INTERACTIVE_VIDEO_ITEM_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "gap-select", "dictation", "read-aloud"];
+export declare const INTERACTIVE_VIDEO_ITEM_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "gap-select", "dictation", "read-aloud"];
 /** One of {@link INTERACTIVE_VIDEO_ITEM_TYPES}. */
-type InteractiveVideoItemType = (typeof INTERACTIVE_VIDEO_ITEM_TYPES)[number];
+export type InteractiveVideoItemType = (typeof INTERACTIVE_VIDEO_ITEM_TYPES)[number];
 /** Whether `type` is one of the item types an interactive video may present. */
-declare function isInteractiveVideoItemType(type: unknown): type is InteractiveVideoItemType;
+export declare function isInteractiveVideoItemType(type: unknown): type is InteractiveVideoItemType;
 /** The most quizzes one video may hold. */
-declare const TIMELINE_MAX_QUIZZES = 100;
+export declare const TIMELINE_MAX_QUIZZES = 100;
 /**
  * The most questions one interactive video may hold, across all its quizzes.
  * The player keeps every one of them mounted, so an answer survives the
  * learner rewinding past its quiz.
  */
-declare const TIMELINE_MAX_ITEMS = 200;
+export declare const TIMELINE_MAX_ITEMS = 200;
 /** The most chapters one video may hold. */
-declare const TIMELINE_MAX_CHAPTERS = 100;
+export declare const TIMELINE_MAX_CHAPTERS = 100;
 /** The longest quiz or chapter title, in UTF-16 units. A title sits on one line of the player. */
-declare const TIMELINE_MAX_TITLE_LENGTH = 120;
-
+export declare const TIMELINE_MAX_TITLE_LENGTH = 120;
+//#endregion
+//#region src/types/theme.d.ts
 /**
  * All CSS custom property tokens consumed by learning-kit components.
  * Every key maps to a `--lk-*` CSS variable name; every value is a CSS value string.
  * Pass a `Partial<ThemeTokens>` to `ThemeProvider` to override individual tokens.
  */
 interface ThemeTokens {
-    '--lk-color-primary': string;
-    '--lk-color-primary-hover': string;
-    '--lk-color-surface': string;
-    '--lk-color-surface-raised': string;
-    '--lk-color-border': string;
-    '--lk-color-text': string;
-    '--lk-color-text-muted': string;
-    '--lk-color-success': string;
-    '--lk-color-error': string;
-    '--lk-color-warning': string;
-    '--lk-color-focus-ring': string;
-    /**
-     * The accent a video player draws on its own dark chrome: the played part
-     * of the progress bar, quiz markers, the centre play button. Optional, so a
-     * theme written before it existed still type-checks; the default is white,
-     * which reads on any video. Set it to a brand colour to match a product.
-     */
-    '--lk-color-media-accent'?: string;
-    /**
-     * The interactive video's drawn captions. Optional like the accent above, so
-     * a theme written before them still type-checks. The primary line's colour;
-     * the second language's colour, which must clear 4.5:1 on the caption box;
-     * the second line's size as a share of the first (a number, e.g. `0.85`);
-     * and the space between the two lines. The second line differs from the
-     * first by position and size as well as colour: colour alone would fail
-     * WCAG 1.4.1.
-     */
-    '--lk-iv-caption-color'?: string;
-    '--lk-iv-caption-secondary-color'?: string;
-    '--lk-iv-caption-secondary-scale'?: string;
-    '--lk-iv-caption-gap'?: string;
-    '--lk-spacing-xs': string;
-    '--lk-spacing-sm': string;
-    '--lk-spacing-md': string;
-    '--lk-spacing-lg': string;
-    '--lk-spacing-xl': string;
-    '--lk-font-family-base': string;
-    '--lk-font-size-sm': string;
-    '--lk-font-size-base': string;
-    '--lk-font-size-lg': string;
-    '--lk-font-weight-normal': string;
-    '--lk-font-weight-bold': string;
-    '--lk-line-height-base': string;
-    '--lk-radius-sm': string;
-    '--lk-radius-base': string;
-    '--lk-radius-lg': string;
-    '--lk-transition-fast': string;
-    '--lk-transition-base': string;
+  '--lk-color-primary': string;
+  '--lk-color-primary-hover': string;
+  '--lk-color-surface': string;
+  '--lk-color-surface-raised': string;
+  '--lk-color-border': string;
+  '--lk-color-text': string;
+  '--lk-color-text-muted': string;
+  '--lk-color-success': string;
+  '--lk-color-error': string;
+  '--lk-color-warning': string;
+  '--lk-color-focus-ring': string;
+  /**
+   * The accent a video player draws on its own dark chrome: the played part
+   * of the progress bar, quiz markers, the centre play button. Optional, so a
+   * theme written before it existed still type-checks; the default is white,
+   * which reads on any video. Set it to a brand colour to match a product.
+   */
+  '--lk-color-media-accent'?: string;
+  /**
+   * The interactive video's drawn captions. Optional like the accent above, so
+   * a theme written before them still type-checks. The primary line's colour;
+   * the second language's colour, which must clear 4.5:1 on the caption box;
+   * the second line's size as a share of the first (a number, e.g. `0.85`);
+   * and the space between the two lines. The second line differs from the
+   * first by position and size as well as colour: colour alone would fail
+   * WCAG 1.4.1.
+   */
+  '--lk-iv-caption-color'?: string;
+  '--lk-iv-caption-secondary-color'?: string;
+  '--lk-iv-caption-secondary-scale'?: string;
+  '--lk-iv-caption-gap'?: string;
+  '--lk-spacing-xs': string;
+  '--lk-spacing-sm': string;
+  '--lk-spacing-md': string;
+  '--lk-spacing-lg': string;
+  '--lk-spacing-xl': string;
+  '--lk-font-family-base': string;
+  '--lk-font-size-sm': string;
+  '--lk-font-size-base': string;
+  '--lk-font-size-lg': string;
+  '--lk-font-weight-normal': string;
+  '--lk-font-weight-bold': string;
+  '--lk-line-height-base': string;
+  '--lk-radius-sm': string;
+  '--lk-radius-base': string;
+  '--lk-radius-lg': string;
+  '--lk-transition-fast': string;
+  '--lk-transition-base': string;
 }
-
-export { AI_COACHING_MAX_TIP_LENGTH, AI_COACHING_MAX_WORDS, AI_EXPLANATION_TYPES, AI_HINT_TYPES, AI_TEXT_MAX_LENGTH, AI_WRITING_MAX_CORRECTIONS, AI_WRITING_MAX_FIELD_LENGTH, ActivityData, ActivityDataMap, ActivityMedia, ActivitySchemaError, ActivityType, type ActivityTypeAuthoring, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, AiActivityInput, AiCoaching, AiCoachingRequest, AiExplanationRequest, AiFeature, AiGrade, AiHintRequest, AiItemFacts, AiRefusal, AiSupportedActivityType, AiTextResult, AiWritingFeedback, AiWritingFeedbackRequest, AssessmentScore, type AttemptPlan, type AttemptPlanDrift, type AttemptPlanSlot, type AttemptProgress, type AttemptState, CompositionPolicy, CriterionScore, DeferredScoringError, DeferredScoringPartial, type DeliveryPolicy, type DeliveryPolicyIssue, DictationData, DictationLearnerResponse, type DraftComplete, type DraftContext, type DraftIssue, type DraftNotComplete, type DraftSeverity, type DraftValidationResult, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, type FlattenSequenceOptions, GapSelectData, GapSelectLearnerResponse, type GradeFromRubricOptions, GradeRecord, INTERACTIVE_VIDEO_ITEM_TYPES, type InteractiveVideoItemType, ItemGroup, ItemOutcome, ItemScoringPolicy, LearnerResponse, type MediaBudgetRef, type MediaPlayClaim, type MediaPlayGrant, type MediaPlayLedger, type MediaPlayLedgerEntry, MediaProgress, type MissingOutcomePolicy, MultipleChoiceData, MultipleChoiceLearnerResponse, NativeControlHint, OPEN_DELIVERY_POLICY, type PartialScoringResult, type PlanAttemptOptions, type PlannableEntry, ReadAloudData, ReadAloudLearnerResponse, type RedactOptions, type RedactedActivityData, type RedactedItemGroup, RedactedScoringError, type RegisteredActivityTypeDescriptor, type ResolvedDeliveryPolicy, ResolvedItemScoringPolicy, type ResolvedPlaybackPolicy, type ResponseDiffEntry, RoundingPolicy, ScoredItem, ScoringDetail, ScoringResult, type SeededShuffleOptions, type Sensitivity, SequenceEntry, SequenceSlot, type ShuffleVersion, SpeechAssessment, StandardSchemaV1, TIMELINE_MAX_CHAPTERS, TIMELINE_MAX_ITEMS, TIMELINE_MAX_QUIZZES, TIMELINE_MAX_TITLE_LENGTH, type ThemeTokens, UnknownActivityTypeError, ValidationError, WrittenResponseData, WrittenResponseLearnerResponse, type XAPIInteractionType, aiAllowedByContent, aiCoachingRequest, aiExplanationRequest, aiGradeOf, aiHintRequest, aiSupports, aiWritingFeedbackRequest, assertRedacted, assertRedactedItemGroup, buildAiFacts, canonicalJson, checkAiCoaching, checkAiExplanation, checkAiHint, checkAiWritingFeedback, combineDeliveryPolicies, composeTimelineScore, contentHash, countWords, createDraft, createInteractiveVideoDraft, createItemGroupDraft, defineActivityType, dictationType, diffResponses, entryKeyOf, fillInTheBlanksType, fingerprint, flattenSequence, gapSelectType, getActivityTypeDescriptor, gradeFromRubric, hasGrade, hashSeed, hintRevealsAnswer, isInteractiveVideoItemType, isItemGroup, multipleChoiceType, outcomeFromGrade, planAttempt, planMediaBudgets, readAiTextResult, readAloudType, readMediaProgress, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolveDeliveryPolicy, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, scoredItemsFromPlan, seededShuffle, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusMediaKey, validateDeliveryPolicy, validateDraft, validateItemGroupDraft, verifyAttemptPlan, writtenResponseType };
+//#endregion
+export { type ActivityAiPermissions, type ActivityData, type ActivityDataMap, type ActivityFeedback, type ActivityMedia, type ActivityResult, type ActivityType, type ActivityTypeAuthoring, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, type AiActivityInput, type AiBlankFact, type AiCoaching, type AiCoachingRequest, type AiCoachingResult, type AiCoachingWord, type AiCriterionJudgement, type AiCritique, type AiCritiqueField, type AiCritiqueFinding, type AiCritiqueFindingResult, type AiCritiqueKind, type AiCritiqueRequest, type AiCritiqueResult, type AiDictationFacts, type AiDraftCaption, type AiDraftProblem, type AiDraftSettings, type AiDraftSource, type AiDraftType, type AiDrafts, type AiDraftsCall, type AiDraftsRequest, type AiDraftsRun, type AiExplanationRequest, type AiFeature, type AiFillInTheBlanksFacts, type AiGapFact, type AiGapSelectFacts, type AiGeneratedDraft, type AiGrade, type AiHintRequest, type AiItemFacts, type AiMultipleChoiceFacts, type AiOptionFact, type AiProvenance, type AiReadingFacts, type AiReadingWordFact, type AiRefusal, type AiRubricCriterionFact, type AiSoundFact, type AiSupportedActivityType, type AiTextResult, type AiVerdict, type AiVideoDraft, type AiWordFact, type AiWritingCorrection, type AiWritingFacts, type AiWritingFeedback, type AiWritingFeedbackRequest, type AiWritingFeedbackResult, type AnsweredStatementParams, type AssessmentScore, type AssessmentSectionInput, type AttemptPlan, type AttemptPlanDrift, type AttemptPlanSlot, type AttemptState, type Band, type BlankConfig, type BuiltInActivityType, type CompletedStatementParams, type CompositionPolicy, type CriterionScore, DEFAULT_ITEM_SCORING_POLICY, DEFAULT_PASS_THRESHOLD, DICTATION_MAX_ACCEPTED_TRANSCRIPTS, DICTATION_MAX_EQUIVALENCES, DICTATION_MAX_EQUIVALENCE_LENGTH, DICTATION_MAX_TEXT_LENGTH, DICTATION_MAX_TRANSCRIPT_LENGTH, type DeferredReason, type DeferredScoringPartial, type DeliveryPolicy, type DeliveryPolicyIssue, type DictationAlignment, type DictationCharOp, type DictationData, type DictationEquivalence, type DictationLearnerResponse, type DictationReference, type DictationSlowMedia, type DictationTolerance, type DictationWordAlignment, type DraftComplete, type DraftContext, type DraftIssue, type DraftNotComplete, type DraftSeverity, type DraftValidationResult, EvaluateOptions, type FieldPolicy, type FillInTheBlanksData, type FillInTheBlanksLearnerResponse, type GapSelectBank, type GapSelectChoice, type GapSelectData, type GapSelectGap, type GapSelectLearnerResponse, type GradeReadAloudOptions, type GradeRecord, type Grader, type GraderKind, type GraderUsage, type GradingState, ITEM_SCORING_MAX_RETRIES, type InlineCorrection, type InteractionEvent, type InteractionKind, type ItemFinding, type ItemFindingSeverity, type ItemGroup, type ItemOutcome, type ItemScoringCount, type ItemScoringPolicy, type ItemScoringPolicyIssue, ItemTriesOutcome, type ItemTriesScore, type ItemTry, type ItemTryScore, type LearnerResponse, type LearnerResponseMap, type MediaBudgetRef, type MediaPlayClaim, type MediaPlayGrant, type MediaPlayLedger, type MediaPlayLedgerEntry, type MediaPlaybackPolicy, type MediaProgress, type MediaTimeline, type MediaTrack, type MultipleChoiceData, type MultipleChoiceLearnerResponse, type MultipleChoiceOption, type MultipleChoiceOptionMedia, type NativeControlHint, type PartialScoringResult, type PassFailureReason, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, type ReadAloudData, type ReadAloudDimension, type ReadAloudDimensionWeight, type ReadAloudLearnerResponse, type ReadAloudSlowMedia, type ReadAloudWordAlignment, type ReadAloudWordState, type RecordingBounds, type RecordingRef, type RedactedActivity, type RedactedBlankConfig, type RedactedDictationData, type RedactedDictationSlowMedia, type RedactedFillInTheBlanksData, type RedactedGapSelectBank, type RedactedGapSelectChoice, type RedactedGapSelectData, type RedactedGapSelectGap, type RedactedMultipleChoiceData, type RedactedMultipleChoiceOption, type RedactedMultipleChoiceOptionMedia, type RedactedReadAloudData, type RedactedStimulus, type RedactedWrittenResponseData, type RegisteredActivityTypeDescriptor, type ResolvedDeliveryPolicy, type ResolvedItemScoringPolicy, type ResponseDiffEntry, type RoundingMode, type RoundingPolicy, SPEECH_ASSESSMENT_MAX_WORDS, type ScoredItem, type ScoringDetail, ScoringOptions, type ScoringOutcome, type ScoringResult, type SectionScore, type Sensitivity, type SequenceEntry, type SequenceSlot, type SequenceSlotGroup, type SpeechAssessment, type SpeechMeasurement, type SpeechPhoneme, type SpeechPhonemeCandidate, type SpeechPlausibilityPolicy, type SpeechSyllable, type SpeechUnscorable, type SpeechUnscorableCode, type SpeechWord, type SpeechWordError, type StandardSchemaV1, type Stimulus, type StimulusKind, type SubmittedStatementParams, type TextMatchPolicy, type TextMatchResult, type ThemeTokens, type TimelineChapter, type TimelineCue, type ValidationError, type ValidationResult, type WavInspection, type WavInspectionPolicy, type WrittenResponseData, type WrittenResponseLearnerResponse, type WrittenResponseRubric, type WrittenResponseRubricCriterion, type XAPIActor, type XAPIConfig, type XAPIContext, type XAPIContextActivities, type XAPIError, type XAPIInteractionType, type XAPIObject, type XAPIObjectParams, type XAPIResult, type XAPIScore, type XAPIStatement, type XAPIStatementParams, XAPIVerb, type XAPIVerbKey, type XAPIVerbObject, XAPI_VERB_DISPLAY, alignDictation, alignReadAloud, classifyBand, composeAssessmentScore, computePassThreshold, dictationJsonSchema, dictationReferenceWords, diffDictationChars, evaluate, evaluateTries, fillInTheBlanksJsonSchema, gapSelectJsonSchema, gradeReadAloud, gte, inspectWav, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, matchText, multipleChoiceJsonSchema, outcomeFromUnscorable, readAloudJsonSchema, resolveItemScoringPolicy, roundGrade, score, scoreTries, stimulusJsonSchema, validateActivity, validateItemGroup, validateItemScoringPolicy, validateMedia, validateOptionMedia, validateSpeechAssessment, validateXAPIStatement, writtenResponseJsonSchema, xAPIBuilder, xapiDefinitionFor };
+//# sourceMappingURL=index.d.cts.map