@lessonkit/react 1.3.0 → 1.4.0

package/dist/blocks-entry.cjs

@@ -0,0 +1,4563 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/blocks-entry.ts
+var blocks_entry_exports = {};
+__export(blocks_entry_exports, {
+  Accordion: () => Accordion,
+  ArithmeticQuiz: () => ArithmeticQuiz,
+  AssessmentSequence: () => AssessmentSequence,
+  DialogCards: () => DialogCards,
+  DragAndDrop: () => DragAndDrop,
+  DragTheWords: () => DragTheWords,
+  Essay: () => Essay,
+  FillInTheBlanks: () => FillInTheBlanks,
+  FindHotspot: () => FindHotspot,
+  FindMultipleHotspots: () => FindMultipleHotspots,
+  Flashcards: () => Flashcards,
+  Heading: () => Heading,
+  Image: () => Image,
+  ImageHotspots: () => ImageHotspots,
+  ImagePairing: () => ImagePairing,
+  ImageSequencing: () => ImageSequencing,
+  ImageSlider: () => ImageSlider,
+  InformationWall: () => InformationWall,
+  InteractiveBook: () => InteractiveBook,
+  InteractiveVideo: () => InteractiveVideo,
+  MarkTheWords: () => MarkTheWords,
+  MemoryGame: () => MemoryGame,
+  Page: () => Page,
+  ParallaxSlideshow: () => ParallaxSlideshow,
+  Questionnaire: () => Questionnaire,
+  Slide: () => Slide,
+  SlideDeck: () => SlideDeck,
+  Summary: () => Summary,
+  Text: () => Text,
+  TimedCue: () => TimedCue,
+  TrueFalse: () => TrueFalse,
+  Video: () => Video
+});
+module.exports = __toCommonJS(blocks_entry_exports);
+
+// src/blocks/TrueFalse.tsx
+var import_react12 = __toESM(require("react"), 1);
+
+// src/assessment/AssessmentLessonGuard.tsx
+var import_react2 = require("react");
+
+// src/lessonContext.tsx
+var import_react = require("react");
+var LessonContext = (0, import_react.createContext)(void 0);
+function useEnclosingLessonId() {
+  return (0, import_react.useContext)(LessonContext);
+}
+
+// src/runtime/validateComponentId.ts
+var import_core = require("@lessonkit/core");
+function isDevEnvironment() {
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
+}
+function normalizeComponentId(id, path) {
+  if (path === "courseId") return (0, import_core.assertValidId)(id, "courseId");
+  if (path === "lessonId") return (0, import_core.assertValidId)(id, "lessonId");
+  if (path === "checkId") return (0, import_core.assertValidId)(id, "checkId");
+  if (path === "blockId") return (0, import_core.assertValidId)(id, "blockId");
+  return (0, import_core.assertValidId)(id, path);
+}
+
+// src/assessment/AssessmentLessonGuard.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var warnedAssessmentOutsideLesson = false;
+function AssessmentLessonGuard(props) {
+  const enclosingLessonId = useEnclosingLessonId();
+  const missingLesson = enclosingLessonId === void 0;
+  (0, import_react2.useEffect)(() => {
+    if (!missingLesson || isDevEnvironment()) 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 && isDevEnvironment()) {
+    throw new Error(`[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>`);
+  }
+  if (missingLesson) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("section", { role: "alert", "aria-label": `${props.blockLabel} configuration error`, "data-lk-check-id": props.checkId, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("p", { children: [
+      props.blockLabel,
+      " must be placed inside a Lesson."
+    ] }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: props.children(enclosingLessonId) });
+}
+
+// src/assessment/internal/buildAssessmentHandle.ts
+function buildAssessmentHandle(opts) {
+  return {
+    getScore: opts.getScore,
+    getMaxScore: opts.getMaxScore,
+    getAnswerGiven: opts.getAnswerGiven,
+    resetTask: opts.resetTask,
+    showSolutions: opts.showSolutions,
+    getXAPIData: opts.getXAPIData,
+    ...opts.getCurrentState ? { getCurrentState: opts.getCurrentState } : {},
+    ...opts.resume ? { resume: opts.resume } : {}
+  };
+}
+
+// src/assessment/internal/resumeState.ts
+function readBooleanField(state, key) {
+  const value = state[key];
+  if (value === true || value === false || value === null) return value;
+  return void 0;
+}
+function readStringField(state, key) {
+  const value = state[key];
+  if (typeof value === "string" || value === null) return value;
+  return void 0;
+}
+function readNumberField(state, key) {
+  const value = state[key];
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (value === null) return null;
+  return void 0;
+}
+function readBooleanStateField(state, key, apply) {
+  const value = state[key];
+  if (typeof value === "boolean") apply(value);
+}
+
+// src/assessment/internal/useAssessmentHandleRegistration.ts
+var import_react6 = require("react");
+
+// src/compound/CompoundProvider.tsx
+var import_react5 = __toESM(require("react"), 1);
+var import_core2 = require("@lessonkit/core");
+
+// src/compound/aggregateScores.ts
+function aggregateAssessmentScores(handles, opts) {
+  let score = 0;
+  let maxScore = 0;
+  let allAnswered = true;
+  for (const entry of handles) {
+    const handle = "handle" in entry ? entry.handle : entry;
+    const pageIndex = "handle" in entry ? entry.pageIndex : void 0;
+    score += handle.getScore();
+    maxScore += handle.getMaxScore();
+    const countsForAnswerGiven = opts?.answerPageIndex === void 0 || pageIndex === void 0 || pageIndex === opts.answerPageIndex;
+    if (countsForAnswerGiven && !handle.getAnswerGiven()) allAnswered = false;
+  }
+  return { score, maxScore, allAnswered };
+}
+
+// src/compound/CompoundHydrationBridge.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var CompoundHydrationBridgeContext = (0, import_react3.createContext)(
+  null
+);
+function CompoundHydrationBridgeProvider({ children }) {
+  const bridgeRef = (0, import_react3.useRef)(null);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CompoundHydrationBridgeContext.Provider, { value: bridgeRef, children });
+}
+function useCompoundHydrationBridgeRef() {
+  return (0, import_react3.useContext)(CompoundHydrationBridgeContext);
+}
+
+// src/compound/CompoundPageIndexContext.tsx
+var import_react4 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var CompoundPageIndexContext = (0, import_react4.createContext)(void 0);
+function CompoundPageIndexProvider({
+  pageIndex,
+  children
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CompoundPageIndexContext.Provider, { value: pageIndex, children });
+}
+function useCompoundPageIndex() {
+  return (0, import_react4.useContext)(CompoundPageIndexContext);
+}
+
+// src/compound/CompoundProvider.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var CompoundRegistryContext = (0, import_react5.createContext)(null);
+var CompoundHandlesVersionContext = (0, import_react5.createContext)(0);
+function CompoundProvider({
+  children,
+  activePageIndex: _activePageIndex,
+  onActivePageIndexChange: _onActivePageIndexChange
+}) {
+  const registryRef = (0, import_react5.useRef)(/* @__PURE__ */ new Map());
+  const [handlesVersion, setHandlesVersion] = (0, import_react5.useState)(0);
+  const register = (0, import_react5.useCallback)((checkId, handle, pageIndex) => {
+    const prev = registryRef.current.get(checkId);
+    if (prev && prev.handle !== handle) {
+      const message = `[lessonkit] duplicate checkId "${checkId}" registered in the same compound container; the previous handle was replaced.`;
+      if (isDevEnvironment()) {
+        console.error(message);
+      } else {
+        console.warn(message);
+      }
+    }
+    registryRef.current.set(checkId, { handle, pageIndex });
+    if (prev?.handle !== handle || prev?.pageIndex !== pageIndex) {
+      setHandlesVersion((v) => v + 1);
+    }
+    return () => {
+      const current = registryRef.current.get(checkId);
+      if (current?.handle === handle) {
+        registryRef.current.delete(checkId);
+        setHandlesVersion((v) => v + 1);
+      }
+    };
+  }, []);
+  const registryValue = (0, import_react5.useMemo)(
+    () => ({
+      register,
+      getHandles: () => {
+        const handles = /* @__PURE__ */ new Map();
+        for (const [checkId, entry] of registryRef.current) {
+          handles.set(checkId, entry.handle);
+        }
+        return handles;
+      },
+      getRegisteredHandles: () => registryRef.current
+    }),
+    [register]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CompoundHydrationBridgeProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CompoundRegistryContext.Provider, { value: registryValue, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CompoundHandlesVersionContext.Provider, { value: handlesVersion, children }) }) });
+}
+function useCompoundRegistry() {
+  const registry = (0, import_react5.useContext)(CompoundRegistryContext);
+  const handlesVersion = (0, import_react5.useContext)(CompoundHandlesVersionContext);
+  if (!registry) return null;
+  return { ...registry, handlesVersion };
+}
+function useCompoundHandlesVersion() {
+  return (0, import_react5.useContext)(CompoundHandlesVersionContext);
+}
+function useRegisterAssessmentHandle(checkId, handle) {
+  const registry = (0, import_react5.useContext)(CompoundRegistryContext);
+  const pageIndex = useCompoundPageIndex();
+  import_react5.default.useLayoutEffect(() => {
+    if (!registry || !handle) return;
+    return registry.register(checkId, handle, pageIndex);
+  }, [registry, checkId, handle, pageIndex]);
+}
+function useCompoundHandleRef(ref, opts) {
+  const { activePageIndex, setActivePageIndex, getHandles, getRegisteredHandles, pageCount } = opts;
+  const bridgeRef = useCompoundHydrationBridgeRef();
+  const setIndexClamped = (0, import_react5.useCallback)(
+    (index) => {
+      const next = pageCount !== void 0 ? (0, import_core2.clampCompoundPageIndex)(index, pageCount) : Math.max(0, Math.floor(index));
+      setActivePageIndex(next);
+    },
+    [pageCount, setActivePageIndex]
+  );
+  (0, import_react5.useImperativeHandle)(
+    ref,
+    () => ({
+      getScore: () => aggregateAssessmentScores(getRegisteredHandles().values()).score,
+      getMaxScore: () => aggregateAssessmentScores(getRegisteredHandles().values()).maxScore,
+      getAnswerGiven: () => aggregateAssessmentScores(getRegisteredHandles().values(), {
+        answerPageIndex: activePageIndex
+      }).allAnswered,
+      resetTask: () => {
+        for (const entry of getRegisteredHandles().values()) entry.handle.resetTask();
+      },
+      showSolutions: () => {
+        if (!opts.enableSolutionsButton) return;
+        for (const entry of getRegisteredHandles().values()) entry.handle.showSolutions();
+      },
+      getCurrentState: () => {
+        const childStates = {};
+        for (const [checkId, entry] of getRegisteredHandles()) {
+          if (entry.handle.getCurrentState) {
+            childStates[checkId] = entry.handle.getCurrentState();
+          }
+        }
+        return (0, import_core2.createCompoundResumeState)({ activePageIndex, childStates });
+      },
+      resume: (state) => {
+        bridgeRef?.current?.notifyImperativeResume(state);
+      }
+    }),
+    [activePageIndex, setIndexClamped, getHandles, getRegisteredHandles, opts.enableSolutionsButton, bridgeRef]
+  );
+}
+
+// src/assessment/internal/useAssessmentHandleRegistration.ts
+function useAssessmentHandleRegistration(checkId, handle, ref) {
+  (0, import_react6.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+}
+
+// src/assessment/internal/usePluginScoring.ts
+var import_react11 = require("react");
+
+// src/hooks.ts
+var import_react10 = require("react");
+
+// src/context.tsx
+var import_react8 = require("react");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var import_react7 = require("react");
+var import_core10 = require("@lessonkit/core");
+
+// src/runtime/observability.ts
+var import_xapi = require("@lessonkit/xapi");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var import_xapi5 = require("@lessonkit/xapi");
+
+// src/runtime/emitTelemetry.ts
+var import_core4 = require("@lessonkit/core");
+
+// src/runtime/telemetryPipeline.ts
+var import_core3 = require("@lessonkit/core");
+var import_xapi2 = require("@lessonkit/xapi");
+
+// src/runtime/lxpackBridge.ts
+var import_bridge = require("@lessonkit/lxpack/bridge");
+
+// src/runtime/ports.ts
+var import_core5 = require("@lessonkit/core");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var import_core11 = require("@lessonkit/core");
+
+// src/runtime/progress.ts
+var import_core6 = require("@lessonkit/core");
+
+// src/runtime/xapi.ts
+var import_xapi3 = require("@lessonkit/xapi");
+
+// src/runtime/session.ts
+var import_core7 = require("@lessonkit/core");
+
+// src/runtime/courseStartedPipeline.ts
+var import_xapi4 = require("@lessonkit/xapi");
+
+// src/runtime/plugins.ts
+var import_core8 = require("@lessonkit/core");
+function buildPluginContext(opts) {
+  return (0, import_core8.buildPluginContext)(opts);
+}
+
+// src/runtime/telemetry.ts
+var import_core9 = require("@lessonkit/core");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var defaultStorage = (0, import_core5.createSessionStoragePort)();
+
+// src/context.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var LessonkitContext = (0, import_react8.createContext)(null);
+
+// src/assessment/useAssessmentState.ts
+var import_react9 = require("react");
+function useAssessmentState(enclosingLessonId) {
+  const { track } = useLessonkit();
+  const trackOpts = enclosingLessonId ? { lessonId: enclosingLessonId } : void 0;
+  return (0, import_react9.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_react10.useContext)(LessonkitContext);
+  if (!ctx) throw new Error("LessonKit: missing LessonkitProvider");
+  return ctx;
+}
+
+// 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/assessment/internal/usePluginScoring.ts
+function usePluginScoring(checkId, lessonId) {
+  const { plugins, config, session } = useLessonkit();
+  const getPluginScore = (0, import_react11.useCallback)(
+    (response) => {
+      const pluginCtx = buildPluginContext({
+        courseId: config.courseId,
+        sessionId: session.sessionId,
+        attemptId: session.attemptId,
+        user: session.user
+      });
+      return plugins?.scoreAssessment({ checkId, lessonId, response }, pluginCtx) ?? null;
+    },
+    [checkId, config.courseId, lessonId, plugins, session.attemptId, session.sessionId, session.user]
+  );
+  const scoreResponse = (0, import_react11.useCallback)(
+    (response, defaultCorrect, maxScore = 1, passingScore) => scoreFromCustom(getPluginScore(response), defaultCorrect, maxScore, passingScore),
+    [getPluginScore]
+  );
+  const isChoiceCorrect = (0, import_react11.useCallback)(
+    (choice, answer, custom, passingScore) => {
+      if (!custom) return choice === answer;
+      if (custom.passed !== void 0) return custom.passed;
+      if (custom.maxScore != null && custom.maxScore > 0 && custom.score != null) {
+        return meetsPassingThreshold(custom.score, custom.maxScore, passingScore);
+      }
+      return choice === answer;
+    },
+    []
+  );
+  return { getPluginScore, scoreResponse, isChoiceCorrect };
+}
+
+// src/blocks/TrueFalse.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var INTERACTION = "trueFalse";
+function TrueFalseInner(props, ref) {
+  const { enclosingLessonId } = props;
+  const checkId = (0, import_react12.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(enclosingLessonId);
+  const { config } = useLessonkit();
+  const { scoreResponse } = usePluginScoring(checkId, enclosingLessonId);
+  const [selected, setSelected] = (0, import_react12.useState)(null);
+  const [selectionCorrect, setSelectionCorrect] = (0, import_react12.useState)(null);
+  const [showSolutions, setShowSolutions] = (0, import_react12.useState)(false);
+  const [passed, setPassed] = (0, import_react12.useState)(false);
+  const [completedScore, setCompletedScore] = (0, import_react12.useState)(null);
+  const [completedMaxScore, setCompletedMaxScore] = (0, import_react12.useState)(null);
+  const completedRef = (0, import_react12.useRef)(false);
+  const telemetryReplayedRef = (0, import_react12.useRef)(false);
+  const questionId = import_react12.default.useId();
+  const reset = () => {
+    completedRef.current = false;
+    telemetryReplayedRef.current = false;
+    setPassed(false);
+    setSelected(null);
+    setSelectionCorrect(null);
+    setShowSolutions(false);
+    setCompletedScore(null);
+    setCompletedMaxScore(null);
+  };
+  (0, import_react12.useEffect)(() => {
+    reset();
+  }, [checkId, props.answer, props.question, config.courseId, enclosingLessonId]);
+  const resolveScores = () => {
+    const maxScore = completedMaxScore ?? 1;
+    if (passed) {
+      return { score: completedScore ?? maxScore, maxScore };
+    }
+    if (selectionCorrect) {
+      return { score: completedMaxScore ?? maxScore, maxScore };
+    }
+    return { score: 0, maxScore };
+  };
+  const replayTelemetry = (nextSelected, nextCorrect, nextPassed, nextScore, nextMaxScore) => {
+    if (!nextPassed || telemetryReplayedRef.current) return;
+    telemetryReplayedRef.current = true;
+    if (nextSelected !== null) {
+      assessment.answer({
+        checkId,
+        interactionType: INTERACTION,
+        question: props.question,
+        response: nextSelected,
+        correct: nextCorrect ?? false
+      });
+    }
+    assessment.complete({
+      checkId,
+      interactionType: INTERACTION,
+      score: nextScore,
+      maxScore: nextMaxScore,
+      passingScore: props.passingScore ?? nextMaxScore
+    });
+  };
+  const handle = (0, import_react12.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => resolveScores().score,
+      getMaxScore: () => resolveScores().maxScore,
+      getAnswerGiven: () => selected !== null,
+      resetTask: reset,
+      showSolutions: () => setShowSolutions(true),
+      getXAPIData: () => {
+        const { score, maxScore } = resolveScores();
+        return {
+          checkId,
+          interactionType: INTERACTION,
+          response: selected ?? void 0,
+          correct: selectionCorrect ?? void 0,
+          score,
+          maxScore
+        };
+      },
+      getCurrentState: () => ({
+        selected,
+        selectionCorrect,
+        passed,
+        showSolutions,
+        completedScore,
+        completedMaxScore
+      }),
+      resume: (state) => {
+        const nextSelected = readBooleanField(state, "selected");
+        if (nextSelected === true || nextSelected === false || nextSelected === null) {
+          setSelected(nextSelected);
+        }
+        const nextCorrect = readBooleanField(state, "selectionCorrect");
+        if (nextCorrect === true || nextCorrect === false || nextCorrect === null) {
+          setSelectionCorrect(nextCorrect);
+        }
+        const nextCompletedScore = readNumberField(state, "completedScore");
+        if (typeof nextCompletedScore === "number") setCompletedScore(nextCompletedScore);
+        const nextCompletedMaxScore = readNumberField(state, "completedMaxScore");
+        if (typeof nextCompletedMaxScore === "number") setCompletedMaxScore(nextCompletedMaxScore);
+        const nextPassed = readBooleanField(state, "passed");
+        if (nextPassed === true || nextPassed === false) {
+          setPassed(nextPassed);
+          completedRef.current = nextPassed;
+          if (nextPassed) {
+            const maxScore = nextCompletedMaxScore ?? completedMaxScore ?? 1;
+            const score = nextCompletedScore ?? completedScore ?? maxScore;
+            replayTelemetry(nextSelected ?? null, nextCorrect ?? null, nextPassed, score, maxScore);
+          }
+        }
+        readBooleanStateField(state, "showSolutions", setShowSolutions);
+      }
+    }),
+    [
+      assessment,
+      checkId,
+      completedMaxScore,
+      completedScore,
+      passed,
+      props.passingScore,
+      props.question,
+      selected,
+      selectionCorrect,
+      showSolutions
+    ]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const submit = (value) => {
+    if (passed && !props.enableRetry) return;
+    setSelected(value);
+    const correct = value === props.answer;
+    const scored = scoreResponse(value, 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);
+      setCompletedScore(scored.score);
+      setCompletedMaxScore(scored.maxScore);
+      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_runtime6.jsxs)("section", { "aria-label": "True or False", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { id: questionId, children: props.question }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("fieldset", { "aria-labelledby": questionId, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("legend", { className: "lk-visually-hidden", children: "True or False" }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("label", { style: { display: "block", marginRight: "1rem" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          "input",
+          {
+            type: "radio",
+            name: `${questionId}-tf`,
+            checked: selected === true,
+            disabled: passed && !props.enableRetry,
+            onChange: () => submit(true)
+          }
+        ),
+        "True"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("label", { style: { display: "block" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          "input",
+          {
+            type: "radio",
+            name: `${questionId}-tf`,
+            checked: selected === false,
+            disabled: passed && !props.enableRetry,
+            onChange: () => submit(false)
+          }
+        ),
+        "False"
+      ] })
+    ] }),
+    reveal ? /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("p", { children: [
+      "Correct answer: ",
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("strong", { children: props.answer ? "True" : "False" })
+    ] }) : null,
+    selected !== null && selectionCorrect !== null ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { role: "status", "aria-live": "polite", children: selectionCorrect ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("button", { type: "button", onClick: reset, children: "Try again" }) : null,
+    props.enableSolutionsButton && !reveal ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
+  ] });
+}
+var TrueFalseInnerForwarded = (0, import_react12.forwardRef)(TrueFalseInner);
+var TrueFalse = (0, import_react12.forwardRef)(function TrueFalse2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(AssessmentLessonGuard, { blockLabel: "TrueFalse", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(TrueFalseInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/MarkTheWords.tsx
+var import_react13 = __toESM(require("react"), 1);
+var import_jsx_runtime7 = 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_react13.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const tokens = (0, import_react13.useMemo)(() => tokenize(props.text), [props.text]);
+  const correctSet = (0, import_react13.useMemo)(
+    () => new Set(props.correctWords.map((w) => w.toLowerCase())),
+    [props.correctWords]
+  );
+  const [marked, setMarked] = (0, import_react13.useState)(() => /* @__PURE__ */ new Set());
+  const [passed, setPassed] = (0, import_react13.useState)(false);
+  const [showSolutions, setShowSolutions] = (0, import_react13.useState)(false);
+  const completedRef = (0, import_react13.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    setPassed(false);
+    setMarked(/* @__PURE__ */ new Set());
+    setShowSolutions(false);
+  };
+  (0, import_react13.useEffect)(() => {
+    reset();
+  }, [checkId, props.text, props.correctWords.join("\0")]);
+  const selectableIndices = (0, import_react13.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_react13.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => score,
+      getMaxScore: () => maxScore || 1,
+      getAnswerGiven: () => marked.size > 0,
+      resetTask: reset,
+      showSolutions: () => setShowSolutions(true),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION2,
+        response: [...marked].map((i) => tokens[i]),
+        correct: passedThreshold,
+        score,
+        maxScore: maxScore || 1
+      }),
+      getCurrentState: () => ({ marked: [...marked], passed, showSolutions }),
+      resume: (state) => {
+        const raw = state.marked;
+        if (Array.isArray(raw)) setMarked(new Set(raw.filter((i) => typeof i === "number")));
+        readBooleanStateField(state, "passed", (value) => {
+          setPassed(value);
+          completedRef.current = value;
+        });
+        readBooleanStateField(state, "showSolutions", setShowSolutions);
+      }
+    }),
+    [checkId, marked, maxScore, passed, passedThreshold, score, showSolutions, tokens]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  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_react13.useEffect)(() => {
+    if (!hasTargets) {
+      if (isDevEnvironment()) {
+        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: passedThreshold
+    });
+    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_runtime7.jsxs)("section", { "aria-label": "Mark the Words", "data-lk-check-id": checkId, children: [
+    !hasTargets ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("p", { role: "alert", children: [
+      "No words in this sentence match ",
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("code", { children: "correctWords" }),
+      ". Check spelling and capitalization in the source text."
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { id: `${checkId}-hint`, children: "Select the correct words in the sentence." }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.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_runtime7.jsx)(import_react13.default.Fragment, { children: token }, i);
+      const selected = marked.has(i);
+      const solution = showSolutions || passed && props.enableSolutionsButton;
+      return /* @__PURE__ */ (0, import_jsx_runtime7.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_runtime7.jsx)("p", { role: "status", "aria-live": "polite", children: "Correct" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", onClick: reset, children: "Try again" }) : null,
+    props.enableSolutionsButton && !showSolutions ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
+  ] });
+}
+var MarkTheWordsInnerForwarded = (0, import_react13.forwardRef)(MarkTheWordsInner);
+var MarkTheWords = (0, import_react13.forwardRef)(function MarkTheWords2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(AssessmentLessonGuard, { blockLabel: "MarkTheWords", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(MarkTheWordsInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/FillInTheBlanks.tsx
+var import_react14 = __toESM(require("react"), 1);
+
+// src/assessment/internal/parseStarDelimitedTemplate.ts
+function parseStarDelimitedTemplate(template, idPrefix) {
+  const parts = [];
+  const values = [];
+  const re = /\*([^*]+)\*/g;
+  let last = 0;
+  let match;
+  let n = 0;
+  while ((match = re.exec(template)) !== null) {
+    parts.push(template.slice(last, match.index));
+    values.push(match[1].trim());
+    parts.push(`${idPrefix}-${n++}`);
+    last = match.index + match[0].length;
+  }
+  parts.push(template.slice(last));
+  return { parts, values };
+}
+
+// src/blocks/FillInTheBlanks.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var INTERACTION3 = "fillInBlanks";
+function parseTemplate(template) {
+  const { parts, values } = parseStarDelimitedTemplate(template, "blank");
+  return {
+    parts,
+    blanks: values.map((answer, i) => ({ id: `blank-${i}`, answer }))
+  };
+}
+function FillInTheBlanksInner(props, ref) {
+  const checkId = (0, import_react14.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const parsed = (0, import_react14.useMemo)(() => parseTemplate(props.template), [props.template]);
+  const blanks = props.blanks ?? parsed.blanks;
+  const [values, setValues] = (0, import_react14.useState)(
+    () => Object.fromEntries(blanks.map((b) => [b.id, ""]))
+  );
+  const [passed, setPassed] = (0, import_react14.useState)(false);
+  const [showSolutions, setShowSolutions] = (0, import_react14.useState)(false);
+  const [submitted, setSubmitted] = (0, import_react14.useState)(false);
+  const completedRef = (0, import_react14.useRef)(false);
+  const answeredRef = (0, import_react14.useRef)(false);
+  const checkSnapshotRef = (0, import_react14.useRef)(null);
+  const telemetryReplayedRef = (0, import_react14.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    answeredRef.current = false;
+    checkSnapshotRef.current = null;
+    telemetryReplayedRef.current = false;
+    setPassed(false);
+    setValues(Object.fromEntries(blanks.map((b) => [b.id, ""])));
+    setShowSolutions(false);
+    setSubmitted(false);
+  };
+  (0, import_react14.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 replayTelemetry = (nextValues, nextPassed, nextSubmitted, nextScore, nextMaxScore) => {
+    if (telemetryReplayedRef.current || !nextSubmitted && !nextPassed) return;
+    telemetryReplayedRef.current = true;
+    const nextPassedThreshold = meetsPassingThreshold(
+      nextScore,
+      nextMaxScore || 1,
+      props.passingScore
+    );
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION3,
+      question: props.template,
+      response: nextValues,
+      correct: nextPassedThreshold
+    });
+    if (nextPassed || nextPassedThreshold) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION3,
+        score: nextScore,
+        maxScore: nextMaxScore,
+        passingScore: props.passingScore ?? nextMaxScore
+      });
+    }
+  };
+  const handle = (0, import_react14.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => score,
+      getMaxScore: () => maxScore || 1,
+      getAnswerGiven: () => allFilled,
+      resetTask: reset,
+      showSolutions: () => setShowSolutions(true),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION3,
+        response: values,
+        correct: passedThreshold,
+        score,
+        maxScore: maxScore || 1
+      }),
+      getCurrentState: () => ({ values, passed, showSolutions, submitted }),
+      resume: (state) => {
+        const raw = state.values;
+        let nextValues = values;
+        if (raw && typeof raw === "object") {
+          nextValues = { ...raw };
+          setValues(nextValues);
+        }
+        let nextPassed = passed;
+        let nextSubmitted = submitted;
+        readBooleanStateField(state, "passed", (value) => {
+          nextPassed = value;
+          setPassed(value);
+          completedRef.current = value;
+          answeredRef.current = value;
+        });
+        readBooleanStateField(state, "showSolutions", setShowSolutions);
+        readBooleanStateField(state, "submitted", (value) => {
+          nextSubmitted = value;
+          setSubmitted(value);
+          if (value) answeredRef.current = true;
+        });
+        let nextScore = 0;
+        blanks.forEach((b) => {
+          if ((nextValues[b.id] ?? "").trim().toLowerCase() === b.answer.toLowerCase()) nextScore += 1;
+        });
+        replayTelemetry(nextValues, nextPassed, nextSubmitted, nextScore, blanks.length);
+      }
+    }),
+    [allFilled, assessment, blanks, checkId, maxScore, passed, passedThreshold, props.passingScore, props.template, score, showSolutions, submitted, values]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const check = () => {
+    if (!hasBlanks) {
+      if (isDevEnvironment()) {
+        console.warn("[lessonkit] FillInTheBlanks has no blanks in template");
+      }
+      return;
+    }
+    if (!allFilled) return;
+    if (passed) return;
+    const snapshot = JSON.stringify(values);
+    if (checkSnapshotRef.current === snapshot) return;
+    checkSnapshotRef.current = snapshot;
+    answeredRef.current = true;
+    setSubmitted(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_react14.useEffect)(() => {
+    if (!allFilled) {
+      answeredRef.current = false;
+      checkSnapshotRef.current = null;
+      setSubmitted(false);
+    }
+  }, [allFilled]);
+  (0, import_react14.useEffect)(() => {
+    if (props.autoCheck && allFilled && !passed) check();
+  }, [allFilled, props.autoCheck, values, passedThreshold, passed]);
+  const reveal = showSolutions || passed && props.enableSolutionsButton;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("section", { "aria-label": "Fill in the Blanks", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { children: parsed.parts.map((part, i) => {
+      const blank = blanks.find((b) => b.id === part);
+      if (!blank) return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react14.default.Fragment, { children: part }, i);
+      return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("label", { style: { margin: "0 0.25em" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "lk-visually-hidden", children: blank.answer }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.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_runtime8.jsx)("button", { type: "button", "data-testid": "check-blanks", disabled: !allFilled || passed, onClick: check, children: "Check" }) : null,
+    !hasBlanks ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { role: "alert", children: "This activity has no blanks. Add text wrapped in asterisks, e.g. The *answer* here." }) : null,
+    submitted ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "button", onClick: reset, children: "Try again" }) : null,
+    props.enableSolutionsButton && !reveal ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
+  ] });
+}
+var FillInTheBlanksInnerForwarded = (0, import_react14.forwardRef)(FillInTheBlanksInner);
+var FillInTheBlanks = (0, import_react14.forwardRef)(
+  function FillInTheBlanks2(props, ref) {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AssessmentLessonGuard, { blockLabel: "FillInTheBlanks", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(FillInTheBlanksInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+  }
+);
+
+// src/blocks/DragTheWords.tsx
+var import_react15 = __toESM(require("react"), 1);
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var INTERACTION4 = "dragTheWords";
+function parseZones(template) {
+  const { parts, values } = parseStarDelimitedTemplate(template, "zone");
+  return { parts, answers: values };
+}
+function DragTheWordsInner(props, ref) {
+  const checkId = (0, import_react15.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const { parts, answers } = (0, import_react15.useMemo)(() => parseZones(props.template), [props.template]);
+  const [zones, setZones] = (0, import_react15.useState)(
+    () => Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""]))
+  );
+  const [pool, setPool] = (0, import_react15.useState)(() => [...props.words]);
+  const [keyboardWord, setKeyboardWord] = (0, import_react15.useState)(null);
+  const [passed, setPassed] = (0, import_react15.useState)(false);
+  const [submitted, setSubmitted] = (0, import_react15.useState)(false);
+  const completedRef = (0, import_react15.useRef)(false);
+  const answeredRef = (0, import_react15.useRef)(false);
+  const checkSnapshotRef = (0, import_react15.useRef)(null);
+  const telemetryReplayedRef = (0, import_react15.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    answeredRef.current = false;
+    checkSnapshotRef.current = null;
+    telemetryReplayedRef.current = false;
+    setPassed(false);
+    setSubmitted(false);
+    setZones(Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""])));
+    setPool([...props.words]);
+    setKeyboardWord(null);
+  };
+  (0, import_react15.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 replayTelemetry = (nextZones, nextPassed, nextSubmitted, nextScore, nextMaxScore) => {
+    if (telemetryReplayedRef.current || !nextSubmitted && !nextPassed) return;
+    telemetryReplayedRef.current = true;
+    const nextPassedThreshold = meetsPassingThreshold(
+      nextScore,
+      nextMaxScore || 1,
+      props.passingScore
+    );
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION4,
+      question: props.template,
+      response: nextZones,
+      correct: nextPassedThreshold
+    });
+    if (nextPassed || nextPassedThreshold) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION4,
+        score: nextScore,
+        maxScore: nextMaxScore,
+        passingScore: props.passingScore ?? nextMaxScore
+      });
+    }
+  };
+  const handle = (0, import_react15.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => score,
+      getMaxScore: () => maxScore || 1,
+      getAnswerGiven: () => allFilled,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION4,
+        response: zones,
+        correct: passedThreshold,
+        score,
+        maxScore: maxScore || 1
+      }),
+      getCurrentState: () => ({ zones, pool, passed, keyboardWord, submitted }),
+      resume: (state) => {
+        const rawZones = state.zones;
+        let nextZones = zones;
+        if (rawZones && typeof rawZones === "object") {
+          nextZones = { ...rawZones };
+          setZones(nextZones);
+        }
+        if (Array.isArray(state.pool)) setPool([...state.pool]);
+        let nextPassed = passed;
+        let nextSubmitted = submitted;
+        readBooleanStateField(state, "passed", (value) => {
+          nextPassed = value;
+          setPassed(value);
+          completedRef.current = value;
+          answeredRef.current = value;
+        });
+        readBooleanStateField(state, "submitted", (value) => {
+          nextSubmitted = value;
+          setSubmitted(value);
+          if (value) answeredRef.current = true;
+        });
+        const kw = state.keyboardWord;
+        if (kw === null || typeof kw === "string") setKeyboardWord(kw ?? null);
+        let nextScore = 0;
+        answers.forEach((ans, i) => {
+          if ((nextZones[`zone-${i}`] ?? "").trim().toLowerCase() === ans.toLowerCase()) nextScore += 1;
+        });
+        replayTelemetry(nextZones, nextPassed, nextSubmitted, nextScore, answers.length);
+      }
+    }),
+    [allFilled, answers, assessment, checkId, keyboardWord, maxScore, passed, passedThreshold, pool, props.passingScore, props.template, score, submitted, zones]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  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 (isDevEnvironment()) {
+        console.warn("[lessonkit] DragTheWords has no drop zones in template");
+      }
+      return;
+    }
+    if (!allFilled) return;
+    if (passed) return;
+    const snapshot = JSON.stringify(zones);
+    if (checkSnapshotRef.current === snapshot) return;
+    checkSnapshotRef.current = snapshot;
+    answeredRef.current = true;
+    setSubmitted(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_react15.useEffect)(() => {
+    if (!allFilled) {
+      answeredRef.current = false;
+      checkSnapshotRef.current = null;
+      setSubmitted(false);
+    }
+  }, [allFilled]);
+  (0, import_react15.useEffect)(() => {
+    if (props.autoCheck && allFilled && !passed) check();
+  }, [allFilled, props.autoCheck, zones, passedThreshold, passed]);
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("section", { "aria-label": "Drag the Words", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("p", { children: "Drag words into the blanks (or select a word, then activate a blank)." }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { role: "list", "aria-label": "Word bank", "data-testid": "word-bank", children: pool.map((word) => /* @__PURE__ */ (0, import_jsx_runtime9.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_runtime9.jsx)("p", { children: parts.map((part, i) => {
+      if (!part.startsWith("zone-")) return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react15.default.Fragment, { children: part }, i);
+      return /* @__PURE__ */ (0, import_jsx_runtime9.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_runtime9.jsx)("button", { type: "button", "data-testid": "check-drag-words", disabled: !allFilled || passed, onClick: check, children: "Check" }),
+    !hasZones ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("p", { role: "alert", children: "This activity has no drop zones. Wrap answers in asterisks in the template." }) : null,
+    submitted ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null
+  ] });
+}
+var DragTheWordsInnerForwarded = (0, import_react15.forwardRef)(DragTheWordsInner);
+var DragTheWords = (0, import_react15.forwardRef)(function DragTheWords2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(AssessmentLessonGuard, { blockLabel: "DragTheWords", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(DragTheWordsInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/DragAndDrop.tsx
+var import_react16 = require("react");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var INTERACTION5 = "dragAndDrop";
+function DragAndDropInner(props, ref) {
+  const checkId = (0, import_react16.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const [assignments, setAssignments] = (0, import_react16.useState)(
+    () => Object.fromEntries(props.targets.map((t) => [t.id, ""]))
+  );
+  const [pool, setPool] = (0, import_react16.useState)(() => props.items.map((i) => i.id));
+  const [keyboardItem, setKeyboardItem] = (0, import_react16.useState)(null);
+  const [passed, setPassed] = (0, import_react16.useState)(false);
+  const [checked, setChecked] = (0, import_react16.useState)(false);
+  const completedRef = (0, import_react16.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    setPassed(false);
+    setChecked(false);
+    setAssignments(Object.fromEntries(props.targets.map((t) => [t.id, ""])));
+    setPool(props.items.map((i) => i.id));
+    setKeyboardItem(null);
+  };
+  (0, import_react16.useEffect)(() => {
+    reset();
+  }, [checkId, props.items.map((i) => i.id).join(","), props.targets.map((t) => t.id).join(",")]);
+  const hasTargets = props.targets.length > 0;
+  const allFilled = hasTargets && props.targets.every((t) => (assignments[t.id] ?? "").length > 0);
+  let score = 0;
+  props.targets.forEach((t) => {
+    if (assignments[t.id] === t.accepts) score += 1;
+  });
+  const maxScore = props.targets.length || 1;
+  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore);
+  const handle = (0, import_react16.useMemo)(() => {
+    return buildAssessmentHandle({
+      checkId,
+      getScore: () => score,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => hasTargets && allFilled,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION5,
+        response: assignments,
+        correct: passedThreshold,
+        score,
+        maxScore
+      }),
+      getCurrentState: () => ({ assignments, pool, passed, checked, keyboardItem }),
+      resume: (state) => {
+        const rawAssignments = state.assignments;
+        if (rawAssignments && typeof rawAssignments === "object") {
+          setAssignments({ ...rawAssignments });
+        }
+        if (Array.isArray(state.pool)) setPool([...state.pool]);
+        readBooleanStateField(state, "passed", (value) => {
+          setPassed(value);
+          completedRef.current = value;
+        });
+        readBooleanStateField(state, "checked", setChecked);
+        const item = state.keyboardItem;
+        if (item === null || typeof item === "string") setKeyboardItem(item ?? null);
+      }
+    });
+  }, [allFilled, assignments, checkId, checked, hasTargets, keyboardItem, maxScore, passed, passedThreshold, pool, props.targets, score]);
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const place = (targetId, itemId) => {
+    if (passed && !props.enableRetry) return;
+    setChecked(false);
+    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;
+    setChecked(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION5,
+      response: assignments,
+      correct: passedThreshold
+    });
+    if (passedThreshold && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION5,
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("section", { "aria-label": "Drag and Drop", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("p", { children: "Match each item to the correct target (drag or use keyboard: select item, then activate target)." }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { role: "list", "aria-label": "Draggable items", children: pool.flatMap((id) => {
+      const item = props.items.find((i) => i.id === id);
+      if (!item) return [];
+      return /* @__PURE__ */ (0, import_jsx_runtime10.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_runtime10.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_runtime10.jsxs)("li", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("strong", { children: target.label }),
+        " ",
+        /* @__PURE__ */ (0, import_jsx_runtime10.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_runtime10.jsx)("button", { type: "button", "data-testid": "check-drag-drop", disabled: !hasTargets || !allFilled || passed, onClick: check, children: "Check" }),
+    checked ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("p", { role: "status", "aria-live": "polite", children: passedThreshold ? "Correct" : "Try again" }) : null
+  ] });
+}
+var DragAndDropInnerForwarded = (0, import_react16.forwardRef)(DragAndDropInner);
+var DragAndDrop = (0, import_react16.forwardRef)(function DragAndDrop2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(AssessmentLessonGuard, { blockLabel: "DragAndDrop", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DragAndDropInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+
+// src/blocks/AssessmentSequence.tsx
+var import_react22 = __toESM(require("react"), 1);
+var import_core17 = require("@lessonkit/core");
+
+// src/compound/useCompoundShell.ts
+var import_react20 = require("react");
+var import_core15 = require("@lessonkit/core");
+
+// src/compound/useCompoundNavigation.ts
+var import_react17 = require("react");
+function useCompoundNavigation(pageCount, index, setIndex) {
+  const goNext = (0, import_react17.useCallback)(() => {
+    if (pageCount < 1) return;
+    setIndex((i) => Math.min(i + 1, pageCount - 1));
+  }, [pageCount, setIndex]);
+  const goPrev = (0, import_react17.useCallback)(() => {
+    setIndex((i) => Math.max(i - 1, 0));
+  }, [setIndex]);
+  const clampedIndex = pageCount < 1 ? 0 : Math.min(index, pageCount - 1);
+  return {
+    index: clampedIndex,
+    setIndex,
+    goNext,
+    goPrev,
+    progress: { current: pageCount < 1 ? 0 : clampedIndex + 1, total: pageCount }
+  };
+}
+
+// src/compound/useCompoundPersistence.ts
+var import_react19 = require("react");
+var import_core14 = require("@lessonkit/core");
+
+// src/compound/resumeChildHandles.ts
+function filterRegisteredChildStates(handles, childStates) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(childStates)) {
+    if (handles.has(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function resumeChildHandles(handles, childStates, opts) {
+  const pendingKeys = Object.keys(childStates);
+  const alreadyResumed = opts?.alreadyResumed;
+  if (opts?.waitForHandles && pendingKeys.length > 0) {
+    if (handles.size === 0) return false;
+    const registeredPending = pendingKeys.filter((k) => handles.has(k));
+    if (registeredPending.length === 0) {
+      return false;
+    }
+    if (registeredPending.length < pendingKeys.length) {
+      for (const key of registeredPending) {
+        if (alreadyResumed?.has(key)) continue;
+        const handle = handles.get(key);
+        const child = childStates[key];
+        if (handle?.resume && child) {
+          handle.resume(child);
+          alreadyResumed?.add(key);
+        }
+      }
+      return false;
+    }
+  }
+  for (const [checkId, handle] of handles) {
+    if (alreadyResumed?.has(checkId)) continue;
+    const child = childStates[checkId];
+    if (child && handle.resume) {
+      handle.resume(child);
+      alreadyResumed?.add(checkId);
+    }
+  }
+  return true;
+}
+
+// src/compound/useCompoundResume.ts
+var import_react18 = require("react");
+var import_core12 = require("@lessonkit/core");
+var import_core13 = require("@lessonkit/core");
+var warnedCompoundPersistFailure = false;
+function warnCompoundPersistFailure() {
+  if (warnedCompoundPersistFailure || !isDevEnvironment()) return;
+  warnedCompoundPersistFailure = true;
+  console.warn(
+    "[lessonkit] compound resume state could not be saved to sessionStorage (quota or privacy mode); progress may be lost on reload."
+  );
+}
+function useCompoundResume(opts) {
+  const lessonkitCtx = (0, import_react18.useContext)(LessonkitContext);
+  const storageRef = (0, import_react18.useRef)(opts.storage ?? lessonkitCtx?.storage ?? (0, import_core13.createSessionStoragePort)());
+  const resumedRef = (0, import_react18.useRef)(false);
+  const resumeKeyRef = (0, import_react18.useRef)("");
+  const prevEnabledRef = (0, import_react18.useRef)(opts.enabled);
+  (0, import_react18.useEffect)(() => {
+    storageRef.current = opts.storage ?? lessonkitCtx?.storage ?? (0, import_core13.createSessionStoragePort)();
+  }, [opts.storage, lessonkitCtx?.storage]);
+  (0, import_react18.useEffect)(() => {
+    if (!prevEnabledRef.current && opts.enabled) {
+      resumedRef.current = false;
+    }
+    prevEnabledRef.current = opts.enabled;
+    const key = `${opts.courseId ?? ""}:${opts.compoundId}`;
+    if (resumeKeyRef.current !== key) {
+      resumeKeyRef.current = key;
+      resumedRef.current = false;
+    }
+    if (!opts.enabled || !opts.courseId || resumedRef.current) return;
+    const saved = (0, import_core12.loadCompoundState)(storageRef.current, opts.courseId, opts.compoundId);
+    if (saved) {
+      resumedRef.current = true;
+      opts.onResume?.(saved);
+    }
+  }, [opts.enabled, opts.courseId, opts.compoundId, opts.onResume]);
+  return (0, import_react18.useCallback)(
+    (state) => {
+      if (!opts.enabled || !opts.courseId) return;
+      const persisted = (0, import_core12.saveCompoundState)(storageRef.current, opts.courseId, opts.compoundId, state);
+      if (!persisted) warnCompoundPersistFailure();
+    },
+    [opts.enabled, opts.courseId, opts.compoundId]
+  );
+}
+
+// src/compound/useCompoundPersistence.ts
+function readCompoundInitialIndex(courseId, compoundId, pageCount, enabled, storage = (0, import_core14.createSessionStoragePort)()) {
+  if (!enabled || !courseId || pageCount < 1) return 0;
+  const saved = (0, import_core14.loadCompoundState)(storage, courseId, compoundId);
+  if (!saved) return 0;
+  return (0, import_core14.clampCompoundPageIndex)(saved.activePageIndex, pageCount);
+}
+function stripOrphanChildStates(handles, childStates) {
+  return filterRegisteredChildStates(handles, childStates);
+}
+function useCompoundPersistence(opts) {
+  const lessonkitCtx = (0, import_react19.useContext)(LessonkitContext);
+  const storage = opts.storage ?? lessonkitCtx?.storage ?? (0, import_core14.createSessionStoragePort)();
+  const ctx = useCompoundRegistry();
+  const handlesVersion = useCompoundHandlesVersion();
+  const bridgeRef = useCompoundHydrationBridgeRef();
+  const pendingChildResumeRef = (0, import_react19.useRef)(null);
+  const resumedChildKeysRef = (0, import_react19.useRef)(/* @__PURE__ */ new Set());
+  const loadedChildStatesRef = (0, import_react19.useRef)({});
+  const skipSaveUntilHydratedRef = (0, import_react19.useRef)(false);
+  const hydrationKeyRef = (0, import_react19.useRef)("");
+  const hydrationInitRef = (0, import_react19.useRef)(false);
+  const hydrationKey = `${opts.courseId ?? ""}:${opts.compoundId}`;
+  if (hydrationKeyRef.current !== hydrationKey) {
+    hydrationKeyRef.current = hydrationKey;
+    hydrationInitRef.current = false;
+    loadedChildStatesRef.current = {};
+    skipSaveUntilHydratedRef.current = false;
+    pendingChildResumeRef.current = null;
+    resumedChildKeysRef.current = /* @__PURE__ */ new Set();
+  }
+  if (!hydrationInitRef.current && opts.enabled && opts.courseId) {
+    hydrationInitRef.current = true;
+    const saved = (0, import_core14.loadCompoundState)(storage, opts.courseId, opts.compoundId);
+    if (saved && Object.keys(saved.childStates).length > 0) {
+      loadedChildStatesRef.current = { ...saved.childStates };
+      skipSaveUntilHydratedRef.current = true;
+      pendingChildResumeRef.current = saved;
+    }
+  }
+  const buildState = (0, import_react19.useCallback)(() => {
+    const childStates = {
+      ...loadedChildStatesRef.current
+    };
+    if (ctx) {
+      for (const [checkId, entry] of ctx.getRegisteredHandles()) {
+        const handle = entry.handle;
+        if (handle.getCurrentState) {
+          childStates[checkId] = handle.getCurrentState();
+          delete loadedChildStatesRef.current[checkId];
+        }
+      }
+    }
+    return (0, import_core14.createCompoundResumeState)({
+      activePageIndex: (0, import_core14.clampCompoundPageIndex)(opts.index, opts.pageCount),
+      childStates
+    });
+  }, [ctx, opts.index, opts.pageCount]);
+  const buildStateRef = (0, import_react19.useRef)(buildState);
+  buildStateRef.current = buildState;
+  const transformStateRef = (0, import_react19.useRef)(opts.transformState);
+  transformStateRef.current = opts.transformState;
+  const persistNowRef = (0, import_react19.useRef)(() => {
+  });
+  const finalizeHydration = (0, import_react19.useCallback)(
+    (childStates) => {
+      loadedChildStatesRef.current = {
+        ...loadedChildStatesRef.current,
+        ...childStates
+      };
+      skipSaveUntilHydratedRef.current = false;
+      pendingChildResumeRef.current = null;
+      queueMicrotask(() => persistNowRef.current());
+    },
+    []
+  );
+  const applyPendingChildResume = (0, import_react19.useCallback)(() => {
+    const pending = pendingChildResumeRef.current;
+    if (!pending || !ctx) return;
+    const handles = ctx.getHandles();
+    const applied = resumeChildHandles(handles, pending.childStates, {
+      waitForHandles: true,
+      alreadyResumed: resumedChildKeysRef.current
+    });
+    if (!applied) {
+      if (handles.size === 0) {
+        const registeredOnly2 = stripOrphanChildStates(handles, pending.childStates);
+        resumeChildHandles(handles, registeredOnly2, {
+          alreadyResumed: resumedChildKeysRef.current
+        });
+        finalizeHydration(registeredOnly2);
+        return;
+      }
+      const handlesAtWait = handles.size;
+      queueMicrotask(() => {
+        if (pendingChildResumeRef.current !== pending) return;
+        const handlesNow = ctx.getHandles();
+        if (handlesNow.size !== handlesAtWait) return;
+        const registeredOnly2 = stripOrphanChildStates(handlesNow, pending.childStates);
+        resumeChildHandles(handlesNow, registeredOnly2, {
+          alreadyResumed: resumedChildKeysRef.current
+        });
+        finalizeHydration(registeredOnly2);
+      });
+      return;
+    }
+    const registeredOnly = stripOrphanChildStates(handles, pending.childStates);
+    finalizeHydration(registeredOnly);
+  }, [ctx, finalizeHydration]);
+  const saveResume = useCompoundResume({
+    courseId: opts.courseId,
+    compoundId: opts.compoundId,
+    enabled: opts.enabled,
+    storage,
+    onResume: (state) => {
+      const clamped = (0, import_core14.clampCompoundPageIndex)(state.activePageIndex, opts.pageCount);
+      loadedChildStatesRef.current = { ...state.childStates };
+      skipSaveUntilHydratedRef.current = Object.keys(state.childStates).length > 0;
+      opts.setIndex(clamped);
+      resumedChildKeysRef.current = /* @__PURE__ */ new Set();
+      pendingChildResumeRef.current = { ...state, activePageIndex: clamped, childStates: state.childStates };
+      queueMicrotask(() => applyPendingChildResume());
+    }
+  });
+  const persistNow = (0, import_react19.useCallback)(() => {
+    if (!opts.enabled || !opts.courseId) return;
+    if (skipSaveUntilHydratedRef.current) return;
+    const built = buildStateRef.current();
+    const state = transformStateRef.current ? transformStateRef.current(built) : built;
+    saveResume(state);
+  }, [opts.enabled, opts.courseId, saveResume]);
+  (0, import_react19.useEffect)(() => {
+    persistNowRef.current = persistNow;
+  }, [persistNow]);
+  const notifyImperativeResume = (0, import_react19.useCallback)(
+    (state) => {
+      const clamped = (0, import_core14.clampCompoundPageIndex)(state.activePageIndex, opts.pageCount);
+      loadedChildStatesRef.current = { ...state.childStates };
+      skipSaveUntilHydratedRef.current = Object.keys(state.childStates).length > 0;
+      opts.setIndex(clamped);
+      resumedChildKeysRef.current = /* @__PURE__ */ new Set();
+      pendingChildResumeRef.current = { ...state, activePageIndex: clamped, childStates: state.childStates };
+      queueMicrotask(() => applyPendingChildResume());
+    },
+    [opts.pageCount, opts.setIndex, applyPendingChildResume]
+  );
+  (0, import_react19.useEffect)(() => {
+    if (!bridgeRef) return;
+    bridgeRef.current = { notifyImperativeResume };
+    return () => {
+      if (bridgeRef.current?.notifyImperativeResume === notifyImperativeResume) {
+        bridgeRef.current = null;
+      }
+    };
+  }, [bridgeRef, notifyImperativeResume]);
+  (0, import_react19.useEffect)(() => {
+    applyPendingChildResume();
+  }, [opts.index, handlesVersion, applyPendingChildResume]);
+  (0, import_react19.useEffect)(() => {
+    persistNow();
+  }, [persistNow, opts.index, opts.pageCount, handlesVersion]);
+  (0, import_react19.useEffect)(() => {
+    if (!opts.enabled || !opts.courseId || typeof document === "undefined") return;
+    const flushOnExit = () => {
+      if (document.visibilityState === "hidden") persistNow();
+    };
+    document.addEventListener("visibilitychange", flushOnExit);
+    window.addEventListener("pagehide", flushOnExit);
+    return () => {
+      document.removeEventListener("visibilitychange", flushOnExit);
+      window.removeEventListener("pagehide", flushOnExit);
+    };
+  }, [opts.enabled, opts.courseId, persistNow]);
+}
+
+// src/compound/useCompoundShell.ts
+function useCompoundShell(opts) {
+  const ctx = useCompoundRegistry();
+  useCompoundPersistence({
+    courseId: opts.courseId,
+    compoundId: opts.compoundId,
+    pageCount: opts.pageCount,
+    index: opts.index,
+    setIndex: opts.setIndex,
+    enabled: opts.persistEnabled,
+    storage: opts.storage,
+    transformState: opts.transformState
+  });
+  const { goNext, goPrev, progress } = useCompoundNavigation(opts.pageCount, opts.index, opts.setIndex);
+  const visibleIndex = (0, import_core15.clampCompoundPageIndex)(opts.index, opts.pageCount);
+  useCompoundHandleRef(opts.ref, {
+    activePageIndex: visibleIndex,
+    setActivePageIndex: opts.setIndex,
+    getHandles: () => ctx?.getHandles() ?? /* @__PURE__ */ new Map(),
+    getRegisteredHandles: () => ctx?.getRegisteredHandles() ?? /* @__PURE__ */ new Map(),
+    pageCount: opts.pageCount,
+    enableSolutionsButton: opts.enableSolutionsButton
+  });
+  return { visibleIndex, goNext, goPrev, progress, ctx };
+}
+function useCompoundInitialIndex(opts) {
+  return (0, import_react20.useMemo)(
+    () => readCompoundInitialIndex(
+      opts.courseId,
+      opts.compoundId,
+      opts.pageCount,
+      opts.persistEnabled,
+      opts.storage
+    ),
+    [opts.courseId, opts.compoundId, opts.pageCount, opts.persistEnabled, opts.storage]
+  );
+}
+
+// src/compound/validateChildren.ts
+var import_react21 = __toESM(require("react"), 1);
+var import_core16 = require("@lessonkit/core");
+
+// src/compound/blockType.ts
+var LESSONKIT_BLOCK_TYPE = /* @__PURE__ */ Symbol.for("lessonkit.blockType");
+function setLessonkitBlockType(component, blockType) {
+  component[LESSONKIT_BLOCK_TYPE] = blockType;
+  if (!component.displayName) {
+    component.displayName = blockType;
+  }
+  return component;
+}
+function getLessonkitBlockType(component) {
+  if (!component || typeof component !== "object" && typeof component !== "function") {
+    return void 0;
+  }
+  const typed = component;
+  return typed[LESSONKIT_BLOCK_TYPE] ?? typed.displayName;
+}
+
+// src/compound/validateChildren.ts
+var warnedPairs = /* @__PURE__ */ new Set();
+var COMPOUND_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+  "Page",
+  "InteractiveBook",
+  "Slide",
+  "SlideDeck",
+  "TimedCue",
+  "InteractiveVideo",
+  "AssessmentSequence"
+]);
+function warnOrThrow(msg, strict) {
+  if (strict) throw new Error(msg);
+  if (!warnedPairs.has(msg)) {
+    warnedPairs.add(msg);
+    console.warn(msg);
+  }
+}
+function validateNode(parent, node, depth, strict) {
+  import_react21.default.Children.forEach(node, (child) => {
+    if (!import_react21.default.isValidElement(child)) return;
+    const blockType = getLessonkitBlockType(child.type);
+    if (!blockType) {
+      if (child.props && typeof child.props === "object" && "children" in child.props) {
+        validateNode(parent, child.props.children, depth, strict);
+      }
+      return;
+    }
+    if (!(0, import_core16.isChildTypeAllowed)(parent, blockType)) {
+      const key = `${parent}:${blockType}`;
+      if (!warnedPairs.has(key)) {
+        warnedPairs.add(key);
+        const msg = `[lessonkit] Block "${blockType}" is not in the allowlist for "${parent}"`;
+        if (strict) throw new Error(msg);
+        console.warn(msg);
+      }
+    }
+    if (COMPOUND_CONTAINER_TYPES.has(blockType)) {
+      const maxDepth = import_core16.COMPOUND_MAX_NESTING_DEPTH[parent];
+      if (depth >= maxDepth) {
+        warnOrThrow(
+          `[lessonkit] Block "${blockType}" exceeds max nesting depth (${maxDepth}) for "${parent}"`,
+          strict
+        );
+      }
+      const nestedParent = blockType;
+      validateNode(nestedParent, child.props.children, depth + 1, strict);
+    } else if (blockType === "Accordion") {
+      const sections = child.props.sections;
+      if (sections) validateAccordionSections(sections, strict);
+    } else if (child.props && typeof child.props === "object" && "children" in child.props) {
+      validateSubtreeForForbidden(
+        child.props.children,
+        import_core16.ACCORDION_FORBIDDEN_CHILD_TYPES,
+        strict
+      );
+    }
+  });
+}
+function validateSubtreeForForbidden(node, forbidden, strict) {
+  import_react21.default.Children.forEach(node, (child) => {
+    if (!import_react21.default.isValidElement(child)) return;
+    const blockType = getLessonkitBlockType(child.type);
+    if (blockType && forbidden.includes(blockType)) {
+      warnOrThrow(`[lessonkit] Block "${blockType}" must not nest inside Accordion`, strict);
+    }
+    if (blockType === "Accordion") {
+      const sections = child.props.sections;
+      if (sections) validateAccordionSections(sections, strict);
+      return;
+    }
+    if (child.props && typeof child.props === "object" && "children" in child.props) {
+      validateSubtreeForForbidden(
+        child.props.children,
+        forbidden,
+        strict
+      );
+    }
+  });
+}
+function validateAccordionSections(sections, strict) {
+  if (!isDevEnvironment() && !strict) return;
+  for (const section of sections) {
+    validateSubtreeForForbidden(section.content, import_core16.ACCORDION_FORBIDDEN_CHILD_TYPES, strict);
+  }
+}
+function validateCompoundChildren(parent, children, strict) {
+  if (!isDevEnvironment() && !strict) return;
+  validateNode(parent, children, 0, strict);
+}
+
+// src/compound/warnPersistence.ts
+var DEFAULT_ASSESSMENT_SEQUENCE_COMPOUND_ID = "assessment-sequence";
+function warnSharedCompoundStorageKey(opts) {
+  if (!opts.persistEnabled || opts.hasExplicitBlockId || !isDevEnvironment()) return;
+  console.warn(
+    `[lessonkit] <${opts.componentName}> without blockId shares one sessionStorage key when persistCompoundState is enabled; set a unique blockId per instance.`
+  );
+}
+
+// src/blocks/AssessmentSequence.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var AssessmentSequenceInner = (0, import_react22.forwardRef)(
+  function AssessmentSequenceInner2(props, ref) {
+    const { compoundId, childArray, index, setIndex, persistEnabled } = props;
+    const sequential = props.sequential !== false;
+    const { config } = useLessonkit();
+    const { visibleIndex, goNext, goPrev, progress } = useCompoundShell({
+      courseId: config.courseId,
+      compoundId,
+      pageCount: childArray.length,
+      index,
+      setIndex,
+      persistEnabled,
+      ref,
+      enableSolutionsButton: props.enableSolutionsButton
+    });
+    validateCompoundChildren("AssessmentSequence", props.children);
+    if (!sequential) {
+      return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("section", { "aria-label": "Assessment sequence", "data-testid": "assessment-sequence", children: props.children });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("section", { "aria-label": "Assessment sequence", "data-testid": "assessment-sequence", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("p", { children: [
+        "Question ",
+        progress.current,
+        " of ",
+        progress.total
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-testid": "assessment-sequence-step", children: childArray.map((child, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { hidden: i !== visibleIndex, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(CompoundPageIndexProvider, { pageIndex: i, children: child }) }, child.key ?? i)) }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("nav", { "aria-label": "Sequence navigation", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          "button",
+          {
+            type: "button",
+            "data-testid": "sequence-prev",
+            disabled: visibleIndex === 0 || childArray.length === 0,
+            onClick: goPrev,
+            children: "Previous"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          "button",
+          {
+            type: "button",
+            "data-testid": "sequence-next",
+            disabled: visibleIndex >= childArray.length - 1 || childArray.length === 0,
+            onClick: goNext,
+            children: "Next"
+          }
+        )
+      ] })
+    ] });
+  }
+);
+var AssessmentSequence = (0, import_react22.forwardRef)(
+  function AssessmentSequence2(props, ref) {
+    const reactInstanceId = (0, import_react22.useId)();
+    const autoCompoundIdRef = (0, import_react22.useRef)(null);
+    if (!props.blockId && !autoCompoundIdRef.current) {
+      autoCompoundIdRef.current = (0, import_core17.deriveId)(`assessment-sequence-${reactInstanceId}`);
+    }
+    const compoundId = (0, import_react22.useMemo)(
+      () => props.blockId ? normalizeComponentId(props.blockId, "blockId") : autoCompoundIdRef.current ?? DEFAULT_ASSESSMENT_SEQUENCE_COMPOUND_ID,
+      [props.blockId]
+    );
+    const childArray = import_react22.default.Children.toArray(props.children).filter(
+      import_react22.default.isValidElement
+    );
+    const { config, storage } = useLessonkit();
+    const persistEnabled = config.session?.persistCompoundState !== false;
+    (0, import_react22.useEffect)(() => {
+      warnSharedCompoundStorageKey({
+        persistEnabled,
+        hasExplicitBlockId: Boolean(props.blockId),
+        componentName: "AssessmentSequence"
+      });
+    }, [persistEnabled, props.blockId]);
+    const initialIndex = useCompoundInitialIndex({
+      courseId: config.courseId,
+      compoundId,
+      pageCount: childArray.length,
+      persistEnabled,
+      storage
+    });
+    const [index, setIndex] = (0, import_react22.useState)(initialIndex);
+    const setIndexStable = (0, import_react22.useCallback)((i) => setIndex(i), []);
+    (0, import_react22.useEffect)(() => {
+      setIndex(initialIndex);
+    }, [config.courseId, compoundId, initialIndex]);
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      AssessmentSequenceInner,
+      {
+        ...props,
+        ref,
+        compoundId,
+        childArray,
+        index,
+        setIndex,
+        persistEnabled
+      }
+    ) });
+  }
+);
+setLessonkitBlockType(AssessmentSequence, "AssessmentSequence");
+
+// src/blocks/Text.tsx
+var import_react23 = require("react");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+function Text(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("p", { "data-lk-block-id": props.blockId, "data-testid": props.blockId ? `text-${props.blockId}` : "text", children: props.children });
+}
+setLessonkitBlockType(Text, "Text");
+
+// src/blocks/Heading.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function Heading(props) {
+  const Tag = `h${props.level}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Tag, { "data-lk-block-id": props.blockId, "data-testid": props.blockId ? `heading-${props.blockId}` : "heading", children: props.children });
+}
+setLessonkitBlockType(Heading, "Heading");
+
+// src/blocks/Image.tsx
+var import_jsx_runtime14 = require("react/jsx-runtime");
+function Image(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    "img",
+    {
+      src: props.src,
+      alt: props.alt,
+      "data-lk-block-id": props.blockId,
+      "data-testid": props.blockId ? `image-${props.blockId}` : "image",
+      style: { maxWidth: "100%", height: "auto" }
+    }
+  );
+}
+setLessonkitBlockType(Image, "Image");
+
+// src/blocks/Video.tsx
+var import_react24 = require("react");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function Video(props) {
+  const blockId = (0, import_react24.useMemo)(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("section", { "aria-label": props.title ?? "Video", "data-lk-block-id": blockId, "data-testid": "video", children: [
+    props.title ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("h3", { "data-testid": "video-title", children: props.title }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      "video",
+      {
+        controls: true,
+        preload: "metadata",
+        poster: props.poster,
+        src: props.src,
+        "data-testid": "video-player",
+        style: { maxWidth: "100%" },
+        children: props.captions ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("track", { kind: "captions", src: props.captions, srcLang: "en", label: "Captions", default: true }) : null
+      }
+    )
+  ] });
+}
+setLessonkitBlockType(Video, "Video");
+
+// src/blocks/Page.tsx
+var import_react25 = require("react");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+function Page(props) {
+  validateCompoundChildren("Page", props.children);
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  (0, import_react25.useEffect)(() => {
+    if (props.hidden || !lessonId || props.parentType) return;
+    track(
+      "compound_page_viewed",
+      {
+        blockId: props.blockId,
+        pageIndex: props.pageIndex ?? 0,
+        parentType: props.parentType
+      },
+      { lessonId }
+    );
+  }, [props.hidden, props.pageIndex, props.parentType, props.blockId, lessonId, track]);
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(
+    "section",
+    {
+      "aria-label": props.title ?? "Page",
+      "data-lk-block-id": props.blockId,
+      "data-testid": `page-${props.blockId}`,
+      hidden: props.hidden ? true : void 0,
+      children: [
+        props.title ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("h3", { children: props.title }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(CompoundPageIndexProvider, { pageIndex: props.pageIndex ?? 0, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { children: props.children }) })
+      ]
+    }
+  );
+}
+setLessonkitBlockType(Page, "Page");
+
+// src/blocks/InteractiveBook.tsx
+var import_react26 = __toESM(require("react"), 1);
+var import_jsx_runtime17 = require("react/jsx-runtime");
+var InteractiveBookInner = (0, import_react26.forwardRef)(
+  function InteractiveBookInner2(props, ref) {
+    const { blockId, pages, index, setIndex, persistEnabled } = props;
+    validateCompoundChildren("InteractiveBook", pages);
+    const { config, track } = useLessonkit();
+    const lessonId = useEnclosingLessonId();
+    const { visibleIndex, goNext, goPrev, progress, ctx } = useCompoundShell({
+      courseId: config.courseId,
+      compoundId: blockId,
+      pageCount: pages.length,
+      index,
+      setIndex,
+      persistEnabled,
+      ref
+    });
+    const pageTitles = (0, import_react26.useMemo)(
+      () => pages.map((page) => page.props.title),
+      [pages]
+    );
+    (0, import_react26.useEffect)(() => {
+      if (!lessonId || pages.length === 0) return;
+      track(
+        "book_page_viewed",
+        {
+          blockId,
+          pageIndex: visibleIndex,
+          pageTitle: pageTitles[visibleIndex]
+        },
+        { lessonId }
+      );
+    }, [visibleIndex, blockId, lessonId, pages.length, pageTitles, track]);
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("section", { "aria-label": props.title, "data-testid": "interactive-book", "data-lk-block-id": blockId, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("h3", { children: props.title }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("p", { children: [
+        "Page ",
+        progress.current,
+        " of ",
+        progress.total
+      ] }),
+      props.showBookScore && ctx ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("p", { "data-testid": "book-score", children: [
+        "Score: ",
+        Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getScore(), 0),
+        " /",
+        " ",
+        Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getMaxScore(), 0)
+      ] }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-testid": "interactive-book-page", children: pages.map(
+        (page, i) => import_react26.default.cloneElement(page, {
+          key: page.key ?? page.props.blockId,
+          hidden: i !== visibleIndex,
+          pageIndex: i,
+          parentType: "InteractiveBook"
+        })
+      ) }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("nav", { "aria-label": "Book navigation", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+          "button",
+          {
+            type: "button",
+            "data-testid": "book-prev",
+            disabled: visibleIndex === 0 || pages.length === 0,
+            onClick: goPrev,
+            children: "Previous"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+          "button",
+          {
+            type: "button",
+            "data-testid": "book-next",
+            disabled: visibleIndex >= pages.length - 1 || pages.length === 0,
+            onClick: goNext,
+            children: "Next"
+          }
+        )
+      ] })
+    ] });
+  }
+);
+var InteractiveBook = (0, import_react26.forwardRef)(function InteractiveBook2(props, ref) {
+  const blockId = (0, import_react26.useMemo)(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
+  const pages = import_react26.default.Children.toArray(props.children).filter(
+    import_react26.default.isValidElement
+  );
+  const { config, storage } = useLessonkit();
+  const persistEnabled = config.session?.persistCompoundState !== false;
+  const initialIndex = useCompoundInitialIndex({
+    courseId: config.courseId,
+    compoundId: blockId,
+    pageCount: pages.length,
+    persistEnabled,
+    storage
+  });
+  const [index, setIndex] = (0, import_react26.useState)(initialIndex);
+  const setIndexStable = (0, import_react26.useCallback)((i) => setIndex(i), []);
+  (0, import_react26.useEffect)(() => {
+    setIndex(initialIndex);
+  }, [config.courseId, blockId, initialIndex]);
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    InteractiveBookInner,
+    {
+      ...props,
+      ref,
+      blockId,
+      pages,
+      index,
+      setIndex,
+      persistEnabled
+    }
+  ) });
+});
+setLessonkitBlockType(InteractiveBook, "InteractiveBook");
+
+// src/blocks/Slide.tsx
+var import_react27 = require("react");
+var import_jsx_runtime18 = require("react/jsx-runtime");
+function Slide(props) {
+  validateCompoundChildren("Slide", props.children);
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  (0, import_react27.useEffect)(() => {
+    if (props.hidden || !lessonId || props.parentType) return;
+    track(
+      "compound_page_viewed",
+      {
+        blockId: props.blockId,
+        pageIndex: props.slideIndex ?? 0,
+        parentType: props.parentType
+      },
+      { lessonId }
+    );
+  }, [props.hidden, props.slideIndex, props.parentType, props.blockId, lessonId, track]);
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(
+    "section",
+    {
+      "aria-label": props.title ?? "Slide",
+      "data-lk-block-id": props.blockId,
+      "data-testid": `slide-${props.blockId}`,
+      hidden: props.hidden ? true : void 0,
+      children: [
+        props.title ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("h3", { children: props.title }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(CompoundPageIndexProvider, { pageIndex: props.slideIndex ?? 0, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { children: props.children }) })
+      ]
+    }
+  );
+}
+setLessonkitBlockType(Slide, "Slide");
+
+// src/blocks/SlideDeck.tsx
+var import_react29 = __toESM(require("react"), 1);
+
+// src/compound/useCompoundKeyboardNav.ts
+var import_react28 = require("react");
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT", "BUTTON"]);
+function isEditableTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  if (INTERACTIVE_TAGS.has(target.tagName)) return true;
+  if (target.isContentEditable) return true;
+  if (target.closest("[role='slider'], [role='listbox'], [data-lk-assessment-interactive]")) {
+    return true;
+  }
+  return false;
+}
+function useCompoundKeyboardNav(opts) {
+  const { containerRef, visibleIndex, pageCount, goNext, goPrev, setIndex } = opts;
+  (0, import_react28.useEffect)(() => {
+    const el = containerRef.current;
+    if (!el || pageCount === 0) return;
+    const onKeyDown = (event) => {
+      if (!el.contains(document.activeElement) && document.activeElement !== document.body) {
+        return;
+      }
+      if (isEditableTarget(event.target)) return;
+      switch (event.key) {
+        case "ArrowRight":
+        case "ArrowDown":
+          if (visibleIndex < pageCount - 1) {
+            event.preventDefault();
+            goNext();
+          }
+          break;
+        case "ArrowLeft":
+        case "ArrowUp":
+          if (visibleIndex > 0) {
+            event.preventDefault();
+            goPrev();
+          }
+          break;
+        case "Home":
+          if (visibleIndex !== 0) {
+            event.preventDefault();
+            setIndex(0);
+          }
+          break;
+        case "End":
+          if (visibleIndex !== pageCount - 1) {
+            event.preventDefault();
+            setIndex(pageCount - 1);
+          }
+          break;
+        default:
+          break;
+      }
+    };
+    el.addEventListener("keydown", onKeyDown);
+    return () => el.removeEventListener("keydown", onKeyDown);
+  }, [containerRef, visibleIndex, pageCount, goNext, goPrev, setIndex]);
+}
+
+// src/blocks/SlideDeck.tsx
+var import_jsx_runtime19 = require("react/jsx-runtime");
+var SlideDeckInner = (0, import_react29.forwardRef)(function SlideDeckInner2(props, ref) {
+  const { blockId, slides, index, setIndex, persistEnabled } = props;
+  validateCompoundChildren("SlideDeck", slides);
+  const { config, track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const containerRef = (0, import_react29.useRef)(null);
+  const { visibleIndex, goNext, goPrev, progress, ctx } = useCompoundShell({
+    courseId: config.courseId,
+    compoundId: blockId,
+    pageCount: slides.length,
+    index,
+    setIndex,
+    persistEnabled,
+    ref
+  });
+  const setIndexStable = (0, import_react29.useCallback)((i) => setIndex(i), [setIndex]);
+  useCompoundKeyboardNav({
+    containerRef,
+    visibleIndex,
+    pageCount: slides.length,
+    goNext,
+    goPrev,
+    setIndex: setIndexStable
+  });
+  const slideTitles = (0, import_react29.useMemo)(
+    () => slides.map((slide) => slide.props.title),
+    [slides]
+  );
+  (0, import_react29.useEffect)(() => {
+    if (!lessonId || slides.length === 0) return;
+    track(
+      "slide_viewed",
+      {
+        blockId,
+        slideIndex: visibleIndex,
+        slideTitle: slideTitles[visibleIndex]
+      },
+      { lessonId }
+    );
+  }, [visibleIndex, blockId, lessonId, slides.length, slideTitles, track]);
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(
+    "section",
+    {
+      ref: containerRef,
+      tabIndex: -1,
+      "aria-label": props.title,
+      "data-testid": "slide-deck",
+      "data-lk-block-id": blockId,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("h3", { children: props.title }),
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("p", { children: [
+          "Slide ",
+          progress.current,
+          " of ",
+          progress.total
+        ] }),
+        props.showDeckScore && ctx ? /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("p", { "data-testid": "deck-score", children: [
+          "Score: ",
+          Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getScore(), 0),
+          " /",
+          " ",
+          Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getMaxScore(), 0)
+        ] }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { "data-testid": "slide-deck-slide", children: slides.map(
+          (slide, i) => import_react29.default.cloneElement(slide, {
+            key: slide.key ?? slide.props.blockId,
+            hidden: i !== visibleIndex,
+            slideIndex: i,
+            parentType: "SlideDeck"
+          })
+        ) }),
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("nav", { "aria-label": "Slide navigation", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-testid": "slide-prev",
+              disabled: visibleIndex === 0 || slides.length === 0,
+              onClick: goPrev,
+              children: "Previous slide"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-testid": "slide-next",
+              disabled: visibleIndex >= slides.length - 1 || slides.length === 0,
+              onClick: goNext,
+              children: "Next slide"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+});
+var SlideDeck = (0, import_react29.forwardRef)(function SlideDeck2(props, ref) {
+  const blockId = (0, import_react29.useMemo)(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
+  const slides = import_react29.default.Children.toArray(props.children).filter(
+    import_react29.default.isValidElement
+  );
+  const { config, storage } = useLessonkit();
+  const persistEnabled = config.session?.persistCompoundState !== false;
+  const initialIndex = useCompoundInitialIndex({
+    courseId: config.courseId,
+    compoundId: blockId,
+    pageCount: slides.length,
+    persistEnabled,
+    storage
+  });
+  const [index, setIndex] = (0, import_react29.useState)(initialIndex);
+  const setIndexStable = (0, import_react29.useCallback)((i) => setIndex(i), []);
+  (0, import_react29.useEffect)(() => {
+    setIndex(initialIndex);
+  }, [config.courseId, blockId, initialIndex]);
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+    SlideDeckInner,
+    {
+      ...props,
+      ref,
+      blockId,
+      slides,
+      index,
+      setIndex,
+      persistEnabled
+    }
+  ) });
+});
+setLessonkitBlockType(SlideDeck, "SlideDeck");
+
+// src/blocks/TimedCue.tsx
+var import_react30 = __toESM(require("react"), 1);
+var import_accessibility = require("@lessonkit/accessibility");
+var import_jsx_runtime20 = require("react/jsx-runtime");
+function TimedCue(props) {
+  validateCompoundChildren("TimedCue", props.children, true);
+  const child = import_react30.default.Children.only(props.children);
+  const overlayRef = (0, import_react30.useRef)(null);
+  (0, import_react30.useEffect)(() => {
+    if (props.hidden || !overlayRef.current) return;
+    const trap = (0, import_accessibility.trapFocus)(overlayRef.current, { restoreFocus: false });
+    trap.activate();
+    const firstFocusable = overlayRef.current.querySelector(
+      'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+    );
+    firstFocusable?.focus();
+    return () => trap.deactivate();
+  }, [props.hidden, props.cueIndex]);
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(
+    "div",
+    {
+      ref: overlayRef,
+      role: "dialog",
+      "aria-modal": props.hidden ? void 0 : true,
+      "aria-hidden": props.hidden ? true : void 0,
+      hidden: props.hidden ? true : void 0,
+      "aria-label": props.label ?? `Interaction at ${props.atSeconds} seconds`,
+      "data-testid": `timed-cue-${props.cueIndex ?? 0}`,
+      "data-lk-cue-at": props.atSeconds,
+      className: "lk-timed-cue-overlay",
+      style: {
+        position: "relative",
+        zIndex: 2,
+        background: "var(--lk-surface, #fff)",
+        padding: "1rem",
+        border: "1px solid var(--lk-border, #ccc)",
+        marginTop: "0.5rem"
+      },
+      children: [
+        props.hidden ? null : props.label ? /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("p", { "data-testid": "timed-cue-label", children: props.label }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(CompoundPageIndexProvider, { pageIndex: props.cueIndex ?? 0, children: child })
+      ]
+    }
+  );
+}
+setLessonkitBlockType(TimedCue, "TimedCue");
+
+// src/blocks/InteractiveVideo.tsx
+var import_react31 = __toESM(require("react"), 1);
+var import_core19 = require("@lessonkit/core");
+
+// src/compound/useCompoundVideoShell.ts
+var import_core18 = require("@lessonkit/core");
+var IV_META_KEY = "__lk_iv__";
+function readInteractiveVideoMeta(childStates) {
+  const raw = childStates[IV_META_KEY];
+  if (!raw || typeof raw !== "object") return null;
+  const currentTime = typeof raw.currentTime === "number" ? raw.currentTime : 0;
+  const completedCueIndices = Array.isArray(raw.completedCueIndices) ? raw.completedCueIndices.filter((n) => typeof n === "number") : [];
+  return { currentTime, completedCueIndices };
+}
+function mergeVideoMetaIntoState(state, meta) {
+  return {
+    ...state,
+    childStates: {
+      ...state.childStates,
+      [IV_META_KEY]: meta
+    }
+  };
+}
+
+// src/blocks/InteractiveVideo.tsx
+var import_jsx_runtime21 = require("react/jsx-runtime");
+function loadVideoMeta(storage, courseId, blockId, enabled) {
+  if (!enabled || !courseId) return { currentTime: 0, completedCueIndices: [] };
+  const saved = (0, import_core19.loadCompoundState)(storage, courseId, blockId);
+  if (!saved) return { currentTime: 0, completedCueIndices: [] };
+  const meta = readInteractiveVideoMeta(saved.childStates);
+  return meta ?? { currentTime: 0, completedCueIndices: [] };
+}
+function getCueChildCheckId(cue) {
+  const child = import_react31.default.Children.only(cue.props.children);
+  if (!import_react31.default.isValidElement(child)) return null;
+  const props = child.props;
+  if (typeof props.checkId !== "string") return null;
+  return normalizeComponentId(props.checkId, "checkId");
+}
+function cueRequiresAnswer(cue) {
+  return Boolean(cue.props.mustComplete && getCueChildCheckId(cue));
+}
+var InteractiveVideoInner = (0, import_react31.forwardRef)(function InteractiveVideoInner2(props, ref) {
+  const { blockId, cues, index, setIndex, persistEnabled, initialMeta } = props;
+  validateCompoundChildren("InteractiveVideo", cues);
+  const { config, track, storage } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const videoRef = (0, import_react31.useRef)(null);
+  const completedCuesRef = (0, import_react31.useRef)(new Set(initialMeta.completedCueIndices));
+  const [completedCues, setCompletedCues] = (0, import_react31.useState)(
+    () => new Set(initialMeta.completedCueIndices)
+  );
+  const [overlayActive, setOverlayActive] = (0, import_react31.useState)(false);
+  const firedCuesRef = (0, import_react31.useRef)(new Set(initialMeta.completedCueIndices));
+  const resumeOverlayCheckedRef = (0, import_react31.useRef)(false);
+  const sortedCues = (0, import_react31.useMemo)(
+    () => [...cues].sort((a, b) => (a.props.atSeconds ?? 0) - (b.props.atSeconds ?? 0)),
+    [cues]
+  );
+  (0, import_react31.useEffect)(() => {
+    completedCuesRef.current = completedCues;
+  }, [completedCues]);
+  const transformState = (0, import_react31.useCallback)(
+    (state) => mergeVideoMetaIntoState(state, {
+      currentTime: videoRef.current?.currentTime ?? initialMeta.currentTime,
+      completedCueIndices: [...completedCuesRef.current]
+    }),
+    [initialMeta.currentTime]
+  );
+  const { ctx } = useCompoundShell({
+    courseId: config.courseId,
+    compoundId: blockId,
+    pageCount: sortedCues.length,
+    index,
+    setIndex,
+    persistEnabled,
+    ref,
+    storage,
+    transformState
+  });
+  const activeCue = sortedCues[index];
+  const cueCanContinue = (0, import_react31.useCallback)(
+    (cue) => {
+      if (!cue || !cueRequiresAnswer(cue)) return true;
+      const checkId = getCueChildCheckId(cue);
+      if (!checkId) return true;
+      const entry = ctx?.getRegisteredHandles().get(checkId);
+      if (!entry) return false;
+      return entry.handle.getAnswerGiven();
+    },
+    [ctx]
+  );
+  const canContinueActiveCue = cueCanContinue(activeCue);
+  (0, import_react31.useEffect)(() => {
+    const video = videoRef.current;
+    if (!video || initialMeta.currentTime <= 0) return;
+    video.currentTime = initialMeta.currentTime;
+  }, [initialMeta.currentTime]);
+  (0, import_react31.useEffect)(() => {
+    if (resumeOverlayCheckedRef.current || sortedCues.length === 0) return;
+    resumeOverlayCheckedRef.current = true;
+    const hasSavedProgress = initialMeta.currentTime > 0 || initialMeta.completedCueIndices.length > 0 || persistEnabled && config.courseId && (0, import_core19.loadCompoundState)(storage, config.courseId, blockId) !== null;
+    if (!hasSavedProgress) return;
+    const video = videoRef.current;
+    if (!video) return;
+    const cue = sortedCues[index];
+    if (!cue || completedCues.has(index)) return;
+    setOverlayActive(true);
+    video.pause();
+    const at = cue.props.atSeconds ?? 0;
+    if (video.currentTime < at) {
+      video.currentTime = at;
+    }
+  }, [
+    blockId,
+    completedCues,
+    config.courseId,
+    index,
+    initialMeta.completedCueIndices.length,
+    initialMeta.currentTime,
+    persistEnabled,
+    sortedCues,
+    storage
+  ]);
+  const mandatoryIncompleteBefore = (0, import_react31.useCallback)(
+    (time) => {
+      for (let i = 0; i < sortedCues.length; i++) {
+        const cue = sortedCues[i];
+        if ((cue.props.atSeconds ?? 0) >= time) break;
+        if (cue.props.mustComplete && !completedCues.has(i)) return cue.props.atSeconds ?? 0;
+      }
+      return null;
+    },
+    [sortedCues, completedCues]
+  );
+  const activateCue = (0, import_react31.useCallback)(
+    (i) => {
+      const cue = sortedCues[i];
+      if (!cue || firedCuesRef.current.has(i)) return;
+      firedCuesRef.current.add(i);
+      videoRef.current?.pause();
+      setIndex(i);
+      setOverlayActive(true);
+      if (lessonId) {
+        track(
+          "video_cue_reached",
+          { blockId, cueIndex: i, atSeconds: cue.props.atSeconds ?? 0, cueLabel: cue.props.label },
+          { lessonId }
+        );
+      }
+    },
+    [blockId, lessonId, setIndex, sortedCues, track]
+  );
+  const onTimeUpdate = () => {
+    const video = videoRef.current;
+    if (!video || overlayActive) return;
+    const t = video.currentTime;
+    const blockSeek = mandatoryIncompleteBefore(t);
+    if (blockSeek !== null && t > blockSeek + 0.5) {
+      video.currentTime = blockSeek;
+      return;
+    }
+    for (let i = 0; i < sortedCues.length; i++) {
+      if (firedCuesRef.current.has(i)) continue;
+      const at = sortedCues[i]?.props.atSeconds ?? 0;
+      if (t >= at) {
+        activateCue(i);
+        break;
+      }
+    }
+  };
+  const completeCue = () => {
+    const cue = sortedCues[index];
+    if (!cue || !cueCanContinue(cue)) return;
+    setCompletedCues((prev) => {
+      const next = /* @__PURE__ */ new Set([...prev, index]);
+      completedCuesRef.current = next;
+      return next;
+    });
+    setOverlayActive(false);
+    if (lessonId) {
+      track(
+        "video_segment_completed",
+        {
+          blockId,
+          segmentIndex: index,
+          atSeconds: cue.props.atSeconds ?? 0,
+          segmentLabel: cue.props.label
+        },
+        { lessonId }
+      );
+    }
+    videoRef.current?.play().catch(() => {
+    });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("section", { "aria-label": props.title, "data-testid": "interactive-video", "data-lk-block-id": blockId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("h3", { children: props.title }),
+    props.showVideoScore && ctx ? /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("p", { "data-testid": "video-score", children: [
+      "Score: ",
+      Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getScore(), 0),
+      " /",
+      " ",
+      Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getMaxScore(), 0)
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { style: { position: "relative" }, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      "video",
+      {
+        ref: videoRef,
+        src: props.src,
+        poster: props.poster,
+        controls: true,
+        "data-testid": "interactive-video-player",
+        onTimeUpdate,
+        onSeeking: () => {
+          const video = videoRef.current;
+          if (!video) return;
+          const blockSeek = mandatoryIncompleteBefore(video.currentTime);
+          if (blockSeek !== null && video.currentTime > blockSeek + 0.5) {
+            video.currentTime = blockSeek;
+          }
+        },
+        children: props.captions ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("track", { kind: "captions", src: props.captions, srcLang: "en", label: "Captions", default: true }) : null
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { "data-testid": "interactive-video-cues", children: sortedCues.map(
+      (cue, i) => import_react31.default.cloneElement(cue, {
+        key: cue.key ?? i,
+        hidden: !overlayActive || i !== index,
+        cueIndex: i,
+        parentType: "InteractiveVideo"
+      })
+    ) }),
+    overlayActive ? /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
+      activeCue?.props.mustComplete && !canContinueActiveCue ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("p", { role: "status", "data-testid": "cue-must-complete-hint", children: "Complete the interaction to continue." }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": "cue-continue",
+          disabled: !canContinueActiveCue,
+          "aria-disabled": !canContinueActiveCue,
+          onClick: completeCue,
+          children: "Continue video"
+        }
+      )
+    ] }) : null
+  ] });
+});
+var InteractiveVideo = (0, import_react31.forwardRef)(
+  function InteractiveVideo2(props, ref) {
+    const blockId = (0, import_react31.useMemo)(
+      () => normalizeComponentId(props.blockId, "blockId"),
+      [props.blockId]
+    );
+    const cues = import_react31.default.Children.toArray(props.children).filter(
+      import_react31.default.isValidElement
+    );
+    const { config, storage } = useLessonkit();
+    const persistEnabled = config.session?.persistCompoundState !== false;
+    const initialMeta = (0, import_react31.useMemo)(
+      () => loadVideoMeta(storage, config.courseId, blockId, persistEnabled),
+      [storage, config.courseId, blockId, persistEnabled]
+    );
+    const initialIndex = useCompoundInitialIndex({
+      courseId: config.courseId,
+      compoundId: blockId,
+      pageCount: cues.length,
+      persistEnabled,
+      storage
+    });
+    const [index, setIndex] = (0, import_react31.useState)(initialIndex);
+    const setIndexStable = (0, import_react31.useCallback)((i) => setIndex(i), []);
+    (0, import_react31.useEffect)(() => {
+      setIndex(initialIndex);
+    }, [config.courseId, blockId, initialIndex]);
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      InteractiveVideoInner,
+      {
+        ...props,
+        ref,
+        blockId,
+        cues,
+        index,
+        setIndex,
+        persistEnabled,
+        initialMeta
+      }
+    ) });
+  }
+);
+setLessonkitBlockType(InteractiveVideo, "InteractiveVideo");
+
+// src/blocks/Summary.tsx
+var import_react32 = require("react");
+var import_jsx_runtime22 = require("react/jsx-runtime");
+var INTERACTION6 = "summary";
+function SummaryInner(props, ref) {
+  const checkId = (0, import_react32.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const [selectedIndices, setSelectedIndices] = (0, import_react32.useState)([]);
+  const [passed, setPassed] = (0, import_react32.useState)(false);
+  const [checked, setChecked] = (0, import_react32.useState)(false);
+  const completedRef = (0, import_react32.useRef)(false);
+  const telemetryReplayedRef = (0, import_react32.useRef)(false);
+  const correctKey = props.correct.join("\0");
+  const statementsKey = props.statements.join("\0");
+  const selected = selectedIndices.map((i) => props.statements[i] ?? "");
+  const reset = () => {
+    completedRef.current = false;
+    telemetryReplayedRef.current = false;
+    setSelectedIndices([]);
+    setPassed(false);
+    setChecked(false);
+  };
+  (0, import_react32.useEffect)(() => {
+    reset();
+  }, [checkId, correctKey, statementsKey]);
+  const isCorrect = selected.length === props.correct.length && selected.every((s, i) => s === props.correct[i]);
+  const maxScore = props.correct.length || 1;
+  const score = isCorrect ? maxScore : 0;
+  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore);
+  const availableIndices = props.statements.map((_, i) => i).filter((i) => !selectedIndices.includes(i));
+  const handle = (0, import_react32.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => passed ? score : 0,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => selectedIndices.length > 0,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION6,
+        response: selected,
+        correct: passedThreshold,
+        score: passed ? score : 0,
+        maxScore
+      }),
+      getCurrentState: () => ({ selectedIndices, passed, checked }),
+      resume: (state) => {
+        let nextIndices = [];
+        if (Array.isArray(state.selectedIndices)) {
+          nextIndices = [...state.selectedIndices];
+        } else if (Array.isArray(state.selected)) {
+          const legacy = state.selected;
+          nextIndices = legacy.map((text) => props.statements.indexOf(text)).filter((i) => i >= 0);
+        }
+        setSelectedIndices(nextIndices);
+        const nextSelected = nextIndices.map((i) => props.statements[i] ?? "");
+        const nextIsCorrect = nextSelected.length === props.correct.length && nextSelected.every((s, i) => s === props.correct[i]);
+        const nextScore = nextIsCorrect ? maxScore : 0;
+        readBooleanStateField(state, "passed", (value) => {
+          setPassed(value);
+          completedRef.current = value;
+          if (value) {
+            if (!telemetryReplayedRef.current) {
+              telemetryReplayedRef.current = true;
+              assessment.answer({
+                checkId,
+                interactionType: INTERACTION6,
+                response: nextSelected,
+                correct: true
+              });
+              assessment.complete({
+                checkId,
+                interactionType: INTERACTION6,
+                score: nextScore,
+                maxScore,
+                passingScore: props.passingScore ?? maxScore
+              });
+            }
+          }
+        });
+        readBooleanStateField(state, "checked", setChecked);
+      }
+    }),
+    [
+      assessment,
+      checkId,
+      checked,
+      maxScore,
+      passed,
+      passedThreshold,
+      props.passingScore,
+      props.statements,
+      score,
+      selected,
+      selectedIndices.length
+    ]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const addStatement = (statementIndex) => {
+    if (passed && !props.enableRetry) return;
+    setChecked(false);
+    setSelectedIndices((prev) => [...prev, statementIndex]);
+  };
+  const removeLast = () => {
+    if (passed && !props.enableRetry) return;
+    setChecked(false);
+    setSelectedIndices((prev) => prev.slice(0, -1));
+  };
+  const check = () => {
+    if (selectedIndices.length === 0) return;
+    setChecked(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION6,
+      response: selected,
+      correct: passedThreshold
+    });
+    if (passedThreshold && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION6,
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("section", { "aria-label": "Summary", "data-lk-check-id": checkId, "data-testid": "summary", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("p", { children: "Select statements in order to build the summary." }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("ol", { "data-testid": "summary-selected", children: selected.map((s, i) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("li", { children: s }, `${i}-${selectedIndices[i]}`)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { role: "group", "aria-label": "Available statements", children: availableIndices.map((statementIndex) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": `summary-statement-${statementIndex}`,
+        disabled: passed && !props.enableRetry,
+        onClick: () => addStatement(statementIndex),
+        style: { display: "block", margin: "0.25rem 0" },
+        children: props.statements[statementIndex]
+      },
+      statementIndex
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "summary-undo",
+        disabled: passed && !props.enableRetry || selectedIndices.length === 0,
+        onClick: removeLast,
+        children: "Remove last"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "summary-check",
+        disabled: selectedIndices.length === 0 || passed && !props.enableRetry,
+        onClick: check,
+        children: "Check"
+      }
+    ),
+    checked ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("p", { role: "status", "aria-live": "polite", "data-testid": "summary-feedback", children: passedThreshold ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("button", { type: "button", "data-testid": "summary-retry", onClick: reset, children: "Try again" }) : null
+  ] });
+}
+var SummaryInnerForwarded = (0, import_react32.forwardRef)(SummaryInner);
+var Summary = (0, import_react32.forwardRef)(function Summary2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(AssessmentLessonGuard, { blockLabel: "Summary", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(SummaryInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+setLessonkitBlockType(Summary, "Summary");
+
+// src/blocks/ImagePairing.tsx
+var import_react33 = require("react");
+var import_jsx_runtime23 = require("react/jsx-runtime");
+var INTERACTION7 = "imagePairing";
+function shuffleCards(cards) {
+  const next = [...cards];
+  for (let i = next.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [next[i], next[j]] = [next[j], next[i]];
+  }
+  return next;
+}
+function buildDeck(pairs) {
+  const cards = pairs.flatMap(
+    (pair) => [0, 1].map((copy) => ({
+      cardKey: `${pair.id}-${copy}`,
+      pairId: pair.id,
+      label: pair.label,
+      imageSrc: pair.imageSrc
+    }))
+  );
+  return shuffleCards(cards);
+}
+function ImagePairingInner(props, ref) {
+  const checkId = (0, import_react33.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const pairsKey = props.pairs.map((p) => p.id).join("\0");
+  const [cards, setCards] = (0, import_react33.useState)(() => buildDeck(props.pairs));
+  const [matched, setMatched] = (0, import_react33.useState)(() => /* @__PURE__ */ new Set());
+  const [revealed, setRevealed] = (0, import_react33.useState)(() => /* @__PURE__ */ new Set());
+  const [keyboardSelection, setKeyboardSelection] = (0, import_react33.useState)(null);
+  const [passed, setPassed] = (0, import_react33.useState)(false);
+  const completedRef = (0, import_react33.useRef)(false);
+  const telemetryReplayedRef = (0, import_react33.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    telemetryReplayedRef.current = false;
+    setCards(buildDeck(props.pairs));
+    setMatched(/* @__PURE__ */ new Set());
+    setRevealed(/* @__PURE__ */ new Set());
+    setKeyboardSelection(null);
+    setPassed(false);
+  };
+  (0, import_react33.useEffect)(() => {
+    reset();
+  }, [checkId, pairsKey]);
+  const totalPairs = props.pairs.length;
+  const matchedCount = matched.size;
+  const maxScore = totalPairs || 1;
+  const score = matchedCount;
+  const allMatched = totalPairs > 0 && matchedCount === totalPairs;
+  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore);
+  const completeIfReady = (nextMatched) => {
+    if (nextMatched.size === totalPairs && totalPairs > 0 && !completedRef.current) {
+      const finalScore = nextMatched.size;
+      const finalPassed = meetsPassingThreshold(finalScore, maxScore, props.passingScore);
+      completedRef.current = true;
+      setPassed(true);
+      assessment.answer({
+        checkId,
+        interactionType: INTERACTION7,
+        response: { matchedPairIds: [...nextMatched] },
+        correct: finalPassed
+      });
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION7,
+        score: finalScore,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    }
+  };
+  const tryMatch = (firstKey, secondKey) => {
+    if (firstKey === secondKey) return;
+    const first = cards.find((c) => c.cardKey === firstKey);
+    const second = cards.find((c) => c.cardKey === secondKey);
+    if (!first || !second) return;
+    setRevealed((prev) => /* @__PURE__ */ new Set([...prev, firstKey, secondKey]));
+    if (first.pairId === second.pairId) {
+      setMatched((prev) => {
+        const next = /* @__PURE__ */ new Set([...prev, first.pairId]);
+        completeIfReady(next);
+        return next;
+      });
+      setRevealed(/* @__PURE__ */ new Set());
+      setKeyboardSelection(null);
+    } else {
+      window.setTimeout(() => {
+        setRevealed((prev) => {
+          const next = new Set(prev);
+          next.delete(firstKey);
+          next.delete(secondKey);
+          return next;
+        });
+        setKeyboardSelection(null);
+      }, 800);
+    }
+  };
+  const selectCard = (cardKey) => {
+    if (passed && !props.enableRetry) return;
+    if (matched.has(cards.find((c) => c.cardKey === cardKey)?.pairId ?? "")) return;
+    if (keyboardSelection === null) {
+      setKeyboardSelection(cardKey);
+      setRevealed((prev) => /* @__PURE__ */ new Set([...prev, cardKey]));
+      return;
+    }
+    if (keyboardSelection === cardKey) {
+      setKeyboardSelection(null);
+      setRevealed((prev) => {
+        const next = new Set(prev);
+        next.delete(cardKey);
+        return next;
+      });
+      return;
+    }
+    tryMatch(keyboardSelection, cardKey);
+  };
+  const handle = (0, import_react33.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => score,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => matchedCount > 0,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION7,
+        response: { matchedPairIds: [...matched] },
+        correct: allMatched && passedThreshold,
+        score,
+        maxScore
+      }),
+      getCurrentState: () => ({
+        matched: [...matched],
+        revealed: [...revealed],
+        keyboardSelection,
+        passed
+      }),
+      resume: (state) => {
+        if (Array.isArray(state.matched)) setMatched(new Set(state.matched));
+        if (Array.isArray(state.revealed)) setRevealed(new Set(state.revealed));
+        const sel = state.keyboardSelection;
+        if (sel === null || typeof sel === "string") setKeyboardSelection(sel ?? null);
+        readBooleanStateField(state, "passed", (value) => {
+          setPassed(value);
+          completedRef.current = value;
+          if (value && !telemetryReplayedRef.current) {
+            telemetryReplayedRef.current = true;
+            const matchedIds = Array.isArray(state.matched) ? state.matched : [...matched];
+            const finalScore = matchedIds.length;
+            assessment.answer({
+              checkId,
+              interactionType: INTERACTION7,
+              response: { matchedPairIds: matchedIds },
+              correct: true
+            });
+            assessment.complete({
+              checkId,
+              interactionType: INTERACTION7,
+              score: finalScore,
+              maxScore,
+              passingScore: props.passingScore ?? maxScore
+            });
+          }
+        });
+      }
+    }),
+    [allMatched, checkId, keyboardSelection, matched, matchedCount, maxScore, passed, passedThreshold, revealed, score]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("section", { "aria-label": "Image Pairing", "data-lk-check-id": checkId, "data-testid": "image-pairing", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("p", { children: "Match the image pairs (select two cards with keyboard or click)." }),
+    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { role: "list", "aria-label": "Image cards", "data-testid": "image-pairing-grid", children: cards.map((card) => {
+      const isMatched = matched.has(card.pairId);
+      const isRevealed = isMatched || revealed.has(card.cardKey);
+      const isSelected = keyboardSelection === card.cardKey;
+      return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+        "button",
+        {
+          type: "button",
+          role: "listitem",
+          "data-testid": `pairing-card-${card.cardKey}`,
+          "aria-pressed": isSelected,
+          disabled: isMatched || passed && !props.enableRetry,
+          onClick: () => selectCard(card.cardKey),
+          style: {
+            margin: "0.25rem",
+            minWidth: "6rem",
+            minHeight: "6rem",
+            border: isSelected ? "2px solid currentColor" : "1px solid currentColor"
+          },
+          children: isRevealed ? /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(import_jsx_runtime23.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("img", { src: card.imageSrc, alt: card.label, style: { maxWidth: "5rem", maxHeight: "5rem" } }),
+            /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", { className: "lk-visually-hidden", children: card.label })
+          ] }) : "?"
+        },
+        card.cardKey
+      );
+    }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("p", { role: "status", "aria-live": "polite", "data-testid": "image-pairing-progress", children: [
+      matchedCount,
+      " / ",
+      totalPairs,
+      " pairs matched"
+    ] }),
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { type: "button", "data-testid": "image-pairing-retry", onClick: reset, children: "Try again" }) : null
+  ] });
+}
+var ImagePairingInnerForwarded = (0, import_react33.forwardRef)(ImagePairingInner);
+var ImagePairing = (0, import_react33.forwardRef)(function ImagePairing2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(AssessmentLessonGuard, { blockLabel: "ImagePairing", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(ImagePairingInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+setLessonkitBlockType(ImagePairing, "ImagePairing");
+
+// src/blocks/ImageSequencing.tsx
+var import_react34 = require("react");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+var INTERACTION8 = "imageSequencing";
+function ImageSequencingInner(props, ref) {
+  const checkId = (0, import_react34.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const imagesKey = props.images.map((i) => i.id).join("\0");
+  const orderKey = props.correctOrder.join("\0");
+  const [order, setOrder] = (0, import_react34.useState)(() => props.images.map((i) => i.id));
+  const [passed, setPassed] = (0, import_react34.useState)(false);
+  const [checked, setChecked] = (0, import_react34.useState)(false);
+  const completedRef = (0, import_react34.useRef)(false);
+  const telemetryReplayedRef = (0, import_react34.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    telemetryReplayedRef.current = false;
+    setOrder(props.images.map((i) => i.id));
+    setPassed(false);
+    setChecked(false);
+  };
+  (0, import_react34.useEffect)(() => {
+    reset();
+  }, [checkId, imagesKey, orderKey]);
+  const isCorrect = order.every((id, i) => id === props.correctOrder[i]);
+  const maxScore = props.correctOrder.length || 1;
+  const score = isCorrect ? maxScore : 0;
+  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore);
+  const move = (index, direction) => {
+    if (passed && !props.enableRetry) return;
+    setChecked(false);
+    const nextIndex = index + direction;
+    if (nextIndex < 0 || nextIndex >= order.length) return;
+    setOrder((prev) => {
+      const next = [...prev];
+      [next[index], next[nextIndex]] = [next[nextIndex], next[index]];
+      return next;
+    });
+  };
+  const handle = (0, import_react34.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => passed ? score : 0,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => order.length > 0,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION8,
+        response: order,
+        correct: passedThreshold,
+        score: passed ? score : 0,
+        maxScore
+      }),
+      getCurrentState: () => ({ order, passed, checked }),
+      resume: (state) => {
+        let nextOrder = order;
+        if (Array.isArray(state.order)) {
+          nextOrder = [...state.order];
+          setOrder(nextOrder);
+        }
+        readBooleanStateField(state, "passed", (value) => {
+          setPassed(value);
+          completedRef.current = value;
+          if (value && !telemetryReplayedRef.current) {
+            telemetryReplayedRef.current = true;
+            const nextIsCorrect = nextOrder.every((id, i) => id === props.correctOrder[i]);
+            const nextScore = nextIsCorrect ? maxScore : 0;
+            assessment.answer({
+              checkId,
+              interactionType: INTERACTION8,
+              response: nextOrder,
+              correct: nextIsCorrect
+            });
+            assessment.complete({
+              checkId,
+              interactionType: INTERACTION8,
+              score: nextScore,
+              maxScore,
+              passingScore: props.passingScore ?? maxScore
+            });
+          }
+        });
+        readBooleanStateField(state, "checked", setChecked);
+      }
+    }),
+    [checkId, checked, maxScore, order, passed, passedThreshold, score]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const check = () => {
+    setChecked(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION8,
+      response: order,
+      correct: passedThreshold
+    });
+    if (passedThreshold && !completedRef.current) {
+      completedRef.current = true;
+      setPassed(true);
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION8,
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("section", { "aria-label": "Image Sequencing", "data-lk-check-id": checkId, "data-testid": "image-sequencing", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("p", { children: "Reorder the images into the correct sequence." }),
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("ol", { "data-testid": "image-sequencing-list", children: order.map((id, index) => {
+      const image = props.images.find((i) => i.id === id);
+      if (!image) return null;
+      return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("li", { "data-testid": `sequencing-item-${id}`, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("img", { src: image.src, alt: image.alt, style: { maxWidth: "8rem", verticalAlign: "middle" } }),
+        /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+          "button",
+          {
+            type: "button",
+            "data-testid": `sequencing-up-${id}`,
+            "aria-label": `Move ${image.alt} up`,
+            disabled: index === 0 || passed && !props.enableRetry,
+            onClick: () => move(index, -1),
+            children: "Up"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+          "button",
+          {
+            type: "button",
+            "data-testid": `sequencing-down-${id}`,
+            "aria-label": `Move ${image.alt} down`,
+            disabled: index >= order.length - 1 || passed && !props.enableRetry,
+            onClick: () => move(index, 1),
+            children: "Down"
+          }
+        )
+      ] }, id);
+    }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "image-sequencing-check",
+        disabled: passed && !props.enableRetry,
+        onClick: check,
+        children: "Check"
+      }
+    ),
+    checked ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("p", { role: "status", "aria-live": "polite", "data-testid": "image-sequencing-feedback", children: passedThreshold ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("button", { type: "button", "data-testid": "image-sequencing-retry", onClick: reset, children: "Try again" }) : null
+  ] });
+}
+var ImageSequencingInnerForwarded = (0, import_react34.forwardRef)(ImageSequencingInner);
+var ImageSequencing = (0, import_react34.forwardRef)(
+  function ImageSequencing2(props, ref) {
+    return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(AssessmentLessonGuard, { blockLabel: "ImageSequencing", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(ImageSequencingInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+  }
+);
+setLessonkitBlockType(ImageSequencing, "ImageSequencing");
+
+// src/blocks/ArithmeticQuiz.tsx
+var import_react35 = require("react");
+var import_jsx_runtime25 = require("react/jsx-runtime");
+var INTERACTION9 = "arithmeticQuiz";
+function ArithmeticQuizInner(props, ref) {
+  const checkId = (0, import_react35.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const problemsKey = props.problems.map((p) => `${p.question}\0${p.answer}`).join("|");
+  const [answers, setAnswers] = (0, import_react35.useState)(
+    () => Object.fromEntries(props.problems.map((_, i) => [i, ""]))
+  );
+  const [passed, setPassed] = (0, import_react35.useState)(false);
+  const [checked, setChecked] = (0, import_react35.useState)(false);
+  const [timeLeft, setTimeLeft] = (0, import_react35.useState)(
+    props.timeLimitSeconds ?? null
+  );
+  const completedRef = (0, import_react35.useRef)(false);
+  const telemetryReplayedRef = (0, import_react35.useRef)(false);
+  const reset = () => {
+    completedRef.current = false;
+    telemetryReplayedRef.current = false;
+    setAnswers(Object.fromEntries(props.problems.map((_, i) => [i, ""])));
+    setPassed(false);
+    setChecked(false);
+    setTimeLeft(props.timeLimitSeconds ?? null);
+  };
+  (0, import_react35.useEffect)(() => {
+    reset();
+  }, [checkId, problemsKey, props.timeLimitSeconds]);
+  let score = 0;
+  props.problems.forEach((p, i) => {
+    if ((answers[i] ?? "").trim() === p.answer.trim()) score += 1;
+  });
+  const maxScore = props.problems.length || 1;
+  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore);
+  const allFilled = props.problems.every((_, i) => (answers[i] ?? "").trim().length > 0);
+  const runCheck = (0, import_react35.useCallback)(
+    (force = false) => {
+      if (!force && !allFilled) return;
+      setChecked(true);
+      assessment.answer({
+        checkId,
+        interactionType: INTERACTION9,
+        response: answers,
+        correct: passedThreshold
+      });
+      if (passedThreshold && !completedRef.current) {
+        completedRef.current = true;
+        setPassed(true);
+        assessment.complete({
+          checkId,
+          interactionType: INTERACTION9,
+          score,
+          maxScore,
+          passingScore: props.passingScore ?? maxScore
+        });
+      }
+    },
+    [allFilled, answers, assessment, checkId, maxScore, passedThreshold, props.passingScore, score]
+  );
+  (0, import_react35.useEffect)(() => {
+    if (timeLeft === null || passed || checked) return;
+    if (timeLeft <= 0) {
+      runCheck(true);
+      return;
+    }
+    const id = window.setTimeout(() => setTimeLeft((t) => t !== null ? t - 1 : t), 1e3);
+    return () => window.clearTimeout(id);
+  }, [checked, passed, runCheck, timeLeft]);
+  const handle = (0, import_react35.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => passed ? score : 0,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => allFilled,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION9,
+        response: answers,
+        correct: passedThreshold,
+        score: passed ? score : 0,
+        maxScore
+      }),
+      getCurrentState: () => ({ answers, passed, checked, timeLeft }),
+      resume: (state) => {
+        const raw = state.answers;
+        let nextAnswers = answers;
+        if (raw && typeof raw === "object") {
+          nextAnswers = { ...raw };
+          setAnswers(nextAnswers);
+        }
+        readBooleanStateField(state, "passed", (value) => {
+          setPassed(value);
+          completedRef.current = value;
+          if (value && !telemetryReplayedRef.current) {
+            telemetryReplayedRef.current = true;
+            let nextScore = 0;
+            props.problems.forEach((p, i) => {
+              if ((nextAnswers[i] ?? "").trim() === p.answer.trim()) nextScore += 1;
+            });
+            assessment.answer({
+              checkId,
+              interactionType: INTERACTION9,
+              response: nextAnswers,
+              correct: true
+            });
+            assessment.complete({
+              checkId,
+              interactionType: INTERACTION9,
+              score: nextScore,
+              maxScore,
+              passingScore: props.passingScore ?? maxScore
+            });
+          }
+        });
+        readBooleanStateField(state, "checked", setChecked);
+        if (typeof state.timeLeft === "number") setTimeLeft(state.timeLeft);
+      }
+    }),
+    [allFilled, answers, checkId, checked, maxScore, passed, passedThreshold, score, timeLeft]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const onInput = (index, value) => {
+    if (passed && !props.enableRetry) return;
+    setChecked(false);
+    setAnswers((prev) => ({ ...prev, [index]: value }));
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("section", { "aria-label": "Arithmetic Quiz", "data-lk-check-id": checkId, "data-testid": "arithmetic-quiz", children: [
+    props.timeLimitSeconds ? /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("p", { "data-testid": "arithmetic-timer", role: "timer", "aria-live": "polite", children: [
+      "Time left: ",
+      timeLeft ?? 0,
+      "s"
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("ol", { "data-testid": "arithmetic-problems", children: props.problems.map((problem, index) => /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("li", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("label", { htmlFor: `${checkId}-problem-${index}`, children: problem.question }),
+      /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+        "input",
+        {
+          id: `${checkId}-problem-${index}`,
+          type: "text",
+          inputMode: "numeric",
+          "data-testid": `arithmetic-answer-${index}`,
+          value: answers[index] ?? "",
+          disabled: passed && !props.enableRetry,
+          onChange: (e) => onInput(index, e.target.value)
+        }
+      )
+    ] }, index)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "arithmetic-check",
+        disabled: !allFilled && timeLeft !== 0 || passed && !props.enableRetry,
+        onClick: () => runCheck(),
+        children: "Check"
+      }
+    ),
+    checked ? /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("p", { role: "status", "aria-live": "polite", "data-testid": "arithmetic-feedback", children: [
+      passedThreshold ? "Correct" : "Try again",
+      " (",
+      score,
+      "/",
+      maxScore,
+      ")"
+    ] }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", { type: "button", "data-testid": "arithmetic-retry", onClick: reset, children: "Try again" }) : null
+  ] });
+}
+var ArithmeticQuizInnerForwarded = (0, import_react35.forwardRef)(ArithmeticQuizInner);
+var ArithmeticQuiz = (0, import_react35.forwardRef)(
+  function ArithmeticQuiz2(props, ref) {
+    return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(AssessmentLessonGuard, { blockLabel: "ArithmeticQuiz", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(ArithmeticQuizInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+  }
+);
+setLessonkitBlockType(ArithmeticQuiz, "ArithmeticQuiz");
+
+// src/blocks/Essay.tsx
+var import_react36 = __toESM(require("react"), 1);
+var import_jsx_runtime26 = require("react/jsx-runtime");
+var INTERACTION10 = "essay";
+function EssayInner(props, ref) {
+  const checkId = (0, import_react36.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const [text, setText] = (0, import_react36.useState)("");
+  const [submitted, setSubmitted] = (0, import_react36.useState)(false);
+  const completedRef = (0, import_react36.useRef)(false);
+  const telemetryReplayedRef = (0, import_react36.useRef)(false);
+  const questionId = import_react36.default.useId();
+  const minLength = props.minLength ?? 0;
+  const meetsMinLength = text.trim().length >= minLength;
+  const reset = () => {
+    completedRef.current = false;
+    telemetryReplayedRef.current = false;
+    setText("");
+    setSubmitted(false);
+  };
+  (0, import_react36.useEffect)(() => {
+    reset();
+  }, [checkId, props.question, props.minLength]);
+  const handle = (0, import_react36.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => 0,
+      getMaxScore: () => 1,
+      getAnswerGiven: () => submitted && meetsMinLength,
+      resetTask: reset,
+      showSolutions: () => {
+      },
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION10,
+        question: props.question,
+        response: text,
+        score: 0,
+        maxScore: 1
+      }),
+      getCurrentState: () => ({ text, submitted }),
+      resume: (state) => {
+        const nextText = readStringField(state, "text");
+        if (typeof nextText === "string") setText(nextText);
+        readBooleanStateField(state, "submitted", (value) => {
+          setSubmitted(value);
+          completedRef.current = value;
+          if (value && !telemetryReplayedRef.current) {
+            telemetryReplayedRef.current = true;
+            const response = typeof nextText === "string" ? nextText : text;
+            assessment.answer({
+              checkId,
+              interactionType: INTERACTION10,
+              question: props.question,
+              response,
+              correct: false
+            });
+            assessment.complete({
+              checkId,
+              interactionType: INTERACTION10,
+              score: 0,
+              maxScore: 1,
+              passingScore: props.passingScore ?? 1
+            });
+          }
+        });
+      }
+    }),
+    [checkId, meetsMinLength, props.question, submitted, text]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const submit = () => {
+    if (!meetsMinLength || submitted && !props.enableRetry) return;
+    setSubmitted(true);
+    if (!completedRef.current) {
+      completedRef.current = true;
+      assessment.answer({
+        checkId,
+        interactionType: INTERACTION10,
+        question: props.question,
+        response: text,
+        correct: false
+      });
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION10,
+        score: 0,
+        maxScore: 1,
+        passingScore: props.passingScore ?? 1
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)("section", { "aria-label": "Essay", "data-lk-check-id": checkId, "data-testid": "essay", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("p", { id: questionId, children: props.question }),
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+      "textarea",
+      {
+        "aria-labelledby": questionId,
+        "data-testid": "essay-textarea",
+        value: text,
+        disabled: submitted && !props.enableRetry,
+        onChange: (e) => {
+          if (submitted && !props.enableRetry) return;
+          setSubmitted(false);
+          completedRef.current = false;
+          setText(e.target.value);
+        },
+        rows: 6,
+        style: { width: "100%" }
+      }
+    ),
+    minLength > 0 ? /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)("p", { "data-testid": "essay-min-length", children: [
+      "Minimum length: ",
+      minLength,
+      " characters (",
+      text.trim().length,
+      "/",
+      minLength,
+      ")"
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "essay-submit",
+        disabled: !meetsMinLength || submitted && !props.enableRetry,
+        onClick: submit,
+        children: "Submit"
+      }
+    ),
+    submitted ? /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("p", { role: "status", "aria-live": "polite", "data-testid": "essay-submitted", children: "Response submitted for review." }) : null,
+    props.enableRetry && submitted ? /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("button", { type: "button", "data-testid": "essay-retry", onClick: reset, children: "Try again" }) : null
+  ] });
+}
+var EssayInnerForwarded = (0, import_react36.forwardRef)(EssayInner);
+var Essay = (0, import_react36.forwardRef)(function Essay2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(AssessmentLessonGuard, { blockLabel: "Essay", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(EssayInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+setLessonkitBlockType(Essay, "Essay");
+
+// src/blocks/Questionnaire.tsx
+var import_react37 = require("react");
+var import_jsx_runtime27 = require("react/jsx-runtime");
+function Questionnaire(props) {
+  const blockId = (0, import_react37.useMemo)(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
+  const fieldsKey = props.fields.map((f) => `${f.id}:${f.type}:${f.label}`).join("|");
+  const [values, setValues] = (0, import_react37.useState)(
+    () => Object.fromEntries(props.fields.map((f) => [f.id, ""]))
+  );
+  const [submitted, setSubmitted] = (0, import_react37.useState)(false);
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const baseId = (0, import_react37.useId)();
+  (0, import_react37.useEffect)(() => {
+    setValues(Object.fromEntries(props.fields.map((f) => [f.id, ""])));
+    setSubmitted(false);
+  }, [blockId, fieldsKey, props.fields]);
+  const submit = () => {
+    if (submitted) return;
+    setSubmitted(true);
+    if (lessonId) {
+      track(
+        "questionnaire_submitted",
+        { blockId, fieldCount: props.fields.length },
+        { lessonId }
+      );
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("section", { "aria-label": "Questionnaire", "data-lk-block-id": blockId, "data-testid": "questionnaire", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(
+      "form",
+      {
+        onSubmit: (e) => {
+          e.preventDefault();
+          submit();
+        },
+        children: [
+          props.fields.map((field) => {
+            const fieldId = `${baseId}-${field.id}`;
+            return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("div", { "data-testid": `questionnaire-field-${field.id}`, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("label", { htmlFor: fieldId, children: field.label }),
+              field.type === "textarea" ? /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+                "textarea",
+                {
+                  id: fieldId,
+                  "data-testid": `questionnaire-input-${field.id}`,
+                  value: values[field.id] ?? "",
+                  disabled: submitted,
+                  rows: 4,
+                  style: { display: "block", width: "100%" },
+                  onChange: (e) => setValues((prev) => ({ ...prev, [field.id]: e.target.value }))
+                }
+              ) : /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+                "input",
+                {
+                  id: fieldId,
+                  type: "text",
+                  "data-testid": `questionnaire-input-${field.id}`,
+                  value: values[field.id] ?? "",
+                  disabled: submitted,
+                  style: { display: "block", width: "100%" },
+                  onChange: (e) => setValues((prev) => ({ ...prev, [field.id]: e.target.value }))
+                }
+              )
+            ] }, field.id);
+          }),
+          /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("button", { type: "submit", "data-testid": "questionnaire-submit", disabled: submitted, children: "Submit" })
+        ]
+      }
+    ),
+    submitted ? /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("p", { role: "status", "aria-live": "polite", "data-testid": "questionnaire-submitted", children: "Thank you for your responses." }) : null
+  ] });
+}
+setLessonkitBlockType(Questionnaire, "Questionnaire");
+
+// src/blocks/MemoryGame.tsx
+var import_react38 = require("react");
+var import_jsx_runtime28 = require("react/jsx-runtime");
+function shuffleCards2(cards) {
+  const next = [...cards];
+  for (let i = next.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [next[i], next[j]] = [next[j], next[i]];
+  }
+  return next;
+}
+function buildDeck2(pairs) {
+  const cards = pairs.flatMap(
+    (pair) => [0, 1].map((copy) => ({
+      cardKey: `${pair.id}-${copy}`,
+      pairId: pair.id,
+      label: pair.label
+    }))
+  );
+  return shuffleCards2(cards);
+}
+function MemoryGame(props) {
+  const pairsKey = props.pairs.map((p) => p.id).join("\0");
+  const [cards, setCards] = (0, import_react38.useState)(() => buildDeck2(props.pairs));
+  const [matched, setMatched] = (0, import_react38.useState)(() => /* @__PURE__ */ new Set());
+  const [revealed, setRevealed] = (0, import_react38.useState)(() => /* @__PURE__ */ new Set());
+  const [selection, setSelection] = (0, import_react38.useState)(null);
+  const [complete, setComplete] = (0, import_react38.useState)(false);
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const trackOpts = lessonId ? { lessonId } : void 0;
+  (0, import_react38.useEffect)(() => {
+    setCards(buildDeck2(props.pairs));
+    setMatched(/* @__PURE__ */ new Set());
+    setRevealed(/* @__PURE__ */ new Set());
+    setSelection(null);
+    setComplete(false);
+  }, [props.blockId, pairsKey]);
+  const cardIndexByKey = (0, import_react38.useMemo)(
+    () => Object.fromEntries(cards.map((c, i) => [c.cardKey, i])),
+    [cards]
+  );
+  const flipCard = (cardKey, face) => {
+    const cardIndex = cardIndexByKey[cardKey];
+    if (typeof cardIndex === "number") {
+      track(
+        "memory_card_flipped",
+        { blockId: props.blockId, cardIndex, face },
+        trackOpts
+      );
+    }
+  };
+  const tryMatch = (firstKey, secondKey) => {
+    const first = cards.find((c) => c.cardKey === firstKey);
+    const second = cards.find((c) => c.cardKey === secondKey);
+    if (!first || !second) return;
+    setRevealed((prev) => /* @__PURE__ */ new Set([...prev, firstKey, secondKey]));
+    flipCard(secondKey, "back");
+    if (first.pairId === second.pairId) {
+      setMatched((prev) => {
+        const next = /* @__PURE__ */ new Set([...prev, first.pairId]);
+        if (next.size === props.pairs.length) setComplete(true);
+        return next;
+      });
+      setRevealed(/* @__PURE__ */ new Set());
+      setSelection(null);
+    } else {
+      window.setTimeout(() => {
+        setRevealed((prev) => {
+          const next = new Set(prev);
+          next.delete(firstKey);
+          next.delete(secondKey);
+          return next;
+        });
+        flipCard(firstKey, "front");
+        flipCard(secondKey, "front");
+        setSelection(null);
+      }, 800);
+    }
+  };
+  const selectCard = (cardKey) => {
+    if (complete) return;
+    if (matched.has(cards.find((c) => c.cardKey === cardKey)?.pairId ?? "")) return;
+    if (selection === null) {
+      setSelection(cardKey);
+      setRevealed((prev) => /* @__PURE__ */ new Set([...prev, cardKey]));
+      flipCard(cardKey, "back");
+      return;
+    }
+    if (selection === cardKey) {
+      setSelection(null);
+      setRevealed((prev) => {
+        const next = new Set(prev);
+        next.delete(cardKey);
+        return next;
+      });
+      flipCard(cardKey, "front");
+      return;
+    }
+    tryMatch(selection, cardKey);
+  };
+  const restart = () => {
+    setCards(buildDeck2(props.pairs));
+    setMatched(/* @__PURE__ */ new Set());
+    setRevealed(/* @__PURE__ */ new Set());
+    setSelection(null);
+    setComplete(false);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)("section", { "aria-label": "Memory Game", "data-lk-block-id": props.blockId, "data-testid": "memory-game", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("div", { role: "list", "aria-label": "Memory cards", "data-testid": "memory-game-grid", children: cards.map((card) => {
+      const isMatched = matched.has(card.pairId);
+      const isRevealed = isMatched || revealed.has(card.cardKey);
+      const isSelected = selection === card.cardKey;
+      return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
+        "button",
+        {
+          type: "button",
+          role: "listitem",
+          "data-testid": `memory-card-${card.cardKey}`,
+          "aria-pressed": isSelected,
+          disabled: isMatched || complete,
+          onClick: () => selectCard(card.cardKey),
+          style: {
+            margin: "0.25rem",
+            minWidth: "5rem",
+            minHeight: "5rem",
+            border: isSelected ? "2px solid currentColor" : "1px solid currentColor"
+          },
+          children: isRevealed ? card.label : "?"
+        },
+        card.cardKey
+      );
+    }) }),
+    complete ? /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("p", { role: "status", "aria-live": "polite", "data-testid": "memory-game-complete", children: "All pairs matched!" }) : null,
+    props.selfScore ? /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("p", { "data-testid": "memory-game-self-score", children: "Self-score mode enabled" }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("button", { type: "button", "data-testid": "memory-game-restart", onClick: restart, children: "Restart" })
+  ] });
+}
+setLessonkitBlockType(MemoryGame, "MemoryGame");
+
+// src/blocks/InformationWall.tsx
+var import_react39 = require("react");
+var import_jsx_runtime29 = require("react/jsx-runtime");
+function InformationWall(props) {
+  const blockId = (0, import_react39.useMemo)(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
+  const [query, setQuery] = (0, import_react39.useState)("");
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const trackOpts = lessonId ? { lessonId } : void 0;
+  const debounceRef = (0, import_react39.useRef)(null);
+  const filtered = (0, import_react39.useMemo)(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return props.panels;
+    return props.panels.filter(
+      (panel) => panel.title.toLowerCase().includes(q) || panel.body.toLowerCase().includes(q)
+    );
+  }, [props.panels, query]);
+  (0, import_react39.useEffect)(
+    () => () => {
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    },
+    []
+  );
+  const onSearch = (value) => {
+    setQuery(value);
+    if (debounceRef.current) clearTimeout(debounceRef.current);
+    debounceRef.current = setTimeout(() => {
+      const q = value.trim().toLowerCase();
+      const resultCount = q ? props.panels.filter(
+        (panel) => panel.title.toLowerCase().includes(q) || panel.body.toLowerCase().includes(q)
+      ).length : props.panels.length;
+      track(
+        "information_wall_search",
+        { blockId, query: value, resultCount },
+        trackOpts
+      );
+    }, 300);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("section", { "aria-label": "Information Wall", "data-lk-block-id": blockId, "data-testid": "information-wall", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("label", { htmlFor: `${blockId}-search`, children: "Search panels" }),
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(
+      "input",
+      {
+        id: `${blockId}-search`,
+        type: "search",
+        "data-testid": "information-wall-search",
+        value: query,
+        placeholder: "Search\u2026",
+        onChange: (e) => onSearch(e.target.value)
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("p", { "data-testid": "information-wall-result-count", children: [
+      filtered.length,
+      " panel",
+      filtered.length === 1 ? "" : "s"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("ul", { "data-testid": "information-wall-panels", children: filtered.map((panel) => /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("li", { "data-testid": `information-panel-${panel.id}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("h4", { children: panel.title }),
+      /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("p", { children: panel.body })
+    ] }, panel.id)) })
+  ] });
+}
+setLessonkitBlockType(InformationWall, "InformationWall");
+
+// src/blocks/ParallaxSlideshow.tsx
+var import_react40 = require("react");
+var import_jsx_runtime30 = require("react/jsx-runtime");
+function usePrefersReducedMotion() {
+  const [reduced, setReduced] = (0, import_react40.useState)(false);
+  (0, import_react40.useEffect)(() => {
+    const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
+    setReduced(mq.matches);
+    const onChange = (e) => setReduced(e.matches);
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  }, []);
+  return reduced;
+}
+function ParallaxSlideshow(props) {
+  const [index, setIndex] = (0, import_react40.useState)(0);
+  const reducedMotion = usePrefersReducedMotion();
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const trackOpts = lessonId ? { lessonId } : void 0;
+  const slide = props.slides[index];
+  (0, import_react40.useEffect)(() => {
+    track(
+      "parallax_slide_viewed",
+      { blockId: props.blockId, slideIndex: index },
+      trackOpts
+    );
+  }, [index, props.blockId, track, trackOpts]);
+  if (!slide) return null;
+  const goTo = (next) => {
+    if (next < 0 || next >= props.slides.length) return;
+    setIndex(next);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)(
+    "section",
+    {
+      "aria-label": "Parallax slideshow",
+      "data-lk-block-id": props.blockId,
+      "data-testid": "parallax-slideshow",
+      "data-reduced-motion": reducedMotion ? "true" : "false",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)(
+          "article",
+          {
+            "data-testid": `parallax-slide-${index}`,
+            style: reducedMotion ? void 0 : {
+              backgroundAttachment: "fixed",
+              backgroundImage: slide.imageSrc ? `url(${slide.imageSrc})` : void 0,
+              backgroundPosition: "center",
+              backgroundSize: "cover",
+              minHeight: "12rem",
+              padding: "1rem"
+            },
+            children: [
+              reducedMotion && slide.imageSrc ? /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+                "img",
+                {
+                  src: slide.imageSrc,
+                  alt: "",
+                  "data-testid": "parallax-slide-image",
+                  style: { maxWidth: "100%" }
+                }
+              ) : null,
+              /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("h3", { "data-testid": "parallax-slide-title", children: slide.title }),
+              /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("p", { "data-testid": "parallax-slide-body", children: slide.body })
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)("nav", { "aria-label": "Slide navigation", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-testid": "parallax-prev",
+              disabled: index === 0,
+              onClick: () => goTo(index - 1),
+              children: "Previous"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)("span", { "data-testid": "parallax-progress", children: [
+            index + 1,
+            " / ",
+            props.slides.length
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-testid": "parallax-next",
+              disabled: index >= props.slides.length - 1,
+              onClick: () => goTo(index + 1),
+              children: "Next"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+setLessonkitBlockType(ParallaxSlideshow, "ParallaxSlideshow");
+
+// src/blocks/Accordion.tsx
+var import_react41 = require("react");
+var import_jsx_runtime31 = require("react/jsx-runtime");
+function Accordion(props) {
+  if (isDevEnvironment()) {
+    validateAccordionSections(props.sections);
+  }
+  const [open, setOpen] = (0, import_react41.useState)(/* @__PURE__ */ new Set());
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const baseId = (0, import_react41.useId)();
+  const toggle = (sectionId) => {
+    setOpen((prev) => {
+      const next = new Set(prev);
+      const expanded = !next.has(sectionId);
+      if (expanded) next.add(sectionId);
+      else next.delete(sectionId);
+      track(
+        "accordion_section_toggled",
+        { blockId: props.blockId, sectionId, expanded },
+        lessonId ? { lessonId } : void 0
+      );
+      return next;
+    });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("section", { "aria-label": "Accordion", "data-lk-block-id": props.blockId, "data-testid": "accordion", children: props.sections.map((section) => {
+    const expanded = open.has(section.id);
+    const panelId = `${baseId}-${section.id}`;
+    const triggerId = `${baseId}-trigger-${section.id}`;
+    return /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)("div", { "data-testid": `accordion-section-${section.id}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("h4", { children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+        "button",
+        {
+          id: triggerId,
+          type: "button",
+          "aria-expanded": expanded,
+          "aria-controls": panelId,
+          "data-testid": `accordion-trigger-${section.id}`,
+          onClick: () => toggle(section.id),
+          children: section.title
+        }
+      ) }),
+      expanded ? /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { id: panelId, role: "region", "aria-labelledby": triggerId, children: section.content }) : null
+    ] }, section.id);
+  }) });
+}
+setLessonkitBlockType(Accordion, "Accordion");
+
+// src/blocks/DialogCards.tsx
+var import_react42 = require("react");
+var import_jsx_runtime32 = require("react/jsx-runtime");
+function DialogCards(props) {
+  const [index, setIndex] = (0, import_react42.useState)(0);
+  const [flipped, setFlipped] = (0, import_react42.useState)(false);
+  const card = props.cards[index];
+  if (!card) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("section", { "aria-label": "Dialog cards", "data-lk-block-id": props.blockId, "data-testid": "dialog-cards", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("p", { children: [
+      "Card ",
+      index + 1,
+      " of ",
+      props.cards.length
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "dialog-card-flip",
+        "aria-pressed": flipped,
+        onClick: () => setFlipped((f) => !f),
+        style: { minHeight: "6rem", width: "100%" },
+        children: flipped ? card.back : card.front
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("nav", { "aria-label": "Card navigation", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": "dialog-prev",
+          disabled: index === 0,
+          onClick: () => {
+            setIndex((i) => i - 1);
+            setFlipped(false);
+          },
+          children: "Previous"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": "dialog-next",
+          disabled: index >= props.cards.length - 1,
+          onClick: () => {
+            setIndex((i) => i + 1);
+            setFlipped(false);
+          },
+          children: "Next"
+        }
+      )
+    ] })
+  ] });
+}
+setLessonkitBlockType(DialogCards, "DialogCards");
+
+// src/blocks/Flashcards.tsx
+var import_react43 = require("react");
+var import_jsx_runtime33 = require("react/jsx-runtime");
+function Flashcards(props) {
+  const [index, setIndex] = (0, import_react43.useState)(0);
+  const [face, setFace] = (0, import_react43.useState)("front");
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const card = props.cards[index];
+  if (!card) return null;
+  const flip = () => {
+    const next = face === "front" ? "back" : "front";
+    setFace(next);
+    track(
+      "flashcard_flipped",
+      { blockId: props.blockId, cardIndex: index, face: next },
+      lessonId ? { lessonId } : void 0
+    );
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)("section", { "aria-label": "Flashcards", "data-lk-block-id": props.blockId, "data-testid": "flashcards", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("button", { type: "button", "data-testid": "flashcard-flip", onClick: flip, style: { minHeight: "6rem", width: "100%" }, children: face === "front" ? card.front : card.back }),
+    props.selfScore ? /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("p", { "data-testid": "flashcard-self-score", children: "Self-score mode enabled" }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "flashcard-next",
+        disabled: index >= props.cards.length - 1,
+        onClick: () => {
+          setIndex((i) => i + 1);
+          setFace("front");
+        },
+        children: "Next card"
+      }
+    )
+  ] });
+}
+setLessonkitBlockType(Flashcards, "Flashcards");
+
+// src/blocks/ImageHotspots.tsx
+var import_react44 = require("react");
+var import_jsx_runtime34 = require("react/jsx-runtime");
+function ImageHotspots(props) {
+  const [active, setActive] = (0, import_react44.useState)(null);
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const open = (hotspotId) => {
+    setActive(hotspotId);
+    track(
+      "hotspot_opened",
+      { blockId: props.blockId, hotspotId },
+      lessonId ? { lessonId } : void 0
+    );
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("section", { "aria-label": "Image hotspots", "data-lk-block-id": props.blockId, "data-testid": "image-hotspots", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { style: { position: "relative", display: "inline-block" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
+      props.hotspots.map((h) => /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+        "button",
+        {
+          type: "button",
+          "aria-expanded": active === h.id,
+          "aria-label": h.label,
+          "data-testid": `hotspot-${h.id}`,
+          style: {
+            position: "absolute",
+            left: `${h.x}%`,
+            top: `${h.y}%`,
+            transform: "translate(-50%, -50%)"
+          },
+          onClick: () => open(h.id),
+          children: "+"
+        },
+        h.id
+      ))
+    ] }),
+    active ? /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { role: "dialog", "aria-label": "Hotspot details", "data-testid": "hotspot-popover", children: [
+      props.hotspots.find((h) => h.id === active)?.content,
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("button", { type: "button", onClick: () => setActive(null), children: "Close" })
+    ] }) : null
+  ] });
+}
+setLessonkitBlockType(ImageHotspots, "ImageHotspots");
+
+// src/blocks/ImageSlider.tsx
+var import_react45 = require("react");
+var import_jsx_runtime35 = require("react/jsx-runtime");
+function ImageSlider(props) {
+  const [index, setIndex] = (0, import_react45.useState)(0);
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const slide = props.slides[index];
+  if (!slide) return null;
+  const goTo = (next) => {
+    setIndex(next);
+    track(
+      "image_slider_changed",
+      { blockId: props.blockId, slideIndex: next },
+      lessonId ? { lessonId } : void 0
+    );
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)("section", { "aria-label": "Image slider", "data-lk-block-id": props.blockId, "data-testid": "image-slider", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("img", { src: slide.src, alt: slide.alt, style: { maxWidth: "100%" } }),
+    slide.caption ? /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("p", { children: slide.caption }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)("nav", { "aria-label": "Slide navigation", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": "slider-prev",
+          disabled: index === 0,
+          onClick: () => goTo(index - 1),
+          children: "Previous"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)("span", { children: [
+        index + 1,
+        " / ",
+        props.slides.length
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+        "button",
+        {
+          type: "button",
+          "data-testid": "slider-next",
+          disabled: index >= props.slides.length - 1,
+          onClick: () => goTo(index + 1),
+          children: "Next"
+        }
+      )
+    ] })
+  ] });
+}
+setLessonkitBlockType(ImageSlider, "ImageSlider");
+
+// src/blocks/FindHotspot.tsx
+var import_react46 = require("react");
+var import_jsx_runtime36 = require("react/jsx-runtime");
+var INTERACTION11 = "findHotspot";
+function FindHotspotInner(props, ref) {
+  const checkId = (0, import_react46.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const [selected, setSelected] = (0, import_react46.useState)(null);
+  const [checked, setChecked] = (0, import_react46.useState)(false);
+  const telemetryReplayedRef = (0, import_react46.useRef)(false);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const targetIdsKey = props.targets.map((t) => t.id).join("\0");
+  (0, import_react46.useEffect)(() => {
+    setSelected(null);
+    setChecked(false);
+    telemetryReplayedRef.current = false;
+  }, [checkId, props.correctTargetId, targetIdsKey]);
+  const correct = selected === props.correctTargetId;
+  const replayTelemetry = (nextSelected, nextChecked, nextCorrect) => {
+    if (telemetryReplayedRef.current || !nextChecked || nextSelected === null) return;
+    telemetryReplayedRef.current = true;
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION11,
+      response: nextSelected,
+      correct: nextCorrect
+    });
+    if (nextCorrect) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION11,
+        score: 1,
+        maxScore: 1,
+        passingScore: props.passingScore ?? 1
+      });
+    }
+  };
+  const handle = (0, import_react46.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => checked && correct ? 1 : 0,
+      getMaxScore: () => 1,
+      getAnswerGiven: () => selected !== null,
+      resetTask: () => {
+        setSelected(null);
+        setChecked(false);
+        telemetryReplayedRef.current = false;
+      },
+      showSolutions: () => setSelected(props.correctTargetId),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION11,
+        response: selected ?? void 0,
+        correct: checked ? correct : void 0,
+        score: checked && correct ? 1 : 0,
+        maxScore: 1
+      }),
+      getCurrentState: () => ({ selected, checked }),
+      resume: (state) => {
+        let nextSelected = selected;
+        const rawSelected = readStringField(state, "selected");
+        if (typeof rawSelected === "string" || rawSelected === null) {
+          const valid = rawSelected === null || props.targets.some((t) => t.id === rawSelected);
+          nextSelected = valid ? rawSelected : null;
+          setSelected(nextSelected);
+        }
+        let nextChecked = checked;
+        readBooleanStateField(state, "checked", (value) => {
+          nextChecked = value;
+          setChecked(value);
+        });
+        const nextCorrect = nextSelected === props.correctTargetId;
+        replayTelemetry(nextSelected, nextChecked, nextCorrect);
+      }
+    }),
+    [assessment, checkId, checked, correct, props.correctTargetId, props.passingScore, props.targets, selected]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const selectTarget = (id) => {
+    setSelected(id);
+    setChecked(false);
+  };
+  const submit = () => {
+    if (!selected || checked) return;
+    setChecked(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION11,
+      response: selected,
+      correct
+    });
+    if (correct) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION11,
+        score: 1,
+        maxScore: 1,
+        passingScore: props.passingScore ?? 1
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("section", { "aria-label": "Find the hotspot", "data-lk-check-id": checkId, "data-testid": "find-hotspot", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("div", { style: { position: "relative", display: "inline-block" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
+      props.targets.map((t) => /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
+        "button",
+        {
+          type: "button",
+          "aria-label": t.label,
+          "aria-pressed": selected === t.id,
+          "data-testid": `target-${t.id}`,
+          style: {
+            position: "absolute",
+            left: `${t.x}%`,
+            top: `${t.y}%`,
+            transform: "translate(-50%, -50%)"
+          },
+          onClick: () => selectTarget(t.id),
+          children: t.label
+        },
+        t.id
+      ))
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("button", { type: "button", "data-testid": "check-hotspot", disabled: !selected, onClick: submit, children: "Check" }),
+    checked ? /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("p", { role: "status", children: correct ? "Correct" : "Try again" }) : null
+  ] });
+}
+var FindHotspotInnerForwarded = (0, import_react46.forwardRef)(FindHotspotInner);
+var FindHotspot = (0, import_react46.forwardRef)(function FindHotspot2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(AssessmentLessonGuard, { blockLabel: "FindHotspot", checkId: props.checkId, children: (enclosingLessonId) => /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(FindHotspotInnerForwarded, { ...props, enclosingLessonId, ref }) });
+});
+setLessonkitBlockType(FindHotspot, "FindHotspot");
+
+// src/blocks/FindMultipleHotspots.tsx
+var import_react47 = require("react");
+var import_jsx_runtime37 = require("react/jsx-runtime");
+var INTERACTION12 = "findMultipleHotspots";
+function FindMultipleHotspotsInner(props, ref) {
+  const checkId = (0, import_react47.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const [selected, setSelected] = (0, import_react47.useState)(/* @__PURE__ */ new Set());
+  const [checked, setChecked] = (0, import_react47.useState)(false);
+  const assessment = useAssessmentState(props.enclosingLessonId);
+  const toggle = (id) => {
+    setSelected((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+    setChecked(false);
+  };
+  const correct = selected.size === props.correctTargetIds.length && props.correctTargetIds.every((id) => selected.has(id));
+  const handle = (0, import_react47.useMemo)(
+    () => buildAssessmentHandle({
+      checkId,
+      getScore: () => checked && correct ? 1 : 0,
+      getMaxScore: () => 1,
+      getAnswerGiven: () => selected.size > 0,
+      resetTask: () => {
+        setSelected(/* @__PURE__ */ new Set());
+        setChecked(false);
+      },
+      showSolutions: () => setSelected(new Set(props.correctTargetIds)),
+      getXAPIData: () => ({
+        checkId,
+        interactionType: INTERACTION12,
+        response: [...selected],
+        correct: checked ? correct : void 0,
+        score: checked && correct ? 1 : 0,
+        maxScore: 1
+      }),
+      getCurrentState: () => ({ selected: [...selected], checked }),
+      resume: (state) => {
+        const raw = state.selected;
+        if (Array.isArray(raw)) setSelected(new Set(raw.filter((id) => typeof id === "string")));
+        readBooleanStateField(state, "checked", setChecked);
+      }
+    }),
+    [checkId, selected, checked, correct, props.correctTargetIds]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  const submit = () => {
+    if (selected.size === 0 || checked) return;
+    setChecked(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION12,
+      response: [...selected],
+      correct
+    });
+    if (correct) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION12,
+        score: 1,
+        maxScore: 1,
+        passingScore: props.passingScore ?? 1
+      });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)("section", { "aria-label": "Find multiple hotspots", "data-lk-check-id": checkId, "data-testid": "find-multiple-hotspots", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)("div", { style: { position: "relative", display: "inline-block" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
+      props.targets.map((t) => /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
+        "button",
+        {
+          type: "button",
+          "aria-label": t.label,
+          "aria-pressed": selected.has(t.id),
+          "data-testid": `target-${t.id}`,
+          style: {
+            position: "absolute",
+            left: `${t.x}%`,
+            top: `${t.y}%`,
+            transform: "translate(-50%, -50%)"
+          },
+          onClick: () => toggle(t.id),
+          children: t.label
+        },
+        t.id
+      ))
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("button", { type: "button", "data-testid": "check-hotspots", disabled: selected.size === 0, onClick: submit, children: "Check" }),
+    checked ? /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("p", { role: "status", children: correct ? "Correct" : "Try again" }) : null
+  ] });
+}
+var FindMultipleHotspotsInnerForwarded = (0, import_react47.forwardRef)(FindMultipleHotspotsInner);
+var FindMultipleHotspots = (0, import_react47.forwardRef)(
+  function FindMultipleHotspots2(props, ref) {
+    return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(AssessmentLessonGuard, { blockLabel: "FindMultipleHotspots", checkId: props.checkId, children: (enclosingLessonId) => /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(FindMultipleHotspotsInnerForwarded, { ...props, enclosingLessonId, ref }) });
+  }
+);
+setLessonkitBlockType(FindMultipleHotspots, "FindMultipleHotspots");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Accordion,
+  ArithmeticQuiz,
+  AssessmentSequence,
+  DialogCards,
+  DragAndDrop,
+  DragTheWords,
+  Essay,
+  FillInTheBlanks,
+  FindHotspot,
+  FindMultipleHotspots,
+  Flashcards,
+  Heading,
+  Image,
+  ImageHotspots,
+  ImagePairing,
+  ImageSequencing,
+  ImageSlider,
+  InformationWall,
+  InteractiveBook,
+  InteractiveVideo,
+  MarkTheWords,
+  MemoryGame,
+  Page,
+  ParallaxSlideshow,
+  Questionnaire,
+  Slide,
+  SlideDeck,
+  Summary,
+  Text,
+  TimedCue,
+  TrueFalse,
+  Video
+});