tessera-learn 0.0.10 → 0.0.13

package/src/runtime/interaction-format.ts

@@ -55,19 +55,26 @@ export const XAPI_INTERACTION_FORMAT: InteractionFormat = {
  * underscore, max 250 chars. Strict validators (SCORM Cloud) reject raw
  * option labels with spaces or punctuation with error 405/406.
  */
-function shortIdentifier(value: string): string {
+export function shortIdentifier(value: string): string {
   const cleaned = value.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
   const trimmed = cleaned.slice(0, 250);
   return trimmed || '_';
 }
 
-function indexLookup(options: string[] | undefined, value: string): string | null {
+function indexLookup(
+  options: string[] | undefined,
+  value: string,
+): string | null {
   if (!options) return null;
   const idx = options.indexOf(value);
   return idx >= 0 ? String(idx) : null;
 }
 
-function encodeListItem(value: string, options: string[] | undefined, fmt: InteractionFormat): string {
+function encodeListItem(
+  value: string,
+  options: string[] | undefined,
+  fmt: InteractionFormat,
+): string {
   if (fmt === SCORM12_INTERACTION_FORMAT) {
     const idx = indexLookup(options, value);
     if (idx !== null) return idx;
@@ -77,12 +84,14 @@ function encodeListItem(value: string, options: string[] | undefined, fmt: Inter
 
 export function formatResponse(
   i: Interaction,
-  fmt: InteractionFormat = SCORM2004_INTERACTION_FORMAT
+  fmt: InteractionFormat = SCORM2004_INTERACTION_FORMAT,
 ): string {
   switch (i.type) {
     case 'choice':
     case 'sequencing':
-      return i.response.map((v) => encodeListItem(v, i.options, fmt)).join(fmt.itemDelim);
+      return i.response
+        .map((v) => encodeListItem(v, i.options, fmt))
+        .join(fmt.itemDelim);
     case 'true-false':
       return fmt.formatBoolean(i.response);
     case 'fill-in':
@@ -94,14 +103,17 @@ export function formatResponse(
       return i.response
         .map(
           ([l, r]) =>
-            `${encodeListItem(l, i.optionPairs?.left, fmt)}${fmt.pairDelim}${encodeListItem(r, i.optionPairs?.right, fmt)}`
+            `${encodeListItem(l, i.optionPairs?.left, fmt)}${fmt.pairDelim}${encodeListItem(r, i.optionPairs?.right, fmt)}`,
         )
         .join(fmt.itemDelim);
     case 'numeric':
       return String(i.response);
     case 'performance':
       return i.response
-        .map(([s, v]) => `${fmt.identifier(s)}${fmt.pairDelim}${fmt.identifier(String(v))}`)
+        .map(
+          ([s, v]) =>
+            `${fmt.identifier(s)}${fmt.pairDelim}${fmt.identifier(String(v))}`,
+        )
         .join(fmt.itemDelim);
   }
 }
@@ -109,7 +121,7 @@ export function formatResponse(
 /** Returns null when no correct pattern was provided. */
 export function formatCorrectPattern(
   i: Interaction,
-  fmt: InteractionFormat = SCORM2004_INTERACTION_FORMAT
+  fmt: InteractionFormat = SCORM2004_INTERACTION_FORMAT,
 ): string | null {
   if (i.correct === undefined) return null;
   switch (i.type) {
@@ -127,7 +139,7 @@ export function formatCorrectPattern(
       return (i.correct as Array<[string, string]>)
         .map(
           ([l, r]) =>
-            `${encodeListItem(l, i.optionPairs?.left, fmt)}${fmt.pairDelim}${encodeListItem(r, i.optionPairs?.right, fmt)}`
+            `${encodeListItem(l, i.optionPairs?.left, fmt)}${fmt.pairDelim}${encodeListItem(r, i.optionPairs?.right, fmt)}`,
         )
         .join(fmt.itemDelim);
     case 'numeric': {
@@ -146,7 +158,10 @@ export function formatCorrectPattern(
       return i.correct as string;
     case 'performance':
       return (i.correct as Array<[string, string | number]>)
-        .map(([s, v]) => `${fmt.identifier(s)}${fmt.pairDelim}${fmt.identifier(String(v))}`)
+        .map(
+          ([s, v]) =>
+            `${fmt.identifier(s)}${fmt.pairDelim}${fmt.identifier(String(v))}`,
+        )
         .join(fmt.itemDelim);
   }
 }
@@ -177,7 +192,7 @@ export function buildScormInteractionFields(
   questionId: string,
   interaction: Interaction,
   correct: boolean | null,
-  spec: ScormInteractionSpec
+  spec: ScormInteractionSpec,
 ): Array<[string, string]> {
   const fields: Array<[string, string]> = [
     [`${prefix}.id`, spec.format.identifier(questionId)],
@@ -187,7 +202,10 @@ export function buildScormInteractionFields(
   if (pattern !== null) {
     fields.push([`${prefix}.correct_responses.0.pattern`, pattern]);
   }
-  fields.push([`${prefix}.${spec.responseField}`, formatResponse(interaction, spec.format)]);
+  fields.push([
+    `${prefix}.${spec.responseField}`,
+    formatResponse(interaction, spec.format),
+  ]);
   if (correct !== null) {
     fields.push([
       `${prefix}.result`,

package/src/runtime/interaction.ts

@@ -7,16 +7,49 @@
  * so there is no impedance mismatch when writing to an LMS.
  */
 export type Interaction =
-  | { type: 'choice';       response: string[]; correct?: string[]; options?: string[] }
-  | { type: 'true-false';   response: boolean;  correct?: boolean }
-  | { type: 'fill-in';      response: string;   correct?: string[]; caseMatters?: boolean }
-  | { type: 'long-fill-in'; response: string;   correct?: string[]; caseMatters?: boolean }
-  | { type: 'matching';     response: Array<[string, string]>; correct?: Array<[string, string]>; optionPairs?: { left: string[]; right: string[] } }
-  | { type: 'sequencing';   response: string[]; correct?: string[]; options?: string[] }
-  | { type: 'numeric';      response: number;   correct?: { min?: number; max?: number } }
-  | { type: 'likert';       response: string;   correct?: string }
-  | { type: 'performance';  response: Array<[string, string | number]>; correct?: Array<[string, string | number]> }
-  | { type: 'other';        response: string;   correct?: string };
+  | {
+      type: 'choice';
+      response: string[];
+      correct?: string[];
+      options?: string[];
+    }
+  | { type: 'true-false'; response: boolean; correct?: boolean }
+  | {
+      type: 'fill-in';
+      response: string;
+      correct?: string[];
+      caseMatters?: boolean;
+    }
+  | {
+      type: 'long-fill-in';
+      response: string;
+      correct?: string[];
+      caseMatters?: boolean;
+    }
+  | {
+      type: 'matching';
+      response: Array<[string, string]>;
+      correct?: Array<[string, string]>;
+      optionPairs?: { left: string[]; right: string[] };
+    }
+  | {
+      type: 'sequencing';
+      response: string[];
+      correct?: string[];
+      options?: string[];
+    }
+  | {
+      type: 'numeric';
+      response: number;
+      correct?: { min?: number; max?: number };
+    }
+  | { type: 'likert'; response: string; correct?: string }
+  | {
+      type: 'performance';
+      response: Array<[string, string | number]>;
+      correct?: Array<[string, string | number]>;
+    }
+  | { type: 'other'; response: string; correct?: string };
 
 /**
  * Decide whether a learner response is correct. Returns:
@@ -86,7 +119,7 @@ function setEqual(a: string[], b: string[]): boolean {
 
 function pairSetEqual(
   a: Array<[string, string]>,
-  b: Array<[string, string]>
+  b: Array<[string, string]>,
 ): boolean {
   if (a.length !== b.length) return false;
   const key = ([l, r]: [string, string]) => `${l}\u241F${r}`;

package/src/runtime/navigation.svelte.ts

@@ -1,12 +1,13 @@
 import type { Manifest } from '../plugin/manifest.js';
 import type { CourseConfig } from './types.js';
 import { ProgressState } from './progress.svelte.js';
+import { resolveAccess } from './access.js';
 
 export function isPageComplete(
   index: number,
   manifest: Manifest,
   progress: ProgressState,
-  config: CourseConfig
+  config: CourseConfig,
 ): boolean {
   const page = manifest.pages[index];
   if (!page) return false;
@@ -29,6 +30,10 @@ export class NavigationState {
   #progress: ProgressState;
   #config: CourseConfig;
   #pageModules: PageModuleMap | null = null;
+  // Audit mode unlocks every page so the Tier-2 auditor can render and scan
+  // each one's DOM. Safe because gating is a runtime-only UX affordance — the
+  // whole course already ships client-side (see access.ts).
+  #auditMode: boolean;
   currentPageIndex = $state(0);
 
   canGoPrev = $derived(this.currentPageIndex > 0);
@@ -50,7 +55,10 @@ export class NavigationState {
     if (prev && prev.size === next.size) {
       let same = true;
       for (const i of next) {
-        if (!prev.has(i)) { same = false; break; }
+        if (!prev.has(i)) {
+          same = false;
+          break;
+        }
       }
       if (same) return prev;
     }
@@ -58,10 +66,16 @@ export class NavigationState {
     return next;
   });
 
-  constructor(manifest: Manifest, progress: ProgressState, config: CourseConfig) {
+  constructor(
+    manifest: Manifest,
+    progress: ProgressState,
+    config: CourseConfig,
+    auditMode = false,
+  ) {
     this.manifest = manifest;
     this.#progress = progress;
     this.#config = config;
+    this.#auditMode = auditMode;
   }
 
   setPageModules(modules: PageModuleMap) {
@@ -78,7 +92,7 @@ export class NavigationState {
     if (index < 0 || index >= this.manifest.totalPages) return;
     if (this.isPageLocked(index)) return;
     const page = this.manifest.pages[index];
-    this.#pageModules[page.importPath]?.();
+    void this.#pageModules[page.importPath]?.();
   }
 
   goToPage(index: number) {
@@ -96,53 +110,28 @@ export class NavigationState {
   }
 
   isPageLocked(index: number): boolean {
+    if (this.#auditMode) return false;
     return this.#lockedSet.has(index);
   }
 
-  // Compute the locked set in a single forward pass. The built-in modes are
-  // expressed inline (rather than calling resolveAccess/freeAccess/sequential
-  // per page) so the whole walk is O(n). Custom predicates fall back to a
-  // per-page evaluation since their semantics are arbitrary — but it still
-  // runs once per state change rather than once per page per render.
+  // Resolve the access predicate once (custom canAccess, or the free /
+  // sequential preset) and evaluate it per page. Runs once per state change
+  // — the presets are the single source of truth for the gating rules.
   #computeLockedSet(): Set<number> {
     const total = this.manifest.totalPages;
     const locked = new Set<number>();
-
-    if (this.#config.navigation.canAccess) {
-      const fn = this.#config.navigation.canAccess;
-      for (let i = 0; i < total; i++) {
-        if (!fn({
+    const access = resolveAccess(this.#config);
+    for (let i = 0; i < total; i++) {
+      if (
+        !access({
           pageIndex: i,
           page: this.manifest.pages[i],
           manifest: this.manifest,
           progress: this.#progress,
           config: this.#config,
-        })) {
-          locked.add(i);
-        }
-      }
-      return locked;
-    }
-
-    if (this.#config.navigation.mode === 'sequential') {
-      // Once any page is incomplete, every later page is locked.
-      for (let i = 1; i < total; i++) {
-        if (!isPageComplete(i - 1, this.manifest, this.#progress, this.#config)) {
-          for (let k = i; k < total; k++) locked.add(k);
-          return locked;
-        }
-      }
-      return locked;
-    }
-
-    // Free mode: a page is locked iff its most-recent gating quiz is unmet.
-    let lastGatingUnmet = false;
-    for (let i = 0; i < total; i++) {
-      if (lastGatingUnmet) locked.add(i);
-      const page = this.manifest.pages[i];
-      if (page.quiz?.gatesProgress) {
-        const score = this.#progress.quizScores.get(i) ?? 0;
-        lastGatingUnmet = score < this.#config.scoring.passingScore;
+        })
+      ) {
+        locked.add(i);
       }
     }
     return locked;

package/src/runtime/persistence.ts

@@ -14,7 +14,7 @@ export interface PersistenceAdapter {
   /** Tell the adapter what was already emitted in prior sessions, so it skips re-emitting on resume. */
   seedLifecycle?(
     completion: 'incomplete' | 'complete',
-    success: 'unknown' | 'passed' | 'failed'
+    success: 'unknown' | 'passed' | 'failed',
   ): void;
   setDuration(seconds: number): void;
   /**
@@ -31,7 +31,7 @@ export interface PersistenceAdapter {
   reportInteraction(
     questionId: string,
     interaction: Interaction,
-    correct: boolean | null
+    correct: boolean | null,
   ): void;
   commit(): void;
   terminate(): void;

package/src/runtime/progress.svelte.ts

@@ -20,7 +20,9 @@ export class ProgressState {
    * Tracked separately from `quizScores` because <Quiz> blocks score as a unit
    * while standalone questions score individually and average per page.
    */
-  standaloneQuestionScores = $state(new SvelteMap<number, Map<string, number>>());
+  standaloneQuestionScores = $state(
+    new SvelteMap<number, Map<string, number>>(),
+  );
   /**
    * Set of page indices that have at least one graded standalone question.
    * Pages in this set contribute to course success status via their standalone average.
@@ -96,7 +98,7 @@ export class ProgressState {
     pageIndex: number,
     questionId: string,
     score: number,
-    graded: boolean
+    graded: boolean,
   ) {
     let pageMap = this.standaloneQuestionScores.get(pageIndex);
     if (!pageMap) {
@@ -124,9 +126,8 @@ export class ProgressState {
     if (config.completion.mode === 'manual') return;
     if (config.completion.mode === 'percentage') {
       const threshold = config.completion.percentageThreshold ?? 100;
-      const percent = totalPages > 0
-        ? (this.visitedPages.size / totalPages) * 100
-        : 0;
+      const percent =
+        totalPages > 0 ? (this.visitedPages.size / totalPages) * 100 : 0;
       this.completionStatus = percent >= threshold ? 'complete' : 'incomplete';
     } else if (config.completion.mode === 'quiz') {
       const { indices } = this.#gradedPages();
@@ -135,7 +136,8 @@ export class ProgressState {
         return;
       }
       const average = this.#gradedAverage(indices);
-      this.completionStatus = average >= config.scoring.passingScore ? 'complete' : 'incomplete';
+      this.completionStatus =
+        average >= config.scoring.passingScore ? 'complete' : 'incomplete';
     }
   }
 
@@ -144,7 +146,8 @@ export class ProgressState {
       const want = config.completion.requireSuccessStatus;
       // Stay 'unknown' until manual mark fires, so a learner who never
       // finishes isn't reported as passed.
-      this.successStatus = this.#manuallyCompleted && want !== undefined ? want : 'unknown';
+      this.successStatus =
+        this.#manuallyCompleted && want !== undefined ? want : 'unknown';
       return;
     }
 
@@ -160,7 +163,17 @@ export class ProgressState {
       return;
     }
     const average = this.#gradedAverage(indices);
-    this.successStatus = average >= config.scoring.passingScore ? 'passed' : 'failed';
+    this.successStatus =
+      average >= config.scoring.passingScore ? 'passed' : 'failed';
+  }
+
+  /**
+   * Effective graded score for LMS reporting — same union and averaging as
+   * recalculateSuccess, so score and success status can't disagree.
+   */
+  gradedScore(): { average: number; attempted: boolean } {
+    const { indices, attempted } = this.#gradedPages();
+    return { average: this.#gradedAverage(indices), attempted };
   }
 
   /**
@@ -172,7 +185,7 @@ export class ProgressState {
     const merged = new Set(this.#quizGradedIndices);
     for (const i of this.gradedStandalonePages) merged.add(i);
     const indices = [...merged];
-    const attempted = indices.some(i => this.#hasScore(i));
+    const attempted = indices.some((i) => this.#hasScore(i));
     return { indices, attempted };
   }