@lessonkit/react 1.3.0 → 1.4.0

package/dist/index.js

@@ -1,4074 +1,198 @@
-// src/components.tsx
-import { useEffect as useEffect4, useId as useId2, useMemo as useMemo6, useRef as useRef5, useState as useState4 } from "react";
-import { visuallyHiddenStyle as visuallyHiddenStyle2 } from "@lessonkit/accessibility";
-
-// src/context.tsx
-import { createContext } from "react";
-
-// src/provider/useLessonkitProviderRuntime.ts
-import {
-  useCallback,
-  useEffect,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState
-} from "react";
-import { createLessonkitRuntime, createTrackingClient as createTrackingClient2, assertValidId } from "@lessonkit/core";
-
-// src/runtime/observability.ts
-import { createInMemoryXAPIQueue } from "@lessonkit/xapi";
-function createXapiQueueFromObservability(observability) {
-  const opts = {};
-  if (observability?.onXapiQueueDepth) {
-    opts.onDepth = observability.onXapiQueueDepth;
-  }
-  if (observability?.onXapiQueueCap) {
-    opts.onCap = observability.onXapiQueueCap;
-  }
-  return createInMemoryXAPIQueue(opts);
-}
-function wrapTrackingSink(sink, observability) {
-  if (!sink || !observability?.onTelemetrySinkError) return sink;
-  const onError = observability.onTelemetrySinkError;
-  return ((event) => {
-    try {
-      const result = sink(event);
-      if (result != null && typeof result.catch === "function") {
-        return result.catch((err) => {
-          onError(err, { sinkId: "tracking" });
-        });
-      }
-      return result;
-    } catch (err) {
-      onError(err, { sinkId: "tracking" });
-      return void 0;
-    }
-  });
-}
-
-// src/provider/useLessonkitProviderRuntime.ts
-import { telemetryEventToXAPIStatement as telemetryEventToXAPIStatement3 } from "@lessonkit/xapi";
-
-// src/runtime/emitTelemetry.ts
-import { buildTelemetryEvent, tryBuildTelemetryEvent } from "@lessonkit/core";
-
-// src/runtime/telemetryPipeline.ts
-import {
-  createTelemetryPipeline,
-  createTrackingPipelineSink
-} from "@lessonkit/core";
-import { telemetryEventToXAPIStatement } from "@lessonkit/xapi";
-
-// src/runtime/lxpackBridge.ts
 import {
-  dispatchBridgeAction,
-  forwardTelemetryToBridge,
-  getLxpackBridge,
-  mapLessonkitTelemetryToBridgeAction,
-  telemetryEventToLessonkit
-} from "@lessonkit/lxpack/bridge";
-var BRIDGE_MISS_EVENT_NAMES = /* @__PURE__ */ new Set([
-  "course_completed",
-  "lesson_completed",
-  "assessment_completed",
-  "quiz_completed"
-]);
-function forwardTelemetryToLxpack(event, mode = "auto", opts) {
-  if (mode === "auto" && opts?.onBridgeMiss && BRIDGE_MISS_EVENT_NAMES.has(event.name) && !getLxpackBridge()) {
-    opts.onBridgeMiss(event);
-  }
-  forwardTelemetryToBridge(event, mode);
-}
-
-// src/runtime/telemetryPipeline.ts
-function isDevEnvironment() {
-  const g = globalThis;
-  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
-}
-function createLegacyPipeline(opts, extraSinks = []) {
-  return createTelemetryPipeline([
-    createTrackingPipelineSink("tracking", (event) => opts.tracking.track(event)),
-    {
-      id: "xapi",
-      emit(event) {
-        try {
-          const statement = telemetryEventToXAPIStatement(event);
-          if (statement) opts.xapi?.send(statement);
-        } catch (err) {
-          if (isDevEnvironment()) {
-            console.warn(
-              "[lessonkit] xAPI mapping skipped:",
-              err instanceof Error ? err.message : err
-            );
-          }
-        }
-      }
-    },
-    {
-      id: "lxpack-bridge",
-      emit(event) {
-        forwardTelemetryToLxpack(event, opts.lxpackBridge, {
-          onBridgeMiss: opts.onLxpackBridgeMiss
-        });
-      }
-    },
-    ...extraSinks
-  ]);
-}
-function emitThroughPipeline(event, opts, extraSinks) {
-  createLegacyPipeline(opts, extraSinks).emit(event);
-}
-
-// src/runtime/emitTelemetry.ts
-var warnedMissingCourseId = false;
-function isDevEnvironment2() {
-  const g = globalThis;
-  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
-}
-function emitTelemetry(tracking, xapi, event, opts) {
-  if (!event.courseId) {
-    if (isDevEnvironment2() && !warnedMissingCourseId) {
-      warnedMissingCourseId = true;
-      console.warn("[lessonkit] telemetry event missing courseId");
-    }
-    return;
-  }
-  const legacy = {
-    tracking,
-    xapi,
-    lxpackBridge: opts?.lxpackBridge ?? "auto",
-    onLxpackBridgeMiss: opts?.onLxpackBridgeMiss
-  };
-  emitThroughPipeline(event, legacy, opts?.extraSinks);
-}
-
-// src/runtime/ports.ts
+  Accordion,
+  ArithmeticQuiz,
+  AssessmentSequence,
+  DialogCards,
+  DragAndDrop,
+  DragTheWords,
+  Essay,
+  FillInTheBlanks,
+  FindHotspot,
+  FindMultipleHotspots,
+  Flashcards,
+  Heading,
+  Image,
+  ImageHotspots,
+  ImagePairing,
+  ImageSequencing,
+  ImageSlider,
+  InformationWall,
+  InteractiveBook,
+  InteractiveVideo,
+  MarkTheWords,
+  MemoryGame,
+  Page,
+  ParallaxSlideshow,
+  Questionnaire,
+  Slide,
+  SlideDeck,
+  Summary,
+  Text,
+  TimedCue,
+  TrueFalse,
+  Video
+} from "./chunk-4LQ4TTEE.js";
 import {
-  createDefaultClock,
-  createGlobalTimer,
-  createNoopStorage,
-  createSessionStoragePort,
-  resetStoragePortForTests
-} from "@lessonkit/core";
-
-// src/provider/useLessonkitProviderRuntime.ts
-import { resetSharedVolatileSessionIdForTests } from "@lessonkit/core";
-
-// src/runtime/progress.ts
-import { createProgressController } from "@lessonkit/core";
-
-// src/runtime/xapi.ts
-import { createXAPIClient } from "@lessonkit/xapi";
-function createXapiClientFromConfig(config, queue) {
-  if (config.xapi?.enabled === false) return null;
-  if (config.xapi?.client) return config.xapi.client;
-  if (!config.courseId) return null;
-  const hasTransport = typeof config.xapi?.transport === "function";
-  if (!hasTransport && config.xapi?.enabled !== true) return null;
-  return createXAPIClient({
-    courseId: config.courseId,
-    transport: config.xapi?.transport,
-    queue
-  });
-}
-
-// src/runtime/session.ts
+  KnowledgeCheck,
+  Quiz,
+  getLessonMountCount,
+  registerLessonMount,
+  resetQuizWarningsForTests
+} from "./chunk-UUTXECVW.js";
 import {
-  SESSION_STORAGE_KEY,
-  getTabSessionId,
-  resolveSessionId,
-  hasCourseStarted,
-  markCourseStarted,
-  hasCourseStartedEmittedToTracking,
-  markCourseStartedEmittedToTracking,
-  hasCourseStartedPipelineDelivered,
-  markCourseStartedPipelineDelivered,
-  migrateCourseStartedMark
-} from "@lessonkit/core";
-
-// src/runtime/courseStartedPipeline.ts
-import { telemetryEventToXAPIStatement as telemetryEventToXAPIStatement2 } from "@lessonkit/xapi";
-function isDevEnvironment3() {
-  const g = globalThis;
-  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
-}
-function warnExtraSinkFailure(sinkId, err) {
-  if (isDevEnvironment3()) {
-    console.warn(
-      `[lessonkit] course_started extra sink "${sinkId}" failed:`,
-      err instanceof Error ? err.message : err
-    );
-  }
-}
-async function emitExtraSinks(sinks, event, emitCtx) {
-  await Promise.all(
-    sinks.map(async (sink) => {
-      let result;
-      try {
-        result = sink.emit(event, emitCtx);
-      } catch (err) {
-        warnExtraSinkFailure(sink.id, err);
-        throw err;
-      }
-      if (result != null && typeof result.then === "function") {
-        try {
-          await result;
-        } catch (err) {
-          warnExtraSinkFailure(sink.id, err);
-          throw err;
-        }
-      }
-    })
-  );
-}
-async function emitCourseStartedNonTrackingPipeline(opts) {
-  let xapiStatementSent = false;
-  if (!opts.skipXapi && opts.xapi) {
-    const statement = telemetryEventToXAPIStatement2(opts.event);
-    if (statement) {
-      opts.xapi.send(statement);
-      xapiStatementSent = true;
-    }
-  }
-  forwardTelemetryToLxpack(opts.event, opts.lxpackBridge, {
-    onBridgeMiss: opts.onLxpackBridgeMiss
-  });
-  const emitCtx = {
-    courseId: opts.event.courseId,
-    sessionId: opts.event.sessionId,
-    attemptId: opts.event.attemptId
-  };
-  await emitExtraSinks(opts.extraSinks ?? [], opts.event, emitCtx);
-  return { xapiStatementSent };
-}
-
-// src/runtime/plugins.ts
-import { buildPluginContext as buildPluginContextFromCore, createPluginRegistry } from "@lessonkit/core";
-function createReactPluginHost(plugins) {
-  if (!plugins?.length) return null;
-  return createPluginRegistry(plugins);
-}
-function buildPluginContext(opts) {
-  return buildPluginContextFromCore(opts);
-}
-function emitTelemetryWithPlugins(opts) {
-  const next = opts.pluginHost ? opts.pluginHost.runTelemetry(opts.event, opts.pluginCtx) : opts.event;
-  if (next === null) return;
-  emitTelemetry(opts.tracking, opts.xapi, next, {
-    lxpackBridge: opts.lxpackBridge ?? "auto",
-    extraSinks: opts.extraSinks,
-    onLxpackBridgeMiss: opts.onLxpackBridgeMiss
-  });
-}
-
-// src/provider/courseStarted/emit.ts
-var courseStartedTrackingFlightKey = null;
-function isTrackingActive(tracking) {
-  return tracking?.enabled !== false;
-}
-function isCourseStartedSinkSettled(result) {
-  return result === "emitted";
-}
-function buildCourseStartedEvent(opts) {
-  const pluginCtx = buildPluginContext({
-    courseId: opts.courseId,
-    sessionId: opts.sessionId,
-    attemptId: opts.attemptId,
-    user: opts.user
-  });
-  const built = buildTelemetryEvent({
-    name: "course_started",
-    courseId: opts.courseId,
-    sessionId: opts.sessionId,
-    attemptId: opts.attemptId,
-    user: opts.user
-  });
-  return opts.pluginHost ? opts.pluginHost.runTelemetry(built, pluginCtx) : built;
-}
-async function emitCourseStartedToTracking(tracking, storage, sessionId, courseId, event, shouldCommit) {
-  const flightKey = `${sessionId}:${courseId}`;
-  if (hasCourseStartedEmittedToTracking(storage, sessionId, courseId)) {
-    return true;
-  }
-  if (courseStartedTrackingFlightKey === flightKey) {
-    return false;
-  }
-  courseStartedTrackingFlightKey = flightKey;
-  try {
-    if (shouldCommit && !shouldCommit()) return false;
-    tracking.track(event);
-    markCourseStartedEmittedToTracking(storage, sessionId, courseId);
-    const delivered = await tracking.flush?.();
-    if (delivered === false) return false;
-    if (shouldCommit && !shouldCommit()) return false;
-    return true;
-  } catch {
-    return false;
-  } finally {
-    if (courseStartedTrackingFlightKey === flightKey) {
-      courseStartedTrackingFlightKey = null;
-    }
-  }
-}
-async function emitCourseStartedPipelineOnly(opts) {
-  try {
-    if (opts.shouldCommit && !opts.shouldCommit()) return "failed";
-    const { xapiStatementSent } = await emitCourseStartedNonTrackingPipeline({
-      event: opts.event,
-      xapi: opts.xapi,
-      lxpackBridge: opts.lxpackBridge,
-      onLxpackBridgeMiss: opts.onLxpackBridgeMiss,
-      extraSinks: opts.extraSinks,
-      skipXapi: opts.skipXapi
-    });
-    if (opts.shouldCommit && !opts.shouldCommit()) return "failed";
-    markCourseStarted(opts.storage, opts.sessionId, opts.courseId);
-    markCourseStartedPipelineDelivered(opts.storage, opts.sessionId, opts.courseId);
-    if (xapiStatementSent) {
-      opts.onXapiStatementSent?.();
-    }
-    return "emitted";
-  } catch {
-    return "failed";
-  }
-}
-async function emitCourseStarted(opts) {
-  const event = buildCourseStartedEvent(opts);
-  if (event === null) return "filtered";
-  const tracked = await emitCourseStartedToTracking(
-    opts.tracking,
-    opts.storage,
-    opts.sessionId,
-    opts.courseId,
-    event,
-    opts.shouldCommit
-  );
-  if (!tracked) return "failed";
-  return emitCourseStartedPipelineOnly({
-    ...opts,
-    event,
-    skipXapi: opts.skipXapi,
-    onXapiStatementSent: opts.onXapiStatementSent,
-    shouldCommit: opts.shouldCommit
-  });
-}
-async function emitCourseStartedToTrackingOnly(opts) {
-  const event = buildCourseStartedEvent(opts);
-  if (event === null) return "filtered";
-  const tracked = await emitCourseStartedToTracking(
-    opts.tracking,
-    opts.storage,
-    opts.sessionId,
-    opts.courseId,
-    event,
-    opts.shouldCommit
-  );
-  if (!tracked) return "failed";
-  try {
-    if (opts.shouldCommit && !opts.shouldCommit()) return "failed";
-    await emitCourseStartedNonTrackingPipeline({
-      event,
-      xapi: null,
-      lxpackBridge: opts.lxpackBridge,
-      onLxpackBridgeMiss: opts.onLxpackBridgeMiss,
-      extraSinks: opts.extraSinks,
-      skipXapi: true
-    });
-    markCourseStartedPipelineDelivered(opts.storage, opts.sessionId, opts.courseId);
-    return "emitted";
-  } catch {
-    return "failed";
-  }
-}
-async function emitPendingCourseStarted(opts) {
-  const trackingEmitted = hasCourseStartedEmittedToTracking(
-    opts.storage,
-    opts.sessionId,
-    opts.courseId
-  );
-  const sessionStarted = hasCourseStarted(opts.storage, opts.sessionId, opts.courseId);
-  if (sessionStarted && !trackingEmitted) {
-    return emitCourseStartedToTrackingOnly(opts);
-  }
-  if (trackingEmitted && !sessionStarted) {
-    const event = buildCourseStartedEvent(opts);
-    if (event === null) return "filtered";
-    return emitCourseStartedPipelineOnly({ ...opts, event });
-  }
-  if (!trackingEmitted && !sessionStarted) {
-    return emitCourseStarted(opts);
-  }
-  const pipelineDelivered = hasCourseStartedPipelineDelivered(
-    opts.storage,
-    opts.sessionId,
-    opts.courseId
-  );
-  if (sessionStarted && trackingEmitted && pipelineDelivered) {
-    return "emitted";
-  }
-  if (sessionStarted && trackingEmitted && !pipelineDelivered) {
-    const event = buildCourseStartedEvent(opts);
-    if (event === null) return "filtered";
-    return emitCourseStartedPipelineOnly({
-      ...opts,
-      event,
-      skipXapi: opts.skipXapi,
-      onXapiStatementSent: opts.onXapiStatementSent
-    });
-  }
-  return "emitted";
-}
-function assertTrackingSinkConfig(tracking) {
-  if (!tracking?.sink || !tracking?.batchSink) return;
-  throw new Error(
-    "[lessonkit] tracking.sink and tracking.batchSink cannot both be set; use batchSink alone for batched delivery"
-  );
-}
-
-// src/runtime/telemetry.ts
-import { createTrackingClient } from "@lessonkit/core";
-function createTrackingClientFromConfig(config, observability) {
-  if (config.tracking?.enabled === false) return createTrackingClient();
-  if (config.tracking?.createClient) return config.tracking.createClient();
-  return createTrackingClient({
-    sink: config.tracking?.sink,
-    batchSink: config.tracking?.batchSink,
-    batch: config.tracking?.batch,
-    onBufferDrop: observability?.onTelemetryBufferDrop
-  });
-}
-async function disposeTrackingClient(client) {
-  try {
-    await client?.flush?.();
-  } catch {
-  }
-  try {
-    await client?.dispose?.();
-  } catch {
-  }
-}
-
-// src/provider/useLessonkitProviderRuntime.ts
-var useIsoLayoutEffect = (
-  /* v8 ignore next -- SSR uses useEffect when window is unavailable */
-  typeof window !== "undefined" ? useLayoutEffect : useEffect
-);
-var defaultStorage = createSessionStoragePort();
-function useLessonkitProviderRuntime(config) {
-  const normalizedCourseId = useMemo(
-    () => assertValidId(config.courseId, "courseId"),
-    [config.courseId]
-  );
-  const normalizedConfig = useMemo(
-    () => ({ ...config, courseId: normalizedCourseId }),
-    [config, normalizedCourseId]
-  );
-  const useV2Runtime = normalizedConfig.runtimeVersion !== "v1";
-  useEffect(() => {
-    if (useV2Runtime) return;
-    const g = globalThis;
-    if (typeof g.process !== "undefined" && g.process.env?.NODE_ENV === "production") return;
-    console.warn(
-      '[lessonkit] LessonkitProvider runtimeVersion "v1" is deprecated; omit or use "v2" (default). v1 will be removed in LessonKit 2.0.'
-    );
-  }, [useV2Runtime]);
-  const extraSinksRef = useRef(normalizedConfig.sinks);
-  extraSinksRef.current = normalizedConfig.sinks;
-  const headlessRef = useRef(null);
-  const sessionIdRef = useRef(resolveSessionId(defaultStorage, normalizedConfig.session?.sessionId));
-  const prevConfiguredSessionIdRef = useRef(normalizedConfig.session?.sessionId);
-  if (normalizedConfig.session?.sessionId) {
-    sessionIdRef.current = normalizedConfig.session.sessionId;
-  } else if (prevConfiguredSessionIdRef.current) {
-    sessionIdRef.current = resolveSessionId(defaultStorage, void 0);
-  }
-  const attemptIdRef = useRef(normalizedConfig.session?.attemptId);
-  const userRef = useRef(normalizedConfig.session?.user);
-  attemptIdRef.current = normalizedConfig.session?.attemptId;
-  userRef.current = normalizedConfig.session?.user;
-  const courseIdRef = useRef(normalizedCourseId);
-  courseIdRef.current = normalizedCourseId;
-  const lxpackBridgeModeRef = useRef(normalizedConfig.lxpack?.bridge ?? "auto");
-  lxpackBridgeModeRef.current = normalizedConfig.lxpack?.bridge ?? "auto";
-  const observabilityRef = useRef(normalizedConfig.observability);
-  observabilityRef.current = normalizedConfig.observability;
-  const onLxpackBridgeMiss = useCallback((event) => {
-    observabilityRef.current?.onLxpackBridgeMiss?.(event);
-  }, []);
-  const pluginsFingerprint = normalizedConfig.plugins?.map((p) => `${p.id}\0${p.version}`).join("|") ?? "";
-  const pluginHost = useMemo(
-    () => createReactPluginHost(normalizedConfig.plugins),
-    [pluginsFingerprint]
-  );
-  const pluginHostRef = useRef(pluginHost);
-  pluginHostRef.current = pluginHost;
-  const progressRef = useRef(createProgressController());
-  const courseStartedEmittedToSinkRef = useRef(false);
-  const courseStartedEmitGenerationRef = useRef(0);
-  const prevCourseIdForProgressRef = useRef(normalizedCourseId);
-  const pendingCourseIdResetRef = useRef(false);
-  const prevUseV2RuntimeRef = useRef(useV2Runtime);
-  const xapiCourseStartedSentOnClientRef = useRef(false);
-  if (prevUseV2RuntimeRef.current !== useV2Runtime) {
-    prevUseV2RuntimeRef.current = useV2Runtime;
-    if (useV2Runtime) {
-      headlessRef.current = createLessonkitRuntime({
-        courseId: normalizedCourseId,
-        runtimeVersion: "v2",
-        session: normalizedConfig.session,
-        plugins: pluginHostRef.current ?? normalizedConfig.plugins,
-        deferPluginSetup: true
-      });
-      progressRef.current = headlessRef.current.progress;
-    } else {
-      headlessRef.current = null;
-      progressRef.current = createProgressController();
-    }
-    pendingCourseIdResetRef.current = true;
-    courseStartedEmittedToSinkRef.current = false;
-    courseStartedEmitGenerationRef.current += 1;
-  } else if (useV2Runtime && !headlessRef.current) {
-    headlessRef.current = createLessonkitRuntime({
-      courseId: normalizedCourseId,
-      runtimeVersion: "v2",
-      session: normalizedConfig.session,
-      plugins: pluginHostRef.current ?? normalizedConfig.plugins,
-      deferPluginSetup: true
-    });
-  }
-  if (prevCourseIdForProgressRef.current !== normalizedCourseId) {
-    prevCourseIdForProgressRef.current = normalizedCourseId;
-    if (useV2Runtime && headlessRef.current) {
-      headlessRef.current.resetForCourseChange(normalizedCourseId);
-      progressRef.current = headlessRef.current.progress;
-    } else {
-      progressRef.current = createProgressController();
-    }
-    pendingCourseIdResetRef.current = true;
-    courseStartedEmittedToSinkRef.current = false;
-    courseStartedEmitGenerationRef.current += 1;
-  }
-  if (useV2Runtime && headlessRef.current) {
-    progressRef.current = headlessRef.current.progress;
-  }
-  const [progress, setProgress] = useState(() => progressRef.current.getState());
-  const syncProgress = useCallback(() => {
-    setProgress(progressRef.current.getState());
-  }, []);
-  const activeLessonIdRef = useRef(progress.activeLessonId);
-  activeLessonIdRef.current = progress.activeLessonId;
-  const xapiQueueRef = useRef(createXapiQueueFromObservability(normalizedConfig.observability));
-  const xapiRef = useRef(null);
-  const [xapi, setXapi] = useState(null);
-  const prevXapiCourseIdRef = useRef(normalizedCourseId);
-  const xapiEnabled = normalizedConfig.xapi?.enabled;
-  const xapiClient = normalizedConfig.xapi?.client;
-  const xapiTransport = normalizedConfig.xapi?.transport;
-  const courseId = normalizedCourseId;
-  const trackingEnabled = normalizedConfig.tracking?.enabled;
-  useIsoLayoutEffect(() => {
-    const courseChanged = prevXapiCourseIdRef.current !== courseId;
-    if (courseChanged) {
-      if (normalizedConfig.xapi?.client) {
-        const g = globalThis;
-        if (typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production") {
-          console.warn(
-            "[lessonkit] courseId changed while using config.xapi.client; flush the client between courses or use config.xapi.transport so the provider can manage the queue."
-          );
-        }
-        void xapiRef.current?.flush();
-      }
-      xapiQueueRef.current = createXapiQueueFromObservability(observabilityRef.current);
-      prevXapiCourseIdRef.current = courseId;
-      xapiCourseStartedSentOnClientRef.current = false;
-    }
-    const prev = xapiRef.current;
-    const next = createXapiClientFromConfig(normalizedConfig, xapiQueueRef.current);
-    xapiRef.current = next;
-    setXapi(next);
-    if (next) {
-      const sessionId = sessionIdRef.current;
-      const cid = courseIdRef.current;
-      const trackingActive = isTrackingActive(normalizedConfig.tracking);
-      const alreadyStarted = hasCourseStarted(defaultStorage, sessionId, cid);
-      const clientChanged = !prev || prev !== next;
-      const skipBootstrap = trackingActive && !alreadyStarted;
-      const needsBootstrap = !skipBootstrap && !xapiCourseStartedSentOnClientRef.current && (!alreadyStarted || clientChanged);
-      if (needsBootstrap) {
-        try {
-          const event = buildCourseStartedEvent({
-            pluginHost: pluginHostRef.current,
-            courseId: cid,
-            sessionId,
-            attemptId: attemptIdRef.current,
-            user: userRef.current,
-            lxpackBridge: lxpackBridgeModeRef.current
-          });
-          if (event === null) {
-          } else {
-            const statement = telemetryEventToXAPIStatement3(event);
-            if (statement) {
-              next.send(statement);
-              if (!alreadyStarted) {
-                markCourseStarted(defaultStorage, sessionId, cid);
-              }
-              xapiCourseStartedSentOnClientRef.current = true;
-            }
-          }
-        } catch {
-        }
-      }
-    }
-    let cancelled = false;
-    void (async () => {
-      if (prev) {
-        try {
-          await prev.flush();
-        } catch {
-        }
-      }
-      if (cancelled) return;
-      try {
-        await next?.flush();
-      } catch {
-      }
-    })();
-    return () => {
-      cancelled = true;
-      void prev?.flush();
-    };
-  }, [xapiEnabled, xapiClient, xapiTransport, courseId, trackingEnabled]);
-  const trackingRef = useRef(createTrackingClient2());
-  const trackingClientForUnmountRef = useRef(trackingRef.current);
-  const [tracking, setTracking] = useState(() => trackingRef.current);
-  const trackingSink = normalizedConfig.tracking?.sink;
-  const trackingBatchSink = normalizedConfig.tracking?.batchSink;
-  const batchEnabled = normalizedConfig.tracking?.batch?.enabled;
-  const batchFlushIntervalMs = normalizedConfig.tracking?.batch?.flushIntervalMs;
-  const batchMaxBatchSize = normalizedConfig.tracking?.batch?.maxBatchSize;
-  const buildCurrentPluginCtx = useCallback(
-    () => buildPluginContext({
-      courseId: courseIdRef.current,
-      sessionId: sessionIdRef.current,
-      attemptId: attemptIdRef.current,
-      user: userRef.current
-    }),
-    []
-  );
-  useIsoLayoutEffect(() => {
-    const prev = trackingRef.current;
-    const baseSink = wrapTrackingSink(normalizedConfig.tracking?.sink, observabilityRef.current);
-    const userBatchSink = normalizedConfig.tracking?.batchSink;
-    assertTrackingSinkConfig(normalizedConfig.tracking);
-    const sink = pluginHostRef.current && baseSink ? (
-      /* v8 ignore next -- composeTrackingSink may return null; fall back to base sink */
-      pluginHostRef.current.composeTrackingSink(baseSink, buildCurrentPluginCtx) ?? baseSink
-    ) : baseSink;
-    const batchSink = pluginHostRef.current && userBatchSink ? async (events) => {
-      const host = pluginHostRef.current;
-      const ctx = buildCurrentPluginCtx();
-      const delivered = host.deliverTelemetryBatch(events, ctx);
-      const perEventForBatch = [];
-      const collector = (event) => {
-        perEventForBatch.push(event);
-      };
-      const composedPerEvent = host.composeTrackingSink(collector, buildCurrentPluginCtx) ?? collector;
-      for (const event of delivered) {
-        await Promise.resolve(composedPerEvent(event));
-      }
-      return userBatchSink(perEventForBatch);
-    } : userBatchSink;
-    const next = createTrackingClientFromConfig(
-      {
-        tracking: { ...normalizedConfig.tracking, sink, batchSink }
-      },
-      observabilityRef.current
-    );
-    trackingRef.current = next;
-    trackingClientForUnmountRef.current = next;
-    setTracking(next);
-    const sessionId = sessionIdRef.current;
-    const cid = courseIdRef.current;
-    const trackingActive = isTrackingActive(normalizedConfig.tracking);
-    const courseStartedFullySettled = hasCourseStartedEmittedToTracking(defaultStorage, sessionId, cid) && hasCourseStarted(defaultStorage, sessionId, cid) && hasCourseStartedPipelineDelivered(defaultStorage, sessionId, cid);
-    if (!trackingActive) {
-      courseStartedEmittedToSinkRef.current = false;
-    } else if (courseStartedFullySettled) {
-      courseStartedEmittedToSinkRef.current = true;
-    } else if (!courseStartedEmittedToSinkRef.current) {
-      const generation = ++courseStartedEmitGenerationRef.current;
-      const shouldCommit = () => generation === courseStartedEmitGenerationRef.current;
-      void (async () => {
-        if (generation !== courseStartedEmitGenerationRef.current) return;
-        const result = await emitPendingCourseStarted({
-          pluginHost: pluginHostRef.current,
-          tracking: next,
-          xapi: xapiRef.current,
-          storage: defaultStorage,
-          sessionId,
-          courseId: cid,
-          attemptId: attemptIdRef.current,
-          user: userRef.current,
-          lxpackBridge: lxpackBridgeModeRef.current,
-          onLxpackBridgeMiss,
-          extraSinks: extraSinksRef.current,
-          skipXapi: xapiCourseStartedSentOnClientRef.current,
-          onXapiStatementSent: () => {
-            xapiCourseStartedSentOnClientRef.current = true;
-          },
-          shouldCommit
-        });
-        if (generation !== courseStartedEmitGenerationRef.current) return;
-        courseStartedEmittedToSinkRef.current = isCourseStartedSinkSettled(result);
-      })();
-    }
-    return () => {
-      courseStartedEmitGenerationRef.current += 1;
-      if (prev !== trackingRef.current) {
-        void disposeTrackingClient(prev);
-      }
-    };
-  }, [
-    trackingEnabled,
-    trackingSink,
-    trackingBatchSink,
-    batchEnabled,
-    batchFlushIntervalMs,
-    batchMaxBatchSize,
-    normalizedConfig.plugins,
-    normalizedCourseId,
-    buildCurrentPluginCtx
-  ]);
-  const emitWithBridge = useCallback((trackingClient, event) => {
-    emitTelemetryWithPlugins({
-      pluginHost: pluginHostRef.current,
-      tracking: trackingClient,
-      xapi: xapiRef.current,
-      event,
-      pluginCtx: buildPluginContext({
-        courseId: courseIdRef.current,
-        sessionId: sessionIdRef.current,
-        attemptId: attemptIdRef.current,
-        user: userRef.current
-      }),
-      lxpackBridge: lxpackBridgeModeRef.current,
-      onLxpackBridgeMiss,
-      extraSinks: extraSinksRef.current
-    });
-  }, [onLxpackBridgeMiss]);
-  const emitLifecycleEvent = useCallback(
-    (name, data, lessonId) => {
-      const event = tryBuildTelemetryEvent({
-        name,
-        courseId: courseIdRef.current,
-        lessonId: lessonId ?? activeLessonIdRef.current,
-        sessionId: sessionIdRef.current,
-        attemptId: attemptIdRef.current,
-        user: userRef.current,
-        data
-      });
-      if (!event) return;
-      emitWithBridge(trackingRef.current, event);
-    },
-    [emitWithBridge]
-  );
-  const track = useCallback(
-    (name, data, opts) => {
-      const event = tryBuildTelemetryEvent({
-        name,
-        courseId: courseIdRef.current,
-        lessonId: opts?.lessonId ?? activeLessonIdRef.current,
-        sessionId: sessionIdRef.current,
-        attemptId: attemptIdRef.current,
-        user: userRef.current,
-        data
-      });
-      if (!event) return;
-      emitWithBridge(trackingRef.current, event);
-    },
-    [emitWithBridge]
-  );
-  useLayoutEffect(() => {
-    if (!pendingCourseIdResetRef.current) return;
-    pendingCourseIdResetRef.current = false;
-    syncProgress();
-    if (!isTrackingActive(normalizedConfig.tracking)) return;
-    const sessionId = sessionIdRef.current;
-    const cid = courseIdRef.current;
-    void (async () => {
-      try {
-        await trackingRef.current?.flush?.();
-      } catch {
-      }
-      if (!courseStartedEmittedToSinkRef.current) {
-        const result = await emitPendingCourseStarted({
-          pluginHost: pluginHostRef.current,
-          tracking: trackingRef.current,
-          xapi: xapiRef.current,
-          storage: defaultStorage,
-          sessionId,
-          courseId: cid,
-          attemptId: attemptIdRef.current,
-          user: userRef.current,
-          lxpackBridge: lxpackBridgeModeRef.current,
-          onLxpackBridgeMiss,
-          extraSinks: extraSinksRef.current
-        });
-        courseStartedEmittedToSinkRef.current = isCourseStartedSinkSettled(result);
-      }
-    })();
-  }, [normalizedCourseId, normalizedConfig.tracking?.enabled, syncProgress, onLxpackBridgeMiss]);
-  const emitLessonCompleted = useCallback(
-    (lessonId, durationMs) => {
-      track("lesson_completed", { lessonId, durationMs }, { lessonId });
-      if (durationMs !== void 0) {
-        track("lesson_time_on_task", { lessonId, durationMs }, { lessonId });
-      }
-    },
-    [track]
-  );
-  const completeLesson = useCallback(
-    (lessonId, opts) => {
-      if (opts?.courseId !== void 0 && opts.courseId !== courseIdRef.current) {
-        return;
-      }
-      if (useV2Runtime && headlessRef.current) {
-        headlessRef.current.completeLesson(lessonId, emitLifecycleEvent);
-        syncProgress();
-        void Promise.resolve(trackingRef.current?.flush?.());
-        return;
-      }
-      const result = progressRef.current.completeLesson(lessonId, Date.now());
-      if (!result.didComplete) return;
-      syncProgress();
-      emitLessonCompleted(lessonId, result.durationMs);
-      void Promise.resolve(trackingRef.current?.flush?.());
-    },
-    [syncProgress, emitLessonCompleted, useV2Runtime, emitLifecycleEvent]
-  );
-  useEffect(() => {
-    return () => {
-      const client = trackingClientForUnmountRef.current;
-      const xapi2 = xapiRef.current;
-      void (async () => {
-        try {
-          await xapi2?.flush();
-        } catch {
-        }
-        try {
-          await client?.flush?.();
-        } catch {
-        }
-        try {
-          await client?.dispose?.();
-        } catch {
-        }
-      })();
-    };
-  }, []);
-  useEffect(() => {
-    if (typeof document === "undefined") return;
-    const flushOnExit = () => {
-      void xapiRef.current?.flush();
-      void trackingRef.current?.flush?.();
-    };
-    const onVisibilityChange = () => {
-      if (document.visibilityState === "hidden") flushOnExit();
-    };
-    document.addEventListener("visibilitychange", onVisibilityChange);
-    window.addEventListener("pagehide", flushOnExit);
-    return () => {
-      document.removeEventListener("visibilitychange", onVisibilityChange);
-      window.removeEventListener("pagehide", flushOnExit);
-    };
-  }, []);
-  const setActiveLesson = useCallback(
-    (lessonId) => {
-      if (useV2Runtime && headlessRef.current) {
-        headlessRef.current.setActiveLesson(lessonId, emitLifecycleEvent);
-        syncProgress();
-        void Promise.resolve(trackingRef.current?.flush?.());
-        return;
-      }
-      const current = progressRef.current.getState();
-      if (current.activeLessonId === lessonId) return;
-      if (current.completedLessonIds.has(lessonId)) {
-        progressRef.current.setActiveLesson(lessonId, Date.now());
-        syncProgress();
-        return;
-      }
-      const previous = current.activeLessonId;
-      if (previous && previous !== lessonId) {
-        const completed = progressRef.current.completeLesson(previous, Date.now());
-        if (completed.didComplete) {
-          emitLessonCompleted(previous, completed.durationMs);
-          void Promise.resolve(trackingRef.current?.flush?.());
-        }
-      }
-      progressRef.current.setActiveLesson(lessonId, Date.now());
-      syncProgress();
-      track("lesson_started", { lessonId }, { lessonId });
-    },
-    [track, syncProgress, emitLessonCompleted, useV2Runtime, emitLifecycleEvent]
-  );
-  const completeCourse = useCallback(() => {
-    if (useV2Runtime && headlessRef.current) {
-      headlessRef.current.completeCourse(emitLifecycleEvent);
-      syncProgress();
-      void trackingRef.current?.flush?.();
-      return;
-    }
-    const current = progressRef.current.getState();
-    if (current.activeLessonId) {
-      const lessonResult = progressRef.current.completeLesson(current.activeLessonId, Date.now());
-      if (lessonResult.didComplete) {
-        emitLessonCompleted(current.activeLessonId, lessonResult.durationMs);
-      }
-    }
-    const result = progressRef.current.completeCourse();
-    if (!result.didComplete) return;
-    syncProgress();
-    track("course_completed");
-    void trackingRef.current?.flush?.();
-  }, [track, syncProgress, emitLessonCompleted, useV2Runtime, emitLifecycleEvent]);
-  const sessionUser = normalizedConfig.session?.user;
-  const sessionUserKey = useMemo(
-    () => sessionUser ? JSON.stringify(sessionUser) : "",
-    [sessionUser]
-  );
-  const sessionAttemptId = normalizedConfig.session?.attemptId;
-  const sessionConfiguredId = normalizedConfig.session?.sessionId;
-  useEffect(() => {
-    if (useV2Runtime && headlessRef.current) {
-      headlessRef.current.updateConfig({
-        courseId: normalizedCourseId,
-        session: normalizedConfig.session
-      });
-    }
-  }, [
-    useV2Runtime,
-    normalizedCourseId,
-    sessionAttemptId,
-    sessionConfiguredId,
-    sessionUserKey,
-    normalizedConfig.session
-  ]);
-  useEffect(() => {
-    if (!useV2Runtime || !headlessRef.current) return;
-    headlessRef.current.updateConfig({
-      plugins: pluginHostRef.current ?? normalizedConfig.plugins
-    });
-  }, [useV2Runtime, pluginHost]);
-  useEffect(() => {
-    const host = useV2Runtime ? headlessRef.current?.pluginHost ?? null : pluginHost;
-    if (!host) return;
-    const ctx = buildPluginContext({
-      courseId: courseIdRef.current,
-      sessionId: sessionIdRef.current,
-      attemptId: attemptIdRef.current,
-      user: userRef.current
-    });
-    host.setupAll(ctx);
-    return () => {
-      host.disposeAll();
-    };
-  }, [pluginHost, useV2Runtime, normalizedCourseId, sessionAttemptId, sessionConfiguredId, sessionUserKey]);
-  useEffect(() => {
-    const nextConfigured = normalizedConfig.session?.sessionId;
-    const prevConfigured = prevConfiguredSessionIdRef.current;
-    if (nextConfigured === prevConfigured) return;
-    prevConfiguredSessionIdRef.current = nextConfigured;
-    const cid = courseIdRef.current;
-    if (nextConfigured) {
-      const fromIds = /* @__PURE__ */ new Set();
-      if (prevConfigured) fromIds.add(prevConfigured);
-      const tabId = getTabSessionId(defaultStorage);
-      if (tabId) fromIds.add(tabId);
-      for (const fromId of fromIds) {
-        if (fromId !== nextConfigured) {
-          migrateCourseStartedMark(defaultStorage, fromId, nextConfigured, cid);
-        }
-      }
-      sessionIdRef.current = nextConfigured;
-    } else if (prevConfigured) {
-      const nextAuto = resolveSessionId(defaultStorage, void 0);
-      migrateCourseStartedMark(defaultStorage, prevConfigured, nextAuto, cid);
-      sessionIdRef.current = nextAuto;
-    }
-  }, [sessionConfiguredId, normalizedCourseId]);
-  const runtime = useMemo(
-    () => ({
-      config: normalizedConfig,
-      tracking,
-      xapi,
-      storage: defaultStorage,
-      session: { sessionId: sessionIdRef.current, attemptId: attemptIdRef.current, user: userRef.current },
-      progress,
-      setActiveLesson,
-      completeLesson,
-      completeCourse,
-      track,
-      plugins: pluginHost
-    }),
-    [
-      normalizedConfig,
-      tracking,
-      xapi,
-      progress,
-      setActiveLesson,
-      completeLesson,
-      completeCourse,
-      track,
-      pluginHost,
-      sessionUser,
-      sessionAttemptId,
-      sessionConfiguredId
-    ]
-  );
-  return runtime;
-}
-
-// src/context.tsx
-import { jsx } from "react/jsx-runtime";
-var LessonkitContext = createContext(null);
-function LessonkitProvider(props) {
-  const runtime = useLessonkitProviderRuntime(props.config);
-  return /* @__PURE__ */ jsx(LessonkitContext.Provider, { value: runtime, children: props.children });
-}
-
-// src/hooks.ts
-import { useContext, useMemo as useMemo3 } from "react";
-
-// src/assessment/useAssessmentState.ts
-import { useMemo as useMemo2 } from "react";
-function useAssessmentState(enclosingLessonId) {
-  const { track } = useLessonkit();
-  const trackOpts = enclosingLessonId ? { lessonId: enclosingLessonId } : void 0;
-  return useMemo2(
-    () => ({
-      answer: (data) => {
-        track("assessment_answered", data, trackOpts);
-      },
-      complete: (data) => {
-        track("assessment_completed", data, trackOpts);
-      }
-    }),
-    [track, enclosingLessonId]
-  );
-}
-
-// src/hooks.ts
-function useLessonkit() {
-  const ctx = useContext(LessonkitContext);
-  if (!ctx) throw new Error("LessonKit: missing LessonkitProvider");
-  return ctx;
-}
-function useProgress() {
-  const { progress } = useLessonkit();
-  return progress;
-}
-function useTracking() {
-  const { track } = useLessonkit();
-  return useMemo3(() => ({ track }), [track]);
-}
-function useCompletion() {
-  const { completeLesson, completeCourse } = useLessonkit();
-  return useMemo3(() => ({ completeLesson, completeCourse }), [completeLesson, completeCourse]);
-}
-function useQuizState(enclosingLessonId) {
-  const { track } = useLessonkit();
-  const trackOpts = enclosingLessonId ? { lessonId: enclosingLessonId } : void 0;
-  return useMemo3(
-    () => ({
-      answer: (opts) => {
-        track("quiz_answered", opts, trackOpts);
-      },
-      complete: (opts) => {
-        track("quiz_completed", opts, trackOpts);
-      }
-    }),
-    [track, enclosingLessonId]
-  );
-}
-
-// src/lessonContext.tsx
-import { createContext as createContext2, useContext as useContext2 } from "react";
-var LessonContext = createContext2(void 0);
-function useEnclosingLessonId() {
-  return useContext2(LessonContext);
-}
-
-// src/runtime/validateComponentId.ts
-import { assertValidId as assertValidId2 } from "@lessonkit/core";
-function isDevEnvironment4() {
-  const g = globalThis;
-  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
-}
-function normalizeComponentId(id, path) {
-  if (path === "courseId") return assertValidId2(id, "courseId");
-  if (path === "lessonId") return assertValidId2(id, "lessonId");
-  if (path === "checkId") return assertValidId2(id, "checkId");
-  if (path === "blockId") return assertValidId2(id, "blockId");
-  return assertValidId2(id, path);
-}
-
-// src/runtime/lessonMountRegistry.ts
-var mountCounts = /* @__PURE__ */ new Map();
-var warnedConcurrentLessons = false;
-function registerLessonMount(lessonId) {
-  if (isDevEnvironment4() && mountCounts.size > 0 && !mountCounts.has(lessonId) && !warnedConcurrentLessons) {
-    warnedConcurrentLessons = true;
-    console.warn(
-      "[lessonkit] Multiple <Lesson> components are mounted; only one should be active at a time. Set autoCompleteOnUnmount={false} on routed lessons or unmount the previous lesson before showing the next."
-    );
-  }
-  mountCounts.set(lessonId, (mountCounts.get(lessonId) ?? 0) + 1);
-  return () => {
-    const next = (mountCounts.get(lessonId) ?? 1) - 1;
-    if (next <= 0) {
-      mountCounts.delete(lessonId);
-    } else {
-      mountCounts.set(lessonId, next);
-    }
-  };
-}
-function getLessonMountCount(lessonId) {
-  return mountCounts.get(lessonId) ?? 0;
-}
-
-// src/components/Quiz.tsx
-import { forwardRef, useEffect as useEffect3, useId, useMemo as useMemo5, useRef as useRef4, useState as useState3 } from "react";
-import { visuallyHiddenStyle } from "@lessonkit/accessibility";
-
-// src/assessment/AssessmentLessonGuard.tsx
-import { useEffect as useEffect2 } from "react";
-import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
-var warnedAssessmentOutsideLesson = false;
-function resetAssessmentWarningsForTests() {
-  warnedAssessmentOutsideLesson = false;
-}
-function AssessmentLessonGuard(props) {
-  const enclosingLessonId = useEnclosingLessonId();
-  const missingLesson = enclosingLessonId === void 0;
-  useEffect2(() => {
-    if (!missingLesson || isDevEnvironment4()) return;
-    if (!warnedAssessmentOutsideLesson) {
-      warnedAssessmentOutsideLesson = true;
-      console.error(
-        `[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>; assessment telemetry will not be emitted.`
-      );
-    }
-  }, [missingLesson, props.blockLabel]);
-  if (missingLesson && isDevEnvironment4()) {
-    throw new Error(`[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>`);
-  }
-  if (missingLesson) {
-    return /* @__PURE__ */ jsx2("section", { role: "alert", "aria-label": `${props.blockLabel} configuration error`, "data-lk-check-id": props.checkId, children: /* @__PURE__ */ jsxs("p", { children: [
-      props.blockLabel,
-      " must be placed inside a Lesson."
-    ] }) });
-  }
-  return /* @__PURE__ */ jsx2(Fragment, { children: props.children(enclosingLessonId) });
-}
-
-// src/assessment/internal/buildAssessmentHandle.ts
-function buildAssessmentHandle(opts) {
-  return {
-    getScore: opts.getScore,
-    getMaxScore: opts.getMaxScore,
-    getAnswerGiven: opts.getAnswerGiven,
-    resetTask: opts.resetTask,
-    showSolutions: opts.showSolutions,
-    getXAPIData: opts.getXAPIData,
-    ...opts.getCurrentState ? { getCurrentState: opts.getCurrentState } : {},
-    ...opts.resume ? { resume: opts.resume } : {}
-  };
-}
-
-// src/assessment/internal/resumeState.ts
-function readBooleanField(state, key) {
-  const value = state[key];
-  if (value === true || value === false || value === null) return value;
-  return void 0;
-}
-function readStringField(state, key) {
-  const value = state[key];
-  if (typeof value === "string" || value === null) return value;
-  return void 0;
-}
-function readNumberField(state, key) {
-  const value = state[key];
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (value === null) return null;
-  return void 0;
-}
-function readBooleanStateField(state, key, apply) {
-  const value = state[key];
-  if (typeof value === "boolean") apply(value);
-}
-
-// src/assessment/internal/useAssessmentHandleRegistration.ts
-import { useImperativeHandle as useImperativeHandle2 } from "react";
-
-// src/compound/CompoundProvider.tsx
-import React5, { createContext as createContext5, useCallback as useCallback2, useContext as useContext5, useImperativeHandle, useMemo as useMemo4, useRef as useRef3, useState as useState2 } from "react";
-import { clampCompoundPageIndex, createCompoundResumeState } from "@lessonkit/core";
-
-// src/compound/aggregateScores.ts
-function aggregateAssessmentScores(handles, opts) {
-  let score = 0;
-  let maxScore = 0;
-  let allAnswered = true;
-  for (const entry of handles) {
-    const handle = "handle" in entry ? entry.handle : entry;
-    const pageIndex = "handle" in entry ? entry.pageIndex : void 0;
-    score += handle.getScore();
-    maxScore += handle.getMaxScore();
-    const countsForAnswerGiven = opts?.answerPageIndex === void 0 || pageIndex === void 0 || pageIndex === opts.answerPageIndex;
-    if (countsForAnswerGiven && !handle.getAnswerGiven()) allAnswered = false;
-  }
-  return { score, maxScore, allAnswered };
-}
-
-// src/compound/CompoundHydrationBridge.tsx
-import { createContext as createContext3, useContext as useContext3, useRef as useRef2 } from "react";
-import { jsx as jsx3 } from "react/jsx-runtime";
-var CompoundHydrationBridgeContext = createContext3(
-  null
-);
-function CompoundHydrationBridgeProvider({ children }) {
-  const bridgeRef = useRef2(null);
-  return /* @__PURE__ */ jsx3(CompoundHydrationBridgeContext.Provider, { value: bridgeRef, children });
-}
-function useCompoundHydrationBridgeRef() {
-  return useContext3(CompoundHydrationBridgeContext);
-}
-
-// src/compound/CompoundPageIndexContext.tsx
-import { createContext as createContext4, useContext as useContext4 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
-var CompoundPageIndexContext = createContext4(void 0);
-function CompoundPageIndexProvider({
-  pageIndex,
-  children
-}) {
-  return /* @__PURE__ */ jsx4(CompoundPageIndexContext.Provider, { value: pageIndex, children });
-}
-function useCompoundPageIndex() {
-  return useContext4(CompoundPageIndexContext);
-}
-
-// src/compound/CompoundProvider.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
-var CompoundRegistryContext = createContext5(null);
-var CompoundHandlesVersionContext = createContext5(0);
-function CompoundProvider({
-  children,
-  activePageIndex: _activePageIndex,
-  onActivePageIndexChange: _onActivePageIndexChange
-}) {
-  const registryRef = useRef3(/* @__PURE__ */ new Map());
-  const [handlesVersion, setHandlesVersion] = useState2(0);
-  const register = useCallback2((checkId, handle, pageIndex) => {
-    const prev = registryRef.current.get(checkId);
-    if (prev && prev.handle !== handle) {
-      const message = `[lessonkit] duplicate checkId "${checkId}" registered in the same compound container; the previous handle was replaced.`;
-      if (isDevEnvironment4()) {
-        console.error(message);
-      } else {
-        console.warn(message);
-      }
-    }
-    registryRef.current.set(checkId, { handle, pageIndex });
-    if (prev?.handle !== handle || prev?.pageIndex !== pageIndex) {
-      setHandlesVersion((v) => v + 1);
-    }
-    return () => {
-      const current = registryRef.current.get(checkId);
-      if (current?.handle === handle) {
-        registryRef.current.delete(checkId);
-        setHandlesVersion((v) => v + 1);
-      }
-    };
-  }, []);
-  const registryValue = useMemo4(
-    () => ({
-      register,
-      getHandles: () => {
-        const handles = /* @__PURE__ */ new Map();
-        for (const [checkId, entry] of registryRef.current) {
-          handles.set(checkId, entry.handle);
-        }
-        return handles;
-      },
-      getRegisteredHandles: () => registryRef.current
-    }),
-    [register]
-  );
-  return /* @__PURE__ */ jsx5(CompoundHydrationBridgeProvider, { children: /* @__PURE__ */ jsx5(CompoundRegistryContext.Provider, { value: registryValue, children: /* @__PURE__ */ jsx5(CompoundHandlesVersionContext.Provider, { value: handlesVersion, children }) }) });
-}
-function useCompoundRegistry() {
-  const registry = useContext5(CompoundRegistryContext);
-  const handlesVersion = useContext5(CompoundHandlesVersionContext);
-  if (!registry) return null;
-  return { ...registry, handlesVersion };
-}
-function useCompoundHandlesVersion() {
-  return useContext5(CompoundHandlesVersionContext);
-}
-function useRegisterAssessmentHandle(checkId, handle) {
-  const registry = useContext5(CompoundRegistryContext);
-  const pageIndex = useCompoundPageIndex();
-  React5.useLayoutEffect(() => {
-    if (!registry || !handle) return;
-    return registry.register(checkId, handle, pageIndex);
-  }, [registry, checkId, handle, pageIndex]);
-}
-function useCompoundHandleRef(ref, opts) {
-  const { activePageIndex, setActivePageIndex, getHandles, getRegisteredHandles, pageCount } = opts;
-  const bridgeRef = useCompoundHydrationBridgeRef();
-  const setIndexClamped = useCallback2(
-    (index) => {
-      const next = pageCount !== void 0 ? clampCompoundPageIndex(index, pageCount) : Math.max(0, Math.floor(index));
-      setActivePageIndex(next);
-    },
-    [pageCount, setActivePageIndex]
-  );
-  useImperativeHandle(
-    ref,
-    () => ({
-      getScore: () => aggregateAssessmentScores(getRegisteredHandles().values()).score,
-      getMaxScore: () => aggregateAssessmentScores(getRegisteredHandles().values()).maxScore,
-      getAnswerGiven: () => aggregateAssessmentScores(getRegisteredHandles().values(), {
-        answerPageIndex: activePageIndex
-      }).allAnswered,
-      resetTask: () => {
-        for (const entry of getRegisteredHandles().values()) entry.handle.resetTask();
-      },
-      showSolutions: () => {
-        if (!opts.enableSolutionsButton) return;
-        for (const entry of getRegisteredHandles().values()) entry.handle.showSolutions();
-      },
-      getCurrentState: () => {
-        const childStates = {};
-        for (const [checkId, entry] of getRegisteredHandles()) {
-          if (entry.handle.getCurrentState) {
-            childStates[checkId] = entry.handle.getCurrentState();
-          }
-        }
-        return createCompoundResumeState({ activePageIndex, childStates });
-      },
-      resume: (state) => {
-        bridgeRef?.current?.notifyImperativeResume(state);
-      }
-    }),
-    [activePageIndex, setIndexClamped, getHandles, getRegisteredHandles, opts.enableSolutionsButton, bridgeRef]
-  );
-}
-
-// src/assessment/internal/useAssessmentHandleRegistration.ts
-function useAssessmentHandleRegistration(checkId, handle, ref) {
-  useImperativeHandle2(ref, () => handle, [handle]);
-  useRegisterAssessmentHandle(checkId, handle);
-}
-
-// src/assessment/internal/usePluginScoring.ts
-import { useCallback as useCallback3 } from "react";
-
-// src/assessment/scoring.ts
-function resolvePassingThreshold(passingScore, maxScore) {
-  return passingScore ?? maxScore;
-}
-function meetsPassingThreshold(score, maxScore, passingScore) {
-  const threshold = resolvePassingThreshold(passingScore, maxScore);
-  return score >= threshold;
-}
-function scoreFromCustom(custom, fallbackCorrect, fallbackMax = 1, passingScore) {
-  const maxScore = custom?.maxScore ?? fallbackMax;
-  if (custom?.passed !== void 0) {
-    const score2 = custom.passed ? custom.score ?? maxScore : custom.score ?? 0;
-    return { score: score2, maxScore, passed: custom.passed };
-  }
-  if (custom?.maxScore != null && custom.maxScore > 0 && custom.score != null) {
-    const passed2 = meetsPassingThreshold(custom.score, custom.maxScore, passingScore);
-    return { score: custom.score, maxScore: custom.maxScore, passed: passed2 };
-  }
-  const score = fallbackCorrect ? maxScore : 0;
-  const passed = meetsPassingThreshold(score, maxScore, passingScore);
-  return { score, maxScore, passed };
-}
-
-// src/assessment/internal/usePluginScoring.ts
-function usePluginScoring(checkId, lessonId) {
-  const { plugins, config, session } = useLessonkit();
-  const getPluginScore = useCallback3(
-    (response) => {
-      const pluginCtx = buildPluginContext({
-        courseId: config.courseId,
-        sessionId: session.sessionId,
-        attemptId: session.attemptId,
-        user: session.user
-      });
-      return plugins?.scoreAssessment({ checkId, lessonId, response }, pluginCtx) ?? null;
-    },
-    [checkId, config.courseId, lessonId, plugins, session.attemptId, session.sessionId, session.user]
-  );
-  const scoreResponse = useCallback3(
-    (response, defaultCorrect, maxScore = 1, passingScore) => scoreFromCustom(getPluginScore(response), defaultCorrect, maxScore, passingScore),
-    [getPluginScore]
-  );
-  const isChoiceCorrect = useCallback3(
-    (choice, answer, custom, passingScore) => {
-      if (!custom) return choice === answer;
-      if (custom.passed !== void 0) return custom.passed;
-      if (custom.maxScore != null && custom.maxScore > 0 && custom.score != null) {
-        return meetsPassingThreshold(custom.score, custom.maxScore, passingScore);
-      }
-      return choice === answer;
-    },
-    []
-  );
-  return { getPluginScore, scoreResponse, isChoiceCorrect };
-}
-
-// src/components/Quiz.tsx
-import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
-function QuizInner(props, ref) {
-  const { enclosingLessonId } = props;
-  const checkId = useMemo5(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const quiz = useQuizState(enclosingLessonId);
-  const { getPluginScore, isChoiceCorrect } = usePluginScoring(checkId, enclosingLessonId);
-  const [selected, setSelected] = useState3(null);
-  const [selectionCorrect, setSelectionCorrect] = useState3(null);
-  const [quizPassed, setQuizPassed] = useState3(false);
-  const [completedScore, setCompletedScore] = useState3(null);
-  const [completedMaxScore, setCompletedMaxScore] = useState3(null);
-  const completedRef = useRef4(false);
-  const telemetryReplayedRef = useRef4(false);
-  const questionId = useId();
-  const choicesKey = props.choices.join("\0");
-  useEffect3(() => {
-    completedRef.current = false;
-    telemetryReplayedRef.current = false;
-    setQuizPassed(false);
-    setSelected(null);
-    setSelectionCorrect(null);
-    setCompletedScore(null);
-    setCompletedMaxScore(null);
-  }, [checkId, props.answer, props.question, choicesKey]);
-  const passed = quizPassed;
-  const resolveScores = () => {
-    const maxScore = completedMaxScore ?? 1;
-    if (quizPassed) {
-      return { score: completedScore ?? maxScore, maxScore };
-    }
-    if (selected !== null && selectionCorrect) {
-      return { score: completedMaxScore ?? maxScore, maxScore };
-    }
-    return { score: 0, maxScore };
-  };
-  const replayTelemetry = (nextSelected, nextCorrect, nextPassed, nextScore, nextMaxScore) => {
-    if (!nextPassed || telemetryReplayedRef.current) return;
-    telemetryReplayedRef.current = true;
-    if (nextSelected !== null) {
-      quiz.answer({
-        checkId,
-        question: props.question,
-        choice: nextSelected,
-        correct: nextCorrect ?? false
-      });
-    }
-    quiz.complete({
-      checkId,
-      score: nextScore,
-      maxScore: nextMaxScore,
-      passingScore: props.passingScore ?? nextMaxScore
-    });
-  };
-  const handle = useMemo5(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => resolveScores().score,
-      getMaxScore: () => resolveScores().maxScore,
-      getAnswerGiven: () => selected !== null,
-      resetTask: () => {
-        completedRef.current = false;
-        telemetryReplayedRef.current = false;
-        setQuizPassed(false);
-        setSelected(null);
-        setSelectionCorrect(null);
-        setCompletedScore(null);
-        setCompletedMaxScore(null);
-      },
-      showSolutions: () => {
-      },
-      getXAPIData: () => {
-        const { score, maxScore } = resolveScores();
-        return {
-          checkId,
-          interactionType: "mcq",
-          response: selected ?? void 0,
-          correct: selectionCorrect ?? void 0,
-          score,
-          maxScore
-        };
-      },
-      getCurrentState: () => ({
-        selected,
-        selectionCorrect,
-        quizPassed,
-        completedScore,
-        completedMaxScore
-      }),
-      resume: (state) => {
-        const nextSelected = readStringField(state, "selected");
-        if (typeof nextSelected === "string" || nextSelected === null) setSelected(nextSelected);
-        const nextCorrect = readBooleanField(state, "selectionCorrect");
-        if (nextCorrect === true || nextCorrect === false || nextCorrect === null) {
-          setSelectionCorrect(nextCorrect);
-        }
-        const nextCompletedScore = readNumberField(state, "completedScore");
-        if (typeof nextCompletedScore === "number") setCompletedScore(nextCompletedScore);
-        const nextCompletedMaxScore = readNumberField(state, "completedMaxScore");
-        if (typeof nextCompletedMaxScore === "number") setCompletedMaxScore(nextCompletedMaxScore);
-        const nextPassed = readBooleanField(state, "quizPassed");
-        if (nextPassed === true || nextPassed === false) {
-          setQuizPassed(nextPassed);
-          completedRef.current = nextPassed;
-          if (nextPassed) {
-            const maxScore = nextCompletedMaxScore ?? completedMaxScore ?? 1;
-            const score = nextCompletedScore ?? completedScore ?? maxScore;
-            replayTelemetry(
-              nextSelected ?? null,
-              nextCorrect ?? null,
-              nextPassed,
-              score,
-              maxScore
-            );
-          }
-        }
-      }
-    }),
-    [
-      checkId,
-      completedMaxScore,
-      completedScore,
-      props.passingScore,
-      props.question,
-      quiz,
-      quizPassed,
-      selected,
-      selectionCorrect
-    ]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  return /* @__PURE__ */ jsxs2("section", { "aria-label": "Quiz", "data-lk-check-id": checkId, children: [
-    /* @__PURE__ */ jsx6("p", { id: questionId, children: props.question }),
-    /* @__PURE__ */ jsxs2("fieldset", { "aria-labelledby": questionId, children: [
-      /* @__PURE__ */ jsx6("legend", { style: visuallyHiddenStyle, children: "Quiz choices" }),
-      props.choices.map((c, i) => /* @__PURE__ */ jsxs2("label", { style: { display: "block" }, children: [
-        /* @__PURE__ */ jsx6(
-          "input",
-          {
-            type: "radio",
-            name: questionId,
-            value: c,
-            checked: selected === c,
-            disabled: passed,
-            "aria-invalid": selected === c && selectionCorrect === false ? true : void 0,
-            onChange: () => {
-              if (passed) return;
-              setSelected(c);
-              const custom = getPluginScore(c);
-              const correct = isChoiceCorrect(c, props.answer, custom, props.passingScore);
-              setSelectionCorrect(correct);
-              quiz.answer({
-                checkId,
-                question: props.question,
-                choice: c,
-                correct
-              });
-              if (correct && !completedRef.current) {
-                completedRef.current = true;
-                setQuizPassed(true);
-                const maxScore = custom?.maxScore ?? 1;
-                const score = custom?.score ?? maxScore;
-                setCompletedScore(score);
-                setCompletedMaxScore(maxScore);
-                quiz.complete({
-                  checkId,
-                  score,
-                  maxScore,
-                  passingScore: props.passingScore ?? maxScore
-                });
-              }
-            }
-          }
-        ),
-        c
-      ] }, `${questionId}-${i}`))
-    ] }),
-    selected && selectionCorrect !== null ? /* @__PURE__ */ jsx6("p", { role: "status", "aria-live": "polite", children: selectionCorrect ? "Correct" : "Try again" }) : null
-  ] });
-}
-var QuizInnerForwarded = forwardRef(QuizInner);
-var Quiz = forwardRef(function Quiz2(props, ref) {
-  return /* @__PURE__ */ jsx6(AssessmentLessonGuard, { blockLabel: "Quiz", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ jsx6(QuizInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
-});
-function KnowledgeCheck(props) {
-  return /* @__PURE__ */ jsx6(
-    Quiz,
-    {
-      checkId: props.checkId,
-      question: props.question,
-      choices: props.choices,
-      answer: props.answer,
-      passingScore: props.passingScore
-    }
-  );
-}
-function resetQuizWarningsForTests() {
-  resetAssessmentWarningsForTests();
-}
+  LessonContext,
+  LessonkitProvider,
+  assertProductionCourseConfig,
+  normalizeComponentId,
+  resetAssessmentWarningsForTests,
+  shouldEnforceProductionGuard,
+  useAssessmentState,
+  useCompletion,
+  useLessonkit,
+  useProgress,
+  useQuizState,
+  useTracking
+} from "./chunk-TDM3ARE7.js";
 
 // src/components.tsx
-import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+import { useEffect, useId, useMemo, useRef, useState } from "react";
+import { visuallyHiddenStyle } from "@lessonkit/accessibility";
+import { jsx, jsxs } from "react/jsx-runtime";
 function Course(props) {
-  const courseId = useMemo6(() => normalizeComponentId(props.courseId, "courseId"), [props.courseId]);
-  const providerConfig = useMemo6(
+  const courseId = useMemo(() => normalizeComponentId(props.courseId, "courseId"), [props.courseId]);
+  const providerConfig = useMemo(
     () => ({ ...props.config, courseId }),
-    [props.config, courseId]
-  );
-  return /* @__PURE__ */ jsx7(LessonkitProvider, { config: providerConfig, children: /* @__PURE__ */ jsxs3("section", { "aria-label": props.title, children: [
-    /* @__PURE__ */ jsx7("h1", { children: props.title }),
-    /* @__PURE__ */ jsx7("div", { children: props.children })
-  ] }) });
-}
-function Lesson(props) {
-  const lessonId = useMemo6(() => normalizeComponentId(props.lessonId, "lessonId"), [props.lessonId]);
-  const autoComplete = props.autoCompleteOnUnmount !== false;
-  const { setActiveLesson, config } = useLessonkit();
-  const { completeLesson } = useCompletion();
-  const lessonMountGenerationRef = useRef5(0);
-  const liveCourseIdRef = useRef5(config.courseId);
-  liveCourseIdRef.current = config.courseId;
-  useEffect4(() => {
-    const unregister = registerLessonMount(lessonId);
-    const generation = ++lessonMountGenerationRef.current;
-    const mountedCourseId = config.courseId;
-    let effectSurvivedTick = false;
-    queueMicrotask(() => {
-      queueMicrotask(() => {
-        effectSurvivedTick = true;
-      });
-    });
-    setActiveLesson(lessonId);
-    return () => {
-      unregister();
-      if (getLessonMountCount(lessonId) > 0) {
-        return;
-      }
-      if (!autoComplete) return;
-      queueMicrotask(() => {
-        if (!effectSurvivedTick) return;
-        if (lessonMountGenerationRef.current !== generation) return;
-        if (liveCourseIdRef.current !== mountedCourseId) return;
-        completeLesson(lessonId, { courseId: mountedCourseId });
-      });
-    };
-  }, [lessonId, config.courseId, setActiveLesson, completeLesson, autoComplete]);
-  return /* @__PURE__ */ jsx7(LessonContext.Provider, { value: lessonId, children: /* @__PURE__ */ jsxs3("article", { "aria-label": props.title, children: [
-    /* @__PURE__ */ jsx7("h2", { children: props.title }),
-    /* @__PURE__ */ jsx7("div", { children: props.children })
-  ] }) });
-}
-function Scenario(props) {
-  const blockId = useMemo6(
-    () => props.blockId !== void 0 ? normalizeComponentId(props.blockId, "blockId") : void 0,
-    [props.blockId]
-  );
-  return /* @__PURE__ */ jsx7("section", { "aria-label": "Scenario", "data-lk-block-id": blockId, children: props.children });
-}
-function Reflection(props) {
-  const blockId = useMemo6(
-    () => props.blockId !== void 0 ? normalizeComponentId(props.blockId, "blockId") : void 0,
-    [props.blockId]
-  );
-  const promptId = useId2();
-  const hintId = useId2();
-  const [internalValue, setInternalValue] = useState4("");
-  const isControlled = props.value !== void 0;
-  const value = isControlled ? props.value : internalValue;
-  const handleChange = (event) => {
-    if (!isControlled) setInternalValue(event.target.value);
-    props.onChange?.(event.target.value);
-  };
-  return /* @__PURE__ */ jsxs3("section", { "aria-label": "Reflection", "data-lk-block-id": blockId, children: [
-    props.prompt ? /* @__PURE__ */ jsx7("p", { id: promptId, children: props.prompt }) : null,
-    props.hint ? /* @__PURE__ */ jsx7("p", { id: hintId, style: visuallyHiddenStyle2, children: props.hint }) : null,
-    props.children,
-    /* @__PURE__ */ jsx7(
-      "textarea",
-      {
-        value,
-        onChange: handleChange,
-        "aria-labelledby": props.prompt ? promptId : void 0,
-        "aria-describedby": props.hint ? hintId : void 0,
-        "aria-label": props.prompt ? void 0 : "Reflection response"
-      }
-    )
-  ] });
-}
-function ProgressTracker(props) {
-  const { progress } = useLessonkit();
-  const completed = progress.completedLessonIds.size;
-  if (props.totalLessons != null) {
-    const total = props.totalLessons;
-    const displayed = Math.min(completed, total);
-    return /* @__PURE__ */ jsx7("aside", { "aria-label": "Progress", children: /* @__PURE__ */ jsx7(
-      "div",
-      {
-        role: "progressbar",
-        "aria-valuemin": 0,
-        "aria-valuemax": total,
-        "aria-valuenow": displayed,
-        "aria-label": "Lessons completed",
-        children: /* @__PURE__ */ jsxs3("p", { children: [
-          "Lessons completed: ",
-          displayed,
-          " of ",
-          total
-        ] })
-      }
-    ) });
-  }
-  return /* @__PURE__ */ jsx7("aside", { "aria-label": "Progress", role: "status", children: /* @__PURE__ */ jsxs3("p", { children: [
-    "Lessons completed: ",
-    completed
-  ] }) });
-}
-
-// src/blocks/TrueFalse.tsx
-import React9, { forwardRef as forwardRef2, useEffect as useEffect5, useMemo as useMemo7, useRef as useRef6, useState as useState5 } from "react";
-import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
-var INTERACTION = "trueFalse";
-function TrueFalseInner(props, ref) {
-  const { enclosingLessonId } = props;
-  const checkId = useMemo7(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const assessment = useAssessmentState(enclosingLessonId);
-  const { config } = useLessonkit();
-  const { scoreResponse } = usePluginScoring(checkId, enclosingLessonId);
-  const [selected, setSelected] = useState5(null);
-  const [selectionCorrect, setSelectionCorrect] = useState5(null);
-  const [showSolutions, setShowSolutions] = useState5(false);
-  const [passed, setPassed] = useState5(false);
-  const [completedScore, setCompletedScore] = useState5(null);
-  const [completedMaxScore, setCompletedMaxScore] = useState5(null);
-  const completedRef = useRef6(false);
-  const telemetryReplayedRef = useRef6(false);
-  const questionId = React9.useId();
-  const reset = () => {
-    completedRef.current = false;
-    telemetryReplayedRef.current = false;
-    setPassed(false);
-    setSelected(null);
-    setSelectionCorrect(null);
-    setShowSolutions(false);
-    setCompletedScore(null);
-    setCompletedMaxScore(null);
-  };
-  useEffect5(() => {
-    reset();
-  }, [checkId, props.answer, props.question, config.courseId, enclosingLessonId]);
-  const resolveScores = () => {
-    const maxScore = completedMaxScore ?? 1;
-    if (passed) {
-      return { score: completedScore ?? maxScore, maxScore };
-    }
-    if (selectionCorrect) {
-      return { score: completedMaxScore ?? maxScore, maxScore };
-    }
-    return { score: 0, maxScore };
-  };
-  const replayTelemetry = (nextSelected, nextCorrect, nextPassed, nextScore, nextMaxScore) => {
-    if (!nextPassed || telemetryReplayedRef.current) return;
-    telemetryReplayedRef.current = true;
-    if (nextSelected !== null) {
-      assessment.answer({
-        checkId,
-        interactionType: INTERACTION,
-        question: props.question,
-        response: nextSelected,
-        correct: nextCorrect ?? false
-      });
-    }
-    assessment.complete({
-      checkId,
-      interactionType: INTERACTION,
-      score: nextScore,
-      maxScore: nextMaxScore,
-      passingScore: props.passingScore ?? nextMaxScore
-    });
-  };
-  const handle = useMemo7(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => resolveScores().score,
-      getMaxScore: () => resolveScores().maxScore,
-      getAnswerGiven: () => selected !== null,
-      resetTask: reset,
-      showSolutions: () => setShowSolutions(true),
-      getXAPIData: () => {
-        const { score, maxScore } = resolveScores();
-        return {
-          checkId,
-          interactionType: INTERACTION,
-          response: selected ?? void 0,
-          correct: selectionCorrect ?? void 0,
-          score,
-          maxScore
-        };
-      },
-      getCurrentState: () => ({
-        selected,
-        selectionCorrect,
-        passed,
-        showSolutions,
-        completedScore,
-        completedMaxScore
-      }),
-      resume: (state) => {
-        const nextSelected = readBooleanField(state, "selected");
-        if (nextSelected === true || nextSelected === false || nextSelected === null) {
-          setSelected(nextSelected);
-        }
-        const nextCorrect = readBooleanField(state, "selectionCorrect");
-        if (nextCorrect === true || nextCorrect === false || nextCorrect === null) {
-          setSelectionCorrect(nextCorrect);
-        }
-        const nextCompletedScore = readNumberField(state, "completedScore");
-        if (typeof nextCompletedScore === "number") setCompletedScore(nextCompletedScore);
-        const nextCompletedMaxScore = readNumberField(state, "completedMaxScore");
-        if (typeof nextCompletedMaxScore === "number") setCompletedMaxScore(nextCompletedMaxScore);
-        const nextPassed = readBooleanField(state, "passed");
-        if (nextPassed === true || nextPassed === false) {
-          setPassed(nextPassed);
-          completedRef.current = nextPassed;
-          if (nextPassed) {
-            const maxScore = nextCompletedMaxScore ?? completedMaxScore ?? 1;
-            const score = nextCompletedScore ?? completedScore ?? maxScore;
-            replayTelemetry(nextSelected ?? null, nextCorrect ?? null, nextPassed, score, maxScore);
-          }
-        }
-        readBooleanStateField(state, "showSolutions", setShowSolutions);
-      }
-    }),
-    [
-      assessment,
-      checkId,
-      completedMaxScore,
-      completedScore,
-      passed,
-      props.passingScore,
-      props.question,
-      selected,
-      selectionCorrect,
-      showSolutions
-    ]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const submit = (value) => {
-    if (passed && !props.enableRetry) return;
-    setSelected(value);
-    const correct = value === props.answer;
-    const scored = scoreResponse(value, correct, 1, props.passingScore);
-    setSelectionCorrect(scored.passed);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION,
-      question: props.question,
-      response: value,
-      correct: scored.passed
-    });
-    if (scored.passed && !completedRef.current) {
-      completedRef.current = true;
-      setPassed(true);
-      setCompletedScore(scored.score);
-      setCompletedMaxScore(scored.maxScore);
-      assessment.complete({
-        checkId,
-        interactionType: INTERACTION,
-        score: scored.score,
-        maxScore: scored.maxScore,
-        passingScore: props.passingScore ?? scored.maxScore
-      });
-    }
-  };
-  const reveal = showSolutions || passed && props.enableSolutionsButton;
-  return /* @__PURE__ */ jsxs4("section", { "aria-label": "True or False", "data-lk-check-id": checkId, children: [
-    /* @__PURE__ */ jsx8("p", { id: questionId, children: props.question }),
-    /* @__PURE__ */ jsxs4("fieldset", { "aria-labelledby": questionId, children: [
-      /* @__PURE__ */ jsx8("legend", { className: "lk-visually-hidden", children: "True or False" }),
-      /* @__PURE__ */ jsxs4("label", { style: { display: "block", marginRight: "1rem" }, children: [
-        /* @__PURE__ */ jsx8(
-          "input",
-          {
-            type: "radio",
-            name: `${questionId}-tf`,
-            checked: selected === true,
-            disabled: passed && !props.enableRetry,
-            onChange: () => submit(true)
-          }
-        ),
-        "True"
-      ] }),
-      /* @__PURE__ */ jsxs4("label", { style: { display: "block" }, children: [
-        /* @__PURE__ */ jsx8(
-          "input",
-          {
-            type: "radio",
-            name: `${questionId}-tf`,
-            checked: selected === false,
-            disabled: passed && !props.enableRetry,
-            onChange: () => submit(false)
-          }
-        ),
-        "False"
-      ] })
-    ] }),
-    reveal ? /* @__PURE__ */ jsxs4("p", { children: [
-      "Correct answer: ",
-      /* @__PURE__ */ jsx8("strong", { children: props.answer ? "True" : "False" })
-    ] }) : null,
-    selected !== null && selectionCorrect !== null ? /* @__PURE__ */ jsx8("p", { role: "status", "aria-live": "polite", children: selectionCorrect ? "Correct" : "Try again" }) : null,
-    props.enableRetry && passed ? /* @__PURE__ */ jsx8("button", { type: "button", onClick: reset, children: "Try again" }) : null,
-    props.enableSolutionsButton && !reveal ? /* @__PURE__ */ jsx8("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
-  ] });
-}
-var TrueFalseInnerForwarded = forwardRef2(TrueFalseInner);
-var TrueFalse = forwardRef2(function TrueFalse2(props, ref) {
-  return /* @__PURE__ */ jsx8(AssessmentLessonGuard, { blockLabel: "TrueFalse", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ jsx8(TrueFalseInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
-});
-
-// src/blocks/MarkTheWords.tsx
-import React10, { forwardRef as forwardRef3, useEffect as useEffect6, useMemo as useMemo8, useRef as useRef7, useState as useState6 } from "react";
-import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
-var INTERACTION2 = "markTheWords";
-function tokenize(text) {
-  return text.split(/(\s+)/).filter((t) => t.length > 0);
-}
-function MarkTheWordsInner(props, ref) {
-  const checkId = useMemo8(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const assessment = useAssessmentState(props.enclosingLessonId);
-  const tokens = useMemo8(() => tokenize(props.text), [props.text]);
-  const correctSet = useMemo8(
-    () => new Set(props.correctWords.map((w) => w.toLowerCase())),
-    [props.correctWords]
-  );
-  const [marked, setMarked] = useState6(() => /* @__PURE__ */ new Set());
-  const [passed, setPassed] = useState6(false);
-  const [showSolutions, setShowSolutions] = useState6(false);
-  const completedRef = useRef7(false);
-  const reset = () => {
-    completedRef.current = false;
-    setPassed(false);
-    setMarked(/* @__PURE__ */ new Set());
-    setShowSolutions(false);
-  };
-  useEffect6(() => {
-    reset();
-  }, [checkId, props.text, props.correctWords.join("\0")]);
-  const selectableIndices = useMemo8(() => {
-    const indices = [];
-    tokens.forEach((t, i) => {
-      if (!/^\s+$/.test(t) && correctSet.has(t.toLowerCase())) indices.push(i);
-    });
-    return indices;
-  }, [tokens, correctSet]);
-  const hasTargets = selectableIndices.length > 0;
-  const allMarked = hasTargets && selectableIndices.every((i) => marked.has(i));
-  const maxScore = selectableIndices.length;
-  const score = allMarked ? maxScore : marked.size;
-  const passedThreshold = meetsPassingThreshold(score, maxScore || 1, props.passingScore);
-  const handle = useMemo8(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => score,
-      getMaxScore: () => maxScore || 1,
-      getAnswerGiven: () => marked.size > 0,
-      resetTask: reset,
-      showSolutions: () => setShowSolutions(true),
-      getXAPIData: () => ({
-        checkId,
-        interactionType: INTERACTION2,
-        response: [...marked].map((i) => tokens[i]),
-        correct: passedThreshold,
-        score,
-        maxScore: maxScore || 1
-      }),
-      getCurrentState: () => ({ marked: [...marked], passed, showSolutions }),
-      resume: (state) => {
-        const raw = state.marked;
-        if (Array.isArray(raw)) setMarked(new Set(raw.filter((i) => typeof i === "number")));
-        readBooleanStateField(state, "passed", (value) => {
-          setPassed(value);
-          completedRef.current = value;
-        });
-        readBooleanStateField(state, "showSolutions", setShowSolutions);
-      }
-    }),
-    [checkId, marked, maxScore, passed, passedThreshold, score, showSolutions, tokens]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const toggle = (index) => {
-    if (passed && !props.enableRetry) return;
-    setMarked((prev) => {
-      const next = new Set(prev);
-      if (next.has(index)) next.delete(index);
-      else next.add(index);
-      return next;
-    });
-  };
-  useEffect6(() => {
-    if (!hasTargets) {
-      if (isDevEnvironment4()) {
-        console.warn(
-          "[lessonkit] MarkTheWords: no tokens match correctWords",
-          props.correctWords
-        );
-      }
-      return;
-    }
-    if (!passedThreshold || completedRef.current) return;
-    completedRef.current = true;
-    setPassed(true);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION2,
-      question: props.text,
-      response: [...marked].map((i) => tokens[i]),
-      correct: passedThreshold
-    });
-    assessment.complete({
-      checkId,
-      interactionType: INTERACTION2,
-      score,
-      maxScore,
-      passingScore: props.passingScore ?? maxScore
-    });
-  }, [
-    assessment,
-    checkId,
-    hasTargets,
-    marked,
-    maxScore,
-    passedThreshold,
-    props.passingScore,
-    props.correctWords,
-    props.text,
-    score,
-    tokens
-  ]);
-  return /* @__PURE__ */ jsxs5("section", { "aria-label": "Mark the Words", "data-lk-check-id": checkId, children: [
-    !hasTargets ? /* @__PURE__ */ jsxs5("p", { role: "alert", children: [
-      "No words in this sentence match ",
-      /* @__PURE__ */ jsx9("code", { children: "correctWords" }),
-      ". Check spelling and capitalization in the source text."
-    ] }) : null,
-    /* @__PURE__ */ jsx9("p", { id: `${checkId}-hint`, children: "Select the correct words in the sentence." }),
-    /* @__PURE__ */ jsx9("p", { "aria-describedby": `${checkId}-hint`, children: tokens.map((token, i) => {
-      const isWord = !/^\s+$/.test(token);
-      const isTarget = isWord && correctSet.has(token.toLowerCase());
-      if (!isTarget) return /* @__PURE__ */ jsx9(React10.Fragment, { children: token }, i);
-      const selected = marked.has(i);
-      const solution = showSolutions || passed && props.enableSolutionsButton;
-      return /* @__PURE__ */ jsx9(
-        "button",
-        {
-          type: "button",
-          "data-testid": `mark-word-${i}`,
-          "aria-pressed": selected,
-          disabled: passed && !props.enableRetry,
-          onClick: () => toggle(i),
-          style: {
-            margin: "0 0.1em",
-            textDecoration: solution ? "underline" : void 0,
-            fontWeight: selected || solution ? "bold" : void 0
-          },
-          children: token
-        },
-        i
-      );
-    }) }),
-    allMarked ? /* @__PURE__ */ jsx9("p", { role: "status", "aria-live": "polite", children: "Correct" }) : null,
-    props.enableRetry && passed ? /* @__PURE__ */ jsx9("button", { type: "button", onClick: reset, children: "Try again" }) : null,
-    props.enableSolutionsButton && !showSolutions ? /* @__PURE__ */ jsx9("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
-  ] });
-}
-var MarkTheWordsInnerForwarded = forwardRef3(MarkTheWordsInner);
-var MarkTheWords = forwardRef3(function MarkTheWords2(props, ref) {
-  return /* @__PURE__ */ jsx9(AssessmentLessonGuard, { blockLabel: "MarkTheWords", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ jsx9(MarkTheWordsInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
-});
-
-// src/blocks/FillInTheBlanks.tsx
-import React11, { forwardRef as forwardRef4, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef8, useState as useState7 } from "react";
-
-// src/assessment/internal/parseStarDelimitedTemplate.ts
-function parseStarDelimitedTemplate(template, idPrefix) {
-  const parts = [];
-  const values = [];
-  const re = /\*([^*]+)\*/g;
-  let last = 0;
-  let match;
-  let n = 0;
-  while ((match = re.exec(template)) !== null) {
-    parts.push(template.slice(last, match.index));
-    values.push(match[1].trim());
-    parts.push(`${idPrefix}-${n++}`);
-    last = match.index + match[0].length;
-  }
-  parts.push(template.slice(last));
-  return { parts, values };
-}
-
-// src/blocks/FillInTheBlanks.tsx
-import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
-var INTERACTION3 = "fillInBlanks";
-function parseTemplate(template) {
-  const { parts, values } = parseStarDelimitedTemplate(template, "blank");
-  return {
-    parts,
-    blanks: values.map((answer, i) => ({ id: `blank-${i}`, answer }))
-  };
-}
-function FillInTheBlanksInner(props, ref) {
-  const checkId = useMemo9(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const assessment = useAssessmentState(props.enclosingLessonId);
-  const parsed = useMemo9(() => parseTemplate(props.template), [props.template]);
-  const blanks = props.blanks ?? parsed.blanks;
-  const [values, setValues] = useState7(
-    () => Object.fromEntries(blanks.map((b) => [b.id, ""]))
-  );
-  const [passed, setPassed] = useState7(false);
-  const [showSolutions, setShowSolutions] = useState7(false);
-  const [submitted, setSubmitted] = useState7(false);
-  const completedRef = useRef8(false);
-  const answeredRef = useRef8(false);
-  const reset = () => {
-    completedRef.current = false;
-    answeredRef.current = false;
-    setPassed(false);
-    setValues(Object.fromEntries(blanks.map((b) => [b.id, ""])));
-    setShowSolutions(false);
-    setSubmitted(false);
-  };
-  useEffect7(() => {
-    reset();
-  }, [checkId, props.template, blanks.map((b) => b.answer).join("\0")]);
-  const hasBlanks = blanks.length > 0;
-  const allFilled = hasBlanks && blanks.every((b) => (values[b.id] ?? "").trim().length > 0);
-  let score = 0;
-  blanks.forEach((b) => {
-    if ((values[b.id] ?? "").trim().toLowerCase() === b.answer.toLowerCase()) score += 1;
-  });
-  const maxScore = blanks.length;
-  const passedThreshold = meetsPassingThreshold(score, maxScore || 1, props.passingScore);
-  const handle = useMemo9(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => score,
-      getMaxScore: () => maxScore || 1,
-      getAnswerGiven: () => allFilled,
-      resetTask: reset,
-      showSolutions: () => setShowSolutions(true),
-      getXAPIData: () => ({
-        checkId,
-        interactionType: INTERACTION3,
-        response: values,
-        correct: passedThreshold,
-        score,
-        maxScore: maxScore || 1
-      }),
-      getCurrentState: () => ({ values, passed, showSolutions, submitted }),
-      resume: (state) => {
-        const raw = state.values;
-        if (raw && typeof raw === "object") setValues({ ...raw });
-        readBooleanStateField(state, "passed", (value) => {
-          setPassed(value);
-          completedRef.current = value;
-          answeredRef.current = value;
-        });
-        readBooleanStateField(state, "showSolutions", setShowSolutions);
-        readBooleanStateField(state, "submitted", (value) => {
-          setSubmitted(value);
-          if (value) answeredRef.current = true;
-        });
-      }
-    }),
-    [allFilled, checkId, maxScore, passed, passedThreshold, score, showSolutions, submitted, values]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const check = () => {
-    if (!hasBlanks) {
-      if (isDevEnvironment4()) {
-        console.warn("[lessonkit] FillInTheBlanks has no blanks in template");
-      }
-      return;
-    }
-    if (!allFilled) return;
-    if (answeredRef.current || submitted) return;
-    answeredRef.current = true;
-    setSubmitted(true);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION3,
-      question: props.template,
-      response: values,
-      correct: passedThreshold
-    });
-    if (passedThreshold && !completedRef.current) {
-      completedRef.current = true;
-      setPassed(true);
-      assessment.complete({
-        checkId,
-        interactionType: INTERACTION3,
-        score,
-        maxScore,
-        passingScore: props.passingScore ?? maxScore
-      });
-    }
-  };
-  useEffect7(() => {
-    if (!allFilled) {
-      answeredRef.current = false;
-      setSubmitted(false);
-    }
-  }, [allFilled]);
-  useEffect7(() => {
-    if (props.autoCheck && allFilled) check();
-  }, [allFilled, props.autoCheck, values, passedThreshold]);
-  const reveal = showSolutions || passed && props.enableSolutionsButton;
-  return /* @__PURE__ */ jsxs6("section", { "aria-label": "Fill in the Blanks", "data-lk-check-id": checkId, children: [
-    /* @__PURE__ */ jsx10("p", { children: parsed.parts.map((part, i) => {
-      const blank = blanks.find((b) => b.id === part);
-      if (!blank) return /* @__PURE__ */ jsx10(React11.Fragment, { children: part }, i);
-      return /* @__PURE__ */ jsxs6("label", { style: { margin: "0 0.25em" }, children: [
-        /* @__PURE__ */ jsx10("span", { className: "lk-visually-hidden", children: blank.answer }),
-        /* @__PURE__ */ jsx10(
-          "input",
-          {
-            type: "text",
-            "data-testid": `blank-${blank.id}`,
-            "aria-label": `Blank ${blank.id}`,
-            value: reveal ? blank.answer : values[blank.id] ?? "",
-            readOnly: reveal,
-            disabled: passed && !props.enableRetry,
-            onChange: (e) => setValues((v) => ({ ...v, [blank.id]: e.target.value })),
-            onBlur: () => props.autoCheck && check(),
-            size: Math.max(8, blank.answer.length + 2)
-          }
-        )
-      ] }, blank.id);
-    }) }),
-    !props.autoCheck ? /* @__PURE__ */ jsx10("button", { type: "button", "data-testid": "check-blanks", disabled: !allFilled || passed, onClick: check, children: "Check" }) : null,
-    !hasBlanks ? /* @__PURE__ */ jsx10("p", { role: "alert", children: "This activity has no blanks. Add text wrapped in asterisks, e.g. The *answer* here." }) : null,
-    submitted ? /* @__PURE__ */ jsx10("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null,
-    props.enableRetry && passed ? /* @__PURE__ */ jsx10("button", { type: "button", onClick: reset, children: "Try again" }) : null,
-    props.enableSolutionsButton && !reveal ? /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => setShowSolutions(true), children: "Show solution" }) : null
-  ] });
-}
-var FillInTheBlanksInnerForwarded = forwardRef4(FillInTheBlanksInner);
-var FillInTheBlanks = forwardRef4(
-  function FillInTheBlanks2(props, ref) {
-    return /* @__PURE__ */ jsx10(AssessmentLessonGuard, { blockLabel: "FillInTheBlanks", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ jsx10(FillInTheBlanksInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
-  }
-);
-
-// src/blocks/DragTheWords.tsx
-import React12, { forwardRef as forwardRef5, useEffect as useEffect8, useMemo as useMemo10, useRef as useRef9, useState as useState8 } from "react";
-import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
-var INTERACTION4 = "dragTheWords";
-function parseZones(template) {
-  const { parts, values } = parseStarDelimitedTemplate(template, "zone");
-  return { parts, answers: values };
-}
-function DragTheWordsInner(props, ref) {
-  const checkId = useMemo10(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const assessment = useAssessmentState(props.enclosingLessonId);
-  const { parts, answers } = useMemo10(() => parseZones(props.template), [props.template]);
-  const [zones, setZones] = useState8(
-    () => Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""]))
-  );
-  const [pool, setPool] = useState8(() => [...props.words]);
-  const [keyboardWord, setKeyboardWord] = useState8(null);
-  const [passed, setPassed] = useState8(false);
-  const [submitted, setSubmitted] = useState8(false);
-  const completedRef = useRef9(false);
-  const answeredRef = useRef9(false);
-  const reset = () => {
-    completedRef.current = false;
-    answeredRef.current = false;
-    setPassed(false);
-    setSubmitted(false);
-    setZones(Object.fromEntries(answers.map((_, i) => [`zone-${i}`, ""])));
-    setPool([...props.words]);
-    setKeyboardWord(null);
-  };
-  useEffect8(() => {
-    reset();
-  }, [checkId, props.template, props.words.join("\0")]);
-  const hasZones = answers.length > 0;
-  const allFilled = hasZones && answers.every((_, i) => (zones[`zone-${i}`] ?? "").length > 0);
-  let score = 0;
-  answers.forEach((ans, i) => {
-    if ((zones[`zone-${i}`] ?? "").trim().toLowerCase() === ans.toLowerCase()) score += 1;
-  });
-  const maxScore = answers.length;
-  const passedThreshold = meetsPassingThreshold(score, maxScore || 1, props.passingScore);
-  const handle = useMemo10(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => score,
-      getMaxScore: () => maxScore || 1,
-      getAnswerGiven: () => allFilled,
-      resetTask: reset,
-      showSolutions: () => {
-      },
-      getXAPIData: () => ({
-        checkId,
-        interactionType: INTERACTION4,
-        response: zones,
-        correct: passedThreshold,
-        score,
-        maxScore: maxScore || 1
-      }),
-      getCurrentState: () => ({ zones, pool, passed, keyboardWord, submitted }),
-      resume: (state) => {
-        const rawZones = state.zones;
-        if (rawZones && typeof rawZones === "object") setZones({ ...rawZones });
-        if (Array.isArray(state.pool)) setPool([...state.pool]);
-        readBooleanStateField(state, "passed", (value) => {
-          setPassed(value);
-          completedRef.current = value;
-          answeredRef.current = value;
-        });
-        readBooleanStateField(state, "submitted", (value) => {
-          setSubmitted(value);
-          if (value) answeredRef.current = true;
-        });
-        const kw = state.keyboardWord;
-        if (kw === null || typeof kw === "string") setKeyboardWord(kw ?? null);
-      }
-    }),
-    [allFilled, checkId, keyboardWord, maxScore, passed, passedThreshold, pool, score, submitted, zones]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const placeInZone = (zoneId, word) => {
-    if (passed && !props.enableRetry) return;
-    const prev = zones[zoneId];
-    setZones((z) => ({ ...z, [zoneId]: word }));
-    setPool((p) => {
-      const next = p.filter((w) => w !== word);
-      if (prev) next.push(prev);
-      return next;
-    });
-    setKeyboardWord(null);
-  };
-  const onDragStart = (word) => (e) => {
-    e.dataTransfer.setData("text/plain", word);
-  };
-  const onDrop = (zoneId) => (e) => {
-    e.preventDefault();
-    const word = e.dataTransfer.getData("text/plain");
-    if (word) placeInZone(zoneId, word);
-  };
-  const check = () => {
-    if (!hasZones) {
-      if (isDevEnvironment4()) {
-        console.warn("[lessonkit] DragTheWords has no drop zones in template");
-      }
-      return;
-    }
-    if (!allFilled) return;
-    if (answeredRef.current || submitted) return;
-    answeredRef.current = true;
-    setSubmitted(true);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION4,
-      question: props.template,
-      response: zones,
-      correct: passedThreshold
-    });
-    if (passedThreshold && !completedRef.current) {
-      completedRef.current = true;
-      setPassed(true);
-      assessment.complete({
-        checkId,
-        interactionType: INTERACTION4,
-        score,
-        maxScore,
-        passingScore: props.passingScore ?? maxScore
-      });
-    }
-  };
-  useEffect8(() => {
-    if (!allFilled) {
-      answeredRef.current = false;
-      setSubmitted(false);
-    }
-  }, [allFilled]);
-  useEffect8(() => {
-    if (props.autoCheck && allFilled) check();
-  }, [allFilled, props.autoCheck, zones, passedThreshold]);
-  return /* @__PURE__ */ jsxs7("section", { "aria-label": "Drag the Words", "data-lk-check-id": checkId, children: [
-    /* @__PURE__ */ jsx11("p", { children: "Drag words into the blanks (or select a word, then activate a blank)." }),
-    /* @__PURE__ */ jsx11("div", { role: "list", "aria-label": "Word bank", "data-testid": "word-bank", children: pool.map((word) => /* @__PURE__ */ jsx11(
-      "button",
-      {
-        type: "button",
-        draggable: true,
-        "data-testid": `word-${word}`,
-        "aria-pressed": keyboardWord === word,
-        onDragStart: onDragStart(word),
-        onClick: () => setKeyboardWord(keyboardWord === word ? null : word),
-        style: { margin: "0.25rem" },
-        children: word
-      },
-      word
-    )) }),
-    /* @__PURE__ */ jsx11("p", { children: parts.map((part, i) => {
-      if (!part.startsWith("zone-")) return /* @__PURE__ */ jsx11(React12.Fragment, { children: part }, i);
-      return /* @__PURE__ */ jsx11(
-        "span",
-        {
-          role: "button",
-          tabIndex: 0,
-          "data-testid": part,
-          onDragOver: (e) => e.preventDefault(),
-          onDrop: onDrop(part),
-          onClick: () => keyboardWord && placeInZone(part, keyboardWord),
-          onKeyDown: (e) => {
-            if (e.key === "Enter" && keyboardWord) placeInZone(part, keyboardWord);
-          },
-          style: {
-            display: "inline-block",
-            minWidth: "6em",
-            border: "1px dashed currentColor",
-            padding: "0.2em 0.5em",
-            margin: "0 0.2em"
-          },
-          children: zones[part] || "___"
-        },
-        part
-      );
-    }) }),
-    /* @__PURE__ */ jsx11("button", { type: "button", "data-testid": "check-drag-words", disabled: !allFilled || passed, onClick: check, children: "Check" }),
-    !hasZones ? /* @__PURE__ */ jsx11("p", { role: "alert", children: "This activity has no drop zones. Wrap answers in asterisks in the template." }) : null,
-    submitted ? /* @__PURE__ */ jsx11("p", { role: "status", "aria-live": "polite", children: passed || passedThreshold ? "Correct" : "Try again" }) : null
-  ] });
-}
-var DragTheWordsInnerForwarded = forwardRef5(DragTheWordsInner);
-var DragTheWords = forwardRef5(function DragTheWords2(props, ref) {
-  return /* @__PURE__ */ jsx11(AssessmentLessonGuard, { blockLabel: "DragTheWords", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ jsx11(DragTheWordsInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
-});
-
-// src/blocks/DragAndDrop.tsx
-import { forwardRef as forwardRef6, useEffect as useEffect9, useMemo as useMemo11, useRef as useRef10, useState as useState9 } from "react";
-import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
-var INTERACTION5 = "dragAndDrop";
-function DragAndDropInner(props, ref) {
-  const checkId = useMemo11(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const assessment = useAssessmentState(props.enclosingLessonId);
-  const [assignments, setAssignments] = useState9(
-    () => Object.fromEntries(props.targets.map((t) => [t.id, ""]))
-  );
-  const [pool, setPool] = useState9(() => props.items.map((i) => i.id));
-  const [keyboardItem, setKeyboardItem] = useState9(null);
-  const [passed, setPassed] = useState9(false);
-  const [checked, setChecked] = useState9(false);
-  const completedRef = useRef10(false);
-  const reset = () => {
-    completedRef.current = false;
-    setPassed(false);
-    setChecked(false);
-    setAssignments(Object.fromEntries(props.targets.map((t) => [t.id, ""])));
-    setPool(props.items.map((i) => i.id));
-    setKeyboardItem(null);
-  };
-  useEffect9(() => {
-    reset();
-  }, [checkId, props.items.map((i) => i.id).join(","), props.targets.map((t) => t.id).join(",")]);
-  const hasTargets = props.targets.length > 0;
-  const allFilled = hasTargets && props.targets.every((t) => (assignments[t.id] ?? "").length > 0);
-  let score = 0;
-  props.targets.forEach((t) => {
-    if (assignments[t.id] === t.accepts) score += 1;
-  });
-  const maxScore = props.targets.length || 1;
-  const passedThreshold = meetsPassingThreshold(score, maxScore, props.passingScore);
-  const handle = useMemo11(() => {
-    return buildAssessmentHandle({
-      checkId,
-      getScore: () => score,
-      getMaxScore: () => maxScore,
-      getAnswerGiven: () => hasTargets && allFilled,
-      resetTask: reset,
-      showSolutions: () => {
-      },
-      getXAPIData: () => ({
-        checkId,
-        interactionType: INTERACTION5,
-        response: assignments,
-        correct: passedThreshold,
-        score,
-        maxScore
-      }),
-      getCurrentState: () => ({ assignments, pool, passed, checked, keyboardItem }),
-      resume: (state) => {
-        const rawAssignments = state.assignments;
-        if (rawAssignments && typeof rawAssignments === "object") {
-          setAssignments({ ...rawAssignments });
-        }
-        if (Array.isArray(state.pool)) setPool([...state.pool]);
-        readBooleanStateField(state, "passed", (value) => {
-          setPassed(value);
-          completedRef.current = value;
-        });
-        readBooleanStateField(state, "checked", setChecked);
-        const item = state.keyboardItem;
-        if (item === null || typeof item === "string") setKeyboardItem(item ?? null);
-      }
-    });
-  }, [allFilled, assignments, checkId, checked, hasTargets, keyboardItem, maxScore, passed, passedThreshold, pool, props.targets, score]);
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const place = (targetId, itemId) => {
-    if (passed && !props.enableRetry) return;
-    setChecked(false);
-    const prev = assignments[targetId];
-    setAssignments((a) => ({ ...a, [targetId]: itemId }));
-    setPool((p) => {
-      const next = p.filter((id) => id !== itemId);
-      if (prev) next.push(prev);
-      return next;
-    });
-    setKeyboardItem(null);
-  };
-  const check = () => {
-    if (!allFilled) return;
-    setChecked(true);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION5,
-      response: assignments,
-      correct: passedThreshold
-    });
-    if (passedThreshold && !completedRef.current) {
-      completedRef.current = true;
-      setPassed(true);
-      assessment.complete({
-        checkId,
-        interactionType: INTERACTION5,
-        score,
-        maxScore,
-        passingScore: props.passingScore ?? maxScore
-      });
-    }
-  };
-  return /* @__PURE__ */ jsxs8("section", { "aria-label": "Drag and Drop", "data-lk-check-id": checkId, children: [
-    /* @__PURE__ */ jsx12("p", { children: "Match each item to the correct target (drag or use keyboard: select item, then activate target)." }),
-    /* @__PURE__ */ jsx12("div", { role: "list", "aria-label": "Draggable items", children: pool.flatMap((id) => {
-      const item = props.items.find((i) => i.id === id);
-      if (!item) return [];
-      return /* @__PURE__ */ jsx12(
-        "button",
-        {
-          type: "button",
-          draggable: true,
-          "data-testid": `drag-item-${id}`,
-          "aria-pressed": keyboardItem === id,
-          onDragStart: (e) => e.dataTransfer.setData("text/plain", id),
-          onClick: () => setKeyboardItem(keyboardItem === id ? null : id),
-          style: { margin: "0.25rem" },
-          children: item.label
-        },
-        id
-      );
-    }) }),
-    /* @__PURE__ */ jsx12("ul", { children: props.targets.map((target) => {
-      const assigned = assignments[target.id];
-      const label = assigned ? props.items.find((i) => i.id === assigned)?.label ?? assigned : "Drop here";
-      return /* @__PURE__ */ jsxs8("li", { children: [
-        /* @__PURE__ */ jsx12("strong", { children: target.label }),
-        " ",
-        /* @__PURE__ */ jsx12(
-          "span",
-          {
-            role: "button",
-            tabIndex: 0,
-            "data-testid": `drop-${target.id}`,
-            onDragOver: (e) => e.preventDefault(),
-            onDrop: (e) => {
-              e.preventDefault();
-              const id = e.dataTransfer.getData("text/plain");
-              if (id) place(target.id, id);
-            },
-            onClick: () => keyboardItem && place(target.id, keyboardItem),
-            onKeyDown: (e) => {
-              if (e.key === "Enter" && keyboardItem) place(target.id, keyboardItem);
-            },
-            style: {
-              display: "inline-block",
-              minWidth: "8em",
-              border: "1px dashed currentColor",
-              padding: "0.25em"
-            },
-            children: label
-          }
-        )
-      ] }, target.id);
-    }) }),
-    /* @__PURE__ */ jsx12("button", { type: "button", "data-testid": "check-drag-drop", disabled: !hasTargets || !allFilled || passed, onClick: check, children: "Check" }),
-    checked ? /* @__PURE__ */ jsx12("p", { role: "status", "aria-live": "polite", children: passedThreshold ? "Correct" : "Try again" }) : null
-  ] });
-}
-var DragAndDropInnerForwarded = forwardRef6(DragAndDropInner);
-var DragAndDrop = forwardRef6(function DragAndDrop2(props, ref) {
-  return /* @__PURE__ */ jsx12(AssessmentLessonGuard, { blockLabel: "DragAndDrop", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ jsx12(DragAndDropInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
-});
-
-// src/blocks/AssessmentSequence.tsx
-import React16, { forwardRef as forwardRef7, useCallback as useCallback7, useEffect as useEffect12, useId as useId3, useMemo as useMemo13, useRef as useRef13, useState as useState10 } from "react";
-import { deriveId } from "@lessonkit/core";
-
-// src/compound/useCompoundShell.ts
-import { useMemo as useMemo12 } from "react";
-import { clampCompoundPageIndex as clampCompoundPageIndex3 } from "@lessonkit/core";
-
-// src/compound/useCompoundNavigation.ts
-import { useCallback as useCallback4 } from "react";
-function useCompoundNavigation(pageCount, index, setIndex) {
-  const goNext = useCallback4(() => {
-    if (pageCount < 1) return;
-    setIndex((i) => Math.min(i + 1, pageCount - 1));
-  }, [pageCount, setIndex]);
-  const goPrev = useCallback4(() => {
-    setIndex((i) => Math.max(i - 1, 0));
-  }, [setIndex]);
-  const clampedIndex = pageCount < 1 ? 0 : Math.min(index, pageCount - 1);
-  return {
-    index: clampedIndex,
-    setIndex,
-    goNext,
-    goPrev,
-    progress: { current: pageCount < 1 ? 0 : clampedIndex + 1, total: pageCount }
-  };
-}
-
-// src/compound/useCompoundPersistence.ts
-import { useCallback as useCallback6, useContext as useContext7, useEffect as useEffect11, useRef as useRef12 } from "react";
-import {
-  clampCompoundPageIndex as clampCompoundPageIndex2,
-  createCompoundResumeState as createCompoundResumeState2,
-  createSessionStoragePort as createSessionStoragePort3,
-  loadCompoundState as loadCompoundState2
-} from "@lessonkit/core";
-
-// src/compound/resumeChildHandles.ts
-function filterRegisteredChildStates(handles, childStates) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(childStates)) {
-    if (handles.has(key)) {
-      filtered[key] = value;
-    }
-  }
-  return filtered;
-}
-function resumeChildHandles(handles, childStates, opts) {
-  const pendingKeys = Object.keys(childStates);
-  const alreadyResumed = opts?.alreadyResumed;
-  if (opts?.waitForHandles && pendingKeys.length > 0) {
-    if (handles.size === 0) return false;
-    const registeredPending = pendingKeys.filter((k) => handles.has(k));
-    if (registeredPending.length === 0) {
-      return false;
-    }
-    if (registeredPending.length < pendingKeys.length) {
-      for (const key of registeredPending) {
-        if (alreadyResumed?.has(key)) continue;
-        const handle = handles.get(key);
-        const child = childStates[key];
-        if (handle?.resume && child) {
-          handle.resume(child);
-          alreadyResumed?.add(key);
-        }
-      }
-      return false;
-    }
-  }
-  for (const [checkId, handle] of handles) {
-    if (alreadyResumed?.has(checkId)) continue;
-    const child = childStates[checkId];
-    if (child && handle.resume) {
-      handle.resume(child);
-      alreadyResumed?.add(checkId);
-    }
-  }
-  return true;
-}
-
-// src/compound/useCompoundResume.ts
-import { useCallback as useCallback5, useContext as useContext6, useEffect as useEffect10, useRef as useRef11 } from "react";
-import { loadCompoundState, saveCompoundState } from "@lessonkit/core";
-import { createSessionStoragePort as createSessionStoragePort2 } from "@lessonkit/core";
-var warnedCompoundPersistFailure = false;
-function warnCompoundPersistFailure() {
-  if (warnedCompoundPersistFailure || !isDevEnvironment4()) return;
-  warnedCompoundPersistFailure = true;
-  console.warn(
-    "[lessonkit] compound resume state could not be saved to sessionStorage (quota or privacy mode); progress may be lost on reload."
-  );
-}
-function useCompoundResume(opts) {
-  const lessonkitCtx = useContext6(LessonkitContext);
-  const storageRef = useRef11(opts.storage ?? lessonkitCtx?.storage ?? createSessionStoragePort2());
-  const resumedRef = useRef11(false);
-  const resumeKeyRef = useRef11("");
-  const prevEnabledRef = useRef11(opts.enabled);
-  useEffect10(() => {
-    storageRef.current = opts.storage ?? lessonkitCtx?.storage ?? createSessionStoragePort2();
-  }, [opts.storage, lessonkitCtx?.storage]);
-  useEffect10(() => {
-    if (!prevEnabledRef.current && opts.enabled) {
-      resumedRef.current = false;
-    }
-    prevEnabledRef.current = opts.enabled;
-    const key = `${opts.courseId ?? ""}:${opts.compoundId}`;
-    if (resumeKeyRef.current !== key) {
-      resumeKeyRef.current = key;
-      resumedRef.current = false;
-    }
-    if (!opts.enabled || !opts.courseId || resumedRef.current) return;
-    const saved = loadCompoundState(storageRef.current, opts.courseId, opts.compoundId);
-    if (saved) {
-      resumedRef.current = true;
-      opts.onResume?.(saved);
-    }
-  }, [opts.enabled, opts.courseId, opts.compoundId, opts.onResume]);
-  return useCallback5(
-    (state) => {
-      if (!opts.enabled || !opts.courseId) return;
-      const persisted = saveCompoundState(storageRef.current, opts.courseId, opts.compoundId, state);
-      if (!persisted) warnCompoundPersistFailure();
-    },
-    [opts.enabled, opts.courseId, opts.compoundId]
-  );
-}
-
-// src/compound/useCompoundPersistence.ts
-function readCompoundInitialIndex(courseId, compoundId, pageCount, enabled, storage = createSessionStoragePort3()) {
-  if (!enabled || !courseId || pageCount < 1) return 0;
-  const saved = loadCompoundState2(storage, courseId, compoundId);
-  if (!saved) return 0;
-  return clampCompoundPageIndex2(saved.activePageIndex, pageCount);
-}
-function stripOrphanChildStates(handles, childStates) {
-  return filterRegisteredChildStates(handles, childStates);
-}
-function useCompoundPersistence(opts) {
-  const lessonkitCtx = useContext7(LessonkitContext);
-  const storage = opts.storage ?? lessonkitCtx?.storage ?? createSessionStoragePort3();
-  const ctx = useCompoundRegistry();
-  const handlesVersion = useCompoundHandlesVersion();
-  const bridgeRef = useCompoundHydrationBridgeRef();
-  const pendingChildResumeRef = useRef12(null);
-  const resumedChildKeysRef = useRef12(/* @__PURE__ */ new Set());
-  const loadedChildStatesRef = useRef12({});
-  const skipSaveUntilHydratedRef = useRef12(false);
-  const hydrationKeyRef = useRef12("");
-  const hydrationInitRef = useRef12(false);
-  const hydrationKey = `${opts.courseId ?? ""}:${opts.compoundId}`;
-  if (hydrationKeyRef.current !== hydrationKey) {
-    hydrationKeyRef.current = hydrationKey;
-    hydrationInitRef.current = false;
-    loadedChildStatesRef.current = {};
-    skipSaveUntilHydratedRef.current = false;
-    pendingChildResumeRef.current = null;
-    resumedChildKeysRef.current = /* @__PURE__ */ new Set();
-  }
-  if (!hydrationInitRef.current && opts.enabled && opts.courseId) {
-    hydrationInitRef.current = true;
-    const saved = 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 = useCallback6(() => {
-    const childStates = {
-      ...loadedChildStatesRef.current
-    };
-    if (ctx) {
-      for (const [checkId, entry] of ctx.getRegisteredHandles()) {
-        const handle = entry.handle;
-        if (handle.getCurrentState) {
-          childStates[checkId] = handle.getCurrentState();
-          delete loadedChildStatesRef.current[checkId];
-        }
-      }
-    }
-    return createCompoundResumeState2({
-      activePageIndex: clampCompoundPageIndex2(opts.index, opts.pageCount),
-      childStates
-    });
-  }, [ctx, opts.index, opts.pageCount]);
-  const buildStateRef = useRef12(buildState);
-  buildStateRef.current = buildState;
-  const finalizeHydration = useCallback6(
-    (childStates) => {
-      loadedChildStatesRef.current = {
-        ...loadedChildStatesRef.current,
-        ...childStates
-      };
-      skipSaveUntilHydratedRef.current = false;
-      pendingChildResumeRef.current = null;
-    },
-    []
-  );
-  const applyPendingChildResume = useCallback6(() => {
-    const pending = pendingChildResumeRef.current;
-    if (!pending || !ctx) return;
-    const handles = ctx.getHandles();
-    const applied = resumeChildHandles(handles, pending.childStates, {
-      waitForHandles: true,
-      alreadyResumed: resumedChildKeysRef.current
-    });
-    if (!applied) {
-      const handlesAtWait = handles.size;
-      queueMicrotask(() => {
-        if (pendingChildResumeRef.current !== pending) return;
-        const handlesNow = ctx.getHandles();
-        if (handlesNow.size !== handlesAtWait) return;
-        const registeredOnly2 = stripOrphanChildStates(handlesNow, pending.childStates);
-        resumeChildHandles(handlesNow, registeredOnly2, {
-          alreadyResumed: resumedChildKeysRef.current
-        });
-        finalizeHydration(registeredOnly2);
-      });
-      return;
-    }
-    const registeredOnly = stripOrphanChildStates(handles, pending.childStates);
-    finalizeHydration(registeredOnly);
-  }, [ctx, finalizeHydration]);
-  const saveResume = useCompoundResume({
-    courseId: opts.courseId,
-    compoundId: opts.compoundId,
-    enabled: opts.enabled,
-    storage,
-    onResume: (state) => {
-      const clamped = clampCompoundPageIndex2(state.activePageIndex, opts.pageCount);
-      loadedChildStatesRef.current = { ...state.childStates };
-      skipSaveUntilHydratedRef.current = Object.keys(state.childStates).length > 0;
-      opts.setIndex(clamped);
-      resumedChildKeysRef.current = /* @__PURE__ */ new Set();
-      pendingChildResumeRef.current = { ...state, activePageIndex: clamped, childStates: state.childStates };
-      queueMicrotask(() => applyPendingChildResume());
-    }
-  });
-  const persistNow = useCallback6(() => {
-    if (!opts.enabled || !opts.courseId) return;
-    saveResume(buildStateRef.current());
-  }, [opts.enabled, opts.courseId, saveResume]);
-  const notifyImperativeResume = useCallback6(
-    (state) => {
-      const clamped = clampCompoundPageIndex2(state.activePageIndex, opts.pageCount);
-      loadedChildStatesRef.current = { ...state.childStates };
-      skipSaveUntilHydratedRef.current = Object.keys(state.childStates).length > 0;
-      opts.setIndex(clamped);
-      resumedChildKeysRef.current = /* @__PURE__ */ new Set();
-      pendingChildResumeRef.current = { ...state, activePageIndex: clamped, childStates: state.childStates };
-      queueMicrotask(() => applyPendingChildResume());
-    },
-    [opts.pageCount, opts.setIndex, applyPendingChildResume]
-  );
-  useEffect11(() => {
-    if (!bridgeRef) return;
-    bridgeRef.current = { notifyImperativeResume };
-    return () => {
-      if (bridgeRef.current?.notifyImperativeResume === notifyImperativeResume) {
-        bridgeRef.current = null;
-      }
-    };
-  }, [bridgeRef, notifyImperativeResume]);
-  useEffect11(() => {
-    persistNow();
-  }, [persistNow, opts.index, opts.pageCount, handlesVersion]);
-  useEffect11(() => {
-    applyPendingChildResume();
-  }, [opts.index, handlesVersion, applyPendingChildResume]);
-  useEffect11(() => {
-    if (!opts.enabled || !opts.courseId || typeof document === "undefined") return;
-    const flushOnExit = () => {
-      if (document.visibilityState === "hidden") persistNow();
-    };
-    document.addEventListener("visibilitychange", flushOnExit);
-    window.addEventListener("pagehide", flushOnExit);
-    return () => {
-      document.removeEventListener("visibilitychange", flushOnExit);
-      window.removeEventListener("pagehide", flushOnExit);
-    };
-  }, [opts.enabled, opts.courseId, persistNow]);
-}
-
-// src/compound/useCompoundShell.ts
-function useCompoundShell(opts) {
-  const ctx = useCompoundRegistry();
-  useCompoundPersistence({
-    courseId: opts.courseId,
-    compoundId: opts.compoundId,
-    pageCount: opts.pageCount,
-    index: opts.index,
-    setIndex: opts.setIndex,
-    enabled: opts.persistEnabled,
-    storage: opts.storage
-  });
-  const { goNext, goPrev, progress } = useCompoundNavigation(opts.pageCount, opts.index, opts.setIndex);
-  const visibleIndex = clampCompoundPageIndex3(opts.index, opts.pageCount);
-  useCompoundHandleRef(opts.ref, {
-    activePageIndex: visibleIndex,
-    setActivePageIndex: opts.setIndex,
-    getHandles: () => ctx?.getHandles() ?? /* @__PURE__ */ new Map(),
-    getRegisteredHandles: () => ctx?.getRegisteredHandles() ?? /* @__PURE__ */ new Map(),
-    pageCount: opts.pageCount,
-    enableSolutionsButton: opts.enableSolutionsButton
-  });
-  return { visibleIndex, goNext, goPrev, progress, ctx };
-}
-function useCompoundInitialIndex(opts) {
-  return useMemo12(
-    () => readCompoundInitialIndex(
-      opts.courseId,
-      opts.compoundId,
-      opts.pageCount,
-      opts.persistEnabled,
-      opts.storage
-    ),
-    [opts.courseId, opts.compoundId, opts.pageCount, opts.persistEnabled, opts.storage]
-  );
-}
-
-// src/compound/validateChildren.ts
-import React15 from "react";
-import {
-  ACCORDION_FORBIDDEN_CHILD_TYPES,
-  COMPOUND_MAX_NESTING_DEPTH,
-  isChildTypeAllowed
-} from "@lessonkit/core";
-
-// src/compound/blockType.ts
-var LESSONKIT_BLOCK_TYPE = /* @__PURE__ */ Symbol.for("lessonkit.blockType");
-function setLessonkitBlockType(component, blockType) {
-  component[LESSONKIT_BLOCK_TYPE] = blockType;
-  if (!component.displayName) {
-    component.displayName = blockType;
-  }
-  return component;
-}
-function getLessonkitBlockType(component) {
-  if (!component || typeof component !== "object" && typeof component !== "function") {
-    return void 0;
-  }
-  const typed = component;
-  return typed[LESSONKIT_BLOCK_TYPE] ?? typed.displayName;
-}
-
-// src/compound/validateChildren.ts
-var warnedPairs = /* @__PURE__ */ new Set();
-var COMPOUND_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-  "Page",
-  "InteractiveBook",
-  "Slide",
-  "SlideDeck",
-  "AssessmentSequence"
-]);
-function warnOrThrow(msg, strict) {
-  if (strict) throw new Error(msg);
-  if (!warnedPairs.has(msg)) {
-    warnedPairs.add(msg);
-    console.warn(msg);
-  }
-}
-function validateNode(parent, node, depth, strict) {
-  React15.Children.forEach(node, (child) => {
-    if (!React15.isValidElement(child)) return;
-    const blockType = getLessonkitBlockType(child.type);
-    if (!blockType) {
-      if (child.props && typeof child.props === "object" && "children" in child.props) {
-        validateNode(parent, child.props.children, depth, strict);
-      }
-      return;
-    }
-    if (!isChildTypeAllowed(parent, blockType)) {
-      const key = `${parent}:${blockType}`;
-      if (!warnedPairs.has(key)) {
-        warnedPairs.add(key);
-        const msg = `[lessonkit] Block "${blockType}" is not in the allowlist for "${parent}"`;
-        if (strict) throw new Error(msg);
-        console.warn(msg);
-      }
-    }
-    if (COMPOUND_CONTAINER_TYPES.has(blockType)) {
-      const maxDepth = COMPOUND_MAX_NESTING_DEPTH[parent];
-      if (depth >= maxDepth) {
-        warnOrThrow(
-          `[lessonkit] Block "${blockType}" exceeds max nesting depth (${maxDepth}) for "${parent}"`,
-          strict
-        );
-      }
-      const nestedParent = blockType;
-      validateNode(nestedParent, child.props.children, depth + 1, strict);
-    } else if (blockType === "Accordion") {
-      const sections = child.props.sections;
-      if (sections) validateAccordionSections(sections, strict);
-    } else if (child.props && typeof child.props === "object" && "children" in child.props) {
-      validateSubtreeForForbidden(
-        child.props.children,
-        ACCORDION_FORBIDDEN_CHILD_TYPES,
-        strict
-      );
-    }
-  });
-}
-function validateSubtreeForForbidden(node, forbidden, strict) {
-  React15.Children.forEach(node, (child) => {
-    if (!React15.isValidElement(child)) return;
-    const blockType = getLessonkitBlockType(child.type);
-    if (blockType && forbidden.includes(blockType)) {
-      warnOrThrow(`[lessonkit] Block "${blockType}" must not nest inside Accordion`, strict);
-    }
-    if (blockType === "Accordion") {
-      const sections = child.props.sections;
-      if (sections) validateAccordionSections(sections, strict);
-      return;
-    }
-    if (child.props && typeof child.props === "object" && "children" in child.props) {
-      validateSubtreeForForbidden(
-        child.props.children,
-        forbidden,
-        strict
-      );
-    }
-  });
-}
-function validateAccordionSections(sections, strict) {
-  if (!isDevEnvironment4() && !strict) return;
-  for (const section of sections) {
-    validateSubtreeForForbidden(section.content, ACCORDION_FORBIDDEN_CHILD_TYPES, strict);
-  }
-}
-function validateCompoundChildren(parent, children, strict) {
-  if (!isDevEnvironment4() && !strict) return;
-  validateNode(parent, children, 0, strict);
-}
-
-// src/compound/warnPersistence.ts
-var DEFAULT_ASSESSMENT_SEQUENCE_COMPOUND_ID = "assessment-sequence";
-function warnSharedCompoundStorageKey(opts) {
-  if (!opts.persistEnabled || opts.hasExplicitBlockId || !isDevEnvironment4()) return;
-  console.warn(
-    `[lessonkit] <${opts.componentName}> without blockId shares one sessionStorage key when persistCompoundState is enabled; set a unique blockId per instance.`
-  );
-}
-
-// src/blocks/AssessmentSequence.tsx
-import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
-var AssessmentSequenceInner = forwardRef7(
-  function AssessmentSequenceInner2(props, ref) {
-    const { compoundId, childArray, index, setIndex, persistEnabled } = props;
-    const sequential = props.sequential !== false;
-    const { config } = useLessonkit();
-    const { visibleIndex, goNext, goPrev, progress } = useCompoundShell({
-      courseId: config.courseId,
-      compoundId,
-      pageCount: childArray.length,
-      index,
-      setIndex,
-      persistEnabled,
-      ref,
-      enableSolutionsButton: props.enableSolutionsButton
-    });
-    validateCompoundChildren("AssessmentSequence", props.children);
-    if (!sequential) {
-      return /* @__PURE__ */ jsx13("section", { "aria-label": "Assessment sequence", "data-testid": "assessment-sequence", children: props.children });
-    }
-    return /* @__PURE__ */ jsxs9("section", { "aria-label": "Assessment sequence", "data-testid": "assessment-sequence", children: [
-      /* @__PURE__ */ jsxs9("p", { children: [
-        "Question ",
-        progress.current,
-        " of ",
-        progress.total
-      ] }),
-      /* @__PURE__ */ jsx13("div", { "data-testid": "assessment-sequence-step", children: childArray.map((child, i) => /* @__PURE__ */ jsx13("div", { hidden: i !== visibleIndex, children: /* @__PURE__ */ jsx13(CompoundPageIndexProvider, { pageIndex: i, children: child }) }, child.key ?? i)) }),
-      /* @__PURE__ */ jsxs9("nav", { "aria-label": "Sequence navigation", children: [
-        /* @__PURE__ */ jsx13(
-          "button",
-          {
-            type: "button",
-            "data-testid": "sequence-prev",
-            disabled: visibleIndex === 0 || childArray.length === 0,
-            onClick: goPrev,
-            children: "Previous"
-          }
-        ),
-        /* @__PURE__ */ jsx13(
-          "button",
-          {
-            type: "button",
-            "data-testid": "sequence-next",
-            disabled: visibleIndex >= childArray.length - 1 || childArray.length === 0,
-            onClick: goNext,
-            children: "Next"
-          }
-        )
-      ] })
-    ] });
-  }
-);
-var AssessmentSequence = forwardRef7(
-  function AssessmentSequence2(props, ref) {
-    const reactInstanceId = useId3();
-    const autoCompoundIdRef = useRef13(null);
-    if (!props.blockId && !autoCompoundIdRef.current) {
-      autoCompoundIdRef.current = deriveId(`assessment-sequence-${reactInstanceId}`);
-    }
-    const compoundId = useMemo13(
-      () => props.blockId ? normalizeComponentId(props.blockId, "blockId") : autoCompoundIdRef.current ?? DEFAULT_ASSESSMENT_SEQUENCE_COMPOUND_ID,
-      [props.blockId]
-    );
-    const childArray = React16.Children.toArray(props.children).filter(
-      React16.isValidElement
-    );
-    const { config, storage } = useLessonkit();
-    const persistEnabled = config.session?.persistCompoundState !== false;
-    useEffect12(() => {
-      warnSharedCompoundStorageKey({
-        persistEnabled,
-        hasExplicitBlockId: Boolean(props.blockId),
-        componentName: "AssessmentSequence"
-      });
-    }, [persistEnabled, props.blockId]);
-    const initialIndex = useCompoundInitialIndex({
-      courseId: config.courseId,
-      compoundId,
-      pageCount: childArray.length,
-      persistEnabled,
-      storage
-    });
-    const [index, setIndex] = useState10(initialIndex);
-    const setIndexStable = useCallback7((i) => setIndex(i), []);
-    useEffect12(() => {
-      setIndex(initialIndex);
-    }, [config.courseId, compoundId, initialIndex]);
-    return /* @__PURE__ */ jsx13(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ jsx13(
-      AssessmentSequenceInner,
-      {
-        ...props,
-        ref,
-        compoundId,
-        childArray,
-        index,
-        setIndex,
-        persistEnabled
-      }
-    ) });
-  }
-);
-setLessonkitBlockType(AssessmentSequence, "AssessmentSequence");
-
-// src/blocks/Text.tsx
-import "react";
-import { jsx as jsx14 } from "react/jsx-runtime";
-function Text(props) {
-  return /* @__PURE__ */ jsx14("p", { "data-lk-block-id": props.blockId, "data-testid": props.blockId ? `text-${props.blockId}` : "text", children: props.children });
-}
-setLessonkitBlockType(Text, "Text");
-
-// src/blocks/Heading.tsx
-import { jsx as jsx15 } from "react/jsx-runtime";
-function Heading(props) {
-  const Tag = `h${props.level}`;
-  return /* @__PURE__ */ jsx15(Tag, { "data-lk-block-id": props.blockId, "data-testid": props.blockId ? `heading-${props.blockId}` : "heading", children: props.children });
-}
-setLessonkitBlockType(Heading, "Heading");
-
-// src/blocks/Image.tsx
-import { jsx as jsx16 } from "react/jsx-runtime";
-function Image(props) {
-  return /* @__PURE__ */ jsx16(
-    "img",
-    {
-      src: props.src,
-      alt: props.alt,
-      "data-lk-block-id": props.blockId,
-      "data-testid": props.blockId ? `image-${props.blockId}` : "image",
-      style: { maxWidth: "100%", height: "auto" }
-    }
-  );
-}
-setLessonkitBlockType(Image, "Image");
-
-// src/blocks/Page.tsx
-import { useEffect as useEffect13 } from "react";
-import { jsx as jsx17, jsxs as jsxs10 } from "react/jsx-runtime";
-function Page(props) {
-  validateCompoundChildren("Page", props.children);
-  const { track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  useEffect13(() => {
-    if (props.hidden || !lessonId || props.parentType) return;
-    track(
-      "compound_page_viewed",
-      {
-        blockId: props.blockId,
-        pageIndex: props.pageIndex ?? 0,
-        parentType: props.parentType
-      },
-      { lessonId }
-    );
-  }, [props.hidden, props.pageIndex, props.parentType, props.blockId, lessonId, track]);
-  return /* @__PURE__ */ jsxs10(
-    "section",
-    {
-      "aria-label": props.title ?? "Page",
-      "data-lk-block-id": props.blockId,
-      "data-testid": `page-${props.blockId}`,
-      hidden: props.hidden ? true : void 0,
-      children: [
-        props.title ? /* @__PURE__ */ jsx17("h3", { children: props.title }) : null,
-        /* @__PURE__ */ jsx17(CompoundPageIndexProvider, { pageIndex: props.pageIndex ?? 0, children: /* @__PURE__ */ jsx17("div", { children: props.children }) })
-      ]
-    }
-  );
-}
-setLessonkitBlockType(Page, "Page");
-
-// src/blocks/InteractiveBook.tsx
-import React19, { forwardRef as forwardRef8, useCallback as useCallback8, useEffect as useEffect14, useMemo as useMemo14, useState as useState11 } from "react";
-import { jsx as jsx18, jsxs as jsxs11 } from "react/jsx-runtime";
-var InteractiveBookInner = forwardRef8(
-  function InteractiveBookInner2(props, ref) {
-    const { blockId, pages, index, setIndex, persistEnabled } = props;
-    validateCompoundChildren("InteractiveBook", pages);
-    const { config, track } = useLessonkit();
-    const lessonId = useEnclosingLessonId();
-    const { visibleIndex, goNext, goPrev, progress, ctx } = useCompoundShell({
-      courseId: config.courseId,
-      compoundId: blockId,
-      pageCount: pages.length,
-      index,
-      setIndex,
-      persistEnabled,
-      ref
-    });
-    const pageTitles = useMemo14(
-      () => pages.map((page) => page.props.title),
-      [pages]
-    );
-    useEffect14(() => {
-      if (!lessonId || pages.length === 0) return;
-      track(
-        "book_page_viewed",
-        {
-          blockId,
-          pageIndex: visibleIndex,
-          pageTitle: pageTitles[visibleIndex]
-        },
-        { lessonId }
-      );
-    }, [visibleIndex, blockId, lessonId, pages.length, pageTitles, track]);
-    return /* @__PURE__ */ jsxs11("section", { "aria-label": props.title, "data-testid": "interactive-book", "data-lk-block-id": blockId, children: [
-      /* @__PURE__ */ jsx18("h3", { children: props.title }),
-      /* @__PURE__ */ jsxs11("p", { children: [
-        "Page ",
-        progress.current,
-        " of ",
-        progress.total
-      ] }),
-      props.showBookScore && ctx ? /* @__PURE__ */ jsxs11("p", { "data-testid": "book-score", children: [
-        "Score: ",
-        Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getScore(), 0),
-        " /",
-        " ",
-        Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getMaxScore(), 0)
-      ] }) : null,
-      /* @__PURE__ */ jsx18("div", { "data-testid": "interactive-book-page", children: pages.map(
-        (page, i) => React19.cloneElement(page, {
-          key: page.key ?? page.props.blockId,
-          hidden: i !== visibleIndex,
-          pageIndex: i,
-          parentType: "InteractiveBook"
-        })
-      ) }),
-      /* @__PURE__ */ jsxs11("nav", { "aria-label": "Book navigation", children: [
-        /* @__PURE__ */ jsx18(
-          "button",
-          {
-            type: "button",
-            "data-testid": "book-prev",
-            disabled: visibleIndex === 0 || pages.length === 0,
-            onClick: goPrev,
-            children: "Previous"
-          }
-        ),
-        /* @__PURE__ */ jsx18(
-          "button",
-          {
-            type: "button",
-            "data-testid": "book-next",
-            disabled: visibleIndex >= pages.length - 1 || pages.length === 0,
-            onClick: goNext,
-            children: "Next"
-          }
-        )
-      ] })
-    ] });
-  }
-);
-var InteractiveBook = forwardRef8(function InteractiveBook2(props, ref) {
-  const blockId = useMemo14(
-    () => normalizeComponentId(props.blockId, "blockId"),
-    [props.blockId]
-  );
-  const pages = React19.Children.toArray(props.children).filter(
-    React19.isValidElement
-  );
-  const { config, storage } = useLessonkit();
-  const persistEnabled = config.session?.persistCompoundState !== false;
-  const initialIndex = useCompoundInitialIndex({
-    courseId: config.courseId,
-    compoundId: blockId,
-    pageCount: pages.length,
-    persistEnabled,
-    storage
-  });
-  const [index, setIndex] = useState11(initialIndex);
-  const setIndexStable = useCallback8((i) => setIndex(i), []);
-  useEffect14(() => {
-    setIndex(initialIndex);
-  }, [config.courseId, blockId, initialIndex]);
-  return /* @__PURE__ */ jsx18(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ jsx18(
-    InteractiveBookInner,
-    {
-      ...props,
-      ref,
-      blockId,
-      pages,
-      index,
-      setIndex,
-      persistEnabled
-    }
-  ) });
-});
-setLessonkitBlockType(InteractiveBook, "InteractiveBook");
-
-// src/blocks/Slide.tsx
-import { useEffect as useEffect15 } from "react";
-import { jsx as jsx19, jsxs as jsxs12 } from "react/jsx-runtime";
-function Slide(props) {
-  validateCompoundChildren("Slide", props.children);
-  const { track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  useEffect15(() => {
-    if (props.hidden || !lessonId || props.parentType) return;
-    track(
-      "compound_page_viewed",
-      {
-        blockId: props.blockId,
-        pageIndex: props.slideIndex ?? 0,
-        parentType: props.parentType
-      },
-      { lessonId }
-    );
-  }, [props.hidden, props.slideIndex, props.parentType, props.blockId, lessonId, track]);
-  return /* @__PURE__ */ jsxs12(
-    "section",
-    {
-      "aria-label": props.title ?? "Slide",
-      "data-lk-block-id": props.blockId,
-      "data-testid": `slide-${props.blockId}`,
-      hidden: props.hidden ? true : void 0,
-      children: [
-        props.title ? /* @__PURE__ */ jsx19("h3", { children: props.title }) : null,
-        /* @__PURE__ */ jsx19(CompoundPageIndexProvider, { pageIndex: props.slideIndex ?? 0, children: /* @__PURE__ */ jsx19("div", { children: props.children }) })
-      ]
-    }
+    [props.config, courseId]
   );
+  return /* @__PURE__ */ jsx(LessonkitProvider, { config: providerConfig, children: /* @__PURE__ */ jsxs("section", { "aria-label": props.title, children: [
+    /* @__PURE__ */ jsx("h1", { children: props.title }),
+    /* @__PURE__ */ jsx("div", { children: props.children })
+  ] }) });
 }
-setLessonkitBlockType(Slide, "Slide");
-
-// src/blocks/SlideDeck.tsx
-import React21, { forwardRef as forwardRef9, useCallback as useCallback9, useEffect as useEffect17, useMemo as useMemo15, useRef as useRef14, useState as useState12 } from "react";
-
-// src/compound/useCompoundKeyboardNav.ts
-import { useEffect as useEffect16 } from "react";
-var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT", "BUTTON"]);
-function isEditableTarget(target) {
-  if (!(target instanceof HTMLElement)) return false;
-  if (INTERACTIVE_TAGS.has(target.tagName)) return true;
-  if (target.isContentEditable) return true;
-  if (target.closest("[role='slider'], [role='listbox'], [data-lk-assessment-interactive]")) {
-    return true;
-  }
-  return false;
-}
-function useCompoundKeyboardNav(opts) {
-  const { containerRef, visibleIndex, pageCount, goNext, goPrev, setIndex } = opts;
-  useEffect16(() => {
-    const el = containerRef.current;
-    if (!el || pageCount === 0) return;
-    const onKeyDown = (event) => {
-      if (!el.contains(document.activeElement) && document.activeElement !== document.body) {
+function Lesson(props) {
+  const lessonId = useMemo(() => normalizeComponentId(props.lessonId, "lessonId"), [props.lessonId]);
+  const autoComplete = props.autoCompleteOnUnmount !== false;
+  const { setActiveLesson, config } = useLessonkit();
+  const { completeLesson } = useCompletion();
+  const lessonMountGenerationRef = useRef(0);
+  const liveCourseIdRef = useRef(config.courseId);
+  liveCourseIdRef.current = config.courseId;
+  useEffect(() => {
+    const unregister = registerLessonMount(lessonId);
+    const generation = ++lessonMountGenerationRef.current;
+    const mountedCourseId = config.courseId;
+    let effectSurvivedTick = false;
+    queueMicrotask(() => {
+      queueMicrotask(() => {
+        effectSurvivedTick = true;
+      });
+    });
+    setActiveLesson(lessonId);
+    return () => {
+      unregister();
+      if (getLessonMountCount(lessonId) > 0) {
         return;
       }
-      if (isEditableTarget(event.target)) return;
-      switch (event.key) {
-        case "ArrowRight":
-        case "ArrowDown":
-          if (visibleIndex < pageCount - 1) {
-            event.preventDefault();
-            goNext();
-          }
-          break;
-        case "ArrowLeft":
-        case "ArrowUp":
-          if (visibleIndex > 0) {
-            event.preventDefault();
-            goPrev();
-          }
-          break;
-        case "Home":
-          if (visibleIndex !== 0) {
-            event.preventDefault();
-            setIndex(0);
-          }
-          break;
-        case "End":
-          if (visibleIndex !== pageCount - 1) {
-            event.preventDefault();
-            setIndex(pageCount - 1);
-          }
-          break;
-        default:
-          break;
-      }
+      if (!autoComplete) return;
+      queueMicrotask(() => {
+        if (!effectSurvivedTick) return;
+        if (lessonMountGenerationRef.current !== generation) return;
+        if (liveCourseIdRef.current !== mountedCourseId) return;
+        completeLesson(lessonId, { courseId: mountedCourseId });
+      });
     };
-    el.addEventListener("keydown", onKeyDown);
-    return () => el.removeEventListener("keydown", onKeyDown);
-  }, [containerRef, visibleIndex, pageCount, goNext, goPrev, setIndex]);
+  }, [lessonId, config.courseId, setActiveLesson, completeLesson, autoComplete]);
+  return /* @__PURE__ */ jsx(LessonContext.Provider, { value: lessonId, children: /* @__PURE__ */ jsxs("article", { "aria-label": props.title, children: [
+    /* @__PURE__ */ jsx("h2", { children: props.title }),
+    /* @__PURE__ */ jsx("div", { children: props.children })
+  ] }) });
 }
-
-// src/blocks/SlideDeck.tsx
-import { jsx as jsx20, jsxs as jsxs13 } from "react/jsx-runtime";
-var SlideDeckInner = forwardRef9(function SlideDeckInner2(props, ref) {
-  const { blockId, slides, index, setIndex, persistEnabled } = props;
-  validateCompoundChildren("SlideDeck", slides);
-  const { config, track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  const containerRef = useRef14(null);
-  const { visibleIndex, goNext, goPrev, progress, ctx } = useCompoundShell({
-    courseId: config.courseId,
-    compoundId: blockId,
-    pageCount: slides.length,
-    index,
-    setIndex,
-    persistEnabled,
-    ref
-  });
-  const setIndexStable = useCallback9((i) => setIndex(i), [setIndex]);
-  useCompoundKeyboardNav({
-    containerRef,
-    visibleIndex,
-    pageCount: slides.length,
-    goNext,
-    goPrev,
-    setIndex: setIndexStable
-  });
-  const slideTitles = useMemo15(
-    () => slides.map((slide) => slide.props.title),
-    [slides]
-  );
-  useEffect17(() => {
-    if (!lessonId || slides.length === 0) return;
-    track(
-      "slide_viewed",
-      {
-        blockId,
-        slideIndex: visibleIndex,
-        slideTitle: slideTitles[visibleIndex]
-      },
-      { lessonId }
-    );
-  }, [visibleIndex, blockId, lessonId, slides.length, slideTitles, track]);
-  return /* @__PURE__ */ jsxs13(
-    "section",
-    {
-      ref: containerRef,
-      tabIndex: -1,
-      "aria-label": props.title,
-      "data-testid": "slide-deck",
-      "data-lk-block-id": blockId,
-      children: [
-        /* @__PURE__ */ jsx20("h3", { children: props.title }),
-        /* @__PURE__ */ jsxs13("p", { children: [
-          "Slide ",
-          progress.current,
-          " of ",
-          progress.total
-        ] }),
-        props.showDeckScore && ctx ? /* @__PURE__ */ jsxs13("p", { "data-testid": "deck-score", children: [
-          "Score: ",
-          Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getScore(), 0),
-          " /",
-          " ",
-          Array.from(ctx.getHandles().values()).reduce((s, h) => s + h.getMaxScore(), 0)
-        ] }) : null,
-        /* @__PURE__ */ jsx20("div", { "data-testid": "slide-deck-slide", children: slides.map(
-          (slide, i) => React21.cloneElement(slide, {
-            key: slide.key ?? slide.props.blockId,
-            hidden: i !== visibleIndex,
-            slideIndex: i,
-            parentType: "SlideDeck"
-          })
-        ) }),
-        /* @__PURE__ */ jsxs13("nav", { "aria-label": "Slide navigation", children: [
-          /* @__PURE__ */ jsx20(
-            "button",
-            {
-              type: "button",
-              "data-testid": "slide-prev",
-              disabled: visibleIndex === 0 || slides.length === 0,
-              onClick: goPrev,
-              children: "Previous slide"
-            }
-          ),
-          /* @__PURE__ */ jsx20(
-            "button",
-            {
-              type: "button",
-              "data-testid": "slide-next",
-              disabled: visibleIndex >= slides.length - 1 || slides.length === 0,
-              onClick: goNext,
-              children: "Next slide"
-            }
-          )
-        ] })
-      ]
-    }
-  );
-});
-var SlideDeck = forwardRef9(function SlideDeck2(props, ref) {
-  const blockId = useMemo15(
-    () => normalizeComponentId(props.blockId, "blockId"),
+function Scenario(props) {
+  const blockId = useMemo(
+    () => props.blockId !== void 0 ? normalizeComponentId(props.blockId, "blockId") : void 0,
     [props.blockId]
   );
-  const slides = React21.Children.toArray(props.children).filter(
-    React21.isValidElement
-  );
-  const { config, storage } = useLessonkit();
-  const persistEnabled = config.session?.persistCompoundState !== false;
-  const initialIndex = useCompoundInitialIndex({
-    courseId: config.courseId,
-    compoundId: blockId,
-    pageCount: slides.length,
-    persistEnabled,
-    storage
-  });
-  const [index, setIndex] = useState12(initialIndex);
-  const setIndexStable = useCallback9((i) => setIndex(i), []);
-  useEffect17(() => {
-    setIndex(initialIndex);
-  }, [config.courseId, blockId, initialIndex]);
-  return /* @__PURE__ */ jsx20(CompoundProvider, { activePageIndex: index, onActivePageIndexChange: setIndexStable, children: /* @__PURE__ */ jsx20(
-    SlideDeckInner,
-    {
-      ...props,
-      ref,
-      blockId,
-      slides,
-      index,
-      setIndex,
-      persistEnabled
-    }
-  ) });
-});
-setLessonkitBlockType(SlideDeck, "SlideDeck");
-
-// src/blocks/Accordion.tsx
-import { useId as useId4, useState as useState13 } from "react";
-import { jsx as jsx21, jsxs as jsxs14 } from "react/jsx-runtime";
-function Accordion(props) {
-  if (isDevEnvironment4()) {
-    validateAccordionSections(props.sections);
-  }
-  const [open, setOpen] = useState13(/* @__PURE__ */ new Set());
-  const { track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  const baseId = useId4();
-  const toggle = (sectionId) => {
-    setOpen((prev) => {
-      const next = new Set(prev);
-      const expanded = !next.has(sectionId);
-      if (expanded) next.add(sectionId);
-      else next.delete(sectionId);
-      track(
-        "accordion_section_toggled",
-        { blockId: props.blockId, sectionId, expanded },
-        lessonId ? { lessonId } : void 0
-      );
-      return next;
-    });
-  };
-  return /* @__PURE__ */ jsx21("section", { "aria-label": "Accordion", "data-lk-block-id": props.blockId, "data-testid": "accordion", children: props.sections.map((section) => {
-    const expanded = open.has(section.id);
-    const panelId = `${baseId}-${section.id}`;
-    const triggerId = `${baseId}-trigger-${section.id}`;
-    return /* @__PURE__ */ jsxs14("div", { "data-testid": `accordion-section-${section.id}`, children: [
-      /* @__PURE__ */ jsx21("h4", { children: /* @__PURE__ */ jsx21(
-        "button",
-        {
-          id: triggerId,
-          type: "button",
-          "aria-expanded": expanded,
-          "aria-controls": panelId,
-          "data-testid": `accordion-trigger-${section.id}`,
-          onClick: () => toggle(section.id),
-          children: section.title
-        }
-      ) }),
-      expanded ? /* @__PURE__ */ jsx21("div", { id: panelId, role: "region", "aria-labelledby": triggerId, children: section.content }) : null
-    ] }, section.id);
-  }) });
-}
-setLessonkitBlockType(Accordion, "Accordion");
-
-// src/blocks/DialogCards.tsx
-import { useState as useState14 } from "react";
-import { jsx as jsx22, jsxs as jsxs15 } from "react/jsx-runtime";
-function DialogCards(props) {
-  const [index, setIndex] = useState14(0);
-  const [flipped, setFlipped] = useState14(false);
-  const card = props.cards[index];
-  if (!card) return null;
-  return /* @__PURE__ */ jsxs15("section", { "aria-label": "Dialog cards", "data-lk-block-id": props.blockId, "data-testid": "dialog-cards", children: [
-    /* @__PURE__ */ jsxs15("p", { children: [
-      "Card ",
-      index + 1,
-      " of ",
-      props.cards.length
-    ] }),
-    /* @__PURE__ */ jsx22(
-      "button",
-      {
-        type: "button",
-        "data-testid": "dialog-card-flip",
-        "aria-pressed": flipped,
-        onClick: () => setFlipped((f) => !f),
-        style: { minHeight: "6rem", width: "100%" },
-        children: flipped ? card.back : card.front
-      }
-    ),
-    /* @__PURE__ */ jsxs15("nav", { "aria-label": "Card navigation", children: [
-      /* @__PURE__ */ jsx22(
-        "button",
-        {
-          type: "button",
-          "data-testid": "dialog-prev",
-          disabled: index === 0,
-          onClick: () => {
-            setIndex((i) => i - 1);
-            setFlipped(false);
-          },
-          children: "Previous"
-        }
-      ),
-      /* @__PURE__ */ jsx22(
-        "button",
-        {
-          type: "button",
-          "data-testid": "dialog-next",
-          disabled: index >= props.cards.length - 1,
-          onClick: () => {
-            setIndex((i) => i + 1);
-            setFlipped(false);
-          },
-          children: "Next"
-        }
-      )
-    ] })
-  ] });
+  return /* @__PURE__ */ jsx("section", { "aria-label": "Scenario", "data-lk-block-id": blockId, children: props.children });
 }
-setLessonkitBlockType(DialogCards, "DialogCards");
-
-// src/blocks/Flashcards.tsx
-import { useState as useState15 } from "react";
-import { jsx as jsx23, jsxs as jsxs16 } from "react/jsx-runtime";
-function Flashcards(props) {
-  const [index, setIndex] = useState15(0);
-  const [face, setFace] = useState15("front");
-  const { track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  const card = props.cards[index];
-  if (!card) return null;
-  const flip = () => {
-    const next = face === "front" ? "back" : "front";
-    setFace(next);
-    track(
-      "flashcard_flipped",
-      { blockId: props.blockId, cardIndex: index, face: next },
-      lessonId ? { lessonId } : void 0
-    );
+function Reflection(props) {
+  const blockId = useMemo(
+    () => props.blockId !== void 0 ? normalizeComponentId(props.blockId, "blockId") : void 0,
+    [props.blockId]
+  );
+  const promptId = useId();
+  const hintId = useId();
+  const [internalValue, setInternalValue] = useState("");
+  const isControlled = props.value !== void 0;
+  const value = isControlled ? props.value : internalValue;
+  const handleChange = (event) => {
+    if (!isControlled) setInternalValue(event.target.value);
+    props.onChange?.(event.target.value);
   };
-  return /* @__PURE__ */ jsxs16("section", { "aria-label": "Flashcards", "data-lk-block-id": props.blockId, "data-testid": "flashcards", children: [
-    /* @__PURE__ */ jsx23("button", { type: "button", "data-testid": "flashcard-flip", onClick: flip, style: { minHeight: "6rem", width: "100%" }, children: face === "front" ? card.front : card.back }),
-    props.selfScore ? /* @__PURE__ */ jsx23("p", { "data-testid": "flashcard-self-score", children: "Self-score mode enabled" }) : null,
-    /* @__PURE__ */ jsx23(
-      "button",
+  return /* @__PURE__ */ jsxs("section", { "aria-label": "Reflection", "data-lk-block-id": blockId, children: [
+    props.prompt ? /* @__PURE__ */ jsx("p", { id: promptId, children: props.prompt }) : null,
+    props.hint ? /* @__PURE__ */ jsx("p", { id: hintId, style: visuallyHiddenStyle, children: props.hint }) : null,
+    props.children,
+    /* @__PURE__ */ jsx(
+      "textarea",
       {
-        type: "button",
-        "data-testid": "flashcard-next",
-        disabled: index >= props.cards.length - 1,
-        onClick: () => {
-          setIndex((i) => i + 1);
-          setFace("front");
-        },
-        children: "Next card"
+        value,
+        onChange: handleChange,
+        "aria-labelledby": props.prompt ? promptId : void 0,
+        "aria-describedby": props.hint ? hintId : void 0,
+        "aria-label": props.prompt ? void 0 : "Reflection response"
       }
     )
   ] });
 }
-setLessonkitBlockType(Flashcards, "Flashcards");
-
-// src/blocks/ImageHotspots.tsx
-import { useState as useState16 } from "react";
-import { jsx as jsx24, jsxs as jsxs17 } from "react/jsx-runtime";
-function ImageHotspots(props) {
-  const [active, setActive] = useState16(null);
-  const { track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  const open = (hotspotId) => {
-    setActive(hotspotId);
-    track(
-      "hotspot_opened",
-      { blockId: props.blockId, hotspotId },
-      lessonId ? { lessonId } : void 0
-    );
-  };
-  return /* @__PURE__ */ jsxs17("section", { "aria-label": "Image hotspots", "data-lk-block-id": props.blockId, "data-testid": "image-hotspots", children: [
-    /* @__PURE__ */ jsxs17("div", { style: { position: "relative", display: "inline-block" }, children: [
-      /* @__PURE__ */ jsx24("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
-      props.hotspots.map((h) => /* @__PURE__ */ jsx24(
-        "button",
-        {
-          type: "button",
-          "aria-expanded": active === h.id,
-          "aria-label": h.label,
-          "data-testid": `hotspot-${h.id}`,
-          style: {
-            position: "absolute",
-            left: `${h.x}%`,
-            top: `${h.y}%`,
-            transform: "translate(-50%, -50%)"
-          },
-          onClick: () => open(h.id),
-          children: "+"
-        },
-        h.id
-      ))
-    ] }),
-    active ? /* @__PURE__ */ jsxs17("div", { role: "dialog", "aria-label": "Hotspot details", "data-testid": "hotspot-popover", children: [
-      props.hotspots.find((h) => h.id === active)?.content,
-      /* @__PURE__ */ jsx24("button", { type: "button", onClick: () => setActive(null), children: "Close" })
-    ] }) : null
-  ] });
-}
-setLessonkitBlockType(ImageHotspots, "ImageHotspots");
-
-// src/blocks/ImageSlider.tsx
-import { useState as useState17 } from "react";
-import { jsx as jsx25, jsxs as jsxs18 } from "react/jsx-runtime";
-function ImageSlider(props) {
-  const [index, setIndex] = useState17(0);
-  const { track } = useLessonkit();
-  const lessonId = useEnclosingLessonId();
-  const slide = props.slides[index];
-  if (!slide) return null;
-  const goTo = (next) => {
-    setIndex(next);
-    track(
-      "image_slider_changed",
-      { blockId: props.blockId, slideIndex: next },
-      lessonId ? { lessonId } : void 0
-    );
-  };
-  return /* @__PURE__ */ jsxs18("section", { "aria-label": "Image slider", "data-lk-block-id": props.blockId, "data-testid": "image-slider", children: [
-    /* @__PURE__ */ jsx25("img", { src: slide.src, alt: slide.alt, style: { maxWidth: "100%" } }),
-    slide.caption ? /* @__PURE__ */ jsx25("p", { children: slide.caption }) : null,
-    /* @__PURE__ */ jsxs18("nav", { "aria-label": "Slide navigation", children: [
-      /* @__PURE__ */ jsx25(
-        "button",
-        {
-          type: "button",
-          "data-testid": "slider-prev",
-          disabled: index === 0,
-          onClick: () => goTo(index - 1),
-          children: "Previous"
-        }
-      ),
-      /* @__PURE__ */ jsxs18("span", { children: [
-        index + 1,
-        " / ",
-        props.slides.length
-      ] }),
-      /* @__PURE__ */ jsx25(
-        "button",
-        {
-          type: "button",
-          "data-testid": "slider-next",
-          disabled: index >= props.slides.length - 1,
-          onClick: () => goTo(index + 1),
-          children: "Next"
-        }
-      )
-    ] })
-  ] });
-}
-setLessonkitBlockType(ImageSlider, "ImageSlider");
-
-// src/blocks/FindHotspot.tsx
-import { forwardRef as forwardRef10, useEffect as useEffect18, useMemo as useMemo16, useState as useState18 } from "react";
-import { jsx as jsx26, jsxs as jsxs19 } from "react/jsx-runtime";
-var INTERACTION6 = "findHotspot";
-function FindHotspotInner(props, ref) {
-  const checkId = useMemo16(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const [selected, setSelected] = useState18(null);
-  const [checked, setChecked] = useState18(false);
-  const assessment = useAssessmentState(props.enclosingLessonId);
-  const targetIdsKey = props.targets.map((t) => t.id).join("\0");
-  useEffect18(() => {
-    setSelected(null);
-    setChecked(false);
-  }, [checkId, props.correctTargetId, targetIdsKey]);
-  const correct = selected === props.correctTargetId;
-  const handle = useMemo16(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => checked && correct ? 1 : 0,
-      getMaxScore: () => 1,
-      getAnswerGiven: () => selected !== null,
-      resetTask: () => {
-        setSelected(null);
-        setChecked(false);
-      },
-      showSolutions: () => setSelected(props.correctTargetId),
-      getXAPIData: () => ({
-        checkId,
-        interactionType: INTERACTION6,
-        response: selected ?? void 0,
-        correct: checked ? correct : void 0,
-        score: checked && correct ? 1 : 0,
-        maxScore: 1
-      }),
-      getCurrentState: () => ({ selected, checked }),
-      resume: (state) => {
-        const nextSelected = readStringField(state, "selected");
-        if (typeof nextSelected === "string" || nextSelected === null) {
-          const valid = nextSelected === null || props.targets.some((t) => t.id === nextSelected);
-          setSelected(valid ? nextSelected : null);
-        }
-        readBooleanStateField(state, "checked", setChecked);
-      }
-    }),
-    [checkId, selected, checked, correct, props.correctTargetId, props.targets]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const selectTarget = (id) => {
-    setSelected(id);
-    setChecked(false);
-  };
-  const submit = () => {
-    if (!selected || checked) return;
-    setChecked(true);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION6,
-      response: selected,
-      correct
-    });
-    if (correct) {
-      assessment.complete({
-        checkId,
-        interactionType: INTERACTION6,
-        score: 1,
-        maxScore: 1,
-        passingScore: props.passingScore ?? 1
-      });
-    }
-  };
-  return /* @__PURE__ */ jsxs19("section", { "aria-label": "Find the hotspot", "data-lk-check-id": checkId, "data-testid": "find-hotspot", children: [
-    /* @__PURE__ */ jsxs19("div", { style: { position: "relative", display: "inline-block" }, children: [
-      /* @__PURE__ */ jsx26("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
-      props.targets.map((t) => /* @__PURE__ */ jsx26(
-        "button",
-        {
-          type: "button",
-          "aria-label": t.label,
-          "aria-pressed": selected === t.id,
-          "data-testid": `target-${t.id}`,
-          style: {
-            position: "absolute",
-            left: `${t.x}%`,
-            top: `${t.y}%`,
-            transform: "translate(-50%, -50%)"
-          },
-          onClick: () => selectTarget(t.id),
-          children: t.label
-        },
-        t.id
-      ))
-    ] }),
-    /* @__PURE__ */ jsx26("button", { type: "button", "data-testid": "check-hotspot", disabled: !selected, onClick: submit, children: "Check" }),
-    checked ? /* @__PURE__ */ jsx26("p", { role: "status", children: correct ? "Correct" : "Try again" }) : null
-  ] });
-}
-var FindHotspotInnerForwarded = forwardRef10(FindHotspotInner);
-var FindHotspot = forwardRef10(function FindHotspot2(props, ref) {
-  return /* @__PURE__ */ jsx26(AssessmentLessonGuard, { blockLabel: "FindHotspot", checkId: props.checkId, children: (enclosingLessonId) => /* @__PURE__ */ jsx26(FindHotspotInnerForwarded, { ...props, enclosingLessonId, ref }) });
-});
-setLessonkitBlockType(FindHotspot, "FindHotspot");
-
-// src/blocks/FindMultipleHotspots.tsx
-import { forwardRef as forwardRef11, useMemo as useMemo17, useState as useState19 } from "react";
-import { jsx as jsx27, jsxs as jsxs20 } from "react/jsx-runtime";
-var INTERACTION7 = "findMultipleHotspots";
-function FindMultipleHotspotsInner(props, ref) {
-  const checkId = useMemo17(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
-  const [selected, setSelected] = useState19(/* @__PURE__ */ new Set());
-  const [checked, setChecked] = useState19(false);
-  const assessment = useAssessmentState(props.enclosingLessonId);
-  const toggle = (id) => {
-    setSelected((prev) => {
-      const next = new Set(prev);
-      if (next.has(id)) next.delete(id);
-      else next.add(id);
-      return next;
-    });
-    setChecked(false);
-  };
-  const correct = selected.size === props.correctTargetIds.length && props.correctTargetIds.every((id) => selected.has(id));
-  const handle = useMemo17(
-    () => buildAssessmentHandle({
-      checkId,
-      getScore: () => checked && correct ? 1 : 0,
-      getMaxScore: () => 1,
-      getAnswerGiven: () => selected.size > 0,
-      resetTask: () => {
-        setSelected(/* @__PURE__ */ new Set());
-        setChecked(false);
-      },
-      showSolutions: () => setSelected(new Set(props.correctTargetIds)),
-      getXAPIData: () => ({
-        checkId,
-        interactionType: INTERACTION7,
-        response: [...selected],
-        correct: checked ? correct : void 0,
-        score: checked && correct ? 1 : 0,
-        maxScore: 1
-      }),
-      getCurrentState: () => ({ selected: [...selected], checked }),
-      resume: (state) => {
-        const raw = state.selected;
-        if (Array.isArray(raw)) setSelected(new Set(raw.filter((id) => typeof id === "string")));
-        readBooleanStateField(state, "checked", setChecked);
+function ProgressTracker(props) {
+  const { progress } = useLessonkit();
+  const completed = progress.completedLessonIds.size;
+  if (props.totalLessons != null) {
+    const total = props.totalLessons;
+    const displayed = Math.min(completed, total);
+    return /* @__PURE__ */ jsx("aside", { "aria-label": "Progress", children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "progressbar",
+        "aria-valuemin": 0,
+        "aria-valuemax": total,
+        "aria-valuenow": displayed,
+        "aria-label": "Lessons completed",
+        children: /* @__PURE__ */ jsxs("p", { children: [
+          "Lessons completed: ",
+          displayed,
+          " of ",
+          total
+        ] })
       }
-    }),
-    [checkId, selected, checked, correct, props.correctTargetIds]
-  );
-  useAssessmentHandleRegistration(checkId, handle, ref);
-  const submit = () => {
-    if (selected.size === 0 || checked) return;
-    setChecked(true);
-    assessment.answer({
-      checkId,
-      interactionType: INTERACTION7,
-      response: [...selected],
-      correct
-    });
-    if (correct) {
-      assessment.complete({
-        checkId,
-        interactionType: INTERACTION7,
-        score: 1,
-        maxScore: 1,
-        passingScore: props.passingScore ?? 1
-      });
-    }
-  };
-  return /* @__PURE__ */ jsxs20("section", { "aria-label": "Find multiple hotspots", "data-lk-check-id": checkId, "data-testid": "find-multiple-hotspots", children: [
-    /* @__PURE__ */ jsxs20("div", { style: { position: "relative", display: "inline-block" }, children: [
-      /* @__PURE__ */ jsx27("img", { src: props.src, alt: props.alt, style: { maxWidth: "100%" } }),
-      props.targets.map((t) => /* @__PURE__ */ jsx27(
-        "button",
-        {
-          type: "button",
-          "aria-label": t.label,
-          "aria-pressed": selected.has(t.id),
-          "data-testid": `target-${t.id}`,
-          style: {
-            position: "absolute",
-            left: `${t.x}%`,
-            top: `${t.y}%`,
-            transform: "translate(-50%, -50%)"
-          },
-          onClick: () => toggle(t.id),
-          children: t.label
-        },
-        t.id
-      ))
-    ] }),
-    /* @__PURE__ */ jsx27("button", { type: "button", "data-testid": "check-hotspots", disabled: selected.size === 0, onClick: submit, children: "Check" }),
-    checked ? /* @__PURE__ */ jsx27("p", { role: "status", children: correct ? "Correct" : "Try again" }) : null
-  ] });
-}
-var FindMultipleHotspotsInnerForwarded = forwardRef11(FindMultipleHotspotsInner);
-var FindMultipleHotspots = forwardRef11(
-  function FindMultipleHotspots2(props, ref) {
-    return /* @__PURE__ */ jsx27(AssessmentLessonGuard, { blockLabel: "FindMultipleHotspots", checkId: props.checkId, children: (enclosingLessonId) => /* @__PURE__ */ jsx27(FindMultipleHotspotsInnerForwarded, { ...props, enclosingLessonId, ref }) });
+    ) });
   }
-);
-setLessonkitBlockType(FindMultipleHotspots, "FindMultipleHotspots");
+  return /* @__PURE__ */ jsx("aside", { "aria-label": "Progress", role: "status", children: /* @__PURE__ */ jsxs("p", { children: [
+    "Lessons completed: ",
+    completed
+  ] }) });
+}
 
 // src/index.tsx
 import {
-  buildTelemetryEvent as buildTelemetryEvent2,
-  createLessonkitRuntime as createLessonkitRuntime2,
-  createPluginRegistry as createPluginRegistry2,
-  createTelemetryPipeline as createTelemetryPipeline2,
+  buildTelemetryEvent,
+  createLessonkitRuntime,
+  createPluginRegistry,
+  createTelemetryPipeline,
   defineAssessmentPlugin,
   defineLifecyclePlugin,
   defineTelemetryPlugin
 } from "@lessonkit/core";
 
 // src/theme/ThemeProvider.tsx
-import React29, {
-  createContext as createContext6,
-  useCallback as useCallback10,
-  useContext as useContext8,
-  useLayoutEffect as useLayoutEffect2,
-  useMemo as useMemo18,
-  useRef as useRef15,
-  useState as useState20
+import React2, {
+  createContext,
+  useCallback,
+  useContext,
+  useLayoutEffect,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2
 } from "react";
 import {
   brandThemeOverrides,
@@ -4095,11 +219,11 @@ function applyCssVariables(target, vars, previousKeys) {
 }
 
 // src/theme/ThemeProvider.tsx
-import { jsx as jsx28 } from "react/jsx-runtime";
-var ThemeContext = createContext6(null);
-var useIsoLayoutEffect2 = (
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ThemeContext = createContext(null);
+var useIsoLayoutEffect = (
   /* v8 ignore next -- SSR uses useEffect when window is unavailable */
-  typeof window !== "undefined" ? useLayoutEffect2 : React29.useEffect
+  typeof window !== "undefined" ? useLayoutEffect : React2.useEffect
 );
 function getSystemMode() {
   if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
@@ -4118,10 +242,10 @@ function ThemeProvider(props) {
   const preset = props.preset ?? "default";
   const mode = props.mode ?? "light";
   const targetKind = props.target ?? "document";
-  const [resolvedMode, setResolvedMode] = useState20(
+  const [resolvedMode, setResolvedMode] = useState2(
     () => mode === "system" ? getSystemMode() : mode
   );
-  useIsoLayoutEffect2(() => {
+  useIsoLayoutEffect(() => {
     if (mode !== "system") {
       setResolvedMode(mode);
       return;
@@ -4134,26 +258,26 @@ function ThemeProvider(props) {
     return () => mq.removeEventListener("change", onChange);
   }, [mode]);
   const dataTheme = mode === "system" ? resolvedMode : mode === "dark" ? "dark" : "light";
-  const effectiveTheme = useMemo18(() => {
+  const effectiveTheme = useMemo2(() => {
     const modeBase = resolveModeBase(mode, dataTheme);
     const base = preset === "default" ? modeBase : preset === "brand" ? mergeThemes(modeBase, brandThemeOverrides) : mergeThemes(modeBase, getPresetTheme(preset));
     return mergeThemes(base, props.theme ?? {});
   }, [preset, mode, dataTheme, props.theme]);
-  const hostRef = useRef15(null);
-  const appliedKeysRef = useRef15(/* @__PURE__ */ new Set());
-  useIsoLayoutEffect2(() => {
+  const hostRef = useRef2(null);
+  const appliedKeysRef = useRef2(/* @__PURE__ */ new Set());
+  useIsoLayoutEffect(() => {
     if (targetKind === "document" && typeof document !== "undefined") {
       document.documentElement.setAttribute("data-lk-theme", dataTheme);
       return () => document.documentElement.removeAttribute("data-lk-theme");
     }
   }, [targetKind, dataTheme]);
-  const inject = useCallback10(() => {
+  const inject = useCallback(() => {
     const vars = themeToCssVariables(effectiveTheme);
     const el = targetKind === "document" && typeof document !== "undefined" ? document.documentElement : hostRef.current;
     if (!el) return;
     appliedKeysRef.current = applyCssVariables(el, vars, appliedKeysRef.current);
   }, [effectiveTheme, targetKind]);
-  useIsoLayoutEffect2(() => {
+  useIsoLayoutEffect(() => {
     inject();
     return () => {
       const el = targetKind === "document" && typeof document !== "undefined" ? document.documentElement : hostRef.current;
@@ -4164,7 +288,7 @@ function ThemeProvider(props) {
       appliedKeysRef.current = /* @__PURE__ */ new Set();
     };
   }, [inject, targetKind]);
-  const value = useMemo18(
+  const value = useMemo2(
     () => ({
       theme: effectiveTheme,
       preset,
@@ -4174,12 +298,12 @@ function ThemeProvider(props) {
     [effectiveTheme, preset, mode, dataTheme]
   );
   if (targetKind === "document") {
-    return /* @__PURE__ */ jsx28(ThemeContext.Provider, { value, children: /* @__PURE__ */ jsx28("div", { "data-lk-theme": dataTheme, style: { display: "contents" }, children: props.children }) });
+    return /* @__PURE__ */ jsx2(ThemeContext.Provider, { value, children: /* @__PURE__ */ jsx2("div", { "data-lk-theme": dataTheme, style: { display: "contents" }, children: props.children }) });
   }
-  return /* @__PURE__ */ jsx28(ThemeContext.Provider, { value, children: /* @__PURE__ */ jsx28("div", { ref: hostRef, "data-lk-theme": dataTheme, children: props.children }) });
+  return /* @__PURE__ */ jsx2(ThemeContext.Provider, { value, children: /* @__PURE__ */ jsx2("div", { ref: hostRef, "data-lk-theme": dataTheme, children: props.children }) });
 }
 function useTheme() {
-  const ctx = useContext8(ThemeContext);
+  const ctx = useContext(ThemeContext);
   if (!ctx) {
     throw new Error("useTheme must be used within a ThemeProvider");
   }
@@ -4190,10 +314,12 @@ function useTheme() {
 import {
   ASSESSMENT_SEQUENCE_ALLOWED_CHILD_TYPES,
   INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES,
+  INTERACTIVE_VIDEO_ALLOWED_CHILD_TYPES,
   PAGE_ALLOWED_CHILD_TYPES,
   SLIDE_ALLOWED_CHILD_TYPES,
   SLIDE_DECK_ALLOWED_CHILD_TYPES,
-  COMPOUND_MAX_NESTING_DEPTH as COMPOUND_MAX_NESTING_DEPTH2
+  TIMED_CUE_ALLOWED_CHILD_TYPES,
+  COMPOUND_MAX_NESTING_DEPTH
 } from "@lessonkit/core";
 var COMPOUND_PARENTS = [
   "Lesson",
@@ -4201,6 +327,8 @@ var COMPOUND_PARENTS = [
   "InteractiveBook",
   "Slide",
   "SlideDeck",
+  "TimedCue",
+  "InteractiveVideo",
   "AssessmentSequence"
 ];
 function extendParents(entry) {
@@ -4259,6 +387,23 @@ var v3CompoundAndContentEntries = [
     theming: { surface: "global-inherit", stylingNotes: "Responsive max-width." },
     telemetry: { emits: [] }
   },
+  {
+    type: "Video",
+    category: "content",
+    description: "Self-hosted video with native controls and optional captions.",
+    props: [
+      { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
+      { name: "src", type: "string", required: true, description: "Video URL." },
+      { name: "poster", type: "string", required: false, description: "Poster image URL." },
+      { name: "captions", type: "string", required: false, description: "WebVTT captions URL." },
+      { name: "title", type: "string", required: false, description: "Accessible title." }
+    ],
+    requiredIds: ["blockId"],
+    parentConstraints: [...COMPOUND_PARENTS],
+    a11y: { element: "video", ariaLabel: "Video", keyboard: "Native video controls.", notes: "No autoplay with sound." },
+    theming: { surface: "global-inherit", stylingNotes: "Responsive video." },
+    telemetry: { emits: [] }
+  },
   {
     type: "Page",
     category: "container",
@@ -4267,7 +412,7 @@ var v3CompoundAndContentEntries = [
     h5pAlias: "Column",
     description: "Column layout container (H5P Column / Page).",
     allowedChildTypes: [...PAGE_ALLOWED_CHILD_TYPES],
-    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH2.Page,
+    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.Page,
     props: [
       { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
       { name: "title", type: "string", required: false, description: "Page title." },
@@ -4288,7 +433,7 @@ var v3CompoundAndContentEntries = [
     h5pAlias: "Interactive Book",
     description: "Multi-page book with chapter navigation.",
     allowedChildTypes: [...INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES],
-    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH2.InteractiveBook,
+    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.InteractiveBook,
     props: [
       { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
       { name: "title", type: "string", required: true, description: "Book title." },
@@ -4312,9 +457,9 @@ var v3CompoundAndContentEntries = [
     compoundContract: true,
     h5pMachineName: "H5P.CoursePresentation",
     h5pAlias: "Course Presentation slide",
-    description: "Single slide row in a SlideDeck. Planned allowlist expansion: Video, Summary.",
+    description: "Single slide row in a SlideDeck. Supports Video, Summary, and 1.4 blocks.",
     allowedChildTypes: [...SLIDE_ALLOWED_CHILD_TYPES],
-    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH2.Slide,
+    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.Slide,
     props: [
       { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
       { name: "title", type: "string", required: false, description: "Slide title." },
@@ -4335,7 +480,7 @@ var v3CompoundAndContentEntries = [
     h5pAlias: "Course Presentation",
     description: "Multi-slide presentation with keyboard navigation.",
     allowedChildTypes: [...SLIDE_DECK_ALLOWED_CHILD_TYPES],
-    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH2.SlideDeck,
+    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.SlideDeck,
     props: [
       { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
       { name: "title", type: "string", required: true, description: "Deck title." },
@@ -4353,6 +498,121 @@ var v3CompoundAndContentEntries = [
     theming: { surface: "global-inherit", stylingNotes: "Deck chrome." },
     telemetry: { emits: ["slide_viewed"], requiresActiveLesson: true }
   },
+  {
+    type: "TimedCue",
+    category: "container",
+    compoundContract: true,
+    h5pMachineName: "H5P.InteractiveVideo",
+    h5pAlias: "Interactive Video timed cue",
+    description: "Timed overlay cue within InteractiveVideo.",
+    allowedChildTypes: [...TIMED_CUE_ALLOWED_CHILD_TYPES],
+    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.TimedCue,
+    props: [
+      { name: "atSeconds", type: "number", required: true, description: "Cue time in seconds." },
+      { name: "label", type: "string", required: false, description: "Cue label." },
+      { name: "mustComplete", type: "boolean", required: false, description: "Block seek until completed." },
+      { name: "children", type: "ReactNode", required: true, description: "Single allowed child block." }
+    ],
+    requiredIds: [],
+    parentConstraints: ["InteractiveVideo"],
+    a11y: { element: "dialog", ariaLabel: "Timed cue", keyboard: "Focus moves to overlay content.", notes: "Pauses parent video." },
+    theming: { surface: "global-inherit", stylingNotes: "Overlay panel." },
+    telemetry: { emits: [] }
+  },
+  {
+    type: "InteractiveVideo",
+    category: "container",
+    compoundContract: true,
+    h5pMachineName: "H5P.InteractiveVideo",
+    h5pAlias: "Interactive Video",
+    description: "Video with timed interaction overlays.",
+    allowedChildTypes: [...INTERACTIVE_VIDEO_ALLOWED_CHILD_TYPES],
+    maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.InteractiveVideo,
+    props: [
+      { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
+      { name: "title", type: "string", required: true, description: "Video title." },
+      { name: "src", type: "string", required: true, description: "Video URL." },
+      { name: "poster", type: "string", required: false, description: "Poster image." },
+      { name: "captions", type: "string", required: false, description: "WebVTT captions." },
+      { name: "showVideoScore", type: "boolean", required: false, description: "Show aggregate score." },
+      { name: "children", type: "TimedCue[]", required: true, description: "Timed cues." }
+    ],
+    requiredIds: ["blockId"],
+    parentConstraints: ["Lesson"],
+    a11y: {
+      element: "section",
+      ariaLabel: "Interactive video",
+      keyboard: "Native video controls; overlay interactions when paused.",
+      notes: "H5P Interactive Video equivalent."
+    },
+    theming: { surface: "global-inherit", stylingNotes: "Video + overlay." },
+    telemetry: { emits: ["video_cue_reached", "video_segment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "Questionnaire",
+    category: "content",
+    h5pMachineName: "H5P.Questionnaire",
+    h5pAlias: "Questionnaire",
+    description: "Unscored multi-field survey.",
+    props: [
+      { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
+      { name: "fields", type: "QuestionnaireField[]", required: true, description: "Form fields." }
+    ],
+    requiredIds: ["blockId"],
+    parentConstraints: [...COMPOUND_PARENTS],
+    a11y: { element: "form", ariaLabel: "Questionnaire", keyboard: "Tab through fields.", notes: "Unscored survey." },
+    theming: { surface: "global-inherit", stylingNotes: "Form layout." },
+    telemetry: { emits: ["questionnaire_submitted"], requiresActiveLesson: true }
+  },
+  {
+    type: "MemoryGame",
+    category: "content",
+    h5pMachineName: "H5P.MemoryGame",
+    h5pAlias: "Memory Game",
+    description: "Card flip memory matching game.",
+    props: [
+      { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
+      { name: "pairs", type: "MemoryPair[]", required: true, description: "Card pairs." },
+      { name: "selfScore", type: "boolean", required: false, description: "Optional self-score mode." }
+    ],
+    requiredIds: ["blockId"],
+    parentConstraints: [...COMPOUND_PARENTS],
+    a11y: { element: "section", ariaLabel: "Memory game", keyboard: "Flip cards with buttons.", notes: "Reduced motion safe." },
+    theming: { surface: "global-inherit", stylingNotes: "Card grid." },
+    telemetry: { emits: ["memory_card_flipped"] }
+  },
+  {
+    type: "InformationWall",
+    category: "content",
+    h5pMachineName: "H5P.InformationWall",
+    h5pAlias: "Information Wall",
+    description: "Searchable information panels.",
+    props: [
+      { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
+      { name: "panels", type: "InformationPanel[]", required: true, description: "Content panels." }
+    ],
+    requiredIds: ["blockId"],
+    parentConstraints: [...COMPOUND_PARENTS],
+    a11y: { element: "section", ariaLabel: "Information wall", keyboard: "Search and browse panels.", notes: "Filterable grid." },
+    theming: { surface: "global-inherit", stylingNotes: "Panel grid." },
+    telemetry: { emits: ["information_wall_search"] }
+  },
+  {
+    type: "ParallaxSlideshow",
+    category: "content",
+    h5pMachineName: "H5P.ImpressivePresentation",
+    h5pAlias: "Slideshow (parallax)",
+    description: "Slideshow with parallax; static fallback when reduced motion.",
+    props: [
+      { name: "blockId", type: "BlockId", required: true, description: "Stable block id." },
+      { name: "slides", type: "ParallaxSlide[]", required: true, description: "Slides." }
+    ],
+    requiredIds: ["blockId"],
+    parentConstraints: [...COMPOUND_PARENTS],
+    a11y: { element: "section", ariaLabel: "Slideshow", keyboard: "Previous/next slide.", notes: "prefers-reduced-motion fallback." },
+    theming: { surface: "global-inherit", stylingNotes: "Slide deck." },
+    telemetry: { emits: ["parallax_slide_viewed"] }
+  },
   {
     type: "Accordion",
     category: "content",
@@ -4487,7 +747,7 @@ function buildV3CatalogFromV2(v2) {
         ...base,
         compoundContract: true,
         allowedChildTypes: [...ASSESSMENT_SEQUENCE_ALLOWED_CHILD_TYPES],
-        maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH2.AssessmentSequence
+        maxNestingDepth: COMPOUND_MAX_NESTING_DEPTH.AssessmentSequence
       };
     }
     return base;
@@ -4834,6 +1094,100 @@ var v2AssessmentEntries = [
     },
     theming: { surface: "global-inherit", stylingNotes: "Container for assessments." },
     telemetry: { emits: [], manualTracking: "Child assessments emit assessment_* events." }
+  },
+  {
+    type: "Summary",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.Summary",
+    h5pAlias: "Summary",
+    description: "Construct a summary from a statement bank in correct order.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "statements", type: "string[]", required: true, description: "Available statements." },
+      { name: "correct", type: "string[]", required: true, description: "Correct ordered summary." },
+      ...assessmentBehaviourProps2
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence", "TimedCue"],
+    a11y: { element: "section", ariaLabel: "Summary", keyboard: "Select statements in order.", notes: "H5P Summary equivalent." },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "ImagePairing",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.ImagePair",
+    h5pAlias: "Image Pairing",
+    description: "Match image pairs in a memory-style task.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "pairs", type: "ImagePair[]", required: true, description: "Image pairs to match." },
+      ...assessmentBehaviourProps2
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence", "TimedCue"],
+    a11y: { element: "section", ariaLabel: "Image Pairing", keyboard: "Select two cards to match.", notes: "H5P Image Pairing equivalent." },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "ImageSequencing",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.ImageSequencing",
+    h5pAlias: "Image Sequencing",
+    description: "Order images in the correct sequence.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "images", type: "SequencingImage[]", required: true, description: "Images to order." },
+      { name: "correctOrder", type: "string[]", required: true, description: "Correct id order." },
+      ...assessmentBehaviourProps2
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence", "TimedCue"],
+    a11y: { element: "section", ariaLabel: "Image Sequencing", keyboard: "Reorder with up/down.", notes: "H5P Image Sequencing equivalent." },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "ArithmeticQuiz",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.ArithmeticQuiz",
+    h5pAlias: "Arithmetic Quiz",
+    description: "Timed arithmetic problems with optional timer.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "problems", type: "ArithmeticProblem[]", required: true, description: "Math problems." },
+      { name: "timeLimitSeconds", type: "number", required: false, description: "Optional time limit." },
+      ...assessmentBehaviourProps2
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence", "TimedCue"],
+    a11y: { element: "section", ariaLabel: "Arithmetic Quiz", keyboard: "Text input per problem.", notes: "H5P Arithmetic Quiz equivalent." },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
+  },
+  {
+    type: "Essay",
+    category: "assessment",
+    assessmentContract: true,
+    h5pMachineName: "H5P.Essay",
+    h5pAlias: "Essay",
+    description: "Open text response; manual or plugin grading.",
+    props: [
+      { name: "checkId", type: "CheckId", required: true, description: "Stable check id." },
+      { name: "question", type: "string", required: true, description: "Essay prompt." },
+      { name: "minLength", type: "number", required: false, description: "Minimum character length." },
+      ...assessmentBehaviourProps2
+    ],
+    requiredIds: ["checkId"],
+    parentConstraints: ["Lesson", "AssessmentSequence", "TimedCue"],
+    a11y: { element: "section", ariaLabel: "Essay", keyboard: "Textarea input.", notes: "H5P Essay equivalent." },
+    theming: { surface: "global-inherit", dataAttributes: ["data-lk-check-id"], stylingNotes: "Uses data-lk-check-id." },
+    telemetry: { emits: ["assessment_answered", "assessment_completed"], requiresActiveLesson: true }
   }
 ];
 var BLOCK_CATALOG_V2 = [
@@ -4872,6 +1226,7 @@ function getBlockCatalogEntry(type, opts) {
 }
 export {
   Accordion,
+  ArithmeticQuiz,
   AssessmentSequence,
   BLOCK_CATALOG,
   BLOCK_CATALOG_V2,
@@ -4880,6 +1235,7 @@ export {
   DialogCards,
   DragAndDrop,
   DragTheWords,
+  Essay,
   FillInTheBlanks,
   FindHotspot,
   FindMultipleHotspots,
@@ -4887,36 +1243,48 @@ export {
   Heading,
   Image,
   ImageHotspots,
+  ImagePairing,
+  ImageSequencing,
   ImageSlider,
+  InformationWall,
   InteractiveBook,
+  InteractiveVideo,
   KnowledgeCheck,
   Lesson,
   LessonkitProvider,
   MarkTheWords,
+  MemoryGame,
   Page,
+  ParallaxSlideshow,
   ProgressTracker,
+  Questionnaire,
   Quiz,
   Reflection,
   Scenario,
   Slide,
   SlideDeck,
+  Summary,
   Text,
   ThemeProvider,
+  TimedCue,
   TrueFalse,
+  Video,
+  assertProductionCourseConfig,
   blockCatalogV2Version,
   blockCatalogV3Version,
   blockCatalogVersion,
   buildBlockCatalog,
-  buildTelemetryEvent2 as buildTelemetryEvent,
-  createLessonkitRuntime2 as createLessonkitRuntime,
-  createPluginRegistry2 as createPluginRegistry,
-  createTelemetryPipeline2 as createTelemetryPipeline,
+  buildTelemetryEvent,
+  createLessonkitRuntime,
+  createPluginRegistry,
+  createTelemetryPipeline,
   defineAssessmentPlugin,
   defineLifecyclePlugin,
   defineTelemetryPlugin,
   getBlockCatalogEntry,
   resetAssessmentWarningsForTests,
   resetQuizWarningsForTests,
+  shouldEnforceProductionGuard,
   useAssessmentState,
   useCompletion,
   useLessonkit,