@intellectif/lk-core 1.13.0 → 1.14.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { $ as AiSpeakingGradingFacts, $n as MatchingLearnerResponse, $r as TextMatchResult, $t as RouteMoveId, A as AiGapSelectFacts, An as ActivityResult, Ar as WrittenResponseRubricCriterion, At as SequenceSlot, B as AiGroupInput, Bn as FillInTheBlanksData, Br as XAPIStatement, Bt as PlannedPair, C as AiDraftsCall, Cn as VersionFinding, Cr as SpeakingRubric, Ct as AiWritingFeedback, D as AiFeature, Dn as ActivityDataMap, Dr as WrittenResponseData, Dt as MediaProgress, E as AiExplanationRequest, En as ActivityData, Er as ValidationResult, Et as ItemGroup, F as AiGradingCriterionFact, Fn as DictationData, Fr as XAPIContextActivities, Ft as TimelineCue, G as AiOptionFact, Gn as GapSelectGap, Gr as GradeRoutingReason, Gt as RouteAnswer, H as AiItemFacts, Hn as GapSelectBank, Hr as CriterionScore, Ht as PlannedTrap, I as AiGradingFacts, In as DictationEquivalence, Ir as XAPIError, It as PassageLayout, J as AiReadingWordFact, Jn as InteractionKind, Jr as GraderKind, Jt as RouteFadingOptions, K as AiProvenance, Kn as GapSelectLearnerResponse, Kr as Grader, Kt as RouteCause, L as AiGradingJudgement, Ln as DictationLearnerResponse, Lr as XAPIObject, Lt as PassageParagraph, M as AiGeneratedVariant, Mn as BlankConfig, Mr as XAPIActor, Mt as Stimulus, N as AiGrade, Nn as DeferredReason, Nr as XAPIConfig, Nt as StimulusKind, O as AiFillInTheBlanksFacts, On as ActivityFeedback, Or as WrittenResponseLearnerResponse, Ot as MediaTimeline, P as AiGradedCriterion, Pn as DeferredScoringPartial, Pr as XAPIContext, Pt as TimelineChapter, Q as AiSpeakingCriterionFact, Qn as MatchingData, Qr as TextMatchPolicy, Qt as RouteLink, R as AiGradingRequest, Rn as DictationSlowMedia, Rr as XAPIResult, Rt as PassageSection, S as AiDrafts, Sn as VersionComparison, Sr as SpeakingResponseLearnerResponse, St as AiWritingFacts, T as AiDraftsRun, Tn as VersionSlot, Tr as ValidationError, Tt as AiWritingFeedbackResult, U as AiMaterialFacts, Un as GapSelectChoice, Ur as GradeRecord, Ut as QuotedRange, V as AiHintRequest, Vn as FillInTheBlanksLearnerResponse, Vr as XAPIVerbObject, Vt as PlannedQuestion, W as AiMultipleChoiceFacts, Wn as GapSelectData, Wr as GradeRouting, Wt as ReadingRoute, X as AiRubricCriterionFact, Xn as LearnerResponse, Xr as GradingState, Xt as RouteLearnerState, Y as AiRefusal, Yn as ItemOutcome, Yr as GraderUsage, Yt as RouteKeyword, Z as AiSoundFact, Zn as LearnerResponseMap, Zr as InlineCorrection, Zt as RouteLevel, _ as AiDraftCaption, _n as DraftNotComplete, _r as ScoringOutcome, _t as AiVariantsRun, a as AiCoachingRequest, an as RouteSection, ar as MultipleChoiceLearnerResponse, at as AiVariantDifficulty, b as AiDraftSource, bn as ItemFinding, br as SpeakingMeasure, bt as AiWordFact, c as AiCriterionJudgement, cn as RouteStrategySummary, cr as NativeControlHint, ct as AiVariantLevelFacts, d as AiCritiqueFinding, dn as RouteTrap, dr as ReadAloudDimensionWeight, dt as AiVariantPair, ei as levenshteinDistance, en as RoutePlan, er as MatchingOption, et as AiSpeakingGradingRequest, f as AiCritiqueFindingResult, fn as RouteTrapKind, fr as ReadAloudLearnerResponse, ft as AiVariantSkip, g as AiDictationFacts, gn as DraftIssue, gr as ScoringDetail, gt as AiVariantsRequest, h as AiCritiqueResult, hn as DraftContext, hr as RecordingRef, ht as AiVariants, i as AiCoaching, in as RouteQuote, ir as MultipleChoiceData, it as AiTextResult, j as AiGeneratedDraft, jn as ActivityType, jr as WrittenResponseRubricLevel, jt as SequenceSlotGroup, k as AiGapFact, kn as ActivityMedia, kr as WrittenResponseRubric, kt as SequenceEntry, l as AiCritique, ln as RouteSummary, lr as ReadAloudData, lt as AiVariantMismatch, m as AiCritiqueRequest, mn as DraftComplete, mr as RecordingBounds, mt as AiVariantTargets, n as AiActivityInput, nn as RouteQuestionPart, nr as MediaPlaybackPolicy, nt as AiSpeakingMeasureFact, o as AiCoachingResult, on as RouteStep, or as MultipleChoiceOption, ot as AiVariantExemplarFacts, p as AiCritiqueKind, pn as TextRange, pr as ReadAloudSlowMedia, pt as AiVariantSkipCode, q as AiReadingFacts, qn as InteractionEvent, qr as GraderConfiguration, qt as RouteEvent, r as AiBlankFact, rn as RouteQuestionSummary, rr as MediaTrack, rt as AiSupportedActivityType, s as AiCoachingWord, sn as RouteStrategyId, sr as MultipleChoiceOptionMedia, st as AiVariantImage, t as ActivityAiPermissions, ti as matchText, tn as RouteQuestion, tr as MatchingPrompt, tt as AiSpeakingGradingRequestProblem, u as AiCritiqueField, un as RouteTrace, ur as ReadAloudDimension, ut as AiVariantMissing, v as AiDraftProblem, vn as DraftSeverity, vr as ScoringResult, vt as AiVerdict, w as AiDraftsRequest, wn as VersionPaper, wr as SpeakingRubricCriterion, wt as AiWritingFeedbackRequest, x as AiDraftType, xn as ItemFindingSeverity, xr as SpeakingResponseData, xt as AiWritingCorrection, y as AiDraftSettings, yn as DraftValidationResult, yr as ScriptTurn, yt as AiVideoDraft, z as AiGradingRequestProblem, zn as DictationTolerance, zr as XAPIScore, zt as PassageSentence } from "./ai-hC5pGYeu.js";
-import { $ as gradeFromRubric, A as DictationCharOp, At as SpeechWordError, B as inAuditSample, C as scoreTries, Ct as SpeechPhoneme, D as DICTATION_MAX_EQUIVALENCE_LENGTH, Dt as SpeechUnscorable, E as DICTATION_MAX_EQUIVALENCES, Et as SpeechSyllable, F as alignDictation, Ft as RoundingPolicy, G as CalibrationPair, H as routeGrade, I as dictationReferenceWords, It as classifyBand, J as CriterionCalibration, K as CalibrationReport, L as CalibrationThresholds, Lt as gte, M as DictationAlignment, Mt as WavInspectionPolicy, N as DictationReference, Nt as Band, O as DICTATION_MAX_TEXT_LENGTH, Ot as SpeechUnscorableCode, P as DictationWordAlignment, Pt as RoundingMode, Q as GradeFromRubricOptions, R as GradeRoutingContext, Rt as roundGrade, S as resolveItemScoringPolicy, St as SpeechMeasurement, T as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, Tt as SpeechPlausibilityPolicy, U as GradeFromJudgementOptions, V as outcomeFromRoutedGrade, W as gradeFromJudgement, X as calibrationReport, Y as TotalCalibration, Z as graderConfiguration, _ as alignReadAloud, _t as GradeSpeakingResponseOptions, a as evaluateTries, at as ItemTriesScore, b as DEFAULT_ITEM_SCORING_POLICY, bt as SpeakingEvidence, c as inspectWav, ct as ResolvedItemScoringPolicy, d as READ_ALOUD_MAX_SECONDS, dt as CompositionPolicy, et as hasGrade, f as READ_ALOUD_MAX_TAKES, ft as PassFailureReason, g as validateSpeechAssessment, gt as GradeReadAloudOptions, h as gradeReadAloud, ht as composeAssessmentScore, i as evaluate, it as ItemScoringPolicyIssue, j as diffDictationChars, jt as WavInspection, k as DICTATION_MAX_TRANSCRIPT_LENGTH, kt as SpeechWord, l as READ_ALOUD_MAX_DIMENSION_WEIGHT, lt as AssessmentScore, m as gradeSpeakingResponse, mt as SectionScore, n as ItemTriesOutcome, nt as ItemScoringCount, o as score, ot as ItemTry, p as SPEECH_ASSESSMENT_MAX_WORDS, pt as ScoredItem, q as CalibrationScope, r as ScoringOptions, rt as ItemScoringPolicy, s as outcomeFromUnscorable, st as ItemTryScore, t as EvaluateOptions, tt as outcomeFromGrade, u as READ_ALOUD_MAX_REFERENCE_LENGTH, ut as AssessmentSectionInput, v as DEFAULT_PASS_THRESHOLD, vt as ReadAloudWordAlignment, w as validateItemScoringPolicy, wt as SpeechPhonemeCandidate, x as ITEM_SCORING_MAX_RETRIES, xt as SpeechAssessment, y as computePassThreshold, yt as ReadAloudWordState, z as GradeRoutingPolicy } from "./index-Du9Kx_H6.js";
-import { A as RedactedMultipleChoiceOption, C as RedactedGapSelectChoice, D as RedactedMatchingOption, E as RedactedMatchingData, M as RedactedReadAloudData, N as RedactedStimulus, O as RedactedMatchingPrompt, P as RedactedWrittenResponseData, S as RedactedGapSelectBank, T as RedactedGapSelectGap, _ as RedactedActivity, a as JsonSchemaTarget, b as RedactedDictationSlowMedia, c as fillInTheBlanksJsonSchema, d as jsonSchemaFor, f as multipleChoiceJsonSchema, g as validateItemGroup, h as writtenResponseJsonSchema, i as SCRIPT_MAX_TURNS, j as RedactedMultipleChoiceOptionMedia, k as RedactedMultipleChoiceData, l as gapSelectJsonSchema, m as stimulusJsonSchema, n as validateMedia, o as contentJsonSchema, p as readAloudJsonSchema, r as validateOptionMedia, s as dictationJsonSchema, t as validateActivity, u as itemGroupJsonSchema, v as RedactedBlankConfig, w as RedactedGapSelectData, x as RedactedFillInTheBlanksData, y as RedactedDictationData } from "./index-DVW_N4pJ.js";
-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-Dlei-7PX.js";
+import { $ as AiSpeakingGradingFacts, $n as MarkTheWordsLearnerResponse, $r as GradingState, $t as RouteMoveId, A as AiGapSelectFacts, An as ActivityResult, Ar as WrittenResponseData, At as SequenceSlot, B as AiGroupInput, Bn as FillInTheBlanksData, Br as XAPIObject, Bt as PlannedPair, C as AiDraftsCall, Cn as VersionFinding, Cr as SpeakingMeasure, Ct as AiWritingFeedback, D as AiFeature, Dn as ActivityDataMap, Dr as SpeakingRubricCriterion, Dt as MediaProgress, E as AiExplanationRequest, En as ActivityData, Er as SpeakingRubric, Et as ItemGroup, F as AiGradingCriterionFact, Fn as DictationData, Fr as XAPIActor, Ft as TimelineCue, G as AiOptionFact, Gn as GapSelectGap, Gr as CriterionScore, Gt as RouteAnswer, H as AiItemFacts, Hn as GapSelectBank, Hr as XAPIScore, Ht as PlannedTrap, I as AiGradingFacts, In as DictationEquivalence, Ir as XAPIConfig, It as PassageLayout, J as AiReadingWordFact, Jn as InteractionKind, Jr as GradeRoutingReason, Jt as RouteFadingOptions, K as AiProvenance, Kn as GapSelectLearnerResponse, Kr as GradeRecord, Kt as RouteCause, L as AiGradingJudgement, Ln as DictationLearnerResponse, Lr as XAPIContext, Lt as PassageParagraph, M as AiGeneratedVariant, Mn as BlankConfig, Mr as WrittenResponseRubric, Mt as Stimulus, N as AiGrade, Nn as DeferredReason, Nr as WrittenResponseRubricCriterion, Nt as StimulusKind, O as AiFillInTheBlanksFacts, On as ActivityFeedback, Or as ValidationError, Ot as MediaTimeline, P as AiGradedCriterion, Pn as DeferredScoringPartial, Pr as WrittenResponseRubricLevel, Pt as TimelineChapter, Q as AiSpeakingCriterionFact, Qn as MarkTheWordsData, Qr as GraderUsage, Qt as RouteLink, R as AiGradingRequest, Rn as DictationSlowMedia, Rr as XAPIContextActivities, Rt as PassageSection, S as AiDrafts, Sn as VersionComparison, Sr as ScriptTurn, St as AiWritingFacts, T as AiDraftsRun, Tn as VersionSlot, Tr as SpeakingResponseLearnerResponse, Tt as AiWritingFeedbackResult, U as AiMaterialFacts, Un as GapSelectChoice, Ur as XAPIStatement, Ut as QuotedRange, V as AiHintRequest, Vn as FillInTheBlanksLearnerResponse, Vr as XAPIResult, Vt as PlannedQuestion, W as AiMultipleChoiceFacts, Wn as GapSelectData, Wr as XAPIVerbObject, Wt as ReadingRoute, X as AiRubricCriterionFact, Xn as LearnerResponse, Xr as GraderConfiguration, Xt as RouteLearnerState, Y as AiRefusal, Yn as ItemOutcome, Yr as Grader, Yt as RouteKeyword, Z as AiSoundFact, Zn as LearnerResponseMap, Zr as GraderKind, Zt as RouteLevel, _ as AiDraftCaption, _n as DraftNotComplete, _r as RecordingBounds, _t as AiVariantsRun, a as AiCoachingRequest, an as RouteSection, ar as MediaPlaybackPolicy, at as AiVariantDifficulty, b as AiDraftSource, bn as ItemFinding, br as ScoringOutcome, bt as AiWordFact, c as AiCriterionJudgement, cn as RouteStrategySummary, cr as MultipleChoiceLearnerResponse, ct as AiVariantLevelFacts, d as AiCritiqueFinding, dn as RouteTrap, dr as NativeControlHint, dt as AiVariantPair, ei as InlineCorrection, en as RoutePlan, er as MarkTheWordsTarget, et as AiSpeakingGradingRequest, f as AiCritiqueFindingResult, fn as RouteTrapKind, fr as ReadAloudData, ft as AiVariantSkip, g as AiDictationFacts, gn as DraftIssue, gr as ReadAloudSlowMedia, gt as AiVariantsRequest, h as AiCritiqueResult, hn as DraftContext, hr as ReadAloudLearnerResponse, ht as AiVariants, i as AiCoaching, ii as matchText, in as RouteQuote, ir as MatchingPrompt, it as AiTextResult, j as AiGeneratedDraft, jn as ActivityType, jr as WrittenResponseLearnerResponse, jt as SequenceSlotGroup, k as AiGapFact, kn as ActivityMedia, kr as ValidationResult, kt as SequenceEntry, l as AiCritique, ln as RouteSummary, lr as MultipleChoiceOption, lt as AiVariantMismatch, m as AiCritiqueRequest, mn as DraftComplete, mr as ReadAloudDimensionWeight, mt as AiVariantTargets, n as AiActivityInput, ni as TextMatchResult, nn as RouteQuestionPart, nr as MatchingLearnerResponse, nt as AiSpeakingMeasureFact, o as AiCoachingResult, on as RouteStep, or as MediaTrack, ot as AiVariantExemplarFacts, p as AiCritiqueKind, pn as TextRange, pr as ReadAloudDimension, pt as AiVariantSkipCode, q as AiReadingFacts, qn as InteractionEvent, qr as GradeRouting, qt as RouteEvent, r as AiBlankFact, ri as levenshteinDistance, rn as RouteQuestionSummary, rr as MatchingOption, rt as AiSupportedActivityType, s as AiCoachingWord, sn as RouteStrategyId, sr as MultipleChoiceData, st as AiVariantImage, t as ActivityAiPermissions, ti as TextMatchPolicy, tn as RouteQuestion, tr as MatchingData, tt as AiSpeakingGradingRequestProblem, u as AiCritiqueField, un as RouteTrace, ur as MultipleChoiceOptionMedia, ut as AiVariantMissing, v as AiDraftProblem, vn as DraftSeverity, vr as RecordingRef, vt as AiVerdict, w as AiDraftsRequest, wn as VersionPaper, wr as SpeakingResponseData, wt as AiWritingFeedbackRequest, x as AiDraftType, xn as ItemFindingSeverity, xr as ScoringResult, xt as AiWritingCorrection, y as AiDraftSettings, yn as DraftValidationResult, yr as ScoringDetail, yt as AiVideoDraft, z as AiGradingRequestProblem, zn as DictationTolerance, zr as XAPIError, zt as PassageSentence } from "./ai-mC-5XhBc.js";
+import { $ as gradeFromRubric, A as DictationCharOp, At as SpeechWordError, B as inAuditSample, C as scoreTries, Ct as SpeechPhoneme, D as DICTATION_MAX_EQUIVALENCE_LENGTH, Dt as SpeechUnscorable, E as DICTATION_MAX_EQUIVALENCES, Et as SpeechSyllable, F as alignDictation, Ft as RoundingPolicy, G as CalibrationPair, H as routeGrade, I as dictationReferenceWords, It as classifyBand, J as CriterionCalibration, K as CalibrationReport, L as CalibrationThresholds, Lt as gte, M as DictationAlignment, Mt as WavInspectionPolicy, N as DictationReference, Nt as Band, O as DICTATION_MAX_TEXT_LENGTH, Ot as SpeechUnscorableCode, P as DictationWordAlignment, Pt as RoundingMode, Q as GradeFromRubricOptions, R as GradeRoutingContext, Rt as roundGrade, S as resolveItemScoringPolicy, St as SpeechMeasurement, T as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, Tt as SpeechPlausibilityPolicy, U as GradeFromJudgementOptions, V as outcomeFromRoutedGrade, W as gradeFromJudgement, X as calibrationReport, Y as TotalCalibration, Z as graderConfiguration, _ as alignReadAloud, _t as GradeSpeakingResponseOptions, a as evaluateTries, at as ItemTriesScore, b as DEFAULT_ITEM_SCORING_POLICY, bt as SpeakingEvidence, c as inspectWav, ct as ResolvedItemScoringPolicy, d as READ_ALOUD_MAX_SECONDS, dt as CompositionPolicy, et as hasGrade, f as READ_ALOUD_MAX_TAKES, ft as PassFailureReason, g as validateSpeechAssessment, gt as GradeReadAloudOptions, h as gradeReadAloud, ht as composeAssessmentScore, i as evaluate, it as ItemScoringPolicyIssue, j as diffDictationChars, jt as WavInspection, k as DICTATION_MAX_TRANSCRIPT_LENGTH, kt as SpeechWord, l as READ_ALOUD_MAX_DIMENSION_WEIGHT, lt as AssessmentScore, m as gradeSpeakingResponse, mt as SectionScore, n as ItemTriesOutcome, nt as ItemScoringCount, o as score, ot as ItemTry, p as SPEECH_ASSESSMENT_MAX_WORDS, pt as ScoredItem, q as CalibrationScope, r as ScoringOptions, rt as ItemScoringPolicy, s as outcomeFromUnscorable, st as ItemTryScore, t as EvaluateOptions, tt as outcomeFromGrade, u as READ_ALOUD_MAX_REFERENCE_LENGTH, ut as AssessmentSectionInput, v as DEFAULT_PASS_THRESHOLD, vt as ReadAloudWordAlignment, w as validateItemScoringPolicy, wt as SpeechPhonemeCandidate, x as ITEM_SCORING_MAX_RETRIES, xt as SpeechAssessment, y as computePassThreshold, yt as ReadAloudWordState, z as GradeRoutingPolicy } from "./index-BudO4ES2.js";
+import { A as RedactedMultipleChoiceData, C as RedactedGapSelectChoice, D as RedactedMatchingData, E as RedactedMarkTheWordsData, F as RedactedWrittenResponseData, M as RedactedMultipleChoiceOptionMedia, N as RedactedReadAloudData, O as RedactedMatchingOption, P as RedactedStimulus, S as RedactedGapSelectBank, T as RedactedGapSelectGap, _ as RedactedActivity, a as JsonSchemaTarget, b as RedactedDictationSlowMedia, c as fillInTheBlanksJsonSchema, d as jsonSchemaFor, f as multipleChoiceJsonSchema, g as validateItemGroup, h as writtenResponseJsonSchema, i as SCRIPT_MAX_TURNS, j as RedactedMultipleChoiceOption, k as RedactedMatchingPrompt, l as gapSelectJsonSchema, m as stimulusJsonSchema, n as validateMedia, o as contentJsonSchema, p as readAloudJsonSchema, r as validateOptionMedia, s as dictationJsonSchema, t as validateActivity, u as itemGroupJsonSchema, v as RedactedBlankConfig, w as RedactedGapSelectData, x as RedactedFillInTheBlanksData, y as RedactedDictationData } from "./index-CFKxHXAY.js";
+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-2UQ5v6NZ.js";
 /**
  * What a model is told about the group a question sits in: the material the
  * learner reads and sees beside it.
@@ -1355,7 +1355,7 @@ export declare function critiqueDraft(type: ActivityType, draft: unknown): ItemF
  * 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", "speaking-response", "matching"];
+export declare const BUILT_IN_ACTIVITY_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "written-response", "gap-select", "dictation", "read-aloud", "speaking-response", "matching", "mark-the-words"];
 /** 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. */
