@lessonkit/react 1.4.0 → 1.5.0

package/dist/{chunk-4LQ4TTEE.js → chunk-5P23C2W3.js}

@@ -3,7 +3,9 @@ import {
   CompoundPageIndexProvider,
   CompoundProvider,
   LessonkitContext,
+  aggregateAssessmentScores,
   buildAssessmentHandle,
+  getLessonkitBlockType,
   isDevEnvironment,
   meetsPassingThreshold,
   normalizeComponentId,
@@ -23,7 +25,7 @@ import {
   usePluginScoring,
   validateAccordionSections,
   validateCompoundChildren
-} from "./chunk-TDM3ARE7.js";
+} from "./chunk-7TJQJFYR.js";
 
 // src/blocks/TrueFalse.tsx
 import React, { forwardRef, useEffect, useMemo, useRef, useState } from "react";
@@ -62,7 +64,7 @@ function TrueFalseInner(props, ref) {
     if (passed) {
       return { score: completedScore ?? maxScore, maxScore };
     }
-    if (selectionCorrect) {
+    if (selected !== null && selectionCorrect) {
       return { score: completedMaxScore ?? maxScore, maxScore };
     }
     return { score: 0, maxScore };
@@ -134,7 +136,9 @@ function TrueFalseInner(props, ref) {
           if (nextPassed) {
             const maxScore = nextCompletedMaxScore ?? completedMaxScore ?? 1;
             const score = nextCompletedScore ?? completedScore ?? maxScore;
-            replayTelemetry(nextSelected ?? null, nextCorrect ?? null, nextPassed, score, maxScore);
+            if (config.tracking?.replayResumeEvents === true) {
+              replayTelemetry(nextSelected ?? null, nextCorrect ?? null, nextPassed, score, maxScore);
+            }
           }
         }
         readBooleanStateField(state, "showSolutions", setShowSolutions);
@@ -150,7 +154,8 @@ function TrueFalseInner(props, ref) {
       props.question,
       selected,
       selectionCorrect,
-      showSolutions
+      showSolutions,
+      config.tracking?.replayResumeEvents
     ]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
@@ -179,6 +184,17 @@ function TrueFalseInner(props, ref) {
         maxScore: scored.maxScore,
         passingScore: props.passingScore ?? scored.maxScore
       });
+    } else if (!scored.passed && props.enableRetry === false && !completedRef.current) {
+      completedRef.current = 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;
@@ -244,11 +260,13 @@ function MarkTheWordsInner(props, ref) {
   );
   const [marked, setMarked] = useState2(() => /* @__PURE__ */ new Set());
   const [passed, setPassed] = useState2(false);
+  const [submitted, setSubmitted] = useState2(false);
   const [showSolutions, setShowSolutions] = useState2(false);
   const completedRef = useRef2(false);
   const reset = () => {
     completedRef.current = false;
     setPassed(false);
+    setSubmitted(false);
     setMarked(/* @__PURE__ */ new Set());
     setShowSolutions(false);
   };
@@ -306,6 +324,27 @@ function MarkTheWordsInner(props, ref) {
       return next;
     });
   };
+  const submitMarks = () => {
+    if (!hasTargets || completedRef.current || marked.size === 0) return;
+    completedRef.current = true;
+    setSubmitted(true);
+    const didPass = passedThreshold;
+    if (didPass) setPassed(true);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION2,
+      question: props.text,
+      response: [...marked].map((i) => tokens[i]),
+      correct: didPass
+    });
+    assessment.complete({
+      checkId,
+      interactionType: INTERACTION2,
+      score,
+      maxScore,
+      passingScore: props.passingScore ?? maxScore
+    });
+  };
   useEffect2(() => {
     if (!hasTargets) {
       if (isDevEnvironment()) {
@@ -316,8 +355,10 @@ function MarkTheWordsInner(props, ref) {
       }
       return;
     }
+    if (props.enableRetry === false) return;
     if (!passedThreshold || completedRef.current) return;
     completedRef.current = true;
+    setSubmitted(true);
     setPassed(true);
     assessment.answer({
       checkId,
@@ -340,6 +381,7 @@ function MarkTheWordsInner(props, ref) {
     marked,
     maxScore,
     passedThreshold,
+    props.enableRetry,
     props.passingScore,
     props.correctWords,
     props.text,
@@ -377,7 +419,8 @@ function MarkTheWordsInner(props, ref) {
         i
       );
     }) }),
-    allMarked ? /* @__PURE__ */ jsx2("p", { role: "status", "aria-live": "polite", children: "Correct" }) : null,
+    passedThreshold ? /* @__PURE__ */ jsx2("p", { role: "status", "aria-live": "polite", children: "Correct" }) : null,
+    props.enableRetry === false && hasTargets && marked.size > 0 && !submitted ? /* @__PURE__ */ jsx2("button", { type: "button", "data-testid": "mark-the-words-submit", onClick: submitMarks, children: "Submit" }) : null,
     props.enableRetry && passed ? /* @__PURE__ */ jsx2("button", { type: "button", onClick: reset, children: "Try again" }) : null,
     props.enableSolutionsButton && !showSolutions ? /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
   ] });
@@ -388,7 +431,7 @@ var MarkTheWords = forwardRef2(function MarkTheWords2(props, ref) {
 });
 
 // src/blocks/FillInTheBlanks.tsx
