@intellectif/lk-core 0.8.2 → 0.10.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 { m as ItemOutcome, A as ActivityData, L as LearnerResponse, V as ValidationError, C as CriterionScore, G as GradeRecord, N as NativeControlHint, c as ActivityMedia, r as ScoringResult, D as DeferredScoringPartial, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, M as MultipleChoiceData, o as MultipleChoiceLearnerResponse, W as WrittenResponseData, u as WrittenResponseLearnerResponse } from './activity-CPtJUBek.js';
-export { a as ActivityDataMap, b as ActivityFeedback, d as ActivityResult, e as ActivityType, B as BlankConfig, g as Grader, h as GraderKind, i as GraderUsage, j as GradingState, I as InlineCorrection, k as InteractionEvent, l as InteractionKind, n as LearnerResponseMap, p as MultipleChoiceOption, S as ScoringDetail, q as ScoringOutcome, T as TextMatchPolicy, s as TextMatchResult, t as ValidationResult, v as WrittenResponseRubric, w as WrittenResponseRubricCriterion, X as XAPIActor, x as XAPIConfig, y as XAPIContext, z as XAPIContextActivities, E as XAPIError, H as XAPIObject, J as XAPIResult, K as XAPIScore, O as XAPIStatement, P as XAPIVerbObject, Q as levenshteinDistance, R as matchText } from './activity-CPtJUBek.js';
-import { u as SequenceSlot, S as SequenceEntry, I as ItemGroup } from './index-BvrA8nIV.js';
-export { B as BlankConfigSchema, F as FeedbackSchema, a as FillInTheBlanksDataSchema, b as ItemGroupSchema, M as MediaPlaybackSchema, c as MediaSchema, d as MediaUrlSchema, e as MultipleChoiceDataSchema, f as MultipleChoiceOptionSchema, N as NativeControlHintSchema, R as RedactedActivity, g as RedactedBlankConfig, h as RedactedBlankConfigSchema, i as RedactedFillInTheBlanksData, j as RedactedFillInTheBlanksDataSchema, k as RedactedItemGroupSchema, l as RedactedMediaSchema, m as RedactedMultipleChoiceData, n as RedactedMultipleChoiceDataSchema, o as RedactedMultipleChoiceOption, p as RedactedMultipleChoiceOptionSchema, q as RedactedStimulus, r as RedactedStimulusSchema, s as RedactedWrittenResponseData, t as RedactedWrittenResponseDataSchema, v as SequenceSlotGroup, w as Stimulus, x as StimulusKind, y as StimulusSchema, T as TextMatchPolicySchema, W as WrittenResponseDataSchema, z as WrittenResponseRubricCriterionSchema, A as WrittenResponseRubricSchema, C as fillInTheBlanksJsonSchema, D as itemGroupJsonSchema, E as jsonSchemaFor, G as multipleChoiceJsonSchema, H as stimulusJsonSchema, J as validateActivity, K as validateItemGroup, L as writtenResponseJsonSchema } from './index-BvrA8nIV.js';
+import { m as ItemOutcome, A as ActivityData, L as LearnerResponse, V as ValidationError, e as ActivityType, a as ActivityDataMap, C as CriterionScore, G as GradeRecord, N as NativeControlHint, c as ActivityMedia, s as ScoringResult, D as DeferredScoringPartial, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, M as MultipleChoiceData, o as MultipleChoiceLearnerResponse, W as WrittenResponseData, v as WrittenResponseLearnerResponse } from './activity-B0zbvu18.js';
+export { b as ActivityFeedback, d as ActivityResult, B as BlankConfig, g as Grader, h as GraderKind, i as GraderUsage, j as GradingState, I as InlineCorrection, k as InteractionEvent, l as InteractionKind, n as LearnerResponseMap, p as MultipleChoiceOption, q as MultipleChoiceOptionMedia, S as ScoringDetail, r as ScoringOutcome, T as TextMatchPolicy, t as TextMatchResult, u as ValidationResult, w as WrittenResponseRubric, x as WrittenResponseRubricCriterion, X as XAPIActor, y as XAPIConfig, z as XAPIContext, E as XAPIContextActivities, H as XAPIError, J as XAPIObject, K as XAPIResult, O as XAPIScore, P as XAPIStatement, Q as XAPIVerbObject, R as levenshteinDistance, U as matchText } from './activity-B0zbvu18.js';
+import { O as SequenceSlot, S as SequenceEntry, I as ItemGroup } from './index-DSfETm4b.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-DSfETm4b.js';
 import { z } from 'zod/v4';
 export { AnsweredStatementParams, CompletedStatementParams, SubmittedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor } from './xapi.js';
 