@@ -1518,6 +1518,82 @@ export declare function flattenSequence<TItem extends {
   id: string;
   type: string;
 }>(entries: readonly SequenceEntry<TItem>[], options?: FlattenSequenceOptions): SequenceSlot<TItem>[];
+/**
+ * The words of a mark-the-words text, and where an author's targets fall
+ * among them. A leaf module: the schema, the scorer, the draft checks and the
+ * component all read it, and it imports nothing.
+ *
+ * A learner marks words, never characters, and a response records a word by
+ * its position — so how a text is cut into words is part of every stored
+ * answer. The cut is the SDK's own (`lk-words@1`), not `Intl.Segmenter`,
+ * whose word boundaries change with the ICU a runtime ships: the same text
+ * must be the same words in every browser and on every server, now and when
+ * the answer is graded again later.
+ */
+/** The name of the word cut. A change to it is a major: stored answers name words by position. */
+export declare const MARK_THE_WORDS_TOKENIZER = "lk-words@1";
+/** The most words a mark-the-words text may have. */
+export declare const MARK_THE_WORDS_MAX_WORDS = 1500;
+/** One markable word of a text. */
+interface MarkableWord {
+  /** 0-based position among the text's words: what a response records. */
+  index: number;
+  /** The word as written. */
+  text: string;
+  /** Where it starts and ends in the text, in UTF-16 units. */
+  start: number;
+  end: number;
+}
+/** Every markable word of `text`, in order, cut by `lk-words@1`. */
+export declare function markableWords(text: string): MarkableWord[];
+/** One word, or several in a row, that the learner should mark. */
+interface MarkTargetQuote {
+  /** The word or words, copied from the text. */
+  text: string;
+  /** Which appearance, 1-based, where they appear more than once. */
+  occurrence?: number;
+}
+/** Why a target names no words of the text. */
+type MarkTargetProblem = 'no-words' | 'not-found' | 'ambiguous' | 'no-such-occurrence';
+/** Where a target falls: the positions of its words, or why it falls nowhere. */
+type MarkTargetResolution = {
+  ok: true;
+  indices: number[];
+} | {
+  ok: false;
+  problem: MarkTargetProblem;
+  found: number;
+};
+/**
+ * Where a target falls among `words`. Its text must be whole words of the text,
+ * in order — case, accents and punctuation as written, apart from the kind of
+ * apostrophe — and must say which appearance it means when there are several.
+ */
+export declare function resolveMarkTarget(words: readonly MarkableWord[], target: {
+  text?: unknown;
+  occurrence?: unknown;
+}): MarkTargetResolution;
+/**
+ * The word positions of each target of an item, in target order; a target
+ * that falls nowhere has none. Read defensively: the scorer is reachable with
+ * content an older build stored.
+ */
+export declare function markTargetIndices(data: {
+  text?: unknown;
+  targets?: unknown;
+}): number[][];
+/**
+ * A text and its targets from markup that stars each target, as an H5P "Mark
+ * the Words" text does: `I *went* home and *had gone* to bed.` A `\*` is a
+ * literal star. Each target names its appearance only where its words appear
+ * more than once in the text.
+ *
+ * @throws Error when a star is left open.
+ */
+export declare function markTheWordsFromMarkup(markup: string): {
+  text: string;
+  targets: MarkTargetQuote[];
+};
 /**
  * What one budgeted recording has cost the learner so far.
  */
@@ -2505,11 +2581,11 @@ export declare function composeTimelineScore(entryKey: string, items: readonly S
  * plays only when the learner presses play while the video is paused. A
  * dictation must carry its own recording (the timeline rule).
  *
- * `speaking-response` joined in 1.10.0, and `matching` in 1.13.0: a host with
- * an exhaustive `switch` or `Record` over {@link InteractiveVideoItemType}
- * needs one more entry for each.
+ * `speaking-response` joined in 1.10.0, `matching` in 1.13.0 and
+ * `mark-the-words` in 1.14.0: a host with an exhaustive `switch` or `Record`
+ * over {@link InteractiveVideoItemType} needs one more entry for each.
  */
-export declare const INTERACTIVE_VIDEO_ITEM_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "gap-select", "dictation", "read-aloud", "speaking-response", "matching"];
+export declare const INTERACTIVE_VIDEO_ITEM_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "gap-select", "dictation", "read-aloud", "speaking-response", "matching", "mark-the-words"];
 /** One of {@link INTERACTIVE_VIDEO_ITEM_TYPES}. */
 export type InteractiveVideoItemType = (typeof INTERACTIVE_VIDEO_ITEM_TYPES)[number];
 /** Whether `type` is one of the item types an interactive video may present. */
@@ -2633,5 +2709,5 @@ export declare function critiqueVersions(a: VersionPaper, b: VersionPaper, optio
   lengthTolerance?: LengthTolerance;
   allowSharedImages?: boolean;
 }): VersionComparison;
