tessera-learn 0.0.8 → 0.0.10

package/src/plugin/index.ts

@@ -27,17 +27,21 @@ function resolveStylesDir(): string {
 }
 
 export function tesseraPlugin() {
+  const manifestRef: { current: Manifest | null; root: string } = { current: null, root: '' };
   return [
     svelte({
-      compilerOptions: { css: 'injected' },
+      compilerOptions: { css: 'external' },
     }),
     tesseraValidationPlugin(),
     tesseraEntryPlugin(),
     tesseraConfigPlugin(),
     tesseraPagesPlugin(),
-    tesseraManifestPlugin(),
+    tesseraManifestPlugin(manifestRef),
     tesseraLayoutPlugin(),
     tesseraQuizPlugin(),
+    tesseraAdapterPlugin(),
+    tesseraXAPISetupPlugin(),
+    tesseraFirstPagePreloadPlugin(manifestRef),
     tesseraExportPlugin(),
   ];
 }
@@ -207,6 +211,11 @@ function tesseraConfigPlugin(): Plugin {
             '$assets': resolve(root, 'assets'),
           },
         },
+        // tessera-learn ships .ts/.svelte.ts source; Vite's dep optimizer
+        // doesn't run vite-plugin-svelte's preprocessor, so skip pre-bundling.
+        optimizeDeps: {
+          exclude: ['tessera-learn'],
+        },
       };
     },
 
