@intellectif/lk-core 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { ScoredItem } from './scoring.js';
-export { AssessmentScore, AssessmentSectionInput, Band, CompositionPolicy, DEFAULT_PASS_THRESHOLD, PassFailureReason, RoundingMode, RoundingPolicy, SectionScore, classifyBand, composeAssessmentScore, computePassThreshold, evaluate, gte, roundGrade, score } from './scoring.js';
-import { r as ItemOutcome, A as ActivityData, L as LearnerResponse, V as ValidationError, e as ActivityType, a as ActivityDataMap, C as CriterionScore, k as GradeRecord, N as NativeControlHint, c as ActivityMedia, x as ScoringResult, D as DeferredScoringPartial, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, M as MultipleChoiceData, t as MultipleChoiceLearnerResponse, W as WrittenResponseData, E as WrittenResponseLearnerResponse } from './activity-B2QxK15j.js';
-export { b as ActivityFeedback, d as ActivityResult, B as BlankConfig, G as GapSelectBank, g as GapSelectChoice, h as GapSelectData, i as GapSelectGap, j as GapSelectLearnerResponse, l as Grader, m as GraderKind, n as GraderUsage, o as GradingState, I as InlineCorrection, p as InteractionEvent, q as InteractionKind, s as LearnerResponseMap, u as MultipleChoiceOption, v as MultipleChoiceOptionMedia, S as ScoringDetail, w as ScoringOutcome, T as TextMatchPolicy, y as TextMatchResult, z as ValidationResult, H as WrittenResponseRubric, J as WrittenResponseRubricCriterion, X as XAPIActor, K as XAPIConfig, O as XAPIContext, P as XAPIContextActivities, Q as XAPIError, R as XAPIObject, U as XAPIResult, Y as XAPIScore, Z as XAPIStatement, _ as XAPIVerbObject, $ as levenshteinDistance, a0 as matchText } from './activity-B2QxK15j.js';
-import { O as SequenceSlot, S as SequenceEntry, I as ItemGroup } from './index-CRKtWP5G.js';
-export { B as BlankConfigSchema, F as FeedbackSchema, a as FillInTheBlanksDataSchema, G as GapSelectBankSchema, b as GapSelectChoiceSchema, c as GapSelectDataSchema, d as GapSelectGapSchema, e as ItemGroupSchema, M as MediaPlaybackSchema, f as MediaSchema, g as MediaUrlSchema, h as MultipleChoiceDataSchema, i as MultipleChoiceOptionMediaSchema, j as MultipleChoiceOptionSchema, N as NativeControlHintSchema, R as RedactedActivity, k as RedactedBlankConfig, l as RedactedBlankConfigSchema, m as RedactedFillInTheBlanksData, n as RedactedFillInTheBlanksDataSchema, o as RedactedGapSelectBank, p as RedactedGapSelectBankSchema, q as RedactedGapSelectChoice, r as RedactedGapSelectChoiceSchema, s as RedactedGapSelectData, t as RedactedGapSelectDataSchema, u as RedactedGapSelectGap, v as RedactedGapSelectGapSchema, w as RedactedItemGroupSchema, x as RedactedMediaSchema, y as RedactedMultipleChoiceData, z as RedactedMultipleChoiceDataSchema, A as RedactedMultipleChoiceOption, C as RedactedMultipleChoiceOptionMedia, D as RedactedMultipleChoiceOptionMediaSchema, E as RedactedMultipleChoiceOptionSchema, H as RedactedStimulus, J as RedactedStimulusSchema, K as RedactedWrittenResponseData, L as RedactedWrittenResponseDataSchema, P as SequenceSlotGroup, Q as Stimulus, T as StimulusKind, U as StimulusSchema, V as TextMatchPolicySchema, W as WrittenResponseDataSchema, X as WrittenResponseRubricCriterionSchema, Y as WrittenResponseRubricSchema, Z as fillInTheBlanksJsonSchema, _ as gapSelectJsonSchema, $ as itemGroupJsonSchema, a0 as jsonSchemaFor, a1 as multipleChoiceJsonSchema, a2 as stimulusJsonSchema, a3 as validateActivity, a4 as validateItemGroup, a5 as writtenResponseJsonSchema } from './index-CRKtWP5G.js';
+export { AssessmentScore, AssessmentSectionInput, Band, CompositionPolicy, DEFAULT_PASS_THRESHOLD, DICTATION_MAX_ACCEPTED_TRANSCRIPTS, DICTATION_MAX_EQUIVALENCES, DICTATION_MAX_EQUIVALENCE_LENGTH, DICTATION_MAX_TEXT_LENGTH, DICTATION_MAX_TRANSCRIPT_LENGTH, DictationAlignment, DictationCharOp, DictationReference, DictationWordAlignment, PassFailureReason, RoundingMode, RoundingPolicy, ScoringOptions, SectionScore, alignDictation, classifyBand, composeAssessmentScore, computePassThreshold, dictationReferenceWords, diffDictationChars, evaluate, gte, roundGrade, score } from './scoring.js';
+import { w as ItemOutcome, A as ActivityData, L as LearnerResponse, V as ValidationError, e as ActivityType, a as ActivityDataMap, C as CriterionScore, p as GradeRecord, N as NativeControlHint, c as ActivityMedia, K as ScoringResult, D as DeferredScoringPartial, f as DictationData, h as DictationLearnerResponse, F as FillInTheBlanksData, k as FillInTheBlanksLearnerResponse, m as GapSelectData, o as GapSelectLearnerResponse, y as MultipleChoiceData, z as MultipleChoiceLearnerResponse, W as WrittenResponseData, Q as WrittenResponseLearnerResponse } from './activity-DfAmJ1sl.js';
+export { b as ActivityFeedback, d as ActivityResult, B as BlankConfig, g as DictationEquivalence, i as DictationSlowMedia, j as DictationTolerance, G as GapSelectBank, l as GapSelectChoice, n as GapSelectGap, q as Grader, r as GraderKind, s as GraderUsage, t as GradingState, I as InlineCorrection, u as InteractionEvent, v as InteractionKind, x as LearnerResponseMap, M as MediaPlaybackPolicy, E as MultipleChoiceOption, H as MultipleChoiceOptionMedia, S as ScoringDetail, J as ScoringOutcome, T as TextMatchPolicy, O as TextMatchResult, P as ValidationResult, R as WrittenResponseRubric, U as WrittenResponseRubricCriterion, X as XAPIActor, Y as XAPIConfig, Z as XAPIContext, _ as XAPIContextActivities, $ as XAPIError, a0 as XAPIObject, a1 as XAPIResult, a2 as XAPIScore, a3 as XAPIStatement, a4 as XAPIVerbObject, a5 as levenshteinDistance, a6 as matchText } from './activity-DfAmJ1sl.js';
+import { Y as SequenceSlot, X as SequenceEntry, I as ItemGroup } from './index-CJbbVE9o.js';
+export { B as BlankConfigSchema, D as DictationDataSchema, a as DictationEquivalenceSchema, b as DictationSlowMediaSchema, c as DictationToleranceSchema, F as FeedbackSchema, d as FillInTheBlanksDataSchema, G as GapSelectBankSchema, e as GapSelectChoiceSchema, f as GapSelectDataSchema, g as GapSelectGapSchema, h as ItemGroupSchema, M as MediaPlaybackSchema, i as MediaSchema, j as MediaUrlSchema, k as MultipleChoiceDataSchema, l as MultipleChoiceOptionMediaSchema, m as MultipleChoiceOptionSchema, N as NativeControlHintSchema, R as RedactedActivity, n as RedactedBlankConfig, o as RedactedBlankConfigSchema, p as RedactedDictationData, q as RedactedDictationDataSchema, r as RedactedDictationSlowMedia, s as RedactedDictationSlowMediaSchema, t as RedactedFillInTheBlanksData, u as RedactedFillInTheBlanksDataSchema, v as RedactedGapSelectBank, w as RedactedGapSelectBankSchema, x as RedactedGapSelectChoice, y as RedactedGapSelectChoiceSchema, z as RedactedGapSelectData, A as RedactedGapSelectDataSchema, C as RedactedGapSelectGap, E as RedactedGapSelectGapSchema, H as RedactedItemGroupSchema, J as RedactedMediaSchema, K as RedactedMultipleChoiceData, L as RedactedMultipleChoiceDataSchema, O as RedactedMultipleChoiceOption, P as RedactedMultipleChoiceOptionMedia, Q as RedactedMultipleChoiceOptionMediaSchema, S as RedactedMultipleChoiceOptionSchema, T as RedactedStimulus, U as RedactedStimulusSchema, V as RedactedWrittenResponseData, W as RedactedWrittenResponseDataSchema, Z as SequenceSlotGroup, _ as Stimulus, $ as StimulusKind, a0 as StimulusSchema, a1 as TextMatchPolicySchema, a2 as WrittenResponseDataSchema, a3 as WrittenResponseRubricCriterionSchema, a4 as WrittenResponseRubricSchema, a5 as dictationJsonSchema, a6 as fillInTheBlanksJsonSchema, a7 as gapSelectJsonSchema, a8 as itemGroupJsonSchema, a9 as jsonSchemaFor, aa as multipleChoiceJsonSchema, ab as stimulusJsonSchema, ac as validateActivity, ad as validateItemGroup, ae as writtenResponseJsonSchema } from './index-CJbbVE9o.js';
 import { z } from 'zod/v4';
 export { AnsweredStatementParams, CompletedStatementParams, SubmittedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor } from './xapi.js';
 
