@lessonkit/react 1.3.1 → 1.5.0

package/dist/testing.cjs

@@ -0,0 +1,576 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  resetAssessmentWarningsForTests: () => resetAssessmentWarningsForTests,
+  resetCompoundValidationWarningsForTests: () => resetCompoundValidationWarningsForTests,
+  resetCourseStartedTrackingFlightForTests: () => resetCourseStartedTrackingFlightForTests,
+  resetLessonMountRegistryForTests: () => resetLessonMountRegistryForTests,
+  resetLessonkitProviderStorageForTests: () => resetLessonkitProviderStorageForTests,
+  resetQuizWarningsForTests: () => resetQuizWarningsForTests
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/components/Quiz.tsx
+var import_react12 = require("react");
+var import_accessibility = require("@lessonkit/accessibility");
+
+// src/assessment/AssessmentLessonGuard.tsx
+var import_react2 = require("react");
+
+// src/lessonContext.tsx
+var import_react = require("react");
+var LessonContext = (0, import_react.createContext)(void 0);
+function useEnclosingLessonId() {
+  return (0, import_react.useContext)(LessonContext);
+}
+
+// src/runtime/validateComponentId.ts
+var import_core = require("@lessonkit/core");
+function isDevEnvironment() {
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
+}
+function normalizeComponentId(id, path) {
+  if (path === "courseId") return (0, import_core.assertValidId)(id, "courseId");
+  if (path === "lessonId") return (0, import_core.assertValidId)(id, "lessonId");
+  if (path === "checkId") return (0, import_core.assertValidId)(id, "checkId");
+  if (path === "blockId") return (0, import_core.assertValidId)(id, "blockId");
+  return (0, import_core.assertValidId)(id, path);
+}
+
+// src/assessment/AssessmentLessonGuard.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var warnedAssessmentOutsideLesson = false;
+function resetAssessmentWarningsForTests() {
+  warnedAssessmentOutsideLesson = false;
+}
+function AssessmentLessonGuard(props) {
+  const enclosingLessonId = useEnclosingLessonId();
+  const missingLesson = enclosingLessonId === void 0;
+  (0, import_react2.useEffect)(() => {
+    if (!missingLesson || isDevEnvironment()) return;
+    if (!warnedAssessmentOutsideLesson) {
+      warnedAssessmentOutsideLesson = true;
+      console.error(
+        `[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>; assessment telemetry will not be emitted.`
+      );
+    }
+  }, [missingLesson, props.blockLabel]);
+  if (missingLesson && isDevEnvironment()) {
+    throw new Error(`[lessonkit] <${props.blockLabel}> must be wrapped in <Lesson>`);
+  }
+  if (missingLesson) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("section", { role: "alert", "aria-label": `${props.blockLabel} configuration error`, "data-lk-check-id": props.checkId, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("p", { children: [
+      props.blockLabel,
+      " must be placed inside a Lesson."
+    ] }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: props.children(enclosingLessonId) });
+}
+
+// src/assessment/internal/buildAssessmentHandle.ts
+function buildAssessmentHandle(opts) {
+  return {
+    getScore: opts.getScore,
+    getMaxScore: opts.getMaxScore,
+    getAnswerGiven: opts.getAnswerGiven,
+    resetTask: opts.resetTask,
+    showSolutions: opts.showSolutions,
+    getXAPIData: opts.getXAPIData,
+    ...opts.getCurrentState ? { getCurrentState: opts.getCurrentState } : {},
+    ...opts.resume ? { resume: opts.resume } : {}
+  };
+}
+
+// src/assessment/internal/resumeState.ts
+function readBooleanField(state, key) {
+  const value = state[key];
+  if (value === true || value === false || value === null) return value;
+  return void 0;
+}
+function readStringField(state, key) {
+  const value = state[key];
+  if (typeof value === "string" || value === null) return value;
+  return void 0;
+}
+function readNumberField(state, key) {
+  const value = state[key];
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (value === null) return null;
+  return void 0;
+}
+
+// src/assessment/internal/useAssessmentHandleRegistration.ts
+var import_react6 = require("react");
+
+// src/compound/CompoundProvider.tsx
+var import_react5 = __toESM(require("react"), 1);
+var import_core2 = require("@lessonkit/core");
+
+// src/compound/CompoundHydrationBridge.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var CompoundHydrationBridgeContext = (0, import_react3.createContext)(
+  null
+);
+
+// src/compound/CompoundPageIndexContext.tsx
+var import_react4 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var CompoundPageIndexContext = (0, import_react4.createContext)(void 0);
+function useCompoundPageIndex() {
+  return (0, import_react4.useContext)(CompoundPageIndexContext);
+}
+
+// src/compound/CompoundProvider.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var CompoundRegistryContext = (0, import_react5.createContext)(null);
+var CompoundHandlesVersionContext = (0, import_react5.createContext)(0);
+function useRegisterAssessmentHandle(checkId, handle) {
+  const registry = (0, import_react5.useContext)(CompoundRegistryContext);
+  const pageIndex = useCompoundPageIndex();
+  import_react5.default.useLayoutEffect(() => {
+    if (!registry || !handle) return;
+    return registry.register(checkId, handle, pageIndex);
+  }, [registry, checkId, handle, pageIndex]);
+}
+
+// src/assessment/internal/useAssessmentHandleRegistration.ts
+function useAssessmentHandleRegistration(checkId, handle, ref) {
+  (0, import_react6.useImperativeHandle)(ref, () => handle, [handle]);
+  useRegisterAssessmentHandle(checkId, handle);
+}
+
+// src/assessment/internal/usePluginScoring.ts
+var import_react11 = require("react");
+
+// src/hooks.ts
+var import_react10 = require("react");
+
+// src/context.tsx
+var import_react8 = require("react");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var import_react7 = require("react");
+var import_core10 = require("@lessonkit/core");
+
+// src/runtime/observability.ts
+var import_xapi = require("@lessonkit/xapi");
+
+// src/runtime/emitTelemetry.ts
+var import_core4 = require("@lessonkit/core");
+
+// src/runtime/telemetryPipeline.ts
+var import_core3 = require("@lessonkit/core");
+var import_xapi2 = require("@lessonkit/xapi");
+
+// src/runtime/lxpackBridge.ts
+var import_bridge = require("@lessonkit/lxpack/bridge");
+
+// src/runtime/courseStartedPipeline.ts
+var import_xapi3 = require("@lessonkit/xapi");
+
+// src/runtime/plugins.ts
+var import_core5 = require("@lessonkit/core");
+function buildPluginContext(opts) {
+  return (0, import_core5.buildPluginContext)(opts);
+}
+
+// src/runtime/session.ts
+var import_core6 = require("@lessonkit/core");
+
+// src/provider/courseStarted/emit.ts
+function createCourseStartedFlightScope() {
+  return {
+    trackingFlights: /* @__PURE__ */ new Map(),
+    emitFlights: /* @__PURE__ */ new Map()
+  };
+}
+var defaultFlightScope = createCourseStartedFlightScope();
+function resetCourseStartedTrackingFlightForTests() {
+  defaultFlightScope.trackingFlights.clear();
+  defaultFlightScope.emitFlights.clear();
+}
+
+// src/provider/useLessonkitProviderRuntime.ts
+var import_xapi5 = require("@lessonkit/xapi");
+
+// src/runtime/ports.ts
+var import_core7 = require("@lessonkit/core");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var import_core11 = require("@lessonkit/core");
+
+// src/runtime/progress.ts
+var import_core8 = require("@lessonkit/core");
+
+// src/runtime/xapi.ts
+var import_xapi4 = require("@lessonkit/xapi");
+
+// src/runtime/telemetry.ts
+var import_core9 = require("@lessonkit/core");
+
+// src/provider/useLessonkitProviderRuntime.ts
+var providerStoragesForTests = /* @__PURE__ */ new Set();
+function resetLessonkitProviderStorageForTests() {
+  for (const storage of providerStoragesForTests) {
+    (0, import_core7.resetStoragePortForTests)(storage);
+  }
+  providerStoragesForTests.clear();
+  (0, import_core11.resetSharedVolatileSessionIdForTests)();
+}
+
+// src/context.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var LessonkitContext = (0, import_react8.createContext)(null);
+
+// src/assessment/useAssessmentState.ts
+var import_react9 = require("react");
+
+// src/hooks.ts
+function useLessonkit() {
+  const ctx = (0, import_react10.useContext)(LessonkitContext);
+  if (!ctx) throw new Error("LessonKit: missing LessonkitProvider");
+  return ctx;
+}
+function useQuizState(enclosingLessonId) {
+  const { track } = useLessonkit();
+  const trackOpts = enclosingLessonId ? { lessonId: enclosingLessonId } : void 0;
+  return (0, import_react10.useMemo)(
+    () => ({
+      answer: (opts) => {
+        track("quiz_answered", opts, trackOpts);
+      },
+      complete: (opts) => {
+        track("quiz_completed", opts, trackOpts);
+      }
+    }),
+    [track, enclosingLessonId]
+  );
+}
+
+// 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;
+  const hasNumericScore = custom?.score != null && Number.isFinite(custom.score);
+  if (hasNumericScore) {
+    const passed2 = custom.passed !== void 0 ? custom.passed : meetsPassingThreshold(custom.score, maxScore, passingScore);
+    return { score: custom.score, maxScore, passed: passed2 };
+  }
+  if (custom?.passed !== void 0) {
+    const score2 = custom.passed ? maxScore : 0;
+    return { score: score2, maxScore, passed: custom.passed };
+  }
+  const score = fallbackCorrect ? maxScore : 0;
+  const passed = meetsPassingThreshold(score, maxScore, passingScore);
+  return { score, maxScore, passed };
+}
+
+// src/assessment/internal/usePluginScoring.ts
+function usePluginScoring(checkId, lessonId) {
+  const { plugins, config, session } = useLessonkit();
+  const getPluginScore = (0, import_react11.useCallback)(
+    (response) => {
+      const pluginCtx = buildPluginContext({
+        courseId: config.courseId,
+        sessionId: session.sessionId,
+        attemptId: session.attemptId,
+        user: session.user
+      });
+      return plugins?.scoreAssessment({ checkId, lessonId, response }, pluginCtx) ?? null;
+    },
+    [checkId, config.courseId, lessonId, plugins, session.attemptId, session.sessionId, session.user]
+  );
+  const scoreResponse = (0, import_react11.useCallback)(
+    (response, defaultCorrect, maxScore = 1, passingScore) => scoreFromCustom(getPluginScore(response), defaultCorrect, maxScore, passingScore),
+    [getPluginScore]
+  );
+  const isChoiceCorrect = (0, import_react11.useCallback)(
+    (choice, answer, custom, passingScore) => {
+      if (!custom) return choice === answer;
+      if (custom.passed !== void 0) return custom.passed;
+      if (custom.maxScore != null && custom.maxScore > 0 && custom.score != null) {
+        return meetsPassingThreshold(custom.score, custom.maxScore, passingScore);
+      }
+      return choice === answer;
+    },
+    []
+  );
+  return { getPluginScore, scoreResponse, isChoiceCorrect };
+}
+
+// src/components/Quiz.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function QuizInner(props, ref) {
+  const { enclosingLessonId } = props;
+  const checkId = (0, import_react12.useMemo)(() => normalizeComponentId(props.checkId, "checkId"), [props.checkId]);
+  const quiz = useQuizState(enclosingLessonId);
+  const { config } = useLessonkit();
+  const { scoreResponse } = usePluginScoring(checkId, enclosingLessonId);
+  const [selected, setSelected] = (0, import_react12.useState)(null);
+  const [selectionCorrect, setSelectionCorrect] = (0, import_react12.useState)(null);
+  const [quizPassed, setQuizPassed] = (0, import_react12.useState)(false);
+  const [completedScore, setCompletedScore] = (0, import_react12.useState)(null);
+  const [completedMaxScore, setCompletedMaxScore] = (0, import_react12.useState)(null);
+  const completedRef = (0, import_react12.useRef)(false);
+  const telemetryReplayedRef = (0, import_react12.useRef)(false);
+  const questionId = (0, import_react12.useId)();
+  const choicesKey = props.choices.join("\0");
+  (0, import_react12.useEffect)(() => {
+    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 = (0, import_react12.useMemo)(
+    () => 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 && config.tracking?.replayResumeEvents === true) {
+            const maxScore = nextCompletedMaxScore ?? 1;
+            const score = nextCompletedScore ?? (nextPassed ? maxScore : 0);
+            replayTelemetry(
+              nextSelected ?? null,
+              nextCorrect ?? null,
+              nextPassed,
+              score,
+              maxScore
+            );
+          }
+        }
+      }
+    }),
+    [
+      checkId,
+      completedMaxScore,
+      completedScore,
+      config.tracking?.replayResumeEvents,
+      props.passingScore,
+      props.question,
+      quiz,
+      quizPassed,
+      selected,
+      selectionCorrect
+    ]
+  );
+  useAssessmentHandleRegistration(checkId, handle, ref);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("section", { "aria-label": "Quiz", "data-lk-check-id": checkId, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { id: questionId, children: props.question }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("fieldset", { "aria-labelledby": questionId, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("legend", { style: import_accessibility.visuallyHiddenStyle, children: "Quiz choices" }),
+      props.choices.map((c, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("label", { style: { display: "block" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          "input",
+          {
+            type: "radio",
+            name: questionId,
+            value: c,
+            checked: selected === c,
+            disabled: passed && !props.enableRetry,
+            "aria-invalid": selected === c && selectionCorrect === false ? true : void 0,
+            onChange: () => {
+              if (passed && !props.enableRetry) return;
+              setSelected(c);
+              const defaultCorrect = c === props.answer;
+              const scored = scoreResponse(c, defaultCorrect, 1, props.passingScore);
+              setSelectionCorrect(scored.passed);
+              quiz.answer({
+                checkId,
+                question: props.question,
+                choice: c,
+                correct: scored.passed
+              });
+              if (scored.passed && !completedRef.current) {
+                completedRef.current = true;
+                setQuizPassed(true);
+                setCompletedScore(scored.score);
+                setCompletedMaxScore(scored.maxScore);
+                quiz.complete({
+                  checkId,
+                  score: scored.score,
+                  maxScore: scored.maxScore,
+                  passingScore: props.passingScore ?? scored.maxScore
+                });
+              } else if (!scored.passed && props.enableRetry === false && !completedRef.current) {
+                completedRef.current = true;
+                setCompletedScore(scored.score);
+                setCompletedMaxScore(scored.maxScore);
+                quiz.complete({
+                  checkId,
+                  score: scored.score,
+                  maxScore: scored.maxScore,
+                  passingScore: props.passingScore ?? scored.maxScore
+                });
+              }
+            }
+          }
+        ),
+        c
+      ] }, `${questionId}-${i}`))
+    ] }),
+    selected && selectionCorrect !== null ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { role: "status", "aria-live": "polite", children: selectionCorrect ? "Correct" : "Try again" }) : null,
+    props.enableRetry && passed ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      "button",
+      {
+        type: "button",
+        "data-testid": "quiz-retry",
+        onClick: () => {
+          completedRef.current = false;
+          telemetryReplayedRef.current = false;
+          setQuizPassed(false);
+          setSelected(null);
+          setSelectionCorrect(null);
+          setCompletedScore(null);
+          setCompletedMaxScore(null);
+        },
+        children: "Try again"
+      }
+    ) : null
+  ] });
+}
+var QuizInnerForwarded = (0, import_react12.forwardRef)(QuizInner);
+var Quiz = (0, import_react12.forwardRef)(function Quiz2(props, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(AssessmentLessonGuard, { blockLabel: "Quiz", checkId: props.checkId, children: (lessonId) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(QuizInnerForwarded, { ...props, enclosingLessonId: lessonId, ref }) });
+});
+function resetQuizWarningsForTests() {
+  resetAssessmentWarningsForTests();
+}
+
+// src/runtime/lessonMountRegistry.ts
+var mountCounts = /* @__PURE__ */ new Map();
+var warnedConcurrentLessons = false;
+function resetLessonMountRegistryForTests() {
+  mountCounts.clear();
+  warnedConcurrentLessons = false;
+}
+
+// src/compound/validateChildren.ts
+var import_react13 = __toESM(require("react"), 1);
+var import_core12 = require("@lessonkit/core");
+var warnedPairs = /* @__PURE__ */ new Set();
+function resetCompoundValidationWarningsForTests() {
+  warnedPairs.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resetAssessmentWarningsForTests,
+  resetCompoundValidationWarningsForTests,
+  resetCourseStartedTrackingFlightForTests,
+  resetLessonMountRegistryForTests,
+  resetLessonkitProviderStorageForTests,
+  resetQuizWarningsForTests
+});

