@lessonkit/react 1.0.1 → 1.1.0

package/dist/index.cjs

@@ -30,16 +30,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.tsx
 var index_exports = {};
 __export(index_exports, {
+  AssessmentSequence: () => AssessmentSequence,
   BLOCK_CATALOG: () => BLOCK_CATALOG,
+  BLOCK_CATALOG_V2: () => BLOCK_CATALOG_V2,
   Course: () => Course,
+  DragAndDrop: () => DragAndDrop,
+  DragTheWords: () => DragTheWords,
+  FillInTheBlanks: () => FillInTheBlanks,
   KnowledgeCheck: () => KnowledgeCheck,
   Lesson: () => Lesson,
   LessonkitProvider: () => LessonkitProvider,
+  MarkTheWords: () => MarkTheWords,
   ProgressTracker: () => ProgressTracker,
   Quiz: () => Quiz,
   Reflection: () => Reflection,
   Scenario: () => Scenario,
   ThemeProvider: () => ThemeProvider,
+  TrueFalse: () => TrueFalse,
+  blockCatalogV2Version: () => blockCatalogV2Version,
   blockCatalogVersion: () => blockCatalogVersion,
   buildBlockCatalog: () => buildBlockCatalog,
   buildTelemetryEvent: () => import_core10.buildTelemetryEvent,
@@ -50,7 +58,9 @@ __export(index_exports, {
   defineLifecyclePlugin: () => import_core10.defineLifecyclePlugin,
   defineTelemetryPlugin: () => import_core10.defineTelemetryPlugin,
   getBlockCatalogEntry: () => getBlockCatalogEntry,
+  resetAssessmentWarningsForTests: () => resetAssessmentWarningsForTests,
   resetQuizWarningsForTests: () => resetQuizWarningsForTests,
+  useAssessmentState: () => useAssessmentState,
   useCompletion: () => useCompletion,
   useLessonkit: () => useLessonkit,
   useProgress: () => useProgress,
@@ -61,9 +71,32 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/components.tsx
-var import_react5 = require("react");
+var import_react6 = require("react");
 var import_accessibility = require("@lessonkit/accessibility");
 
+// src/assessment/scoring.ts
+function resolvePassingThreshold(passingScore, maxScore) {
+  return passingScore ?? maxScore;
+}
+function meetsPassingThreshold(score, maxScore, passingScore) {
+  const threshold = resolvePassingThreshold(passingScore, maxScore);
+  return score >= threshold;
+}
+function scoreFromCustom(custom, fallbackCorrect, fallbackMax = 1, passingScore) {
+  const maxScore = custom?.maxScore ?? fallbackMax;
+  if (custom?.passed !== void 0) {
+    const score2 = custom.passed ? custom.score ?? maxScore : custom.score ?? 0;
+    return { score: score2, maxScore, passed: custom.passed };
+  }
+  if (custom?.maxScore != null && custom.maxScore > 0 && custom.score != null) {
+    const passed2 = meetsPassingThreshold(custom.score, custom.maxScore, passingScore);
+    return { score: custom.score, maxScore: custom.maxScore, passed: passed2 };
+  }
+  const score = fallbackCorrect ? maxScore : 0;
+  const passed = meetsPassingThreshold(score, maxScore, passingScore);
+  return { score, maxScore, passed };
+}
+
 // src/context.tsx
 var import_react2 = require("react");
 
@@ -171,7 +204,40 @@ var import_core5 = require("@lessonkit/core");
 
 // src/runtime/courseStartedPipeline.ts
 var import_xapi3 = require("@lessonkit/xapi");
-function emitCourseStartedNonTrackingPipeline(opts) {
+function isDevEnvironment3() {
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
+}
+function warnExtraSinkFailure(sinkId, err) {
+  if (isDevEnvironment3()) {
+    console.warn(
+      `[lessonkit] course_started extra sink "${sinkId}" failed:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+async function emitExtraSinks(sinks, event, emitCtx) {
+  await Promise.all(
+    sinks.map(async (sink) => {
+      let result;
+      try {
+        result = sink.emit(event, emitCtx);
+      } catch (err) {
+        warnExtraSinkFailure(sink.id, err);
+        throw err;
+      }
+      if (result != null && typeof result.then === "function") {
+        try {
+          await result;
+        } catch (err) {
+          warnExtraSinkFailure(sink.id, err);
+          throw err;
+        }
+      }
+    })
+  );
+}
+async function emitCourseStartedNonTrackingPipeline(opts) {
   let xapiStatementSent = false;
   if (!opts.skipXapi && opts.xapi) {
     const statement = (0, import_xapi3.telemetryEventToXAPIStatement)(opts.event);
@@ -186,9 +252,7 @@ function emitCourseStartedNonTrackingPipeline(opts) {
     sessionId: opts.event.sessionId,
     attemptId: opts.event.attemptId
   };
-  for (const sink of opts.extraSinks ?? []) {
-    sink.emit(opts.event, emitCtx);
-  }
+  await emitExtraSinks(opts.extraSinks ?? [], opts.event, emitCtx);
   return { xapiStatementSent };
 }
 
@@ -238,8 +302,12 @@ async function disposeTrackingClient(client) {
 }
 
 // src/provider/useLessonkitProviderRuntime.ts
-var useIsoLayoutEffect = typeof window !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect;
+var useIsoLayoutEffect = (
+  /* v8 ignore next -- SSR uses useEffect when window is unavailable */
+  typeof window !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect
+);
 var defaultStorage = (0, import_core3.createSessionStoragePort)();
+var courseStartedTrackingFlightKey = null;
 function isTrackingActive(tracking) {
   return tracking?.enabled !== false;
 }
@@ -262,15 +330,41 @@ function buildCourseStartedEvent(opts) {
   });
   return opts.pluginHost ? opts.pluginHost.runTelemetry(built, pluginCtx) : built;
 }
-function emitCourseStartedPipelineOnly(opts) {
+async function emitCourseStartedToTracking(tracking, storage, sessionId, courseId, event, shouldCommit) {
+  const flightKey = `${sessionId}:${courseId}`;
+  if ((0, import_core5.hasCourseStartedEmittedToTracking)(storage, sessionId, courseId)) {
+    return true;
+  }
+  if (courseStartedTrackingFlightKey === flightKey) {
+    return false;
+  }
+  courseStartedTrackingFlightKey = flightKey;
+  try {
+    if (shouldCommit && !shouldCommit()) return false;
+    tracking.track(event);
+    await tracking.flush?.();
+    if (shouldCommit && !shouldCommit()) return false;
+    (0, import_core5.markCourseStartedEmittedToTracking)(storage, sessionId, courseId);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (courseStartedTrackingFlightKey === flightKey) {
+      courseStartedTrackingFlightKey = null;
+    }
+  }
+}
+async function emitCourseStartedPipelineOnly(opts) {
   try {
-    const { xapiStatementSent } = emitCourseStartedNonTrackingPipeline({
+    if (opts.shouldCommit && !opts.shouldCommit()) return "failed";
+    const { xapiStatementSent } = await emitCourseStartedNonTrackingPipeline({
       event: opts.event,
       xapi: opts.xapi,
       lxpackBridge: opts.lxpackBridge,
       extraSinks: opts.extraSinks,
       skipXapi: opts.skipXapi
     });
+    if (opts.shouldCommit && !opts.shouldCommit()) return "failed";
     (0, import_core5.markCourseStarted)(opts.storage, opts.sessionId, opts.courseId);
     (0, import_core5.markCourseStartedPipelineDelivered)(opts.storage, opts.sessionId, opts.courseId);
     if (xapiStatementSent) {
@@ -281,47 +375,41 @@ function emitCourseStartedPipelineOnly(opts) {
     return "failed";
   }
 }
-function emitCourseStarted(opts) {
+async function emitCourseStarted(opts) {
   const event = buildCourseStartedEvent(opts);
   if (event === null) return "filtered";
-  const trackingAlreadyEmitted = (0, import_core5.hasCourseStartedEmittedToTracking)(
+  const tracked = await emitCourseStartedToTracking(
+    opts.tracking,
     opts.storage,
     opts.sessionId,
-    opts.courseId
+    opts.courseId,
+    event,
+    opts.shouldCommit
   );
-  if (!trackingAlreadyEmitted) {
-    try {
-      opts.tracking.track(event);
-      (0, import_core5.markCourseStartedEmittedToTracking)(opts.storage, opts.sessionId, opts.courseId);
-    } catch {
-      return "failed";
-    }
-  }
+  if (!tracked) return "failed";
   return emitCourseStartedPipelineOnly({
     ...opts,
     event,
     skipXapi: opts.skipXapi,
-    onXapiStatementSent: opts.onXapiStatementSent
+    onXapiStatementSent: opts.onXapiStatementSent,
+    shouldCommit: opts.shouldCommit
   });
 }
-function emitCourseStartedToTrackingOnly(opts) {
+async function emitCourseStartedToTrackingOnly(opts) {
   const event = buildCourseStartedEvent(opts);
   if (event === null) return "filtered";
-  const trackingAlreadyEmitted = (0, import_core5.hasCourseStartedEmittedToTracking)(
+  const tracked = await emitCourseStartedToTracking(
+    opts.tracking,
     opts.storage,
     opts.sessionId,
-    opts.courseId
+    opts.courseId,
+    event,
+    opts.shouldCommit
   );
-  if (!trackingAlreadyEmitted) {
-    try {
-      opts.tracking.track(event);
-      (0, import_core5.markCourseStartedEmittedToTracking)(opts.storage, opts.sessionId, opts.courseId);
-    } catch {
-      return "failed";
-    }
-  }
+  if (!tracked) return "failed";
   try {
-    emitCourseStartedNonTrackingPipeline({
+    if (opts.shouldCommit && !opts.shouldCommit()) return "failed";
+    await emitCourseStartedNonTrackingPipeline({
       event,
       xapi: null,
       lxpackBridge: opts.lxpackBridge,
@@ -334,7 +422,7 @@ function emitCourseStartedToTrackingOnly(opts) {
     return "failed";
   }
 }
-function emitPendingCourseStarted(opts) {
+async function emitPendingCourseStarted(opts) {
   const trackingEmitted = (0, import_core5.hasCourseStartedEmittedToTracking)(
     opts.storage,
     opts.sessionId,
@@ -357,6 +445,9 @@ function emitPendingCourseStarted(opts) {
     opts.sessionId,
     opts.courseId
   );
+  if (sessionStarted && trackingEmitted && pipelineDelivered) {
+    return "emitted";
+  }
   if (sessionStarted && trackingEmitted && !pipelineDelivered) {
     const event = buildCourseStartedEvent(opts);
     if (event === null) return "filtered";
@@ -408,6 +499,7 @@ function useLessonkitProviderRuntime(config) {
   pluginHostRef.current = pluginHost;
   const progressRef = (0, import_react.useRef)((0, import_core4.createProgressController)());
   const courseStartedEmittedToSinkRef = (0, import_react.useRef)(false);
+  const courseStartedEmitGenerationRef = (0, import_react.useRef)(0);
   const prevCourseIdForProgressRef = (0, import_react.useRef)(normalizedCourseId);
   const pendingCourseIdResetRef = (0, import_react.useRef)(false);
   const prevUseV2RuntimeRef = (0, import_react.useRef)(useV2Runtime);
@@ -427,6 +519,7 @@ function useLessonkitProviderRuntime(config) {
     }
     pendingCourseIdResetRef.current = true;
     courseStartedEmittedToSinkRef.current = false;
+    courseStartedEmitGenerationRef.current += 1;
   } else if (useV2Runtime && !headlessRef.current) {
     headlessRef.current = (0, import_core8.createLessonkitRuntime)({
       courseId: normalizedCourseId,
@@ -444,6 +537,7 @@ function useLessonkitProviderRuntime(config) {
     }
     pendingCourseIdResetRef.current = true;
     courseStartedEmittedToSinkRef.current = false;
+    courseStartedEmitGenerationRef.current += 1;
   }
   if (useV2Runtime && headlessRef.current) {
     progressRef.current = headlessRef.current.progress;
@@ -557,7 +651,10 @@ function useLessonkitProviderRuntime(config) {
     const baseSink = normalizedConfig.tracking?.sink;
     const userBatchSink = normalizedConfig.tracking?.batchSink;
     assertTrackingSinkConfig(normalizedConfig.tracking);
-    const sink = pluginHostRef.current && baseSink ? pluginHostRef.current.composeTrackingSink(baseSink, buildCurrentPluginCtx) ?? baseSink : baseSink;
+    const sink = pluginHostRef.current && baseSink ? (
+      /* v8 ignore next -- composeTrackingSink may return null; fall back to base sink */
+      pluginHostRef.current.composeTrackingSink(baseSink, buildCurrentPluginCtx) ?? baseSink
+    ) : baseSink;
     const batchSink = pluginHostRef.current && userBatchSink ? async (events) => {
       const host = pluginHostRef.current;
       const ctx = buildCurrentPluginCtx();
@@ -581,30 +678,39 @@ function useLessonkitProviderRuntime(config) {
     const sessionId = sessionIdRef.current;
     const cid = courseIdRef.current;
     const trackingActive = isTrackingActive(normalizedConfig.tracking);
+    const courseStartedFullySettled = (0, import_core5.hasCourseStartedEmittedToTracking)(defaultStorage, sessionId, cid) && (0, import_core5.hasCourseStarted)(defaultStorage, sessionId, cid) && (0, import_core5.hasCourseStartedPipelineDelivered)(defaultStorage, sessionId, cid);
     if (!trackingActive) {
       courseStartedEmittedToSinkRef.current = false;
-    } else if (!courseStartedEmittedToSinkRef.current) {
-      const result = emitPendingCourseStarted({
-        pluginHost: pluginHostRef.current,
-        tracking: next,
-        xapi: xapiRef.current,
-        storage: defaultStorage,
-        sessionId,
-        courseId: cid,
-        attemptId: attemptIdRef.current,
-        user: userRef.current,
-        lxpackBridge: lxpackBridgeModeRef.current,
-        extraSinks: extraSinksRef.current,
-        skipXapi: xapiCourseStartedSentOnClientRef.current,
-        onXapiStatementSent: () => {
-          xapiCourseStartedSentOnClientRef.current = true;
-        }
-      });
-      courseStartedEmittedToSinkRef.current = isCourseStartedSinkSettled(result);
-    } else if (trackingActive) {
+    } else if (courseStartedFullySettled) {
       courseStartedEmittedToSinkRef.current = true;
+    } else if (!courseStartedEmittedToSinkRef.current) {
+      const generation = ++courseStartedEmitGenerationRef.current;
+      const shouldCommit = () => generation === courseStartedEmitGenerationRef.current;
+      void (async () => {
+        if (generation !== courseStartedEmitGenerationRef.current) return;
+        const result = await emitPendingCourseStarted({
+          pluginHost: pluginHostRef.current,
+          tracking: next,
+          xapi: xapiRef.current,
+          storage: defaultStorage,
+          sessionId,
+          courseId: cid,
+          attemptId: attemptIdRef.current,
+          user: userRef.current,
+          lxpackBridge: lxpackBridgeModeRef.current,
+          extraSinks: extraSinksRef.current,
+          skipXapi: xapiCourseStartedSentOnClientRef.current,
+          onXapiStatementSent: () => {
+            xapiCourseStartedSentOnClientRef.current = true;
+          },
+          shouldCommit
+        });
+        if (generation !== courseStartedEmitGenerationRef.current) return;
+        courseStartedEmittedToSinkRef.current = isCourseStartedSinkSettled(result);
+      })();
     }
     return () => {
+      courseStartedEmitGenerationRef.current += 1;
       if (prev !== trackingRef.current) {
         void disposeTrackingClient(prev);
       }
@@ -681,7 +787,7 @@ function useLessonkitProviderRuntime(config) {
       } catch {
       }
       if (!courseStartedEmittedToSinkRef.current) {
-        const result = emitPendingCourseStarted({
+        const result = await emitPendingCourseStarted({
           pluginHost: pluginHostRef.current,
           tracking: trackingRef.current,
           xapi: xapiRef.current,
@@ -707,7 +813,10 @@ function useLessonkitProviderRuntime(config) {
     [track]
   );
   const completeLesson = (0, import_react.useCallback)(
-    (lessonId) => {
+    (lessonId, opts) => {
+      if (opts?.courseId !== void 0 && opts.courseId !== courseIdRef.current) {
+        return;
+      }
       if (useV2Runtime && headlessRef.current) {
         headlessRef.current.completeLesson(lessonId, emitLifecycleEvent);
         syncProgress();
@@ -882,9 +991,29 @@ function LessonkitProvider(props) {
 }
 
 // src/hooks.ts
+var import_react4 = require("react");
+
+// src/assessment/useAssessmentState.ts
 var import_react3 = require("react");
+function useAssessmentState(enclosingLessonId) {
+  const { track } = useLessonkit();
+  const trackOpts = enclosingLessonId ? { lessonId: enclosingLessonId } : void 0;
+  return (0, import_react3.useMemo)(
+    () => ({
+      answer: (data) => {
+        track("assessment_answered", data, trackOpts);
+      },
+      complete: (data) => {
+        track("assessment_completed", data, trackOpts);
+      }
+    }),
+    [track, enclosingLessonId]
+  );
+}
+
+// src/hooks.ts
 function useLessonkit() {
-  const ctx = (0, import_react3.useContext)(LessonkitContext);
+  const ctx = (0, import_react4.useContext)(LessonkitContext);
   if (!ctx) throw new Error("LessonKit: missing LessonkitProvider");
   return ctx;
 }
@@ -894,16 +1023,16 @@ function useProgress() {
 }
 function useTracking() {
   const { track } = useLessonkit();
-  return (0, import_react3.useMemo)(() => ({ track }), [track]);
+  return (0, import_react4.useMemo)(() => ({ track }), [track]);
 }
 function useCompletion() {
   const { completeLesson, completeCourse } = useLessonkit();
-  return (0, import_react3.useMemo)(() => ({ completeLesson, completeCourse }), [completeLesson, completeCourse]);
+  return (0, import_react4.useMemo)(() => ({ completeLesson, completeCourse }), [completeLesson, completeCourse]);
 }
 function useQuizState(enclosingLessonId) {
   const { track } = useLessonkit();
   const trackOpts = enclosingLessonId ? { lessonId: enclosingLessonId } : void 0;
-  return (0, import_react3.useMemo)(
+  return (0, import_react4.useMemo)(
     () => ({
       answer: (opts) => {
         track("quiz_answered", opts, trackOpts);
@@ -917,15 +1046,15 @@ function useQuizState(enclosingLessonId) {
 }
 
 // src/lessonContext.tsx
-var import_react4 = require("react");
-var LessonContext = (0, import_react4.createContext)(void 0);
+var import_react5 = require("react");
+var LessonContext = (0, import_react5.createContext)(void 0);
 function useEnclosingLessonId() {
-  return (0, import_react4.useContext)(LessonContext);
+  return (0, import_react5.useContext)(LessonContext);
 }
 
 // src/runtime/validateComponentId.ts
 var import_core9 = require("@lessonkit/core");
-function isDevEnvironment3() {
+function isDevEnvironment4() {
   const g = globalThis;
   return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
 }
@@ -941,7 +1070,7 @@ function normalizeComponentId(id, path) {
 var mountCounts = /* @__PURE__ */ new Map();
 var warnedConcurrentLessons = false;
 function registerLessonMount(lessonId) {
-  if (isDevEnvironment3() && mountCounts.size > 0 && !mountCounts.has(lessonId) && !warnedConcurrentLessons) {
+  if (isDevEnvironment4() && mountCounts.size > 0 && !mountCounts.has(lessonId) && !warnedConcurrentLessons) {
     warnedConcurrentLessons = true;
     console.warn(
       "[lessonkit] Multiple <Lesson> components are mounted; only one should be active at a time. Set autoCompleteOnUnmount={false} on routed lessons or unmount the previous lesson before showing the next."
@@ -968,8 +1097,8 @@ function resetQuizWarningsForTests() {
   warnedQuizOutsideLesson = false;
 }
 function Course(props) {
-  const courseId = (0, import_react5.useMemo)(() => normalizeComponentId(props.courseId, "courseId"), [props.courseId]);
-  const providerConfig = (0, import_react5.useMemo)(
+  const courseId = (0, import_react6.useMemo)(() => normalizeComponentId(props.courseId, "courseId"), [props.courseId]);
+  const providerConfig = (0, import_react6.useMemo)(
     () => ({ ...props.config, courseId }),
     [props.config, courseId]
   );
@@ -979,14 +1108,23 @@ function Course(props) {
   ] }) });
 }
 function Lesson(props) {
-  const lessonId = (0, import_react5.useMemo)(() => normalizeComponentId(props.lessonId, "lessonId"), [props.lessonId]);
+  const lessonId = (0, import_react6.useMemo)(() => normalizeComponentId(props.lessonId, "lessonId"), [props.lessonId]);
   const autoComplete = props.autoCompleteOnUnmount !== false;
   const { setActiveLesson, config } = useLessonkit();
   const { completeLesson } = useCompletion();
-  const lessonMountGenerationRef = (0, import_react5.useRef)(0);
-  (0, import_react5.useEffect)(() => {
+  const lessonMountGenerationRef = (0, import_react6.useRef)(0);
+  const liveCourseIdRef = (0, import_react6.useRef)(config.courseId);
+  liveCourseIdRef.current = config.courseId;
+  (0, import_react6.useEffect)(() => {
     const unregister = registerLessonMount(lessonId);
     const generation = ++lessonMountGenerationRef.current;
+    const mountedCourseId = config.courseId;
+    let effectSurvivedTick = false;
+    queueMicrotask(() => {
+      queueMicrotask(() => {
+        effectSurvivedTick = true;
+      });
+    });
     setActiveLesson(lessonId);
     return () => {
       unregister();
@@ -995,8 +1133,10 @@ function Lesson(props) {
       }
       if (!autoComplete) return;
       queueMicrotask(() => {
+        if (!effectSurvivedTick) return;
         if (lessonMountGenerationRef.current !== generation) return;
-        completeLesson(lessonId);
+        if (liveCourseIdRef.current !== mountedCourseId) return;
+        completeLesson(lessonId, { courseId: mountedCourseId });
       });
     };
   }, [lessonId, config.courseId, setActiveLesson, completeLesson, autoComplete]);
@@ -1006,20 +1146,20 @@ function Lesson(props) {
   ] }) });
 }
 function Scenario(props) {
-  const blockId = (0, import_react5.useMemo)(
+  const blockId = (0, import_react6.useMemo)(
     () => props.blockId !== void 0 ? normalizeComponentId(props.blockId, "blockId") : void 0,
     [props.blockId]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("section", { "aria-label": "Scenario", "data-lk-block-id": blockId, children: props.children });
 }
 function Reflection(props) {
-  const blockId = (0, import_react5.useMemo)(
+  const blockId = (0, import_react6.useMemo)(
     () => props.blockId !== void 0 ? normalizeComponentId(props.blockId, "blockId") : void 0,
     [props.blockId]
   );
-  const promptId = (0, import_react5.useId)();
-  const hintId = (0, import_react5.useId)();
-  const [internalValue, setInternalValue] = (0, import_react5.useState)("");
+  const promptId = (0, import_react6.useId)();
+  const hintId = (0, import_react6.useId)();
+  const [internalValue, setInternalValue] = (0, import_react6.useState)("");
   const isControlled = props.value !== void 0;
   const value = isControlled ? props.value : internalValue;
   const handleChange = (event) => {
@@ -1055,11 +1195,10 @@ function KnowledgeCheck(props) {
   );
 }
 function Quiz(props) {
-  const checkId = (0, import_react5.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
   const enclosingLessonId = useEnclosingLessonId();
   const missingLesson = enclosingLessonId === void 0;
-  (0, import_react5.useEffect)(() => {
-    if (!missingLesson || isDevEnvironment3()) return;
+  (0, import_react6.useEffect)(() => {
+    if (!missingLesson || isDevEnvironment4()) return;
     if (!warnedQuizOutsideLesson) {
       warnedQuizOutsideLesson = true;
       console.error(
@@ -1067,18 +1206,26 @@ function Quiz(props) {
       );
     }
   }, [missingLesson]);
-  if (missingLesson && isDevEnvironment3()) {
+  if (missingLesson && isDevEnvironment4()) {
     throw new Error("[lessonkit] <Quiz> must be wrapped in <Lesson>");
   }
+  if (missingLesson) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("section", { role: "alert", "aria-label": "Quiz configuration error", "data-lk-check-id": props.checkId, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { children: "Quiz must be placed inside a Lesson." }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(QuizInner, { ...props, enclosingLessonId });
+}
+function QuizInner(props) {
+  const { enclosingLessonId } = props;
+  const checkId = (0, import_react6.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
   const quiz = useQuizState(enclosingLessonId);
   const { plugins, config, session } = useLessonkit();
-  const [selected, setSelected] = (0, import_react5.useState)(null);
-  const [selectionCorrect, setSelectionCorrect] = (0, import_react5.useState)(null);
-  const [quizPassed, setQuizPassed] = (0, import_react5.useState)(false);
-  const completedRef = (0, import_react5.useRef)(false);
-  const questionId = (0, import_react5.useId)();
+  const [selected, setSelected] = (0, import_react6.useState)(null);
+  const [selectionCorrect, setSelectionCorrect] = (0, import_react6.useState)(null);
+  const [quizPassed, setQuizPassed] = (0, import_react6.useState)(false);
+  const completedRef = (0, import_react6.useRef)(false);
+  const questionId = (0, import_react6.useId)();
   const choicesKey = props.choices.join("\0");
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     completedRef.current = false;
     setQuizPassed(false);
     setSelected(null);
@@ -1087,14 +1234,11 @@ function Quiz(props) {
   const isChoiceCorrect = (choice, custom) => {
     if (!custom) return choice === props.answer;
     if (custom.passed !== void 0) return custom.passed;
-    if (custom.maxScore != null && custom.maxScore > 0) {
-      return custom.score / custom.maxScore >= 1;
+    if (custom.maxScore != null && custom.maxScore > 0 && custom.score != null) {
+      return meetsPassingThreshold(custom.score, custom.maxScore, props.passingScore);
     }
     return choice === props.answer;
   };
-  if (missingLesson) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("section", { role: "alert", "aria-label": "Quiz configuration error", "data-lk-check-id": checkId, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { children: "Quiz must be placed inside a Lesson." }) });
-  }
   const passed = quizPassed;
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("section", { "aria-label": "Quiz", "data-lk-check-id": checkId, children: [
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { id: questionId, children: props.question }),
@@ -1141,7 +1285,7 @@ function Quiz(props) {
                 const maxScore = custom?.maxScore ?? 1;
                 quiz.complete({
                   checkId,
-                  score: custom?.score ?? 1,
+                  score: custom?.score ?? maxScore,
                   maxScore,
                   passingScore: props.passingScore ?? maxScore
                 });
@@ -1184,11 +1328,864 @@ function ProgressTracker(props) {
   ] }) });
 }
 
+// src/blocks/TrueFalse.tsx
+var import_react9 = __toESM(require("react"), 1);
+
+// src/assessment/AssessmentLessonGuard.tsx
+var import_react7 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var warnedAssessmentOutsideLesson = false;
+function resetAssessmentWarningsForTests() {
+  warnedAssessmentOutsideLesson = false;
+}
+function AssessmentLessonGuard(props) {
+  const enclosingLessonId = useEnclosingLessonId();
+  const missingLesson = enclosingLessonId === void 0;
+  (0, import_react7.useEffect)(() => {
+    if (!missingLesson || isDevEnvironment4()) return;
+    if (!warnedAssessmentOutsideLesson) {
+      warnedAssessmentOutsideLesson = true;
+      console.error(
+        `[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>; assessment telemetry will not be emitted.`
+      );
+    }
+  }, [missingLesson, props.blockLabel]);
+  if (missingLesson && isDevEnvironment4()) {
+    throw new Error(`[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>`);
+  }
+  if (missingLesson) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("section", { role: "alert", "aria-label": `${props.blockLabel} configuration error`, "data-lk-check-id": props.checkId, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("p", { children: [
+      props.blockLabel,
+      " must be placed inside a Lesson."
+    ] }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: props.children(enclosingLessonId) });
+}
+
+// src/assessment/AssessmentSequenceContext.tsx
+var import_react8 = __toESM(require("react"), 1);
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var AssessmentSequenceContext = (0, import_react8.createContext)(null);
+function AssessmentSequenceProvider({ children }) {
+  const registryRef = (0, import_react8.useRef)(/* @__PURE__ */ new Map());
+  const register = (0, import_react8.useCallback)((checkId, handle) => {
+    registryRef.current.set(checkId, handle);
+    return () => {
+      registryRef.current.delete(checkId);
+    };
+  }, []);
+  const value = (0, import_react8.useMemo)(
+    () => ({
+      register,
+      getHandles: () => registryRef.current
+    }),
+    [register]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(AssessmentSequenceContext.Provider, { value, children });
+}
+function useAssessmentSequenceRegistry() {
+  return (0, import_react8.useContext)(AssessmentSequenceContext);
+}
+function useRegisterAssessmentHandle(checkId, handle) {
+  const ctx = useAssessmentSequenceRegistry();
+  import_react8.default.useEffect(() => {
+    if (!ctx || !handle) return;
+    return ctx.register(checkId, handle);
+  }, [ctx, checkId, handle]);
+}
+
+// src/blocks/TrueFalse.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var INTERACTION = "trueFalse";
+function TrueFalseInner(props, ref) {
+  const { enclosingLessonId } = props;
+  const checkId = (0, import_react9.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(enclosingLessonId);
+  const { plugins, config, session } = useLessonkit();
+  const [selected, setSelected] = (0, import_react9.useState)(null);
+  const [selectionCorrect, setSelectionCorrect] = (0, import_react9.useState)(null);
+  const [showSolutions, setShowSolutions] = (0, import_react9.useState)(false);
+  const [passed, setPassed] = (0, import_react9.useState)(false);
+  const completedRef = (0, import_react9.useRef)(false);
+  const questionId = import_react9.default.useId();
+  const reset = () => {
+    completedRef.current = false;
+    setPassed(false);
+    setSelected(null);
+    setSelectionCorrect(null);
+    setShowSolutions(false);
+  };
+  (0, import_react9.useEffect)(() => {
+    reset();
+  }, [checkId, props.answer, props.question, config.courseId, enclosingLessonId]);
+  const handle = (0, import_react9.useMemo)(() => {
+    const maxScore = 1;
+    const score = passed ? maxScore : selected === null ? 0 : selected === props.answer ? maxScore : 0;
+    return {
+      getScore: () => score,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => selected !== null,
+      resetTask: reset,
+      showSolutions: () => setShowSolutions(true),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION,
+        response: selected ?? void 0,
+        correct: selected === props.answer,
+        score,
+        maxScore
+      })
+    };
+  }, [checkId, passed, props.answer, selected]);
+  (0, import_react9.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+  const submit = (value) => {
+    if (passed && !props.enableRetry) return;
+    setSelected(value);
+    const pluginCtx = buildPluginContext({
+      courseId: config.courseId,
+      sessionId: session.sessionId,
+      attemptId: session.attemptId,
+      user: session.user
+    });
+    const custom = plugins?.scoreAssessment(
+      { checkId, lessonId: enclosingLessonId, response: value },
+      pluginCtx
+    ) ?? null;
+    const correct = value === props.answer;
+    const scored = scoreFromCustom(custom, correct, 1, props.passingScore);
+    setSelectionCorrect(scored.passed);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION,
+      question: props.question,
+      response: value,
+      correct: scored.passed
+    });
+    if (scored.passed && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION,
+        score: scored.score,
+        maxScore: scored.maxScore,
+        passingScore: props.passingScore ?? scored.maxScore
+      });
+    }
+  };
+  const reveal = showSolutions || passed && props.enableSolutionsButton;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("section", { "aria-label": "True or False", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("p", { id: questionId, children: props.question }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("fieldset", { "aria-labelledby": questionId, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("legend", { className: "lk-visually-hidden", children: "True or False" }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("label", { style: { display: "block", marginRight: "1rem" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "input",
+          {
+            type: "radio",
+            name: `${questionId}-tf`,
+            checked: selected === true,
+            disabled: passed && !props.enableRetry,
+            onChange: () => submit(true)
+          }
+        ),
+        "True"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("label", { style: { display: "block" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "input",
+          {
+            type: "radio",
+            name: `${questionId}-tf`,
+            checked: selected === false,
+            disabled: passed && !props.enableRetry,
+            onChange: () => submit(false)
+          }
+        ),
+        "False"
+      ] })
+    ] }),
+    reveal ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("p", { children: [
+      "Correct answer: ",
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("strong", { children: props.answer ? "True" : "False" })
+    ] }) : null,
+    selected !== null && selectionCorrect !== null ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("p", { role: "status", "aria-live": "polite", children: selectionCorrect ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("button", { type: "button", onClick: reset, children: "Try again" }) : null,
+    props.enableSolutionsButton && !reveal ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
+  ] });
+}
+var TrueFalseInnerForwarded = (0, import_react9.forwardRef)(TrueFalseInner);
+var TrueFalse = (0, import_react9.forwardRef)(function TrueFalse2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(AssessmentLessonGuard, { blockLabel: "TrueFalse", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TrueFalseInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/MarkTheWords.tsx
+var import_react10 = __toESM(require("react"), 1);
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var INTERACTION2 = "markTheWords";
+function tokenize(text) {
+  return text.split(/(\s+)/).filter((t) => t.length > 0);
+}
+function MarkTheWordsInner(props, ref) {
+  const checkId = (0, import_react10.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const tokens = (0, import_react10.useMemo)(() => tokenize(props.text), [props.text]);
+  const correctSet = (0, import_react10.useMemo)(
+    () => new Set(props.correctWords.map((w) => w.toLowerCase())),
+    [props.correctWords]
+  );
+  const [marked, setMarked] = (0, import_react10.useState)(() => /* @__PURE__ */ new Set());
+  const [passed, setPassed] = (0, import_react10.useState)(false);
+  const [showSolutions, setShowSolutions] = (0, import_react10.useState)(false);
+  const completedRef = (0, import_react10.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    setPassed(false);
+    setMarked(/* @__PURE__ */ new Set());
+    setShowSolutions(false);
+  };
+  (0, import_react10.useEffect)(() => {
+    reset();
+  }, [checkId, props.text, props.correctWords.join("\0")]);
+  const selectableIndices = (0, import_react10.useMemo)(() => {
+    const indices = [];
+    tokens.forEach((t, i) => {
+      if (!/^\s+$/.test(t) && correctSet.has(t.toLowerCase())) indices.push(i);
+    });
+    return indices;
+  }, [tokens, correctSet]);
+  const hasTargets = selectableIndices.length > 0;
+  const allMarked = hasTargets && selectableIndices.every((i) => marked.has(i));
+  const maxScore = selectableIndices.length;
+  const score = allMarked ? maxScore : marked.size;
+  const passedThreshold = meetsPassingThreshold(score, maxScore || 1, props.passingScore);
+  const handle = (0, import_react10.useMemo)(() => {
+    const handleMax = maxScore || 1;
+    return {
+      getScore: () => score,
+      getMaxScore: () => handleMax,
+      getAnswerGiven: () => marked.size > 0,
+      resetTask: reset,
+      showSolutions: () => setShowSolutions(true),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION2,
+        response: [...marked].map((i) => tokens[i]),
+        correct: passedThreshold,
+        score,
+        maxScore: handleMax
+      })
+    };
+  }, [checkId, marked, maxScore, passedThreshold, score, tokens]);
+  (0, import_react10.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+  const toggle = (index) => {
+    if (passed && !props.enableRetry) return;
+    setMarked((prev) => {
+      const next = new Set(prev);
+      if (next.has(index)) next.delete(index);
+      else next.add(index);
+      return next;
+    });
+  };
+  (0, import_react10.useEffect)(() => {
+    if (!hasTargets) {
+      if (isDevEnvironment4()) {
+        console.warn(
+          "[lessonkit] MarkTheWords: no tokens match correctWords",
+          props.correctWords
+        );
+      }
+      return;
+    }
+    if (!passedThreshold || completedRef.current) return;
+    completedRef.current = true;
+    setPassed(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION2,
+      question: props.text,
+      response: [...marked].map((i) => tokens[i]),
+      correct: true
+    });
+    assessment.complete({
+      checkId,
+      interactionType: INTERACTION2,
+      score,
+      maxScore,
+      passingScore: props.passingScore ?? maxScore
+    });
+  }, [
+    assessment,
+    checkId,
+    hasTargets,
+    marked,
+    maxScore,
+    passedThreshold,
+    props.passingScore,
+    props.correctWords,
+    props.text,
+    score,
+    tokens
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("section", { "aria-label": "Mark the Words", "data-lk-check-id": checkId, children: [
+    !hasTargets ? /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("p", { role: "alert", children: [
+      "No words in this sentence match ",
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("code", { children: "correctWords" }),
+      ". Check spelling and capitalization in the source text."
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { id: `${checkId}-hint`, children: "Select the correct words in the sentence." }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { "aria-describedby": `${checkId}-hint`, children: tokens.map((token, i) => {
+      const isWord = !/^\s+$/.test(token);
+      const isTarget = isWord && correctSet.has(token.toLowerCase());
+      if (!isTarget) return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react10.default.Fragment, { children: token }, i);
+      const selected = marked.has(i);
+      const solution = showSolutions || passed && props.enableSolutionsButton;
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": `mark-word-${i}`,
+          "aria-pressed": selected,
+          disabled: passed && !props.enableRetry,
+          onClick: () => toggle(i),
+          style: {
+            margin: "0 0.1em",
+            textDecoration: solution ? "underline" : void 0,
+            fontWeight: selected || solution ? "bold" : void 0
+          },
+          children: token
+        },
+        i
+      );
+    }) }),
+    allMarked ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { role: "status", "aria-live": "polite", children: "Correct" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("button", { type: "button", onClick: reset, children: "Try again" }) : null,
+    props.enableSolutionsButton && !showSolutions ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
+  ] });
+}
+var MarkTheWordsInnerForwarded = (0, import_react10.forwardRef)(MarkTheWordsInner);
+var MarkTheWords = (0, import_react10.forwardRef)(function MarkTheWords2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(AssessmentLessonGuard, { blockLabel: "MarkTheWords", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(MarkTheWordsInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/FillInTheBlanks.tsx
+var import_react11 = __toESM(require("react"), 1);
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var INTERACTION3 = "fillInBlanks";
+function parseTemplate(template) {
+  const parts = [];
+  const blanks = [];
+  const re = /\*([^*]+)\*/g;
+  let last = 0;
+  let match;
+  let n = 0;
+  while ((match = re.exec(template)) !== null) {
+    parts.push(template.slice(last, match.index));
+    const id = `blank-${n++}`;
+    blanks.push({ id, answer: match[1].trim() });
+    parts.push(id);
+    last = match.index + match[0].length;
+  }
+  parts.push(template.slice(last));
+  return { parts, blanks };
+}
+function FillInTheBlanksInner(props, ref) {
+  const checkId = (0, import_react11.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const parsed = (0, import_react11.useMemo)(() => parseTemplate(props.template), [props.template]);
+  const blanks = props.blanks ?? parsed.blanks;
+  const [values, setValues] = (0, import_react11.useState)(
+    () => Object.fromEntries(blanks.map((b) => [b.id, ""]))
+  );
+  const [passed, setPassed] = (0, import_react11.useState)(false);
+  const [showSolutions, setShowSolutions] = (0, import_react11.useState)(false);
+  const completedRef = (0, import_react11.useRef)(false);
+  const answeredRef = (0, import_react11.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    answeredRef.current = false;
+    setPassed(false);
+    setValues(Object.fromEntries(blanks.map((b) => [b.id, ""])));
+    setShowSolutions(false);
+  };
+  (0, import_react11.useEffect)(() => {
+    reset();
+  }, [checkId, props.template, blanks.map((b) => b.answer).join("\0")]);
+  const hasBlanks = blanks.length > 0;
+  const allFilled = hasBlanks && blanks.every((b) => (values[b.id] ?? "").trim().length > 0);
+  let score = 0;
+  blanks.forEach((b) => {
+    if ((values[b.id] ?? "").trim().toLowerCase() === b.answer.toLowerCase()) score += 1;
+  });
+  const maxScore = blanks.length;
+  const passedThreshold = meetsPassingThreshold(score, maxScore || 1, props.passingScore);
+  const handle = (0, import_react11.useMemo)(() => {
+    const handleMax = maxScore || 1;
+    return {
+      getScore: () => score,
+      getMaxScore: () => handleMax,
+      getAnswerGiven: () => allFilled,
+      resetTask: reset,
+      showSolutions: () => setShowSolutions(true),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION3,
+        response: values,
+        correct: passedThreshold,
+        score,
+        maxScore: handleMax
+      })
+    };
+  }, [allFilled, blanks.length, checkId, maxScore, passedThreshold, score, values]);
+  (0, import_react11.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+  const check = () => {
+    if (!hasBlanks) {
+      if (isDevEnvironment4()) {
+        console.warn("[lessonkit] FillInTheBlanks has no blanks in template");
+      }
+      return;
+    }
+    if (!allFilled) return;
+    if (!answeredRef.current) {
+      answeredRef.current = true;
+      assessment.answer({
+        checkId,
+        interactionType: INTERACTION3,
+        question: props.template,
+        response: values,
+        correct: passedThreshold
+      });
+    }
+    if (passedThreshold && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION3,
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    }
+  };
+  (0, import_react11.useEffect)(() => {
+    if (!allFilled) answeredRef.current = false;
+  }, [allFilled]);
+  (0, import_react11.useEffect)(() => {
+    if (props.autoCheck && allFilled) check();
+  }, [allFilled, props.autoCheck, values, passedThreshold]);
+  const reveal = showSolutions || passed && props.enableSolutionsButton;
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("section", { "aria-label": "Fill in the Blanks", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { children: parsed.parts.map((part, i) => {
+      const blank = blanks.find((b) => b.id === part);
+      if (!blank) return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react11.default.Fragment, { children: part }, i);
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("label", { style: { margin: "0 0.25em" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { className: "lk-visually-hidden", children: blank.answer }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "input",
+          {
+            type: "text",
+            "data-testid": `blank-${blank.id}`,
+            "aria-label": `Blank ${blank.id}`,
+            value: reveal ? blank.answer : values[blank.id] ?? "",
+            readOnly: reveal,
+            disabled: passed && !props.enableRetry,
+            onChange: (e) => setValues((v) => ({ ...v, [blank.id]: e.target.value })),
+            onBlur: () => props.autoCheck && check(),
+            size: Math.max(8, blank.answer.length + 2)
+          }
+        )
+      ] }, blank.id);
+    }) }),
+    !props.autoCheck ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", "data-testid": "check-blanks", disabled: !allFilled || passed, onClick: check, children: "Check" }) : null,
+    !hasBlanks ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { role: "alert", children: "This activity has no blanks. Add text wrapped in asterisks, e.g. The *answer* here." }) : null,
+    allFilled ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", onClick: reset, children: "Try again" }) : null,
+    props.enableSolutionsButton && !reveal ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
+  ] });
+}
+var FillInTheBlanksInnerForwarded = (0, import_react11.forwardRef)(FillInTheBlanksInner);
+var FillInTheBlanks = (0, import_react11.forwardRef)(
+  function FillInTheBlanks2(props, ref) {
+    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(AssessmentLessonGuard, { blockLabel: "FillInTheBlanks", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(FillInTheBlanksInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+  }
+);
+
+// src/blocks/DragTheWords.tsx
+var import_react12 = __toESM(require("react"), 1);
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var INTERACTION4 = "dragTheWords";
+function parseZones(template) {
+  const parts = [];
+  const answers = [];
+  const re = /\*([^*]+)\*/g;
+  let last = 0;
+  let match;
+  let n = 0;
+  while ((match = re.exec(template)) !== null) {
+    parts.push(template.slice(last, match.index));
+    answers.push(match[1].trim());
+    parts.push(`zone-${n++}`);
+    last = match.index + match[0].length;
+  }
+  parts.push(template.slice(last));
+  return { parts, answers };
+}
+function DragTheWordsInner(props, ref) {
+  const checkId = (0, import_react12.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const { parts, answers } = (0, import_react12.useMemo)(() => parseZones(props.template), [props.template]);
+  const [zones, setZones] = (0, import_react12.useState)(
+    () => Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""]))
+  );
+  const [pool, setPool] = (0, import_react12.useState)(() => [...props.words]);
+  const [keyboardWord, setKeyboardWord] = (0, import_react12.useState)(null);
+  const [passed, setPassed] = (0, import_react12.useState)(false);
+  const completedRef = (0, import_react12.useRef)(false);
+  const answeredRef = (0, import_react12.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    answeredRef.current = false;
+    setPassed(false);
+    setZones(Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""])));
+    setPool([...props.words]);
+    setKeyboardWord(null);
+  };
+  (0, import_react12.useEffect)(() => {
+    reset();
+  }, [checkId, props.template, props.words.join("\0")]);
+  const hasZones = answers.length > 0;
+  const allFilled = hasZones && answers.every((_, i) => (zones[`zone-${i}`] ?? "").length > 0);
+  let score = 0;
+  answers.forEach((ans, i) => {
+    if ((zones[`zone-${i}`] ?? "").trim().toLowerCase() === ans.toLowerCase()) score += 1;
+  });
+  const maxScore = answers.length;
+  const passedThreshold = meetsPassingThreshold(score, maxScore || 1, props.passingScore);
+  const handle = (0, import_react12.useMemo)(() => {
+    const handleMax = maxScore || 1;
+    return {
+      getScore: () => score,
+      getMaxScore: () => handleMax,
+      getAnswerGiven: () => allFilled,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION4,
+        response: zones,
+        correct: passedThreshold,
+        score,
+        maxScore: handleMax
+      })
+    };
+  }, [allFilled, answers.length, checkId, maxScore, passedThreshold, score, zones]);
+  (0, import_react12.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+  const placeInZone = (zoneId, word) => {
+    if (passed && !props.enableRetry) return;
+    const prev = zones[zoneId];
+    setZones((z) => ({ ...z, [zoneId]: word }));
+    setPool((p) => {
+      const next = p.filter((w) => w !== word);
+      if (prev) next.push(prev);
+      return next;
+    });
+    setKeyboardWord(null);
+  };
+  const onDragStart = (word) => (e) => {
+    e.dataTransfer.setData("text/plain", word);
+  };
+  const onDrop = (zoneId) => (e) => {
+    e.preventDefault();
+    const word = e.dataTransfer.getData("text/plain");
+    if (word) placeInZone(zoneId, word);
+  };
+  const check = () => {
+    if (!hasZones) {
+      if (isDevEnvironment4()) {
+        console.warn("[lessonkit] DragTheWords has no drop zones in template");
+      }
+      return;
+    }
+    if (!allFilled) return;
+    if (!answeredRef.current) {
+      answeredRef.current = true;
+      assessment.answer({
+        checkId,
+        interactionType: INTERACTION4,
+        question: props.template,
+        response: zones,
+        correct: passedThreshold
+      });
+    }
+    if (passedThreshold && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION4,
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    if (!allFilled) answeredRef.current = false;
+  }, [allFilled]);
+  (0, import_react12.useEffect)(() => {
+    if (props.autoCheck && allFilled) check();
+  }, [allFilled, props.autoCheck, zones, passedThreshold]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("section", { "aria-label": "Drag the Words", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { children: "Drag words into the blanks (or select a word, then activate a blank)." }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { role: "list", "aria-label": "Word bank", "data-testid": "word-bank", children: pool.map((word) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      "button",
+      {
+        type: "button",
+        draggable: true,
+        "data-testid": `word-${word}`,
+        "aria-pressed": keyboardWord === word,
+        onDragStart: onDragStart(word),
+        onClick: () => setKeyboardWord(keyboardWord === word ? null : word),
+        style: { margin: "0.25rem" },
+        children: word
+      },
+      word
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { children: parts.map((part, i) => {
+      if (!part.startsWith("zone-")) return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react12.default.Fragment, { children: part }, i);
+      return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+        "span",
+        {
+          role: "button",
+          tabIndex: 0,
+          "data-testid": part,
+          onDragOver: (e) => e.preventDefault(),
+          onDrop: onDrop(part),
+          onClick: () => keyboardWord && placeInZone(part, keyboardWord),
+          onKeyDown: (e) => {
+            if (e.key === "Enter" && keyboardWord) placeInZone(part, keyboardWord);
+          },
+          style: {
+            display: "inline-block",
+            minWidth: "6em",
+            border: "1px dashed currentColor",
+            padding: "0.2em 0.5em",
+            margin: "0 0.2em"
+          },
+          children: zones[part] || "___"
+        },
+        part
+      );
+    }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "button", "data-testid": "check-drag-words", disabled: !allFilled || passed, onClick: check, children: "Check" }),
+    !hasZones ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { role: "alert", children: "This activity has no drop zones. Wrap answers in asterisks in the template." }) : null,
+    allFilled ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null
+  ] });
+}
+var DragTheWordsInnerForwarded = (0, import_react12.forwardRef)(DragTheWordsInner);
+var DragTheWords = (0, import_react12.forwardRef)(function DragTheWords2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AssessmentLessonGuard, { blockLabel: "DragTheWords", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(DragTheWordsInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/DragAndDrop.tsx
+var import_react13 = require("react");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var INTERACTION5 = "dragAndDrop";
+function DragAndDropInner(props, ref) {
+  const checkId = (0, import_react13.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const [assignments, setAssignments] = (0, import_react13.useState)(
+    () => Object.fromEntries(props.targets.map((t) => [t.id, ""]))
+  );
+  const [pool, setPool] = (0, import_react13.useState)(() => props.items.map((i) => i.id));
+  const [keyboardItem, setKeyboardItem] = (0, import_react13.useState)(null);
+  const [passed, setPassed] = (0, import_react13.useState)(false);
+  const completedRef = (0, import_react13.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    setPassed(false);
+    setAssignments(Object.fromEntries(props.targets.map((t) => [t.id, ""])));
+    setPool(props.items.map((i) => i.id));
+    setKeyboardItem(null);
+  };
+  (0, import_react13.useEffect)(() => {
+    reset();
+  }, [checkId, props.items.map((i) => i.id).join(","), props.targets.map((t) => t.id).join(",")]);
+  const allFilled = props.targets.every((t) => (assignments[t.id] ?? "").length > 0);
+  const allCorrect = props.targets.every((t) => assignments[t.id] === t.accepts);
+  const handle = (0, import_react13.useMemo)(() => {
+    const maxScore = props.targets.length || 1;
+    let score = 0;
+    props.targets.forEach((t) => {
+      if (assignments[t.id] === t.accepts) score += 1;
+    });
+    return {
+      getScore: () => score,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => allFilled,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION5,
+        response: assignments,
+        correct: allCorrect,
+        score,
+        maxScore
+      })
+    };
+  }, [allCorrect, allFilled, assignments, checkId, props.targets]);
+  (0, import_react13.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+  const place = (targetId, itemId) => {
+    if (passed && !props.enableRetry) return;
+    const prev = assignments[targetId];
+    setAssignments((a) => ({ ...a, [targetId]: itemId }));
+    setPool((p) => {
+      const next = p.filter((id) => id !== itemId);
+      if (prev) next.push(prev);
+      return next;
+    });
+    setKeyboardItem(null);
+  };
+  const check = () => {
+    if (!allFilled) return;
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION5,
+      response: assignments,
+      correct: allCorrect
+    });
+    if (allCorrect && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION5,
+        score: props.targets.length,
+        maxScore: props.targets.length,
+        passingScore: props.passingScore ?? props.targets.length
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("section", { "aria-label": "Drag and Drop", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("p", { children: "Match each item to the correct target (drag or use keyboard: select item, then activate target)." }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { role: "list", "aria-label": "Draggable items", children: pool.map((id) => {
+      const item = props.items.find((i) => i.id === id);
+      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        "button",
+        {
+          type: "button",
+          draggable: true,
+          "data-testid": `drag-item-${id}`,
+          "aria-pressed": keyboardItem === id,
+          onDragStart: (e) => e.dataTransfer.setData("text/plain", id),
+          onClick: () => setKeyboardItem(keyboardItem === id ? null : id),
+          style: { margin: "0.25rem" },
+          children: item.label
+        },
+        id
+      );
+    }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("ul", { children: props.targets.map((target) => {
+      const assigned = assignments[target.id];
+      const label = assigned ? props.items.find((i) => i.id === assigned)?.label ?? assigned : "Drop here";
+      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("li", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("strong", { children: target.label }),
+        " ",
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+          "span",
+          {
+            role: "button",
+            tabIndex: 0,
+            "data-testid": `drop-${target.id}`,
+            onDragOver: (e) => e.preventDefault(),
+            onDrop: (e) => {
+              e.preventDefault();
+              const id = e.dataTransfer.getData("text/plain");
+              if (id) place(target.id, id);
+            },
+            onClick: () => keyboardItem && place(target.id, keyboardItem),
+            onKeyDown: (e) => {
+              if (e.key === "Enter" && keyboardItem) place(target.id, keyboardItem);
+            },
+            style: {
+              display: "inline-block",
+              minWidth: "8em",
+              border: "1px dashed currentColor",
+              padding: "0.25em"
+            },
+            children: label
+          }
+        )
+      ] }, target.id);
+    }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("button", { type: "button", "data-testid": "check-drag-drop", disabled: !allFilled || passed, onClick: check, children: "Check" }),
+    allFilled ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("p", { role: "status", "aria-live": "polite", children: passed || allCorrect ? "Correct" : "Try again" }) : null
+  ] });
+}
+var DragAndDropInnerForwarded = (0, import_react13.forwardRef)(DragAndDropInner);
+var DragAndDrop = (0, import_react13.forwardRef)(function DragAndDrop2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(AssessmentLessonGuard, { blockLabel: "DragAndDrop", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(DragAndDropInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/AssessmentSequence.tsx
+var import_react14 = __toESM(require("react"), 1);
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function AssessmentSequence(props) {
+  const sequential = props.sequential !== false;
+  const childArray = import_react14.default.Children.toArray(props.children).filter(import_react14.default.isValidElement);
+  const [index, setIndex] = (0, import_react14.useState)(0);
+  const current = childArray[index] ?? null;
+  const goNext = (0, import_react14.useCallback)(() => {
+    setIndex((i) => Math.min(i + 1, childArray.length - 1));
+  }, [childArray.length]);
+  const goPrev = (0, import_react14.useCallback)(() => {
+    setIndex((i) => Math.max(i - 1, 0));
+  }, []);
+  const progress = (0, import_react14.useMemo)(
+    () => ({ current: index + 1, total: childArray.length }),
+    [index, childArray.length]
+  );
+  if (!sequential) {
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(AssessmentSequenceProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("section", { "aria-label": "Assessment sequence", children: props.children }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(AssessmentSequenceProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("section", { "aria-label": "Assessment sequence", "data-testid": "assessment-sequence", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("p", { children: [
+      "Question ",
+      progress.current,
+      " of ",
+      progress.total
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { "data-testid": "assessment-sequence-step", children: current }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("nav", { "aria-label": "Sequence navigation", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("button", { type: "button", "data-testid": "sequence-prev", disabled: index === 0, onClick: goPrev, children: "Previous" }),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": "sequence-next",
+          disabled: index >= childArray.length - 1,
+          onClick: goNext,
+          children: "Next"
+        }
+      )
+    ] })
+  ] }) });
+}
+
 // src/index.tsx
 var import_core10 = require("@lessonkit/core");
 
 // src/theme/ThemeProvider.tsx
-var import_react6 = __toESM(require("react"), 1);
+var import_react15 = __toESM(require("react"), 1);
 var import_themes = require("@lessonkit/themes");
 
 // src/theme/applyCssVariables.ts
@@ -1207,9 +2204,12 @@ function applyCssVariables(target, vars, previousKeys) {
 }
 
 // src/theme/ThemeProvider.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var ThemeContext = (0, import_react6.createContext)(null);
-var useIsoLayoutEffect2 = typeof window !== "undefined" ? import_react6.useLayoutEffect : import_react6.default.useEffect;
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var ThemeContext = (0, import_react15.createContext)(null);
+var useIsoLayoutEffect2 = (
+  /* v8 ignore next -- SSR uses useEffect when window is unavailable */
+  typeof window !== "undefined" ? import_react15.useLayoutEffect : import_react15.default.useEffect
+);
 function getSystemMode() {
   if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
     return "light";
@@ -1227,7 +2227,7 @@ function ThemeProvider(props) {
   const preset = props.preset ?? "default";
   const mode = props.mode ?? "light";
   const targetKind = props.target ?? "document";
-  const [resolvedMode, setResolvedMode] = (0, import_react6.useState)(
+  const [resolvedMode, setResolvedMode] = (0, import_react15.useState)(
     () => mode === "system" ? getSystemMode() : mode
   );
   useIsoLayoutEffect2(() => {
@@ -1243,20 +2243,20 @@ function ThemeProvider(props) {
     return () => mq.removeEventListener("change", onChange);
   }, [mode]);
   const dataTheme = mode === "system" ? resolvedMode : mode === "dark" ? "dark" : "light";
-  const effectiveTheme = (0, import_react6.useMemo)(() => {
+  const effectiveTheme = (0, import_react15.useMemo)(() => {
     const modeBase = resolveModeBase(mode, dataTheme);
     const base = preset === "default" ? modeBase : preset === "brand" ? (0, import_themes.mergeThemes)(modeBase, import_themes.brandThemeOverrides) : (0, import_themes.mergeThemes)(modeBase, (0, import_themes.getPresetTheme)(preset));
     return (0, import_themes.mergeThemes)(base, props.theme ?? {});
   }, [preset, mode, dataTheme, props.theme]);
-  const hostRef = (0, import_react6.useRef)(null);
-  const appliedKeysRef = (0, import_react6.useRef)(/* @__PURE__ */ new Set());
+  const hostRef = (0, import_react15.useRef)(null);
+  const appliedKeysRef = (0, import_react15.useRef)(/* @__PURE__ */ new Set());
   useIsoLayoutEffect2(() => {
     if (targetKind === "document" && typeof document !== "undefined") {
       document.documentElement.setAttribute("data-lk-theme", dataTheme);
       return () => document.documentElement.removeAttribute("data-lk-theme");
     }
   }, [targetKind, dataTheme]);
-  const inject = (0, import_react6.useCallback)(() => {
+  const inject = (0, import_react15.useCallback)(() => {
     const vars = (0, import_themes.themeToCssVariables)(effectiveTheme);
     const el = targetKind === "document" && typeof document !== "undefined" ? document.documentElement : hostRef.current;
     if (!el) return;
@@ -1273,7 +2273,7 @@ function ThemeProvider(props) {
       appliedKeysRef.current = /* @__PURE__ */ new Set();
     };
   }, [inject, targetKind]);
-  const value = (0, import_react6.useMemo)(
+  const value = (0, import_react15.useMemo)(
     () => ({
       theme: effectiveTheme,
       preset,
@@ -1283,12 +2283,12 @@ function ThemeProvider(props) {
     [effectiveTheme, preset, mode, dataTheme]
   );
   if (targetKind === "document") {
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ThemeContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { "data-lk-theme": dataTheme, style: { display: "contents" }, children: props.children }) });
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ThemeContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-lk-theme": dataTheme, style: { display: "contents" }, children: props.children }) });
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ThemeContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { ref: hostRef, "data-lk-theme": dataTheme, children: props.children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ThemeContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { ref: hostRef, "data-lk-theme": dataTheme, children: props.children }) });
 }
 function useTheme() {
-  const ctx = (0, import_react6.useContext)(ThemeContext);
+  const ctx = (0, import_react15.useContext)(ThemeContext);
   if (!ctx) {
     throw new Error("useTheme must be used within a ThemeProvider");
   }
@@ -1297,6 +2297,7 @@ function useTheme() {
 
 // src/blockCatalog.ts
 var blockCatalogVersion = 1;
+var blockCatalogV2Version = 2;
 var BLOCK_CATALOG = [
   {
     type: "Course",
@@ -1483,8 +2484,163 @@ var BLOCK_CATALOG = [
     }
   }
 ];
-function buildBlockCatalog() {
-  return BLOCK_CATALOG.map((entry) => ({
+var assessmentBehaviourProps = [
+  { name: "enableRetry", type: "boolean", required: false, description: "Allow retry after completion." },
+  { name: "enableSolutionsButton", type: "boolean", required: false, description: "Show solution control." },
+  { name: "autoCheck", type: "boolean", required: false, description: "Check answers automatically when possible." },
+  { name: "passingScore", type: "number", required: false, description: "Minimum score to pass." }
+];
+var v2AssessmentEntries = [
+  {
+    type: "TrueFalse",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.TrueFalse",
+    h5pAlias: "True/False",
+    description: "Binary true/false question with assessment contract.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "question", type: "string", required: true, description: "Question text." },
+      { name: "answer", type: "boolean", required: true, description: "Correct answer." },
+      ...assessmentBehaviourProps
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence"],
+    a11y: {
+      element: "section",
+      ariaLabel: "True or False",
+      keyboard: "Radio group with True/False options.",
+      liveRegions: "role='status' for feedback.",
+      notes: "H5P True/False equivalent."
+    },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "FillInTheBlanks",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.Blanks",
+    h5pAlias: "Fill in the Blanks",
+    description: "Fill-in-the-blank text with *answer* markers in template.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "template", type: "string", required: true, description: "Text with *blank* markers." },
+      { name: "blanks", type: "FillInBlankSpec[]", required: false, description: "Explicit blank specs." },
+      ...assessmentBehaviourProps
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence"],
+    a11y: {
+      element: "section",
+      ariaLabel: "Fill in the Blanks",
+      keyboard: "Tab between text inputs.",
+      notes: "H5P Fill in the Blanks equivalent."
+    },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "DragAndDrop",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.DragQuestion",
+    h5pAlias: "Drag and Drop",
+    description: "Drag items onto labeled targets.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "items", type: "DragItem[]", required: true, description: "Draggable items." },
+      { name: "targets", type: "DropTarget[]", required: true, description: "Drop targets." },
+      ...assessmentBehaviourProps
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence"],
+    a11y: {
+      element: "section",
+      ariaLabel: "Drag and Drop",
+      keyboard: "Select item then activate target; drag also supported.",
+      notes: "H5P Drag and Drop equivalent."
+    },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "DragTheWords",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.DragText",
+    h5pAlias: "Drag the Words",
+    description: "Drag words into inline blanks.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "template", type: "string", required: true, description: "Sentence with *blank* zones." },
+      { name: "words", type: "string[]", required: true, description: "Draggable word bank." },
+      ...assessmentBehaviourProps
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence"],
+    a11y: {
+      element: "section",
+      ariaLabel: "Drag the Words",
+      keyboard: "Select word then activate zone.",
+      notes: "H5P Drag the Words equivalent."
+    },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "MarkTheWords",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.MarkTheWords",
+    h5pAlias: "Mark the Words",
+    description: "Select correct words in a sentence.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "text", type: "string", required: true, description: "Source text." },
+      { name: "correctWords", type: "string[]", required: true, description: "Words to mark." },
+      ...assessmentBehaviourProps
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence"],
+    a11y: {
+      element: "section",
+      ariaLabel: "Mark the Words",
+      keyboard: "Toggle words with buttons.",
+      notes: "H5P Mark the Words equivalent."
+    },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "AssessmentSequence",
+    category: "container",
+    h5pMachineName: "H5P.QuestionSet",
+    h5pAlias: "Question Set",
+    description: "Ordered sequence of contract-compliant assessments.",
+    props: [
+      { name: "children", type: "ReactNode", required: true, description: "Assessment blocks." },
+      { name: "sequential", type: "boolean", required: false, description: "One question at a time." },
+      ...assessmentBehaviourProps.filter((p) => p.name !== "passingScore")
+    ],
+    requiredIds: [],
+    parentConstraints: ["Lesson"],
+    a11y: {
+      element: "section",
+      ariaLabel: "Assessment sequence",
+      keyboard: "Previous/Next navigation between steps.",
+      notes: "H5P Question Set equivalent."
+    },
+    theming: { surface: "global-inherit", stylingNotes: "Container for assessments." },
+    telemetry: { emits: [], manualTracking: "Child assessments emit assessment_* events." }
+  }
+];
+var BLOCK_CATALOG_V2 = [
+  ...BLOCK_CATALOG,
+  ...v2AssessmentEntries
+];
+function cloneCatalogEntry(entry) {
+  return {
     ...entry,
     props: entry.props.map((p) => ({ ...p })),
     aliases: entry.aliases ? [...entry.aliases] : void 0,
@@ -1499,23 +2655,38 @@ function buildBlockCatalog() {
       ...entry.telemetry,
       emits: [...entry.telemetry.emits]
     }
-  }));
+  };
+}
+function buildBlockCatalog(opts) {
+  const version = opts?.version ?? 2;
+  const source = version === 2 ? BLOCK_CATALOG_V2 : BLOCK_CATALOG;
+  return source.map((entry) => cloneCatalogEntry(entry));
 }
-function getBlockCatalogEntry(type) {
-  return BLOCK_CATALOG.find((entry) => entry.type === type || entry.aliases?.includes(type));
+function getBlockCatalogEntry(type, opts) {
+  const version = opts?.version ?? 2;
+  const source = version === 2 ? BLOCK_CATALOG_V2 : BLOCK_CATALOG;
+  return source.find((entry) => entry.type === type || entry.aliases?.includes(type));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AssessmentSequence,
   BLOCK_CATALOG,
+  BLOCK_CATALOG_V2,
   Course,
+  DragAndDrop,
+  DragTheWords,
+  FillInTheBlanks,
   KnowledgeCheck,
   Lesson,
   LessonkitProvider,
+  MarkTheWords,
   ProgressTracker,
   Quiz,
   Reflection,
   Scenario,
   ThemeProvider,
+  TrueFalse,
+  blockCatalogV2Version,
   blockCatalogVersion,
   buildBlockCatalog,
   buildTelemetryEvent,
@@ -1526,7 +2697,9 @@ function getBlockCatalogEntry(type) {
   defineLifecyclePlugin,
   defineTelemetryPlugin,
   getBlockCatalogEntry,
+  resetAssessmentWarningsForTests,
   resetQuizWarningsForTests,
+  useAssessmentState,
   useCompletion,
   useLessonkit,
   useProgress,