@@ -382,6 +382,40 @@ interface DraftContext {
     newId: () => string;
 }
 
+/**
+ * A new, empty reading or listening testlet for an editor to start from.
+ *
+ * The stimulus starts as `text`, the only kind that needs no media file to be
+ * a valid draft — an author who is writing a passage can begin typing, and one
+ * who is building a listening item changes `kind` before uploading. `items`
+ * starts empty, exactly as a new fill-in-the-blanks draft starts with no
+ * blanks: the group is `incomplete` until somebody writes a question into it.
+ *
+ * @throws Error when `newId` returns an empty or repeated id.
+ */
+declare function createItemGroupDraft(context: DraftContext): ItemGroup;
+/**
+ * Tells an unfinished testlet from a broken one — {@link validateDraft} for the
+ * container that holds several questions around one passage or recording.
+ *
+ * It is a **separate entry point rather than a `'item-group'` type**, because
+ * `validateDraft('item-group', …)` throws by design: `item-group` is reserved
+ * in the registry precisely so it can never be registered as an activity, and
+ * that guard is what keeps `isItemGroup` and `flattenSequence` able to trust
+ * their own container. Widening `validateDraft` to accept it would have meant
+ * weakening that.
+ *
+ * Each item is checked by `validateDraft` for its own type and its issues are
+ * re-pathed under `items.N.…`, so an editor gets one list for the whole group
+ * and every code in it is the code that type already documents. An item whose
+ * type nobody registered is REPORTED, never thrown — an author fixing a
+ * six-item group wants all six problems, not the first one that blew up.
+ *
+ * The group is `complete` only when the container passes, every item passes its
+ * own schema, and every item is itself `complete`.
+ */
+declare function validateItemGroupDraft(draft: unknown): DraftValidationResult<ItemGroup>;
+
 /**
  * Tells a draft that is not finished from a draft that is wrong.
  *
@@ -1048,6 +1082,14 @@ declare const fillInTheBlanksType: ActivityTypeDescriptor<FillInTheBlanksData, F
  * count is informational, never trusted.
  */
 declare const writtenResponseType: ActivityTypeDescriptor<WrittenResponseData, WrittenResponseLearnerResponse>;
