@intellectif/lk-core 1.8.0 → 1.9.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { $ as AiTextResult, $n as GradeRoutingReason, $t as DictationEquivalence, A as AiGapSelectFacts, An as ScoringOutcome, At as TimelineCue, B as AiGroupInput, Bn as XAPIActor, Bt as VersionFinding, C as AiDraftsCall, Cn as ReadAloudDimension, Ct as MediaTimeline, D as AiFeature, Dn as RecordingBounds, Dt as Stimulus, E as AiExplanationRequest, En as ReadAloudSlowMedia, Et as SequenceSlotGroup, F as AiGradingCriterionFact, Fn as WrittenResponseData, Ft as DraftSeverity, G as AiOptionFact, Gn as XAPIObject, Gt as ActivityFeedback, H as AiItemFacts, Hn as XAPIContext, Ht as VersionSlot, I as AiGradingFacts, In as WrittenResponseLearnerResponse, It as DraftValidationResult, J as AiReadingWordFact, Jn as XAPIStatement, Jt as ActivityType, K as AiProvenance, Kn as XAPIResult, Kt as ActivityMedia, L as AiGradingJudgement, Ln as WrittenResponseRubric, Lt as ItemFinding, M as AiGeneratedVariant, Mn as ScriptTurn, Mt as DraftContext, N as AiGrade, Nn as ValidationError, Nt as DraftIssue, O as AiFillInTheBlanksFacts, On as RecordingRef, Ot as StimulusKind, P as AiGradedCriterion, Pn as ValidationResult, Pt as DraftNotComplete, Q as AiSupportedActivityType, Qn as GradeRouting, Qt as DictationData, R as AiGradingRequest, Rn as WrittenResponseRubricCriterion, Rt as ItemFindingSeverity, S as AiDrafts, Sn as ReadAloudData, St as MediaProgress, T as AiDraftsRun, Tn as ReadAloudLearnerResponse, Tt as SequenceSlot, U as AiMaterialFacts, Un as XAPIContextActivities, Ut as ActivityData, V as AiHintRequest, Vn as XAPIConfig, Vt as VersionPaper, W as AiMultipleChoiceFacts, Wn as XAPIError, Wt as ActivityDataMap, X as AiRubricCriterionFact, Xn as CriterionScore, Xt as DeferredReason, Y as AiRefusal, Yn as XAPIVerbObject, Yt as BlankConfig, Z as AiSoundFact, Zn as GradeRecord, Zt as DeferredScoringPartial, _ as AiDraftCaption, _n as MultipleChoiceData, _t as AiWritingFacts, a as AiCoachingRequest, an as GapSelectBank, ar as InlineCorrection, at as AiVariantMissing, b as AiDraftSource, bn as MultipleChoiceOptionMedia, bt as AiWritingFeedbackResult, c as AiCriterionJudgement, cn as GapSelectGap, cr as levenshteinDistance, ct as AiVariantSkipCode, d as AiCritiqueFinding, dn as InteractionKind, dt as AiVariantsRequest, en as DictationLearnerResponse, er as Grader, et as AiVariantDifficulty, f as AiCritiqueFindingResult, fn as ItemOutcome, ft as AiVariantsRun, g as AiDictationFacts, gn as MediaTrack, gt as AiWritingCorrection, h as AiCritiqueResult, hn as MediaPlaybackPolicy, ht as AiWordFact, i as AiCoaching, in as FillInTheBlanksLearnerResponse, ir as GradingState, it as AiVariantMismatch, j as AiGeneratedDraft, jn as ScoringResult, jt as DraftComplete, k as AiGapFact, kn as ScoringDetail, kt as TimelineChapter, l as AiCritique, ln as GapSelectLearnerResponse, lr as matchText, lt as AiVariantTargets, m as AiCritiqueRequest, mn as LearnerResponseMap, mt as AiVideoDraft, n as AiActivityInput, nn as DictationTolerance, nr as GraderKind, nt as AiVariantImage, o as AiCoachingResult, on as GapSelectChoice, or as TextMatchPolicy, ot as AiVariantPair, p as AiCritiqueKind, pn as LearnerResponse, pt as AiVerdict, q as AiReadingFacts, qn as XAPIScore, qt as ActivityResult, r as AiBlankFact, rn as FillInTheBlanksData, rr as GraderUsage, rt as AiVariantLevelFacts, s as AiCoachingWord, sn as GapSelectData, sr as TextMatchResult, st as AiVariantSkip, t as ActivityAiPermissions, tn as DictationSlowMedia, tr as GraderConfiguration, tt as AiVariantExemplarFacts, u as AiCritiqueField, un as InteractionEvent, ut as AiVariants, v as AiDraftProblem, vn as MultipleChoiceLearnerResponse, vt as AiWritingFeedback, w as AiDraftsRequest, wn as ReadAloudDimensionWeight, wt as SequenceEntry, x as AiDraftType, xn as NativeControlHint, xt as ItemGroup, y as AiDraftSettings, yn as MultipleChoiceOption, yt as AiWritingFeedbackRequest, z as AiGradingRequestProblem, zn as WrittenResponseRubricLevel, zt as VersionComparison } from "./ai-Cnm0qE8v.js";
-import { $ as hasGrade, A as diffDictationChars, At as Band, B as outcomeFromRoutedGrade, C as validateItemScoringPolicy, Ct as SpeechSyllable, D as DICTATION_MAX_TEXT_LENGTH, Dt as SpeechWordError, E as DICTATION_MAX_EQUIVALENCE_LENGTH, Et as SpeechWord, F as dictationReferenceWords, Ft as roundGrade, G as CalibrationReport, H as GradeFromJudgementOptions, I as CalibrationThresholds, J as TotalCalibration, K as CalibrationScope, L as GradeRoutingContext, M as DictationReference, Mt as RoundingPolicy, N as DictationWordAlignment, Nt as classifyBand, O as DICTATION_MAX_TRANSCRIPT_LENGTH, Ot as WavInspection, P as alignDictation, Pt as gte, Q as gradeFromRubric, R as GradeRoutingPolicy, S as scoreTries, St as SpeechPlausibilityPolicy, T as DICTATION_MAX_EQUIVALENCES, Tt as SpeechUnscorableCode, U as gradeFromJudgement, V as routeGrade, W as CalibrationPair, X as graderConfiguration, Y as calibrationReport, Z as GradeFromRubricOptions, _ as DEFAULT_PASS_THRESHOLD, _t as ReadAloudWordState, a as evaluateTries, at as ItemTry, b as ITEM_SCORING_MAX_RETRIES, bt as SpeechPhoneme, c as inspectWav, ct as AssessmentScore, d as READ_ALOUD_MAX_SECONDS, dt as PassFailureReason, et as outcomeFromGrade, f as READ_ALOUD_MAX_TAKES, ft as ScoredItem, g as alignReadAloud, gt as ReadAloudWordAlignment, h as validateSpeechAssessment, ht as GradeReadAloudOptions, i as evaluate, it as ItemTriesScore, j as DictationAlignment, jt as RoundingMode, k as DictationCharOp, kt as WavInspectionPolicy, l as READ_ALOUD_MAX_DIMENSION_WEIGHT, lt as AssessmentSectionInput, m as gradeReadAloud, mt as composeAssessmentScore, n as ItemTriesOutcome, nt as ItemScoringPolicy, o as score, ot as ItemTryScore, p as SPEECH_ASSESSMENT_MAX_WORDS, pt as SectionScore, q as CriterionCalibration, r as ScoringOptions, rt as ItemScoringPolicyIssue, s as outcomeFromUnscorable, st as ResolvedItemScoringPolicy, t as EvaluateOptions, tt as ItemScoringCount, u as READ_ALOUD_MAX_REFERENCE_LENGTH, ut as CompositionPolicy, v as computePassThreshold, vt as SpeechAssessment, w as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, wt as SpeechUnscorable, x as resolveItemScoringPolicy, xt as SpeechPhonemeCandidate, y as DEFAULT_ITEM_SCORING_POLICY, yt as SpeechMeasurement, z as inAuditSample } from "./index-g-EWIugp.js";
-import { A as RedactedStimulus, C as RedactedGapSelectChoice, D as RedactedMultipleChoiceOption, E as RedactedMultipleChoiceData, O as RedactedMultipleChoiceOptionMedia, 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 RedactedWrittenResponseData, k as RedactedReadAloudData, 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-HXvg0YRQ.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-CtoPhJAH.js";
+import { $ as AiSpeakingGradingFacts, $n as XAPIContextActivities, $t as ActivityType, A as AiGapSelectFacts, An as ReadAloudLearnerResponse, At as SequenceSlot, B as AiGroupInput, Bn as SpeakingResponseLearnerResponse, Bt as DraftSeverity, C as AiDraftsCall, Cn as MultipleChoiceLearnerResponse, Ct as AiWritingFeedback, D as AiFeature, Dn as ReadAloudData, Dt as MediaProgress, E as AiExplanationRequest, En as NativeControlHint, Et as ItemGroup, F as AiGradingCriterionFact, Fn as ScoringOutcome, Ft as TimelineCue, G as AiOptionFact, Gn as WrittenResponseData, Gt as VersionFinding, H as AiItemFacts, Hn as SpeakingRubricCriterion, Ht as ItemFinding, I as AiGradingFacts, In as ScoringResult, It as DraftComplete, J as AiReadingWordFact, Jn as WrittenResponseRubricCriterion, Jt as ActivityData, K as AiProvenance, Kn as WrittenResponseLearnerResponse, Kt as VersionPaper, L as AiGradingJudgement, Ln as ScriptTurn, Lt as DraftContext, M as AiGeneratedVariant, Mn as RecordingBounds, Mt as Stimulus, N as AiGrade, Nn as RecordingRef, Nt as StimulusKind, O as AiFillInTheBlanksFacts, On as ReadAloudDimension, Ot as MediaTimeline, P as AiGradedCriterion, Pn as ScoringDetail, Pt as TimelineChapter, Q as AiSpeakingCriterionFact, Qn as XAPIContext, Qt as ActivityResult, R as AiGradingRequest, Rn as SpeakingMeasure, Rt as DraftIssue, S as AiDrafts, Sn as MultipleChoiceData, St as AiWritingFacts, T as AiDraftsRun, Tn as MultipleChoiceOptionMedia, Tt as AiWritingFeedbackResult, U as AiMaterialFacts, Un as ValidationError, Ut as ItemFindingSeverity, V as AiHintRequest, Vn as SpeakingRubric, Vt as DraftValidationResult, W as AiMultipleChoiceFacts, Wn as ValidationResult, Wt as VersionComparison, X as AiRubricCriterionFact, Xn as XAPIActor, Xt as ActivityFeedback, Y as AiRefusal, Yn as WrittenResponseRubricLevel, Yt as ActivityDataMap, Z as AiSoundFact, Zn as XAPIConfig, Zt as ActivityMedia, _ as AiDraftCaption, _n as ItemOutcome, _r as TextMatchResult, _t as AiVariantsRun, a as AiCoachingRequest, an as DictationLearnerResponse, ar as XAPIVerbObject, at as AiVariantDifficulty, b as AiDraftSource, bn as MediaPlaybackPolicy, bt as AiWordFact, c as AiCriterionJudgement, cn as FillInTheBlanksData, cr as GradeRouting, ct as AiVariantLevelFacts, d as AiCritiqueFinding, dn as GapSelectChoice, dr as GraderConfiguration, dt as AiVariantPair, en as BlankConfig, er as XAPIError, et as AiSpeakingGradingRequest, f as AiCritiqueFindingResult, fn as GapSelectData, fr as GraderKind, ft as AiVariantSkip, g as AiDictationFacts, gn as InteractionKind, gr as TextMatchPolicy, gt as AiVariantsRequest, h as AiCritiqueResult, hn as InteractionEvent, hr as InlineCorrection, ht as AiVariants, i as AiCoaching, in as DictationEquivalence, ir as XAPIStatement, it as AiTextResult, j as AiGeneratedDraft, jn as ReadAloudSlowMedia, jt as SequenceSlotGroup, k as AiGapFact, kn as ReadAloudDimensionWeight, kt as SequenceEntry, l as AiCritique, ln as FillInTheBlanksLearnerResponse, lr as GradeRoutingReason, lt as AiVariantMismatch, m as AiCritiqueRequest, mn as GapSelectLearnerResponse, mr as GradingState, mt as AiVariantTargets, n as AiActivityInput, nn as DeferredScoringPartial, nr as XAPIResult, nt as AiSpeakingMeasureFact, o as AiCoachingResult, on as DictationSlowMedia, or as CriterionScore, ot as AiVariantExemplarFacts, p as AiCritiqueKind, pn as GapSelectGap, pr as GraderUsage, pt as AiVariantSkipCode, q as AiReadingFacts, qn as WrittenResponseRubric, qt as VersionSlot, r as AiBlankFact, rn as DictationData, rr as XAPIScore, rt as AiSupportedActivityType, s as AiCoachingWord, sn as DictationTolerance, sr as GradeRecord, st as AiVariantImage, t as ActivityAiPermissions, tn as DeferredReason, tr as XAPIObject, tt as AiSpeakingGradingRequestProblem, u as AiCritiqueField, un as GapSelectBank, ur as Grader, ut as AiVariantMissing, v as AiDraftProblem, vn as LearnerResponse, vr as levenshteinDistance, vt as AiVerdict, w as AiDraftsRequest, wn as MultipleChoiceOption, wt as AiWritingFeedbackRequest, x as AiDraftType, xn as MediaTrack, xt as AiWritingCorrection, y as AiDraftSettings, yn as LearnerResponseMap, yr as matchText, yt as AiVideoDraft, z as AiGradingRequestProblem, zn as SpeakingResponseData, zt as DraftNotComplete } from "./ai-zhc9yhRj.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-CxkqS62X.js";
+import { A as RedactedStimulus, C as RedactedGapSelectChoice, D as RedactedMultipleChoiceOption, E as RedactedMultipleChoiceData, O as RedactedMultipleChoiceOptionMedia, 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 RedactedWrittenResponseData, k as RedactedReadAloudData, 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-f4YuMgFb.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-Byar5VVs.js";
 /**
  * What a model is told about the group a question sits in: the material the
  * learner reads and sees beside it.
@@ -425,6 +425,39 @@ export declare function aiGradingRequest(input: {
   problem: AiGradingRequestProblem;
   path?: (string | number)[];
 };
+/**
+ * The request for a model's grade of a spoken answer (1.9), or why there is
+ * none to make.
+ *
+ * Built as a written response's is, on the server and from the whole item, with
+ * the take's evidence: the model reads `assessment.transcript` — the
+ * transcriber's verbatim text, the same text the engine measured the take
+ * against — and scores the criteria a judge scores: those that name no
+ * `measure`, or every criterion when `judgeMeasures` is set. The measured
+ * criteria go with it as context, with the engine's scores, so feedback can
+ * speak of them; the model does not score them.
+ *
+ * The evidence is checked as `gradeSpeakingResponse` checks it — valid,
+ * unscripted, for this item's locale and this response's recording — so a model
+ * is never paid to judge a take the grade would refuse. Read the reply with
+ * `checkAiGrading`, and grade with `gradeSpeakingResponse` under the same
+ * `judgeMeasures`.
+ */
+export declare function aiSpeakingGradingRequest(input: {
+  data: AiActivityInput;
+  response: LearnerResponse | null;
+  assessment: SpeechAssessment | null;
+  judgeMeasures?: boolean;
+  group?: AiGroupInput;
+  learnerLocale?: string;
+}): {
+  ok: true;
+  request: AiSpeakingGradingRequest;
+} | {
+  ok: false;
+  problem: AiSpeakingGradingRequestProblem;
+  path?: (string | number)[];
+};
 type Refused = {
   ok: false;
   refusal: AiRefusal;
@@ -454,7 +487,7 @@ type Refused = {
  * The total is not computed here: `gradeFromJudgement` computes it, as
  * `gradeFromRubric` computes every grade in the SDK.
  */
-export declare function checkAiGrading(raw: unknown, request: AiGradingRequest): {
+export declare function checkAiGrading(raw: unknown, request: AiGradingRequest | AiSpeakingGradingRequest): {
   ok: true;
   judgement: AiGradingJudgement;
 } | Refused;
@@ -1314,7 +1347,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"];
+export declare const BUILT_IN_ACTIVITY_TYPES: readonly ["multiple-choice", "fill-in-the-blanks", "written-response", "gap-select", "dictation", "read-aloud", "speaking-response"];
 /** 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. */
@@ -2394,5 +2427,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 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 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 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, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, type ReadAloudData, type ReadAloudDimension, type ReadAloudDimensionWeight, type ReadAloudLearnerResponse, type ReadAloudSlowMedia, type ReadAloudWordAlignment, type ReadAloudWordState, type RecordingBounds, type RecordingRef, type RedactedActivity, type RedactedBlankConfig, type RedactedDictationData, type RedactedDictationSlowMedia, type RedactedFillInTheBlanksData, type RedactedGapSelectBank, type RedactedGapSelectChoice, type RedactedGapSelectData, type RedactedGapSelectGap, type RedactedMultipleChoiceData, type RedactedMultipleChoiceOption, type RedactedMultipleChoiceOptionMedia, type RedactedReadAloudData, type RedactedStimulus, type RedactedWrittenResponseData, type RegisteredActivityTypeDescriptor, type ResolvedDeliveryPolicy, type ResolvedItemScoringPolicy, type ResponseDiffEntry, type RoundingMode, type RoundingPolicy, 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 SpeechAssessment, type SpeechMeasurement, type SpeechPhoneme, type SpeechPhonemeCandidate, type SpeechPlausibilityPolicy, type SpeechSyllable, type SpeechUnscorable, type SpeechUnscorableCode, type SpeechWord, type SpeechWordError, type StandardSchemaV1, type Stimulus, type StimulusKind, type SubmittedStatementParams, type TextMatchPolicy, type TextMatchResult, type ThemeTokens, type TimelineChapter, type TimelineCue, type 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, 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 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, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, type ReadAloudData, type ReadAloudDimension, type ReadAloudDimensionWeight, type ReadAloudLearnerResponse, type ReadAloudSlowMedia, type ReadAloudWordAlignment, type ReadAloudWordState, type RecordingBounds, type RecordingRef, type RedactedActivity, type RedactedBlankConfig, type RedactedDictationData, type RedactedDictationSlowMedia, type RedactedFillInTheBlanksData, type RedactedGapSelectBank, type RedactedGapSelectChoice, type RedactedGapSelectData, type RedactedGapSelectGap, type RedactedMultipleChoiceData, type RedactedMultipleChoiceOption, type RedactedMultipleChoiceOptionMedia, type RedactedReadAloudData, type RedactedStimulus, type RedactedWrittenResponseData, type RegisteredActivityTypeDescriptor, type ResolvedDeliveryPolicy, type ResolvedItemScoringPolicy, type ResponseDiffEntry, type RoundingMode, type RoundingPolicy, 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 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/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/types/media-budget.ts","../src/media-budget.ts","../src/media-refs.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 AI_HINT_TYPES, A as createInteractiveVideoDraft, B as sharedAnswers, C as AI_CRITIQUE_MAX_FIELD_LENGTH, D as createDraft, E as checkAiCritique, F as AI_VARIANT_LENGTH_BANDS, G as listMediaRefs, H as structureMisses, I as AI_VARIANT_NEAR_COPY_THRESHOLD, J as AI_COACHING_MAX_TIP_LENGTH, K as mapMediaRefs, L as keysOf, M as critiqueDrafts, N as critiqueItemGroupDraft, O as critiqueDraft, P as validateItemGroupDraft, Q as AI_EXPLANATION_TYPES, R as lengthMisses, S as interactiveVideoFromDrafts, T as aiCritiqueRequest, U as textSimilarity, V as shownScore, W as textsOf, X as aiCoachingRequest, Y as AI_COACHING_MAX_WORDS, Z as checkAiCoaching, _ as AI_DRAFTS_MAX_REPAIRS, a as AI_VARIANTS_MAX_REPAIRS, at as aiSupports, b as checkAiDrafts, c as aiVariantsRequest, ct as checkAiHint, d as AI_GRADING_PROBABILITY_TOLERANCE, dt as AI_MATERIAL_MAX_LENGTH, et as AI_TEXT_MAX_LENGTH, f as aiGradingRequest, g as AI_DRAFTS_MAX_COUNT, h as AI_WRITING_MAX_FIELD_LENGTH, i as AI_VARIANTS_MAX_MATERIAL_LENGTH, it as aiHintRequest, j as createItemGroupDraft, k as validateDraft, l as checkAiVariants, lt as hintRevealsAnswer, m as AI_WRITING_MAX_CORRECTIONS, n as checkAiWritingFeedback, nt as aiExplanationRequest, o as AI_VARIANT_CODE_SEVERITY, ot as buildAiFacts, p as checkAiGrading, q as transcriptOf, r as AI_VARIANTS_MAX_EXEMPLARS, rt as aiGradeOf, s as aiVariantsRepairRequest, st as checkAiExplanation, t as aiWritingFeedbackRequest, tt as aiAllowedByContent, u as generateVariants, ut as readAiTextResult, v as aiDraftsRepairRequest, w as AI_CRITIQUE_MAX_FINDINGS, x as generateDrafts, y as aiDraftsRequest, z as optionSet } from "./ai-writing-DeIV-GfN.js";
-import { $ as ActivitySchemaError, C as READ_ALOUD_MAX_TAKES, M as levenshteinDistance, N as matchText, Ot as SCRIPT_MAX_TURNS, R as countWords, S as READ_ALOUD_MAX_SECONDS, T as SPEECH_ASSESSMENT_MAX_WORDS, _t as isBuiltInActivityType, a as readSchema, b as READ_ALOUD_MAX_DIMENSION_WEIGHT, c as dictationType, ct as DICTATION_MAX_EQUIVALENCES, d as multipleChoiceType, dt as DICTATION_MAX_TRANSCRIPT_LENGTH, et as DeferredScoringError, f as readAloudType, h as defineActivityType, ht as BUILT_IN_ACTIVITY_TYPES, it as alignDictation, l as fillInTheBlanksType, lt as DICTATION_MAX_EQUIVALENCE_LENGTH, m as guardOf, n as registerActivityType, nt as UnknownActivityTypeError, ot as dictationReferenceWords, p as writtenResponseType, r as registeredActivityTypes, s as MEDIA_FIELD_POLICY, st as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, t as getActivityTypeDescriptor, tt as RedactedScoringError, u as gapSelectType, ut as DICTATION_MAX_TEXT_LENGTH, x as READ_ALOUD_MAX_REFERENCE_LENGTH } from "./registry-tkacvJUI.js";
-import { A as DEFAULT_ITEM_SCORING_POLICY, C as contentHash, D as classifyBand, E as computePassThreshold, M as resolveItemScoringPolicy, N as scoreTries, O as gte, P as validateItemScoringPolicy, S as canonicalJson, T as DEFAULT_PASS_THRESHOLD, _ as gradeFromRubric, a as inspectWav, b as calibrationReport, c as validateSpeechAssessment, d as inAuditSample, f as outcomeFromRoutedGrade, g as gradeFromJudgement, h as seededShuffle, i as outcomeFromUnscorable, j as ITEM_SCORING_MAX_RETRIES, k as roundGrade, l as diffDictationChars, m as hashSeed, n as evaluateTries, o as gradeReadAloud, p as routeGrade, r as score, s as alignReadAloud, t as evaluate, u as composeAssessmentScore, v as hasGrade, w as fingerprint, x as graderConfiguration, y as outcomeFromGrade } from "./scoring-DIBmo_cy.js";
-import { a as INTERACTIVE_VIDEO_ITEM_TYPES, c as TIMELINE_MAX_QUIZZES, i as validateItemGroup, l as TIMELINE_MAX_TITLE_LENGTH, n as RedactedItemGroupSchema, o as TIMELINE_MAX_CHAPTERS, s as TIMELINE_MAX_ITEMS, u as isInteractiveVideoItemType } from "./item-group-BceUoxoM.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-DM8sN_f0.js";
-import { a as validateXAPIStatement, i as XAPI_VERB_DISPLAY, n as xapiDefinitionFor, r as XAPIVerb, t as xAPIBuilder } from "./xapi-gCAo549Q.js";
+import { $ as AI_EXPLANATION_TYPES, A as validateDraft, B as optionSet, C as interactiveVideoFromDrafts, D as checkAiCritique, E as aiCritiqueRequest, F as validateItemGroupDraft, G as textsOf, H as shownScore, I as AI_VARIANT_LENGTH_BANDS, J as transcriptOf, K as listMediaRefs, L as AI_VARIANT_NEAR_COPY_THRESHOLD, M as createItemGroupDraft, N as critiqueDrafts, O as createDraft, P as critiqueItemGroupDraft, Q as checkAiCoaching, R as keysOf, S as generateDrafts, T as AI_CRITIQUE_MAX_FINDINGS, U as structureMisses, V as sharedAnswers, W as textSimilarity, X as AI_COACHING_MAX_WORDS, Y as AI_COACHING_MAX_TIP_LENGTH, Z as aiCoachingRequest, _ as AI_DRAFTS_MAX_COUNT, a as AI_VARIANTS_MAX_REPAIRS, at as aiHintRequest, b as aiDraftsRequest, c as aiVariantsRequest, ct as checkAiExplanation, d as AI_GRADING_PROBABILITY_TOLERANCE, dt as readAiTextResult, et as AI_HINT_TYPES, f as aiGradingRequest, ft as AI_MATERIAL_MAX_LENGTH, g as AI_WRITING_MAX_FIELD_LENGTH, h as AI_WRITING_MAX_CORRECTIONS, i as AI_VARIANTS_MAX_MATERIAL_LENGTH, it as aiGradeOf, j as createInteractiveVideoDraft, k as critiqueDraft, l as checkAiVariants, lt as checkAiHint, m as checkAiGrading, n as checkAiWritingFeedback, nt as aiAllowedByContent, o as AI_VARIANT_CODE_SEVERITY, ot as aiSupports, p as aiSpeakingGradingRequest, q as mapMediaRefs, r as AI_VARIANTS_MAX_EXEMPLARS, rt as aiExplanationRequest, s as aiVariantsRepairRequest, st as buildAiFacts, t as aiWritingFeedbackRequest, tt as AI_TEXT_MAX_LENGTH, u as generateVariants, ut as hintRevealsAnswer, v as AI_DRAFTS_MAX_REPAIRS, w as AI_CRITIQUE_MAX_FIELD_LENGTH, x as checkAiDrafts, y as aiDraftsRepairRequest, z as lengthMisses } from "./ai-writing-DQjI9EFN.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-Bw9grsCN.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-BGKdff2i.js";
+import { a as INTERACTIVE_VIDEO_ITEM_TYPES, c as TIMELINE_MAX_QUIZZES, i as validateItemGroup, l as TIMELINE_MAX_TITLE_LENGTH, n as RedactedItemGroupSchema, o as TIMELINE_MAX_CHAPTERS, s as TIMELINE_MAX_ITEMS, u as isInteractiveVideoItemType } from "./item-group-CKZk3txt.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-BJe3W6Xb.js";
+import { a as validateXAPIStatement, i as XAPI_VERB_DISPLAY, n as xapiDefinitionFor, r as XAPIVerb, t as xAPIBuilder } from "./xapi-BtBm8AWZ.js";
 // src/delivery.ts
 /**
 * The policy that restricts nothing: every setting `true`. It is what an absent
@@ -1354,6 +1354,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, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, 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, 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, countWords, createDraft, createInteractiveVideoDraft, createItemGroupDraft, critiqueDraft, critiqueDrafts, critiqueItemGroupDraft, critiqueVersions, defineActivityType, dictationJsonSchema, dictationReferenceWords, dictationType, diffDictationChars, diffResponses, entryKeyOf, evaluate, evaluateTries, fillInTheBlanksJsonSchema, fillInTheBlanksType, fingerprint, flattenSequence, gapSelectJsonSchema, gapSelectType, generateDrafts, generateVariants, getActivityTypeDescriptor, gradeFromJudgement, gradeFromRubric, gradeReadAloud, graderConfiguration, gte, hasGrade, hashSeed, hintRevealsAnswer, inAuditSample, inspectWav, interactiveVideoFromDrafts, isBuiltInActivityType, isInteractiveVideoItemType, isItemGroup, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, listMediaRefs, mapMediaRefs, matchText, multipleChoiceJsonSchema, multipleChoiceType, outcomeFromGrade, outcomeFromRoutedGrade, outcomeFromUnscorable, planAttempt, planMediaBudgets, readAiTextResult, readAloudJsonSchema, readAloudType, readMediaProgress, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolveDeliveryPolicy, resolveItemScoringPolicy, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, roundGrade, routeGrade, score, scoreTries, scoredItemsFromPlan, seededShuffle, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusJsonSchema, stimulusMediaKey, 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, OPEN_DELIVERY_POLICY, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, 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, countWords, createDraft, createInteractiveVideoDraft, createItemGroupDraft, critiqueDraft, critiqueDrafts, critiqueItemGroupDraft, critiqueVersions, defineActivityType, dictationJsonSchema, dictationReferenceWords, dictationType, diffDictationChars, diffResponses, entryKeyOf, evaluate, evaluateTries, fillInTheBlanksJsonSchema, fillInTheBlanksType, fingerprint, flattenSequence, gapSelectJsonSchema, gapSelectType, generateDrafts, generateVariants, getActivityTypeDescriptor, gradeFromJudgement, gradeFromRubric, gradeReadAloud, gradeSpeakingResponse, graderConfiguration, gte, hasGrade, hashSeed, hintRevealsAnswer, inAuditSample, inspectWav, interactiveVideoFromDrafts, isBuiltInActivityType, isInteractiveVideoItemType, isItemGroup, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, listMediaRefs, mapMediaRefs, matchText, multipleChoiceJsonSchema, multipleChoiceType, outcomeFromGrade, outcomeFromRoutedGrade, outcomeFromUnscorable, planAttempt, planMediaBudgets, readAiTextResult, readAloudJsonSchema, readAloudType, readMediaProgress, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolveDeliveryPolicy, resolveItemScoringPolicy, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, roundGrade, routeGrade, score, scoreTries, scoredItemsFromPlan, seededShuffle, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusJsonSchema, stimulusMediaKey, 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-BceUoxoM.js → item-group-CKZk3txt.js}

@@ -1,4 +1,4 @@
-import { At as maxUnits, Dt as RedactedMediaSchema, Et as MediaSchema, Q as groupCaptionsField, Z as GROUP_CAPTIONS_REVEAL_DICTATION, a as readSchema, kt as ScriptSchema, t as getActivityTypeDescriptor } from "./registry-tkacvJUI.js";
+import { $ as GROUP_CAPTIONS_REVEAL_DICTATION, Mt as maxUnits, Ot as MediaSchema, a as readSchema, et as groupCaptionsField, jt as ScriptSchema, kt as RedactedMediaSchema, t as getActivityTypeDescriptor } from "./registry-Bw9grsCN.js";
 import * as z from "zod/v4";
 // src/timeline-limits.ts
 /**
@@ -441,4 +441,4 @@ function validateItemGroup(data) {
 }
 export { INTERACTIVE_VIDEO_ITEM_TYPES as a, TIMELINE_MAX_QUIZZES as c, validateItemGroup as i, TIMELINE_MAX_TITLE_LENGTH as l, RedactedItemGroupSchema as n, TIMELINE_MAX_CHAPTERS as o, StimulusSchema as r, TIMELINE_MAX_ITEMS as s, ItemGroupSchema as t, isInteractiveVideoItemType as u };
 
-//# sourceMappingURL=item-group-BceUoxoM.js.map
+//# sourceMappingURL=item-group-CKZk3txt.js.map

package/dist/{item-group-BceUoxoM.js.map → item-group-CKZk3txt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"item-group-BceUoxoM.js","names":[],"sources":["../src/timeline-limits.ts","../src/schemas/item-group.ts"],"sourcesContent":["/**\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 microphone included, because every quiz pauses the video\n * first.\n */\nexport const INTERACTIVE_VIDEO_ITEM_TYPES = [\n  'multiple-choice',\n  'fill-in-the-blanks',\n  'gap-select',\n  'dictation',\n  'read-aloud',\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 { 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/** 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  })\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  });\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  })\n  .check((ctx) => {\n    for (const issue of timelineIssues(ctx.value, 'redacted')) {\n      ctx.issues.push({ code: 'custom', ...issue });\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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"}
+{"version":3,"file":"item-group-CKZk3txt.js","names":[],"sources":["../src/timeline-limits.ts","../src/schemas/item-group.ts"],"sourcesContent":["/**\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 microphone included, because every quiz pauses the video\n * first.\n */\nexport const INTERACTIVE_VIDEO_ITEM_TYPES = [\n  'multiple-choice',\n  'fill-in-the-blanks',\n  'gap-select',\n  'dictation',\n  'read-aloud',\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 { 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/** 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  })\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  });\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  })\n  .check((ctx) => {\n    for (const issue of timelineIssues(ctx.value, 'redacted')) {\n      ctx.issues.push({ code: 'custom', ...issue });\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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"}

package/dist/{item-group-KV4hYu3a.cjs → item-group-COP5OwEC.cjs}

@@ -1,4 +1,4 @@
-const require_registry = require("./registry-Cymq7Ah0.cjs");
+const require_registry = require("./registry-C9O9txy5.cjs");
 let zod_v4 = require("zod/v4");
 zod_v4 = require_registry.__toESM(zod_v4, 1);
 // src/timeline-limits.ts
@@ -501,4 +501,4 @@ Object.defineProperty(exports, "validateItemGroup", {
 	}
 });
 
-//# sourceMappingURL=item-group-KV4hYu3a.cjs.map
+//# sourceMappingURL=item-group-COP5OwEC.cjs.map

package/dist/{item-group-KV4hYu3a.cjs.map → item-group-COP5OwEC.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"item-group-KV4hYu3a.cjs","names":["z","MediaSchema","ScriptSchema","maxUnits","RedactedMediaSchema","groupCaptionsField","GROUP_CAPTIONS_REVEAL_DICTATION","getActivityTypeDescriptor","readSchema"],"sources":["../src/timeline-limits.ts","../src/schemas/item-group.ts"],"sourcesContent":["/**\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 microphone included, because every quiz pauses the video\n * first.\n */\nexport const INTERACTIVE_VIDEO_ITEM_TYPES = [\n  'multiple-choice',\n  'fill-in-the-blanks',\n  'gap-select',\n  'dictation',\n  'read-aloud',\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 { 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/** 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  })\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  });\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  })\n  .check((ctx) => {\n    for (const issue of timelineIssues(ctx.value, 'redacted')) {\n      ctx.issues.push({ code: 'custom', ...issue });\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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"}
+{"version":3,"file":"item-group-COP5OwEC.cjs","names":["z","MediaSchema","ScriptSchema","maxUnits","RedactedMediaSchema","groupCaptionsField","GROUP_CAPTIONS_REVEAL_DICTATION","getActivityTypeDescriptor","readSchema"],"sources":["../src/timeline-limits.ts","../src/schemas/item-group.ts"],"sourcesContent":["/**\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 microphone included, because every quiz pauses the video\n * first.\n */\nexport const INTERACTIVE_VIDEO_ITEM_TYPES = [\n  'multiple-choice',\n  'fill-in-the-blanks',\n  'gap-select',\n  'dictation',\n  'read-aloud',\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 { 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/** 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  })\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  });\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  })\n  .check((ctx) => {\n    for (const issue of timelineIssues(ctx.value, 'redacted')) {\n      ctx.issues.push({ code: 'custom', ...issue });\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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"}