package/dist/testing.d.cts

@@ -0,0 +1,16 @@
+export { r as resetAssessmentWarningsForTests, a as resetQuizWarningsForTests } from './AssessmentLessonGuard-BzNPbjaV.cjs';
+import '@lessonkit/core';
+import 'react';
+
+/** Reset registry state between tests. */
+declare function resetLessonMountRegistryForTests(): void;
+
+/** @internal Reset dev warnings between tests. */
+declare function resetCompoundValidationWarningsForTests(): void;
+
+/** @internal Reset in-flight course_started tracking guard between tests. */
+declare function resetCourseStartedTrackingFlightForTests(): void;
+
+declare function resetLessonkitProviderStorageForTests(): void;
+
+export { resetCompoundValidationWarningsForTests, resetCourseStartedTrackingFlightForTests, resetLessonMountRegistryForTests, resetLessonkitProviderStorageForTests };

package/dist/testing.d.ts

@@ -0,0 +1,16 @@
+export { r as resetAssessmentWarningsForTests, a as resetQuizWarningsForTests } from './AssessmentLessonGuard-BzNPbjaV.js';
+import '@lessonkit/core';
+import 'react';
+
+/** Reset registry state between tests. */
+declare function resetLessonMountRegistryForTests(): void;
+
+/** @internal Reset dev warnings between tests. */
+declare function resetCompoundValidationWarningsForTests(): void;
+
+/** @internal Reset in-flight course_started tracking guard between tests. */
+declare function resetCourseStartedTrackingFlightForTests(): void;
+
+declare function resetLessonkitProviderStorageForTests(): void;
+
+export { resetCompoundValidationWarningsForTests, resetCourseStartedTrackingFlightForTests, resetLessonMountRegistryForTests, resetLessonkitProviderStorageForTests };

package/dist/testing.js

@@ -0,0 +1,18 @@
+import {
+  resetLessonMountRegistryForTests,
+  resetQuizWarningsForTests
+} from "./chunk-ELGQ4XI3.js";
+import {
+  resetAssessmentWarningsForTests,
+  resetCompoundValidationWarningsForTests,
+  resetCourseStartedTrackingFlightForTests,
+  resetLessonkitProviderStorageForTests
+} from "./chunk-7TJQJFYR.js";
+export {
+  resetAssessmentWarningsForTests,
+  resetCompoundValidationWarningsForTests,
+  resetCourseStartedTrackingFlightForTests,
+  resetLessonMountRegistryForTests,
+  resetLessonkitProviderStorageForTests,
+  resetQuizWarningsForTests
+};