@@ -392,15 +401,15 @@ function tesseraExportPlugin(): Plugin {
 const VIRTUAL_MANIFEST_ID = 'virtual:tessera-manifest';
 const RESOLVED_MANIFEST_ID = '\0' + VIRTUAL_MANIFEST_ID;
 
-function tesseraManifestPlugin(): Plugin {
+function tesseraManifestPlugin(manifestRef: { current: Manifest | null; root: string }): Plugin {
   let projectRoot: string;
   let pagesDir: string;
-  let currentManifest: Manifest | null = null;
   let server: ViteDevServer | null = null;
 
   function buildManifest(): Manifest {
-    currentManifest = generateManifest(pagesDir);
-    return currentManifest;
+    const m = generateManifest(pagesDir);
+    manifestRef.current = m;
+    return m;
   }
 
   return {
@@ -410,6 +419,7 @@ function tesseraManifestPlugin(): Plugin {
     configResolved(config: ResolvedConfig) {
       projectRoot = config.root;
       pagesDir = resolve(projectRoot, 'pages');
+      manifestRef.root = projectRoot;
     },
 
     configureServer(devServer: ViteDevServer) {
@@ -427,7 +437,7 @@ function tesseraManifestPlugin(): Plugin {
           event === 'unlinkDir';
 
         if (isRelevant) {
-          currentManifest = null; // invalidate cache
+          manifestRef.current = null; // invalidate cache
 
           // Invalidate the virtual module to trigger HMR
           const mod = devServer.moduleGraph.getModuleById(RESOLVED_MANIFEST_ID);
@@ -452,7 +462,7 @@ function tesseraManifestPlugin(): Plugin {
 
     load(id) {
       if (id === RESOLVED_MANIFEST_ID) {
-        if (!currentManifest) {
+        if (!manifestRef.current) {
           buildManifest();
         }
 
@@ -463,7 +473,7 @@ function tesseraManifestPlugin(): Plugin {
         // Encode as base64 to prevent Vite's import analysis from
         // scanning .svelte importPath strings as module imports.
         // Replace Infinity with 1e9 since JSON.stringify drops it.
-        const json = JSON.stringify(currentManifest, (_key, value) =>
+        const json = JSON.stringify(manifestRef.current, (_key, value) =>
           value === Infinity ? 1e9 : value
         );
         const b64 = Buffer.from(json).toString('base64');
@@ -473,3 +483,168 @@ function tesseraManifestPlugin(): Plugin {
     },
   };
 }
+
+const VIRTUAL_ADAPTER_ID = 'virtual:tessera-adapter';
+const RESOLVED_ADAPTER_ID = '\0' + VIRTUAL_ADAPTER_ID;
+
+function tesseraAdapterPlugin(): Plugin {
+  let projectRoot: string;
+  let isBuild = false;
+
+  return {
+    name: 'tessera:adapter',
+    enforce: 'pre',
+
+    configResolved(config: ResolvedConfig) {
+      projectRoot = config.root;
+      isBuild = config.command === 'build';
+    },
+
+    resolveId(id) {
+      if (id === VIRTUAL_ADAPTER_ID) return RESOLVED_ADAPTER_ID;
+      return null;
+    },
+
+    load(id) {
+      if (id !== RESOLVED_ADAPTER_ID) return null;
+
+      // In dev, defer to the runtime selector so its WebAdapter fallback
+      // for unreachable LMS APIs keeps working.
+      if (!isBuild) {
+        return `export { createAdapter } from 'tessera-learn/runtime/adapters/index.js';`;
+      }
+
+      let standard = 'web';
+      const configPath = resolve(projectRoot, 'course.config.js');
+      if (existsSync(configPath)) {
+        const objectStr = extractDefaultExportObjectLiteral(readFileSync(configPath, 'utf-8'));
+        if (objectStr) {
+          try {
+            const parsed = JSON5.parse(objectStr);
+            if (typeof parsed?.export?.standard === 'string') standard = parsed.export.standard;
+          } catch {}
+        }
+      }
+
+      switch (standard) {
+        case 'scorm12':
+          return `
+import { SCORM12Adapter } from 'tessera-learn/runtime/adapters/scorm12.js';
+import { findSCORM12API } from 'tessera-learn/runtime/adapters/discovery.js';
+import { LMSAdapterError } from 'tessera-learn/runtime/adapters/index.js';
+export function createAdapter() {
+  const api = findSCORM12API();
+  if (!api) throw new LMSAdapterError('scorm12', 'Tessera: SCORM 1.2 API not found in window.parent/opener chain. Course must be launched from a SCORM 1.2 LMS.');
+  return new SCORM12Adapter(api);
+}
+`;
+        case 'scorm2004':
+          return `
+import { SCORM2004Adapter } from 'tessera-learn/runtime/adapters/scorm2004.js';
+import { findSCORM2004API } from 'tessera-learn/runtime/adapters/discovery.js';
+import { LMSAdapterError } from 'tessera-learn/runtime/adapters/index.js';
+export function createAdapter() {
+  const api = findSCORM2004API();
+  if (!api) throw new LMSAdapterError('scorm2004', 'Tessera: SCORM 2004 API not found in window.parent/opener chain. Course must be launched from a SCORM 2004 LMS.');
+  return new SCORM2004Adapter(api);
+}
+`;
+        case 'cmi5':
+          return `
+import { CMI5Adapter } from 'tessera-learn/runtime/adapters/cmi5.js';
+import { hasCMI5LaunchParams } from 'tessera-learn/runtime/adapters/discovery.js';
+import { LMSAdapterError } from 'tessera-learn/runtime/adapters/index.js';
+export function createAdapter() {
+  if (!hasCMI5LaunchParams()) throw new LMSAdapterError('cmi5', 'Tessera: cmi5 launch parameters not present on URL. Course must be launched from a cmi5-compliant LMS.');
+  return new CMI5Adapter();
+}
+`;
+        default:
+          return `
+import { WebAdapter } from 'tessera-learn/runtime/adapters/web.js';
+export function createAdapter(config) {
+  return new WebAdapter(config);
+}
+`;
+      }
+    },
+  };
+}
+
+const VIRTUAL_XAPI_SETUP_ID = 'virtual:tessera-xapi-setup';
+const RESOLVED_XAPI_SETUP_ID = '\0' + VIRTUAL_XAPI_SETUP_ID;
+
+function tesseraXAPISetupPlugin(): Plugin {
+  let projectRoot: string;
+  let isBuild = false;
+
+  return {
+    name: 'tessera:xapi-setup',
+    enforce: 'pre',
+
+    configResolved(config: ResolvedConfig) {
+      projectRoot = config.root;
+      isBuild = config.command === 'build';
+    },
+
+    resolveId(id) {
+      if (id === VIRTUAL_XAPI_SETUP_ID) return RESOLVED_XAPI_SETUP_ID;
+      return null;
+    },
+
+    load(id) {
+      if (id !== RESOLVED_XAPI_SETUP_ID) return null;
+
+      if (!isBuild) {
+        return `export { buildXAPIClient } from 'tessera-learn/runtime/xapi/setup.js';`;
+      }
+
+      let standard = 'web';
+      let hasXapi = false;
+      const configPath = resolve(projectRoot, 'course.config.js');
+      if (existsSync(configPath)) {
+        const objectStr = extractDefaultExportObjectLiteral(readFileSync(configPath, 'utf-8'));
+        if (objectStr) {
+          try {
+            const parsed = JSON5.parse(objectStr);
+            if (typeof parsed?.export?.standard === 'string') standard = parsed.export.standard;
+            hasXapi = parsed?.xapi != null;
+          } catch {}
+        }
+      }
+
+      // cmi5 needs the publisher regardless of explicit xapi config (cmi5
+      // adapter shares the publisher queue for its own LMS-required statements).
+      if (hasXapi || standard === 'cmi5') {
+        return `export { buildXAPIClient } from 'tessera-learn/runtime/xapi/setup.js';`;
+      }
+
+      return `export async function buildXAPIClient() { return null; }`;
+    },
+  };
+}
+
+function tesseraFirstPagePreloadPlugin(manifestRef: { current: Manifest | null; root: string }): Plugin {
+  return {
+    name: 'tessera:first-page-preload',
+    apply: 'build',
+    transformIndexHtml: {
+      order: 'post',
+      handler(_html, ctx) {
+        const firstPagePath = manifestRef.current?.pages[0]?.importPath;
+        if (!firstPagePath || !ctx.bundle) return;
+        const normalized = resolve(manifestRef.root, firstPagePath.replace(/^\//, '')).replace(/\\/g, '/');
+        const chunk = Object.values(ctx.bundle).find(
+          (c): c is import('vite').Rollup.OutputChunk =>
+            c.type === 'chunk' && !!c.facadeModuleId && c.facadeModuleId.replace(/\\/g, '/') === normalized
+        );
+        if (!chunk) return;
+        return [{
+          tag: 'link',
+          attrs: { rel: 'modulepreload', href: `./${chunk.fileName}` },
+          injectTo: 'head',
+        }];
+      },
+    },
+  };
+}

package/src/plugin/validation.ts

@@ -542,7 +542,8 @@ function validatePageFile(
   if (
     pageConfig?.quiz &&
     !HAS_USE_QUESTION_RE.test(content) &&
-    !HAS_QUESTION_TAG_RE.test(content)
+    !HAS_QUESTION_TAG_RE.test(content) &&
+    !HAS_LOCAL_SVELTE_IMPORT_RE.test(content)
   ) {
     warnings.push(
       `${fileRel}: quiz page has no question components or useQuestion() calls — ` +
@@ -810,7 +811,7 @@ function validateQuizConfig(quiz: unknown, fileRel: string, errors: string[]): v
     }
   }
 
-  for (const field of ['graded', 'gatesProgress', 'showFeedback']) {
+  for (const field of ['graded', 'gatesProgress']) {
     if (cfg[field] !== undefined && typeof cfg[field] !== 'boolean') {
       errors.push(
         `${fileRel}: quiz.${field} must be a boolean, got ${typeof cfg[field]}`
@@ -1041,6 +1042,10 @@ const HAS_USE_QUESTION_RE = /\buseQuestion\s*\(/;
 const HAS_QUESTION_TAG_RE = new RegExp(
   `<(${Object.keys(QUESTION_COMPONENT_REQUIRED).join('|')})(?=[\\s/>])`
 );
+// Custom widget imported from a local `.svelte` file may wrap useQuestion.
+// Treat its presence as enough to suppress the "no questions" warning —
+// false negatives are acceptable for a heuristic that's already advisory.
+const HAS_LOCAL_SVELTE_IMPORT_RE = /from\s+['"][^'"]+\.svelte['"]/;
 
 /**
  * Detect ways an author file can bypass the LMS data contract. These check

package/src/runtime/App.svelte

@@ -5,14 +5,14 @@
   import UserLayout from 'virtual:tessera-layout';
   import Quiz from 'virtual:tessera-quiz';
   import { onMount, onDestroy, setContext, untrack } from 'svelte';
-  import LoadingSkeleton from './LoadingSkeleton.svelte';
+  import LoadingBar from './LoadingBar.svelte';
   import ErrorPage from './ErrorPage.svelte';
   import DefaultLayout from '../components/DefaultLayout.svelte';
   import { NavigationState } from './navigation.svelte.js';
   import { ProgressState } from './progress.svelte.js';
   import { DurationTracker } from './duration.js';
-  import { createAdapter } from './adapters/index.js';
-  import { buildXAPIClient } from './xapi/setup.js';
+  import { createAdapter } from 'virtual:tessera-adapter';
+  import { buildXAPIClient } from 'virtual:tessera-xapi-setup';
   import { registerXAPIClient } from './xapi/registry.js';
   import { TESSERA_PAGE, TESSERA_NAV, TESSERA_ADAPTER, TESSERA_USER_STATE } from './contexts.js';
 
@@ -24,12 +24,19 @@
   // can reach it.
   let xapiClient = null;
 
+  const gradedQuizIndices = new Set(
+    manifest.pages.filter(p => p.quiz?.graded).map(p => p.index)
+  );
+
   // ---- State classes ----
-  const progress = new ProgressState();
+  const progress = new ProgressState(gradedQuizIndices);
   const nav = new NavigationState(manifest, progress, config);
+  nav.setPageModules(pageModules);
   let duration = $state(new DurationTracker(0));
 
-  const gradedQuizIndices = manifest.pages.filter(p => p.quiz?.graded).map(p => p.index);
+  const onIdle = typeof window !== 'undefined' && window.requestIdleCallback
+    ? window.requestIdleCallback.bind(window)
+    : (cb) => setTimeout(() => cb({ didTimeout: false, timeRemaining: () => 50 }), 1);
 
   // Page loading state
   let PageComponent = $state(null);
@@ -84,22 +91,20 @@
 
     const gen = ++loadGeneration;
     pageLoading = true;
-    pageError = null;
-    PageComponent = null;
-
-    // Update context for the new page
-    pageContext.quiz = page.quiz;
 
     const loader = pageModules[page.importPath];
     if (!loader) {
       console.error(`Tessera: No loader for page ${index} at ${page.importPath}`);
       pageError = new Error(`Page not found: ${page.importPath}`);
+      PageComponent = null;
       pageLoading = false;
       return;
     }
 
     loader().then(mod => {
       if (gen !== loadGeneration) return; // stale
+      pageError = null;
+      pageContext.quiz = page.quiz;
       PageComponent = mod.default;
       pageLoading = false;
       progress.markVisited(index);
@@ -109,8 +114,9 @@
       ) {
         progress.markCompleteManually();
       }
-      progress.recalculateCompletion(manifest, config);
-      progress.recalculateSuccess(manifest, config);
+      progress.recalculateCompletion(manifest.totalPages, config);
+      progress.recalculateSuccess(config);
+      onIdle(() => nav.prefetch(index + 1));
     }).catch(err => {
       if (gen !== loadGeneration) return; // stale
       console.error(`Tessera: Failed to load page ${index}`, err);
@@ -132,18 +138,25 @@
   }
 
   // ---- Branding ----
+  // Two sentinels so the validity check doesn't false-positive when the
+  // input happens to normalize to the initial fillStyle ("#000000").
   function parseColor(color) {
     if (typeof CSS !== 'undefined' && CSS.supports && !CSS.supports('color', color)) {
       return null;
     }
-    const el = document.createElement('span');
-    el.style.color = color;
-    document.documentElement.appendChild(el);
-    const computed = getComputedStyle(el).color;
-    el.remove();
-    const match = computed.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
-    if (!match) return null;
-    return { r: +match[1], g: +match[2], b: +match[3] };
+    const ctx = document.createElement('canvas').getContext('2d');
+    if (!ctx) return null;
+    ctx.fillStyle = '#000';
+    ctx.fillStyle = color;
+    const onBlack = ctx.fillStyle;
+    ctx.fillStyle = '#fff';
+    ctx.fillStyle = color;
+    const onWhite = ctx.fillStyle;
+    if (onBlack !== onWhite) return null;
+    const hex = String(onBlack).match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (hex) return { r: parseInt(hex[1], 16), g: parseInt(hex[2], 16), b: parseInt(hex[3], 16) };
+    const rgba = String(onBlack).match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    return rgba ? { r: +rgba[1], g: +rgba[2], b: +rgba[3] } : null;
   }
 
   function rgbToHsl(r, g, b) {
@@ -177,18 +190,12 @@
     }
   }
 
-  // ---- Quiz completion handler ----
   function handleQuizComplete(e) {
-    const { score, interactions = [] } = e.detail;
+    const { score } = e.detail;
     const pageIndex = nav.currentPageIndex;
     progress.quizCompleted(pageIndex, score);
-    for (const { id, interaction, correct } of interactions) {
-      adapter.reportInteraction(id, interaction, correct);
-    }
-    progress.recalculateCompletion(manifest, config);
-    progress.recalculateSuccess(manifest, config);
-    // Persistence is scheduled by the version-tracking effect below; no
-    // explicit call needed here.
+    progress.recalculateCompletion(manifest.totalPages, config);
+    progress.recalculateSuccess(config);
   }
 
   // ---- Persistence: serialize / restore ----
@@ -257,8 +264,8 @@
       progress.markCompleteManually();
     }
     // Recalculate derived state
-    progress.recalculateCompletion(manifest, config);
-    progress.recalculateSuccess(manifest, config);
+    progress.recalculateCompletion(manifest.totalPages, config);
+    progress.recalculateSuccess(config);
     // Navigate to bookmark (after state is restored so locking is correct)
     if (saved.b > 0 && saved.b < manifest.totalPages) {
       nav.goToPage(saved.b);
@@ -302,14 +309,21 @@
   $effect(() => {
     const scores = progress.quizScores;
     if (!persistenceReady || scores.size === 0) return;
-    if (gradedQuizIndices.length === 0) return;
-
-    const completedGraded = gradedQuizIndices.filter(i => scores.has(i));
-    if (completedGraded.length === 0) return;
+    if (gradedQuizIndices.size === 0) return;
+
+    let sum = 0;
+    let attempted = false;
+    for (const i of gradedQuizIndices) {
+      if (scores.has(i)) {
+        sum += scores.get(i) ?? 0;
+        attempted = true;
+      }
+    }
+    if (!attempted) return;
 
     // Divide by total graded count — incomplete quizzes count as 0, matching
     // the recalculateSuccess logic in progress.svelte.ts.
-    const average = completedGraded.reduce((sum, i) => sum + (scores.get(i) ?? 0), 0) / gradedQuizIndices.length;
+    const average = sum / gradedQuizIndices.size;
 
     untrack(() => {
       adapter.setScore(Math.round(average));
@@ -403,6 +417,7 @@
       restoreState(saved);
       prevCompletionStatus = progress.completionStatus;
       prevSuccessStatus = progress.successStatus;
+      adapter.seedLifecycle?.(progress.completionStatus, progress.successStatus);
     }
     persistenceReady = true;
 
@@ -468,9 +483,7 @@
 </script>
 
 {#snippet page()}
-  {#if pageLoading}
-    <LoadingSkeleton />
-  {:else if pageError}
+  {#if pageError}
     <ErrorPage error={pageError} onretry={retryPage} />
   {:else if PageComponent}
     {#if pageContext.quiz}
@@ -484,6 +497,7 @@
 {/snippet}
 
 <div id="tessera-app" data-chrome={chromeMode}>
+  <LoadingBar active={pageLoading} />
   {#if UserLayout}
     <UserLayout {page} />
   {:else if chromeMode === 'custom'}

package/src/runtime/LoadingBar.svelte

@@ -0,0 +1,47 @@
+<script>
+  import { untrack } from 'svelte';
+
+  let { active = false } = $props();
+
+  let visible = $state(false);
+  let appeared = $state(false);
+  let complete = $state(false);
+  let showSlowMessage = $state(false);
+
+  $effect(() => {
+    if (active) {
+      // Defer the bar so sub-100ms loads never flash. Add `.appear` on the
+      // next frame so the CSS transition from width:0 → 90% actually fires.
+      const appearTimer = setTimeout(() => {
+        visible = true;
+        requestAnimationFrame(() => { appeared = true; });
+      }, 100);
+      const slowTimer = setTimeout(() => { showSlowMessage = true; }, 5000);
+      return () => {
+        clearTimeout(appearTimer);
+        clearTimeout(slowTimer);
+      };
+    }
+
+    // Completing. If the bar never appeared we have nothing to finish.
+    // untrack so flipping `visible` doesn't re-trigger this effect.
+    if (!untrack(() => visible)) return;
+    complete = true;
+    const hideTimer = setTimeout(() => {
+      visible = false;
+      appeared = false;
+      complete = false;
+      showSlowMessage = false;
+    }, 220);
+    return () => clearTimeout(hideTimer);
+  });
+</script>
+
+{#if visible}
+  <div class="tessera-loading-bar" class:appear={appeared} class:complete aria-hidden="true">
+    <div class="tessera-loading-bar-fill"></div>
+  </div>
+  {#if showSlowMessage}
+    <p class="tessera-loading-bar-message" role="status">Still loading…</p>
+  {/if}
+{/if}

package/src/runtime/Sidebar.svelte

@@ -60,6 +60,8 @@
               aria-current={page.index === currentPageIndex ? 'page' : undefined}
               aria-disabled={locked ? 'true' : undefined}
               onclick={() => handlePageClick(page.index)}
+              onpointerenter={() => !locked && nav.prefetch(page.index)}
+              onfocusin={() => !locked && nav.prefetch(page.index)}
             >
               {#if locked}
                 <svg class="tessera-nav-lock-icon" viewBox="0 0 16 16" fill="currentColor" aria-hidden="true" width="12" height="12">

package/src/runtime/adapters/cmi5.ts

@@ -1,6 +1,10 @@
 import type { PersistenceAdapter, SavedState } from '../persistence.js';
 import type { Interaction } from '../interaction.js';
-import { formatResponse, formatCorrectPattern } from '../interaction-format.js';
+import {
+  formatResponse,
+  formatCorrectPattern,
+  XAPI_INTERACTION_FORMAT,
+} from '../interaction-format.js';
 import { formatISO8601Duration } from './retry.js';
 import { XAPIPublisher } from '../xapi/publisher.js';
 import { X_API_VERSION } from '../xapi/version.js';
@@ -139,8 +143,8 @@ export class CMI5Adapter implements PersistenceAdapter {
   #score: number | null = null;
   #durationSeconds = 0;
   #state: SavedState | null = null;
-  #completedSent = false;
-  #successSent = false;
+  #completedEmitted = false;
+  #lastSuccessEmitted: 'unknown' | 'passed' | 'failed' = 'unknown';
   #terminated = false;
 
   // cmi5 §8 launch params. masteryScore (when present) overrides the
@@ -240,13 +244,28 @@ export class CMI5Adapter implements PersistenceAdapter {
     // Basic credential (already base64); we don't re-encode.
     let token = '';
     if (text.startsWith('{')) {
+      let parsed: unknown;
       try {
-        const parsed = JSON.parse(text);
-        if (parsed && typeof parsed['auth-token'] === 'string') {
-          token = parsed['auth-token'].trim();
-        }
+        parsed = JSON.parse(text);
       } catch {
-        // fall through to legacy parsing
+        parsed = undefined;
+      }
+      if (parsed && typeof parsed === 'object') {
+        const obj = parsed as Record<string, unknown>;
+        if (typeof obj['auth-token'] === 'string') {
+          token = (obj['auth-token'] as string).trim();
+        } else {
+          const code = typeof obj['error-code'] === 'string' ? obj['error-code'] : undefined;
+          const errText = typeof obj['error-text'] === 'string' ? obj['error-text'] : undefined;
+          const detail =
+            code !== undefined || errText !== undefined
+              ? ` (error-code=${code ?? 'unknown'}${errText ? `: ${errText}` : ''})`
+              : '';
+          throw new Error(
+            `Tessera cmi5: fetch URL returned a JSON response without an 'auth-token' field${detail}. ` +
+              'The cmi5 fetch URL is single-use (§8.2.3.1); reload from the LMS to obtain a fresh launch.'
+          );
+        }
       }
     }
     if (!token) {
@@ -434,11 +453,21 @@ export class CMI5Adapter implements PersistenceAdapter {
     this.#score = Math.max(0, Math.min(100, score));
   }
 
+  seedLifecycle(
+    completion: 'incomplete' | 'complete',
+    success: 'unknown' | 'passed' | 'failed'
+  ): void {
+    if (completion === 'complete') this.#completedEmitted = true;
+    if (success === 'passed' || success === 'failed') {
+      this.#lastSuccessEmitted = success;
+    }
+  }
+
   setCompletionStatus(status: 'incomplete' | 'complete'): void {
-    if (status !== 'complete' || this.#completedSent || !this.#publisher) return;
+    if (status !== 'complete' || this.#completedEmitted || !this.#publisher) return;
     // cmi5 §10.2.2 — Browse/Review launches MUST NOT emit Completed.
     if (this.#launchMode !== 'Normal') return;
-    this.#completedSent = true;
+    this.#completedEmitted = true;
     // cmi5 §9.5.1 — `score` MUST NOT appear on Completed (Passed/Failed only).
     const result: Record<string, unknown> = {
       completion: true,
@@ -457,10 +486,11 @@ export class CMI5Adapter implements PersistenceAdapter {
   }
 
   setSuccessStatus(status: 'passed' | 'failed' | 'unknown'): void {
-    if (status === 'unknown' || this.#successSent || !this.#publisher) return;
+    if (status === 'unknown' || !this.#publisher) return;
+    if (status === this.#lastSuccessEmitted) return;
     // cmi5 §10.2.2 — Browse/Review launches MUST NOT emit Passed/Failed.
     if (this.#launchMode !== 'Normal') return;
-    this.#successSent = true;
+    this.#lastSuccessEmitted = status;
 
     const verb = status === 'passed' ? VERBS.passed : VERBS.failed;
     const verbName = status === 'passed' ? 'passed' : 'failed';
@@ -518,8 +548,8 @@ export class CMI5Adapter implements PersistenceAdapter {
     correct: boolean | null
   ): void {
     if (!this.#publisher) return;
-    const response = formatResponse(interaction);
-    const pattern = formatCorrectPattern(interaction);
+    const response = formatResponse(interaction, XAPI_INTERACTION_FORMAT);
+    const pattern = formatCorrectPattern(interaction, XAPI_INTERACTION_FORMAT);
     const definition: Record<string, unknown> = {
       type: CMI_INTERACTION_TYPE,
       interactionType: interaction.type,