+/** Built-in Gap Select descriptor. */
+declare const gapSelectType: ActivityTypeDescriptor<GapSelectData, GapSelectLearnerResponse>;
+/**
+ * Built-in Dictation descriptor. Graded synchronously: the score is the
+ * character-level similarity of the typed text to the transcript, a pure
+ * computation identical in a browser and on a server.
+ */
+declare const dictationType: ActivityTypeDescriptor<DictationData, DictationLearnerResponse>;
 
 /**
  * Seeded, deterministic shuffling — the ONE algorithm every presentation-order
@@ -1148,4 +1190,4 @@ interface ThemeTokens {
     '--lk-transition-base': string;
 }
 
-export { ActivityData, ActivityDataMap, ActivityMedia, ActivitySchemaError, ActivityType, type ActivityTypeAuthoring, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, type AttemptPlan, type AttemptPlanDrift, type AttemptPlanSlot, type AttemptProgress, type AttemptState, CriterionScore, DeferredScoringError, DeferredScoringPartial, type DraftComplete, type DraftContext, type DraftIssue, type DraftNotComplete, type DraftSeverity, type DraftValidationResult, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, type FlattenSequenceOptions, type GradeFromRubricOptions, GradeRecord, ItemGroup, ItemOutcome, LearnerResponse, type MediaBudgetRef, type MediaPlayClaim, type MediaPlayGrant, type MediaPlayLedger, type MediaPlayLedgerEntry, type MissingOutcomePolicy, MultipleChoiceData, MultipleChoiceLearnerResponse, type PartialScoringResult, type PlanAttemptOptions, type PlannableEntry, type RedactOptions, type RedactedActivityData, type RedactedItemGroup, RedactedScoringError, type RegisteredActivityTypeDescriptor, type ResolvedPlaybackPolicy, type ResponseDiffEntry, ScoredItem, ScoringResult, type SeededShuffleOptions, type Sensitivity, SequenceEntry, SequenceSlot, type ShuffleVersion, type ThemeTokens, UnknownActivityTypeError, ValidationError, WrittenResponseData, WrittenResponseLearnerResponse, type XAPIInteractionType, assertRedacted, assertRedactedItemGroup, canonicalJson, contentHash, countWords, createDraft, defineActivityType, diffResponses, entryKeyOf, fillInTheBlanksType, fingerprint, flattenSequence, getActivityTypeDescriptor, gradeFromRubric, hasGrade, hashSeed, isItemGroup, multipleChoiceType, outcomeFromGrade, planAttempt, planMediaBudgets, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, scoredItemsFromPlan, seededShuffle, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusMediaKey, validateDraft, verifyAttemptPlan, writtenResponseType };
+export { ActivityData, ActivityDataMap, ActivityMedia, ActivitySchemaError, ActivityType, type ActivityTypeAuthoring, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, type AttemptPlan, type AttemptPlanDrift, type AttemptPlanSlot, type AttemptProgress, type AttemptState, CriterionScore, DeferredScoringError, DeferredScoringPartial, DictationData, DictationLearnerResponse, type DraftComplete, type DraftContext, type DraftIssue, type DraftNotComplete, type DraftSeverity, type DraftValidationResult, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, type FlattenSequenceOptions, GapSelectData, GapSelectLearnerResponse, type GradeFromRubricOptions, GradeRecord, ItemGroup, ItemOutcome, LearnerResponse, type MediaBudgetRef, type MediaPlayClaim, type MediaPlayGrant, type MediaPlayLedger, type MediaPlayLedgerEntry, type MissingOutcomePolicy, MultipleChoiceData, MultipleChoiceLearnerResponse, NativeControlHint, type PartialScoringResult, type PlanAttemptOptions, type PlannableEntry, type RedactOptions, type RedactedActivityData, type RedactedItemGroup, RedactedScoringError, type RegisteredActivityTypeDescriptor, type ResolvedPlaybackPolicy, type ResponseDiffEntry, ScoredItem, ScoringResult, type SeededShuffleOptions, type Sensitivity, SequenceEntry, SequenceSlot, type ShuffleVersion, type ThemeTokens, UnknownActivityTypeError, ValidationError, WrittenResponseData, WrittenResponseLearnerResponse, type XAPIInteractionType, assertRedacted, assertRedactedItemGroup, canonicalJson, contentHash, countWords, createDraft, createItemGroupDraft, defineActivityType, dictationType, diffResponses, entryKeyOf, fillInTheBlanksType, fingerprint, flattenSequence, gapSelectType, getActivityTypeDescriptor, gradeFromRubric, hasGrade, hashSeed, isItemGroup, multipleChoiceType, outcomeFromGrade, planAttempt, planMediaBudgets, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, scoredItemsFromPlan, seededShuffle, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusMediaKey, validateDraft, validateItemGroupDraft, verifyAttemptPlan, writtenResponseType };

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   classifyBand,
   composeAssessmentScore,
   computePassThreshold,
+  diffDictationChars,
   evaluate,
   gradeFromRubric,
   gte,
@@ -10,19 +11,20 @@ import {
   outcomeFromGrade,
   roundGrade,
   score
-} from "./chunk-ZTY4UIUD.js";
+} from "./chunk-FGN4LLSP.js";
 import {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
   xAPIBuilder,
   xapiDefinitionFor
-} from "./chunk-IXXMYJI7.js";
+} from "./chunk-PYP3HCRQ.js";
 import {
   ItemGroupSchema,
   RedactedItemGroupSchema,
   RedactedStimulusSchema,
   StimulusSchema,
+  dictationJsonSchema,
   fillInTheBlanksJsonSchema,
   gapSelectJsonSchema,
   itemGroupJsonSchema,
@@ -32,14 +34,24 @@ import {
   validateActivity,
   validateItemGroup,
   writtenResponseJsonSchema
-} from "./chunk-XGCTAQSS.js";
+} from "./chunk-Y36S3X3L.js";
 import {
   ActivitySchemaError,
   BlankConfigSchema,
+  DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
+  DICTATION_MAX_EQUIVALENCES,
+  DICTATION_MAX_EQUIVALENCE_LENGTH,
+  DICTATION_MAX_TEXT_LENGTH,
+  DICTATION_MAX_TRANSCRIPT_LENGTH,
   DRAFT_ISSUE_SEVERITY,
   DeferredScoringError,
+  DictationDataSchema,
+  DictationEquivalenceSchema,
+  DictationSlowMediaSchema,
+  DictationToleranceSchema,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
+  GROUP_CAPTIONS_REVEAL_DICTATION,
   GapSelectBankSchema,
   GapSelectChoiceSchema,
   GapSelectDataSchema,
@@ -53,6 +65,8 @@ import {
   MultipleChoiceOptionSchema,
   NativeControlHintSchema,
   RedactedBlankConfigSchema,
+  RedactedDictationDataSchema,
+  RedactedDictationSlowMediaSchema,
   RedactedFillInTheBlanksDataSchema,
   RedactedGapSelectBankSchema,
   RedactedGapSelectChoiceSchema,
@@ -69,20 +83,33 @@ import {
   WrittenResponseDataSchema,
   WrittenResponseRubricCriterionSchema,
   WrittenResponseRubricSchema,
+  alignDictation,
+  checkMedia,
   countWords,
+  coveredPathsOf,
+  covers,
   defineActivityType,
+  dictationReferenceWords,
+  dictationType,
   fillInTheBlanksType,
+  gapSelectType,
   getActivityTypeDescriptor,
+  groupCaptionsRevealDictation,
+  isMissingId,
   isRecord,
+  isUnset,
+  isUnwritten,
   issue,
   levenshteinDistance,
   matchText,
   multipleChoiceType,
+  pathKey,
   refusesEmpty,
   registerActivityType,
   registeredActivityTypes,
+  withValidationScope,
   writtenResponseType
-} from "./chunk-FIS5KBCE.js";
+} from "./chunk-XKKKWKRH.js";
 
 // src/content-hash.ts
 function canonicalJson(value, seen = /* @__PURE__ */ new Set()) {
@@ -586,8 +613,278 @@ function diffResponses(before, after) {
   return entries;
 }
 
+// src/authoring/item-group.ts
+function createItemGroupDraft(context) {
+  const issued = /* @__PURE__ */ new Set();
+  const newId = () => {
+    const id = context.newId();
+    if (typeof id !== "string" || id === "") {
+      throw new Error("createItemGroupDraft: newId() must return a non-empty string.");
+    }
+    if (issued.has(id)) {
+      throw new Error(
+        `createItemGroupDraft: newId() returned "${id}" twice. Ids within one draft must differ.`
+      );
+    }
+    issued.add(id);
+    return id;
+  };
+  return {
+    schemaVersion: "1.0",
+    type: "item-group",
+    id: newId(),
+    stimulus: { id: newId(), kind: "text", body: "" },
+    items: []
+  };
+}
+function validateItemGroupDraft(draft) {
+  return withValidationScope(() => validateItemGroupDraftInScope(draft));
+}
+function validateItemGroupDraftInScope(draft) {
+  const issues = [];
+  if (!isRecord(draft)) {
+    issues.push(
+      issue("ig_not_an_object", [], "A group must be an object with a stimulus and its items.")
+    );
+    return { status: "invalid", issues };
+  }
+  issues.push(...checkGroupIdentity(draft));
+  if (isRecord(draft.stimulus)) {
+    issues.push(...checkStimulus(draft.stimulus));
+  } else if (isUnset(draft.stimulus)) {
+    issues.push(
+      issue(
+        "ig_stimulus_required",
+        ["stimulus"],
+        "Add the passage, recording or image the questions are about."
+      )
+    );
+  }
+  issues.push(...checkItems(draft));
+  if (groupCaptionsRevealDictation(draft, (captionsUrl) => !isUnwritten(captionsUrl))) {
+    issues.push(
+      issue(
+        "dc_captions_not_allowed",
+        ["stimulus", "media", "captionsUrl"],
+        GROUP_CAPTIONS_REVEAL_DICTATION
+      )
+    );
+  }
+  const parsed = ItemGroupSchema.safeParse(draft, { reportInput: true });
+  if (!parsed.success) {
+    for (const schemaIssue of parsed.error.issues) {
+      const path = schemaIssue.path.map(String);
+      if (issues.some((known) => covers(known.path, path))) {
+        continue;
+      }
+      if (path.length > 0 && refusesEmpty(draft, schemaIssue)) {
+        issues.push(
+          issue(
+            "null_not_allowed",
+            path,
+            "This field cannot be null. Leave it out if it is optional, or give it a value."
+          )
+        );
+        continue;
+      }
+      issues.push({
+        path,
+        message: schemaIssue.message,
+        code: schemaIssue.code,
+        severity: "invalid"
+      });
+    }
+  }
+  const stored = validateItemGroup(draft);
+  if (issues.length === 0 && stored.success) {
+    return { status: "complete", data: stored.data, issues };
+  }
+  if (issues.length === 0) {
+    for (const error of stored.success ? [] : stored.errors) {
+      issues.push({ ...error, severity: "invalid" });
+    }
+  }
+  const invalid = issues.some((found) => found.severity !== "incomplete");
+  return { status: invalid ? "invalid" : "incomplete", issues };
+}
+function checkGroupIdentity(draft) {
+  const issues = [];
+  if (draft.schemaVersion !== "1.0") {
+    issues.push(
+      issue(
+        "schema_version_invalid",
+        ["schemaVersion"],
+        'The draft must have schemaVersion "1.0". A draft from createItemGroupDraft has it.'
+      )
+    );
+  }
+  if (draft.type !== "item-group") {
+    issues.push(issue("type_mismatch", ["type"], `The draft's type must be "item-group".`));
+  }
+  if (isMissingId(draft.id)) {
+    issues.push(issue("id_required", ["id"], "The group has no id."));
+  }
+  if (!isUnset(draft.shuffle) && draft.shuffle !== "none" && draft.shuffle !== "within-group") {
+    issues.push(
+      issue(
+        "ig_shuffle_invalid",
+        ["shuffle"],
+        'Shuffling is either "none" or "within-group". Leave it out to keep the authored order.'
+      )
+    );
+  }
+  return issues;
+}
+var KINDS = /* @__PURE__ */ new Set(["text", "audio", "video", "image", "mixed"]);
+var MEDIA_FOR_KIND = {
+  audio: ["audio"],
+  video: ["video", "embed"],
+  image: ["image"],
+  mixed: ["audio", "video", "image", "embed"]
+};
+function checkStimulus(stimulus) {
+  const issues = [];
+  const at = (...rest) => ["stimulus", ...rest];
+  if (isMissingId(stimulus.id)) {
+    issues.push(issue("ig_stimulus_id_required", at("id"), "The stimulus has no id."));
+  }
+  const kind = stimulus.kind;
+  if (isUnwritten(kind)) {
+    issues.push(
+      issue(
+        "ig_stimulus_kind_required",
+        at("kind"),
+        "Choose what the questions are about: a text, a recording, a video, an image, or a mix."
+      )
+    );
+  } else if (typeof kind !== "string" || !KINDS.has(kind)) {
+    if (typeof kind === "string") {
+      issues.push(
+        issue(
+          "ig_stimulus_kind_invalid",
+          at("kind"),
+          `"${kind}" is not a stimulus kind. Use text, audio, video, image or mixed.`
+        )
+      );
+    }
+    if (isRecord(stimulus.media)) {
+      issues.push(...checkMedia(stimulus.media, at("media")));
+    }
+    return issues;
+  }
+  const hasBody = typeof stimulus.body === "string" && stimulus.body.trim() !== "";
+  const htmlPresent = !isUnset(stimulus.bodyHtml);
+  if (!hasBody && (kind === "text" || kind === "mixed" || htmlPresent)) {
+    issues.push(
+      issue(
+        "ig_stimulus_body_required",
+        at("body"),
+        isUnwritten(stimulus.bodyHtml) ? "Write the passage." : "Write the passage as plain text too. The rich-text version is shown only where a sanitiser is supplied."
+      )
+    );
+  }
+  if (kind !== "text" && isUnset(stimulus.media)) {
+    issues.push(
+      issue("ig_stimulus_media_required", at("media"), "Add the recording, video or image.")
+    );
+  } else if (isRecord(stimulus.media)) {
+    const allowed = MEDIA_FOR_KIND[kind];
+    const mediaType = stimulus.media.type;
+    if (allowed !== void 0 && typeof mediaType === "string" && !allowed.includes(mediaType)) {
+      issues.push(
+        issue(
+          "ig_stimulus_media_kind",
+          at("media", "type"),
+          `A "${kind}" stimulus cannot carry ${mediaType} media. Use ${allowed.join(" or ")}.`
+        )
+      );
+    }
+    issues.push(...checkMedia(stimulus.media, at("media")));
+  }
+  return issues;
+}
+function checkItems(draft) {
+  const issues = [];
+  const items = isUnset(draft.items) ? [] : draft.items;
+  if (!Array.isArray(items)) {
+    return issues;
+  }
+  if (items.length === 0) {
+    issues.push(
+      issue("ig_items_required", ["items"], "Add at least one question about this material.")
+    );
+    return issues;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const repeated = /* @__PURE__ */ new Set();
+  for (const [index, item] of items.entries()) {
+    if (!isRecord(item)) {
+      continue;
+    }
+    const ordinal = index + 1;
+    if (isMissingId(item.id)) {
+      issues.push(
+        issue("ig_item_id_required", ["items", index, "id"], `Question ${ordinal} has no id.`)
+      );
+    } else if (typeof item.id === "string") {
+      if (seen.has(item.id)) {
+        repeated.add(item.id);
+      }
+      seen.add(item.id);
+    }
+    if (item.type === "item-group") {
+      issues.push(
+        issue(
+          "ig_item_nested_group",
+          ["items", index, "type"],
+          "Groups do not nest: every item must be an activity."
+        )
+      );
+      continue;
+    }
+    if (isUnwritten(item.type)) {
+      issues.push(
+        issue(
+          "ig_item_type_required",
+          ["items", index, "type"],
+          `Choose what kind of question ${ordinal} is.`
+        )
+      );
+      continue;
+    }
+    if (typeof item.type !== "string") {
+      continue;
+    }
+    let result;
+    try {
+      result = validateDraft(item.type, item);
+    } catch {
+      issues.push(
+        issue(
+          "ig_item_type_unknown",
+          ["items", index, "type"],
+          `"${item.type}" is not a registered activity type.`
+        )
+      );
+      continue;
+    }
+    for (const found of result.issues) {
+      issues.push({ ...found, path: ["items", String(index), ...found.path] });
+    }
+  }
+  for (const id of repeated) {
+    issues.push(
+      issue("ig_item_id_duplicate", ["items"], `More than one question has the id "${id}".`)
+    );
+  }
+  return issues;
+}
+
 // src/authoring/index.ts
 function validateDraft(type, draft) {
+  return withValidationScope(() => validateDraftInScope(type, draft));
+}
+function validateDraftInScope(type, draft) {
   const descriptor = getActivityTypeDescriptor(type);
   if (descriptor === void 0) {
     throw new UnknownActivityTypeError(String(type));
@@ -596,10 +893,11 @@ function validateDraft(type, draft) {
   const issues = [...reported];
   const parsed = descriptor.schema.safeParse(draft, { reportInput: true });
   if (!parsed.success) {
+    const covered = coveredPathsOf(reported);
     const reportedEmpty = /* @__PURE__ */ new Set();
     for (const schemaIssue of parsed.error.issues) {
       const path = schemaIssue.path.map(String);
-      if (reported.some((known) => covers(known.path, path))) {
+      if (covered.has(pathKey(path))) {
         continue;
       }
       if (path.length > 0 && refusesEmpty(draft, schemaIssue)) {
@@ -665,12 +963,6 @@ function normalise(found) {
     severity: documented ?? (found.severity === "incomplete" ? "incomplete" : "invalid")
   };
 }
-function covers(reported, failed) {
-  if (failed.length === 0) {
-    return reported.length === 0;
-  }
-  return failed.every((segment, index) => reported[index] === segment);
-}
 
 // src/redact.ts
 function mergePolicy(base, overrides) {
@@ -891,7 +1183,16 @@ export {
   ActivitySchemaError,
   BlankConfigSchema,
   DEFAULT_PASS_THRESHOLD,
+  DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
+  DICTATION_MAX_EQUIVALENCES,
+  DICTATION_MAX_EQUIVALENCE_LENGTH,
+  DICTATION_MAX_TEXT_LENGTH,
+  DICTATION_MAX_TRANSCRIPT_LENGTH,
   DeferredScoringError,
+  DictationDataSchema,
+  DictationEquivalenceSchema,
+  DictationSlowMediaSchema,
+  DictationToleranceSchema,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
   GapSelectBankSchema,
@@ -907,6 +1208,8 @@ export {
   MultipleChoiceOptionSchema,
   NativeControlHintSchema,
   RedactedBlankConfigSchema,
+  RedactedDictationDataSchema,
+  RedactedDictationSlowMediaSchema,
   RedactedFillInTheBlanksDataSchema,
   RedactedGapSelectBankSchema,
   RedactedGapSelectChoiceSchema,
@@ -928,6 +1231,7 @@ export {
   WrittenResponseRubricSchema,
   XAPIVerb,
   XAPI_VERB_DISPLAY,
+  alignDictation,
   assertRedacted,
   assertRedactedItemGroup,
   canonicalJson,
@@ -937,7 +1241,12 @@ export {
   contentHash,
   countWords,
   createDraft,
+  createItemGroupDraft,
   defineActivityType,
+  dictationJsonSchema,
+  dictationReferenceWords,
+  dictationType,
+  diffDictationChars,
   diffResponses,
   entryKeyOf,
   evaluate,
@@ -946,6 +1255,7 @@ export {
   fingerprint,
   flattenSequence,
   gapSelectJsonSchema,
+  gapSelectType,
   getActivityTypeDescriptor,
   gradeFromRubric,
   gte,
@@ -980,6 +1290,7 @@ export {
   validateActivity,
   validateDraft,
   validateItemGroup,
+  validateItemGroupDraft,
   validateXAPIStatement,
   verifyAttemptPlan,
   writtenResponseJsonSchema,