@@ -327,6 +327,118 @@ declare function restoreAttemptState(plan: AttemptPlan, state: AttemptState): At
  */
 declare function diffResponses(before: Pick<AttemptState, 'responses'>, after: Pick<AttemptState, 'responses'>): ResponseDiffEntry[];
 
+/**
+ * Why a draft is not an activity yet.
+ *
+ * - `incomplete` — something the author has not written yet: an empty title, an
+ *   option with no text, no option marked correct. The fix is to add it.
+ * - `invalid` — something is wrong in a way that writing more cannot fix: two
+ *   correct options on a single-selection question, a maximum word count below
+ *   the minimum, a media address with a scheme the SDK refuses, a `null` in an
+ *   optional field that accepts none. The fix is to change it.
+ */
+type DraftSeverity = 'incomplete' | 'invalid';
+/**
+ * One problem with a draft. A {@link ValidationError} with a severity, so code
+ * that already lists `validateActivity` errors can list these unchanged.
+ */
+interface DraftIssue extends ValidationError {
+    severity: DraftSeverity;
+}
+/** A draft that is a valid activity and has nothing left to write. */
+interface DraftComplete<T> {
+    status: 'complete';
+    /** The validated activity, exactly as `validateActivity` returns it. */
+    data: T;
+    /** Always empty. Present so that every result can be read the same way. */
+    issues: DraftIssue[];
+}
+/**
+ * A draft that is not an activity yet: `invalid` when any issue is invalid,
+ * otherwise `incomplete`. It carries no `data`, because nothing here may be
+ * stored or rendered as an activity.
+ */
+interface DraftNotComplete {
+    status: 'incomplete' | 'invalid';
+    issues: DraftIssue[];
+}
+/**
+ * The result of `validateDraft`.
+ *
+ * There is deliberately no `success` boolean. A boolean has to call an
+ * incomplete draft either a success, which lets a half-written answer key
+ * through anything that checks it, or a failure, which is the conflation this
+ * result exists to remove. Branch on `status`.
+ */
+type DraftValidationResult<T> = DraftComplete<T> | DraftNotComplete;
+/** What `createDraft` hands an activity type's `authoring.createDraft`. */
+interface DraftContext {
+    /**
+     * Returns a new id on every call. The SDK invents none: an id made here would
+     * need `crypto`, which plain-http origins do not have, or would be positional —
+     * and option ids reach the learner, so ids like `"a"` and `"b"` would tell them
+     * which option was written first.
+     */
+    newId: () => string;
+}
+
+/**
+ * Tells a draft that is not finished from a draft that is wrong.
+ *
+ * `validateActivity` answers "may this be stored?", and to that question an
+ * empty new question and a broken one are the same answer: no. An editor needs
+ * the difference — "Add a title" is a to-do, "Only one option can be marked
+ * correct" is an error — so a freshly added question does not read as a
+ * failure, disable a whole form, or blank a preview.
+ *
+ * - `complete` — the draft is a valid activity with nothing left to write.
+ *   `data` is exactly what `validateActivity` returns for it.
+ * - `incomplete` — every problem is something not yet written.
+ * - `invalid` — at least one problem is wrong in a way writing more cannot fix.
+ *
+ * It is stricter than `validateActivity`, never looser: `complete` requires the
+ * activity's schema to pass, and a draft can fail here that the schema accepts
+ * (a title that is only whitespace). Content stored by an older build can
+ * therefore be valid and still not `complete`. `validateActivity` stays the
+ * check at your write boundary.
+ *
+ * Issues come from the type's `authoring.checkDraft`, plus every schema failure
+ * it did not already report at that path or inside it. (A failure at the root of
+ * the draft counts as reported only by an issue at the root, since every path is
+ * inside the root.) Such a failure is added as `invalid`: under the code
+ * `null_not_allowed` when the schema refused a `null` there, or an `undefined`
+ * entry in a list, and otherwise under the schema's own code and message. A type
+ * with no `checkDraft` therefore reports every schema failure as `invalid`.
+ *
+ * The codes documented in `docs/authoring.md` are a contract, and each is
+ * reported with its documented severity, whichever check reports it. A code
+ * passed through from the schema is not a contract: the code and its English
+ * message belong to the schema library, so give a code you do not recognise a
+ * generic message of your own.
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor —
+ *   including `'item-group'`, which is a container, not an activity type.
+ */
+declare function validateDraft<T extends ActivityType>(type: T, draft: unknown): DraftValidationResult<ActivityDataMap[T]>;
+/**
+ * A new, empty draft of an activity type, for an editor to start from.
+ *
+ * Every required field is present and nothing is authored, so the draft comes
+ * back from {@link validateDraft} as `incomplete`, and `validateActivity`
+ * rejects it until someone writes it. The SDK invents no ids: `newId` is called
+ * once per id the draft needs, and must return a different non-empty string each
+ * time.
+ *
+ * ```ts
+ * const draft = createDraft('multiple-choice', { newId: () => crypto.randomUUID() });
+ * ```
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ * @throws Error when the type declares no `authoring.createDraft`, or when
+ *   `newId` returns an empty or repeated id.
+ */
+declare function createDraft<T extends ActivityType>(type: T, context: DraftContext): ActivityDataMap[T];
+
 /**
  * Content fingerprinting — "is this the same content the learner was served?"
  *
@@ -706,12 +818,48 @@ type ActivityTypeScoring<TData, TResponse> = {
     readonly reason: 'requires_async_grading';
     readonly partial?: (data: TData, response: TResponse | undefined) => DeferredScoringPartial;
 };
+/**
+ * Authoring support for an activity type: the empty draft an editor starts
+ * from, and the rules that tell a draft that is unfinished from one that is
+ * wrong. Both are optional. Without `checkDraft`, `validateDraft` still works
+ * and reports every schema failure as `invalid`; without `createDraft`,
+ * `createDraft()` throws for the type.
+ */
+interface ActivityTypeAuthoring<TData> {
+    /**
+     * A new draft: every required field present, nothing authored yet. It must
+     * come back from `validateDraft` as `incomplete` — never `invalid`, and never
+     * `complete` — so a freshly added question is not reported as an error, and
+     * cannot pass validation before anyone has written it.
+     */
+    readonly createDraft?: (context: DraftContext) => TData;
+    /**
+     * Reports what is missing (`incomplete`) and what is wrong (`invalid`) in a
+     * draft. Receives any plain object and must not throw on one.
+     *
+     * Report each problem at the path the schema reports it. `validateDraft` adds
+     * every schema failure as `invalid` unless an issue returned here sits at that
+     * path or inside it — so an issue at the wrong path leaves the schema's
+     * message standing beside yours, and makes an unfinished draft read as wrong.
+     * An issue inside a path accounts for every failure at that path, a list's
+     * length included, so report a rule about a whole list at the list's own path.
+     * A failure at the root of the draft is accounted for only by an issue at the
+     * root. A `null` the schema refuses, where nothing here reports it, comes back
+     * as `null_not_allowed` — except inside a plain `z.union`, which reports a
+     * failure once, at the union's own path, under its own code.
+     *
+     * A code documented in `docs/authoring.md` is reported with its documented
+     * severity. For a code of your own, a severity other than `'incomplete'` is
+     * reported as `invalid`.
+     */
+    readonly checkDraft?: (draft: Readonly<Record<string, unknown>>) => DraftIssue[];
+}
 /**
  * A value-level description of an activity type: its contract (schema), its
  * grading, its redaction policy, and its interop facts. Registering a
- * descriptor makes `validateActivity`, `score`, `evaluate`, `redact`, and
- * `jsonSchemaFor` work for the type — an activity type is a value, not a
- * hardcoded union member (R1).
+ * descriptor makes `validateActivity`, `validateDraft`, `score`, `evaluate`,
+ * `redact`, and `jsonSchemaFor` work for the type — an activity type is a value,
+ * not a hardcoded union member (R1).
  */
 interface ActivityTypeDescriptor<TData extends {
     type: string;
@@ -736,6 +884,8 @@ interface ActivityTypeDescriptor<TData extends {
     readonly interop?: ActivityTypeInterop<TData>;
     /** The interaction-event kinds components for this type emit. */
     readonly interactions?: readonly string[];
+    /** Draft support for authoring tools. See {@link ActivityTypeAuthoring}. */
+    readonly authoring?: ActivityTypeAuthoring<TData>;
 }
 /**
  * Internal type-erased descriptor shape stored in the registry. Dispatch call
@@ -757,6 +907,7 @@ interface RegisteredActivityTypeDescriptor {
     readonly redactedSchema?: z.ZodType<unknown>;
     readonly interop?: ActivityTypeInterop<unknown>;
     readonly interactions?: readonly string[];
+    readonly authoring?: ActivityTypeAuthoring<unknown>;
 }
 /**
  * Identity helper that gives full type inference when authoring a descriptor:
@@ -997,4 +1148,4 @@ interface ThemeTokens {
     '--lk-transition-base': string;
 }
 
-export { ActivityData, ActivityMedia, ActivitySchemaError, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, type AttemptPlan, type AttemptPlanDrift, type AttemptPlanSlot, type AttemptProgress, type AttemptState, CriterionScore, DeferredScoringError, DeferredScoringPartial, 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, 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, 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, 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 };

package/dist/index.js

@@ -10,20 +10,21 @@ import {
   outcomeFromGrade,
   roundGrade,
   score
-} from "./chunk-LNA33IK7.js";
+} from "./chunk-ZTY4UIUD.js";
 import {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
   xAPIBuilder,
   xapiDefinitionFor
-} from "./chunk-NHGXOOZ2.js";
+} from "./chunk-IXXMYJI7.js";
 import {
   ItemGroupSchema,
   RedactedItemGroupSchema,
   RedactedStimulusSchema,
   StimulusSchema,
   fillInTheBlanksJsonSchema,
+  gapSelectJsonSchema,
   itemGroupJsonSchema,
   jsonSchemaFor,
   multipleChoiceJsonSchema,
@@ -31,24 +32,35 @@ import {
   validateActivity,
   validateItemGroup,
   writtenResponseJsonSchema
-} from "./chunk-2M76F32Y.js";
+} from "./chunk-XGCTAQSS.js";
 import {
   ActivitySchemaError,
   BlankConfigSchema,
+  DRAFT_ISSUE_SEVERITY,
   DeferredScoringError,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
+  GapSelectBankSchema,
+  GapSelectChoiceSchema,
+  GapSelectDataSchema,
+  GapSelectGapSchema,
   MEDIA_FIELD_POLICY,
   MediaPlaybackSchema,
   MediaSchema,
   MediaUrlSchema,
   MultipleChoiceDataSchema,
+  MultipleChoiceOptionMediaSchema,
   MultipleChoiceOptionSchema,
   NativeControlHintSchema,
   RedactedBlankConfigSchema,
   RedactedFillInTheBlanksDataSchema,
+  RedactedGapSelectBankSchema,
+  RedactedGapSelectChoiceSchema,
+  RedactedGapSelectDataSchema,
+  RedactedGapSelectGapSchema,
   RedactedMediaSchema,
   RedactedMultipleChoiceDataSchema,
+  RedactedMultipleChoiceOptionMediaSchema,
   RedactedMultipleChoiceOptionSchema,
   RedactedScoringError,
   RedactedWrittenResponseDataSchema,
@@ -61,13 +73,16 @@ import {
   defineActivityType,
   fillInTheBlanksType,
   getActivityTypeDescriptor,
+  isRecord,
+  issue,
   levenshteinDistance,
   matchText,
   multipleChoiceType,
+  refusesEmpty,
   registerActivityType,
   registeredActivityTypes,
   writtenResponseType
-} from "./chunk-HCOWSGEZ.js";
+} from "./chunk-FIS5KBCE.js";
 
 // src/content-hash.ts
 function canonicalJson(value, seen = /* @__PURE__ */ new Set()) {
@@ -571,6 +586,92 @@ function diffResponses(before, after) {
   return entries;
 }
 
+// src/authoring/index.ts
+function validateDraft(type, draft) {
+  const descriptor = getActivityTypeDescriptor(type);
+  if (descriptor === void 0) {
+    throw new UnknownActivityTypeError(String(type));
+  }
+  const reported = isRecord(draft) && descriptor.authoring?.checkDraft !== void 0 ? descriptor.authoring.checkDraft(draft).map(normalise) : [];
+  const issues = [...reported];
+  const parsed = descriptor.schema.safeParse(draft, { reportInput: true });
+  if (!parsed.success) {
+    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))) {
+        continue;
+      }
+      if (path.length > 0 && refusesEmpty(draft, schemaIssue)) {
+        const key = JSON.stringify(path);
+        if (!reportedEmpty.has(key)) {
+          reportedEmpty.add(key);
+          issues.push(
+            issue(
+              "null_not_allowed",
+              path,
+              typeof schemaIssue.path.at(-1) === "number" ? "This entry has no value. Remove it, or fill it in." : "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"
+      });
+    }
+  }
+  if (parsed.success && issues.length === 0) {
+    return { status: "complete", data: parsed.data, issues };
+  }
+  const invalid = issues.some((found) => found.severity !== "incomplete");
+  return { status: invalid ? "invalid" : "incomplete", issues };
+}
+function createDraft(type, context) {
+  const descriptor = getActivityTypeDescriptor(type);
+  if (descriptor === void 0) {
+    throw new UnknownActivityTypeError(String(type));
+  }
+  const create = descriptor.authoring?.createDraft;
+  if (create === void 0) {
+    throw new Error(
+      `Activity type "${String(type)}" declares no authoring.createDraft, so there is no empty draft to create. Build the draft yourself; validateDraft works for every registered type.`
+    );
+  }
+  const issued = /* @__PURE__ */ new Set();
+  const newId = () => {
+    const id = context.newId();
+    if (typeof id !== "string" || id === "") {
+      throw new Error("createDraft: newId() must return a non-empty string.");
+    }
+    if (issued.has(id)) {
+      throw new Error(
+        `createDraft: newId() returned "${id}" twice. Ids within one draft must differ \u2014 two options sharing an id cannot be scored apart.`
+      );
+    }
+    issued.add(id);
+    return id;
+  };
+  return create({ newId });
+}
+function normalise(found) {
+  const documented = Object.hasOwn(DRAFT_ISSUE_SEVERITY, found.code) ? DRAFT_ISSUE_SEVERITY[found.code] : void 0;
+  return {
+    ...found,
+    path: found.path.map(String),
+    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) {
   if (overrides === void 0) {
@@ -644,10 +745,10 @@ function redact(data, options = {}) {
     if (!parsed.success) {
       throw new ActivitySchemaError(
         descriptor.type,
-        parsed.error.issues.map((issue) => ({
-          path: issue.path.map(String),
-          message: issue.message,
-          code: issue.code
+        parsed.error.issues.map((issue2) => ({
+          path: issue2.path.map(String),
+          message: issue2.message,
+          code: issue2.code
         }))
       );
     }
@@ -688,10 +789,10 @@ function assertRedacted(data) {
   if (!parsed.success) {
     throw new ActivitySchemaError(
       descriptor.type,
-      parsed.error.issues.map((issue) => ({
-        path: issue.path.map(String),
-        message: issue.message,
-        code: issue.code
+      parsed.error.issues.map((issue2) => ({
+        path: issue2.path.map(String),
+        message: issue2.message,
+        code: issue2.code
       }))
     );
   }
@@ -732,10 +833,10 @@ function redactItemGroup(group, options = {}) {
     if (!parsed.success) {
       throw new ActivitySchemaError(
         "item-group",
-        parsed.error.issues.map((issue) => ({
-          path: issue.path.map(String),
-          message: issue.message,
-          code: issue.code
+        parsed.error.issues.map((issue2) => ({
+          path: issue2.path.map(String),
+          message: issue2.message,
+          code: issue2.code
         }))
       );
     }
@@ -762,10 +863,10 @@ function assertRedactedItemGroup(data) {
   if (!parsed.success) {
     throw new ActivitySchemaError(
       "item-group",
-      parsed.error.issues.map((issue) => ({
-        path: issue.path.map(String),
-        message: issue.message,
-        code: issue.code
+      parsed.error.issues.map((issue2) => ({
+        path: issue2.path.map(String),
+        message: issue2.message,
+        code: issue2.code
       }))
     );
   }
@@ -776,9 +877,9 @@ function assertRedactedItemGroup(data) {
       if (error instanceof ActivitySchemaError) {
         throw new ActivitySchemaError(
           "item-group",
-          error.errors.map((issue) => ({
-            ...issue,
-            path: ["items", String(index), ...issue.path]
+          error.errors.map((issue2) => ({
+            ...issue2,
+            path: ["items", String(index), ...issue2.path]
           }))
         );
       }
@@ -793,18 +894,28 @@ export {
   DeferredScoringError,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
+  GapSelectBankSchema,
+  GapSelectChoiceSchema,
+  GapSelectDataSchema,
+  GapSelectGapSchema,
   ItemGroupSchema,
   MediaPlaybackSchema,
   MediaSchema,
   MediaUrlSchema,
   MultipleChoiceDataSchema,
+  MultipleChoiceOptionMediaSchema,
   MultipleChoiceOptionSchema,
   NativeControlHintSchema,
   RedactedBlankConfigSchema,
   RedactedFillInTheBlanksDataSchema,
+  RedactedGapSelectBankSchema,
+  RedactedGapSelectChoiceSchema,
+  RedactedGapSelectDataSchema,
+  RedactedGapSelectGapSchema,
   RedactedItemGroupSchema,
   RedactedMediaSchema,
   RedactedMultipleChoiceDataSchema,
+  RedactedMultipleChoiceOptionMediaSchema,
   RedactedMultipleChoiceOptionSchema,
   RedactedScoringError,
   RedactedStimulusSchema,
@@ -825,6 +936,7 @@ export {
   computePassThreshold,
   contentHash,
   countWords,
+  createDraft,
   defineActivityType,
   diffResponses,
   entryKeyOf,
@@ -833,6 +945,7 @@ export {
   fillInTheBlanksType,
   fingerprint,
   flattenSequence,
+  gapSelectJsonSchema,
   getActivityTypeDescriptor,
   gradeFromRubric,
   gte,
@@ -865,6 +978,7 @@ export {
   stimulusJsonSchema,
   stimulusMediaKey,
   validateActivity,
+  validateDraft,
   validateItemGroup,
   validateXAPIStatement,
   verifyAttemptPlan,