-import React3, { forwardRef as forwardRef3, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
+import React3, { forwardRef as forwardRef3, useCallback, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
 
 // src/assessment/internal/parseStarDelimitedTemplate.ts
 function parseStarDelimitedTemplate(template, idPrefix) {
@@ -418,11 +461,43 @@ function parseTemplate(template) {
     blanks: values.map((answer, i) => ({ id: `blank-${i}`, answer }))
   };
 }
+function normalizeBlanks(blanks) {
+  return blanks.map((b) => ({ id: b.id.trim(), answer: b.answer.trim() })).filter((b) => b.id.length > 0 && b.answer.length > 0);
+}
+function resolveBlanks(template, explicitBlanks) {
+  const parsed = parseTemplate(template);
+  if (!explicitBlanks) {
+    return { parts: parsed.parts, blanks: parsed.blanks };
+  }
+  const normalized = normalizeBlanks(explicitBlanks);
+  if (normalized.length !== parsed.blanks.length) {
+    if (isDevEnvironment()) {
+      console.warn(
+        "[lessonkit] FillInTheBlanks: blanks length does not match template; using parsed blanks",
+        { templateBlanks: parsed.blanks.length, explicitBlanks: normalized.length }
+      );
+    }
+    return { parts: parsed.parts, blanks: parsed.blanks };
+  }
+  let blankIdx = 0;
+  const interleavedParts = parsed.parts.map((part) => {
+    if (part.startsWith("blank-")) {
+      const id = normalized[blankIdx]?.id;
+      blankIdx += 1;
+      return id ?? part;
+    }
+    return part;
+  });
+  return { parts: interleavedParts, blanks: normalized };
+}
 function FillInTheBlanksInner(props, ref) {
   const checkId = useMemo3(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
   const assessment = useAssessmentState(props.enclosingLessonId);
-  const parsed = useMemo3(() => parseTemplate(props.template), [props.template]);
-  const blanks = props.blanks ?? parsed.blanks;
+  const { config } = useLessonkit();
+  const { parts, blanks } = useMemo3(
+    () => resolveBlanks(props.template, props.blanks),
+    [props.template, props.blanks]
+  );
   const [values, setValues] = useState3(
     () => Object.fromEntries(blanks.map((b) => [b.id, ""]))
   );
@@ -521,13 +596,14 @@ function FillInTheBlanksInner(props, ref) {
         blanks.forEach((b) => {
           if ((nextValues[b.id] ?? "").trim().toLowerCase() === b.answer.toLowerCase()) nextScore += 1;
         });
-        replayTelemetry(nextValues, nextPassed, nextSubmitted, nextScore, blanks.length);
+        if (config.tracking?.replayResumeEvents === true) {
+          replayTelemetry(nextValues, nextPassed, nextSubmitted, nextScore, blanks.length);
+        }
       }
     }),
-    [allFilled, assessment, blanks, checkId, maxScore, passed, passedThreshold, props.passingScore, props.template, score, showSolutions, submitted, values]
+    [allFilled, assessment, blanks, checkId, config.tracking?.replayResumeEvents, maxScore, passed, passedThreshold, props.passingScore, props.template, score, showSolutions, submitted, values]
   );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const check = () => {
+  const check = useCallback(() => {
     if (!hasBlanks) {
       if (isDevEnvironment()) {
         console.warn("[lessonkit] FillInTheBlanks has no blanks in template");
@@ -535,7 +611,7 @@ function FillInTheBlanksInner(props, ref) {
       return;
     }
     if (!allFilled) return;
-    if (passed) return;
+    if (passed && !props.enableRetry) return;
     const snapshot = JSON.stringify(values);
     if (checkSnapshotRef.current === snapshot) return;
     checkSnapshotRef.current = snapshot;
@@ -548,9 +624,9 @@ function FillInTheBlanksInner(props, ref) {
       response: values,
       correct: passedThreshold
     });
-    if (passedThreshold && !completedRef.current) {
+    if ((passedThreshold || props.enableRetry === false) && !completedRef.current) {
       completedRef.current = true;
-      setPassed(true);
+      if (passedThreshold) setPassed(true);
       assessment.complete({
         checkId,
         interactionType: INTERACTION3,
@@ -559,7 +635,22 @@ function FillInTheBlanksInner(props, ref) {
         passingScore: props.passingScore ?? maxScore
       });
     }
-  };
+  }, [
+    allFilled,
+    assessment,
+    blanks.length,
+    checkId,
+    hasBlanks,
+    maxScore,
+    passed,
+    passedThreshold,
+    props.enableRetry,
+    props.passingScore,
+    props.template,
+    score,
+    values
+  ]);
+  useAssessmentHandleRegistration(checkId, handle, ref);
   useEffect3(() => {
     if (!allFilled) {
       answeredRef.current = false;
@@ -569,14 +660,17 @@ function FillInTheBlanksInner(props, ref) {
   }, [allFilled]);
   useEffect3(() => {
     if (props.autoCheck && allFilled && !passed) check();
-  }, [allFilled, props.autoCheck, values, passedThreshold, passed]);
+  }, [allFilled, check, passed, props.autoCheck]);
   const reveal = showSolutions || passed && props.enableSolutionsButton;
   return /* @__PURE__ */ jsxs3("section", { "aria-label": "Fill in the Blanks", "data-lk-check-id": checkId, children: [
-    /* @__PURE__ */ jsx3("p", { children: parsed.parts.map((part, i) => {
+    /* @__PURE__ */ jsx3("p", { children: parts.map((part, i) => {
       const blank = blanks.find((b) => b.id === part);
       if (!blank) return /* @__PURE__ */ jsx3(React3.Fragment, { children: part }, i);
       return /* @__PURE__ */ jsxs3("label", { style: { margin: "0 0.25em" }, children: [
-        /* @__PURE__ */ jsx3("span", { className: "lk-visually-hidden", children: blank.answer }),
+        /* @__PURE__ */ jsxs3("span", { className: "lk-visually-hidden", children: [
+          "Blank ",
+          blank.id
+        ] }),
         /* @__PURE__ */ jsx3(
           "input",
           {
@@ -593,7 +687,16 @@ function FillInTheBlanksInner(props, ref) {
         )
       ] }, blank.id);
     }) }),
-    !props.autoCheck ? /* @__PURE__ */ jsx3("button", { type: "button", "data-testid": "check-blanks", disabled: !allFilled || passed, onClick: check, children: "Check" }) : null,
+    !props.autoCheck ? /* @__PURE__ */ jsx3(
+      "button",
+      {
+        type: "button",
+        "data-testid": "check-blanks",
+        disabled: !allFilled || passed && !props.enableRetry,
+        onClick: check,
+        children: "Check"
+      }
+    ) : null,
     !hasBlanks ? /* @__PURE__ */ jsx3("p", { role: "alert", children: "This activity has no blanks. Add text wrapped in asterisks, e.g. The *answer* here." }) : null,
     submitted ? /* @__PURE__ */ jsx3("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null,
     props.enableRetry && passed ? /* @__PURE__ */ jsx3("button", { type: "button", onClick: reset, children: "Try again" }) : null,
@@ -618,6 +721,7 @@ function parseZones(template) {
 function DragTheWordsInner(props, ref) {
   const checkId = useMemo4(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
   const assessment = useAssessmentState(props.enclosingLessonId);
+  const { config } = useLessonkit();
   const { parts, answers } = useMemo4(() => parseZones(props.template), [props.template]);
   const [zones, setZones] = useState4(
     () => Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""]))
@@ -722,10 +826,12 @@ function DragTheWordsInner(props, ref) {
         answers.forEach((ans, i) => {
           if ((nextZones[`zone-${i}`] ?? "").trim().toLowerCase() === ans.toLowerCase()) nextScore += 1;
         });
-        replayTelemetry(nextZones, nextPassed, nextSubmitted, nextScore, answers.length);
+        if (config.tracking?.replayResumeEvents === true) {
+          replayTelemetry(nextZones, nextPassed, nextSubmitted, nextScore, answers.length);
+        }
       }
     }),
-    [allFilled, answers, assessment, checkId, keyboardWord, maxScore, passed, passedThreshold, pool, props.passingScore, props.template, score, submitted, zones]
+    [allFilled, answers, assessment, checkId, config.tracking?.replayResumeEvents, keyboardWord, maxScore, passed, passedThreshold, pool, props.passingScore, props.template, score, submitted, zones]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   const placeInZone = (zoneId, word) => {
@@ -768,9 +874,9 @@ function DragTheWordsInner(props, ref) {
       response: zones,
       correct: passedThreshold
     });
-    if (passedThreshold && !completedRef.current) {
+    if ((passedThreshold || props.enableRetry === false) && !completedRef.current) {
       completedRef.current = true;
-      setPassed(true);
+      if (passedThreshold) setPassed(true);
       assessment.complete({
         checkId,
         interactionType: INTERACTION4,
@@ -832,7 +938,16 @@ function DragTheWordsInner(props, ref) {
         part
       );
     }) }),
-    /* @__PURE__ */ jsx4("button", { type: "button", "data-testid": "check-drag-words", disabled: !allFilled || passed, onClick: check, children: "Check" }),
+    /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        "data-testid": "check-drag-words",
+        disabled: !allFilled || passed && !props.enableRetry,
+        onClick: check,
+        children: "Check"
+      }
+    ),
     !hasZones ? /* @__PURE__ */ jsx4("p", { role: "alert", children: "This activity has no drop zones. Wrap answers in asterisks in the template." }) : null,
     submitted ? /* @__PURE__ */ jsx4("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null
   ] });
@@ -846,6 +961,37 @@ var DragTheWords = forwardRef4(function DragTheWords2(props, ref) {
 import { forwardRef as forwardRef5, useEffect as useEffect5, useMemo as useMemo5, useRef as useRef5, useState as useState5 } from "react";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var INTERACTION5 = "dragAndDrop";
+function normalizeDragAndDropState(rawAssignments, rawPool, items, targets) {
+  const itemIds = new Set(items.map((i) => i.id));
+  const targetIds = targets.map((t) => t.id);
+  const assignments = Object.fromEntries(targetIds.map((id) => [id, ""]));
+  if (rawAssignments && typeof rawAssignments === "object") {
+    for (const targetId of targetIds) {
+      const value = rawAssignments[targetId];
+      if (typeof value === "string" && (value === "" || itemIds.has(value))) {
+        assignments[targetId] = value;
+      }
+    }
+  }
+  const assigned = new Set(Object.values(assignments).filter(Boolean));
+  const pool = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (Array.isArray(rawPool)) {
+    for (const id of rawPool) {
+      if (typeof id === "string" && itemIds.has(id) && !assigned.has(id) && !seen.has(id)) {
+        pool.push(id);
+        seen.add(id);
+      }
+    }
+  }
+  for (const item of items) {
+    if (!assigned.has(item.id) && !seen.has(item.id)) {
+      pool.push(item.id);
+      seen.add(item.id);
+    }
+  }
+  return { assignments, pool };
+}
 function DragAndDropInner(props, ref) {
   const checkId = useMemo5(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
   const assessment = useAssessmentState(props.enclosingLessonId);
@@ -895,11 +1041,14 @@ function DragAndDropInner(props, ref) {
       }),
       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]);
+        const normalized = normalizeDragAndDropState(
+          state.assignments,
+          state.pool,
+          props.items,
+          props.targets
+        );
+        setAssignments(normalized.assignments);
+        setPool(normalized.pool);
         readBooleanStateField(state, "passed", (value) => {
           setPassed(value);
           completedRef.current = value;
@@ -932,9 +1081,9 @@ function DragAndDropInner(props, ref) {
       response: assignments,
       correct: passedThreshold
     });
-    if (passedThreshold && !completedRef.current) {
+    if ((passedThreshold || props.enableRetry === false) && !completedRef.current) {
       completedRef.current = true;
-      setPassed(true);
+      if (passedThreshold) setPassed(true);
       assessment.complete({
         checkId,
         interactionType: INTERACTION5,
@@ -997,7 +1146,16 @@ function DragAndDropInner(props, ref) {
         )
       ] }, target.id);
     }) }),
-    /* @__PURE__ */ jsx5("button", { type: "button", "data-testid": "check-drag-drop", disabled: !hasTargets || !allFilled || passed, onClick: check, children: "Check" }),
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        "data-testid": "check-drag-drop",
+        disabled: !hasTargets || !allFilled || passed && !props.enableRetry,
+        onClick: check,
+        children: "Check"
+      }
+    ),
     checked ? /* @__PURE__ */ jsx5("p", { role: "status", "aria-live": "polite", children: passedThreshold ? "Correct" : "Try again" }) : null
   ] });
 }
@@ -1007,7 +1165,7 @@ var DragAndDrop = forwardRef5(function DragAndDrop2(props, ref) {
 });
 
 // src/blocks/AssessmentSequence.tsx
-import React7, { forwardRef as forwardRef6, useCallback as useCallback4, useEffect as useEffect8, useId, useMemo as useMemo7, useRef as useRef8, useState as useState6 } from "react";
+import React7, { forwardRef as forwardRef6, useCallback as useCallback5, useEffect as useEffect8, useId, useMemo as useMemo7, useRef as useRef8, useState as useState6 } from "react";
 import { deriveId } from "@lessonkit/core";
 
 // src/compound/useCompoundShell.ts
@@ -1015,13 +1173,13 @@ import { useMemo as useMemo6 } from "react";
 import { clampCompoundPageIndex as clampCompoundPageIndex2 } from "@lessonkit/core";
 
 // src/compound/useCompoundNavigation.ts
-import { useCallback } from "react";
+import { useCallback as useCallback2 } from "react";
 function useCompoundNavigation(pageCount, index, setIndex) {
-  const goNext = useCallback(() => {
+  const goNext = useCallback2(() => {
     if (pageCount < 1) return;
     setIndex((i) => Math.min(i + 1, pageCount - 1));
   }, [pageCount, setIndex]);
-  const goPrev = useCallback(() => {
+  const goPrev = useCallback2(() => {
     setIndex((i) => Math.max(i - 1, 0));
   }, [setIndex]);
   const clampedIndex = pageCount < 1 ? 0 : Math.min(index, pageCount - 1);
@@ -1035,34 +1193,138 @@ function useCompoundNavigation(pageCount, index, setIndex) {
 }
 
 // src/compound/useCompoundPersistence.ts
-import { useCallback as useCallback3, useContext as useContext2, useEffect as useEffect7, useRef as useRef7 } from "react";
+import { useCallback as useCallback4, useContext as useContext2, useEffect as useEffect7, useLayoutEffect, useRef as useRef7 } from "react";
 import {
   clampCompoundPageIndex,
-  createCompoundResumeState,
+  createCompoundResumeState as createCompoundResumeState3,
   createSessionStoragePort as createSessionStoragePort2,
   loadCompoundState as loadCompoundState2
 } from "@lessonkit/core";
 
+// src/compound/compoundHydration.ts
+var hydratedKeys = /* @__PURE__ */ new Set();
+function compoundHydrationKey(courseId, compoundId) {
+  return `${courseId}:${compoundId}`;
+}
+function markCompoundHydrated(key) {
+  hydratedKeys.add(key);
+}
+function isCompoundHydrated(key) {
+  return hydratedKeys.has(key);
+}
+function clearCompoundHydrated(key) {
+  hydratedKeys.delete(key);
+}
+
+// src/compound/useCompoundBranchShell.ts
+import "@lessonkit/core";
+var BS_META_KEY = "__lk_bs__";
+function createInitialBranchMeta(startNodeId) {
+  return { activeNodeId: startNodeId, visitedNodeIds: [startNodeId] };
+}
+function readBranchingScenarioMeta(childStates) {
+  const raw = childStates[BS_META_KEY];
+  if (!raw || typeof raw !== "object") return null;
+  const activeNodeId = typeof raw.activeNodeId === "string" ? raw.activeNodeId : "";
+  const visitedNodeIds = Array.isArray(raw.visitedNodeIds) ? raw.visitedNodeIds.filter((id) => typeof id === "string") : [];
+  const choiceScores = raw.choiceScores && typeof raw.choiceScores === "object" && !Array.isArray(raw.choiceScores) ? raw.choiceScores : void 0;
+  if (!activeNodeId) return null;
+  return { activeNodeId, visitedNodeIds, choiceScores };
+}
+function sanitizeBranchMeta(meta, nodeIndexMap, startNodeId, validChoiceKeys) {
+  const knownIds = new Set(nodeIndexMap.keys());
+  const activeNodeId = knownIds.has(meta.activeNodeId) ? meta.activeNodeId : startNodeId;
+  const visitedNodeIds = meta.visitedNodeIds.filter((id) => knownIds.has(id));
+  if (!visitedNodeIds.includes(activeNodeId)) {
+    visitedNodeIds.push(activeNodeId);
+  }
+  if (visitedNodeIds.length === 0) {
+    visitedNodeIds.push(startNodeId);
+  }
+  const choiceScores = meta.choiceScores ? Object.fromEntries(
+    Object.entries(meta.choiceScores).filter(
+      ([key]) => validChoiceKeys ? validChoiceKeys.has(key) : knownIds.has(key.split(":")[0] ?? "")
+    )
+  ) : void 0;
+  return {
+    activeNodeId,
+    visitedNodeIds,
+    ...Object.keys(choiceScores ?? {}).length > 0 ? { choiceScores } : {}
+  };
+}
+function mergeBranchMetaIntoState(state, meta) {
+  return {
+    ...state,
+    childStates: {
+      ...state.childStates,
+      [BS_META_KEY]: meta
+    }
+  };
+}
+function choiceScoreKey(fromNodeId, toNodeId) {
+  return `${fromNodeId}:${toNodeId}`;
+}
+function applyChoiceScoreUpdate(prev, fromNodeId, toNodeId, scoreWeight) {
+  if (scoreWeight === void 0) return prev;
+  const next = { ...prev ?? {} };
+  for (const key of Object.keys(next)) {
+    if (key.startsWith(`${fromNodeId}:`)) {
+      delete next[key];
+    }
+  }
+  next[choiceScoreKey(fromNodeId, toNodeId)] = scoreWeight;
+  return next;
+}
+function sumChoiceScores(choiceScores) {
+  if (!choiceScores) return 0;
+  return Object.values(choiceScores).reduce((sum, value) => sum + (Number.isFinite(value) ? value : 0), 0);
+}
+
+// src/compound/useCompoundVideoShell.ts
+import "@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") : [];
+  const firedCueIndices = Array.isArray(raw.firedCueIndices) ? raw.firedCueIndices.filter((n) => typeof n === "number") : completedCueIndices;
+  return { currentTime, completedCueIndices, firedCueIndices };
+}
+function mergeVideoMetaIntoState(state, meta) {
+  return {
+    ...state,
+    childStates: {
+      ...state.childStates,
+      [IV_META_KEY]: meta
+    }
+  };
+}
+
 // src/compound/resumeChildHandles.ts
-function filterRegisteredChildStates(handles, childStates) {
+var DEFAULT_PRESERVED_CHILD_STATE_KEYS = /* @__PURE__ */ new Set([BS_META_KEY, IV_META_KEY]);
+function registerablePendingKeys(childStates, preserveKeys = DEFAULT_PRESERVED_CHILD_STATE_KEYS) {
+  return Object.keys(childStates).filter((key) => !preserveKeys.has(key));
+}
+function filterRegisteredChildStates(handles, childStates, preserveKeys = DEFAULT_PRESERVED_CHILD_STATE_KEYS) {
   const filtered = {};
   for (const [key, value] of Object.entries(childStates)) {
-    if (handles.has(key)) {
+    if (preserveKeys.has(key) || 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) {
+  const registerableKeys = registerablePendingKeys(childStates);
+  if (opts?.waitForHandles && registerableKeys.length > 0) {
     if (handles.size === 0) return false;
-    const registeredPending = pendingKeys.filter((k) => handles.has(k));
+    const registeredPending = registerableKeys.filter((k) => handles.has(k));
     if (registeredPending.length === 0) {
       return false;
     }
-    if (registeredPending.length < pendingKeys.length) {
+    if (registeredPending.length < registerableKeys.length) {
       for (const key of registeredPending) {
         if (alreadyResumed?.has(key)) continue;
         const handle = handles.get(key);
@@ -1087,15 +1349,27 @@ function resumeChildHandles(handles, childStates, opts) {
 }
 
 // src/compound/useCompoundResume.ts
-import { useCallback as useCallback2, useContext, useEffect as useEffect6, useRef as useRef6 } from "react";
+import { useCallback as useCallback3, useContext, useEffect as useEffect6, useRef as useRef6 } from "react";
 import { loadCompoundState, saveCompoundState } from "@lessonkit/core";
 import { createSessionStoragePort } from "@lessonkit/core";
-var warnedCompoundPersistFailure = false;
-function warnCompoundPersistFailure() {
-  if (warnedCompoundPersistFailure || !isDevEnvironment()) return;
-  warnedCompoundPersistFailure = true;
+
+// src/compound/compoundLoadOpts.ts
+function compoundLoadOpts(ctx, compoundId) {
+  const onCorruptHook = ctx?.config?.observability?.onCompoundResumeCorrupt;
+  if (!onCorruptHook) return void 0;
+  return {
+    onCorrupt: () => onCorruptHook({ compoundId, corrupt: true }),
+    onDroppedChildKeys: (droppedChildKeys) => onCorruptHook({ compoundId, droppedChildKeys })
+  };
+}
+
+// src/compound/useCompoundResume.ts
+var warnedCompoundPersistFailures = /* @__PURE__ */ new Set();
+function warnCompoundPersistFailure(compoundId) {
+  if (warnedCompoundPersistFailures.has(compoundId) || !isDevEnvironment()) return;
+  warnedCompoundPersistFailures.add(compoundId);
   console.warn(
-    "[lessonkit] compound resume state could not be saved to sessionStorage (quota or privacy mode); progress may be lost on reload."
+    `[lessonkit] compound resume state for "${compoundId}" could not be saved to sessionStorage (quota or privacy mode); progress may be lost on reload.`
   );
 }
 function useCompoundResume(opts) {
@@ -1118,23 +1392,37 @@ function useCompoundResume(opts) {
       resumedRef.current = false;
     }
     if (!opts.enabled || !opts.courseId || resumedRef.current) return;
-    const saved = loadCompoundState(storageRef.current, opts.courseId, opts.compoundId);
+    if (isCompoundHydrated(key)) {
+      resumedRef.current = true;
+      return;
+    }
+    const saved = loadCompoundState(
+      storageRef.current,
+      opts.courseId,
+      opts.compoundId,
+      compoundLoadOpts(lessonkitCtx, opts.compoundId)
+    );
     if (saved) {
       resumedRef.current = true;
       opts.onResume?.(saved);
     }
   }, [opts.enabled, opts.courseId, opts.compoundId, opts.onResume]);
-  return useCallback2(
+  return useCallback3(
     (state) => {
       if (!opts.enabled || !opts.courseId) return;
       const persisted = saveCompoundState(storageRef.current, opts.courseId, opts.compoundId, state);
-      if (!persisted) warnCompoundPersistFailure();
+      if (!persisted) warnCompoundPersistFailure(opts.compoundId);
     },
     [opts.enabled, opts.courseId, opts.compoundId]
   );
 }
 
 // src/compound/useCompoundPersistence.ts
+var MAX_HYDRATION_RETRIES = 10;
+function isEmptyResumeState(state) {
+  if (!state || typeof state !== "object") return true;
+  return Object.keys(state).length === 0;
+}
 function readCompoundInitialIndex(courseId, compoundId, pageCount, enabled, storage = createSessionStoragePort2()) {
   if (!enabled || !courseId || pageCount < 1) return 0;
   const saved = loadCompoundState2(storage, courseId, compoundId);
@@ -1154,51 +1442,60 @@ function useCompoundPersistence(opts) {
   const resumedChildKeysRef = useRef7(/* @__PURE__ */ new Set());
   const loadedChildStatesRef = useRef7({});
   const skipSaveUntilHydratedRef = useRef7(false);
+  const postResumePersistPendingRef = useRef7(false);
   const hydrationKeyRef = useRef7("");
-  const hydrationInitRef = useRef7(false);
+  const hydrationRetryRef = useRef7(0);
   const hydrationKey = `${opts.courseId ?? ""}:${opts.compoundId}`;
   if (hydrationKeyRef.current !== hydrationKey) {
+    if (hydrationKeyRef.current) {
+      clearCompoundHydrated(hydrationKeyRef.current);
+    }
     hydrationKeyRef.current = hydrationKey;
-    hydrationInitRef.current = false;
     loadedChildStatesRef.current = {};
     skipSaveUntilHydratedRef.current = false;
+    postResumePersistPendingRef.current = false;
     pendingChildResumeRef.current = null;
     resumedChildKeysRef.current = /* @__PURE__ */ new Set();
+    hydrationRetryRef.current = 0;
   }
-  if (!hydrationInitRef.current && opts.enabled && opts.courseId) {
-    hydrationInitRef.current = true;
-    const saved = loadCompoundState2(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 = useCallback3(() => {
+  const buildState = useCallback4(() => {
     const childStates = {
       ...loadedChildStatesRef.current
     };
     if (ctx) {
       for (const [checkId, entry] of ctx.getRegisteredHandles()) {
+        if (opts.shouldIncludeChildState && !opts.shouldIncludeChildState(checkId, entry.pageIndex)) {
+          continue;
+        }
         const handle = entry.handle;
         if (handle.getCurrentState) {
-          childStates[checkId] = handle.getCurrentState();
-          delete loadedChildStatesRef.current[checkId];
+          const live = handle.getCurrentState();
+          const loaded = loadedChildStatesRef.current[checkId];
+          if (loaded !== void 0 && isEmptyResumeState(live)) {
+            childStates[checkId] = loaded;
+          } else {
+            childStates[checkId] = live;
+            if (!isEmptyResumeState(live)) {
+              delete loadedChildStatesRef.current[checkId];
+            }
+          }
         }
       }
     }
-    return createCompoundResumeState({
+    return createCompoundResumeState3({
       activePageIndex: clampCompoundPageIndex(opts.index, opts.pageCount),
       childStates
     });
-  }, [ctx, opts.index, opts.pageCount]);
+  }, [ctx, opts.index, opts.pageCount, opts.shouldIncludeChildState]);
   const buildStateRef = useRef7(buildState);
   buildStateRef.current = buildState;
   const transformStateRef = useRef7(opts.transformState);
   transformStateRef.current = opts.transformState;
+  const onCompoundResumeRef = useRef7(opts.onCompoundResume);
+  onCompoundResumeRef.current = opts.onCompoundResume;
   const persistNowRef = useRef7(() => {
   });
-  const finalizeHydration = useCallback3(
+  const finalizeHydration = useCallback4(
     (childStates) => {
       loadedChildStatesRef.current = {
         ...loadedChildStatesRef.current,
@@ -1206,11 +1503,20 @@ function useCompoundPersistence(opts) {
       };
       skipSaveUntilHydratedRef.current = false;
       pendingChildResumeRef.current = null;
-      queueMicrotask(() => persistNowRef.current());
+      hydrationRetryRef.current = 0;
+      postResumePersistPendingRef.current = true;
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          postResumePersistPendingRef.current = false;
+          persistNowRef.current();
+        });
+      });
     },
     []
   );
-  const applyPendingChildResume = useCallback3(() => {
+  const applyPendingChildResumeRef = useRef7(() => {
+  });
+  const applyPendingChildResume = useCallback4(() => {
     const pending = pendingChildResumeRef.current;
     if (!pending || !ctx) return;
     const handles = ctx.getHandles();
@@ -1219,30 +1525,57 @@ function useCompoundPersistence(opts) {
       alreadyResumed: resumedChildKeysRef.current
     });
     if (!applied) {
-      if (handles.size === 0) {
-        const registeredOnly2 = stripOrphanChildStates(handles, pending.childStates);
-        resumeChildHandles(handles, registeredOnly2, {
-          alreadyResumed: resumedChildKeysRef.current
-        });
-        finalizeHydration(registeredOnly2);
+      const registerable = registerablePendingKeys(pending.childStates);
+      const missing = registerable.filter((k) => !handles.has(k));
+      if (missing.length > 0 && hydrationRetryRef.current < MAX_HYDRATION_RETRIES) {
+        hydrationRetryRef.current += 1;
+        requestAnimationFrame(() => applyPendingChildResumeRef.current());
         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);
+      if (missing.length > 0 && isDevEnvironment()) {
+        console.warn(
+          `[lessonkit] Compound hydration: ${missing.length} child state(s) not restored (missing handles: ${missing.join(", ")})`
+        );
+      }
+      lessonkitCtx?.config?.observability?.onCompoundHydrationPartial?.({
+        compoundId: opts.compoundId,
+        missingCheckIds: missing
+      });
+      for (const key of missing) {
+        const state = pending.childStates[key];
+        if (state) {
+          loadedChildStatesRef.current[key] = state;
+        }
+      }
+      const registeredOnly2 = stripOrphanChildStates(handles, pending.childStates);
+      resumeChildHandles(handles, registeredOnly2, {
+        alreadyResumed: resumedChildKeysRef.current
+      });
+      finalizeHydration({
+        ...loadedChildStatesRef.current,
+        ...registeredOnly2
       });
       return;
     }
     const registeredOnly = stripOrphanChildStates(handles, pending.childStates);
     finalizeHydration(registeredOnly);
   }, [ctx, finalizeHydration]);
+  applyPendingChildResumeRef.current = applyPendingChildResume;
+  useLayoutEffect(() => {
+    if (!opts.enabled || !opts.courseId) return;
+    markCompoundHydrated(compoundHydrationKey(opts.courseId, opts.compoundId));
+    const saved = loadCompoundState2(storage, opts.courseId, opts.compoundId);
+    if (!saved) return;
+    if (Object.keys(saved.childStates).length > 0) {
+      loadedChildStatesRef.current = { ...saved.childStates };
+      skipSaveUntilHydratedRef.current = true;
+      pendingChildResumeRef.current = saved;
+    }
+    const clamped = clampCompoundPageIndex(saved.activePageIndex, opts.pageCount);
+    onCompoundResumeRef.current?.({ ...saved, activePageIndex: clamped });
+    opts.setIndex(clamped);
+    queueMicrotask(() => applyPendingChildResumeRef.current());
+  }, [hydrationKey, opts.courseId, opts.compoundId, opts.enabled, opts.pageCount, storage]);
   const saveResume = useCompoundResume({
     courseId: opts.courseId,
     compoundId: opts.compoundId,
@@ -1252,29 +1585,65 @@ function useCompoundPersistence(opts) {
       const clamped = clampCompoundPageIndex(state.activePageIndex, opts.pageCount);
       loadedChildStatesRef.current = { ...state.childStates };
       skipSaveUntilHydratedRef.current = Object.keys(state.childStates).length > 0;
+      onCompoundResumeRef.current?.({ ...state, activePageIndex: clamped });
       opts.setIndex(clamped);
       resumedChildKeysRef.current = /* @__PURE__ */ new Set();
+      hydrationRetryRef.current = 0;
       pendingChildResumeRef.current = { ...state, activePageIndex: clamped, childStates: state.childStates };
       queueMicrotask(() => applyPendingChildResume());
     }
   });
-  const persistNow = useCallback3(() => {
-    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]);
+  const buildBestEffortState = useCallback4(() => {
+    const childStates = {
+      ...loadedChildStatesRef.current
+    };
+    if (ctx) {
+      for (const [checkId, entry] of ctx.getRegisteredHandles()) {
+        if (opts.shouldIncludeChildState && !opts.shouldIncludeChildState(checkId, entry.pageIndex)) {
+          continue;
+        }
+        const handle = entry.handle;
+        if (handle.getCurrentState) {
+          const live = handle.getCurrentState();
+          if (!isEmptyResumeState(live)) {
+            childStates[checkId] = live;
+          }
+        }
+      }
+    }
+    const built = createCompoundResumeState3({
+      activePageIndex: clampCompoundPageIndex(opts.index, opts.pageCount),
+      childStates
+    });
+    return transformStateRef.current ? transformStateRef.current(built) : built;
+  }, [ctx, opts.index, opts.pageCount, opts.shouldIncludeChildState]);
+  const persistNow = useCallback4(
+    (options) => {
+      if (!opts.enabled || !opts.courseId) return;
+      if (options?.forceDuringHydration) {
+        saveResume(buildBestEffortState());
+        return;
+      }
+      if (skipSaveUntilHydratedRef.current) return;
+      if (postResumePersistPendingRef.current) return;
+      const built = buildStateRef.current();
+      const state = transformStateRef.current ? transformStateRef.current(built) : built;
+      saveResume(state);
+    },
+    [opts.enabled, opts.courseId, saveResume, buildBestEffortState]
+  );
   useEffect7(() => {
     persistNowRef.current = persistNow;
   }, [persistNow]);
-  const notifyImperativeResume = useCallback3(
+  const notifyImperativeResume = useCallback4(
     (state) => {
       const clamped = clampCompoundPageIndex(state.activePageIndex, opts.pageCount);
       loadedChildStatesRef.current = { ...state.childStates };
       skipSaveUntilHydratedRef.current = Object.keys(state.childStates).length > 0;
+      onCompoundResumeRef.current?.({ ...state, activePageIndex: clamped });
       opts.setIndex(clamped);
       resumedChildKeysRef.current = /* @__PURE__ */ new Set();
+      hydrationRetryRef.current = 0;
       pendingChildResumeRef.current = { ...state, activePageIndex: clamped, childStates: state.childStates };
       queueMicrotask(() => applyPendingChildResume());
     },
@@ -1294,17 +1663,22 @@ function useCompoundPersistence(opts) {
   }, [opts.index, handlesVersion, applyPendingChildResume]);
   useEffect7(() => {
     persistNow();
-  }, [persistNow, opts.index, opts.pageCount, handlesVersion]);
+  }, [persistNow, opts.index, opts.pageCount, handlesVersion, opts.persistTrigger]);
   useEffect7(() => {
     if (!opts.enabled || !opts.courseId || typeof document === "undefined") return;
     const flushOnExit = () => {
-      if (document.visibilityState === "hidden") persistNow();
+      if (document.visibilityState === "hidden") {
+        persistNow({ forceDuringHydration: skipSaveUntilHydratedRef.current });
+      }
     };
     document.addEventListener("visibilitychange", flushOnExit);
-    window.addEventListener("pagehide", flushOnExit);
+    const flushOnPageHide = () => {
+      persistNow({ forceDuringHydration: skipSaveUntilHydratedRef.current });
+    };
+    window.addEventListener("pagehide", flushOnPageHide);
     return () => {
       document.removeEventListener("visibilitychange", flushOnExit);
-      window.removeEventListener("pagehide", flushOnExit);
+      window.removeEventListener("pagehide", flushOnPageHide);
     };
   }, [opts.enabled, opts.courseId, persistNow]);
 }
@@ -1320,7 +1694,9 @@ function useCompoundShell(opts) {
     setIndex: opts.setIndex,
     enabled: opts.persistEnabled,
     storage: opts.storage,
-    transformState: opts.transformState
+    transformState: opts.transformState,
+    persistTrigger: opts.persistTrigger,
+    onCompoundResume: opts.onCompoundResume
   });
   const { goNext, goPrev, progress } = useCompoundNavigation(opts.pageCount, opts.index, opts.setIndex);
   const visibleIndex = clampCompoundPageIndex2(opts.index, opts.pageCount);
@@ -1347,13 +1723,19 @@ function useCompoundInitialIndex(opts) {
   );
 }
 
-// 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/compound/requireCompoundBlockId.ts
+var MissingCompoundBlockIdError = class extends Error {
+  constructor(componentName) {
+    super(
+      `[lessonkit] <${componentName}> requires a unique blockId when session.persistCompoundState is enabled`
+    );
+    this.name = "MissingCompoundBlockIdError";
+  }
+};
+function requireCompoundBlockIdWhenPersisting(opts) {
+  if (opts.persistEnabled && !opts.blockId) {
+    throw new MissingCompoundBlockIdError(opts.componentName);
+  }
 }
 
 // src/blocks/AssessmentSequence.tsx
@@ -1362,7 +1744,10 @@ var AssessmentSequenceInner = forwardRef6(
   function AssessmentSequenceInner2(props, ref) {
     const { compoundId, childArray, index, setIndex, persistEnabled } = props;
     const sequential = props.sequential !== false;
+    const requireAnswerBeforeNext = props.requireAnswerBeforeNext !== false;
     const { config } = useLessonkit();
+    const registry = useCompoundRegistry();
+    const handlesVersion = useCompoundHandlesVersion();
     const { visibleIndex, goNext, goPrev, progress } = useCompoundShell({
       courseId: config.courseId,
       compoundId,
@@ -1374,6 +1759,21 @@ var AssessmentSequenceInner = forwardRef6(
       enableSolutionsButton: props.enableSolutionsButton
     });
     validateCompoundChildren("AssessmentSequence", props.children);
+    const activeStepAnswered = useMemo7(() => {
+      if (!requireAnswerBeforeNext || !registry) return true;
+      let handlesForStep = 0;
+      for (const entry of registry.getRegisteredHandles().values()) {
+        if (entry.pageIndex !== visibleIndex) continue;
+        handlesForStep += 1;
+        if (!entry.handle.getAnswerGiven()) return false;
+      }
+      if (handlesForStep === 0) {
+        const child = childArray[visibleIndex];
+        const childProps = child?.props;
+        if (child && typeof childProps?.checkId === "string") return false;
+      }
+      return true;
+    }, [childArray, handlesVersion, registry, requireAnswerBeforeNext, visibleIndex]);
     if (!sequential) {
       return /* @__PURE__ */ jsx6("section", { "aria-label": "Assessment sequence", "data-testid": "assessment-sequence", children: props.children });
     }
@@ -1401,7 +1801,7 @@ var AssessmentSequenceInner = forwardRef6(
           {
             type: "button",
             "data-testid": "sequence-next",
-            disabled: visibleIndex >= childArray.length - 1 || childArray.length === 0,
+            disabled: visibleIndex >= childArray.length - 1 || childArray.length === 0 || !activeStepAnswered,
             onClick: goNext,
             children: "Next"
           }
@@ -1417,22 +1817,22 @@ var AssessmentSequence = forwardRef6(
     if (!props.blockId && !autoCompoundIdRef.current) {
       autoCompoundIdRef.current = deriveId(`assessment-sequence-${reactInstanceId}`);
     }
-    const compoundId = useMemo7(
-      () => props.blockId ? normalizeComponentId(props.blockId, "blockId") : autoCompoundIdRef.current ?? DEFAULT_ASSESSMENT_SEQUENCE_COMPOUND_ID,
-      [props.blockId]
-    );
+    const compoundId = useMemo7(() => {
+      if (props.blockId) {
+        return normalizeComponentId(props.blockId, "blockId");
+      }
+      return autoCompoundIdRef.current ?? deriveId(`assessment-sequence-${reactInstanceId}`);
+    }, [props.blockId, reactInstanceId]);
     const childArray = React7.Children.toArray(props.children).filter(
       React7.isValidElement
     );
     const { config, storage } = useLessonkit();
     const persistEnabled = config.session?.persistCompoundState !== false;
-    useEffect8(() => {
-      warnSharedCompoundStorageKey({
-        persistEnabled,
-        hasExplicitBlockId: Boolean(props.blockId),
-        componentName: "AssessmentSequence"
-      });
-    }, [persistEnabled, props.blockId]);
+    requireCompoundBlockIdWhenPersisting({
+      persistEnabled,
+      blockId: props.blockId,
+      componentName: "AssessmentSequence"
+    });
     const initialIndex = useCompoundInitialIndex({
       courseId: config.courseId,
       compoundId,
@@ -1441,7 +1841,7 @@ var AssessmentSequence = forwardRef6(
       storage
     });
     const [index, setIndex] = useState6(initialIndex);
-    const setIndexStable = useCallback4((i) => setIndex(i), []);
+    const setIndexStable = useCallback5((i) => setIndex(i), []);
     useEffect8(() => {
       setIndex(initialIndex);
     }, [config.courseId, compoundId, initialIndex]);
@@ -1477,14 +1877,180 @@ function Heading(props) {
 }
 setLessonkitBlockType(Heading, "Heading");
 
+// src/blocks/embedSecurity.ts
+var BLOCKED_SANDBOX_TOKENS = /* @__PURE__ */ new Set([
+  "allow-top-navigation",
+  "allow-top-navigation-by-user-activation",
+  "allow-modals",
+  "allow-downloads",
+  "allow-popups-to-escape-sandbox"
+]);
+var ALLOWED_SANDBOX_TOKENS = /* @__PURE__ */ new Set([
+  "allow-forms",
+  "allow-popups",
+  "allow-presentation"
+]);
+var DEFAULT_SANDBOX = "allow-scripts";
+function isProductionEmbedBuild() {
+  try {
+    if (import.meta.env?.PROD === true) return true;
+  } catch {
+  }
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV === "production";
+}
+function allowedEmbedSchemes() {
+  return isProductionEmbedBuild() ? /* @__PURE__ */ new Set(["https:"]) : /* @__PURE__ */ new Set(["https:", "http:"]);
+}
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+}
+function expandIpv4Literal(hostname) {
+  if (/^\d+$/.test(hostname)) {
+    const value2 = Number(hostname);
+    if (!Number.isInteger(value2) || value2 < 0 || value2 > 4294967295) return null;
+    return `${value2 >>> 24 & 255}.${value2 >>> 16 & 255}.${value2 >>> 8 & 255}.${value2 & 255}`;
+  }
+  if (!/^\d+(?:\.\d+){1,3}$/.test(hostname)) return null;
+  const parts = hostname.split(".").map((part) => Number(part));
+  if (parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return null;
+  let value = 0;
+  for (const part of parts) {
+    value = value << 8 | part;
+  }
+  value <<= (4 - parts.length) * 8;
+  return `${value >>> 24 & 255}.${value >>> 16 & 255}.${value >>> 8 & 255}.${value & 255}`;
+}
+function canonicalHostnameForBlocklist(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return expandIpv4Literal(normalized) ?? normalized;
+}
+function isIpv4MappedAddress(hostname) {
+  const match = hostname.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+  return match?.[1] ?? null;
+}
+function isLoopbackHost(hostname) {
+  const ipv4Mapped = isIpv4MappedAddress(hostname);
+  if (ipv4Mapped) return isLoopbackHost(ipv4Mapped);
+  return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname) || hostname === "::1" || hostname === "0.0.0.0";
+}
+function isIpv6UniqueLocalHost(hostname) {
+  return /^f[cd][0-9a-f]{0,2}:/i.test(hostname);
+}
+function isLinkLocalOrMetadataHost(hostname) {
+  if (hostname === "169.254.169.254") return true;
+  if (/^169\.254\./.test(hostname)) return true;
+  if (/^fe80:/i.test(hostname)) return true;
+  return false;
+}
+function isRfc1918Host(hostname) {
+  const ipv4Mapped = isIpv4MappedAddress(hostname);
+  if (ipv4Mapped) return isRfc1918Host(ipv4Mapped);
+  if (/^10\./.test(hostname)) return true;
+  if (/^192\.168\./.test(hostname)) return true;
+  const parts = hostname.split(".").map(Number);
+  if (parts.length === 4 && parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
+  return false;
+}
+function isBlockedHost(hostname, allowedHosts) {
+  const normalized = normalizeHostname(hostname);
+  const canonical = canonicalHostnameForBlocklist(hostname);
+  if (allowedHosts?.some((host) => {
+    const allowedNormalized = normalizeHostname(host);
+    return canonicalHostnameForBlocklist(host) === canonical || allowedNormalized === normalized;
+  })) {
+    return false;
+  }
+  if (!isProductionEmbedBuild()) return false;
+  return isLoopbackHost(canonical) || isLinkLocalOrMetadataHost(canonical) || isRfc1918Host(canonical) || isIpv6UniqueLocalHost(normalized);
+}
+function resolveAllowedUrl(src, options) {
+  const trimmed = src.trim();
+  if (!trimmed) return null;
+  try {
+    const base = typeof window !== "undefined" ? window.location.href : "https://example.com/";
+    const url = new URL(trimmed, base);
+    if (!allowedEmbedSchemes().has(url.protocol)) return null;
+    if (isBlockedHost(url.hostname, options?.allowedHosts)) return null;
+    if (typeof window !== "undefined") {
+      const pageOrigin = window.location.origin;
+      const isAbsolute = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(trimmed) || trimmed.startsWith("//");
+      if (!isAbsolute && url.origin !== pageOrigin) return null;
+      if (trimmed.startsWith("//") && url.origin !== pageOrigin) return null;
+    }
+    url.username = "";
+    url.password = "";
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+function resolveEmbedSrc(src, options) {
+  return resolveAllowedUrl(src, options);
+}
+function resolveMediaSrc(src, options) {
+  if (src === void 0) return null;
+  return resolveAllowedUrl(src, options);
+}
+function buildEmbedSandbox(allow, options) {
+  const tokens = /* @__PURE__ */ new Set([DEFAULT_SANDBOX]);
+  if (allow) {
+    for (const raw of allow.split(/\s+/)) {
+      const token = raw.trim();
+      if (!token || BLOCKED_SANDBOX_TOKENS.has(token)) continue;
+      if (ALLOWED_SANDBOX_TOKENS.has(token)) tokens.add(token);
+    }
+  }
+  if (options?.restrictPopupsInProduction !== false && isProductionEmbedBuild()) {
+    tokens.delete("allow-popups");
+  }
+  return [...tokens].join(" ");
+}
+function telemetryEmbedSrc(src) {
+  try {
+    const url = new URL(src);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return src;
+  }
+}
+function resolveEmbedAspectRatio(aspectRatio) {
+  if (!aspectRatio) return void 0;
+  const trimmed = aspectRatio.trim();
+  if (!/^\d+(\.\d+)?\s*\/\s*\d+(\.\d+)?$/.test(trimmed)) return void 0;
+  const [numRaw, denRaw] = trimmed.split("/").map((part) => part.trim());
+  const num = Number(numRaw);
+  const den = Number(denRaw);
+  if (!Number.isFinite(num) || !Number.isFinite(den) || num <= 0 || den <= 0) return void 0;
+  return trimmed;
+}
+
 // src/blocks/Image.tsx
 import { jsx as jsx9 } from "react/jsx-runtime";
 function Image(props) {
-  return /* @__PURE__ */ jsx9(
-    "img",
-    {
-      src: props.src,
-      alt: props.alt,
+  const { config } = useLessonkit();
+  const resolvedSrc = resolveMediaSrc(props.src, {
+    allowedHosts: config.embed?.allowedHosts
+  });
+  if (!resolvedSrc) {
+    return /* @__PURE__ */ jsx9(
+      "figure",
+      {
+        "data-lk-block-id": props.blockId,
+        "data-testid": props.blockId ? `image-${props.blockId}` : "image",
+        children: /* @__PURE__ */ jsx9("p", { role: "alert", children: "This image URL is not allowed." })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx9(
+    "img",
+    {
+      src: resolvedSrc,
+      alt: props.alt,
       "data-lk-block-id": props.blockId,
       "data-testid": props.blockId ? `image-${props.blockId}` : "image",
       style: { maxWidth: "100%", height: "auto" }
@@ -1497,10 +2063,21 @@ setLessonkitBlockType(Image, "Image");
 import { useMemo as useMemo8 } from "react";
 import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
 function Video(props) {
+  const { config } = useLessonkit();
   const blockId = useMemo8(
     () => normalizeComponentId(props.blockId, "blockId"),
     [props.blockId]
   );
+  const mediaOptions = { allowedHosts: config.embed?.allowedHosts };
+  const resolvedSrc = resolveMediaSrc(props.src, mediaOptions);
+  const resolvedPoster = resolveMediaSrc(props.poster, mediaOptions);
+  const resolvedCaptions = resolveMediaSrc(props.captions, mediaOptions);
+  if (!resolvedSrc) {
+    return /* @__PURE__ */ jsxs7("section", { "aria-label": props.title ?? "Video", "data-lk-block-id": blockId, "data-testid": "video", children: [
+      props.title ? /* @__PURE__ */ jsx10("h3", { "data-testid": "video-title", children: props.title }) : null,
+      /* @__PURE__ */ jsx10("p", { role: "alert", "data-testid": "video-blocked", children: "This video URL is not allowed." })
+    ] });
+  }
   return /* @__PURE__ */ jsxs7("section", { "aria-label": props.title ?? "Video", "data-lk-block-id": blockId, "data-testid": "video", children: [
     props.title ? /* @__PURE__ */ jsx10("h3", { "data-testid": "video-title", children: props.title }) : null,
     /* @__PURE__ */ jsx10(
@@ -1508,11 +2085,20 @@ function Video(props) {
       {
         controls: true,
         preload: "metadata",
-        poster: props.poster,
-        src: props.src,
+        poster: resolvedPoster ?? void 0,
+        src: resolvedSrc,
         "data-testid": "video-player",
         style: { maxWidth: "100%" },
-        children: props.captions ? /* @__PURE__ */ jsx10("track", { kind: "captions", src: props.captions, srcLang: "en", label: "Captions", default: true }) : null
+        children: resolvedCaptions ? /* @__PURE__ */ jsx10(
+          "track",
+          {
+            kind: "captions",
+            src: resolvedCaptions,
+            srcLang: "en",
+            label: "Captions",
+            default: true
+          }
+        ) : null
       }
     )
   ] });
@@ -1555,7 +2141,7 @@ function Page(props) {
 setLessonkitBlockType(Page, "Page");
 
 // src/blocks/InteractiveBook.tsx
-import React11, { forwardRef as forwardRef7, useCallback as useCallback5, useEffect as useEffect10, useMemo as useMemo9, useState as useState7 } from "react";
+import React11, { forwardRef as forwardRef7, useCallback as useCallback6, useEffect as useEffect10, useMemo as useMemo9, useState as useState7 } from "react";
 import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
 var InteractiveBookInner = forwardRef7(
   function InteractiveBookInner2(props, ref) {
@@ -1637,15 +2223,20 @@ var InteractiveBookInner = forwardRef7(
   }
 );
 var InteractiveBook = forwardRef7(function InteractiveBook2(props, ref) {
-  const blockId = useMemo9(
-    () => normalizeComponentId(props.blockId, "blockId"),
-    [props.blockId]
-  );
   const pages = React11.Children.toArray(props.children).filter(
     React11.isValidElement
   );
   const { config, storage } = useLessonkit();
   const persistEnabled = config.session?.persistCompoundState !== false;
+  requireCompoundBlockIdWhenPersisting({
+    persistEnabled,
+    blockId: props.blockId,
+    componentName: "InteractiveBook"
+  });
+  const blockId = useMemo9(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
   const initialIndex = useCompoundInitialIndex({
     courseId: config.courseId,
     compoundId: blockId,
@@ -1654,7 +2245,7 @@ var InteractiveBook = forwardRef7(function InteractiveBook2(props, ref) {
     storage
   });
   const [index, setIndex] = useState7(initialIndex);
-  const setIndexStable = useCallback5((i) => setIndex(i), []);
+  const setIndexStable = useCallback6((i) => setIndex(i), []);
   useEffect10(() => {
     setIndex(initialIndex);
   }, [config.courseId, blockId, initialIndex]);
@@ -1709,7 +2300,7 @@ function Slide(props) {
 setLessonkitBlockType(Slide, "Slide");
 
 // src/blocks/SlideDeck.tsx
-import React13, { forwardRef as forwardRef8, useCallback as useCallback6, useEffect as useEffect13, useMemo as useMemo10, useRef as useRef9, useState as useState8 } from "react";
+import React13, { forwardRef as forwardRef8, useCallback as useCallback7, useEffect as useEffect13, useMemo as useMemo10, useRef as useRef9, useState as useState8 } from "react";
 
 // src/compound/useCompoundKeyboardNav.ts
 import { useEffect as useEffect12 } from "react";
@@ -1786,7 +2377,7 @@ var SlideDeckInner = forwardRef8(function SlideDeckInner2(props, ref) {
     persistEnabled,
     ref
   });
-  const setIndexStable = useCallback6((i) => setIndex(i), [setIndex]);
+  const setIndexStable = useCallback7((i) => setIndex(i), [setIndex]);
   useCompoundKeyboardNav({
     containerRef,
     visibleIndex,
@@ -1869,15 +2460,20 @@ var SlideDeckInner = forwardRef8(function SlideDeckInner2(props, ref) {
   );
 });
 var SlideDeck = forwardRef8(function SlideDeck2(props, ref) {
-  const blockId = useMemo10(
-    () => normalizeComponentId(props.blockId, "blockId"),
-    [props.blockId]
-  );
   const slides = React13.Children.toArray(props.children).filter(
     React13.isValidElement
   );
   const { config, storage } = useLessonkit();
   const persistEnabled = config.session?.persistCompoundState !== false;
+  requireCompoundBlockIdWhenPersisting({
+    persistEnabled,
+    blockId: props.blockId,
+    componentName: "SlideDeck"
+  });
+  const blockId = useMemo10(
+    () => normalizeComponentId(props.blockId, "blockId"),
+    [props.blockId]
+  );
   const initialIndex = useCompoundInitialIndex({
     courseId: config.courseId,
     compoundId: blockId,
@@ -1886,7 +2482,7 @@ var SlideDeck = forwardRef8(function SlideDeck2(props, ref) {
     storage
   });
   const [index, setIndex] = useState8(initialIndex);
-  const setIndexStable = useCallback6((i) => setIndex(i), []);
+  const setIndexStable = useCallback7((i) => setIndex(i), []);
   useEffect13(() => {
     setIndex(initialIndex);
   }, [config.courseId, blockId, initialIndex]);
@@ -1953,37 +2549,19 @@ function TimedCue(props) {
 setLessonkitBlockType(TimedCue, "TimedCue");
 
 // src/blocks/InteractiveVideo.tsx
-import React15, { forwardRef as forwardRef9, useCallback as useCallback7, useEffect as useEffect15, useMemo as useMemo11, useRef as useRef11, useState as useState9 } from "react";
+import React15, { forwardRef as forwardRef9, useCallback as useCallback8, useEffect as useEffect15, useMemo as useMemo11, useRef as useRef11, useState as useState9 } from "react";
 import { loadCompoundState as loadCompoundState3 } from "@lessonkit/core";
-
-// src/compound/useCompoundVideoShell.ts
-import "@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
 import { Fragment, jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
+function sortCuesByTime(cues) {
+  return [...cues].sort((a, b) => (a.props.atSeconds ?? 0) - (b.props.atSeconds ?? 0));
+}
 function loadVideoMeta(storage, courseId, blockId, enabled) {
-  if (!enabled || !courseId) return { currentTime: 0, completedCueIndices: [] };
+  const empty = { currentTime: 0, completedCueIndices: [], firedCueIndices: [] };
+  if (!enabled || !courseId) return empty;
   const saved = loadCompoundState3(storage, courseId, blockId);
-  if (!saved) return { currentTime: 0, completedCueIndices: [] };
+  if (!saved) return empty;
   const meta = readInteractiveVideoMeta(saved.childStates);
-  return meta ?? { currentTime: 0, completedCueIndices: [] };
+  return meta ?? empty;
 }
 function getCueChildCheckId(cue) {
   const child = React15.Children.only(cue.props.children);
@@ -2000,29 +2578,59 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
   validateCompoundChildren("InteractiveVideo", cues);
   const { config, track, storage } = useLessonkit();
   const lessonId = useEnclosingLessonId();
+  const mediaOptions = { allowedHosts: config.embed?.allowedHosts };
+  const resolvedSrc = resolveMediaSrc(props.src, mediaOptions);
+  const resolvedPoster = resolveMediaSrc(props.poster, mediaOptions);
+  const resolvedCaptions = resolveMediaSrc(props.captions, mediaOptions);
   const videoRef = useRef11(null);
+  const lastKnownTimeRef = useRef11(initialMeta.currentTime);
   const completedCuesRef = useRef11(new Set(initialMeta.completedCueIndices));
   const [completedCues, setCompletedCues] = useState9(
     () => new Set(initialMeta.completedCueIndices)
   );
   const [overlayActive, setOverlayActive] = useState9(false);
-  const firedCuesRef = useRef11(new Set(initialMeta.completedCueIndices));
-  const resumeOverlayCheckedRef = useRef11(false);
-  const sortedCues = useMemo11(
-    () => [...cues].sort((a, b) => (a.props.atSeconds ?? 0) - (b.props.atSeconds ?? 0)),
-    [cues]
+  const firedCuesRef = useRef11(
+    new Set(
+      initialMeta.firedCueIndices.length > 0 ? initialMeta.firedCueIndices : initialMeta.completedCueIndices
+    )
   );
+  const resumeOverlayCheckedRef = useRef11(false);
+  const [persistTrigger, setPersistTrigger] = useState9(0);
+  const lastPersistTimeRef = useRef11(0);
+  const sortedCues = cues;
   useEffect15(() => {
     completedCuesRef.current = completedCues;
   }, [completedCues]);
-  const transformState = useCallback7(
-    (state) => mergeVideoMetaIntoState(state, {
-      currentTime: videoRef.current?.currentTime ?? initialMeta.currentTime,
-      completedCueIndices: [...completedCuesRef.current]
-    }),
-    [initialMeta.currentTime]
+  const transformState = useCallback8(
+    (state) => {
+      const liveTime = videoRef.current?.currentTime;
+      const currentTime = Math.max(
+        lastKnownTimeRef.current,
+        typeof liveTime === "number" && Number.isFinite(liveTime) ? liveTime : 0
+      );
+      return mergeVideoMetaIntoState(state, {
+        currentTime,
+        completedCueIndices: [...completedCuesRef.current],
+        firedCueIndices: [...firedCuesRef.current]
+      });
+    },
+    []
   );
-  const { ctx } = useCompoundShell({
+  const applyVideoMetaFromState = useCallback8((state) => {
+    const meta = readInteractiveVideoMeta(state.childStates);
+    if (!meta) return;
+    lastKnownTimeRef.current = meta.currentTime;
+    completedCuesRef.current = new Set(meta.completedCueIndices);
+    firedCuesRef.current = new Set(
+      meta.firedCueIndices.length > 0 ? meta.firedCueIndices : meta.completedCueIndices
+    );
+    setCompletedCues(new Set(meta.completedCueIndices));
+    const video = videoRef.current;
+    if (video && meta.currentTime > 0) {
+      video.currentTime = meta.currentTime;
+    }
+  }, []);
+  const { visibleIndex, ctx } = useCompoundShell({
     courseId: config.courseId,
     compoundId: blockId,
     pageCount: sortedCues.length,
@@ -2031,10 +2639,12 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
     persistEnabled,
     ref,
     storage,
-    transformState
+    transformState,
+    persistTrigger,
+    onCompoundResume: applyVideoMetaFromState
   });
-  const activeCue = sortedCues[index];
-  const cueCanContinue = useCallback7(
+  const activeCue = sortedCues[visibleIndex];
+  const cueCanContinue = useCallback8(
     (cue) => {
       if (!cue || !cueRequiresAnswer(cue)) return true;
       const checkId = getCueChildCheckId(cue);
@@ -2058,8 +2668,8 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
     if (!hasSavedProgress) return;
     const video = videoRef.current;
     if (!video) return;
-    const cue = sortedCues[index];
-    if (!cue || completedCues.has(index)) return;
+    const cue = sortedCues[visibleIndex];
+    if (!cue || completedCues.has(visibleIndex)) return;
     setOverlayActive(true);
     video.pause();
     const at = cue.props.atSeconds ?? 0;
@@ -2071,13 +2681,14 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
     completedCues,
     config.courseId,
     index,
+    visibleIndex,
     initialMeta.completedCueIndices.length,
     initialMeta.currentTime,
     persistEnabled,
     sortedCues,
     storage
   ]);
-  const mandatoryIncompleteBefore = useCallback7(
+  const mandatoryIncompleteBefore = useCallback8(
     (time) => {
       for (let i = 0; i < sortedCues.length; i++) {
         const cue = sortedCues[i];
@@ -2088,7 +2699,7 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
     },
     [sortedCues, completedCues]
   );
-  const activateCue = useCallback7(
+  const activateCue = useCallback8(
     (i) => {
       const cue = sortedCues[i];
       if (!cue || firedCuesRef.current.has(i)) return;
@@ -2110,6 +2721,12 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
     const video = videoRef.current;
     if (!video || overlayActive) return;
     const t = video.currentTime;
+    lastKnownTimeRef.current = Math.max(lastKnownTimeRef.current, t);
+    const now = Date.now();
+    if (now - lastPersistTimeRef.current >= 5e3) {
+      lastPersistTimeRef.current = now;
+      setPersistTrigger((n) => n + 1);
+    }
     const blockSeek = mandatoryIncompleteBefore(t);
     if (blockSeek !== null && t > blockSeek + 0.5) {
       video.currentTime = blockSeek;
@@ -2125,10 +2742,10 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
     }
   };
   const completeCue = () => {
-    const cue = sortedCues[index];
+    const cue = sortedCues[visibleIndex];
     if (!cue || !cueCanContinue(cue)) return;
     setCompletedCues((prev) => {
-      const next = /* @__PURE__ */ new Set([...prev, index]);
+      const next = /* @__PURE__ */ new Set([...prev, visibleIndex]);
       completedCuesRef.current = next;
       return next;
     });
@@ -2138,7 +2755,7 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
         "video_segment_completed",
         {
           blockId,
-          segmentIndex: index,
+          segmentIndex: visibleIndex,
           atSeconds: cue.props.atSeconds ?? 0,
           segmentLabel: cue.props.label
         },
@@ -2157,12 +2774,12 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
       " ",
       Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getMaxScore(), 0)
     ] }) : null,
-    /* @__PURE__ */ jsx16("div", { style: { position: "relative" }, children: /* @__PURE__ */ jsx16(
+    !resolvedSrc ? /* @__PURE__ */ jsx16("p", { role: "alert", "data-testid": "interactive-video-blocked", children: "This video URL is not allowed." }) : /* @__PURE__ */ jsx16("div", { style: { position: "relative" }, children: /* @__PURE__ */ jsx16(
       "video",
       {
         ref: videoRef,
-        src: props.src,
-        poster: props.poster,
+        src: resolvedSrc,
+        poster: resolvedPoster ?? void 0,
         controls: true,
         "data-testid": "interactive-video-player",
         onTimeUpdate,
@@ -2174,13 +2791,22 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
             video.currentTime = blockSeek;
           }
         },
-        children: props.captions ? /* @__PURE__ */ jsx16("track", { kind: "captions", src: props.captions, srcLang: "en", label: "Captions", default: true }) : null
+        children: resolvedCaptions ? /* @__PURE__ */ jsx16(
+          "track",
+          {
+            kind: "captions",
+            src: resolvedCaptions,
+            srcLang: "en",
+            label: "Captions",
+            default: true
+          }
+        ) : null
       }
     ) }),
     /* @__PURE__ */ jsx16("div", { "data-testid": "interactive-video-cues", children: sortedCues.map(
       (cue, i) => React15.cloneElement(cue, {
         key: cue.key ?? i,
-        hidden: !overlayActive || i !== index,
+        hidden: !overlayActive || i !== visibleIndex,
         cueIndex: i,
         parentType: "InteractiveVideo"
       })
@@ -2203,15 +2829,21 @@ var InteractiveVideoInner = forwardRef9(function InteractiveVideoInner2(props, r
 });
 var InteractiveVideo = forwardRef9(
   function InteractiveVideo2(props, ref) {
-    const blockId = useMemo11(
-      () => normalizeComponentId(props.blockId, "blockId"),
-      [props.blockId]
-    );
     const cues = React15.Children.toArray(props.children).filter(
       React15.isValidElement
     );
+    const sortedCues = useMemo11(() => sortCuesByTime(cues), [cues]);
     const { config, storage } = useLessonkit();
     const persistEnabled = config.session?.persistCompoundState !== false;
+    requireCompoundBlockIdWhenPersisting({
+      persistEnabled,
+      blockId: props.blockId,
+      componentName: "InteractiveVideo"
+    });
+    const blockId = useMemo11(
+      () => normalizeComponentId(props.blockId, "blockId"),
+      [props.blockId]
+    );
     const initialMeta = useMemo11(
       () => loadVideoMeta(storage, config.courseId, blockId, persistEnabled),
       [storage, config.courseId, blockId, persistEnabled]
@@ -2219,22 +2851,22 @@ var InteractiveVideo = forwardRef9(
     const initialIndex = useCompoundInitialIndex({
       courseId: config.courseId,
       compoundId: blockId,
-      pageCount: cues.length,
+      pageCount: sortedCues.length,
       persistEnabled,
       storage
     });
     const [index, setIndex] = useState9(initialIndex);
-    const setIndexStable = useCallback7((i) => setIndex(i), []);
+    const setIndexStable = useCallback8((i) => setIndex(i), []);
     useEffect15(() => {
       setIndex(initialIndex);
-    }, [config.courseId, blockId, initialIndex]);
+    }, [config.courseId, blockId, initialIndex, sortedCues.length]);
     return /* @__PURE__ */ jsx16(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ jsx16(
       InteractiveVideoInner,
       {
         ...props,
         ref,
         blockId,
-        cues,
+        cues: sortedCues,
         index,
         setIndex,
         persistEnabled,
@@ -2247,10 +2879,18 @@ setLessonkitBlockType(InteractiveVideo, "InteractiveVideo");
 
 // src/blocks/Summary.tsx
 import { forwardRef as forwardRef10, useEffect as useEffect16, useMemo as useMemo12, useRef as useRef12, useState as useState10 } from "react";
+
+// src/assessment/shouldReplayResumeTelemetry.ts
+function shouldReplayResumeTelemetry(config) {
+  return config?.tracking?.replayResumeEvents === true;
+}
+
+// src/blocks/Summary.tsx
 import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
 var INTERACTION6 = "summary";
 function SummaryInner(props, ref) {
   const checkId = useMemo12(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
   const assessment = useAssessmentState(props.enclosingLessonId);
   const [selectedIndices, setSelectedIndices] = useState10([]);
   const [passed, setPassed] = useState10(false);
@@ -2278,7 +2918,7 @@ function SummaryInner(props, ref) {
   const handle = useMemo12(
     () => buildAssessmentHandle({
       checkId,
-      getScore: () => passed ? score : 0,
+      getScore: () => score,
       getMaxScore: () => maxScore,
       getAnswerGiven: () => selectedIndices.length > 0,
       resetTask: reset,
@@ -2289,7 +2929,7 @@ function SummaryInner(props, ref) {
         interactionType: INTERACTION6,
         response: selected,
         correct: passedThreshold,
-        score: passed ? score : 0,
+        score,
         maxScore
       }),
       getCurrentState: () => ({ selectedIndices, passed, checked }),
@@ -2299,34 +2939,48 @@ function SummaryInner(props, ref) {
           nextIndices = [...state.selectedIndices];
         } else if (Array.isArray(state.selected)) {
           const legacy = state.selected;
+          if (isDevEnvironment()) {
+            const seen = /* @__PURE__ */ new Set();
+            for (const text of props.statements) {
+              if (seen.has(text)) {
+                console.warn(
+                  "[lessonkit] Summary: duplicate statement strings; legacy selected resume may be ambiguous",
+                  text
+                );
+                break;
+              }
+              seen.add(text);
+            }
+          }
           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
-              });
-            }
-          }
-        });
+        const nextPassedThreshold = meetsPassingThreshold(
+          nextScore,
+          maxScore,
+          props.passingScore
+        );
+        setPassed(nextPassedThreshold);
+        completedRef.current = nextPassedThreshold;
+        if (nextPassedThreshold && !telemetryReplayedRef.current && shouldReplayResumeTelemetry(config)) {
+          telemetryReplayedRef.current = true;
+          assessment.answer({
+            checkId,
+            interactionType: INTERACTION6,
+            response: nextSelected,
+            correct: nextPassedThreshold
+          });
+          assessment.complete({
+            checkId,
+            interactionType: INTERACTION6,
+            score: nextScore,
+            maxScore,
+            passingScore: props.passingScore ?? maxScore
+          });
+        }
         readBooleanStateField(state, "checked", setChecked);
       }
     }),
@@ -2334,14 +2988,16 @@ function SummaryInner(props, ref) {
       assessment,
       checkId,
       checked,
+      config,
       maxScore,
       passed,
       passedThreshold,
+      props.correct,
       props.passingScore,
       props.statements,
       score,
       selected,
-      selectedIndices.length
+      selectedIndices
     ]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
@@ -2364,9 +3020,9 @@ function SummaryInner(props, ref) {
       response: selected,
       correct: passedThreshold
     });
-    if (passedThreshold && !completedRef.current) {
+    if ((passedThreshold || props.enableRetry === false) && !completedRef.current) {
       completedRef.current = true;
-      setPassed(true);
+      if (passedThreshold) setPassed(true);
       assessment.complete({
         checkId,
         interactionType: INTERACTION6,
@@ -2444,8 +3100,34 @@ function buildDeck(pairs) {
   );
   return shuffleCards(cards);
 }
+function rebuildCardsFromKeys(pairs, cardKeys) {
+  const pairMap = new Map(pairs.map((pair) => [pair.id, pair]));
+  if (cardKeys.length !== pairs.length * 2) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const cards = [];
+  for (const cardKey of cardKeys) {
+    if (seen.has(cardKey)) return null;
+    seen.add(cardKey);
+    const match = /^(.+)-([01])$/.exec(cardKey);
+    if (!match) return null;
+    const pairId = match[1];
+    const copy = Number(match[2]);
+    if (copy !== 0 && copy !== 1) return null;
+    const pair = pairMap.get(pairId);
+    if (!pair) return null;
+    cards.push({
+      cardKey,
+      pairId: pair.id,
+      label: pair.label,
+      imageSrc: pair.imageSrc
+    });
+  }
+  return cards;
+}
 function ImagePairingInner(props, ref) {
   const checkId = useMemo13(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
+  const mediaOptions = { allowedHosts: config.embed?.allowedHosts };
   const assessment = useAssessmentState(props.enclosingLessonId);
   const pairsKey = props.pairs.map((p) => p.id).join("\0");
   const [cards, setCards] = useState11(() => buildDeck(props.pairs));
@@ -2453,9 +3135,15 @@ function ImagePairingInner(props, ref) {
   const [revealed, setRevealed] = useState11(() => /* @__PURE__ */ new Set());
   const [keyboardSelection, setKeyboardSelection] = useState11(null);
   const [passed, setPassed] = useState11(false);
+  const [submitted, setSubmitted] = useState11(false);
   const completedRef = useRef13(false);
   const telemetryReplayedRef = useRef13(false);
+  const mismatchTimeoutRef = useRef13(null);
   const reset = () => {
+    if (mismatchTimeoutRef.current !== null) {
+      window.clearTimeout(mismatchTimeoutRef.current);
+      mismatchTimeoutRef.current = null;
+    }
     completedRef.current = false;
     telemetryReplayedRef.current = false;
     setCards(buildDeck(props.pairs));
@@ -2463,10 +3151,19 @@ function ImagePairingInner(props, ref) {
     setRevealed(/* @__PURE__ */ new Set());
     setKeyboardSelection(null);
     setPassed(false);
+    setSubmitted(false);
   };
   useEffect17(() => {
     reset();
   }, [checkId, pairsKey]);
+  useEffect17(
+    () => () => {
+      if (mismatchTimeoutRef.current !== null) {
+        window.clearTimeout(mismatchTimeoutRef.current);
+      }
+    },
+    []
+  );
   const totalPairs = props.pairs.length;
   const matchedCount = matched.size;
   const maxScore = totalPairs || 1;
@@ -2474,25 +3171,34 @@ function ImagePairingInner(props, ref) {
   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
-      });
-    }
+    if (totalPairs === 0 || completedRef.current) return;
+    const finalScore = nextMatched.size;
+    const finalPassed = meetsPassingThreshold(finalScore, maxScore, props.passingScore);
+    if (!finalPassed && nextMatched.size < totalPairs) return;
+    completeWithScore(nextMatched, finalScore, finalPassed);
+  };
+  const completeWithScore = (nextMatched, finalScore, finalPassed) => {
+    if (completedRef.current) return;
+    completedRef.current = true;
+    setSubmitted(true);
+    setPassed(finalPassed);
+    assessment.answer({
+      checkId,
+      interactionType: INTERACTION7,
+      response: { matchedPairIds: [...nextMatched] },
+      correct: finalPassed
+    });
+    assessment.complete({
+      checkId,
+      interactionType: INTERACTION7,
+      score: finalScore,
+      maxScore,
+      passingScore: props.passingScore ?? maxScore
+    });
+  };
+  const finishAttempt = () => {
+    if (completedRef.current || matchedCount === 0) return;
+    completeWithScore(matched, matchedCount, passedThreshold);
   };
   const tryMatch = (firstKey, secondKey) => {
     if (firstKey === secondKey) return;
@@ -2509,7 +3215,11 @@ function ImagePairingInner(props, ref) {
       setRevealed(/* @__PURE__ */ new Set());
       setKeyboardSelection(null);
     } else {
-      window.setTimeout(() => {
+      if (mismatchTimeoutRef.current !== null) {
+        window.clearTimeout(mismatchTimeoutRef.current);
+      }
+      mismatchTimeoutRef.current = window.setTimeout(() => {
+        mismatchTimeoutRef.current = null;
         setRevealed((prev) => {
           const next = new Set(prev);
           next.delete(firstKey);
@@ -2552,17 +3262,22 @@ function ImagePairingInner(props, ref) {
         checkId,
         interactionType: INTERACTION7,
         response: { matchedPairIds: [...matched] },
-        correct: allMatched && passedThreshold,
+        correct: passedThreshold,
         score,
         maxScore
       }),
       getCurrentState: () => ({
+        cardKeys: cards.map((card) => card.cardKey),
         matched: [...matched],
         revealed: [...revealed],
         keyboardSelection,
         passed
       }),
       resume: (state) => {
+        if (Array.isArray(state.cardKeys)) {
+          const restored = rebuildCardsFromKeys(props.pairs, state.cardKeys);
+          if (restored) setCards(restored);
+        }
         if (Array.isArray(state.matched)) setMatched(new Set(state.matched));
         if (Array.isArray(state.revealed)) setRevealed(new Set(state.revealed));
         const sel = state.keyboardSelection;
@@ -2570,15 +3285,20 @@ function ImagePairingInner(props, ref) {
         readBooleanStateField(state, "passed", (value) => {
           setPassed(value);
           completedRef.current = value;
-          if (value && !telemetryReplayedRef.current) {
+          if (value && !telemetryReplayedRef.current && shouldReplayResumeTelemetry(config)) {
             telemetryReplayedRef.current = true;
             const matchedIds = Array.isArray(state.matched) ? state.matched : [...matched];
             const finalScore = matchedIds.length;
+            const finalPassed = meetsPassingThreshold(
+              finalScore,
+              maxScore,
+              props.passingScore
+            );
             assessment.answer({
               checkId,
               interactionType: INTERACTION7,
               response: { matchedPairIds: matchedIds },
-              correct: true
+              correct: finalPassed
             });
             assessment.complete({
               checkId,
@@ -2591,7 +3311,7 @@ function ImagePairingInner(props, ref) {
         });
       }
     }),
-    [allMatched, checkId, keyboardSelection, matched, matchedCount, maxScore, passed, passedThreshold, revealed, score]
+    [allMatched, assessment, cards, checkId, config, keyboardSelection, matched, matchedCount, maxScore, passed, passedThreshold, props.pairs, props.passingScore, revealed, score]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   return /* @__PURE__ */ jsxs15("section", { "aria-label": "Image Pairing", "data-lk-check-id": checkId, "data-testid": "image-pairing", children: [
@@ -2600,6 +3320,7 @@ function ImagePairingInner(props, ref) {
       const isMatched = matched.has(card.pairId);
       const isRevealed = isMatched || revealed.has(card.cardKey);
       const isSelected = keyboardSelection === card.cardKey;
+      const resolvedCardSrc = resolveMediaSrc(card.imageSrc, mediaOptions);
       return /* @__PURE__ */ jsx18(
         "button",
         {
@@ -2616,7 +3337,14 @@ function ImagePairingInner(props, ref) {
             border: isSelected ? "2px solid currentColor" : "1px solid currentColor"
           },
           children: isRevealed ? /* @__PURE__ */ jsxs15(Fragment2, { children: [
-            /* @__PURE__ */ jsx18("img", { src: card.imageSrc, alt: card.label, style: { maxWidth: "5rem", maxHeight: "5rem" } }),
+            resolvedCardSrc ? /* @__PURE__ */ jsx18(
+              "img",
+              {
+                src: resolvedCardSrc,
+                alt: card.label,
+                style: { maxWidth: "5rem", maxHeight: "5rem" }
+              }
+            ) : /* @__PURE__ */ jsx18("span", { "aria-hidden": "true", children: "!" }),
             /* @__PURE__ */ jsx18("span", { className: "lk-visually-hidden", children: card.label })
           ] }) : "?"
         },
@@ -2629,6 +3357,7 @@ function ImagePairingInner(props, ref) {
       totalPairs,
       " pairs matched"
     ] }),
+    props.enableRetry === false && matchedCount > 0 && !submitted ? /* @__PURE__ */ jsx18("button", { type: "button", "data-testid": "image-pairing-finish", onClick: finishAttempt, children: "Submit" }) : null,
     props.enableRetry && passed ? /* @__PURE__ */ jsx18("button", { type: "button", "data-testid": "image-pairing-retry", onClick: reset, children: "Try again" }) : null
   ] });
 }
@@ -2644,6 +3373,8 @@ import { jsx as jsx19, jsxs as jsxs16 } from "react/jsx-runtime";
 var INTERACTION8 = "imageSequencing";
 function ImageSequencingInner(props, ref) {
   const checkId = useMemo14(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
+  const mediaOptions = { allowedHosts: config.embed?.allowedHosts };
   const assessment = useAssessmentState(props.enclosingLessonId);
   const imagesKey = props.images.map((i) => i.id).join("\0");
   const orderKey = props.correctOrder.join("\0");
@@ -2680,9 +3411,9 @@ function ImageSequencingInner(props, ref) {
   const handle = useMemo14(
     () => buildAssessmentHandle({
       checkId,
-      getScore: () => passed ? score : 0,
+      getScore: () => score,
       getMaxScore: () => maxScore,
-      getAnswerGiven: () => order.length > 0,
+      getAnswerGiven: () => checked,
       resetTask: reset,
       showSolutions: () => {
       },
@@ -2691,7 +3422,7 @@ function ImageSequencingInner(props, ref) {
         interactionType: INTERACTION8,
         response: order,
         correct: passedThreshold,
-        score: passed ? score : 0,
+        score,
         maxScore
       }),
       getCurrentState: () => ({ order, passed, checked }),
@@ -2704,7 +3435,7 @@ function ImageSequencingInner(props, ref) {
         readBooleanStateField(state, "passed", (value) => {
           setPassed(value);
           completedRef.current = value;
-          if (value && !telemetryReplayedRef.current) {
+          if (value && !telemetryReplayedRef.current && shouldReplayResumeTelemetry(config)) {
             telemetryReplayedRef.current = true;
             const nextIsCorrect = nextOrder.every((id, i) => id === props.correctOrder[i]);
             const nextScore = nextIsCorrect ? maxScore : 0;
@@ -2726,7 +3457,7 @@ function ImageSequencingInner(props, ref) {
         readBooleanStateField(state, "checked", setChecked);
       }
     }),
-    [checkId, checked, maxScore, order, passed, passedThreshold, score]
+    [assessment, checkId, checked, config, maxScore, order, passed, passedThreshold, props.correctOrder, props.passingScore, score]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   const check = () => {
@@ -2737,9 +3468,9 @@ function ImageSequencingInner(props, ref) {
       response: order,
       correct: passedThreshold
     });
-    if (passedThreshold && !completedRef.current) {
+    if ((passedThreshold || props.enableRetry === false) && !completedRef.current) {
       completedRef.current = true;
-      setPassed(true);
+      if (passedThreshold) setPassed(true);
       assessment.complete({
         checkId,
         interactionType: INTERACTION8,
@@ -2754,8 +3485,16 @@ function ImageSequencingInner(props, ref) {
     /* @__PURE__ */ jsx19("ol", { "data-testid": "image-sequencing-list", children: order.map((id, index) => {
       const image = props.images.find((i) => i.id === id);
       if (!image) return null;
+      const resolvedSrc = resolveMediaSrc(image.src, mediaOptions);
       return /* @__PURE__ */ jsxs16("li", { "data-testid": `sequencing-item-${id}`, children: [
-        /* @__PURE__ */ jsx19("img", { src: image.src, alt: image.alt, style: { maxWidth: "8rem", verticalAlign: "middle" } }),
+        resolvedSrc ? /* @__PURE__ */ jsx19(
+          "img",
+          {
+            src: resolvedSrc,
+            alt: image.alt,
+            style: { maxWidth: "8rem", verticalAlign: "middle" }
+          }
+        ) : /* @__PURE__ */ jsx19("span", { "aria-hidden": "true", children: "!" }),
         /* @__PURE__ */ jsx19(
           "button",
           {
@@ -2803,11 +3542,12 @@ var ImageSequencing = forwardRef12(
 setLessonkitBlockType(ImageSequencing, "ImageSequencing");
 
 // src/blocks/ArithmeticQuiz.tsx
-import { forwardRef as forwardRef13, useCallback as useCallback8, useEffect as useEffect19, useMemo as useMemo15, useRef as useRef15, useState as useState13 } from "react";
+import { forwardRef as forwardRef13, useCallback as useCallback9, useEffect as useEffect19, useMemo as useMemo15, useRef as useRef15, useState as useState13 } from "react";
 import { jsx as jsx20, jsxs as jsxs17 } from "react/jsx-runtime";
 var INTERACTION9 = "arithmeticQuiz";
 function ArithmeticQuizInner(props, ref) {
   const checkId = useMemo15(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
   const assessment = useAssessmentState(props.enclosingLessonId);
   const problemsKey = props.problems.map((p) => `${p.question}\0${p.answer}`).join("|");
   const [answers, setAnswers] = useState13(
@@ -2838,7 +3578,7 @@ function ArithmeticQuizInner(props, ref) {
   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 = useCallback8(
+  const runCheck = useCallback9(
     (force = false) => {
       if (!force && !allFilled) return;
       setChecked(true);
@@ -2848,9 +3588,9 @@ function ArithmeticQuizInner(props, ref) {
         response: answers,
         correct: passedThreshold
       });
-      if (passedThreshold && !completedRef.current) {
+      if ((passedThreshold || props.enableRetry === false) && !completedRef.current) {
         completedRef.current = true;
-        setPassed(true);
+        setPassed(passedThreshold);
         assessment.complete({
           checkId,
           interactionType: INTERACTION9,
@@ -2874,7 +3614,7 @@ function ArithmeticQuizInner(props, ref) {
   const handle = useMemo15(
     () => buildAssessmentHandle({
       checkId,
-      getScore: () => passed ? score : 0,
+      getScore: () => score,
       getMaxScore: () => maxScore,
       getAnswerGiven: () => allFilled,
       resetTask: reset,
@@ -2885,7 +3625,7 @@ function ArithmeticQuizInner(props, ref) {
         interactionType: INTERACTION9,
         response: answers,
         correct: passedThreshold,
-        score: passed ? score : 0,
+        score,
         maxScore
       }),
       getCurrentState: () => ({ answers, passed, checked, timeLeft }),
@@ -2899,17 +3639,18 @@ function ArithmeticQuizInner(props, ref) {
         readBooleanStateField(state, "passed", (value) => {
           setPassed(value);
           completedRef.current = value;
-          if (value && !telemetryReplayedRef.current) {
+          if (value && !telemetryReplayedRef.current && shouldReplayResumeTelemetry(config)) {
             telemetryReplayedRef.current = true;
             let nextScore = 0;
             props.problems.forEach((p, i) => {
               if ((nextAnswers[i] ?? "").trim() === p.answer.trim()) nextScore += 1;
             });
+            const replayCorrect = nextScore >= (props.passingScore ?? maxScore);
             assessment.answer({
               checkId,
               interactionType: INTERACTION9,
               response: nextAnswers,
-              correct: true
+              correct: replayCorrect
             });
             assessment.complete({
               checkId,
@@ -2924,7 +3665,7 @@ function ArithmeticQuizInner(props, ref) {
         if (typeof state.timeLeft === "number") setTimeLeft(state.timeLeft);
       }
     }),
-    [allFilled, answers, checkId, checked, maxScore, passed, passedThreshold, score, timeLeft]
+    [allFilled, answers, checkId, checked, config, maxScore, passed, passedThreshold, props.problems, props.passingScore, score, timeLeft]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   const onInput = (index, value) => {
@@ -2988,6 +3729,7 @@ import { jsx as jsx21, jsxs as jsxs18 } from "react/jsx-runtime";
 var INTERACTION10 = "essay";
 function EssayInner(props, ref) {
   const checkId = useMemo16(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
   const assessment = useAssessmentState(props.enclosingLessonId);
   const [text, setText] = useState14("");
   const [submitted, setSubmitted] = useState14(false);
@@ -3027,16 +3769,22 @@ function EssayInner(props, ref) {
         const nextText = readStringField(state, "text");
         if (typeof nextText === "string") setText(nextText);
         readBooleanStateField(state, "submitted", (value) => {
+          const textVal = typeof nextText === "string" ? nextText : text;
+          const meetsMin = textVal.trim().length >= minLength;
+          if (value && !meetsMin) {
+            setSubmitted(false);
+            completedRef.current = false;
+            return;
+          }
           setSubmitted(value);
           completedRef.current = value;
-          if (value && !telemetryReplayedRef.current) {
+          if (value && !telemetryReplayedRef.current && shouldReplayResumeTelemetry(config)) {
             telemetryReplayedRef.current = true;
-            const response = typeof nextText === "string" ? nextText : text;
             assessment.answer({
               checkId,
               interactionType: INTERACTION10,
               question: props.question,
-              response,
+              response: textVal,
               correct: false
             });
             assessment.complete({
@@ -3050,7 +3798,7 @@ function EssayInner(props, ref) {
         });
       }
     }),
-    [checkId, meetsMinLength, props.question, submitted, text]
+    [assessment, checkId, config, meetsMinLength, minLength, props.passingScore, props.question, submitted, text]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   const submit = () => {
@@ -3201,7 +3949,7 @@ function Questionnaire(props) {
 setLessonkitBlockType(Questionnaire, "Questionnaire");
 
 // src/blocks/MemoryGame.tsx
-import { useEffect as useEffect22, useMemo as useMemo18, useState as useState16 } from "react";
+import { useEffect as useEffect22, useMemo as useMemo18, useRef as useRef17, useState as useState16 } from "react";
 import { jsx as jsx23, jsxs as jsxs20 } from "react/jsx-runtime";
 function shuffleCards2(cards) {
   const next = [...cards];
@@ -3228,16 +3976,29 @@ function MemoryGame(props) {
   const [revealed, setRevealed] = useState16(() => /* @__PURE__ */ new Set());
   const [selection, setSelection] = useState16(null);
   const [complete, setComplete] = useState16(false);
+  const mismatchTimeoutRef = useRef17(null);
   const { track } = useLessonkit();
   const lessonId = useEnclosingLessonId();
   const trackOpts = lessonId ? { lessonId } : void 0;
   useEffect22(() => {
+    if (mismatchTimeoutRef.current !== null) {
+      window.clearTimeout(mismatchTimeoutRef.current);
+      mismatchTimeoutRef.current = null;
+    }
     setCards(buildDeck2(props.pairs));
     setMatched(/* @__PURE__ */ new Set());
     setRevealed(/* @__PURE__ */ new Set());
     setSelection(null);
     setComplete(false);
   }, [props.blockId, pairsKey]);
+  useEffect22(
+    () => () => {
+      if (mismatchTimeoutRef.current !== null) {
+        window.clearTimeout(mismatchTimeoutRef.current);
+      }
+    },
+    []
+  );
   const cardIndexByKey = useMemo18(
     () => Object.fromEntries(cards.map((c, i) => [c.cardKey, i])),
     [cards]
@@ -3267,7 +4028,11 @@ function MemoryGame(props) {
       setRevealed(/* @__PURE__ */ new Set());
       setSelection(null);
     } else {
-      window.setTimeout(() => {
+      if (mismatchTimeoutRef.current !== null) {
+        window.clearTimeout(mismatchTimeoutRef.current);
+      }
+      mismatchTimeoutRef.current = window.setTimeout(() => {
+        mismatchTimeoutRef.current = null;
         setRevealed((prev) => {
           const next = new Set(prev);
           next.delete(firstKey);
@@ -3341,7 +4106,7 @@ function MemoryGame(props) {
 setLessonkitBlockType(MemoryGame, "MemoryGame");
 
 // src/blocks/InformationWall.tsx
-import { useEffect as useEffect23, useMemo as useMemo19, useRef as useRef17, useState as useState17 } from "react";
+import { useEffect as useEffect23, useMemo as useMemo19, useRef as useRef18, useState as useState17 } from "react";
 import { jsx as jsx24, jsxs as jsxs21 } from "react/jsx-runtime";
 function InformationWall(props) {
   const blockId = useMemo19(
@@ -3352,7 +4117,7 @@ function InformationWall(props) {
   const { track } = useLessonkit();
   const lessonId = useEnclosingLessonId();
   const trackOpts = lessonId ? { lessonId } : void 0;
-  const debounceRef = useRef17(null);
+  const debounceRef = useRef18(null);
   const filtered = useMemo19(() => {
     const q = query.trim().toLowerCase();
     if (!q) return props.panels;
@@ -3424,10 +4189,16 @@ function usePrefersReducedMotion() {
 function ParallaxSlideshow(props) {
   const [index, setIndex] = useState18(0);
   const reducedMotion = usePrefersReducedMotion();
-  const { track } = useLessonkit();
+  const { track, config } = useLessonkit();
   const lessonId = useEnclosingLessonId();
   const trackOpts = lessonId ? { lessonId } : void 0;
   const slide = props.slides[index];
+  const mediaOptions = { allowedHosts: config.embed?.allowedHosts };
+  const resolvedImageSrc = slide?.imageSrc ? resolveMediaSrc(slide.imageSrc, mediaOptions) : null;
+  useEffect24(() => {
+    if (props.slides.length < 1) return;
+    setIndex((current) => Math.min(current, props.slides.length - 1));
+  }, [props.slides.length]);
   useEffect24(() => {
     track(
       "parallax_slide_viewed",
@@ -3454,22 +4225,23 @@ function ParallaxSlideshow(props) {
             "data-testid": `parallax-slide-${index}`,
             style: reducedMotion ? void 0 : {
               backgroundAttachment: "fixed",
-              backgroundImage: slide.imageSrc ? `url(${slide.imageSrc})` : void 0,
+              backgroundImage: resolvedImageSrc ? `url("${resolvedImageSrc}")` : void 0,
               backgroundPosition: "center",
               backgroundSize: "cover",
               minHeight: "12rem",
               padding: "1rem"
             },
             children: [
-              reducedMotion && slide.imageSrc ? /* @__PURE__ */ jsx25(
+              reducedMotion && resolvedImageSrc ? /* @__PURE__ */ jsx25(
                 "img",
                 {
-                  src: slide.imageSrc,
+                  src: resolvedImageSrc,
                   alt: "",
                   "data-testid": "parallax-slide-image",
                   style: { maxWidth: "100%" }
                 }
               ) : null,
+              !reducedMotion && slide.imageSrc && !resolvedImageSrc ? /* @__PURE__ */ jsx25("p", { role: "alert", children: "This image URL is not allowed." }) : null,
               /* @__PURE__ */ jsx25("h3", { "data-testid": "parallax-slide-title", children: slide.title }),
               /* @__PURE__ */ jsx25("p", { "data-testid": "parallax-slide-body", children: slide.body })
             ]
@@ -3658,8 +4430,9 @@ import { useState as useState22 } from "react";
 import { jsx as jsx29, jsxs as jsxs26 } from "react/jsx-runtime";
 function ImageHotspots(props) {
   const [active, setActive] = useState22(null);
-  const { track } = useLessonkit();
+  const { track, config } = useLessonkit();
   const lessonId = useEnclosingLessonId();
+  const resolvedSrc = resolveMediaSrc(props.src, { allowedHosts: config.embed?.allowedHosts });
   const open = (hotspotId) => {
     setActive(hotspotId);
     track(
@@ -3670,7 +4443,7 @@ function ImageHotspots(props) {
   };
   return /* @__PURE__ */ jsxs26("section", { "aria-label": "Image hotspots", "data-lk-block-id": props.blockId, "data-testid": "image-hotspots", children: [
     /* @__PURE__ */ jsxs26("div", { style: { position: "relative", display: "inline-block" }, children: [
-      /* @__PURE__ */ jsx29("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
+      resolvedSrc ? /* @__PURE__ */ jsx29("img", { src: resolvedSrc, alt: props.alt, style: { maxWidth: "100%" } }) : /* @__PURE__ */ jsx29("p", { role: "alert", children: "This image URL is not allowed." }),
       props.hotspots.map((h) => /* @__PURE__ */ jsx29(
         "button",
         {
@@ -3703,9 +4476,11 @@ import { useState as useState23 } from "react";
 import { jsx as jsx30, jsxs as jsxs27 } from "react/jsx-runtime";
 function ImageSlider(props) {
   const [index, setIndex] = useState23(0);
-  const { track } = useLessonkit();
+  const { track, config } = useLessonkit();
   const lessonId = useEnclosingLessonId();
   const slide = props.slides[index];
+  const mediaOptions = { allowedHosts: config.embed?.allowedHosts };
+  const resolvedSrc = slide ? resolveMediaSrc(slide.src, mediaOptions) : null;
   if (!slide) return null;
   const goTo = (next) => {
     setIndex(next);
@@ -3716,7 +4491,7 @@ function ImageSlider(props) {
     );
   };
   return /* @__PURE__ */ jsxs27("section", { "aria-label": "Image slider", "data-lk-block-id": props.blockId, "data-testid": "image-slider", children: [
-    /* @__PURE__ */ jsx30("img", { src: slide.src, alt: slide.alt, style: { maxWidth: "100%" } }),
+    resolvedSrc ? /* @__PURE__ */ jsx30("img", { src: resolvedSrc, alt: slide.alt, style: { maxWidth: "100%" } }) : /* @__PURE__ */ jsx30("p", { role: "alert", children: "This image URL is not allowed." }),
     slide.caption ? /* @__PURE__ */ jsx30("p", { children: slide.caption }) : null,
     /* @__PURE__ */ jsxs27("nav", { "aria-label": "Slide navigation", children: [
       /* @__PURE__ */ jsx30(
@@ -3750,14 +4525,16 @@ function ImageSlider(props) {
 setLessonkitBlockType(ImageSlider, "ImageSlider");
 
 // src/blocks/FindHotspot.tsx
-import { forwardRef as forwardRef15, useEffect as useEffect25, useMemo as useMemo20, useRef as useRef18, useState as useState24 } from "react";
+import { forwardRef as forwardRef15, useEffect as useEffect25, useMemo as useMemo20, useRef as useRef19, useState as useState24 } from "react";
 import { jsx as jsx31, jsxs as jsxs28 } from "react/jsx-runtime";
 var INTERACTION11 = "findHotspot";
 function FindHotspotInner(props, ref) {
   const checkId = useMemo20(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
+  const resolvedSrc = resolveMediaSrc(props.src, { allowedHosts: config.embed?.allowedHosts });
   const [selected, setSelected] = useState24(null);
   const [checked, setChecked] = useState24(false);
-  const telemetryReplayedRef = useRef18(false);
+  const telemetryReplayedRef = useRef19(false);
   const assessment = useAssessmentState(props.enclosingLessonId);
   const targetIdsKey = props.targets.map((t) => t.id).join("\0");
   useEffect25(() => {
@@ -3790,7 +4567,7 @@ function FindHotspotInner(props, ref) {
       checkId,
       getScore: () => checked && correct ? 1 : 0,
       getMaxScore: () => 1,
-      getAnswerGiven: () => selected !== null,
+      getAnswerGiven: () => checked,
       resetTask: () => {
         setSelected(null);
         setChecked(false);
@@ -3820,10 +4597,12 @@ function FindHotspotInner(props, ref) {
           setChecked(value);
         });
         const nextCorrect = nextSelected === props.correctTargetId;
-        replayTelemetry(nextSelected, nextChecked, nextCorrect);
+        if (config.tracking?.replayResumeEvents === true) {
+          replayTelemetry(nextSelected, nextChecked, nextCorrect);
+        }
       }
     }),
-    [assessment, checkId, checked, correct, props.correctTargetId, props.passingScore, props.targets, selected]
+    [assessment, checkId, checked, config.tracking?.replayResumeEvents, correct, props.correctTargetId, props.passingScore, props.targets, selected]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   const selectTarget = (id) => {
@@ -3847,11 +4626,19 @@ function FindHotspotInner(props, ref) {
         maxScore: 1,
         passingScore: props.passingScore ?? 1
       });
+    } else if (props.enableRetry === false) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION11,
+        score: 0,
+        maxScore: 1,
+        passingScore: props.passingScore ?? 1
+      });
     }
   };
   return /* @__PURE__ */ jsxs28("section", { "aria-label": "Find the hotspot", "data-lk-check-id": checkId, "data-testid": "find-hotspot", children: [
     /* @__PURE__ */ jsxs28("div", { style: { position: "relative", display: "inline-block" }, children: [
-      /* @__PURE__ */ jsx31("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
+      resolvedSrc ? /* @__PURE__ */ jsx31("img", { src: resolvedSrc, alt: props.alt, style: { maxWidth: "100%" } }) : /* @__PURE__ */ jsx31("p", { role: "alert", children: "This image URL is not allowed." }),
       props.targets.map((t) => /* @__PURE__ */ jsx31(
         "button",
         {
@@ -3882,14 +4669,26 @@ var FindHotspot = forwardRef15(function FindHotspot2(props, ref) {
 setLessonkitBlockType(FindHotspot, "FindHotspot");
 
 // src/blocks/FindMultipleHotspots.tsx
-import { forwardRef as forwardRef16, useMemo as useMemo21, useState as useState25 } from "react";
+import { forwardRef as forwardRef16, useEffect as useEffect26, useMemo as useMemo21, useState as useState25 } from "react";
 import { jsx as jsx32, jsxs as jsxs29 } from "react/jsx-runtime";
 var INTERACTION12 = "findMultipleHotspots";
 function FindMultipleHotspotsInner(props, ref) {
   const checkId = useMemo21(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const { config } = useLessonkit();
+  const resolvedSrc = resolveMediaSrc(props.src, { allowedHosts: config.embed?.allowedHosts });
   const [selected, setSelected] = useState25(/* @__PURE__ */ new Set());
   const [checked, setChecked] = useState25(false);
   const assessment = useAssessmentState(props.enclosingLessonId);
+  const correctSet = useMemo21(
+    () => new Set(props.correctTargetIds),
+    [props.correctTargetIds]
+  );
+  const targetIdsKey = props.targets.map((t) => t.id).join("\0");
+  const correctIdsKey = props.correctTargetIds.join("\0");
+  useEffect26(() => {
+    setSelected(/* @__PURE__ */ new Set());
+    setChecked(false);
+  }, [checkId, correctIdsKey, targetIdsKey]);
   const toggle = (id) => {
     setSelected((prev) => {
       const next = new Set(prev);
@@ -3899,13 +4698,26 @@ function FindMultipleHotspotsInner(props, ref) {
     });
     setChecked(false);
   };
-  const correct = selected.size === props.correctTargetIds.length && props.correctTargetIds.every((id) => selected.has(id));
+  const maxScore = props.correctTargetIds.length || 1;
+  const score = props.correctTargetIds.filter((id) => selected.has(id)).length;
+  const wrongSelected = [...selected].filter((id) => !correctSet.has(id)).length;
+  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore) && wrongSelected === 0;
+  const isFactuallyCorrect = (sel) => {
+    const wrong = [...sel].filter((id) => !correctSet.has(id)).length;
+    const matched = props.correctTargetIds.filter((id) => sel.has(id)).length;
+    return wrong === 0 && sel.size === props.correctTargetIds.length && matched === maxScore;
+  };
+  const factualCorrect = checked ? isFactuallyCorrect(selected) : false;
+  const validTargetIds = useMemo21(
+    () => new Set(props.targets.map((t) => t.id)),
+    [props.targets]
+  );
   const handle = useMemo21(
     () => buildAssessmentHandle({
       checkId,
-      getScore: () => checked && correct ? 1 : 0,
-      getMaxScore: () => 1,
-      getAnswerGiven: () => selected.size > 0,
+      getScore: () => score,
+      getMaxScore: () => maxScore,
+      getAnswerGiven: () => checked,
       resetTask: () => {
         setSelected(/* @__PURE__ */ new Set());
         setChecked(false);
@@ -3915,42 +4727,68 @@ function FindMultipleHotspotsInner(props, ref) {
         checkId,
         interactionType: INTERACTION12,
         response: [...selected],
-        correct: checked ? correct : void 0,
-        score: checked && correct ? 1 : 0,
-        maxScore: 1
+        correct: checked ? factualCorrect : void 0,
+        score: checked ? score : 0,
+        maxScore
       }),
       getCurrentState: () => ({ selected: [...selected], checked }),
       resume: (state) => {
         const raw = state.selected;
-        if (Array.isArray(raw)) setSelected(new Set(raw.filter((id) => typeof id === "string")));
+        if (Array.isArray(raw)) {
+          setSelected(
+            new Set(
+              raw.filter(
+                (id) => typeof id === "string" && validTargetIds.has(id)
+              )
+            )
+          );
+        }
         readBooleanStateField(state, "checked", setChecked);
       }
     }),
-    [checkId, selected, checked, correct, props.correctTargetIds]
+    [
+      checkId,
+      checked,
+      factualCorrect,
+      maxScore,
+      props.correctTargetIds,
+      score,
+      selected,
+      validTargetIds
+    ]
   );
   useAssessmentHandleRegistration(checkId, handle, ref);
   const submit = () => {
     if (selected.size === 0 || checked) return;
+    const correctAtSubmit = isFactuallyCorrect(selected);
     setChecked(true);
     assessment.answer({
       checkId,
       interactionType: INTERACTION12,
       response: [...selected],
-      correct
+      correct: correctAtSubmit
     });
-    if (correct) {
+    if (passedThreshold) {
       assessment.complete({
         checkId,
         interactionType: INTERACTION12,
-        score: 1,
-        maxScore: 1,
-        passingScore: props.passingScore ?? 1
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
+      });
+    } else if (props.enableRetry === false) {
+      assessment.complete({
+        checkId,
+        interactionType: INTERACTION12,
+        score,
+        maxScore,
+        passingScore: props.passingScore ?? maxScore
       });
     }
   };
   return /* @__PURE__ */ jsxs29("section", { "aria-label": "Find multiple hotspots", "data-lk-check-id": checkId, "data-testid": "find-multiple-hotspots", children: [
     /* @__PURE__ */ jsxs29("div", { style: { position: "relative", display: "inline-block" }, children: [
-      /* @__PURE__ */ jsx32("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
+      resolvedSrc ? /* @__PURE__ */ jsx32("img", { src: resolvedSrc, alt: props.alt, style: { maxWidth: "100%" } }) : /* @__PURE__ */ jsx32("p", { role: "alert", children: "This image URL is not allowed." }),
       props.targets.map((t) => /* @__PURE__ */ jsx32(
         "button",
         {
@@ -3971,7 +4809,7 @@ function FindMultipleHotspotsInner(props, ref) {
       ))
     ] }),
     /* @__PURE__ */ jsx32("button", { type: "button", "data-testid": "check-hotspots", disabled: selected.size === 0, onClick: submit, children: "Check" }),
-    checked ? /* @__PURE__ */ jsx32("p", { role: "status", children: correct ? "Correct" : "Try again" }) : null
+    checked ? /* @__PURE__ */ jsx32("p", { role: "status", children: passedThreshold ? "Correct" : "Try again" }) : null
   ] });
 }
 var FindMultipleHotspotsInnerForwarded = forwardRef16(FindMultipleHotspotsInner);
@@ -3982,6 +4820,679 @@ var FindMultipleHotspots = forwardRef16(
 );
 setLessonkitBlockType(FindMultipleHotspots, "FindMultipleHotspots");
 
+// src/compound/useBranchingScenario.tsx
+import { createContext, useContext as useContext3 } from "react";
+import { jsx as jsx33 } from "react/jsx-runtime";
+var BranchingScenarioContext = createContext(null);
+function BranchingScenarioProvider(props) {
+  return /* @__PURE__ */ jsx33(BranchingScenarioContext.Provider, { value: props.value, children: props.children });
+}
+function useBranchingScenario() {
+  const ctx = useContext3(BranchingScenarioContext);
+  if (!ctx) {
+    throw new Error("useBranchingScenario must be used within BranchingScenario");
+  }
+  return ctx;
+}
+function useBranchingScenarioOptional() {
+  return useContext3(BranchingScenarioContext);
+}
+
+// src/blocks/BranchingScenario.tsx
+import React34, { forwardRef as forwardRef17, useCallback as useCallback11, useEffect as useEffect27, useLayoutEffect as useLayoutEffect2, useMemo as useMemo22, useRef as useRef20, useState as useState26 } from "react";
+import { clampCompoundPageIndex as clampCompoundPageIndex3 } from "@lessonkit/core";
+
+// src/compound/useCompoundBranchHandle.ts
+import { useCallback as useCallback10, useImperativeHandle } from "react";
+import { createCompoundResumeState as createCompoundResumeState4 } from "@lessonkit/core";
+function useCompoundBranchHandle(ref, opts) {
+  const bridgeRef = useCompoundHydrationBridgeRef();
+  const {
+    activePageIndex,
+    getRegisteredHandles,
+    visitedNodeIndices,
+    choiceScores,
+    meta,
+    maxChoiceScore = 0,
+    onResetMeta,
+    enableSolutionsButton
+  } = opts;
+  const filterVisited = useCallback10(
+    (handles) => {
+      const filtered = [];
+      for (const entry of handles) {
+        const { pageIndex } = entry;
+        if (pageIndex === void 0) continue;
+        if (visitedNodeIndices.has(pageIndex)) filtered.push(entry);
+      }
+      return filtered;
+    },
+    [visitedNodeIndices]
+  );
+  useImperativeHandle(
+    ref,
+    () => ({
+      getScore: () => {
+        const assessment = aggregateAssessmentScores(filterVisited(getRegisteredHandles().values()));
+        return assessment.score + sumChoiceScores(choiceScores);
+      },
+      getMaxScore: () => {
+        const assessment = aggregateAssessmentScores(filterVisited(getRegisteredHandles().values()));
+        return assessment.maxScore + maxChoiceScore;
+      },
+      getAnswerGiven: () => aggregateAssessmentScores(filterVisited(getRegisteredHandles().values())).allAnswered,
+      resetTask: () => {
+        onResetMeta();
+        for (const entry of filterVisited(getRegisteredHandles().values())) {
+          entry.handle.resetTask();
+        }
+      },
+      showSolutions: () => {
+        if (!enableSolutionsButton) return;
+        for (const entry of filterVisited(getRegisteredHandles().values())) {
+          entry.handle.showSolutions();
+        }
+      },
+      getCurrentState: () => {
+        const childStates = {};
+        for (const [checkId, entry] of getRegisteredHandles()) {
+          const { pageIndex } = entry;
+          if (pageIndex === void 0 || !visitedNodeIndices.has(pageIndex)) continue;
+          if (entry.handle.getCurrentState) {
+            childStates[checkId] = entry.handle.getCurrentState();
+          }
+        }
+        return mergeBranchMetaIntoState(
+          createCompoundResumeState4({ activePageIndex, childStates }),
+          meta
+        );
+      },
+      resume: (state) => {
+        bridgeRef?.current?.notifyImperativeResume(state);
+      }
+    }),
+    [
+      activePageIndex,
+      bridgeRef,
+      choiceScores,
+      enableSolutionsButton,
+      filterVisited,
+      getRegisteredHandles,
+      meta,
+      maxChoiceScore,
+      onResetMeta,
+      visitedNodeIndices
+    ]
+  );
+}
+
+// src/compound/validateBranchGraph.ts
+import React33 from "react";
+import { validateBranchGraph } from "@lessonkit/core";
+function extractBranchGraph(nodes) {
+  return nodes.map((node) => {
+    const choices = [];
+    React33.Children.forEach(node.props.children, (child) => {
+      if (!React33.isValidElement(child)) return;
+      if (getLessonkitBlockType(child.type) !== "BranchChoice") return;
+      const targetNodeId = child.props.targetNodeId;
+      if (typeof targetNodeId === "string") {
+        choices.push({ targetNodeId: normalizeComponentId(targetNodeId, "blockId") });
+      }
+    });
+    return {
+      nodeId: normalizeComponentId(node.props.nodeId, "blockId"),
+      terminal: Boolean(node.props.terminal),
+      choices
+    };
+  });
+}
+function validateBranchGraphAtMount(startNodeId, nodes, strict) {
+  const graph = extractBranchGraph(nodes);
+  const result = validateBranchGraph(startNodeId, graph.map(({ nodeId, choices }) => ({ nodeId, choices })));
+  for (const node of graph) {
+    if (node.terminal && node.choices.length > 0) {
+      const msg = `[lessonkit] BranchingScenario: terminal node "${node.nodeId}" must not contain BranchChoice children`;
+      if (strict || !isDevEnvironment()) {
+        throw new Error(msg);
+      }
+      console.warn(msg);
+    }
+  }
+  for (const issue of result.issues) {
+    const msg = `[lessonkit] BranchingScenario: ${issue.message}`;
+    if (strict || !isDevEnvironment()) {
+      throw new Error(msg);
+    }
+    console.warn(msg);
+  }
+}
+function buildNodeIndexMap(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  nodes.forEach((node, index) => {
+    map.set(normalizeComponentId(node.props.nodeId, "blockId"), index);
+  });
+  return map;
+}
+function buildNodeLabels(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const nodeId = normalizeComponentId(node.props.nodeId, "blockId");
+    map.set(nodeId, node.props.title ?? nodeId);
+  }
+  return map;
+}
+function filterBranchNodeContent(children) {
+  const filtered = [];
+  React33.Children.forEach(children, (child) => {
+    if (!React33.isValidElement(child)) {
+      filtered.push(child);
+      return;
+    }
+    if (getLessonkitBlockType(child.type) === "BranchChoice") return;
+    filtered.push(child);
+  });
+  return filtered;
+}
+function nodeHasChoices(node) {
+  let hasChoice = false;
+  React33.Children.forEach(node.props.children, (child) => {
+    if (!React33.isValidElement(child)) return;
+    if (getLessonkitBlockType(child.type) === "BranchChoice") hasChoice = true;
+  });
+  return hasChoice;
+}
+
+// src/blocks/BranchingScenario.tsx
+import { jsx as jsx34, jsxs as jsxs30 } from "react/jsx-runtime";
+var BranchingScenarioInner = forwardRef17(function BranchingScenarioInner2(props, ref) {
+  const { blockId, nodes, persistEnabled, startNodeId } = props;
+  validateCompoundChildren("BranchingScenario", nodes);
+  useLayoutEffect2(() => {
+    validateBranchGraphAtMount(startNodeId, nodes);
+  }, [startNodeId, nodes]);
+  const { config, track, storage } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const ctx = useCompoundRegistry();
+  const nodeIndexMap = useMemo22(() => buildNodeIndexMap(nodes), [nodes]);
+  const nodeLabels = useMemo22(() => buildNodeLabels(nodes), [nodes]);
+  const [meta, setMeta] = useState26(() => createInitialBranchMeta(startNodeId));
+  const metaRef = useRef20(meta);
+  const branchViewedRef = useRef20(/* @__PURE__ */ new Set());
+  const legacyResumeWarnedRef = useRef20(false);
+  const commitMeta = useCallback11((next) => {
+    metaRef.current = next;
+    setMeta(next);
+  }, []);
+  const activeIndex = nodeIndexMap.get(meta.activeNodeId) ?? 0;
+  const visitedNodeIndices = useMemo22(() => {
+    const indices = /* @__PURE__ */ new Set();
+    for (const nodeId of meta.visitedNodeIds) {
+      const i = nodeIndexMap.get(nodeId);
+      if (i !== void 0) indices.add(i);
+    }
+    return indices;
+  }, [meta.visitedNodeIds, nodeIndexMap]);
+  const syncBranchViewedRef = useCallback11(
+    (restoredMeta) => {
+      const next = /* @__PURE__ */ new Set();
+      for (const nodeId of restoredMeta.visitedNodeIds) {
+        if (nodeId !== restoredMeta.activeNodeId) {
+          next.add(`${blockId}:${nodeId}`);
+        }
+      }
+      branchViewedRef.current = next;
+    },
+    [blockId]
+  );
+  const applyResumeState = useCallback11(
+    (state) => {
+      const fromMeta = readBranchingScenarioMeta(state.childStates);
+      if (fromMeta) {
+        const sanitized = sanitizeBranchMeta(fromMeta, nodeIndexMap, startNodeId);
+        commitMeta(sanitized);
+        syncBranchViewedRef(sanitized);
+        return;
+      }
+      const hasChildCheckStates = Object.keys(state.childStates).some((k) => k !== BS_META_KEY);
+      const clampedIndex = clampCompoundPageIndex3(state.activePageIndex, nodes.length);
+      const nodeAtIndex = nodes[clampedIndex];
+      if (nodeAtIndex || hasChildCheckStates) {
+        const nodeId = nodeAtIndex?.props.nodeId ?? startNodeId;
+        const visitedNodeIds = [startNodeId];
+        if (nodeId !== startNodeId) visitedNodeIds.push(nodeId);
+        const legacyMeta = sanitizeBranchMeta(
+          { activeNodeId: nodeId, visitedNodeIds, choiceScores: {} },
+          nodeIndexMap,
+          startNodeId
+        );
+        commitMeta(legacyMeta);
+        syncBranchViewedRef(legacyMeta);
+        if (!legacyResumeWarnedRef.current && isDevEnvironment() && (hasChildCheckStates || state.activePageIndex !== 0)) {
+          legacyResumeWarnedRef.current = true;
+          console.warn(
+            "[lessonkit] BranchingScenario: legacy save without branch meta; restored via activePageIndex and child states"
+          );
+        }
+        return;
+      }
+      if (!legacyResumeWarnedRef.current && isDevEnvironment() && (state.activePageIndex !== 0 || Object.keys(state.childStates).length > 0)) {
+        legacyResumeWarnedRef.current = true;
+        console.warn(
+          "[lessonkit] BranchingScenario: legacy save without branch meta; starting at startNodeId"
+        );
+      }
+      const fresh = sanitizeBranchMeta(createInitialBranchMeta(startNodeId), nodeIndexMap, startNodeId);
+      commitMeta(fresh);
+      syncBranchViewedRef(fresh);
+    },
+    [commitMeta, nodeIndexMap, nodes, startNodeId, syncBranchViewedRef]
+  );
+  const resetBranchMeta = useCallback11(() => {
+    commitMeta(createInitialBranchMeta(startNodeId));
+    branchViewedRef.current = /* @__PURE__ */ new Set();
+  }, [commitMeta, startNodeId]);
+  const transformState = useCallback11(
+    (state) => mergeBranchMetaIntoState(state, metaRef.current),
+    []
+  );
+  const shouldIncludeChildState = useCallback11(
+    (_checkId, pageIndex) => pageIndex !== void 0 && visitedNodeIndices.has(pageIndex),
+    [visitedNodeIndices]
+  );
+  useCompoundPersistence({
+    courseId: config.courseId,
+    compoundId: blockId,
+    pageCount: nodes.length,
+    index: activeIndex,
+    setIndex: () => {
+    },
+    enabled: persistEnabled,
+    storage,
+    transformState,
+    onCompoundResume: applyResumeState,
+    shouldIncludeChildState
+  });
+  const maxChoiceScoreOnPath = useMemo22(() => {
+    if (!meta.choiceScores) return 0;
+    const branchFromIds = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(meta.choiceScores)) {
+      const fromId = key.split(":")[0];
+      if (fromId) branchFromIds.add(fromId);
+    }
+    let total = 0;
+    for (const node of nodes) {
+      const nodeId = node.props.nodeId;
+      if (!branchFromIds.has(nodeId)) continue;
+      let maxWeight = 0;
+      let found = false;
+      for (const child of React34.Children.toArray(node.props.children)) {
+        if (!React34.isValidElement(child)) continue;
+        const weight = child.props.scoreWeight;
+        if (typeof weight === "number" && Number.isFinite(weight)) {
+          found = true;
+          maxWeight = Math.max(maxWeight, weight);
+        }
+      }
+      if (found) total += maxWeight;
+    }
+    return total;
+  }, [meta.choiceScores, nodes]);
+  useCompoundBranchHandle(ref, {
+    activePageIndex: activeIndex,
+    getRegisteredHandles: () => ctx?.getRegisteredHandles() ?? /* @__PURE__ */ new Map(),
+    visitedNodeIndices,
+    choiceScores: meta.choiceScores ?? {},
+    meta,
+    maxChoiceScore: maxChoiceScoreOnPath,
+    onResetMeta: resetBranchMeta,
+    enableSolutionsButton: props.enableSolutionsButton
+  });
+  const activeNode = nodes[activeIndex];
+  const isTerminal = Boolean(activeNode?.props.terminal) || (activeNode ? !nodeHasChoices(activeNode) && meta.activeNodeId !== startNodeId : false);
+  const visitedLabels = useMemo22(
+    () => meta.visitedNodeIds.map((id) => ({
+      nodeId: id,
+      label: nodeLabels.get(id) ?? id
+    })),
+    [meta.visitedNodeIds, nodeLabels]
+  );
+  useEffect27(() => {
+    if (!lessonId || !activeNode) return;
+    const dedupeKey = `${blockId}:${meta.activeNodeId}`;
+    if (branchViewedRef.current.has(dedupeKey)) return;
+    branchViewedRef.current.add(dedupeKey);
+    track(
+      "branch_node_viewed",
+      {
+        blockId,
+        nodeId: meta.activeNodeId,
+        nodeIndex: activeIndex,
+        nodeTitle: activeNode.props.title
+      },
+      { lessonId }
+    );
+  }, [activeIndex, activeNode, blockId, lessonId, meta.activeNodeId, track]);
+  const navigateToNode = useCallback11(
+    (opts) => {
+      const toNodeId = normalizeComponentId(opts.toNodeId, "blockId");
+      const fromNodeId = normalizeComponentId(opts.fromNodeId, "blockId");
+      if (!nodeIndexMap.has(toNodeId)) {
+        if (isDevEnvironment()) {
+          console.warn(
+            `[lessonkit] BranchingScenario: unknown targetNodeId "${toNodeId}" from "${fromNodeId}"`
+          );
+        }
+        return;
+      }
+      const activeNodeId = metaRef.current.activeNodeId;
+      if (fromNodeId !== activeNodeId) {
+        if (isDevEnvironment()) {
+          console.warn(
+            `[lessonkit] BranchingScenario: navigateToNode from "${fromNodeId}" but active node is "${activeNodeId}"`
+          );
+        }
+        return;
+      }
+      if (lessonId) {
+        track(
+          "branch_selected",
+          {
+            blockId,
+            fromNodeId,
+            toNodeId,
+            label: opts.label,
+            scoreWeight: opts.scoreWeight
+          },
+          { lessonId }
+        );
+      }
+      setMeta((prev) => {
+        const choiceScores = applyChoiceScoreUpdate(
+          prev.choiceScores,
+          fromNodeId,
+          toNodeId,
+          opts.scoreWeight
+        );
+        const visited = prev.visitedNodeIds.includes(toNodeId) ? prev.visitedNodeIds : [...prev.visitedNodeIds, toNodeId];
+        const next = sanitizeBranchMeta(
+          {
+            activeNodeId: toNodeId,
+            visitedNodeIds: visited,
+            choiceScores
+          },
+          nodeIndexMap,
+          startNodeId
+        );
+        metaRef.current = next;
+        return next;
+      });
+    },
+    [blockId, lessonId, nodeIndexMap, startNodeId, track]
+  );
+  const choicesLocked = isTerminal;
+  const contextValue = useMemo22(
+    () => ({
+      compoundBlockId: blockId,
+      activeNodeId: meta.activeNodeId,
+      visitedNodeIds: meta.visitedNodeIds,
+      visitedLabels: visitedLabels.map((entry) => entry.label),
+      navigateToNode,
+      isTerminal,
+      choicesLocked
+    }),
+    [blockId, choicesLocked, isTerminal, meta.activeNodeId, meta.visitedNodeIds, navigateToNode, visitedLabels]
+  );
+  const pathScore = ctx ? Array.from(ctx.getRegisteredHandles().values()).filter((h) => h.pageIndex !== void 0 && visitedNodeIndices.has(h.pageIndex)).reduce((s, h) => s + h.handle.getScore(), 0) + sumChoiceScores(meta.choiceScores) : 0;
+  const pathMaxScore = ctx ? Array.from(ctx.getRegisteredHandles().values()).filter((h) => h.pageIndex !== void 0 && visitedNodeIndices.has(h.pageIndex)).reduce((s, h) => s + h.handle.getMaxScore(), 0) + maxChoiceScoreOnPath : 0;
+  return /* @__PURE__ */ jsx34(BranchingScenarioProvider, { value: contextValue, children: /* @__PURE__ */ jsxs30("section", { "aria-label": props.title, "data-testid": "branching-scenario", "data-lk-block-id": blockId, children: [
+    /* @__PURE__ */ jsx34("h3", { children: props.title }),
+    props.showPathScore && ctx ? /* @__PURE__ */ jsxs30("p", { "data-testid": "branch-score", children: [
+      "Score: ",
+      pathScore,
+      " / ",
+      pathMaxScore
+    ] }) : null,
+    props.showPathRecap && isTerminal && meta.visitedNodeIds.length > 0 ? /* @__PURE__ */ jsxs30("aside", { "data-testid": "branch-path-recap", "aria-label": "Your path", children: [
+      /* @__PURE__ */ jsx34("h4", { children: "Your path" }),
+      /* @__PURE__ */ jsx34("ol", { children: visitedLabels.map((entry) => /* @__PURE__ */ jsx34("li", { children: entry.label }, entry.nodeId)) })
+    ] }) : null,
+    /* @__PURE__ */ jsx34("div", { "data-testid": "branching-scenario-active-node", children: nodes.map((node, i) => {
+      const content = React34.Children.map(node.props.children, (child) => {
+        if (!React34.isValidElement(child)) return child;
+        if (getLessonkitBlockType(child.type) !== "BranchChoice") return child;
+        return React34.cloneElement(child, {
+          fromNodeId: node.props.nodeId
+        });
+      });
+      return React34.cloneElement(node, {
+        key: node.key ?? node.props.nodeId,
+        hidden: i !== activeIndex,
+        nodeIndex: i,
+        children: content
+      });
+    }) })
+  ] }) });
+});
+var BranchingScenario = forwardRef17(
+  function BranchingScenario2(props, ref) {
+    const nodes = React34.Children.toArray(props.children).filter(
+      React34.isValidElement
+    );
+    const { config } = useLessonkit();
+    const persistEnabled = config.session?.persistCompoundState !== false;
+    requireCompoundBlockIdWhenPersisting({
+      persistEnabled,
+      blockId: props.blockId,
+      componentName: "BranchingScenario"
+    });
+    const blockId = useMemo22(
+      () => normalizeComponentId(props.blockId, "blockId"),
+      [props.blockId]
+    );
+    const startNodeId = useMemo22(
+      () => normalizeComponentId(props.startNodeId, "blockId"),
+      [props.startNodeId]
+    );
+    const nodeIndexMap = useMemo22(() => buildNodeIndexMap(nodes), [nodes]);
+    const initialIndex = nodeIndexMap.get(startNodeId) ?? 0;
+    const hydrationKey = `${config.courseId ?? "no-course"}:${blockId}`;
+    const setIndexStable = useCallback11(() => {
+    }, []);
+    return /* @__PURE__ */ jsx34(CompoundProvider, { activePageIndex: initialIndex, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ jsx34(
+      BranchingScenarioInner,
+      {
+        ...props,
+        startNodeId,
+        ref,
+        blockId,
+        nodes,
+        persistEnabled
+      },
+      hydrationKey
+    ) });
+  }
+);
+setLessonkitBlockType(BranchingScenario, "BranchingScenario");
+
+// src/blocks/BranchNode.tsx
+import "react";
+import { jsx as jsx35, jsxs as jsxs31 } from "react/jsx-runtime";
+function BranchNode(props) {
+  validateCompoundChildren("BranchNode", filterBranchNodeContent(props.children));
+  return /* @__PURE__ */ jsxs31(
+    "section",
+    {
+      "aria-label": props.title ?? props.nodeId,
+      "data-lk-node-id": props.nodeId,
+      "data-testid": `branch-node-${props.nodeId}`,
+      hidden: props.hidden ? true : void 0,
+      style: props.hidden ? { display: "none" } : void 0,
+      children: [
+        props.title ? /* @__PURE__ */ jsx35("h4", { children: props.title }) : null,
+        /* @__PURE__ */ jsx35(CompoundPageIndexProvider, { pageIndex: props.nodeIndex ?? 0, children: /* @__PURE__ */ jsx35("div", { children: props.children }) })
+      ]
+    }
+  );
+}
+setLessonkitBlockType(BranchNode, "BranchNode");
+
+// src/blocks/BranchChoice.tsx
+import { useId as useId4 } from "react";
+import { jsx as jsx36 } from "react/jsx-runtime";
+function BranchChoice(props) {
+  const ctx = useBranchingScenarioOptional();
+  const groupId = useId4();
+  const fromNodeId = props.fromNodeId ?? ctx?.activeNodeId ?? "";
+  const isActiveNode = ctx ? ctx.activeNodeId === fromNodeId : true;
+  const locked = ctx?.choicesLocked ?? false;
+  const onSelect = () => {
+    if (!ctx || !fromNodeId || props.disabled || locked || !isActiveNode) return;
+    ctx.navigateToNode({
+      fromNodeId,
+      toNodeId: props.targetNodeId,
+      label: props.label,
+      scoreWeight: props.scoreWeight
+    });
+  };
+  return /* @__PURE__ */ jsx36(
+    "button",
+    {
+      type: "button",
+      role: "radio",
+      "aria-checked": false,
+      "aria-labelledby": groupId,
+      "data-testid": `branch-choice-${props.targetNodeId}`,
+      disabled: props.disabled || locked || !isActiveNode,
+      onClick: onSelect,
+      children: /* @__PURE__ */ jsx36("span", { id: groupId, children: props.label })
+    }
+  );
+}
+setLessonkitBlockType(BranchChoice, "BranchChoice");
+
+// src/blocks/Embed.tsx
+import { useEffect as useEffect28 } from "react";
+import { jsx as jsx37, jsxs as jsxs32 } from "react/jsx-runtime";
+function Embed(props) {
+  const blockId = normalizeComponentId(props.blockId, "blockId");
+  const { config, track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const resolvedSrc = resolveEmbedSrc(props.src, {
+    allowedHosts: config.embed?.allowedHosts
+  });
+  const sandbox = buildEmbedSandbox(props.allow, {
+    restrictPopupsInProduction: config.embed?.restrictPopupsInProduction ?? true
+  });
+  const aspectRatio = resolveEmbedAspectRatio(props.aspectRatio);
+  useEffect28(() => {
+    if (!resolvedSrc) return;
+    track(
+      "interaction",
+      { kind: "embed_viewed", blockId, src: telemetryEmbedSrc(resolvedSrc) },
+      lessonId ? { lessonId } : void 0
+    );
+  }, [blockId, lessonId, resolvedSrc, track]);
+  if (!resolvedSrc) {
+    return /* @__PURE__ */ jsx37("figure", { "data-lk-block-id": blockId, "data-testid": `embed-${blockId}`, children: /* @__PURE__ */ jsx37("p", { role: "alert", children: "This embed URL is not allowed." }) });
+  }
+  return /* @__PURE__ */ jsxs32("figure", { "data-lk-block-id": blockId, "data-testid": `embed-${blockId}`, children: [
+    /* @__PURE__ */ jsx37(
+      "iframe",
+      {
+        title: props.title,
+        src: resolvedSrc,
+        sandbox,
+        referrerPolicy: "no-referrer",
+        style: aspectRatio ? { aspectRatio, width: "100%", border: 0 } : { width: "100%", border: 0 }
+      }
+    ),
+    /* @__PURE__ */ jsx37("figcaption", { className: "lk-visually-hidden", children: props.title })
+  ] });
+}
+setLessonkitBlockType(Embed, "Embed");
+
+// src/blocks/Chart.tsx
+import { useEffect as useEffect29, useMemo as useMemo23 } from "react";
+
+// src/blocks/chartUtils.ts
+function normalizeChartType(type) {
+  if (type === "bar" || type === "pie") return type;
+  if (type !== void 0 && isDevEnvironment()) {
+    console.warn(`[lessonkit] Chart: unknown type "${type}"; rendering data table only.`);
+  }
+  return type === void 0 ? "pie" : "table";
+}
+function normalizeChartData(data) {
+  if (!Array.isArray(data)) return [];
+  const rows = [];
+  for (let i = 0; i < data.length; i += 1) {
+    const row = data[i];
+    if (!row || typeof row !== "object") continue;
+    const label = typeof row.label === "string" ? row.label : `Item ${i + 1}`;
+    const raw = Number(row.value);
+    const value = Number.isFinite(raw) && raw >= 0 ? raw : 0;
+    rows.push({ label, value, key: `${label}-${i}` });
+  }
+  return rows;
+}
+function chartMaxValue(rows) {
+  if (rows.length === 0) return 1;
+  return Math.max(...rows.map((row) => row.value), 1);
+}
+
+// src/blocks/Chart.tsx
+import { jsx as jsx38, jsxs as jsxs33 } from "react/jsx-runtime";
+function Chart(props) {
+  const blockId = normalizeComponentId(props.blockId, "blockId");
+  const { track } = useLessonkit();
+  const lessonId = useEnclosingLessonId();
+  const chartType = normalizeChartType(props.type);
+  const rows = useMemo23(() => normalizeChartData(props.data), [props.data]);
+  const max = useMemo23(() => chartMaxValue(rows), [rows]);
+  useEffect29(() => {
+    track(
+      "interaction",
+      { kind: "chart_viewed", blockId, chartType },
+      lessonId ? { lessonId } : void 0
+    );
+  }, [blockId, chartType, lessonId, track]);
+  return /* @__PURE__ */ jsxs33("figure", { "data-lk-block-id": blockId, "data-testid": `chart-${blockId}`, children: [
+    props.title ? /* @__PURE__ */ jsx38("figcaption", { children: props.title }) : null,
+    rows.length === 0 ? /* @__PURE__ */ jsx38("p", { "data-testid": "chart-empty", children: "No chart data." }) : chartType === "table" ? null : chartType === "bar" ? /* @__PURE__ */ jsx38("div", { role: "img", "aria-label": props.title ?? "Bar chart", "aria-describedby": `${blockId}-table`, children: rows.map((datum) => /* @__PURE__ */ jsxs33("div", { style: { display: "flex", alignItems: "center", gap: "0.5rem" }, children: [
+      /* @__PURE__ */ jsx38("span", { style: { minWidth: "6rem" }, children: datum.label }),
+      /* @__PURE__ */ jsx38(
+        "div",
+        {
+          style: {
+            height: "1rem",
+            width: `${datum.value / max * 100}%`,
+            background: "var(--lk-color-primary, #2563eb)"
+          },
+          "aria-hidden": true
+        }
+      ),
+      /* @__PURE__ */ jsx38("span", { children: datum.value })
+    ] }, datum.key)) }) : /* @__PURE__ */ jsx38("ul", { role: "list", "aria-label": props.title ?? "Pie chart segments", children: rows.map((datum) => /* @__PURE__ */ jsxs33("li", { children: [
+      datum.label,
+      ": ",
+      datum.value
+    ] }, datum.key)) }),
+    /* @__PURE__ */ jsxs33("table", { id: `${blockId}-table`, children: [
+      /* @__PURE__ */ jsx38("caption", { children: props.title ?? "Chart data" }),
+      /* @__PURE__ */ jsx38("thead", { children: /* @__PURE__ */ jsxs33("tr", { children: [
+        /* @__PURE__ */ jsx38("th", { scope: "col", children: "Label" }),
+        /* @__PURE__ */ jsx38("th", { scope: "col", children: "Value" })
+      ] }) }),
+      /* @__PURE__ */ jsx38("tbody", { children: rows.map((datum) => /* @__PURE__ */ jsxs33("tr", { children: [
+        /* @__PURE__ */ jsx38("th", { scope: "row", children: datum.label }),
+        /* @__PURE__ */ jsx38("td", { children: datum.value })
+      ] }, datum.key)) })
+    ] })
+  ] });
+}
+setLessonkitBlockType(Chart, "Chart");
+
 export {
   TrueFalse,
   MarkTheWords,
@@ -4014,5 +5525,11 @@ export {
   ImageHotspots,
   ImageSlider,
   FindHotspot,
-  FindMultipleHotspots
+  FindMultipleHotspots,
+  useBranchingScenario,
+  BranchingScenario,
+  BranchNode,
+  BranchChoice,
+  Embed,
+  Chart
 };