-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 AiGeneratedVariant, type AiGrade, type AiGradedCriterion, type AiGradingCriterionFact, type AiGradingFacts, type AiGradingJudgement, type AiGradingRequest, type AiGradingRequestProblem, type AiGroupInput, type AiHintRequest, type AiItemFacts, type AiMaterialFacts, type AiMultipleChoiceFacts, type AiOptionFact, type AiProvenance, type AiReadingFacts, type AiReadingWordFact, type AiRefusal, type AiRubricCriterionFact, type AiSoundFact, type AiSpeakingCriterionFact, type AiSpeakingGradingFacts, type AiSpeakingGradingRequest, type AiSpeakingGradingRequestProblem, type AiSpeakingMeasureFact, type AiSupportedActivityType, type AiTextResult, type AiVariantDifficulty, type AiVariantExemplarFacts, type AiVariantImage, type AiVariantLevelFacts, type AiVariantMismatch, type AiVariantMissing, type AiVariantPair, type AiVariantSkip, type AiVariantSkipCode, type AiVariantTargets, type AiVariants, type AiVariantsRequest, type AiVariantsRun, 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 CalibrationPair, type CalibrationReport, type CalibrationScope, type CalibrationThresholds, type CompletedStatementParams, type CompositionPolicy, type CriterionCalibration, 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 GradeFromJudgementOptions, GradeFromRubricOptions, type GradeReadAloudOptions, type GradeRecord, type GradeRouting, type GradeRoutingContext, type GradeRoutingPolicy, type GradeRoutingReason, type GradeSpeakingResponseOptions, type Grader, type GraderConfiguration, 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 JsonSchemaTarget, type LearnerResponse, type LearnerResponseMap, type LengthTolerance, type MatchingData, type MatchingLearnerResponse, type MatchingOption, type MatchingPrompt, type MediaBudgetRef, type MediaPlayClaim, type MediaPlayGrant, type MediaPlayLedger, type MediaPlayLedgerEntry, type MediaPlaybackPolicy, type MediaProgress, type MediaSlot, type MediaTimeline, type MediaTrack, type MultipleChoiceData, type MultipleChoiceLearnerResponse, type MultipleChoiceOption, type MultipleChoiceOptionMedia, type NativeControlHint, type PartialScoringResult, type PassFailureReason, type PassageLayout, type PassageParagraph, type PassageSection, type PassageSentence, type PlanRouteOptions, type PlannedPair, type PlannedQuestion, type PlannedTrap, type QuoteMatch, type QuotedRange, 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 ReadingRoute, type ReadingRouteItemType, type RecordingBounds, type RecordingRef, type RedactedActivity, type RedactedBlankConfig, type RedactedDictationData, type RedactedDictationSlowMedia, type RedactedFillInTheBlanksData, type RedactedGapSelectBank, type RedactedGapSelectChoice, type RedactedGapSelectData, type RedactedGapSelectGap, type RedactedMatchingData, type RedactedMatchingOption, type RedactedMatchingPrompt, type RedactedMultipleChoiceData, type RedactedMultipleChoiceOption, type RedactedMultipleChoiceOptionMedia, type RedactedReadAloudData, type RedactedStimulus, type RedactedWrittenResponseData, type RegisteredActivityTypeDescriptor, type ResolvedDeliveryPolicy, type ResolvedItemScoringPolicy, type ResponseDiffEntry, type RoundingMode, type RoundingPolicy, type RouteAnswer, type RouteCause, type RouteEvent, type RouteFadingOptions, type RouteIssue, type RouteIssueCode, type RouteKeyword, type RouteLearnerState, type RouteLevel, type RouteLink, type RouteMoveId, type RoutePlan, type RouteQuestion, type RouteQuestionPart, type RouteQuestionSummary, type RouteQuote, type RouteSection, type RouteStep, type RouteStrategy, type RouteStrategyId, type RouteStrategySummary, type RouteSummary, type RouteTrace, type RouteTrap, type RouteTrapKind, SCRIPT_MAX_TURNS, SPEECH_ASSESSMENT_MAX_WORDS, type ScoredItem, type ScoringDetail, ScoringOptions, type ScoringOutcome, type ScoringResult, type ScriptTurn, type SectionScore, type Sensitivity, type SequenceEntry, type SequenceSlot, type SequenceSlotGroup, type SpeakingEvidence, type SpeakingMeasure, type SpeakingResponseData, type SpeakingResponseLearnerResponse, type SpeakingRubric, type SpeakingRubricCriterion, 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 TextRange, type ThemeTokens, type TimelineChapter, type TimelineCue, type TotalCalibration, type ValidationError, type ValidationResult, type VersionComparison, type VersionFinding, type VersionPaper, type VersionSlot, type WavInspection, type WavInspectionPolicy, type WrittenResponseData, type WrittenResponseLearnerResponse, type WrittenResponseRubric, type WrittenResponseRubricCriterion, type WrittenResponseRubricLevel, 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, calibrationReport, classifyBand, composeAssessmentScore, computePassThreshold, contentJsonSchema, dictationJsonSchema, dictationReferenceWords, diffDictationChars, evaluate, evaluateTries, fillInTheBlanksJsonSchema, gapSelectJsonSchema, gradeFromJudgement, gradeFromRubric, gradeReadAloud, gradeSpeakingResponse, graderConfiguration, gte, hasGrade, inAuditSample, inspectWav, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, matchText, multipleChoiceJsonSchema, outcomeFromGrade, outcomeFromRoutedGrade, outcomeFromUnscorable, readAloudJsonSchema, resolveItemScoringPolicy, roundGrade, routeGrade, score, scoreTries, stimulusJsonSchema, validateActivity, validateItemGroup, validateItemScoringPolicy, validateMedia, validateOptionMedia, validateSpeechAssessment, validateXAPIStatement, writtenResponseJsonSchema, xAPIBuilder, xapiDefinitionFor };
+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 AiGeneratedVariant, type AiGrade, type AiGradedCriterion, type AiGradingCriterionFact, type AiGradingFacts, type AiGradingJudgement, type AiGradingRequest, type AiGradingRequestProblem, type AiGroupInput, type AiHintRequest, type AiItemFacts, type AiMaterialFacts, type AiMultipleChoiceFacts, type AiOptionFact, type AiProvenance, type AiReadingFacts, type AiReadingWordFact, type AiRefusal, type AiRubricCriterionFact, type AiSoundFact, type AiSpeakingCriterionFact, type AiSpeakingGradingFacts, type AiSpeakingGradingRequest, type AiSpeakingGradingRequestProblem, type AiSpeakingMeasureFact, type AiSupportedActivityType, type AiTextResult, type AiVariantDifficulty, type AiVariantExemplarFacts, type AiVariantImage, type AiVariantLevelFacts, type AiVariantMismatch, type AiVariantMissing, type AiVariantPair, type AiVariantSkip, type AiVariantSkipCode, type AiVariantTargets, type AiVariants, type AiVariantsRequest, type AiVariantsRun, 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 CalibrationPair, type CalibrationReport, type CalibrationScope, type CalibrationThresholds, type CompletedStatementParams, type CompositionPolicy, type CriterionCalibration, 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 GradeFromJudgementOptions, GradeFromRubricOptions, type GradeReadAloudOptions, type GradeRecord, type GradeRouting, type GradeRoutingContext, type GradeRoutingPolicy, type GradeRoutingReason, type GradeSpeakingResponseOptions, type Grader, type GraderConfiguration, 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 JsonSchemaTarget, type LearnerResponse, type LearnerResponseMap, type LengthTolerance, type MarkTargetProblem, type MarkTargetResolution, type MarkTheWordsData, type MarkTheWordsLearnerResponse, type MarkTheWordsTarget, type MarkableWord, type MatchingData, type MatchingLearnerResponse, type MatchingOption, type MatchingPrompt, type MediaBudgetRef, type MediaPlayClaim, type MediaPlayGrant, type MediaPlayLedger, type MediaPlayLedgerEntry, type MediaPlaybackPolicy, type MediaProgress, type MediaSlot, type MediaTimeline, type MediaTrack, type MultipleChoiceData, type MultipleChoiceLearnerResponse, type MultipleChoiceOption, type MultipleChoiceOptionMedia, type NativeControlHint, type PartialScoringResult, type PassFailureReason, type PassageLayout, type PassageParagraph, type PassageSection, type PassageSentence, type PlanRouteOptions, type PlannedPair, type PlannedQuestion, type PlannedTrap, type QuoteMatch, type QuotedRange, 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 ReadingRoute, type ReadingRouteItemType, type RecordingBounds, type RecordingRef, type RedactedActivity, type RedactedBlankConfig, type RedactedDictationData, type RedactedDictationSlowMedia, type RedactedFillInTheBlanksData, type RedactedGapSelectBank, type RedactedGapSelectChoice, type RedactedGapSelectData, type RedactedGapSelectGap, type RedactedMarkTheWordsData, type RedactedMatchingData, type RedactedMatchingOption, type RedactedMatchingPrompt, type RedactedMultipleChoiceData, type RedactedMultipleChoiceOption, type RedactedMultipleChoiceOptionMedia, type RedactedReadAloudData, type RedactedStimulus, type RedactedWrittenResponseData, type RegisteredActivityTypeDescriptor, type ResolvedDeliveryPolicy, type ResolvedItemScoringPolicy, type ResponseDiffEntry, type RoundingMode, type RoundingPolicy, type RouteAnswer, type RouteCause, type RouteEvent, type RouteFadingOptions, type RouteIssue, type RouteIssueCode, type RouteKeyword, type RouteLearnerState, type RouteLevel, type RouteLink, type RouteMoveId, type RoutePlan, type RouteQuestion, type RouteQuestionPart, type RouteQuestionSummary, type RouteQuote, type RouteSection, type RouteStep, type RouteStrategy, type RouteStrategyId, type RouteStrategySummary, type RouteSummary, type RouteTrace, type RouteTrap, type RouteTrapKind, SCRIPT_MAX_TURNS, SPEECH_ASSESSMENT_MAX_WORDS, type ScoredItem, type ScoringDetail, ScoringOptions, type ScoringOutcome, type ScoringResult, type ScriptTurn, type SectionScore, type Sensitivity, type SequenceEntry, type SequenceSlot, type SequenceSlotGroup, type SpeakingEvidence, type SpeakingMeasure, type SpeakingResponseData, type SpeakingResponseLearnerResponse, type SpeakingRubric, type SpeakingRubricCriterion, 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 TextRange, type ThemeTokens, type TimelineChapter, type TimelineCue, type TotalCalibration, type ValidationError, type ValidationResult, type VersionComparison, type VersionFinding, type VersionPaper, type VersionSlot, type WavInspection, type WavInspectionPolicy, type WrittenResponseData, type WrittenResponseLearnerResponse, type WrittenResponseRubric, type WrittenResponseRubricCriterion, type WrittenResponseRubricLevel, 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, calibrationReport, classifyBand, composeAssessmentScore, computePassThreshold, contentJsonSchema, dictationJsonSchema, dictationReferenceWords, diffDictationChars, evaluate, evaluateTries, fillInTheBlanksJsonSchema, gapSelectJsonSchema, gradeFromJudgement, gradeFromRubric, gradeReadAloud, gradeSpeakingResponse, graderConfiguration, gte, hasGrade, inAuditSample, inspectWav, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, matchText, multipleChoiceJsonSchema, outcomeFromGrade, outcomeFromRoutedGrade, outcomeFromUnscorable, readAloudJsonSchema, resolveItemScoringPolicy, roundGrade, routeGrade, score, scoreTries, stimulusJsonSchema, validateActivity, validateItemGroup, validateItemScoringPolicy, validateMedia, validateOptionMedia, validateSpeechAssessment, validateXAPIStatement, writtenResponseJsonSchema, xAPIBuilder, xapiDefinitionFor };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["_$__registry_js0.ActivityTypeDescriptor"],"sources":["../src/ai-material.ts","../src/ai.ts","../src/ai-coaching.ts","../src/ai-critique.ts","../src/ai-drafts.ts","../src/ai-grading.ts","../src/variant-rules.ts","../src/ai-variants.ts","../src/ai-written.ts","../src/ai-writing.ts","../src/types/delivery.ts","../src/types/attempt-plan.ts","../src/attempt-plan.ts","../src/types/attempt-state.ts","../src/attempt-state.ts","../src/authoring/item-group.ts","../src/authoring/index.ts","../src/built-in-types.ts","../src/content-hash.ts","../src/count-words.ts","../src/delivery.ts","../src/errors.ts","../src/item-group.ts","../src/types/media-budget.ts","../src/media-budget.ts","../src/media-refs.ts","../src/reading-route/check.ts","../src/reading-route/layout.ts","../src/reading-route/plan.ts","../src/reading-route/progress.ts","../src/reading-route/questions.ts","../src/reading-route/quotes.ts","../src/reading-route/strategies.ts","../src/reading-route/text.ts","../src/standard-schema.ts","../src/registry/define.ts","../src/registry/registry.ts","../src/redact.ts","../src/registry/builtins.ts","../src/shuffle.ts","../src/timeline.ts","../src/timeline-limits.ts","../src/types/theme.ts","../src/versions.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["_$__registry_js0.ActivityTypeDescriptor"],"sources":["../src/ai-material.ts","../src/ai.ts","../src/ai-coaching.ts","../src/ai-critique.ts","../src/ai-drafts.ts","../src/ai-grading.ts","../src/variant-rules.ts","../src/ai-variants.ts","../src/ai-written.ts","../src/ai-writing.ts","../src/types/delivery.ts","../src/types/attempt-plan.ts","../src/attempt-plan.ts","../src/types/attempt-state.ts","../src/attempt-state.ts","../src/authoring/item-group.ts","../src/authoring/index.ts","../src/built-in-types.ts","../src/content-hash.ts","../src/count-words.ts","../src/delivery.ts","../src/errors.ts","../src/item-group.ts","../src/mark-the-words.ts","../src/types/media-budget.ts","../src/media-budget.ts","../src/media-refs.ts","../src/reading-route/check.ts","../src/reading-route/layout.ts","../src/reading-route/plan.ts","../src/reading-route/progress.ts","../src/reading-route/questions.ts","../src/reading-route/quotes.ts","../src/reading-route/strategies.ts","../src/reading-route/text.ts","../src/standard-schema.ts","../src/registry/define.ts","../src/registry/registry.ts","../src/redact.ts","../src/registry/builtins.ts","../src/shuffle.ts","../src/timeline.ts","../src/timeline-limits.ts","../src/types/theme.ts","../src/versions.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,9 +1,9 @@
-import { $ as checkAiCoaching, A as validateDraft, B as lengthMisses, C as interactiveVideoFromDrafts, D as checkAiCritique, E as aiCritiqueRequest, F as critiqueItemGroupDraft, G as textSimilarity, H as sharedAnswers, I as validateItemGroupDraft, J as mapMediaRefs, K as textsOf, L as AI_VARIANT_LENGTH_BANDS, M as createItemGroupDraft, N as createReadingRouteDraft, O as createDraft, P as critiqueDrafts, Q as aiCoachingRequest, R as AI_VARIANT_NEAR_COPY_THRESHOLD, S as generateDrafts, T as AI_CRITIQUE_MAX_FINDINGS, U as shownScore, V as optionSet, W as structureMisses, X as AI_COACHING_MAX_TIP_LENGTH, Y as transcriptOf, Z as AI_COACHING_MAX_WORDS, _ as AI_DRAFTS_MAX_COUNT, a as AI_VARIANTS_MAX_REPAIRS, at as aiGradeOf, b as aiDraftsRequest, c as aiVariantsRequest, ct as buildAiFacts, d as AI_GRADING_PROBABILITY_TOLERANCE, dt as hintRevealsAnswer, et as AI_EXPLANATION_TYPES, f as aiGradingRequest, ft as readAiTextResult, g as AI_WRITING_MAX_FIELD_LENGTH, h as AI_WRITING_MAX_CORRECTIONS, i as AI_VARIANTS_MAX_MATERIAL_LENGTH, it as aiExplanationRequest, j as createInteractiveVideoDraft, k as critiqueDraft, l as checkAiVariants, lt as checkAiExplanation, m as checkAiGrading, n as checkAiWritingFeedback, nt as AI_TEXT_MAX_LENGTH, o as AI_VARIANT_CODE_SEVERITY, ot as aiHintRequest, p as aiSpeakingGradingRequest, pt as AI_MATERIAL_MAX_LENGTH, q as listMediaRefs, r as AI_VARIANTS_MAX_EXEMPLARS, rt as aiAllowedByContent, s as aiVariantsRepairRequest, st as aiSupports, t as aiWritingFeedbackRequest, tt as AI_HINT_TYPES, u as generateVariants, ut as checkAiHint, v as AI_DRAFTS_MAX_REPAIRS, w as AI_CRITIQUE_MAX_FIELD_LENGTH, x as checkAiDrafts, y as aiDraftsRepairRequest, z as keysOf } from "./ai-writing-Dsmvv4T-.js";
-import { At as SCRIPT_MAX_TURNS, B as countWords, C as READ_ALOUD_MAX_REFERENCE_LENGTH, D as SPEECH_ASSESSMENT_MAX_WORDS, F as matchText, P as levenshteinDistance, S as READ_ALOUD_MAX_DIMENSION_WEIGHT, T as READ_ALOUD_MAX_TAKES, _t as BUILT_IN_ACTIVITY_TYPES, a as readSchema, c as dictationType, ct as dictationReferenceWords, d as multipleChoiceType, dt as DICTATION_MAX_EQUIVALENCE_LENGTH, f as readAloudType, ft as DICTATION_MAX_TEXT_LENGTH, h as defineActivityType, it as UnknownActivityTypeError, l as fillInTheBlanksType, lt as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, m as guardOf, n as registerActivityType, nt as DeferredScoringError, ot as alignDictation, p as writtenResponseType, pt as DICTATION_MAX_TRANSCRIPT_LENGTH, r as registeredActivityTypes, rt as RedactedScoringError, s as MEDIA_FIELD_POLICY, t as getActivityTypeDescriptor, tt as ActivitySchemaError, u as gapSelectType, ut as DICTATION_MAX_EQUIVALENCES, w as READ_ALOUD_MAX_SECONDS, yt as isBuiltInActivityType } from "./registry-Cn2it-y7.js";
-import { A as roundGrade, C as canonicalJson, D as computePassThreshold, E as DEFAULT_PASS_THRESHOLD, F as validateItemScoringPolicy, M as ITEM_SCORING_MAX_RETRIES, N as resolveItemScoringPolicy, O as classifyBand, P as scoreTries, S as graderConfiguration, T as fingerprint, _ as gradeFromJudgement, a as inspectWav, b as outcomeFromGrade, c as alignReadAloud, d as composeAssessmentScore, f as inAuditSample, g as seededShuffle, h as hashSeed, i as outcomeFromUnscorable, j as DEFAULT_ITEM_SCORING_POLICY, k as gte, l as validateSpeechAssessment, m as routeGrade, n as evaluateTries, o as gradeSpeakingResponse, p as outcomeFromRoutedGrade, r as score, s as gradeReadAloud, t as evaluate, u as diffDictationChars, v as gradeFromRubric, w as contentHash, x as calibrationReport, y as hasGrade } from "./scoring-weQ4SzwB.js";
-import { C as itemQuestions, D as overlaps, E as countParagraphs, O as passageLayout, S as choicesOf, T as ROUTE_SEGMENTER, _ as ROUTE_WORD_LIMIT_MAX, a as INTERACTIVE_VIDEO_ITEM_TYPES, b as findQuote, c as TIMELINE_MAX_QUIZZES, d as readingQuizzes, f as routeIssues, g as ROUTE_STRATEGY_IDS, h as ROUTE_STRATEGIES, i as validateItemGroup, k as sentencesTouching, l as TIMELINE_MAX_TITLE_LENGTH, m as ROUTE_NOTE_MAX_LENGTH, n as RedactedItemGroupSchema, o as TIMELINE_MAX_CHAPTERS, p as READING_ROUTE_ITEM_TYPES, s as TIMELINE_MAX_ITEMS, u as isInteractiveVideoItemType, v as isReadingRouteItemType, w as questionKey, x as quoteText, y as isRouteStrategyId } from "./item-group-vTcNy2JF.js";
-import { a as dictationJsonSchema, c as itemGroupJsonSchema, d as readAloudJsonSchema, f as stimulusJsonSchema, i as contentJsonSchema, l as jsonSchemaFor, n as validateMedia, o as fillInTheBlanksJsonSchema, p as writtenResponseJsonSchema, r as validateOptionMedia, s as gapSelectJsonSchema, t as validateActivity, u as multipleChoiceJsonSchema } from "./schemas-DlxeS7Lu.js";
-import { a as validateXAPIStatement, i as XAPI_VERB_DISPLAY, n as xapiDefinitionFor, r as XAPIVerb, t as xAPIBuilder } from "./xapi-DbRVH_RB.js";
+import { $ as checkAiCoaching, A as validateDraft, B as lengthMisses, C as interactiveVideoFromDrafts, D as checkAiCritique, E as aiCritiqueRequest, F as critiqueItemGroupDraft, G as textSimilarity, H as sharedAnswers, I as validateItemGroupDraft, J as mapMediaRefs, K as textsOf, L as AI_VARIANT_LENGTH_BANDS, M as createItemGroupDraft, N as createReadingRouteDraft, O as createDraft, P as critiqueDrafts, Q as aiCoachingRequest, R as AI_VARIANT_NEAR_COPY_THRESHOLD, S as generateDrafts, T as AI_CRITIQUE_MAX_FINDINGS, U as shownScore, V as optionSet, W as structureMisses, X as AI_COACHING_MAX_TIP_LENGTH, Y as transcriptOf, Z as AI_COACHING_MAX_WORDS, _ as AI_DRAFTS_MAX_COUNT, a as AI_VARIANTS_MAX_REPAIRS, at as aiGradeOf, b as aiDraftsRequest, c as aiVariantsRequest, ct as buildAiFacts, d as AI_GRADING_PROBABILITY_TOLERANCE, dt as hintRevealsAnswer, et as AI_EXPLANATION_TYPES, f as aiGradingRequest, ft as readAiTextResult, g as AI_WRITING_MAX_FIELD_LENGTH, h as AI_WRITING_MAX_CORRECTIONS, i as AI_VARIANTS_MAX_MATERIAL_LENGTH, it as aiExplanationRequest, j as createInteractiveVideoDraft, k as critiqueDraft, l as checkAiVariants, lt as checkAiExplanation, m as checkAiGrading, n as checkAiWritingFeedback, nt as AI_TEXT_MAX_LENGTH, o as AI_VARIANT_CODE_SEVERITY, ot as aiHintRequest, p as aiSpeakingGradingRequest, pt as AI_MATERIAL_MAX_LENGTH, q as listMediaRefs, r as AI_VARIANTS_MAX_EXEMPLARS, rt as aiAllowedByContent, s as aiVariantsRepairRequest, st as aiSupports, t as aiWritingFeedbackRequest, tt as AI_HINT_TYPES, u as generateVariants, ut as checkAiHint, v as AI_DRAFTS_MAX_REPAIRS, w as AI_CRITIQUE_MAX_FIELD_LENGTH, x as checkAiDrafts, y as aiDraftsRepairRequest, z as keysOf } from "./ai-writing-D3oREPsp.js";
+import { A as MARK_THE_WORDS_MAX_WORDS, B as levenshteinDistance, C as READ_ALOUD_MAX_REFERENCE_LENGTH, Ct as BUILT_IN_ACTIVITY_TYPES, D as SPEECH_ASSESSMENT_MAX_WORDS, F as resolveMarkTarget, It as SCRIPT_MAX_TURNS, K as countWords, M as markTargetIndices, N as markTheWordsFromMarkup, P as markableWords, S as READ_ALOUD_MAX_DIMENSION_WEIGHT, T as READ_ALOUD_MAX_TAKES, Tt as isBuiltInActivityType, V as matchText, _t as DICTATION_MAX_EQUIVALENCE_LENGTH, a as readSchema, c as dictationType, ct as DeferredScoringError, d as multipleChoiceType, f as readAloudType, ft as alignDictation, gt as DICTATION_MAX_EQUIVALENCES, h as defineActivityType, ht as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, j as MARK_THE_WORDS_TOKENIZER, l as fillInTheBlanksType, lt as RedactedScoringError, m as guardOf, mt as dictationReferenceWords, n as registerActivityType, p as writtenResponseType, r as registeredActivityTypes, s as MEDIA_FIELD_POLICY, st as ActivitySchemaError, t as getActivityTypeDescriptor, u as gapSelectType, ut as UnknownActivityTypeError, vt as DICTATION_MAX_TEXT_LENGTH, w as READ_ALOUD_MAX_SECONDS, yt as DICTATION_MAX_TRANSCRIPT_LENGTH } from "./registry-CroAI5nc.js";
+import { A as roundGrade, C as canonicalJson, D as computePassThreshold, E as DEFAULT_PASS_THRESHOLD, F as validateItemScoringPolicy, M as ITEM_SCORING_MAX_RETRIES, N as resolveItemScoringPolicy, O as classifyBand, P as scoreTries, S as graderConfiguration, T as fingerprint, _ as gradeFromJudgement, a as inspectWav, b as outcomeFromGrade, c as alignReadAloud, d as composeAssessmentScore, f as inAuditSample, g as seededShuffle, h as hashSeed, i as outcomeFromUnscorable, j as DEFAULT_ITEM_SCORING_POLICY, k as gte, l as validateSpeechAssessment, m as routeGrade, n as evaluateTries, o as gradeSpeakingResponse, p as outcomeFromRoutedGrade, r as score, s as gradeReadAloud, t as evaluate, u as diffDictationChars, v as gradeFromRubric, w as contentHash, x as calibrationReport, y as hasGrade } from "./scoring-BxvOhHE0.js";
+import { C as itemQuestions, D as overlaps, E as countParagraphs, O as passageLayout, S as choicesOf, T as ROUTE_SEGMENTER, _ as ROUTE_WORD_LIMIT_MAX, a as INTERACTIVE_VIDEO_ITEM_TYPES, b as findQuote, c as TIMELINE_MAX_QUIZZES, d as readingQuizzes, f as routeIssues, g as ROUTE_STRATEGY_IDS, h as ROUTE_STRATEGIES, i as validateItemGroup, k as sentencesTouching, l as TIMELINE_MAX_TITLE_LENGTH, m as ROUTE_NOTE_MAX_LENGTH, n as RedactedItemGroupSchema, o as TIMELINE_MAX_CHAPTERS, p as READING_ROUTE_ITEM_TYPES, s as TIMELINE_MAX_ITEMS, u as isInteractiveVideoItemType, v as isReadingRouteItemType, w as questionKey, x as quoteText, y as isRouteStrategyId } from "./item-group-BIl1ZJHg.js";
+import { a as dictationJsonSchema, c as itemGroupJsonSchema, d as readAloudJsonSchema, f as stimulusJsonSchema, i as contentJsonSchema, l as jsonSchemaFor, n as validateMedia, o as fillInTheBlanksJsonSchema, p as writtenResponseJsonSchema, r as validateOptionMedia, s as gapSelectJsonSchema, t as validateActivity, u as multipleChoiceJsonSchema } from "./schemas-COw7muXH.js";
+import { a as validateXAPIStatement, i as XAPI_VERB_DISPLAY, n as xapiDefinitionFor, r as XAPIVerb, t as xAPIBuilder } from "./xapi-DHHm7Os9.js";
 // src/delivery.ts
 /**
 * The policy that restricts nothing: every setting `true`. It is what an absent
@@ -2086,6 +2086,6 @@ function critiqueVersions(a, b, options = {}) {
 		}
 	};
 }
-export { AI_COACHING_MAX_TIP_LENGTH, AI_COACHING_MAX_WORDS, AI_CRITIQUE_MAX_FIELD_LENGTH, AI_CRITIQUE_MAX_FINDINGS, AI_DRAFTS_MAX_COUNT, AI_DRAFTS_MAX_REPAIRS, AI_EXPLANATION_TYPES, AI_GRADING_PROBABILITY_TOLERANCE, AI_HINT_TYPES, AI_MATERIAL_MAX_LENGTH, AI_TEXT_MAX_LENGTH, AI_VARIANTS_MAX_EXEMPLARS, AI_VARIANTS_MAX_MATERIAL_LENGTH, AI_VARIANTS_MAX_REPAIRS, AI_VARIANT_CODE_SEVERITY, AI_VARIANT_LENGTH_BANDS, AI_VARIANT_NEAR_COPY_THRESHOLD, AI_WRITING_MAX_CORRECTIONS, AI_WRITING_MAX_FIELD_LENGTH, ActivitySchemaError, BUILT_IN_ACTIVITY_TYPES, 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, DeferredScoringError, INTERACTIVE_VIDEO_ITEM_TYPES, ITEM_SCORING_MAX_RETRIES, OPEN_DELIVERY_POLICY, READING_ROUTE_ITEM_TYPES, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, ROUTE_NOTE_MAX_LENGTH, ROUTE_SEGMENTER, ROUTE_STRATEGIES, ROUTE_STRATEGY_IDS, ROUTE_WORD_LIMIT_MAX, RedactedScoringError, SCRIPT_MAX_TURNS, SPEECH_ASSESSMENT_MAX_WORDS, TIMELINE_MAX_CHAPTERS, TIMELINE_MAX_ITEMS, TIMELINE_MAX_QUIZZES, TIMELINE_MAX_TITLE_LENGTH, UnknownActivityTypeError, VERSION_FINDING_SEVERITY, XAPIVerb, XAPI_VERB_DISPLAY, aiAllowedByContent, aiCoachingRequest, aiCritiqueRequest, aiDraftsRepairRequest, aiDraftsRequest, aiExplanationRequest, aiGradeOf, aiGradingRequest, aiHintRequest, aiSpeakingGradingRequest, aiSupports, aiVariantsRepairRequest, aiVariantsRequest, aiWritingFeedbackRequest, alignDictation, alignReadAloud, assertRedacted, assertRedactedItemGroup, buildAiFacts, calibrationReport, canonicalJson, checkAiCoaching, checkAiCritique, checkAiDrafts, checkAiExplanation, checkAiGrading, checkAiHint, checkAiVariants, checkAiWritingFeedback, classifyBand, combineDeliveryPolicies, composeAssessmentScore, composeTimelineScore, computePassThreshold, contentHash, contentJsonSchema, countParagraphs, countWords, createDraft, createInteractiveVideoDraft, createItemGroupDraft, createReadingRouteDraft, critiqueDraft, critiqueDrafts, critiqueItemGroupDraft, critiqueVersions, defineActivityType, dictationJsonSchema, dictationReferenceWords, dictationType, diffDictationChars, diffResponses, entryKeyOf, evaluate, evaluateTries, fillInTheBlanksJsonSchema, fillInTheBlanksType, findQuote, fingerprint, flattenSequence, gapSelectJsonSchema, gapSelectType, generateDrafts, generateVariants, getActivityTypeDescriptor, gradeFromJudgement, gradeFromRubric, gradeReadAloud, gradeSpeakingResponse, graderConfiguration, gte, hasGrade, hashSeed, hintRevealsAnswer, inAuditSample, inspectWav, interactiveVideoFromDrafts, isBuiltInActivityType, isInteractiveVideoItemType, isItemGroup, isReadingRouteItemType, isRouteStrategyId, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, listMediaRefs, mapMediaRefs, markedSentences, marksFindEvidence, matchText, multipleChoiceJsonSchema, multipleChoiceType, nextRouteLearnerState, outcomeFromGrade, outcomeFromRoutedGrade, outcomeFromUnscorable, overlaps, passageLayout, planAttempt, planMediaBudgets, planRoute, questionKey, quoteText, readAiTextResult, readAloudJsonSchema, readAloudType, readMediaProgress, readRouteLearnerState, readRouteTrace, readingQuizzes, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolveDeliveryPolicy, resolveItemScoringPolicy, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, roundGrade, routeAnswers, routeGrade, routeIssues, routeLevels, routePassageFingerprint, routeStepText, routeTrapText, score, scoreTries, scoredItemsFromPlan, seededShuffle, sentencesTouching, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusJsonSchema, stimulusMediaKey, summarizeRoute, transcriptOf, validateActivity, validateDeliveryPolicy, validateDraft, validateItemGroup, validateItemGroupDraft, validateItemScoringPolicy, validateMedia, validateOptionMedia, validateSpeechAssessment, validateXAPIStatement, verifyAttemptPlan, withoutAuthorOnly, writtenResponseJsonSchema, writtenResponseType, xAPIBuilder, xapiDefinitionFor };
+export { AI_COACHING_MAX_TIP_LENGTH, AI_COACHING_MAX_WORDS, AI_CRITIQUE_MAX_FIELD_LENGTH, AI_CRITIQUE_MAX_FINDINGS, AI_DRAFTS_MAX_COUNT, AI_DRAFTS_MAX_REPAIRS, AI_EXPLANATION_TYPES, AI_GRADING_PROBABILITY_TOLERANCE, AI_HINT_TYPES, AI_MATERIAL_MAX_LENGTH, AI_TEXT_MAX_LENGTH, AI_VARIANTS_MAX_EXEMPLARS, AI_VARIANTS_MAX_MATERIAL_LENGTH, AI_VARIANTS_MAX_REPAIRS, AI_VARIANT_CODE_SEVERITY, AI_VARIANT_LENGTH_BANDS, AI_VARIANT_NEAR_COPY_THRESHOLD, AI_WRITING_MAX_CORRECTIONS, AI_WRITING_MAX_FIELD_LENGTH, ActivitySchemaError, BUILT_IN_ACTIVITY_TYPES, 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, DeferredScoringError, INTERACTIVE_VIDEO_ITEM_TYPES, ITEM_SCORING_MAX_RETRIES, MARK_THE_WORDS_MAX_WORDS, MARK_THE_WORDS_TOKENIZER, OPEN_DELIVERY_POLICY, READING_ROUTE_ITEM_TYPES, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, ROUTE_NOTE_MAX_LENGTH, ROUTE_SEGMENTER, ROUTE_STRATEGIES, ROUTE_STRATEGY_IDS, ROUTE_WORD_LIMIT_MAX, RedactedScoringError, SCRIPT_MAX_TURNS, SPEECH_ASSESSMENT_MAX_WORDS, TIMELINE_MAX_CHAPTERS, TIMELINE_MAX_ITEMS, TIMELINE_MAX_QUIZZES, TIMELINE_MAX_TITLE_LENGTH, UnknownActivityTypeError, VERSION_FINDING_SEVERITY, XAPIVerb, XAPI_VERB_DISPLAY, aiAllowedByContent, aiCoachingRequest, aiCritiqueRequest, aiDraftsRepairRequest, aiDraftsRequest, aiExplanationRequest, aiGradeOf, aiGradingRequest, aiHintRequest, aiSpeakingGradingRequest, aiSupports, aiVariantsRepairRequest, aiVariantsRequest, aiWritingFeedbackRequest, alignDictation, alignReadAloud, assertRedacted, assertRedactedItemGroup, buildAiFacts, calibrationReport, canonicalJson, checkAiCoaching, checkAiCritique, checkAiDrafts, checkAiExplanation, checkAiGrading, checkAiHint, checkAiVariants, checkAiWritingFeedback, classifyBand, combineDeliveryPolicies, composeAssessmentScore, composeTimelineScore, computePassThreshold, contentHash, contentJsonSchema, countParagraphs, countWords, createDraft, createInteractiveVideoDraft, createItemGroupDraft, createReadingRouteDraft, critiqueDraft, critiqueDrafts, critiqueItemGroupDraft, critiqueVersions, defineActivityType, dictationJsonSchema, dictationReferenceWords, dictationType, diffDictationChars, diffResponses, entryKeyOf, evaluate, evaluateTries, fillInTheBlanksJsonSchema, fillInTheBlanksType, findQuote, fingerprint, flattenSequence, gapSelectJsonSchema, gapSelectType, generateDrafts, generateVariants, getActivityTypeDescriptor, gradeFromJudgement, gradeFromRubric, gradeReadAloud, gradeSpeakingResponse, graderConfiguration, gte, hasGrade, hashSeed, hintRevealsAnswer, inAuditSample, inspectWav, interactiveVideoFromDrafts, isBuiltInActivityType, isInteractiveVideoItemType, isItemGroup, isReadingRouteItemType, isRouteStrategyId, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, listMediaRefs, mapMediaRefs, markTargetIndices, markTheWordsFromMarkup, markableWords, markedSentences, marksFindEvidence, matchText, multipleChoiceJsonSchema, multipleChoiceType, nextRouteLearnerState, outcomeFromGrade, outcomeFromRoutedGrade, outcomeFromUnscorable, overlaps, passageLayout, planAttempt, planMediaBudgets, planRoute, questionKey, quoteText, readAiTextResult, readAloudJsonSchema, readAloudType, readMediaProgress, readRouteLearnerState, readRouteTrace, readingQuizzes, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolveDeliveryPolicy, resolveItemScoringPolicy, resolveMarkTarget, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, roundGrade, routeAnswers, routeGrade, routeIssues, routeLevels, routePassageFingerprint, routeStepText, routeTrapText, score, scoreTries, scoredItemsFromPlan, seededShuffle, sentencesTouching, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusJsonSchema, stimulusMediaKey, summarizeRoute, transcriptOf, validateActivity, validateDeliveryPolicy, validateDraft, validateItemGroup, validateItemGroupDraft, validateItemScoringPolicy, validateMedia, validateOptionMedia, validateSpeechAssessment, validateXAPIStatement, verifyAttemptPlan, withoutAuthorOnly, writtenResponseJsonSchema, writtenResponseType, xAPIBuilder, xapiDefinitionFor };
 
 //# sourceMappingURL=index.js.map

package/dist/{item-group-vTcNy2JF.js → item-group-BIl1ZJHg.js}

@@ -1,4 +1,4 @@
-import { $ as GROUP_CAPTIONS_REVEAL_DICTATION, B as countWords, Ct as passageWithoutPlaceholders, Mt as maxUnits, Ot as MediaSchema, St as numberedPassage, Tt as revealsAnswer, a as readSchema, bt as containsWords, et as groupCaptionsField, jt as ScriptSchema, kt as RedactedMediaSchema, t as getActivityTypeDescriptor, wt as placeholderOrder, xt as fold$1 } from "./registry-Cn2it-y7.js";
+import { At as placeholderOrder, Dt as fold$1, Et as containsWords, Ft as RedactedMediaSchema, K as countWords, Lt as ScriptSchema, Ot as numberedPassage, Pt as MediaSchema, Rt as maxUnits, a as readSchema, at as GROUP_CAPTIONS_REVEAL_DICTATION, jt as revealsAnswer, kt as passageWithoutPlaceholders, ot as groupCaptionsField, t as getActivityTypeDescriptor } from "./registry-CroAI5nc.js";
 import * as z from "zod/v4";
 // src/reading-route/layout.ts
 /** Names the segmentation rules below. A change to them is a new name. */
@@ -875,9 +875,9 @@ function routeIssues(group, scope = "content") {
 * plays only when the learner presses play while the video is paused. A
 * dictation must carry its own recording (the timeline rule).
 *
-* `speaking-response` joined in 1.10.0, and `matching` in 1.13.0: a host with
-* an exhaustive `switch` or `Record` over {@link InteractiveVideoItemType}
-* needs one more entry for each.
+* `speaking-response` joined in 1.10.0, `matching` in 1.13.0 and
+* `mark-the-words` in 1.14.0: a host with an exhaustive `switch` or `Record`
+* over {@link InteractiveVideoItemType} needs one more entry for each.
 */
 const INTERACTIVE_VIDEO_ITEM_TYPES = [
 	"multiple-choice",
@@ -886,7 +886,8 @@ const INTERACTIVE_VIDEO_ITEM_TYPES = [
 	"dictation",
 	"read-aloud",
 	"speaking-response",
-	"matching"
+	"matching",
+	"mark-the-words"
 ];
 /** Whether `type` is one of the item types an interactive video may present. */
 function isInteractiveVideoItemType(type) {
@@ -1403,4 +1404,4 @@ function validateItemGroup(data) {
 }
 export { itemQuestions as C, overlaps as D, countParagraphs as E, passageLayout as O, choicesOf as S, ROUTE_SEGMENTER as T, ROUTE_WORD_LIMIT_MAX as _, INTERACTIVE_VIDEO_ITEM_TYPES as a, findQuote as b, TIMELINE_MAX_QUIZZES as c, readingQuizzes as d, routeIssues as f, ROUTE_STRATEGY_IDS as g, ROUTE_STRATEGIES as h, validateItemGroup as i, sentencesTouching as k, TIMELINE_MAX_TITLE_LENGTH as l, ROUTE_NOTE_MAX_LENGTH as m, RedactedItemGroupSchema as n, TIMELINE_MAX_CHAPTERS as o, READING_ROUTE_ITEM_TYPES as p, StimulusSchema as r, TIMELINE_MAX_ITEMS as s, ItemGroupSchema as t, isInteractiveVideoItemType as u, isReadingRouteItemType as v, questionKey as w, quoteText as x, isRouteStrategyId as y };
 
-//# sourceMappingURL=item-group-vTcNy2JF.js.map
+//# sourceMappingURL=item-group-BIl1ZJHg.js.map

package/dist/item-group-BIl1ZJHg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-group-BIl1ZJHg.js","names":["isFields","list","fold"],"sources":["../src/reading-route/layout.ts","../src/reading-route/questions.ts","../src/reading-route/quotes.ts","../src/reading-route/strategies.ts","../src/reading-route/check.ts","../src/timeline-limits.ts","../src/schemas/item-group.ts"],"sourcesContent":["/**\n * The passage cut into paragraphs and sentences, by rules of the SDK's own.\n *\n * `Intl.Segmenter` would be shorter, and wrong here: engines segment\n * differently and change between versions, and a learner's \"found the\n * evidence\" must not depend on their browser. These rules are plain code, so\n * a server and every browser cut the same passage the same way, and a trace's\n * sentence numbers mean one thing. They change only with\n * {@link ROUTE_SEGMENTER}.\n */\n\nimport type {\n  PassageLayout,\n  PassageParagraph,\n  PassageSection,\n  PassageSentence,\n  RouteSection,\n  TextRange,\n} from '../types/reading-route.js';\n\n/** Names the segmentation rules below. A change to them is a new name. */\nexport const ROUTE_SEGMENTER = 'lk-sentences@1';\n\nconst TERMINALS = new Set(['.', '!', '?', '…', '‼', '⁇', '⁈', '⁉']);\n/** Terminals of scripts written without spaces: a sentence ends at them outright. */\nconst CLOSED_TERMINALS = new Set(['。', '！', '？', '｡']);\nconst CLOSERS = new Set(['\"', \"'\", '”', '’', ')', ']', '}', '»', '›', '」', '』', '）']);\n\n/**\n * Words a full stop follows without ending a sentence. Lower case, without\n * their dots. `etc` is not one: it ends sentences as often as not, and a\n * capital after it says which.\n */\nconst ABBREVIATIONS = new Set([\n  'mr',\n  'mrs',\n  'ms',\n  'dr',\n  'prof',\n  'sr',\n  'jr',\n  'st',\n  'mt',\n  'vs',\n  'fig',\n  'figs',\n  'vol',\n  'approx',\n  'ca',\n  'cf',\n  'eg',\n  'ie',\n  'inc',\n  'ltd',\n  'co',\n  'corp',\n  'jan',\n  'feb',\n  'mar',\n  'apr',\n  'jun',\n  'jul',\n  'aug',\n  'sep',\n  'sept',\n  'oct',\n  'nov',\n  'dec',\n  'gen',\n  'gov',\n  'rev',\n  'ed',\n  'eds',\n  'pp',\n  'no',\n]);\n\nconst isSpace = (char: string | undefined): boolean => char !== undefined && /\\s/u.test(char);\nconst isLower = (char: string | undefined): boolean => char !== undefined && /\\p{Ll}/u.test(char);\n\n/** The word before a full stop at `dot`, letters and inner dots only (\"e.g\", \"U.S\"). */\nfunction wordBefore(text: string, dot: number): string {\n  let start = dot;\n  while (start > 0 && /[\\p{L}.]/u.test(text[start - 1] as string)) {\n    start -= 1;\n  }\n  return text.slice(start, dot);\n}\n\n/** Whether the full stop at `dot` follows an abbreviation or an initial (\"J. K.\", \"U.S.\"). */\nfunction abbreviated(text: string, dot: number): boolean {\n  const word = wordBefore(text, dot);\n  if (word === '') {\n    return false;\n  }\n  const last = word.split('.').at(-1) as string;\n  if (last.length === 1 && /\\p{Lu}/u.test(last)) {\n    return true;\n  }\n  return ABBREVIATIONS.has(word.replaceAll('.', '').toLowerCase());\n}\n\n/** `range` with whitespace trimmed off both ends; `null` when nothing is left. */\nfunction trimmed(text: string, start: number, end: number): TextRange | null {\n  let from = start;\n  let to = end;\n  while (from < to && isSpace(text[from])) {\n    from += 1;\n  }\n  while (to > from && isSpace(text[to - 1])) {\n    to -= 1;\n  }\n  return from < to ? { start: from, end: to } : null;\n}\n\n/** The sentences of `text.slice(start, end)`: one paragraph. A line break always ends one. */\nfunction sentencesIn(text: string, start: number, end: number): TextRange[] {\n  const found: TextRange[] = [];\n  let from = start;\n  const close = (to: number, next: number): void => {\n    const range = trimmed(text, from, to);\n    if (range !== null) {\n      found.push(range);\n    }\n    from = next;\n  };\n  let index = start;\n  while (index < end) {\n    const char = text[index] as string;\n    if (char === '\\n') {\n      close(index, index + 1);\n      index += 1;\n      continue;\n    }\n    if (CLOSED_TERMINALS.has(char)) {\n      let after = index + 1;\n      while (after < end && CLOSERS.has(text[after] as string)) {\n        after += 1;\n      }\n      close(after, after);\n      index = after;\n      continue;\n    }\n    if (!TERMINALS.has(char)) {\n      index += 1;\n      continue;\n    }\n    let after = index + 1;\n    while (after < end && TERMINALS.has(text[after] as string)) {\n      after += 1;\n    }\n    while (after < end && CLOSERS.has(text[after] as string)) {\n      after += 1;\n    }\n    if (after >= end) {\n      close(end, end);\n      index = end;\n      continue;\n    }\n    if (!isSpace(text[after])) {\n      // \"3.5\", \"e.g.,\", \"www.example.org\": no space, no sentence end.\n      index = after;\n      continue;\n    }\n    let next = after;\n    while (next < end && text[next] !== '\\n' && isSpace(text[next])) {\n      next += 1;\n    }\n    const continues =\n      isLower(text[next]) || (char === '.' && after === index + 1 && abbreviated(text, index));\n    if (!continues) {\n      close(after, after);\n    }\n    index = after;\n  }\n  close(end, end);\n  return found;\n}\n\n/** The paragraphs of `body`: runs of text between blank lines. */\nfunction paragraphRanges(body: string): TextRange[] {\n  const ranges: TextRange[] = [];\n  const blank = /\\n[^\\S\\n]*\\n\\s*/gu;\n  let from = 0;\n  for (const match of body.matchAll(blank)) {\n    const range = trimmed(body, from, match.index);\n    if (range !== null) {\n      ranges.push(range);\n    }\n    from = match.index + match[0].length;\n  }\n  const last = trimmed(body, from, body.length);\n  if (last !== null) {\n    ranges.push(last);\n  }\n  return ranges;\n}\n\n/** How many paragraphs `body` has, by the rules {@link passageLayout} uses. */\nexport function countParagraphs(body: string): number {\n  return paragraphRanges(body).length;\n}\n\n/**\n * The passage cut into paragraphs and sentences. Paragraph labels and sections\n * are applied when they fit; the checks report when they do not.\n */\nexport function passageLayout(\n  body: string,\n  route?: { paragraphLabels?: readonly string[]; sections?: readonly RouteSection[] },\n): PassageLayout {\n  const ranges = paragraphRanges(body);\n  const labels = route?.paragraphLabels;\n  const sectionList = route?.sections ?? [];\n  const sections: PassageSection[] = [];\n  const sectionOf: number[] = [];\n  const fits =\n    sectionList.reduce((total, section) => total + section.paragraphs, 0) === ranges.length;\n  if (fits) {\n    let first = 0;\n    sectionList.forEach((section, index) => {\n      const last = first + section.paragraphs - 1;\n      sections.push({\n        label: section.label,\n        ...(section.title !== undefined ? { title: section.title } : {}),\n        first,\n        last,\n      });\n      for (let paragraph = first; paragraph <= last; paragraph += 1) {\n        sectionOf[paragraph] = index;\n      }\n      first = last + 1;\n    });\n  }\n  const labelled = labels !== undefined && labels.length === ranges.length;\n  const paragraphs: PassageParagraph[] = [];\n  const sentences: PassageSentence[] = [];\n  ranges.forEach((range, index) => {\n    const label = labelled ? (labels[index] as string) : '';\n    const section = sectionOf[index];\n    paragraphs.push({\n      index,\n      start: range.start,\n      end: range.end,\n      ...(label !== '' ? { label } : {}),\n      ...(section !== undefined ? { section } : {}),\n    });\n    for (const sentence of sentencesIn(body, range.start, range.end)) {\n      sentences.push({ index: sentences.length, paragraph: index, ...sentence });\n    }\n  });\n  return { paragraphs, sentences, sections };\n}\n\n/** Whether two ranges share at least one character. */\nexport function overlaps(a: TextRange, b: TextRange): boolean {\n  return a.start < b.end && b.start < a.end;\n}\n\n/** The sentences a range touches, in order. */\nexport function sentencesTouching(layout: PassageLayout, range: TextRange): number[] {\n  return layout.sentences.filter((sentence) => overlaps(sentence, range)).map((s) => s.index);\n}\n","/**\n * The questions of a routed group, read off its items: one per multiple-choice\n * item, one per blank, gap or prompt of the others, numbered as on the paper. Read\n * defensively, because the checks run on drafts and on redacted items.\n */\n\nimport { passageWithoutPlaceholders, placeholderOrder } from '../answer-leak.js';\n\n/** A question as the items define it, before the route says anything about it. */\nexport interface ItemQuestion {\n  key: string;\n  itemId: string;\n  partId?: string;\n  itemIndex: number;\n  /** 0-based position among the group's questions. */\n  position: number;\n  type: string;\n}\n\ntype Fields = Record<string, unknown>;\n\nconst isFields = (value: unknown): value is Fields =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\nconst text = (value: unknown): string => (typeof value === 'string' ? value : '');\n\nconst list = (value: unknown): Fields[] => (Array.isArray(value) ? value.filter(isFields) : []);\n\n/** `itemId`, or `itemId#partId`: a question's name in traces and summaries. */\nexport function questionKey(itemId: string, partId?: string): string {\n  return partId === undefined ? itemId : `${itemId}#${partId}`;\n}\n\n/**\n * The ids of an item's parts in the order the learner answers them: its blanks\n * or gaps in passage order, its prompts in list order, or none for multiple\n * choice.\n */\nexport function partIdsOf(item: unknown): string[] | null {\n  if (!isFields(item)) {\n    return null;\n  }\n  if (item.type === 'multiple-choice') {\n    return null;\n  }\n  if (item.type === 'matching') {\n    const ids = list(item.prompts)\n      .map((prompt) => prompt.id)\n      .filter((id): id is string => typeof id === 'string' && id !== '');\n    return [...new Set(ids)];\n  }\n  const declared = list(item.type === 'gap-select' ? item.gaps : item.blanks)\n    .map((part) => part.id)\n    .filter((id): id is string => typeof id === 'string' && id !== '');\n  const order = placeholderOrder(text(item.passage)).filter((id) => declared.includes(id));\n  const rest = declared.filter((id) => !order.includes(id));\n  return [...new Set([...order, ...rest])];\n}\n\n/** Every question of the group's items, in paper order. */\nexport function itemQuestions(items: readonly unknown[]): ItemQuestion[] {\n  const found: ItemQuestion[] = [];\n  items.forEach((item, itemIndex) => {\n    if (!isFields(item) || typeof item.id !== 'string') {\n      return;\n    }\n    const type = text(item.type);\n    const parts = partIdsOf(item);\n    if (parts === null) {\n      found.push({\n        key: questionKey(item.id),\n        itemId: item.id,\n        itemIndex,\n        position: found.length,\n        type,\n      });\n      return;\n    }\n    for (const partId of parts) {\n      found.push({\n        key: questionKey(item.id, partId),\n        itemId: item.id,\n        partId,\n        itemIndex,\n        position: found.length,\n        type,\n      });\n    }\n  });\n  return found;\n}\n\n/** What the learner reads of an item: its instructions, question, passage or prompts, and its options or choices. */\nexport function learnerTextOf(item: unknown): string {\n  if (!isFields(item)) {\n    return '';\n  }\n  const parts = [text(item.instructions)];\n  if (item.type === 'multiple-choice') {\n    parts.push(text(item.question), ...list(item.options).map((option) => text(option.text)));\n  } else if (item.type === 'matching') {\n    parts.push(\n      text(item.optionsTitle),\n      ...list(item.prompts).map((prompt) => text(prompt.text)),\n      ...list(item.options).map((option) => text(option.text)),\n    );\n  } else {\n    parts.push(passageWithoutPlaceholders(text(item.passage)));\n    for (const gap of list(item.gaps)) {\n      parts.push(...list(gap.choices).map((choice) => text(choice.text)));\n    }\n    for (const bank of list(item.banks)) {\n      parts.push(...list(bank.choices).map((choice) => text(choice.text)));\n    }\n  }\n  return parts.filter((part) => part !== '').join('\\n');\n}\n\n/** The options or choices a question offers, by id, with their text and whether each is right. */\nexport function choicesOf(\n  item: unknown,\n  partId?: string,\n): { id: string; text: string; correct: boolean }[] {\n  if (!isFields(item)) {\n    return [];\n  }\n  if (item.type === 'multiple-choice') {\n    return list(item.options)\n      .filter((option) => typeof option.id === 'string')\n      .map((option) => ({\n        id: option.id as string,\n        text: text(option.text),\n        correct: option.isCorrect === true,\n      }));\n  }\n  if (item.type === 'matching') {\n    const prompt = list(item.prompts).find((candidate) => candidate.id === partId);\n    if (prompt === undefined) {\n      return [];\n    }\n    return list(item.options)\n      .filter((option) => typeof option.id === 'string')\n      .map((option) => ({\n        id: option.id as string,\n        text: text(option.text),\n        correct: option.id === prompt.correctOptionId,\n      }));\n  }\n  if (item.type !== 'gap-select') {\n    return [];\n  }\n  const gap = list(item.gaps).find((candidate) => candidate.id === partId);\n  if (gap === undefined) {\n    return [];\n  }\n  const bank = list(item.banks).find((candidate) => candidate.id === gap.bankId);\n  const offered = gap.choices !== undefined ? list(gap.choices) : list(bank?.choices);\n  return offered\n    .filter((choice) => typeof choice.id === 'string')\n    .map((choice) => ({\n      id: choice.id as string,\n      text: text(choice.text),\n      correct: choice.id === gap.correctChoiceId,\n    }));\n}\n\n/** The accepted answers of a blank. */\nexport function acceptedAnswersOf(item: unknown, partId?: string): string[] {\n  if (!isFields(item) || item.type !== 'fill-in-the-blanks') {\n    return [];\n  }\n  const blank = list(item.blanks).find((candidate) => candidate.id === partId);\n  return Array.isArray(blank?.acceptedAnswers)\n    ? blank.acceptedAnswers.filter((answer): answer is string => typeof answer === 'string')\n    : [];\n}\n\n/** 1-based position of a blank or gap among its item's placeholders, for the leak check. */\nexport function placeholderPosition(item: unknown, partId?: string): number | undefined {\n  if (!isFields(item) || partId === undefined) {\n    return undefined;\n  }\n  const index = placeholderOrder(text(item.passage)).indexOf(partId);\n  return index === -1 ? undefined : index + 1;\n}\n","/**\n * Finding a route's quotes in the passage. A quote is the words themselves,\n * so it survives an edit elsewhere in the passage; it is matched ignoring\n * runs of whitespace and the difference between curly and straight quotation\n * marks — what copying words out of a document changes — and nothing else.\n */\n\nimport type { RouteQuote, TextRange } from '../types/reading-route.js';\n\nconst FOLDED: Readonly<Record<string, string>> = {\n  '‘': \"'\",\n  '’': \"'\",\n  '‛': \"'\",\n  '′': \"'\",\n  '“': '\"',\n  '”': '\"',\n  '„': '\"',\n  '″': '\"',\n};\n\n/** A text folded for matching, and for each folded character the index it came from. */\ninterface Folded {\n  text: string;\n  origin: number[];\n}\n\nfunction fold(text: string): Folded {\n  let folded = '';\n  const origin: number[] = [];\n  let space = false;\n  for (let index = 0; index < text.length; index += 1) {\n    const char = text[index] as string;\n    if (/\\s/u.test(char)) {\n      if (!space && folded !== '') {\n        folded += ' ';\n        origin.push(index);\n      }\n      space = true;\n      continue;\n    }\n    space = false;\n    folded += FOLDED[char] ?? char;\n    origin.push(index);\n  }\n  if (folded.endsWith(' ')) {\n    folded = folded.slice(0, -1);\n    origin.pop();\n  }\n  return { text: folded, origin };\n}\n\n/** The text of a quote, whichever form it takes. Non-strings read as empty. */\nexport function quoteText(quote: RouteQuote | unknown): string {\n  if (typeof quote === 'string') {\n    return quote;\n  }\n  if (\n    typeof quote === 'object' &&\n    quote !== null &&\n    typeof (quote as { text?: unknown }).text === 'string'\n  ) {\n    return (quote as { text: string }).text;\n  }\n  return '';\n}\n\nfunction occurrenceOf(quote: RouteQuote | unknown): number | undefined {\n  if (typeof quote !== 'object' || quote === null) {\n    return undefined;\n  }\n  const occurrence = (quote as { occurrence?: unknown }).occurrence;\n  return typeof occurrence === 'number' ? occurrence : undefined;\n}\n\n/** What finding a quote came to. */\nexport type QuoteMatch =\n  | { found: true; range: TextRange }\n  | { found: false; reason: 'empty' | 'missing' | 'ambiguous' | 'occurrence'; count: number };\n\n/**\n * Where `quote` is in `body`. Every occurrence is counted, overlapping ones\n * included, so \"a a\" in \"a a a\" is ambiguous rather than silently the first.\n */\nexport function findQuote(body: string, quote: RouteQuote | unknown): QuoteMatch {\n  const needle = fold(quoteText(quote)).text;\n  if (needle === '') {\n    return { found: false, reason: 'empty', count: 0 };\n  }\n  const hay = fold(body);\n  const starts: number[] = [];\n  let at = hay.text.indexOf(needle);\n  while (at !== -1) {\n    starts.push(at);\n    at = hay.text.indexOf(needle, at + 1);\n  }\n  if (starts.length === 0) {\n    return { found: false, reason: 'missing', count: 0 };\n  }\n  const occurrence = occurrenceOf(quote);\n  if (occurrence === undefined && starts.length > 1) {\n    return { found: false, reason: 'ambiguous', count: starts.length };\n  }\n  const chosen = starts[(occurrence ?? 1) - 1];\n  if (chosen === undefined) {\n    return { found: false, reason: 'occurrence', count: starts.length };\n  }\n  const start = hay.origin[chosen] as number;\n  const end = (hay.origin[chosen + needle.length - 1] as number) + 1;\n  return { found: true, range: { start, end } };\n}\n\n/** Whether `phrase` occurs in `text`, by the same folding as quotes, ignoring case. */\nexport function containsPhrase(text: string, phrase: string): boolean {\n  const needle = fold(phrase).text.toLowerCase();\n  return needle !== '' && fold(text).text.toLowerCase().includes(needle);\n}\n","/**\n * The strategy library: for each exam reading task, the order in which a\n * skilled candidate looks, and what they do at each look. A leaf module: the\n * schemas, the checks and the planner read it, and it imports none of them.\n *\n * What the steps rest on (the guide, `docs/reading-route.md`, cites each):\n * successful candidates find a small relevant part of the text and read it\n * carefully, where weaker ones read larger chunks for longer; exam reading\n * interleaves fast search with careful reading of what was found; answers are\n * hidden behind paraphrase, and a word-for-word match is the classic\n * distractor; skimming keeps the gist and structure, not details.\n */\n\nimport type { RouteMoveId, RouteStrategyId } from '../types/reading-route.js';\n\n/**\n * The item types a reading route may hold: the ones every common exam reading\n * task is written in. CLOSED on purpose, as an interactive video's list is: a\n * type added later is not silently routable.\n */\nexport const READING_ROUTE_ITEM_TYPES = [\n  'multiple-choice',\n  'fill-in-the-blanks',\n  'gap-select',\n  'matching',\n] as const;\n\n/** One of {@link READING_ROUTE_ITEM_TYPES}. */\nexport type ReadingRouteItemType = (typeof READING_ROUTE_ITEM_TYPES)[number];\n\n/** Whether `type` is one of the item types a reading route may hold. */\nexport function isReadingRouteItemType(type: unknown): type is ReadingRouteItemType {\n  return (READING_ROUTE_ITEM_TYPES as readonly unknown[]).includes(type);\n}\n\n/** How a strategy is planned. */\nexport interface RouteStrategy {\n  id: RouteStrategyId;\n  /** Its name, in English, as a learner meets it. */\n  title: string;\n  /** The exam tasks it serves, in English, for authors. */\n  serves: string;\n  /** The item types it can be written in. */\n  itemTypes: readonly ReadingRouteItemType[];\n  /** Its steps, in order. `survey` is planned once, before the route's first question. */\n  moves: readonly RouteMoveId[];\n  /** Whether the answers come in the order of the text, so each search starts after the previous answer. */\n  followsOrder: boolean;\n}\n\nconst CHOICE: readonly ReadingRouteItemType[] = ['multiple-choice', 'gap-select'];\n\n/** The tasks that match prompts to a shared list: written one question per item, or as one matching item. */\nconst MATCHING: readonly ReadingRouteItemType[] = ['multiple-choice', 'gap-select', 'matching'];\n\n/**\n * The built-in strategies. Data, versioned with lk-core: a route stores only\n * a strategy's id, so a learner always meets the current steps.\n */\nexport const ROUTE_STRATEGIES: Readonly<Record<RouteStrategyId, RouteStrategy>> = Object.freeze({\n  tfng: {\n    id: 'tfng',\n    title: 'True / False / Not Given',\n    serves: 'IELTS identifying information.',\n    itemTypes: CHOICE,\n    moves: ['read-instructions', 'keywords', 'locate', 'read-around', 'paraphrase', 'decide'],\n    followsOrder: true,\n  },\n  ynng: {\n    id: 'ynng',\n    title: 'Yes / No / Not Given',\n    serves: \"IELTS identifying the writer's views or claims.\",\n    itemTypes: CHOICE,\n    moves: ['read-instructions', 'keywords', 'locate', 'read-around', 'paraphrase', 'decide'],\n    followsOrder: true,\n  },\n  'multiple-choice': {\n    id: 'multiple-choice',\n    title: 'Multiple choice',\n    serves: 'IELTS multiple choice; Cambridge C1 Advanced and C2 Proficiency Part 5.',\n    itemTypes: ['multiple-choice'],\n    moves: ['keywords', 'predict', 'locate', 'read-around', 'paraphrase', 'eliminate'],\n    followsOrder: true,\n  },\n  'matching-headings': {\n    id: 'matching-headings',\n    title: 'Matching headings',\n    serves: 'IELTS matching headings.',\n    itemTypes: MATCHING,\n    moves: ['survey', 'locate', 'paraphrase', 'eliminate'],\n    followsOrder: false,\n  },\n  'matching-information': {\n    id: 'matching-information',\n    title: 'Matching information',\n    serves: 'IELTS matching information (\"Which paragraph contains...\").',\n    itemTypes: MATCHING,\n    moves: ['keywords', 'locate', 'read-around', 'paraphrase'],\n    followsOrder: false,\n  },\n  'matching-features': {\n    id: 'matching-features',\n    title: 'Matching features',\n    serves: 'IELTS matching features (people, dates, places to statements).',\n    itemTypes: MATCHING,\n    moves: ['keywords', 'locate', 'read-around', 'paraphrase'],\n    followsOrder: false,\n  },\n  'multiple-matching': {\n    id: 'multiple-matching',\n    title: 'Multiple matching',\n    serves: 'Cambridge C1 Advanced Part 8 and C2 Proficiency Part 7.',\n    itemTypes: MATCHING,\n    moves: ['survey', 'keywords', 'locate', 'read-around', 'paraphrase'],\n    followsOrder: false,\n  },\n  'sentence-endings': {\n    id: 'sentence-endings',\n    title: 'Matching sentence endings',\n    serves: 'IELTS matching sentence endings.',\n    itemTypes: MATCHING,\n    moves: ['keywords', 'predict', 'locate', 'read-around', 'eliminate'],\n    followsOrder: true,\n  },\n  completion: {\n    id: 'completion',\n    title: 'Completion',\n    serves: 'IELTS sentence, note, table and flow-chart completion, and short answers.',\n    itemTypes: ['fill-in-the-blanks'],\n    moves: ['read-instructions', 'keywords', 'predict', 'locate', 'read-around', 'check-answer'],\n    followsOrder: true,\n  },\n  'summary-word-list': {\n    id: 'summary-word-list',\n    title: 'Summary completion from a list',\n    serves: 'IELTS summary completion with a list of words.',\n    itemTypes: ['gap-select'],\n    moves: ['keywords', 'predict', 'locate', 'read-around', 'paraphrase', 'check-answer'],\n    followsOrder: false,\n  },\n  'gapped-text': {\n    id: 'gapped-text',\n    title: 'Gapped text',\n    serves: 'Cambridge C1 Advanced Part 7 and C2 Proficiency Part 6.',\n    itemTypes: MATCHING,\n    moves: ['survey', 'locate', 'cohesion', 'eliminate'],\n    followsOrder: false,\n  },\n  'cross-text': {\n    id: 'cross-text',\n    title: 'Cross-text matching',\n    serves: 'Cambridge C1 Advanced Part 6.',\n    itemTypes: MATCHING,\n    moves: ['survey', 'keywords', 'locate', 'compare-views'],\n    followsOrder: false,\n  },\n});\n\n/** Every built-in strategy id, in the library's order. */\nexport const ROUTE_STRATEGY_IDS = Object.freeze(\n  Object.keys(ROUTE_STRATEGIES),\n) as readonly RouteStrategyId[];\n\n/** Whether `id` names a built-in strategy. */\nexport function isRouteStrategyId(id: unknown): id is RouteStrategyId {\n  return typeof id === 'string' && Object.hasOwn(ROUTE_STRATEGIES, id);\n}\n\n/** The most characters an author's note on a step may have. */\nexport const ROUTE_NOTE_MAX_LENGTH = 280;\n\n/** The longest word limit a completion question may set. */\nexport const ROUTE_WORD_LIMIT_MAX = 10;\n","/**\n * The rules a reading route keeps, beyond its shape: every question of the\n * group has exactly one entry, every quote is in the passage once, the words\n * an author adds never give the answer away, and the strategy fits the item.\n *\n * One list of rules serves the stored schema (every rule refuses) and the\n * draft checks (each code with its own severity), so the two cannot drift.\n * Read defensively: drafts and redacted groups reach it as they are.\n */\n\nimport { containsWords, fold, numberedPassage, revealsAnswer } from '../answer-leak.js';\nimport { countWords } from '../count-words.js';\nimport { countParagraphs } from './layout.js';\nimport {\n  acceptedAnswersOf,\n  choicesOf,\n  itemQuestions,\n  learnerTextOf,\n  partIdsOf,\n  placeholderPosition,\n  questionKey,\n} from './questions.js';\nimport { containsPhrase, findQuote, quoteText } from './quotes.js';\nimport {\n  isReadingRouteItemType,\n  isRouteStrategyId,\n  READING_ROUTE_ITEM_TYPES,\n  ROUTE_NOTE_MAX_LENGTH,\n  ROUTE_STRATEGIES,\n} from './strategies.js';\n\n/** The codes a route's rules report. Each one's severity is in `DRAFT_ISSUE_SEVERITY`. */\nexport type RouteIssueCode =\n  | 'ig_route_stimulus_kind'\n  | 'ig_route_body_required'\n  /**\n   * @deprecated Reported by 1.11.0 only, for a route in an interactive video,\n   * which 1.12.0 allows: a video's reading quizzes. Never reported since;\n   * kept so code that names it still compiles.\n   */\n  | 'ig_route_with_timeline'\n  | 'ig_route_quiz_mixed'\n  | 'ig_route_shuffle'\n  | 'ig_route_item_type'\n  | 'ig_route_question_item_unknown'\n  | 'ig_route_question_part_required'\n  | 'ig_route_question_part_unknown'\n  | 'ig_route_question_part_not_allowed'\n  | 'ig_route_question_duplicate'\n  | 'ig_route_question_missing'\n  | 'ig_route_strategy_required'\n  | 'ig_route_strategy_unknown'\n  | 'ig_route_strategy_item_type'\n  | 'ig_route_evidence_required'\n  | 'ig_route_quote_not_found'\n  | 'ig_route_quote_ambiguous'\n  | 'ig_route_keyword_not_in_question'\n  | 'ig_route_trap_option_unknown'\n  | 'ig_route_trap_on_answer'\n  | 'ig_route_note_move_unknown'\n  | 'ig_route_note_too_long'\n  | 'ig_route_note_reveals_answer'\n  | 'ig_route_word_limit_type'\n  | 'ig_route_answer_over_limit'\n  | 'ig_route_paragraph_labels'\n  | 'ig_route_sections';\n\nexport interface RouteIssue {\n  code: RouteIssueCode;\n  path: (string | number)[];\n  message: string;\n}\n\ntype Fields = Record<string, unknown>;\n\nconst isFields = (value: unknown): value is Fields =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\nconst unset = (value: unknown): boolean =>\n  value === undefined || value === null || (typeof value === 'string' && value.trim() === '');\n\nconst list = (value: unknown): unknown[] => (Array.isArray(value) ? value : []);\n\n/**\n * Whether an author's note gives a question's answer away. For a choice, a\n * note that names the right option and not every other one; naming them all —\n * \"True if it agrees, False if it contradicts, Not Given if it is silent\" — is\n * the rule, not the answer.\n */\n/** What one question of an item with parts is called: a blank, a gap or a prompt. */\nfunction partNoun(type: unknown, capital: boolean): string {\n  const noun = type === 'fill-in-the-blanks' ? 'blank' : type === 'matching' ? 'prompt' : 'gap';\n  return capital ? `${noun[0]?.toUpperCase()}${noun.slice(1)}` : noun;\n}\n\nfunction noteRevealsAnswer(item: unknown, partId: string | undefined, note: string): boolean {\n  const accepted = acceptedAnswersOf(item, partId);\n  if (accepted.length > 0) {\n    const passage = numberedPassage(\n      typeof (item as Fields).passage === 'string' ? ((item as Fields).passage as string) : '',\n    );\n    const position = placeholderPosition(item, partId);\n    return accepted.some((answer) => revealsAnswer(note, answer, passage, position));\n  }\n  const choices = choicesOf(item, partId);\n  const words = fold(note);\n  const named = choices.filter((choice) => containsWords(words, fold(choice.text)));\n  return named.some((choice) => choice.correct) && named.length < choices.length;\n}\n\n/**\n * The quizzes of an interactive video that are reading quizzes: every question\n * in them has a route entry. In practice the player opens each as a reading\n * route over the stimulus's text; in an exam or a review, as an ordinary quiz.\n * Empty for a group with no timeline or no route.\n */\nexport function readingQuizzes(group: unknown): string[] {\n  if (!isFields(group) || !isFields(group.route) || !isFields(group.timeline)) {\n    return [];\n  }\n  const routed = new Set(\n    list(group.route.questions).flatMap((question) =>\n      isFields(question) && typeof question.itemId === 'string' ? [question.itemId] : [],\n    ),\n  );\n  return list(group.timeline.cues).flatMap((cue) => {\n    if (!isFields(cue) || typeof cue.id !== 'string') {\n      return [];\n    }\n    const ids = list(cue.itemIds);\n    return ids.length > 0 && ids.every((id) => routed.has(id as string)) ? [cue.id] : [];\n  });\n}\n\n/**\n * Every rule the route of `group` breaks. `scope: 'redacted'` checks only what\n * a learner's copy still carries: the evidence, key words, traps and notes are\n * gone from it.\n */\nexport function routeIssues(\n  group: unknown,\n  scope: 'content' | 'redacted' = 'content',\n): RouteIssue[] {\n  if (!isFields(group) || !isFields(group.route)) {\n    return [];\n  }\n  const route = group.route;\n  const issues: RouteIssue[] = [];\n  const add = (code: RouteIssueCode, path: (string | number)[], message: string): void => {\n    issues.push({ code, path, message });\n  };\n\n  const stimulus = isFields(group.stimulus) ? group.stimulus : undefined;\n  const body = typeof stimulus?.body === 'string' ? stimulus.body : '';\n  // In an interactive video the passage is the video stimulus's `body`, read in\n  // the quizzes the route covers (see `readingQuizzes`).\n  const timeline = isFields(group.timeline) ? group.timeline : undefined;\n  const kinds = timeline === undefined ? ['text', 'mixed'] : ['text', 'mixed', 'video'];\n  if (stimulus !== undefined && !unset(stimulus.kind) && !kinds.includes(stimulus.kind as string)) {\n    add(\n      'ig_route_stimulus_kind',\n      ['stimulus', 'kind'],\n      'A reading route needs a text to read: make the stimulus a text.',\n    );\n  } else if (stimulus !== undefined && body.trim() === '') {\n    add(\n      'ig_route_body_required',\n      ['stimulus', 'body'],\n      timeline === undefined\n        ? 'Add the passage the questions are about.'\n        : \"Add the passage the video's reading quizzes are about, as the stimulus's text.\",\n    );\n  }\n  if (group.shuffle === 'within-group') {\n    add(\n      'ig_route_shuffle',\n      ['shuffle'],\n      'A reading route keeps its questions in paper order: many answers follow the order of the text.',\n    );\n  }\n\n  const items = list(group.items);\n  // In a video, only the items of its reading quizzes are the route's; the\n  // other quizzes hold whatever a video may.\n  const routed = new Set(\n    list(route.questions).flatMap((question) =>\n      isFields(question) && typeof question.itemId === 'string' ? [question.itemId] : [],\n    ),\n  );\n  const covered = (itemId: unknown): boolean => {\n    if (timeline === undefined) {\n      return true;\n    }\n    return list(timeline.cues).some(\n      (cue) =>\n        isFields(cue) &&\n        list(cue.itemIds).includes(itemId) &&\n        list(cue.itemIds).some((id) => routed.has(id as string)),\n    );\n  };\n  if (timeline !== undefined) {\n    list(timeline.cues).forEach((cue, index) => {\n      if (!isFields(cue)) {\n        return;\n      }\n      const ids = list(cue.itemIds);\n      const inRoute = ids.filter((id) => routed.has(id as string)).length;\n      if (inRoute > 0 && inRoute < ids.length) {\n        add(\n          'ig_route_quiz_mixed',\n          ['timeline', 'cues', index, 'itemIds'],\n          'A quiz is a reading quiz when the route covers all of its questions, or an ordinary one when it covers none.',\n        );\n      }\n    });\n  }\n  items.forEach((item, index) => {\n    if (\n      isFields(item) &&\n      !unset(item.type) &&\n      !isReadingRouteItemType(item.type) &&\n      covered(item.id)\n    ) {\n      add(\n        'ig_route_item_type',\n        ['items', index, 'type'],\n        `A reading route holds ${READING_ROUTE_ITEM_TYPES.join(', ')} questions; \"${String(item.type)}\" is not one of them.`,\n      );\n    }\n  });\n  const itemsById = new Map<string, unknown>();\n  for (const item of items) {\n    if (isFields(item) && typeof item.id === 'string') {\n      itemsById.set(item.id, item);\n    }\n  }\n\n  if (body !== '' && route.paragraphLabels !== undefined) {\n    const paragraphs = countParagraphs(body);\n    if (!Array.isArray(route.paragraphLabels) || route.paragraphLabels.length !== paragraphs) {\n      add(\n        'ig_route_paragraph_labels',\n        ['route', 'paragraphLabels'],\n        `The passage has ${paragraphs} paragraphs (separated by blank lines); give one label for each, or \"\" to leave one unlabelled.`,\n      );\n    }\n  }\n  if (body !== '' && Array.isArray(route.sections)) {\n    const paragraphs = countParagraphs(body);\n    const covered = route.sections.reduce<number>(\n      (total, section) =>\n        total +\n        (isFields(section) && typeof section.paragraphs === 'number' ? section.paragraphs : 0),\n      0,\n    );\n    if (covered !== paragraphs) {\n      add(\n        'ig_route_sections',\n        ['route', 'sections'],\n        `The sections cover ${covered} paragraphs, but the passage has ${paragraphs}.`,\n      );\n    }\n  }\n\n  const seen = new Set<string>();\n  const questions = list(route.questions);\n  questions.forEach((raw, index) => {\n    const at = (...rest: (string | number)[]): (string | number)[] => [\n      'route',\n      'questions',\n      index,\n      ...rest,\n    ];\n    if (!isFields(raw)) {\n      return;\n    }\n    const itemId = typeof raw.itemId === 'string' ? raw.itemId : undefined;\n    const item = itemId === undefined ? undefined : itemsById.get(itemId);\n    if (itemId === undefined || item === undefined) {\n      add(\n        'ig_route_question_item_unknown',\n        at('itemId'),\n        `No item of this group has the id \"${String(raw.itemId)}\".`,\n      );\n      return;\n    }\n    const parts = partIdsOf(item);\n    const partId = typeof raw.partId === 'string' && raw.partId !== '' ? raw.partId : undefined;\n    if (parts === null && partId !== undefined) {\n      add(\n        'ig_route_question_part_not_allowed',\n        at('partId'),\n        'A multiple-choice item is one question: leave out partId.',\n      );\n      return;\n    }\n    if (parts !== null && partId === undefined) {\n      add(\n        'ig_route_question_part_required',\n        at('partId'),\n        `Name the ${partNoun((item as Fields).type, false)} this question is: each one is a question of its own.`,\n      );\n      return;\n    }\n    if (parts !== null && partId !== undefined && !parts.includes(partId)) {\n      add(\n        'ig_route_question_part_unknown',\n        at('partId'),\n        `Item \"${itemId}\" has no ${partNoun((item as Fields).type, false)} \"${partId}\".`,\n      );\n      return;\n    }\n    const key = questionKey(itemId, partId);\n    if (seen.has(key)) {\n      add('ig_route_question_duplicate', at(), `Question \"${key}\" has two entries; keep one.`);\n      return;\n    }\n    seen.add(key);\n\n    const type = (item as Fields).type;\n    if (unset(raw.strategy)) {\n      add(\n        'ig_route_strategy_required',\n        at('strategy'),\n        'Choose the reading strategy this question practises.',\n      );\n    } else if (!isRouteStrategyId(raw.strategy)) {\n      add(\n        'ig_route_strategy_unknown',\n        at('strategy'),\n        `\"${String(raw.strategy)}\" is not a reading strategy.`,\n      );\n    } else if (\n      isReadingRouteItemType(type) &&\n      !ROUTE_STRATEGIES[raw.strategy].itemTypes.includes(type)\n    ) {\n      add(\n        'ig_route_strategy_item_type',\n        at('strategy'),\n        `The ${ROUTE_STRATEGIES[raw.strategy].title} strategy is written as ${ROUTE_STRATEGIES[raw.strategy].itemTypes.join(' or ')}, not ${String(type)}.`,\n      );\n    }\n\n    if (raw.wordLimit !== undefined) {\n      if (type !== 'fill-in-the-blanks') {\n        add(\n          'ig_route_word_limit_type',\n          at('wordLimit'),\n          'Only a question the learner writes has a word limit.',\n        );\n      } else if (typeof raw.wordLimit === 'number') {\n        const limit = raw.wordLimit;\n        for (const answer of acceptedAnswersOf(item, partId)) {\n          if (countWords(answer) > limit) {\n            add(\n              'ig_route_answer_over_limit',\n              at('wordLimit'),\n              `The accepted answer \"${answer}\" is longer than ${limit} word${limit === 1 ? '' : 's'}: a learner who writes it would lose the mark.`,\n            );\n          }\n        }\n      }\n    }\n\n    if (scope === 'redacted') {\n      return;\n    }\n    const quote = (value: unknown, path: (string | number)[]): void => {\n      if (body === '') {\n        return;\n      }\n      const match = findQuote(body, value);\n      if (match.found) {\n        return;\n      }\n      const words = quoteText(value);\n      if (match.reason === 'ambiguous') {\n        add(\n          'ig_route_quote_ambiguous',\n          path,\n          `\"${words}\" appears ${match.count} times in the passage. Quote more words, or say which occurrence: { \"text\": ..., \"occurrence\": 2 }.`,\n        );\n      } else {\n        add(\n          'ig_route_quote_not_found',\n          path,\n          match.reason === 'occurrence'\n            ? `\"${words}\" appears only ${match.count} time${match.count === 1 ? '' : 's'} in the passage.`\n            : `\"${words}\" is not in the passage. Copy the words exactly as the passage writes them.`,\n        );\n      }\n    };\n\n    const evidence = list(raw.evidence);\n    if (evidence.length === 0) {\n      add(\n        'ig_route_evidence_required',\n        at('evidence'),\n        'Quote where the passage justifies the answer — for a Not Given answer, where it discusses the topic.',\n      );\n    }\n    evidence.forEach((value, at2) => {\n      quote(value, at('evidence', at2));\n    });\n\n    const visible = learnerTextOf(item);\n    list(raw.keywords).forEach((keyword, at2) => {\n      if (!isFields(keyword)) {\n        return;\n      }\n      if (typeof keyword.question === 'string' && !containsPhrase(visible, keyword.question)) {\n        add(\n          'ig_route_keyword_not_in_question',\n          at('keywords', at2, 'question'),\n          `\"${keyword.question}\" is not in the question. Copy the words as the question writes them.`,\n        );\n      }\n      if (keyword.passage !== undefined) {\n        quote(keyword.passage, at('keywords', at2, 'passage'));\n      }\n    });\n    list(raw.links).forEach((link, at2) => {\n      if (isFields(link)) {\n        quote(link.from, at('links', at2, 'from'));\n        quote(link.to, at('links', at2, 'to'));\n      }\n    });\n\n    const choices = choicesOf(item, partId);\n    list(raw.traps).forEach((trap, at2) => {\n      if (!isFields(trap)) {\n        return;\n      }\n      const choice = choices.find((candidate) => candidate.id === trap.optionId);\n      if (choice === undefined) {\n        add(\n          'ig_route_trap_option_unknown',\n          at('traps', at2, 'optionId'),\n          `This question has no option or choice \"${String(trap.optionId)}\".`,\n        );\n      } else if (choice.correct) {\n        add(\n          'ig_route_trap_on_answer',\n          at('traps', at2, 'optionId'),\n          'A trap is a wrong option; this one is the answer.',\n        );\n      }\n      if (trap.lure !== undefined) {\n        quote(trap.lure, at('traps', at2, 'lure'));\n      }\n    });\n\n    if (isFields(raw.notes) && isRouteStrategyId(raw.strategy)) {\n      const moves = ROUTE_STRATEGIES[raw.strategy].moves;\n      for (const [move, note] of Object.entries(raw.notes)) {\n        const path = at('notes', move);\n        if (!(moves as readonly string[]).includes(move) || move === 'survey') {\n          add(\n            'ig_route_note_move_unknown',\n            path,\n            `The ${ROUTE_STRATEGIES[raw.strategy].title} strategy has no \"${move}\" step for a question.`,\n          );\n          continue;\n        }\n        if (typeof note !== 'string') {\n          continue;\n        }\n        if (note.length > ROUTE_NOTE_MAX_LENGTH) {\n          add(\n            'ig_route_note_too_long',\n            path,\n            `Keep a step's note to ${ROUTE_NOTE_MAX_LENGTH} characters.`,\n          );\n        } else if (noteRevealsAnswer(item, partId, note)) {\n          add(\n            'ig_route_note_reveals_answer',\n            path,\n            'This note gives the answer away. Say where to look and why, not what to answer.',\n          );\n        }\n      }\n    }\n  });\n\n  for (const question of itemQuestions(items)) {\n    if (\n      !seen.has(question.key) &&\n      itemsById.has(question.itemId) &&\n      isReadingRouteItemType(question.type) &&\n      covered(question.itemId)\n    ) {\n      add(\n        'ig_route_question_missing',\n        ['route', 'questions'],\n        question.partId === undefined\n          ? `Question \"${question.itemId}\" has no route entry.`\n          : `${partNoun(question.type, true)} \"${question.partId}\" of \"${question.itemId}\" has no route entry.`,\n      );\n    }\n  }\n  return issues;\n}\n","/**\n * The bounds of an interactive video — an item group with a `timeline`.\n *\n * A leaf module on purpose: the schemas, the authoring checks and the timeline\n * helpers all read these, and nothing here may import any of them back.\n */\n\n/**\n * The item types an interactive video may present. CLOSED on purpose: a type\n * added to the SDK later, or a custom type a host registers, is not silently\n * embeddable. Each one here was chosen, and each works inside a paused video —\n * a read-aloud's and a spoken answer's microphone included, because every quiz\n * pauses the video first.\n *\n * A question's own media is allowed as on any other item, under its own\n * playback policy: a picture to describe, or a recording to answer, which\n * plays only when the learner presses play while the video is paused. A\n * dictation must carry its own recording (the timeline rule).\n *\n * `speaking-response` joined in 1.10.0, `matching` in 1.13.0 and\n * `mark-the-words` in 1.14.0: a host with an exhaustive `switch` or `Record`\n * over {@link InteractiveVideoItemType} needs one more entry for each.\n */\nexport const INTERACTIVE_VIDEO_ITEM_TYPES = [\n  'multiple-choice',\n  'fill-in-the-blanks',\n  'gap-select',\n  'dictation',\n  'read-aloud',\n  'speaking-response',\n  'matching',\n  'mark-the-words',\n] as const;\n\n/** One of {@link INTERACTIVE_VIDEO_ITEM_TYPES}. */\nexport type InteractiveVideoItemType = (typeof INTERACTIVE_VIDEO_ITEM_TYPES)[number];\n\n/** Whether `type` is one of the item types an interactive video may present. */\nexport function isInteractiveVideoItemType(type: unknown): type is InteractiveVideoItemType {\n  return (INTERACTIVE_VIDEO_ITEM_TYPES as readonly unknown[]).includes(type);\n}\n\n/** The most quizzes one video may hold. */\nexport const TIMELINE_MAX_QUIZZES = 100;\n\n/**\n * The most questions one interactive video may hold, across all its quizzes.\n * The player keeps every one of them mounted, so an answer survives the\n * learner rewinding past its quiz.\n */\nexport const TIMELINE_MAX_ITEMS = 200;\n\n/** The most chapters one video may hold. */\nexport const TIMELINE_MAX_CHAPTERS = 100;\n\n/** The longest quiz or chapter title, in UTF-16 units. A title sits on one line of the player. */\nexport const TIMELINE_MAX_TITLE_LENGTH = 120;\n","import * as z from 'zod/v4';\nimport { routeIssues } from '../reading-route/check.js';\nimport {\n  ROUTE_NOTE_MAX_LENGTH,\n  ROUTE_STRATEGY_IDS,\n  ROUTE_WORD_LIMIT_MAX,\n} from '../reading-route/strategies.js';\nimport { getActivityTypeDescriptor } from '../registry/index.js';\nimport {\n  INTERACTIVE_VIDEO_ITEM_TYPES,\n  isInteractiveVideoItemType,\n  TIMELINE_MAX_CHAPTERS,\n  TIMELINE_MAX_ITEMS,\n  TIMELINE_MAX_QUIZZES,\n  TIMELINE_MAX_TITLE_LENGTH,\n} from '../timeline-limits.js';\nimport type { ActivityData, ValidationError, ValidationResult } from '../types/activity.js';\nimport type { ItemGroup, StimulusKind } from '../types/item-group.js';\nimport { GROUP_CAPTIONS_REVEAL_DICTATION, groupCaptionsField } from './dictation.js';\nimport { MediaSchema, RedactedMediaSchema, ScriptSchema } from './media.js';\nimport { readSchema } from './read-schema.js';\nimport { maxUnits } from './text-length.js';\n\n/**\n * An authored slot key.\n *\n * A `.` is rejected here, not at render time: `flattenSequence` uses the first\n * `.` to separate a group from its item, so a key containing one would produce\n * an ambiguous slot id. `keyOf` already threw on it — this moves the rejection\n * to `validateItemGroup`, where an author finds it, instead of leaving it to\n * surface when a learner opens the paper. Content that would newly fail\n * validation already threw at flatten time, so it can never have been sat.\n */\nconst SlotKeySchema = z\n  .string()\n  .min(1)\n  .refine((key) => !key.includes('.'), {\n    error:\n      'slotKey must not contain \".\" — that character separates a group from its item in a slot id, so a key containing one would make the slot ambiguous.',\n  });\n\nfunction hasBody(stimulus: { body?: string | undefined }): boolean {\n  return typeof stimulus.body === 'string' && stimulus.body.trim().length > 0;\n}\n\n/** Which media types can carry a stimulus of each kind. `text`/`mixed` accept any. */\nfunction mediaFits(kind: StimulusKind, mediaType: string | undefined): boolean {\n  switch (kind) {\n    case 'audio':\n      return mediaType === 'audio';\n    case 'video':\n      return mediaType === 'video' || mediaType === 'embed';\n    case 'image':\n      return mediaType === 'image';\n    default:\n      return true;\n  }\n}\n\n/**\n * Zod schema for a {@link Stimulus}. Loose: unknown keys preserved.\n *\n * The semantic guards exist because a stimulus that does not carry what its\n * `kind` promises is an authoring error that must not reach an exam: an\n * \"audio\" stimulus with no recording renders as a blank panel above six\n * listening questions. Unrepresentable in JSON Schema; dropped from\n * `stimulusJsonSchema` by design.\n */\nexport const StimulusSchema = z\n  .looseObject({\n    id: z.string().min(1),\n    kind: z.enum(['text', 'audio', 'video', 'image', 'mixed']),\n    title: z.string().optional(),\n    body: z.string().optional(),\n    bodyHtml: z.string().optional(),\n    media: MediaSchema.optional(),\n    transcript: z.string().optional(),\n    script: ScriptSchema.optional(),\n    locale: z.string().optional(),\n    attribution: z.string().optional(),\n  })\n  .refine((stimulus) => stimulus.bodyHtml === undefined || hasBody(stimulus), {\n    error:\n      'bodyHtml requires a plain-text body: it is the accessible fallback rendered when no sanitiser is supplied.',\n    path: ['body'],\n  })\n  .refine(\n    (stimulus) => (stimulus.kind !== 'text' && stimulus.kind !== 'mixed') || hasBody(stimulus),\n    {\n      error: 'A text or mixed stimulus needs a non-empty body.',\n      path: ['body'],\n    },\n  )\n  .refine((stimulus) => stimulus.kind === 'text' || stimulus.media !== undefined, {\n    error: 'An audio, video, image or mixed stimulus needs media.',\n    path: ['media'],\n  })\n  .refine(\n    (stimulus) => stimulus.media === undefined || mediaFits(stimulus.kind, stimulus.media.type),\n    {\n      error:\n        'media.type does not fit the stimulus kind: audio needs audio; video needs video or embed; image needs image.',\n      path: ['media', 'type'],\n    },\n  );\n\nconst TimelineTitleSchema = maxUnits(z.string(), TIMELINE_MAX_TITLE_LENGTH).refine(\n  (title) => title.trim().length > 0,\n  { error: 'A title must not be empty.' },\n);\n\n/** Seconds from the start of the video. zod rejects NaN and ±Infinity itself. */\nconst TimelineTimeSchema = z.number().min(0, { error: 'A time is 0 seconds or more.' });\n\n/**\n * A quiz. STRICT, like every part of a timeline: a misspelt `requried` would\n * otherwise be kept and the quiz silently optional on a paper that believed it\n * was required.\n */\nexport const TimelineCueSchema = z.strictObject({\n  id: maxUnits(z.string().min(1), 64),\n  at: TimelineTimeSchema,\n  itemIds: z.array(z.string().min(1)).min(1).max(TIMELINE_MAX_ITEMS),\n  title: TimelineTitleSchema.optional(),\n  required: z.boolean().optional(),\n});\n\nexport const TimelineChapterSchema = z.strictObject({\n  at: TimelineTimeSchema,\n  title: TimelineTitleSchema,\n});\n\n/**\n * A timeline on its own: its quizzes, chapters and navigation. The rules that\n * need the group — every item in exactly one quiz, a video stimulus, the five\n * item types — are {@link timelineIssues}, which both group schemas run.\n */\nexport const MediaTimelineSchema = z\n  .strictObject({\n    cues: z.array(TimelineCueSchema).max(TIMELINE_MAX_QUIZZES),\n    chapters: z.array(TimelineChapterSchema).max(TIMELINE_MAX_CHAPTERS).optional(),\n    navigation: z.enum(['free', 'no-skip-ahead']).optional(),\n  })\n  .check((ctx) => {\n    const seen = new Set<string>();\n    ctx.value.cues.forEach((cue, index) => {\n      if (seen.has(cue.id)) {\n        ctx.issues.push({\n          code: 'custom',\n          input: cue.id,\n          message: `Quiz id \"${cue.id}\" is used twice: events, drafts and the contents panel name a quiz by its id.`,\n          path: ['cues', index, 'id'],\n        });\n      }\n      seen.add(cue.id);\n    });\n    // Strictly increasing, not merely sorted: two chapters starting at one\n    // moment leave the first with no length, and the scrubber no room to draw it.\n    const chapters = ctx.value.chapters ?? [];\n    chapters.forEach((chapter, index) => {\n      const previous = chapters[index - 1];\n      if (previous !== undefined && chapter.at <= previous.at) {\n        ctx.issues.push({\n          code: 'custom',\n          input: chapter.at,\n          message: 'Chapter times must be strictly increasing.',\n          path: ['chapters', index, 'at'],\n        });\n      }\n    });\n  });\n\n/** Words copied from the passage: the words, or the words and which occurrence of them. */\nconst RouteQuoteSchema = z.union([\n  z.string().min(1),\n  z.strictObject({ text: z.string().min(1), occurrence: z.number().int().min(1).optional() }),\n]);\n\nconst ROUTE_TRAP_KINDS = [\n  'word-match',\n  'opposite',\n  'partial',\n  'outside-knowledge',\n  'too-general',\n  'too-specific',\n  'not-the-question',\n] as const;\n\nconst ROUTE_MOVE_IDS = [\n  'read-instructions',\n  'survey',\n  'keywords',\n  'predict',\n  'locate',\n  'read-around',\n  'paraphrase',\n  'decide',\n  'eliminate',\n  'cohesion',\n  'check-answer',\n  'compare-views',\n] as const;\n\nconst RouteSectionSchema = z.strictObject({\n  label: z.string().min(1),\n  title: z.string().optional(),\n  paragraphs: z.number().int().min(1),\n});\n\n/**\n * One question of a route. STRICT, like every part of a route: a misspelt\n * `evidense` would otherwise leave a question with no evidence and no error.\n * The rules that need the passage or the items are {@link routeIssues}.\n */\nconst RouteQuestionSchema = z.strictObject({\n  itemId: z.string().min(1),\n  partId: z.string().min(1).optional(),\n  strategy: z.enum(ROUTE_STRATEGY_IDS as unknown as [string, ...string[]]),\n  evidence: z.array(RouteQuoteSchema).min(1),\n  evidenceMatch: z.enum(['any', 'all']).optional(),\n  keywords: z\n    .array(z.strictObject({ question: z.string().min(1), passage: RouteQuoteSchema.optional() }))\n    .optional(),\n  links: z.array(z.strictObject({ from: RouteQuoteSchema, to: RouteQuoteSchema })).optional(),\n  wordLimit: z.number().int().min(1).max(ROUTE_WORD_LIMIT_MAX).optional(),\n  traps: z\n    .array(\n      z.strictObject({\n        optionId: z.string().min(1),\n        kind: z.enum(ROUTE_TRAP_KINDS),\n        lure: RouteQuoteSchema.optional(),\n      }),\n    )\n    .optional(),\n  notes: z\n    .partialRecord(z.enum(ROUTE_MOVE_IDS), maxUnits(z.string().min(1), ROUTE_NOTE_MAX_LENGTH))\n    .optional(),\n});\n\n/** A route on its own. The rules that span the route, the passage and the items are {@link routeIssues}, which both group schemas run. */\nexport const ReadingRouteSchema = z.strictObject({\n  routeVersion: z.literal('1.0'),\n  startAt: z.number().int().min(1).optional(),\n  paragraphLabels: z.array(z.string()).optional(),\n  sections: z.array(RouteSectionSchema).min(1).optional(),\n  questions: z.array(RouteQuestionSchema),\n});\n\n/** A route as a learner's copy carries it: which question practises which strategy, and nothing that locates an answer. */\nexport const RedactedReadingRouteSchema = z.strictObject({\n  routeVersion: z.literal('1.0'),\n  startAt: z.number().int().min(1).optional(),\n  paragraphLabels: z.array(z.string()).optional(),\n  sections: z.array(RouteSectionSchema).min(1).optional(),\n  questions: z.array(\n    z.strictObject({\n      itemId: z.string().min(1),\n      partId: z.string().min(1).optional(),\n      strategy: z.enum(ROUTE_STRATEGY_IDS as unknown as [string, ...string[]]),\n      wordLimit: z.number().int().min(1).max(ROUTE_WORD_LIMIT_MAX).optional(),\n    }),\n  ),\n});\n\n/** A URL only this document can resolve, or one that inlines the bytes. */\nfunction isLocalOnlyUrl(url: unknown): boolean {\n  return typeof url === 'string' && /^(data|blob):/i.test(url);\n}\n\n/**\n * The rules of an interactive video that span the timeline, the stimulus and\n * the items. Run by the content schema and, for everything but the two\n * authoring-only rules, by the strict redacted schema — a projection built by\n * hand never passed through the content schema.\n *\n * Items are read defensively: the redacted schema leaves them opaque, and each\n * is proven against its own type's schema elsewhere.\n */\nfunction timelineIssues(\n  group: {\n    stimulus: {\n      kind: string;\n      media?:\n        | {\n            type: string;\n            url: string;\n            poster?: string | undefined;\n            tracks?: readonly { src: string }[] | undefined;\n          }\n        | undefined;\n    };\n    items: readonly unknown[];\n    shuffle?: string | undefined;\n    timeline?: { cues: readonly { itemIds: readonly string[] }[] } | undefined;\n  },\n  scope: 'content' | 'redacted',\n): { path: (string | number)[]; message: string; input: unknown }[] {\n  const timeline = group.timeline;\n  if (timeline === undefined) {\n    return [];\n  }\n  const issues: { path: (string | number)[]; message: string; input: unknown }[] = [];\n  const media = group.stimulus.media;\n\n  // Reported at the field that is wrong, so an editor's own check at that path\n  // can stand in for it without hiding anything else about the stimulus.\n  if (group.stimulus.kind !== 'video') {\n    issues.push({\n      path: ['stimulus', 'kind'],\n      input: group.stimulus.kind,\n      message:\n        'An interactive video needs a video stimulus: quizzes open at moments of a video, and nothing else has them.',\n    });\n  } else if (media !== undefined && media.type !== 'video') {\n    issues.push({\n      path: ['stimulus', 'media', 'type'],\n      input: media.type,\n      message:\n        'An interactive video needs a video file. An embedded provider player cannot be paused at the moment a quiz opens.',\n    });\n  }\n  if (group.shuffle === 'within-group') {\n    issues.push({\n      path: ['shuffle'],\n      input: group.shuffle,\n      message:\n        'An interactive video presents its questions in the order its quizzes open; shuffle: \"within-group\" cannot apply to it.',\n    });\n  }\n  if (group.items.length > TIMELINE_MAX_ITEMS) {\n    issues.push({\n      path: ['items'],\n      input: group.items.length,\n      message: `An interactive video holds at most ${TIMELINE_MAX_ITEMS} questions.`,\n    });\n  }\n\n  const itemIds = new Map<string, number>();\n  group.items.forEach((item, index) => {\n    const {\n      id,\n      type,\n      media: itemMedia,\n    } = (item ?? {}) as { id?: unknown; type?: unknown; media?: unknown };\n    if (typeof id === 'string') {\n      itemIds.set(id, index);\n    }\n    if (!isInteractiveVideoItemType(type)) {\n      issues.push({\n        path: ['items', index, 'type'],\n        input: type,\n        message: `An interactive video may hold only ${INTERACTIVE_VIDEO_ITEM_TYPES.join(', ')} questions.`,\n      });\n    }\n    // The \"play the stimulus\" fallback a dictation has in a listening group\n    // means nothing halfway through a video.\n    if (scope === 'content' && type === 'dictation' && itemMedia === undefined) {\n      issues.push({\n        path: ['items', index, 'media'],\n        input: itemMedia,\n        message: 'A dictation inside an interactive video needs its own recording.',\n      });\n    }\n  });\n\n  const placed = new Set<string>();\n  timeline.cues.forEach((cue, cueIndex) => {\n    cue.itemIds.forEach((itemId, position) => {\n      const path = ['timeline', 'cues', cueIndex, 'itemIds', position];\n      if (!itemIds.has(itemId)) {\n        issues.push({\n          path,\n          input: itemId,\n          message: `No item in this group has the id \"${itemId}\".`,\n        });\n      } else if (placed.has(itemId)) {\n        issues.push({\n          path,\n          input: itemId,\n          message: `Item \"${itemId}\" is placed twice: every question belongs to exactly one quiz.`,\n        });\n      }\n      placed.add(itemId);\n    });\n  });\n  for (const [itemId, index] of itemIds) {\n    if (!placed.has(itemId)) {\n      issues.push({\n        path: ['items', index],\n        input: itemId,\n        message: `Item \"${itemId}\" is in no quiz, so the video would never show it.`,\n      });\n    }\n  }\n\n  // A `data:` video swells the payload and every fingerprint over it; a stored\n  // `blob:` URL means nothing in another document.\n  if (scope === 'content' && media !== undefined) {\n    const urls: [unknown, (string | number)[]][] = [\n      [media.url, ['stimulus', 'media', 'url']],\n      [media.poster, ['stimulus', 'media', 'poster']],\n      ...(media.tracks ?? []).map((track, index): [unknown, (string | number)[]] => [\n        track.src,\n        ['stimulus', 'media', 'tracks', index, 'src'],\n      ]),\n    ];\n    for (const [url, path] of urls) {\n      if (isLocalOnlyUrl(url)) {\n        issues.push({\n          path,\n          input: url,\n          message:\n            'An interactive video is stored and served: its URLs cannot be data: or blob: URLs.',\n        });\n      }\n    }\n  }\n  return issues;\n}\n\n/**\n * The structural minimum of an item as seen by the CONTAINER schema. Each\n * item's own contract is checked against its registered schema by\n * {@link validateItemGroup} — a zod schema cannot dispatch on a registry\n * that consumers extend at runtime.\n */\nconst ItemShapeSchema = z.looseObject({\n  type: z.string().min(1),\n  id: z.string().min(1),\n  slotKey: SlotKeySchema.optional(),\n});\n\n/**\n * Zod schema for an {@link ItemGroup} CONTAINER. Loose: unknown keys\n * preserved. Validates the group's own fields and the stimulus in full, and\n * each item only structurally (`type` and `id`); use {@link validateItemGroup}\n * to validate the items against their registered schemas as well.\n */\nexport const ItemGroupSchema = z\n  .looseObject({\n    schemaVersion: z.literal('1.0'),\n    type: z.literal('item-group'),\n    id: z.string().min(1),\n    title: z.string().optional(),\n    slotKey: SlotKeySchema.optional(),\n    stimulus: StimulusSchema,\n    items: z.array(ItemShapeSchema).min(1),\n    shuffle: z.enum(['none', 'within-group']).optional(),\n    timeline: MediaTimelineSchema.optional(),\n    route: ReadingRouteSchema.optional(),\n  })\n  .refine((group) => group.items.every((item) => item.type !== 'item-group'), {\n    error: 'Item groups do not nest: every item must be an activity.',\n    path: ['items'],\n  })\n  .refine((group) => new Set(group.items.map((item) => item.id)).size === group.items.length, {\n    error: 'Item ids must be unique within a group.',\n    path: ['items'],\n  })\n  .check((ctx) => {\n    for (const issue of timelineIssues(ctx.value, 'content')) {\n      ctx.issues.push({ code: 'custom', ...issue });\n    }\n    for (const { path, message } of routeIssues(ctx.value, 'content')) {\n      ctx.issues.push({ code: 'custom', input: ctx.value.route, path, message });\n    }\n  });\n\n/** Strict learner-safe stimulus: everything but the author-only `transcript`. */\nexport const RedactedStimulusSchema = z.strictObject({\n  id: z.string().min(1),\n  kind: z.enum(['text', 'audio', 'video', 'image', 'mixed']),\n  title: z.string().optional(),\n  body: z.string().optional(),\n  bodyHtml: z.string().optional(),\n  media: RedactedMediaSchema.optional(),\n  locale: z.string().optional(),\n  attribution: z.string().optional(),\n});\n\n/**\n * Strict learner-safe item group. Items are left opaque here — each is proven\n * learner-safe by `assertRedacted` against its OWN type's redacted schema,\n * which is the only place that knowledge lives. The one exception is the one\n * rule that spans the container and an item: a captioned stimulus recording\n * played to a dictation is not learner-safe, because the captions are the\n * dictation's answer.\n */\nexport const RedactedItemGroupSchema = z\n  .strictObject({\n    redacted: z.literal(true),\n    schemaVersion: z.literal('1.0'),\n    type: z.literal('item-group'),\n    id: z.string().min(1),\n    title: z.string().optional(),\n    slotKey: SlotKeySchema.optional(),\n    stimulus: RedactedStimulusSchema,\n    items: z.array(z.unknown()).min(1),\n    shuffle: z.enum(['none', 'within-group']).optional(),\n    timeline: MediaTimelineSchema.optional(),\n    route: RedactedReadingRouteSchema.optional(),\n  })\n  .check((ctx) => {\n    for (const issue of timelineIssues(ctx.value, 'redacted')) {\n      ctx.issues.push({ code: 'custom', ...issue });\n    }\n    for (const { path, message } of routeIssues(ctx.value, 'redacted')) {\n      ctx.issues.push({ code: 'custom', input: ctx.value.route, path, message });\n    }\n    const captions = groupCaptionsField(ctx.value);\n    if (captions !== undefined) {\n      ctx.issues.push({\n        code: 'custom',\n        input: ctx.value.stimulus.media?.[captions],\n        message: GROUP_CAPTIONS_REVEAL_DICTATION,\n        path: ['stimulus', 'media', captions],\n      });\n    }\n  });\n\nfunction toValidationErrors(\n  issues: readonly { path: readonly PropertyKey[]; message: string; code: string }[],\n  prefix: string[],\n): ValidationError[] {\n  return issues.map((issue) => ({\n    path: [...prefix, ...issue.path.map(String)],\n    message: issue.message,\n    code: issue.code,\n  }));\n}\n\n/**\n * Validates an item group in full: the container and stimulus against\n * {@link ItemGroupSchema}, then every item against the schema registered for\n * its `type`. Errors from items are reported at `items.<index>.…`.\n *\n * Unlike `validateActivity`, an item whose type is not registered is REPORTED\n * (code `unknown_activity_type`) rather than thrown: a group is validated as\n * a whole, and an author fixing a six-item group wants every problem listed,\n * not the first one that happened to throw.\n */\nexport function validateItemGroup(data: unknown): ValidationResult<ItemGroup> {\n  const container = ItemGroupSchema.safeParse(data);\n  if (!container.success) {\n    return { success: false, errors: toValidationErrors(container.error.issues, []) };\n  }\n\n  const errors: ValidationError[] = [];\n  const items: ActivityData[] = [];\n  container.data.items.forEach((item, index) => {\n    const descriptor = getActivityTypeDescriptor(item.type);\n    if (descriptor === undefined) {\n      errors.push({\n        path: ['items', String(index), 'type'],\n        message: `Activity type \"${item.type}\" is not registered`,\n        code: 'unknown_activity_type',\n      });\n      return;\n    }\n    const parsed = readSchema(descriptor.schema, item, `Activity type \"${descriptor.type}\"`);\n    if (!parsed.success) {\n      errors.push(...toValidationErrors(parsed.issues, ['items', String(index)]));\n      return;\n    }\n    items.push(parsed.data as ActivityData);\n  });\n  const captions = groupCaptionsField(container.data);\n  if (captions !== undefined) {\n    errors.push({\n      path: ['stimulus', 'media', captions],\n      message: GROUP_CAPTIONS_REVEAL_DICTATION,\n      code: 'custom',\n    });\n  }\n\n  if (errors.length > 0) {\n    return { success: false, errors };\n  }\n  // zod4 optional outputs are `T | undefined`; the wire type uses exact\n  // optionals. Structurally identical at runtime — the cast is type-level.\n  return { success: true, data: { ...container.data, items } as unknown as ItemGroup };\n}\n"],"mappings":"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"}