@lessonkit/core 1.2.0 → 1.3.1

package/dist/index.cjs

@@ -29,6 +29,8 @@ __export(index_exports, {
   INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES: () => INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES,
   PAGE_ALLOWED_CHILD_TYPES: () => PAGE_ALLOWED_CHILD_TYPES,
   SESSION_STORAGE_KEY: () => SESSION_STORAGE_KEY,
+  SLIDE_ALLOWED_CHILD_TYPES: () => SLIDE_ALLOWED_CHILD_TYPES,
+  SLIDE_DECK_ALLOWED_CHILD_TYPES: () => SLIDE_DECK_ALLOWED_CHILD_TYPES,
   TELEMETRY_EVENT_CATALOG: () => TELEMETRY_EVENT_CATALOG,
   TELEMETRY_EVENT_CATALOG_V2: () => TELEMETRY_EVENT_CATALOG_V2,
   TELEMETRY_EVENT_CATALOG_V3: () => TELEMETRY_EVENT_CATALOG_V3,
@@ -79,6 +81,7 @@ __export(index_exports, {
   parseCompoundResumeState: () => parseCompoundResumeState,
   parseCourseId: () => parseCourseId,
   parseLessonId: () => parseLessonId,
+  resetSharedVolatileSessionIdForTests: () => resetSharedVolatileSessionIdForTests,
   resetStoragePortForTests: () => resetStoragePortForTests,
   resetTelemetryBuilderWarningsForTests: () => resetTelemetryBuilderWarningsForTests,
   resolveSessionId: () => resolveSessionId,
@@ -155,21 +158,40 @@ function assertValidId(input, path = "id") {
 }
 
 // src/slugify.ts
+function shortHash(input) {
+  let h = 0;
+  for (let i = 0; i < input.length; i++) {
+    h = Math.imul(31, h) + input.charCodeAt(i) >>> 0;
+  }
+  return h.toString(36);
+}
+function uniqueFallbackId(input, usedIds) {
+  const hash = shortHash(input);
+  for (let n = 0; n < 100; n++) {
+    const candidate = (n === 0 ? `id-${hash}` : `id-${hash}-${n}`).slice(0, 64);
+    const validated2 = validateId(candidate);
+    if (validated2.ok && !usedIds.has(validated2.id)) return validated2.id;
+  }
+  const timed = `id-${hash}-${Date.now().toString(36)}`.slice(0, 64);
+  const validated = validateId(timed);
+  return validated.ok ? validated.id : `id-${hash}`;
+}
 function slugifyId(input) {
   const slug = input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").slice(0, 64);
-  if (!slug.length) return "id";
-  const candidate = /^[a-z]/.test(slug) ? slug : `id-${slug}`;
+  if (!slug.length) return uniqueFallbackId(input, /* @__PURE__ */ new Set());
+  const candidate = /^[a-z]/.test(slug) ? slug : `id-${slug}`.slice(0, 64);
   const validated = validateId(candidate);
-  return validated.ok ? validated.id : "id";
+  return validated.ok ? validated.id : uniqueFallbackId(input, /* @__PURE__ */ new Set());
 }
 function deriveId(title, usedIds = /* @__PURE__ */ new Set()) {
   const base = slugifyId(title);
-  if (!usedIds.has(base)) return base;
+  if (!usedIds.has(base) && validateId(base).ok) return base;
   for (let n = 2; n < 1e3; n++) {
-    const candidate = `${base}-${n}`;
-    if (!usedIds.has(candidate)) return candidate;
+    const candidate = `${base}-${n}`.slice(0, 64);
+    const validated = validateId(candidate);
+    if (validated.ok && !usedIds.has(validated.id)) return validated.id;
   }
-  return `${base}-${Date.now()}`;
+  return uniqueFallbackId(`${title}-${Date.now()}`, usedIds);
 }
 
 // src/urn.ts
@@ -217,6 +239,27 @@ function clampCompoundPageIndex(index, pageCount) {
   if (pageCount < 1) return 0;
   return Math.min(Math.max(0, Math.floor(index)), pageCount - 1);
 }
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isPlainStringKeyMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.entries(value).every(
+    ([key, entry]) => typeof key === "string" && isJsonPrimitive(entry)
+  );
+}
+function isValidChildResumeValue(value) {
+  if (isJsonPrimitive(value)) return true;
+  if (Array.isArray(value)) return value.every((item) => isJsonPrimitive(item));
+  if (isPlainStringKeyMap(value)) return true;
+  return false;
+}
+function isPlainSerializableChildState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every(
+    (entry) => isValidChildResumeValue(entry)
+  );
+}
 function parseCompoundResumeState(raw) {
   if (!raw || typeof raw !== "object") return null;
   const obj = raw;
@@ -225,7 +268,7 @@ function parseCompoundResumeState(raw) {
   const childStates = {};
   if (obj.childStates && typeof obj.childStates === "object" && !Array.isArray(obj.childStates)) {
     for (const [key, value] of Object.entries(obj.childStates)) {
-      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      if (isPlainSerializableChildState(value)) {
         childStates[key] = value;
       }
     }
@@ -239,22 +282,40 @@ function parseCompoundResumeState(raw) {
   };
 }
 
+// src/internal/env.ts
+function isDevEnvironment() {
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
+}
+function warnDev(message, err) {
+  if (!isDevEnvironment()) return;
+  console.warn(message, err instanceof Error ? err.message : err);
+}
+
 // src/compoundState.ts
 var COMPOUND_STATE_PREFIX = "lessonkit:compound:";
 function compoundStateStorageKey(courseId, compoundId) {
   return `${COMPOUND_STATE_PREFIX}${courseId}:${compoundId}`;
 }
 function loadCompoundState(storage, courseId, compoundId) {
-  const raw = storage.getItem(compoundStateStorageKey(courseId, compoundId));
+  const key = compoundStateStorageKey(courseId, compoundId);
+  const raw = storage.getItem(key);
   if (!raw) return null;
   try {
-    return parseCompoundResumeState(JSON.parse(raw));
+    const parsed = parseCompoundResumeState(JSON.parse(raw));
+    if (parsed === null && isDevEnvironment()) {
+      console.warn(`[lessonkit] Ignoring corrupt compound resume state at ${key}`);
+    }
+    return parsed;
   } catch {
+    if (isDevEnvironment()) {
+      console.warn(`[lessonkit] Ignoring corrupt compound resume state at ${key}`);
+    }
     return null;
   }
 }
 function saveCompoundState(storage, courseId, compoundId, state) {
-  storage.setItem(compoundStateStorageKey(courseId, compoundId), JSON.stringify(state));
+  return storage.setItem(compoundStateStorageKey(courseId, compoundId), JSON.stringify(state));
 }
 function clearCompoundState(storage, courseId, compoundId) {
   storage.removeItem?.(compoundStateStorageKey(courseId, compoundId));
@@ -284,6 +345,28 @@ var PAGE_ALLOWED_CHILD_TYPES = [
   "ProgressTracker"
 ];
 var INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES = ["Page"];
+var SLIDE_ALLOWED_CHILD_TYPES = [
+  "Text",
+  "Heading",
+  "Image",
+  "Scenario",
+  "Reflection",
+  "Quiz",
+  "KnowledgeCheck",
+  "TrueFalse",
+  "FillInTheBlanks",
+  "DragAndDrop",
+  "DragTheWords",
+  "MarkTheWords",
+  "Accordion",
+  "DialogCards",
+  "Flashcards",
+  "ImageHotspots",
+  "FindHotspot",
+  "FindMultipleHotspots",
+  "ImageSlider"
+];
+var SLIDE_DECK_ALLOWED_CHILD_TYPES = ["Slide"];
 var ASSESSMENT_SEQUENCE_ALLOWED_CHILD_TYPES = [
   "TrueFalse",
   "FillInTheBlanks",
@@ -298,11 +381,15 @@ var ASSESSMENT_SEQUENCE_ALLOWED_CHILD_TYPES = [
 var ALLOWLISTS = {
   Page: PAGE_ALLOWED_CHILD_TYPES,
   InteractiveBook: INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES,
+  Slide: SLIDE_ALLOWED_CHILD_TYPES,
+  SlideDeck: SLIDE_DECK_ALLOWED_CHILD_TYPES,
   AssessmentSequence: ASSESSMENT_SEQUENCE_ALLOWED_CHILD_TYPES
 };
 var COMPOUND_MAX_NESTING_DEPTH = {
   Page: 1,
   InteractiveBook: 2,
+  Slide: 1,
+  SlideDeck: 2,
   AssessmentSequence: 1
 };
 function getAllowedChildTypes(parent) {
@@ -420,6 +507,14 @@ var TELEMETRY_EVENT_CATALOG_V3 = [
     xapiVerb: "http://adlnet.gov/expapi/verbs/experienced",
     urnPattern: "urn:lessonkit:course:{courseId}:lesson:{lessonId}:block:{blockId}"
   },
+  {
+    name: "slide_viewed",
+    description: "Learner viewed a slide in a SlideDeck (Course Presentation)",
+    requiredFields: ["courseId", "lessonId", "sessionId", "timestamp"],
+    dataFields: ["blockId", "slideIndex", "slideTitle"],
+    xapiVerb: "http://adlnet.gov/expapi/verbs/experienced",
+    urnPattern: "urn:lessonkit:course:{courseId}:lesson:{lessonId}:block:{blockId}"
+  },
   {
     name: "compound_page_viewed",
     description: "Learner activated a page inside a compound container",
@@ -465,16 +560,6 @@ function buildTelemetryCatalogV3() {
   return TELEMETRY_EVENT_CATALOG_V3.map((entry) => ({ ...entry }));
 }
 
-// src/internal/env.ts
-function isDevEnvironment() {
-  const g = globalThis;
-  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
-}
-function warnDev(message, err) {
-  if (!isDevEnvironment()) return;
-  console.warn(message, err instanceof Error ? err.message : err);
-}
-
 // src/internal/sinkInvoke.ts
 function invokeTrackingSink(sink, event) {
   let result;
@@ -535,45 +620,66 @@ function createTrackingClient(opts) {
   }
   const buffer = [];
   let flushInFlight = null;
+  let inflightExitBatch = null;
   let disposed = false;
   let disposing = false;
   let intervalId;
   const runFlush = () => {
-    if (!buffer.length) return Promise.resolve();
+    if (!buffer.length) return Promise.resolve(true);
     const events = buffer.splice(0, buffer.length);
-    let sent = 0;
+    inflightExitBatch = events;
     let succeeded = false;
     return Promise.resolve().then(async () => {
       if (batchSink) {
         await batchSink(events);
       } else {
-        for (const e of events) {
-          await sink?.(e);
-          sent += 1;
+        for (let i = 0; i < events.length; i++) {
+          try {
+            await sink?.(events[i]);
+          } catch {
+            buffer.unshift(...events.slice(i));
+            return;
+          }
         }
       }
       succeeded = true;
     }).catch(() => {
-      buffer.unshift(...events.slice(sent));
-    }).then(() => {
+      if (batchSink) {
+        buffer.unshift(...events);
+      }
+    }).then(async () => {
       if (succeeded && buffer.length > 0 && !disposed) {
         return runFlush();
       }
+      return succeeded;
+    }).finally(() => {
+      inflightExitBatch = null;
     });
   };
   const flush = () => {
-    if (disposed) return Promise.resolve();
+    if (disposed) return Promise.resolve(true);
     if (flushInFlight) return flushInFlight;
-    if (!buffer.length) return Promise.resolve();
+    if (!buffer.length) return Promise.resolve(true);
     flushInFlight = runFlush().finally(() => {
       flushInFlight = null;
     });
     return flushInFlight;
   };
+  const MAX_DISPOSE_FLUSH_ATTEMPTS = 10;
   const drainAll = async () => {
-    await flush();
-    while (buffer.length > 0) {
-      await flush();
+    let attempts = 0;
+    while (buffer.length > 0 && attempts < MAX_DISPOSE_FLUSH_ATTEMPTS) {
+      const delivered = await flush();
+      attempts += 1;
+      if (!delivered) break;
+    }
+    if (buffer.length > 0) {
+      if (isDevEnvironment()) {
+        console.warn(
+          `[lessonkit] dropped ${buffer.length} buffered telemetry event(s) after dispose flush cap`
+        );
+      }
+      buffer.length = 0;
     }
   };
   intervalId = flushIntervalMs > 0 ? globalThis.setInterval(() => void flush(), flushIntervalMs) : void 0;
@@ -582,18 +688,35 @@ function createTrackingClient(opts) {
     track: (event) => {
       if (disposed || disposing) return;
       if (buffer.length >= maxBufferSize) {
-        buffer.shift();
+        opts?.onBufferDrop?.();
         if (!warnedBufferCap && isDevEnvironment()) {
           warnedBufferCap = true;
           console.warn(
-            `[lessonkit] telemetry batch buffer capped at ${maxBufferSize} events; oldest events are dropped while the sink is unavailable.`
+            `[lessonkit] telemetry batch buffer capped at ${maxBufferSize} events; new events are dropped until the buffer drains.`
           );
         }
+        return;
       }
       buffer.push(event);
       if (buffer.length >= maxBatchSize) void flush();
     },
     flush,
+    flushOnExit: opts?.exitBatchSink ? () => {
+      const fromBuffer = buffer.splice(0, buffer.length);
+      const fromInflight = inflightExitBatch ? [...inflightExitBatch] : [];
+      const events = [...fromInflight, ...fromBuffer];
+      if (!events.length) return;
+      try {
+        const result = opts.exitBatchSink(events);
+        if (result != null && typeof result.catch === "function") {
+          void result.catch(() => {
+            buffer.unshift(...events);
+          });
+        }
+      } catch {
+        buffer.unshift(...events);
+      }
+    } : void 0,
     dispose: () => {
       if (disposed || disposing) return Promise.resolve();
       disposing = true;
@@ -746,6 +869,20 @@ var TELEMETRY_EVENT_REGISTRY = {
       };
     }
   },
+  slide_viewed: {
+    requiresLessonId: true,
+    build: (opts, base) => {
+      if (opts.name !== "slide_viewed") throw new Error("unexpected event");
+      const lessonId = opts.lessonId;
+      if (!lessonId) throw new Error("slide_viewed requires active lessonId");
+      return {
+        name: "slide_viewed",
+        ...base,
+        lessonId,
+        data: opts.data
+      };
+    }
+  },
   compound_page_viewed: {
     requiresLessonId: true,
     build: (opts, base) => {
@@ -894,8 +1031,7 @@ function createDefaultClock() {
 function createNoopStorage() {
   return {
     getItem: () => null,
-    setItem: () => {
-    }
+    setItem: () => true
   };
 }
 function createMemoryBackedSessionStorage(session) {
@@ -926,8 +1062,10 @@ function createMemoryBackedSessionStorage(session) {
       memory.set(key, value);
       try {
         session.setItem(key, value);
+        return true;
       } catch {
         warnPersistFailure();
+        return false;
       }
     },
     removeItem: (key) => {
@@ -952,6 +1090,7 @@ function createInMemorySessionStoragePort() {
     getItem: (key) => memory.get(key) ?? null,
     setItem: (key, value) => {
       memory.set(key, value);
+      return true;
     },
     removeItem: (key) => {
       memory.delete(key);
@@ -1004,7 +1143,12 @@ function createProgressController() {
       return { previousLessonId };
     },
     completeLesson: (lessonId, completedAtMs) => {
-      if (completedLessonIds.has(lessonId)) return { didComplete: false };
+      if (completedLessonIds.has(lessonId)) {
+        if (activeLessonId === lessonId) {
+          activeLessonId = void 0;
+        }
+        return { didComplete: false };
+      }
       completedLessonIds = new Set(completedLessonIds).add(lessonId);
       if (activeLessonId === lessonId) {
         activeLessonId = void 0;
@@ -1024,6 +1168,12 @@ function createProgressController() {
 
 // src/session.ts
 var SESSION_STORAGE_KEY = "lessonkit:sessionId";
+var volatileSessionIds = /* @__PURE__ */ new WeakMap();
+var sharedVolatileSessionId = null;
+function isDevEnvironment2() {
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
+}
 function getTabSessionId(storage) {
   return storage.getItem(SESSION_STORAGE_KEY);
 }
@@ -1031,11 +1181,28 @@ var COURSE_STARTED_PREFIX = "lessonkit:course_started:";
 var COURSE_STARTED_TRACKING_PREFIX = "lessonkit:course_started_tracking:";
 var COURSE_STARTED_PIPELINE_PREFIX = "lessonkit:course_started_pipeline:";
 function resolveSessionId(storage, provided) {
-  if (provided) return provided;
+  if (provided !== void 0) {
+    const trimmed = provided.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
   const existing = storage.getItem(SESSION_STORAGE_KEY);
   if (existing) return existing;
+  const volatile = volatileSessionIds.get(storage);
+  if (volatile) return volatile;
   const id = createSessionId();
-  storage.setItem(SESSION_STORAGE_KEY, id);
+  const persisted = storage.setItem(SESSION_STORAGE_KEY, id);
+  if (!persisted) {
+    if (!sharedVolatileSessionId) {
+      sharedVolatileSessionId = id;
+    }
+    volatileSessionIds.set(storage, sharedVolatileSessionId);
+    if (isDevEnvironment2()) {
+      console.warn(
+        "[lessonkit] session id could not be persisted; reusing in-memory id for this tab."
+      );
+    }
+    return sharedVolatileSessionId;
+  }
   return id;
 }
 function courseStartedStorageKey(sessionId, courseId) {
@@ -1052,24 +1219,27 @@ function hasCourseStarted(storage, sessionId, courseId) {
   return storage.getItem(courseStartedStorageKey(sessionId, courseId)) === "1";
 }
 function markCourseStarted(storage, sessionId, courseId) {
-  if (!courseId) return;
-  storage.setItem(courseStartedStorageKey(sessionId, courseId), "1");
+  if (!courseId) return false;
+  return storage.setItem(courseStartedStorageKey(sessionId, courseId), "1");
 }
 function hasCourseStartedEmittedToTracking(storage, sessionId, courseId) {
   if (!courseId) return false;
   return storage.getItem(courseStartedTrackingStorageKey(sessionId, courseId)) === "1";
 }
 function markCourseStartedEmittedToTracking(storage, sessionId, courseId) {
-  if (!courseId) return;
-  storage.setItem(courseStartedTrackingStorageKey(sessionId, courseId), "1");
+  if (!courseId) return false;
+  return storage.setItem(courseStartedTrackingStorageKey(sessionId, courseId), "1");
 }
 function hasCourseStartedPipelineDelivered(storage, sessionId, courseId) {
   if (!courseId) return false;
   return storage.getItem(courseStartedPipelineStorageKey(sessionId, courseId)) === "1";
 }
 function markCourseStartedPipelineDelivered(storage, sessionId, courseId) {
-  if (!courseId) return;
-  storage.setItem(courseStartedPipelineStorageKey(sessionId, courseId), "1");
+  if (!courseId) return false;
+  return storage.setItem(courseStartedPipelineStorageKey(sessionId, courseId), "1");
+}
+function resetSharedVolatileSessionIdForTests() {
+  sharedVolatileSessionId = null;
 }
 function migrateCourseStartedMark(storage, fromSessionId, toSessionId, courseId) {
   if (!courseId || fromSessionId === toSessionId) return;
@@ -1088,19 +1258,29 @@ function migrateCourseStartedMark(storage, fromSessionId, toSessionId, courseId)
 }
 
 // src/runtime/courseLifecycle.ts
+var courseStartedEmitFlights = /* @__PURE__ */ new Set();
 function tryEmitCourseStarted(ctx, deps, alreadyEmittedToSink) {
+  const flightKey = `${ctx.sessionId}:${ctx.courseId}`;
   const marked = hasCourseStarted(ctx.storage, ctx.sessionId, ctx.courseId);
   if (alreadyEmittedToSink) {
     return { emitted: true, marked };
   }
-  if (marked) {
-    return { emitted: false, marked: true };
+  if (courseStartedEmitFlights.has(flightKey)) {
+    return { emitted: false, marked };
   }
-  const emitted = deps.emitCourseStartedEvent(ctx);
-  if (emitted) {
-    markCourseStarted(ctx.storage, ctx.sessionId, ctx.courseId);
+  courseStartedEmitFlights.add(flightKey);
+  try {
+    const emitted = deps.emitCourseStartedEvent(ctx);
+    if (emitted && !marked) {
+      markCourseStarted(ctx.storage, ctx.sessionId, ctx.courseId);
+    }
+    return {
+      emitted,
+      marked: hasCourseStarted(ctx.storage, ctx.sessionId, ctx.courseId)
+    };
+  } finally {
+    courseStartedEmitFlights.delete(flightKey);
   }
-  return { emitted, marked: emitted };
 }
 function buildCourseStartedTelemetryEvent(ctx) {
   return buildTelemetryEvent({
@@ -1190,7 +1370,7 @@ function createPluginRegistry(plugins = []) {
   const composeTrackingSink = (sink, ctxSource) => {
     if (!sink) return void 0;
     const resolveCtx = () => typeof ctxSource === "function" ? ctxSource() : ctxSource;
-    const ctxKey = (ctx) => `${ctx.courseId}\0${ctx.sessionId ?? ""}\0${ctx.attemptId ?? ""}`;
+    const ctxKey = (ctx) => `${ctx.courseId}\0${ctx.sessionId ?? ""}\0${ctx.attemptId ?? ""}\0${ctx.user?.id ?? ""}`;
     const layers = [];
     let composed = sink;
     for (const plugin of list) {
@@ -1261,6 +1441,9 @@ function createLessonkitRuntime(config, ports = {}) {
     attemptId,
     user
   });
+  if (!configSnapshot.deferPluginSetup) {
+    pluginHost?.setupAll(getPluginCtx());
+  }
   const getSession = () => ({ sessionId, attemptId, user });
   const syncSessionFromConfig = (next) => {
     sessionId = resolveSessionId(storage, next.session?.sessionId);
@@ -1320,11 +1503,8 @@ function createLessonkitRuntime(config, ports = {}) {
     getProgressState: () => progress.getState(),
     getSession,
     updateConfig(next) {
-      if (next.plugins !== void 0 && next.plugins !== pluginHost) {
-        pluginHost?.disposeAll();
-        configSnapshot.plugins = next.plugins;
-        pluginHost = resolvePluginHost(configSnapshot.plugins);
-      }
+      const previousCourseId = courseId;
+      const sessionKeyBefore = JSON.stringify({ sessionId, attemptId, user });
       if (next.courseId !== void 0) configSnapshot.courseId = next.courseId;
       if (next.runtimeVersion !== void 0) {
         if (next.runtimeVersion === "v1") warnRuntimeV1Deprecated();
@@ -1334,6 +1514,19 @@ function createLessonkitRuntime(config, ports = {}) {
         configSnapshot.session = { ...configSnapshot.session, ...next.session };
       }
       syncSessionFromConfig(configSnapshot);
+      const sessionKeyAfter = JSON.stringify({ sessionId, attemptId, user });
+      if (next.courseId !== void 0 && next.courseId !== previousCourseId) {
+        progress = createProgressController();
+      }
+      if (next.plugins !== void 0 && next.plugins !== pluginHost) {
+        pluginHost?.disposeAll();
+        configSnapshot.plugins = next.plugins;
+        pluginHost = resolvePluginHost(configSnapshot.plugins);
+        pluginHost?.setupAll(getPluginCtx());
+      } else if (next.session !== void 0 && sessionKeyBefore !== sessionKeyAfter && pluginHost && !configSnapshot.deferPluginSetup) {
+        pluginHost.disposeAll();
+        pluginHost.setupAll(getPluginCtx());
+      }
     },
     setActiveLesson(lessonId, emitFn) {
       const wrapped = wrapEmitFn(emitFn);
@@ -1406,6 +1599,8 @@ function defineLifecyclePlugin(plugin) {
   INTERACTIVE_BOOK_ALLOWED_CHILD_TYPES,
   PAGE_ALLOWED_CHILD_TYPES,
   SESSION_STORAGE_KEY,
+  SLIDE_ALLOWED_CHILD_TYPES,
+  SLIDE_DECK_ALLOWED_CHILD_TYPES,
   TELEMETRY_EVENT_CATALOG,
   TELEMETRY_EVENT_CATALOG_V2,
   TELEMETRY_EVENT_CATALOG_V3,
@@ -1456,6 +1651,7 @@ function defineLifecyclePlugin(plugin) {
   parseCompoundResumeState,
   parseCourseId,
   parseLessonId,
+  resetSharedVolatileSessionIdForTests,
   resetStoragePortForTests,
   resetTelemetryBuilderWarningsForTests,
   resolveSessionId,